// ==UserScript==
// @name         英语填空题自动填写助手（超星学习通）
// @namespace    chaoxing-fill-blank
// @version      3.3.0
// @author       fysh
// @description  专注超星学习通英语填空题：读取含空位的题目片段与原文做序列对齐，自动为每空匹配填写答案。支持浏览器内 Whisper 转写听力音频、多音频依次处理、URL 下拉选择、全部完成后自动下一章。
// @icon         https://www.google.com/s2/favicons?domain=chaoxing.com
// @match        *://*.chaoxing.com/*
// @match        *://*.edu.cn/*
// @match        *://*.nbdlib.cn/*
// @match        *://*.hnsyu.net/*
// @match        *://*.gdhkmooc.com/*
// @grant        GM_getValue
// @grant        GM_setValue
// @grant        GM_addStyle
// @grant        GM_registerMenuCommand
// @grant        GM_xmlhttpRequest
// @grant        unsafeWindow
// @connect      *
// @run-at       document-end
// @license MIT
// ==/UserScript==

(function () {
  'use strict';

  /* =========================================================================
   * 一、基础配置与工具
   * =======================================================================*/

  const CONFIG_KEY = 'cx_fill_blank_config';
  const MARKER = '@@BLANK@@'; // 片段中代表一个空位的占位标记
  const CONTAINER_SELECTOR = '.TiMu, .questionLi, .mark_table';
  const WORD_RE = /[A-Za-z0-9]+(?:['\u2019\-][A-Za-z0-9]+)*/g;

  const defaultConfig = {
    originalText: '',   // 手动粘贴的英文原文
    autoFill: true,     // 是否自动填空
    answerInterval: 1,  // 每个空之间的填写间隔(秒)
    audioUrl: '',       // 听力音频地址（留空则自动识别页面上的音频）
    audioAuto: false,   // 进入页面后是否自动转写音频
    autoNext: false,    // 所有音频处理完成后是否自动进入下一章
    whisperModel: 'Xenova/whisper-base.en', // 语音识别模型（base 比 tiny 准很多，长音频建议 base）
    modelHost: 'https://hf-mirror.com', // 模型下载源（国内镜像更稳；官方为 https://huggingface.co）
  };

  const IS_TOP = (() => {
    try { return window.self === window.top; } catch (e) { return false; }
  })();

  // 页面真实 window：油猴沙箱里 window.UE 取不到，必须用 unsafeWindow
  const PAGE = (() => {
    try { return (typeof unsafeWindow !== 'undefined' && unsafeWindow) ? unsafeWindow : window; } catch (e) { return window; }
  })();

  // 安全获取页面上的 UEditor 库
  function getUE() {
    try { if (PAGE && PAGE.UE) return PAGE.UE; } catch (e) { /* ignore */ }
    try { if (window.UE) return window.UE; } catch (e) { /* ignore */ }
    return null;
  }

  // 等待 UEditor 就绪（最多 timeoutMs 毫秒）
  async function ensureUE(timeoutMs) {
    if (getUE()) return true;
    const deadline = Date.now() + (timeoutMs || 0);
    while (Date.now() < deadline) {
      await sleep(0.2);
      if (getUE()) return true;
    }
    return !!getUE();
  }

  function getConfig() {
    try {
      const saved = GM_getValue(CONFIG_KEY, {});
      return Object.assign({}, defaultConfig, saved || {});
    } catch (e) {
      return Object.assign({}, defaultConfig);
    }
  }

  function saveConfig(patch) {
    const cfg = Object.assign(getConfig(), patch);
    try { GM_setValue(CONFIG_KEY, cfg); } catch (e) { /* ignore */ }
    return cfg;
  }

  const sleep = (sec) => new Promise((r) => setTimeout(r, Math.max(0, sec) * 1000));

  function withTimeout(promise, ms, message) {
    return new Promise((resolve, reject) => {
      const t = setTimeout(() => reject(new Error(message || '操作超时')), ms);
      Promise.resolve(promise).then(
        (v) => { clearTimeout(t); resolve(v); },
        (e) => { clearTimeout(t); reject(e); }
      );
    });
  }

  /* =========================================================================
   * 二、日志（子 iframe 的日志会转发给顶层面板）
   * =======================================================================*/

  const LOG_STYLE = {
    info: 'color:#409eff;font-weight:bold',
    success: 'color:#67c23a;font-weight:bold',
    error: 'color:#f56c6c;font-weight:bold',
  };

  function log(msg, level = 'info') {
    try { console.log('%c[填空助手] ' + msg, LOG_STYLE[level] || LOG_STYLE.info); } catch (e) { /* ignore */ }
    if (IS_TOP) {
      appendLog(msg, level);
    } else {
      try { window.top.postMessage({ __cxfill: true, type: 'log', msg, level }, '*'); } catch (e) { /* ignore */ }
    }
  }

  /* =========================================================================
   * 三、核心匹配算法
   *
   * 思路：把「题目片段」看作「原文」挖掉若干单词后的结果。
   *  1) 对片段与原文分别分词（只保留英文单词/数字，忽略中文乱码与标点）；
   *  2) 用最长公共子序列(LCS)把片段中的保留词对齐到原文的单词上；
   *  3) 原文里没有被对齐上的词，就是被挖掉的内容；
   *  4) 按空位出现顺序，把每一段被挖掉的词依次分配给对应的空（每空一个单词）。
   * =======================================================================*/

  /** 把文本切成英文单词数组（保留原样，含撇号/连字符） */
  function tokenize(text) {
    const out = [];
    const re = new RegExp(WORD_RE.source, 'g');
    let m;
    while ((m = re.exec(text)) !== null) out.push(m[0]);
    return out;
  }

  /** 把带占位标记的片段切成 token 序列：空白处为 {blank:true} */
  function tokenizeFragment(text) {
    const parts = String(text).split(MARKER);
    const tokens = [];
    parts.forEach((part, i) => {
      if (i > 0) tokens.push({ blank: true });
      tokenize(part).forEach((w) => tokens.push({ raw: w, norm: w.toLowerCase() }));
    });
    return tokens;
  }

  /**
   * LCS 对齐：返回数组 map，map[i] = 片段第 i 个非空词匹配到的原文下标（-1 表示未匹配）
   */
  function lcsMatch(fTokens, oTokens) {
    const n = fTokens.length;
    const m = oTokens.length;
    if (!n || !m) return new Int32Array(n).fill(-1);

    const fNorm = fTokens.map((t) => t.norm);
    const oNorm = oTokens.map((t) => t.toLowerCase());

    const dp = [];
    for (let i = 0; i <= n; i++) dp.push(new Int32Array(m + 1));
    for (let i = 1; i <= n; i++) {
      const row = dp[i];
      const prev = dp[i - 1];
      const fn = fNorm[i - 1];
      for (let j = 1; j <= m; j++) {
        row[j] = fn === oNorm[j - 1] ? prev[j - 1] + 1 : Math.max(prev[j], row[j - 1]);
      }
    }

    const map = new Int32Array(n).fill(-1);
    let i = n;
    let j = m;
    while (i > 0 && j > 0) {
      if (fNorm[i - 1] === oNorm[j - 1]) {
        map[i - 1] = j - 1;
        i--;
        j--;
      } else if (dp[i - 1][j] >= dp[i][j - 1]) {
        i--;
      } else {
        j--;
      }
    }
    return map;
  }

  /**
   * 计算每个空的答案
   * @param {Array} fragmentTokens tokenizeFragment 的结果
   * @param {Array<string>} oTokens 原文分词结果
   * @returns {Array<string>} 按空位顺序排列的答案
   */
  function solveBlanks(fragmentTokens, oTokens) {
    const fWords = fragmentTokens.filter((t) => !t.blank);
    const match = lcsMatch(fWords, oTokens);
    const answers = [];
    const positions = []; // 每个空 -> 命中单词在原文中的下标数组（用于高亮）
    let pending = 0;   // 等待分配答案的空位数
    let lastO = -1;    // 上一个已对齐的原文下标
    let fi = 0;        // 片段非空词的游标

    // 把原文 [lastO+1, nextOi-1] 区间分配给等待中的空
    function flush(nextOi) {
      if (pending <= 0) return;
      const words = [];
      const poss = [];
      for (let idx = lastO + 1; idx <= nextOi - 1; idx++) { words.push(oTokens[idx]); poss.push(idx); }

      if (words.length <= pending) {
        // 词数不超过空数：每个空一个词
        for (let k = 0; k < pending; k++) {
          if (k < words.length) { answers.push(words[k]); positions.push([poss[k]]); }
          else { answers.push(''); positions.push([]); }
        }
      } else {
        // 词数多于空数：前面的空各一个词，最后一个空收下剩余所有词（短语）
        for (let k = 0; k < pending - 1; k++) { answers.push(words[k]); positions.push([poss[k]]); }
        answers.push(words.slice(pending - 1).join(' '));
        positions.push(poss.slice(pending - 1));
      }
      pending = 0;
    }

    for (const tok of fragmentTokens) {
      if (tok.blank) { pending++; continue; }
      const oi = match[fi++];
      if (oi >= 0) {
        flush(oi);
        lastO = oi;
      }
    }
    flush(oTokens.length); // 处理结尾处的空
    return { answers, positions };
  }

  /** 完整求解：从片段文本 + 原文得到答案数组与答案在原文中的位置 */
  function matchAnswers(fragmentText, originalText) {
    const ft = tokenizeFragment(fragmentText);
    const ot = tokenize(originalText);
    const r = solveBlanks(ft, ot);
    return {
      answers: r.answers,
      positions: r.positions,
      blankCount: ft.filter((t) => t.blank).length,
      originalWordCount: ot.length,
    };
  }

  /* =========================================================================
   * 四、页面识别与片段提取
   * =======================================================================*/

  /** 找出题目容器（章节测验 / 作业 / 考试），并剔除包含其它容器的外层，保留最内层 */
  function findContainers(root) {
    let all = [];
    try { all = Array.from(root.querySelectorAll(CONTAINER_SELECTOR)); } catch (e) { return []; }
    return all.filter((el) => !all.some((other) => other !== el && el.contains(other)));
  }

  /** 去重（按元素引用） */
  function uniqEls(arr) {
    const seen = new Set();
    return arr.filter((el) => {
      if (seen.has(el)) return false;
      seen.add(el);
      return true;
    });
  }

  /** 通用输入框查找（兜底用） */
  function findEditors(root) {
    const textareas = Array.from(root.querySelectorAll('textarea'));
    if (textareas.length) return textareas;
    return Array.from(root.querySelectorAll('.eidtDiv, [contenteditable="true"], input[type="text"]'));
  }

  /**
   * 找出填空题真正用于输入答案的控件（按文档顺序），即每个空一个：
   * 超星标准结构为 .blankItemDiv 内的 UEditor 源 textarea（name="answerEditor..."）
   */
  function findBlankEditors(container) {
    // 1) 超星标准填空题：每个空一个隐藏 textarea（UEditor 源）
    const ta = uniqEls(Array.from(container.querySelectorAll('.blankItemDiv textarea, textarea[name^="answerEditor"]')));
    if (ta.length) return ta;

    // 2) 备选：可见的可编辑区域
    const ce = uniqEls(Array.from(container.querySelectorAll('.blankItemDiv .eidtDiv, .blankItemInp [contenteditable="true"], .InpDIV')));
    if (ce.length) return ce;

    // 3) 兜底
    return findEditors(container);
  }

  /** 找到题干元素（章节/作业/考试三种结构） */
  function findStemElement(container) {
    return container.querySelector('.Zy_TItle .fontLabel')
      || container.querySelector('.Zy_TItle .newZy_TItle')
      || container.querySelector('.Zy_TItle')
      || container.querySelector('.mark_name')
      || container.querySelector('.fontLabel')
      || container;
  }

  /** 判断是否填空题 */
  function isFillBlank(container) {
    // 1) 题型编号为 2（填空题）
    try {
      const inputs = container.querySelectorAll('input[name^="answertype"], input[name^="type"]');
      for (const inp of inputs) {
        if (String(inp.value) === '2') return true;
      }
      if (container.getAttribute && container.getAttribute('data') === '2' && findBlankEditors(container).length) return true;
    } catch (e) { /* ignore */ }

    // 2) 题干里出现“填空题”
    const text = container.innerText || container.textContent || '';
    if (/填空题/.test(text)) return true;

    // 3) 兜底：出现 2 个及以上输入框
    return findBlankEditors(container).length >= 2;
  }

  /**
   * 从题干中提取「带空位标记的片段文本」。
   * 只取题干（.Zy_TItle 等），忽略下方独立的答题区，避免重复计数。
   * 空的表示形式：连续下划线，或题干里的内联输入框。
   */
  function extractFragment(container, editorCount) {
    const stem = findStemElement(container);
    const clone = stem.cloneNode(true);

    // 把题干里的内联输入框替换为内联占位（\u0001），稍后与下划线一起当作空位
    Array.from(clone.querySelectorAll('textarea, input[type="text"], .eidtDiv, [contenteditable="true"]')).forEach((el) => {
      if (el.parentNode) el.parentNode.replaceChild(document.createTextNode(' \u0001 '), el);
    });

    // 临时挂到页面外，利用 innerText 保留元素之间的空格/换行
    clone.style.cssText = 'position:fixed;left:-99999px;top:0;width:800px;opacity:0;pointer-events:none;';
    const host = document.body || document.documentElement;
    host.appendChild(clone);
    let text = clone.innerText || clone.textContent || '';
    host.removeChild(clone);

    text = text.replace(/[\r\n\t]+/g, ' ').replace(/\s{2,}/g, ' ');

    // 收集所有「空位片段」：连续下划线 + 内联输入框占位
    const spans = [];
    const runRe = /[＿_]{2,}/g;
    let m;
    while ((m = runRe.exec(text)) !== null) spans.push({ start: m.index, end: m.index + m[0].length, inline: false });
    let p = -1;
    while ((p = text.indexOf('\u0001', p + 1)) !== -1) spans.push({ start: p, end: p + 1, inline: true });
    spans.sort((a, b) => a.start - b.start);

    if (!spans.length) return { text: text.replace(/\u0001/g, ' ').trim(), blankCount: 0 };

    // 以「输入框数量」为准：片段多了就把最靠近的相邻片段合并（处理被空格拆开的同一个空），
    // 片段不多于输入框则保持独立（处理「一个编号对应多个空」）。
    let markers = spans.slice();
    const target = editorCount || markers.length;
    while (markers.length > target) {
      let bi = -1;
      let bg = Infinity;
      for (let i = 0; i < markers.length - 1; i++) {
        const gap = markers[i + 1].start - markers[i].end;
        if (gap < bg) { bg = gap; bi = i; }
      }
      if (bi < 0) break;
      markers[bi] = { start: markers[bi].start, end: markers[bi + 1].end, inline: markers[bi].inline && markers[bi + 1].inline };
      markers.splice(bi + 1, 1);
    }

    let out = '';
    let last = 0;
    for (const mk of markers) {
      out += text.slice(last, mk.start) + ' ' + MARKER + ' ';
      last = mk.end;
    }
    out += text.slice(last);

    return { text: out.replace(/\u0001/g, ' ').replace(/\s{2,}/g, ' ').trim(), blankCount: markers.length };
  }

  /* =========================================================================
   * 五、填写
   * =======================================================================*/

  function fireEvent(el, type, isInput) {
    try {
      if (isInput && typeof InputEvent === 'function') {
        el.dispatchEvent(new InputEvent(type, { bubbles: true }));
      } else {
        el.dispatchEvent(new Event(type, { bubbles: true }));
      }
    } catch (e) { /* 跨域/事件构造失败时忽略 */ }
  }

  function setBlankValue(el, value, win) {
    try {
      const tag = (el.tagName || '').toLowerCase();
      const UE = getUE();

      if (tag === 'textarea') {
        const name = el.getAttribute('name') || el.id;
        // 超星填空题使用 UEditor：必须通过页面 window 上的 UE 实例写入
        if (UE && name && typeof UE.getEditor === 'function') {
          const editor = UE.getEditor(name);
          if (editor) {
            const write = () => { try { editor.setContent(value); } catch (e) { el.value = value; } };
            if (typeof editor.ready === 'function') editor.ready(write); // 已就绪会立即执行
            write(); // 立即尝试一次
            el.value = value; // 同步隐藏源 textarea
            fireEvent(el, 'input');
            fireEvent(el, 'change');
            return true;
          }
        }
        el.value = value;
        fireEvent(el, 'input');
        fireEvent(el, 'change');
        return true;
      }

      if (el.isContentEditable || (el.className && String(el.className).indexOf('eidtDiv') !== -1)) {
        try { el.focus(); } catch (e) { /* ignore */ }
        el.textContent = value;
        fireEvent(el, 'input', true);
        fireEvent(el, 'change');
        return true;
      }

      el.value = value;
      fireEvent(el, 'input');
      fireEvent(el, 'change');
      return true;
    } catch (e) {
      return false;
    }
  }

  /* =========================================================================
   * 五·五、音频转写（浏览器内置 Whisper，无需 API key）
   *
   * 思路：
   *  1) 用 GM_xmlhttpRequest 下载音频（绕过跨域）；
   *  2) 用 Web Audio 解码并重采样为 16kHz 单声道 Float32；
   *  3) 动态加载 transformers.js，用 Whisper 英文模型转写为文本；
   *  4) 转写结果写入「原文」框，再走原来的对齐填空流程。
   * =======================================================================*/

  const TRANSFORMERS_URL = 'https://cdn.jsdelivr.net/npm/@xenova/transformers@2.17.2/dist/transformers.min.js';

  /** 用油猴请求下载二进制数据 */
  function getBinary(url, timeoutMs) {
    return new Promise((resolve, reject) => {
      try {
        GM_xmlhttpRequest({
          method: 'GET',
          url: url,
          responseType: 'arraybuffer',
          timeout: timeoutMs || 120000,
          onload: (res) => {
            if (res.status >= 200 && res.status < 300 && res.response) resolve(res.response);
            else reject(new Error('下载失败 HTTP ' + res.status));
          },
          onerror: () => reject(new Error('网络错误')),
          ontimeout: () => reject(new Error('下载超时')),
        });
      } catch (e) { reject(e); }
    });
  }

  /** 把音频解码为 16kHz 单声道 Float32Array */
  async function decodeAudioTo16k(arrayBuffer) {
    const AC = (PAGE && PAGE.AudioContext) || (PAGE && PAGE.webkitAudioContext) || window.AudioContext || window.webkitAudioContext;
    const OAC = (PAGE && PAGE.OfflineAudioContext) || window.OfflineAudioContext || window.webkitOfflineAudioContext;
    if (!AC || !OAC) throw new Error('当前浏览器不支持 Web Audio');

    const ctx = new AC();
    let decoded;
    try {
      decoded = await new Promise((res, rej) => {
        const p = ctx.decodeAudioData(arrayBuffer.slice(0), res, rej);
        if (p && typeof p.then === 'function') p.then(res, rej);
      });
    } finally {
      try { ctx.close(); } catch (e) { /* ignore */ }
    }

    const targetRate = 16000;
    const length = Math.max(1, Math.ceil(decoded.duration * targetRate));
    const offline = new OAC(1, length, targetRate);
    const src = offline.createBufferSource();
    src.buffer = decoded;
    src.connect(offline.destination);
    src.start(0);
    const rendered = await offline.startRendering();
    return rendered.getChannelData(0);
  }

  /** 方式一：注入 type=module 脚本，把 transformers.js 导出挂到页面 window 上 */
  function importViaScript() {
    return new Promise((resolve, reject) => {
      try {
        const key = '__cxTransformers_' + Math.random().toString(36).slice(2);
        const doc = (PAGE && PAGE.document) || document;
        const s = doc.createElement('script');
        s.type = 'module';
        s.textContent = 'import * as M from ' + JSON.stringify(TRANSFORMERS_URL) + ';\n' +
          'window[' + JSON.stringify(key) + '] = M;';
        doc.documentElement.appendChild(s);
        const start = Date.now();
        const timer = setInterval(() => {
          let m;
          try { m = PAGE[key]; } catch (e) { m = undefined; }
          if (m) { clearInterval(timer); try { s.remove(); } catch (e) { /* ignore */ } resolve(m); }
          else if (Date.now() - start > 60000) { clearInterval(timer); reject(new Error('transformers.js 加载超时')); }
        }, 150);
      } catch (e) { reject(e); }
    });
  }

  /** 方式二：通过 new Function 动态 import（避免在脚本正文里出现 import 语法） */
  async function importViaFunction() {
    const importer = new Function('u', 'return import(u)');
    const ns = await importer(TRANSFORMERS_URL);
    return (ns && ns.pipeline) ? ns : (ns && ns.default) ? ns.default : ns;
  }

  /** 加载 transformers.js（优先注入模块脚本，其次动态 import） */
  async function loadTransformers() {
    if (loadTransformers._mod) return loadTransformers._mod;

    let mod = null;
    try {
      mod = await importViaScript();
    } catch (e) {
      try { console.warn('[填空助手] 注入模块脚本加载失败，尝试动态 import：', e && e.message); } catch (err) { /* ignore */ }
    }
    if (!mod) {
      try { mod = await importViaFunction(); } catch (e) { /* ignore */ }
    }
    if (!mod || !mod.pipeline) throw new Error('无法加载 transformers.js（可能被页面 CSP 拦截）');

    loadTransformers._mod = mod;
    return mod;
  }

  // ---------- 主线程兜底方案（worker 不可用时才用）----------
  let _transcriber = null;
  let _transcriberModel = '';

  async function createTranscriber(model, host, onProgress) {
    const mod = await loadTransformers();
    const env = mod.env;
    try { env.allowLocalModels = false; } catch (e) { /* ignore */ }
    try { env.useBrowserCache = true; } catch (e) { /* ignore */ }
    try { env.backends.onnx.wasm.numThreads = 1; } catch (e) { /* ignore */ }
    try { env.backends.onnx.wasm.proxy = false; } catch (e) { /* ignore */ }
    try { env.remoteHost = host; } catch (e) { /* ignore */ }
    try { env.remotePathTemplate = '{model}/resolve/{revision}/'; } catch (e) { /* ignore */ }
    return await mod.pipeline('automatic-speech-recognition', model, {
      quantized: true,
      progress_callback: onProgress,
    });
  }

  function modelHosts() {
    const primary = (getConfig().modelHost || 'https://hf-mirror.com').replace(/\/+$/, '');
    const backup = primary.indexOf('hf-mirror.com') !== -1 ? 'https://huggingface.co' : 'https://hf-mirror.com';
    return [primary, backup];
  }

  async function getTranscriberMain(model, onProgress) {
    if (_transcriber && _transcriberModel === model) return _transcriber;
    let lastErr = null;
    for (const host of modelHosts()) {
      try {
        _transcriber = await createTranscriber(model, host, onProgress);
        _transcriberModel = model;
        return _transcriber;
      } catch (e) {
        lastErr = e;
        log('主线程加载失败（源=' + host + '）：' + ((e && e.message) || e), 'error');
      }
    }
    throw lastErr || new Error('模型加载失败');
  }

  // ---------- 优先方案：在独立 Web Worker 里跑 Whisper，避免页面卡死 ----------
  const TRANSFORMERS_ESM = 'https://cdn.jsdelivr.net/npm/@xenova/transformers@2.17.2/dist/transformers.min.js';
  let _worker = null;

  function workerCode() {
    return [
      "import { pipeline, env } from " + JSON.stringify(TRANSFORMERS_ESM) + ";",
      "env.allowLocalModels = false;",
      "env.useBrowserCache = true;",
      "try { env.backends.onnx.wasm.numThreads = 1; } catch (e) {}",
      "let transcriber = null; let curModel = '';",
      "self.onmessage = async function (e) {",
      "  var d = e.data || {};",
      "  if (d.type !== 'transcribe') return;",
      "  try {",
      "    if (d.host) { try { env.remoteHost = d.host; env.remotePathTemplate = '{model}/resolve/{revision}/'; } catch (e2) {} }",
      "    if (!transcriber || curModel !== d.model) {",
      "      transcriber = await pipeline('automatic-speech-recognition', d.model, { quantized: true, progress_callback: function (p) { self.postMessage({ type: 'progress', p: p && { status: p.status, file: p.file, progress: p.progress } }); } });",
      "      curModel = d.model;",
      "    }",
      "    var res = await transcriber(d.audio, { chunk_length_s: 30, stride_length_s: 5, return_timestamps: false });",
      "    self.postMessage({ type: 'result', text: (res && res.text) || '' });",
      "  } catch (err) { self.postMessage({ type: 'error', message: String((err && err.message) || err) }); }",
      "};",
    ].join('\n');
  }

  function ensureWorker() {
    if (_worker) return _worker;
    const BlobC = (PAGE && PAGE.Blob) || Blob;
    const URLC = (PAGE && PAGE.URL) || URL;
    const WorkerC = (PAGE && PAGE.Worker) || Worker;
    const blob = new BlobC([workerCode()], { type: 'text/javascript' });
    const url = URLC.createObjectURL(blob);
    _worker = new WorkerC(url, { type: 'module' });
    return _worker;
  }

  function killWorker() {
    if (_worker) { try { _worker.terminate(); } catch (e) { /* ignore */ } _worker = null; }
  }

  function transcribeWithWorker(f32, model, host, onProgress) {
    return new Promise((resolve, reject) => {
      let w;
      try { w = ensureWorker(); } catch (e) { reject(e); return; }
      const onMsg = (ev) => {
        const d = ev.data || {};
        if (d.type === 'progress') { if (onProgress) onProgress(d.p); }
        else if (d.type === 'result') { cleanup(); resolve(d.text); }
        else if (d.type === 'error') { cleanup(); killWorker(); reject(new Error(d.message)); }
      };
      const onErr = () => { cleanup(); killWorker(); reject(new Error('Worker 加载失败（可能被页面 CSP 拦截）')); };
      function cleanup() {
        try { w.removeEventListener('message', onMsg); } catch (e) { /* ignore */ }
        try { w.removeEventListener('error', onErr); } catch (e) { /* ignore */ }
      }
      w.addEventListener('message', onMsg);
      w.addEventListener('error', onErr);
      try { w.postMessage({ type: 'transcribe', model, host, audio: f32 }); }
      catch (e) { cleanup(); reject(e); }
    });
  }

  /** 识别页面上的所有音频地址（一个章节可能有多个音频；排除视频） */
  function detectAudioUrls() {
    const urls = [];
    const push = (u) => { if (u && urls.indexOf(u) === -1) urls.push(u); };
    const isVideo = (u) => /\.(mp4|m4v|mov|avi|mkv|flv|webm|m3u8|ts)(\?|$)/i.test(u);
    try {
      // 只看 <audio> 及其内部 <source>，绝不含 <video>
      Array.from(document.querySelectorAll('audio')).forEach((a) => {
        const s = a.currentSrc || a.src || a.getAttribute('src') || '';
        if (s && !isVideo(s)) push(s);
        Array.from(a.querySelectorAll('source')).forEach((so) => {
          const v = so.src || so.getAttribute('src') || '';
          if (v && !isVideo(v)) push(v);
        });
      });
    } catch (e) { /* ignore */ }
    return urls;
  }

  /** 识别页面上的音频地址（取第一个） */
  function detectAudioUrl() {
    const urls = detectAudioUrls();
    if (urls.length > 1) {
      log('当前页面检测到 ' + urls.length + ' 个音频，将使用第 1 个；如需其它请手动填写音频URL', 'error');
    }
    return urls[0] || '';
  }

  /** 转写进度日志（限流） */
  function makeProgressLogger() {
    return (p) => {
      try {
        if (p && p.status === 'progress' && p.file && p.progress != null) {
          const pct = Math.round(p.progress);
          if (pct % 20 === 0) log('模型 ' + p.file + ' ' + pct + '%');
        }
      } catch (e) { /* ignore */ }
    };
  }

  /** 完整流程：下载 → 解码 → 转写，返回文本 */
  async function transcribeAudio(url) {
    log('开始下载音频…');
    const buf = await getBinary(url);
    log('音频已下载（' + Math.round(buf.byteLength / 1024) + ' KB），正在解码…');
    const f32 = await decodeAudioTo16k(buf);
    log('音频解码完成（约 ' + (f32.length / 16000).toFixed(1) + ' 秒），正在加载语音模型（首次需下载，请耐心等待）…');

    const model = getConfig().whisperModel || 'Xenova/whisper-base.en';
    const onProgress = makeProgressLogger();

    // 优先：在独立 Worker 里推理，避免阻塞页面主线程
    for (const host of modelHosts()) {
      try {
        log('在后台 Worker 中加载模型（源=' + host + '）…');
        const text = await transcribeWithWorker(f32, model, host, onProgress);
        return String(text || '').replace(/\s+/g, ' ').trim();
      } catch (e) {
        log('Worker 方式失败（源=' + host + '）：' + ((e && e.message) || e), 'error');
      }
    }

    // 兜底：主线程推理（页面可能短暂卡顿）
    log('改为在主线程推理（转写期间页面可能卡顿）…', 'error');
    const transcriber = await getTranscriberMain(model, onProgress);
    log('语音模型就绪，开始转写…');
    const res = await transcriber(f32, { chunk_length_s: 30, stride_length_s: 5, return_timestamps: false });
    return ((res && res.text) || '').replace(/\s+/g, ' ').trim();
  }

  /** 各 frame 收到转写指令后执行 */
  let _transcribing = false;
  async function handleTranscribe() {
    if (_transcribing) { log('已有转写任务在进行中，请稍候；若长时间无反应请刷新页面', 'error'); return; }
    _transcribing = true;
    try {
      const cfg = getConfig();
      const manual = (cfg.audioUrl || '').trim();
      if (manual && !IS_TOP) return; // 手动 URL 只由顶层执行，避免多 frame 重复转写
      const url = manual || detectAudioUrl();
      if (!url) { log('未在当前页面找到音频，请在面板手动填写音频URL', 'error'); return; }
      log('准备转写音频：' + url.slice(0, 90) + (url.length > 90 ? '…' : ''));
      const text = await withTimeout(transcribeAudio(url), 600000, '转写超时（10分钟）');
      if (!text) { log('转写结果为空，请重试或改用更准确的模型', 'error'); return; }
      if (IS_TOP) applyTranscript(text, url);
      else {
        try { window.top.postMessage({ __cxfill: true, type: 'transcript', text, url }, '*'); } catch (e) { /* ignore */ }
      }
    } catch (e) {
      const msg = (e && e.message) ? e.message : String(e);
      log('音频转写失败：' + msg + '（可尝试在面板切换「模型源」后重试）', 'error');
      if (!IS_TOP) {
        try { window.top.postMessage({ __cxfill: true, type: 'transcript-error', message: msg }, '*'); } catch (err) { /* ignore */ }
      }
    } finally {
      _transcribing = false;
    }
  }

  /** 顶层应用转写结果（手动流程） */
  function applyTranscript(text, url) {
    _lastTranscript = text;
    saveConfig({ originalText: text, audioUrl: url || getConfig().audioUrl || '' });
    updatePreview(text, []);
    log('转写完成（' + text.length + ' 字符），已填入「原文」框，请核对后填空', 'success');
    broadcast({ __cxfill: true, type: 'fill', text });
  }

  /* -------------------------------------------------------------------------
   * 多音频顺序处理 + 章节自动化
   *   - 每个 frame 只需负责自己页面里的音频，顺序「转写→填空→转写下一条」
   *   - 顶层负责汇总音频列表、协调进度、完成后进入下一章
   * -----------------------------------------------------------------------*/

  let _audioUrls = [];       // 顶层聚合到的音频地址
  let _pendingFrames = 0;    // 汇报了音频的 frame 数
  let _doneFrames = 0;       // 已完成转写的 frame 数
  let _seqRunning = false;   // 是否有一轮任务在进行
  let _seqToken = 0;         // 用于中断正在进行的序列
  let _lastTranscript = '';  // 当前正在展示/匹配的原文

  function postToTop(obj) {
    try { window.top.postMessage(Object.assign({ __cxfill: true }, obj), '*'); } catch (e) { /* ignore */ }
  }

  /** 每个 frame：把自己页面里的音频地址汇报给顶层 */
  function reportAudioList() {
    try {
      const urls = detectAudioUrls();
      if (urls.length) postToTop({ type: 'audio-list', urls });
    } catch (e) { /* ignore */ }
  }

  /** 每个 frame：顺序转写自己页面里的音频，每次转写后立即填空 */
  async function runFrameAudioSequence() {
    const token = ++_seqToken;
    let urls = [];
    try { urls = detectAudioUrls(); } catch (e) { /* ignore */ }
    const manual = (getConfig().audioUrl || '').trim();
    if (manual) urls = [manual];
    if (!urls.length) return;
    for (let i = 0; i < urls.length; i++) {
      if (token !== _seqToken) { log('已取消当前转写序列', 'error'); return; }
      log('转写第 ' + (i + 1) + '/' + urls.length + ' 个音频：' + urls[i].slice(0, 80) + '…');
      try {
        const text = await withTimeout(transcribeAudio(urls[i]), 900000, '转写超时');
        if (token !== _seqToken) { log('已取消当前转写序列', 'error'); return; }
        if (!text) { log('转写为空，跳过', 'error'); continue; }
        _lastTranscript = text;
        updatePreview(text, []); // 先把本条原文显示到「原文」区
        broadcast({ __cxfill: true, type: 'fill', text });
        await sleep(3);
      } catch (e) {
        log('音频转写失败：' + ((e && e.message) || e), 'error');
      }
    }
    postToTop({ type: 'auto-seq-done' });
  }

  /** 顶层：开始一轮自动处理 */
  async function startAutoSequence() {
    if (!IS_TOP) return;
    // 中断正在进行的序列，然后开始新的
    broadcast({ __cxfill: true, type: 'abort' });
    _seqToken++;
    if (_seqRunning) { log('已中断上一轮，开始新一轮…', 'info'); }
    _seqRunning = true;
    // 重新开始：允许重新匹配填写
    processed = new WeakSet();
    lastOriginal = null;
    try {
      _audioUrls = []; _pendingFrames = 0; _doneFrames = 0;
      const manual = (getConfig().audioUrl || '').trim();
      if (manual) {
        log('开始转写指定音频：' + manual.slice(0, 80) + '…', 'info');
        try {
          const text = await withTimeout(transcribeAudio(manual), 900000, '转写超时');
          if (text) {
            _lastTranscript = text;
            updatePreview(text, []);
            broadcast({ __cxfill: true, type: 'fill', text });
          }
        } catch (e) { log('转写失败：' + ((e && e.message) || e), 'error'); }
        return;
      }
      broadcast({ __cxfill: true, type: 'collect-audio' });
      await sleep(2);
      if (!_pendingFrames) {
        // 播放器/音频可能尚未初始化，再等一会儿重试一次
        await sleep(3);
        broadcast({ __cxfill: true, type: 'collect-audio' });
        await sleep(3);
      }
      if (!_pendingFrames) {
        log('本页未检测到音频（若还有其它任务点，全部完成后会自动进入下一章）', 'error');
        return;
      }
      log('检测到 ' + _pendingFrames + ' 个含音频的页面（共 ' + _audioUrls.length + ' 个音频），开始依次转写…');
      broadcast({ __cxfill: true, type: 'auto-seq' });
    } finally {
      _seqRunning = false;
    }
  }

  /** 顶层：清空状态，准备新一章 */
  function resetForNewChapter() {
    if (!IS_TOP) return;
    _audioUrls = []; _pendingFrames = 0; _doneFrames = 0;
    processed = new WeakSet();
    lastOriginal = null;
    saveConfig({ originalText: '', audioUrl: '' });
    setPlainOriginal('');
    const sel = document.getElementById('cx-fill-audiourl'); if (sel) sel.selectedIndex = 0;
    const manualBox = document.getElementById('cx-fill-audiourl-manual'); if (manualBox) manualBox.value = '';
    log('新章节：已清空「原文」与「音频URL」，开启新一轮', 'success');
  }

  /** 顶层：点击「下一章」 */
  function clickNextChapter() {
    if (!IS_TOP) return;
    let btn = document.querySelector('.nextChapter') || document.querySelector('a.nextChapter');
    if (!btn) {
      try {
        const cands = Array.from(document.querySelectorAll('a,button,div,span'));
        btn = cands.find((el) => /下一章|下一节|下一单元|下一页/.test((el.textContent || '').trim()) && el.offsetParent !== null);
      } catch (e) { /* ignore */ }
    }
    if (btn) {
      log('本轮任务完成，自动进入下一章…', 'success');
      setTimeout(() => { try { btn.click(); } catch (e) { log('点击下一章失败：' + e.message, 'error'); } }, 1500);
    } else {
      log('未找到「下一章」按钮，可能已是最后一章', 'error');
    }
  }

  /** 顶层：刷新音频下拉框 */
  function refreshAudioSelect() {
    if (!IS_TOP) return;
    const sel = document.getElementById('cx-fill-audiourl');
    if (!sel) return;
    const cur = sel.value;
    sel.innerHTML = '';
    const optAll = document.createElement('option');
    optAll.value = '';
    optAll.textContent = '全部音频（依次转写）';
    sel.appendChild(optAll);
    _audioUrls.forEach((u, i) => {
      const o = document.createElement('option');
      o.value = u;
      o.textContent = '音频' + (i + 1) + '：' + u.replace(/^https?:\/\//, '').slice(0, 64);
      sel.appendChild(o);
    });
    if (cur && _audioUrls.indexOf(cur) !== -1) sel.value = cur;
  }

  /* -------------------------------------------------------------------------
   * 任务点完成检测 + 自动下一章
   *   —— 只有章节内「所有任务点」都变为已完成，才进入下一章
   * -----------------------------------------------------------------------*/

  function getChapterJobIcons() {
    try {
      const f = document.querySelector('#iframe');
      const doc = f && f.contentWindow && f.contentWindow.document;
      if (!doc) return null;
      return Array.from(doc.querySelectorAll('.ans-job-icon'));
    } catch (e) { return null; }
  }

  let _nextMonitor = null;
  let _nextClicked = false;
  function startNextChapterMonitor() {
    if (!IS_TOP || _nextMonitor) return;
    _nextMonitor = setInterval(() => {
      if (!getConfig().autoNext || _nextClicked) return;
      let jobs = null;
      try { jobs = getChapterJobIcons(); } catch (e) { /* ignore */ }
      if (!jobs || !jobs.length) return; // 非章节页 / 尚未加载
      const unfinished = jobs.filter((j) => !(j.parentElement && j.parentElement.classList.contains('ans-job-finished')));
      if (unfinished.length === 0) {
        _nextClicked = true;
        clearInterval(_nextMonitor); _nextMonitor = null;
        log('所有任务点已完成，自动进入下一章', 'success');
        resetForNewChapter();
        clickNextChapter();
      }
    }, 3000);
  }

  /* -------------------------------------------------------------------------
   * 原文预览：把命中的答案加粗并编号
   * -----------------------------------------------------------------------*/

  function escapeHtml(s) {
    return String(s).replace(/[&<>"]/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' }[c]));
  }

  function renderPreview(text, positions) {
    const uniq = Array.from(new Set(positions.filter((p) => p >= 0))).sort((a, b) => a - b);
    const numByPos = {};
    uniq.forEach((p, i) => { numByPos[p] = i + 1; });
    let out = '';
    let last = 0;
    let idx = 0;
    const re = new RegExp(WORD_RE.source, 'g');
    let m;
    while ((m = re.exec(text)) !== null) {
      out += escapeHtml(text.slice(last, m.index));
      const w = m[0];
      if (numByPos[idx] != null) out += '<b class="cx-ans">' + numByPos[idx] + '. ' + escapeHtml(w) + '</b>';
      else out += escapeHtml(w);
      last = m.index + w.length;
      idx++;
    }
    out += escapeHtml(text.slice(last));
    return out;
  }

  /** 顶层：把「原文」区显示为纯文本（手动输入时） */
  function setPlainOriginal(text) {
    if (!IS_TOP) return;
    const box = document.getElementById('cx-fill-original');
    if (!box) return;
    box.dataset.styled = '0';
    box.textContent = text || '';
  }

  /** 顶层：把「原文」区显示为带样式的文本（答案加粗编号） */
  function setStyledOriginal(html, plainText) {
    if (!IS_TOP) return;
    const box = document.getElementById('cx-fill-original');
    if (!box) return;
    box.dataset.styled = '1';
    box.innerHTML = html || '';
    if (plainText != null) saveConfig({ originalText: plainText });
  }

  /** 读取当前「原文」的纯文本（用于对齐） */
  function readOriginal() {
    const box = document.getElementById('cx-fill-original');
    if (box && box.dataset.styled !== '1') return (box.innerText || '').trim();
    return (getConfig().originalText || '').trim();
  }

  /** 渲染并展示「原文」（命中答案加粗编号）；非顶层则转发给顶层 */
  function updatePreview(text, positions) {
    if (!text) return;
    const html = renderPreview(text, positions || []);
    if (IS_TOP) setStyledOriginal(html, text);
    else postToTop({ type: 'preview', html, text });
  }

  /* =========================================================================
   * 六、执行流程
   * =======================================================================*/

  let processed = new WeakSet();
  let running = false;
  let warnedNoOriginal = false;
  let lastOriginal = null;

  async function runFill(original, onlyMatched) {
    const containers = findContainers(document);
    let filled = 0;
    const usedPositions = [];

    for (const container of containers) {
      if (processed.has(container)) continue;
      if (!isFillBlank(container)) continue;

      const editors = findBlankEditors(container);
      if (!editors.length) continue;

      const frag = extractFragment(container, editors.length);
      const text = frag.text;
      const { answers, positions, blankCount } = matchAnswers(text, original);

      // 答案数量与输入框数量对齐
      let finalAnswers = answers.slice();
      let finalPositions = positions.slice();
      if (finalAnswers.length < editors.length) {
        finalAnswers = finalAnswers.concat(new Array(editors.length - finalAnswers.length).fill(''));
        finalPositions = finalPositions.concat(new Array(editors.length - finalPositions.length).fill([]));
      }
      finalAnswers = finalAnswers.slice(0, editors.length);
      finalPositions = finalPositions.slice(0, editors.length);

      log('识别到填空题：' + editors.length + ' 个空（题干解析出 ' + blankCount + ' 个空）');
      log('片段预览：' + text.slice(0, 160) + (text.length > 160 ? '…' : ''));
      if (blankCount !== editors.length) {
        log('提示：题干空位数与输入框数不一致，请核对页面结构或原文', 'error');
        try {
          log('题干元素：<' + findStemElement(container).tagName.toLowerCase() + ' class="' + (findStemElement(container).className || '') + '">');
          log('输入框统计：textarea=' + container.querySelectorAll('textarea').length + '，识别 ' + editors.length + ' 个');
        } catch (e) { /* ignore */ }
      }
      log('答案预览：' + finalAnswers.map((a, i) => (i + 1) + '.' + (a || '×')).join('  '));

      // 若含 UEditor 输入框，等待编辑器库就绪，避免写入隐藏的源 textarea 而界面无变化
      const hasTextarea = editors.some((e) => (e.tagName || '').toLowerCase() === 'textarea');
      if (hasTextarea) await ensureUE(3000);
      log('UEditor 状态：' + (getUE() ? '已就绪' : '未检测到'));

      const interval = Number(getConfig().answerInterval) || 1;
      let skipped = 0;
      let wroteThis = false;
      for (let i = 0; i < editors.length; i++) {
        const val = finalAnswers[i] || '';
        // 匹配失败的空不写入，避免清空其它题目已填内容
        if (!val) { skipped++; continue; }
        const ok = setBlankValue(editors[i], val, PAGE);
        if (ok) {
          filled++;
          wroteThis = true;
          const ps = finalPositions[i] || [];
          for (let q = 0; q < ps.length; q++) if (ps[q] >= 0) usedPositions.push(ps[q]);
        }
        if (i < editors.length - 1) await sleep(interval);
      }
      if (skipped) log('有 ' + skipped + ' 个空未匹配到答案，已跳过（不清空）', 'error');
      // 音频逐条匹配时：只有真正填入了才标记为已处理，否则把机会留给下一条音频
      if (wroteThis || !onlyMatched) processed.add(container);
    }
    if (usedPositions.length) updatePreview(original, usedPositions);
    return filled;
  }

  async function runAuto() {
    if (running) return;
    running = true;
    try {
      const cfg = getConfig();
      const original = (cfg.originalText || '').trim();
      if (!original) {
        if (!warnedNoOriginal) {
          warnedNoOriginal = true;
          log('尚未配置原文，请点击右下角按钮粘贴英文原文', 'error');
        }
        return;
      }
      warnedNoOriginal = false;
      if (original !== lastOriginal) {
        // 原文变化时重置，允许用新原文重新填写
        processed = new WeakSet();
        lastOriginal = original;
      }
      const filled = await runFill(original);
      if (filled > 0) {
        log('已自动填写 ' + filled + ' 个空，请检查后手动提交', 'success');
      }
    } catch (e) {
      log('填写出错：' + (e && e.message ? e.message : e), 'error');
    } finally {
      running = false;
    }
  }

  let _lastChapterKey = '';
  function chapterKey() {
    try {
      const f = document.querySelector('#iframe');
      return location.href + '|' + (f ? f.src : '');
    } catch (e) { return location.href; }
  }

  /** 等待题目出现后执行一次，并做周期性检查（SPA/iframe 异步加载） */
  async function bootstrapFrame() {
    const cfg = getConfig();

    if (cfg.audioAuto) {
      // 自动转写模式：由顶层统一发起，先清空上一章残留
      if (IS_TOP) {
        resetForNewChapter();
        setTimeout(() => { startAutoSequence(); }, 3000);
      }
    } else if (cfg.autoFill) {
      for (let i = 0; i < 30; i++) {
        if (document.querySelector(CONTAINER_SELECTOR)) break;
        await sleep(1);
      }
      await runAuto();
    }

    // 顶层：启动了自动下一章的话，持续监测任务点完成情况
    if (IS_TOP && cfg.autoNext) startNextChapterMonitor();

    // 顶层：章节切换检测 → 清空并开启新一轮
    if (IS_TOP && !bootstrapFrame._chapterTimer) {
      _lastChapterKey = chapterKey();
      bootstrapFrame._chapterTimer = setInterval(() => {
        const k = chapterKey();
        if (k !== _lastChapterKey) {
          _lastChapterKey = k;
          _nextClicked = false;
          if (getConfig().audioAuto) {
            resetForNewChapter();
            setTimeout(() => { startAutoSequence(); }, 4000);
          }
          if (getConfig().autoNext) startNextChapterMonitor();
        }
      }, 3000);
    }

    // 周期检查：手动模式下原文非空时补填（自动转写模式不走这里，避免用旧原文乱填）
    if (!bootstrapFrame._timer) {
      bootstrapFrame._timer = setInterval(() => {
        const c = getConfig();
        if (c.autoFill && !c.audioAuto && (c.originalText || '').trim()) runAuto();
      }, 3000);
    }
  }

  /* =========================================================================
   * 七、顶层面板 UI（仅顶层窗口创建）
   * =======================================================================*/

  const PANEL_CSS = `
    #cx-fill-toggle{position:fixed;right:20px;bottom:20px;z-index:999999;width:52px;height:52px;border:none;border-radius:50%;
      background:linear-gradient(135deg,#667eea,#764ba2);color:#fff;font-size:20px;font-weight:700;cursor:pointer;
      box-shadow:0 6px 16px rgba(0,0,0,.25);transition:transform .2s;}
    #cx-fill-toggle:hover{transform:scale(1.08);}
    #cx-fill-panel{position:fixed;right:20px;bottom:84px;z-index:999999;width:520px;max-width:92vw;background:#fff;border-radius:14px;
      box-shadow:0 12px 40px rgba(0,0,0,.25);font-family:system-ui,-apple-system,"Microsoft YaHei",sans-serif;color:#303133;overflow:hidden;}
    #cx-fill-panel.cx-hidden{display:none;}
    #cx-fill-panel .cx-head{display:flex;align-items:center;justify-content:space-between;padding:12px 16px;
      background:linear-gradient(135deg,#667eea,#764ba2);color:#fff;font-weight:600;font-size:15px;}
    #cx-fill-panel .cx-close{cursor:pointer;font-size:20px;line-height:1;opacity:.9;}
    #cx-fill-panel .cx-body{padding:14px 16px;max-height:70vh;overflow:auto;}
    #cx-fill-panel label{display:block;font-size:13px;font-weight:600;margin:8px 0 6px;}
    #cx-fill-panel textarea{width:100%;height:180px;box-sizing:border-box;border:1px solid #dcdfe6;border-radius:8px;padding:10px;
      font-size:13px;line-height:1.6;resize:vertical;outline:none;}
    #cx-fill-panel textarea:focus{border-color:#764ba2;}
    #cx-fill-panel .cx-row{display:flex;align-items:center;gap:10px;margin-top:10px;flex-wrap:wrap;}
    #cx-fill-panel button{cursor:pointer;border:none;border-radius:8px;padding:8px 14px;font-size:13px;font-weight:600;transition:.2s;}
    #cx-fill-panel .cx-primary{background:linear-gradient(135deg,#667eea,#764ba2);color:#fff;}
    #cx-fill-panel .cx-primary:hover{opacity:.9;}
    #cx-fill-panel .cx-ghost{background:#f2f3f5;color:#303133;}
    #cx-fill-panel .cx-input,#cx-fill-panel select.cx-select{width:100%;box-sizing:border-box;border:1px solid #dcdfe6;border-radius:8px;
      padding:8px 10px;font-size:13px;outline:none;margin-bottom:8px;background:#fff;color:#303133;}
    #cx-fill-panel .cx-input:focus,#cx-fill-panel select.cx-select:focus{border-color:#764ba2;}
    #cx-fill-panel .cx-sep{margin:14px 0 8px;padding-top:12px;border-top:1px solid #ebeef5;font-size:13px;font-weight:600;color:#606266;}
    #cx-fill-panel .cx-original{width:100%;height:170px;box-sizing:border-box;border:1px solid #dcdfe6;border-radius:8px;padding:10px;
      font-size:13px;line-height:1.9;overflow:auto;outline:none;white-space:pre-wrap;word-break:break-word;color:#303133;background:#fff;}
    #cx-fill-panel .cx-original:focus{border-color:#764ba2;}
    #cx-fill-panel .cx-original:empty::before{content:attr(data-ph);color:#a8abb2;}
    #cx-fill-panel .cx-original .cx-ans{color:#c0392b;font-weight:700;}
    #cx-fill-panel .cx-log{margin-top:12px;background:#1e1e1e;border-radius:8px;padding:10px;height:150px;overflow:auto;
      font-family:Consolas,Monaco,monospace;font-size:12px;line-height:1.6;}
    #cx-fill-panel .cx-log div{color:#d4d4d4;}
    #cx-fill-panel .cx-log .success{color:#67c23a;}
    #cx-fill-panel .cx-log .error{color:#f56c6c;}
    #cx-fill-panel .cx-log .info{color:#409eff;}
  `;

  function addStyle(css) {
    try {
      if (typeof GM_addStyle === 'function') { GM_addStyle(css); return; }
    } catch (e) { /* ignore */ }
    const style = document.createElement('style');
    style.textContent = css;
    (document.head || document.documentElement).appendChild(style);
  }

  let _lastLogMsg = '';
  let _lastLogTime = 0;

  function appendLog(msg, level) {
    try {
      // 抑制 3 秒内重复的相同日志（多个 iframe 会各报一次）
      const now = Date.now();
      if (msg === _lastLogMsg && now - _lastLogTime < 3000) return;
      _lastLogMsg = msg;
      _lastLogTime = now;

      const box = document.getElementById('cx-fill-log');
      if (!box) return;
      const line = document.createElement('div');
      line.className = level || 'info';
      line.textContent = '[' + new Date().toLocaleTimeString() + '] ' + msg;
      box.appendChild(line);
      while (box.childNodes.length > 60) box.removeChild(box.firstChild);
      box.scrollTop = box.scrollHeight;
    } catch (e) { /* ignore */ }
  }

  function broadcast(msg) {
    const seen = new Set();
    (function walk(win) {
      if (!win || seen.has(win)) return;
      seen.add(win);
      try { win.postMessage(msg, '*'); } catch (e) { /* ignore */ }
      let n = 0;
      try { n = win.frames.length; } catch (e) { return; }
      for (let i = 0; i < n; i++) {
        try { walk(win.frames[i]); } catch (e) { /* ignore */ }
      }
    })(window.top || window);
  }

  function buildPanel() {
    if (!IS_TOP) return;
    if (document.getElementById('cx-fill-root')) return;

    addStyle(PANEL_CSS);
    const cfg = getConfig();

    const root = document.createElement('div');
    root.id = 'cx-fill-root';
    root.innerHTML = `
      <button id="cx-fill-toggle" title="英语填空题助手">填</button>
      <div id="cx-fill-panel" class="cx-hidden">
        <div class="cx-head"><span>英语填空题自动填写助手</span><span class="cx-close" id="cx-fill-close">×</span></div>
        <div class="cx-body">
          <label>英文原文（识别后在此显示，命中的答案会加粗标红并编号）</label>
          <div id="cx-fill-original" class="cx-original" contenteditable="true" data-ph="在此粘贴完整英文原文，或直接点下方「转写并填空」自动识别"></div>
          <div class="cx-row">
            <label style="margin:0;font-weight:400;"><input type="checkbox" id="cx-fill-auto"> 自动填空</label>
            <button class="cx-primary" id="cx-fill-run">立即扫描并填空</button>
            <button class="cx-ghost" id="cx-fill-save">保存原文</button>
            <button class="cx-ghost" id="cx-fill-debug">复制题目HTML(调试)</button>
            <button class="cx-ghost" id="cx-fill-clear">清空原文/URL</button>
          </div>

          <div class="cx-sep">听力音频转写（浏览器内置 Whisper）</div>
          <div class="cx-row" style="margin-bottom:6px;">
            <select id="cx-fill-audiourl" class="cx-select" style="flex:1;margin-bottom:0;">
              <option value="">全部音频（依次转写）</option>
            </select>
            <button class="cx-ghost" id="cx-fill-refresh">刷新列表</button>
          </div>
          <input id="cx-fill-audiourl-manual" class="cx-input" placeholder="或手动填写音频URL（留空则使用上面的选择）">
          <div class="cx-row">
            <select id="cx-fill-whispermodel" class="cx-select" style="width:auto;margin-bottom:0;">
              <option value="Xenova/whisper-tiny.en">tiny.en（快，约40MB）</option>
              <option value="Xenova/whisper-base.en">base.en（较准，约80MB）</option>
            </select>
            <select id="cx-fill-modelhost" class="cx-select" style="width:auto;margin-bottom:0;">
              <option value="https://hf-mirror.com">模型源：国内镜像</option>
              <option value="https://huggingface.co">模型源：官方</option>
            </select>
            <button class="cx-primary" id="cx-fill-transcribe">转写并填空</button>
            <label style="margin:0;font-weight:400;"><input type="checkbox" id="cx-fill-audioauto"> 自动转写</label>
            <label style="margin:0;font-weight:400;"><input type="checkbox" id="cx-fill-autonext"> 完成后自动下一章</label>
          </div>

          <div class="cx-log" id="cx-fill-log"></div>
        </div>
      </div>`;
    (document.body || document.documentElement).appendChild(root);

    const panel = document.getElementById('cx-fill-panel');
    const originalBox = document.getElementById('cx-fill-original');
    const autoBox = document.getElementById('cx-fill-auto');

    if (cfg.originalText) setPlainOriginal(cfg.originalText);
    originalBox.dataset.styled = '0';
    autoBox.checked = !!cfg.autoFill;

    // 手动编辑后按纯文本处理，并同步保存
    originalBox.addEventListener('input', () => {
      originalBox.dataset.styled = '0';
      saveConfig({ originalText: (originalBox.innerText || '').trim() });
    });

    const audioUrlBox = document.getElementById('cx-fill-audiourl');
    const audioManualBox = document.getElementById('cx-fill-audiourl-manual');
    const modelSel = document.getElementById('cx-fill-whispermodel');
    const hostSel = document.getElementById('cx-fill-modelhost');
    const audioAutoBox = document.getElementById('cx-fill-audioauto');
    const autoNextBox = document.getElementById('cx-fill-autonext');
    audioManualBox.value = cfg.audioUrl || '';
    modelSel.value = cfg.whisperModel || 'Xenova/whisper-base.en';
    if (!modelSel.value) modelSel.value = 'Xenova/whisper-base.en';
    hostSel.value = cfg.modelHost || 'https://hf-mirror.com';
    if (!hostSel.value) hostSel.value = 'https://hf-mirror.com';
    audioAutoBox.checked = !!cfg.audioAuto;
    autoNextBox.checked = !!cfg.autoNext;

    document.getElementById('cx-fill-toggle').addEventListener('click', () => {
      panel.classList.toggle('cx-hidden');
      if (!panel.classList.contains('cx-hidden')) {
        // 打开面板时刷新音频列表
        _audioUrls = [];
        refreshAudioSelect();
        broadcast({ __cxfill: true, type: 'collect-audio' });
      }
    });
    document.getElementById('cx-fill-close').addEventListener('click', () => {
      panel.classList.add('cx-hidden');
    });
    document.getElementById('cx-fill-save').addEventListener('click', () => {
      const t = readOriginal();
      saveConfig({ originalText: t, autoFill: autoBox.checked });
      log('原文已保存（共 ' + t.length + ' 字符）', 'success');
      broadcast({ __cxfill: true, type: 'run' });
    });
    document.getElementById('cx-fill-run').addEventListener('click', () => {
      saveConfig({ originalText: readOriginal(), autoFill: autoBox.checked });
      broadcast({ __cxfill: true, type: 'run' });
    });
    document.getElementById('cx-fill-debug').addEventListener('click', () => {
      log('正在收集题目HTML，请稍候…', 'info');
      broadcast({ __cxfill: true, type: 'debug' });
    });
    document.getElementById('cx-fill-clear').addEventListener('click', () => {
      setPlainOriginal('');
      audioManualBox.value = '';
      audioUrlBox.selectedIndex = 0;
      saveConfig({ originalText: '', audioUrl: '' });
      log('已清空「原文」和「音频URL」', 'success');
    });
    document.getElementById('cx-fill-refresh').addEventListener('click', () => {
      _audioUrls = [];
      refreshAudioSelect();
      broadcast({ __cxfill: true, type: 'collect-audio' });
      log('正在刷新音频列表…', 'info');
    });
    audioUrlBox.addEventListener('change', () => {
      audioManualBox.value = audioUrlBox.value; // 选择“全部”时为空
      saveConfig({ audioUrl: audioUrlBox.value });
    });
    audioManualBox.addEventListener('change', () => saveConfig({ audioUrl: audioManualBox.value.trim() }));
    modelSel.addEventListener('change', () => saveConfig({ whisperModel: modelSel.value }));
    hostSel.addEventListener('change', () => saveConfig({ modelHost: hostSel.value }));
    audioAutoBox.addEventListener('change', () => saveConfig({ audioAuto: audioAutoBox.checked }));
    autoNextBox.addEventListener('change', () => saveConfig({ autoNext: autoNextBox.checked }));
    document.getElementById('cx-fill-transcribe').addEventListener('click', () => {
      saveConfig({
        audioUrl: audioManualBox.value.trim(),
        whisperModel: modelSel.value,
        modelHost: hostSel.value,
        audioAuto: audioAutoBox.checked,
        autoNext: autoNextBox.checked,
      });
      log('开始音频转写…', 'info');
      startAutoSequence();
    });
    autoBox.addEventListener('change', () => {
      saveConfig({ autoFill: autoBox.checked });
      if (autoBox.checked) broadcast({ __cxfill: true, type: 'run' });
    });

    try {
      if (typeof GM_registerMenuCommand === 'function') {
        GM_registerMenuCommand('打开/关闭英语填空助手', () => panel.classList.toggle('cx-hidden'));
      }
    } catch (e) { /* ignore */ }
  }

  /* =========================================================================
   * 八、消息监听与启动
   * =======================================================================*/

  window.addEventListener('message', (e) => {
    const d = e.data;
    if (!d || !d.__cxfill) return;
    if (d.type === 'run') {
      runAuto();
    } else if (d.type === 'fill') {
      runFill(d.text, true);
    } else if (d.type === 'collect-audio') {
      reportAudioList();
    } else if (d.type === 'audio-list' && IS_TOP) {
      (d.urls || []).forEach((u) => { if (u && _audioUrls.indexOf(u) === -1) _audioUrls.push(u); });
      _pendingFrames++;
      refreshAudioSelect();
    } else if (d.type === 'auto-seq') {
      runFrameAudioSequence();
    } else if (d.type === 'auto-seq-done' && IS_TOP) {
      _doneFrames++;
      if (_doneFrames >= _pendingFrames) {
        log('本轮音频处理完成（等待其它任务点完成后自动进入下一章）', 'success');
      }
    } else if (d.type === 'preview' && IS_TOP) {
      setStyledOriginal(d.html, d.text);
    } else if (d.type === 'abort') {
      _seqToken++;
    } else if (d.type === 'transcribe') {
      handleTranscribe();
    } else if (d.type === 'transcript' && IS_TOP) {
      applyTranscript(d.text, d.url);
    } else if (d.type === 'transcript-error' && IS_TOP) {
      log('音频转写失败：' + d.message, 'error');
    } else if (d.type === 'log' && IS_TOP) {
      appendLog(d.msg, d.level);
    } else if (d.type === 'debug') {
      const cs = findContainers(document);
      if (!cs.length) return;
      cs.slice(0, 5).forEach((c, i) => {
        log('调试 容器' + (i + 1) + '：<' + c.tagName.toLowerCase() + ' class="' + (c.className || '') + '"> 输入框=' + findBlankEditors(c).length);
        log('  文本：' + (c.innerText || '').replace(/\s+/g, ' ').slice(0, 120));
      });
      try {
        window.top.postMessage({ __cxfill: true, type: 'debug-html', html: cs[0].outerHTML }, '*');
      } catch (err) { /* ignore */ }
    } else if (d.type === 'debug-html' && IS_TOP) {
      window.__cxDebugHTML = d.html;
      console.log('[填空助手] 题目HTML（已保存到 window.__cxDebugHTML）：\n' + d.html);
      const manual = () => {
        try { window.prompt('自动复制失败，请全选复制下面的题目HTML：', d.html); } catch (err) { /* ignore */ }
      };
      try {
        navigator.clipboard.writeText(d.html).then(
          () => appendLog('题目HTML已复制到剪贴板（长度 ' + d.html.length + '），请粘贴给开发者', 'success'),
          () => { appendLog('剪贴板写入失败，已弹出文本框供手动复制', 'error'); manual(); }
        );
      } catch (err) {
        appendLog('剪贴板不可用，已弹出文本框供手动复制', 'error');
        manual();
      }
    }
  });

  if (IS_TOP) {
    buildPanel();
  }
  bootstrapFrame();

})();