import { describe, expect, it } from "vitest";
import * as protocol from "../src/generated-protocol.js";
import {
	classifySidecarWrittenProtocolFrame,
	decodeBareProtocolFrame,
	decodeProtocolFramePayload,
	encodeBareProtocolFrame,
	encodeProtocolFramePayload,
	fromGeneratedSidecarWrittenProtocolFrame,
	HostProtocolFrameFactory,
	resolveSidecarRequestFramePayload,
	toGeneratedProtocolFrame,
} from "../src/protocol-frames.js";
import { SIDECAR_PROTOCOL_SCHEMA } from "../src/protocol-schema.js";

const textDecoder = new TextDecoder();

const ownership = {
	scope: "connection" as const,
	connection_id: "conn",
};

const generatedAuthOwnership = {
	scope: "connection" as const,
	connection_id: "conn-1",
};

const GENERATED_AUTH_FRAME_HEX =
	"00166167656e746f732d6e61746976652d73696465636172080007000000000000000006636f6e6e2d31000e67656e6572617465642d7465737405746f6b656e080001000000";

const hostCallbackRequest = {
	frame_type: "sidecar_request" as const,
	schema: SIDECAR_PROTOCOL_SCHEMA,
	request_id: 7,
	ownership,
	payload: {
		type: "host_callback" as const,
		invocation_id: "invocation",
		callback_key: "tool",
		input: {},
		timeout_ms: 1000,
	},
};

describe("protocol frame conversion", () => {
	it("creates host-written request, response, and control frames", () => {
		const factory = new HostProtocolFrameFactory();

		const first = factory.createRequestFrame({
			ownership,
			payload: {
				type: "authenticate",
				client_name: "agentos",
				auth_token: "token",
				protocol_version: 8,
				bridge_version: 1,
			},
		});
		const second = factory.createRequestFrame({
			ownership,
			payload: {
				type: "create_layer",
			},
		});

		expect(first).toMatchObject({
			frame_type: "request",
			schema: SIDECAR_PROTOCOL_SCHEMA,
			request_id: 1,
			ownership,
		});
		expect(second.request_id).toBe(2);
		expect(
			factory.createSidecarResponseFrame({
				request: hostCallbackRequest,
				payload: {
					type: "host_callback_result",
					invocation_id: "invocation",
					result: { ok: true },
				},
			}),
		).toEqual({
			frame_type: "sidecar_response",
			schema: SIDECAR_PROTOCOL_SCHEMA,
			request_id: 7,
			ownership,
			payload: {
				type: "host_callback_result",
				invocation_id: "invocation",
				result: { ok: true },
			},
		});
		expect(
			factory.createControlFrame({ type: "shutdown", reason: "test complete" }),
		).toEqual({
			frame_type: "control",
			schema: SIDECAR_PROTOCOL_SCHEMA,
			payload: { type: "shutdown", reason: "test complete" },
		});
	});

	it("resolves sidecar request frame handlers", async () => {
		await expect(
			resolveSidecarRequestFramePayload(hostCallbackRequest, async () => ({
				type: "host_callback_result",
				invocation_id: "invocation",
				result: { ok: true },
			})),
		).resolves.toEqual({
			type: "host_callback_result",
			invocation_id: "invocation",
			result: { ok: true },
		});
	});

	it("returns error payloads for missing or mismatched sidecar handlers", async () => {
		await expect(
			resolveSidecarRequestFramePayload(hostCallbackRequest, null),
		).resolves.toMatchObject({
			type: "host_callback_result",
			invocation_id: "invocation",
			error: "no sidecar request handler registered for host_callback",
		});

		await expect(
			resolveSidecarRequestFramePayload(hostCallbackRequest, async () => ({
				type: "js_bridge_result",
				call_id: "call",
				result: {},
			})),
		).resolves.toMatchObject({
			type: "host_callback_result",
			invocation_id: "invocation",
			error: "sidecar handler returned js_bridge_result for host_callback",
		});
	});

	it("maps host-written request frames to generated protocol frames", () => {
		expect(
			toGeneratedProtocolFrame({
				frame_type: "request",
				schema: SIDECAR_PROTOCOL_SCHEMA,
				request_id: 7,
				ownership,
				payload: {
					type: "authenticate",
					client_name: "agentos",
					auth_token: "token",
					protocol_version: 8,
					bridge_version: 1,
				},
			}),
		).toMatchObject({
			tag: "RequestFrame",
			val: {
				requestId: 7n,
				payload: {
					tag: "AuthenticateRequest",
				},
			},
		});
	});

	it("encodes host-written frames as BARE protocol bytes", () => {
		const encoded = encodeBareProtocolFrame({
			frame_type: "sidecar_response",
			schema: SIDECAR_PROTOCOL_SCHEMA,
			request_id: 8,
			ownership,
			payload: {
				type: "host_callback_result",
				invocation_id: "invocation",
				result: { ok: true },
			},
		});

		expect(protocol.decodeProtocolFrame(new Uint8Array(encoded)).tag).toBe(
			"SidecarResponseFrame",
		);

		const control = encodeBareProtocolFrame({
			frame_type: "control",
			schema: SIDECAR_PROTOCOL_SCHEMA,
			payload: { type: "shutdown", reason: "test complete" },
		});
		expect(protocol.decodeProtocolFrame(new Uint8Array(control))).toMatchObject(
			{
				tag: "ControlFrame",
				val: {
					payload: {
						tag: "ShutdownControl",
						val: { reason: "test complete" },
					},
				},
			},
		);
	});

	it("matches native generated auth frame BARE bytes", () => {
		const encoded = encodeBareProtocolFrame({
			frame_type: "request",
			schema: SIDECAR_PROTOCOL_SCHEMA,
			request_id: 7,
			ownership: generatedAuthOwnership,
			payload: {
				type: "authenticate",
				client_name: "generated-test",
				auth_token: "token",
				protocol_version: SIDECAR_PROTOCOL_SCHEMA.version,
				bridge_version: 1,
			},
		});

		expect(Buffer.from(encoded).toString("hex")).toBe(GENERATED_AUTH_FRAME_HEX);
		expect(protocol.decodeProtocolFrame(new Uint8Array(encoded))).toMatchObject(
			{
				tag: "RequestFrame",
				val: {
					requestId: 7n,
					payload: { tag: "AuthenticateRequest" },
				},
			},
		);
	});

	it("decodes sidecar-written response frames from generated protocol frames", () => {
		expect(
			fromGeneratedSidecarWrittenProtocolFrame({
				tag: "ResponseFrame",
				val: {
					schema: SIDECAR_PROTOCOL_SCHEMA,
					requestId: 9n,
					ownership: {
						tag: "ConnectionOwnership",
						val: { connectionId: "conn" },
					},
					payload: {
						tag: "VmCreatedResponse",
						val: { vmId: "vm" },
					},
				},
			}),
		).toEqual({
			frame_type: "response",
			schema: SIDECAR_PROTOCOL_SCHEMA,
			request_id: 9,
			ownership,
			payload: { type: "vm_created", vm_id: "vm" },
		});
	});

	it("decodes sidecar-written event frames from BARE bytes", () => {
		const bytes = protocol.encodeProtocolFrame({
			tag: "EventFrame",
			val: {
				schema: SIDECAR_PROTOCOL_SCHEMA,
				ownership: {
					tag: "ConnectionOwnership",
					val: { connectionId: "conn" },
				},
				payload: {
					tag: "StructuredEvent",
					val: {
						name: "ready",
						detail: new Map([["ok", "true"]]),
					},
				},
			},
		});

		expect(decodeBareProtocolFrame(bytes)).toEqual({
			frame_type: "event",
			schema: SIDECAR_PROTOCOL_SCHEMA,
			ownership,
			payload: {
				type: "structured",
				name: "ready",
				detail: { ok: "true" },
			},
		});
	});

	it("encodes and decodes JSON compatibility protocol frames", () => {
		const encoded = encodeProtocolFramePayload(
			{
				frame_type: "event",
				schema: SIDECAR_PROTOCOL_SCHEMA,
				ownership,
				payload: {
					type: "process_output",
					process_id: "proc",
					channel: "stdout",
					chunk: new Uint8Array([1, 2, 3]),
				},
			},
			"json",
		);

		expect(JSON.parse(textDecoder.decode(encoded)).payload.chunk).toEqual([
			1, 2, 3,
		]);

		const decoded = decodeProtocolFramePayload(encoded, "json");
		if (
			decoded.frame_type !== "event" ||
			decoded.payload.type !== "process_output"
		) {
			throw new Error("expected process_output event");
		}
		expect(decoded.payload.chunk).toBeInstanceOf(Uint8Array);
		expect(Array.from(decoded.payload.chunk)).toEqual([1, 2, 3]);
	});

	it("classifies sidecar-written protocol frames for RPC dispatch", () => {
		expect(
			classifySidecarWrittenProtocolFrame({
				frame_type: "response",
				schema: SIDECAR_PROTOCOL_SCHEMA,
				request_id: 10,
				ownership,
				payload: { type: "vm_created", vm_id: "vm" },
			}),
		).toMatchObject({
			kind: "response",
			requestId: 10,
			frame: { frame_type: "response" },
		});

		expect(
			classifySidecarWrittenProtocolFrame({
				frame_type: "event",
				schema: SIDECAR_PROTOCOL_SCHEMA,
				ownership,
				payload: {
					type: "structured",
					name: "ready",
					detail: {},
				},
			}),
		).toMatchObject({
			kind: "event",
			frame: { frame_type: "event" },
		});

		expect(
			classifySidecarWrittenProtocolFrame({
				frame_type: "sidecar_request",
				schema: SIDECAR_PROTOCOL_SCHEMA,
				request_id: 11,
				ownership,
				payload: {
					type: "host_callback",
					invocation_id: "invocation",
					callback_key: "tool",
					input: { ok: true },
					timeout_ms: 1_000,
				},
			}),
		).toMatchObject({
			kind: "sidecarRequest",
			frame: { frame_type: "sidecar_request" },
		});
	});

	it("rejects host-written generated frames on the sidecar-written decode path", () => {
		expect(() =>
			fromGeneratedSidecarWrittenProtocolFrame({
				tag: "RequestFrame",
				val: {
					schema: SIDECAR_PROTOCOL_SCHEMA,
					requestId: 1n,
					ownership: {
						tag: "ConnectionOwnership",
						val: { connectionId: "conn" },
					},
					payload: {
						tag: "CreateLayerRequest",
						val: null,
					},
				},
			}),
		).toThrow("unsupported BARE protocol frame tag: RequestFrame");
	});
});