import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";

vi.mock("../../open-sse/utils/proxyFetch.js", () => ({
  proxyAwareFetch: vi.fn(),
}));

import { proxyAwareFetch } from "../../open-sse/utils/proxyFetch.js";
import { getUsageForProvider } from "../../open-sse/services/usage.js";
import {
  USAGE_SUPPORTED_PROVIDERS,
  USAGE_APIKEY_PROVIDERS,
} from "../../src/shared/constants/providers.js";
import { parseQuotaData } from "../../src/app/(dashboard)/dashboard/usage/components/ProviderLimits/utils.js";

const USAGE_URL = "https://ollama.com/api/usage";
const ME_URL = "https://ollama.com/api/me";

function jsonResponse(body, status = 200) {
  return new Response(JSON.stringify(body), {
    status,
    headers: { "Content-Type": "application/json" },
  });
}

const SAMPLE_USAGE = {
  activity: {
    cost: "0.00000",
    period: {
      type: "last_4_weeks",
      starting_at: "2026-07-01T00:00:00Z",
      ending_at: "2026-07-29T00:00:00Z",
    },
    models: [],
  },
  limits: {
    session: { usage: 0, models: [] },
    weekly: {
      usage: 1,
      models: [
        { name: "glm-5.2", request_count: 5967 },
        { name: "kimi-k2.5", request_count: 2 },
      ],
    },
  },
};

const SAMPLE_FREE_USAGE = {
  activity: {
    cost: "0.00000",
    period: {
      type: "last_4_weeks",
      starting_at: "2026-08-24T00:00:00Z",
      ending_at: "2026-09-18T15:03:00Z",
    },
    models: [],
  },
  limits: {
    monthly: {
      usage: 0.021,
      models: [
        { name: "gpt-oss:120b", request_count: 6 },
        { name: "gemma4:31b", request_count: 6 },
      ],
    },
  },
};

const SAMPLE_ME = {
  Plan: "max",
};

describe("ollama registry usage flags", () => {
  it("is listed for apikey quota dashboard", () => {
    expect(USAGE_SUPPORTED_PROVIDERS).toContain("ollama");
    expect(USAGE_APIKEY_PROVIDERS).toContain("ollama");
  });
});

describe("getUsageForProvider(ollama)", () => {
  beforeEach(() => {
    vi.clearAllMocks();
  });

  it("GETs /api/usage with Bearer apiKey and POSTs /api/me for plan", async () => {
    proxyAwareFetch
      .mockResolvedValueOnce(jsonResponse(SAMPLE_USAGE))
      .mockResolvedValueOnce(jsonResponse(SAMPLE_ME));

    const usage = await getUsageForProvider({
      provider: "ollama",
      apiKey: "k",
      providerSpecificData: {},
    });

    expect(usage.message).toBeUndefined();
    expect(usage.plan).toBe("Max");
    expect(usage.quotas["Session (5h)"]).toMatchObject({
      used: 0,
      total: 100,
      remainingPercentage: 100,
      unlimited: false,
    });
    expect(usage.quotas["Weekly (7d)"]).toMatchObject({
      used: 100,
      total: 100,
      remainingPercentage: 0,
      unlimited: false,
    });
    // Must not set absolute remaining — UI treats remaining as %
    expect(usage.quotas["Session (5h)"].remaining).toBeUndefined();
    expect(usage.quotas["Weekly (7d)"].remaining).toBeUndefined();

    expect(proxyAwareFetch).toHaveBeenCalledTimes(2);

    const [usageUrl, usageOpts] = proxyAwareFetch.mock.calls[0];
    expect(usageUrl).toBe(USAGE_URL);
    expect(usageOpts.headers.Authorization).toBe("Bearer k");
    expect(usageOpts.headers.Accept).toBe("application/json");

    const [meUrl, meOpts] = proxyAwareFetch.mock.calls[1];
    expect(meUrl).toBe(ME_URL);
    expect(meOpts.method).toBe("POST");
    expect(meOpts.headers.Authorization).toBe("Bearer k");
    expect(meOpts.headers["Content-Length"]).toBe("0");
  });

  it("maps the free plan's monthly window", async () => {
    proxyAwareFetch
      .mockResolvedValueOnce(jsonResponse(SAMPLE_FREE_USAGE))
      .mockResolvedValueOnce(jsonResponse({ Plan: "free" }));

    const usage = await getUsageForProvider({
      provider: "ollama",
      apiKey: "k",
      providerSpecificData: {},
    });

    expect(usage.message).toBeUndefined();
    expect(usage.plan).toBe("Free");
    expect(Object.keys(usage.quotas)).toEqual(["Monthly"]);
    expect(usage.quotas["Monthly"]).toMatchObject({
      used: 2,
      total: 100,
      remainingPercentage: 98,
      unlimited: false,
    });
    expect(usage.quotas["Monthly"].remaining).toBeUndefined();
    expect(usage.quotas["Monthly"].resetAt).toBeNull();
  });

  describe("free plan monthly reset from signup date", () => {
    afterEach(() => {
      vi.useRealTimers();
    });

    async function monthlyResetAt(createdAt, now) {
      vi.useFakeTimers();
      vi.setSystemTime(new Date(now));
      proxyAwareFetch
        .mockResolvedValueOnce(jsonResponse(SAMPLE_FREE_USAGE))
        .mockResolvedValueOnce(jsonResponse({ Plan: "free", CreatedAt: createdAt }));

      const usage = await getUsageForProvider({
        provider: "ollama",
        apiKey: "k",
        providerSpecificData: {},
      });
      return usage.quotas["Monthly"].resetAt;
    }

    it("uses the signup day of the next month", async () => {
      expect(await monthlyResetAt("2025-09-06T22:15:39.871687Z", "2026-09-18T15:03:00Z"))
        .toBe("2026-10-06T22:15:39.000Z");
    });

    it("stays in the current month when the signup day is still ahead", async () => {
      expect(await monthlyResetAt("2026-09-18T09:50:49.514335Z", "2026-09-18T15:33:33Z"))
        .toBe("2026-10-18T09:50:49.000Z");
      expect(await monthlyResetAt("2025-09-25T10:00:00Z", "2026-09-18T15:33:33Z"))
        .toBe("2026-09-25T10:00:00.000Z");
    });

    it("clamps the signup day to shorter months", async () => {
      expect(await monthlyResetAt("2026-01-31T12:00:00Z", "2026-02-10T00:00:00Z"))
        .toBe("2026-02-28T12:00:00.000Z");
    });

    it("skips the reset when the plan is not free", async () => {
      vi.useFakeTimers();
      vi.setSystemTime(new Date("2026-09-18T15:03:00Z"));
      proxyAwareFetch
        .mockResolvedValueOnce(jsonResponse(SAMPLE_FREE_USAGE))
        .mockResolvedValueOnce(jsonResponse({ Plan: "pro", CreatedAt: "2025-09-06T22:15:39Z" }));

      const usage = await getUsageForProvider({
        provider: "ollama",
        apiKey: "k",
        providerSpecificData: {},
      });
      expect(usage.quotas["Monthly"].resetAt).toBeNull();
    });
  });

  it("reports no limits when no known window is present", async () => {
    proxyAwareFetch
      .mockResolvedValueOnce(jsonResponse({ activity: {}, limits: {} }))
      .mockResolvedValueOnce(jsonResponse({ Plan: "free" }));

    const usage = await getUsageForProvider({
      provider: "ollama",
      apiKey: "k",
      providerSpecificData: {},
    });

    expect(usage.message).toMatch(/no usage limits/i);
    expect(usage.quotas).toEqual({});
  });

  it("surfaces invalid key message on 401", async () => {
    proxyAwareFetch.mockResolvedValueOnce(
      jsonResponse({ error: "unauthorized" }, 401),
    );

    const usage = await getUsageForProvider({
      provider: "ollama",
      apiKey: "bad",
    });

    expect(usage.message).toMatch(/invalid/i);
    expect(proxyAwareFetch).toHaveBeenCalledTimes(1);
  });

  it("returns message when apiKey missing", async () => {
    const usage = await getUsageForProvider({
      provider: "ollama",
      providerSpecificData: {},
    });

    expect(usage.message).toMatch(/api key/i);
    expect(proxyAwareFetch).not.toHaveBeenCalled();
  });
});

describe("parseQuotaData(ollama)", () => {
  it("forwards remainingPercentage for dashboard bars", () => {
    const rows = parseQuotaData("ollama", {
      plan: "Max",
      quotas: {
        "Session (5h)": {
          used: 0,
          total: 100,
          remainingPercentage: 100,
          resetAt: null,
        },
        "Weekly (7d)": {
          used: 100,
          total: 100,
          remainingPercentage: 0,
          resetAt: null,
        },
      },
    });

    expect(rows).toHaveLength(2);
    expect(rows[0]).toMatchObject({
      name: "Session (5h)",
      used: 0,
      total: 100,
      remainingPercentage: 100,
    });
    expect(rows[1]).toMatchObject({
      name: "Weekly (7d)",
      used: 100,
      total: 100,
      remainingPercentage: 0,
    });
  });
});