import { existsSync, readFileSync } from "node:fs";
import { basename, join } from "node:path";
import {
	buildConnectionUpdate,
	buildWorkspaceMetadata,
	type ClineCore,
	type CoreSessionConfig,
	type SessionPendingPrompt,
	SessionSource,
	splitCoreSessionConfig,
} from "@cline/core";
import type { Message } from "@cline/llms";
import { buildClineSystemPrompt } from "@cline/shared";
import { emitChunk, nowMs, sendEvent } from "./context";
import { readSessionManifest, sharedSessionDataDir } from "./paths";
import type {
	ChatSessionCommandRequest,
	JsonRecord,
	LiveSession,
	PromptInQueue,
	SidecarContext,
} from "./types";

type SessionConnectionUpdate = Parameters<
	ClineCore["updateSessionConnection"]
>[1];

// ---------------------------------------------------------------------------
// Session data helpers
// ---------------------------------------------------------------------------

function readPersistedChatMessages(sessionId: string): unknown[] | null {
	const path = join(
		sharedSessionDataDir(),
		sessionId,
		`${sessionId}.messages.json`,
	);
	if (!existsSync(path)) return null;
	try {
		const parsed = JSON.parse(readFileSync(path, "utf8").trim()) as
			| { messages?: unknown[] }
			| unknown[];
		if (Array.isArray(parsed)) return parsed;
		return Array.isArray(parsed.messages) ? parsed.messages : null;
	} catch {
		return null;
	}
}

function readSessionMetadataTitle(sessionId: string): string | undefined {
	const manifest = readSessionManifest(sessionId);
	const metadata =
		manifest?.metadata && typeof manifest.metadata === "object"
			? (manifest.metadata as JsonRecord)
			: undefined;
	const title = metadata?.title;
	return typeof title === "string" ? title.trim() || undefined : undefined;
}

function readSessionMetadata(sessionId: string): JsonRecord | undefined {
	const manifest = readSessionManifest(sessionId);
	return manifest?.metadata && typeof manifest.metadata === "object"
		? (manifest.metadata as JsonRecord)
		: undefined;
}

function derivePromptFromMessages(messages: unknown[]): string {
	for (const msg of messages) {
		if (!msg || typeof msg !== "object") continue;
		const m = msg as JsonRecord;
		if (m.role !== "user") continue;
		if (typeof m.content === "string") {
			const line = m.content.trim().split("\n")[0]?.trim();
			if (line) return line.slice(0, 200);
		}
	}
	return "";
}

// ---------------------------------------------------------------------------
// Live session factory
// ---------------------------------------------------------------------------

function createLiveSession(
	config: JsonRecord,
	overrides?: Partial<LiveSession>,
): LiveSession {
	return {
		config,
		messages: overrides?.messages ?? [],
		promptsInQueue: overrides?.promptsInQueue ?? [],
		busy: false,
		startedAt: nowMs(),
		status: overrides?.status ?? "idle",
		prompt: overrides?.prompt,
		title: overrides?.title,
		attachedViaHub: overrides?.attachedViaHub ?? false,
	};
}

function isoTimestampToMs(
	value: string | null | undefined,
): number | undefined {
	if (!value) {
		return undefined;
	}
	const parsed = Date.parse(value);
	return Number.isFinite(parsed) ? parsed : undefined;
}

function readReasoningEffort(
	value: unknown,
): "low" | "medium" | "high" | "xhigh" | undefined {
	if (
		value === "low" ||
		value === "medium" ||
		value === "high" ||
		value === "xhigh"
	) {
		return value;
	}
	return undefined;
}

function readPositiveInteger(value: unknown): number | undefined {
	if (typeof value === "number" && Number.isFinite(value) && value > 0) {
		return Math.trunc(value);
	}
	return undefined;
}

function buildCoreSessionConfig(config: JsonRecord): JsonRecord {
	const thinking =
		typeof config.thinking === "boolean" ? config.thinking : undefined;
	const reasoningEffort =
		thinking === false
			? undefined
			: readReasoningEffort(config.reasoningEffort);
	const thinkingBudgetTokens =
		thinking === false
			? undefined
			: readPositiveInteger(
					config.thinkingBudgetTokens ?? config.thinking_budget_tokens,
				);
	return {
		sessionId: config.sessionId ?? config.session_id,
		providerId: config.provider ?? config.providerId ?? "",
		modelId: config.model ?? config.modelId ?? "",
		mode: config.mode ?? "act",
		apiKey: config.apiKey ?? config.api_key ?? "",
		workspaceRoot: config.workspaceRoot ?? config.workspace_root ?? "",
		cwd: config.cwd ?? config.workspaceRoot ?? config.workspace_root ?? "",
		systemPrompt: config.systemPrompt ?? config.system_prompt ?? "",
		maxIterations: config.maxIterations ?? config.max_iterations,
		enableTools: config.enableTools ?? config.enable_tools ?? true,
		enableSpawnAgent:
			config.enableSpawn ??
			config.enableSpawnAgent ??
			config.enable_spawn ??
			false,
		enableAgentTeams:
			config.enableTeams ??
			config.enableAgentTeams ??
			config.enable_teams ??
			false,
		...(thinking !== undefined ? { thinking } : {}),
		...(reasoningEffort ? { reasoningEffort } : {}),
		...(thinkingBudgetTokens !== undefined ? { thinkingBudgetTokens } : {}),
		teamName: config.teamName ?? config.team_name,
		missionLogIntervalSteps:
			config.missionStepInterval ?? config.missionLogIntervalSteps,
		missionLogIntervalMs:
			config.missionTimeIntervalMs ?? config.missionLogIntervalMs,
		checkpoint: { enabled: true },
		sessions: config.sessions,
		initialMessages: config.initialMessages,
	};
}

export function buildSessionConnectionUpdate(
	config: JsonRecord,
): SessionConnectionUpdate {
	// Coerce the untrusted webview JSON (snake_case aliases, blank strings)
	// into typed fields; the thinking/reasoning transition rules live in the
	// shared @cline/core builder.
	const providerId = String(config.provider ?? config.providerId ?? "").trim();
	const modelId = String(config.model ?? config.modelId ?? "").trim();
	const rawApiKey =
		typeof config.apiKey === "string"
			? config.apiKey.trim()
			: typeof config.api_key === "string"
				? config.api_key.trim()
				: undefined;
	const baseUrl =
		typeof config.baseUrl === "string" ? config.baseUrl.trim() : undefined;
	const reasoningEffort = readReasoningEffort(config.reasoningEffort);
	const thinkingBudgetTokens = readPositiveInteger(
		config.thinkingBudgetTokens ?? config.thinking_budget_tokens,
	);
	return buildConnectionUpdate({
		...(providerId ? { providerId } : {}),
		...(modelId ? { modelId } : {}),
		...(rawApiKey ? { apiKey: rawApiKey } : {}),
		...(baseUrl ? { baseUrl } : {}),
		...(config.headers && typeof config.headers === "object"
			? { headers: config.headers as Record<string, string> }
			: {}),
		...(config.providerConfig && typeof config.providerConfig === "object"
			? {
					providerConfig:
						config.providerConfig as SessionConnectionUpdate["providerConfig"],
				}
			: {}),
		...(typeof config.thinking === "boolean"
			? { thinking: config.thinking }
			: {}),
		...(reasoningEffort ? { reasoningEffort } : {}),
		...(thinkingBudgetTokens !== undefined ? { thinkingBudgetTokens } : {}),
	});
}

async function resolveSystemPrompt(config: JsonRecord): Promise<string> {
	const cwd = String(
		config.cwd ?? config.workspaceRoot ?? config.workspace_root ?? "",
	).trim();
	if (!cwd) {
		return String(config.systemPrompt ?? config.system_prompt ?? "").trim();
	}
	const providerId = String(config.provider ?? config.providerId ?? "").trim();
	const mode = config.autoApproveTools
		? "yolo"
		: config.mode === "plan"
			? "plan"
			: "act";
	const metadata = await buildWorkspaceMetadata(cwd);
	const inlineRules =
		typeof config.rules === "string" && config.rules.trim().length > 0
			? config.rules
			: undefined;
	return buildClineSystemPrompt({
		ide: "Terminal Shell",
		workspaceRoot: cwd,
		workspaceName: basename(cwd),
		metadata,
		rules: inlineRules,
		mode,
		providerId: providerId || undefined,
		overridePrompt:
			typeof config.systemPrompt === "string" &&
			config.systemPrompt.trim().length > 0
				? config.systemPrompt
				: typeof config.system_prompt === "string" &&
						config.system_prompt.trim().length > 0
					? config.system_prompt
					: undefined,
		platform: process.platform || "unknown",
	});
}

function resolveToolPolicies(
	config: JsonRecord,
): { "*": { autoApprove: boolean } } | undefined {
	return {
		"*": {
			autoApprove: config.autoApproveTools !== false,
		},
	};
}

function sendPromptsInQueueSnapshot(
	ctx: SidecarContext,
	sessionId: string,
): void {
	const session = ctx.liveSessions.get(sessionId);
	sendEvent(ctx, "prompts_in_queue_state", {
		sessionId,
		items: session?.promptsInQueue ?? [],
	});
}

function mapPendingPrompt(item: SessionPendingPrompt): PromptInQueue {
	return {
		id: item.id,
		prompt: item.prompt,
		steer: item.delivery === "steer",
		attachmentCount: item.attachmentCount,
	};
}

function applyPendingPrompts(
	ctx: SidecarContext,
	sessionId: string,
	prompts: SessionPendingPrompt[],
): PromptInQueue[] {
	const mapped = prompts.map(mapPendingPrompt).filter((item) => item.id);
	const session = ctx.liveSessions.get(sessionId);
	if (session) {
		session.promptsInQueue = mapped;
	}
	sendPromptsInQueueSnapshot(ctx, sessionId);
	return mapped;
}

function getSessionManager(ctx: SidecarContext): ClineCore {
	if (!ctx.sessionManager) throw new Error("Session manager not initialized");
	return ctx.sessionManager;
}

// ---------------------------------------------------------------------------
// Chat session action handlers
// ---------------------------------------------------------------------------

async function handleStart(
	ctx: SidecarContext,
	request: ChatSessionCommandRequest,
): Promise<unknown> {
	if (!request.config) throw new Error("config is required");
	const manager = getSessionManager(ctx);
	const systemPrompt = await resolveSystemPrompt(request.config);
	const requestedSessionId = String(
		request.config.sessionId ?? request.config.session_id ?? "",
	).trim();
	const initialMessages =
		Array.isArray(request.config.initialMessages) &&
		request.config.initialMessages.length > 0
			? request.config.initialMessages
			: requestedSessionId
				? (readPersistedChatMessages(requestedSessionId) ?? undefined)
				: undefined;
	const coreConfig: JsonRecord = {
		...buildCoreSessionConfig(request.config),
		systemPrompt,
		...(initialMessages ? { initialMessages } : {}),
	};
	// Note: do NOT pass `prompt` to manager.start() here. When a prompt is
	// provided to start(), the local runtime host runs the full agent turn
	// synchronously inside start(). We always start the session idle and let
	// the frontend call the separate "send" action to dispatch the prompt.
	// This avoids a double-execution bug where start() would run the turn AND
	// the subsequent manager.send() fire-and-forget would run it again.
	console.error(
		`[sidecar:handleStart] calling manager.start provider=${coreConfig.providerId} model=${coreConfig.modelId}`,
	);
	const startResult = await manager.start({
		...splitCoreSessionConfig(coreConfig as unknown as CoreSessionConfig),
		source: SessionSource.DESKTOP,
		interactive: true,
		...(initialMessages
			? { initialMessages: initialMessages as Message[] }
			: {}),
		toolPolicies: resolveToolPolicies(request.config),
	});
	const sessionId = startResult.sessionId;
	console.error(`[sidecar:handleStart] session started sessionId=${sessionId}`);
	const session = createLiveSession(request.config, {
		messages: initialMessages,
		prompt: initialMessages
			? derivePromptFromMessages(initialMessages)
			: undefined,
		title: requestedSessionId
			? readSessionMetadataTitle(requestedSessionId)
			: undefined,
		status: "idle",
	});
	ctx.liveSessions.set(sessionId, session);
	return { sessionId };
}

async function handleAttach(
	ctx: SidecarContext,
	request: ChatSessionCommandRequest,
): Promise<unknown> {
	const sessionId = request.sessionId?.trim();
	if (!sessionId) {
		throw new Error("sessionId is required");
	}

	const manager = getSessionManager(ctx);
	const session = await manager.get(sessionId);
	if (!session) {
		throw new Error(`Session ${sessionId} not found`);
	}

	const metadata =
		session.metadata && typeof session.metadata === "object"
			? (session.metadata as JsonRecord)
			: undefined;
	const existing = ctx.liveSessions.get(sessionId);
	if (ctx.hubClient) {
		await ctx.hubClient.command("session.attach", { sessionId }, sessionId);
	}
	const attachedConfig: JsonRecord = {
		...(existing?.config ?? {}),
		...(request.config ?? {}),
		sessionId,
		provider: session.provider || existing?.config.provider || "",
		model: session.model || existing?.config.model || "",
		cwd:
			session.cwd ||
			session.workspaceRoot ||
			String(request.config?.cwd ?? "").trim() ||
			String(existing?.config.cwd ?? "").trim(),
		workspaceRoot:
			session.workspaceRoot ||
			session.cwd ||
			String(request.config?.workspaceRoot ?? "").trim() ||
			String(existing?.config.workspaceRoot ?? "").trim(),
	};
	ctx.liveSessions.set(
		sessionId,
		createLiveSession(attachedConfig, {
			messages: existing?.messages ?? [],
			promptsInQueue: existing?.promptsInQueue ?? [],
			status: session.status,
			prompt:
				session.prompt ||
				(typeof metadata?.prompt === "string" ? metadata.prompt : undefined) ||
				existing?.prompt,
			title:
				(typeof metadata?.title === "string" ? metadata.title : undefined) ||
				existing?.title,
			endedAt: isoTimestampToMs(session.endedAt),
			attachedViaHub: true,
		}),
	);

	return {
		sessionId,
		status: session.status,
		provider: session.provider,
		model: session.model,
		cwd: session.cwd,
		workspaceRoot: session.workspaceRoot,
		prompt: session.prompt,
		metadata,
	};
}

async function handleSend(
	ctx: SidecarContext,
	request: ChatSessionCommandRequest,
): Promise<unknown> {
	const sessionId = request.sessionId?.trim();
	if (!sessionId) throw new Error("sessionId is required");
	const prompt = request.prompt?.trim();
	if (!prompt) throw new Error("prompt is required");
	const manager = getSessionManager(ctx);
	const session = ctx.liveSessions.get(sessionId);
	if (request.config) {
		const connectionUpdate = buildSessionConnectionUpdate(request.config);
		await manager.updateSessionConnection(sessionId, connectionUpdate);
		if (session) {
			session.config = { ...session.config, ...request.config };
		}
	}

	// Determine effective delivery mode.
	// When the session is busy and no explicit delivery was requested, queue it
	// via Core so that Core's own pending-prompts mechanism handles draining.
	// This avoids a sidecar-only local queue that never calls manager.send().
	let delivery = request.delivery;
	if (!delivery && session?.busy) {
		delivery = "queue";
	}

	if (delivery === "queue") {
		if (session) {
			session.prompt = prompt;
		}
		// Delegate queuing to Core — it will drain the prompt once the current
		// turn finishes and emit pending_prompts / pending_prompt_submitted events.
		await manager.send({
			sessionId,
			prompt,
			delivery: "queue",
			userImages: request.attachments?.userImages,
		});
		const prompts = await manager.pendingPrompts.list({ sessionId });
		return {
			sessionId,
			ok: true,
			queued: true,
			promptsInQueue: applyPendingPrompts(ctx, sessionId, prompts),
		};
	}

	if (session) {
		session.prompt = prompt;
		session.busy = true;
		session.status = "running";
	}
	try {
		console.error(
			`[sidecar:handleSend] calling manager.send sessionId=${sessionId} prompt=${prompt.slice(0, 80)}`,
		);
		const result = await manager.send({
			sessionId,
			prompt,
			delivery,
			userImages: request.attachments?.userImages,
		});
		console.error(
			`[sidecar:handleSend] manager.send resolved sessionId=${sessionId} finishReason=${result?.finishReason} textLen=${result?.text?.length ?? 0}`,
		);
		if (session) {
			session.busy = false;
			session.status = "idle";
			if (result?.messages) session.messages = result.messages as unknown[];
		}
		return {
			sessionId,
			ok: true,
			result: result
				? {
						text: result.text,
						finishReason: result.finishReason,
						messages: result.messages,
						usage: result.usage,
						iterations: result.iterations,
						toolCalls: result.toolCalls,
					}
				: undefined,
		};
	} catch (error) {
		console.error(
			`[sidecar:handleSend] manager.send THREW sessionId=${sessionId} error=${error instanceof Error ? error.message : String(error)}`,
		);
		if (session) {
			session.busy = false;
			session.status = "error";
		}
		emitChunk(
			ctx,
			sessionId,
			"chat_core_log",
			JSON.stringify({
				level: "error",
				message: error instanceof Error ? error.message : String(error),
			}),
		);
		return {
			sessionId,
			ok: true,
			result: {
				finishReason: "error",
				text: error instanceof Error ? error.message : String(error),
			},
		};
	}
}

async function handleStop(
	ctx: SidecarContext,
	request: ChatSessionCommandRequest,
): Promise<unknown> {
	const sessionId = request.sessionId?.trim();
	if (!sessionId) throw new Error("sessionId is required");
	await getSessionManager(ctx).stop(sessionId);
	const session = ctx.liveSessions.get(sessionId);
	if (session) {
		session.busy = false;
		session.status = "stopped";
	}
	return { sessionId, ok: true };
}

async function handleAbort(
	ctx: SidecarContext,
	request: ChatSessionCommandRequest,
): Promise<unknown> {
	const sessionId = request.sessionId?.trim();
	if (!sessionId) throw new Error("sessionId is required");
	await getSessionManager(ctx).abort(sessionId, "user_abort");
	const session = ctx.liveSessions.get(sessionId);
	if (session) {
		session.busy = false;
		session.status = "aborted";
	}
	return { sessionId, ok: true };
}

async function handleFork(
	ctx: SidecarContext,
	request: ChatSessionCommandRequest,
): Promise<unknown> {
	const sourceSessionId = request.sessionId?.trim();
	if (!sourceSessionId) throw new Error("sessionId is required");
	const manager = getSessionManager(ctx);
	const sourceMessages =
		readPersistedChatMessages(sourceSessionId) ??
		ctx.liveSessions.get(sourceSessionId)?.messages;
	if (!sourceMessages?.length) {
		throw new Error(`No messages found for session ${sourceSessionId}`);
	}

	const sourceSession = await manager.get(sourceSessionId);
	const sourceMetadata =
		(sourceSession?.metadata && typeof sourceSession.metadata === "object"
			? (sourceSession.metadata as JsonRecord)
			: undefined) ?? readSessionMetadata(sourceSessionId);
	const liveConfig = ctx.liveSessions.get(sourceSessionId)?.config;
	const forkConfig: JsonRecord = {
		...(liveConfig ?? {}),
		...(request.config ?? {}),
		sessionId: undefined,
		provider:
			sourceSession?.provider ||
			liveConfig?.provider ||
			request.config?.provider ||
			request.config?.providerId ||
			"",
		model:
			sourceSession?.model ||
			liveConfig?.model ||
			request.config?.model ||
			request.config?.modelId ||
			"",
		cwd:
			sourceSession?.cwd ||
			sourceSession?.workspaceRoot ||
			liveConfig?.cwd ||
			request.config?.cwd ||
			request.config?.workspaceRoot ||
			request.config?.workspace_root ||
			"",
		workspaceRoot:
			sourceSession?.workspaceRoot ||
			sourceSession?.cwd ||
			liveConfig?.workspaceRoot ||
			request.config?.workspaceRoot ||
			request.config?.workspace_root ||
			request.config?.cwd ||
			"",
	};
	const checkpointMetadata =
		sourceMetadata?.checkpoint !== undefined
			? { checkpoints: sourceMetadata.checkpoint }
			: {};
	const forkMetadata: JsonRecord = {
		...(sourceMetadata ?? {}),
		fork: {
			forkedFromSessionId: sourceSessionId,
			forkedAt: new Date().toISOString(),
			source: sourceSession?.source ?? "desktop",
			...checkpointMetadata,
		},
	};
	const systemPrompt = await resolveSystemPrompt(forkConfig);
	const startResult = await manager.start({
		...splitCoreSessionConfig(
			buildCoreSessionConfig({
				...forkConfig,
				systemPrompt,
				initialMessages: sourceMessages,
			}) as unknown as CoreSessionConfig,
		),
		source: SessionSource.DESKTOP,
		interactive: true,
		initialMessages: sourceMessages as Message[],
		sessionMetadata: forkMetadata,
		toolPolicies: resolveToolPolicies(forkConfig),
	});
	const newSessionId = startResult.sessionId;
	ctx.liveSessions.delete(sourceSessionId);
	ctx.liveSessions.set(
		newSessionId,
		createLiveSession(forkConfig, {
			messages: sourceMessages,
			prompt: derivePromptFromMessages(sourceMessages),
			title: readSessionMetadataTitle(sourceSessionId),
			status: "idle",
		}),
	);
	sendPromptsInQueueSnapshot(ctx, sourceSessionId);
	sendPromptsInQueueSnapshot(ctx, newSessionId);
	let messages: unknown[] = sourceMessages;
	try {
		const read = await manager.readMessages(newSessionId);
		if (read?.length > 0) messages = read;
	} catch {}
	return {
		sessionId: newSessionId,
		forkedFromSessionId: sourceSessionId,
		messages,
	};
}

async function handleReset(
	ctx: SidecarContext,
	request: ChatSessionCommandRequest,
): Promise<unknown> {
	const sessionId = request.sessionId?.trim();
	if (sessionId) {
		const session = ctx.liveSessions.get(sessionId);
		if (
			session?.busy ||
			session?.status === "starting" ||
			session?.status === "running" ||
			session?.status === "stopping"
		) {
			await getSessionManager(ctx).stop(sessionId);
		}
		ctx.liveSessions.delete(sessionId);
		sendPromptsInQueueSnapshot(ctx, sessionId);
	}
	return { sessionId: request.sessionId, ok: true };
}

async function handleRestoreCheckpoint(
	ctx: SidecarContext,
	request: ChatSessionCommandRequest,
): Promise<unknown> {
	const sourceSessionId = request.sessionId?.trim();
	if (!sourceSessionId) throw new Error("sessionId is required");
	const runCount = request.checkpointRunCount;
	if (
		typeof runCount !== "number" ||
		!Number.isInteger(runCount) ||
		runCount < 1
	)
		throw new Error("checkpointRunCount must be a positive integer");
	if (!request.config)
		throw new Error("config is required to restore a checkpoint");
	const cwd =
		(typeof request.config.cwd === "string" && request.config.cwd.trim()) ||
		(typeof request.config.workspaceRoot === "string" &&
			request.config.workspaceRoot.trim()) ||
		"";
	if (!cwd) throw new Error("config.cwd or config.workspaceRoot is required");
	const manager = getSessionManager(ctx);
	const restored = await manager.restore({
		sessionId: sourceSessionId,
		checkpointRunCount: runCount,
		cwd,
		restore: { messages: true, workspace: true },
		start: {
			...splitCoreSessionConfig(
				buildCoreSessionConfig({
					...request.config,
					systemPrompt: await resolveSystemPrompt(request.config),
				}) as unknown as CoreSessionConfig,
			),
			source: SessionSource.DESKTOP,
			interactive: true,
			toolPolicies: resolveToolPolicies(request.config),
		},
	});
	const sessionId = restored.sessionId;
	const restoredMessages = restored.messages;
	if (!sessionId || !restoredMessages) {
		throw new Error("Checkpoint restore did not return a new session");
	}
	ctx.liveSessions.delete(sourceSessionId);
	ctx.liveSessions.set(
		sessionId,
		createLiveSession(request.config, {
			messages: restoredMessages,
			prompt: derivePromptFromMessages(restoredMessages),
			title: readSessionMetadataTitle(sourceSessionId),
			status: "idle",
		}),
	);
	sendPromptsInQueueSnapshot(ctx, sourceSessionId);
	sendPromptsInQueueSnapshot(ctx, sessionId);
	let messages: unknown[] = restoredMessages;
	try {
		const read = await manager.readMessages(sessionId);
		if (read?.length > 0) messages = read;
	} catch {}
	return {
		sessionId,
		messages,
		restoredCheckpoint: restored.checkpoint,
	};
}

async function handlePendingPrompts(
	ctx: SidecarContext,
	request: ChatSessionCommandRequest,
): Promise<unknown> {
	const sessionId = request.sessionId?.trim();
	if (!sessionId) throw new Error("sessionId is required");
	const prompts = await getSessionManager(ctx).pendingPrompts.list({
		sessionId,
	});
	return {
		sessionId,
		promptsInQueue: applyPendingPrompts(ctx, sessionId, prompts),
	};
}

async function handleSteerPrompt(
	ctx: SidecarContext,
	request: ChatSessionCommandRequest,
): Promise<unknown> {
	const sessionId = request.sessionId?.trim();
	const promptId = request.promptId?.trim();
	if (!sessionId || !promptId)
		throw new Error("sessionId and promptId are required");
	const manager = getSessionManager(ctx);
	const result = await manager.pendingPrompts.update({
		sessionId,
		promptId,
		delivery: "steer",
	});
	return {
		sessionId,
		updated: result.updated === true,
		promptsInQueue: applyPendingPrompts(ctx, sessionId, result.prompts),
	};
}

async function handleUpdatePendingPrompt(
	ctx: SidecarContext,
	request: ChatSessionCommandRequest,
): Promise<unknown> {
	const sessionId = request.sessionId?.trim();
	const promptId = request.promptId?.trim();
	const prompt = request.prompt?.trim();
	if (!sessionId || !promptId) {
		throw new Error("sessionId and promptId are required");
	}
	if (!prompt) {
		throw new Error("prompt is required");
	}
	const manager = getSessionManager(ctx);
	const result = await manager.pendingPrompts.update({
		sessionId,
		promptId,
		prompt,
	});
	return {
		sessionId,
		updated: result.updated === true,
		prompt: result.prompt ? mapPendingPrompt(result.prompt) : undefined,
		promptsInQueue: applyPendingPrompts(ctx, sessionId, result.prompts),
	};
}

async function handleRemovePendingPrompt(
	ctx: SidecarContext,
	request: ChatSessionCommandRequest,
): Promise<unknown> {
	const sessionId = request.sessionId?.trim();
	const promptId = request.promptId?.trim();
	if (!sessionId || !promptId) {
		throw new Error("sessionId and promptId are required");
	}
	const manager = getSessionManager(ctx);
	const result = await manager.pendingPrompts.delete({
		sessionId,
		promptId,
	});
	return {
		sessionId,
		removed: result.removed === true,
		prompt: result.prompt ? mapPendingPrompt(result.prompt) : undefined,
		promptsInQueue: applyPendingPrompts(ctx, sessionId, result.prompts),
	};
}

// ---------------------------------------------------------------------------
// Action dispatch
// ---------------------------------------------------------------------------

const ACTION_HANDLERS: Record<
	string,
	(ctx: SidecarContext, req: ChatSessionCommandRequest) => Promise<unknown>
> = {
	start: handleStart,
	attach: handleAttach,
	send: handleSend,
	stop: handleStop,
	abort: handleAbort,
	fork: handleFork,
	reset: handleReset,
	restore_checkpoint: handleRestoreCheckpoint,
	pending_prompts: handlePendingPrompts,
	steer_prompt: handleSteerPrompt,
	update_pending_prompt: handleUpdatePendingPrompt,
	remove_pending_prompt: handleRemovePendingPrompt,
};

export async function handleChatSessionCommand(
	ctx: SidecarContext,
	request: ChatSessionCommandRequest,
): Promise<unknown> {
	const handler = ACTION_HANDLERS[request.action];
	if (!handler) throw new Error("unsupported action");
	return handler(ctx, request);
}