/**
 * ToolCallCard shows one tool call the agent is running, in the spirit of
 * Zed's agent panel: a collapsible card with the tool kind, a live status,
 * touched locations, and the call's output (text, or a file diff).
 *
 * @example
 * <ToolCallCard call={{ toolCallId: "c1", title: "Reading main.go",
 *   toolKind: "read", status: "in_progress", contents: [], locations: [] }} />
 */

import type { ToolCall } from "../reducer";
import { InlineText } from "./InlineText";
import type { AcpToolCallContent } from "../protocol";
import { Markdown } from "./Markdown";
import { CopyButton } from "./CopyButton";

const kindIcons: Record<string, string> = {
	read: "📖",
	edit: "✏️",
	delete: "🗑️",
	move: "📦",
	search: "🔍",
	execute: "⚡",
	think: "💭",
	fetch: "🌐",
	switch_mode: "🔀",
	other: "🔧",
};

const statusLabels: Record<string, string> = {
	pending: "pending",
	in_progress: "running",
	completed: "done",
	failed: "failed",
};

/**
 * contentText flattens one tool-call content block into plain text for the
 * copy button: a "content" block's text, or a diff's path / old / new
 * sections. Anything else (terminal handles, …) yields "".
 *
 * @example
 * contentText({ type: "content", content: { type: "text", text: "hi" } }) // "hi"
 */
export function contentText(content: AcpToolCallContent): string {
	switch (content.type) {
		case "content":
			return content.content?.text ?? "";
		case "diff":
			return diffText(content);
		default:
			return "";
	}
}

function diffText(diff: {
	path?: string;
	oldText?: string | null;
	newText?: string | null;
}): string {
	const parts: string[] = [];
	if (diff.path) parts.push(`Path: ${diff.path}`);
	if (diff.oldText) parts.push(`Old:\n${diff.oldText}`);
	if (diff.newText) parts.push(`New:\n${diff.newText}`);
	return parts.join("\n\n");
}

/**
 * toolContentText joins the textual content of a whole tool call, skipping
 * empty blocks, so the copy button copies exactly what the card shows.
 *
 * @example
 * toolContentText([]) // ""
 */
export function toolContentText(contents: AcpToolCallContent[]): string {
	return contents.map(contentText).filter(Boolean).join("\n\n");
}

export function ToolCallCard({ call }: { call: ToolCall }) {
	const copyText = toolContentText(call.contents);

	return (
		<details className={`tool tool-${call.status}`}>
			<summary className="tool-summary">
				<span className="tool-icon" aria-hidden>
					{kindIcons[call.toolKind] ?? kindIcons.other}
				</span>
				<span className="tool-title">
					<InlineText text={call.title} />
				</span>
				<span className={`tool-status tool-status-${call.status}`}>
					{statusLabels[call.status] ?? call.status}
				</span>
				{copyText && <CopyButton content={copyText} label="Copy tool output" />}
			</summary>
			<div className="tool-body">
				{call.locations.length > 0 && (
					<ul className="tool-locations">
						{call.locations.map((location, index) => (
							// biome-ignore lint/suspicious/noArrayIndexKey: tool-call locations carry no id and the list is replaced wholesale on every update.
							<li key={index}>
								<code>
									{location.path}
									{location.line != null ? `:${location.line}` : ""}
								</code>
							</li>
						))}
					</ul>
				)}
				{call.contents.map((content, index) => (
					// biome-ignore lint/suspicious/noArrayIndexKey: tool-call contents carry no id and the list is replaced wholesale on every update.
					<ToolContent key={index} content={content} toolKind={call.toolKind} />
				))}
			</div>
		</details>
	);
}

function ToolContent({
	content,
	toolKind,
}: { content: AcpToolCallContent; toolKind: string }) {
	switch (content.type) {
		case "content":
			return (
				<TextToolContent text={content.content?.text} toolKind={toolKind} />
			);
		case "diff":
			return (
				<div className="tool-diff">
					<code className="tool-diff-path">{content.path}</code>
					{content.oldText != null && (
						<pre className="tool-diff-old">
							{prefixLines(content.oldText, "- ")}
						</pre>
					)}
					<pre className="tool-diff-new">
						{prefixLines(content.newText ?? "", "+ ")}
					</pre>
				</div>
			);
		case "terminal":
			return <p className="tool-terminal">terminal: {content.terminalId}</p>;
		default:
			return null;
	}
}

/**
 * TextToolContent renders a tool call's textual output. System-command
 * output (kind "execute") is verbatim text: it goes into a monospace block,
 * never through the markdown pipeline.
 */
function TextToolContent({
	text,
	toolKind,
}: { text: string | undefined; toolKind: string }) {
	if (!text) {
		return null;
	}
	if (toolKind === "execute") {
		return <pre className="tool-output">{text}</pre>;
	}
	return <Markdown text={text} />;
}

function prefixLines(text: string, prefix: string): string {
	return text
		.split("\n")
		.map((line) => prefix + line)
		.join("\n");
}