// ❌ 错误示范：V2 时代可以这样写，V3 中行不通
let syncCount = 0;

chrome.bookmarks.onCreated.addListener(() => {
  syncCount++;  // Service Worker 被终止后，这个变量就没了
  console.log('累计变动次数:', syncCount);
});

// ✅ 正确写法：用 chrome.storage 保存状态
chrome.bookmarks.onCreated.addListener(async () => {
  const { syncCount = 0 } = await chrome.storage.local.get(['syncCount']);
  await chrome.storage.local.set({ syncCount: syncCount + 1 });
});

{
  "background": {
    "service_worker": "background.js"
  }
}

{
  "manifest_version": 3,
  "name": "__MSG_extName__",
  "version": "2026.7.30",
  "default_locale": "en",
  "description": "__MSG_extDesc__",
  "permissions": [
    "bookmarks",
    "storage",
    "alarms"
  ],
  "host_permissions": [
    "https://api.github.com/*",
    "https://gitee.com/*"
  ],
  "action": {
    "default_popup": "popup.html",
    "default_icon": {
      "16": "icons/icon16.png",
      "48": "icons/icon48.png",
      "128": "icons/icon128.png"
    }
  },
  "background": {
    "service_worker": "background.js"
  },
  "icons": {
    "16": "icons/icon16.png",
    "48": "icons/icon48.png",
    "128": "icons/icon128.png"
  }
}

{
  "extName": {
    "message": "MiniMark",
    "description": "Extension name"
  },
  "extDesc": {
    "message": "Sync bookmarks to GitHub Gist or Gitee for cross-device bookmark management",
    "description": "Extension description"
  }
}

{
  "extName": {
    "message": "MiniMark",
    "description": "扩展名"
  },
  "extDesc": {
    "message": "同步书签到 GitHub Gist 或 Gitee，跨设备管理您的书签",
    "description": "扩展描述"
  }
}

// 第一步：创建定时任务（最小间隔 1 分钟）
chrome.alarms.create('autoSync', { periodInMinutes: 30 });

// 第二步：监听触发
chrome.alarms.onAlarm.addListener((alarm) => {
  if (alarm.name === 'autoSync') {
    performSync();  // Service Worker 此时已被唤醒，可以执行同步
  }
});

{
  "permissions": ["bookmarks"]
}

根节点 (id: "0")  ← 用户不可见的虚拟根
├── 书签栏          ← 显示在浏览器顶部工具栏下方的书签条
│   ├── 文件夹A
│   │   ├── 书签1（叶子节点，有 url）
│   │   └── 书签2
│   └── 书签3
├── 其他书签        ← 不显示在工具栏，但在书签管理器中可见
│   └── 书签4
└── 移动设备书签    ← 桌面版通常为空，给手机端 Chrome 用的

const bookmarks = await chrome.bookmarks.getTree();
const bookmarkCount = countBookmarks(bookmarks[0]);

function countBookmarks(node) {
  let count = 0;
  if (node.url) {
    count = 1;  // 这个节点是书签，计数 +1
  }
  if (node.children) {
    // 这个节点是文件夹，继续往下找
    for (const child of node.children) {
      count += countBookmarks(child);
    }
  }
  return count;
}

// 获取书签栏下的所有直接子项（不包含子文件夹里的内容）
const children = await chrome.bookmarks.getChildren('1');
// children 是一个数组，每个元素是一个 BookmarkTreeNode

let existing = [];
try { existing = await chrome.bookmarks.getChildren(parentId); } catch (e) { return; }

// 获取单个节点
const [node] = await chrome.bookmarks.get('123');

// 同时获取多个节点
const nodes = await chrome.bookmarks.get(['123', '456']);

// 字符串搜索：在标题和 URL 中匹配关键词
const results = await chrome.bookmarks.search('github');

// 对象搜索：精确匹配（所有条件同时满足）
const exact = await chrome.bookmarks.search({
  title: 'GitHub',
  url: 'https://github.com'
});

// 创建书签（传入 url）
await chrome.bookmarks.create({
  parentId: parentId,    // 放在哪个文件夹下
  title: child.title,    // 显示名称
  url: child.url         // 有 url → 书签
});

// 创建文件夹（不传 url）
const folder = await chrome.bookmarks.create({
  parentId: parentId,
  title: child.title     // 没有 url → 文件夹
});

const folder = await chrome.bookmarks.create({
  parentId: parentId,
  title: child.title
});
if (folder && folder.id) {
  await restoreBookmarkTree(child, folder.id);  // 用新文件夹的 id 继续递归
}

// 修改标题
await chrome.bookmarks.update('123', { title: '新标题' });

// 修改 URL
await chrome.bookmarks.update('123', { url: 'https://new-url.com' });

// 移到另一个文件夹
await chrome.bookmarks.move('123', { parentId: '456' });

// 调整顺序（移到当前文件夹的第一个位置）
await chrome.bookmarks.move('123', { index: 0 });

// 清空本地所有书签（保留"书签栏""其他书签"等根文件夹骨架）
async function clearLocalBookmarks() {
  const tree = await chrome.bookmarks.getTree();
  const root = tree[0];
  if (!root || !root.children) return;
  for (const folder of root.children) {
    if (!folder.children) continue;
    for (const child of folder.children) {
      try {
        if (child.children) {
          // 有 children → 是文件夹 → 用 removeTree 递归删除
          await chrome.bookmarks.removeTree(child.id);
        } else {
          // 没有 children → 是书签 → 用 remove 直接删除
          await chrome.bookmarks.remove(child.id);
        }
      } catch (e) {
        console.warn('删除书签失败:', e);
      }
    }
  }
}

chrome.bookmarks.onCreated.addListener(() => { markUnsynced().catch(e=>console.warn(e)); });
chrome.bookmarks.onRemoved.addListener(() => { markUnsynced().catch(e=>console.warn(e)); });
chrome.bookmarks.onChanged.addListener(() => { markUnsynced().catch(e=>console.warn(e)); });
chrome.bookmarks.onMoved.addListener(() => { markUnsynced().catch(e=>console.warn(e)); });

┌──────────────────────────────────────────────────────────┐
│                        用户界面层                          │
│              popup.html / popup.js / popup.css            │
│    状态卡 · 统计卡 · 快速操作 · 趋势图 · 历史记录 · 设置     │
└────────────────────────┬─────────────────────────────────┘
                         │ chrome.runtime.sendMessage
                         ▼
┌──────────────────────────────────────────────────────────┐
│                    Service Worker                         │
│                      background.js                        │
│                                                          │
│  · Token 验证        · Gist 增删改查                      │
│  · 书签树序列化      · 书签树恢复                          │
│  · 智能同步决策      · 状态对比分析                        │
│  · 定时任务调度      · 旧片段清理                          │
│  · 角标状态管理      · 书签变动监听                        │
│                                                          │
│  ┌─────────────────────────────────────────────────────┐ │
│  │              chrome.storage.local                    │ │
│  │  Token · Gist ID · 同步历史 · 配置 · 同步状态         │ │
│  └─────────────────────────────────────────────────────┘ │
└──────────────────────────────────────────────────────────┘
                         │ fetch
                         ▼
┌──────────────────────────────────────────────────────────┐
│              GitHub Gist API  /  Gitee Gist API           │
│            api.github.com/gists   gitee.com/api/v5/gists   │
└──────────────────────────────────────────────────────────┘

MiniMark/
├── manifest.json          # 扩展清单（Manifest V3）
├── background.js          # Service Worker，全部后台逻辑
├── popup.html             # 弹窗界面结构
├── popup.css              # 弹窗样式
├── popup.js               # 弹窗交互逻辑
├── _locales/              # 多语言资源
│   ├── en/messages.json
│   └── zh_CN/messages.json
└── icons/                 # 图标资源
    ├── icon16.png
    ├── icon48.png
    ├── icon128.png
    ├── logo.ico
    ├── github.svg
    └── gitee.svg

{
  "manifest_version": 3,
  "name": "__MSG_extName__",
  "version": "2026.7.30",
  "default_locale": "en",
  "description": "__MSG_extDesc__",
  "permissions": [
    "bookmarks",
    "storage",
    "alarms"
  ],
  "host_permissions": [
    "https://api.github.com/*",
    "https://gitee.com/*"
  ],
  "action": {
    "default_popup": "popup.html",
    "default_icon": {
      "16": "icons/icon16.png",
      "48": "icons/icon48.png",
      "128": "icons/icon128.png"
    }
  },
  "background": {
    "service_worker": "background.js"
  },
  "icons": {
    "16": "icons/icon16.png",
    "48": "icons/icon48.png",
    "128": "icons/icon128.png"
  }
}

async function performSync(platform) {
  // ...获取配置与 Token...

  // 获取所有书签
  const bookmarks = await chrome.bookmarks.getTree();
  const bookmarkCount = countBookmarks(bookmarks[0]);

  // 直接使用原始书签树（保留标题中的 emoji，Gitee Gist 内容本身支持 emoji）
  const cleanedBookmarks = bookmarks;

  const bookmarkData = {
    version: '1.0',
    timestamp: Date.now(),
    count: bookmarkCount,
    bookmarks: cleanedBookmarks
  };

  // 检查数据大小
  const dataSize = JSON.stringify(bookmarkData).length;
  const dataSizeMB = (dataSize / 1024 / 1024).toFixed(2);
  console.log(`书签数据大小: ${dataSizeMB} MB (${dataSize} 字节)`);

  // Gitee 限制单个文件最大 1MB
  if (platform === 'gitee' && dataSize > 1024 * 1024) {
    throw new Error(`书签数据过大 (${dataSizeMB} MB)，Gitee 限制单个文件最大 1MB。`);
  }

  // 根据平台执行同步
  let result;
  if (platform === 'github') {
    result = await syncToGithub(token, gistId, bookmarkData);
  } else if (platform === 'gitee') {
    result = await syncToGitee(token, gistId, bookmarkData);
  }

  // ...保存同步状态...
}

{
  "version": "1.0",
  "timestamp": 1722300000000,
  "count": 152,
  "bookmarks": [
    {
      "id": "0",
      "title": "",
      "children": [
        { "id": "1", "title": "书签栏", "children": [...] },
        { "id": "2", "title": "其他书签", "children": [...] }
      ]
    }
  ]
}

async function restoreFromRemote(platform) {
  // ...获取配置、Token、Gist ID...

  // 获取远程书签数据
  let bookmarkData;
  if (platform === 'github') {
    bookmarkData = await fetchFromGithub(token, gistId);
  } else if (platform === 'gitee') {
    bookmarkData = await fetchFromGitee(token, gistId);
  }

  // 合并模式：不清空本地，直接把远端合并进本地后返回
  const syncMode = (await chrome.storage.local.get(['syncMode'])).syncMode;
  if (syncMode === 'merge') {
    if (bookmarkData && bookmarkData.bookmarks) {
      await mergeRemoteIntoLocal(bookmarkData.bookmarks);
      // ...保存状态、记录历史...
      return { count: mergedCount };
    }
  }

  // 覆盖模式：删除本地所有书签（保留根文件夹骨架）
  const tree = await chrome.bookmarks.getTree();
  const root = tree[0];
  if (root.children) {
    for (const folder of root.children) {
      if (folder.children) {
        for (const child of folder.children) {
          try {
            if (child.children) {
              await chrome.bookmarks.removeTree(child.id);
            } else {
              await chrome.bookmarks.remove(child.id);
            }
          } catch (e) {
            console.warn('删除书签失败:', e);
          }
        }
      }
    }
  }

  // 恢复书签到对应的文件夹
  if (bookmarkData.bookmarks && bookmarkData.bookmarks[0]) {
    const currentTree = await chrome.bookmarks.getTree();
    const currentRoot = currentTree[0];

    if (currentRoot.children && bookmarkData.bookmarks[0].children) {
      const remoteFolders = bookmarkData.bookmarks[0].children;
      for (let i = 0; i < remoteFolders.length; i++) {
        const remoteFolder = remoteFolders[i];
        // 优先按标题匹配本地文件夹；跨语言时回退到固定位置
        let localFolder = currentRoot.children.find(f => f.title === remoteFolder.title);
        if (!localFolder && currentRoot.children[i]) {
          localFolder = currentRoot.children[i];
        }
        if (localFolder && remoteFolder.children) {
          await restoreBookmarkTree(remoteFolder, localFolder.id);
        }
      }
    }
  }
  // ...保存恢复状态...
}

async function restoreBookmarkTree(node, parentId) {
  if (!node.children) {
    return;
  }

  for (const child of node.children) {
    try {
      if (child.url) {
        // 创建书签
        await chrome.bookmarks.create({
          parentId: parentId,
          title: child.title,
          url: child.url
        });
      } else if (child.children) {
        // 创建文件夹，然后递归
        const folder = await chrome.bookmarks.create({
          parentId: parentId,
          title: child.title
        });
        if (folder && folder.id) {
          await restoreBookmarkTree(child, folder.id);
        }
      }
    } catch (e) {
      console.warn('恢复书签项失败:', e, child);
    }
  }
}

headers: {
  'Authorization': `Bearer ${token}`,
  'Accept': 'application/vnd.github.v3+json'
}

async function syncToGithub(token, gistId, bookmarkData) {
  const url = gistId
    ? `https://api.github.com/gists/${gistId}`
    : 'https://api.github.com/gists';

  const method = gistId ? 'PATCH' : 'POST';

  const body = {
    description: 'MiniBookmark',
    public: false,  // 私有 Gist，仅本人可见
    files: {
      'bookmarks.json': {
        content: JSON.stringify(bookmarkData, null, 2)
      }
    }
  };

  const response = await fetch(url, {
    method: method,
    headers: {
      'Authorization': `Bearer ${token}`,
      'Accept': 'application/vnd.github.v3+json',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(body)
  });

  if (!response.ok) {
    const errorText = await response.text();
    let errorMsg;
    try {
      const error = JSON.parse(errorText);
      errorMsg = error.message || error.error || `GitHub API 错误: ${response.status}`;
    } catch (e) {
      errorMsg = `GitHub API 错误: ${response.status} - ${errorText}`;
    }
    throw new Error(errorMsg);
  }

  const result = await response.json();
  return {
    gistId: result.id,
    url: result.html_url,
    updatedAt: result.updated_at
  };
}

async function fetchFromGithub(token, gistId) {
  const response = await fetch(`https://api.github.com/gists/${gistId}`, {
    headers: {
      'Authorization': `Bearer ${token}`,
      'Accept': 'application/vnd.github.v3+json'
    }
  });

  if (!response.ok) {
    throw new Error(`GitHub API 错误: ${response.status}`);
  }

  const result = await response.json();
  const content = result.files['bookmarks.json'].content;
  return JSON.parse(content);
}

async function deleteGithubGist(token, gistId) {
  const response = await fetch(`https://api.github.com/gists/${gistId}`, {
    method: 'DELETE',
    headers: {
      'Authorization': `Bearer ${token}`,
      'Accept': 'application/vnd.github.v3+json'
    }
  });
  // 成功返回 204；404 表示已被删除，可忽略
  if (!response.ok && response.status !== 404) {
    const t = await response.text().catch(() => '');
    throw new Error(`GitHub 删除 Gist 失败: ${response.status} ${t.slice(0, 120)}`);
  }
}

const auth = `?access_token=${encodeURIComponent(token)}`;
const url = `https://gitee.com/api/v5/gists/${id}${auth}`;

function sanitizeForGitee(text) {
  if (typeof text !== 'string') return text;
  // 移除 U+10000 及以上的补充平面字符（即 4 字节 UTF-8）
  return text.replace(/[\u{10000}-\u{10FFFF}]/gu, '');
}

async function syncToGitee(token, gistId, bookmarkData) {
  // 剥离 4 字节 UTF-8 字符，避免 Gitee 数据库写入失败
  const safeContent = sanitizeForGitee(JSON.stringify(bookmarkData));
  // ...后续用 safeContent 替代原始内容...
}

async function syncToGitee(token, gistId, bookmarkData) {
  const safeContent = sanitizeForGitee(JSON.stringify(bookmarkData));
  const auth = `?access_token=${encodeURIComponent(token)}`;
  const headers = { 'Content-Type': 'application/json' };
  const patchBody = JSON.stringify({
    files: { 'bookmarks.json': { content: safeContent, filename: 'bookmarks.json' } }
  });

  const patchGist = async (id) => {
    const r = await fetch(`https://gitee.com/api/v5/gists/${id}${auth}`, {
      method: 'PATCH', headers, body: patchBody
    });
    if (r.ok) {
      const res = await r.json();
      return res;
    }
    return null;  // 失败返回 null，尝试下一个候选
  };

  // 需要尝试更新的目标：记录的 gistId 优先；失效则查询列表取最新一份
  const targets = [];
  if (gistId) targets.push(gistId);
  try {
    const list = await fetchGiteeGists(token);
    const candidates = (list || [])
      .filter(g => g.files && g.files['bookmarks.json'])
      .sort((a, b) =>
        new Date(b.updated_at || b.created_at || 0).getTime() -
        new Date(a.updated_at || a.created_at || 0).getTime()
      );
    if (candidates[0]) targets.push(candidates[0].id);
  } catch (e) {
    console.warn('获取 Gitee 片段列表失败:', e);
  }

  // 去重后依次尝试 PATCH 更新
  const tried = new Set();
  for (const id of targets) {
    if (!id || tried.has(id)) continue;
    tried.add(id);
    try {
      const res = await patchGist(id);
      if (res) {
        return { gistId: res.id, url: res.html_url, updatedAt: res.updated_at };
      }
    } catch (e) {
      console.warn('Gitee 更新异常（尝试下一候选）:', e);
    }
  }

  // 没有任何可更新的现有片段：新建一份
  const createResponse = await fetch(`https://gitee.com/api/v5/gists${auth}`, {
    method: 'POST',
    headers,
    body: JSON.stringify({
      files: { 'bookmarks.json': { content: safeContent } },
      description: 'MiniBookmark',
      public: false
    })
  });
  // ...错误处理与返回...
}

async function findExistingGist(platform) {
  const config = await chrome.storage.local.get(['githubToken', 'giteeToken']);
  const token = platform === 'github' ? config.githubToken : config.giteeToken;

  let gistList;
  if (platform === 'github') {
    gistList = await fetchGithubGists(token);
  } else if (platform === 'gitee') {
    gistList = await fetchGiteeGists(token);
  }

  // 查找名为 bookmarks.json 的 Gist，按更新时间倒序取最新
  const bookmarkCandidates = (gistList || []).filter(gist => {
    return gist.files && gist.files['bookmarks.json'];
  });
  bookmarkCandidates.sort((a, b) => {
    const ta = new Date(a.updated_at || a.created_at || 0).getTime();
    const tb = new Date(b.updated_at || b.created_at || 0).getTime();
    return tb - ta;
  });
  const bookmarkGist = bookmarkCandidates[0] || null;

  if (bookmarkGist) {
    // 保存 gistId 到本地，下次直接用
    const storageData = {};
    if (platform === 'github') {
      storageData.githubGistId = bookmarkGist.id;
    } else {
      storageData.giteeGistId = bookmarkGist.id;
    }
    await chrome.storage.local.set(storageData);
    return { gistId: bookmarkGist.id, count: bookmarkData.count || 0 };
  } else {
    return { gistId: null, count: 0 };
  }
}

if (!gistId) {
  try {
    const existing = await findExistingGist(platform);
    if (existing && existing.gistId) {
      gistId = existing.gistId;
      console.log(`${platform}: 复用已存在的 Gist ${gistId}，不再新建`);
    }
  } catch (e) {
    console.warn(`查找已存在 ${platform} Gist 失败，将继续创建新 Gist:`, e);
  }
}

async function mergeIntoLocal(remoteNodes, parentId) {
  if (!Array.isArray(remoteNodes) || !parentId) return;
  // 获取本地该文件夹下已有的子节点
  let existing = [];
  try { existing = await chrome.bookmarks.getChildren(parentId); } catch (e) { return; }

  // 按 URL（书签）或标题（文件夹）建立去重索引
  const existingByKey = new Map();
  for (const n of existing) {
    const key = n.url ? ('u:' + n.url) : ('f:' + (n.title || ''));
    if (!existingByKey.has(key)) existingByKey.set(key, n);
  }

  for (const r of remoteNodes) {
    const key = r.url ? ('u:' + r.url) : ('f:' + (r.title || ''));
    const found = existingByKey.get(key);
    if (found) {
      // 文件夹则继续向下合并；书签（叶子）已存在则跳过
      if (!r.url && r.children && found.url === undefined) {
        await mergeIntoLocal(r.children, found.id);
      }
      continue;
    }
    // 本地不存在，创建
    try {
      if (r.url) {
        await chrome.bookmarks.create({ parentId, title: r.title || '', url: r.url });
      } else {
        const folder = await chrome.bookmarks.create({ parentId, title: r.title || '文件夹' });
        if (r.children) await mergeIntoLocal(r.children, folder.id);
      }
    } catch (e) {
      console.warn('合并创建书签失败:', e);
    }
  }
}

async function mergeRemoteIntoLocal(remoteBookmarks) {
  if (!remoteBookmarks || !remoteBookmarks[0]) return;
  const localTree = await chrome.bookmarks.getTree();
  const localRoot = localTree[0];
  for (const remoteTop of (remoteBookmarks[0].children || [])) {
    // 按标题匹配本地顶层文件夹
    let localTop = (localRoot.children || []).find(c => !c.url && c.title === remoteTop.title);
    if (!localTop) {
      // 本地没有同名文件夹，创建一个
      try {
        localTop = await chrome.bookmarks.create({ parentId: localRoot.id, title: remoteTop.title || '文件夹' });
      } catch (e) { console.warn('创建顶层文件夹失败:', e); continue; }
    }
    await mergeIntoLocal(remoteTop.children || [], localTop.id);
  }
}

// performSync 中的合并逻辑
const syncMode = (await chrome.storage.local.get(['syncMode'])).syncMode;
if (syncMode === 'merge') {
  try {
    const remote = await fetchRemoteBookmarkData(platform);
    if (remote && remote.bookmarks) {
      await mergeRemoteIntoLocal(remote.bookmarks);
      console.log('合并模式：已把远端书签合并进本地');
    }
  } catch (e) {
    console.warn('合并远端到本地失败（继续以本地为准上传）:', e);
  }
}

function setupAutoSync(intervalMinutes) {
  chrome.alarms.create('autoSync', {
    periodInMinutes: intervalMinutes
  });
  console.log(`自动同步已设置，间隔: ${intervalMinutes} 分钟`);
}

// background.js 消息处理
} else if (request.action === 'updateAutoSync') {
  if (request.enabled) {
    chrome.storage.local.get(['syncInterval'], (result) => {
      setupAutoSync(result.syncInterval || 1440);
    });
  } else {
    chrome.alarms.clear('autoSync');
  }
  sendResponse({ success: true });
}

chrome.alarms.onAlarm.addListener((alarm) => {
  if (alarm.name === 'autoSync') {
    performAutoSync().catch(error => {
      console.error('自动同步失败:', error);
    });
  }
});

async function performAutoSync() {
  const config = await chrome.storage.local.get([
    'githubToken', 'giteeToken', 'githubGistId', 'giteeGistId', 'syncMode'
  ]);

  const bookmarks = await chrome.bookmarks.getTree();
  const localCount = countBookmarks(bookmarks[0]);

  // 对每个已配置的平台执行智能同步
  const platforms = [];
  if (config.githubToken) platforms.push('github');
  if (config.giteeToken) platforms.push('gitee');

  for (const platform of platforms) {
    try {
      const gistId = platform === 'github' ? config.githubGistId : config.giteeGistId;
      const syncMode = config.syncMode;

      // 合并模式：直接走 performSync（内部双向合并）
      if (syncMode === 'merge') {
        await performSync(platform);
        continue;
      }

      if (!gistId) {
        // 没有远程备份，直接上传
        await performSync(platform);
        continue;
      }

      // 覆盖模式：比较数量选择方向
      const remoteCount = await getRemoteBookmarkCount(platform);

      if (remoteCount > localCount) {
        // 远端更多，从远端下载，避免覆盖更多数据
        await restoreFromRemote(platform);
      } else {
        // 本地更多或相等，上传到远端
        await performSync(platform);
      }
    } catch (error) {
      console.error(`${platform} 自动同步失败:`, error);
      // 继续处理下一个平台
    }
  }
}

function flattenBookmarks(treeNode, folderPath = '', out = []) {
  const children = Array.isArray(treeNode) ? treeNode : (treeNode && treeNode.children) || [];
  for (const node of children) {
    const title = node.title || '';
    const path = folderPath ? `${folderPath} / ${title}` : title;
    if (node.url) {
      out.push({ title, url: node.url, folderPath: path });
    }
    if (node.children) {
      flattenBookmarks(node.children, path, out);
    }
  }
  return out;
}

async function analyzeSyncStatus(platform) {
  const localTree = await chrome.bookmarks.getTree();
  const localFlat = flattenBookmarks(localTree);
  let remoteFlat = [];
  let remoteError = null;
  try {
    const remoteData = await fetchRemoteBookmarkData(platform);
    if (remoteData && remoteData.bookmarks) {
      remoteFlat = flattenBookmarks(remoteData.bookmarks);
    }
  } catch (e) {
    remoteError = e.message || String(e);
  }

  // 用 URL 集合做差集
  const localUrls = new Set(localFlat.filter(b => b.url).map(b => b.url));
  const remoteUrls = new Set(remoteFlat.filter(b => b.url).map(b => b.url));

  const localOnlyItems = localFlat.filter(b => b.url && !remoteUrls.has(b.url));
  const remoteOnlyItems = remoteFlat.filter(b => b.url && !localUrls.has(b.url));
  const bothCount = localFlat.filter(b => b.url && remoteUrls.has(b.url)).length;

  const SAMPLE = 50;
  return {
    platform,
    localCount: localFlat.length,
    remoteCount: remoteFlat.length,
    localOnlyCount: localOnlyItems.length,
    remoteOnlyCount: remoteOnlyItems.length,
    bothCount,
    remoteError,
    localOnlyItems: localOnlyItems.slice(0, SAMPLE),
    remoteOnlyItems: remoteOnlyItems.slice(0, SAMPLE),
    localOnlyTotal: localOnlyItems.length,
    remoteOnlyTotal: remoteOnlyItems.length,
    hasMoreLocal: localOnlyItems.length > SAMPLE,
    hasMoreRemote: remoteOnlyItems.length > SAMPLE,
  };
}

// checkStatus 函数中（popup.js）
const identical = !a.remoteError && a.localOnlyCount === 0 && a.remoteOnlyCount === 0;
if (identical) {
  const cur = await chrome.storage.local.get(['hasUnsynced']);
  if (cur.hasUnsynced) {
    await chrome.storage.local.set({ hasUnsynced: false });
    await renderAll();
    toast('本地与远端一致，已自动标记为已同步', 'success');
  }
}

// 验证成功后保存 Token
await chrome.storage.local.set({ [tokenKey]: token });

// 保存用户信息
await chrome.storage.local.set({ [userKey]: res.user });

async function verifyGithubToken(token) {
  const r = await fetch('https://api.github.com/user', {
    headers: { 'Authorization': 'Bearer ' + token, 'Accept': 'application/vnd.github.v3+json' }
  });
  if (!r.ok) {
    const t = await r.text().catch(() => '');
    throw new Error('GitHub 验证失败: ' + r.status + (t ? ' ' + t.slice(0, 120) : ''));
  }
  const u = await r.json();
  return {
    name: u.name || u.login || 'GitHub 用户',
    login: u.login || '',
    avatarUrl: u.avatar_url || ''
  };
}

// popup.js 中的验证流程
const res = await chrome.runtime.sendMessage({ action: 'verifyToken', platform });
if (res && res.success && res.user) {
  await chrome.storage.local.set({ [userKey]: res.user });
  toast(name + ' Token 验证成功', 'success');
} else {
  // 验证失败，清除 Token
  await chrome.storage.local.remove([tokenKey, userKey]);
  toast(name + ' Token 验证失败: ' + ((res && res.error) || '请检查 Token 权限'), 'error');
}

chrome.bookmarks.onCreated.addListener(() => { markUnsynced().catch(e=>console.warn(e)); });
chrome.bookmarks.onRemoved.addListener(() => { markUnsynced().catch(e=>console.warn(e)); });
chrome.bookmarks.onChanged.addListener(() => { markUnsynced().catch(e=>console.warn(e)); });
chrome.bookmarks.onMoved.addListener(() => { markUnsynced().catch(e=>console.warn(e)); });

async function markUnsynced() {
  try {
    const res = await chrome.storage.local.get(['lastSyncCount']);
    const tree = await chrome.bookmarks.getTree();
    const current = countBookmarks(tree[0]);
    const last = res.lastSyncCount !== undefined ? res.lastSyncCount : null;
    // 如果没有 lastSyncCount（首次）且 current>0，视为未同步
    const hasUnsynced = (last === null && current > 0) || (last !== null && current !== last);
    await chrome.storage.local.set({ hasUnsynced });
    await updateActionBadge();
  } catch (e) {
    console.warn('标记未同步失败:', e);
  }
}

await chrome.storage.local.set({
  lastSyncCount: bookmarkCount,
  hasUnsynced: false
});
await updateActionBadge();

async function updateActionBadge() {
  try {
    const res = await chrome.storage.local.get(['hasUnsynced', 'githubToken', 'giteeToken']);
    const has = !!res.hasUnsynced;
    const loggedIn = !!(res.githubToken || res.giteeToken);

    // 未登录任何平台则不显示角标
    if (!loggedIn) {
      chrome.action.setBadgeText({ text: '' });
      return;
    }

    if (has) {
      chrome.action.setBadgeText({ text: '●' });
      chrome.action.setBadgeBackgroundColor({ color: '#FF3B30' });
    } else {
      chrome.action.setBadgeText({ text: '' });
    }
  } catch (e) {
    console.warn('更新角标失败:', e);
  }
}

chrome.storage.onChanged.addListener((changes, areaName) => {
  if (areaName !== 'local') return;
  const keys = Object.keys(changes);
  const watched = ['hasUnsynced', 'githubToken', 'giteeToken', 'lastSyncCount'];
  if (keys.some(k => watched.includes(k))) {
    updateActionBadge().catch(e => console.warn('storage change 更新角标失败:', e));
  }
});

async function cleanupOldGists(platform) {
  const config = await chrome.storage.local.get([
    'githubToken', 'giteeToken', 'githubGistId', 'giteeGistId'
  ]);
  const token = platform === 'github' ? config.githubToken : config.giteeToken;
  if (!token) return;

  const list = platform === 'github'
    ? await fetchGithubGists(token)
    : await fetchGiteeGists(token);

  // 找出所有包含 bookmarks.json 的 Gist
  const candidates = (list || []).filter(g => g.files && g.files['bookmarks.json']);
  if (candidates.length <= 1) return; // 不足两份无需清理

  // 按更新时间倒序，最新的排在最前
  candidates.sort((a, b) => {
    const ta = new Date(a.updated_at || a.created_at || 0).getTime();
    const tb = new Date(b.updated_at || b.created_at || 0).getTime();
    return tb - ta;
  });

  const keep = candidates[0];        // 保留最新
  const remove = candidates.slice(1); // 删除其余
  let deleted = 0;

  for (const g of remove) {
    try {
      if (platform === 'github') await deleteGithubGist(token, g.id);
      else await deleteGiteeGist(token, g.id);
      deleted++;
    } catch (e) {
      console.warn(`[${platform}] 删除旧片段 ${g.id} 失败:`, e);
    }
  }

  // 若本地记录的 gistId 不是保留的最新一份，则更新
  const storedId = platform === 'github' ? config.githubGistId : config.giteeGistId;
  if (storedId !== keep.id) {
    const set = platform === 'github'
      ? { githubGistId: keep.id }
      : { giteeGistId: keep.id };
    await chrome.storage.local.set(set);
  }
}

chrome.runtime.onStartup.addListener(() => {
  updateActionBadge().catch(e=>console.warn(e));
  cleanupOnStartup().catch(e=>console.warn(e));
});

async function cleanupOnStartup() {
  const config = await chrome.storage.local.get([
    'autoCleanupOldGists', 'githubToken', 'giteeToken'
  ]);
  if (config.autoCleanupOldGists === false) return; // 默认开启，可手动关闭
  const platforms = [];
  if (config.githubToken) platforms.push('github');
  if (config.giteeToken) platforms.push('gitee');
  for (const p of platforms) {
    await cleanupOldGists(p);
  }
}

<main class="app-main" id="mainScroll"> ... 主页内容 ... </main>
<main class="app-main settings-view" id="settingsView" hidden> ... 设置内容 ... </main>
<main class="app-main settings-view" id="historyView" hidden> ... 历史内容 ... </main>

function showSettingsView() {
  loadConfig();
  $('mainScroll').hidden = true;
  $('settingsView').hidden = false;
  const header = document.querySelector('.app-header');
  if (header) header.style.display = 'none';
}
function hideSettingsView() {
  $('settingsView').hidden = true;
  $('mainScroll').hidden = false;
  const header = document.querySelector('.app-header');
  if (header) header.style.display = '';
}

async function renderStatus() {
  const { hasUnsynced, syncHistory = [], autoSync = false, githubToken, giteeToken, syncPlatform = 'github' } = 
    await chrome.storage.local.get(['hasUnsynced', 'syncHistory', 'autoSync', 'githubToken', 'giteeToken', 'syncPlatform']);
  const last = syncHistory.find((h) => h.status === 'success');

  $('statusTitleLg').textContent = hasUnsynced ? '有未同步的修改' : '已是最新';
  $('statusDescLg').textContent = hasUnsynced ? '本地书签与远端不一致' : '本地与远端已保持同步';
  $('statusMetaLg').textContent = '最后同步: ' + (last ? formatTimeShort(last.time) : '--');

  // 进度条：未同步显示 40%，已同步显示 100%
  if (hasUnsynced) {
    fill.style.width = '40%';
    pct.textContent = '40%';
  } else {
    fill.style.width = '100%';
    pct.textContent = '100%';
  }

  // 自动同步开关
  badge.textContent = autoSync ? '自动同步' : '自动同步已关闭';

  // 同步对象
  const platformName = syncPlatform === 'gitee' ? 'Gitee' : 'GitHub';
  healthText.textContent = platformName;
}

async function renderTrend() {
  const { syncHistory = [] } = await chrome.storage.local.get(['syncHistory']);
  const dayLabels = ['周一', '周二', '周三', '周四', '周五', '周六', '周日'];
  const now = new Date();
  const dow = (now.getDay() + 6) % 7; // 周一=0
  const startOfWeek = new Date(now);
  startOfWeek.setDate(now.getDate() - dow);
  startOfWeek.setHours(0, 0, 0, 0);

  const days = [];
  for (let i = 0; i < 7; i++) {
    const d = new Date(startOfWeek);
    d.setDate(startOfWeek.getDate() + i);
    const dayStart = d.getTime();
    const dayEnd = dayStart + 86400000;
    const count = syncHistory.filter((h) => h.time >= dayStart && h.time < dayEnd).length;
    days.push({ date: d, label: dayLabels[i], count, isToday: i === dow });
  }

  // 计算较上周变化百分比
  const thisWeekCount = days.reduce((s, d) => s + d.count, 0);
  const lastWeekCount = syncHistory.filter((h) => 
    h.time >= lastWeekStart && h.time < weekStart
  ).length;
  let pct = 0;
  if (lastWeekCount > 0) pct = Math.round(((thisWeekCount - lastWeekCount) / lastWeekCount) * 100);
  else if (thisWeekCount > 0) pct = 100;

  // 渲染柱子
  const max = Math.max(1, ...days.map((d) => d.count));
  chart.innerHTML = days.map((d, i) => {
    const h = Math.max(4, Math.round((d.count / max) * 80));
    const today = d.isToday ? ' today' : '';
    return '<div class="trend-col' + today + '">' +
      '<div class="trend-bar" style="height:' + h + 'px">' + num + '</div>' +
      '<span class="trend-day">' + d.label + '</span>' +
      '</div>';
  }).join('');
}

// 上传同步
const res = await chrome.runtime.sendMessage({ action: 'uploadToRemote', platform: platform.toLowerCase() });

// 下载恢复
const res = await chrome.runtime.sendMessage({ action: 'downloadFromRemote', platform: platform.toLowerCase() });

// 验证 Token
const res = await chrome.runtime.sendMessage({ action: 'verifyToken', platform });

// 分析同步状态
const res = await chrome.runtime.sendMessage({ action: 'analyzeSyncStatus', platform });

// 更新自动同步设置
await chrome.runtime.sendMessage({ action: 'updateAutoSync', enabled: next });

// 清理旧片段
const res = await chrome.runtime.sendMessage({ action: 'cleanupOldGists', platform: 'all' });

chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
  if (request.action === 'syncNow' || request.action === 'uploadToRemote') {
    performSync(request.platform)
      .then(result => sendResponse({ success: true, gistId: result.gistId, count: result.count }))
      .catch(error => sendResponse({ success: false, error: error.message }));
    return true; // 保持消息通道开启（异步响应）
  } else if (request.action === 'downloadFromRemote') {
    restoreFromRemote(request.platform)
      .then(result => sendResponse({ success: true, count: result.count }))
      .catch(error => sendResponse({ success: false, error: error.message }));
    return true;
  }
  // ...其他 action...
});