import { describe, expect, it } from "vitest";
import {
	renderScene,
	SCENE_INTRO_TICKS,
	type SceneState,
	sceneFormLines,
	sceneLayout,
	sceneOutcomeTicks,
	sceneVerdictLines,
} from "../src/setup-scene";

const LONG_LIVED = "sk-ant-oat01-abcdefghijklmnopqrstuvwxyz0123456789";
const URL =
	"https://claude.com/cai/oauth/authorize?code=true&client_id=9d1c250a&scope=user%3Ainference&state=abc";

const theme = {
	fg: (_color: string, text: string) => text,
	bold: (text: string) => text,
	getColorMode: () => "256color",
} as never;

const truecolorTheme = {
	fg: (_color: string, text: string) => text,
	bold: (text: string) => text,
	getColorMode: () => "truecolor",
} as never;

function state(overrides: Partial<SceneState> = {}): SceneState {
	return {
		tick: SCENE_INTRO_TICKS,
		phaseTick: 0,
		phase: "signin",
		input: ["Code: "],
		hyperlinks: true,
		url: URL,
		clipboard: "idle",
		hints: "enter submit · c copy link · esc cancel",
		now: 0,
		...overrides,
	};
}

function approved(overrides: Partial<SceneState> = {}): SceneState {
	const base = state({
		phase: "approved",
		input: [],
		token: LONG_LIVED,
		tokenCopied: true,
		expiresInSeconds: 365 * 24 * 60 * 60,
		hints: "any key to close",
		...overrides,
	});
	return { ...base, phaseTick: overrides.phaseTick ?? sceneOutcomeTicks(base) };
}

function text(scene: SceneState, width = 100, active = theme): string {
	return renderScene(scene, width, active).map(stripAnsi).join("\n");
}

function stripAnsi(value: string): string {
	return value
		.replace(/\x1b\[[0-9;]*m/g, "")
		.replace(/\x1b\]8;;[^\x1b]*\x1b\\/g, "");
}

describe("Bureau of Tokens scene", () => {
	it("keeps one counter on screen across every phase", () => {
		const signin = text(state());
		expect(signin).toContain("✻ KLAUS · BUREAU OF TOKENS · WINDOW 08/15 ✻");
		expect(signin).toContain("✦ APPLICATION");
		expect(signin).toContain("◈ STATUS");
		expect(signin).toContain("at the window, waiting for your code");
		expect(signin).toContain("Open the Claude sign-in page");
		expect(signin).toContain("Code: ");
		expect(signin).not.toContain("APPROVED");

		const exchanging = text(state({ phase: "exchanging", input: [] }));
		expect(exchanging).toContain("consulting the archive");
		expect(exchanging).toContain("✦ APPLICATION");
		expect(exchanging).not.toContain("Open the Claude sign-in page");
		expect(exchanging).not.toContain("Code: ");

		const done = text(approved());
		expect(done).toContain("✦ APPLICATION");
		expect(done).toContain("stamped, filed, and forgotten");
		expect(done).toContain("✷ VALID UNTIL ...... 1971-01-01");
		expect(done).toContain("A P P R O V E D");
		expect(done).toContain("✔ Token in clipboard.");
		expect(done).not.toContain(LONG_LIVED);
	});

	it("keeps the link and the code field live from the first frame", () => {
		const first = text(state({ tick: 0 }));
		expect(first).toContain("Open the Claude sign-in page");
		expect(first).toContain("Code: ");
		expect(first).not.toContain("KLAUS");
		expect(first).not.toContain("APPLICATION");

		const midIntro = text(state({ tick: 13 }));
		expect(midIntro).toContain("█");
		expect(midIntro).toContain("KLAUS");
		expect(midIntro).toContain("Code: ");
		expect(midIntro).not.toContain("APPLICATION");
	});

	it("stamps DENIED with the failure and a retry hint", () => {
		const denied = state({
			phase: "denied",
			input: [],
			error: "Anthropic rejected the authorization code.",
			hints: "r retry · esc close",
		});
		const rendered = text({
			...denied,
			phaseTick: sceneOutcomeTicks(denied),
		});
		expect(rendered).toContain("D E N I E D");
		expect(rendered).toContain("✗ Anthropic rejected the authorization code.");
		expect(rendered).toContain("rejected at the window");
		expect(rendered).toContain("r retry · esc close");
		expect(rendered).not.toContain("VALID UNTIL");
	});

	it("keeps the stamp dim before it lands", () => {
		const raised = text(approved({ phaseTick: 1 }));
		expect(raised).toContain("A P P R O V E D");
		expect(raised).not.toContain("Token in clipboard.");
	});

	it("prints the token when the clipboard failed", () => {
		const rendered = text(approved({ tokenCopied: false }));
		expect(rendered).toContain(LONG_LIVED);
		expect(rendered).not.toContain("✔ Token in clipboard.");
	});

	it("links the sign-in page with OSC 8 and falls back to the raw URL", () => {
		const linked = renderScene(state(), 100, theme).join("\n");
		expect(linked).toContain(`\x1b]8;;${URL}\x1b\\`);
		expect(stripAnsi(linked)).not.toContain("code=true");

		const plain = renderScene(state({ hyperlinks: false }), 100, theme).join(
			"\n",
		);
		expect(plain).not.toContain("\x1b]8;;");
		expect(plain).toContain("code=true");
	});

	it("reports the clipboard result for the sign-in link", () => {
		expect(text(state({ clipboard: "copied" }))).toContain(
			"✔ Link copied to clipboard.",
		);
		expect(text(state({ clipboard: "failed" }))).toContain(
			"⚠ No clipboard tool found.",
		);
	});
});

describe("Bureau of Tokens responsiveness", () => {
	it("picks a layout tier from the available width", () => {
		expect(sceneLayout(200)).toBe("full");
		expect(sceneLayout(62)).toBe("full");
		expect(sceneLayout(61)).toBe("compact");
		expect(sceneLayout(42)).toBe("compact");
		expect(sceneLayout(41)).toBe("tiny");
		expect(sceneLayout(12)).toBe("tiny");
	});

	it("shrinks mascot, title, stamp, and labels as width drops", () => {
		const wide = text(approved(), 100);
		const narrow = text(approved(), 30);
		expect(wide.split("\n").length).toBeGreaterThan(narrow.split("\n").length);
		expect(narrow).toContain("✻ KLAUS · TOKENS ✻");
		expect(narrow).toContain("✔ APPROVED");
		expect(narrow).toContain("✻ CLERK: Klaus, since 1961");
		expect(narrow).toContain("◈ STATUS: stamped");
		expect(narrow).not.toContain("PROCESSING FEE");
	});

	it("wraps long rows instead of truncating them in a tiny terminal", () => {
		const rendered = text(approved({ tokenCopied: false }), 20);
		expect(rendered.replace(/\n/g, "")).toContain(LONG_LIVED.slice(0, 20));
		expect(rendered).toContain("paperwork.");
	});

	it("never exceeds the supplied width in any phase", () => {
		const scenes = [
			state({ tick: 4 }),
			state(),
			state({ hyperlinks: false }),
			state({ phase: "exchanging", input: [] }),
			approved(),
			approved({ tokenCopied: false }),
		];
		for (const width of [12, 16, 20, 24, 30, 41, 42, 50, 61, 62, 80, 200]) {
			for (const scene of scenes) {
				for (const line of renderScene(scene, width, theme)) {
					expect(stripAnsi(line).length).toBeLessThanOrEqual(
						Math.max(width, 12),
					);
				}
			}
		}
	});

	it("paints with the Anthropic brand ramp only in true color", () => {
		const mascot = (active: never) =>
			renderScene(state({ tick: 6 }), 100, active)[0] ?? "";
		expect(mascot(truecolorTheme)).toContain("\x1b[38;2;");
		expect(mascot(theme)).not.toContain("\x1b[38;2;");
	});
});

describe("Bureau of Tokens copy", () => {
	it("adds the validity row only once a token exists", () => {
		expect(sceneFormLines(state()).some((line) => line.includes("VALID"))).toBe(
			false,
		);
		expect(
			sceneFormLines(approved()).some((line) => line.includes("VALID")),
		).toBe(true);
		expect(
			sceneFormLines(approved({ expiresInSeconds: undefined })).some((line) =>
				line.includes("VALID"),
			),
		).toBe(false);
	});

	it("has no verdict before an outcome", () => {
		expect(sceneVerdictLines(state())).toEqual([]);
		expect(sceneVerdictLines(state({ phase: "exchanging" }))).toEqual([]);
		expect(sceneVerdictLines(approved())).toHaveLength(2);
		expect(sceneOutcomeTicks(state())).toBe(0);
		expect(sceneOutcomeTicks(approved())).toBeGreaterThan(0);
	});
});