// Covers §24's Email section: SMTP settings in kepr.toml, the test send, emailed notifications
// and the delivery queue's retries, retry now and discard. SMTP is a fake server in this process.

import { beforeEach, describe, expect, test } from "bun:test";
import { mkdtemp, stat } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { openBucket } from "../src/bucket/reader.ts";
import { createApp } from "../src/server/app.ts";
import { type Config, loadConfig, parseConfig, saveConfig } from "../src/server/config.ts";
import { notify, openKeprDb } from "../src/server/db.ts";
import { deliverDue } from "../src/server/mail.ts";
import { Browser, PASSWORD } from "./browser.ts";

const HASH = await Bun.password.hash(PASSWORD, "argon2id");
type Received = { from: string; to: string; data: string };
const received: Received[] = [];
let refuse = false;

// Just enough SMTP for nodemailer: EHLO, AUTH PLAIN, MAIL, RCPT, DATA, QUIT. `refuse` turns MAIL away.
const smtp = Bun.listen<{ buffer: string; data: boolean; mail: Received }>({
	hostname: "127.0.0.1",
	port: 0,
	socket: {
		open(socket) {
			socket.data = { buffer: "", data: false, mail: { from: "", to: "", data: "" } };
			socket.write("220 fake ESMTP\r\n");
		},
		data(socket, bytes) {
			const state = socket.data;
			state.buffer += new TextDecoder().decode(bytes);
			while (true) {
				if (state.data) {
					const end = state.buffer.indexOf("\r\n.\r\n");
					if (end < 0) return;
					state.mail.data = state.buffer.slice(0, end);
					state.buffer = state.buffer.slice(end + 5);
					state.data = false;
					received.push(state.mail);
					state.mail = { from: "", to: "", data: "" };
					socket.write("250 queued\r\n");
					continue;
				}
				const end = state.buffer.indexOf("\r\n");
				if (end < 0) return;
				const line = state.buffer.slice(0, end);
				state.buffer = state.buffer.slice(end + 2);
				const verb = line.slice(0, 4).toUpperCase();
				if (verb === "EHLO") socket.write("250-fake\r\n250 AUTH PLAIN LOGIN\r\n");
				else if (verb === "AUTH") socket.write("235 ok\r\n");
				else if (verb === "MAIL") {
					if (refuse) socket.write("550 no thanks\r\n");
					else {
						state.mail.from = line;
						socket.write("250 ok\r\n");
					}
				} else if (verb === "RCPT") {
					state.mail.to = line;
					socket.write("250 ok\r\n");
				} else if (verb === "DATA") {
					state.data = true;
					socket.write("354 go\r\n");
				} else if (verb === "QUIT") {
					socket.write("221 bye\r\n");
					socket.end();
				} else socket.write("250 ok\r\n");
			}
		},
	},
});

const SMTP = {
	host: "127.0.0.1",
	port: smtp.port,
	security: "none" as const,
	username: "kepr",
	password: "MAIL-SECRET",
	from: "kepr@kepr.example",
	to: "june@example.com",
};

async function build(withSmtp: boolean) {
	const dataDir = await mkdtemp(join(tmpdir(), "kepr-email-"));
	const configPath = join(dataDir, "kepr.toml");
	const config: Config = {
		domain: "kepr.example",
		dataDir,
		adminPasswordHash: HASH,
		bucket: { kind: "folder", path: dataDir },
		...(withSmtp ? { smtp: { ...SMTP } } : {}),
	};
	await saveConfig(configPath, config);
	const original = await Bun.file(configPath).text();
	const kepr = openKeprDb(dataDir);
	const app = createApp(config, kepr, openBucket(config.bucket), configPath);
	const browser = new Browser(app);
	await browser.signIn();
	await browser.get("/admin/email");
	return { config, configPath, original, kepr, browser };
}

const form = (fields: Record<string, string>) => ({
	host: "127.0.0.1",
	port: String(smtp.port),
	security: "none",
	username: "kepr",
	password: "",
	from: "kepr@kepr.example",
	to: "june@example.com",
	...fields,
});

beforeEach(() => {
	received.length = 0;
	refuse = false;
});

describe("SMTP settings (§19, §24)", () => {
	test("kepr.toml's [smtp] parses, saves back and refuses nonsense", () => {
		const base = `domain = "kepr.example"\ndata_dir = "d"\nadmin_password_hash = "${HASH}"\n[bucket]\nfolder = "b"\n`;
		const smtpToml = `[smtp]\nhost = "mail.example"\nport = 587\nsecurity = "starttls"\nusername = "u"\npassword = "p"\nfrom = "a@b.c"\nto = "d@e.f"\n`;
		expect(parseConfig(base + smtpToml).smtp).toEqual({
			host: "mail.example",
			port: 587,
			security: "starttls",
			username: "u",
			password: "p",
			from: "a@b.c",
			to: "d@e.f",
		});
		expect(() => parseConfig(base + smtpToml.replace("587", "70000"))).toThrow("[smtp] port");
		expect(() => parseConfig(base + smtpToml.replace('"starttls"', '"ssl"'))).toThrow(
			"[smtp] security",
		);
	});

	test("the page shows every setting but the password", async () => {
		const { browser } = await build(true);
		const text = await (await browser.get("/admin/email")).text();
		expect(text).toContain('value="kepr@kepr.example"');
		expect(text).toContain('<option value="none" selected>');
		expect(text).not.toContain("MAIL-SECRET");
	});

	test("send test mails the form's settings at once and saves nothing", async () => {
		const { browser, configPath, original } = await build(false);
		const sent = await browser.post("/admin/email", form({ action: "test", password: "x" }));
		expect(await sent.text()).toContain("Test email sent to june@example.com.");
		expect(sent.status).toBe(200);
		expect(received.length).toBe(1);
		expect(received[0]?.to).toContain("june@example.com");
		expect(received[0]?.data).toContain("Subject: kepr: test email");
		refuse = true;
		const failed = await browser.post("/admin/email", form({ action: "test", password: "x" }));
		expect(failed.status).toBe(400);
		expect(await failed.text()).toContain("The test email was not sent:");
		expect(await Bun.file(configPath).text()).toBe(original);
	});

	test("save rewrites kepr.toml, keeping a blank password and the bucket", async () => {
		const { browser, configPath, config } = await build(true);
		const saved = await browser.post("/admin/email", form({ action: "save", port: "2525" }));
		expect(saved.status).toBe(303);
		const reloaded = await loadConfig(configPath);
		expect(reloaded.smtp).toEqual({ ...SMTP, port: 2525 });
		expect(reloaded.bucket).toEqual(config.bucket);
		expect(config.smtp?.port).toBe(2525);
		expect((await stat(configPath)).mode & 0o777).toBe(0o600);
	});

	test("refuses a malformed form", async () => {
		const { browser, configPath, original } = await build(false);
		const cases: [Record<string, string>, string][] = [
			[{ host: "" }, "The host is required."],
			[{ port: "0" }, "The port is a number from 1 to 65535."],
			[{ security: "ssl" }, "Pick a security setting."],
			[{ to: "not an address" }, "The to address must be an email address."],
			[{ password: "a\nb" }, "The password cannot contain control characters."],
			[{}, "A new SMTP server needs its password"],
		];
		for (const [fields, error] of cases) {
			const response = await browser.post("/admin/email", form({ action: "save", ...fields }));
			expect(response.status).toBe(400);
			expect(await response.text()).toContain(error);
		}
		expect(await Bun.file(configPath).text()).toBe(original);
	});
});

describe("emailed notifications and the delivery queue (§24)", () => {
	const rows = (kepr: ReturnType<typeof openKeprDb>) =>
		kepr
			.query<
				{ id: number; status: string; attempts: number; next_at: number; last_error: string },
				[]
			>("SELECT id, status, attempts, next_at, last_error FROM email_queue ORDER BY id")
			.all();

	test("emailing a kind can be switched on only with SMTP settings", async () => {
		const { browser, kepr } = await build(false);
		const on = await browser.post("/admin/email", { action: "preferences", issue_filed: "1" });
		expect(on.status).toBe(400);
		notify(kepr, "issue_filed", "New issue app #1: t", "/admin/issues/app/1");
		expect(rows(kepr).length).toBe(0);
	});

	test("a switched-on kind is queued and delivered with a link back", async () => {
		const { browser, kepr, config } = await build(true);
		expect(
			(await browser.post("/admin/email", { action: "preferences", issue_filed: "1" })).status,
		).toBe(303);
		notify(kepr, "issue_filed", "New issue app #1: t", "/admin/issues/app/1");
		notify(kepr, "sync_failed", "Sync failed for app: x", "/admin/repos?repo=app");
		expect(rows(kepr).map((row) => row.status)).toEqual(["waiting"]);
		await deliverDue(kepr, config);
		expect(rows(kepr)[0]?.status).toBe("sent");
		expect(received.length).toBe(1);
		expect(received[0]?.data).toContain("Subject: kepr: New issue app #1: t");
		expect(received[0]?.data).toContain("https://kepr.example/admin/issues/app/1");
	});

	test("a failure retries after 1, 5, 30, 120 and 720 minutes, then fails; retry and discard", async () => {
		const { browser, kepr, config } = await build(true);
		kepr.run("INSERT INTO settings (key, value) VALUES ('email_on_backup_failed', '1')");
		notify(kepr, "backup_failed", "Backup failed: disk full", "/admin?section=backups");
		refuse = true;
		let now = Date.now();
		for (const minutes of [1, 5, 30, 120, 720]) {
			await deliverDue(kepr, config, now);
			const row = rows(kepr)[0];
			expect(row?.status).toBe("waiting");
			expect(row?.next_at).toBe(Math.floor(now / 1000) + minutes * 60);
			expect(row?.last_error).toContain("550");
			// Not due yet: nothing happens.
			await deliverDue(kepr, config, now + 1000);
			now += minutes * 60 * 1000;
		}
		await deliverDue(kepr, config, now);
		expect(rows(kepr)[0]?.status).toBe("failed");
		expect(rows(kepr)[0]?.attempts).toBe(6);
		const page = await (await browser.get("/admin/email")).text();
		expect(page).toContain("Backup failed: disk full");
		expect(page).toContain("failed · 6 attempts");
		const id = String(rows(kepr)[0]?.id);
		expect((await browser.post("/admin/email", { action: "retry", id })).status).toBe(303);
		expect(rows(kepr)[0]?.status).toBe("waiting");
		refuse = false;
		await deliverDue(kepr, config);
		expect(rows(kepr)[0]?.status).toBe("sent");
		expect((await browser.post("/admin/email", { action: "discard", id })).status).toBe(303);
		expect(rows(kepr).length).toBe(0);
		expect((await browser.post("/admin/email", { action: "retry", id })).status).toBe(404);
	});
});