// Central store — SolidJS reactive state, OpenCode-style.
import { createSignal } from "solid-js";
import path from "path";
import fs from "fs";
import os from "os";
import { loadTuiJson, saveTuiJson } from "./tui-config.ts";

let _sess: any = null;
export function getSession(): any {
  if (!_sess) {
    const { Session } = require("../core/session.js");
    _sess = new Session();
  }
  return _sess;
}

export function setSessionAuto(auto: boolean): void {
  getSession().permissions.setAuto(auto);
  setAutoPerm(auto);
}

// ─── Permission auto-approve state (muted "auto" indicator in the status row) ───
export const [autoPerm, setAutoPerm] = createSignal(false);

// ─── Chat state ───
export const [messages, setMessages] = createSignal<any[]>([]);
export const [input, setInput] = createSignal("");
export const [thinking, setThinking] = createSignal(false);
export const [thinkStart, setThinkStart] = createSignal<number | null>(null);
// Index (into messages()) of the user bubble whose collapsed preview is
// expanded. Ctrl+E toggles the most recent collapsed one; clicking a bubble
// also sets this. Null = everything collapsed.
export const [userExpandedIdx, setUserExpandedIdx] = createSignal<number | null>(null);
// Settled reasoning parts (message index → part indices) the user expanded.
// Clicking a settled "+ Thought" row toggles its part; absent = all collapsed.
export const [thoughtExpanded, setThoughtExpanded] = createSignal<Map<number, Set<number>>>(new Map());
// While a turn is RUNNING its thinking streams open by default; clicking the
// "⠋ Thinking" header collapses it live (opencode toggles reasoning at any
// time). Indices of running thoughts the user collapsed manually.
export const [thoughtClosed, setThoughtClosed] = createSignal<Set<number>>(new Set());

// ─── Prompt history (Up/Down recall of earlier prompts) ───
export const [promptHistory, setPromptHistory] = createSignal<string[]>([]);
export const [historyIndex, setHistoryIndex] = createSignal(-1);
let historyDraft = "";

// Record every submitted prompt (deduped, capped at 50) and reset navigation
// so the next Up arrow starts from the newest entry.
export function recordPrompt(text: string) {
  const t = text.trim();
  if (!t) return;
  setPromptHistory(h => (h[h.length - 1] === t ? h : [...h.slice(-49), t]));
  setHistoryIndex(-1);
  historyDraft = "";
}

// Up arrow: walk toward older prompts; the first Up saves the current draft so
// Down past the end restores it.
export function historyPrev(): string | null {
  const h = promptHistory();
  if (!h.length) return null;
  if (historyIndex() === -1) historyDraft = input();
  const ni = historyIndex() === -1 ? h.length - 1 : Math.max(0, historyIndex() - 1);
  setHistoryIndex(ni);
  return h[ni];
}

// Down arrow: walk toward newer prompts; past the newest restores the draft.
export function historyNext(): string | null {
  const h = promptHistory();
  if (historyIndex() === -1) return null;
  const ni = historyIndex() + 1;
  if (ni >= h.length) { setHistoryIndex(-1); return historyDraft; }
  setHistoryIndex(ni);
  return h[ni];
}

// Typing fresh text (or escaping) abandons history navigation.
export function historyReset() { setHistoryIndex(-1); historyDraft = ""; }

// ─── Autocomplete (slash / @file / !shell) ───
export type AutoKind = "none" | "slash" | "file" | "shell" | "at";
export type Suggestion = { label: string; desc?: string };
export const [suggestions, setSuggestions] = createSignal<Suggestion[]>([]);
export const [autoKind, setAutoKind] = createSignal<AutoKind>("none");
export const [autoIndex, setAutoIndex] = createSignal(0);

// App registers a handler that executes the picked suggestion (slash / shell / file).
let _suggestionPicker: ((label: string) => void) | null = null;
export function registerSuggestionPicker(fn: ((label: string) => void) | null) { _suggestionPicker = fn; }

export function selectSuggestionAt(i: number) {
  setAutoIndex(Math.max(0, Math.min(suggestions().length - 1, i)));
}

export function moveSuggestionIndex(delta: number) {
  const n = suggestions().length;
  if (!n) return;
  setAutoIndex(i => Math.max(0, Math.min(n - 1, i + delta)));
}

// Compute the start index of a visible window that keeps `selected` in view.
// `visible` rows are shown; selection stays inside with ~1/3 of the window above it.
// If `selected` is already inside the current window, the window is NOT moved —
// this keeps the popup stable during mouse down/up (clicking must not shift rows
// between press and release, or the release lands on a different row).
export function windowFor(selected: number, total: number, visible: number, currentStart: number = 0): number {
  if (total <= visible) return 0;
  const maxStart = total - visible;
  const c = Math.max(0, Math.min(currentStart, maxStart));
  if (selected >= c && selected < c + visible) return c;
  const target = selected - Math.floor(visible / 3);
  return Math.max(0, Math.min(maxStart, target));
}

export function pickSuggestionAt(i: number): boolean {
  selectSuggestionAt(i);
  return pickSuggestion();
}

export function pickSuggestion(): boolean {
  const list = suggestions();
  const pick = list[autoIndex()];
  if (!pick) return false;
  const label = pick.label;
  setInput(""); setSuggestions([]); setAutoKind("none"); setAutoIndex(0);
  if (_suggestionPicker) _suggestionPicker(label);
  return true;
}

// ─── Modal ───
export const [modal, setModal] = createSignal<any>(null);
export function openModal(m: any) { setModal(m); }
export function closeModal() { setModal(null); }

// ─── Permission popup (model wants to run a command / change a file) ───
// The same popup hosts QUESTIONS (the ask tool): isQuestion flips it into
// question mode, where the user picks one of the provided options or types
// their own answer instead of the Allow/Always/Deny choices.
export type PermissionRequest = {
  tool: string;
  command: string;
  label: string;
  isQuestion?: boolean;
  options?: string[];
  sessionStart?: boolean;
  resolve: (approved: boolean, note?: string) => void;
};
export const [permission, setPermission] = createSignal<PermissionRequest | null>(null);

// Draft caret position (index into input) — the chatbox is a real editing
// surface: left/right arrows move it, typing inserts at it, backspace deletes
// before it. Kept in the store so history/paste/submit paths can sync it.
export const [cursor, setCursor] = createSignal(0);

// Set the draft and place the cursor (defaults to the end).
export function setDraft(text: string, pos?: number) {
  setInput(text);
  setCursor(typeof pos === "number" ? Math.max(0, Math.min(text.length, pos)) : text.length);
}

// Draft text selection (readline-style): selStart/selEnd are indices into
// input; both -1 = no selection. Ctrl+A marks everything, Ctrl+C copies the
// highlighted span, typing/backspace replace it.
export const [selStart, setSelStart] = createSignal(-1);
export const [selEnd, setSelEnd] = createSignal(-1);
export function clearSelection() { setSelStart(-1); setSelEnd(-1); }

// Paste-vs-typing marker: set when a paste lands in the input and cleared the
// moment the user edits. Pasted drafts past 10 lines render compressed
// ("pasted ~N lines") instead of blowing the chatbox up to its scroll limit.
export const [pastedAt, setPastedAt] = createSignal(0);

// Typing an answer to a QUESTION popup (the ask tool) switches the popup into
// its inline answer editor; the text lives here so the reconciler can remount
// the popup on signal changes without wiping the typed answer.
export const [questionOpen, setQuestionOpen] = createSignal(false);
export const [questionText, setQuestionText] = createSignal("");

export function openQuestion(initial: string) {
  setQuestionText(initial);
  setQuestionOpen(true);
}

export function closeQuestion() {
  setQuestionOpen(false);
  setQuestionText("");
}

// Raised by the session's onPermissionRequest callback; resolves once the user
// answers the popup (Allow / Always allow / Deny, or a question option/answer).
// The promise resolves { approved, note } — the session turns questions into
// the answer (note) and permissions into an approve/deny verdict.
export function requestPermission(tool: string, command: string, label: string, isQuestion?: boolean, options?: string[]): Promise<{ approved: boolean; note: string }> {
  return new Promise((resolve) => {
    setPermission({
      tool, command, label, isQuestion, options,
      resolve: (approved, note) => { setPermission(null); resolve({ approved: !!approved, note: note || "" }); },
    });
  });
}

// One-time prompt shown at the start of a new session: "Allow all commands in
// this session?" — picking "Allow all commands" flips on session-wide
// auto-approval (Shift+Tab also toggles it), "Ask each time" keeps per-command
// asks. Fire-and-forget: the popup resolves itself once the user answers.
export function askSessionPermissions(): Promise<void> {
  return new Promise((resolve) => {
    setPermission({
      tool: "session",
      command: "Allow all commands in this session?",
      label: "",
      isQuestion: true,
      options: ["Allow all commands", "Ask each time"],
      sessionStart: true,
      resolve: () => { setPermission(null); resolve(); },
    });
  });
}

// ─── Floating toasts ───
// Transient confirmations (copied, model switched, key saved, ...) render as a
// small floating box above the input bar and auto-dismiss — they are NOT chat
// messages, so they never pollute the conversation history.
export type Toast = { id: number; text: string; kind: "info" | "ok" | "error" };
export const [toasts, setToasts] = createSignal<Toast[]>([]);
let toastSeq = 0;
export function showToast(text: string, kind: "info" | "ok" | "error" = "info", durationMs: number = 3000) {
  const id = ++toastSeq;
  setToasts(t => [...t, { id, text, kind }]);
  setTimeout(() => setToasts(t => t.filter(x => x.id !== id)), durationMs);
}

// ─── Sidebar ───
export const [sidebarVisible, setSidebarVisible] = createSignal(true);
export const [sidebarTab, setSidebarTab] = createSignal(0);

// ─── Live model speed (sidebar "Speed" row) ───
export type SpeedSnapshot = {
  live: { elapsedMs: number; firstTokenMs: number | null; tokensPerSec: number } | null;
  last: { latencyMs: number | null; tokensPerSec: number | null; durationMs: number | null; tokens: number | null; model: string } | null;
};
export const [speedStats, setSpeedStats] = createSignal<SpeedSnapshot>({ live: null, last: null });

// ─── Settings toggles ───
export const [showToolDetails, setShowToolDetails] = createSignal(true);
export const [showThinking, setShowThinking] = createSignal(true);
export const [inputMode, setInputMode] = createSignal<"build" | "plan" | "chat">("build");

// ─── Provider state ───
export const [providerName, setProviderName] = createSignal("");
export const [modelName, setModelName] = createSignal("");
export const [providerKeyOk, setProviderKeyOk] = createSignal(false);
export const [sessionId, setSessionId] = createSignal("");

// ─── Todos ───
export const [todos, setTodos] = createSignal<any[]>([]);

// ─── Usage & billing ───
export const [sessionUsage, setSessionUsage] = createSignal<{ tokens: number; pct: number; cost: number }>({ tokens: 0, pct: 0, cost: 0 });
export const [lifetimeUsage, setLifetimeUsage] = createSignal<{ tokens: number; cost: number; monthCost: number; pct: number; budget: number }>({ tokens: 0, cost: 0, monthCost: 0, pct: 0, budget: 25 });
export const [modelMeta, setModelMeta] = createSignal<any>(null);
export const [budgetLevel, setBudgetLevel] = createSignal<string>("auto");
// Phase 2.4: the last skill(s) that fired this turn — drives the sidebar Skills row.
export const [skillActive, setSkillActive] = createSignal<string[]>([]);

const { PROVIDERS, PROVIDER_ORDER, PROVIDER_LABELS } = require("../providers/index.js");
export { PROVIDERS, PROVIDER_ORDER, PROVIDER_LABELS };

export function refreshProviderState() {
  const s = getSession();
  const cfg = s.config || {};
  const prov = s.provider?.active?.name || cfg.provider || "anthropic";
  const model = cfg.model?.[prov] || "default";
  setProviderName(prov);
  setModelName(model);
  setSessionId(s.conversationId || "");
  setBudgetLevel(cfg.budgetLevel || "auto");
  const { envNamesFor } = require("../providers/index.js");
  const hasKey = !!(cfg.apiKeys?.[prov]) || (envNamesFor(prov) || []).some(n => !!process.env[n]);
  setProviderKeyOk(!!hasKey);
}

// Refresh the session + lifetime usage/billing signals from the session counters and ~/.loom/usage.json.
export function refreshUsage() {
  refreshProviderState();
  const s = getSession();
  const { getModelMeta } = require("../providers/index.js");
  const meta = getModelMeta(providerName(), modelName());
  const ctx = meta?.context || 200000;
  setModelMeta(meta);
  setSessionUsage({
    tokens: s.tokensUsed,
    pct: ctx ? (s.tokensUsed / ctx) * 100 : 0,
    cost: s.sessionCost,
  });
  const { getUsage } = require("../core/usage.js");
  const u = getUsage();
  setLifetimeUsage({
    tokens: u.totalTokens,
    cost: u.totals.costUsd,
    monthCost: u.month.costUsd,
    pct: u.budgetUsd ? (u.month.costUsd / u.budgetUsd) * 100 : 0,
    budget: u.budgetUsd,
  });
}

export function modelOptionsForProvider(provider: string) {
  return PROVIDERS[provider]?.models || [];
}

export function allModelOptions() {
  const out: any[] = [];
  const { getRecentModels, hasApiKey } = require("../config/settings.js");
  const { BUILTIN_PROVIDERS } = require("../providers/index.js");
  const recents = getRecentModels();
  const seen = new Set<string>();
  if (recents.length) {
    out.push({ header: "Recent", value: "__header_recent", isHeader: true });
    for (const r of recents) {
      if (!r || !r.provider || !r.model) continue;
      const mods = modelOptionsForProvider(r.provider);
      const m = mods.find(x => x.id === r.model);
      if (!m) continue;
      const key = r.provider + "/" + r.model;
      seen.add(key);
      out.push({ label: m.name, value: m.id, sub: m.id, provider: r.provider, tags: m.tags, recent: true });
    }
  }
  for (const p of PROVIDER_ORDER) {
    const mods = modelOptionsForProvider(p);
    if (!mods.length) continue;
    // models.dev-scale: only providers with a key list their full model set —
    // the rest stay in /connect until a key is added. Built-ins always show.
    if (!BUILTIN_PROVIDERS.includes(p) && !hasApiKey(p)) continue;
    out.push({ header: PROVIDER_LABELS[p] || p, value: `__header__${p}`, isHeader: true });
    for (const m of mods) {
      const key = p + "/" + m.id;
      if (seen.has(key)) continue;
      out.push({ label: m.name, value: m.id, sub: m.id, provider: p, tags: m.tags });
    }
  }
  out.push({ label: "(custom model ID)", value: "__custom__" });
  return out;
}

// ─── Message helpers ───
export function appendMessage(m: any) { setMessages(l => [...l, m]); }

// ─── Vim mode ───
// Optional modal editing (config `vimMode`, toggled via /vim). Normal-mode
// keys are intercepted in the App's central key handler; insert mode behaves
// exactly like the default input.
export const [vimMode, setVimMode] = createSignal(!!loadTuiJson().vimMode);
export const [vimNormal, setVimNormal] = createSignal(false);
export function toggleVim(): boolean {
  const next = !vimMode();
  setVimMode(next);
  setVimNormal(false);
  saveTuiJson({ vimMode: next });
  return next;
}

// ─── Queued drafts ───
// Messages typed while a turn runs are queued (claude-style) and flushed
// FIFO when the turn ends. Plain strings; submitted verbatim.
export const [queuedDrafts, setQueuedDrafts] = createSignal<string[]>([]);
export function queueDraft(text: string): void { setQueuedDrafts(q => q.concat(text)); }
export function dequeueDraft(): string | null {
  const q = queuedDrafts();
  if (!q.length) return null;
  setQueuedDrafts(q.slice(1));
  return q[0];
}
export function patchLastMessage(patch: any) {
  setMessages(l => {
    const i = l.length - 1;
    if (i < 0) return l;
    return l.map((m, j) => j === i ? { ...m, ...patch } : m);
  });
}
export function patchMessageAt(idx: number, patch: any) {
  setMessages(l => l.map((m, i) => (i === idx ? { ...m, ...patch } : m)));
}

// Matches bare markers ("[x] task") AND markdown checklist lines
// ("- [x] task", "* [ ] task", "1. [~] task") so the sidebar mirrors todo
// lists the model writes in its reply even without the todowrite tool.
const TODO_RX = /^\s*(?:[-*+]\s+|\d+\.\s+)?\[([x+~ \-])\]\s+(.+)/i;
export function recomputeTodos() {
  // Real todo state from the session (todowrite tool persists there) wins.
  const sess = getSession();
  const real = sess.todos;
  if (Array.isArray(real) && real.length) {
    setTodos(real.map(t => ({
      done: t.status === "completed",
      inProgress: t.status === "in_progress",
      cancelled: t.status === "cancelled",
      text: t.content,
    })));
    return;
  }
  // Fallback: scan replies for [ ] [x] [+] markers (resumed/old sessions).
  const out: any[] = [];
  for (const m of messages()) {
    if (m.role !== "assistant" || !m.content) continue;
    for (const line of String(m.content).split("\n")) {
      const hit = line.match(TODO_RX);
      if (hit) {
        const st = hit[1].toLowerCase();
        out.push({ done: st === "x" || st === "+", inProgress: st === "+" || st === "~", cancelled: st === "-", text: hit[2].trim() });
      }
    }
  }
  setTodos(out);
}

// ─── File helpers ───
const IGNORE = /(^|[\/])(node_modules|\.git|dist|build|\.next|\.venv|venv|coverage|__pycache__|\.loom|\.idea|\.vscode)([\/]|$)/i;
let filesCache: string[] | null = null;
// Reactive re-calc engine: bumping filesVersion invalidates the cache AND
// re-runs every reactive caller (the Sidebar's file list) because
// getProjectFiles() reads the signal. Bump after writes/create/rm calls.
const [filesVersion, setFilesVersion] = createSignal(0);

export function getProjectFiles(): string[] {
  filesVersion();
  if (filesCache) return filesCache;
  const cwd = process.cwd();
  const out: string[] = [];
  function walk(dir: string, depth: number) {
    if (depth > 4 || out.length > 500) return;
    let entries;
    try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
    for (const e of entries) {
      const full = path.join(dir, e.name);
      if (IGNORE.test(full)) continue;
      const rel = path.relative(cwd, full).replace(/\\/g, "/");
      if (e.isDirectory()) walk(full, depth + 1);
      else out.push(rel);
    }
  }
  walk(cwd, 0);
  filesCache = out.sort();
  return filesCache;
}

export function fuzzyFiles(query: string): string[] {
  if (!query) return getProjectFiles().slice(0, 12);
  const q = query.toLowerCase();
  return getProjectFiles()
    .filter((f: string) => f.toLowerCase().includes(q))
    .sort((a: string, b: string) => {
      const ai = a.toLowerCase().indexOf(q);
      const bi = b.toLowerCase().indexOf(q);
      if (ai !== bi) return ai - bi;
      return a.length - b.length;
    })
    .slice(0, 12);
}

export function invalidateFilesCache() { filesCache = null; }

export function bumpFilesVersion() { setFilesVersion(v => v + 1); invalidateFilesCache(); }

// Recompute the sidebar's file list when a known mutator lands. Called by the
// tool-execution layer after write/edit/bash so the Files tab is always fresh.
export function refreshFilesIfNeeded(src?: string) {
  if (src === "write" || src === "edit" || src === "bash" || src === "mcp") bumpFilesVersion();
}

// Live agent todos: Session.setTodos → core event "todos:changed" → here.
// This _replaces_ any markdown-scan fallback so the sidebar mirrors the
// model's real todowrite output without waiting for a full assistant re-render.
// Registration is idempotent: App remounts must not stack duplicate listeners.
let _todoEvOff: (() => void) | null = null;
export function wireTodoEvents() {
  if (_todoEvOff) return;
  const ev = require("../core/events.js");
  _todoEvOff = ev.on("todos:changed", (todos: any[]) => {
    const sess = getSession();
    const real = Array.isArray(todos) && todos.length ? todos : sess.todos;
    setTodos(
      (Array.isArray(real) ? real : []).map((t: any) => ({
        done: t.status === "completed",
        inProgress: t.status === "in_progress",
        cancelled: t.status === "cancelled",
        text: String(t.content || ""),
      }))
    );
  });
}

// ─── Slash commands (for autocomplete) ───
export interface SlashCmd { cmd: string; desc: string; args?: string; }

export const SLASH_LIST: SlashCmd[] = [
  { cmd: "help", desc: "Show help dialog" },
  { cmd: "agents", desc: "List agents — primaries + subagents (@mention or task tool)" },
  { cmd: "build", desc: "Build mode — full agent tools (Tab cycles)" },
  { cmd: "plan", desc: "Plan mode — read-only analysis, no file changes" },
  { cmd: "chat", desc: "Chat mode — conversation only, no tools" },
  { cmd: "connect", desc: "Add/connect a provider", args: "[provider]" },
  { cmd: "key", desc: "Edit API key" },
  { cmd: "baseurl", desc: "Set provider base URL", args: "[provider] [url]" },
  { cmd: "model", desc: "Pick the active model", args: "[model-id]" },
  { cmd: "models", desc: "Open the model picker (grouped by provider)" },
  { cmd: "providers", desc: "List supported providers" },
  { cmd: "status", desc: "Show connection status" },
  { cmd: "usage", desc: "Show token usage and billing" },
  { cmd: "budget", desc: "Budget level: free | cheap | best | auto", args: "[level]" },
  { cmd: "new", desc: "Start a new session" },
  { cmd: "clear", desc: "Clear the chat" },
  { cmd: "restore", desc: "Restore project to an earlier state" },
  { cmd: "settings", desc: "Toggle details/thinking display" },
  { cmd: "sessions", desc: "Browse saved sessions (jump to one)" },
  { cmd: "thinking", desc: "Toggle thinking visibility" },
  { cmd: "details", desc: "Toggle tool detail visibility" },
  { cmd: "theme", desc: "Switch UI theme" },
  { cmd: "graph", desc: "View the memory graph (nodes + links)" },
  { cmd: "skills", desc: "Manage skills", args: "install <dir|git> | remove <name>" },
  { cmd: "mcp", desc: "Manage MCP servers", args: "add <name> <cmd> | remove | toggle" },
  { cmd: "connectors", desc: "Manage connectors (hosting & cloud services)", args: "add <name> <cmd> | remove | toggle" },
  { cmd: "permissions", desc: "Show saved permission rules", args: "| reset | auto" },
  { cmd: "exit", desc: "Quit Loom Code" },
  // Newer commands sit at the END so early rows (help/connect/…) keep their
  // popup positions — the interactive suite and muscle memory rely on it.
  { cmd: "subagents", desc: "View subagent runs (live + history, cancel, details)" },
  { cmd: "context", desc: "Show ~token breakdown of the current context window" },
  { cmd: "think", desc: "Thinking budget", args: "off|low|medium|high" },
  { cmd: "approve", desc: "Approve the plan & switch to Build (Plan mode)" },
  { cmd: "tasks", desc: "List background tasks (bash background:true)" },
  { cmd: "rewind", desc: "Pick a restore point and rewind files" },
  { cmd: "share", desc: "Export this chat as a self-contained HTML file" },
  { cmd: "worktree", desc: "New git worktree + branch for parallel work", args: "<name>" },
  { cmd: "style", desc: "Output style preset or free text; empty clears" },
  { cmd: "vim", desc: "Toggle vim modal editing (Esc = NORMAL)" },
  { cmd: "remember", desc: "Save a fact to project LOOM.md (or type # fact)", args: "<fact>" },
];

// ─── TUI prefs ───
const _p = loadTuiJson();
if (_p.sidebarVisible !== undefined) setSidebarVisible(_p.sidebarVisible);
if (_p.showToolDetails !== undefined) setShowToolDetails(_p.showToolDetails);
if (_p.showThinking !== undefined) setShowThinking(_p.showThinking);

// ─── First-run welcome tips (small sidebar card, dismissible with ✕) ───
// Visible only until the user dismisses them once; the flag persists in
// tui.json so existing users never see the card again.
export const [welcomeTipSeen, setWelcomeTipSeen] = createSignal(!!_p.welcomeTipSeen);
export function dismissWelcomeTips() {
  setWelcomeTipSeen(true);
  saveTuiJson({ welcomeTipSeen: true });
}

export function persistUi() {
  saveTuiJson({
    sidebarVisible: sidebarVisible(),
    showToolDetails: showToolDetails(),
    showThinking: showThinking(),
    welcomeTipSeen: welcomeTipSeen(),
  });
}

// ─── Convenience getters ───
export function cwdShort(): string {
  const cwd = process.cwd().replace(/\\/g, "/");
  return cwd.split("/").filter(Boolean).slice(-2).join("/");
}
export function username(): string { return os.userInfo().username || "you"; }

// ─── Subagent tracker ───
// Active subagent runs are kept in a Solid signal so the /subagents panel can
// render live status (running/done/error/cancelled, elapsed time, last tool).
// Completed runs are also persisted to disk via saveSubagentRun and merged
// into subagentHistory so the panel can show runs from past sessions.
export interface SubagentEntry {
  runId: string;
  agent: string;
  agentId: string;
  prompt: string;
  status: "running" | "done" | "error" | "cancelled";
  startTime: number;
  endTime: number | null;
  durationMs: number;
  tokensIn: number;
  tokensOut: number;
  costUsd: number;
  interrupted: boolean;
  content: string;
  toolLog: string[];
  sessionId?: string;
}

// Active (in-flight + just-completed this session). Map keyed by runId; the
// signal value is replaced (not mutated) so Solid sees the change.
export const [activeSubagents, setActiveSubagents] = createSignal<Map<string, SubagentEntry>>(new Map());

export function startSubagent(opts: { runId: string; agent: string; agentId: string; prompt: string; sessionId?: string }): void {
  const now = Date.now();
  const entry: SubagentEntry = {
    runId: opts.runId,
    agent: opts.agent,
    agentId: opts.agentId,
    prompt: String(opts.prompt || ""),
    status: "running",
    startTime: now,
    endTime: null,
    durationMs: 0,
    tokensIn: 0,
    tokensOut: 0,
    costUsd: 0,
    interrupted: false,
    content: "",
    toolLog: [],
    sessionId: opts.sessionId,
  };
  setActiveSubagents(prev => {
    const next = new Map(prev);
    next.set(opts.runId, entry);
    return next;
  });
}

// Append to content / toolLog and patch scalar fields. Solid needs a new Map
// to detect the change — we copy on every update.
export function updateSubagent(runId: string, patch: { contentAppend?: string; toolLogAppend?: string; durationMs?: number }): void {
  setActiveSubagents(prev => {
    const cur = prev.get(runId);
    if (!cur) return prev;
    const next = new Map(prev);
    const live: SubagentEntry = {
      ...cur,
      durationMs: patch.durationMs != null ? patch.durationMs : (Date.now() - cur.startTime),
    };
    if (patch.contentAppend) live.content = cur.content + patch.contentAppend;
    if (patch.toolLogAppend) live.toolLog = cur.toolLog.concat(patch.toolLogAppend);
    next.set(runId, live);
    return next;
  });
}

// Mark a run done/error/cancelled and (when done) copy into the in-memory
// history so the panel can keep showing it after activeSubagents evicts it.
export function endSubagent(runId: string, final: { status: "done" | "error" | "cancelled"; endTime?: number; tokensIn?: number; tokensOut?: number; costUsd?: number; durationMs?: number; interrupted?: boolean; content?: string }): SubagentEntry | null {
  let finished: SubagentEntry | null = null;
  setActiveSubagents(prev => {
    const cur = prev.get(runId);
    if (!cur) return prev;
    const next = new Map(prev);
    finished = {
      ...cur,
      status: final.status,
      endTime: final.endTime != null ? final.endTime : Date.now(),
      durationMs: final.durationMs != null ? final.durationMs : (Date.now() - cur.startTime),
      tokensIn: final.tokensIn != null ? final.tokensIn : cur.tokensIn,
      tokensOut: final.tokensOut != null ? final.tokensOut : cur.tokensOut,
      costUsd: final.costUsd != null ? final.costUsd : cur.costUsd,
      interrupted: final.interrupted != null ? final.interrupted : cur.interrupted,
      content: final.content != null ? final.content : cur.content,
    };
    next.set(runId, finished);
    return next;
  });
  if (finished) {
    // Snapshot into in-memory history so the panel can show it even if the
    // disk write fails or the panel is opened in the same session.
    setSubagentHistory(prev => [finished!, ...prev].slice(0, 500));
  }
  return finished;
}

export function getSubagent(runId: string): SubagentEntry | undefined {
  return activeSubagents().get(runId);
}

// Cancel a live subagent by runId. Delegates to core/agents.js so the
// child's interrupt() actually fires; the run will resolve as interrupted
// and endSubagent will be called with status 'cancelled' / interrupted=true.
export function cancelSubagentRun(runId: string): boolean {
  try {
    const { cancelSubagent } = require("../core/agents.js");
    return !!cancelSubagent(runId);
  } catch {
    return false;
  }
}

// History from disk (loaded on startup; refreshed when the panel opens).
export const [subagentHistory, setSubagentHistory] = createSignal<SubagentEntry[]>([]);

// Synchronous load (the log file is small — a few hundred entries max — and
// the panel needs the data immediately on first paint).
export function loadSubagentHistory(opts?: { since?: number; sessionId?: string; limit?: number }): SubagentEntry[] {
  try {
    const { loadSubagentRuns } = require("../core/subagent-log.js");
    const rows = loadSubagentRuns(opts) as SubagentEntry[];
    setSubagentHistory(rows);
    return rows;
  } catch {
    return [];
  }
}

// Persist a finished run to the on-disk log. Best-effort — a write failure
// must not break the TUI.
export function persistSubagent(entry: SubagentEntry): boolean {
  try {
    const { saveSubagentRun } = require("../core/subagent-log.js");
    return !!saveSubagentRun(entry);
  } catch {
    return false;
  }
}