background.js

// 本文件维护 ImgPrompt 扩展后台服务。
// 本次修改把“禧哈哈灵感集”的本地保存、云端上传和分组同步放到后台执行，避免内容脚本直接承载后端请求逻辑。
// 具体修改点：新增 xihaha 消息处理、Cloudflare Worker 上传、chrome.storage.local 本地灵感库保存，并把生成图片 data URL 传回结果面板。
//
// 2026-07-13 健壮性修复（问题 4/5/6/8/11）：
//  - 问题4：saveToHistory 超出上限时改为循环删除所有超额记录，并在同一事务内 await 完成，修复历史记录无法真正裁剪到 50 条的问题。
//  - 问题5：compressImageBlob 对 PNG/WebP/GIF 等可能带透明通道的图片改用 PNG 输出，避免透明背景被填成黑底影响模型分析。
//  - 问题6：新增 fetchWithTimeout，为正式生成的模型请求（OpenAI 兼容 / Anthropic）加入自动超时（默认 120s），避免接口卡死时进度条永久停留。
//  - 问题8：settings:updated 消息处理改为同步回包并对 sendResponse 做保护，避免 message port closed 告警。
//  - 问题11：将 Supabase URL/Key 抽到 config.js 统一维护，background 不再内联硬编码，减少多处重复。
// 问题3（遥测默认关闭）：trackAnalyticsEvent 原判断为 `analyticsConfig !== false`，因存储键从未被写入，
//   默认 undefined 被判定为开启，且 options 无可见开关，导致 PostHog 遥测默认常开。现改为必须显式
//   为 true 才发送（opt-in），默认即关闭，避免把访问页面 URL 默认上报到第三方。
importScripts("config.js");

const CONFIG = globalThis.ImgPromptConfig || {};
const DEFAULT_SETTINGS = CONFIG.DEFAULT_SETTINGS;
const UI_STRINGS = CONFIG.UI_STRINGS;
const POSTHOG_PROJECT_KEY = CONFIG.POSTHOG_PROJECT_KEY;
const POSTHOG_HOST = CONFIG.POSTHOG_HOST;
const ERROR_CODES = CONFIG.ERROR_CODES;
const ERROR_MESSAGES = CONFIG.ERROR_MESSAGES;
const ANALYTICS_CONFIG_KEY = CONFIG.ANALYTICS_CONFIG_KEY;
const XIHAHA_WORKER_ENDPOINT = CONFIG.XIHAHA_WORKER_ENDPOINT;
const XIHAHA_CATEGORIES_ENDPOINT = CONFIG.XIHAHA_CATEGORIES_ENDPOINT;
const XIHAHA_LOCAL_LIBRARY_KEY = CONFIG.XIHAHA_LOCAL_LIBRARY_KEY || "xihaha_local_inspirations";
// 问题11：Supabase 连接信息统一从 config.js 读取，避免在 background 内联硬编码导致多处维护。
const SUPABASE_URL = CONFIG.SUPABASE_URL || "https://mxcsnyobeboahlctkssq.supabase.co";
const SUPABASE_PUBLISHABLE_KEY =
  CONFIG.SUPABASE_PUBLISHABLE_KEY || "sb_publishable_i4hxK3VR6QYRuSlCiBszoA_G_Ew-2qc";

const MENU_ID = "image-prompt-inspector.generate";
const CLIENT_ID_KEY = "clientId";
const MAX_HISTORY_ITEMS = 50;
// 问题6：正式生成的模型请求超时时间（毫秒）。视觉模型响应较慢，给到 120s；超时后自动中止并按超时错误处理。
const MODEL_REQUEST_TIMEOUT_MS = 120000;

// IndexedDB configuration
const DB_NAME = "ImgPromptDB";
const DB_VERSION = 1;
const HISTORY_STORE = "history";
let dbInstance = null;
const activeRequests = new Map();

// Initialize IndexedDB when service worker starts
initIndexedDB().catch((error) => {
  console.error("[ImgPrompt] Failed to initialize IndexedDB on startup:", error);
});

chrome.runtime.onInstalled.addListener(async (details) => {
  const clientId = await ensureClientId();
  chrome.contextMenus.create({
    id: MENU_ID,
    title: "ImgPrompt",
    contexts: ["image"],
  });

  if (chrome.sidePanel?.setPanelBehavior) {
    await chrome.sidePanel.setPanelBehavior({
      openPanelOnActionClick: true,
    });
  }

  const current = await chrome.storage.local.get(Object.keys(DEFAULT_SETTINGS));
  const nextValues = {};
  for (const [key, value] of Object.entries(DEFAULT_SETTINGS)) {
    if (current[key] === undefined) {
      nextValues[key] = value;
    }
  }
  if (Object.keys(nextValues).length) {
    await chrome.storage.local.set(nextValues);
  }

  // Initialize IndexedDB for history
  try {
    await initIndexedDB();
  } catch (error) {
    console.error("[ImgPrompt] Failed to initialize IndexedDB:", error);
  }

  const installReason = details?.reason || "unknown";
  if (installReason === "install") {
    void safeTrackAnalyticsEvent("extension_installed", {
      clientId,
      installReason,
    });
  } else if (installReason === "update") {
    void safeTrackAnalyticsEvent("extension_updated", {
      clientId,
      installReason,
      previousVersion: details?.previousVersion || "",
    });
  }
});

chrome.contextMenus.onClicked.addListener(async (info, tab) => {
  if (info.menuItemId !== MENU_ID || !tab?.id) {
    return;
  }

  const requestId = crypto.randomUUID();
  await sendTabMessage(tab.id, {
    type: "prompt:start-analysis",
    requestId,
    srcUrl: info.srcUrl || "",
    pageUrl: info.pageUrl || "",
    trigger: "context_menu",
  });
});

chrome.commands.onCommand.addListener(async (command) => {
  if (command !== "capture_screenshot") return;

  const settings = await loadSettings();
  if (settings.snippingShortcutEnabled === false) return;

  const [tab] = await chrome.tabs.query({ active: true, currentWindow: true });
  if (!tab?.id) return;

  try {
    const dataUrl = await chrome.tabs.captureVisibleTab(tab.windowId, { format: "png" });
    await sendTabMessage(tab.id, {
      type: "prompt:start-snipping",
      dataUrl,
    });
  } catch (err) {
    console.error("Failed to capture screenshot:", err);
  }
});

// 记录最近一次激活的“普通网页”标签页 id，供设置页“抓取当前页面”使用。
// 否则当设置页本身处于激活态时，会把设置页当成抓取目标（无图片/无内容脚本）。
let lastWebTabId = null;
if (chrome.tabs?.onActivated) {
  chrome.tabs.onActivated.addListener(async ({ tabId }) => {
    try {
      const tab = await chrome.tabs.get(tabId);
      const url = tab?.url || "";
      if (/^https?:\/\//i.test(url)) {
        lastWebTabId = tabId;
      }
    } catch {
      /* 忽略无权限或临时标签 */
    }
  });
}

chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
  if (message?.type === "analytics:track") {
    safeTrackAnalyticsEvent(message.event, {
      ...(message.properties || {}),
      ...buildAnalyticsContext(message.properties?.pageUrl || sender.tab?.url || ""),
    })
      .then((sent) => sendResponse({ ok: true, sent }))
      .catch((error) => {
        sendResponse({
          ok: false,
          error: error instanceof Error ? error.message : String(error),
        });
      });
    return true;
  }

  if (message?.type === "prompt:open-options") {
    openSidePanelForSender(sender)
      .then(() => sendResponse({ ok: true }))
      .catch((error) => {
        sendResponse({
          ok: false,
          error: error instanceof Error ? error.message : String(error),
        });
      });
    return true;
  }

  // 中转：侧边栏历史记录 → 网页 content script 面板
  if (message?.type === "prompt:relay-history-item") {
    (async () => {
      try {
        const targetTabId = await findBestWebTabId();
        if (!targetTabId) {
          sendResponse({ ok: false, error: "当前窗口无可用网页标签（请先打开一个普通网页）" });
          return;
        }
        // 逐标签尝试，直到有 content script 成功接收
        const webTabIds = (await chrome.tabs.query({ currentWindow: true }))
          .filter(
            (t) =>
              t.id && /^https?:\/\//i.test(t.url || "") && !t.url.startsWith("chrome-extension://"),
          )
          .map((t) => t.id);
        // 把最佳标签排到最前
        const ordered = [targetTabId, ...webTabIds.filter((id) => id !== targetTabId)];

        let lastErr = null;
        for (const tabId of ordered) {
          try {
            await chrome.tabs.sendMessage(tabId, {
              type: "prompt:load-history-item",
              data: message.data,
            });
            sendResponse({ ok: true });
            return;
          } catch (e) {
            lastErr = e;
          }
        }
        sendResponse({
          ok: false,
          error:
            lastErr instanceof Error ? lastErr.message : "所有网页标签均无响应（可能未加载完成）",
        });
      } catch (err) {
        sendResponse({
          ok: false,
          error: err instanceof Error ? err.message : String(err),
        });
      }
    })();
    return true;
  }

  if (message?.type === "prompt:cancel-generation") {
    const controller = activeRequests.get(message.requestId);
    if (controller) {
      controller.abort();
      activeRequests.delete(message.requestId);
      sendResponse({ ok: true, canceled: true });
      return false;
    }
    sendResponse({ ok: true, canceled: false });
    return false;
  }

  if (message?.type === "settings:updated") {
    // 问题8：这是一个“通知型”消息，无需等待转发结果即可回包。
    // 先同步回包（避免消息端口在异步 tabs.query 期间关闭产生 message port closed 告警），
    // 再 fire-and-forget 地把更新转发给所有标签页的内容脚本。
    try {
      sendResponse({ ok: true });
    } catch (error) {
      // 端口可能已被发送方关闭（发送方使用 fire-and-forget），忽略即可。
    }
    chrome.tabs.query({}, (tabs) => {
      tabs.forEach((tab) => {
        if (tab.id) {
          chrome.tabs.sendMessage(tab.id, { type: "settings:updated" }).catch(() => {
            // Ignore errors for tabs where content script is not injected or responsive
          });
        }
      });
    });
    return false;
  }

  if (message?.type === "history:get") {
    getHistory()
      .then((history) => sendResponse({ ok: true, history }))
      .catch((error) => sendResponse({ ok: false, error: String(error) }));
    return true;
  }

  if (message?.type === "history:delete") {
    deleteHistoryItem(message.id)
      .then(() => sendResponse({ ok: true }))
      .catch((error) => sendResponse({ ok: false, error: String(error) }));
    return true;
  }

  if (message?.type === "history:clear") {
    clearHistory()
      .then(() => sendResponse({ ok: true }))
      .catch((error) => sendResponse({ ok: false, error: String(error) }));
    return true;
  }

  if (message?.type === "api:test-connection") {
    testApiConnection(message.settings)
      .then((result) => sendResponse(result))
      .catch((error) => sendResponse({ success: false, error: error.message }));
    return true;
  }

  if (message?.type === "xihaha:get-categories") {
    getXihahaCategories()
      .then((categories) => sendResponse({ ok: true, categories }))
      .catch((error) =>
        sendResponse({ ok: false, error: error instanceof Error ? error.message : String(error) }),
      );
    return true;
  }

  if (message?.type === "xihaha:collect-page-images") {
    collectActiveTabImages()
      .then((result) =>
        sendResponse({
          ok: true,
          images: result.images,
          prompt: result.prompt,
          title: result.title,
          pageUrl: result.pageUrl,
        }),
      )
      .catch((error) =>
        sendResponse({ ok: false, error: error instanceof Error ? error.message : String(error) }),
      );
    return true;
  }

  if (message?.type === "xihaha:save-local") {
    saveXihahaLocalInspiration(message.payload || {})
      .then((item) => sendResponse({ ok: true, item }))
      .catch((error) =>
        sendResponse({ ok: false, error: error instanceof Error ? error.message : String(error) }),
      );
    return true;
  }

  if (message?.type === "xihaha:upload-cloud") {
    uploadXihahaCloudInspiration(message.payload || {})
      .then((result) => sendResponse({ ok: true, result }))
      .catch((error) =>
        sendResponse({ ok: false, error: error instanceof Error ? error.message : String(error) }),
      );
    return true;
  }

  if (message?.type !== "prompt:begin-generation") {
    return false;
  }

  processGeneration(message, sender)
    .then(() => sendResponse({ ok: true }))
    .catch((error) => {
      sendResponse({
        ok: false,
        error: error instanceof Error ? error.message : String(error),
      });
    });

  return true;
});

async function openSidePanelForSender(sender) {
  if (!chrome.sidePanel?.open) {
    throw new Error("当前浏览器不支持侧边栏 API。");
  }

  if (sender.tab?.windowId) {
    await chrome.sidePanel.open({
      windowId: sender.tab.windowId,
    });
    return;
  }

  const [activeTab] = await chrome.tabs.query({
    active: true,
    currentWindow: true,
  });

  if (!activeTab?.windowId) {
    throw new Error("未找到可用窗口来打开侧边栏。");
  }

  await chrome.sidePanel.open({
    windowId: activeTab.windowId,
  });
}

// 找到最适合承载 ImgPrompt 内容面板的网页标签页：
// 优先 lastWebTabId（最近激活的普通网页）→ 其次当前窗口中激活的网页 → 再退化为任意普通网页
async function findBestWebTabId() {
  const isWebUrl = (url) =>
    !!url && /^https?:\/\//i.test(url) && !url.startsWith("chrome-extension://");

  const tabs = await chrome.tabs.query({ currentWindow: true });
  const webTabs = tabs.filter((t) => t.id && isWebUrl(t.url));

  if (!webTabs.length) return null;

  // 1. lastWebTabId 优先
  if (lastWebTabId) {
    const matched = webTabs.find((t) => t.id === lastWebTabId);
    if (matched) return matched.id;
  }

  // 2. 当前激活的网页标签
  const activeWeb = webTabs.find((t) => t.active);
  if (activeWeb) return activeWeb.id;

  // 3. 退化：第一个可用网页
  return webTabs[0].id;
}

function normalizeXihahaPayload(payload = {}) {
  const title = String(payload.title || "").trim();
  const category = String(payload.category || "未分组").trim() || "未分组";
  const prompt = String(payload.prompt || "").trim();
  const imageDataUrl = String(payload.imageDataUrl || "").trim();
  const imageUrl = String(payload.imageUrl || "").trim();

  if (!title) {
    throw new Error("缺少标题。");
  }
  if (!prompt) {
    throw new Error("缺少提示词内容。");
  }
  if (!imageDataUrl && !imageUrl) {
    throw new Error("缺少图片内容或图片链接。");
  }

  return {
    title,
    category,
    prompt,
    imageDataUrl,
    imageUrl,
    pageTitle: String(payload.pageTitle || "").trim(),
    pageUrl: String(payload.pageUrl || "").trim(),
  };
}

async function saveXihahaLocalInspiration(payload) {
  const normalized = normalizeXihahaPayload(payload);
  const stored = await chrome.storage.local.get({ [XIHAHA_LOCAL_LIBRARY_KEY]: [] });
  const currentItems = Array.isArray(stored[XIHAHA_LOCAL_LIBRARY_KEY])
    ? stored[XIHAHA_LOCAL_LIBRARY_KEY]
    : [];
  const item = {
    id: crypto.randomUUID(),
    createdAt: Date.now(),
    source: "img2prompt",
    ...normalized,
  };

  await chrome.storage.local.set({
    [XIHAHA_LOCAL_LIBRARY_KEY]: [item, ...currentItems].slice(0, 500),
  });

  // 同时尽力推送到桌面端「我的灵感」本地收藏：桌面端需运行且桥接服务在监听 127.0.0.1:18765
  pushToDesktopLocalBridge(normalized);

  return item;
}

// 浏览器扩展 → 桌面端本地收藏 的桥接推送（best-effort，桌面端未运行时静默忽略）
const XIHAHA_DESKTOP_BRIDGE_URL = "http://127.0.0.1:18765/api/xihaha/local-inspiration";

async function pushToDesktopLocalBridge(normalized) {
  try {
    const controller = new AbortController();
    const timeout = setTimeout(() => controller.abort(), 4000);
    const response = await fetch(XIHAHA_DESKTOP_BRIDGE_URL, {
      method: "POST",
      headers: { "Content-Type": "application/json; charset=utf-8" },
      body: JSON.stringify({
        title: normalized.title,
        prompt: normalized.prompt,
        group: normalized.category,
        imageUrl: normalized.imageUrl,
        imageDataUrl: normalized.imageDataUrl || undefined,
        sourceUrl: normalized.pageUrl || normalized.pageTitle || "",
        tags: normalized.category && normalized.category !== "未分组" ? [normalized.category] : [],
      }),
      signal: controller.signal,
    });
    clearTimeout(timeout);
    if (!response.ok) {
      console.warn("[ImgPrompt] 桌面端桥接返回非成功状态:", response.status);
    }
  } catch (error) {
    // 桌面端未启动 / 端口未监听 / 被拦截：忽略，保存本地已成功写入扩展本地库
    console.warn(
      "[ImgPrompt] 推送桌面端本地收藏失败（桌面端可能未运行）:",
      error?.message || error,
    );
  }
}

async function uploadXihahaCloudInspiration(payload) {
  const normalized = normalizeXihahaPayload(payload);
  const adminPassword = String(payload.adminPassword || "").trim();

  if (!adminPassword) {
    throw new Error("请先在禧哈哈灵感集设置里填写管理员密码。");
  }
  if (!XIHAHA_WORKER_ENDPOINT) {
    throw new Error("缺少云端上传接口配置。");
  }

  const response = await fetch(XIHAHA_WORKER_ENDPOINT, {
    method: "POST",
    headers: {
      "Content-Type": "application/json; charset=utf-8",
    },
    body: JSON.stringify({
      adminPassword,
      ...normalized,
    }),
  });

  let data = null;
  try {
    data = await response.json();
  } catch (error) {
    data = null;
  }

  if (!response.ok || data?.ok === false) {
    throw new Error(data?.error || `云端上传失败：HTTP ${response.status}`);
  }

  return data || { ok: true };
}

async function getXihahaCategories() {
  // 策略1：优先从 Cloudflare Worker 获取分组
  if (XIHAHA_CATEGORIES_ENDPOINT) {
    try {
      const response = await fetch(XIHAHA_CATEGORIES_ENDPOINT, {
        method: "GET",
        headers: { Accept: "application/json" },
      });
      if (response.ok) {
        const data = await response.json();
        const cats = extractCategories(data);
        if (cats.length > 0) return cats;
      }
    } catch (e) {
      console.warn("[ImgPrompt] Worker categories 端点不可达，改用 Supabase 直连:", e.message);
    }
  }

  // 策略2：Worker 不可达或返回空时，直连 Supabase REST API 兜底
  // 问题11：使用 config.js 统一维护的 SUPABASE_URL / SUPABASE_PUBLISHABLE_KEY，不再内联硬编码。
  try {
    const response = await fetch(
      `${SUPABASE_URL}/rest/v1/inspirations?select=category&order=category.asc`,
      {
        method: "GET",
        headers: {
          apikey: SUPABASE_PUBLISHABLE_KEY,
          authorization: `Bearer ${SUPABASE_PUBLISHABLE_KEY}`,
          Accept: "application/json",
        },
      },
    );
    if (!response.ok) {
      throw new Error(`HTTP ${response.status}`);
    }
    const rows = await response.json();
    const cats = [
      ...new Set(
        rows
          .map((row) => (typeof row.category === "string" ? row.category.trim() : ""))
          .filter(Boolean),
      ),
    ];
    return cats;
  } catch (e) {
    console.warn("[ImgPrompt] Supabase 分组直连也失败:", e.message);
    return [];
  }
}

function extractCategories(data) {
  const rawCategories = Array.isArray(data)
    ? data
    : Array.isArray(data?.categories)
      ? data.categories
      : Array.isArray(data?.data)
        ? data.data
        : [];
  return rawCategories
    .map((item) => {
      if (typeof item === "string") return item;
      return item?.name || item?.category || item?.title || "";
    })
    .map((category) => String(category || "").trim())
    .filter(Boolean);
}

// 向当前激活标签页的内容脚本请求页面图片列表（供设置页"抓取当前页面"使用）
// 抓取当前页面的图片/提示词/标题/地址，完整透传给设置页。
// 优先抓取"最近激活的普通网页"，避免设置页自身作为激活标签时抓不到任何内容。
// 若 lastWebTabId 无结果则遍历所有非扩展标签页尝试。
async function collectActiveTabImages() {
  const empty = { images: [], prompt: "", title: "", pageUrl: "" };

  // 收集候选标签页：当前活跃 + 最近访问的网页 + 所有其他网页标签
  const [activeTab] = await chrome.tabs.query({ active: true, currentWindow: true });
  const allTabs = await chrome.tabs.query({ currentWindow: true });
  const webTabs = allTabs.filter(
    (t) => t.id && /^https?:\/\//i.test(t.url || "") && !t.url.startsWith("chrome-extension://"),
  );

  // 去重候选列表（保持顺序：active → lastWebTab → 其他网页）
  const candidateIds = [];
  if (activeTab?.id) candidateIds.push(activeTab.id);
  if (lastWebTabId && lastWebTabId !== activeTab?.id) candidateIds.push(lastWebTabId);
  for (const t of webTabs) {
    if (!candidateIds.includes(t.id)) candidateIds.push(t.id);
  }

  // 记录最佳候选（有图片的那个）用于日志
  let bestResult = null;

  for (const tabId of candidateIds) {
    try {
      const response = await chrome.tabs.sendMessage(tabId, { type: "xihaha:collect-page-images" });
      if (response?.ok) {
        const images = Array.isArray(response.images) ? response.images : [];
        const result = {
          images,
          prompt: String(response.prompt || ""),
          title: String(response.title || ""),
          pageUrl: String(response.pageUrl || ""),
        };
        // 有图片直接采用；无图片但有 prompt/title 也保留为备选
        if (images.length > 0) return result;
        if (!bestResult && (result.prompt || result.title)) bestResult = result;
      }
    } catch (e) {
      // 该标签无内容脚本或不可达，继续下一个
      console.warn(`[ImgPrompt] 标签 ${tabId} 抓取跳过:`, e?.message || e);
      if (!bestResult) {
        // 尝试动态注入内容脚本并重试
        try {
          await chrome.scripting.executeScript({
            target: { tabId: tabId },
            files: ["config.js", "content.js"],
          });
          const retryResponse = await chrome.tabs.sendMessage(tabId, {
            type: "xihaha:collect-page-images",
          });
          if (
            retryResponse &&
            retryResponse.ok &&
            (retryResponse.images?.length > 0 || retryResponse.prompt || retryResponse.title)
          ) {
            bestResult = retryResponse;
            continue; // 成功获取，继续下一个
          }
        } catch (injectErr) {
          // 注入失败，继续执行基础后备逻辑
          console.warn(`[ImgPrompt] 标签 ${tabId} 注入回退失败:`, injectErr?.message || injectErr);
        }

        // 如果依然没有结果，获取起码的页面标题和URL
        if (!bestResult) {
          try {
            const tab = await chrome.tabs.get(tabId);
            if (tab && tab.title) {
              bestResult = {
                images: [],
                prompt: "",
                title: String(tab.title || ""),
                pageUrl: String(tab.url || ""),
              };
            }
          } catch (err) {
            // 忽略
          }
        }
      }
    }
  }

  // 所有候选都没有图片但可能有文字内容
  return bestResult || empty;
}

async function processGeneration(message, sender) {
  const tabId = sender.tab?.id;
  if (!tabId) {
    throw new Error("Missing tab id.");
  }

  const { requestId, srcUrl, imageDataUrl, pageContext = {}, trigger = "unknown" } = message;
  const controller = new AbortController();
  activeRequests.set(requestId, controller);
  const startedAt = Date.now();
  const settings = await loadSettings();
  const lang = settings.uiLanguage || "zh";
  const dict = UI_STRINGS[lang] || UI_STRINGS.zh;

  try {
    await sendProgress(tabId, requestId, 8, dict.preparing, "config");
    void safeTrackAnalyticsEvent("generation_started", {
      requestId,
      trigger,
      model: settings.model,
      ...buildAnalyticsContext(pageContext.pageUrl || sender.tab?.url || ""),
    });
    validateSettings(settings, lang);

    await sendProgress(tabId, requestId, 22, dict.fetchingImage, "image");

    // Always fetch and compress in background (unified logic)
    const imageInput = await fetchAndCompressImage(
      imageDataUrl || srcUrl,
      settings.maxImageEdge || 1024,
      controller.signal,
    );

    if (!imageInput) {
      throw new Error(dict.base64Failed);
    }

    await sendProgress(tabId, requestId, 48, dict.callingModel, "request");
    const rawResult = await requestPromptFromModel({
      settings,
      imageInput,
      pageContext,
      signal: controller.signal,
    });

    await sendProgress(tabId, requestId, 88, dict.organizingPrompts, "parse");
    const prompts = normalizePromptResult(rawResult, lang);

    await sendTabMessage(tabId, {
      type: "prompt:result",
      requestId,
      progress: 100,
      prompts,
      source: {
        srcUrl,
        imageDataUrl: imageInput,
      },
    });
    void safeTrackAnalyticsEvent("generation_succeeded", {
      requestId,
      trigger,
      model: settings.model,
      durationMs: Date.now() - startedAt,
      ...buildAnalyticsContext(pageContext.pageUrl || sender.tab?.url || ""),
    });
    void saveToHistory({
      prompts,
      srcUrl,
      imageDataUrl: imageInput,
      pageUrl: pageContext.pageUrl || sender.tab?.url || "",
      model: settings.model,
      trigger,
    }).then(() => {
      // Notify options page to refresh history
      chrome.runtime.sendMessage({ type: "history:updated" }).catch(() => {});
    });
  } catch (error) {
    if (controller.signal.aborted) {
      await sendTabMessage(tabId, {
        type: "prompt:canceled",
        requestId,
        errorCode: ERROR_CODES.CANCELED,
      });
      void safeTrackAnalyticsEvent("generation_canceled", {
        requestId,
        trigger,
        durationMs: Date.now() - startedAt,
        ...buildAnalyticsContext(pageContext.pageUrl || sender.tab?.url || ""),
      });
      return;
    }

    // Classify error
    const errorCode = classifyError(error);
    const userMessage = getUserErrorMessage(errorCode, lang);

    await sendTabMessage(tabId, {
      type: "prompt:error",
      requestId,
      errorCode,
      message: userMessage,
    });

    void safeTrackAnalyticsEvent("generation_failed", {
      requestId,
      trigger,
      model: (await loadSettings()).model,
      durationMs: Date.now() - startedAt,
      errorCode,
      errorMessage:
        error instanceof Error ? error.message.slice(0, 240) : String(error).slice(0, 240),
      ...buildAnalyticsContext(pageContext.pageUrl || sender.tab?.url || ""),
    });
    throw error;
  } finally {
    activeRequests.delete(requestId);
  }
}

async function loadSettings() {
  const stored = await chrome.storage.local.get(Object.keys(DEFAULT_SETTINGS));
  return {
    ...DEFAULT_SETTINGS,
    ...stored,
  };
}

async function ensureClientId() {
  const stored = await chrome.storage.local.get(CLIENT_ID_KEY);
  if (stored[CLIENT_ID_KEY]) {
    return stored[CLIENT_ID_KEY];
  }

  const clientId = crypto.randomUUID();
  await chrome.storage.local.set({
    [CLIENT_ID_KEY]: clientId,
  });
  return clientId;
}

function buildAnalyticsContext(rawUrl) {
  if (!rawUrl) {
    return {};
  }

  try {
    const url = new URL(rawUrl);
    return {
      pageHost: url.host,
      pageProtocol: url.protocol.replace(":", ""),
    };
  } catch (error) {
    return {};
  }
}

async function trackAnalyticsEvent(eventName, properties = {}) {
  if (!eventName) {
    return false;
  }

  // 问题3：遥测改为 opt-in——必须显式存储为 true 才发送，默认（undefined/任何非 true 值）一律关闭。
  const analyticsConfig = await chrome.storage.local.get(ANALYTICS_CONFIG_KEY);
  const analyticsEnabled = analyticsConfig[ANALYTICS_CONFIG_KEY] === true;
  if (!analyticsEnabled) {
    return false;
  }

  if (!POSTHOG_PROJECT_KEY || !POSTHOG_HOST) {
    return false;
  }

  const clientId = properties.clientId || (await ensureClientId());
  const captureUrl = `${String(POSTHOG_HOST).replace(/\/+$/, "")}/capture/`;
  const response = await fetch(captureUrl, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      api_key: POSTHOG_PROJECT_KEY,
      event: eventName,
      distinct_id: clientId,
      timestamp: new Date().toISOString(),
      properties: {
        ...properties,
        distinct_id: clientId,
        $lib: "imgprompt-extension",
        $lib_version: chrome.runtime.getManifest().version,
        extensionVersion: chrome.runtime.getManifest().version,
      },
    }),
  });

  if (!response.ok) {
    throw new Error(`Analytics request failed (${response.status})`);
  }

  return true;
}

async function safeTrackAnalyticsEvent(eventName, properties = {}) {
  try {
    return await trackAnalyticsEvent(eventName, properties);
  } catch (error) {
    return false;
  }
}

async function saveToHistory(record) {
  try {
    console.log("[ImgPrompt] Saving to history:", {
      prompts: record.prompts?.zh?.substring(0, 50),
    });
    const db = await getDB();
    const tx = db.transaction(HISTORY_STORE, "readwrite");
    const store = tx.objectStore(HISTORY_STORE);

    const item = {
      id: crypto.randomUUID(),
      timestamp: Date.now(),
      ...record,
    };

    await new Promise((resolve, reject) => {
      const request = store.add(item);
      request.onsuccess = () => {
        console.log("[ImgPrompt] History item saved successfully");
        resolve();
      };
      request.onerror = (event) => {
        console.error("[ImgPrompt] Failed to save history item:", event.target.error);
        reject(event.target.error);
      };
    });

    // Check if we exceed max items and delete oldest if needed
    const count = await new Promise((resolve, reject) => {
      const request = store.count();
      request.onsuccess = () => resolve(request.result);
      request.onerror = reject;
    });

    // 问题4：超过上限时，循环删除所有超额的最旧记录，并在同一事务内 await 完成，
    // 避免旧实现只删 1 条且 cursor.delete() 时机不稳导致历史缓慢超出上限。
    if (count > MAX_HISTORY_ITEMS) {
      const excess = count - MAX_HISTORY_ITEMS;
      await new Promise((resolve, reject) => {
        const index = store.index("timestamp");
        // timestamp 升序（next）即从最旧开始
        const cursorRequest = index.openCursor(null, "next");
        let removed = 0;
        cursorRequest.onsuccess = (event) => {
          const cursor = event.target.result;
          if (cursor && removed < excess) {
            cursor.delete();
            removed += 1;
            cursor.continue();
          } else {
            resolve();
          }
        };
        cursorRequest.onerror = (event) => reject(event.target.error);
      });
    }

    return true;
  } catch (error) {
    console.error("[ImgPrompt] Failed to save history:", error);
    return false;
  }
}

async function getHistory() {
  try {
    const db = await getDB();
    const tx = db.transaction(HISTORY_STORE, "readonly");
    const store = tx.objectStore(HISTORY_STORE);
    const index = store.index("timestamp");

    return new Promise((resolve, reject) => {
      const request = index.openCursor(null, "prev");
      const results = [];

      request.onsuccess = (event) => {
        const cursor = event.target.result;
        if (cursor && results.length < MAX_HISTORY_ITEMS) {
          results.push(cursor.value);
          cursor.continue();
        } else {
          console.log("[ImgPrompt] Retrieved history items:", results.length);
          resolve(results);
        }
      };
      request.onerror = (event) => {
        console.error("[ImgPrompt] Failed to retrieve history:", event.target.error);
        reject(event.target.error);
      };
    });
  } catch (error) {
    console.error("[ImgPrompt] Failed to get history:", error);
    return [];
  }
}

async function deleteHistoryItem(id) {
  try {
    const db = await getDB();
    const tx = db.transaction(HISTORY_STORE, "readwrite");
    const store = tx.objectStore(HISTORY_STORE);

    await new Promise((resolve, reject) => {
      const request = store.delete(id);
      request.onsuccess = resolve;
      request.onerror = reject;
    });

    return true;
  } catch (error) {
    console.error("[ImgPrompt] Failed to delete history item:", error);
    return false;
  }
}

async function clearHistory() {
  try {
    const db = await getDB();
    const tx = db.transaction(HISTORY_STORE, "readwrite");
    const store = tx.objectStore(HISTORY_STORE);

    await new Promise((resolve, reject) => {
      const request = store.clear();
      request.onsuccess = resolve;
      request.onerror = reject;
    });

    return true;
  } catch (error) {
    console.error("[ImgPrompt] Failed to clear history:", error);
    return false;
  }
}

// IndexedDB helper functions
function initIndexedDB() {
  return new Promise((resolve, reject) => {
    const request = indexedDB.open(DB_NAME, DB_VERSION);

    request.onerror = () => reject(request.error);
    request.onsuccess = () => {
      dbInstance = request.result;
      resolve(dbInstance);
    };

    request.onupgradeneeded = (event) => {
      const db = event.target.result;
      if (!db.objectStoreNames.contains(HISTORY_STORE)) {
        const store = db.createObjectStore(HISTORY_STORE, { keyPath: "id" });
        store.createIndex("timestamp", "timestamp", { unique: false });
      }
    };
  });
}

function getDB() {
  if (dbInstance) {
    return Promise.resolve(dbInstance);
  }
  return initIndexedDB();
}

function validateSettings(settings, lang = "zh") {
  const isEn = lang === "en";
  if (!settings.apiEndpoint) {
    throw new Error(
      isEn
        ? "Please fill in the API Endpoint in the settings panel."
        : "请先在插件设置页填写 API Endpoint。",
    );
  }
  if (!settings.apiKey) {
    throw new Error(
      isEn ? "Please fill in the API Key in the settings panel." : "请先在插件设置页填写 API Key。",
    );
  }
  if (!settings.model) {
    throw new Error(
      isEn
        ? "Please fill in the Model name in the settings panel."
        : "请先在插件设置页填写模型名称。",
    );
  }
}

async function requestPromptFromModel({ settings, imageInput, pageContext, signal }) {
  const pageHints = [
    pageContext.altText ? `Image alt: ${pageContext.altText}` : "",
    pageContext.title ? `Page title: ${pageContext.title}` : "",
    pageContext.pageUrl ? `Page URL: ${pageContext.pageUrl}` : "",
  ]
    .filter(Boolean)
    .join("\n");

  const requestFormat = resolveRequestFormat(settings);
  if (requestFormat === "anthropic") {
    return await requestViaAnthropic({
      settings,
      imageInput,
      pageHints,
      signal,
    });
  }

  return await requestViaOpenAICompatible({
    settings,
    imageInput,
    pageHints,
    signal,
  });
}

function resolveRequestFormat(settings) {
  if (settings.requestFormat && settings.requestFormat !== "auto") {
    return settings.requestFormat;
  }

  if (
    String(settings.model || "")
      .toLowerCase()
      .startsWith("claude")
  ) {
    return "anthropic";
  }

  return "openai";
}

function buildSystemPrompt(settings = {}) {
  const baseSystemPrompt = ImgPromptConfig.DEFAULT_SETTINGS.systemPrompt;
  const recreateModeSystemOverlay = ImgPromptConfig.RECREATE_MODE_SYSTEM_OVERLAY;
  const parts = [baseSystemPrompt];

  if (settings.recreateMode && recreateModeSystemOverlay) {
    parts.push(recreateModeSystemOverlay);
  }

  return parts.filter(Boolean).join("\n\n");
}

// Build user prompt with smart stacking logic
function buildUserPrompt(userPrompt, pageHints, settings = {}) {
  const basePrompt = ImgPromptConfig.BASE_USER_PROMPT;
  const genericUserConstraints = ImgPromptConfig.GENERIC_USER_CONSTRAINTS;
  const recreateModeUserOverlay = ImgPromptConfig.RECREATE_MODE_USER_OVERLAY;
  const englishPromptRequirement = ImgPromptConfig.ENGLISH_PROMPT_REQUIREMENT;
  const presets = ImgPromptConfig.USER_PROMPT_PRESETS;

  // Check if userPrompt matches a preset (not general)
  let scenePrompt = "";
  if (userPrompt && presets) {
    for (const [key, presetText] of Object.entries(presets)) {
      if (key !== "general" && userPrompt === basePrompt + presetText) {
        // User selected a specific scene preset
        scenePrompt = presetText;
        break;
      }
    }
  }

  // Build final prompt: base + scene focus (if any) + page hints
  const parts = [basePrompt];
  if (scenePrompt) {
    parts.push(scenePrompt);
  }
  if (pageHints) {
    parts.push(pageHints);
  }
  if (genericUserConstraints) {
    parts.push(genericUserConstraints);
  }
  if (settings.recreateMode && recreateModeUserOverlay) {
    parts.push(recreateModeUserOverlay);
  }
  if (englishPromptRequirement) {
    parts.push(englishPromptRequirement);
  }

  return parts.filter(Boolean).join("\n\n");
}

// 问题6：带自动超时的 fetch。使用本地 AbortController 控制超时，同时桥接父级 signal（用户手动取消）。
// 超时中止不会置位父级 signal，因此上层会按“超时错误”处理而非“已取消”。
async function fetchWithTimeout(
  url,
  options = {},
  timeoutMs = MODEL_REQUEST_TIMEOUT_MS,
  parentSignal,
) {
  const controller = new AbortController();
  const timeoutId = setTimeout(() => {
    controller.abort(new DOMException("Request timed out", "TimeoutError"));
  }, timeoutMs);

  const onParentAbort = () => controller.abort(parentSignal?.reason);
  if (parentSignal) {
    if (parentSignal.aborted) {
      controller.abort(parentSignal.reason);
    } else {
      parentSignal.addEventListener("abort", onParentAbort, { once: true });
    }
  }

  try {
    return await fetch(url, { ...options, signal: controller.signal });
  } finally {
    clearTimeout(timeoutId);
    if (parentSignal) {
      parentSignal.removeEventListener("abort", onParentAbort);
    }
  }
}

async function requestViaOpenAICompatible({ settings, imageInput, pageHints, signal }) {
  const modelName = String(settings.model || "").toLowerCase();
  if (modelName.startsWith("deepseek")) {
    const isEn = (settings.uiLanguage || "zh") === "en";
    throw new Error(
      isEn
        ? "DeepSeek currently doesn't support the image format used by this extension. Please use gpt-*, gemini-*, or claude-* models instead."
        : "当前 DeepSeek 接口不支持这个插件使用的图片输入格式，无法用于图片提示词生成。请改用 gpt-*、gemini-* 或 claude-* 模型。",
    );
  }

  const requestBody = {
    model: settings.model,
    temperature: Number(settings.temperature) || 1,
    messages: [
      {
        role: "system",
        content: buildSystemPrompt(settings),
      },
      {
        role: "user",
        content: [
          {
            type: "text",
            text: buildUserPrompt(settings.userPrompt, pageHints, settings),
          },
          {
            type: "image_url",
            image_url: {
              url: imageInput,
            },
          },
        ],
      },
    ],
  };

  // 问题6：改用带超时的 fetch，避免接口卡死时永久停留在“正在调用模型”。
  const response = await fetchWithTimeout(
    settings.apiEndpoint,
    {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        Authorization: `Bearer ${settings.apiKey}`,
      },
      body: JSON.stringify(requestBody),
    },
    MODEL_REQUEST_TIMEOUT_MS,
    signal,
  );

  if (!response.ok) {
    const errorText = await response.text();
    const isEn = (settings.uiLanguage || "zh") === "en";
    const status = response.status;

    // Provide more specific error messages based on status code
    let statusMsg;
    if (status === 401) {
      statusMsg = isEn ? "Authentication failed (invalid API key)" : "认证失败（API 密钥无效）";
    } else if (status === 403) {
      statusMsg = isEn ? "Access forbidden (check API permissions)" : "访问被拒绝（检查 API 权限）";
    } else if (status === 429) {
      statusMsg = isEn ? "Rate limit exceeded" : "调用次数超限";
    } else if (status === 408 || status >= 500) {
      statusMsg = isEn ? "Server error" : "服务器错误";
    } else {
      statusMsg = isEn ? "Request failed" : "请求失败";
    }

    throw new Error(`${statusMsg} (${status}): ${errorText.slice(0, 240)}`);
  }

  const payload = await response.json();
  const content = extractOpenAICompatibleContent(payload);
  if (!content) {
    const isEn = (settings.uiLanguage || "zh") === "en";
    throw new Error(isEn ? "Model returned empty content." : "模型返回内容为空，无法生成提示词。");
  }

  return content;
}

async function requestViaAnthropic({ settings, imageInput, pageHints, signal }) {
  const endpoint = normalizeAnthropicEndpoint(settings.apiEndpoint);
  const imageSource = toAnthropicImageSource(imageInput);
  if (!imageSource) {
    const isEn = (settings.uiLanguage || "zh") === "en";
    throw new Error(
      isEn
        ? "Claude mode requires base64 image data. This image could not be safely read. Please try another image or use an OpenAI compatible model."
        : "Claude 模式要求可直接上传的 base64 图片数据。当前图片无法安全读取，请换一张图或改用 OpenAI 兼容模型。",
    );
  }

  // 问题6：改用带超时的 fetch，避免接口卡死时永久停留在“正在调用模型”。
  const response = await fetchWithTimeout(
    endpoint,
    {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "x-api-key": settings.apiKey,
        "anthropic-version": settings.anthropicVersion || "2023-06-01",
      },
      body: JSON.stringify({
        model: settings.model,
        system: buildSystemPrompt(settings),
        max_tokens: settings.recreateMode ? 2600 : 1400,
        temperature: Number(settings.temperature) || 1,
        messages: [
          {
            role: "user",
            content: [
              {
                type: "text",
                text: buildUserPrompt(settings.userPrompt, pageHints, settings),
              },
              {
                type: "image",
                source: imageSource,
              },
            ],
          },
        ],
      }),
    },
    MODEL_REQUEST_TIMEOUT_MS,
    signal,
  );

  if (!response.ok) {
    const errorText = await response.text();
    const isEn = (settings.uiLanguage || "zh") === "en";
    const status = response.status;

    let statusMsg;
    if (status === 401) {
      statusMsg = isEn ? "Authentication failed (invalid API key)" : "认证失败（API 密钥无效）";
    } else if (status === 403) {
      statusMsg = isEn ? "Access forbidden" : "访问被拒绝";
    } else if (status === 429) {
      statusMsg = isEn ? "Rate limit exceeded" : "调用次数超限";
    } else if (status >= 500) {
      statusMsg = isEn ? "Server error" : "服务器错误";
    } else {
      statusMsg = isEn ? "Request failed" : "请求失败";
    }

    throw new Error(`${statusMsg} (${status}): ${errorText.slice(0, 280)}`);
  }

  const payload = await response.json();
  const textBlock = Array.isArray(payload?.content)
    ? payload.content.find((item) => item?.type === "text")
    : null;
  const content = textBlock?.text || "";
  if (!content) {
    throw new Error("模型返回内容为空，无法生成提示词。");
  }

  return content;
}

function normalizeAnthropicEndpoint(apiEndpoint) {
  if (apiEndpoint.endsWith("/v1/messages")) {
    return apiEndpoint;
  }
  if (apiEndpoint.endsWith("/v1/chat/completions")) {
    return apiEndpoint.replace(/\/v1\/chat\/completions$/, "/v1/messages");
  }
  return apiEndpoint;
}

function toAnthropicImageSource(imageInput) {
  if (typeof imageInput !== "string" || !imageInput.startsWith("data:")) {
    return null;
  }

  const match = imageInput.match(/^data:([^;]+);base64,(.+)$/);
  if (!match) {
    return null;
  }

  return {
    type: "base64",
    media_type: match[1],
    data: match[2],
  };
}

function normalizePromptResult(rawResult, lang = "zh") {
  const dict = UI_STRINGS[lang] || UI_STRINGS.zh;
  let parsed = rawResult;
  if (typeof rawResult === "string") {
    try {
      parsed = JSON.parse(rawResult);
    } catch (error) {
      const cleaned = sanitizeJsonLikeText(rawResult);
      if (!cleaned) {
        throw new Error(dict.noJson);
      }

      try {
        parsed = JSON.parse(cleaned);
      } catch (innerError) {
        throw new Error(dict.noJson);
      }
    }
  }

  // Require at least one structured field to be present
  const hasStructuredContent =
    parsed?.image_type ||
    parsed?.background ||
    parsed?.subject ||
    parsed?.style ||
    parsed?.lighting ||
    parsed?.color_palette ||
    parsed?.zh ||
    parsed?.en;

  if (!hasStructuredContent) {
    throw new Error(dict.missingFields);
  }

  // Build result - pass through ALL fields from AI response
  const result = {};

  // Copy structured visual analysis fields directly
  if (parsed?.image_type) result.image_type = parsed.image_type;
  if (parsed?.aspect_ratio) result.aspect_ratio = parsed.aspect_ratio;
  if (parsed?.background) result.background = parsed.background;
  if (parsed?.subject) result.subject = parsed.subject;
  if (parsed?.surrounding_elements) result.surrounding_elements = parsed.surrounding_elements;
  if (parsed?.composition) result.composition = parsed.composition;
  if (parsed?.text_content) result.text_content = parsed.text_content;
  if (parsed?.style) result.style = parsed.style;
  if (parsed?.lighting) result.lighting = parsed.lighting;
  if (parsed?.color_palette) result.color_palette = parsed.color_palette;
  if (parsed?.negative) result.negative = parsed.negative;
  if (parsed?.parameters) result.parameters = parsed.parameters;

  // For backward compatibility: if AI still returns zh/en, preserve them
  // but DO NOT generate them from structured fields (avoid redundancy)
  if (parsed?.zh) result.zh = String(parsed.zh).trim();
  if (parsed?.en) result.en = String(parsed.en).trim();

  return result;
}

function extractOpenAICompatibleContent(payload) {
  const messageContent = payload?.choices?.[0]?.message?.content;
  if (typeof messageContent === "string") {
    return messageContent;
  }

  if (Array.isArray(messageContent)) {
    const textParts = messageContent
      .map((item) => {
        if (typeof item === "string") {
          return item;
        }
        if (item?.type === "text") {
          return item.text || "";
        }
        return "";
      })
      .filter(Boolean);

    if (textParts.length) {
      return textParts.join("\n");
    }
  }

  return "";
}

function sanitizeJsonLikeText(rawText) {
  const text = String(rawText || "").trim();
  if (!text) {
    return "";
  }

  const fencedMatch = text.match(/```(?:json)?\s*([\s\S]*?)\s*```/i);
  if (fencedMatch?.[1]) {
    return fencedMatch[1].trim();
  }

  const firstBrace = text.indexOf("{");
  const lastBrace = text.lastIndexOf("}");
  if (firstBrace !== -1 && lastBrace !== -1 && lastBrace > firstBrace) {
    return text.slice(firstBrace, lastBrace + 1).trim();
  }

  return "";
}

async function fetchAndCompressImage(srcUrl, maxEdge = 1024, signal) {
  if (!srcUrl) {
    return "";
  }

  // If already a data URL, compress it
  if (srcUrl.startsWith("data:")) {
    return await compressImageDataUrl(srcUrl, maxEdge);
  }

  // Fetch the image
  const response = await fetch(srcUrl, {
    method: "GET",
    cache: "no-store",
    signal,
  });

  if (!response.ok) {
    throw new Error(`Failed to fetch image: ${response.status} ${response.statusText}`);
  }

  const contentType = response.headers.get("content-type");
  if (contentType && !contentType.startsWith("image/")) {
    console.warn("[ImgPrompt] Fetched source is not an image:", contentType);
  }

  const blob = await response.blob();
  if (blob.size === 0) {
    throw new Error("Fetched image blob is empty.");
  }

  return await compressImageBlob(blob, maxEdge);
}

async function compressImageDataUrl(dataUrl, maxEdge = 1024) {
  const res = await fetch(dataUrl);
  const blob = await res.blob();
  return await compressImageBlob(blob, maxEdge);
}

async function compressImageBlob(blob, maxEdge = 1024) {
  const imgBitmap = await createImageBitmap(blob);
  const { width: sw, height: sh } = imgBitmap;

  let tw = sw;
  let th = sh;
  if (Math.max(sw, sh) > maxEdge) {
    const scale = maxEdge / Math.max(sw, sh);
    tw = Math.round(sw * scale);
    th = Math.round(sh * scale);
  }

  const canvas = new OffscreenCanvas(tw, th);
  const ctx = canvas.getContext("2d");
  if (!ctx) throw new Error("Could not get OffscreenCanvas context");

  ctx.drawImage(imgBitmap, 0, 0, tw, th);
  imgBitmap.close();

  // 问题5：保留透明通道。PNG/WebP/GIF/SVG 等可能带 alpha 的格式统一用 PNG 输出，
  // 避免把透明背景填成黑底，导致送给模型分析的画面与原图不一致。
  // 不透明来源（JPEG 等）仍用 JPEG 压缩以控制体积。
  const sourceType = String(blob.type || "").toLowerCase();
  const keepAlpha = /png|webp|gif|svg/.test(sourceType);

  const outBlob = keepAlpha
    ? await canvas.convertToBlob({ type: "image/png" })
    : await canvas.convertToBlob({ type: "image/jpeg", quality: 0.92 });

  return await blobToDataUrl(outBlob);
}

function blobToDataUrl(blob) {
  return new Promise((resolve, reject) => {
    const reader = new FileReader();
    reader.onloadend = () => resolve(String(reader.result || ""));
    reader.onerror = () => reject(new Error("Failed to read blob."));
    reader.readAsDataURL(blob);
  });
}

async function sendProgress(tabId, requestId, progress, text, stage) {
  await sendTabMessage(tabId, {
    type: "prompt:progress",
    requestId,
    progress,
    text,
    stage,
  });
}

async function sendTabMessage(tabId, message) {
  try {
    await chrome.tabs.sendMessage(tabId, message);
  } catch (error) {
    const messageText = error instanceof Error ? error.message : String(error);
    if (!messageText.includes("Receiving end does not exist")) {
      throw error;
    }
  }
}

// Error classification
function classifyError(error) {
  const message = error instanceof Error ? error.message : String(error);
  const lowerMessage = message.toLowerCase();

  // Network errors
  if (
    lowerMessage.includes("failed to fetch") ||
    lowerMessage.includes("networkerror") ||
    lowerMessage.includes("network error")
  ) {
    return ERROR_CODES.NETWORK_ERROR;
  }

  // Image fetch errors
  if (
    lowerMessage.includes("fetch") &&
    (lowerMessage.includes("image") || lowerMessage.includes("404"))
  ) {
    return ERROR_CODES.IMAGE_FETCH_FAILED;
  }

  // Missing config
  if (
    lowerMessage.includes("api endpoint") ||
    lowerMessage.includes("模型名称") ||
    lowerMessage.includes("model name")
  ) {
    return ERROR_CODES.API_INVALID_RESPONSE;
  }

  // Image processing
  if (
    lowerMessage.includes("base64") ||
    lowerMessage.includes("image processing") ||
    lowerMessage.includes("bitmap") ||
    lowerMessage.includes("图片处理失败")
  ) {
    return ERROR_CODES.IMAGE_PROCESSING_FAILED;
  }

  // API auth errors (401, 403)
  if (
    message.includes("(401)") ||
    message.includes("(403)") ||
    lowerMessage.includes("authentication") ||
    lowerMessage.includes("api key") ||
    lowerMessage.includes("unauthorized") ||
    lowerMessage.includes("forbidden") ||
    lowerMessage.includes("认证失败") ||
    lowerMessage.includes("访问被拒绝")
  ) {
    return ERROR_CODES.API_AUTH_FAILED;
  }

  // Rate limiting (429)
  if (
    message.includes("(429)") ||
    lowerMessage.includes("rate limit") ||
    lowerMessage.includes("too many requests")
  ) {
    return ERROR_CODES.API_RATE_LIMITED;
  }

  // Timeout
  if (
    lowerMessage.includes("timeout") ||
    lowerMessage.includes("timed out") ||
    lowerMessage.includes("abort") ||
    lowerMessage.includes("aborted") ||
    message.includes("(408)")
  ) {
    return ERROR_CODES.API_TIMEOUT;
  }

  // JSON parse errors
  if (
    lowerMessage.includes("json") ||
    lowerMessage.includes("parse") ||
    lowerMessage.includes("invalid json")
  ) {
    return ERROR_CODES.JSON_PARSE_FAILED;
  }

  // Missing fields
  if (
    lowerMessage.includes("zh/en") ||
    lowerMessage.includes("missing") ||
    lowerMessage.includes("field")
  ) {
    return ERROR_CODES.MISSING_FIELDS;
  }

  // Empty content
  if (
    lowerMessage.includes("empty content") ||
    lowerMessage.includes("内容为空") ||
    lowerMessage.includes("empty response")
  ) {
    return ERROR_CODES.EMPTY_RESPONSE;
  }

  // API errors (4xx, 5xx)
  if (/\(\d{3}\)/.test(message)) {
    return ERROR_CODES.API_INVALID_RESPONSE;
  }

  return ERROR_CODES.UNKNOWN;
}

function getUserErrorMessage(errorCode, lang = "zh") {
  const messages = ERROR_MESSAGES[lang] || ERROR_MESSAGES.zh;
  return messages[errorCode] || messages[ERROR_CODES.UNKNOWN];
}

async function testApiConnection(settings) {
  try {
    const controller = new AbortController();
    const timeoutId = setTimeout(() => controller.abort(), 10000);

    const format = resolveRequestFormat(settings);
    const requestBody = {
      model: settings.model,
      max_tokens: 100,
      messages: [{ role: "user", content: "Hi" }],
    };

    const response = await fetch(settings.apiEndpoint, {
      method: "POST",
      signal: controller.signal,
      headers: {
        "Content-Type": "application/json",
        ...(format === "anthropic"
          ? {
              "x-api-key": settings.apiKey,
              "anthropic-version": settings.anthropicVersion || "2023-06-01",
            }
          : { Authorization: `Bearer ${settings.apiKey}` }),
      },
      body: JSON.stringify(requestBody),
    });

    clearTimeout(timeoutId);

    if (response.ok) {
      return { success: true, message: "连接成功!" };
    } else {
      const errorText = await response.text();
      return { success: false, error: `HTTP ${response.status}: ${errorText.slice(0, 200)}` };
    }
  } catch (error) {
    if (error.name === "AbortError") {
      return { success: false, error: "请求超时(10秒)" };
    }
    return { success: false, error: error.message };
  }
}