import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
import { resolveModelString, getEffectiveModel } from "../src/resolver";
import { CLAUDE_MODEL_MAP, DEFAULT_MODELS } from "@automaker/types";

describe("model-resolver", () => {
  let consoleLogSpy: ReturnType<typeof vi.spyOn>;
  let consoleWarnSpy: ReturnType<typeof vi.spyOn>;

  beforeEach(() => {
    consoleLogSpy = vi.spyOn(console, "log").mockImplementation(() => {});
    consoleWarnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
  });

  afterEach(() => {
    consoleLogSpy.mockRestore();
    consoleWarnSpy.mockRestore();
  });

  describe("resolveModelString", () => {
    describe("with undefined/null input", () => {
      it("should return default model when modelKey is undefined", () => {
        const result = resolveModelString(undefined);
        expect(result).toBe(DEFAULT_MODELS.claude);
      });

      it("should return custom default when modelKey is undefined", () => {
        const customDefault = "claude-opus-4-20241113";
        const result = resolveModelString(undefined, customDefault);
        expect(result).toBe(customDefault);
      });

      it("should return default when modelKey is empty string", () => {
        const result = resolveModelString("");
        expect(result).toBe(DEFAULT_MODELS.claude);
      });
    });

    describe("with full Claude model strings", () => {
      it("should pass through full Claude model string unchanged", () => {
        const fullModel = "claude-sonnet-4-20250514";
        const result = resolveModelString(fullModel);

        expect(result).toBe(fullModel);
        expect(consoleLogSpy).toHaveBeenCalledWith(
          expect.stringContaining("Using full Claude model string")
        );
      });

      it("should handle claude-opus model strings", () => {
        const fullModel = "claude-opus-4-20241113";
        const result = resolveModelString(fullModel);

        expect(result).toBe(fullModel);
      });

      it("should handle claude-haiku model strings", () => {
        const fullModel = "claude-3-5-haiku-20241022";
        const result = resolveModelString(fullModel);

        expect(result).toBe(fullModel);
      });

      it("should handle any string containing 'claude-'", () => {
        const customModel = "claude-custom-experimental-v1";
        const result = resolveModelString(customModel);

        expect(result).toBe(customModel);
      });
    });

    describe("with model aliases", () => {
      it("should resolve 'sonnet' alias", () => {
        const result = resolveModelString("sonnet");

        expect(result).toBe(CLAUDE_MODEL_MAP.sonnet);
        expect(consoleLogSpy).toHaveBeenCalledWith(
          expect.stringContaining('Resolved model alias: "sonnet"')
        );
      });

      it("should resolve 'opus' alias", () => {
        const result = resolveModelString("opus");

        expect(result).toBe(CLAUDE_MODEL_MAP.opus);
        expect(consoleLogSpy).toHaveBeenCalledWith(
          expect.stringContaining('Resolved model alias: "opus"')
        );
      });

      it("should resolve 'haiku' alias", () => {
        const result = resolveModelString("haiku");

        expect(result).toBe(CLAUDE_MODEL_MAP.haiku);
      });

      it("should log the resolution for aliases", () => {
        resolveModelString("sonnet");

        expect(consoleLogSpy).toHaveBeenCalledWith(
          expect.stringContaining("Resolved model alias")
        );
        expect(consoleLogSpy).toHaveBeenCalledWith(
          expect.stringContaining(CLAUDE_MODEL_MAP.sonnet)
        );
      });
    });

    describe("with unknown model keys", () => {
      it("should return default for unknown model key", () => {
        const result = resolveModelString("unknown-model");

        expect(result).toBe(DEFAULT_MODELS.claude);
      });

      it("should warn about unknown model key", () => {
        resolveModelString("unknown-model");

        expect(consoleWarnSpy).toHaveBeenCalledWith(
          expect.stringContaining("Unknown model key")
        );
        expect(consoleWarnSpy).toHaveBeenCalledWith(
          expect.stringContaining("unknown-model")
        );
      });

      it("should use custom default for unknown model key", () => {
        const customDefault = "claude-opus-4-20241113";
        const result = resolveModelString("gpt-4", customDefault);

        expect(result).toBe(customDefault);
      });

      it("should warn and show default being used", () => {
        const customDefault = "claude-custom-default";
        resolveModelString("invalid-key", customDefault);

        expect(consoleWarnSpy).toHaveBeenCalledWith(
          expect.stringContaining(customDefault)
        );
      });
    });

    describe("case sensitivity", () => {
      it("should be case-sensitive for aliases", () => {
        const resultUpper = resolveModelString("SONNET");
        const resultLower = resolveModelString("sonnet");

        // Uppercase should not resolve (falls back to default)
        expect(resultUpper).toBe(DEFAULT_MODELS.claude);
        // Lowercase should resolve
        expect(resultLower).toBe(CLAUDE_MODEL_MAP.sonnet);
      });

      it("should handle mixed case in claude- strings", () => {
        const result = resolveModelString("Claude-Sonnet-4-20250514");

        // Capital 'C' means it won't match 'claude-', falls back to default
        expect(result).toBe(DEFAULT_MODELS.claude);
      });
    });

    describe("edge cases", () => {
      it("should handle model key with whitespace", () => {
        const result = resolveModelString("  sonnet  ");

        // Will not match due to whitespace, falls back to default
        expect(result).toBe(DEFAULT_MODELS.claude);
      });

      it("should handle special characters in model key", () => {
        const result = resolveModelString("model@123");

        expect(result).toBe(DEFAULT_MODELS.claude);
      });
    });
  });

  describe("getEffectiveModel", () => {
    describe("priority handling", () => {
      it("should prioritize explicit model over all others", () => {
        const explicit = "claude-opus-4-20241113";
        const session = "claude-sonnet-4-20250514";
        const defaultModel = "claude-3-5-haiku-20241022";

        const result = getEffectiveModel(explicit, session, defaultModel);

        expect(result).toBe(explicit);
      });

      it("should use session model when explicit is undefined", () => {
        const session = "claude-sonnet-4-20250514";
        const defaultModel = "claude-3-5-haiku-20241022";

        const result = getEffectiveModel(undefined, session, defaultModel);

        expect(result).toBe(session);
      });

      it("should use default model when both explicit and session are undefined", () => {
        const defaultModel = "claude-opus-4-20241113";

        const result = getEffectiveModel(undefined, undefined, defaultModel);

        expect(result).toBe(defaultModel);
      });

      it("should use system default when all are undefined", () => {
        const result = getEffectiveModel(undefined, undefined, undefined);

        expect(result).toBe(DEFAULT_MODELS.claude);
      });
    });

    describe("with aliases", () => {
      it("should resolve explicit model alias", () => {
        const result = getEffectiveModel("opus", "sonnet");

        expect(result).toBe(CLAUDE_MODEL_MAP.opus);
      });

      it("should resolve session model alias when explicit is undefined", () => {
        const result = getEffectiveModel(undefined, "haiku");

        expect(result).toBe(CLAUDE_MODEL_MAP.haiku);
      });

      it("should prioritize explicit alias over session full string", () => {
        const result = getEffectiveModel(
          "sonnet",
          "claude-opus-4-20241113"
        );

        expect(result).toBe(CLAUDE_MODEL_MAP.sonnet);
      });
    });

    describe("with empty strings", () => {
      it("should treat empty explicit string as undefined", () => {
        const session = "claude-sonnet-4-20250514";

        const result = getEffectiveModel("", session);

        expect(result).toBe(session);
      });

      it("should treat empty session string as undefined", () => {
        const defaultModel = "claude-opus-4-20241113";

        const result = getEffectiveModel(undefined, "", defaultModel);

        expect(result).toBe(defaultModel);
      });

      it("should handle all empty strings", () => {
        const result = getEffectiveModel("", "", "");

        // Empty strings are falsy, so explicit || session becomes "" || ""  = ""
        // Then resolveModelString("", "") returns "" (not in CLAUDE_MODEL_MAP, not containing "claude-")
        // This actually returns the custom default which is ""
        expect(result).toBe("");
      });
    });

    describe("integration scenarios", () => {
      it("should handle user overriding session model with alias", () => {
        const sessionModel = "claude-sonnet-4-20250514";
        const userChoice = "opus";

        const result = getEffectiveModel(userChoice, sessionModel);

        expect(result).toBe(CLAUDE_MODEL_MAP.opus);
      });

      it("should handle fallback chain: unknown -> session -> default", () => {
        const result = getEffectiveModel(
          "invalid",
          "also-invalid",
          "claude-opus-4-20241113"
        );

        // Both invalid models fall back to default
        expect(result).toBe("claude-opus-4-20241113");
      });

      it("should handle session with alias, no explicit", () => {
        const result = getEffectiveModel(undefined, "haiku");

        expect(result).toBe(CLAUDE_MODEL_MAP.haiku);
      });
    });
  });

  describe("CLAUDE_MODEL_MAP integration", () => {
    it("should have valid mappings for all known aliases", () => {
      const aliases = ["sonnet", "opus", "haiku"];

      for (const alias of aliases) {
        const resolved = resolveModelString(alias);
        expect(resolved).toBeDefined();
        expect(resolved).toContain("claude-");
        expect(resolved).toBe(CLAUDE_MODEL_MAP[alias]);
      }
    });
  });

  describe("DEFAULT_MODELS integration", () => {
    it("should use DEFAULT_MODELS.claude as fallback", () => {
      const result = resolveModelString(undefined);

      expect(result).toBe(DEFAULT_MODELS.claude);
      expect(DEFAULT_MODELS.claude).toBeDefined();
      expect(DEFAULT_MODELS.claude).toContain("claude-");
    });
  });
});