import type { Context, Hono } from "hono";
import { BucketWriteError } from "../bucket/reader.ts";
import { isSafePath } from "../bucket/repo.ts";
import { MAX_CHARS } from "../issues/spam.ts";
import { operatorIssues } from "../issues/store.ts";
import { languageLines, repoStats } from "../mirror/queries.ts";
import { openMirror, quarantinedPaths } from "../mirror/store.ts";
import { html } from "../pages/html.ts";
import { formatDate, plural } from "../pages/layout.ts";
import {
	deleteRelease,
	deleteReleaseFile,
	LastReleaseFile,
	type OperatorRelease,
	operatorReleases,
	setRelease,
	visibleReleases,
} from "../releases/releases.ts";
import { type RepoText, repoText, setRepoText } from "../server/db.ts";
import { dropTarballs } from "../tarball/cache.ts";
import { type AdminContext, adminPage, formField, notice, textFields } from "./console.ts";
import { renameErrors, renameProblem, renameRepo, renames } from "./rename.ts";
import { type AdminRepo, allRepos, findRepo, type RepoEdit, updateRepo } from "./store.ts";
import { LIMITS } from "./text.ts";

const MAX_FIELD = 500;
const HTTP_URL = /^https?:\/\/[^\s]+$/i;
const MAX_LANGUAGES = 5;
const MAX_LANGUAGE = 30;
const MAX_HIDDEN = 100;
const TABS = ["overview", "settings", "builds", "archives"] as const;
type Tab = (typeof TABS)[number];

/** Shown languages as typed, comma-separated; blanks between commas are dropped. */
function languageNames(value: string): string[] {
	return value
		.split(",")
		.map((name) => name.trim())
		.filter((name) => name !== "");
}

/** §24's Repos section: visibility (§20), card settings, texts, builds, sync status and "sync now". */
export function registerRepos(app: Hono, ctx: AdminContext): void {
	app.get("/admin/repos", (c) => {
		const tab = TABS.find((t) => t === c.req.query("tab")) ?? "overview";
		return c.html(reposPage(c, ctx, "", c.req.query("repo"), tab));
	});

	app.post("/admin/sync", async (c) => {
		await ctx.syncer.syncAll();
		return c.redirect("/admin/repos", 303);
	});

	app.post("/admin/repos/:repo", async (c) => {
		const repo = findRepo(ctx.kepr, c.req.param("repo"));
		if (!repo) return c.notFound();
		const fields = await textFields(c);
		const text = (name: string) => (fields[name] ?? "").trim();
		const languages = languageNames(fields.languages ?? "");
		const hidden = (fields.hidden_paths ?? "")
			.split(/\r?\n/)
			.map((path) => path.trim().replace(/\/+$/, ""))
			.filter((path) => path !== "");
		const edit: RepoEdit = {
			public: fields.public === "1" ? 1 : 0,
			category: text("category"),
			homepage: text("homepage"),
			// Joined with the separator `publicRepo` splits on, so a name never contains it.
			languages: languages.join(", "),
			issues_paused: fields.issues_paused === "1" ? 1 : 0,
			hidden_paths: hidden.join("\n"),
		};
		const refuse = (error: string) =>
			c.html(reposPage(c, ctx, `${repo.name}: ${error}`, repo.name, "settings"), 400);
		const texts = (["description", "details"] as const).map((field): [RepoText, string] => [
			field,
			(fields[field] ?? "").replace(/\r\n/g, "\n").trim(),
		]);
		const long = texts.find(([field, value]) => value.length > LIMITS[field]);
		if (long) {
			const [field] = long;
			return refuse(`Keep the ${field} under ${LIMITS[field].toLocaleString("en-US")} characters.`);
		}
		if ([edit.category, edit.homepage, fields.languages ?? ""].some((v) => v.length > MAX_FIELD)) {
			return refuse(`keep each field under ${MAX_FIELD} characters.`);
		}
		if (edit.homepage !== "" && !HTTP_URL.test(edit.homepage)) {
			return refuse("the homepage must be an http or https address.");
		}
		if (languages.length > MAX_LANGUAGES) return refuse("up to five languages.");
		if (languages.some((name) => name.length > MAX_LANGUAGE)) {
			return refuse(`a language name is at most ${MAX_LANGUAGE} characters.`);
		}
		if (languages.some((name) => /\p{C}/u.test(name))) {
			return refuse("a language name is printable text.");
		}
		if (hidden.length > MAX_HIDDEN) return refuse(`up to ${MAX_HIDDEN} hidden paths.`);
		const unsafe = hidden.find((path) => path.length > MAX_FIELD || !isSafePath(path));
		if (unsafe !== undefined) return refuse(`"${unsafe}" is not a path in the repo.`);
		updateRepo(ctx.kepr, repo.name, edit);
		for (const [field, value] of texts) setRepoText(ctx.kepr, repo.name, field, value);
		// The sync hands the list to Koh (`handHidden`); the mirror has it before the response.
		if (edit.hidden_paths !== repo.hidden_paths) await ctx.syncer.applyHidden([repo.name]);
		return c.redirect(`/admin/repos?repo=${repo.name}&tab=settings&saved=1`, 303);
	});

	// A build's displayed notes and hiding live in kepr.db; the record in the bucket is untouched.
	app.post("/admin/releases/:repo/:version", async (c) => {
		const found = findRelease(ctx, c.req.param("repo"), c.req.param("version"));
		if (!found) return c.notFound();
		const { repo, release } = found;
		const fields = await textFields(c);
		const notes = (fields.notes ?? "").replace(/\r\n/g, "\n");
		if (notes.length > MAX_CHARS) {
			const limit = MAX_CHARS.toLocaleString("en-US");
			const error = `${repo.name} ${release.version}: notes are over ${limit} characters.`;
			return c.html(reposPage(c, ctx, error, repo.name, "builds"), 400);
		}
		// Notes equal to the record's are no override, so a later record edit would show through.
		const override = notes === release.recordNotes ? null : notes;
		setRelease(ctx.kepr, repo.name, release.version, fields.hidden === "1", override);
		return c.redirect(
			`/admin/repos?repo=${repo.name}&tab=builds&saved=1#${repo.name}-${release.version}`,
			303,
		);
	});

	app.post("/admin/repos/:repo/rename", async (c) => {
		const repo = findRepo(ctx.kepr, c.req.param("repo"));
		if (!repo) return c.notFound();
		const to = ((await textFields(c)).name ?? "").trim();
		const problem = await renameProblem(ctx, repo.name, to);
		if (problem) {
			return c.html(reposPage(c, ctx, `${repo.name}: ${problem}`, repo.name, "settings"), 400);
		}
		renameRepo(ctx, repo.name, to);
		return c.redirect(`/admin/repos?repo=${repo.name}&tab=settings`, 303);
	});

	app.post("/admin/repos/:repo/tarballs/delete", async (c) => {
		const repo = findRepo(ctx.kepr, c.req.param("repo"));
		if (!repo) return c.notFound();
		try {
			await dropTarballs(ctx.sync.bucket, repo.name);
		} catch (error) {
			if (!(error instanceof BucketWriteError)) throw error;
			const message = `${repo.name}: ${error.message}`;
			return c.html(reposPage(c, ctx, message, repo.name, "archives"), 503);
		}
		return c.redirect(`/admin/repos?repo=${repo.name}&tab=archives&saved=1`, 303);
	});

	app.post("/admin/releases/:repo/:version/delete", async (c) => {
		const found = findRelease(ctx, c.req.param("repo"), c.req.param("version"));
		if (!found) return c.notFound();
		const { repo, mirror, release } = found;
		const refuse = (status: 400 | 503, error: string) =>
			c.html(
				reposPage(c, ctx, `${repo.name} ${release.version}: ${error}`, repo.name, "builds"),
				status,
			);
		if ((await textFields(c)).confirm !== "1") return refuse(400, "tick the box to delete it.");
		try {
			await deleteRelease(ctx.sync.bucket, ctx.kepr, mirror, repo.name, release.version);
		} catch (error) {
			if (error instanceof BucketWriteError) return refuse(503, error.message);
			throw error;
		}
		return c.redirect(`/admin/repos?repo=${repo.name}&tab=builds&saved=1`, 303);
	});

	app.post("/admin/releases/:repo/:version/:platform/delete", async (c) => {
		const found = findRelease(ctx, c.req.param("repo"), c.req.param("version"));
		const platform = c.req.param("platform");
		if (!found?.release.downloads.some(([p]) => p === platform)) return c.notFound();
		const { repo, mirror, release } = found;
		const refuse = (status: 400 | 503, error: string) =>
			c.html(
				reposPage(
					c,
					ctx,
					`${repo.name} ${release.version} ${platform}: ${error}`,
					repo.name,
					"builds",
				),
				status,
			);
		if ((await textFields(c)).confirm !== "1") return refuse(400, "tick the box to delete it.");
		try {
			await deleteReleaseFile(
				ctx.sync.bucket,
				ctx.kepr,
				mirror,
				repo.name,
				release.version,
				platform,
			);
		} catch (error) {
			if (error instanceof LastReleaseFile) return refuse(400, error.message);
			if (error instanceof BucketWriteError) return refuse(503, error.message);
			throw error;
		}
		return c.redirect(
			`/admin/repos?repo=${repo.name}&tab=builds&saved=1#${repo.name}-${release.version}`,
			303,
		);
	});
}

/** A build of a known repo, as the console lists it, or null. */
function findRelease(ctx: AdminContext, name: string, version: string) {
	const repo = findRepo(ctx.kepr, name);
	const mirror = repo && openMirror(ctx.mirrorDir, repo.name);
	const release =
		repo &&
		mirror &&
		operatorReleases(ctx.kepr, mirror, repo.name).find((r) => r.version === version);
	return repo && mirror && release ? { repo, mirror, release } : null;
}

function reposPage(
	c: Context,
	ctx: AdminContext,
	error: string,
	chosen: string | undefined,
	tab: Tab,
) {
	const repos = allRepos(ctx.kepr);
	const selected = repos.find((repo) => repo.name === chosen) ?? repos[0];
	const body = html`${notice(error)}
<p class="admin-intro">Choose a repository to manage its visibility and public page.</p>
<form method="post" action="/admin/sync">
${formField(c)}<button class="issues-submit" type="submit">sync now</button></form>
${repos.length === 0 && html`<p class="muted mono save-empty">no repos found in the bucket yet</p>`}
<div class="admin-repos">
<nav aria-label="repositories">
${repos.map(
	(repo) => html`<a class="issue-row" id="repo-${repo.name}"
href="/admin/repos?repo=${repo.name}#repo-editor"${selected?.name === repo.name ? html` aria-current="page"` : ""}>
<span>${repo.name}</span><span>${repo.public ? "public" : "private"}</span>
<span class="issue-meta mono">${repo.last_sync_at === null ? "never synced" : `last sync ${formatDate(repo.last_sync_at)} UTC`}</span>
${repo.last_sync_error && html`<span class="issues-error">${repo.last_sync_error}</span>`}</a>`,
)}
</nav>
${selected && repoForm(c, ctx, selected, tab)}
</div>`;
	return adminPage(c, ctx, "repos", body);
}

/** The selected repo at a glance: its numbers and languages (§24). */
function workspace(ctx: AdminContext, repo: AdminRepo) {
	const mirror = openMirror(ctx.mirrorDir, repo.name);
	const stats = repoStats(mirror);
	const releases = operatorReleases(ctx.kepr, mirror, repo.name);
	const downloads = (release: (typeof releases)[number]) =>
		release.downloads.reduce((sum, [, count]) => sum + count, 0);
	const open = operatorIssues(ctx.kepr, "open").filter((issue) => issue.repo === repo.name);
	const vital = (label: string, value: string | number) =>
		html`<div><strong>${String(value)}</strong><span class="mono">${label}</span></div>`;
	return html`<div class="admin-vitals">
${vital("saves", stats.saves)}
${vital("lines", stats.lines)}
${vital("newest version", visibleReleases(ctx.kepr, mirror, repo.name)[0]?.version ?? "none")}
${vital("open issues", open.length)}
${vital(
	"downloads",
	releases.reduce((sum, release) => sum + downloads(release), 0),
)}
</div>
<p class="issue-meta mono">detected languages:
${languageLines(mirror).map(
	([language, lines], i) =>
		html`${i > 0 ? " · " : " "}${language} <span class="muted">${plural(lines, "line")}</span>`,
)}</p>
`;
}

function repoForm(c: Context, ctx: AdminContext, repo: AdminRepo, tab: Tab) {
	const synced =
		repo.last_sync_at === null ? "never synced" : `last sync ${formatDate(repo.last_sync_at)} UTC`;
	const link = (t: Tab) =>
		html`<a class="issues-tab${t === tab ? " active" : ""}" href="/admin/repos?repo=${repo.name}&amp;tab=${t}"${
			t === tab ? html` aria-current="page"` : ""
		}>${t}</a>`;
	const content = {
		overview: () => overviewTab(ctx, repo),
		settings: () => settingsTab(c, ctx, repo),
		builds: () => buildsTab(c, ctx, repo),
		archives: () => archivesTab(c, repo),
	}[tab]();
	return html`<article class="issue-post" id="repo-editor">
<p class="issue-post-head mono">
<span class="issue-author">
${repo.public ? html`<a href="/${repo.name}">${repo.name}</a>` : repo.name}</span>
<span>${repo.public ? "public" : "private"}</span><span class="history-when">${synced}</span></p>
<nav class="issues-bar mono" aria-label="${repo.name} workspace">${TABS.map(link)}</nav>
${content}
</article>`;
}

function overviewTab(ctx: AdminContext, repo: AdminRepo) {
	const quarantined = quarantinedPaths(openMirror(ctx.mirrorDir, repo.name));
	return html`${workspace(ctx, repo)}
${
	repo.last_sync_error && html`<p class="issues-error mono">sync error: ${repo.last_sync_error}</p>`
}
${
	quarantined.length > 0 &&
	html`<p class="issues-error mono">${plural(quarantined.length, "path")} quarantined: ${quarantined.join(", ")}</p>`
}`;
}

function settingsTab(c: Context, ctx: AdminContext, repo: AdminRepo) {
	const own = repoText(ctx.kepr, repo.name);
	const input = (name: keyof RepoEdit, label: string) =>
		html`<label class="issues-label" for="${repo.name}-${name}">${label}</label>
<input class="issues-input" id="${repo.name}-${name}" name="${name}" maxlength="${MAX_FIELD}" value="${String(repo[name])}">`;
	return html`<form class="issues-form" method="post" action="/admin/repos/${repo.name}">
${formField(c)}
<label class="issues-label">
<input type="checkbox" name="public" value="1"${repo.public ? html` checked` : ""}> public</label>
<label class="issues-label">
<input type="checkbox" name="issues_paused" value="1"${repo.issues_paused ? html` checked` : ""}>
pause new issues</label>
${input("category", "category")}
${input("homepage", "homepage")}
${input("languages", "shown languages")}
<p class="issue-meta mono">Up to five, separated by commas. Leave blank to show the detected one.</p>
${textArea(repo.name, "description", "description", 3, own.description)}
${textArea(repo.name, "details", "details", 12, own.details)}
<p class="issue-meta mono">Markdown. Leave either blank to use the README's.</p>
<label class="issues-label" for="${repo.name}-hidden_paths">hidden files and folders</label>
<textarea class="issues-textarea mono" id="${repo.name}-hidden_paths" name="hidden_paths"
rows="4">${repo.hidden_paths}</textarea>
<p class="issue-meta mono">One path per line, such as notes.md or docs/private. Hidden from every page,
the stats and tarballs, and passed to Koh for .kohignore when there is a write key.</p>
<button class="issues-submit" type="submit">save ${repo.name}</button>
</form>
${renameForm(c, repo.name)}`;
}

// The rename runs in the background; the console shows it under way, or why it last failed.
function renameForm(c: Context, name: string) {
	const to = renames.get(name);
	if (to)
		return html`<p class="admin-intro">Renaming ${name} to ${to}. This page shows ${to} once it is done.</p>`;
	return html`${notice(renameErrors.get(name) ? `rename failed: ${renameErrors.get(name)}` : "")}
<form class="issues-form" method="post" action="/admin/repos/${name}/rename">
${formField(c)}
<label class="issues-label" for="${name}-rename">rename</label>
<input class="issues-input mono" id="${name}-rename" name="name" maxlength="100" required>
<p class="issue-meta mono">Moves its history to the new name in the bucket, with its settings, issues and
counts, and sends old links there. Your machines follow it on their next save or steal.</p>
<button class="issues-submit" type="submit">rename ${name}</button>
</form>`;
}

function buildsTab(c: Context, ctx: AdminContext, repo: AdminRepo) {
	const releases = operatorReleases(ctx.kepr, openMirror(ctx.mirrorDir, repo.name), repo.name);
	return html`<section class="repo-section" id="builds">
${
	releases.length > 0
		? releases.map((release) => releaseForm(c, repo.name, release))
		: html`<p class="muted mono save-empty">no builds yet</p>`
}</section>`;
}

function archivesTab(c: Context, repo: AdminRepo) {
	return html`<section class="repo-section">
<form class="issues-form" method="post" action="/admin/repos/${repo.name}/tarballs/delete">
${formField(c)}
<p class="issue-meta mono">Tarballs are kept in the bucket once downloaded, and rebuilt on the next download.
Each one is listed under <a href="/admin/storage">storage</a>.</p>
<button class="issues-submit" type="submit">delete kept tarballs</button>
</form></section>`;
}

function textArea(repo: string, name: RepoText, label: string, rows: number, value: string) {
	return html`<label class="issues-label" for="${repo}-${name}">${label}</label>
<textarea class="issues-textarea" id="${repo}-${name}" name="${name}" rows="${String(rows)}"
maxlength="${String(LIMITS[name])}">${value}</textarea>`;
}

function releaseForm(c: Context, repo: string, release: OperatorRelease) {
	const total = release.downloads.reduce((sum, [, n]) => sum + n, 0);
	const id = `${repo}-${release.version}`;
	return html`<article class="issue-post" id="${id}">
<p class="issue-post-head mono">
${/* this row stays one line: splitting its spans changes the HTML that tests/console.test.ts pins */ ""}${html`<span class="issue-author">${release.version}</span>`}${html`<span>${release.hidden ? "hidden" : "shown"}</span>`}${html`<span>${plural(total, "download")}</span>`}${release.downloads.map(
	([platform, n]) => html`<span class="muted">${platform} ${n}</span>`,
)}
</p>
<form class="issues-form" method="post" action="/admin/releases/${repo}/${release.version}">
${formField(c)}
<label class="issues-label" for="${id}-notes">notes
${release.notes !== release.recordNotes ? html` <span class="muted">(edited)</span>` : ""}</label>
<textarea class="issues-textarea" id="${id}-notes" name="notes" rows="3"
maxlength="${MAX_CHARS}">${release.notes}</textarea>
${
	// One line on purpose: Biome folds a hole-by-hole split back together, and breaking the
	// tag itself would put whitespace in the HTML that tests/console.test.ts pins.
	""
}<label class="issues-label">${html`<input type="checkbox"`}${html` name="hidden" value="1"`}${release.hidden ? html` checked` : ""}> hidden</label>
<button class="issues-submit" type="submit">save ${release.version}</button>
</form>
${
	release.downloads.length > 1 &&
	release.downloads.map(
		([platform]) => html`<form class="issues-form" method="post"
action="/admin/releases/${repo}/${release.version}/${platform}/delete">
${formField(c)}
<label class="issues-label"><input type="checkbox" name="confirm" value="1" required>
delete the ${platform} file from the bucket</label>
<button class="issues-submit" type="submit">delete ${platform}</button>
</form>`,
	)
}
<form class="issues-form" method="post" action="/admin/releases/${repo}/${release.version}/delete">
${formField(c)}
<label class="issues-label"><input type="checkbox" name="confirm" value="1" required>
delete ${release.version} and its files from the bucket; this cannot be undone</label>
<button class="issues-submit" type="submit">delete ${release.version}</button>
</form>
</article>`;
}