import { beforeAll, describe, expect, test } from "bun:test";
import { mkdtemp, writeFile } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";
import type { Hono } from "hono";
import { openBucket } from "../src/bucket/reader.ts";
import { syncAll } from "../src/bucket/sync.ts";
import { fileAt, objectBytes } from "../src/mirror/queries.ts";
import { openMirror } from "../src/mirror/store.ts";
import { createApp } from "../src/server/app.ts";
import { openKeprDb } from "../src/server/db.ts";
import { type Fixture, makeKohBucket } from "./fixture.ts";

let fx: Fixture;
let app: Hono;
let mirrorDir: string;
const get = (path: string) => app.request(path);
const body = async (path: string) => (await get(path)).text();

beforeAll(async () => {
	fx = await makeKohBucket();
	const secretRepo = await makeKohBucket("hidden");
	const large = await makeKohBucket("large");
	// Over 1 MB each: text with a two-byte "é" split by the 1 MB mark, and invalid UTF-8 with no NUL.
	await writeFile(
		join(large.repoDir, "big.txt"),
		`${"a".repeat(1024 * 1024 - 1)}é${"b".repeat(1000)}\n`,
	);
	await writeFile(join(large.repoDir, "big.bin"), new Uint8Array(1024 * 1024 + 500).fill(0xff));
	Bun.spawnSync(["koh3", "save", "add large files"], {
		cwd: large.repoDir,
		env: { PATH: process.env.PATH, HOME: join(large.repoDir, "../../home"), NO_COLOR: "1" },
	});
	const dataDir = await mkdtemp(join(tmpdir(), "kepr-pages-"));
	mirrorDir = join(dataDir, "mirror");
	const kepr = openKeprDb(dataDir);
	for (const bucketDir of [fx.bucketDir, secretRepo.bucketDir, large.bucketDir]) {
		const bucket = openBucket({ kind: "folder", path: bucketDir });
		await syncAll({ bucket, kepr, mirrorDir, tarballDir: join(dataDir, "tarballs") });
	}
	kepr.run(
		"UPDATE repos SET public = 1, install1 = 'nix profile add x', homepage = 'https://demo.example' WHERE name = 'demo'",
	);
	kepr.run("UPDATE repos SET public = 1 WHERE name = 'large'");
	app = createApp(
		{
			domain: "kepr.example",
			dataDir,
			adminPasswordHash: "$argon2id$x",
			bucket: { kind: "folder", path: fx.bucketDir },
		},
		kepr,
	);
});

const [head, , second, first] = [0, 1, 2, 3].map((i) => () => fx.saveIds[i] as string);

describe("the visibility gate", () => {
	test("a private repo and an unknown one are the same 404, everywhere", async () => {
		for (const suffix of ["", "/files/src/main.ts", "/raw/src/main.ts"]) {
			const hidden = await get(`/hidden${suffix}`);
			const missing = await get(`/nowhere${suffix}`);
			expect(hidden.status).toBe(404);
			expect(missing.status).toBe(404);
			expect((await hidden.text()).replaceAll("/hidden", "/nowhere")).toBe(await missing.text());
		}
	});
});

describe("the repo page", () => {
	test("renders header, timeline, history and README at HEAD with a short cache", async () => {
		const response = await get("/demo");
		expect(response.status).toBe(200);
		expect(response.headers.get("cache-control")).toBe("public, max-age=60");
		const page = await response.text();
		expect(page).toContain('<h1 class="repo-name">demo</h1>');
		// The README opens with an HTML comment and a raw <p align>; neither is the intro.
		expect(/<div class="repo-desc"><p>(.*?)<\/p>/.exec(page)?.[1]).toBe(
			"A small repo for <strong>Kepr's</strong> tests.",
		);
		expect(page).toContain(
			'<meta property="og:description" content="A small repo for Kepr&#39;s tests.">',
		);
		expect(page).toContain('href="https://demo.example"');
		expect(page).toContain('<span class="lang-badge">TypeScript</span>');
		expect(page).toContain("3 saves");
		expect(page).toContain('data-copy="nix profile add x"');
		expect(page.match(/class="dot d\d"/g)?.length).toBe(3);
		expect(page).toContain("density = activity · position = time");
		const history = [...page.matchAll(/class="history-id">([0-9a-f]+)</g)].map((m) => m[1]);
		expect(history).toEqual([head(), second(), first()]);
	});

	test("checkpoints never appear", async () => {
		expect(await body("/demo")).not.toContain(fx.saveIds[1] as string);
	});

	test("the README points relative links and images at raw files and drops unsafe links", async () => {
		const page = await body("/demo");
		expect(page).toContain('<a href="/demo/raw/docs/guide.md">the guide</a>');
		expect(page).toContain('<img src="/demo/raw/docs/logo.png" alt="logo">');
		expect(page).toContain('<a href="https://example.com">the site</a>');
		expect(page).not.toContain('href="javascript:');
		expect(page).toContain("&lt;script&gt;alert");
		expect(page).not.toContain("<script>alert");
	});
});

describe("the file viewer", () => {
	test("shows a file at HEAD and at an old save, with line anchors", async () => {
		const now = await get("/demo/files/src/main.ts");
		expect(now.headers.get("cache-control")).toBe("public, max-age=60");
		const nowPage = await now.text();
		expect(nowPage).toContain("hello");
		expect(nowPage).toContain(
			'<span class="line" id="L2"><a class="ln" href="#L2">2</a><span class="lc">',
		);
		expect(nowPage).toContain('class="tk-');

		const then = await get(`/demo/files/src/main.ts?at=${second().slice(0, 6)}`);
		expect(then.headers.get("cache-control")).toBe("public, max-age=31536000");
		const thenPage = await then.text();
		expect(thenPage).toContain("&#39;hi&#39;");
		expect(thenPage).not.toContain("hello");
		expect(thenPage).toContain(`/demo/raw/src/main.ts?at=${second()}`);
	});

	test("a file absent at that save, a bad save or an unsafe path is a 404", async () => {
		expect((await get(`/demo/files/src/main.ts?at=${first()}`)).status).toBe(404);
		expect((await get("/demo/files/src/main.ts?at=zzzzzz")).status).toBe(404);
		expect((await get("/demo/files/src/main.ts?at=abc")).status).toBe(404);
		expect((await get("/demo/files/src%2F..%2FREADME.md")).status).toBe(404);
		expect((await get("/demo/files/nothing.txt")).status).toBe(404);
	});

	test("Markdown renders, with a source toggle", async () => {
		const rendered = await body("/demo/files/docs/guide.md");
		expect(rendered).toContain("<h1>Guide</h1>");
		const source = await body("/demo/files/docs/guide.md?view=source");
		expect(source).toContain('id="L1"');
		expect(source).not.toContain("<h1>Guide</h1>");
	});

	test("an image displays inline from its raw file", async () => {
		expect(await body("/demo/files/docs/logo.png")).toContain('<img src="/demo/raw/docs/logo.png"');
	});
});

describe("files over 1 MB", () => {
	test("text shows its first 1 MB with a raw link, even with a character cut at the mark", async () => {
		const page = await body("/large/files/big.txt");
		expect(page).toContain("showing the first 1 MB");
		expect(page).toContain('href="/large/raw/big.txt"');
		expect(page).not.toContain("bbb");
		const raw = await get("/large/raw/big.txt");
		expect(raw.headers.get("content-type")).toBe("text/plain; charset=utf-8");
	});

	test("invalid UTF-8 without a NUL is binary, not text", async () => {
		const page = await body("/large/files/big.bin");
		expect(page).toContain("binary file");
		expect(page).not.toContain('class="code"');
		const raw = await get("/large/raw/big.bin");
		expect(raw.headers.get("content-type")).toBe("application/octet-stream");
	});
});

describe("the Atlas", () => {
	// The detail panel markup waiting in the <template> after a file's row.
	const panelOf = (page: string, name: string) =>
		new RegExp(`data-name="${name}">.*?</a>\\n<template>(.*?)</template>`, "s").exec(page)?.[1] ??
		"";
	const rowOf = (page: string, name: string) =>
		new RegExp(`data-name="${name}">(.*?)</a>`, "s").exec(page)?.[1] ?? "";

	test("sits between the timeline and History", async () => {
		const page = await body("/demo");
		const atlas = page.indexOf('id="atlas"');
		expect(page.indexOf('class="timeline"')).toBeLessThan(atlas);
		expect(atlas).toBeLessThan(page.indexOf('id="history"'));
	});

	test("is a folder tree, folders first, then files, alphabetical", async () => {
		const names = [...(await body("/demo")).matchAll(/class="atlas-name">([^<]*)</g)].map(
			(m) => m[1],
		);
		expect(names).toEqual([
			"docs/",
			"guide.md",
			"logo.png",
			"src/",
			"lib/",
			"deep/",
			"util.ts",
			"main.ts",
			"vendor/",
			"big.c",
			".kohignore",
			"README.md",
			"secret.txt",
		]);
	});

	test("rows carry the first sentence of the file's own comment, rendered, and link to the file", async () => {
		const page = await body("/demo");
		expect(rowOf(page, "util.ts")).toContain(
			'<span class="atlas-desc">The <em>one</em> helper.</span>',
		);
		expect(rowOf(page, "main.ts")).toContain("Entry point.");
		expect(rowOf(page, "guide.md")).toContain('<span class="atlas-desc">Read me.</span>');
		expect(rowOf(page, "secret.txt")).toContain('<span class="atlas-desc"></span>');
		expect(page).toContain(
			'<a class="atlas-row atlas-file" href="/demo/files/src/main.ts" data-name="main.ts">',
		);
		expect(panelOf(page, "util.ts")).toContain("<p>The <em>one</em> helper. Deep down.</p>");
	});

	test("the panel counts only real saves, crediting a checkpoint's change to the next save", async () => {
		const page = await body("/demo");
		const main = panelOf(page, "main.ts");
		expect(main).toContain("<dt>lines</dt><dd>2</dd>");
		expect(main).toContain("<dt>saves</dt><dd>2</dd>");
		expect(main).toContain(`<dt>first save</dt><dd><a href="/demo/saves/${second()}">`);
		expect(main).toContain(`<dt>last save</dt><dd><a href="/demo/saves/${head()}">`);
		expect(main.indexOf(head())).toBeLessThan(main.lastIndexOf(second()));
		const guide = panelOf(page, "guide.md");
		expect(guide).toContain("<dt>saves</dt><dd>2</dd>");
		expect(guide).toContain(`<dt>last save</dt><dd><a href="/demo/saves/${head()}">`);
		expect(panelOf(page, "logo.png")).toContain("<dt>lines</dt><dd>binary</dd>");
		expect(page).not.toContain(fx.saveIds[1] as string);
	});

	test("a folder's panel sums its files and counts the saves that touched anything under it", async () => {
		const page = await body("/demo");
		const folderPanel = (path: string) =>
			new RegExp(
				`data-path="${path}">\\n<summary.*?</summary>\\n<template>(.*?)</template>`,
				"s",
			).exec(page)?.[1] ?? "";
		const docs = folderPanel("docs");
		expect(docs).toContain('<p class="atlas-info-path mono">docs</p>');
		expect(docs).toContain("<dt>lines</dt><dd>3</dd>");
		expect(docs).toContain("<dt>files</dt><dd>2</dd>");
		expect(docs).toContain("<dt>saves</dt><dd>2</dd>");
		expect(docs).toContain(`<dt>first save</dt><dd><a href="/demo/saves/${first()}">`);
		expect(docs).toContain(`<dt>last save</dt><dd><a href="/demo/saves/${head()}">`);
		const src = folderPanel("src");
		expect(src).toContain("<dt>saves</dt><dd>3</dd>");
		const recentIds = [
			...(/<ul class="atlas-recent">(.*?)<\/ul>/s.exec(src)?.[1] ?? "").matchAll(
				/saves\/([0-9a-f]+)/g,
			),
		].map((m) => m[1]);
		expect(recentIds).toEqual([head(), second(), first()]);
	});

	test("can be viewed at an older save, and an unknown save is a 404", async () => {
		const page = await body(`/demo?at=${second().slice(0, 8)}`);
		expect(page).toContain(`at <a href="/demo/saves/${second()}">${second()}</a>`);
		expect(page).toContain(`href="/demo/files/src/main.ts?at=${second()}"`);
		expect(panelOf(page, "main.ts")).toContain("<dt>saves</dt><dd>1</dd>");
		expect(panelOf(page, "main.ts")).not.toContain(head());
		const oldest = await body(`/demo?at=${first()}`);
		expect(oldest).not.toContain('data-name="main.ts"');
		expect((await get("/demo?at=abcdef")).status).toBe(404);
		expect((await get("/demo?at=../x")).status).toBe(404);
	});
});

describe("the save page", () => {
	test("shows the save's facts and diffs against the previous real save, skipping the checkpoint", async () => {
		const response = await get(`/demo/saves/${head()}`);
		expect(response.status).toBe(200);
		expect(response.headers.get("cache-control")).toBe("public, max-age=60");
		const page = await response.text();
		expect(page).toContain('<h1 class="save-message-head">say hello</h1>');
		expect(page).toContain(
			`<dt>parent</dt><dd><a href="/demo/saves/${second()}">${second()}</a></dd>`,
		);
		expect(page).not.toContain(fx.saveIds[1] as string);
		expect(page).not.toContain("save-flag");
		// The guide's edit was first recorded by the checkpoint; it belongs to this save.
		const rows = [
			...page.matchAll(
				/class="change-row change-(\w+)" href="#diff-\d"><span class="change-path">([^<]+)</g,
			),
		];
		expect(rows.map((m) => [m[1], m[2]])).toEqual([
			["modified", "docs/guide.md"],
			["modified", "src/main.ts"],
		]);
		expect(page).toContain('<span class="diff-add">+1</span> <span class="diff-del">−1</span>');
		expect(page).toContain('<span class="dh">@@ -1,2 +1,2 @@</span>');
		expect(page).toContain(
			'<span class="dl dl-del"><span class="ln">2</span><span class="ln"></span><span class="ds">-</span>',
		);
		expect(page).toContain('class="tk-');
		expect(page).toContain(`href="/demo/archive/${head()}.tar.gz"`);
		expect(page).toContain(`href="/demo?at=${head()}#atlas"`);
	});

	test("the first save diffs against nothing, notes binaries, and shows its flag and agent", async () => {
		const page = await body(`/demo/saves/${first()}`);
		expect(page).toContain('<span class="save-flag-label mono">flagged</span> holds a secret');
		expect(page).toContain("<dt>parent</dt><dd>none, the first save</dd>");
		expect(page).toContain(
			'change-added" href="#diff-2"><span class="change-path">docs/logo.png</span><span class="change-stat mono"><span class="diff-note">binary</span>',
		);
		expect(page).toContain("binary file, not shown");
		expect(page).toContain('<span class="dh">@@ -0,0 +1 @@</span>');
		const second_ = await body(`/demo/saves/${second()}`);
		expect(second_).toContain("<dt>agent</dt><dd>test-agent</dd><dt>session</dt><dd>fixture</dd>");
		expect(second_).not.toContain("save-flag");
	});

	test("a prefix redirects, and a checkpoint, an unknown or a private save is a 404", async () => {
		const short = await get(`/demo/saves/${head().slice(0, 6)}`);
		expect(short.status).toBe(302);
		expect(short.headers.get("location")).toBe(`/demo/saves/${head()}`);
		expect((await get(`/demo/saves/${fx.saveIds[1]}`)).status).toBe(404);
		expect((await get("/demo/saves/abcdef")).status).toBe(404);
		expect((await get("/demo/saves/abc")).status).toBe(404);
		expect((await get(`/hidden/saves/${head()}`)).status).toBe(404);
	});
});

describe("raw files", () => {
	test("are the exact object bytes, text as text/plain", async () => {
		const mirror = openMirror(mirrorDir, "demo");
		for (const [path, type] of [
			["src/main.ts", "text/plain; charset=utf-8"],
			["docs/logo.png", "image/png"],
			["README.md", "text/plain; charset=utf-8"],
		] as const) {
			const response = await get(`/demo/raw/${path}`);
			const file = fileAt(mirror, head(), path);
			expect(response.headers.get("content-type")).toBe(type);
			expect(new Uint8Array(await response.arrayBuffer())).toEqual(
				objectBytes(mirror, file?.hash as string) as Uint8Array<ArrayBuffer>,
			);
		}
		expect(await (await get(`/demo/raw/src/main.ts?at=${second()}`)).text()).toContain("'hi'");
	});
});

test("static assets are served and the CSP allows Bunny Fonts but no inline script", async () => {
	const css = await get("/static/css/kepr.css");
	expect(css.status).toBe(200);
	expect(css.headers.get("content-type")).toContain("text/css");
	expect((await get("/static/../package.json")).status).toBe(404);
	const csp = (await get("/demo")).headers.get("content-security-policy") ?? "";
	expect(csp).toContain("style-src 'self' https://fonts.bunny.net");
	expect(csp).toContain("font-src https://fonts.bunny.net");
	expect(csp).not.toContain("unsafe-inline");
});