import { Database } from "bun:sqlite";
import {
	cpSync,
	existsSync,
	mkdirSync,
	readdirSync,
	readFileSync,
	renameSync,
	rmSync,
	statSync,
} from "node:fs";
import { join, relative } from "node:path";
import { buildTarball } from "../tarball/tar.ts";
import type { BackupBucket, Config } from "./config.ts";
import { notify, setting } from "./db.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");
	// Not a folder is no backups, so the console still shows why the next one fails.
	return existsSync(root) && statSync(root).isDirectory()
		? 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, and an upload
 * to the backup bucket that failed is retried. `config` is the live one the console edits.
 */
export function startBackupLoop(kepr: Database, config: Config): void {
	const tick = () => {
		attemptBackup(kepr, () => backupIfDue(kepr, config.dataDir));
		attemptUpload(kepr, config.dataDir, config.backup).catch((error) =>
			console.error(`kepr: backup upload failed: ${error}`),
		);
	};
	tick();
	setInterval(tick, CHECK_MS);
}

/**
 * One backup attempt. A failure is kept for the console until a backup succeeds (§24), and only a
 * backup that starts failing is told, not every hourly retry. Returns the failure, or null.
 */
export function attemptBackup(kepr: Database, make: () => unknown): string | null {
	try {
		make();
		kepr.query("DELETE FROM settings WHERE key = 'backup_error'").run();
		return null;
	} catch (error) {
		return keepFailure(kepr, "backup_error", "Backup failed", error);
	}
}

/** Keeps a failure under `key` for the console, telling the operator only when it starts. */
function keepFailure(kepr: Database, key: string, what: string, error: unknown): string {
	const message = String(error);
	console.error(`kepr: ${what.toLowerCase()}: ${message}`);
	if (!setting(kepr, key)) {
		notify(kepr, "backup_failed", `${what}: ${message}`, "/admin?section=backups");
	}
	kepr.query("INSERT OR REPLACE INTO settings (key, value) VALUES (?, ?)").run(key, message);
	return message;
}

const OFFSITE = /^kepr-backup-(\d{8}T\d{6}Z)\.tar\.gz$/;
const offsiteKey = (name: string) => `kepr-backup-${name}.tar.gz`;

function backupClient(bucket: BackupBucket): Bun.S3Client {
	return new Bun.S3Client({
		endpoint: bucket.endpoint,
		bucket: bucket.name,
		region: bucket.region,
		accessKeyId: bucket.accessKeyId,
		secretAccessKey: bucket.secretAccessKey,
	});
}

/** The backups in the backup bucket, oldest first, with their sizes. */
export async function offsiteBackups(
	bucket: BackupBucket,
): Promise<{ name: string; size: number }[]> {
	const found: { name: string; size: number }[] = [];
	const client = backupClient(bucket);
	let continuationToken: string | undefined;
	do {
		const page = await client.list({ prefix: "kepr-backup-", continuationToken });
		for (const object of page.contents ?? []) {
			const name = OFFSITE.exec(object.key)?.[1];
			if (name) found.push({ name, size: object.size ?? 0 });
		}
		continuationToken = page.isTruncated ? page.nextContinuationToken : undefined;
	} while (continuationToken);
	return found.sort((a, b) => a.name.localeCompare(b.name));
}

/** Tried before a backup bucket is saved: a test file must write, list and delete. Returns what failed. */
export async function checkBackupBucket(bucket: BackupBucket): Promise<string | null> {
	const client = backupClient(bucket);
	try {
		await client.write("kepr-backup-test", "test", { type: "text/plain" });
		await offsiteBackups(bucket);
		await client.delete("kepr-backup-test");
		return null;
	} catch (error) {
		return `The backup bucket did not take a test file: ${error instanceof Error ? error.message : String(error)}`;
	}
}

/**
 * Copies the newest local backup to the backup bucket unless it is there already, then keeps the
 * newest 14 there. A failure is kept and told once, as a local one is; null when all is well.
 */
export async function attemptUpload(
	kepr: Database,
	dataDir: string,
	bucket: BackupBucket | undefined,
): Promise<string | null> {
	const newest = backups(dataDir).at(-1);
	if (!bucket || !newest || setting(kepr, "backup_uploaded") === newest) return null;
	try {
		const tarball = backupTarball(dataDir, newest);
		if (!tarball) return null;
		const client = backupClient(bucket);
		await client.write(offsiteKey(newest), tarball.bytes, { type: "application/gzip" });
		for (const old of (await offsiteBackups(bucket)).slice(0, -KEEP)) {
			await client.delete(offsiteKey(old.name));
		}
		kepr
			.query("INSERT OR REPLACE INTO settings (key, value) VALUES ('backup_uploaded', ?)")
			.run(newest);
		kepr.query("DELETE FROM settings WHERE key = 'backup_upload_error'").run();
		return null;
	} catch (error) {
		return keepFailure(kepr, "backup_upload_error", "Backup upload failed", error);
	}
}

function backupFiles(dataDir: string, name: string): { path: string; full: string }[] {
	const dir = join(dataDir, "backups", name);
	return readdirSync(dir, { recursive: true, withFileTypes: true })
		.filter((entry) => entry.isFile())
		.map((entry) => {
			const full = join(entry.parentPath, entry.name);
			return { path: relative(dir, full), full };
		});
}

/** What one backup takes on disk. */
export function backupBytes(dataDir: string, name: string): number {
	return backupFiles(dataDir, name).reduce((sum, file) => sum + statSync(file.full).size, 0);
}

/**
 * A kept backup as a `.tar.gz` for the console's downloads (§24), the newest when no name is
 * given; null when there is no such backup.
 */
export function backupTarball(
	dataDir: string,
	wanted?: string,
): { name: string; bytes: Uint8Array<ArrayBuffer> } | null {
	const kept = backups(dataDir);
	// Only a name from the list, so a request can never reach outside data/backups/.
	const name = wanted === undefined ? kept.at(-1) : kept.find((known) => known === wanted);
	if (!name) return null;
	const files = backupFiles(dataDir, name).map((file) => ({
		path: file.path,
		bytes: readFileSync(file.full),
	}));
	// Owner-only once unpacked: kepr.db holds reporters' contact emails.
	return { name, bytes: buildTarball(`kepr-backup-${name}`, files, 0o600) };
}