import { createServer } from "http";
import { readFileSync, existsSync, writeFileSync, statSync } from "fs";
import { appendFile, mkdir, readFile } from "fs/promises";

// ---------- 配置加载 ----------
function loadEnv() {
  const env: Record<string, string> = {};
  try {
    const raw = readFileSync(".env", "utf-8");
    for (const line of raw.split("\n")) {
      const t = line.trim();
      if (!t || t.startsWith("#")) continue;
      const idx = t.indexOf("=");
      if (idx === -1) continue;
      env[t.slice(0, idx).trim()] = t.slice(idx + 1).trim();
    }
  } catch {
    /* ignore */
  }
  return env;
}

const ENV = loadEnv();

// 运行时可变配置（可通过 /api/settings 修改并持久化）
function parseList(v: string | undefined): string[] {
  return (v || "").split(",").map((s) => s.trim()).filter(Boolean);
}
const DEFAULT_WHITELIST = ["d:\\"];

const config = {
  BASE_URL: process.env.BASE_URL || ENV.BASE_URL || "https://ark.cn-beijing.volces.com/api/coding/v3",
  API_KEY: process.env.API_KEY || ENV.API_KEY || "",
  MODEL: process.env.MODEL || ENV.MODEL || "",
  WORKSPACE: process.env.WORKSPACE || ENV.WORKSPACE || process.cwd(),
  CMD_APPROVE_LEVEL: (process.env.CMD_APPROVE_LEVEL || ENV.CMD_APPROVE_LEVEL || "medium").toLowerCase(),
  PORT: parseInt(process.env.PORT || ENV.PORT || "3000", 10),
  LOG_LEVEL: (process.env.LOG_LEVEL || ENV.LOG_LEVEL || "debug").toLowerCase(),
  TEMPERATURE: parseFloat(process.env.TEMPERATURE || ENV.TEMPERATURE || "0.3"),
  WHITELIST: parseList(process.env.WHITELIST || ENV.WHITELIST).length ? parseList(process.env.WHITELIST || ENV.WHITELIST) : DEFAULT_WHITELIST,
  BLACKLIST: parseList(process.env.BLACKLIST || ENV.BLACKLIST),
};

// 持久化配置到 .env（WORKSPACE 为内部默认值，不在设置页暴露）
const ENV_KEYS = ["BASE_URL", "API_KEY", "MODEL", "WORKSPACE", "CMD_APPROVE_LEVEL", "PORT", "LOG_LEVEL", "TEMPERATURE", "WHITELIST", "BLACKLIST"] as const;
function saveEnv() {
  const lines = ENV_KEYS.map((k) => `${k}=${String((config as any)[k])}`);
  const header = "# Mini AI Assistant 配置（可由设置页面修改）\n";
  try {
    writeFileSync(".env", header + lines.join("\n") + "\n", "utf-8");
  } catch (e) {
    console.error("保存配置失败:", (e as any).message);
  }
}

// ---------- 日志系统 ----------
const LOG_DIR = "logs";
const LEVELS: Record<string, number> = { debug: 0, info: 1, warn: 2, error: 3 };
function shouldLog(level: string): boolean {
  const lv = LEVELS[level] ?? 1;
  return lv >= (LEVELS[config.LOG_LEVEL] ?? 0);
}
async function log(level: string, category: string, data: any) {
  if (!shouldLog(level)) return;
  const ts = new Date().toISOString();
  const text = typeof s === "string" ? s : safeStringify(data);
  const line = `[${ts}] [${level.toUpperCase().padEnd(5)}] [${category}] ${text}\n`;
  try {
    if (!existsSync(LOG_DIR)) await mkdir(LOG_DIR, { recursive: true });
    await appendFile(`${LOG_DIR}/chat-${ts.slice(0, 10)}.log`, line, "utf-8");
  } catch {
    /* 忽略日志写入失败 */
  }
}
// 可安全序列化 BigInt 等类型
function safeStringify(s: any): string {
  try {
    return JSON.stringify(s, (_k, v) => (typeof v === "bigint" ? v.toString() : v), 0);
  } catch {
    try { return String(s); } catch { return "[unserializable]"; }
  }
}
// 安全截断
function clip(s: any, n = 600): string {
  const str = typeof s === "string" ? s : safeStringify(s);
  return str.length > n ? str.slice(0, n) + "…" : str;
}

// ---------- 依赖 ----------
import { readFile, writeFile, readdir, rename, unlink, stat, mkdir } from "fs/promises";
import { resolve, normalize, extname, sep } from "path";
import { read as xlsxRead, write as xlsxWrite, utils } from "xlsx";
import duckdb from "duckdb";

// ---------- 路径安全（白名单 + 黑名单，黑名单优先） ----------
// 判断 target 是否等于 base 或位于 base 的子目录下（跨平台）
function isWithin(base: string, target: string): boolean {
  const b = normalize(base).replace(/\\/g, "/").replace(/\/+$/, "");
  const t = normalize(target).replace(/\\/g, "/").replace(/\/+$/, "");
  return t === b || t.startsWith(b + "/");
}

// 白名单：允许访问的根目录（默认包含 D 盘根目录）；工作区始终隐式允许
// 黑名单：禁止访问（优先于白名单）；命中黑名单或其子目录则拒绝
function isAllowedPath(p: string): boolean {
  const abs = resolve(config.WORKSPACE, normalize(p));
  for (const b of config.BLACKLIST) {
    if (isWithin(b, abs)) return false;
  }
  const allowed = [...config.WHITELIST, config.WORKSPACE];
  for (const w of allowed) {
    if (isWithin(w, abs)) return true;
  }
  return false;
}

// ---------- 危险命令检测 ----------
const DANGEROUS_PATTERNS = [
  "rm -rf /", "rd /s", "format", "mkfs", "shutdown", "reboot", "poweroff",
  "dd if=", "fdisk", ":(){:|:&};:", "chmod -r", "del /s", "attrib",
];

function isDangerousCommand(cmd: string): boolean {
  const lower = cmd.toLowerCase();
  return DANGEROUS_PATTERNS.some((p) => lower.includes(p));
}

// ---------- DuckDB（Excel 数据处理） ----------
let duckDb: any = null;
function getDuck(): Promise<any> {
  return new Promise((resolve, reject) => {
    if (duckDb) return resolve(duckDb);
    duckDb = new duckdb.Database(":memory:", (err: any) => {
      if (err) return reject(err);
      resolve(duckDb);
    });
  });
}
function duckExec(db: any, sql: string): Promise<void> {
  return new Promise((resolve, reject) => db.exec(sql, (e: any) => (e ? reject(e) : resolve())));
}
function duckAll(db: any, sql: string): Promise<any[]> {
  return new Promise((resolve, reject) => db.all(sql, (e: any, rows: any) => (e ? reject(e) : resolve(rows || []))));
}
function sqlVal(v: any): string {
  if (v === null || v === undefined || v === "") return "NULL";
  if (typeof v === "number") return Number.isFinite(v) ? String(v) : "NULL";
  if (typeof v === "boolean") return v ? "TRUE" : "FALSE";
  if (v instanceof Date) return `'${v.toISOString().replace(/'/g, "''")}'`;
  return `'${String(v).replace(/'/g, "''")}'`;
}
function safeCol(c: string): string {
  const s = String(c).trim() || "col";
  return s.replace(/[^\w一-龥]/g, "_");
}

// ---------- 工具执行 ----------
async function execTool(name: string, args: any): Promise<{ ok: boolean; result: any }> {
  try {
    switch (name) {
      case "read_file": {
        if (!isAllowedPath(args.path)) throw new Error("路径越权");
        const content = await readFile(resolve(config.WORKSPACE, normalize(args.path)), "utf-8");
        return { ok: true, result: content.slice(0, 50000) };
      }
      case "write_file": {
        if (!isAllowedPath(args.path)) throw new Error("路径越权");
        const abs = resolve(config.WORKSPACE, normalize(args.path));
        await mkdir(resolve(abs, ".."), { recursive: true }).catch(() => {});
        await writeFile(abs, args.content ?? "", "utf-8");
        return { ok: true, result: `已写入 ${args.path} (${((args.content ?? "").length)} 字符)` };
      }
      case "list_directory": {
        const target = args.path ? normalize(args.path) : ".";
        if (!isAllowedPath(target)) throw new Error("路径越权");
        const entries = await readdir(resolve(config.WORKSPACE, target), { withFileTypes: true });
        return {
          ok: true,
          result: entries.map((e) => ({ name: e.name, type: e.isDirectory() ? "dir" : "file" })),
        };
      }
      case "copy_file": {
        if (!isAllowedPath(args.source) || !isAllowedPath(args.destination)) throw new Error("路径越权");
        const src = resolve(config.WORKSPACE, normalize(args.source));
        const dst = resolve(config.WORKSPACE, normalize(args.destination));
        const content = await readFile(src);
        await mkdir(resolve(dst, ".."), { recursive: true }).catch(() => {});
        await writeFile(dst, content);
        return { ok: true, result: `已复制 ${args.source} -> ${args.destination}` };
      }
      case "move_file": {
        if (!isAllowedPath(args.source) || !isAllowedPath(args.destination)) throw new Error("路径越权");
        const src = resolve(config.WORKSPACE, normalize(args.source));
        const dst = resolve(config.WORKSPACE, normalize(args.destination));
        await mkdir(resolve(dst, ".."), { recursive: true }).catch(() => {});
        await rename(src, dst);
        return { ok: true, result: `已移动 ${args.source} -> ${args.destination}` };
      }
      case "delete_file": {
        if (!isAllowedPath(args.path)) throw new Error("路径越权");
        await unlink(resolve(config.WORKSPACE, normalize(args.path)));
        return { ok: true, result: `已删除 ${args.path}` };
      }
      case "execute_command": {
        const { spawn } = await import("child_process");
        const out = await new Promise<{ success: boolean; output: string; error: string }>((resolve) => {
          const proc = spawn(args.command, { cwd: config.WORKSPACE, shell: true, env: { ...process.env } });
          let stdout = "", stderr = "";
          proc.stdout?.on("data", (d) => (stdout += d.toString()));
          proc.stderr?.on("data", (d) => (stderr += d.toString()));
          proc.on("close", (code) => resolve({ success: code === 0, output: stdout, error: stderr }));
          proc.on("error", (e) => resolve({ success: false, output: "", error: e.message }));
        });
        return { ok: out.success, result: out.output || out.error };
      }
      case "read_excel": {
        if (!isAllowedPath(args.path)) throw new Error("路径越权");
        const buf = await readFile(resolve(config.WORKSPACE, normalize(args.path)));
        const wb = xlsxRead(buf, { type: "buffer" });
        const sheetName = args.sheet || wb.SheetNames[0];
        const ws = wb.Sheets[sheetName];
        const rows = utils.sheet_to_json(ws, { header: 1 });
        const limit = args.limit || 200;
        return {
          ok: true,
          result: { totalRows: rows.length, columns: rows[0] || [], data: rows.slice(0, limit) },
        };
      }
      case "write_excel": {
        if (!isAllowedPath(args.path)) throw new Error("路径越权");
        const rows = (args.data || []).map((o: any) => Object.values(o));
        const headers = args.data?.length ? Object.keys(args.data[0]) : [];
        const ws = utils.aoa_to_sheet([headers, ...rows]);
        const wb = { Sheets: {}, SheetNames: [] } as any;
        wb.SheetNames.push(args.sheet || "Sheet1");
        wb.Sheets[wb.SheetNames[0]] = ws;
        await mkdir(resolve(config.WORKSPACE, normalize(args.path), ".."), { recursive: true }).catch(() => {});
        const out = xlsxWrite(wb, { type: "buffer", bookType: "xlsx" });
        writeFileSync(resolve(config.WORKSPACE, normalize(args.path)), out);
        return { ok: true, result: `已写入 Excel: ${args.path} (${rows.length} 行)` };
      }
      case "load_excel": {
        if (!isAllowedPath(args.path)) throw new Error("路径越权");
        const buf = await readFile(resolve(config.WORKSPACE, normalize(args.path)));
        const wb = xlsxRead(buf, { type: "buffer" });
        const sheetName = args.sheet || wb.SheetNames[0];
        const ws = wb.Sheets[sheetName];
        if (!ws) throw new Error("工作表不存在: " + sheetName);
        const rows: any[] = utils.sheet_to_json(ws, { defval: null });
        const table = args.table || "excel_data";
        const db = await getDuck();
        if (!rows.length) return { ok: true, result: `工作表 "${sheetName}" 无数据行` };
        const rawCols = Object.keys(rows[0]);
        const seen = new Set<string>();
        const cols = rawCols.map((c, i) => {
          let name = String(c).trim() === "" ? `col_${i}` : c;
          let n = name, k = 1;
          while (seen.has(n)) n = `${name}_${k++}`;
          seen.add(n);
          return n;
        });
        // 类型推断：整列均为数字 → DOUBLE，否则 VARCHAR
        const types: Record<string, string> = {};
        for (const c of cols) {
          let allNum = true, hasVal = false;
          for (const r of rows) {
            const v = r[c];
            if (v === null || v === undefined || v === "") continue;
            hasVal = true;
            if (typeof v !== "number") { allNum = false; break; }
          }
          types[c] = hasVal && allNum ? "DOUBLE" : "VARCHAR";
        }
        const colDefs = cols.map((c) => `"${c}" ${types[c]}`).join(", ");
        await duckExec(db, `CREATE OR REPLACE TABLE "${table}" (${colDefs})`);
        const MAX = 50000;
        const slice = rows.slice(0, MAX);
        const values = slice.map((r) => `(${cols.map((c) => sqlVal(r[c])).join(", ")})`).join(", ");
        if (values) await duckExec(db, `INSERT INTO "${table}" VALUES ${values}`);
        return {
          ok: true,
          result: {
            table, sheet: sheetName, rowCount: rows.length, truncated: rows.length > MAX,
            columns: cols.map((c) => ({ name: c, type: types[c] })),
            preview: slice.slice(0, 3),
            note: `已加载为 DuckDB 表 "${table}"，可用 query_duckdb 执行 SQL；列名用双引号引用，例如 SELECT * FROM "${table}" LIMIT 10`,
          },
        };
      }
      case "query_duckdb": {
        const sql = String(args.sql || "").trim();
        if (!sql) throw new Error("缺少 SQL 语句");
        const db = await getDuck();
        try {
          const rows = await duckAll(db, sql);
          const cols = rows.length ? Object.keys(rows[0]) : [];
          return { ok: true, result: { rowCount: rows.length, columns: cols, data: rows.slice(0, 200) } };
        } catch (e: any) {
          return { ok: false, result: "SQL 执行失败: " + e.message };
        }
      }
      default:
        return { ok: false, result: "未知工具: " + name };
    }
  } catch (e: any) {
    return { ok: false, result: "执行失败: " + e.message };
  }
}

// 需要审批的工具：delete_file 始终需要；execute_command 依据授权级别
const NEEDS_APPROVAL = new Set(["delete_file"]);

// 命令授权级别：high=每个命令都审核, medium=仅危险命令审核, low=全部不审核（默认 medium）
function needsApproval(name: string, args: any): boolean {
  if (NEEDS_APPROVAL.has(name)) return true;
  if (name === "execute_command") {
    const lv = config.CMD_APPROVE_LEVEL;
    if (lv === "high") return true;
    if (lv === "low") return false;
    return isDangerousCommand(String(args?.command || ""));
  }
  return false;
}

// ---------- 工具定义 (OpenAI function calling) ----------
const TOOL_DEFINITIONS = [
  { type: "function", function: { name: "read_file", description: "读取文本文件内容", parameters: { type: "object", properties: { path: { type: "string" } }, required: ["path"] } } },
  { type: "function", function: { name: "write_file", description: "写入文本内容到文件（覆盖）", parameters: { type: "object", properties: { path: { type: "string" }, content: { type: "string" } }, required: ["path", "content"] } } },
  { type: "function", function: { name: "list_directory", description: "列出目录内容", parameters: { type: "object", properties: { path: { type: "string" } } } } },
  { type: "function", function: { name: "copy_file", description: "复制文件或目录", parameters: { type: "object", properties: { source: { type: "string" }, destination: { type: "string" } }, required: ["source", "destination"] } } },
  { type: "function", function: { name: "move_file", description: "移动/重命名文件或目录", parameters: { type: "object", properties: { source: { type: "string" }, destination: { type: "string" } }, required: ["source", "destination"] } } },
  { type: "function", function: { name: "delete_file", description: "删除文件或空目录（需审批）", parameters: { type: "object", properties: { path: { type: "string" } }, required: ["path"] } } },
  { type: "function", function: { name: "execute_command", description: "执行 Shell 命令（需审批）", parameters: { type: "object", properties: { command: { type: "string" } }, required: ["command"] } } },
  { type: "function", function: { name: "read_excel", description: "读取 Excel 返回 JSON（默认前 200 行）", parameters: { type: "object", properties: { path: { type: "string" }, sheet: { type: "string" }, limit: { type: "number" } }, required: ["path"] } } },
  { type: "function", function: { name: "write_excel", description: "将 JSON 数组写入 Excel", parameters: { type: "object", properties: { path: { type: "string" }, data: { type: "array" }, sheet: { type: "string" } }, required: ["path", "data"] } } },
  { type: "function", function: { name: "load_excel", description: "将 Excel 文件加载进 DuckDB 内存表以便用 SQL 分析数据处理。返回表名、列名与类型、前几行预览。加载后即可用 query_duckdb 执行 SQL（筛选/聚合/排序/连接等）。", parameters: { type: "object", properties: { path: { type: "string", description: "Excel 文件路径" }, sheet: { type: "string", description: "工作表名，默认第一个" }, table: { type: "string", description: "目标表名，默认 excel_data" } }, required: ["path"] } } },
  { type: "function", function: { name: "query_duckdb", description: "在已加载的 DuckDB 表上执行 SQL 查询（SELECT 等）。列名用双引号引用，例如 SELECT \"姓名\", SUM(\"金额\") FROM excel_data GROUP BY \"姓名\"。", parameters: { type: "object", properties: { sql: { type: "string", description: "要执行的 SQL 语句" } }, required: ["sql"] } } },
];

// ---------- LLM 调用 (流式) ----------
interface ChatMsg { role: string; content: any; tool_calls?: any[]; name?: string; }

async function* streamLLM(messages: ChatMsg[]): AsyncGenerator<{ type: "token" | "toolcall" | "error"; content?: string; toolcall?: any }> {
  const url = config.BASE_URL.replace(/\/$/, "") + "/chat/completions";
  const body: any = {
    messages: messages.map((m) => ({
      role: m.role,
      content: m.content,
      ...(m.tool_calls ? { tool_calls: m.tool_calls } : {}),
      ...(m.name ? { name: m.name } : {}),
      ...(m.tool_call_id ? { tool_call_id: m.tool_call_id } : {}),
    })),
    tools: TOOL_DEFINITIONS,
    tool_choice: "auto",
    stream: true,
    temperature: config.TEMPERATURE,
  };
  if (config.MODEL) body.model = config.MODEL;

  let resp: any;
  try {
    resp = await fetch(url, {
      method: "POST",
      headers: { "Content-Type": "application/json", Authorization: `Bearer ${config.API_KEY}` },
      body: JSON.stringify(body),
    });
  } catch (e: any) {
    yield { type: "error", content: "无法连接模型服务: " + e.message };
    return;
  }
  if (!resp.ok) {
    const txt = await resp.text().catch(() => "");
    yield { type: "error", content: `模型返回错误 (${resp.status}): ${txt.slice(0, 300)}` };
    return;
  }

  const reader = resp.body.getReader();
  const decoder = new TextDecoder();
  let buffer = "";
  let toolAcc: any = null;

  while (true) {
    const { done, value } = await reader.read();
    if (done) break;
    buffer += decoder.decode(value, { stream: true });
    const lines = buffer.split("\n");
    buffer = lines.pop() || "";
    for (const line of lines) {
      const t = line.trim();
      if (!t.startsWith("data:")) continue;
      const data = t.slice(5).trim();
      if (data === "[DONE]") continue;
      let json: any;
      try { json = JSON.parse(data); } catch { continue; }
      const delta = json.choices?.[0]?.delta || {};
      if (delta.content) yield { type: "token", content: delta.content };
      if (delta.tool_calls) {
        for (const tc of delta.tool_calls) {
          if (!toolAcc) toolAcc = { id: "", type: "function", function: { name: "", arguments: "" } };
          if (tc.id) toolAcc.id = tc.id;
          if (tc.function?.name) toolAcc.function.name = tc.function.name;
          if (tc.function?.arguments) toolAcc.function.arguments += tc.function.arguments;
        }
      }
    }
  }
  if (toolAcc) {
    if (!toolAcc.id) toolAcc.id = "call_" + Date.now() + "_" + Math.random().toString(36).slice(2, 7);
    yield { type: "toolcall", toolcall: toolAcc };
  }
}

// ---------- SSE 辅助 ----------
function sseInit(res: any) {
  res.writeHead(200, {
    "Content-Type": "text/event-stream",
    "Cache-Control": "no-cache",
    Connection: "keep-alive",
    "Access-Control-Allow-Origin": "*",
  });
}
function sseSend(res: any, obj: any) {
  res.write(`data: ${JSON.stringify(obj)}\n\n`);
}

// ---------- 对话处理（带工具循环） ----------
let pendingApproval: { messages: ChatMsg[]; toolCall: any } | null = null;

// 系统提示：定义助手身份
const SYSTEM_PROMPT = "你是小鑫，一个专为冯雅鑫定制的本地 AI 助手，可以帮助处理文件读写、Excel、列出目录、执行命令（需审批）等任务。分析 Excel 数据时，优先用 load_excel 把文件加载进 DuckDB，再用 query_duckdb 执行 SQL 完成筛选、聚合、统计、排序等；处理大量数据时不要逐行读取。请用简体中文友好、简洁地回答。";
function withSystem(msgs: ChatMsg[]): ChatMsg[] {
  if (msgs.length && msgs[0].role === "system") return msgs;
  return [{ role: "system", content: SYSTEM_PROMPT }, ...msgs];
}

async function runConversation(initialMessages: ChatMsg[], res: any, fromApproval = false) {
  sseInit(res);
  let messages = withSystem(initialMessages);

  // 日志：记录用户/工具输入
  log("debug", "conversation_start", {
    fromApproval,
    messages: messages.map((m) => ({ role: m.role, content: clip(m.content, 800) })),
  });

  // 工具循环（最多 5 轮避免死循环）
  for (let round = 0; round < 5; round++) {
    const gen = streamLLM(messages);
    let content = "";
    let toolCall: any = null;
    let errored = false;
    for await (const ev of gen) {
      if (ev.type === "token") {
        content += ev.content;
        sseSend(res, { type: "token", content: ev.content });
      } else if (ev.type === "toolcall") {
        toolCall = ev.toolcall;
      } else if (ev.type === "error") {
        errored = true;
        log("error", "llm_error", ev.content);
        sseSend(res, { type: "token", content: "\n\n⚠️ " + ev.content });
      }
    }

    if (errored) { sseSend(res, { type: "done" }); res.end(); return; }

    // 需要工具调用
    if (toolCall && toolCall.function?.name) {
      const name = toolCall.function.name;
      let args = {};
      try { args = toolCall.function.arguments ? JSON.parse(toolCall.function.arguments) : {}; } catch { args = {}; }

      if (needsApproval(name, args)) {
        // 请求审批，保存上下文等待 /api/approve
        log("info", "approval_required", { tool: name, args });
        pendingApproval = {
          messages: [
            ...messages,
            { role: "assistant", content: content || null, tool_calls: [toolCall] },
          ],
          toolCall,
        };
        sseSend(res, {
          type: "approval_required",
          tool_call_id: toolCall.id,
          tool: name,
          args,
          command: name === "execute_command" ? args.command : `${name}(${JSON.stringify(args)})`,
        });
        sseSend(res, { type: "done" });
        res.end();
        return;
      }

      // 直接执行
      log("debug", "tool_call", { name, args });
      const exec = await execTool(name, args);
      log("debug", "tool_result", { name, ok: exec.ok, result: clip(exec.result, 800) });
      messages = [
        ...messages,
        { role: "assistant", content: content || null, tool_calls: [toolCall] },
        { role: "tool", name, content: safeStringify(exec), tool_call_id: toolCall.id },
      ];
      // 继续循环，让模型基于工具结果生成最终回复
      continue;
    }

    // 无工具调用，正常结束
    log("debug", "assistant", clip(content, 2000));
    sseSend(res, { type: "done" });
    res.end();
    return;
  }

  sseSend(res, { type: "token", content: "\n[达到最大工具调用轮数]" });
  sseSend(res, { type: "done" });
  res.end();
}

// ---------- 静态文件服务（生产构建） ----------
const DIST = resolve("dist");
const MIME: Record<string, string> = {
  ".html": "text/html; charset=utf-8",
  ".js": "text/javascript",
  ".css": "text/css",
  ".json": "application/json",
  ".svg": "image/svg+xml",
  ".png": "image/png",
  ".jpg": "image/jpeg",
  ".jpeg": "image/jpeg",
  ".gif": "image/gif",
  ".ico": "image/x-icon",
  ".woff": "font/woff",
  ".woff2": "font/woff2",
  ".ttf": "font/ttf",
  ".map": "application/json",
};

async function serveStatic(res: any, url: URL): Promise<boolean> {
  if (!existsSync(DIST) || !statSync(DIST).isDirectory()) return false;
  let pathname = decodeURIComponent(url.pathname);
  if (pathname === "/") pathname = "/index.html";
  const safePath = resolve(DIST, "." + pathname);
  if (safePath !== DIST && !safePath.startsWith(DIST + sep)) {
    res.writeHead(403, { "Content-Type": "text/plain; charset=utf-8" });
    res.end("Forbidden");
    return true;
  }
  try {
    if (existsSync(safePath) && statSync(safePath).isFile()) {
      const ext = extname(safePath).toLowerCase();
      res.writeHead(200, { "Content-Type": MIME[ext] || "application/octet-stream" });
      res.end(await readFile(safePath));
      return true;
    }
    const idx = resolve(DIST, "index.html");
    if (existsSync(idx)) {
      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
      res.end(await readFile(idx));
      return true;
    }
  } catch {
    res.writeHead(500, { "Content-Type": "text/plain; charset=utf-8" });
    res.end("Internal error");
    return true;
  }
  return false;
}

// ---------- HTTP 服务 ----------
const server = createServer(async (req, res) => {
  const url = new URL(req.url || "", `http://localhost:${config.PORT}`);
  res.setHeader("Access-Control-Allow-Origin", "*");
  res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
  res.setHeader("Access-Control-Allow-Headers", "Content-Type");

  if (req.method === "OPTIONS") { res.writeHead(204); res.end(); return; }

  if (req.method === "GET" && !url.pathname.startsWith("/api")) {
    if (await serveStatic(res, url)) return;
  }

  if (req.method === "GET" && url.pathname === "/") {
    res.writeHead(200, { "Content-Type": "application/json" });
    res.end(JSON.stringify({ status: "ok", model: config.MODEL || "default", workspace: config.WORKSPACE }));
    return;
  }

  // 读取设置
  if (req.method === "GET" && url.pathname === "/api/settings") {
    res.writeHead(200, { "Content-Type": "application/json" });
    res.end(JSON.stringify({
      BASE_URL: config.BASE_URL,
      API_KEY: config.API_KEY ? "******" + config.API_KEY.slice(-4) : "",
      MODEL: config.MODEL,
      CMD_APPROVE_LEVEL: config.CMD_APPROVE_LEVEL,
      LOG_LEVEL: config.LOG_LEVEL,
      TEMPERATURE: config.TEMPERATURE,
      WHITELIST: config.WHITELIST,
      BLACKLIST: config.BLACKLIST,
    }));
    return;
  }

  // 保存设置
  if (req.method === "POST" && url.pathname === "/api/settings") {
    let body = "";
    for await (const c of req) body += c;
    let payload: any;
    try { payload = JSON.parse(body); } catch { res.writeHead(400); res.end("bad json"); return; }
    if (typeof payload.BASE_URL === "string") config.BASE_URL = payload.BASE_URL;
    if (typeof payload.API_KEY === "string" && !payload.API_KEY.startsWith("******")) config.API_KEY = payload.API_KEY;
    if (typeof payload.MODEL === "string") config.MODEL = payload.MODEL;
    if (payload.CMD_APPROVE_LEVEL === "high" || payload.CMD_APPROVE_LEVEL === "medium" || payload.CMD_APPROVE_LEVEL === "low") {
      config.CMD_APPROVE_LEVEL = payload.CMD_APPROVE_LEVEL;
    }
    if (typeof payload.LOG_LEVEL === "string") config.LOG_LEVEL = payload.LOG_LEVEL.toLowerCase();
    if (typeof payload.TEMPERATURE === "number") config.TEMPERATURE = payload.TEMPERATURE;
    if (payload.WHITELIST !== undefined) {
      const wl = Array.isArray(payload.WHITELIST) ? payload.WHITELIST : String(payload.WHITELIST).split(",");
      config.WHITELIST = wl.map((s: string) => String(s).trim()).filter(Boolean);
    }
    if (payload.BLACKLIST !== undefined) {
      const bl = Array.isArray(payload.BLACKLIST) ? payload.BLACKLIST : String(payload.BLACKLIST).split(",");
      config.BLACKLIST = bl.map((s: string) => String(s).trim()).filter(Boolean);
    }
    saveEnv();
    log("info", "settings_updated", { CMD_APPROVE_LEVEL: config.CMD_APPROVE_LEVEL, MODEL: config.MODEL, LOG_LEVEL: config.LOG_LEVEL, WHITELIST: config.WHITELIST, BLACKLIST: config.BLACKLIST });
    res.writeHead(200, { "Content-Type": "application/json" });
    res.end(JSON.stringify({ ok: true }));
    return;
  }

  // 聊天：流式 SSE
  if (req.method === "POST" && url.pathname === "/api/chat") {
    let body = "";
    for await (const c of req) body += c;
    let payload: any;
    try { payload = JSON.parse(body); } catch { res.writeHead(400); res.end("bad json"); return; }
    const history: ChatMsg[] = (payload.messages || []).map((m: any) => ({
      role: m.role,
      content: m.content,
    }));
    await runConversation(history, res);
    return;
  }

  // 审批反馈：流式 SSE（继续对话）
  if (req.method === "POST" && url.pathname === "/api/approve") {
    let body = "";
    for await (const c of req) body += c;
    let payload: any;
    try { payload = JSON.parse(body); } catch { res.writeHead(400); res.end("bad json"); return; }
    const approved = !!payload.approved;

    if (!pendingApproval) {
      res.writeHead(200, { "Content-Type": "application/json" });
      res.end(JSON.stringify({ error: "无待审批操作" }));
      return;
    }
    const { messages, toolCall } = pendingApproval;
    pendingApproval = null;
    const name = toolCall.function.name;
    let args = {};
    try { args = toolCall.function.arguments ? JSON.parse(toolCall.function.arguments) : {}; } catch {}

    let exec;
    if (approved) {
      log("info", "approval_granted", { tool: name, args });
      exec = await execTool(name, args);
    } else {
      log("info", "approval_denied", { tool: name, args });
      exec = { ok: false, result: "用户已拒绝该操作" };
    }
    const nextMessages: ChatMsg[] = [
      ...messages,
      { role: "tool", name, content: safeStringify(exec), tool_call_id: toolCall.id },
    ];
    await runConversation(nextMessages, res, true);
    return;
  }

  res.writeHead(404);
  res.end("Not Found");
});

server.listen(config.PORT, () => {
  console.log(`Mini AI Assistant 后端已启动`);
  console.log(`  API:   http://127.0.0.1:${config.PORT}`);
  console.log(`  模型:  ${config.BASE_URL}`);
  console.log(`  工作区: ${config.WORKSPACE}`);
  console.log(`  日志级别: ${config.LOG_LEVEL}  → logs/`);
});