background.js

import { buildPrompt, normalizeCard } from "./src/prompts.js";
import {
  clearHistory,
  getHistory,
  removeHistoryEntry,
  saveHistoryEntry
} from "./src/storage.js";
import {
  formatTimecode,
  mergeAdjacentSegments,
  dedupeNumericList,
  buildTranscriptPayload
} from "./src/subtitle-utils.js";

if (chrome.sidePanel?.setPanelBehavior) {
  chrome.sidePanel.setPanelBehavior({ openPanelOnActionClick: true }).catch(() => {});
}

chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
  if (message?.type === "ANALYZE_CURRENT_PAGE") {
    handleAnalyzeCurrentPage()
      .then((card) => sendResponse({ ok: true, card }))
      .catch((error) => sendResponse({ ok: false, error: formatError(error) }));
    return true;
  }

  if (message?.type === "ANALYZE_URL") {
    handleAnalyzeUrl(message.url)
      .then((card) => sendResponse({ ok: true, card }))
      .catch((error) => sendResponse({ ok: false, error: formatError(error) }));
    return true;
  }

  if (message?.type === "GET_SETTINGS") {
    getSettings().then((settings) => sendResponse({ ok: true, settings }));
    return true;
  }

  if (message?.type === "GET_HISTORY") {
    getHistory().then((history) => sendResponse({ ok: true, history }));
    return true;
  }

  if (message?.type === "SAVE_CARD") {
    saveCard(message.card)
      .then((history) => sendResponse({ ok: true, history }))
      .catch((error) => sendResponse({ ok: false, error: formatError(error) }));
    return true;
  }

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

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

  if (message?.type === "DOWNLOAD_CARD") {
    downloadCardAsset(message)
      .then(() => sendResponse({ ok: true }))
      .catch((error) => sendResponse({ ok: false, error: formatError(error) }));
    return true;
  }

  return false;
});

async function handleAnalyzeCurrentPage() {
  const [tab] = await chrome.tabs.query({ active: true, currentWindow: true });
  if (!tab?.id || !tab.url) {
    throw new Error("没有找到当前标签页。");
  }

  const page = await extractFromTab(tab.id);
  return buildCard(page);
}

async function handleAnalyzeUrl(url) {
  const safeUrl = ensureUrl(url);
  const hostname = new URL(safeUrl).hostname;
  if (hostname.includes("youtube.com") || hostname === "youtu.be") {
    throw new Error("YouTube 暂不支持“分析这个链接”。请先打开视频页面，再用“读取当前页面”。");
  }
  const tab = await chrome.tabs.create({ url: safeUrl, active: false });

  try {
    await waitForTabComplete(tab.id);
    const page = await extractFromTab(tab.id);
    return buildCard(page);
  } finally {
    if (tab.id) {
      chrome.tabs.remove(tab.id).catch(() => {});
    }
  }
}

async function extractFromTab(tabId) {
  await pingTab(tabId);
  const response = await chrome.tabs.sendMessage(tabId, { type: "EXTRACT_PAGE" });
  if (!response?.ok) {
    throw new Error(response?.error || "页面内容提取失败。");
  }
  return {
    ...response.payload,
    tabId
  };
}

async function pingTab(tabId) {
  try {
    await chrome.tabs.sendMessage(tabId, { type: "PING" });
  } catch (error) {
    await chrome.scripting.executeScript({
      target: { tabId },
      files: ["content-script.js"]
    });
  }
}

async function buildCard(page) {
  page = await enrichVideoPage(page);
  const settings = await getSettings();
  validateSettings(settings);
  validatePageForAnalysis(page);

  const prompt = buildPrompt(page);
  const response = await requestCompletion({
    providerFormat: settings.providerFormat,
    endpoint: settings.baseUrl,
    apiKey: settings.apiKey,
    model: settings.model,
    prompt
  });

  const content = await extractResponseText(response, settings.providerFormat);
  if (!content) {
    throw new Error("模型没有返回可解析的内容。");
  }

  const parsed = tryParseJson(content);
  const card = normalizeCard(parsed, {
    sourceType: page.pageType,
    sourceUrl: page.url,
    sourceTitle: page.title,
    provider: settings.providerFormat,
    model: settings.model
  });

  await saveCard(card);
  return card;
}

async function getSettings() {
  const defaults = {
    providerFormat: "openai",
    baseUrl: "https://api.openai.com/v1",
    model: "gpt-4.1-mini",
    apiKey: ""
  };
  return chrome.storage.sync.get(defaults);
}

function validateSettings(settings) {
  if (!settings.apiKey?.trim()) {
    throw new Error("请先在设置页填写 API Key。");
  }
  if (!settings.baseUrl?.trim()) {
    throw new Error("请先填写 API Base URL。");
  }
  if (!settings.model?.trim()) {
    throw new Error("请先填写模型名。");
  }
}

function validatePageForAnalysis(page) {
  if (page.pageType !== "video") {
    return;
  }

  if (!["youtube", "bilibili", "douyin"].includes(page.videoPlatform || "")) {
    throw new Error("当前仅支持 B站、YouTube、抖音 的视频分析。");
  }

  const transcriptText = page.video?.transcript?.text?.trim();
  const hasChapters = Array.isArray(page.video?.chapters) && page.video.chapters.length > 0;

  if (!transcriptText && !hasChapters) {
    throw new Error(page.videoError || "当前视频没有可用字幕或章节信息，暂时无法分析。");
  }
}

async function enrichVideoPage(page) {
  if (page.pageType !== "video") {
    return page;
  }

  // 如果已有字幕，直接使用
  if (page.video?.transcript?.text?.trim()) {
    return page;
  }

  // 如果没有字幕但视频已有章节信息，使用章节作为时间轴
  if (page.video?.chapters?.length) {
    return {
      ...page,
      timestamps: page.video.chapters.map((chapter) => ({
        time: chapter.time,
        context: chapter.title
      })),
      videoError: ""
    };
  }

  // 尝试获取字幕
  try {
    if (page.videoPlatform === "bilibili") {
      const transcript = await fetchBilibiliTranscript(page.video);
      return {
        ...page,
        video: {
          ...page.video,
          transcript
        },
        timestamps: transcript.segments.map((item) => ({
          time: item.timecode,
          context: item.text
        })),
        videoError: ""
      };
    }

    if (page.videoPlatform === "douyin") {
      const enrichedVideo = await fetchDouyinVideoData(page.video);
      return {
        ...page,
        video: enrichedVideo,
        timestamps: enrichedVideo.transcript.segments.map((item) => ({
          time: item.timecode,
          context: item.text
        })),
        videoError: ""
      };
    }

    if (page.videoPlatform === "youtube" && page.tabId) {
      const enrichedVideo = await fetchYoutubeVideoDataFromTab(page.tabId, page.video);
      return {
        ...page,
        video: enrichedVideo,
        timestamps: enrichedVideo.transcript.segments.map((item) => ({
          time: item.timecode,
          context: item.text
        })),
        videoError: ""
      };
    }
  } catch (error) {
    // 字幕获取失败，检查是否有章节信息可以降级使用
    if (page.video?.chapters?.length) {
      return {
        ...page,
        timestamps: page.video.chapters.map((chapter) => ({
          time: chapter.time,
          context: chapter.title
        })),
        videoError: ""
      };
    }
    return {
      ...page,
      videoError: formatError(error)
    };
  }

  return page;
}

function waitForTabComplete(tabId) {
  return new Promise((resolve, reject) => {
    let settled = false;
    const timeoutId = setTimeout(() => {
      if (settled) {
        return;
      }
      settled = true;
      chrome.tabs.onUpdated.removeListener(listener);
      reject(new Error("页面加载超时，请重试。"));
    }, 20000);

    function listener(updatedTabId, info, tab) {
      if (settled) {
        return;
      }
      if (updatedTabId === tabId && info.status === "complete" && !tab.pendingUrl) {
        settled = true;
        clearTimeout(timeoutId);
        chrome.tabs.onUpdated.removeListener(listener);
        resolve();
      }
    }

    chrome.tabs.onUpdated.addListener(listener);
    chrome.tabs
      .get(tabId)
      .then((tab) => {
        if (settled) {
          return;
        }
        if (tab.status === "complete" && !tab.pendingUrl) {
          settled = true;
          clearTimeout(timeoutId);
          chrome.tabs.onUpdated.removeListener(listener);
          resolve();
        }
      })
      .catch(() => {});
  });
}

function ensureUrl(raw) {
  const value = String(raw || "").trim();
  if (!value) {
    throw new Error("请输入要分析的链接。");
  }
  try {
    return new URL(value).toString();
  } catch (error) {
    return new URL(`https://${value}`).toString();
  }
}

function trimTrailingSlash(value) {
  return value.replace(/\/+$/, "");
}

function tryParseJson(content) {
  try {
    return JSON.parse(content);
  } catch (error) {
    const match = content.match(/\{[\s\S]*\}/);
    if (!match) {
      throw new Error("模型返回的不是合法 JSON。");
    }
    return JSON.parse(match[0]);
  }
}

async function safeReadText(response) {
  try {
    return (await response.text()).slice(0, 400);
  } catch (error) {
    return "";
  }
}

function formatError(error) {
  return error instanceof Error ? error.message : String(error);
}

async function requestCompletion({ providerFormat, endpoint, apiKey, model, prompt }) {
  if (providerFormat === "anthropic") {
    return requestAnthropic({ endpoint, apiKey, model, prompt });
  }
  return requestOpenAICompatible({ endpoint, apiKey, model, prompt });
}

async function fetchBilibiliTranscript(video) {
  const bvid = video?.identifiers?.bvid;
  const cid = video?.identifiers?.cid;
  const cidCandidates = Array.isArray(video?.identifiers?.cidCandidates)
    ? video.identifiers.cidCandidates
    : [];
  const aid = video?.identifiers?.aid;
  const durationSeconds = video?.durationSeconds || null;

  const candidateList = dedupeNumericList([cid, ...cidCandidates]);

  if (!bvid || !candidateList.length) {
    throw new Error("无法识别当前 B站 视频信息，暂时无法分析。");
  }

  let lastError = "这个 B站 视频没有可用字幕，暂时无法分析。";
  const attempts = [];

  for (const currentCid of candidateList) {
    try {
      const transcript = await fetchSingleBilibiliTranscript({
        bvid,
        aid,
        cid: currentCid,
        durationSeconds
      });

      return transcript;
    } catch (error) {
      lastError = formatError(error);
      attempts.push(`cid=${currentCid}: ${lastError}`);
    }
  }

  throw new Error(`${lastError}${attempts.length ? `；尝试记录：${attempts.slice(0, 6).join(" | ")}` : ""}`);
}

async function fetchDouyinVideoData(video) {
  const captions = Array.isArray(video?.subtitleMeta?.captions) ? video.subtitleMeta.captions : [];
  if (!captions.length) {
    throw new Error("这个抖音视频没有可用字幕，暂时无法分析。");
  }

  const selectedCaption = selectDouyinCaption(captions);
  if (!selectedCaption?.url) {
    throw new Error("这个抖音视频没有可用字幕，暂时无法分析。");
  }

  const response = await fetch(selectedCaption.url);
  if (!response.ok) {
    throw new Error(`抖音字幕请求失败 (${response.status})`);
  }

  const data = await response.json();
  const transcript = buildTranscriptPayload(normalizeDouyinSubtitleBody(data), video?.durationSeconds || null);
  if (!transcript.text.trim()) {
    throw new Error("这个抖音视频没有可解析字幕，暂时无法分析。");
  }

  return {
    ...video,
    subtitleMeta: {
      languageCode: selectedCaption.lang || "",
      trackName: selectedCaption.lang || "",
      isAutoGenerated: false
    },
    transcript
  };
}

async function fetchSingleBilibiliTranscript({ bvid, aid, cid, durationSeconds }) {
  const apiUrl = new URL("https://api.bilibili.com/x/player/v2");
  apiUrl.searchParams.set("cid", String(cid));
  apiUrl.searchParams.set("bvid", String(bvid));
  if (aid) {
    apiUrl.searchParams.set("aid", String(aid));
  }

  const response = await fetch(apiUrl.toString());
  if (!response.ok) {
    throw new Error(`B站字幕接口请求失败 (${response.status})`);
  }

  const data = await response.json();
  const subtitle = data?.data?.subtitle;
  const subtitles = subtitle?.subtitles || [];

  if (!subtitles.length) {
    if (subtitle?.need_login_subtitle) {
      throw new Error("这个 B站 视频字幕需要登录后才能获取，当前无法分析。");
    }
    throw new Error(`cid=${cid} 没有可用字幕`);
  }

  const selectedSubtitle = selectBilibiliSubtitle(subtitles);
  const subtitleUrl = selectedSubtitle.subtitle_url?.startsWith("//")
    ? `https:${selectedSubtitle.subtitle_url}`
    : selectedSubtitle.subtitle_url;

  if (!subtitleUrl) {
    throw new Error(`cid=${cid} 没有可用字幕地址`);
  }

  const subtitleResponse = await fetch(subtitleUrl);
  if (!subtitleResponse.ok) {
    throw new Error(`B站字幕文件请求失败 (${subtitleResponse.status})`);
  }

  const subtitleJson = await subtitleResponse.json();
  const segments = (subtitleJson?.body || [])
    .map((item) => ({
      startSeconds: Number(item.from || 0),
      endSeconds: Number(item.to || 0),
      text: String(item.content || "").trim()
    }))
    .filter((item) => item.text)
    .filter((item) => !durationSeconds || item.startSeconds <= durationSeconds + 0.5);

  if (!segments.length) {
    throw new Error(`cid=${cid} 字幕内容为空`);
  }

  return buildTranscriptPayload(segments, durationSeconds);
}

async function fetchYoutubeVideoDataFromTab(tabId, fallbackVideo) {
  let result;
  try {
    result = await executeYoutubeScriptWithRetry(tabId);
  } catch (error) {
    const message = formatError(error);
    if (isMissingTabError(message)) {
      throw new Error("目标 YouTube 页面已关闭或刚刚刷新，请停稳后重试。");
    }
    throw error;
  }

  if (!result?.ok) {
    throw new Error(result?.error || "当前 YouTube 视频无法读取字幕。");
  }

  return {
    ...fallbackVideo,
    ...result.video
  };
}

async function executeYoutubeScriptWithRetry(tabId) {
  await waitForTabReady(tabId);

  try {
    const [{ result }] = await chrome.scripting.executeScript({
      target: { tabId },
      world: "MAIN",
      func: async () => {
      function sanitizeText(value) {
        return String(value || "").replace(/\s+/g, " ").trim();
      }

      /**
       * 选择最优的 YouTube 字幕轨道
       * 评分规则：
       * - 人工字幕优先（+10 分）
       * - 中文字幕优先（+6 分）
       * - 英文字幕次之（+4 分）
       */
      function scoreTrack(track) {
        const language = String(track?.languageCode || "");
        let score = 0;

        // 人工字幕优先（asr = auto-generated，非 asr 是人工字幕）
        if (track?.kind !== "asr") {
          score += 10;
        }

        // 中文字幕优先
        if (language.startsWith("zh")) {
          score += 6;
        }

        // 英文字幕次之
        if (language.startsWith("en")) {
          score += 4;
        }

        return score;
      }

      function selectTrack(tracks) {
        return [...tracks].sort((left, right) => scoreTrack(right) - scoreTrack(left))[0];
      }

      function decodeHtml(text) {
        const textarea = document.createElement("textarea");
        textarea.innerHTML = text;
        return textarea.value;
      }

      function parseXmlTranscript(xmlText) {
        const xml = new DOMParser().parseFromString(xmlText, "text/xml");
        return Array.from(xml.querySelectorAll("text"))
          .map((node) => {
            const text = sanitizeText(decodeHtml(node.textContent || ""));
            if (!text) {
              return null;
            }
            const startSeconds = parseFloat(node.getAttribute("start") || "0");
            const duration = parseFloat(node.getAttribute("dur") || "0");
            return {
              startSeconds,
              endSeconds: startSeconds + duration,
              text
            };
          })
          .filter(Boolean);
      }

      function withQuery(url, params) {
        const parsed = new URL(url);
        Object.entries(params).forEach(([key, value]) => parsed.searchParams.set(key, value));
        return parsed.toString();
      }

      function mergeSegments(segments) {
        const merged = [];
        for (const segment of segments) {
          const text = sanitizeText(segment.text || "");
          if (!text) continue;
          const current = {
            startSeconds: Number(segment.startSeconds || 0),
            endSeconds: Number(segment.endSeconds || segment.startSeconds || 0),
            text
          };
          const previous = merged[merged.length - 1];
          if (previous && current.startSeconds - previous.endSeconds <= 0.35 && previous.text.length < 120) {
            previous.endSeconds = Math.max(previous.endSeconds, current.endSeconds);
            previous.text = `${previous.text} ${current.text}`.trim();
          } else {
            merged.push(current);
          }
        }
        return merged;
      }

      function formatTimecode(totalSeconds) {
        const rounded = Math.max(0, Math.floor(Number(totalSeconds) || 0));
        const hours = Math.floor(rounded / 3600);
        const minutes = Math.floor((rounded % 3600) / 60);
        const seconds = rounded % 60;
        if (hours > 0) {
          return [hours, minutes, seconds].map((value) => String(value).padStart(2, "0")).join(":");
        }
        return [minutes, seconds].map((value) => String(value).padStart(2, "0")).join(":");
      }

      function buildTranscriptPayload(segments, durationSeconds) {
        const cleaned = mergeSegments(segments)
          .map((item) => ({
            startSeconds: item.startSeconds,
            endSeconds: item.endSeconds,
            timecode: formatTimecode(item.startSeconds),
            text: item.text
          }))
          .filter((item) => item.text)
          .filter((item) => !durationSeconds || item.startSeconds <= durationSeconds + 0.5)
          .slice(0, 400);

        return {
          durationSeconds,
          text: cleaned.map((item) => `${item.timecode} ${item.text}`).join("\n"),
          segments: cleaned
        };
      }

      function parseVisibleTranscriptFromDom() {
        const segmentNodes = document.querySelectorAll(
          'ytd-transcript-segment-renderer, [target-id^="transcript-segment-"]'
        );
        const segments = Array.from(segmentNodes)
          .map((node) => {
            const timeText =
              node.querySelector('.segment-timestamp')?.textContent ||
              node.querySelector('[class*="timestamp"]')?.textContent ||
              "";
            const bodyText =
              node.querySelector('.segment-text')?.textContent ||
              node.querySelector('[class*="segment-text"]')?.textContent ||
              node.textContent ||
              "";
            const timecode = String(timeText || "").trim();
            const text = sanitizeText(bodyText.replace(timecode, ""));
            if (!timecode || !text) {
              return null;
            }
            const startSeconds = parseTimecode(timecode);
            if (startSeconds == null) {
              return null;
            }
            return {
              startSeconds,
              endSeconds: startSeconds,
              text
            };
          })
          .filter(Boolean);

        return segments;
      }

      function parseTimecode(value) {
        const parts = String(value || "")
          .trim()
          .split(":")
          .map((part) => Number(part));
        if (!parts.length || parts.some((part) => Number.isNaN(part))) {
          return null;
        }
        if (parts.length === 3) {
          return parts[0] * 3600 + parts[1] * 60 + parts[2];
        }
        if (parts.length === 2) {
          return parts[0] * 60 + parts[1];
        }
        return null;
      }

      const playerResponse = window.ytInitialPlayerResponse || window.ytplayer?.config?.args?.player_response && JSON.parse(window.ytplayer.config.args.player_response);
      const details = playerResponse?.videoDetails || {};
      const trackList = playerResponse?.captions?.playerCaptionsTracklistRenderer?.captionTracks || [];

      if (!trackList.length) {
        const domSegments = parseVisibleTranscriptFromDom();
        if (domSegments.length) {
          const durationSeconds = parseInt(details.lengthSeconds || "0", 10) || null;
          return {
            ok: true,
            video: {
              platform: "youtube",
              channelName: details.author || "",
              description: String(details.shortDescription || "").trim(),
              durationSeconds,
              subtitleMeta: {
                languageCode: "",
                trackName: "visible-transcript-panel",
                isAutoGenerated: false
              },
              transcript: buildTranscriptPayload(domSegments, durationSeconds)
            }
          };
        }
        return { ok: false, error: "这个 YouTube 视频没有可用字幕，暂时无法分析。" };
      }

      const selectedTrack = selectTrack(trackList);
      if (!selectedTrack?.baseUrl) {
        return { ok: false, error: "这个 YouTube 视频没有可用字幕地址，暂时无法分析。" };
      }

      let segments = [];

      const xmlResponse = await fetch(selectedTrack.baseUrl, { credentials: "include" });
      if (xmlResponse.ok) {
        const xmlText = await xmlResponse.text();
        segments = parseXmlTranscript(xmlText);
      }

      if (!segments.length) {
        const jsonResponse = await fetch(withQuery(selectedTrack.baseUrl, { fmt: "json3" }), { credentials: "include" });
        if (jsonResponse.ok) {
          const text = await jsonResponse.text();
          if (text.trim()) {
            try {
              const json = JSON.parse(text);
              segments = (json?.events || [])
                .map((event) => {
                  const segmentText = sanitizeText((event?.segs || []).map((seg) => seg?.utf8 || "").join(""));
                  if (!segmentText) {
                    return null;
                  }
                  return {
                    startSeconds: (event.tStartMs || 0) / 1000,
                    endSeconds: ((event.tStartMs || 0) + (event.dDurationMs || 0)) / 1000,
                    text: segmentText
                  };
                })
                .filter(Boolean);
            } catch (error) {}
          }
        }
      }

      if (!segments.length) {
        const domSegments = parseVisibleTranscriptFromDom();
        if (domSegments.length) {
          return {
            ok: true,
            video: {
              platform: "youtube",
              channelName: details.author || "",
              description: String(details.shortDescription || "").trim(),
              durationSeconds: parseInt(details.lengthSeconds || "0", 10) || null,
              subtitleMeta: {
                languageCode: selectedTrack.languageCode || "",
                trackName: "visible-transcript-panel",
                isAutoGenerated: selectedTrack.kind === "asr"
              },
              transcript: buildTranscriptPayload(domSegments, parseInt(details.lengthSeconds || "0", 10) || null)
            }
          };
        }
        return { ok: false, error: "这个 YouTube 视频字幕内容为空，暂时无法分析。" };
      }

      const durationSeconds = parseInt(details.lengthSeconds || "0", 10) || null;
      return {
        ok: true,
        video: {
          platform: "youtube",
          channelName: details.author || "",
          description: String(details.shortDescription || "").trim(),
          durationSeconds,
          subtitleMeta: {
            languageCode: selectedTrack.languageCode || "",
            trackName: selectedTrack.name?.simpleText || selectedTrack.vssId || "",
            isAutoGenerated: selectedTrack.kind === "asr"
          },
          transcript: buildTranscriptPayload(segments, durationSeconds)
        }
      };
      }
    });
    return result;
  } catch (error) {
    const message = formatError(error);
    if (!shouldRetryMainWorldInjection(message)) {
      throw error;
    }

    await waitForTabReady(tabId);
    const [{ result }] = await chrome.scripting.executeScript({
      target: { tabId },
      world: "MAIN",
      func: async () => {
        function sanitizeText(value) {
          return String(value || "").replace(/\s+/g, " ").trim();
        }

        function scoreTrack(track) {
          const language = String(track?.languageCode || "");
          let score = 0;
          if (track?.kind !== "asr") {
            score += 10;
          }
          if (language.startsWith("zh")) {
            score += 6;
          }
          if (language.startsWith("en")) {
            score += 4;
          }
          return score;
        }

        function selectTrack(tracks) {
          return [...tracks].sort((left, right) => scoreTrack(right) - scoreTrack(left))[0];
        }

        function decodeHtml(text) {
          const textarea = document.createElement("textarea");
          textarea.innerHTML = text;
          return textarea.value;
        }

        function parseXmlTranscript(xmlText) {
          const xml = new DOMParser().parseFromString(xmlText, "text/xml");
          return Array.from(xml.querySelectorAll("text"))
            .map((node) => {
              const text = sanitizeText(decodeHtml(node.textContent || ""));
              if (!text) {
                return null;
              }
              const startSeconds = parseFloat(node.getAttribute("start") || "0");
              const duration = parseFloat(node.getAttribute("dur") || "0");
              return {
                startSeconds,
                endSeconds: startSeconds + duration,
                text
              };
            })
            .filter(Boolean);
        }

        function withQuery(url, params) {
          const parsed = new URL(url);
          Object.entries(params).forEach(([key, value]) => parsed.searchParams.set(key, value));
          return parsed.toString();
        }

        function mergeSegments(segments) {
          const merged = [];
          for (const segment of segments) {
            const text = sanitizeText(segment.text || "");
            if (!text) continue;
            const current = {
              startSeconds: Number(segment.startSeconds || 0),
              endSeconds: Number(segment.endSeconds || segment.startSeconds || 0),
              text
            };
            const previous = merged[merged.length - 1];
            if (previous && current.startSeconds - previous.endSeconds <= 0.35 && previous.text.length < 120) {
              previous.endSeconds = Math.max(previous.endSeconds, current.endSeconds);
              previous.text = `${previous.text} ${current.text}`.trim();
            } else {
              merged.push(current);
            }
          }
          return merged;
        }

        function formatTimecode(totalSeconds) {
          const rounded = Math.max(0, Math.floor(Number(totalSeconds) || 0));
          const hours = Math.floor(rounded / 3600);
          const minutes = Math.floor((rounded % 3600) / 60);
          const seconds = rounded % 60;
          if (hours > 0) {
            return [hours, minutes, seconds].map((value) => String(value).padStart(2, "0")).join(":");
          }
          return [minutes, seconds].map((value) => String(value).padStart(2, "0")).join(":");
        }

        function buildTranscriptPayload(segments, durationSeconds) {
          const cleaned = mergeSegments(segments)
            .map((item) => ({
              startSeconds: item.startSeconds,
              endSeconds: item.endSeconds,
              timecode: formatTimecode(item.startSeconds),
              text: item.text
            }))
            .filter((item) => item.text)
            .filter((item) => !durationSeconds || item.startSeconds <= durationSeconds + 0.5)
            .slice(0, 400);

          return {
            durationSeconds,
            text: cleaned.map((item) => `${item.timecode} ${item.text}`).join("\n"),
            segments: cleaned
          };
        }

        function parseVisibleTranscriptFromDom() {
          const segmentNodes = document.querySelectorAll(
            'ytd-transcript-segment-renderer, [target-id^="transcript-segment-"]'
          );
          const segments = Array.from(segmentNodes)
            .map((node) => {
              const timeText =
                node.querySelector('.segment-timestamp')?.textContent ||
                node.querySelector('[class*="timestamp"]')?.textContent ||
                "";
              const bodyText =
                node.querySelector('.segment-text')?.textContent ||
                node.querySelector('[class*="segment-text"]')?.textContent ||
                node.textContent ||
                "";
              const timecode = String(timeText || "").trim();
              const text = sanitizeText(bodyText.replace(timecode, ""));
              if (!timecode || !text) {
                return null;
              }
              const startSeconds = parseTimecode(timecode);
              if (startSeconds == null) {
                return null;
              }
              return {
                startSeconds,
                endSeconds: startSeconds,
                text
              };
            })
            .filter(Boolean);

          return segments;
        }

        function parseTimecode(value) {
          const parts = String(value || "")
            .trim()
            .split(":")
            .map((part) => Number(part));
          if (!parts.length || parts.some((part) => Number.isNaN(part))) {
            return null;
          }
          if (parts.length === 3) {
            return parts[0] * 3600 + parts[1] * 60 + parts[2];
          }
          if (parts.length === 2) {
            return parts[0] * 60 + parts[1];
          }
          return null;
        }

        const playerResponse = window.ytInitialPlayerResponse || window.ytplayer?.config?.args?.player_response && JSON.parse(window.ytplayer.config.args.player_response);
        const details = playerResponse?.videoDetails || {};
        const trackList = playerResponse?.captions?.playerCaptionsTracklistRenderer?.captionTracks || [];

        if (!trackList.length) {
          const domSegments = parseVisibleTranscriptFromDom();
          if (domSegments.length) {
            const durationSeconds = parseInt(details.lengthSeconds || "0", 10) || null;
            return {
              ok: true,
              video: {
                platform: "youtube",
                channelName: details.author || "",
                description: String(details.shortDescription || "").trim(),
                durationSeconds,
                subtitleMeta: {
                  languageCode: "",
                  trackName: "visible-transcript-panel",
                  isAutoGenerated: false
                },
                transcript: buildTranscriptPayload(domSegments, durationSeconds)
              }
            };
          }
          return { ok: false, error: "这个 YouTube 视频没有可用字幕，暂时无法分析。" };
        }

        const selectedTrack = selectTrack(trackList);
        if (!selectedTrack?.baseUrl) {
          return { ok: false, error: "这个 YouTube 视频没有可用字幕地址，暂时无法分析。" };
        }

        let segments = [];

        const xmlResponse = await fetch(selectedTrack.baseUrl, { credentials: "include" });
        if (xmlResponse.ok) {
          const xmlText = await xmlResponse.text();
          segments = parseXmlTranscript(xmlText);
        }

        if (!segments.length) {
          const jsonResponse = await fetch(withQuery(selectedTrack.baseUrl, { fmt: "json3" }), { credentials: "include" });
          if (jsonResponse.ok) {
            const text = await jsonResponse.text();
            if (text.trim()) {
              try {
                const json = JSON.parse(text);
                segments = (json?.events || [])
                  .map((event) => {
                    const segmentText = sanitizeText((event?.segs || []).map((seg) => seg?.utf8 || "").join(""));
                    if (!segmentText) {
                      return null;
                    }
                    return {
                      startSeconds: (event.tStartMs || 0) / 1000,
                      endSeconds: ((event.tStartMs || 0) + (event.dDurationMs || 0)) / 1000,
                      text: segmentText
                    };
                  })
                  .filter(Boolean);
              } catch (error) {}
            }
          }
        }

        if (!segments.length) {
          const domSegments = parseVisibleTranscriptFromDom();
          if (domSegments.length) {
            return {
              ok: true,
              video: {
                platform: "youtube",
                channelName: details.author || "",
                description: String(details.shortDescription || "").trim(),
                durationSeconds: parseInt(details.lengthSeconds || "0", 10) || null,
                subtitleMeta: {
                  languageCode: selectedTrack.languageCode || "",
                  trackName: "visible-transcript-panel",
                  isAutoGenerated: selectedTrack.kind === "asr"
                },
                transcript: buildTranscriptPayload(domSegments, parseInt(details.lengthSeconds || "0", 10) || null)
              }
            };
          }
          return { ok: false, error: "这个 YouTube 视频字幕内容为空，暂时无法分析。" };
        }

        const durationSeconds = parseInt(details.lengthSeconds || "0", 10) || null;
        return {
          ok: true,
          video: {
            platform: "youtube",
            channelName: details.author || "",
            description: String(details.shortDescription || "").trim(),
            durationSeconds,
            subtitleMeta: {
              languageCode: selectedTrack.languageCode || "",
              trackName: selectedTrack.name?.simpleText || selectedTrack.vssId || "",
              isAutoGenerated: selectedTrack.kind === "asr"
            },
            transcript: buildTranscriptPayload(segments, durationSeconds)
          }
        };
      }
    });
    return result;
  }
}

function shouldRetryMainWorldInjection(message) {
  return (
    message.includes("Frame with ID 0 was removed") ||
    message.includes("No tab with id") ||
    message.includes("No frame with id") ||
    message.includes("The tab was closed") ||
    message.includes("Cannot access contents of the page")
  );
}

async function waitForTabReady(tabId, timeoutMs = 10000) {
  const start = Date.now();
  while (Date.now() - start < timeoutMs) {
    try {
      const tab = await chrome.tabs.get(tabId);
      if (tab?.status === "complete" && !tab.pendingUrl) {
        return;
      }
    } catch (error) {
      if (isMissingTabError(formatError(error))) {
        throw new Error("目标 YouTube 页面已关闭或刚刚刷新，请停稳后重试。");
      }
    }
    await sleep(250);
  }
}

function sleep(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

function isMissingTabError(message) {
  return (
    message.includes("No tab with id") ||
    message.includes("The tab was closed") ||
    message.includes("Tabs cannot be edited right now")
  );
}

/**
 * 选择最优的 Bilibili 字幕轨道
 * 评分规则：
 * - 人工字幕优先（+10 分）
 * - 中文字幕优先（+6 分）
 * - 英文字幕次之（+4 分）
 */
function selectBilibiliSubtitle(subtitles) {
  if (!Array.isArray(subtitles) || !subtitles.length) {
    return null;
  }
  const ranked = [...subtitles].sort((left, right) => scoreBilibiliSubtitle(right) - scoreBilibiliSubtitle(left));
  return ranked[0];
}

function scoreBilibiliSubtitle(track) {
  const language = String(track?.lan || "");
  const lanDoc = String(track?.lan_doc || "");
  let score = 0;

  // 人工字幕优先（通过 id 判断，非 ai- 开头的是人工字幕）
  if (!String(track?.id || "").startsWith("ai-")) {
    score += 10;
  }

  // 中文字幕优先
  if (language.includes("zh") || lanDoc.includes("中文")) {
    score += 6;
  }

  // 英文字幕次之
  if (language.includes("en") || lanDoc.includes("英文")) {
    score += 4;
  }

  return score;
}

function selectDouyinCaption(captions) {
  const ranked = [...captions].sort((left, right) => scoreDouyinCaption(right) - scoreDouyinCaption(left));
  return ranked[0];
}

function scoreDouyinCaption(track) {
  const language = String(track?.lang || "");
  if (language.startsWith("zh")) {
    return 6;
  }
  if (language.startsWith("en")) {
    return 4;
  }
  return 1;
}

function normalizeDouyinSubtitleBody(data) {
  const body =
    data?.utterances ||
    data?.captions ||
    data?.body ||
    data?.paragraphs ||
    [];

  return body
    .map((item) => ({
      startSeconds: Number(item.start_time || item.startTime || item.from || item.start || 0) / detectMsDivisor(item),
      endSeconds: Number(item.end_time || item.endTime || item.to || item.end || 0) / detectMsDivisor(item),
      text: String(item.text || item.utterance || item.content || "").trim()
    }))
    .filter((item) => item.text);
}

function detectMsDivisor(item) {
  const value = Number(item?.start_time || item?.startTime || item?.from || item?.start || 0);
  return value > 1000 ? 1000 : 1;
}

async function requestOpenAICompatible({ endpoint, apiKey, model, prompt }) {
  const basePayload = {
    model,
    temperature: 0.2,
    messages: [
      {
        role: "system",
        content: prompt.system
      },
      {
        role: "user",
        content: prompt.user
      }
    ]
  };

  let response = await fetch(`${trimTrailingSlash(endpoint)}/chat/completions`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: `Bearer ${apiKey}`
    },
    body: JSON.stringify({
      ...basePayload,
      response_format: { type: "json_object" }
    })
  });

  if (response.ok || response.status !== 400) {
    return response;
  }

  return fetch(`${trimTrailingSlash(endpoint)}/chat/completions`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: `Bearer ${apiKey}`
    },
    body: JSON.stringify(basePayload)
  });
}

async function requestAnthropic({ endpoint, apiKey, model, prompt }) {
  return fetch(`${trimTrailingSlash(endpoint)}/messages`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-api-key": apiKey,
      "anthropic-version": "2023-06-01"
    },
    body: JSON.stringify({
      model,
      max_tokens: 1400,
      temperature: 0.2,
      system: prompt.system,
      messages: [
        {
          role: "user",
          content: prompt.user
        }
      ]
    })
  });
}

async function extractResponseText(response, providerFormat) {
  if (!response.ok) {
    const details = await safeReadText(response);
    throw new Error(`模型调用失败 (${response.status})：${details || "请检查 API Key、模型名或接口地址。"}`);
  }

  const data = await response.json();

  if (providerFormat === "anthropic") {
    return data?.content
      ?.filter((item) => item?.type === "text")
      .map((item) => item.text)
      .join("\n");
  }

  return data?.choices?.[0]?.message?.content;
}

async function saveCard(card) {
  const entry = {
    id: card.id || crypto.randomUUID(),
    savedAt: new Date().toISOString(),
    title: card.title,
    summary: card.summary,
    cardType: card.cardType,
    sourceUrl: card.sourceMeta.sourceUrl,
    provider: card.sourceMeta.provider,
    model: card.sourceMeta.model,
    card
  };
  card.id = entry.id;
  card.savedAt = entry.savedAt;
  return saveHistoryEntry(entry);
}

async function downloadCardAsset({ dataUrl, filename, card }) {
  const url = dataUrl || createMarkdownDataUrl(card);
  if (!url) {
    throw new Error("没有可下载的卡片。");
  }

  await chrome.downloads.download({
    url,
    filename: filename || `quick-card/${slugify(card?.title || "card")}.md`,
    saveAs: true
  });
}

function createMarkdownDataUrl(card) {
  if (!card) {
    return "";
  }
  return `data:text/markdown;charset=utf-8,${encodeURIComponent(serializeCard(card))}`;
}

function serializeCard(card) {
  return [
    `# ${card.title}`,
    "",
    `类型：${card.cardType}`,
    `来源：${card.sourceMeta.sourceUrl}`,
    `模型：${card.sourceMeta.provider} / ${card.sourceMeta.model}`,
    "",
    "## 摘要",
    card.summary,
    "",
    "## 关键点",
    ...card.keyPoints.map((item, index) => `${index + 1}. ${item}`),
    "",
    ...(card.timeline.length
      ? ["## 时间轴", ...card.timeline.map((item) => `- ${item.time} ${item.title} ${item.detail}`), ""]
      : []),
    ...(card.repoPitch ? ["## 项目用途", card.repoPitch, ""] : []),
    ...(card.install.length ? ["## 安装方式", ...card.install.map((item, index) => `${index + 1}. ${item}`), ""] : [])
  ].join("\n");
}

function slugify(value) {
  return String(value || "card")
    .toLowerCase()
    .replace(/[^a-z0-9\u4e00-\u9fa5]+/gi, "-")
    .replace(/^-+|-+$/g, "")
    .slice(0, 48);
}