import * as React from "react";
import Markdown from "react-markdown";
import { Prism as SyntaxHighlighter } from "react-syntax-highlighter";
import { oneDark } from "react-syntax-highlighter/dist/esm/styles/prism";
import type { PipelineState } from "../api/client";
import { api, ChatWebSocket } from "../api/client";
import type { Message, ProviderConfig, ToolCall } from "../types";
import { AgentPanel } from "./AgentPanel";
import { ChatHeader } from "./ChatHeader";
import { LozengeFlyProvider } from "./LozengeFlyContext";
import { StagePanel } from "./StagePanel";

const { useCallback, useEffect, useRef, useState } = React;

const NARROW_BREAKPOINT = 900;

interface ChatProps {
	projectPath: string;
	onCloseProject: () => void;
}

export function Chat({ projectPath, onCloseProject }: ChatProps) {
	const [messages, setMessages] = useState<Message[]>([]);
	const [input, setInput] = useState("");
	const [loading, setLoading] = useState(false);
	const [model, setModel] = useState("llama3.1");
	const [enableTools, setEnableTools] = useState(true);
	const [availableModels, setAvailableModels] = useState<string[]>([]);
	const [claudeModels, setClaudeModels] = useState<string[]>([]);
	const [streamingContent, setStreamingContent] = useState("");
	const [showApiKeyDialog, setShowApiKeyDialog] = useState(false);
	const [apiKeyInput, setApiKeyInput] = useState("");
	const [hasAnthropicKey, setHasAnthropicKey] = useState(false);
	const [pipeline, setPipeline] = useState<PipelineState>({
		upcoming: [],
		current: [],
		qa: [],
		merge: [],
	});
	const [claudeSessionId, setClaudeSessionId] = useState<string | null>(null);
	const [isNarrowScreen, setIsNarrowScreen] = useState(
		window.innerWidth < NARROW_BREAKPOINT,
	);

	const wsRef = useRef<ChatWebSocket | null>(null);
	const messagesEndRef = useRef<HTMLDivElement>(null);
	const inputRef = useRef<HTMLTextAreaElement>(null);
	const scrollContainerRef = useRef<HTMLDivElement>(null);
	const shouldAutoScrollRef = useRef(true);
	const lastScrollTopRef = useRef(0);
	const userScrolledUpRef = useRef(false);
	const pendingMessageRef = useRef<string>("");

	const estimateTokens = (text: string): number => Math.ceil(text.length / 4);

	const getContextWindowSize = (modelName: string): number => {
		if (modelName.startsWith("claude-")) return 200000;
		if (modelName.includes("llama3")) return 8192;
		if (modelName.includes("qwen2.5")) return 32768;
		if (modelName.includes("deepseek")) return 16384;
		return 8192;
	};

	const calculateContextUsage = (): {
		used: number;
		total: number;
		percentage: number;
	} => {
		let totalTokens = 0;

		totalTokens += 200;

		for (const msg of messages) {
			totalTokens += estimateTokens(msg.content);
			if (msg.tool_calls) {
				totalTokens += estimateTokens(JSON.stringify(msg.tool_calls));
			}
		}

		if (streamingContent) {
			totalTokens += estimateTokens(streamingContent);
		}

		const contextWindow = getContextWindowSize(model);
		const percentage = Math.round((totalTokens / contextWindow) * 100);

		return {
			used: totalTokens,
			total: contextWindow,
			percentage,
		};
	};

	const contextUsage = calculateContextUsage();

	useEffect(() => {
		api
			.getOllamaModels()
			.then(async (models) => {
				if (models.length > 0) {
					const sortedModels = models.sort((a, b) =>
						a.toLowerCase().localeCompare(b.toLowerCase()),
					);
					setAvailableModels(sortedModels);

					try {
						const savedModel = await api.getModelPreference();
						if (savedModel) {
							setModel(savedModel);
						} else if (sortedModels.length > 0) {
							setModel(sortedModels[0]);
						}
					} catch (e) {
						console.error(e);
					}
				}
			})
			.catch((err) => console.error(err));

		api
			.getAnthropicApiKeyExists()
			.then((exists) => {
				setHasAnthropicKey(exists);
				if (!exists) return;
				return api.getAnthropicModels().then((models) => {
					if (models.length > 0) {
						const sortedModels = models.sort((a, b) =>
							a.toLowerCase().localeCompare(b.toLowerCase()),
						);
						setClaudeModels(sortedModels);
					} else {
						setClaudeModels([]);
					}
				});
			})
			.catch((err) => {
				console.error(err);
				setHasAnthropicKey(false);
				setClaudeModels([]);
			});
	}, []);

	useEffect(() => {
		const ws = new ChatWebSocket();
		wsRef.current = ws;

		ws.connect({
			onToken: (content) => {
				setStreamingContent((prev: string) => prev + content);
			},
			onUpdate: (history) => {
				setMessages(history);
				setStreamingContent("");
				const last = history[history.length - 1];
				if (last?.role === "assistant" && !last.tool_calls) {
					setLoading(false);
				}
			},
			onSessionId: (sessionId) => {
				setClaudeSessionId(sessionId);
			},
			onError: (message) => {
				console.error("WebSocket error:", message);
				setLoading(false);
			},
			onPipelineState: (state) => {
				setPipeline(state);
			},
		});

		return () => {
			ws.close();
			wsRef.current = null;
		};
	}, []);

	const scrollToBottom = useCallback(() => {
		const element = scrollContainerRef.current;
		if (element) {
			element.scrollTop = element.scrollHeight;
			lastScrollTopRef.current = element.scrollHeight;
		}
	}, []);

	const handleScroll = () => {
		const element = scrollContainerRef.current;
		if (!element) return;

		const currentScrollTop = element.scrollTop;
		const isAtBottom =
			element.scrollHeight - element.scrollTop - element.clientHeight < 5;

		if (currentScrollTop < lastScrollTopRef.current) {
			userScrolledUpRef.current = true;
			shouldAutoScrollRef.current = false;
		}

		if (isAtBottom) {
			userScrolledUpRef.current = false;
			shouldAutoScrollRef.current = true;
		}

		lastScrollTopRef.current = currentScrollTop;
	};

	const autoScrollKey = messages.length + streamingContent.length;

	useEffect(() => {
		if (
			autoScrollKey >= 0 &&
			shouldAutoScrollRef.current &&
			!userScrolledUpRef.current
		) {
			scrollToBottom();
		}
	}, [autoScrollKey, scrollToBottom]);

	useEffect(() => {
		inputRef.current?.focus();
	}, []);

	useEffect(() => {
		const handleResize = () =>
			setIsNarrowScreen(window.innerWidth < NARROW_BREAKPOINT);
		window.addEventListener("resize", handleResize);
		return () => window.removeEventListener("resize", handleResize);
	}, []);

	const cancelGeneration = async () => {
		try {
			wsRef.current?.cancel();
			await api.cancelChat();

			if (streamingContent) {
				setMessages((prev: Message[]) => [
					...prev,
					{ role: "assistant", content: streamingContent },
				]);
				setStreamingContent("");
			}

			setLoading(false);
		} catch (e) {
			console.error("Failed to cancel chat:", e);
		}
	};

	const sendMessage = async (messageOverride?: string) => {
		const messageToSend = messageOverride ?? input;
		if (!messageToSend.trim() || loading) return;

		const isClaudeCode = model === "claude-code-pty";
		if (!isClaudeCode && model.startsWith("claude-")) {
			const hasKey = await api.getAnthropicApiKeyExists();
			if (!hasKey) {
				pendingMessageRef.current = messageToSend;
				setShowApiKeyDialog(true);
				return;
			}
		}

		const userMsg: Message = { role: "user", content: messageToSend };
		const newHistory = [...messages, userMsg];

		setMessages(newHistory);
		if (!messageOverride || messageOverride === input) {
			setInput("");
		}
		setLoading(true);
		setStreamingContent("");

		try {
			const provider = isClaudeCode
				? "claude-code"
				: model.startsWith("claude-")
					? "anthropic"
					: "ollama";
			const config: ProviderConfig = {
				provider,
				model,
				base_url: "http://localhost:11434",
				enable_tools: enableTools,
				...(isClaudeCode && claudeSessionId
					? { session_id: claudeSessionId }
					: {}),
			};

			wsRef.current?.sendChat(newHistory, config);
		} catch (e) {
			console.error("Chat error:", e);
			const errorMessage = String(e);
			if (!errorMessage.includes("Chat cancelled by user")) {
				setMessages((prev: Message[]) => [
					...prev,
					{ role: "assistant", content: `**Error:** ${e}` },
				]);
			}
			setLoading(false);
		}
	};

	const handleSaveApiKey = async () => {
		if (!apiKeyInput.trim()) return;

		try {
			await api.setAnthropicApiKey(apiKeyInput);
			setShowApiKeyDialog(false);
			setApiKeyInput("");

			const pendingMessage = pendingMessageRef.current;
			pendingMessageRef.current = "";

			if (pendingMessage.trim()) {
				sendMessage(pendingMessage);
			}
		} catch (e) {
			console.error("Failed to save API key:", e);
			alert(`Failed to save API key: ${e}`);
		}
	};

	const clearSession = async () => {
		const confirmed = window.confirm(
			"Are you sure? This will clear all messages and reset the conversation context.",
		);

		if (confirmed) {
			try {
				await api.cancelChat();
				wsRef.current?.cancel();
			} catch (e) {
				console.error("Failed to cancel chat:", e);
			}

			setMessages([]);
			setStreamingContent("");
			setLoading(false);
			setClaudeSessionId(null);
		}
	};

	return (
		<div
			className="chat-container"
			style={{
				display: "flex",
				flexDirection: "column",
				height: "100%",
				backgroundColor: "#171717",
				color: "#ececec",
			}}
		>
			<ChatHeader
				projectPath={projectPath}
				onCloseProject={onCloseProject}
				contextUsage={contextUsage}
				onClearSession={clearSession}
				model={model}
				availableModels={availableModels}
				claudeModels={claudeModels}
				hasAnthropicKey={hasAnthropicKey}
				onModelChange={(newModel) => {
					setModel(newModel);
					api.setModelPreference(newModel).catch(console.error);
				}}
				enableTools={enableTools}
				onToggleTools={setEnableTools}
			/>

			{/* Two-column content area */}
			<div
				data-testid="chat-content-area"
				style={{
					display: "flex",
					flex: 1,
					minHeight: 0,
					flexDirection: isNarrowScreen ? "column" : "row",
				}}
			>
				{/* Left column: chat messages + input pinned at bottom */}
				<div
					data-testid="chat-left-column"
					style={{
						display: "flex",
						flexDirection: "column",
						flex: "0 0 60%",
						minHeight: 0,
						overflow: "hidden",
					}}
				>
					{/* Scrollable messages area */}
					<div
						ref={scrollContainerRef}
						onScroll={handleScroll}
						style={{
							flex: 1,
							overflowY: "auto",
							padding: "20px 0",
							display: "flex",
							flexDirection: "column",
							gap: "24px",
						}}
					>
						<div
							style={{
								maxWidth: "768px",
								margin: "0 auto",
								width: "100%",
								padding: "0 24px",
								display: "flex",
								flexDirection: "column",
								gap: "24px",
							}}
						>
							{messages.map((msg: Message, idx: number) => (
								<div
									key={`msg-${idx}-${msg.role}-${msg.content.substring(0, 20)}`}
									style={{
										display: "flex",
										flexDirection: "column",
										alignItems: msg.role === "user" ? "flex-end" : "flex-start",
									}}
								>
									<div
										style={{
											maxWidth: "100%",
											padding: msg.role === "user" ? "10px 16px" : "0",
											borderRadius: msg.role === "user" ? "20px" : "0",
											background:
												msg.role === "user"
													? "#2f2f2f"
													: msg.role === "tool"
														? "#222"
														: "transparent",
											color: "#ececec",
											border: msg.role === "tool" ? "1px solid #333" : "none",
											fontFamily: msg.role === "tool" ? "monospace" : "inherit",
											fontSize: msg.role === "tool" ? "0.85em" : "1em",
											fontWeight: "500",
											whiteSpace: msg.role === "tool" ? "pre-wrap" : "normal",
											lineHeight: "1.6",
										}}
									>
										{msg.role === "user" ? (
											msg.content
										) : msg.role === "tool" ? (
											<details style={{ cursor: "pointer" }}>
												<summary
													style={{
														color: "#aaa",
														fontSize: "0.9em",
														marginBottom: "8px",
														listStyle: "none",
														display: "flex",
														alignItems: "center",
														gap: "6px",
													}}
												>
													<span style={{ fontSize: "0.8em" }}>▶</span>
													<span>
														Tool Output
														{msg.tool_call_id && ` (${msg.tool_call_id})`}
													</span>
												</summary>
												<pre
													style={{
														maxHeight: "300px",
														overflow: "auto",
														margin: 0,
														padding: "8px",
														background: "#1a1a1a",
														borderRadius: "4px",
														fontSize: "0.85em",
														whiteSpace: "pre-wrap",
														wordBreak: "break-word",
													}}
												>
													{msg.content}
												</pre>
											</details>
										) : (
											<div className="markdown-body">
												<Markdown
													components={{
														// eslint-disable-next-line @typescript-eslint/no-explicit-any
														// biome-ignore lint/suspicious/noExplicitAny: react-markdown requires any for component props
														code: ({ className, children, ...props }: any) => {
															const match = /language-(\w+)/.exec(
																className || "",
															);
															const isInline = !className;
															return !isInline && match ? (
																<SyntaxHighlighter
																	// biome-ignore lint/suspicious/noExplicitAny: oneDark style types are incompatible
																	style={oneDark as any}
																	language={match[1]}
																	PreTag="div"
																>
																	{String(children).replace(/\n$/, "")}
																</SyntaxHighlighter>
															) : (
																<code className={className} {...props}>
																	{children}
																</code>
															);
														},
													}}
												>
													{msg.content}
												</Markdown>
											</div>
										)}

										{msg.tool_calls && (
											<div
												style={{
													marginTop: "12px",
													fontSize: "0.85em",
													color: "#aaa",
													display: "flex",
													flexDirection: "column",
													gap: "8px",
												}}
											>
												{msg.tool_calls.map((tc: ToolCall, i: number) => {
													let argsSummary = "";
													try {
														const args = JSON.parse(tc.function.arguments);
														const firstKey = Object.keys(args)[0];
														if (firstKey && args[firstKey]) {
															argsSummary = String(args[firstKey]);
															if (argsSummary.length > 50) {
																argsSummary = `${argsSummary.substring(0, 47)}...`;
															}
														}
													} catch (_e) {
														// ignore
													}

													return (
														<div
															key={`tool-${i}-${tc.function.name}`}
															style={{
																display: "flex",
																alignItems: "center",
																gap: "8px",
																fontFamily: "monospace",
															}}
														>
															<span style={{ color: "#888" }}>▶</span>
															<span
																style={{
																	background: "#333",
																	padding: "2px 6px",
																	borderRadius: "4px",
																}}
															>
																{tc.function.name}
																{argsSummary && `(${argsSummary})`}
															</span>
														</div>
													);
												})}
											</div>
										)}
									</div>
								</div>
							))}
							{loading && streamingContent && (
								<div
									style={{
										display: "flex",
										flexDirection: "column",
										alignItems: "flex-start",
									}}
								>
									<div
										style={{
											maxWidth: "85%",
											padding: "16px 20px",
											borderRadius: "12px",
											background: "#262626",
											color: "#fff",
											border: "1px solid #404040",
											fontFamily: "system-ui, -apple-system, sans-serif",
											fontSize: "0.95rem",
											fontWeight: 400,
											whiteSpace: "pre-wrap",
											lineHeight: 1.6,
										}}
									>
										<Markdown
											components={{
												// eslint-disable-next-line @typescript-eslint/no-explicit-any
												// biome-ignore lint/suspicious/noExplicitAny: react-markdown requires any for component props
												code: ({ className, children, ...props }: any) => {
													const match = /language-(\w+)/.exec(className || "");
													const isInline = !className;
													return !isInline && match ? (
														<SyntaxHighlighter
															// biome-ignore lint/suspicious/noExplicitAny: oneDark style types are incompatible
															style={oneDark as any}
															language={match[1]}
															PreTag="div"
														>
															{String(children).replace(/\n$/, "")}
														</SyntaxHighlighter>
													) : (
														<code className={className} {...props}>
															{children}
														</code>
													);
												},
											}}
										>
											{streamingContent}
										</Markdown>
									</div>
								</div>
							)}
							{loading && !streamingContent && (
								<div
									style={{
										alignSelf: "flex-start",
										color: "#888",
										fontSize: "0.9em",
										marginTop: "10px",
									}}
								>
									<span className="pulse">Thinking...</span>
								</div>
							)}
							<div ref={messagesEndRef} />
						</div>
					</div>

					{/* Chat input pinned at bottom of left column */}
					<div
						style={{
							padding: "24px",
							background: "#171717",
							display: "flex",
							justifyContent: "center",
						}}
					>
						<div
							style={{
								maxWidth: "768px",
								width: "100%",
								display: "flex",
								gap: "8px",
								alignItems: "center",
							}}
						>
							<textarea
								ref={inputRef}
								value={input}
								onChange={(e) => setInput(e.target.value)}
								onKeyDown={(e) => {
									if (e.key === "Enter" && !e.shiftKey) {
										e.preventDefault();
										sendMessage();
									}
								}}
								placeholder="Send a message..."
								rows={1}
								style={{
									flex: 1,
									padding: "14px 20px",
									borderRadius: "24px",
									border: "1px solid #333",
									outline: "none",
									fontSize: "1rem",
									fontWeight: "500",
									background: "#2f2f2f",
									color: "#ececec",
									boxShadow: "0 2px 6px rgba(0,0,0,0.02)",
									resize: "none",
									overflowY: "auto",
									fontFamily: "inherit",
								}}
							/>
							<button
								type="button"
								onClick={loading ? cancelGeneration : () => sendMessage()}
								disabled={!loading && !input.trim()}
								style={{
									background: "#ececec",
									color: "black",
									border: "none",
									borderRadius: "50%",
									width: "32px",
									height: "32px",
									display: "flex",
									alignItems: "center",
									justifyContent: "center",
									cursor: "pointer",
									opacity: !loading && !input.trim() ? 0.5 : 1,
									flexShrink: 0,
								}}
							>
								{loading ? "■" : "↑"}
							</button>
						</div>
					</div>
				</div>

				{/* Right column: panels independently scrollable */}
				<div
					data-testid="chat-right-column"
					style={{
						flex: "0 0 40%",
						overflowY: "auto",
						borderLeft: isNarrowScreen ? "none" : "1px solid #333",
						borderTop: isNarrowScreen ? "1px solid #333" : "none",
						padding: "12px",
						display: "flex",
						flexDirection: "column",
						gap: "12px",
					}}
				>
					<LozengeFlyProvider pipeline={pipeline}>
						<AgentPanel />

						<StagePanel title="To Merge" items={pipeline.merge} />
						<StagePanel title="QA" items={pipeline.qa} />
						<StagePanel title="Current" items={pipeline.current} />
						<StagePanel title="Upcoming" items={pipeline.upcoming} />
					</LozengeFlyProvider>
				</div>
			</div>

			{showApiKeyDialog && (
				<div
					style={{
						position: "fixed",
						top: 0,
						left: 0,
						right: 0,
						bottom: 0,
						backgroundColor: "rgba(0, 0, 0, 0.7)",
						display: "flex",
						alignItems: "center",
						justifyContent: "center",
						zIndex: 1000,
					}}
				>
					<div
						style={{
							backgroundColor: "#2f2f2f",
							padding: "32px",
							borderRadius: "12px",
							maxWidth: "500px",
							width: "90%",
							border: "1px solid #444",
						}}
					>
						<h2 style={{ marginTop: 0, color: "#ececec" }}>
							Enter Anthropic API Key
						</h2>
						<p
							style={{ color: "#aaa", fontSize: "0.9em", marginBottom: "20px" }}
						>
							To use Claude models, please enter your Anthropic API key. Your
							key will be stored server-side and reused across sessions.
						</p>
						<input
							type="password"
							value={apiKeyInput}
							onChange={(e) => setApiKeyInput(e.target.value)}
							onKeyDown={(e) => e.key === "Enter" && handleSaveApiKey()}
							placeholder="sk-ant-..."
							style={{
								width: "100%",
								padding: "12px",
								borderRadius: "8px",
								border: "1px solid #555",
								backgroundColor: "#1a1a1a",
								color: "#ececec",
								fontSize: "1em",
								marginBottom: "20px",
								outline: "none",
							}}
						/>
						<div
							style={{
								display: "flex",
								gap: "12px",
								justifyContent: "flex-end",
							}}
						>
							<button
								type="button"
								onClick={() => {
									setShowApiKeyDialog(false);
									setApiKeyInput("");
									pendingMessageRef.current = "";
								}}
								style={{
									padding: "10px 20px",
									borderRadius: "8px",
									border: "1px solid #555",
									backgroundColor: "transparent",
									color: "#aaa",
									cursor: "pointer",
									fontSize: "0.9em",
								}}
							>
								Cancel
							</button>
							<button
								type="button"
								onClick={handleSaveApiKey}
								disabled={!apiKeyInput.trim()}
								style={{
									padding: "10px 20px",
									borderRadius: "8px",
									border: "none",
									backgroundColor: apiKeyInput.trim() ? "#ececec" : "#555",
									color: apiKeyInput.trim() ? "#000" : "#888",
									cursor: apiKeyInput.trim() ? "pointer" : "not-allowed",
									fontSize: "0.9em",
								}}
							>
								Save Key
							</button>
						</div>
					</div>
				</div>
			)}
		</div>
	);
}