/**
 * Regression guard: a hosted loop's monthly budget must not be bypassable by
 * simply declining to report usage.
 *
 * The cap itself was fine — invokeLoop short-circuits with `budget_exceeded`
 * once monthly spend reaches monthlyBudgetCents. What fed it was not. Spend
 * came entirely from extractUsageFromStdout, i.e. from a `usage` block
 * printed by the snippet, and loop.sourceCode is arbitrary user-supplied
 * code that any registered account can run (the file says so itself, above
 * the env block).
 *
 * So a snippet that never prints a usage block costed 0 cents, its monthly
 * spend never advanced, and the cap could never stop it: unlimited
 * invocations, each burning up to LOOP_EXEC_TIMEOUT_MS of platform compute,
 * and platform Anthropic credits wherever HOSTED_LOOPS_PLATFORM_KEY=1.
 *
 * The fix charges a floor derived from the executor's own measured duration,
 * which the snippet cannot forge. Self-reported usage still wins when it is
 * higher — it is the better estimate of real token spend and nobody has an
 * incentive to overstate it. The floor only removes the option of reporting
 * nothing.
 *
 * NOTE this is a deliberate billing behaviour change, not purely internal:
 * runs that previously cost 0 now cost at least the per-run minimum. Both
 * knobs are env-tunable and read at access time.
 */

import { describe, it, expect, afterEach } from "bun:test";
import { readFileSync } from "node:fs";
import { join } from "node:path";
import {
  invocationFloorCents,
  extractUsageFromStdout,
  LOOP_EXEC_TIMEOUT_MS,
} from "../lib/hosted-claude-loop";

const ENV_MIN = "HOSTED_LOOP_MIN_CENTS_PER_RUN";
const ENV_RATE = "HOSTED_LOOP_MS_PER_CENT";

afterEach(() => {
  delete process.env[ENV_MIN];
  delete process.env[ENV_RATE];
});

describe("invocationFloorCents", () => {
  it("charges at least one cent even for an instant run", () => {
    // This is the whole point: a snippet reporting nothing is not free.
    expect(invocationFloorCents(0)).toBe(1);
    expect(invocationFloorCents(1)).toBe(1);
  });

  it("scales with measured wall clock", () => {
    expect(invocationFloorCents(10_000)).toBe(1);
    expect(invocationFloorCents(10_001)).toBe(2);
    expect(invocationFloorCents(25_000)).toBe(3);
  });

  it("bounds a maximum-length run sensibly", () => {
    // Execution is hard-capped, so the floor per run is bounded too.
    const maxFloor = invocationFloorCents(LOOP_EXEC_TIMEOUT_MS);
    expect(maxFloor).toBeGreaterThan(0);
    expect(maxFloor).toBeLessThanOrEqual(5);
  });

  it("never returns a negative or non-finite charge", () => {
    for (const bad of [-1, -100_000, NaN, Infinity, -Infinity]) {
      const got = invocationFloorCents(bad as number);
      expect(Number.isFinite(got)).toBe(true);
      expect(got).toBeGreaterThanOrEqual(1);
    }
  });

  it("honours the env knobs at access time", () => {
    process.env[ENV_MIN] = "5";
    process.env[ENV_RATE] = "1000";
    expect(invocationFloorCents(0)).toBe(5);
    expect(invocationFloorCents(9_000)).toBe(9);
  });

  it("falls back to safe defaults when the env is nonsense", () => {
    process.env[ENV_MIN] = "not-a-number";
    process.env[ENV_RATE] = "0";
    expect(invocationFloorCents(0)).toBe(1);
    expect(invocationFloorCents(10_000)).toBe(1);
  });

  it("allows the floor to be disabled deliberately", () => {
    // Explicit zero is a real operator choice, not nonsense — it must be
    // honoured rather than silently coerced back to the default.
    process.env[ENV_MIN] = "0";
    expect(invocationFloorCents(0)).toBe(0);
  });
});

describe("extractUsageFromStdout is the untrusted input", () => {
  it("reports nothing for a snippet that prints nothing", () => {
    // The exact shape that used to cost zero and never advance the cap.
    expect(extractUsageFromStdout("")).toEqual({
      inputTokens: 0,
      outputTokens: 0,
      model: null,
    });
    expect(extractUsageFromStdout("hello, no json here")).toEqual({
      inputTokens: 0,
      outputTokens: 0,
      model: null,
    });
  });

  it("still reads a well-formed usage block", () => {
    const got = extractUsageFromStdout(
      JSON.stringify({ usage: { input_tokens: 100, output_tokens: 50 } })
    );
    expect(got.inputTokens).toBe(100);
    expect(got.outputTokens).toBe(50);
  });
});

// --- the floor must actually be applied ------------------------------------
//
// Asserting the identifier merely APPEARS is not asserting it is invoked —
// `void fn;` would satisfy that. Assert the call form. Strip ONLY line
// comments.

describe("invokeLoop applies the floor to what it charges", () => {
  const src = (() => {
    const raw = readFileSync(
      join(import.meta.dir, "..", "lib", "hosted-claude-loop.ts"),
      "utf8"
    );
    const stripped = raw
      .split("\n")
      .filter((l) => !l.trim().startsWith("//") && !l.trim().startsWith("*"))
      .join("\n");
    expect(stripped.length).toBeGreaterThan(0);
    return stripped;
  })();

  it("takes the max of self-reported cost and the measured floor", () => {
    expect(src).toContain("invocationFloorCents(execResult.durationMs)");
    expect(src).toContain("Math.max(");
  });

  it("charges the floor before the run row is written", () => {
    // centsEstimate on the run row, the loop rollup and the agent charge all
    // read the same `cents`, so it has to be floored before any of them.
    const at = src.indexOf("invocationFloorCents(execResult.durationMs)");
    expect(at).toBeGreaterThan(-1);
    const after = src.slice(at);
    expect(after.length).toBeGreaterThan(0);
    expect(after).toContain("centsEstimate: cents");
    expect(after).toContain("bumpLoopTotals(loop.id, cents)");
  });

  it("still short-circuits over-budget loops before executing", () => {
    // The floor is worthless if the cap check itself goes away.
    const at = src.indexOf("getLoopMonthlySpendCents(loop.id)");
    expect(at).toBeGreaterThan(-1);
    const window = src.slice(at, at + 400);
    expect(window.length).toBeGreaterThan(0);
    expect(window).toContain("loop.monthlyBudgetCents");
    expect(window).toContain("budget_exceeded");
    // ...and it happens before the executor is invoked.
    expect(at).toBeLessThan(src.indexOf("await exec({"));
  });
});