import { type ChildProcessWithoutNullStreams, spawn } from "node:child_process";
import type { Duplex } from "node:stream";

export {
	SidecarProcessError,
	SidecarProcessExited,
} from "./sidecar-errors.js";

import { SidecarProcessError, SidecarProcessExited } from "./sidecar-errors.js";

export interface StdioSidecarProcessSpawnOptions {
	command: string;
	args?: string[];
	cwd?: string;
}

export class StdioSidecarProcess {
	readonly child: ChildProcessWithoutNullStreams;
	readonly control: Duplex;
	private readonly stderrChunks: Buffer[] = [];
	private readonly exitListeners = new Set<
		(error: SidecarProcessExited) => void
	>();
	private readonly errorListeners = new Set<
		(error: SidecarProcessError) => void
	>();

	private constructor(child: ChildProcessWithoutNullStreams, control: Duplex) {
		this.child = child;
		this.control = control;
		this.child.stderr.on("data", (chunk: Buffer | string) => {
			this.stderrChunks.push(
				typeof chunk === "string" ? Buffer.from(chunk) : Buffer.from(chunk),
			);
		});
		this.child.on("exit", (code, signal) => {
			const error = new SidecarProcessExited({
				exitCode: code,
				signal,
				stderr: this.stderrText(),
			});
			for (const listener of this.exitListeners) {
				listener(error);
			}
		});
		this.child.on("error", (error) => {
			const normalized =
				error instanceof Error ? error : new Error(String(error));
			const sidecarError = new SidecarProcessError(
				normalized,
				this.stderrText(),
			);
			for (const listener of this.errorListeners) {
				listener(sidecarError);
			}
		});
	}

	static spawn(options: StdioSidecarProcessSpawnOptions): StdioSidecarProcess {
		const child = spawn(options.command, options.args ?? [], {
			cwd: options.cwd,
			stdio: ["pipe", "pipe", "pipe", "pipe"],
		}) as unknown as ChildProcessWithoutNullStreams;
		try {
			return new StdioSidecarProcess(child, requireControlStream(child));
		} catch (error) {
			child.kill("SIGKILL");
			throw error;
		}
	}

	static fromChild(
		child: ChildProcessWithoutNullStreams,
		control?: Duplex,
	): StdioSidecarProcess {
		return new StdioSidecarProcess(
			child,
			control ?? requireControlStream(child),
		);
	}

	onExit(handler: (error: SidecarProcessExited) => void): () => void {
		this.exitListeners.add(handler);
		return () => {
			this.exitListeners.delete(handler);
		};
	}

	onError(handler: (error: SidecarProcessError) => void): () => void {
		this.errorListeners.add(handler);
		return () => {
			this.errorListeners.delete(handler);
		};
	}

	stderrText(): string {
		return Buffer.concat(this.stderrChunks).toString("utf8").trim();
	}

	currentExitError(): SidecarProcessExited | null {
		if (this.child.exitCode === null && this.child.signalCode === null) {
			return null;
		}
		return new SidecarProcessExited({
			exitCode: this.child.exitCode,
			signal: this.child.signalCode,
			stderr: this.stderrText(),
		});
	}

	waitForExit(timeoutMs: number): Promise<number | null> {
		return new Promise<number | null>((resolve) => {
			let timer: ReturnType<typeof setTimeout> | null = null;
			const cleanup = () => {
				this.child.off("exit", onExit);
				this.child.off("close", onClose);
				if (timer !== null) {
					clearTimeout(timer);
					timer = null;
				}
			};
			const onExit = (code: number | null) => {
				cleanup();
				resolve(code);
			};
			const onClose = (code: number | null) => {
				cleanup();
				resolve(code);
			};
			if (this.child.exitCode !== null || this.child.signalCode !== null) {
				resolve(this.child.exitCode);
				return;
			}
			this.child.on("exit", onExit);
			this.child.on("close", onClose);
			timer = setTimeout(() => {
				cleanup();
				resolve(null);
			}, timeoutMs);
		});
	}
}

function requireControlStream(child: ChildProcessWithoutNullStreams): Duplex {
	const stream = child.stdio[3];
	if (
		!stream ||
		typeof (stream as Duplex).write !== "function" ||
		typeof (stream as Duplex).on !== "function" ||
		typeof (stream as Duplex).read !== "function"
	) {
		throw new Error("sidecar process did not expose a full-duplex fd 3");
	}
	return stream as Duplex;
}