import { afterAll, afterEach, beforeAll, describe, expect, it, setDefaultTimeout, vi } from "bun:test";
import * as path from "node:path";
import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
import { Settings } from "@oh-my-pi/pi-coding-agent/config/settings";
import { disposeAllVmContexts } from "@oh-my-pi/pi-coding-agent/eval/js/context-manager";
import { executeJs, type JsResult } from "@oh-my-pi/pi-coding-agent/eval/js/executor";
import type { ToolSession } from "@oh-my-pi/pi-coding-agent/tools";
import { TempDir } from "@oh-my-pi/pi-utils";
import { INTENT_FIELD } from "@oh-my-pi/pi-wire";
import { type } from "arktype";

// JS eval cold-starts a Bun worker; under --isolate + high CI concurrency that startup
// can exceed Bun's 5s default per-test timeout, flaking the suite. Give the worker-backed
// tests headroom above the worker-init floor (context-manager WORKER_INIT_TIMEOUT_MS).
setDefaultTimeout(20_000);

function createTool(
	name: string,
	execute: (toolCallId: string, args: unknown, signal?: AbortSignal) => Promise<AgentToolResult>,
): AgentTool {
	return {
		name,
		label: name,
		description: `${name} tool`,
		parameters: type({}),
		concurrency: "parallel",
		execute,
	} as unknown as AgentTool;
}

function getJsonData(result: JsResult): unknown {
	const jsonOutputs = result.displayOutputs.filter(
		(output): output is Extract<JsResult["displayOutputs"][number], { type: "json" }> => output.type === "json",
	);
	expect(jsonOutputs).toHaveLength(1);
	return jsonOutputs[0].data;
}

function getStatusEvents(result: JsResult) {
	return result.displayOutputs.filter(
		(output): output is Extract<JsResult["displayOutputs"][number], { type: "status" }> => output.type === "status",
	);
}

describe("executeJs", () => {
	let tempDir: TempDir;
	let session: ToolSession;
	let sessionFile: string;
	let sessionId: string;

	beforeAll(async () => {
		tempDir = TempDir.createSync("@js-executor-");
		sessionFile = path.join(tempDir.path(), "session.jsonl");
		sessionId = `session:${sessionFile}:cwd:${tempDir.path()}`;
		session = {
			cwd: tempDir.path(),
			hasUI: false,
			getSessionFile: () => sessionFile,
			getSessionSpawns: () => null,
			settings: Settings.isolated(),
		};

		await Bun.write(
			path.join(tempDir.path(), "config.json"),
			JSON.stringify({ name: "demo", enabled: true }, null, 2),
		);
		await Bun.write(path.join(tempDir.path(), "config.yaml"), "name: demo\nenabled: true\n");
	});

	afterEach(() => {
		vi.restoreAllMocks();
	});

	afterAll(async () => {
		await disposeAllVmContexts();
		tempDir.removeSync();
	});

	it("persists bindings across calls and reset clears them", async () => {
		await executeJs("const answer = 2;", { sessionId, session, sessionFile });

		const persisted = await executeJs("return answer + 2;", { sessionId, session, sessionFile });
		expect(persisted.exitCode).toBe(0);
		expect(persisted.output.trim()).toBe("4");

		const resetResult = await executeJs("return typeof answer;", {
			sessionId,
			session,
			sessionFile,
			reset: true,
		});
		expect(resetResult.exitCode).toBe(0);
		expect(resetResult.output.trim()).toBe("undefined");
	});

	it("parallel() barriers until every thunk settles and throws the lowest-index error", async () => {
		const result = await executeJs(
			[
				"const settled = [];",
				"try {",
				"	await parallel([",
				"		async () => { await new Promise(r => setTimeout(r, 30)); settled.push('slow'); },",
				"		async () => { settled.push('bad1'); throw new Error('bad1'); },",
				"		async () => { settled.push('bad2'); throw new Error('bad2'); },",
				"	]);",
				"	return 'no-throw';",
				"} catch (err) {",
				"	return JSON.stringify([err.message, settled.sort()]);",
				"}",
			].join("\n"),
			{ sessionId, session, sessionFile },
		);
		expect(result.exitCode).toBe(0);
		// Every thunk ran to completion (the slow one was not orphaned by the
		// early rejections), and the lowest-index error propagated.
		expect(JSON.parse(result.output.trim())).toEqual(["bad1", ["bad1", "bad2", "slow"]]);
	});

	it("persists bindings from cells that contain nested returns", async () => {
		const first = await executeJs(
			[
				"const nestedReturnCarry = { value: 11 };",
				"const readCarry = () => {",
				"  return nestedReturnCarry.value;",
				"};",
				"readCarry();",
			].join("\n"),
			{ sessionId, session, sessionFile },
		);
		expect(first.exitCode).toBe(0);
		expect(first.output.trim()).toBe("11");

		const persisted = await executeJs("return nestedReturnCarry.value + 1;", { sessionId, session, sessionFile });
		expect(persisted.exitCode).toBe(0);
		expect(persisted.output.trim()).toBe("12");
	});

	it("persists bindings from cells that need the async wrapper", async () => {
		const awaited = await executeJs(
			"const { value: awaitedCarry } = await Promise.resolve({ value: 6 }); awaitedCarry;",
			{
				sessionId,
				session,
				sessionFile,
			},
		);
		expect(awaited.exitCode).toBe(0);
		expect(awaited.output.trim()).toBe("6");

		const returned = await executeJs("const returnedCarry = 7; return returnedCarry;", {
			sessionId,
			session,
			sessionFile,
		});
		expect(returned.exitCode).toBe(0);
		expect(returned.output.trim()).toBe("7");

		const persisted = await executeJs("return awaitedCarry * returnedCarry;", { sessionId, session, sessionFile });
		expect(persisted.exitCode).toBe(0);
		expect(persisted.output.trim()).toBe("42");
	});

	it("persists bindings when auto-displaying the final expression", async () => {
		const first = await executeJs("const inspected = 40; inspected + 2;", { sessionId, session, sessionFile });
		expect(first.exitCode).toBe(0);
		expect(first.output.trim()).toBe("42");

		const persisted = await executeJs("return inspected + 1;", { sessionId, session, sessionFile });
		expect(persisted.exitCode).toBe(0);
		expect(persisted.output.trim()).toBe("41");
	});

	it("does not expose the final expression marker as a global property", async () => {
		const result = await executeJs("const localOnly = 7; localOnly;", { sessionId, session, sessionFile });
		expect(result.exitCode).toBe(0);
		expect(result.output.trim()).toBe("7");

		const marker = await executeJs("return Object.hasOwn(globalThis, '__omp_final_expr__');", {
			sessionId,
			session,
			sessionFile,
		});
		expect(marker.exitCode).toBe(0);
		expect(marker.output.trim()).toBe("false");

		const persisted = await executeJs("return localOnly;", { sessionId, session, sessionFile });
		expect(persisted.exitCode).toBe(0);
		expect(persisted.output.trim()).toBe("7");
	});

	it("ignores user-assigned final expression markers without a rewritten final expression", async () => {
		const result = await executeJs("globalThis.__omp_final_expr__ = 'manual'; return 'actual';", {
			sessionId,
			session,
			sessionFile,
		});

		expect(result.exitCode).toBe(0);
		expect(result.output.trim()).toBe("actual");
	});

	it("captures promise-valued final expression before promise callbacks can mutate the marker", async () => {
		const result = await executeJs(
			"const pending = Promise.resolve(1).then(value => { globalThis.__omp_final_expr__ = 999; return value; }); pending;",
			{ sessionId, session, sessionFile },
		);

		expect(result.exitCode).toBe(0);
		expect(result.output.trim()).toBe("1");
	});

	it("awaits rewritten thenable final expressions once", async () => {
		const result = await executeJs(
			[
				"globalThis.thenCalls = 0;",
				"const thenable = {",
				"  then(resolve) {",
				"    globalThis.thenCalls++;",
				"    resolve('done');",
				"  },",
				"};",
				"thenable;",
			].join("\n"),
			{ sessionId, session, sessionFile },
		);
		expect(result.exitCode).toBe(0);
		expect(result.output.trim()).toBe("done");

		const calls = await executeJs("return globalThis.thenCalls;", { sessionId, session, sessionFile });
		expect(calls.exitCode).toBe(0);
		expect(calls.output.trim()).toBe("1");
	});

	it("does not auto-display side-effect import rewrites", async () => {
		const result = await executeJs('import "node:path";', { sessionId, session, sessionFile });

		expect(result.exitCode).toBe(0);
		expect(result.output.trim()).toBe("");
		expect(result.displayOutputs).toEqual([]);
	});

	it("exposes the worker's real process object", async () => {
		const result = await executeJs(
			[
				"return {",
				"  version: process.version,",
				"  versionsNode: typeof process.versions.node,",
				"  platform: process.platform,",
				"  arch: process.arch,",
				"  hasEnv: 'env' in process,",
				"  hasExit: 'exit' in process,",
				"};",
			].join("\n"),
			{ sessionId, session, sessionFile },
		);

		expect(result.exitCode).toBe(0);
		expect(getJsonData(result)).toEqual({
			version: process.version,
			versionsNode: "string",
			platform: process.platform,
			arch: process.arch,
			hasEnv: true,
			hasExit: true,
		});
	});

	it("exposes common web globals and the raw Node fs module", async () => {
		const result = await executeJs(
			[
				"const uuid = crypto.randomUUID();",
				"const digest = await webcrypto.subtle.digest('SHA-256', new TextEncoder().encode('ok'));",
				"const base = __omp_session__.cwd;",
				"fs.mkdirSync(base + '/nested', { recursive: true });",
				"fs.writeFileSync(base + '/nested/value.txt', 'hello');",
				"await fs.promises.copyFile(base + '/nested/value.txt', base + '/nested/copy.txt');",
				"const text = fs.readFileSync(base + '/nested/copy.txt', 'utf8');",
				"const bytes = await fs.promises.readFile(base + '/nested/copy.txt');",
				"const stat = fs.statSync(base + '/nested/copy.txt');",
				"const entries = fs.readdirSync(base + '/nested');",
				"const start = performance.now();",
				"return {",
				"  uuid: typeof uuid,",
				"  digestBytes: digest.byteLength,",
				"  text,",
				"  byteLength: bytes.byteLength,",
				"  isFile: stat.isFile(),",
				"  entries: entries.sort(),",
				"  hasConstants: typeof fs.constants.R_OK,",
				"  buffer: Buffer.from('ok').toString('hex'),",
				"  performance: typeof start,",
				"};",
			].join("\n"),
			{ sessionId, session, sessionFile },
		);

		expect(result.exitCode).toBe(0);
		expect(getJsonData(result)).toEqual({
			uuid: "string",
			digestBytes: 32,
			text: "hello",
			byteLength: 5,
			isFile: true,
			entries: ["copy.txt", "value.txt"],
			hasConstants: "number",
			buffer: "6f6b",
			performance: "number",
		});
	});

	it("reads files as text and supports offset/limit slicing", async () => {
		const result = await executeJs(
			[
				"const full = await read('config.json');",
				"const objectSliced = await read('config.json', { offset: 2, limit: 1 });",
				"const positionalSliced = await read('config.json', 3, 1);",
				"const nullOffsetLimit = await read('config.json', null, 2);",
				"const undefinedOffsetLimit = await read('config.json', undefined, 1);",
				"return { isString: typeof full === 'string', full, objectSliced, positionalSliced, nullOffsetLimit, undefinedOffsetLimit };",
			].join("\n"),
			{
				sessionId,
				session,
				sessionFile,
			},
		);

		expect(result.exitCode).toBe(0);
		expect(getStatusEvents(result)).toHaveLength(5);
		expect(getJsonData(result)).toEqual({
			isString: true,
			full: '{\n  "name": "demo",\n  "enabled": true\n}',
			objectSliced: '  "name": "demo",',
			positionalSliced: '  "enabled": true',
			nullOffsetLimit: '{\n  "name": "demo",',
			undefinedOffsetLimit: "{",
		});
	});

	it("delegates URI reads through the read tool with positional slicing", async () => {
		const execute = vi.fn(async (_toolCallId: string, args: unknown): Promise<AgentToolResult> => {
			const record = args as { path: string };
			return { content: [{ type: "text", text: record.path.endsWith(":1-1400") ? "wide" : "limited" }] };
		});
		const toolSession: ToolSession = {
			...session,
			getToolByName: name => (name === "read" ? createTool("read", execute) : undefined),
		};

		const result = await executeJs(
			[
				"const wide = await read('artifact://15:raw', 1, 1400);",
				"const limited = await read('artifact://15:raw', null, 2);",
				"return { wide, limited };",
			].join("\n"),
			{
				sessionId,
				session: toolSession,
				sessionFile,
			},
		);

		expect(result.exitCode).toBe(0);
		expect(getStatusEvents(result)).toHaveLength(2);
		expect(getJsonData(result)).toEqual({ wide: "wide", limited: "limited" });
		expect(execute).toHaveBeenNthCalledWith(
			1,
			expect.stringMatching(/^js-read-/),
			{ path: "artifact://15:raw:1-1400", [INTENT_FIELD]: "js prelude" },
			expect.any(AbortSignal),
		);
		expect(execute).toHaveBeenNthCalledWith(
			2,
			expect.stringMatching(/^js-read-/),
			{ path: "artifact://15:raw:1-2", [INTENT_FIELD]: "js prelude" },
			expect.any(AbortSignal),
		);
	});

	it("rejects directory reads from native read()", async () => {
		const directoryResult = await executeJs("await read('.');", {
			sessionId,
			session,
			sessionFile,
		});
		expect(directoryResult.exitCode).toBe(1);
		expect(directoryResult.output).toContain("Directory paths are not supported");
	});

	it("routes output() through tool.read and keeps tool.* results normalized", async () => {
		const execute = vi.fn(async (_toolCallId: string, args: unknown): Promise<AgentToolResult> => {
			const record = args as { path: string };
			if (record.path.startsWith("agent://")) {
				return { content: [{ type: "text", text: "from-agent" }] };
			}
			return {
				content: [{ type: "text", text: "annotated" }],
				details: { path: record.path, kind: "tool-result" },
			};
		});
		const toolSession: ToolSession = {
			...session,
			getToolByName: name => (name === "read" ? createTool("read", execute) : undefined),
		};

		const result = await executeJs(
			"return { toolResult: await tool.read({ path: 'package.json' }), agentOutput: await output('agent-42') };",
			{
				sessionId,
				session: toolSession,
				sessionFile,
			},
		);

		expect(result.exitCode).toBe(0);
		expect(getStatusEvents(result)).toHaveLength(2);
		expect(getJsonData(result)).toEqual({
			toolResult: {
				text: "annotated",
				details: { path: "package.json", kind: "tool-result" },
				images: undefined,
			},
			agentOutput: "from-agent",
		});
		expect(execute).toHaveBeenCalledTimes(2);
		expect(execute.mock.calls[0]?.[1]).toEqual({ path: "package.json", [INTENT_FIELD]: "js prelude" });
		expect(execute.mock.calls[1]?.[1]).toEqual({ path: "agent://agent-42", [INTENT_FIELD]: "js prelude" });
	});

	it("auto-displays the final awaited expression result", async () => {
		const execute = vi.fn(
			async (): Promise<AgentToolResult> => ({
				content: [{ type: "text", text: "tool output" }],
				details: { kind: "tool-result" },
			}),
		);
		const toolSession: ToolSession = {
			...session,
			getToolByName: name => (name === "read" ? createTool("read", execute) : undefined),
		};

		const result = await executeJs("await tool.read({ path: 'package.json' });", {
			sessionId,
			session: toolSession,
			sessionFile,
		});

		expect(result.exitCode).toBe(0);
		expect(getJsonData(result)).toEqual({
			text: "tool output",
			details: { kind: "tool-result" },
			images: undefined,
		});
	});

	it("awaits promise-valued final expressions before displaying", async () => {
		const result = await executeJs("read('config.json');", {
			sessionId,
			session,
			sessionFile,
		});

		expect(result.exitCode).toBe(0);
		expect(result.output.trim()).toBe('{\n  "name": "demo",\n  "enabled": true\n}');
	});

	it("awaits identifier promise final expressions before displaying", async () => {
		const result = await executeJs("const pending = read('config.json'); pending;", {
			sessionId,
			session,
			sessionFile,
		});

		expect(result.exitCode).toBe(0);
		expect(result.output.trim()).toBe('{\n  "name": "demo",\n  "enabled": true\n}');
	});

	it("auto-displays returned objects as structured output", async () => {
		const result = await executeJs("return { answer: 42, nested: { ok: true } };", {
			sessionId,
			session,
			sessionFile,
		});

		expect(result.exitCode).toBe(0);
		expect(result.output).toBe("");
		expect(result.displayOutputs).toEqual([{ type: "json", data: { answer: 42, nested: { ok: true } } }]);
	});

	it('rewrites static `import { x } from "pkg"` to dynamic import', async () => {
		const result = await executeJs('import { join } from "node:path";\nreturn join("a", "b");', {
			sessionId,
			session,
			sessionFile,
		});
		expect(result.exitCode).toBe(0);
		expect(result.output.trim()).toBe(path.join("a", "b"));
	});

	it("strips TypeScript syntax before executing user code", async () => {
		const result = await executeJs(
			[
				"interface Pair { a: number; b: number }",
				"const make = (a: number, b: number): Pair => ({ a, b });",
				"const p = make(3, 4) as Pair;",
				"return p.a + p.b;",
			].join("\n"),
			{ sessionId, session, sessionFile },
		);
		expect(result.exitCode).toBe(0);
		expect(result.output.trim()).toBe("7");
	});
	it("falls back to text display when the final expression value is not structured-cloneable", async () => {
		const result = await executeJs("({ fn: () => 1 });", { sessionId, session, sessionFile });
		expect(result.exitCode).toBe(0);
		expect(result.output).toContain("[object Object]");
		// No JSON display because structuredClone fails on the embedded function.
		expect(result.displayOutputs.filter(o => o.type === "json")).toHaveLength(0);
	});

	it("cancels execution when the timeout expires", async () => {
		const result = await executeJs("await new Promise(() => {})", {
			sessionId,
			session,
			sessionFile,
			timeoutMs: 20,
		});

		expect(result.cancelled).toBe(true);
		expect(result.exitCode).toBeUndefined();
		expect(result.output).toContain("Command timed out");
	});
});