import type { Database } from "bun:sqlite";
import type { Hono } from "hono";
import { isText } from "../describe/describe.ts";
import {
	type FileEntry,
	filesAt,
	flagReason,
	objectBytes,
	type Save,
	saveByPrefix,
	visibleParent,
} from "../mirror/queries.ts";
import { diffLines, type Edit, hunks } from "./diff.ts";
import { highlightLines } from "./highlight.ts";
import { type Html, html } from "./html.ts";
import {
	cacheFor,
	formatDate,
	notFound,
	openPublicRepo,
	type PageContext,
	page,
	pathUrl,
	plural,
	relativeTime,
} from "./layout.ts";

// A side over the file viewer's 1 MB is not diffed; past 256 KB it is shown without highlighting.
const DIFF_MAX_BYTES = 1024 * 1024;
const HIGHLIGHT_MAX_BYTES = 256 * 1024;
// A file's diff longer than this starts collapsed; once the page has shown this many lines, the
// remaining files are listed without their diffs so one huge save can't make a huge page.
const COLLAPSE_LINES = 300;
const PAGE_MAX_LINES = 5000;

type Change = {
	path: string;
	status: "added" | "removed" | "modified";
	before: FileEntry | null;
	after: FileEntry | null;
};

type FileDiff = Change & {
	kind: "text" | "binary" | "large";
	oldText: string;
	newText: string;
	edits: Edit[];
	added: number;
	removed: number;
};

export function registerSavePage(app: Hono, ctx: PageContext): void {
	app.get("/:repo/saves/:id", async (c) => {
		const repo = openPublicRepo(ctx, c.req.param("repo"));
		const id = c.req.param("id");
		const save = repo && saveByPrefix(repo.mirror, id);
		// Checkpoints never appear (§21.4), so a link to one finds nothing, like an unknown ID.
		if (!repo || !save || save.is_checkpoint) return notFound(c, ctx);
		const name = repo.settings.name;
		if (save.id !== id) return c.redirect(`/${name}/saves/${save.id}`, 302);
		const parent = visibleParent(repo.mirror, save);
		const diffs = changes(repo.mirror, save, parent).map((change) => fileDiff(repo.mirror, change));
		// Not a year like other per-save content: a flag or a strip can arrive for this save later.
		cacheFor(c, false);
		const [title = "", ...rest] = save.message.split("\n");
		return c.html(
			page(ctx, {
				title: `${title} · ${name}`,
				description: `${save.id} · ${plural(diffs.length, "file")} changed`,
				path: `/${name}/saves/${save.id}`,
				body: html`<p class="breadcrumb mono"><a href="/${
					name
				}">${name}</a> / <a href="/${name}#history">history</a></p>
${saveHeader(repo.mirror, name, save, parent, title, rest.join("\n").trim())}
<section class="repo-section">
<details class="repo-section-toggle" open>
<summary class="section-head"><span class="section-label">files changed</span><span class="section-count">${plural(
					diffs.length,
					"file",
				)}</span></summary>
${
	diffs.length === 0
		? html`<p class="muted mono save-empty">no files changed</p>`
		: diffs.map((d, i) => changeRow(d, i))
}
</details>
</section>
<section class="repo-section">${await diffSections(name, save, parent, diffs)}</section>`,
			}),
		);
	});
}

function saveHeader(
	db: Database,
	name: string,
	save: Save,
	parent: Save | null,
	title: string,
	body: string,
): Html {
	const reason = flagReason(db, save.id);
	const facts: [string, Html | string][] = [
		["time", `${formatDate(save.created_at)} UTC · ${relativeTime(save.created_at)}`],
		["machine", save.machine],
		...(save.agent ? [["agent", save.agent] as [string, string]] : []),
		...(save.session ? [["session", save.session] as [string, string]] : []),
		[
			"parent",
			parent
				? html`<a href="/${name}/saves/${parent.id}">${parent.id}</a>`
				: "none, the first save",
		],
	];
	return html`<p class="save-id mono">${save.id}</p>
${
	reason !== null &&
	html`<p class="save-flag"><span class="save-flag-label mono">flagged</span> ${reason || "no reason given"}</p>`
}
<h1 class="save-message-head">${title}</h1>
${body && html`<p class="save-message-body">${body}</p>`}
<dl class="save-facts mono">${facts.map(
		([term, value]) => html`<dt>${term}</dt><dd>${value}</dd>`,
	)}</dl>
<p class="save-links mono"><a href="/${
		name
	}/archive/${save.id}.tar.gz">↓ ${name}-${save.id.slice(0, 8)}.tar.gz</a><a href="/${name}?at=${save.id}#atlas">atlas at this save</a></p>`;
}

function changes(db: Database, save: Save, parent: Save | null): Change[] {
	const before = new Map(parent ? filesAt(db, parent.id).map((f) => [f.path, f]) : []);
	const after = new Map(filesAt(db, save.id).map((f) => [f.path, f]));
	const paths = [...new Set([...before.keys(), ...after.keys()])].sort();
	return paths.flatMap((path) => {
		const old = before.get(path) ?? null;
		const now = after.get(path) ?? null;
		if (old && now && old.hash === now.hash && old.executable === now.executable) return [];
		const status = !old ? "added" : !now ? "removed" : "modified";
		return [{ path, status, before: old, after: now }];
	});
}

function fileDiff(db: Database, change: Change): FileDiff {
	const empty = { oldText: "", newText: "", edits: [], added: 0, removed: 0 };
	const sides = [change.before, change.after];
	if (sides.some((f) => f && f.size > DIFF_MAX_BYTES))
		return { ...change, ...empty, kind: "large" };
	const [oldBytes, newBytes] = sides.map((f) => (f && objectBytes(db, f.hash)) ?? new Uint8Array());
	if (!isText(oldBytes as Uint8Array) || !isText(newBytes as Uint8Array)) {
		return { ...change, ...empty, kind: "binary" };
	}
	const oldText = new TextDecoder().decode(oldBytes);
	const newText = new TextDecoder().decode(newBytes);
	const edits = diffLines(compared(oldText), compared(newText));
	const added = edits.filter((e) => e.kind === "+").length;
	const removed = edits.filter((e) => e.kind === "-").length;
	return { ...change, kind: "text", oldText, newText, edits, added, removed };
}

function lines(text: string): string[] {
	return text === "" ? [] : text.replace(/\n$/, "").split("\n");
}

// A last line without its newline differs from the same line with one, as in GNU diff: a newline
// can never occur inside a split line, so it marks the ending for the comparison alone.
function compared(text: string): string[] {
	const split = lines(text);
	if (split.length > 0 && !text.endsWith("\n")) split[split.length - 1] += "\n";
	return split;
}

function stat(d: FileDiff): Html {
	if (d.kind !== "text") return html`<span class="diff-note">${d.kind}</span>`;
	return html`<span class="diff-add">+${d.added}</span> <span class="diff-del">−${d.removed}</span>`;
}

function changeRow(d: FileDiff, index: number): Html {
	return html`<a class="change-row change-${
		d.status
	}" href="#diff-${index}"><span class="change-path">${d.path}</span><span class="change-stat mono">${stat(d)}</span></a>`;
}

async function diffSections(
	name: string,
	save: Save,
	parent: Save | null,
	diffs: FileDiff[],
): Promise<Html[]> {
	let shown = 0;
	const sections: Html[] = [];
	for (const [index, d] of diffs.entries()) {
		const at = d.status === "removed" ? parent?.id : save.id;
		const view = `/${name}/files/${pathUrl(d.path)}?at=${at}`;
		const hunkList = hunks(d.edits);
		const length = hunkList.reduce((sum, h) => sum + h.edits.length + 1, 0);
		const mode =
			d.before && d.after && d.before.executable !== d.after.executable
				? html`<p class="diff-note mono">${
						d.after.executable ? "now executable" : "no longer executable"
					}</p>`
				: "";
		let content: Html | string = "";
		if (d.kind === "binary") content = html`<p class="diff-note mono">binary file, not shown</p>`;
		else if (d.kind === "large") content = html`<p class="diff-note mono">over 1 MB, not shown</p>`;
		else if (shown + length > PAGE_MAX_LINES) {
			content = html`<p class="diff-note mono">not shown here: too long for one page</p>`;
		} else if (length > 0) {
			shown += length;
			content = await diffBody(d, hunkList);
		}
		sections.push(html`<details class="diff-file change-${
			d.status
		}" id="diff-${index}"${length <= COLLAPSE_LINES && " open"}>
<summary class="diff-head"><span class="change-path">${
			d.path
		}</span><span class="change-stat mono">${stat(d)}</span></summary>
${mode}${content}
<p class="diff-view mono"><a href="${
			view
		}">view file${d.status === "removed" && " at the parent"}</a></p>
</details>`);
	}
	return sections;
}

async function diffBody(d: FileDiff, hunkList: ReturnType<typeof hunks>): Promise<Html> {
	const [oldLines, newLines] = await Promise.all([
		highlighted(d.oldText, d.path),
		highlighted(d.newText, d.path),
	]);
	// The last line of a side that doesn't end in a newline, or -1 when it does.
	const unterminated = (text: string, count: number) =>
		text === "" || text.endsWith("\n") ? -1 : count - 1;
	const oldEnd = unterminated(d.oldText, oldLines.length);
	const newEnd = unterminated(d.newText, newLines.length);
	const row = (e: Edit) => {
		const code = e.kind === "-" ? oldLines[e.a] : newLines[e.b];
		const kind = e.kind === "+" ? "add" : e.kind === "-" ? "del" : "ctx";
		const bare = (e.kind !== "+" && e.a === oldEnd) || (e.kind !== "-" && e.b === newEnd);
		return html`<span class="dl dl-${
			kind
		}"><span class="ln">${e.kind !== "+" && e.a + 1}</span><span class="ln">${e.kind !== "-" && e.b + 1}</span><span class="ds">${e.kind}</span><span class="lc">${code}</span></span>${bare && html`<span class="dh">\\ No newline at end of file</span>`}`;
	};
	return html`<div class="file-view"><pre class="code diff"><code>${hunkList.map(
		(h) => html`<span class="dh">${h.header}</span>${h.edits.map(row)}`,
	)}</code></pre></div>`;
}

function highlighted(text: string, path: string): Promise<Html[]> | Html[] {
	if (text.length > HIGHLIGHT_MAX_BYTES) return lines(text).map((line) => html`${line}`);
	return highlightLines(text, path);
}