import { assert, assertEquals } from "@std/assert";
import { subscriptionUsage, usageWindows } from "./usage.ts";

const token = (account: string) =>
  `header.${
    btoa(JSON.stringify({
      "https://api.openai.com/auth": { chatgpt_account_id: account },
    }))
  }.signature`;
const oauth = (apiKey = "secret") => ({ source: "OAuth", auth: { apiKey } });
const claude = { five_hour: { utilization: 42, resets_at: "2026-04-01T12:00:00Z" } };

Deno.test("subscription windows preserve zero usage, scoped limits, and unknown reset times", () => {
  assertEquals(
    usageWindows("anthropic", {
      five_hour: { utilization: 0, resets_at: null },
      seven_day: { utilization: 73.4, resets_at: "2026-04-02T00:00:00+00:00" },
      seven_day_opus: null,
      seven_day_sonnet: { utilization: "42", resets_at: "bad" },
      limits: [
        { percent: 12, resets_at: "bad", scope: { model: { display_name: "Fable" } } },
        { percent: 90, is_active: false, scope: { model: { display_name: "Inactive" } } },
        null,
      ],
    }),
    [
      { label: "5 hours", usedPercent: 0, resetsAt: null },
      { label: "Weekly", usedPercent: 73.4, resetsAt: "2026-04-02T00:00:00.000Z" },
      { label: "Weekly · Fable", usedPercent: 12, resetsAt: null },
    ],
  );
  assertEquals(
    usageWindows("openai-codex", {
      rate_limit: {
        primary_window: { used_percent: 90, reset_at: 1775044800, limit_window_seconds: 18000 },
        secondary_window: { used_percent: 0, reset_at: null, limit_window_seconds: 604800 },
      },
      additional_rate_limits: [
        { limit_name: "Spark", rate_limit: { primary_window: { used_percent: 15 } } },
        { limit_name: "Invalid", rate_limit: { primary_window: { used_percent: -1 } } },
        null,
      ],
    }),
    [
      { label: "5 hours", usedPercent: 90, resetsAt: "2026-04-01T12:00:00.000Z" },
      { label: "7 days", usedPercent: 0, resetsAt: null },
      { label: "Spark · Session", usedPercent: 15, resetsAt: null },
    ],
  );
  for (const invalid of [null, [], 42, {}, { rate_limit: "bad" }]) {
    assertEquals(usageWindows("openai", invalid), []);
  }
});

Deno.test("usage requests are coalesced, cached, and authenticated only at the provider endpoint", async () => {
  let now = 1775044800000;
  let requests = 0;
  const gate = Promise.withResolvers<void>();
  const usage = subscriptionUsage({
    now: () => now,
    auth: () => Promise.resolve(oauth()),
    fetch: async (url, init) => {
      requests++;
      assertEquals(url, "https://api.anthropic.com/api/oauth/usage");
      const headers = new Headers(init?.headers);
      assertEquals(headers.get("authorization"), "Bearer secret");
      assertEquals(headers.get("anthropic-beta"), "oauth-2025-04-20");
      assertEquals(init?.redirect, "error");
      assert(init?.signal);
      await gate.promise;
      return Response.json({ ...claude, account_id: "private", other_secret: "private" });
    },
  });
  const first = usage("anthropic");
  const second = usage("anthropic");
  assertEquals(first, second);
  gate.resolve();
  const result = await first;
  assertEquals(result, {
    status: "ok",
    fetchedAt: "2026-04-01T12:00:00.000Z",
    windows: [{ label: "5 hours", usedPercent: 42, resetsAt: "2026-04-01T12:00:00.000Z" }],
  });
  assertEquals(await usage("anthropic"), result);
  assertEquals(requests, 1);
  now += 61_000;
  await usage("anthropic");
  assertEquals(requests, 2);
});

Deno.test("ChatGPT OAuth and legacy Codex send the selected account and invalidate cache after login changes", async () => {
  let account = "account-one";
  const accounts: string[] = [];
  const usage = subscriptionUsage({
    auth: () => Promise.resolve(oauth(token(account))),
    fetch: (url, init) => {
      assertEquals(url, "https://chatgpt.com/backend-api/wham/usage");
      const headers = new Headers(init?.headers);
      accounts.push(headers.get("ChatGPT-Account-Id")!);
      assertEquals(headers.get("authorization"), `Bearer ${token(account)}`);
      return Promise.resolve(
        Response.json({ rate_limit: { primary_window: { used_percent: 5 } } }),
      );
    },
  });
  await usage("openai");
  await usage("openai-codex");
  await usage("openai");
  account = "account-two";
  await usage("openai");
  assertEquals(accounts, ["account-one", "account-one", "account-two"]);
});

Deno.test("OpenCode Go API keys load all allowance windows and are isolated from OAuth providers", async () => {
  const now = Date.parse("2026-04-01T12:00:00Z");
  let key: string | undefined = "go-key";
  const keys: string[] = [];
  const usage = subscriptionUsage({
    now: () => now,
    auth: (provider) => {
      assertEquals(provider, "opencode-go");
      return Promise.resolve(
        key ? { source: "stored credential", auth: { apiKey: key } } : undefined,
      );
    },
    fetch: (url, init) => {
      assertEquals(url, "https://opencode.ai/inference/go/v1/usage");
      const headers = new Headers(init?.headers);
      keys.push(headers.get("authorization")!);
      assertEquals(headers.get("ChatGPT-Account-Id"), null);
      assertEquals(headers.get("anthropic-beta"), null);
      assertEquals(init?.redirect, "error");
      return Promise.resolve(Response.json({
        usage: {
          rolling: { status: "ok", percent: 0, resetsAt: "2026-04-01T17:00:00Z" },
          weekly: { status: "ok", percent: 25.5, resetsAt: "2026-04-08T12:00:00Z" },
          monthly: { status: "rate-limited", percent: 100, resetsAt: "2026-05-01T12:00:00Z" },
        },
      }));
    },
  });
  const result = await usage("opencode-go");
  assertEquals(result, {
    status: "ok",
    fetchedAt: "2026-04-01T12:00:00.000Z",
    windows: [
      { label: "5 hours", usedPercent: 0, resetsAt: "2026-04-01T17:00:00.000Z" },
      { label: "Weekly", usedPercent: 25.5, resetsAt: "2026-04-08T12:00:00.000Z" },
      { label: "Monthly", usedPercent: 100, resetsAt: "2026-05-01T12:00:00.000Z" },
    ],
  });
  assertEquals(await usage("opencode-go"), result);
  key = "replacement-key";
  await usage("opencode-go");
  key = undefined;
  assertEquals((await usage("opencode-go")).status, "unavailable");
  assertEquals(keys, ["Bearer go-key", "Bearer replacement-key"]);
});

Deno.test("Go preserves legacy relative resets and skips malformed windows without losing valid ones", () => {
  assertEquals(
    usageWindows("opencode-go", {
      rollingUsage: { usagePercent: 12, resetInSec: 1800 },
      weeklyUsage: { usagePercent: 30, resetInSec: null },
      monthlyUsage: { usagePercent: "wrong", resetInSec: 100 },
    }, Date.parse("2026-04-01T12:00:00Z")),
    [
      { label: "5 hours", usedPercent: 12, resetsAt: "2026-04-01T12:30:00.000Z" },
      { label: "Weekly", usedPercent: 30, resetsAt: null },
    ],
  );
  assertEquals(
    usageWindows("opencode-go", {
      usage: {
        rolling: { percent: -1, resetsAt: null },
        weekly: { percent: 20, resetsAt: "bad" },
        monthly: null,
      },
    }),
    [{ label: "Weekly", usedPercent: 20, resetsAt: null }],
  );
});

Deno.test("Claude API keys and missing logins never go to the subscription endpoint", async () => {
  for (
    const resolved of [undefined, { source: "stored credential", auth: { apiKey: "api-key" } }]
  ) {
    const usage = subscriptionUsage({
      auth: () => Promise.resolve(resolved),
      fetch: () => {
        throw new Error("must not request usage");
      },
    });
    assertEquals((await usage("anthropic")).status, "unavailable");
  }
});

Deno.test("rate limits honor Retry-After and provider errors never expose response bodies or tokens", async () => {
  let now = 1775044800000;
  let requests = 0;
  const usage = subscriptionUsage({
    now: () => now,
    auth: () => Promise.resolve(oauth()),
    fetch: () => {
      requests++;
      return Promise.resolve(
        new Response("secret upstream body", {
          status: 429,
          headers: { "retry-after": "600" },
        }),
      );
    },
  });
  const result = await usage("anthropic");
  assertEquals(result.status, "error");
  assert(!JSON.stringify(result).includes("secret"));
  now += 301_000;
  await usage("anthropic");
  assertEquals(requests, 1);
  now += 300_000;
  await usage("anthropic");
  assertEquals(requests, 2);
  const failed = subscriptionUsage({
    auth: () => Promise.resolve(oauth()),
    fetch: () => Promise.resolve(new Response("secret", { status: 500 })),
  });
  const error = await failed("anthropic");
  assertEquals(error.status, "error");
  assert(!JSON.stringify(error).includes("secret"));
  const refreshFailure = subscriptionUsage({
    auth: () => Promise.reject(new Error("secret refresh error")),
  });
  assert(!JSON.stringify(await refreshFailure("anthropic")).includes("secret"));
});

Deno.test("malformed account tokens, usage JSON, and reset dates fail without losing valid windows", async () => {
  for (const apiKey of ["not-a-jwt", `header.${btoa("{}")}.signature`]) {
    let requested = false;
    const usage = subscriptionUsage({
      auth: () => Promise.resolve(oauth(apiKey)),
      fetch: () => {
        requested = true;
        return Promise.resolve(Response.json({}));
      },
    });
    assertEquals((await usage("openai")).status, "error");
    assertEquals(requested, false);
  }
  const malformed = subscriptionUsage({
    auth: () => Promise.resolve(oauth()),
    fetch: () => Promise.resolve(new Response("not json")),
  });
  assertEquals((await malformed("anthropic")).status, "error");
  assertEquals(
    usageWindows("openai", {
      rate_limit: { primary_window: { used_percent: 10, reset_at: 1e50 } },
    }),
    [{ label: "Session", usedPercent: 10, resetsAt: null }],
  );
});