import { Database } from "bun:sqlite";
import {
	cpSync,
	existsSync,
	mkdirSync,
	readdirSync,
	readFileSync,
	renameSync,
	rmSync,
} from "node:fs";
import { join, relative } from "node:path";
import { buildTarball } from "../tarball/tar.ts";

const KEEP = 14;
const DAY_MS = 24 * 3600 * 1000;
const CHECK_MS = 3600 * 1000;
const NAME = /^\d{8}T\d{6}Z$/;

/** A backup's name: its UTC time, `20260926T031500Z`, so names sort in time order. */
function stamp(ms: number): string {
	return new Date(ms).toISOString().replace(/[-:]|\.\d{3}/g, "");
}

/** The backups in `data/backups/`, oldest first. */
export function backups(dataDir: string): string[] {
	const root = join(dataDir, "backups");
	return existsSync(root)
		? readdirSync(root)
				.filter((name) => NAME.test(name))
				.sort()
		: [];
}

/**
 * §19's backup: `VACUUM INTO` of kepr.db and a copy of `assets/`, built in a hidden folder and
 * renamed into `data/backups/<time>/`, so a half-made backup is never the newest. Keeps the last 14.
 */
export function makeBackup(kepr: Database, dataDir: string, now = Date.now()): string {
	const root = join(dataDir, "backups");
	const name = stamp(now);
	const tmp = join(root, `.${name}`);
	rmSync(tmp, { recursive: true, force: true });
	// It holds reporters' contact emails, so only Kepr's user may read it.
	mkdirSync(tmp, { recursive: true, mode: 0o700 });
	// Synchronous from here to the rename: no request can change kepr.db or assets/ in between.
	kepr.query("VACUUM INTO ?").run(join(tmp, "kepr.db"));
	// A restored backup must not bring live sign-ins with it.
	const copy = new Database(join(tmp, "kepr.db"));
	copy.run("DELETE FROM sessions");
	copy.run("VACUUM");
	copy.close();
	const assets = join(dataDir, "assets");
	if (existsSync(assets)) cpSync(assets, join(tmp, "assets"), { recursive: true });
	rmSync(join(root, name), { recursive: true, force: true });
	renameSync(tmp, join(root, name));
	for (const old of backups(dataDir).slice(0, -KEEP)) {
		rmSync(join(root, old), { recursive: true, force: true });
	}
	return name;
}

/** Makes a backup when the newest is a day old or there is none; returns its name, else null. */
export function backupIfDue(kepr: Database, dataDir: string, now = Date.now()): string | null {
	const newest = backups(dataDir).at(-1);
	return newest && newest > stamp(now - DAY_MS) ? null : makeBackup(kepr, dataDir, now);
}

/** Daily backups: checked at startup and every hour, so a restart never skips a day. */
export function startBackupLoop(kepr: Database, dataDir: string): void {
	const tick = () => {
		try {
			backupIfDue(kepr, dataDir);
		} catch (error) {
			console.error(`kepr: backup failed: ${error}`);
		}
	};
	tick();
	setInterval(tick, CHECK_MS);
}

/** The newest backup as a `.tar.gz` for "download backup" (§24), or null when there is none. */
export function newestBackupTarball(
	dataDir: string,
): { name: string; bytes: Uint8Array<ArrayBuffer> } | null {
	const name = backups(dataDir).at(-1);
	if (!name) return null;
	const dir = join(dataDir, "backups", name);
	const files = readdirSync(dir, { recursive: true, withFileTypes: true })
		.filter((entry) => entry.isFile())
		.map((entry) => {
			const path = join(entry.parentPath, entry.name);
			return { path: relative(dir, path), bytes: readFileSync(path) };
		});
	// Owner-only once unpacked: kepr.db holds reporters' contact emails.
	return { name, bytes: buildTarball(`kepr-backup-${name}`, files, 0o600) };
}