// Covers §23–§24's triage: tab counts, awaiting reply, repo/type/word filters, hiding one
// follow-up, and pausing new issues per repo.

import { beforeAll, describe, expect, test } from "bun:test";
import { addEntry, fileIssue, setClosed } from "../src/issues/store.ts";
import { Browser, type Instance, instance } from "./browser.ts";
import { makeRepos } from "./fixture.ts";

describe("issue triage (§23, §24)", () => {
	let inst: Instance;
	let operator: Browser;
	let followUp: number;
	let token: string;
	const list = async (query = "") => (await operator.get(`/admin/issues${query}`)).text();
	const text = async (path: string) => (await inst.app.request(path)).text();
	const file = (repo: string, title: string, body: string, type: "bug" | "idea" | "question") =>
		fileIssue(inst.kepr, {
			repo,
			title,
			body,
			type,
			version: "",
			reporterName: "",
			contactEmail: "",
			ipHash: "x",
			filedAt: 1,
		});
	const id = (repo: string, n: number) =>
		(
			inst.kepr
				.query<{ id: number }, [string, number]>(
					"SELECT id FROM issues WHERE repo = ? AND number = ?",
				)
				.get(repo, n) as { id: number }
		).id;

	beforeAll(async () => {
		const repos = await makeRepos(["app", "tools"]);
		inst = await instance(repos.bucketDir);
		operator = new Browser(inst.app);
		await operator.signIn();
		for (const repo of ["app", "tools"]) {
			await operator.post(`/admin/repos/${repo}`, { public: "1" });
		}
		file("app", "Crash on start", "A segfault in main", "bug");
		file("app", "Dark mode", "Please", "idea");
		token = file("app", "How to install", "Which command?", "question").token;
		file("tools", "Tools broken", "Nothing works", "bug");
		addEntry(inst.kepr, id("app", 2), "operator", "Planned.", 2);
		addEntry(inst.kepr, id("app", 3), "operator", "Use the script.", 2);
		followUp = addEntry(inst.kepr, id("app", 3), "reporter", "Buy cheap pills here", 3);
		setClosed(inst.kepr, id("tools", 1), 4);
	});

	test("every tab carries its count", async () => {
		const page = await list();
		expect(page).toMatch(/>\s*open <span class="muted">3<\/span>/);
		expect(page).toMatch(/>\s*awaiting reply <span class="muted">2<\/span>/);
		expect(page).toMatch(/>\s*closed <span class="muted">1<\/span>/);
		expect(page).toMatch(/>\s*hidden <span class="muted">0<\/span>/);
	});

	test("awaiting reply is the open issues where the reporter spoke last", async () => {
		const page = await list("?filter=awaiting");
		expect(page).toContain('href="/admin/issues/app/1"');
		expect(page).toContain('href="/admin/issues/app/3"');
		expect(page).not.toContain('href="/admin/issues/app/2"');
		const rows = (await list()).split('class="issue-row"');
		const row = (n: number) => rows.find((r) => r.includes(`/admin/issues/app/${n}"`)) ?? "";
		expect(row(1)).toContain("awaiting reply");
		expect(row(2)).not.toContain("awaiting reply");
	});

	test("narrows by repo, type and words in the title or text, keeping the form filled", async () => {
		const closedTools = await list("?filter=closed&repo=tools");
		expect(closedTools).toContain('href="/admin/issues/tools/1"');
		expect(closedTools).toContain('<option value="tools" selected>');
		expect(await list("?repo=tools")).not.toContain('href="/admin/issues/app/1"');
		const ideas = await list("?type=idea");
		expect(ideas).toContain('href="/admin/issues/app/2"');
		expect(ideas).not.toContain('href="/admin/issues/app/1"');
		const words = await list("?q=SEGFAULT");
		expect(words).toContain('href="/admin/issues/app/1"');
		expect(words).not.toContain('href="/admin/issues/app/2"');
		expect(words).toContain('value="SEGFAULT"');
		expect(words).toMatch(/>\s*open <span class="muted">1<\/span>/);
		// An unknown repo or type narrows nothing rather than failing.
		expect(await list("?repo=nowhere&type=nonsense")).toContain('href="/admin/issues/app/2"');
	});

	test("hiding one follow-up removes it publicly, keeps it marked in the console", async () => {
		const act = (fields: Record<string, string>) => operator.post("/admin/issues/app/3", fields);
		expect((await act({ action: "hide_entry", entry: String(followUp) })).status).toBe(303);
		expect(await text("/app/issues/3")).not.toContain("cheap pills");
		expect(await text("/app/issues/3")).toContain("Use the script.");
		const console = await (await operator.get("/admin/issues/app/3")).text();
		expect(console).toContain("cheap pills");
		expect(console).toMatch(/hidden[\s\S]*?cheap pills/);
		// The hidden follow-up no longer counts as the reporter speaking last.
		expect(await list("?filter=awaiting")).not.toContain('href="/admin/issues/app/3"');
		expect((await act({ action: "unhide_entry", entry: String(followUp) })).status).toBe(303);
		expect(await text("/app/issues/3")).toContain("cheap pills");
		const other = operator.post("/admin/issues/app/1", {
			action: "hide_entry",
			entry: String(followUp),
		});
		expect((await other).status).toBe(404);
		expect((await act({ action: "hide_entry", entry: "x" })).status).toBe(404);
	});

	test("pausing new issues stops filing but keeps the list and follow-ups", async () => {
		const pause = await operator.post("/admin/repos/app", {
			public: "1",
			issues_paused: "1",
		});
		expect(pause.status).toBe(303);
		expect(await (await operator.get("/admin/repos?repo=app")).text()).toMatch(
			/name="issues_paused" value="1" checked/,
		);
		const form = await inst.app.request("/app/issues/new");
		expect(form.status).toBe(200);
		const formText = await form.text();
		expect(formText).toContain("app is not taking new issues right now.");
		expect(formText).not.toContain('name="title"');
		const filed = await inst.app.request("/app/issues/new", {
			method: "POST",
			body: new URLSearchParams({ title: "t", body: "b", type: "bug" }),
		});
		expect(filed.status).toBe(403);
		expect(await text("/app/issues")).not.toContain("report an issue →");
		expect(await text("/app/issues")).toContain('href="/app/issues/1"');
		expect(await text(`/app/issues/3?token=${token}`)).toContain('name="body"');
		await operator.post("/admin/repos/app", { public: "1" });
		expect(await text("/app/issues/new")).toContain('name="title"');
	});

	test("ticked issues are closed, reopened, hidden and unhidden together", async () => {
		const ticked = [id("app", 1), id("app", 2)];
		const bulk = (action: string, issues = ticked) => {
			const form = new FormData();
			form.set("action", action);
			form.set("filter", "closed");
			for (const issue of issues) form.append("issue", String(issue));
			return operator.post("/admin/issues", form);
		};
		const status = () =>
			inst.kepr
				.query("SELECT status, hidden FROM issues WHERE id IN (?, ?) ORDER BY id")
				.all(...ticked);
		expect(await list()).toContain(`name="issue" value="${ticked[0]}"`);
		const closed = await bulk("close");
		expect(closed.status).toBe(303);
		expect(closed.headers.get("location")).toBe("/admin/issues?filter=closed");
		expect(status()).toEqual([
			{ status: "closed", hidden: 0 },
			{ status: "closed", hidden: 0 },
		]);
		await bulk("hide");
		expect(status().map((row) => (row as { hidden: number }).hidden)).toEqual([1, 1]);
		await bulk("unhide");
		await bulk("reopen");
		expect(status()).toEqual([
			{ status: "open", hidden: 0 },
			{ status: "open", hidden: 0 },
		]);
		expect((await bulk("close", [999_999])).status).toBe(404);
		expect((await bulk("explode")).status).toBe(404);
	});

	test("blocking a reporter lists the block under the tabs until it is lifted", async () => {
		expect(await list()).not.toContain("blocked reporters");
		const blocked = await operator.post("/admin/issues/app/2", { action: "block" });
		expect(blocked.status).toBe(303);
		const issue = await (await operator.get("/admin/issues/app/2")).text();
		expect(issue).toContain("reporter blocked");
		const page = await list();
		expect(page).toContain("blocked reporters");
		expect(page).toContain('href="/admin/issues/app/2"');
		const block = /name="block" value="(\d+)"/.exec(page)?.[1] ?? "";
		expect(block).not.toBe("");
		expect((await operator.post("/admin/issues", { action: "unblock", block: "999" })).status).toBe(
			404,
		);
		expect((await operator.post("/admin/issues", { action: "unblock", block })).status).toBe(303);
		expect(await list()).not.toContain("blocked reporters");
	});
});