// edit-mode.js -- 文件管理模式（重构版）
// 保留: 文件树渲染、文档修改追踪、外部变更处理、快捷键、拖拽引用
// 移除: Monaco 编辑器、标签页、Agent 面板

import { $, escapeHtml, showToast, dedupePendingFiles } from './utils.js';
import { api } from './api.js';
import { state } from './state.js';
import {
  readTextFile, readBinaryFile, writeTextFile, listDir, getFileUrl,
  pickFolder, watchDir, onFileChanged, copyExternalFile, writeFromBuffer, deleteFile
} from './electron-api.js';
import {
  renderPersistentToolCalls, renderToolCallRow, formatDuration, getToolCallsTotalDuration,
} from './toolcalls.js';
import { renderDocTree, setDocTreeDeps } from './doc-tree.js';
import { openFilePreview, closeFilePreview } from './file-preview.js';
import { setDocModifications } from './doc-mod-panel.js';

// ===== DOM 引用 =====
const modeEditBtn = $("modeEditBtn");
const modeChatBtn = $("modeChatBtn");
const modeCronBtn = $("modeCronBtn");
const chatPanel = $("chatPanel");
const sessionListWrap = $("sessionListWrap");
const docTreeWrap = $("docTreeWrap");
const cronListWrap = $("cronListWrap");
const docTree = $("docTree");
const sidebarHint = document.querySelector(".sidebar-hint");

// ===== 文档修改状态 =====
let docModifications = {};
let currentTaskModifications = [];
let _externalChanges = {};
let _fsChangeTimer = null;
let _fsApplying = false;

// 预览相关
const IMG_EXTS = new Set(['.png', '.jpg', '.jpeg', '.gif', '.bmp', '.webp', '.ico']);
const ALL_TEXT_EXTS = new Set(['.txt', '.json', '.md', '.py', '.js', '.ts', '.css', '.xml', '.yaml', '.yml',
  '.toml', '.csv', '.log', '.env', '.ini', '.cfg', '.sh', '.bat', '.ps1', '.sql', '.r', '.go', '.rs',
  '.rb', '.php', '.swift', '.kt', '.scala', '.cpp', '.c', '.h', '.java', '.m', '.html', '.htm', '.svg']);

function isSupportedFile(name) {
  const ext = (name || '').toLowerCase();
  const dot = ext.lastIndexOf('.');
  if (dot < 0) return false;
  const e = ext.substring(dot);
  return IMG_EXTS.has(e) || e === '.svg' || ALL_TEXT_EXTS.has(e) || e === '.pdf' || e === '.pptx'
    || e === '.xlsx' || e === '.xls' || e === '.docx' || e === '.doc' || e === '.ppt';
}

function isPreviewableImage(name) {
  const ext = (name || '').toLowerCase();
  const dot = ext.lastIndexOf('.');
  return dot >= 0 && IMG_EXTS.has(ext.substring(dot));
}

function isPreviewableHtml(name) {
  return (name || '').toLowerCase().endsWith('.html') || (name || '').toLowerCase().endsWith('.htm');
}

/** 二进制表格（XLSX/XLS）：由后端 /api/table/text 提取为 TSV 后按列着色预览 */
function isPreviewableTable(name) {
  const ext = (name || '').toLowerCase();
  return ext.endsWith('.xlsx') || ext.endsWith('.xls');
}

const BINARY_EXTS = new Set([
  '.exe','.dll','.so','.dylib','.bin','.dat','.zip','.rar','.7z','.tar','.gz','.bz2','.xz',
  '.png','.jpg','.jpeg','.gif','.bmp','.ico','.webp','.tiff','.tif','.psd','.ai','.eps',
  '.mp3','.wav','.flac','.ogg','.m4a','.aac','.wma','.aiff',
  '.mp4','.avi','.mkv','.mov','.wmv','.flv','.webm','.m4v',
  '.pdf','.doc','.docx','.xls','.xlsx','.ppt','.pptx',
  '.ttf','.otf','.woff','.woff2','.eot',
  '.db','.sqlite','.sqlite3','.mdb',
  '.iso','.dmg','.img','.vmdk',
  '.class','.jar','.war','.pyc','.pyo','.pyd',
  '.o','.obj','.lib','.a','.wasm',
]);
function isBinaryFile(name) {
  const lower = (name || '').toLowerCase();
  const dot = lower.lastIndexOf('.');
  return dot >= 0 && BINARY_EXTS.has(lower.substring(dot));
}

// ===== 模式切换 =====
let _modeSwitchCooldown = false;

export function switchToMode(mode) {
  // 防连点：短时间内禁止重复切换
  if (_modeSwitchCooldown) return;
  _modeSwitchCooldown = true;
  setTimeout(() => { _modeSwitchCooldown = false; }, 300);

  // Agent 运行中禁止切换到 cron/edit 模式，避免 chat 区域被替换导致工具调用和思考历史消失
  if (state.sending && mode !== "chat") {
    showToast("Agent 正在运行中，请等待完成后再切换模式");
    return;
  }
  state.mode = mode;
  if (mode === "edit") {
    state.editMode = true;
    modeChatBtn?.classList.remove("active");
    modeEditBtn?.classList.add("active");
    modeCronBtn?.classList.remove("active");
    // 编辑模式只影响左侧栏：显示文件树，隐藏会话列表与定时任务列表；聊天区域保持不变
    sessionListWrap?.classList.add("mode-hidden");
    cronListWrap?.classList.add("mode-hidden");
    if (sidebarHint) sidebarHint.classList.add("mode-hidden");
    docTreeWrap?.classList.remove("mode-hidden");
    _onLeaveCron();
  } else if (mode === "cron") {
    state.editMode = false;
    modeChatBtn?.classList.remove("active");
    modeEditBtn?.classList.remove("active");
    modeCronBtn?.classList.add("active");
    chatPanel?.classList.remove("mode-hidden");
    sessionListWrap?.classList.add("mode-hidden");
    docTreeWrap?.classList.add("mode-hidden");
    if (sidebarHint) sidebarHint.classList.add("mode-hidden");
    cronListWrap?.classList.remove("mode-hidden");
    closeFilePreview();
    _onEnterCron();
  } else {
    // chat 模式
    state.editMode = false;
    modeChatBtn?.classList.add("active");
    modeEditBtn?.classList.remove("active");
    modeCronBtn?.classList.remove("active");
    chatPanel?.classList.remove("mode-hidden");
    sessionListWrap?.classList.remove("mode-hidden");
    if (sidebarHint) sidebarHint.classList.remove("mode-hidden");
    docTreeWrap?.classList.add("mode-hidden");
    cronListWrap?.classList.add("mode-hidden");
    closeFilePreview();
    _onLeaveCron();
  }
}

// ===== Cron 模式进入/离开钩子（由 app.js 注入，避免循环依赖） =====
let _onEnterCronFn = null;
let _onLeaveCronFn = null;
export function setCronModeHooks({ onEnter, onLeave } = {}) {
  _onEnterCronFn = onEnter || null;
  _onLeaveCronFn = onLeave || null;
}
function _onEnterCron() {
  try { _onEnterCronFn && _onEnterCronFn(); } catch { /* ignore */ }
}
function _onLeaveCron() {
  try { _onLeaveCronFn && _onLeaveCronFn(); } catch { /* ignore */ }
}

// ===== 打开文件夹 =====
export async function autoOpenWorkspace() {
  if (!window.electronAPI) return;
  try {
    const data = await api("/api/workspace");
    const current = data.current || "";
    const defaultPath = data.default || "";
    const rootPath = current || defaultPath;
    if (rootPath) {
      await openFolder(rootPath);
    }
  } catch { /* ignore */ }
}

export async function openFolder(folderPath) {
  try {
    let rootPath = (typeof folderPath === "string" && folderPath) ? folderPath : null;
    if (!rootPath) {
      rootPath = await pickFolder();
    }
    if (!rootPath) return;

    // 先校验目录存在并列出文件；文件夹被删除/不可访问时给出明确提示，避免把失效路径写入状态
    let listRes;
    try {
      listRes = await listDir(rootPath, 10);
    } catch (e) {
      showToast("打开文件夹失败: " + (e.message || e));
      return;
    }

    state._docRootPath = rootPath;
    state._docRootName = rootPath.split(/[/\\]/).pop() || rootPath;

    try {
      const { addRecentFolder } = await import('../app.js');
      await addRecentFolder(rootPath);
    } catch {}

    if (!state._docTreeFolders) state._docTreeFolders = {};
    state._docTreeFolders[state._docRootName] = true;

    const files = listRes.files || [];
    const supportedFiles = files.filter((f) => !f.is_dir && isSupportedFile(f.name));
    // 去重：按 path 去重
    const seen = new Set();
    const uniqueFiles = [];
    for (const f of supportedFiles) {
      if (seen.has(f.path)) continue;
      seen.add(f.path);
      // 规范化路径：去掉 rootPath 前缀，确保相对路径，统一用 /
      let relPath = f.path.replace(/\\/g, "/");
      const normalizedRoot = rootPath.replace(/\\/g, "/").replace(/\/$/, "");
      if (relPath.startsWith(normalizedRoot + "/")) {
        relPath = relPath.substring(normalizedRoot.length + 1);
      }
      uniqueFiles.push({ ...f, path: relPath });
    }
    state.docFiles = [];
    state.docOpenTabs = [];
    docModifications = {};
    currentTaskModifications = [];
    _externalChanges = {};

    for (const f of uniqueFiles) {
      state.docFiles.push({ path: f.path, name: f.name, status: "original", size: f.size });
    }

    renderDocTree();
    renderDocTabs && renderDocTabs();

    if (state.docFiles.length > 0) {
      state.activeDocFile = state.docFiles[0].path;
      state.activeDocTab = state.docFiles[0].path;
      state.docOpenTabs = [{ path: state.docFiles[0].path, name: state.docFiles[0].name, modified: false }];
      renderDocTabs && renderDocTabs();
    }

    if (window.electronAPI) {
      watchDir(rootPath).then(() => {
        onFileChanged(handleFsChange);
      }).catch(() => {});
    }
  } catch (e) {
    showToast("打开文件夹失败: " + (e.message || e));
  }
}

export function showOpenButtons() {
  const snapDir = _snapDir();
  if (snapDir) {
    try { deleteFile(snapDir, ''); } catch {}
  }
  state._docRootPath = null;
  state._docRootName = null;
  state.docFiles = [];
  state.docOpenTabs = [];
  docModifications = {};
  currentTaskModifications = [];
  _externalChanges = {};
  _snapshots = [];
  _turnCounter = 0;
  _acceptedBaselines = {};
  renderDocTree();
  renderDocTabs && renderDocTabs();
}

// ===== 标签页（保留用于打开状态追踪） =====
export function renderDocTabs() {
  // 简化为无标签栏 - 文件点击直接预览
}

// ===== 文件点击预览 =====
export async function loadDocContent(filePath) {
  if (!state._docRootPath) return;
  const fileName = filePath.split(/[/\\]/).pop() || filePath;
  const status = docModifications[filePath]?.type || "";

  try {
    if (isPreviewableImage(fileName)) {
      const res = await readBinaryFile(filePath, state._docRootPath);
      if (res && res.status === 'ok' && res.data) {
        const dataUrl = `data:${res.mime || 'image/png'};base64,${res.data}`;
        const { showImagePreview } = await import('./toolcalls.js');
        showImagePreview(dataUrl);
      }
    } else if (isPreviewableHtml(fileName)) {
      const res = await readTextFile(filePath, state._docRootPath);
      if (res && res.status === 'ok') {
        openFilePreview(filePath, fileName, res.content || '',
          { status, onDownload: () => downloadFile(filePath, fileName) });
      }
    } else if (isPreviewableTable(fileName)) {
      // XLSX/XLS：后端提取为 TSV 文本，走与 CSV/TSV 一致的按列着色预览
      const absPath = (/^[A-Za-z]:[\\/]/.test(filePath) || filePath.startsWith('/') || filePath.startsWith('\\'))
        ? filePath
        : state._docRootPath.replace(/[\\/]+$/, '') + '/' + filePath.replace(/^[\\/]+/, '');
      try {
        const tsv = await api('/api/table/text?path=' + encodeURIComponent(absPath));
        openFilePreview(absPath, fileName, (tsv && tsv.content) || '',
          { status, onDownload: () => downloadFile(absPath, fileName) });
      } catch (e) {
        openFilePreview(absPath, fileName, '(加载失败: ' + (e.message || e) + ')',
          { status, onDownload: () => downloadFile(absPath, fileName) });
      }
    } else if (isBinaryFile(fileName)) {
      showToast('二进制文件不支持在线查看', 'warning');
    } else {
      const res = await readTextFile(filePath, state._docRootPath);
      if (res && res.status === 'ok') {
        openFilePreview(filePath, fileName, res.content || '',
          { status, onDownload: () => downloadFile(filePath, fileName) });
      } else {
        openFilePreview(filePath, fileName, '(无法读取文件)',
          { status, onDownload: () => downloadFile(filePath, fileName) });
      }
    }
  } catch {
    openFilePreview(filePath, fileName, '(加载失败)',
      { status, onDownload: () => downloadFile(filePath, fileName) });
  }
}

/** 以纯文本模式打开文件（供右键"文本编辑"使用） */
export async function openFileAsText(filePath) {
  if (!state._docRootPath) return;
  const fileName = filePath.split(/[/\\]/).pop() || filePath;
  if (isBinaryFile(fileName)) {
    showToast('二进制文件不支持在线查看', 'warning');
    return;
  }
  const status = docModifications[filePath]?.type || "";
  try {
    const res = await readTextFile(filePath, state._docRootPath);
    if (res && res.status === 'ok') {
      openFilePreview(filePath, fileName, res.content || '',
        { status, onDownload: () => downloadFile(filePath, fileName), asText: true });
    } else {
      openFilePreview(filePath, fileName, '(无法读取文件)',
        { status, onDownload: () => downloadFile(filePath, fileName) });
    }
  } catch {
    openFilePreview(filePath, fileName, '(加载失败)',
      { status, onDownload: () => downloadFile(filePath, fileName) });
  }
}

async function downloadFile(filePath, fileName) {
  try {
    if (isPreviewableImage(fileName)) {
      const res = await readBinaryFile(filePath, state._docRootPath);
      if (res && res.status === 'ok' && res.data) {
        const url = `data:${res.mime || 'image/png'};base64,${res.data}`;
        const a = document.createElement('a');
        a.href = url; a.download = fileName;
        document.body.appendChild(a); a.click(); document.body.removeChild(a);
      }
    } else if (isBinaryFile(fileName)) {
      // 二进制文件（xlsx/docx/pdf 等）：按 base64 还原字节后下载
      const res = await readBinaryFile(filePath, state._docRootPath);
      if (res && res.status === 'ok' && res.data) {
        const bin = atob(res.data);
        const bytes = new Uint8Array(bin.length);
        for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i);
        const blob = new Blob([bytes], { type: res.mime || 'application/octet-stream' });
        const url = URL.createObjectURL(blob);
        const a = document.createElement('a');
        a.href = url; a.download = fileName;
        document.body.appendChild(a); a.click(); document.body.removeChild(a);
        URL.revokeObjectURL(url);
      }
    } else {
      const res = await readTextFile(filePath, state._docRootPath);
      if (res && res.status === 'ok') {
        const blob = new Blob([res.content || ''], { type: 'text/plain;charset=utf-8' });
        const url = URL.createObjectURL(blob);
        const a = document.createElement('a');
        a.href = url; a.download = fileName;
        document.body.appendChild(a); a.click(); document.body.removeChild(a);
        URL.revokeObjectURL(url);
      }
    }
  } catch { /* ignore */ }
}

// ===== 快照系统（类 Git，持久化到磁盘）=====
// 目录结构: {snapshots_base}/{workspace_key}/
//   ├── _accepted/       # 接受基线
//   ├── turn_1/          # 第一轮快照
//   └── turn_2/          # 第二轮快照
// snapshots_base 由后端 /api/workspace 返回，默认为 workspace/.minor_snapshots
let _snapshots = []; // [{ turn: N, rootPath, timestamp, files: Map<path, {content, size, isBinary}> }]
let _turnCounter = 0;
let _acceptedBaselines = {}; // { path: { content, snapshotIdx } }

function _workspaceKey() {
  if (!state._docRootPath) return null;
  return state._docRootPath.replace(/[/\\]$/, '')
    .replace(/^[A-Za-z]:/, '')
    .replace(/[/\\:]/g, '_')
    .replace(/^_+/, '');
}

function _snapDir() {
  if (!state._docRootPath) return null;
  const wsKey = _workspaceKey();
  if (!wsKey) return null;
  const base = window.__minorSnapBase
    || (state._docRootPath.replace(/[/\\]$/, '') + '/.minor_snapshots');
  return base + '/' + wsKey;
}

function _turnDir(turn) { return _snapDir() + '/turn_' + turn; }
function _acceptDir() { return _snapDir() + '/_accepted'; }

/** 由外部设置快照基础目录（在 initWorkspace 中调用） */
export function setSnapBaseDir(baseDir) {
  window.__minorSnapBase = baseDir.replace(/\\/g, '/').replace(/\/$/, '');
}

/** 删除快照目录中的文件 */
async function _deleteSnapFile(relPath, srcDirRel) {
  const rootPath = state._docRootPath;
  const srcRel = srcDirRel.replace(rootPath.replace(/[/\\]$/, ''), '').replace(/^[/\\]+/, '') + '/' + relPath.replace(/\\/g, '/');
  try { await deleteFile(srcRel, rootPath); } catch {}
}

/** 复制文件（文本或二进制）到目标路径，目标路径相对于 workspace */
async function _copyFileTo(relPath, targetDirRel) {
  const rootPath = state._docRootPath;
  const tgtRel = targetDirRel.replace(rootPath.replace(/[/\\]$/, ''), '').replace(/^[/\\]+/, '') + '/' + relPath.replace(/\\/g, '/');
  try {
    // Try text first
    const text = await readTextFile(relPath, rootPath);
    await writeTextFile(tgtRel, text, rootPath);
    return { content: text, isBinary: false };
  } catch {
    // Binary
    try {
      const bin = await readBinaryFile(relPath, rootPath);
      if (bin && bin.base64) {
        // writeFromBuffer takes (parentDir, fileName, base64)
        const parentDir = tgtRel.substring(0, tgtRel.lastIndexOf('/'));
        const fileName = relPath.replace(/\\/g, '/').split('/').pop();
        await writeFromBuffer(parentDir, fileName, bin.base64);
        return { content: bin, isBinary: true };
      }
    } catch {}
  }
  return null;
}

/** 恢复文件（从源目录复制到 workspace）*/
async function _restoreFile(relPath, srcDirRel) {
  const rootPath = state._docRootPath;
  const srcRel = srcDirRel.replace(rootPath.replace(/[/\\]$/, ''), '').replace(/^[/\\]+/, '') + '/' + relPath.replace(/\\/g, '/');
  try {
    // Try text
    const text = await readTextFile(srcRel, rootPath);
    await writeTextFile(relPath, text, rootPath);
    return true;
  } catch {
    // Try binary
    try {
      const bin = await readBinaryFile(srcRel, rootPath);
      if (bin && bin.base64) {
        const parentDir = relPath.replace(/\\/g, '/').split('/').slice(0, -1).join('/') || '.';
        const fileName = relPath.replace(/\\/g, '/').split('/').pop();
        await writeFromBuffer(parentDir, fileName, bin.base64);
        return true;
      }
    } catch {}
  }
  return false;
}

/** 删除某文件在所有快照中的备份（接受或撤销时清理） */
async function _purgeFileFromSnapshots(relPath) {
  for (const s of _snapshots) {
    s.files.delete(relPath);
    await _deleteSnapFile(relPath, _turnDir(s.turn));
  }
  // Also delete from accepted baselines
  await _deleteSnapFile(relPath, _acceptDir());
}

/** 删除某个 turn 目录 */
async function _deleteTurnDir(turn) {
  const dir = _turnDir(turn);
  try { await deleteFile(dir, ''); } catch {}
}

/** 保存任务前快照（含完整文件内容，持久化到磁盘） */
export async function snapshotFilesForTask() {
  if (!state._docRootPath) return;
  const rootPath = state._docRootPath;
  const files = new Map();
  const turn = ++_turnCounter;
  const tDir = _turnDir(turn);

  for (const f of state.docFiles) {
    const result = await _copyFileTo(f.path, tDir);
    if (result) {
      files.set(f.path, { content: result.content, size: f.size, isBinary: result.isBinary });
    } else {
      files.set(f.path, { content: null, size: f.size, isBinary: false });
    }
  }

  _snapshots.push({
    turn,
    rootPath,
    timestamp: Date.now(),
    files,
  });

  // 首次快照时初始化接受基线（保存到磁盘）
  if (_snapshots.length === 1) {
    for (const [fp, info] of files) {
      await _copyFileTo(fp, _acceptDir());
      _acceptedBaselines[fp] = { content: info.content, snapshotIdx: 0, isBinary: info.isBinary };
    }
  }
}

/** 任务结束后对比快照，将Agent产生的变更记录到docModifications */
export function detectTaskFileChanges() {
  if (_snapshots.length === 0 || !state._docRootPath) return;

  const preSnap = _snapshots[_snapshots.length - 1];
  const preMap = preSnap.files;
  const curMap = new Map(state.docFiles.map(f => [f.path, f]));
  let changed = false;

  for (const [fp, f] of curMap) {
    const pre = preMap.get(fp);
    if (!pre) {
      // 新文件
      docModifications[fp] = { original: "", current: f.path, type: "new", snapshotIdx: preSnap.turn };
      if (!currentTaskModifications.includes(fp)) currentTaskModifications.push(fp);
      changed = true;
    } else if (pre.size !== f.size) {
      // 内容被修改
      docModifications[fp] = { original: pre.content || f.path, current: f.path, type: "modified", snapshotIdx: preSnap.turn, oldContent: pre.content };
      if (!currentTaskModifications.includes(fp)) currentTaskModifications.push(fp);
      changed = true;
    }
  }
  for (const [fp] of preMap) {
    if (!curMap.has(fp)) {
      // 被删除
      const preInfo = preMap.get(fp);
      docModifications[fp] = { original: preInfo.content || fp, current: "", type: "deleted", snapshotIdx: preSnap.turn, oldContent: preInfo.content };
      if (!currentTaskModifications.includes(fp)) currentTaskModifications.push(fp);
      changed = true;
    }
  }

  if (changed) {
    setDocModifications(docModifications);
    renderDocTree();
    try { import('./doc-mod-panel.js').then(m => { m.setDocModifications(docModifications); m.renderDocModPanel(); }); } catch {}
  }
}

/** 计算两个文本内容的行级 diff（返回简化差异列表） */
export function computeLineDiff(oldText, newText) {
  if (oldText == null || newText == null) return null;
  const oldLines = (oldText || '').split('\n');
  const newLines = (newText || '').split('\n');
  return _lineDiff(oldLines, newLines);
}

function _lineDiff(oldLines, newLines) {
  // 回溯 LCS
  const m = oldLines.length, n = newLines.length;
  // 对短文本使用简单 diff
  if (m === 0 && n === 0) return [];
  if (m === 0) return [{ type: 'add', startLine: 1, endLine: n, lines: newLines }];
  if (n === 0) return [{ type: 'remove', startLine: 1, endLine: m, lines: oldLines }];

  // LCS 矩阵
  const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
  for (let i = 1; i <= m; i++) {
    for (let j = 1; j <= n; j++) {
      if (oldLines[i - 1] === newLines[j - 1]) {
        dp[i][j] = dp[i - 1][j - 1] + 1;
      } else {
        dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
      }
    }
  }

  // 回溯
  const diffs = [];
  let i = m, j = n;
  const tempOps = [];

  while (i > 0 || j > 0) {
    if (i > 0 && j > 0 && oldLines[i - 1] === newLines[j - 1]) {
      tempOps.unshift({ type: 'keep', oldLine: i, newLine: j });
      i--; j--;
    } else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
      tempOps.unshift({ type: 'add', newLine: j, line: newLines[j - 1] });
      j--;
    } else {
      tempOps.unshift({ type: 'remove', oldLine: i, line: oldLines[i - 1] });
      i--;
    }
  }

  // 合并相邻的同类型差异
  for (const op of tempOps) {
    if (op.type === 'keep') continue;
    const last = diffs[diffs.length - 1];
    if (last && last.type === op.type) {
      if (op.type === 'add') {
        last.endLine = op.newLine;
        last.lines.push(op.line);
      } else {
        last.endLine = op.oldLine;
        last.lines.push(op.line);
      }
    } else {
      if (op.type === 'add') {
        diffs.push({ type: 'add', startLine: op.newLine, endLine: op.newLine, lines: [op.line] });
      } else {
        diffs.push({ type: 'remove', startLine: op.oldLine, endLine: op.oldLine, lines: [op.line] });
      }
    }
  }

  return diffs;
}

/** 接受单个文件的修改（更新接受基线，持久化，清理快照）*/
export async function acceptFileModification(filePath) {
  const rootPath = state._docRootPath;
  if (!rootPath) return;

  const mod = docModifications[filePath];
  if (!mod) return;

  if (mod.type === 'deleted') {
    // 接受删除 → 从修改列表和接受基线中移除
    delete docModifications[filePath];
    delete _acceptedBaselines[filePath];
    await _deleteSnapFile(filePath, _acceptDir());
  } else {
    // 接受新增/修改 → 更新磁盘上的接受基线
    const result = await _copyFileTo(filePath, _acceptDir());
    _acceptedBaselines[filePath] = {
      content: result ? result.content : null,
      snapshotIdx: _snapshots.length,
      isBinary: result ? result.isBinary : false
    };
    delete docModifications[filePath];
  }

  // 清理该文件在所有快照中的备份
  await _purgeFileFromSnapshots(filePath);

  currentTaskModifications = currentTaskModifications.filter(f => f !== filePath);
  setDocModifications(docModifications);
  renderDocTree();
}

/** 撤销单个文件的修改（回到接受基线，从磁盘恢复，支持二进制）*/
export async function rejectFileModification(filePath) {
  const rootPath = state._docRootPath;
  if (!rootPath) return;

  const mod = docModifications[filePath];
  if (!mod) return;

  if (mod.type === 'deleted') {
    // 撤销删除 → 从接受基线恢复文件
    await _restoreFile(filePath, _acceptDir());
  } else if (mod.type === 'new') {
    // 撤销新增 → 删除文件
    try { await deleteFile(filePath, rootPath); } catch {}
  } else {
    // 撤销修改 → 从接受基线恢复文件
    await _restoreFile(filePath, _acceptDir());
  }

  // 清理该文件在所有快照中的备份
  await _purgeFileFromSnapshots(filePath);

  delete docModifications[filePath];
  currentTaskModifications = currentTaskModifications.filter(f => f !== filePath);
  setDocModifications(docModifications);
  renderDocTree();

  // 刷新文件列表
  setTimeout(() => openFolder(rootPath), 500);
}

// 向后兼容导出
export function getDocModifications() { return docModifications; }
export function getCurrentTaskModifications() { return currentTaskModifications; }
export async function acceptAllModifications() {
  for (const fp of Object.keys(docModifications)) await acceptFileModification(fp);
}
export async function rejectAllModifications() {
  for (const fp of Object.keys(docModifications)) await rejectFileModification(fp);
}

// ===== 外部文件变更（实时自动刷新，类似 VS Code） =====
function handleFsChange(events) {
  if (_fsChangeTimer) clearTimeout(_fsChangeTimer);
  _fsChangeTimer = setTimeout(() => applyFsChanges(events), 300);
}

async function applyFsChanges(events) {
  if (_fsApplying || !state._docRootPath) return;
  _fsApplying = true;
  try {
    const rootPath = state._docRootPath;
    const listRes = await listDir(rootPath, 10);
    const currentFiles = (listRes.files || []).filter((f) => !f.is_dir && isSupportedFile(f.name));
    const currentMap = new Map(currentFiles.map((f) => [f.path, f]));

    const existingMap = new Map(state.docFiles.map((f) => [f.path, f]));
    const existingNames = new Set(existingMap.keys());
    const currentNames = new Set(currentMap.keys());

    let changed = false;

    // 检测新增和修改的文件
    for (const [fp, f] of currentMap) {
      if (!existingNames.has(fp)) {
        _externalChanges[fp] = { type: 'externally_added', name: f.name, size: f.size };
        changed = true;
      } else {
        const old = existingMap.get(fp);
        // 检测文件大小变化（即内容被外部修改）
        if (old.size !== f.size) {
          _externalChanges[fp] = { type: 'externally_modified', name: f.name, size: f.size, oldSize: old.size };
          changed = true;
        }
      }
    }

    // 检测删除的文件
    for (const fp of existingNames) {
      if (!currentNames.has(fp)) {
        _externalChanges[fp] = { type: 'externally_deleted', name: existingMap.get(fp).name };
        changed = true;
      }
    }

    if (changed) {
      state.docFiles = currentFiles;
      renderDocTree();
      // 同步外部变更到文档修改面板
      const extMods = {};
      for (const [fp, ec] of Object.entries(_externalChanges)) {
        extMods[fp] = { original: fp, current: fp, type: ec.type === 'externally_added' ? 'new' : ec.type === 'externally_modified' ? 'modified' : 'deleted' };
      }
      setDocModifications({ ...docModifications, ...extMods });
      try { import('./doc-mod-panel.js').then(m => m.renderDocModPanel()); } catch {}
    }
  } finally {
    _fsApplying = false;
  }
}

export function clearExternalChange(filePath) {
  delete _externalChanges[filePath];
  renderDocTree();
  setDocModifications(docModifications);
  try { import('./doc-mod-panel.js').then(m => m.renderDocModPanel()); } catch {}
}

// ===== 拖拽引用 =====
export function initDocReferences() {
  // 文件树元素拖拽到输入框
  if (docTree) {
    docTree.addEventListener('dragstart', (e) => {
      const item = e.target.closest('[data-file-path]');
      if (!item) return;
      const filePath = item.dataset.filePath;
      // 用专用 mime type 传递路径，避免和 text/plain 冲突
      e.dataTransfer.setData('application/doc-path', filePath);
      e.dataTransfer.effectAllowed = 'copy';
    });
  }

  // 输入区接收拖入
  setupInputDropHandler();
}

function setupInputDropHandler() {
  // 拖放目标设为整个 composer 输入区域，不只是 textarea
  const composerInput = document.querySelector('.composer-input-shell');
  const target = composerInput || $('textInput');
  if (!target) return;

  // 子元素间移动会成对触发 dragenter/dragleave，用计数器避免状态误清除
  let dragDepth = 0;
  const setDragState = (on) => target.classList.toggle('is-drag-attach', on);
  const isAcceptedDrag = (types) => types.includes('application/doc-path') || types.includes('Files');

  target.addEventListener('dragenter', (e) => {
    if (isAcceptedDrag(Array.from(e.dataTransfer.types))) {
      dragDepth++;
      setDragState(true);
    }
  });

  target.addEventListener('dragover', (e) => {
    const types = Array.from(e.dataTransfer.types);
    // 接受应用内文件/文件夹引用拖拽 或 外部文件拖拽
    if (types.includes('application/doc-path') || types.includes('Files')) {
      e.preventDefault();
      e.dataTransfer.dropEffect = 'copy';
      setDragState(true);
    }
  });

  target.addEventListener('dragleave', () => {
    dragDepth = Math.max(0, dragDepth - 1);
    if (dragDepth === 0) setDragState(false);
  });

  target.addEventListener('drop', async (e) => {
    e.preventDefault();
    dragDepth = 0;
    setDragState(false);

    // 1. 内部拖拽（doc-tree 文件/文件夹引用）
    // app.js 检测到 application/doc-path 也会 return，无需 stopPropagation
    if (Array.from(e.dataTransfer.types).includes('application/doc-path')) {
      const docPath = e.dataTransfer.getData('application/doc-path');
      const isFolder = e.dataTransfer.getData('application/doc-folder') === '1';
      if (isFolder) {
        addFolderRef(docPath);
      } else {
        addDocRef(docPath);
      }
      return;
    }

    // 2. 聊天区图片/文件拖拽 — 交给 app.js 处理（不 stopPropagation，让事件冒泡）
    if (e.dataTransfer.types.includes('application/x-chat-image') ||
        e.dataTransfer.types.includes('application/x-chat-file')) {
      return;
    }

    // 3. 外部拖拽（文件/文件夹）
    // stopPropagation 防止 app.js 递归展开文件夹内所有文件
    if (e.dataTransfer.items && e.dataTransfer.items.length > 0) {
      e.stopPropagation();
      const items = Array.from(e.dataTransfer.items);
      // 先收集所有 entry，判断是否包含文件夹
      const allEntries = [];
      for (const item of items) {
        if (item.kind !== 'file') continue;
        const entry = item.webkitGetAsEntry ? item.webkitGetAsEntry() : null;
        const file = item.getAsFile();
        allEntries.push({ entry, file });
      }
      const hasDirectory = allEntries.some(({ entry }) => entry && entry.isDirectory);

      if (hasDirectory) {
        // 有文件夹时：只处理文件夹项，跳过文件项（避免展开文件夹内容）
        for (const { entry, file } of allEntries) {
          if (entry && entry.isDirectory) {
            const folderPath = (file && file.path) ? file.path : '';
            const folderName = entry.name || (file ? file.name : '文件夹');
            addExternalFolderRef(folderPath, folderName);
          }
        }
      } else {
        // 无文件夹：图片作为普通 File 上传（HumanMessage image_url），非图片作为 @file: 引用
        // Electron 拖入的 File 带 path（绝对路径）且已包含二进制内容；无 path 时回退为普通上传
        let needFallback = false;
        for (const { file } of allEntries) {
          if (!file) continue;
          if (_isImageName(file.name)) {
            // 图片：直接作为普通文件上传（File 已含二进制内容）
            state.pendingFiles = dedupePendingFiles(state.pendingFiles.concat([file]));
            needFallback = true;
          } else if (file.path) {
            // 非图片：作为 @file: 绝对路径引用
            addExternalDocRef(file.path, file.name);
          } else {
            state.pendingFiles = dedupePendingFiles(state.pendingFiles.concat([file]));
            needFallback = true;
          }
        }
        if (needFallback) {
          import('./chat-render.js').then(m => { if (m.renderAttachmentChips) m.renderAttachmentChips(); });
        }
      }

      if (allEntries.length > 0) {
        import('./chat-render.js').then(m => { if (m.renderAttachmentChips) m.renderAttachmentChips(); });
      }
      return;
    }

    // 4. 回退：dataTransfer.files（无 items 时）— 图片作为普通 File 上传，非图片作为 @file: 引用
    if (e.dataTransfer.files && e.dataTransfer.files.length > 0) {
      e.stopPropagation();
      const files = Array.from(e.dataTransfer.files);
      let needFallback = false;
      for (const file of files) {
        if (_isImageName(file.name)) {
          // 图片：直接作为普通文件上传
          state.pendingFiles = dedupePendingFiles(state.pendingFiles.concat([file]));
          needFallback = true;
        } else if (file.path) {
          // 非图片：作为 @file: 绝对路径引用
          addExternalDocRef(file.path, file.name);
        } else {
          state.pendingFiles = dedupePendingFiles(state.pendingFiles.concat([file]));
          needFallback = true;
        }
      }
      if (files.length > 0) {
        import('./chat-render.js').then(m => { if (m.renderAttachmentChips) m.renderAttachmentChips(); });
      }
    }
  });
}

/** 判断文件名是否为图片（与后端 IMAGE_FILE_EXTENSIONS 对齐：png/jpg/jpeg/bmp/gif/webp/ico） */
function _isImageName(name) {
  const ext = (name || '').toLowerCase();
  return /\.(png|jpe?g|gif|webp|bmp|ico)$/.test(ext);
}

/** 读取工作区内图片文件二进制，构造为 File 并加入 pendingFiles（作为普通图片上传，HumanMessage image_url） */
async function _addImageFileAsUpload(relPath, fileName) {
  const rootPath = state._docRootPath;
  if (!rootPath) {
    showToast('请先打开工作区');
    return;
  }
  const name = fileName || relPath.split(/[/\\]/).pop() || relPath;
  try {
    const res = await readBinaryFile(relPath, rootPath);
    if (!res || res.status !== 'ok' || !res.data) {
      showToast('图片读取失败：' + name);
      return;
    }
    const bytes = Uint8Array.from(atob(res.data), c => c.charCodeAt(0));
    const blob = new Blob([bytes], { type: res.mime || 'image/png' });
    const file = new File([blob], name, { type: blob.type });
    state.pendingFiles = dedupePendingFiles(state.pendingFiles.concat([file]));
    import('./chat-render.js').then(m => { if (m.renderAttachmentChips) m.renderAttachmentChips(); });
  } catch (e) {
    showToast('图片读取失败：' + (e.message || e));
  }
}

/** 添加一个文档引用 chip
 * 图片（无行号引用）：读取二进制作为普通图片 File 上传（HumanMessage image_url），不生成 @file: 文本。
 * 非图片或带行号引用：作为 @file:path [Lx-Ly] 文本引用，只给 agent 绝对路径。
 */
export async function addDocRef(filePath, lineStart, lineEnd) {
  if (!filePath) return;
  const fileName = filePath.split(/[/\\]/).pop() || filePath;

  // 图片且无行号引用 → 作为普通图片上传
  if (_isImageName(fileName) && !lineStart) {
    // 防重复：若已作为普通文件或引用存在则跳过
    const exists = state.pendingFiles.some((f) =>
      (f.__isRef && f.refPath === filePath) || (!f.__isRef && f.name === fileName)
    );
    if (exists) return;
    await _addImageFileAsUpload(filePath, fileName);
    return;
  }

  // 非图片或带行号引用 → 作为 @file: 文本引用
  if (state.pendingRefs.some((r) => r.path === filePath)) return;
  const ref = {
    path: filePath,
    name: fileName,
    startLine: lineStart || null,
    endLine: lineEnd || null,
  };
  state.pendingRefs.push(ref);
  // 同步到 pendingFiles（统一渲染），用 __isRef 标记区分
  state.pendingFiles.push({
    __isRef: true,
    refPath: filePath,
    refName: fileName + (lineStart ? ` L${lineStart}-L${lineEnd}` : ''),
    type: 'ref/file',
    name: fileName,
  });
  import('./chat-render.js').then(m => { if (m.renderAttachmentChips) m.renderAttachmentChips(); });
}

/** 添加工作区文件夹引用 chip（路径相对于 workspace root） */
export function addFolderRef(folderPath) {
  // 防重复
  if (state.pendingRefs.some((r) => r.isFolder && r.path === folderPath)) return;
  const folderName = folderPath
    ? folderPath.split(/[/\\]/).pop()
    : (state._docRootName || 'workspace');
  const ref = {
    path: folderPath,
    name: folderName,
    isFolder: true,
  };
  state.pendingRefs.push(ref);
  state.pendingFiles.push({
    __isRef: true,
    refPath: folderPath,
    refName: folderName,
    type: 'ref/folder',
    name: folderName,
    isFolder: true,
  });
  import('./chat-render.js').then(m => { if (m.renderAttachmentChips) m.renderAttachmentChips(); });
}

/** 添加外部文件夹引用 chip（路径为绝对路径） */
export function addExternalFolderRef(absolutePath, folderName) {
  if (!absolutePath && !folderName) return;
  // 防重复
  if (state.pendingRefs.some((r) => r.isFolder && r.path === absolutePath)) return;
  const ref = {
    path: absolutePath || '',
    name: folderName || '文件夹',
    isFolder: true,
    isExternal: true,
  };
  state.pendingRefs.push(ref);
  state.pendingFiles.push({
    __isRef: true,
    refPath: absolutePath || '',
    refName: folderName || '文件夹',
    type: 'ref/folder',
    name: folderName || '文件夹',
    isFolder: true,
    isExternal: true,
  });
  import('./chat-render.js').then(m => { if (m.renderAttachmentChips) m.renderAttachmentChips(); });
}

/** 添加外部文件引用 chip（绝对路径）
 * 图片：读取二进制作为普通图片 File 上传（HumanMessage image_url）。
 * 非图片：作为 @file:abspath 文本引用，只给 agent 绝对路径不读内容。
 */
export async function addExternalDocRef(absolutePath, fileName) {
  if (!absolutePath) return;
  const name = fileName || absolutePath.split(/[/\\]/).pop() || absolutePath;

  // 图片 → 读取二进制作为普通图片上传
  if (_isImageName(name)) {
    const exists = state.pendingFiles.some((f) =>
      (f.__isRef && f.refPath === absolutePath) || (!f.__isRef && f.name === name)
    );
    if (exists) return;
    await _addExternalImageAsUpload(absolutePath, name);
    return;
  }

  // 非图片 → 作为 @file: 文本引用
  if (state.pendingRefs.some((r) => r.path === absolutePath)) return;
  const ref = {
    path: absolutePath,
    name: name,
    isExternal: true,
  };
  state.pendingRefs.push(ref);
  state.pendingFiles.push({
    __isRef: true,
    refPath: absolutePath,
    refName: name,
    type: 'ref/file',
    name: name,
    isExternal: true,
  });
  import('./chat-render.js').then(m => { if (m.renderAttachmentChips) m.renderAttachmentChips(); });
}

/** 读取外部（绝对路径）图片二进制，构造为 File 并加入 pendingFiles */
async function _addExternalImageAsUpload(absolutePath, fileName) {
  try {
    const { readBinaryFile: _readBinary } = await import('./electron-api.js');
    const res = await _readBinary(absolutePath, null);
    if (!res || res.status !== 'ok' || !res.data) {
      showToast('图片读取失败：' + fileName);
      return;
    }
    const bytes = Uint8Array.from(atob(res.data), c => c.charCodeAt(0));
    const blob = new Blob([bytes], { type: res.mime || 'image/png' });
    const file = new File([blob], fileName, { type: blob.type });
    state.pendingFiles = dedupePendingFiles(state.pendingFiles.concat([file]));
    import('./chat-render.js').then(m => { if (m.renderAttachmentChips) m.renderAttachmentChips(); });
  } catch (e) {
    showToast('图片读取失败：' + (e.message || e));
  }
}

/** 清除所有引用 chip */
export function clearRefChips() {
  state.pendingRefs = [];
  state.pendingFiles = state.pendingFiles.filter((f) => !f.__isRef);
  import('./chat-render.js').then(m => { if (m.renderAttachmentChips) m.renderAttachmentChips(); });
}

/** 将 pendingRefs 转为发送给 AI 的文本引用 */
function _refsToText() {
  if (!state.pendingRefs.length) return '';
  const root = state._docRootPath ? state._docRootPath.replace(/\\/g, '/').replace(/\/$/, '') : '';
  return state.pendingRefs.map((ref) => {
    // 外部引用路径已是绝对路径（统一为正斜杠），工作区引用需拼接 root
    const absPath = ref.isExternal
      ? String(ref.path || '').replace(/\\/g, '/')
      : (root + '/' + ref.path);
    const prefix = ref.isFolder ? '@folder:' : '@file:';
    const linePart = ref.startLine ? ` L${ref.startLine}-L${ref.endLine}` : '';
    return `${prefix}${absPath}${linePart}`;
  }).join('\n');
}

// ===== 清除状态 =====
export function clearEditState() {
  // 清理该工作空间对应的快照子目录
  const snapDir = _snapDir();
  if (snapDir) {
    try { deleteFile(snapDir, ''); } catch {}
  }
  docModifications = {};
  currentTaskModifications = [];
  _externalChanges = {};
  _snapshots = [];
  _turnCounter = 0;
  _acceptedBaselines = {};
  setDocModifications({});
  closeFilePreview();
  clearRefChips();
  state.docFiles = [];
  state.docOpenTabs = [];
  state._docRootPath = null;
  state._docRootName = null;
  renderDocTree();
}

// ===== 发送 Edit 消息 =====
export async function sendEditChat() {
  if (!state.sessionId || state.sending) return;
  const textInput = $('textInput');
  const trimmed = textInput ? textInput.value.trim() : "";
  const refsText = _refsToText();
  const hasInput = trimmed || state.pendingFiles.length > 0 || state.pendingRefs.length > 0;
  if (!hasInput) return;

  // 保存原始文本，以便失败时恢复
  const originalVal = textInput ? textInput.value : '';

  // 将文档引用注入 textInput
  if (refsText) {
    textInput.value = originalVal ? originalVal + '\n\n' + refsText : refsText;
  }

  try {
    const { sendChat } = await import('./send.js');
    await sendChat();
  } catch (err) {
    // 发送失败：恢复原始文本，避免下次发送时重复注入 refs
    if (textInput) textInput.value = originalVal;
    throw err;
  } finally {
    // 无论成功失败都清除引用 chip，防止重复注入
    clearRefChips();
  }
}

// ===== 初始化 =====
export function initEditMode() {
  // 模式切换按钮
  modeEditBtn?.addEventListener("click", () => {
    if (!state.editMode) switchToMode("edit");
  });
  modeChatBtn?.addEventListener("click", () => {
    // 从 edit 或 cron 模式均可切回 chat
    if (state.mode !== "chat") switchToMode("chat");
  });

  // 打开文件夹 - 移除按钮，改用工作空间选择器触发

  // 文件树点击预览
  docTree?.addEventListener("click", async (e) => {
    const item = e.target.closest('[data-file-path]');
    if (!item) return;
    const filePath = item.dataset.filePath;
    if (filePath) {
      await loadDocContent(filePath);
    }
  });

  // 文件树拖拽引用
  initDocReferences();

  // 全局快捷键（Ctrl+C/X/V/F2/Delete 文件操作）
  document.addEventListener("keydown", (e) => {
    if (!state.editMode) return;
    const tag = document.activeElement?.tagName?.toLowerCase();
    if (tag === 'input' || tag === 'textarea' || tag === 'select') return;

    // 这些操作委托给 doc-tree.js
    // doc-tree.js 中已有自己的事件绑定
  }, { capture: true });

  // 文件树依赖注入
  setDocTreeDeps({
    loadDocContent,
    openFileAsText,
    externalChanges: () => _externalChanges,
  });

  // 初始化后同步到 doc-mod-panel
  try {
    import('./doc-mod-panel.js').then(m => m.bindDocModEvents());
  } catch {}
}