import { spawn } from "node:child_process";
import { promises as fs } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import type { AssistantMessage } from "@earendil-works/pi-ai";
import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
import { Box, MouseRegion, Text, type TuiMouseEvent } from "@earendil-works/pi-tui";

const TYPE = "bash-code-actions";
const LANGS = new Set(["bash", "sh", "shell", "zsh"]);
type Block = { index: number; language: string; code: string };
type Data = { sourceEntryId: string; cwd: string; blocks: Block[] };
let current: ExtensionContext | undefined;

function body(message: unknown): string {
  const parts = (message as AssistantMessage | undefined)?.content;
  return Array.isArray(parts) ? parts.filter(p => p.type === "text").map(p => p.text).join("\n") : "";
}
function parse(text: string): Block[] {
  const out: Block[] = [];
  for (const m of text.matchAll(/```([^\n`]*)\n([\s\S]*?)```/g)) {
    const language = m[1].trim().toLowerCase().split(/\s+/)[0] || "";
    if (LANGS.has(language)) out.push({ index: out.length + 1, language, code: m[2].replace(/\n$/, "") });
  }
  return out;
}
function quote(s: string): string { return `'${s.replace(/'/g, `'\\''`)}'`; }
function stdin(command: string, args: string[], text: string): Promise<boolean> {
  return new Promise(resolve => {
    const p = spawn(command, args, { stdio: ["pipe", "ignore", "ignore"] });
    let settled = false;
    const done = (ok: boolean) => { if (!settled) { settled = true; resolve(ok); } };
    p.once("error", () => done(false)); p.once("close", code => done(code === 0)); p.stdin.end(text);
  });
}
async function clipboard(text: string): Promise<boolean> {
  if (process.platform === "darwin") return stdin("pbcopy", [], text);
  if (process.platform === "win32") return stdin("clip", [], text);
  return await stdin("wl-copy", [], text) || await stdin("xclip", ["-selection", "clipboard"], text) || stdin("xsel", ["--clipboard", "--input"], text);
}
async function terminal(code: string, cwd: string): Promise<boolean> {
  const dir = await fs.mkdtemp(join(tmpdir(), "pi-bash-code-")), script = join(dir, "run.sh");
  await fs.writeFile(script, `#!/usr/bin/env bash\ntrap 'rm -rf -- "$(dirname -- "$0")"' EXIT\ncd -- ${quote(cwd)} 2>/dev/null || true\n${code}\n`, { mode: 0o700 });
  const candidates: Array<[string, string[]]> = [];
  const configured = process.env.TERMINAL?.trim();
  if (configured && !configured.includes(" ")) candidates.push([configured, ["bash", script]]);
  candidates.push(["konsole", ["--hold", "-e", "bash", script]], ["gnome-terminal", ["--", "bash", script]], ["x-terminal-emulator", ["-e", "bash", script]]);
  for (const [cmd, args] of candidates) {
    const ok = await new Promise<boolean>(resolve => {
      const p = spawn(cmd, args, { detached: true, stdio: "ignore" });
      p.once("error", () => resolve(false)); p.once("spawn", () => { p.unref(); resolve(true); });
    });
    if (ok) return true;
  }
  await fs.rm(dir, { recursive: true, force: true }); return false;
}
function warning(code: string): string {
  if (/\bsudo\b|\brm\s+-rf\b|\bdd\s+if=|\bmkfs\b|\bshutdown\b|\breboot\b/.test(code)) return "⚠ Comandi privilegiati o potenzialmente distruttivi.";
  if (/\bcurl\b|\bwget\b|\|\s*(bash|sh)\b/.test(code)) return "⚠ Comandi di rete o pipe a una shell.";
  return "";
}
async function action(kind: "copy" | "open" | "execute", block: Block, data: Data, ctx: ExtensionContext): Promise<void> {
  if (!ctx.hasUI) return;
  if (kind === "copy") {
    const ok = await clipboard(block.code); ctx.ui.notify(ok ? `Blocco ${block.index} copiato.` : "Clipboard non disponibile.", ok ? "info" : "error"); return;
  }
  if (kind === "execute") {
    const shown = block.code.length > 1600 ? `${block.code.slice(0, 1597)}...` : block.code;
    if (!(await ctx.ui.confirm("Conferma esecuzione", [`Eseguire il blocco bash ${block.index}?`, "", shown, warning(block.code)].filter(Boolean).join("\n")))) return;
  }
  const ok = await terminal(block.code, data.cwd);
  ctx.ui.notify(ok ? "Blocco avviato in un nuovo terminale." : "Terminale non disponibile.", ok ? "info" : "error");
}
function preview(code: string): string {
  const line = code.split("\n").find(s => s.trim())?.trim() || "(vuoto)"; return line.length > 65 ? `${line.slice(0, 62)}...` : line;
}
function button(label: string, kind: "copy" | "open" | "execute", block: Block, data: Data, theme: any): MouseRegion {
  return new MouseRegion(new Text(theme.fg(kind === "execute" ? "warning" : "accent", `[ ${label} ]`), 1, 0), (e: TuiMouseEvent) => {
    if (e.type !== "click" || e.button !== "left") return undefined;
    if (current) void action(kind, block, data, current); return { handled: true, render: false };
  });
}
function render(data: Data, theme: any): Box {
  const box = new Box(1, 0, s => theme.bg("customMessageBg", s));
  box.addChild(new Text(theme.fg("muted", "bash code actions"), 1, 0));
  for (const b of data.blocks) {
    box.addChild(new Text(theme.fg("dim", `${b.index}. ${preview(b.code)}`), 1, 0));
    box.addChild(button("copia", "copy", b, data, theme)); box.addChild(button("terminale", "open", b, data, theme)); box.addChild(button("esegui", "execute", b, data, theme));
  }
  return box;
}
function known(ctx: ExtensionContext): Data[] {
  return ctx.sessionManager.getBranch().filter((e: any) => e.type === "custom" && e.customType === TYPE).map((e: any) => e.data).filter((d: any) => d?.blocks);
}
async function recover(pi: ExtensionAPI, ctx: ExtensionContext): Promise<void> {
  const branch = ctx.sessionManager.getBranch() as any[];
  const ids = new Set(branch.filter(e => e.type === "custom" && e.customType === TYPE).map(e => e.data?.sourceEntryId));
  for (const e of branch) {
    if (e.type !== "message" || e.message?.role !== "assistant" || ids.has(e.id)) continue;
    const blocks = parse(body(e.message)); if (blocks.length) pi.appendEntry(TYPE, { sourceEntryId: e.id, cwd: ctx.cwd, blocks } satisfies Data);
  }
}
export default function (pi: ExtensionAPI) {
  pi.registerEntryRenderer(TYPE, (entry, _opts, theme) => { const d = entry.data as Data | undefined; return d?.blocks?.length ? render(d, theme) : undefined; });
  pi.on("session_start", async (_e, ctx) => { current = ctx; await recover(pi, ctx); });
  pi.on("session_shutdown", () => { current = undefined; });
  pi.on("turn_end", (e, ctx) => {
    current = ctx; if (e.message.role !== "assistant") return;
    const blocks = parse(body(e.message)); if (blocks.length) pi.appendEntry(TYPE, { sourceEntryId: e.messageEntryId, cwd: ctx.cwd, blocks } satisfies Data);
  });
  pi.registerCommand("bash-blocks", { description: "Gestisce i blocchi shell della sessione", handler: async (_args, ctx) => {
    const choices = known(ctx).flatMap(d => d.blocks.map(b => ({ d, b, label: `${d.sourceEntryId.slice(0, 8)} · ${b.index}: ${preview(b.code)}` })));
    if (!choices.length) { ctx.ui.notify("Nessun blocco shell trovato.", "info"); return; }
    const selected = await ctx.ui.select("Scegli blocco", choices.map(c => c.label)), choice = choices.find(c => c.label === selected); if (!choice) return;
    const selectedAction = await ctx.ui.select("Azione", ["Copia", "Apri terminale", "Esegui"]);
    if (selectedAction === "Copia") await action("copy", choice.b, choice.d, ctx);
    if (selectedAction === "Apri terminale") await action("open", choice.b, choice.d, ctx);
    if (selectedAction === "Esegui") await action("execute", choice.b, choice.d, ctx);
  } });
}