import { createJiti } from "jiti";

interface Registrations {
	tools: string[];
	commands: string[];
	shortcuts: string[];
	flags: string[];
	providers: string[];
	events: string[];
	renderers: string[];
	/**
	 * Names, within tools/commands/shortcuts/flags respectively, whose registration call carried an
	 * explicit `shared: true` marker -- see @danypops/vehicle-client-pi's own markSharedRegistration.
	 * doctor.ts only suppresses a name's conflict once EVERY one of its claimants marked it shared.
	 */
	sharedTools: string[];
	sharedCommands: string[];
	sharedShortcuts: string[];
	sharedFlags: string[];
}

const MAX_REGISTRATIONS_TOTAL = 100;
const MAX_NAME_LENGTH = 128;
const originalWrite = process.stdout.write.bind(process.stdout);
console.log = () => {};
console.info = () => {};
console.warn = () => {};
console.error = () => {};
globalThis.fetch = Object.assign(
	async () => {
		const error = new Error("network disabled by Packed smoke sandbox") as Error & { code: string };
		error.code = "ENETUNREACH";
		throw error;
	},
	{ preconnect() {} },
) as typeof fetch;
const denyProcess = () => {
	const error = new Error("subprocesses disabled by Packed smoke sandbox") as Error & { code: string };
	error.code = "EPERM";
	throw error;
};
const bunRuntime = Bun as unknown as Record<string, unknown>;
bunRuntime.spawn = denyProcess;
bunRuntime.spawnSync = denyProcess;
bunRuntime.$ = denyProcess;

const registrations: Registrations = {
	tools: [],
	commands: [],
	shortcuts: [],
	flags: [],
	providers: [],
	events: [],
	renderers: [],
	sharedTools: [],
	sharedCommands: [],
	sharedShortcuts: [],
	sharedFlags: [],
};

function capture(kind: keyof Registrations, value: unknown): void {
	if (Object.values(registrations).reduce((total, values) => total + values.length, 0) >= MAX_REGISTRATIONS_TOTAL) return;
	const name = typeof value === "string" ? value : "";
	registrations[kind].push(name.slice(0, MAX_NAME_LENGTH));
}

const SHARED_KIND: Partial<Record<keyof Registrations, keyof Registrations>> = {
	tools: "sharedTools",
	commands: "sharedCommands",
	shortcuts: "sharedShortcuts",
	flags: "sharedFlags",
};

/** Captures the plain registration as usual, plus a parallel sharedX entry when the caller's own definition/options object carried an explicit `shared: true` marker. */
function captureWithSharedMarker(kind: keyof Registrations, value: unknown, sharedMarker: unknown): void {
	capture(kind, value);
	const sharedKind = SHARED_KIND[kind];
	if (sharedKind && sharedMarker === true) capture(sharedKind, value);
}

const api = new Proxy<Record<string, unknown>>(
	{},
	{
		get(_target, property) {
			switch (property) {
				case "registerTool":
					return (definition: { name?: unknown; shared?: unknown }) => captureWithSharedMarker("tools", definition?.name, definition?.shared);
				case "registerCommand":
					return (name: unknown, options?: { shared?: unknown }) => captureWithSharedMarker("commands", name, options?.shared);
				case "registerShortcut":
					return (name: unknown, options?: { shared?: unknown }) => captureWithSharedMarker("shortcuts", name, options?.shared);
				case "registerFlag":
					return (name: unknown, options?: { shared?: unknown }) => captureWithSharedMarker("flags", name, options?.shared);
				case "registerProvider":
					return (name: unknown) => capture("providers", name);
				case "registerMessageRenderer":
					return (name: unknown) => capture("renderers", name);
				case "on":
					return (name: unknown) => capture("events", name);
				case "getAllTools":
					return () => [];
				case "getActiveTools":
					return () => [];
				case "getCommands":
					return () => [];
				default:
					return () => undefined;
			}
		},
	},
);

function classify(error: unknown): "capability-denied" | "crash" {
	const value = error as { code?: unknown; message?: unknown; cause?: { code?: unknown } };
	const code = String(value?.code ?? value?.cause?.code ?? "");
	const message = String(value?.message ?? error ?? "");
	return /^(?:EACCES|EPERM|EROFS|ENETUNREACH|EAI_AGAIN|ECONNREFUSED|EAGAIN)$/.test(code) ||
		/permission denied|operation not permitted|read-only file system|network is unreachable|failed to connect|unable to connect|resource temporarily unavailable/i.test(
			message,
		)
		? "capability-denied"
		: "crash";
}

async function main(): Promise<void> {
	const extensionPath = process.argv[2];
	if (!extensionPath) throw new Error("extension path is required");
	try {
		// tryNative matches loader.ts's own real, non-Bun-binary Pi extension loading convention:
		// prefer Bun's native TS/ESM transform, falling back to jiti's own Babel transform only for
		// what native genuinely can't handle. Confirmed live: tryNative:false forced EVERY
		// transitive dependency (including plain CJS libraries that never needed a Babel transform,
		// e.g. follow-redirects) through jiti's Babel path -- which has its own real, reproducible
		// bug interacting with a library that calls Error.captureStackTrace on a not-yet-initialized
		// Error instance during module-level prototype setup (confirmed outside this sandbox too,
		// given a cold jiti transform cache), surfacing as an opaque "First argument must be an
		// Error object" crash unrelated to the extension's own code.
		const jiti = createJiti(import.meta.url, { interopDefault: true, tryNative: true });
		const factory = (await jiti.import(extensionPath, { default: true })) as unknown;
		if (typeof factory !== "function") throw new Error("extension has no default factory export");
		await factory(api);
		originalWrite(`${JSON.stringify({ status: "ok", registrations })}\n`);
	} catch (error) {
		const message = (error instanceof Error ? error.message : String(error)).slice(0, 1_000);
		originalWrite(`${JSON.stringify({ status: classify(error), message, registrations })}\n`);
	}
}

await main();