/**
 * Regression guard: the AI spend cap must actually be able to trip.
 *
 * assertAiQuota is called at the top of the AI features (ai-review,
 * ai-review-trio, ai-ci-healer). It reads
 * userQuotas.aiTokensUsedThisMonth — and NOTHING ever incremented that
 * column. bumpUsage, the function whose entire job is to increment it, had
 * zero callers anywhere in the codebase. So the counter sat at 0 forever,
 * `allowed` was always true, and the monthly AI cap could never fire.
 *
 * Token counts were being recorded accurately the whole time, just into
 * ai_cost_events via recordAiCost, which the enforcement path does not read.
 * Metering and enforcement were wired to two different stores. Every piece
 * existed — bumpUsage, invalidateQuotaCache, checkAiQuotaCached,
 * assertAiQuota — and none of them were connected.
 *
 * The second half matters as much as the first: getUserQuota does NOT roll
 * the monthly cycle, and resetIfCycleExpired's only other caller is the
 * repo-creation gate. Making the counter live without also rolling it would
 * have permanently locked users out of AI once they hit the cap, released
 * only by the unrelated act of creating a repository. That would be a worse
 * bug than the one being fixed.
 *
 * The rule is asserted directly; the wiring is asserted from source, because
 * the defect was an absent call and no test of the rule alone would catch a
 * regression that simply stops calling it.
 */

import { describe, it, expect } from "bun:test";
import { readFileSync } from "node:fs";
import { join } from "node:path";
import { quotaChargeForCall } from "../lib/ai-cost-tracker";

const USER = "11111111-1111-1111-1111-111111111111";

describe("quotaChargeForCall", () => {
  it("charges the owner for input plus output tokens", () => {
    expect(
      quotaChargeForCall({ ownerUserId: USER, inputTokens: 900, outputTokens: 100 })
    ).toEqual({ userId: USER, tokens: 1000 });
  });

  it("charges nobody when the call has no owner", () => {
    // Platform-internal work (cron sweeps, system tasks) has nobody to bill
    // and must not be charged to whichever user happens to be nearby.
    expect(
      quotaChargeForCall({ ownerUserId: null, inputTokens: 500, outputTokens: 500 })
    ).toBeNull();
    expect(
      quotaChargeForCall({ ownerUserId: "", inputTokens: 500, outputTokens: 500 })
    ).toBeNull();
    expect(
      quotaChargeForCall({ inputTokens: 500, outputTokens: 500 })
    ).toBeNull();
  });

  it("skips calls that consumed nothing", () => {
    expect(
      quotaChargeForCall({ ownerUserId: USER, inputTokens: 0, outputTokens: 0 })
    ).toBeNull();
  });

  it("never charges a negative or fractional amount", () => {
    // A bad usage payload must not be able to REFUND quota and hand a user
    // unlimited spend.
    expect(
      quotaChargeForCall({ ownerUserId: USER, inputTokens: -5000, outputTokens: 10 })
    ).toEqual({ userId: USER, tokens: 10 });
    expect(
      quotaChargeForCall({ ownerUserId: USER, inputTokens: -50, outputTokens: -50 })
    ).toBeNull();
    expect(
      quotaChargeForCall({ ownerUserId: USER, inputTokens: 1.9, outputTokens: 0.9 })
    ).toEqual({ userId: USER, tokens: 1 });
  });

  it("tolerates missing token fields", () => {
    expect(
      quotaChargeForCall({
        ownerUserId: USER,
        inputTokens: undefined as unknown as number,
        outputTokens: 7,
      })
    ).toEqual({ userId: USER, tokens: 7 });
  });
});

// --- the wiring must stay connected ----------------------------------------
//
// Strip ONLY line comments: a block-comment regex eats path-like text.

function source(...rel: string[]): string {
  const raw = readFileSync(join(import.meta.dir, "..", ...rel), "utf8");
  const stripped = raw
    .split("\n")
    .filter((l) => !l.trim().startsWith("//") && !l.trim().startsWith("*"))
    .join("\n");
  expect(stripped.length).toBeGreaterThan(0);
  return stripped;
}

/** Slice by anchor, never by character count. */
function slice(src: string, startAnchor: string, endAnchor: string): string {
  const start = src.indexOf(startAnchor);
  expect(start).toBeGreaterThan(-1);
  const end = src.indexOf(endAnchor, start + startAnchor.length);
  expect(end).toBeGreaterThan(start);
  const body = src.slice(start, end);
  expect(body.length).toBeGreaterThan(0);
  return body;
}

describe("recordAiCost meters the quota", () => {
  const src = source("lib", "ai-cost-tracker.ts");

  it("awaits the meter — referencing it is not calling it", () => {
    // Asserting the identifier merely APPEARS is too weak: `void
    // meterAiQuota;` satisfies that while metering nothing. Require the
    // awaited invocation.
    const body = slice(
      src,
      "export async function recordAiCost",
      "export async function summarize"
    );
    expect(body).toContain("await meterAiQuota(args)");
  });

  it("meters before the ledger insert, so a ledger failure cannot skip it", () => {
    const body = slice(
      src,
      "export async function recordAiCost",
      "export async function summarize"
    );
    expect(body.indexOf("await meterAiQuota(args)")).toBeLessThan(
      body.indexOf("insert(aiCostEvents)")
    );
  });

  it("bumps the column the enforcement path actually reads", () => {
    expect(src).toContain("bumpUsage");
    expect(src).toContain("aiTokensUsedThisMonth");
  });

  it("invalidates the cached verdict after bumping", () => {
    // Otherwise a burst of calls keeps reusing a stale allow until the cache
    // expires and sails past the cap.
    const meter = slice(src, "async function meterAiQuota", "export interface");
    expect(meter).toContain("invalidateQuotaCache");
    expect(meter.indexOf("bumpUsage")).toBeLessThan(
      meter.indexOf("invalidateQuotaCache")
    );
  });
});

describe("the quota gate rolls the monthly cycle", () => {
  const src = source("lib", "billing.ts");

  it("resets an expired cycle before reading usage", () => {
    const body = slice(
      src,
      "export async function checkAiQuotaCached",
      "export function invalidateQuotaCache"
    );
    expect(body).toContain("resetIfCycleExpired");
    expect(body.indexOf("resetIfCycleExpired")).toBeLessThan(
      body.indexOf("getUserQuota(userId)")
    );
  });

  it("still fails open on billing errors", () => {
    // Billing must never be a hard dependency of the primary path.
    const body = slice(
      src,
      "export async function checkAiQuotaCached",
      "export function invalidateQuotaCache"
    );
    expect(body).toContain("allowed: true");
  });
});

describe("AI entry points still assert the quota", () => {
  for (const file of ["ai-review.ts", "ai-review-trio.ts", "ai-ci-healer.ts"]) {
    it(`${file} calls assertAiQuota`, () => {
      expect(source("lib", file)).toContain("assertAiQuota(");
    });
  }
});