import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
import { DEFAULT_API_BASE, ENV_API_KEY, PROVIDER_NAME } from "../../src/env.js";
import { MODELS } from "../../src/models.js";

describe("provider registration", () => {
  beforeEach(() => {
    vi.stubGlobal("fetch", vi.fn().mockResolvedValue(new Response("Not Found", { status: 404 })));
    vi.stubEnv(ENV_API_KEY, "");
  });

  afterEach(() => {
    vi.unstubAllGlobals();
    vi.unstubAllEnvs();
  });

  it("registers with correct baseUrl, apiKey from auth.json when env unset", async () => {
    let captured: { name: string; config: Record<string, unknown> } | undefined;

    const fakePi = {
      registerProvider(name: string, config: Record<string, unknown>) {
        captured = { name, config };
      },
      on(_event: string, _handler: unknown) {},
      registerCommand(_name: string, _options: Record<string, unknown>) {},
    };

    const mod = await import("../../src/index.js");
    await mod.default(fakePi as never);

    expect(captured).toBeDefined();
    expect(captured!.name).toBe(PROVIDER_NAME);
    expect(captured!.config.baseUrl).toBe(DEFAULT_API_BASE);
    expect(captured!.config.apiKey).toBeUndefined();
    expect(captured!.config.api).toBe("openai-completions");
    expect(captured!.config.authHeader).toBe(true);
  });

  it("registers apiKey config when QWENCLOUD_API_KEY env var is set", async () => {
    vi.stubEnv(ENV_API_KEY, "test-key-123");
    let captured: { name: string; config: Record<string, unknown> } | undefined;
    const fakePi = {
      registerProvider(name: string, config: Record<string, unknown>) {
        captured = { name, config };
      },
      on(_event: string, _handler: unknown) {},
      registerCommand(_name: string, _options: Record<string, unknown>) {},
    };

    const mod = await import("../../src/index.js");
    await mod.default(fakePi as never);

    expect(captured).toBeDefined();
    expect(captured!.config.apiKey).toBe("test-key-123");
  });

  it("registers all static models as fallback when API is unavailable", async () => {
    let captured: { config: Record<string, unknown> } | undefined;

    const fakePi = {
      registerProvider(_name: string, config: Record<string, unknown>) {
        captured = { config };
      },
      on(_event: string, _handler: unknown) {},
      registerCommand(_n: string, _o: Record<string, unknown>) {},
    };

    const mod = await import("../../src/index.js");
    await mod.default(fakePi as never);

    const models = captured!.config.models as Array<Record<string, unknown>>;
    expect(models).toHaveLength(MODELS.length);

    for (let i = 0; i < MODELS.length; i++) {
      // Model IDs no longer include qwencloud/ prefix.
      expect(models[i].id).toBe(MODELS[i].id);
      expect(models[i].name).toBe(MODELS[i].name);
      expect(models[i].reasoning).toBe(MODELS[i].reasoning);
      expect(models[i].cost).toEqual(MODELS[i].cost);
      expect(models[i].thinkingLevelMap).toEqual(MODELS[i].thinkingLevelMap);
      expect(models[i].compat).toEqual(MODELS[i].compat);
      expect(models[i].input).toEqual([...MODELS[i].input]);
      expect(Array.isArray(models[i].input)).toBe(true);
    }
  });

  it("wires oauth with login, refreshToken, and getApiKey", async () => {
    let captured: { config: Record<string, unknown> } | undefined;

    const fakePi = {
      registerProvider(_name: string, config: Record<string, unknown>) {
        captured = { config };
      },
      on(_event: string, _handler: unknown) {},
      registerCommand(_n: string, _o: Record<string, unknown>) {},
    };

    const mod = await import("../../src/index.js");
    await mod.default(fakePi as never);

    const oauth = captured!.config.oauth as Record<string, unknown>;
    expect(oauth.name).toBe("QwenCloud");
    expect(typeof oauth.login).toBe("function");
    expect(typeof oauth.refreshToken).toBe("function");
    expect(typeof oauth.getApiKey).toBe("function");
  });
});

describe("message_end event registration", () => {
  beforeEach(() => {
    vi.stubGlobal("fetch", vi.fn().mockResolvedValue(new Response("Not Found", { status: 404 })));
  });

  afterEach(() => {
    vi.unstubAllGlobals();
  });

  it("registers a message_end event listener", async () => {
    const registeredEvents: string[] = [];

    const fakePi = {
      registerProvider(_name: string, _config: Record<string, unknown>) {},
      registerCommand(_name: string, _options: Record<string, unknown>) {},
      on(event: string, _handler: unknown) {
        registeredEvents.push(event);
      },
    };

    const mod = await import("../../src/index.js");
    await mod.default(fakePi as never);

    expect(registeredEvents).toContain("message_end");
  });
});