import type { Context, Hono } from "hono";
import { checkFormat, listRepos } from "../bucket/repo.ts";
import type { SyncTarget } from "../bucket/sync.ts";
import { type Html, html } from "../pages/html.ts";
import { type PageContext, page, plural } from "../pages/layout.ts";
import { backups, newestBackupTarball } from "../server/backup.ts";
import { MACHINES_LISTED } from "../server/connect.ts";
import { formToken } from "../server/login.ts";

export type AdminContext = PageContext & { sync: SyncTarget; dataDir: string; canConnect: boolean };

const SECTIONS = [
	["/admin", "status"],
	["/admin/repos", "repos"],
	["/admin/issues", "issues"],
	["/admin/releases", "releases"],
	["/admin/site", "site"],
] as const;

/** The hidden same-site token (§25) that every admin form posts back. */
export function formField(c: Context): Html {
	return html`<input type="hidden" name="form" value="${formToken(c)}">`;
}

/** A posted form's text fields; the guard has already parsed and checked the body. */
export async function textFields(c: Context): Promise<Record<string, string>> {
	const fields: Record<string, string> = {};
	for (const [name, value] of Object.entries(await c.req.parseBody())) {
		if (typeof value === "string") fields[name] = value;
	}
	return fields;
}

export function notice(error: string): Html | "" {
	return error && html`<p class="issues-error mono" role="alert">${error}</p>`;
}

/** An admin page: the site's own look, with the console's sections and sign-out on top. */
export function adminPage(c: Context, ctx: AdminContext, title: string, body: Html): string {
	const tab = ([href, name]: (typeof SECTIONS)[number]) =>
		html`<a class="issues-tab${c.req.path === href ? " active" : ""}" href="${href}">${name}</a>`;
	return page(ctx, {
		title: `${title} · admin`,
		description: "",
		path: c.req.path,
		body: html`<form class="issues-bar mono" method="post" action="/admin/sign-out">
${SECTIONS.map(tab)}${formField(c)}
<button class="issues-tab issues-new" type="submit">sign out</button>
</form>
<h1 class="file-page-title">${title}</h1>
${body}`,
	});
}

// ponytail: counted once per process by walking the source, since there is no build step.
let runningLines: number | null = null;
async function sourceLines(): Promise<number> {
	if (runningLines !== null) return runningLines;
	let total = 0;
	const root = `${import.meta.dir}/../..`;
	for await (const path of new Bun.Glob("{src,scripts}/**/*.ts").scan(root)) {
		if (path.endsWith(".test.ts")) continue;
		const text = await Bun.file(`${root}/${path}`).text();
		total += text.split("\n").length - (text.endsWith("\n") ? 1 : 0);
	}
	runningLines = total;
	return total;
}

/** The last machines that redeemed a code, and how to take their access away again. */
function connectedMachines(ctx: AdminContext): Html | "" {
	const rows = ctx.kepr
		.query<{ machine: string; used_at: number }, [number]>(
			`SELECT machine, used_at FROM connect_codes
			 WHERE used_at IS NOT NULL
			 ORDER BY used_at DESC, rowid DESC
			 LIMIT ?`,
		)
		.all(MACHINES_LISTED);
	if (rows.length === 0) return "";
	const led = rows.map((row) => {
		const at = new Date(row.used_at * 1000).toISOString();
		return html`<li>${row.machine} <span class="muted">${at}</span></li>`;
	});
	return html`<h2>Machines connected</h2>
<ul>${led}</ul>
<p class="muted">To revoke access, rotate the write key in Scaleway and update kepr.toml.</p>`;
}

/** §24's Status section at `/admin`: the bucket, each repo's format, backups, the running version. */
export function registerStatus(app: Hono, ctx: AdminContext): void {
	app.get("/admin", async (c) => {
		let bucket: Html;
		try {
			const repos = await listRepos(ctx.sync.bucket);
			const formats = await Promise.all(
				repos.map(async (repo) => {
					try {
						await checkFormat(ctx.sync.bucket, repo);
						return html`<li><span class="mono">${repo}</span> <span class="muted">format ok</span></li>`;
					} catch (error) {
						return html`<li><span class="mono">${repo}</span>
<span class="issues-error">${String(error)}</span></li>`;
					}
				}),
			);
			bucket = html`<p>Bucket reachable: ${plural(repos.length, "repo")}.</p><ul>${formats}</ul>`;
		} catch (error) {
			bucket = html`<p class="issues-error" role="alert">Bucket unreachable: ${String(error)}</p>`;
		}
		const { version } = (await Bun.file(`${import.meta.dir}/../../package.json`).json()) as {
			version: string;
		};
		const lines = (await sourceLines()).toLocaleString("en-US");
		const newest = backups(ctx.dataDir).at(-1);
		const backup = newest
			? html`<p>Last backup: ${newest.replace(
					/^(\d{4})(\d\d)(\d\d)T(\d\d)(\d\d)(\d\d)Z$/,
					"$1-$2-$3 $4:$5:$6 UTC",
				)}. <a href="/admin/backup">download backup</a></p>`
			: html`<p>No backup yet.</p>`;
		return c.html(
			adminPage(
				c,
				ctx,
				"status",
				html`<section class="repo-section markdown">${bucket}
${ctx.canConnect ? connectedMachines(ctx) : ""}
${backup}
<p>Running kepr ${version}: ${lines} lines of TypeScript.</p></section>`,
			),
		);
	});

	app.get("/admin/backup", (c) => {
		const backup = newestBackupTarball(ctx.dataDir);
		if (!backup) return c.notFound();
		return c.body(backup.bytes, 200, {
			"Content-Type": "application/gzip",
			"Content-Disposition": `attachment; filename="kepr-backup-${backup.name}.tar.gz"`,
		});
	});
}