import type { Context, Hono } from "hono";
import { MAX_CHARS } from "../issues/spam.ts";
import {
	addEntry,
	type Entry,
	ISSUE_TYPES,
	type IssueType,
	type OperatorFilter,
	type OperatorIssue,
	operatorEntries,
	operatorIssue,
	operatorIssues,
	setClosed,
	setEntryHidden,
	setHidden,
	setType,
} from "../issues/store.ts";
import { saveByPrefix } from "../mirror/queries.ts";
import { openMirror } from "../mirror/store.ts";
import { html } from "../pages/html.ts";
import { formatDate, relativeTime } from "../pages/layout.ts";
import { type AdminContext, adminPage, formField, notice, textFields } from "./console.ts";
import { allRepos } from "./store.ts";

const FILTERS: [filter: OperatorFilter, label: string][] = [
	["open", "open"],
	["awaiting", "awaiting reply"],
	["closed", "closed"],
	["hidden", "hidden"],
];
const SAVE_PREFIX = /^[0-9a-f]{6,12}$/;
const ISSUE_PATH = "/admin/issues/:repo/:n{[0-9]{1,9}}";
const unixNow = () => Math.floor(Date.now() / 1000);

/** §24's Issues section: every repo's issues, and the operator's actions of §23. */
export function registerIssues(app: Hono, ctx: AdminContext): void {
	app.get("/admin/issues", (c) => {
		const filter = FILTERS.find(([f]) => f === c.req.query("filter"))?.[0] ?? "open";
		// An unknown repo or type narrows nothing, as the public list treats an unknown type.
		const repos = allRepos(ctx.kepr).map((repo) => repo.name);
		const repo = repos.find((name) => name === c.req.query("repo")) ?? "";
		const type = ISSUE_TYPES.find((t) => t === c.req.query("type")) ?? "";
		const words = (c.req.query("q") ?? "").trim();
		const narrowed = (f: OperatorFilter) =>
			operatorIssues(ctx.kepr, f).filter(
				(issue) =>
					(!repo || issue.repo === repo) &&
					(!type || issue.type === type) &&
					`${issue.title}\n${issue.body}`.toLowerCase().includes(words.toLowerCase()),
			);
		const tab = ([f, label]: (typeof FILTERS)[number]) => {
			const query = new URLSearchParams({ filter: f, repo, type, q: words });
			return html`<a class="issues-tab${f === filter ? " active" : ""}"
				href="/admin/issues?${query.toString()}">
${label} <span class="muted">${narrowed(f).length}</span></a>`;
		};
		const option = (value: string, selected: string) =>
			html`<option value="${value}"${value === selected ? html` selected` : ""}>${value}</option>`;
		const issues = narrowed(filter);
		const body = html`<p class="issues-bar mono">${FILTERS.map(tab)}</p>
<form class="issues-filter" method="get" action="/admin/issues">
<input type="hidden" name="filter" value="${filter}">
<select class="issues-input" name="repo" aria-label="repository">
<option value="">all repos</option>
${repos.map((name) => option(name, repo))}
</select>
<select class="issues-input" name="type" aria-label="issue type">
<option value="">all types</option>
${ISSUE_TYPES.map((value) => option(value, type))}
</select>
<input class="issues-input" name="q" type="search" aria-label="search titles and text"
placeholder="search titles and text" value="${words}">
<button class="issues-submit" type="submit">filter</button>
</form>
<section class="repo-section">
${
	issues.length > 0
		? issues.map(
				(issue) =>
					html`<a class="issue-row" href="/admin/issues/${issue.repo}/${issue.number}">
<span class="issue-title">${issue.title}${
						issue.awaiting && !issue.hidden && issue.status === "open"
							? html` <span class="issue-badge">awaiting reply</span>`
							: ""
					}</span>
<span class="issue-meta mono">${issue.repo} #${issue.number} · ${issue.type} ·
${issue.status} · ${relativeTime(issue.filed_at)}</span></a>`,
			)
		: html`<p class="muted mono save-empty">no issues here</p>`
}
</section>`;
		return c.html(adminPage(c, ctx, "issues", body));
	});

	app.get(ISSUE_PATH, (c) => {
		const issue = operatorIssue(ctx.kepr, c.req.param("repo"), Number(c.req.param("n")));
		return issue ? c.html(issuePage(c, ctx, issue, "")) : c.notFound();
	});

	app.post(ISSUE_PATH, async (c) => {
		const issue = operatorIssue(ctx.kepr, c.req.param("repo"), Number(c.req.param("n")));
		if (!issue) return c.notFound();
		const fields = await textFields(c);
		const refuse = (error: string) => c.html(issuePage(c, ctx, issue, error), 400);
		switch (fields.action) {
			case "reply": {
				const body = (fields.body ?? "").trim();
				if (body === "" || body.length > MAX_CHARS) {
					return refuse(`A reply is 1 to ${MAX_CHARS.toLocaleString("en-US")} characters.`);
				}
				addEntry(ctx.kepr, issue.id, "operator", body, unixNow());
				break;
			}
			case "close": {
				const prefix = (fields.fixed_in ?? "").trim();
				if (prefix === "") {
					setClosed(ctx.kepr, issue.id, unixNow());
					break;
				}
				const save = SAVE_PREFIX.test(prefix)
					? saveByPrefix(openMirror(ctx.mirrorDir, issue.repo), prefix)
					: null;
				if (!save) return refuse(`No save ${prefix} in ${issue.repo}.`);
				setClosed(ctx.kepr, issue.id, unixNow(), save.id);
				break;
			}
			case "reopen":
				setClosed(ctx.kepr, issue.id, null);
				break;
			case "hide_entry":
			case "unhide_entry": {
				const entry = Number(fields.entry);
				const hidden = fields.action === "hide_entry";
				if (!Number.isSafeInteger(entry) || !setEntryHidden(ctx.kepr, issue.id, entry, hidden)) {
					return c.notFound();
				}
				break;
			}
			case "hide":
			case "unhide":
				setHidden(ctx.kepr, issue.id, fields.action === "hide");
				break;
			case "type":
				if (!ISSUE_TYPES.includes(fields.type as IssueType)) return refuse("Pick a type.");
				setType(ctx.kepr, issue.id, fields.type as IssueType);
				break;
			default:
				return refuse("Unknown action.");
		}
		return c.redirect(`/admin/issues/${issue.repo}/${issue.number}`, 303);
	});
}

function issuePage(c: Context, ctx: AdminContext, issue: OperatorIssue, error: string): string {
	const action = `/admin/issues/${issue.repo}/${issue.number}`;
	const button = (name: string, label: string) =>
		html`<form method="post" action="${action}">
${formField(c)}<input type="hidden" name="action" value="${name}">
<button class="issues-submit" type="submit">${label}</button></form>`;
	const post = (operator: boolean, at: number, text: string, entry?: Entry) =>
		html`<article class="issue-post${operator ? " issue-post--operator" : ""}">
<p class="issue-post-head mono">${
			operator
				? html`<span class="issue-badge">operator</span>`
				: html`<span class="issue-author">${issue.reporter_name || "anonymous"}</span>`
		}<span class="history-when">${formatDate(at)}</span>${
			entry?.hidden ? html`<span class="issues-error">hidden</span>` : ""
		}</p>
<div class="issue-text">${text}</div>
${
	entry &&
	html`<form method="post" action="${action}">${formField(c)}
<input type="hidden" name="action" value="${entry.hidden ? "unhide_entry" : "hide_entry"}">
<input type="hidden" name="entry" value="${String(entry.id)}">
<button class="issues-cancel mono" type="submit">${entry.hidden ? "unhide" : "hide (spam)"}</button>
</form>`
}
</article>`;
	const typeOption = (type: string) =>
		html`<option value="${type}"${issue.type === type ? html` selected` : ""}>${type}</option>`;
	const body = html`${notice(error)}
<p class="issue-meta mono">${issue.repo} #${issue.number} · ${issue.status}${
		issue.fixed_in && ` · fixed in ${issue.fixed_in}`
	}${issue.hidden ? " · hidden" : ""} · ${issue.version && `v${issue.version} · `}filed ${formatDate(issue.filed_at)}</p>
<p class="issue-meta mono">reporter: ${issue.reporter_name || "anonymous"}
· contact: ${issue.contact_email || "none given"}</p>
${post(false, issue.filed_at, issue.body)}
${operatorEntries(ctx.kepr, issue.id).map((entry) =>
	post(entry.author === "operator", entry.created_at, entry.body, entry),
)}
<form class="issues-form" method="post" action="${action}">${formField(c)}
<input type="hidden" name="action" value="reply">
<label class="issues-label" for="reply">reply</label>
<textarea class="issues-textarea" id="reply" name="body" rows="5" required
maxlength="${MAX_CHARS}"></textarea>
<button class="issues-submit" type="submit">reply</button>
</form>
${
	issue.status === "open"
		? html`<form class="issues-form" method="post" action="${action}">${formField(c)}
<input type="hidden" name="action" value="close">
<label class="issues-label" for="fixed-in">fixed in save
<span class="muted">(optional)</span></label>
<input class="issues-input" id="fixed-in" name="fixed_in" maxlength="12">
<button class="issues-submit" type="submit">close</button>
</form>`
		: button("reopen", "reopen")
}
<form class="issues-form" method="post" action="${action}">${formField(c)}
<input type="hidden" name="action" value="type">
<label class="issues-label" for="type">type</label>
<select class="issues-input" id="type" name="type">${ISSUE_TYPES.map(typeOption)}</select>
<button class="issues-submit" type="submit">set type</button>
</form>
${issue.hidden ? button("unhide", "unhide") : button("hide", "hide (spam)")}`;
	return adminPage(c, ctx, issue.title, body);
}