/**
 * pi-perf — Performance Profiling
 * Time commands, profile Node.js scripts, detect slow operations.
 *
 * /perf time <command>      → time a shell command
 * /perf profile <script>    → profile a Node.js script (--prof)
 * /perf bench <command> [n] → run N times, report avg/min/max
 * /perf history             → past measurements
 */
import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
import { Type } from "@sinclair/typebox";
import { existsSync, readFileSync, appendFileSync, mkdirSync } from "node:fs";
import { join } from "node:path";
import { homedir } from "node:os";
import { execSync } from "node:child_process";

const DIR = join(homedir(), ".pi", "perf");
const LOG = join(DIR, "history.jsonl");
const RST = "\x1b[0m", B = "\x1b[1m", D = "\x1b[2m";
const G = "\x1b[32m", R = "\x1b[31m", Y = "\x1b[33m", C = "\x1b[36m";

function ensureDir() { if (!existsSync(DIR)) mkdirSync(DIR, { recursive: true }); }

function logEntry(entry: Record<string, any>) {
  ensureDir();
  appendFileSync(LOG, JSON.stringify({ ts: new Date().toISOString(), ...entry }) + "\n");
}

function timeCmd(cmd: string): { ms: number; stdout: string; stderr: string; exitCode: number } {
  const start = performance.now();
  try {
    const stdout = execSync(cmd, { encoding: "utf-8", timeout: 120000, stdio: ["pipe", "pipe", "pipe"] });
    return { ms: Math.round(performance.now() - start), stdout: stdout.trim(), stderr: "", exitCode: 0 };
  } catch (e: any) {
    return { ms: Math.round(performance.now() - start), stdout: (e.stdout || "").trim(), stderr: (e.stderr || "").trim(), exitCode: e.status || 1 };
  }
}

function formatMs(ms: number): string {
  if (ms < 1000) return ms + "ms";
  if (ms < 60000) return (ms / 1000).toFixed(2) + "s";
  return (ms / 60000).toFixed(1) + "min";
}

function speedColor(ms: number): string {
  return ms < 1000 ? G : ms < 5000 ? Y : R;
}

export default function (pi: ExtensionAPI) {
  ensureDir();

  pi.registerCommand("perf", {
    description: "Performance: /perf time|bench|profile|history",
    handler: async (args, ctx) => {
      const parts = (args || "").trim().match(/(?:[^\s"]+|"[^"]*")+/g) || [];
      const cmd = (parts[0] || "help").toLowerCase();

      if (cmd === "time") {
        const shellCmd = parts.slice(1).join(" ").replace(/^"|"$/g, "");
        if (!shellCmd) return `${Y}Usage:${RST} /perf time <command>`;
        const result = timeCmd(shellCmd);
        const sc = speedColor(result.ms);
        logEntry({ type: "time", cmd: shellCmd, ms: result.ms, exit: result.exitCode });
        let out = `${B}${C}⏱ Time${RST}\n\n`;
        out += `  Command: ${D}${shellCmd}${RST}\n`;
        out += `  Time:    ${sc}${B}${formatMs(result.ms)}${RST}\n`;
        out += `  Exit:    ${result.exitCode === 0 ? G + "0" : R + result.exitCode}${RST}\n`;
        if (result.stdout) out += `\n  ${D}${result.stdout.split("\n").slice(0, 5).join("\n  ")}${RST}\n`;
        return out;
      }

      if (cmd === "bench") {
        const shellCmd = parts.slice(1, -1).join(" ").replace(/^"|"$/g, "") || parts[1] || "";
        const n = parseInt(parts[parts.length - 1]) || 5;
        const actualCmd = isNaN(parseInt(parts[parts.length - 1])) ? parts.slice(1).join(" ").replace(/^"|"$/g, "") : shellCmd;
        if (!actualCmd) return `${Y}Usage:${RST} /perf bench <command> [iterations]\nExample: /perf bench "node -e 'console.log(1)'" 10`;
        
        const times: number[] = [];
        let failures = 0;
        for (let i = 0; i < n; i++) {
          const r = timeCmd(actualCmd);
          times.push(r.ms);
          if (r.exitCode !== 0) failures++;
        }
        
        const sorted = [...times].sort((a, b) => a - b);
        const avg = Math.round(times.reduce((s, t) => s + t, 0) / n);
        const min = sorted[0];
        const max = sorted[sorted.length - 1];
        const median = sorted[Math.floor(n / 2)];
        const p95 = sorted[Math.floor(n * 0.95)];

        logEntry({ type: "bench", cmd: actualCmd, n, avg, min, max, median, failures });

        let out = `${B}${C}📊 Benchmark${RST} (${n} runs)\n\n`;
        out += `  Command: ${D}${actualCmd}${RST}\n\n`;
        out += `  Avg:    ${speedColor(avg)}${B}${formatMs(avg)}${RST}\n`;
        out += `  Min:    ${speedColor(min)}${formatMs(min)}${RST}\n`;
        out += `  Max:    ${speedColor(max)}${formatMs(max)}${RST}\n`;
        out += `  Median: ${speedColor(median)}${formatMs(median)}${RST}\n`;
        if (n >= 20) out += `  P95:    ${speedColor(p95)}${formatMs(p95)}${RST}\n`;
        if (failures) out += `  ${R}Failures: ${failures}/${n}${RST}\n`;
        out += `\n  ${D}Distribution: ${times.map(t => formatMs(t)).join(", ")}${RST}`;
        return out;
      }

      if (cmd === "profile") {
        const script = parts[1];
        if (!script) return `${Y}Usage:${RST} /perf profile <script.js>\n  Runs node --prof and processes the output.`;
        const result = timeCmd(`node --prof "${script}"`);
        logEntry({ type: "profile", script, ms: result.ms });
        return `${B}${C}📊 Profile${RST}\n\n  Script: ${script}\n  Time: ${speedColor(result.ms)}${formatMs(result.ms)}${RST}\n  ${D}Tick files written to cwd. Process with: node --prof-process isolate-*.log${RST}`;
      }

      if (cmd === "history") {
        if (!existsSync(LOG)) return `${Y}No performance history yet.${RST}`;
        const lines = readFileSync(LOG, "utf-8").trim().split("\n").filter(Boolean);
        const entries = lines.slice(-20).map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
        let out = `${B}${C}📈 Performance History${RST} (last ${entries.length})\n\n`;
        for (const e of entries) {
          const sc = speedColor(e.ms || e.avg || 0);
          const time = (e.ts || "").slice(11, 19);
          if (e.type === "bench") {
            out += `  ${D}${time}${RST} bench ${sc}avg=${formatMs(e.avg)}${RST} min=${formatMs(e.min)} max=${formatMs(e.max)} (${e.n}x)\n`;
          } else {
            out += `  ${D}${time}${RST} ${e.type} ${sc}${formatMs(e.ms)}${RST} ${D}${(e.cmd || e.script || "").slice(0, 50)}${RST}\n`;
          }
        }
        return out;
      }

      return `${B}${C}⏱ Performance${RST}\n  /perf time <cmd>       — time a command\n  /perf bench <cmd> [n]  — benchmark N runs\n  /perf profile <script> — Node.js profiling\n  /perf history          — past measurements`;
    }
  });

  pi.registerTool({
    name: "perf_time",
    description: "Time a shell command. Returns milliseconds elapsed, stdout, exit code.",
    parameters: Type.Object({ command: Type.String({ description: "Shell command to time" }) }),
    execute: async (p) => {
      const r = timeCmd(p.command);
      logEntry({ type: "time", cmd: p.command, ms: r.ms, exit: r.exitCode });
      return JSON.stringify(r, null, 2);
    }
  });

  pi.registerTool({
    name: "perf_bench",
    description: "Benchmark a command over N iterations. Returns avg/min/max/median times.",
    parameters: Type.Object({
      command: Type.String({ description: "Shell command to benchmark" }),
      iterations: Type.Optional(Type.Number({ description: "Number of runs (default: 5)" })),
    }),
    execute: async (p) => {
      const n = p.iterations || 5;
      const times: number[] = [];
      for (let i = 0; i < n; i++) times.push(timeCmd(p.command).ms);
      const sorted = [...times].sort((a, b) => a - b);
      const avg = Math.round(times.reduce((s, t) => s + t, 0) / n);
      logEntry({ type: "bench", cmd: p.command, n, avg, min: sorted[0], max: sorted[n - 1] });
      return JSON.stringify({ iterations: n, avg, min: sorted[0], max: sorted[n - 1], median: sorted[Math.floor(n / 2)], times });
    }
  });
}