import { spawn } from "node:child_process";
import { mkdir, mkdtemp, realpath, rm } from "node:fs/promises";
import { tmpdir } from "node:os";
import { isAbsolute, join, relative, sep } from "node:path";
import { pathToFileURL } from "node:url";
import { ROOT } from "./lib/common.mjs";

export function within(directory, path) {
	const rel = relative(directory, path);
	return (
		rel === "" ||
		(rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel))
	);
}

export function isolatedEnvironment(root, parent = process.env) {
	const originalHome = parent.HOME ?? parent.USERPROFILE;
	if (!originalHome) throw new Error("E2E requires HOME or USERPROFILE");
	const originalData =
		parent.MISE_DATA_DIR ??
		join(parent.XDG_DATA_HOME ?? join(originalHome, ".local", "share"), "mise");
	const originalConfig =
		parent.MISE_CONFIG_DIR ??
		join(parent.XDG_CONFIG_HOME ?? join(originalHome, ".config"), "mise");
	const env = {
		...parent,
		HOME: join(root, "home"),
		USERPROFILE: join(root, "home"),
		APPDATA: join(root, "config"),
		LOCALAPPDATA: join(root, "data"),
		XDG_CONFIG_HOME: join(root, "config"),
		XDG_CACHE_HOME: join(root, "cache"),
		XDG_DATA_HOME: join(root, "data"),
		XDG_STATE_HOME: join(root, "state"),
		TMPDIR: join(root, "tmp"),
		TMP: join(root, "tmp"),
		TEMP: join(root, "tmp"),
		PLAYWRIGHT_BROWSERS_PATH: join(root, "browsers"),
		npm_config_cache: join(root, "npm-cache"),
		PI_CODING_AGENT_DIR: join(root, "agent"),
		PI_BAK_E2E_S3: "0",
		PI_EXT_E2E_ROOT: root,
		MISE_CONFIG_DIR: originalConfig,
		MISE_DATA_DIR: originalData,
		MISE_CACHE_DIR: join(root, "mise-cache"),
		MISE_STATE_DIR: join(root, "mise-state"),
		MISE_AUTO_INSTALL: "0",
		MISE_TASK_RUN_AUTO_INSTALL: "0",
	};
	for (const key of Object.keys(env))
		if (key.startsWith("PI_BAK_S3_")) delete env[key];
	return env;
}

function run(command, args, env, signal) {
	if (signal.aborted) return Promise.resolve(130);
	return new Promise((resolve, reject) => {
		const child = spawn(command, args, {
			cwd: ROOT,
			env,
			stdio: "inherit",
			detached: process.platform !== "win32",
		});
		const interrupt = () => {
			try {
				if (process.platform !== "win32" && child.pid)
					process.kill(-child.pid, "SIGTERM");
				else child.kill("SIGTERM");
			} catch {
				// The child already exited.
			}
		};
		signal.addEventListener("abort", interrupt, { once: true });
		child.once("error", (error) => {
			signal.removeEventListener("abort", interrupt);
			reject(error);
		});
		child.once("close", (code, exitSignal) => {
			signal.removeEventListener("abort", interrupt);
			resolve(signal.aborted ? 130 : (code ?? (exitSignal ? 1 : 0)));
		});
	});
}

export function selectedTasks(tasks, filter) {
	if (!filter) return tasks;
	if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(filter))
		throw new Error("E2E filter must be an extension slug");
	const selected = tasks.filter(
		(task) => task === `//extensions/${filter}:e2e`,
	);
	if (selected.length !== 1) throw new Error(`No local E2E task for ${filter}`);
	return selected;
}

export async function main(tasks = process.argv.slice(2)) {
	if (tasks.length === 0)
		throw new Error("E2E requires explicit Mise task names");
	tasks = selectedTasks(tasks, process.env.PI_EXT_E2E_FILTER);
	const [repo, osTemp] = await Promise.all([
		realpath(ROOT),
		realpath(tmpdir()),
	]);
	if (within(repo, osTemp))
		throw new Error(
			`OS temporary directory must be outside repository: ${osTemp}`,
		);
	const root = await mkdtemp(join(osTemp, "pi-ext-e2e-"));
	const abort = new AbortController();
	const interrupt = () => abort.abort();
	process.once("SIGINT", interrupt);
	process.once("SIGTERM", interrupt);
	try {
		for (const name of [
			"home",
			"config",
			"cache",
			"data",
			"state",
			"tmp",
			"agent",
			"browsers",
		])
			await mkdir(join(root, name));
		const env = isolatedEnvironment(root);
		const installed = await run(
			"npm",
			["exec", "--", "playwright", "install", "chromium", "firefox"],
			env,
			abort.signal,
		);
		if (installed !== 0) return installed;
		const failures = [];
		for (const task of tasks) {
			if (abort.signal.aborted) return 130;
			const exitCode = await run("mise", ["run", task], env, abort.signal);
			if (abort.signal.aborted) return 130;
			if (exitCode !== 0) failures.push(task);
		}
		if (failures.length) {
			console.error(`E2E failed: ${failures.join(", ")}`);
			return 1;
		}
		return 0;
	} finally {
		process.off("SIGINT", interrupt);
		process.off("SIGTERM", interrupt);
		await rm(root, { recursive: true, force: true });
	}
}

if (import.meta.url === pathToFileURL(process.argv[1] ?? "").href) {
	try {
		process.exitCode = await main();
	} catch (error) {
		console.error(error instanceof Error ? error.message : String(error));
		process.exitCode = 1;
	}
}