// ==UserScript==
// @name         U校园刷课助手
// @namespace    http://tampermonkey.net/
// @version      1.1
// @description  U校园（Unipus）刷课工具，自动遍历目录 + AI 自动作答（DeepSeek 文本 + Qwen3-Omni-Flash 多模态听力）+ 时长分配 + 视频自动播放
// @author       叶屿
// @license      GPL3
// @antifeature  payment AI 答题与解锁加速功能需要验证码（免费看广告获取），视频自动播放等基础功能完全免费；用户需自备 DeepSeek / 通义千问 等 API Key
// @match        https://ucontent.unipus.cn/*
// @match        https://ipub.unipus.cn/*
// @match        https://uai.unipus.cn/*
// @match        https://u.unipus.cn/*
// @match        https://*.u.unipus.cn/*
// @icon         https://ucontent.unipus.cn/favicon.ico
// @grant        GM_xmlhttpRequest
// @grant        GM_setValue
// @grant        GM_getValue
// @connect      qsy.iano.cn
// @connect      open.bigmodel.cn
// @connect      api.deepseek.com
// @connect      dashscope.aliyuncs.com
// @connect      unipus.cn
// @connect      ucontent.unipus.cn
// @connect      *.unipus.cn
// @connect      *
// @run-at       document-end
// @noframes     false
// ==/UserScript==

/*
 * ==========================================
 * U校园刷课助手 v1.1
 * ==========================================
 *
 * 【功能说明】
 * - 自动遍历 Unit/Section/Micro 三级目录
 * - AI 自动作答：DeepSeek（文本）+ 通义千问Qwen3-Omni-Flash / 智谱GLM-4-Voice（听力多模态）
 * - 学习时长智能分配（总时长均分到每项）
 * - 视频/音频自动播放
 * - 自动关闭"我知道了"等弹窗
 * - 实时进度日志 + 倒计时显示
 * - 悬浮球UI入口
 *
 * 【参考项目】
 * - UnipusAIAutoPlayer (https://github.com/uxudjs/UnipusAIAutoPlayer)
 *   - 借鉴菜单识别 + iframe 通信架构
 *
 * 【免责声明】
 * 本脚本仅供学习交流使用，请勿用于违反学校规定或作弊行为
 *
 * 【版权信息】
 * 作者：叶屿 | 版本：v1.1 | 更新：2026-05-24
 *
 * 【v1.1 更新】
 * - 听力题模型推荐标签（千问满分率高，智谱限流不稳）
 * - 远程公告系统（对接 qsy.iano.cn 后台）
 * - 增加 @antifeature payment 合规声明
 *
 * ==========================================
 */

(() => {
  'use strict';

  // ---- 全局环境标识 ----
  const IS_IPUB = location.hostname.includes('ipub.unipus.cn') || location.hostname.includes('uai.unipus.cn');
  const IS_UCONTENT = location.hostname.includes('ucontent.unipus.cn');
  // 普通版（旧版）U 校园：u.unipus.cn / sso.u.unipus.cn 等
  const IS_LEGACY = location.hostname === 'u.unipus.cn' || location.hostname.endsWith('.u.unipus.cn');
  // ucontent 可能是全页面（用户从目录点进来）或 iframe 内
  const IS_IFRAME = (() => {
    try { return window.self !== window.top; } catch (_) { return true; }
  })();
  // 主页面：顶层 ipub/legacy，或者 ucontent 作为全页面打开时
  const IS_MAIN = !IS_IFRAME && (IS_IPUB || IS_LEGACY || IS_UCONTENT);

  // ---- 全局状态 ----
  let panel = null;
  let isRunning = false;
  let isPaused = false;
  let stopRequested = false;
  let AI_PROVIDERS = {};
  // 各 AI 提供商最近一次请求时间（节流避免限流）
  const aiLastRequestAt = {};

  // ---- 配置 ----
  const Config = {
    version: '1.1',
    playbackRate: 1,           // 视频倍速（默认 1x）
    stepWaitMs: 3000,          // 章节进入后等待（给 SPA 足够加载时间）
    minStepSec: 8,             // 每项最少等待秒数
    pollIntervalMs: 800,       // DOM 轮询间隔
    chapterEndWaitMs: 2500,    // 章节末尾 → 下一章 之前的缓冲时间
    afterSubmitWaitMs: 1500,   // 答题提交后等待（关弹窗 / 等待跳转）
    tabSwitchWaitMs: 2500,     // 标签页切换后的等待
    // 题间延迟（毫秒）
    questionDelayLocked: 35000,   // 广告模式：35 秒
    questionDelayUnlocked: 1500,  // 解锁后：1.5 秒
    questionDelayJitter: 500,     // 抖动随机量
    // 广告 / 解锁码 API
    qrImageUrl: 'https://qsy.iano.cn/yzm.png',
    verifyUrl: 'https://qsy.iano.cn/index.php?s=/api/code/verify',
    announceUrl: 'https://qsy.iano.cn/index.php?s=/admin/unified_manage/scriptannouncementapi',
    storageKeys: {
      deviceId: 'unipus_device_id',
      aiApiKey: 'unipus_ai_api_key',
      aiProvider: 'unipus_ai_provider',
      audioApiKey: 'unipus_audio_api_key',
      audioProvider: 'unipus_audio_provider',
      verifyValidUntil: 'unipus_verify_valid_until',
      answerMode: 'unipus_answer_mode',
      unmatchedFallback: 'unipus_unmatched_fallback',
      playbackRate: 'unipus_playback_rate',
      featureConf: 'unipus_feature_conf',
      lastTimeValue: 'unipus_last_time_value',
      panelOpen: 'unipus_panel_open',
    }
  };

  // ---- 工具函数 ----
  const Utils = {
    sleep: (ms = 1000) => new Promise(r => setTimeout(r, ms)),
    safeText: (v) => (typeof v === 'string' ? v.replace(/\s+/g, ' ').trim() : ''),
    safeJSON(raw, fallback = null) {
      if (!raw) return fallback;
      try { return JSON.parse(raw); } catch (_) { return fallback; }
    },
    genDeviceId() {
      let id = localStorage.getItem(Config.storageKeys.deviceId);
      if (!id) {
        id = 'unipus_' + Date.now() + '_' + Math.random().toString(36).slice(2, 11);
        localStorage.setItem(Config.storageKeys.deviceId, id);
      }
      return id;
    },
    // 等待条件成立
    async poll(predicate, { interval = 800, timeout = 30000 } = {}) {
      const start = Date.now();
      while (Date.now() - start < timeout) {
        if (stopRequested) return null;
        const v = await predicate();
        if (v) return v;
        await Utils.sleep(interval);
      }
      return null;
    },
    // 等待暂停结束
    async waitIfPaused() {
      while (isPaused && !stopRequested) {
        await Utils.sleep(500);
      }
    },
    formatTime(seconds) {
      seconds = Math.max(0, Math.round(seconds));
      const m = Math.floor(seconds / 60);
      const s = seconds % 60;
      return `${m}:${String(s).padStart(2, '0')}`;
    },
    // 模拟点击（鼠标事件 + click）
    safeClick(el) {
      if (!el) return false;
      try {
        if (el.scrollIntoView) {
          try { el.scrollIntoView({ block: 'center', inline: 'center' }); } catch (_) {}
        }
        const opts = { bubbles: true, cancelable: true, view: window };
        ['mouseover', 'mousedown', 'mouseup', 'click'].forEach(t => {
          try { el.dispatchEvent(new MouseEvent(t, opts)); } catch (_) {}
        });
        if (typeof el.click === 'function') {
          try { el.click(); } catch (_) {}
        }
        return true;
      } catch (_) { return false; }
    },
    // 取第一个可见元素
    firstVisible(nodes) {
      for (const n of (nodes || [])) {
        if (!n) continue;
        try {
          const rect = n.getBoundingClientRect?.();
          if (rect && rect.width > 0 && rect.height > 0) return n;
        } catch (_) {}
      }
      return null;
    },
  };

  // ---- 存储 Store ----
  const Store = {
    getAIApiKey() { return localStorage.getItem(Config.storageKeys.aiApiKey) || ''; },
    setAIApiKey(v) { localStorage.setItem(Config.storageKeys.aiApiKey, v || ''); },
    getAIProvider() {
      const p = localStorage.getItem(Config.storageKeys.aiProvider) || 'deepseek';
      // 旧值兼容：之前可能存的是 zhipu/qwen/gpt 等已删除的，统一回退到 deepseek
      return (typeof AI_PROVIDERS !== 'undefined' && AI_PROVIDERS[p] && AI_PROVIDERS[p].type === 'text') ? p : 'deepseek';
    },
    setAIProvider(v) { localStorage.setItem(Config.storageKeys.aiProvider, v || 'deepseek'); },
    getAudioApiKey() { return localStorage.getItem(Config.storageKeys.audioApiKey) || ''; },
    setAudioApiKey(v) { localStorage.setItem(Config.storageKeys.audioApiKey, v || ''); },
    getAudioProvider() {
      const p = localStorage.getItem(Config.storageKeys.audioProvider) || 'qwen_audio';
      return (typeof AI_PROVIDERS !== 'undefined' && AI_PROVIDERS[p] && AI_PROVIDERS[p].type === 'audio') ? p : 'qwen_audio';
    },
    setAudioProvider(v) { localStorage.setItem(Config.storageKeys.audioProvider, v || 'qwen_audio'); },
    getVerifyValidUntil() { return parseInt(localStorage.getItem(Config.storageKeys.verifyValidUntil) || '0', 10); },
    setVerifyValidUntil(ts) { localStorage.setItem(Config.storageKeys.verifyValidUntil, String(ts)); },
    isVerifyValid() { return this.getVerifyValidUntil() > Math.floor(Date.now() / 1000); },
    // 广告模式别名
    isUnlocked() { return this.isVerifyValid(); },
    getRemainingMs() {
      const until = this.getVerifyValidUntil();
      if (!until) return 0;
      return Math.max(0, until * 1000 - Date.now());
    },
    getValidUntilStr() {
      const until = this.getVerifyValidUntil();
      if (!until) return '';
      try { return new Date(until * 1000).toLocaleString('zh-CN'); } catch (_) { return ''; }
    },
    getAnswerMode() { return localStorage.getItem(Config.storageKeys.answerMode) || 'free'; }, // free/ai
    setAnswerMode(v) { localStorage.setItem(Config.storageKeys.answerMode, v || 'free'); },
    getPlaybackRate() {
      const v = parseFloat(localStorage.getItem(Config.storageKeys.playbackRate));
      return Number.isFinite(v) && v > 0 ? v : 1;
    },
    setPlaybackRate(v) { localStorage.setItem(Config.storageKeys.playbackRate, String(v)); },
    getFeatureConf() {
      return Utils.safeJSON(localStorage.getItem(Config.storageKeys.featureConf), { autoAnswer: true, autoPopup: true });
    },
    setFeatureConf(conf) { localStorage.setItem(Config.storageKeys.featureConf, JSON.stringify(conf || {})); },
    getLastTimeValue() {
      const v = parseInt(localStorage.getItem(Config.storageKeys.lastTimeValue) || '60', 10);
      return Number.isFinite(v) && v > 0 ? v : 60;
    },
    setLastTimeValue(v) { localStorage.setItem(Config.storageKeys.lastTimeValue, String(v)); },
    getPanelOpen() { return localStorage.getItem(Config.storageKeys.panelOpen) === '1'; },
    setPanelOpen(v) { localStorage.setItem(Config.storageKeys.panelOpen, v ? '1' : '0'); },
  };

  // 各 provider 最小请求间隔（毫秒）—— 避免触发免费层级限流
  // 智谱 GLM-4-Voice 限流严格（QPM ~6），需要至少 10s 间隔
  const AI_MIN_INTERVAL_MS = {
    deepseek: 500,
    qwen_audio: 1500,
    zhipu_audio: 12000,
  };

  // ---- AI 提供商配置 ----
  // type: 'text' = 普通文本题；'audio' = 多模态（含音频）听力题
  AI_PROVIDERS = {
    deepseek: {
      name: 'DeepSeek-V3',
      model: 'deepseek-chat',
      url: 'https://api.deepseek.com/chat/completions',
      free: false,
      type: 'text',
      desc: 'DeepSeek高性价比文本模型，用于普通题目兜底',
      link: 'https://platform.deepseek.com/',
      linkText: '前往 DeepSeek 平台 →',
      keyHint: '左侧 API Keys → 创建',
    },
    qwen_audio: {
      name: '通义千问 Qwen3-Omni-Flash',
      model: 'qwen3-omni-flash',
      url: 'https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions',
      free: false,
      type: 'audio',
      desc: '阿里通义千问全模态模型 Flash 版，听力题首选',
      link: 'https://bailian.console.aliyun.com/',
      linkText: '前往阿里云百炼 →',
      keyHint: '右上角 API-KEY → 创建（新用户有免费额度）',
    },
    zhipu_audio: {
      name: '智谱 GLM-4-Voice',
      model: 'glm-4-voice',
      url: 'https://open.bigmodel.cn/api/paas/v4/chat/completions',
      free: true,
      type: 'audio',
      desc: '智谱端到端语音模型，邀请注册得 2000万 Tokens',
      link: 'https://www.bigmodel.cn/invite?icode=upWK8Rq09RynLhZ8CwWAqf2gad6AKpjZefIo3dVEQyA%3D',
      linkText: '前往智谱开放平台 (得2000万Tokens) →',
      keyHint: '控制台 → API Keys → 创建',
    },
  };

  // ---- Solver: 题目识别 + AI 答题 ----
  const Solver = {
    // 标准题型（与雨课堂/题库 API 一致）
    TYPE_SINGLE: 0, TYPE_MULTI: 1, TYPE_FILL: 2, TYPE_JUDGE: 3, TYPE_OTHER: 4,
    // U 校园扩展题型（内部使用，发送到题库前会映射回标准题型）
    TYPE_LISTENING: 10,    // 听力（音频+选择）
    TYPE_READING: 11,      // 阅读理解（文章+多题）
    TYPE_TRANSLATION: 12,  // 翻译题（输入框）
    TYPE_WRITING: 13,      // 写作（长文 textarea）
    TYPE_CLOZE: 14,        // 完形填空（多个空格）
    TYPE_DICTATION: 15,    // 听写
    TYPE_SPEAKING: 16,     // 跟读/口语（不支持，自动跳过）

    // 把内部扩展题型映射回标准题型（用于题库查询/AI prompt）
    standardType(t) {
      const map = {
        10: 0,   // 听力 → 单选/多选（看实际选项）
        11: 0,   // 阅读 → 单选
        12: 2,   // 翻译 → 填空
        13: 2,   // 写作 → 填空
        14: 2,   // 完形 → 填空
        15: 2,   // 听写 → 填空
      };
      return map[t] !== undefined ? map[t] : t;
    },
    typeName(t) {
      const names = {
        0: '单选题', 1: '多选题', 2: '填空题', 3: '判断题', 4: '其他',
        10: '听力题', 11: '阅读理解', 12: '翻译题', 13: '写作题', 14: '完形填空', 15: '听写题', 16: '口语题',
      };
      return names[t] || '未知';
    },

    // 在文档中查找所有题目容器（兼容新版 + 普通版 U 校园）
    findQuestions(doc = document) {
      // 排除脚本自身面板（避免把"AI 兜底/跳过"radio 当成题目）
      const isInOwnPanel = (el) => {
        if (!el || !el.closest) return false;
        return !!el.closest('#unipus-panel, #unipus-settings-overlay, [data-unipus-helper]');
      };
      const selectors = [
        // 新版（ipub/uai/ucontent）—— 精确选择器
        '.QuestionBox',
        '.question-item',
        '.test-question',
        '.exercise-question',
        '[class*="QuestionItem"]',
        '[class*="question-wrap"]',
        '.iSlide-item .question',
        'div[data-question-id]',
        // ucontent 常见题目容器
        '.topic-item', '.subject-item', '.ques-item',
        '.practice-item', '.practice-question',
        // 普通版 u.unipus.cn
        '.exercise-item',
        '.exercise-container',
        '.activity-question',
        '[data-type="question"]',
        '[id^="question-"]',
        '[id^="q_"]',
        '.test-item',
        '.task-item',
        '.quiz-item',
        '.exam-item',
      ];
      const candidates = new Set();
      for (const sel of selectors) {
        try {
          doc.querySelectorAll(sel).forEach(el => {
            if (!isInOwnPanel(el)) candidates.add(el);
          });
        } catch (_) {}
      }

      // 始终用「按 radio/checkbox 分组」补充候选（不只在选择器空时）
      try {
        const radios = doc.querySelectorAll('input[type="radio"], input[type="checkbox"]');
        // 按 name 分组（同 name 一定是同一题）
        const byName = new Map();
        radios.forEach(r => {
          if (isInOwnPanel(r)) return; // 排除自身面板的 radio
          const name = r.name || r.getAttribute('data-name') || '';
          if (!name) return;
          if (!byName.has(name)) byName.set(name, []);
          byName.get(name).push(r);
        });
        for (const group of byName.values()) {
          if (group.length < 2 || group.length > 10) continue;
          // 找整组的最近公共祖先
          let ancestor = group[0].parentElement;
          for (let d = 0; d < 12 && ancestor; d++) {
            if (group.every(r => ancestor.contains(r))) break;
            ancestor = ancestor.parentElement;
          }
          if (ancestor && !isInOwnPanel(ancestor)) candidates.add(ancestor);
        }
      } catch (_) {}

      // 验证：每个候选必须有真实答题元素（≥2 个 radio/checkbox 或 ≥1 个填空类输入）
      const validated = [];
      for (const el of candidates) {
        if (isInOwnPanel(el)) continue;
        try {
          const radioCount = el.querySelectorAll('input[type="radio"], input[type="checkbox"]').length;
          const fillCount = el.querySelectorAll('input[type="text"], input[type="number"], textarea, [contenteditable="true"]').length;
          if (radioCount >= 2 || (radioCount === 0 && fillCount >= 1)) {
            validated.push(el);
          }
        } catch (_) {}
      }

      // 去重：嵌套时只保留最内层（深度更深的）
      const filtered = validated.filter(c =>
        !validated.some(other => other !== c && c.contains(other))
      );

      // 排序：按 DOM 顺序（document order）
      filtered.sort((a, b) => {
        try {
          const pos = a.compareDocumentPosition(b);
          if (pos & Node.DOCUMENT_POSITION_FOLLOWING) return -1;
          if (pos & Node.DOCUMENT_POSITION_PRECEDING) return 1;
        } catch (_) {}
        return 0;
      });

      return filtered;
    },

    // 从题目容器提取题干
    extractQuestion(container) {
      if (!container) return '';
      const stems = [
        // 新版
        '.QuestionStem', '.question-stem',
        '.q-content', '.stem',
        '[class*="QuestionStem"]',
        '[class*="question-content"]',
        '[class*="question-title"]', '[class*="QuestionTitle"]',
        // 普通版
        '.exercise-stem',
        '.exercise-title',
        '.q-stem', '.q-title',
        '.task-content',
        '.question-title',
        '.test-title',
        '.exam-title',
        'h3', 'h4',  // 题干常用标题
      ];
      for (const sel of stems) {
        const el = container.querySelector(sel);
        if (el) {
          const txt = Utils.safeText(el.innerText || el.textContent);
          if (txt && txt.length >= 3) return this._cleanQuestionText(txt);
        }
      }
      // 兜底：克隆容器，移除所有选项 / 输入框，取剩下的文字（避免把选项混进题干）
      try {
        const clone = container.cloneNode(true);
        clone.querySelectorAll(
          'input, textarea, ' +
          'label[class*="radio"], label[class*="checkbox"], ' +
          '[role="radio"], [role="checkbox"], ' +
          '[class*="option"], [class*="Option"], ' +
          '[class*="choice"], [class*="Choice"], ' +
          '.QuestionOption, .question-option, .answer-option, .test-option, ' +
          'audio, video, button, .ant-radio-wrapper, .ant-checkbox-wrapper'
        ).forEach(n => n.remove());
        const txt = Utils.safeText(clone.innerText || clone.textContent);
        if (txt && txt.length >= 3) {
          return this._cleanQuestionText(txt.length > 500 ? txt.slice(0, 500) : txt);
        }
      } catch (_) {}
      // 题干在容器内为空（典型听力题：只有 ABCD 选项），向上找父节点的指引文字
      try {
        const sharedPrompt = this._findSharedPrompt(container);
        if (sharedPrompt) return this._cleanQuestionText(sharedPrompt);
      } catch (_) {}
      // 最终兜底：返回提示语（避免把选项当题干，导致 AI 混乱）
      return '（听力题，请根据音频和选项作答）';
    },

    // 向上找祖先节点，寻找共享的题目指引文字（如"Listen and choose..."）
    _findSharedPrompt(container) {
      let cur = container.parentElement;
      for (let d = 0; d < 6 && cur; d++) {
        // 找父节点直接子元素中不含选项 / input 的文本节点
        const directChildren = Array.from(cur.children).filter(c => !c.contains(container));
        for (const ch of directChildren) {
          // 跳过包含 input / option 的子树
          if (ch.querySelector('input[type="radio"], input[type="checkbox"], [class*="option"], [class*="Option"]')) continue;
          const txt = Utils.safeText(ch.innerText || ch.textContent);
          // 长度合理 (10-300) 且包含问号或祈使语气
          if (txt && txt.length >= 10 && txt.length <= 300 &&
              (/[?？]/.test(txt) || /listen|choose|select|watch|read|please|根据|选择|听|看|读/i.test(txt))) {
            return txt;
          }
        }
        cur = cur.parentElement;
      }
      return '';
    },

    // 清洗题干：去掉常见前缀干扰
    _cleanQuestionText(t) {
      if (!t) return '';
      return t
        .replace(/^\s*\d+\s*[.、．:：)）]\s*/, '')      // 去开头的 "1." "2、" 等题号
        .replace(/^\s*\(\s*\d+\s*\)\s*/, '')             // 去开头 "(1)"
        .replace(/^\s*【\s*\d+\s*】\s*/, '')             // 去开头 "【1】"
        .replace(/^\s*Q\s*\d+\s*[.:：]?\s*/i, '')        // 去开头 "Q1." "Q1:"
        .trim();
    },

    // 提取选项列表（返回 [{text, node}, ...]）
    extractOptions(container) {
      if (!container) return [];
      const seen = new Set();
      const options = [];

      const stripPrefix = (s) => (s || '').replace(/^[A-Ha-h]\s*[.、．:：)）]\s*/, '').trim();

      // 优先策略：直接找 radio/checkbox，每个对应一个选项
      // 这是最可靠的（题目最终要点这些 input）
      try {
        const inputs = container.querySelectorAll('input[type="radio"], input[type="checkbox"]');
        for (const inp of inputs) {
          // 找最近的可点击包装（label > .option > li > div）
          const wrap = inp.closest('label, [class*="option"], [class*="Option"], [class*="choice"], [class*="Choice"], li')
                    || inp.parentElement;
          if (!wrap || seen.has(wrap)) continue;
          seen.add(wrap);
          seen.add(inp);
          let text = Utils.safeText(wrap.innerText || wrap.textContent);
          text = stripPrefix(text);
          if (text && text.length <= 500) options.push({ text, node: wrap });
        }
      } catch (_) {}

      // 备用：role=radio/checkbox（无原生 input 时）
      if (options.length < 2) {
        try {
          container.querySelectorAll('[role="radio"], [role="checkbox"]').forEach(n => {
            if (seen.has(n)) return;
            seen.add(n);
            let text = stripPrefix(Utils.safeText(n.innerText || n.textContent));
            if (text && text.length <= 500) options.push({ text, node: n });
          });
        } catch (_) {}
      }

      // 备用 2：用 CSS class 选择器（仅当上面都没找到）
      if (options.length < 2) {
        const optSelectors = [
          '.QuestionOption', '.question-option',
          '.option-item', '.opt-item', '.opt',
          '.choice', '.choice-item',
          '[class*="Option"]', '[class*="option"]',
          '.answer-option', '.answer-item',
          '.test-option', '.quiz-option',
          '.choice-list > li', '.option-list > li',
          'ul.options > li', 'ol.options > li',
          'label.choice', 'label.option',
        ];
        for (const sel of optSelectors) {
          let nodes;
          try { nodes = container.querySelectorAll(sel); } catch (_) { continue; }
          if (!nodes || !nodes.length) continue;
          for (const n of nodes) {
            if (seen.has(n)) continue;
            seen.add(n);
            let text = stripPrefix(Utils.safeText(n.innerText || n.textContent));
            if (text && text.length <= 500) options.push({ text, node: n });
          }
        }
      }

      return options;
    },

    // 探测题型（U 校园扩展：先识别特殊题型，再回退到通用题型）
    detectType(container, optionCount) {
      if (!container) return this.TYPE_OTHER;
      const txt = (container.innerText || container.textContent || '').slice(0, 300);
      const hint = txt.toLowerCase();
      const html = (container.innerHTML || '').toLowerCase();

      // ----- U 校园特殊题型识别 -----

      // 口语/跟读：检测录音按钮（无法自动）
      if (/跟读|口语|record|speaking/i.test(txt) ||
          container.querySelector('[class*="record"], [class*="Record"], [class*="speak"]')) {
        return this.TYPE_SPEAKING;
      }

      // 听写题：音频 + 多个填空框（不是选项）
      // 音频可能在容器内 / 父级 / 兄弟节点（多个子题共享一个 tab 级音频）
      const hasAudioInside = !!container.querySelector('audio, [class*="audio"], [class*="Audio"]');
      // 整页查找（兜底）：U 校园通常每个 tab 共享一个顶层音频，可能在容器外更高位置
      const hasAudioOnPage = !!document.querySelector('audio');
      const hasAudio = hasAudioInside || hasAudioOnPage;
      const inputCount = container.querySelectorAll('input[type="text"], textarea, [contenteditable="true"]').length;
      if (/听写|dictation/i.test(txt) || (hasAudio && inputCount >= 2 && !optionCount)) {
        return this.TYPE_DICTATION;
      }

      // 听力选择：音频 + 选项
      if (hasAudio && optionCount > 0) {
        return this.TYPE_LISTENING;
      }

      // 写作题：长文 textarea（一个 textarea + 题干含"写作/作文/composition/essay"）
      if (/写作|作文|composition|essay|write\s+(an?\s+)?(essay|article|paragraph)/i.test(txt)) {
        if (container.querySelector('textarea')) return this.TYPE_WRITING;
      }
      // 单一 textarea 且字数限制提示 → 写作
      if (container.querySelectorAll('textarea').length === 1 &&
          /字数|words|word\s*count|至少.*\d+\s*字/i.test(txt)) {
        return this.TYPE_WRITING;
      }

      // 翻译题：题干含"翻译/translate/中译英/英译中" + 有输入框
      if (/翻译|translate|translation|译成|中译英|英译中|翻成/i.test(txt) && inputCount > 0) {
        return this.TYPE_TRANSLATION;
      }

      // 完形填空：多个空（≥3）且常带"完形/cloze"
      if (/完形填空|cloze/i.test(txt) || (inputCount >= 3 && !optionCount)) {
        return this.TYPE_CLOZE;
      }

      // 阅读理解：题干很长（>500 字符）且有选项 → 多半是阅读
      if (txt.length > 500 && optionCount >= 2) {
        return this.TYPE_READING;
      }

      // ----- 通用题型识别 -----
      if (/判断|对错|正确.*错误|true.*false|✓.*✗/i.test(txt)) return this.TYPE_JUDGE;
      if (/多选|多项选择|选出所有|选择所有|all\s+that\s+apply/i.test(txt)) return this.TYPE_MULTI;
      if (/单选|单项选择|选择正确/i.test(txt)) return this.TYPE_SINGLE;
      if (/填空|fill\s+in|gap[\s-]?fill/i.test(txt)) return this.TYPE_FILL;

      // 通过 DOM 推断
      if (container.querySelector('input[type="checkbox"], label.ant-checkbox-wrapper, [role="checkbox"]')) return this.TYPE_MULTI;
      if (container.querySelector('input[type="radio"], label.ant-radio-wrapper, [role="radio"]')) return this.TYPE_SINGLE;
      if (inputCount > 0) return this.TYPE_FILL;
      if (optionCount === 2) return this.TYPE_JUDGE;
      return this.TYPE_OTHER;
    },

    // 探测题目内的音频元素（用于听力/听写题先播完音频）
    findAudioInQuestion(container) {
      if (!container) return null;
      const audio = container.querySelector('audio');
      if (audio) return audio;
      // 自定义音频播放器
      const customPlayer = container.querySelector('[class*="audio-player"], [class*="AudioPlayer"], [class*="audioBox"], .play-btn, [class*="PlayBtn"]');
      if (customPlayer) {
        // 找音频元素
        const a = customPlayer.querySelector('audio');
        if (a) return a;
        // 如果只有播放按钮，返回按钮（调用方可以点击）
        return customPlayer;
      }
      return null;
    },

    // 播放音频并等待完成（用于听力题）
    async playAudioAndWait(audioOrBtn, maxWaitMs = 5 * 60 * 1000) {
      if (!audioOrBtn) return;
      if (audioOrBtn.tagName === 'AUDIO') {
        try {
          audioOrBtn.muted = false; // 听力题需要听完，浏览器允许 muted 自动播放
          audioOrBtn.volume = 0.001; // 实际接近静音
          audioOrBtn.playbackRate = Store.getPlaybackRate();
          const p = audioOrBtn.play();
          if (p && p.catch) p.catch(() => {});
        } catch (_) {}
        // 等待播放完成
        const start = Date.now();
        await Utils.poll(() => {
          if (Date.now() - start > maxWaitMs) return true;
          return Player.isEnded(audioOrBtn);
        }, { interval: 1000, timeout: maxWaitMs });
      } else {
        // 点击播放按钮
        Utils.safeClick(audioOrBtn);
        // 等几秒让音频播放
        await Utils.sleep(3000);
        // 再尝试找 audio 元素
        const a = audioOrBtn.querySelector?.('audio') || document.querySelector('audio');
        if (a) await this.playAudioAndWait(a, maxWaitMs);
      }
    },

    // 综合识别：返回 {question, options, type, container, optionNodes}
    recognize(container) {
      const question = this.extractQuestion(container);
      const optionPairs = this.extractOptions(container);
      const options = optionPairs.map(o => o.text);
      const optionNodes = optionPairs.map(o => o.node);
      const type = this.detectType(container, options.length);
      return { question, options, type, container, optionNodes };
    },

    // 根据题型构造专门 prompt（U 校园英语类题型）
    buildAIPrompt(question, options, type, blankCount = 1) {
      const typeName = this.typeName(type);
      const optTxt = (options && options.length)
        ? '\n选项：\n' + options.map((o, i) => `${String.fromCharCode(65 + i)}. ${o}`).join('\n')
        : '';

      switch (type) {
        case this.TYPE_TRANSLATION:
          return `你是英语翻译助手。请直接翻译，不要解释。

题目（翻译）：${question}

要求：
- 中→英 或 英→中（根据题目方向）
- 译文要自然、地道，符合语境
- 多个待翻译的句子或段落用 "||" 分隔
- 直接给出译文，不要"译：" 前缀`;

        case this.TYPE_WRITING:
          return `你是英语写作助手。请直接写出一篇符合要求的英语作文。

题目（写作）：${question}

要求：
- 写作题：直接给出完整作文（150-300 词，看题目要求）
- 结构清晰：开头-主体-结尾
- 语法正确、用词地道
- 不要解释，不要标题，不要"开始作文"等前缀
- 直接输出正文`;

        case this.TYPE_CLOZE:
          return `你是完形填空助手。请根据上下文给出每个空的最佳答案。

题目（完形填空）：${question}

要求：
- 直接给出每个空的答案，按顺序用 "||" 分隔
- 答案应该是单个英文单词或短语（除非题目要求短句）
- 不要解释，不要带空号
- 例如：apple || run || beautiful`;

        case this.TYPE_DICTATION:
          return `你是英语听写助手。请根据题目上下文推断听写答案。

题目（听写）：${question}

要求：
- 如果题目提供了听力原文，请按顺序给出每空的内容
- 多个空用 "||" 分隔
- 直接给出文本，不要解释`;

        case this.TYPE_LISTENING: {
          const hasRealQuestion = question && !/听力题.*音频.*选项|根据.*音频/.test(question);
          const head = hasRealQuestion
            ? `请仔细听音频，从下面 ${options.length} 个选项里选出能回答下方问题的答案。\n\n问题：${question}`
            : `请仔细听音频，从下面 ${options.length} 个选项里选出**最符合音频内容**的答案（题干未提供文字，请根据选项推断要问什么）。`;
          return `你是英语听力题助手。${head}${optTxt}

要求：
- 必须根据音频内容判断，不要凭选项字面意思猜测
- 只输出一个选项的完整文本（与给定选项一字不差地复制其中一个）
- 不要输出字母 A/B/C/D，不要 "||" 分隔，不要解释，不要多余文字
- 不要输出其他题目的答案或音频中无关内容`;
        }

        case this.TYPE_READING:
          return `你是英语阅读理解助手。请仔细阅读文章后回答问题。

题目（阅读理解）：${question}${optTxt}

要求：
- 单选：只给一个选项内容（不要字母）
- 多选：用 "||" 分隔
- 直接答案，不要解释`;

        case this.TYPE_MULTI:
          return `你是答题助手。请直接给出答案，不要解释。

题目类型：多选题
题目：${question}${optTxt}

要求：
- 回答所有正确选项的完整内容，用 "||" 分隔
- 不要回答字母 A/B/C/D
- 例如：apple || banana`;

        case this.TYPE_JUDGE:
          return `你是答题助手。请直接给出答案，不要解释。

题目类型：判断题
题目：${question}

要求：只回答 "正确" 或 "错误"（也可用 True/False）`;

        case this.TYPE_FILL:
          return `你是答题助手。请直接给出填空答案。

题目（填空题）：${question}

要求：
- 给出每个空的内容
- 多个空用 "||" 分隔
- 不要解释、不要前缀`;

        default:
          return `你是答题助手。请直接给出答案，不要解释。

题目类型：${typeName}
题目：${question}${optTxt}

回答要求：
- 单选题：只回答一个选项的完整内容（不要回答字母A/B/C/D）
- 多选题：回答所有正确选项的完整内容，用"||"分隔
- 判断题：只回答"正确"或"错误"
- 填空题：直接给出填空内容（多个空用 || 分隔）`;
      }
    },

    // 从题目容器提取音频 URL（用于多模态 AI 听力题）
    extractAudioUrl(container) {
      if (!container) return null;
      try {
        // 1) <audio src=...>
        const audio = container.querySelector('audio[src]');
        if (audio?.src && !audio.src.startsWith('blob:')) return audio.src;
        // 2) <audio><source src=.../></audio>
        const src = container.querySelector('audio source[src]');
        if (src?.src && !src.src.startsWith('blob:')) return src.src;
        // 3) data-audio / data-src
        const dataAudio = container.querySelector('[data-audio], [data-src]');
        if (dataAudio) {
          const u = dataAudio.getAttribute('data-audio') || dataAudio.getAttribute('data-src');
          if (u && /\.(mp3|wav|m4a|ogg|aac)/i.test(u)) return u;
        }
        // 4) 整页查找（兜底）
        const pageAudio = document.querySelector('audio[src]:not([src^="blob:"])');
        if (pageAudio?.src) return pageAudio.src;
      } catch (_) {}
      return null;
    },

    // 解析 AI 文本输出 → 答案数组
    _parseAIText(content, type) {
      content = (content || '').trim()
        .replace(/^答案[：:]\s*/i, '')
        .replace(/^答[：:]\s*/i, '')
        .replace(/^译文[：:]\s*/i, '')
        .replace(/^译[：:]\s*/i, '')
        .trim();
      if (type === Solver.TYPE_WRITING) return [content];
      let parts = content.includes('||')
        ? content.split('||').map(s => s.trim()).filter(Boolean)
        : [content];
      // 单选题/判断题/听力题/阅读题 默认单选 —— AI 偶尔会返回多答案污染，强制只取第一个
      const singleAnswerTypes = new Set([
        Solver.TYPE_SINGLE,
        Solver.TYPE_JUDGE,
        Solver.TYPE_LISTENING,
        Solver.TYPE_READING,
      ]);
      if (singleAnswerTypes.has(type)) parts = parts.slice(0, 1);
      return parts;
    },

    // 全局节流：确保两次同 provider 请求间隔不小于 AI_MIN_INTERVAL_MS[provider]
    async _throttle(provider, logger = null, label = '') {
      const minMs = AI_MIN_INTERVAL_MS[provider] || 0;
      if (!minMs) return;
      const last = aiLastRequestAt[provider] || 0;
      const elapsed = Date.now() - last;
      if (elapsed < minMs) {
        const wait = minMs - elapsed;
        // 等待 > 2s 时给个提示
        if (wait > 2000 && typeof logger === 'function') {
          logger(`⏳ ${label} ${AI_PROVIDERS[provider]?.name || provider} 限流节流，等待 ${(wait / 1000).toFixed(1)}s...`);
        }
        await Utils.sleep(wait);
      }
      aiLastRequestAt[provider] = Date.now();
    },

    // 调用 AI 模型作答（自动根据是否有音频选择文本/多模态模型）
    // 内置节流 + 429 重试（指数退避）
    async askAI(question, options = [], type = 4, audioUrl = null, opts = {}) {
      const logger = opts.logger || null;
      const label = opts.label || '';
      // 决定走音频模型还是文本模型
      const useAudio = !!audioUrl;
      const provider = useAudio ? Store.getAudioProvider() : Store.getAIProvider();
      const apiKey = useAudio ? Store.getAudioApiKey() : Store.getAIApiKey();
      const conf = AI_PROVIDERS[provider];
      if (!conf) throw `AI 提供商 ${provider} 配置缺失`;
      if (!apiKey) throw useAudio ? '音频 AI 未配置 API Key' : 'AI 未配置 API Key';

      const prompt = this.buildAIPrompt(question, options, type);
      const maxTokens = (type === this.TYPE_WRITING) ? 600 : 200;

      const callOnce = () => {
        if (provider === 'qwen_audio') return this._callQwenAudio(conf, apiKey, prompt, type, audioUrl, maxTokens);
        if (provider === 'zhipu_audio') return this._callZhipuAudio(conf, apiKey, prompt, type, audioUrl, maxTokens);
        return this._callTextAI(conf, apiKey, prompt, type, maxTokens);
      };

      // 节流 + 重试（智谱限流极严，不重试直接放弃；其他 provider 最多重试 3 次）
      const maxAttempts = (provider === 'zhipu_audio') ? 1 : 3;
      let lastErr = null;
      for (let attempt = 1; attempt <= maxAttempts; attempt++) {
        if (stopRequested) throw '用户已停止';
        await this._throttle(provider, logger, label);
        try {
          return await callOnce();
        } catch (err) {
          lastErr = err;
          const msg = String(err || '');
          const isRateLimit = /429|请求过于频繁|too many|rate limit|频率/i.test(msg);
          if (!isRateLimit || attempt === maxAttempts) throw err;
          // 指数退避：5s → 15s → 30s
          const backoff = 5000 * Math.pow(2, attempt - 1);
          if (typeof logger === 'function') {
            logger(`⚠️ ${label} 限流(${msg})，第 ${attempt}/${maxAttempts} 次重试，等 ${backoff / 1000}s...`);
          }
          await Utils.sleep(backoff);
        }
      }
      throw lastErr || 'AI 请求失败';
    },

    // OpenAI 兼容文本对话
    _callTextAI(conf, apiKey, prompt, type, maxTokens) {
      const headers = { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` };
      const body = { model: conf.model, messages: [{ role: 'user', content: prompt }], temperature: 0.1, max_tokens: maxTokens };
      return new Promise((resolve, reject) => {
        GM_xmlhttpRequest({
          method: 'POST', url: conf.url, headers, data: JSON.stringify(body), timeout: 60000,
          onload: res => {
            if (res.status !== 200) {
              if (res.status === 401) return reject('AI Key 无效');
              if (res.status === 429) return reject('AI 请求过于频繁');
              return reject(`AI HTTP ${res.status}`);
            }
            try {
              const json = JSON.parse(res.responseText);
              const content = json.choices?.[0]?.message?.content || '';
              resolve({ answers: Solver._parseAIText(content, type), remaining: -1 });
            } catch (_) { reject('AI 响应解析失败'); }
          },
          onerror: () => reject('AI 网络错误'),
          ontimeout: () => reject('AI 请求超时'),
        });
      });
    },

    // 通义千问 Qwen3-Omni-Flash（OpenAI 兼容模式，必须 stream:true）
    async _callQwenAudio(conf, apiKey, prompt, type, audioUrl, maxTokens) {
      // 推测音频格式
      let audioFormat = 'mp3';
      const fmt = (audioUrl.match(/\.(wav|mp3|m4a|aac|ogg|flac|amr|3gp)(?:\?|$)/i) || [])[1];
      if (fmt) audioFormat = fmt.toLowerCase();
      // 处理 audio data：HTTP(S) URL 直接用；blob: 转 base64
      let audioData = audioUrl;
      if (audioUrl.startsWith('blob:') || audioUrl.startsWith('data:')) {
        const r = await this._fetchAudioAsBase64(audioUrl);
        audioData = r.base64;
        audioFormat = r.format || audioFormat;
      }
      const headers = { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` };
      const body = {
        model: conf.model,
        messages: [{
          role: 'user',
          content: [
            { type: 'input_audio', input_audio: { data: audioData, format: audioFormat } },
            { type: 'text', text: prompt },
          ],
        }],
        modalities: ['text'],          // 只要文字输出
        stream: true,                  // 必须流式
        stream_options: { include_usage: false },
        max_tokens: maxTokens,
        temperature: 0.1,
      };
      return new Promise((resolve, reject) => {
        GM_xmlhttpRequest({
          method: 'POST', url: conf.url, headers, data: JSON.stringify(body), timeout: 120000,
          onload: res => {
            if (res.status !== 200) {
              if (res.status === 401) return reject('Qwen Key 无效');
              if (res.status === 429) return reject('Qwen 请求过于频繁');
              return reject(`Qwen HTTP ${res.status}: ${res.responseText?.slice(0, 200)}`);
            }
            try {
              // 解析 SSE 流：每行 data: {...}
              let content = '';
              const lines = (res.responseText || '').split('\n');
              for (const raw of lines) {
                const line = raw.trim();
                if (!line.startsWith('data:')) continue;
                const data = line.slice(5).trim();
                if (!data || data === '[DONE]') continue;
                try {
                  const json = JSON.parse(data);
                  const delta = json.choices?.[0]?.delta;
                  if (delta && typeof delta.content === 'string') content += delta.content;
                } catch (_) {}
              }
              if (!content) return reject('Qwen 响应为空');
              resolve({ answers: Solver._parseAIText(content, type), remaining: -1 });
            } catch (e) { reject('Qwen 响应解析失败: ' + (e.message || e)); }
          },
          onerror: () => reject('Qwen 网络错误'),
          ontimeout: () => reject('Qwen 请求超时'),
        });
      });
    },

    // 智谱 GLM-4-Voice（要求 base64 数据 + format 字段，不接受 URL）
    async _callZhipuAudio(conf, apiKey, prompt, type, audioUrl, maxTokens) {
      // 先下载音频转 base64
      const { base64, format } = await this._fetchAudioAsBase64(audioUrl);
      const headers = { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` };
      const body = {
        model: conf.model,
        messages: [{
          role: 'user',
          content: [
            { type: 'input_audio', input_audio: { data: base64, format } },
            { type: 'text', text: prompt },
          ],
        }],
        temperature: 0.1,
        max_tokens: maxTokens,
      };
      return new Promise((resolve, reject) => {
        GM_xmlhttpRequest({
          method: 'POST', url: conf.url, headers, data: JSON.stringify(body), timeout: 120000,
          onload: res => {
            if (res.status !== 200) {
              if (res.status === 401) return reject('智谱 Key 无效');
              if (res.status === 429) return reject('智谱 请求过于频繁');
              return reject(`智谱 HTTP ${res.status}: ${res.responseText?.slice(0, 200)}`);
            }
            try {
              const json = JSON.parse(res.responseText);
              const content = json.choices?.[0]?.message?.content || '';
              resolve({ answers: Solver._parseAIText(content, type), remaining: -1 });
            } catch (_) { reject('智谱 响应解析失败'); }
          },
          onerror: () => reject('智谱 网络错误'),
          ontimeout: () => reject('智谱 请求超时'),
        });
      });
    },

    // 下载音频文件转 base64（用于不支持 URL 的多模态 API）
    _fetchAudioAsBase64(url) {
      return new Promise((resolve, reject) => {
        // 从 URL 推断格式
        const m = (url || '').toLowerCase().match(/\.(mp3|wav|m4a|ogg|aac|flac)(?:\?|$)/);
        const format = m ? m[1] : 'mp3';
        GM_xmlhttpRequest({
          method: 'GET',
          url,
          responseType: 'arraybuffer',
          timeout: 60000,
          onload: res => {
            if (res.status !== 200 && res.status !== 206) {
              return reject(`下载音频失败 HTTP ${res.status}`);
            }
            try {
              const buf = res.response;
              if (!buf || !buf.byteLength) return reject('音频内容为空');
              // ArrayBuffer → base64
              const bytes = new Uint8Array(buf);
              let binary = '';
              const chunk = 0x8000;
              for (let i = 0; i < bytes.length; i += chunk) {
                binary += String.fromCharCode.apply(null, bytes.subarray(i, i + chunk));
              }
              const base64 = btoa(binary);
              resolve({ base64, format });
            } catch (e) { reject('音频转 base64 失败: ' + e.message); }
          },
          onerror: () => reject('下载音频网络错误'),
          ontimeout: () => reject('下载音频超时'),
        });
      });
    },

    // 不支持自动作答的题型（口语等）
    isUnsupportedType(type) {
      return type === this.TYPE_SPEAKING;
    },

    // 不需要选项的题型（填空、判断、翻译、写作、完形、听写）
    isFillLikeType(type) {
      return type === this.TYPE_FILL
        || type === this.TYPE_JUDGE
        || type === this.TYPE_TRANSLATION
        || type === this.TYPE_WRITING
        || type === this.TYPE_CLOZE
        || type === this.TYPE_DICTATION;
    },

    // 调用 AI 答题（文本题用 DeepSeek / 听力题自动切到音频 AI）
    async solveWithAI(result, logger = console.log, label = '本题') {
      const opts = (result?.options || []).filter(Boolean);
      const t = result.type !== undefined ? result.type : Solver.TYPE_OTHER;
      if (this.isUnsupportedType(t)) {
        logger(`⏭️ ${label} 检测到口语/跟读题，不支持自动作答，跳过`);
        return null;
      }
      if (!opts.length && !this.isFillLikeType(t)) {
        logger(`🤖 ${label} 选项为空，跳过`);
        return null;
      }
      // 检测音频：优先从题目容器找，找不到就在整页找
      const audioUrl = this.extractAudioUrl(result.container);
      const useAudio = !!audioUrl;
      // 检查对应的 API Key
      const needKey = useAudio ? Store.getAudioApiKey() : Store.getAIApiKey();
      if (!needKey) {
        const tip = useAudio
          ? `🤖 ${label} 检测到听力题但音频 AI 未配置 Key，跳过（请在面板配置 Qwen-Omni / 智谱 Voice 的 Key）`
          : `🤖 ${label} 未配置文本 AI Key，跳过（请在面板配置 DeepSeek Key）`;
        logger(tip);
        return null;
      }
      try {
        const provName = useAudio
          ? AI_PROVIDERS[Store.getAudioProvider()]?.name || '音频AI'
          : AI_PROVIDERS[Store.getAIProvider()]?.name || '文本AI';
        logger(`🤖 ${label} 调用 ${provName}（${this.typeName(t)}${useAudio ? ' · 含音频' : ''}，选项：${opts.length}）...`);
        const ai = await this.askAI(result.question, result.options || [], t, audioUrl, { logger, label });
        const answers = (ai?.answers || []).filter(Boolean);
        if (answers.length) {
          const preview = answers.map(a => a.length > 60 ? a.slice(0, 60) + '...' : a).join(' / ');
          logger(`🤖 AI 返回 ${answers.length} 个答案：${preview}`);
          return answers;
        }
        logger(`🤖 ${label} AI 未返回有效答案，跳过`);
        return null;
      } catch (err) {
        logger(`🤖 ${label} AI 调用失败：${err}`);
        return null;
      }
    },

    // 智能匹配答案到选项节点（返回需要勾选的节点列表）
    matchAnswersToOptions(answers, optionPairs, type) {
      if (!answers || !answers.length || !optionPairs.length) return [];
      // 剥掉 AI 答案常见的 "A. xxx" / "B、xxx" / "C) xxx" 前缀（防止 "D. 8." 不匹配 "8."）
      const stripLetterPrefix = (s) => String(s || '').replace(/^\s*[A-Ha-h]\s*[.、．:：)）]\s*/, '').trim();
      const normalize = (s) => stripLetterPrefix(s).toLowerCase().replace(/[\s.、，。,;；:：!！?？'"'""\(\)（）\-_]/g, '');
      const matched = [];
      const used = new Set();
      // 判断题特殊处理
      if (type === Solver.TYPE_JUDGE) {
        const ans = stripLetterPrefix(answers[0] || '');
        const isTrue = /^(正确|对|true|t|✓|right|yes|是)$/i.test(ans);
        const isFalse = /^(错误|错|false|f|✗|wrong|no|否)$/i.test(ans);
        for (const opt of optionPairs) {
          const optTxt = Utils.safeText(opt.text);
          if (isTrue && /^(正确|对|true|t|✓|right|yes|是|T)$/i.test(optTxt)) { matched.push(opt); break; }
          if (isFalse && /^(错误|错|false|f|✗|wrong|no|否|F)$/i.test(optTxt)) { matched.push(opt); break; }
        }
        if (matched.length) return matched;
      }
      for (const ans of answers) {
        const ansNorm = normalize(ans);
        if (!ansNorm) continue;
        let bestIdx = -1, bestScore = 0;
        for (let i = 0; i < optionPairs.length; i++) {
          if (used.has(i)) continue;
          const optNorm = normalize(optionPairs[i].text);
          if (!optNorm) continue;
          let score = 0;
          if (optNorm === ansNorm) score = 100;
          else if (optNorm.includes(ansNorm) || ansNorm.includes(optNorm)) {
            const minLen = Math.min(optNorm.length, ansNorm.length);
            const maxLen = Math.max(optNorm.length, ansNorm.length);
            score = (minLen / maxLen) * 80;
          } else {
            // 字母匹配（A/B/C/D） — 若答案以字母开头且对应索引匹配，给中等分
            const m = String(ans).match(/^\s*([A-Ha-h])\b/);
            if (m && i === (m[1].toUpperCase().charCodeAt(0) - 65)) score = 60;
          }
          if (score > bestScore) { bestScore = score; bestIdx = i; }
        }
        if (bestIdx >= 0 && bestScore >= 50) {
          matched.push(optionPairs[bestIdx]);
          used.add(bestIdx);
        }
      }
      // 兜底：单条答案没匹上但内部含 "A. xxx B. xxx C. xxx" 多段 → 拆段重试
      if (matched.length === 0 && answers.length === 1) {
        const raw = String(answers[0] || '');
        const segs = raw.match(/[A-Ha-h]\s*[.、．:：)）]\s*[^A-Ha-h]+?(?=\s+[A-Ha-h]\s*[.、．:：)）]|$)/g);
        if (segs && segs.length >= 2) {
          const isSingleChoice = type === Solver.TYPE_SINGLE || type === Solver.TYPE_JUDGE
            || type === Solver.TYPE_LISTENING || type === Solver.TYPE_READING;
          const newAnswers = isSingleChoice ? [segs[0].trim()] : segs.map(s => s.trim());
          // 防止递归（已经拆过一次）
          if (newAnswers[0] !== raw) {
            return this.matchAnswersToOptions(newAnswers, optionPairs, type);
          }
        }
      }
      return matched;
    },

    // 在选项节点上模拟点击（适配 ant-radio / ant-checkbox / 普通 label）
    clickOption(node) {
      if (!node) return false;
      // 优先找到内部的 input
      const input = node.querySelector?.('input[type="radio"], input[type="checkbox"]');
      if (input) {
        Utils.safeClick(input);
        Utils.safeClick(node);
        return true;
      }
      // 否则直接点 node
      Utils.safeClick(node);
      return true;
    },

    // 填空题：将答案填入第一个输入框
    fillBlanks(answers, container) {
      const inputs = container.querySelectorAll('input[type="text"], textarea, [contenteditable="true"]');
      if (!inputs.length) return false;
      for (let i = 0; i < Math.min(inputs.length, answers.length); i++) {
        const el = inputs[i];
        const val = answers[i];
        if (!val) continue;
        try {
          if (el.contentEditable === 'true') {
            el.textContent = val;
            el.dispatchEvent(new InputEvent('input', { bubbles: true }));
          } else {
            // 触发 React 受控组件的 onChange
            const setter = Object.getOwnPropertyDescriptor(el.constructor.prototype, 'value')?.set;
            if (setter) setter.call(el, val);
            else el.value = val;
            el.dispatchEvent(new Event('input', { bubbles: true }));
            el.dispatchEvent(new Event('change', { bubbles: true }));
          }
        } catch (_) {
          el.value = val;
        }
      }
      return true;
    },

    // 应用答案到题目（点击选项 / 填空 / 写作）
    async applyAnswers(answers, recognized) {
      if (!answers || !answers.length) return false;
      const { container, optionNodes, type } = recognized;

      // 口语/跟读：不支持
      if (this.isUnsupportedType(type)) return false;

      // 填空类（fill/translation/writing/cloze/dictation）：写入输入框
      if (this.isFillLikeType(type) && type !== Solver.TYPE_JUDGE) {
        return this.fillBlanks(answers, container);
      }

      // 判断题：可能是选项或文本输入
      if (type === Solver.TYPE_JUDGE) {
        if (optionNodes.length > 0) {
          const optionPairs = optionNodes.map((node, i) => ({
            text: recognized.options[i] || '', node,
          }));
          const matched = this.matchAnswersToOptions(answers, optionPairs, type);
          if (matched.length) {
            for (const m of matched) {
              this.clickOption(m.node);
              await Utils.sleep(300);
            }
            return true;
          }
        }
        // 没选项 → 尝试填空
        return this.fillBlanks(answers, container);
      }

      // 选择题（单选/多选/听力/阅读）：匹配并点击
      const optionPairs = optionNodes.map((node, i) => ({
        text: recognized.options[i] || '', node,
      }));
      const matched = this.matchAnswersToOptions(answers, optionPairs, type);
      if (!matched.length) return false;
      for (const m of matched) {
        this.clickOption(m.node);
        await Utils.sleep(300);
      }
      return true;
    },

    // ---- 广告模式 / 解锁码 ----

    // 题间延迟（毫秒）：解锁后 1.5s ± 抖动，未解锁 35s ± 抖动
    getQuestionDelay() {
      const jitter = Math.random() * Config.questionDelayJitter;
      if (Store.isUnlocked()) {
        return Config.questionDelayUnlocked + jitter;
      }
      return Config.questionDelayLocked + jitter;
    },

    // 验证解锁码（POST 到 qsy.iano.cn）
    verifyUnlockCode(code) {
      return new Promise((resolve, reject) => {
        if (!code || typeof code !== 'string') return reject('请输入解锁码');
        const c = code.trim();
        if (!c) return reject('请输入解锁码');
        GM_xmlhttpRequest({
          method: 'POST',
          url: Config.verifyUrl,
          headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
          data: `code=${encodeURIComponent(c)}`,
          timeout: 15000,
          onload: (resp) => {
            try {
              const data = JSON.parse(resp.responseText);
              if (data.code === 1 && data.data && data.data.valid) {
                const validUntil = parseInt(data.data.valid_until, 10);
                const validUntilStr = data.data.valid_until_str || new Date(validUntil * 1000).toLocaleString('zh-CN');
                resolve({ validUntil, validUntilStr });
              } else {
                reject(data.msg || '验证码无效或已过期');
              }
            } catch (_) {
              reject('验证响应解析失败');
            }
          },
          onerror: () => reject('网络错误'),
          ontimeout: () => reject('请求超时'),
        });
      });
    },
  };

  // ---- 弹窗自动关闭（U校园常见"我知道了"等） ----
  function clickIKnow(doc = document) {
    const selectors = [
      '.know-box .iKnow',
      '.ant-modal-confirm-btns .ant-btn-primary',
      '.ant-modal-confirm-btns .ant-btn.ant-btn-primary',
      '.ipublish-modal-footer-ok',
      'button.ant-btn.ant-btn-default.ipublish-modal-footer-ok',
      '.modal-footer .confirm',
      '.popup-confirm',
      '.el-dialog__footer .el-button--primary',
      '.el-message-box__btns .el-button--primary',
      '.layui-layer-btn0',
    ];
    for (const sel of selectors) {
      try {
        doc.querySelectorAll(sel).forEach(btn => {
          if (btn && typeof btn.click === 'function') {
            try { btn.click(); } catch (_) {}
          }
        });
      } catch (_) {}
    }
    // 通用：按文本查找含"确定/知道了/关闭/OK"的按钮（排除脚本自身面板内的按钮）
    try {
      const confirmTexts = /^(确定|确认|知道了|我知道了|关闭|好的|OK|Got it|Close)$/i;
      doc.querySelectorAll('button, a.btn, [role="button"], .btn').forEach(btn => {
        // 跳过脚本自身面板内的按钮
        if (btn.closest('#unipus-panel, #unipus-settings-overlay')) return;
        const txt = (btn.innerText || btn.textContent || '').trim();
        if (confirmTexts.test(txt) && btn.offsetParent !== null) {
          try { btn.click(); } catch (_) {}
        }
      });
    } catch (_) {}
  }

  // ---- 媒体（视频/音频）控制 ----
  const Player = {
    applyMediaDefault(media) {
      if (!media) return;
      try {
        media.volume = 0;
        media.muted = true;
        media.playbackRate = Store.getPlaybackRate();
        const p = media.play();
        if (p && p.catch) p.catch(() => setTimeout(() => media.play().catch(() => {}), 1500));
      } catch (_) {}
    },
    isEnded(media) {
      if (!media) return false;
      if (media.ended) return true;
      if (media.duration > 0 && media.currentTime >= media.duration - 0.5) return true;
      return false;
    },
    // 在文档中找所有有效的课程 video/audio（排除录音系统、隐藏、无源元素）
    findAllMedia(doc = document) {
      const medias = [];
      try {
        doc.querySelectorAll('video, audio').forEach(m => {
          // 排除：无 src 且无 <source> 子元素
          const hasSrc = m.src || m.currentSrc || m.querySelector('source[src]');
          if (!hasSrc) return;
          // 排除：隐藏元素（录音系统等）
          if (m.offsetParent === null && !m.closest('[class*="video"], [class*="player"], [class*="media"]')) return;
          // 排除：属于录音/评测系统的元素
          if (m.closest('[class*="record"], [class*="clio"], [class*="webrtc"], [class*="Record"]')) return;
          // 排除：blob URL（通常是录音流）
          if ((m.src || '').startsWith('blob:')) return;
          medias.push(m);
        });
      } catch (_) {}
      return medias;
    },
  };

  // ---- iframe 通信：父子页面菜单同步 ----
  // ucontent.unipus.cn 是 iframe，被 ipub/uai 嵌入
  // 菜单在 ucontent 中，控制面板在 ipub 中

  // 收集菜单节点（在 ucontent 内或普通版主页内调用）
  function getMenuList(doc = document) {
    const containerSelectors = [
      // 新版 ucontent
      '.pc-slider-menu-container.show .pc-slider-content-menu',
      '.pc-slider-menu-container .pc-slider-content-menu',
      '#part-menu-view .pc-slider-content-menu',
      '#part-menu-view .ant-tree',
      '#part-menu-view',
      '.pc-slider-content-menu',
      // 普通版 u.unipus.cn 常见结构
      '.chapter-list', '.chapters-list',
      '.book-menu', '.book-chapters',
      '.course-menu', '.course-catalog',
      '.menu-tree', '.menu-list',
      '.lesson-list', '.unit-list',
      '.sidebar-menu', '.left-menu',
      'aside .menu', 'aside ul',
      // 通用兜底
      '.ant-tree',
      '[role="tree"]',
      '.ant-menu',
      '[role="menu"]',
      'nav ul.menu',
    ];
    // 检查候选容器是否合法（排除播放器倍速菜单等）
    const isInvalidContainer = (el) => {
      if (!el) return true;
      // 在视频/播放器附近的菜单 → 多半是倍速菜单/字幕菜单
      const inPlayer = el.closest('video, audio, [class*="video"], [class*="player"], [class*="Player"], [class*="media-control"]');
      if (inPlayer) return true;
      // 自身就含 video/audio/play 控件
      if (el.querySelector('video, audio, [class*="play-btn"], [class*="speed"], [class*="rate"]')) {
        // 但要确认不是普通课程页（课程页里可能有视频但不在菜单容器里）
        const ownItems = el.querySelectorAll('li, [role="treeitem"], [role="menuitem"]');
        if (ownItems.length > 0 && ownItems.length <= 6) return true; // 小型菜单 + 含播放控件 → 高度可疑
      }
      return false;
    };
    let container = null;
    for (const sel of containerSelectors) {
      try {
        const c = doc.querySelector(sel);
        if (c && !isInvalidContainer(c)) { container = c; break; }
      } catch (_) {}
    }
    if (!container) {
      // ---- 兜底策略：扫描页面上所有 <a> 链接中匹配课程编号模式的 ----
      // u.unipus.cn 课程目录页的链接文本形如 "1-1 iPrepare", "1-2 iExplore 1: ..."
      const fallbackNodes = [];
      try {
        const courseItemRe = /^\s*(\d+)\s*[-–]\s*(\d+)\s+(.+)/;
        const unitRe = /^Unit\s+(\d+)/i;
        let curUnit = '';
        const seenKeys = new Set(); // 按编号去重
        // 扫描所有可能含课程项的元素（优先 <a> 链接）
        const allEls = doc.querySelectorAll('a, span[class*="item"], span[class*="node"], li > span, [data-key], [data-id]');
        allEls.forEach(el => {
          const txt = (el.innerText || el.textContent || '').trim();
          // 只匹配短文本（真正的菜单项，排除包含多行文本的父元素）
          if (!txt || txt.length > 80 || txt.includes('\n')) return;
          // 检测 Unit 标题
          const um = txt.match(unitRe);
          if (um) { curUnit = txt; return; }
          // 检测课程项
          const cm = txt.match(courseItemRe);
          if (cm) {
            const key = `${cm[1]}-${cm[2]}`; // e.g. "1-1", "1-2"
            if (seenKeys.has(key)) return; // 去重
            seenKeys.add(key);
            fallbackNodes.push({
              unit: curUnit,
              section: '',
              micro: txt,
              element: el,
            });
          }
        });
      } catch (_) {}
      if (fallbackNodes.length) {
        console.log(`[U校园助手] 兜底策略命中 ${fallbackNodes.length} 个课程项`);
        return fallbackNodes;
      }

      // 诊断：输出页面中前 60 个 class 帮助定位选择器
      try {
        const allCls = new Set();
        doc.querySelectorAll('[class]').forEach(el => {
          (el.className || '').split(/\s+/).forEach(c => { if (c && c.length > 2 && c.length < 60) allCls.add(c); });
        });
        const clsList = [...allCls].slice(0, 60).join(' | ');
        console.warn('[U校园助手] 菜单容器未命中，页面 class 列表(前60):', clsList);
        const pnl = window.__unipusPanel;
        if (pnl?.addLog) pnl.addLog(`⚠️ 菜单未识别\n调试: ${clsList.slice(0, 200)}`);
      } catch (_) {}
      return [];
    }

    const nodes = [];
    const pushNode = (unit, section, micro, element) => {
      const m = Utils.safeText(micro);
      if (!m || !element) return;
      nodes.push({ unit: Utils.safeText(unit), section: Utils.safeText(section), micro: m, element });
    };
    const pickClickable = (root) => {
      if (!root) return null;
      if (root.classList?.contains('pc-slider-menu-node')) {
        const s = root.querySelector('span');
        if (s) return s;
      }
      const checks = ['.pc-menu-node-name', '.ant-tree-node-content-wrapper', '.ant-menu-title-content'];
      for (const sel of checks) {
        const el = root.querySelector?.(sel);
        if (el) return el;
      }
      return root.querySelector?.('a, span') || root;
    };
    const pickName = (el) => {
      if (!el) return '';
      return Utils.safeText(el.title || el.getAttribute?.('title') || el.innerText || el.textContent);
    };

    // 策略 1: pc-slider-menu-unit > section > micro
    try {
      container.querySelectorAll('.pc-slider-menu-unit').forEach(unit => {
        const unitName = pickName(unit.querySelector('.unit-label-item'));
        const unitRoot = unit.parentElement || container;
        unitRoot.querySelectorAll('.pc-slider-menu-section').forEach(sec => {
          const secName = pickName(sec.querySelector('span'));
          const secRoot = sec.parentElement || unitRoot;
          secRoot.querySelectorAll('.pc-slider-menu-micro').forEach(micro => {
            const clickable = pickClickable(micro);
            const microName = pickName(micro.querySelector('.pc-menu-node-name')) || pickName(clickable);
            pushNode(unitName, secName, microName, clickable);
          });
        });
      });
    } catch (_) {}
    if (nodes.length) return validateMenuList(nodes);

    // 策略 2: 按顺序遍历同级 .pc-slider-menu-unit / section / micro / node
    try {
      let curUnit = '', curSec = '';
      const seen = new Set();
      container.querySelectorAll('.pc-slider-menu-unit, .pc-slider-menu-section, .pc-slider-menu-micro, .pc-slider-menu-node').forEach(el => {
        if (!el.classList) return;
        if (el.classList.contains('pc-slider-menu-unit')) {
          curUnit = pickName(el.querySelector('.unit-label-item'));
        } else if (el.classList.contains('pc-slider-menu-section')) {
          curSec = pickName(el.querySelector('span'));
        } else {
          const clickable = pickClickable(el);
          const microName = pickName(clickable) || pickName(el);
          const key = `${curUnit}|${curSec}|${microName}`;
          if (microName && !seen.has(key)) {
            seen.add(key);
            pushNode(curUnit, curSec, microName, clickable);
          }
        }
      });
    } catch (_) {}
    if (nodes.length) return validateMenuList(nodes);

    // 策略 3: ant-tree 通用结构
    try {
      const treeRoot = container.querySelector('.ant-tree') || container.querySelector('[role="tree"]') || container;
      let candidates = Array.from(treeRoot.querySelectorAll('[role="treeitem"]'));
      if (!candidates.length) candidates = Array.from(treeRoot.querySelectorAll('.ant-tree-treenode'));
      if (!candidates.length) candidates = Array.from(treeRoot.querySelectorAll('.ant-menu-item, .ant-menu-submenu-title'));

      const baseLeft = treeRoot.getBoundingClientRect?.().left || 0;
      const rows = [];
      candidates.forEach(node => {
        const clickable = pickClickable(node);
        if (!clickable?.getBoundingClientRect) return;
        const name = pickName(clickable);
        if (!name) return;
        const rect = clickable.getBoundingClientRect();
        if (!rect || rect.width === 0) return;
        const indent = Math.max(0, Math.round(rect.left - baseLeft));
        const ariaLevel = parseInt(node.getAttribute?.('aria-level') || '', 10);
        rows.push({ node, clickable, name, indent, ariaLevel });
      });
      if (rows.length) {
        const indents = [...new Set(rows.map(r => r.indent))].sort((a, b) => a - b);
        const levelByIndent = (ind) => {
          if (!indents.length) return 3;
          let bestIdx = 0, bestDiff = Math.abs(ind - indents[0]);
          for (let i = 1; i < indents.length; i++) {
            const d = Math.abs(ind - indents[i]);
            if (d < bestDiff) { bestDiff = d; bestIdx = i; }
          }
          return Math.min(6, bestIdx + 1);
        };
        const stack = [];
        const seen = new Set();
        const leafs = [], all = [];
        rows.forEach(r => {
          let lvl = Number.isFinite(r.ariaLevel) ? r.ariaLevel : levelByIndent(r.indent);
          if (lvl < 1) lvl = 1;
          stack[lvl - 1] = r.name;
          stack.length = lvl;
          const unitName = stack[0] || '';
          const secName = stack[1] || '';
          const microName = stack.slice(2).join(' / ') || r.name;
          const key = `${unitName}|${secName}|${microName}`;
          if (seen.has(key)) return;
          seen.add(key);
          const item = { unit: Utils.safeText(unitName), section: Utils.safeText(secName), micro: Utils.safeText(microName), element: r.clickable };
          all.push(item);
          const isLeaf = r.node.classList?.contains('ant-tree-treenode-leaf') || r.node.classList?.contains('ant-tree-treenode-leaf-last');
          const isParent = r.node.getAttribute?.('aria-expanded') === 'true' || r.node.getAttribute?.('aria-expanded') === 'false';
          if (!isParent || isLeaf) leafs.push(item);
        });
        return validateMenuList(leafs.length > 0 ? leafs : all);
      }
    } catch (_) {}

    // 策略 4: 普通版 ul/li 嵌套菜单（按 DOM 层级推断 unit/section/micro）
    try {
      const items = container.querySelectorAll('li');
      if (items.length) {
        const seen = new Set();
        const all = [], leafs = [];
        items.forEach(li => {
          const link = li.querySelector('a, span.clickable, [data-href], [data-url]') || li;
          const name = pickName(link);
          if (!name || name.length > 200) return;
          // 用嵌套 ul 的 li 距离推断层级
          let depth = 0;
          let p = li.parentElement;
          while (p && p !== container && depth < 6) {
            if (p.tagName === 'LI') depth++;
            p = p.parentElement;
          }
          const lvl = Math.min(3, depth + 1);
          const isLeaf = !li.querySelector('ul, ol');
          // 用包含关系组装 unit/section/micro
          let unit = '', sec = '', micro = name;
          const ancestors = [];
          let cur = li.parentElement?.closest('li');
          while (cur && ancestors.length < 4) {
            const n = pickName(cur.querySelector('a, span') || cur);
            if (n) ancestors.unshift(n);
            cur = cur.parentElement?.closest('li');
          }
          if (ancestors.length >= 1) unit = ancestors[0];
          if (ancestors.length >= 2) sec = ancestors[1];
          if (ancestors.length >= 3) micro = ancestors.slice(2).join(' / ') + ' / ' + name;
          const key = `${unit}|${sec}|${micro}`;
          if (seen.has(key)) return;
          seen.add(key);
          const item = { unit: Utils.safeText(unit), section: Utils.safeText(sec), micro: Utils.safeText(micro), element: link };
          all.push(item);
          if (isLeaf) leafs.push(item);
        });
        if (leafs.length || all.length) return validateMenuList(leafs.length ? leafs : all);
      }
    } catch (_) {}

    return validateMenuList(nodes);
  }

  // 验证菜单列表：过滤掉播放器倍速菜单、字幕菜单等垃圾项
  function validateMenuList(list) {
    if (!Array.isArray(list) || !list.length) return [];
    // 检测：所有 micro 名都是 "1.2x" / "1x" / "0.8x, selected" 这种倍速选项
    const isPlaybackRate = (s) => /^\s*\d+(?:\.\d+)?\s*x\s*(?:,\s*selected)?\s*$/i.test(s || '');
    const isJunkMicro = (s) => {
      if (!s || s.length > 200) return false;
      if (isPlaybackRate(s)) return true;
      // 纯数字 / 单字母
      if (/^\s*\d+\s*[.,]?\s*$/.test(s)) return true;
      if (/^[A-D]\s*[.,)]?\s*$/.test(s)) return true;
      return false;
    };
    const allJunk = list.every(item => isJunkMicro(item.micro));
    if (allJunk) {
      console.warn('[U校园助手] 菜单提取结果全是垃圾（疑似倍速/字幕菜单），已丢弃:', list);
      return [];
    }
    // 过滤单个垃圾项
    const filtered = list.filter(item => !isJunkMicro(item.micro));
    if (filtered.length === 0) return [];
    return filtered;
  }

  // ============== Worker：执行业务（iframe 子页面 & 普通版主页共用） ==============
  const Worker = {
    safeClickEl(el) {
      if (!el) return false;
      try {
        clickIKnow();
        if (el.scrollIntoView) {
          try { el.scrollIntoView({ block: 'center', inline: 'center' }); } catch (_) {}
        }
        const opts = { bubbles: true, cancelable: true, view: window };
        ['mouseover', 'mousedown', 'mouseup', 'click'].forEach(t => {
          try { el.dispatchEvent(new MouseEvent(t, opts)); } catch (_) {}
        });
        if (typeof el.click === 'function') el.click();
        const outer = el.closest?.('.pc-slider-menu-node, .ant-tree-treenode, li, .menu-item');
        if (outer && outer !== el && typeof outer.click === 'function') {
          try { outer.click(); } catch (_) {}
        }
        const span = el.querySelector?.('span, a');
        if (span && span !== el && typeof span.click === 'function') {
          try { span.click(); } catch (_) {}
        }
        setTimeout(clickIKnow, 500);
        return true;
      } catch (_) { return false; }
    },

    serializeMenu(nodes) {
      return nodes.map((n, i) => {
        let path = '';
        if (n.element) {
          if (n.element.id) path = n.element.id;
          else {
            const uid = 'unipus-node-' + Date.now() + '-' + i;
            try { n.element.id = uid; path = uid; } catch (_) {}
          }
        }
        return { unit: n.unit, section: n.section, micro: n.micro, path };
      });
    },

    scanMenu() {
      const list = getMenuList(document);
      return this.serializeMenu(list);
    },

    clickByPath(path) {
      if (!path) return false;
      try {
        const el = document.getElementById(path);
        if (el) return this.safeClickEl(el);
        const el2 = document.querySelector(path);
        if (el2) return this.safeClickEl(el2);
      } catch (_) {}
      return false;
    },

    probe() {
      const questions = Solver.findQuestions(document);
      const medias = Player.findAllMedia(document);
      const inOwnPanel = (el) => !!el.closest?.('[data-unipus-helper]');
      const txt = (document.body?.innerText || '').slice(0, 2000);
      // 检测口语/录音题：有麦克风/录音按钮但没识别到选择题
      const hasSpeaking = !questions.length && (
        !!document.querySelector(
          '[class*="record"], [class*="Record"], ' +
          '[class*="speak"], [class*="Speak"], ' +
          '[class*="microphone"], [class*="Microphone"], [class*="mic"][class*="-btn"], ' +
          '[class*="voice-btn"], [class*="VoiceBtn"], ' +
          'button[aria-label*="record" i], button[aria-label*="录音" i]'
        ) ||
        /录音|跟读|口语|speaking|recording|click.*record/i.test(txt)
      );
      // 下拉填空：≥2 个原生 select 或 .ant-select 选择器
      const dropdowns = Array.from(document.querySelectorAll(
        'select, .ant-select:not(.ant-select-disabled), [role="combobox"]'
      )).filter(s => !inOwnPanel(s) && s.offsetParent !== null);
      const hasDropdown = !questions.length && !hasSpeaking && dropdowns.length >= 1;
      // Self-reflection 清单：含 Checklist/Got it/Reflection 表头 + 多个 checkbox
      const checklistCbs = Array.from(document.querySelectorAll('input[type="checkbox"]'))
        .filter(c => !inOwnPanel(c) && c.offsetParent !== null);
      const hasChecklist = !questions.length && !hasDropdown
        && /Got\s*it|Checklist|Self[\s-]?reflection|reflection/i.test(txt)
        && checklistCbs.length >= 2;
      // 讨论 / 写作（开放性 textarea，需 AI 生成）
      const discussionTas = Array.from(document.querySelectorAll('textarea')).filter(t =>
        !inOwnPanel(t) && t.offsetParent !== null && !t.value);
      const hasDiscussion = !questions.length && !hasChecklist && discussionTas.length >= 1
        && /discussion|share\s*your|讨论|share.*answer|talk.*about|invite|present|reply|comment|think.*about.*following/i.test(txt);
      return {
        hasQuestion: questions.length > 0,
        questionCount: questions.length,
        hasMedia: medias.length > 0,
        mediaCount: medias.length,
        hasSpeaking,
        hasDropdown, dropdownCount: dropdowns.length,
        hasChecklist, checklistCount: checklistCbs.length,
        hasDiscussion, discussionCount: discussionTas.length,
      };
    },

    clickNext(opts = {}) {
      const skipSubmit = !!opts.skipSubmit;
      // 先找"提交"按钮（除非要跳过）
      if (!skipSubmit) {
        const submitTexts = /^(提交|提交答案|Submit|确认提交)$/i;
        document.querySelectorAll('button, a.btn, [role="button"], input[type="submit"]').forEach(btn => {
          if (btn.closest('#unipus-panel, #unipus-settings-overlay')) return;
          const txt = (btn.innerText || btn.textContent || '').trim();
          if (submitTexts.test(txt) && btn.offsetParent !== null) {
            Utils.safeClick(btn);
          }
        });
      }
      // 再找"下一步/下一题"
      const next = document.querySelector(
        '.next-btn, .btn-next, button.next, ' +
        '[class*="next-step"], [class*="NextStep"], ' +
        'button[class*="next"], a[class*="next"], ' +
        '.pagination-next, [aria-label*="next"]'
      );
      if (next) {
        Utils.safeClick(next);
        return true;
      }
      // 按文本找"下一步/下一页/下一题"
      const nextTexts = /^(下一步|下一题|下一页|Next|下一个)$/i;
      const allBtns = document.querySelectorAll('button, a, [role="button"]');
      for (const btn of allBtns) {
        if (btn.closest('#unipus-panel, #unipus-settings-overlay')) continue;
        const txt = (btn.innerText || btn.textContent || '').trim();
        if (nextTexts.test(txt) && btn.offsetParent !== null) {
          Utils.safeClick(btn);
          return true;
        }
      }
      return false;
    },

    closePopup() {
      clickIKnow(document);
      return true;
    },

    // 检测顶部标签页（如 Listening skills / Conversation / Passage / Viewing and understanding 等）
    getTabs() {
      // 过滤掉纯数字/题号/选项字母（如 "1." "2." "A."），避免误识别为标签
      const isJunkText = (t) => {
        if (!t || t.length < 2) return true;
        if (/^\s*\d+\s*[.、．:：)）]?\s*$/.test(t)) return true;  // 纯数字+标点
        if (/^[\d\s.、，。:：)）()]+$/.test(t)) return true;       // 全是数字/标点/空白
        if (/^[A-D]\s*[.、．:：)）]?\s*$/i.test(t)) return true;  // 选项字母 A./B.
        return false;
      };
      const _mkTabs = (nodes) => Array.from(nodes).map((t, idx) => ({
        text: (t.innerText || t.textContent || '').trim(),
        idx,
        active: t.classList.contains('active') || t.classList.contains('current') ||
                t.getAttribute('aria-selected') === 'true' ||
                !!t.querySelector('.active, .current'),
        _el: t,
      })).filter(t => t.text.length >= 3 && t.text.length <= 40 && !isJunkText(t.text));

      // 策略 1：常见 CSS 选择器
      const tabSelectors = [
        '.nav-tabs > li > a', '.nav-tabs > li',
        '.tab-nav > a', '.tab-nav > li > a',
        '[class*="tab-bar"] a', '[class*="tab-bar"] > div',
        '[class*="TabBar"] a', '[class*="TabBar"] > div',
        '[role="tablist"] > [role="tab"]',
        '.ant-tabs-tab', '.el-tabs__item',
        // ucontent 标签栏（各种变体）
        '.pc-header-tab a', '.header-tab a',
        '[class*="header-tab"] a', '[class*="content-tab"] a',
        '[class*="courseware-tab"] a', '[class*="courseware-header"] a',
        '[class*="ppt-tab"] a', '[class*="ppt-header"] a',
        '.steps-bar a', '.steps-bar > div',
      ];
      for (const sel of tabSelectors) {
        try {
          const tabs = document.querySelectorAll(sel);
          if (tabs.length >= 2) {
            const result = _mkTabs(tabs);
            if (result.length >= 2) return result;
          }
        } catch (_) {}
      }

      // 策略 2：找页面顶部区域（前 250px）的水平排列可点击元素组
      try {
        // 扫描所有可能是标签的元素（包括 Vue/React 渲染的 div/span）
        const allEls = document.querySelectorAll('a, button, div, span, li, [role="tab"]');
        const topElements = [];
        allEls.forEach(el => {
          if (el.closest('#unipus-panel, #unipus-settings-overlay, .ant-tree, [class*="menu"], [class*="sidebar"], [class*="bread"]')) return;
          // 排除包含子链接的容器（只要叶子级别）
          if (el.querySelector('a, button')) return;
          const rect = el.getBoundingClientRect();
          if (rect.top < 250 && rect.top > 0 && rect.height > 20 && rect.height < 60 && rect.width > 80) {
            const txt = (el.innerText || el.textContent || '').trim();
            if (txt.length >= 3 && txt.length <= 40 && !txt.includes('\n') && !isJunkText(txt)) {
              topElements.push({ el, rect, txt });
            }
          }
        });
        // 按 Y 坐标分组（同一行的元素）
        if (topElements.length >= 2) {
          const groups = {};
          topElements.forEach(item => {
            const yKey = Math.round(item.rect.top / 10) * 10; // 10px 容差分组
            if (!groups[yKey]) groups[yKey] = [];
            groups[yKey].push(item);
          });
          // 找满足条件的组：至少 2 个，且总宽度占页面宽度 > 50%
          const vw = window.innerWidth || document.documentElement.clientWidth;
          const candidates = Object.values(groups)
            .filter(g => g.length >= 2 && g.length <= 10)
            .sort((a, b) => b.length - a.length);
          for (const group of candidates) {
            group.sort((a, b) => a.rect.left - b.rect.left);
            const totalWidth = group.reduce((s, it) => s + it.rect.width, 0);
            // 标签栏通常占页面宽度的 40% 以上
            if (totalWidth > vw * 0.4) {
              return group.map((item, idx) => ({
                text: item.txt,
                idx,
                active: item.el.classList.contains('active') || item.el.classList.contains('current') ||
                        item.el.getAttribute('aria-selected') === 'true',
                _el: item.el,
              }));
            }
          }
        }
      } catch (_) {}

      // 策略 3：遍历所有容器，找含 2-10 个同级短文本子元素的（顶部 300px）
      try {
        const containers = document.querySelectorAll('div, ul, nav, header, section');
        for (const bar of containers) {
          if (bar.closest('#unipus-panel, #unipus-settings-overlay, [class*="sidebar"], [class*="menu"]')) continue;
          const rect = bar.getBoundingClientRect();
          if (rect.top > 300 || rect.top < 0 || rect.height > 80 || rect.height < 15) continue;
          // 容器宽度需占页面 40% 以上
          const vw2 = window.innerWidth || document.documentElement.clientWidth;
          if (rect.width < vw2 * 0.4) continue;
          const children = bar.querySelectorAll(':scope > a, :scope > li, :scope > div, :scope > button, :scope > span');
          if (children.length >= 2 && children.length <= 10) {
            const allValid = Array.from(children).every(c => {
              const t = (c.innerText || '').trim();
              return t.length >= 3 && t.length <= 40 && !t.includes('\n') && !isJunkText(t);
            });
            if (allValid) {
              const result = _mkTabs(children);
              if (result.length >= 2) return result;
            }
          }
        }
      } catch (_) {}
      return [];
    },

    clickTab(idx) {
      const tabs = this.getTabs();
      if (idx >= 0 && idx < tabs.length) {
        Utils.safeClick(tabs[idx]._el);
        return true;
      }
      return false;
    },

    // 在当前文档中运行答题
    async runAnswer(logger) {
      const questions = Solver.findQuestions(document);
      if (!questions.length) return { ok: false, msg: '未发现题目' };
      logger(`📝 发现 ${questions.length} 道题，开始作答`);
      let success = 0, failed = 0, skipped = 0;
      for (let i = 0; i < questions.length; i++) {
        if (stopRequested) break;
        const q = questions[i];
        const recognized = Solver.recognize(q);
        const label = `第 ${i+1} 题`;

        if (!recognized.question || recognized.question.length < 3) {
          logger(`${label} 识别失败，跳过`);
          failed++;
          continue;
        }

        // 显示题型 + 题干 + 选项预览（便于排查识别错乱）
        const qPreview = recognized.question.length > 60 ? recognized.question.slice(0, 60) + '...' : recognized.question;
        const optsPreview = recognized.options.slice(0, 4).map((o, i) => `${String.fromCharCode(65 + i)}.${o.length > 20 ? o.slice(0, 20) + '…' : o}`).join(' / ');
        logger(`${label} 题型：${Solver.typeName(recognized.type)}（选项 ${recognized.options.length} 个）`);
        logger(`   题干：${qPreview}`);
        if (recognized.options.length) logger(`   选项：${optsPreview}`);

        // 口语/跟读题：直接跳过
        if (Solver.isUnsupportedType(recognized.type)) {
          logger(`⏭️ ${label} 口语题不支持自动作答，跳过`);
          skipped++;
          continue;
        }

        // 听力/听写：先播完音频
        if (recognized.type === Solver.TYPE_LISTENING || recognized.type === Solver.TYPE_DICTATION) {
          const audio = Solver.findAudioInQuestion(recognized.container);
          if (audio) {
            logger(`🎵 ${label} 检测到音频，先播放完毕...`);
            try { await Solver.playAudioAndWait(audio); } catch (_) {}
            logger(`🎵 ${label} 音频播放完毕`);
          }
        }

        // 直接调用 AI 答题（已移除付费题库）
        let answers = null;
        const ai = await Solver.solveWithAI(recognized, logger, label);
        if (ai?.length) answers = ai;

        if (answers && answers.length) {
          const applied = await Solver.applyAnswers(answers, recognized);
          if (applied) {
            success++;
            logger(`✅ ${label} 已作答`);
          } else {
            logger(`⚠️ ${label} 答案应用失败（可能未找到输入框/选项）`);
            failed++;
          }
        } else {
          logger(`❌ ${label} 无答案，跳过`);
          failed++;
        }
        // 题间延迟：解锁后 1.5s ± 抖动，未解锁 35s ± 抖动（广告模式）
        if (i < questions.length - 1 && !stopRequested) {
          const delayMs = Solver.getQuestionDelay();
          const sec = Math.round(delayMs / 1000);
          if (!Store.isUnlocked() && delayMs >= 5000) {
            logger(`⏳ 广告模式冷却 ${sec}s（输入解锁码可加速至 ~1.5s）`);
          }
          await Utils.sleep(delayMs);
        }
      }
      return { ok: true, success, failed, skipped, total: questions.length };
    },

    // 播放所有媒体（视频/音频）并等待播放完成
    async playMedia(logger) {
      const medias = Player.findAllMedia(document);
      if (!medias.length) return { ok: false, msg: '无媒体' };
      logger(`🎬 发现 ${medias.length} 个媒体元素，开始播放`);
      const promises = medias.map(m => new Promise(resolve => {
        Player.applyMediaDefault(m);
        let lastTime = m.currentTime || 0;
        let stallCount = 0; // 无进度计数
        const checker = setInterval(() => {
          if (stopRequested || Player.isEnded(m)) {
            clearInterval(checker);
            resolve();
            return;
          }
          // 检测是否有进度
          const curTime = m.currentTime || 0;
          if (Math.abs(curTime - lastTime) < 0.1) {
            stallCount++;
            // 15 秒无进度 → 认为不是有效视频，跳过
            if (stallCount >= 10) {
              logger(`⏩ 媒体无进度，跳过`);
              clearInterval(checker);
              resolve();
              return;
            }
          } else {
            stallCount = 0;
            lastTime = curTime;
          }
          // 防暂停
          if (m.paused && !m.ended) {
            m.play().catch(() => {});
          }
        }, 1500);
        // 最大等待 30 分钟
        setTimeout(() => { clearInterval(checker); resolve(); }, 30 * 60 * 1000);
      }));
      await Promise.all(promises);
      logger(`✅ 媒体播放完毕`);
      return { ok: true };
    },

    // ---- Self-reflection Checklist：自动勾选所有 "Got it" 复选框 ----
    async runChecklist(logger) {
      const cbs = Array.from(document.querySelectorAll('input[type="checkbox"]')).filter(cb =>
        !cb.closest('[data-unipus-helper]') && !cb.checked && cb.offsetParent !== null);
      if (!cbs.length) {
        logger('☑️ 未发现需要勾选的复选框');
        return { ok: true, count: 0, total: 0 };
      }
      logger(`☑️ 发现 ${cbs.length} 个复选框，开始勾选`);
      let count = 0;
      for (const cb of cbs) {
        if (stopRequested) break;
        Utils.safeClick(cb);
        const wrapper = cb.closest('label, [class*="checkbox-wrapper"], [role="checkbox"]');
        if (wrapper && !cb.checked) Utils.safeClick(wrapper);
        if (cb.checked) count++;
        await Utils.sleep(180);
      }
      return { ok: true, count, total: cbs.length };
    },

    // 提取下拉框周围的句子（替换下拉为 ___ 让 AI 看到上下文）
    _getDropdownContext(node) {
      let parent = node.parentElement;
      let best = null;
      for (let depth = 0; depth < 8 && parent; depth++) {
        const t = (parent.textContent || '').trim();
        if (t.length >= 30 && t.length <= 1200) { best = parent; break; }
        parent = parent.parentElement;
      }
      if (!best) best = node.parentElement || document.body;
      // 简单清理：把 "请选择" / "点击选择" 占位符替换为 "___"
      let ctx = (best.textContent || '').replace(/请选择|点击选择|请\s*选\s*择|select\s+one/gi, '___').trim();
      // 折叠空白
      ctx = ctx.replace(/\s+/g, ' ').slice(0, 1000);
      return ctx;
    },

    // ---- 下拉填空：原生 select + Ant Design Select ----
    async runDropdowns(logger) {
      let success = 0, failed = 0, skipped = 0;

      // 原生 <select>
      const nativeSelects = Array.from(document.querySelectorAll('select')).filter(s =>
        !s.closest('[data-unipus-helper]') && s.offsetParent !== null);
      for (const sel of nativeSelects) {
        if (stopRequested) break;
        if (sel.selectedIndex > 0) { skipped++; continue; }
        const optsRaw = Array.from(sel.options)
          .map(o => ({ value: o.value, text: (o.textContent || '').trim() }))
          .filter(o => o.text && !/请选择|点击选择|select\s*one|^--/i.test(o.text));
        if (!optsRaw.length) { skipped++; continue; }
        const ctx = this._getDropdownContext(sel);
        try {
          const ai = await Solver.askAI(ctx, optsRaw.map(o => o.text), Solver.TYPE_FILL, null,
            { logger, label: `下拉[原生]` });
          if (ai?.length) {
            const t = ai[0].toLowerCase().trim();
            const match = optsRaw.find(o => o.text.toLowerCase().trim() === t)
              || optsRaw.find(o => o.text.toLowerCase().includes(t) || t.includes(o.text.toLowerCase()));
            if (match) {
              const setter = Object.getOwnPropertyDescriptor(sel.constructor.prototype, 'value')?.set;
              if (setter) setter.call(sel, match.value); else sel.value = match.value;
              sel.dispatchEvent(new Event('input', { bubbles: true }));
              sel.dispatchEvent(new Event('change', { bubbles: true }));
              success++;
              logger(`  ✅ 下拉填入：${match.text}`);
            } else { failed++; logger(`  ❌ AI 答案 "${ai[0]}" 未匹配选项`); }
          } else { failed++; }
        } catch (e) { failed++; logger(`  ❌ AI 调用失败：${e}`); }
        await Utils.sleep(300);
      }

      // Ant Design Select（自定义下拉）
      const antSelects = Array.from(document.querySelectorAll(
        '.ant-select:not(.ant-select-disabled)'
      )).filter(s => !s.closest('[data-unipus-helper]') && s.offsetParent !== null);
      for (const ant of antSelects) {
        if (stopRequested) break;
        // 已选 → 跳过
        const display = ant.querySelector('.ant-select-selection-item, [class*="selection-item"]');
        const placeholder = ant.querySelector('.ant-select-selection-placeholder, [class*="placeholder"]');
        if (display && (!placeholder || !placeholder.offsetParent)) {
          const dt = (display.textContent || '').trim();
          if (dt && !/请选择|点击选择|select\s*one/i.test(dt)) { skipped++; continue; }
        }
        // 点击触发器打开下拉
        const trigger = ant.querySelector('.ant-select-selector') || ant;
        Utils.safeClick(trigger);
        await Utils.sleep(450);
        // 找下拉浮层（Ant Design 通常 portal 到 body）
        let dropdown = document.querySelector('.ant-select-dropdown:not(.ant-select-dropdown-hidden)');
        if (!dropdown) {
          // 兜底：找 visible 状态的浮层
          dropdown = Array.from(document.querySelectorAll('[class*="select-dropdown"]'))
            .find(d => d.offsetParent !== null && !d.className.includes('hidden'));
        }
        if (!dropdown) { skipped++; Utils.safeClick(document.body); await Utils.sleep(150); continue; }
        const optEls = Array.from(dropdown.querySelectorAll('.ant-select-item-option, [role="option"]'))
          .filter(o => !o.classList.contains('ant-select-item-option-disabled'));
        const opts = optEls.map(el => ({ el, text: (el.textContent || '').trim() }))
          .filter(o => o.text && !/请选择|点击选择/i.test(o.text));
        if (!opts.length) {
          Utils.safeClick(document.body);
          await Utils.sleep(200);
          skipped++; continue;
        }
        const ctx = this._getDropdownContext(ant);
        try {
          const ai = await Solver.askAI(ctx, opts.map(o => o.text), Solver.TYPE_FILL, null,
            { logger, label: `下拉[Ant]` });
          if (ai?.length) {
            const t = ai[0].toLowerCase().trim();
            const match = opts.find(o => o.text.toLowerCase().trim() === t)
              || opts.find(o => o.text.toLowerCase().includes(t) || t.includes(o.text.toLowerCase()));
            if (match) {
              Utils.safeClick(match.el);
              success++;
              logger(`  ✅ 下拉填入：${match.text}`);
              await Utils.sleep(400);
            } else {
              failed++;
              logger(`  ❌ AI 答案 "${ai[0]}" 未匹配 ${opts.length} 个选项`);
              Utils.safeClick(document.body);
              await Utils.sleep(200);
            }
          } else { failed++; Utils.safeClick(document.body); await Utils.sleep(200); }
        } catch (e) {
          failed++;
          logger(`  ❌ AI 调用失败：${e}`);
          Utils.safeClick(document.body);
          await Utils.sleep(200);
        }
      }

      return { ok: true, success, failed, skipped, total: nativeSelects.length + antSelects.length };
    },

    // ---- 讨论 / 开放写作：用 AI 生成回答填入 textarea（不自动提交） ----
    async runDiscussion(logger) {
      const tas = Array.from(document.querySelectorAll('textarea')).filter(t =>
        !t.closest('[data-unipus-helper]') && t.offsetParent !== null && !t.value);
      if (!tas.length) return { ok: true, success: 0, total: 0 };
      let success = 0, failed = 0;
      for (const ta of tas) {
        if (stopRequested) break;
        // 提取 prompt：从 textarea 向上找包含问题文字的容器
        let prompt = '';
        let parent = ta.parentElement;
        for (let depth = 0; depth < 6 && parent; depth++) {
          const t = (parent.textContent || '').trim();
          if (t.length > 30 && t.length < 1500) { prompt = t; break; }
          parent = parent.parentElement;
        }
        // 清理 prompt 里的占位符 / textarea 自带文字
        prompt = prompt.replace(/请输入|请\s*输\s*入/g, '').replace(/\s+/g, ' ').trim().slice(0, 800);
        if (!prompt) prompt = '请就上述话题用英语写一段简短回复（80-120 词）';
        try {
          const ai = await Solver.askAI(
            `请就下列话题写一段 80-120 词的英语回复，自然、简洁、切题：\n${prompt}`,
            [], Solver.TYPE_WRITING, null,
            { logger, label: `讨论填答` });
          if (ai?.length) {
            const setter = Object.getOwnPropertyDescriptor(ta.constructor.prototype, 'value')?.set;
            if (setter) setter.call(ta, ai[0]); else ta.value = ai[0];
            ta.dispatchEvent(new Event('input', { bubbles: true }));
            ta.dispatchEvent(new Event('change', { bubbles: true }));
            success++;
            logger(`  ✏️ 已填入 ${ai[0].length} 字（不会自动提交，请人工检查）`);
          } else { failed++; }
        } catch (e) { failed++; logger(`  ❌ AI 调用失败：${e}`); }
        await Utils.sleep(500);
      }
      return { ok: true, success, failed, total: tas.length };
    },
  };

  // ============== iframe 子页面 setup（薄包装：把 postMessage 转发给 Worker） ==============
  function setupIframeChild() {
    function postToParent(payload) {
      try { window.parent.postMessage(payload, '*'); } catch (_) {}
    }

    function scanAndSendMenu() {
      const list = Worker.scanMenu();
      if (!list.length) return false;
      postToParent({ type: 'UNIPUS_MENU_LIST', payload: list });
      return true;
    }

    // 处理父页面消息
    window.addEventListener('message', async (e) => {
      if (!e.data || typeof e.data !== 'object') return;
      const { type, cmd, path, requestId } = e.data;
      if (type !== 'UNIPUS_CMD') return;
      const reply = (data) => postToParent({ type: 'UNIPUS_RESULT', requestId, ...data });
      const logger = (msg) => postToParent({ type: 'UNIPUS_LOG', msg });
      try {
        if (cmd === 'SCAN')         { scanAndSendMenu(); reply({ ok: true }); }
        else if (cmd === 'CLICK')   { reply({ ok: Worker.clickByPath(path) }); }
        else if (cmd === 'PROBE')   { reply({ ok: true, info: Worker.probe() }); }
        else if (cmd === 'ANSWER')  { const r = await Worker.runAnswer(logger);   reply({ ok: true, result: r }); }
        else if (cmd === 'PLAY_MEDIA') { const r = await Worker.playMedia(logger); reply({ ok: true, result: r }); }
        else if (cmd === 'CHECKLIST') { const r = await Worker.runChecklist(logger); reply({ ok: true, result: r }); }
        else if (cmd === 'DROPDOWNS') { const r = await Worker.runDropdowns(logger); reply({ ok: true, result: r }); }
        else if (cmd === 'DISCUSSION') { const r = await Worker.runDiscussion(logger); reply({ ok: true, result: r }); }
        else if (cmd === 'CLICK_NEXT') { reply({ ok: Worker.clickNext(e.data.opts || {}) }); }
        else if (cmd === 'GET_TABS') { const tabs = Worker.getTabs().map(t => ({ text: t.text, idx: t.idx, active: t.active })); reply({ ok: true, tabs }); }
        else if (cmd === 'CLICK_TAB') { reply({ ok: Worker.clickTab(e.data.tabIdx || 0) }); }
        else if (cmd === 'CLOSE_POPUP') { Worker.closePopup(); reply({ ok: true }); }
        else if (cmd === 'STOP')   { stopRequested = true;  reply({ ok: true }); }
        else if (cmd === 'RESET')  { stopRequested = false; reply({ ok: true }); }
      } catch (err) {
        reply({ ok: false, err: String(err) });
      }
    });

    // 定时自动关闭弹窗
    setInterval(clickIKnow, 1500);

    // 初次扫描（带重试）
    function initScan() {
      if (scanAndSendMenu()) return;
      let count = 0;
      const tm = setInterval(() => {
        count++;
        if (count > 30 || scanAndSendMenu()) clearInterval(tm);
      }, 1500);
    }
    if (document.readyState === 'loading') {
      document.addEventListener('DOMContentLoaded', () => setTimeout(initScan, 800));
    } else {
      setTimeout(initScan, 800);
    }
  }

  // ============== 主页面（ipub/uai）逻辑 ==============

  // ---- 菜单缓存 ----
  let _menuListCache = [];
  let _menuDetectionDone = false;

  // ---- IframeRPC：父页面与 iframe 通信 ----
  const IframeRPC = {
    _pendingRequests: new Map(),
    _reqId: 0,
    _logHandlers: [],

    getIframeWin() {
      try {
        // 先用精确选择器
        let iframe =
          document.getElementById('ipublish-pc-book-easy-iframe') ||
          document.querySelector('iframe.ipublish-pc-iframe-container') ||
          document.querySelector('iframe[src*="ucontent.unipus.cn"]') ||
          document.querySelector('iframe[src*="pc.html"]');
        // 宽松兜底：遍历所有 iframe，找到载入了 ucontent 的
        if (!iframe) {
          for (const f of document.querySelectorAll('iframe')) {
            try {
              const h = f.contentWindow?.location?.hostname;
              if (h && h.includes('ucontent.unipus.cn')) { iframe = f; break; }
            } catch (_) {}
            // src 属性兜底
            if ((f.src || '').includes('ucontent.unipus.cn')) { iframe = f; break; }
          }
        }
        // 最后兜底：任意 iframe（但排除极小的辅助 iframe）
        if (!iframe) {
          const all = document.querySelectorAll('iframe');
          for (const f of all) {
            const r = f.getBoundingClientRect();
            if (r.width > 100 && r.height > 100) { iframe = f; break; }
          }
        }
        return iframe ? iframe.contentWindow : null;
      } catch (_) { return null; }
    },

    init() {
      window.addEventListener('message', (e) => {
        if (!e.data || typeof e.data !== 'object') return;
        const { type, requestId } = e.data;
        if (type === 'UNIPUS_MENU_LIST') {
          const payload = e.data.payload;
          if (Array.isArray(payload) && payload.length) {
            _menuListCache = payload;
            _menuDetectionDone = true;
            window.dispatchEvent(new CustomEvent('UNIPUS_MENU_READY', { detail: payload }));
          }
        } else if (type === 'UNIPUS_RESULT') {
          const pending = this._pendingRequests.get(requestId);
          if (pending) {
            this._pendingRequests.delete(requestId);
            pending.resolve(e.data);
          }
        } else if (type === 'UNIPUS_LOG') {
          this._logHandlers.forEach(h => { try { h(e.data.msg); } catch (_) {} });
        }
      });
    },

    onLog(handler) {
      this._logHandlers.push(handler);
    },

    async sendCmd(cmd, params = {}, { timeout = 60000 } = {}) {
      const iw = this.getIframeWin();
      // 无 iframe：本地直接执行（适用于普通版 u.unipus.cn）
      if (!iw) return this._runLocal(cmd, params);
      const requestId = ++this._reqId;
      const result = await new Promise((resolve) => {
        const timer = setTimeout(() => {
          this._pendingRequests.delete(requestId);
          resolve({ ok: false, err: '超时' });
        }, timeout);
        this._pendingRequests.set(requestId, {
          resolve: (data) => {
            clearTimeout(timer);
            resolve(data);
          }
        });
        try {
          iw.postMessage({ type: 'UNIPUS_CMD', cmd, requestId, ...params }, '*');
        } catch (e) {
          clearTimeout(timer);
          this._pendingRequests.delete(requestId);
          resolve({ ok: false, err: e.message || 'postMessage 失败' });
        }
      });
      // 如果 iframe 通信超时/失败且是 SCAN 命令，自动回退到本地扫描
      if (!result.ok && cmd === 'SCAN') {
        console.log('[U校园助手] iframe 通信失败，回退本地扫描');
        return this._runLocal(cmd, params);
      }
      return result;
    },

    // 本地执行（普通版无 iframe 时直接调用 Worker）
    async _runLocal(cmd, params = {}) {
      const logger = (msg) => this._logHandlers.forEach(h => { try { h(msg); } catch (_) {} });
      try {
        switch (cmd) {
          case 'SCAN': {
            const list = Worker.scanMenu();
            if (list.length) {
              _menuListCache = list;
              window.dispatchEvent(new CustomEvent('UNIPUS_MENU_READY', { detail: list }));
            }
            return { ok: true };
          }
          case 'CLICK':       return { ok: Worker.clickByPath(params.path) };
          case 'PROBE':       return { ok: true, info: Worker.probe() };
          case 'ANSWER':      { const r = await Worker.runAnswer(logger);   return { ok: true, result: r }; }
          case 'PLAY_MEDIA':  { const r = await Worker.playMedia(logger);   return { ok: true, result: r }; }
          case 'CHECKLIST':   { const r = await Worker.runChecklist(logger); return { ok: true, result: r }; }
          case 'DROPDOWNS':   { const r = await Worker.runDropdowns(logger); return { ok: true, result: r }; }
          case 'DISCUSSION':  { const r = await Worker.runDiscussion(logger); return { ok: true, result: r }; }
          case 'CLICK_NEXT':  return { ok: Worker.clickNext(params.opts || {}) };
          case 'GET_TABS':    { const tabs = Worker.getTabs().map(t => ({ text: t.text, idx: t.idx, active: t.active })); return { ok: true, tabs }; }
          case 'CLICK_TAB':   return { ok: Worker.clickTab(params.tabIdx || 0) };
          case 'CLOSE_POPUP': Worker.closePopup(); return { ok: true };
          case 'STOP':        stopRequested = true;  return { ok: true };
          case 'RESET':       stopRequested = false; return { ok: true };
          default:            return { ok: false, err: 'unknown cmd' };
        }
      } catch (e) {
        return { ok: false, err: String(e) };
      }
    },

    requestScan() { return this.sendCmd('SCAN', {}, { timeout: 4000 }); },
    clickItem(path) { return this.sendCmd('CLICK', { path }, { timeout: 5000 }); },
    probe() { return this.sendCmd('PROBE', {}, { timeout: 5000 }); },
    answer() { return this.sendCmd('ANSWER', {}, { timeout: 5 * 60 * 1000 }); },
    playMedia() { return this.sendCmd('PLAY_MEDIA', {}, { timeout: 30 * 60 * 1000 }); },
    runChecklist() { return this.sendCmd('CHECKLIST', {}, { timeout: 60 * 1000 }); },
    runDropdowns() { return this.sendCmd('DROPDOWNS', {}, { timeout: 5 * 60 * 1000 }); },
    runDiscussion() { return this.sendCmd('DISCUSSION', {}, { timeout: 5 * 60 * 1000 }); },
    clickNext(opts = {}) { return this.sendCmd('CLICK_NEXT', { opts }, { timeout: 3000 }); },
    getTabs() { return this.sendCmd('GET_TABS', {}, { timeout: 3000 }); },
    clickTab(tabIdx) { return this.sendCmd('CLICK_TAB', { tabIdx }, { timeout: 3000 }); },
    closePopup() { return this.sendCmd('CLOSE_POPUP', {}, { timeout: 3000 }); },
    stop() { return this.sendCmd('STOP', {}, { timeout: 1000 }); },
    reset() { return this.sendCmd('RESET', {}, { timeout: 1000 }); },
  };

  // ---- MenuRunner: 自动遍历目录 + 时长分配 + 视频/答题 ----
  const MenuRunner = {
    perStepSec: 60,
    startIdx: 0,
    totalSeconds: 0,
    currentIdx: 0,

    async run(menuList, totalMin, startIdx, logger) {
      if (!Array.isArray(menuList) || !menuList.length) {
        logger('⚠️ 目录列表为空，请先在 iframe 内展开目录');
        return;
      }
      if (startIdx < 0 || startIdx >= menuList.length) startIdx = 0;
      this.startIdx = startIdx;
      const jobs = menuList.slice(startIdx);
      this.totalSeconds = Math.max(60, totalMin * 60);
      this.perStepSec = Math.max(Config.minStepSec, Math.floor(this.totalSeconds / jobs.length));

      logger(`🚀 开始刷课：共 ${jobs.length} 项，总时长 ${totalMin} 分钟，平均每项 ${Math.round(this.perStepSec)} 秒`);
      isRunning = true;
      stopRequested = false;
      isPaused = false;
      await IframeRPC.reset();

      try {
        for (let i = 0; i < jobs.length; i++) {
          if (stopRequested) {
            logger('⏹ 已停止');
            break;
          }
          await Utils.waitIfPaused();
          this.currentIdx = startIdx + i;

          const job = jobs[i];
          logger(`\n📖 [${i + 1}/${jobs.length}] ${job.unit} / ${job.section} / ${job.micro}`);

          // 点击菜单项
          const clickResult = await IframeRPC.clickItem(job.path);
          if (!clickResult?.ok) {
            logger(`⚠️ 点击失败，跳过该项`);
            continue;
          }
          // 等页面加载
          await Utils.sleep(Config.stepWaitMs);
          await IframeRPC.closePopup();

          // 检测标签页（如 Listening skills / Conversation / Passage 等）
          const tabResult = await IframeRPC.getTabs();
          const tabs = tabResult?.tabs || [];
          if (tabs.length >= 2) {
            logger(`📑 检测到 ${tabs.length} 个标签页：${tabs.map(t => t.text).join(', ')}`);
            for (let t = 0; t < tabs.length; t++) {
              if (stopRequested) break;
              await Utils.waitIfPaused();
              // 点击标签
              await IframeRPC.clickTab(t);
              await Utils.sleep(Config.tabSwitchWaitMs);
              await IframeRPC.closePopup();
              logger(`  📌 标签 [${t + 1}/${tabs.length}] ${tabs[t].text}`);
              // 处理当前标签内容
              await this._processTabContent(logger, job.micro);
            }
          } else {
            logger(`🔍 未检测到标签页，处理当前内容`);
            // 无标签页，直接处理内容
            await this._processTabContent(logger, job.micro);
          }

          // 章节末尾：只点"下一步"，不再触发"提交"（每个 tab 内已经提交过；防止讨论题被误提交）
          await IframeRPC.clickNext({ skipSubmit: true });
          await Utils.sleep(Config.afterSubmitWaitMs);
          await IframeRPC.closePopup();
          if (i < jobs.length - 1 && !stopRequested) {
            logger(`⏭️ 进入下一章节...`);
            await Utils.sleep(Config.chapterEndWaitMs);
          }
        }
      } finally {
        isRunning = false;
        stopRequested = false;
        logger('🎉 全部完成！');
      }
    },

    async _processTabContent(logger, label) {
      const probe = await IframeRPC.probe();
      const info = probe?.info || {};
      const auto = Store.getFeatureConf().autoAnswer;
      let didSomething = false;

      if (info.hasQuestion && auto) {
        logger(`📝 发现 ${info.questionCount} 道题，启动自动作答`);
        const r = await IframeRPC.answer();
        if (r?.result) {
          const { success = 0, failed = 0, skipped = 0, total = 0 } = r.result;
          logger(`✅ 作答完成：成功 ${success}/${total}，失败 ${failed}${skipped ? `，跳过 ${skipped}` : ''}`);
        }
        await Utils.sleep(800);
        await IframeRPC.clickNext();
        await Utils.sleep(Config.afterSubmitWaitMs);
        await IframeRPC.closePopup();
        didSomething = true;
      }

      if (info.hasMedia) {
        logger(`🎬 发现 ${info.mediaCount} 个媒体，启动播放`);
        await IframeRPC.playMedia();
        didSomething = true;
      }

      // 下拉填空（如 1-11 词汇填空、Word replacement）
      if (info.hasDropdown && auto) {
        logger(`🔽 检测到 ${info.dropdownCount} 个下拉框，启动 AI 填空`);
        const r = await IframeRPC.runDropdowns();
        if (r?.result) {
          const { success = 0, failed = 0, skipped = 0, total = 0 } = r.result;
          logger(`🔽 下拉完成：成功 ${success}/${total}，失败 ${failed}${skipped ? `，跳过 ${skipped}` : ''}`);
        }
        await Utils.sleep(800);
        await IframeRPC.clickNext();
        await Utils.sleep(Config.afterSubmitWaitMs);
        await IframeRPC.closePopup();
        didSomething = true;
      }

      // Self-reflection 复选框清单
      if (info.hasChecklist) {
        logger(`☑️ 检测到 Checklist (${info.checklistCount} 项)，自动勾选`);
        const r = await IframeRPC.runChecklist();
        if (r?.result) {
          const { count = 0, total = 0 } = r.result;
          logger(`☑️ 勾选完成：${count}/${total}`);
        }
        await Utils.sleep(600);
        await IframeRPC.clickNext();
        await Utils.sleep(Config.afterSubmitWaitMs);
        didSomething = true;
      }

      // 讨论 / 写作（AI 生成填入，不自动提交）
      if (info.hasDiscussion && auto) {
        logger(`💬 检测到讨论/写作题（${info.discussionCount} 个文本框），启动 AI 生成`);
        const r = await IframeRPC.runDiscussion();
        if (r?.result) {
          const { success = 0, failed = 0, total = 0 } = r.result;
          logger(`💬 已填入 ${success}/${total}（不会自动提交，请人工检查后提交）`);
        }
        await Utils.sleep(1200);
        didSomething = true;
      }

      // 口语/录音题：无法自动作答，简短等待后跳过
      if (!didSomething && info.hasSpeaking) {
        logger(`🎤 检测到录音/口语题，无法自动作答，跳过（需要手动录制）`);
        await Utils.sleep(2000);
        return;
      }
      if (!didSomething) {
        // 普通页面：按时长分配等待
        await this._countdownWait(this.perStepSec, logger, label);
      }
    },

    async _countdownWait(seconds, logger, label) {
      const end = Date.now() + seconds * 1000;
      let lastSec = -1;
      while (Date.now() < end) {
        if (stopRequested) break;
        await Utils.waitIfPaused();
        const remaining = Math.ceil((end - Date.now()) / 1000);
        if (remaining !== lastSec) {
          lastSec = remaining;
          logger(`⏳ ${label} 等待中 ${Utils.formatTime(remaining)}`, true);
        }
        await Utils.sleep(1000);
      }
    },
  };

  // ---- UI Panel: 悬浮球 + 控制面板 ----
  const Panel = {
    panelEl: null,
    ballEl: null,
    logEl: null,
    menuSelectEl: null,
    timeInputEl: null,
    startBtn: null,
    pauseBtn: null,
    stopBtn: null,
    settingsPanel: null,

    addLog(msg, isCountdown = false) {
      if (!this.logEl) return;
      if (isCountdown) {
        const last = this.logEl.lastElementChild;
        if (last && last.classList.contains('countdown-line')) {
          last.textContent = msg;
        } else {
          const div = document.createElement('div');
          div.className = 'countdown-line';
          div.textContent = msg;
          this.logEl.appendChild(div);
        }
      } else {
        const div = document.createElement('div');
        // 按 emoji 添加颜色 hint
        if (/^[\s]*✅|^[\s]*🎉|^[\s]*🚀/.test(msg)) div.className = 'log-success';
        else if (/^[\s]*⚠️|^[\s]*⏸|^[\s]*⏭/.test(msg)) div.className = 'log-warn';
        else if (/^[\s]*❌|^[\s]*⛔/.test(msg)) div.className = 'log-error';
        div.textContent = msg;
        this.logEl.appendChild(div);
      }
      this.logEl.scrollTop = this.logEl.scrollHeight;
      while (this.logEl.children.length > 200) this.logEl.removeChild(this.logEl.firstChild);
    },

    populateMenu(list) {
      if (!this.menuSelectEl) return;
      this.menuSelectEl.innerHTML = '';
      if (!list || !list.length) {
        const opt = document.createElement('option');
        opt.value = '0';
        opt.textContent = '请先在 iframe 中展开目录';
        this.menuSelectEl.appendChild(opt);
        return;
      }
      list.forEach((n, i) => {
        const opt = document.createElement('option');
        opt.value = String(i);
        opt.textContent = `${i + 1}. [${n.unit || '-'}] ${n.section || ''} > ${n.micro}`;
        this.menuSelectEl.appendChild(opt);
      });
      this.addLog(`✅ 已加载 ${list.length} 个目录项`);
    },

    // 注入全局样式（只注入一次）
    injectStyles() {
      if (document.getElementById('unipus-styles')) return;
      const style = document.createElement('style');
      style.id = 'unipus-styles';
      style.textContent = `
        #unipus-ball,#unipus-panel,#unipus-settings-overlay{
          font-family:-apple-system,BlinkMacSystemFont,'Segoe UI','Microsoft YaHei',sans-serif;
        }
        #unipus-ball{
          position:fixed;bottom:24px;right:24px;width:54px;height:54px;
          border-radius:50%;background:linear-gradient(135deg,#06b6d4 0%,#3b82f6 50%,#8b5cf6 100%);
          z-index:99999;box-shadow:0 8px 24px rgba(59,130,246,.35),0 2px 6px rgba(0,0,0,.12);
          display:flex;align-items:center;justify-content:center;cursor:pointer;color:#fff;font-size:24px;
          user-select:none;transition:transform .25s cubic-bezier(.34,1.56,.64,1),box-shadow .25s ease;
        }
        #unipus-ball:hover{transform:scale(1.12) rotate(-6deg);box-shadow:0 12px 32px rgba(59,130,246,.55),0 4px 8px rgba(0,0,0,.15);}
        #unipus-ball.running::after{
          content:'';position:absolute;top:-2px;right:-2px;width:14px;height:14px;border-radius:50%;
          background:#10b981;border:2px solid #fff;animation:up-pulse 1.5s ease-in-out infinite;
        }
        @keyframes up-pulse{0%,100%{transform:scale(1);opacity:1}50%{transform:scale(1.2);opacity:.7}}
        @keyframes up-slidein{from{transform:translateY(20px) scale(.95);opacity:0}to{transform:translateY(0) scale(1);opacity:1}}
        @keyframes up-spin{to{transform:rotate(360deg)}}

        #unipus-panel{
          position:fixed;right:24px;bottom:90px;width:380px;max-height:80vh;display:flex;flex-direction:column;
          background:#0f172a;color:#e2e8f0;border-radius:16px;z-index:99999;
          box-shadow:0 24px 60px rgba(0,0,0,.4),0 0 0 1px rgba(255,255,255,.06);
          animation:up-slidein .25s cubic-bezier(.34,1.56,.64,1);overflow:hidden;
        }
        .up-header{
          padding:14px 16px;display:flex;align-items:center;justify-content:space-between;
          background:linear-gradient(135deg,rgba(6,182,212,.15),rgba(139,92,246,.15));
          border-bottom:1px solid rgba(255,255,255,.06);cursor:move;user-select:none;
        }
        .up-title{font-size:14px;font-weight:600;display:flex;align-items:center;gap:8px;color:#f1f5f9;}
        .up-dot{width:8px;height:8px;border-radius:50%;background:#64748b;}
        .up-dot.ok{background:#10b981;box-shadow:0 0 8px #10b981;}
        .up-dot.running{background:#06b6d4;animation:up-pulse 1.2s ease-in-out infinite;}
        .up-dot.paused{background:#f59e0b;}
        .up-dot.error{background:#ef4444;}
        .up-iconbtn{
          background:rgba(255,255,255,.08);color:#e2e8f0;border:none;width:28px;height:28px;
          border-radius:7px;cursor:pointer;font-size:13px;display:inline-flex;align-items:center;
          justify-content:center;transition:background .15s,transform .15s;
        }
        .up-iconbtn:hover{background:rgba(255,255,255,.16);transform:translateY(-1px);}
        .up-body{padding:14px;overflow-y:auto;flex:1;display:flex;flex-direction:column;gap:12px;}
        .up-body::-webkit-scrollbar{width:6px}
        .up-body::-webkit-scrollbar-thumb{background:rgba(255,255,255,.15);border-radius:3px}

        .up-section{
          background:rgba(255,255,255,.04);border:1px solid rgba(255,255,255,.06);
          border-radius:10px;padding:12px;
        }
        .up-section-title{font-size:11px;color:#94a3b8;font-weight:600;text-transform:uppercase;letter-spacing:.5px;margin-bottom:8px;display:flex;align-items:center;gap:6px;}
        .up-row{display:flex;align-items:center;gap:8px;margin-bottom:8px;}
        .up-row:last-child{margin-bottom:0;}
        .up-label{font-size:12px;color:#cbd5e1;flex:1;font-weight:500;}
        .up-input,.up-select{
          width:100%;padding:7px 10px;background:#1e293b;color:#f1f5f9;border:1px solid rgba(255,255,255,.1);
          border-radius:7px;font-size:12px;box-sizing:border-box;transition:border-color .15s,box-shadow .15s;
          font-family:inherit;
        }
        .up-input:focus,.up-select:focus{outline:none;border-color:#06b6d4;box-shadow:0 0 0 3px rgba(6,182,212,.2);}
        .up-select{cursor:pointer;}
        .up-btn{
          padding:9px 14px;background:linear-gradient(135deg,#06b6d4,#3b82f6);color:#fff;border:none;
          border-radius:7px;font-size:13px;font-weight:600;cursor:pointer;transition:transform .12s,box-shadow .15s;
          font-family:inherit;display:inline-flex;align-items:center;justify-content:center;gap:6px;
        }
        .up-btn:hover{transform:translateY(-1px);box-shadow:0 6px 16px rgba(6,182,212,.35);}
        .up-btn:active{transform:translateY(0);}
        .up-btn-ghost{background:rgba(255,255,255,.08);color:#cbd5e1;}
        .up-btn-ghost:hover{background:rgba(255,255,255,.16);box-shadow:none;}
        .up-btn-warn{background:linear-gradient(135deg,#f59e0b,#f97316);}
        .up-btn-danger{background:linear-gradient(135deg,#ef4444,#dc2626);}
        .up-btn-success{background:linear-gradient(135deg,#10b981,#059669);}
        .up-btn-sm{padding:5px 9px;font-size:11px;}
        .up-btn:disabled{opacity:.5;cursor:not-allowed;transform:none;box-shadow:none;}

        .up-switch{position:relative;display:inline-block;width:36px;height:20px;flex-shrink:0;}
        .up-switch input{opacity:0;width:0;height:0;}
        .up-switch-slider{
          position:absolute;cursor:pointer;inset:0;background:#334155;border-radius:20px;transition:.2s;
        }
        .up-switch-slider:before{
          content:'';position:absolute;height:14px;width:14px;left:3px;bottom:3px;background:#fff;
          border-radius:50%;transition:.2s;
        }
        .up-switch input:checked + .up-switch-slider{background:linear-gradient(135deg,#06b6d4,#3b82f6);}
        .up-switch input:checked + .up-switch-slider:before{transform:translateX(16px);}

        .up-radiogroup{display:flex;gap:6px;}
        .up-radiogroup label{
          flex:1;padding:6px 10px;background:#1e293b;border:1px solid rgba(255,255,255,.08);
          border-radius:7px;cursor:pointer;text-align:center;font-size:12px;color:#cbd5e1;
          transition:all .15s;
        }
        .up-radiogroup input{display:none;}
        .up-radiogroup input:checked + span{color:#06b6d4;}
        .up-radiogroup label:has(input:checked){
          background:rgba(6,182,212,.15);border-color:#06b6d4;color:#06b6d4;
        }

        #unipus-log{
          height:160px;overflow-y:auto;background:#020617;border:1px solid rgba(255,255,255,.06);
          border-radius:8px;padding:8px 10px;font-family:'JetBrains Mono','Cascadia Code',Consolas,monospace;
          font-size:11px;color:#94a3b8;line-height:1.5;
        }
        #unipus-log::-webkit-scrollbar{width:5px}
        #unipus-log::-webkit-scrollbar-thumb{background:rgba(255,255,255,.15);border-radius:3px}
        #unipus-log > div{padding:1px 0;word-break:break-all;}
        #unipus-log .countdown-line{color:#06b6d4;}
        #unipus-log .log-success{color:#10b981;}
        #unipus-log .log-warn{color:#f59e0b;}
        #unipus-log .log-error{color:#ef4444;}

        .up-key-row{position:relative;}
        .up-key-toggle{
          position:absolute;right:8px;top:50%;transform:translateY(-50%);
          background:none;border:none;color:#94a3b8;cursor:pointer;font-size:14px;padding:0 4px;
        }
        .up-key-toggle:hover{color:#06b6d4;}

        /* 广告模式 / 解锁 */
        .up-qr-box{
          width:96px;height:96px;background:#fff;border-radius:8px;padding:6px;flex-shrink:0;
          display:flex;align-items:center;justify-content:center;position:relative;
          border:2px dashed rgba(6,182,212,.3);
        }
        .up-qr-box img{width:100%;height:100%;object-fit:contain;border-radius:4px;}
        .up-qr-fallback{
          display:none;flex-direction:column;align-items:center;justify-content:center;
          gap:4px;position:absolute;inset:6px;
        }
        .up-unlock-status{
          font-size:10px;font-weight:600;padding:2px 6px;border-radius:10px;letter-spacing:.3px;
        }
        .up-unlock-status.locked{background:rgba(245,158,11,.15);color:#f59e0b;}
        .up-unlock-status.unlocked{background:rgba(16,185,129,.15);color:#10b981;}

        #unipus-settings-overlay{
          position:fixed;inset:0;background:rgba(0,0,0,.6);backdrop-filter:blur(4px);
          z-index:100000;display:flex;align-items:center;justify-content:center;
          animation:up-fadein .2s ease;
        }
        @keyframes up-fadein{from{opacity:0}to{opacity:1}}
        .up-dialog{
          background:#0f172a;color:#e2e8f0;border-radius:14px;width:440px;max-width:90vw;max-height:80vh;
          overflow-y:auto;padding:18px;box-shadow:0 24px 60px rgba(0,0,0,.5);
          animation:up-slidein .25s cubic-bezier(.34,1.56,.64,1);
        }
        .up-dialog h3{margin:0 0 12px 0;font-size:16px;font-weight:600;color:#f1f5f9;}
        .up-footer{
          padding:8px 14px;font-size:10px;color:#64748b;display:flex;align-items:center;justify-content:space-between;
          background:rgba(0,0,0,.2);border-top:1px solid rgba(255,255,255,.04);
        }
        .up-footer a{color:#06b6d4;text-decoration:none;}

        /* 微信反馈条 */
        .up-wechat-tip{
          padding:7px 14px;font-size:11px;line-height:1.5;color:#fbbf24;
          background:linear-gradient(90deg,rgba(245,158,11,.12),rgba(245,158,11,.04));
          border-bottom:1px solid rgba(245,158,11,.18);
          display:flex;align-items:center;gap:6px;flex-wrap:wrap;
        }
        .up-wechat-copy{
          display:inline-flex;align-items:center;gap:4px;padding:1px 8px;
          background:rgba(255,255,255,.08);border:1px solid rgba(245,158,11,.3);
          border-radius:5px;cursor:pointer;font-weight:600;color:#fcd34d;
          transition:all .15s;user-select:none;
        }
        .up-wechat-copy:hover{
          background:rgba(245,158,11,.18);border-color:#f59e0b;color:#fff;
          transform:translateY(-1px);
        }
        .up-wechat-copy.copied{
          background:rgba(16,185,129,.18);border-color:#10b981;color:#34d399;
        }

        /* 公告条（远程拉取，默认隐藏） */
        .up-announce{
          display:none;padding:8px 14px;font-size:11px;line-height:1.55;
          border-bottom:1px solid rgba(59,130,246,.22);
          align-items:flex-start;gap:6px;position:relative;
        }
        .up-announce.show{display:flex;animation:upAnnounceIn .35s ease;}
        @keyframes upAnnounceIn{from{opacity:0;transform:translateY(-4px);}to{opacity:1;transform:translateY(0);}}
        .up-announce.info   {color:#93c5fd;background:linear-gradient(90deg,rgba(59,130,246,.16),rgba(59,130,246,.04));border-color:rgba(59,130,246,.25);}
        .up-announce.warning{color:#fcd34d;background:linear-gradient(90deg,rgba(245,158,11,.16),rgba(245,158,11,.04));border-color:rgba(245,158,11,.3);}
        .up-announce.error  {color:#fca5a5;background:linear-gradient(90deg,rgba(239,68,68,.16),rgba(239,68,68,.04));border-color:rgba(239,68,68,.3);}
        .up-announce.success{color:#86efac;background:linear-gradient(90deg,rgba(34,197,94,.16),rgba(34,197,94,.04));border-color:rgba(34,197,94,.3);}
        .up-announce-icon{flex-shrink:0;font-size:13px;line-height:1.3;}
        .up-announce-body{flex:1;min-width:0;}
        .up-announce-title{font-weight:600;margin-bottom:2px;font-size:11.5px;}
        .up-announce-content{font-size:11px;color:rgba(255,255,255,.85);line-height:1.55;word-break:break-word;}
        .up-announce-content b{color:#fde68a;font-weight:600;}
        .up-announce-close{
          position:absolute;top:4px;right:8px;cursor:pointer;color:rgba(255,255,255,.5);
          font-size:14px;line-height:1;padding:2px;user-select:none;
        }
        .up-announce-close:hover{color:#fff;}
      `;
      document.head.appendChild(style);
    },

    setStatus(status) {
      // status: idle | running | paused | error | ok
      const dot = this.panelEl?.querySelector('.up-dot');
      const ball = this.ballEl;
      if (dot) {
        dot.className = 'up-dot ' + status;
      }
      if (ball) {
        ball.classList.toggle('running', status === 'running' || status === 'paused');
      }
    },

    // 刷新广告模式 UI（locked / unlocked + 倒计时）
    refreshUnlockUI() {
      if (!this.panelEl) return;
      const statusEl = this.panelEl.querySelector('#up-unlock-status');
      const lockedBox = this.panelEl.querySelector('#up-unlock-locked');
      const activeBox = this.panelEl.querySelector('#up-unlock-active');
      const remainEl = this.panelEl.querySelector('#up-unlock-remaining');
      const untilEl = this.panelEl.querySelector('#up-unlock-until');
      if (!statusEl || !lockedBox || !activeBox) return;

      if (Store.isUnlocked()) {
        statusEl.textContent = '已解锁';
        statusEl.className = 'up-unlock-status unlocked';
        lockedBox.style.display = 'none';
        activeBox.style.display = 'block';
        const remainMs = Store.getRemainingMs();
        const h = Math.floor(remainMs / 3600000);
        const m = Math.floor((remainMs % 3600000) / 60000);
        const s = Math.floor((remainMs % 60000) / 1000);
        if (remainEl) {
          remainEl.textContent = h > 0
            ? `剩余 ${h} 时 ${m} 分 ${s} 秒`
            : `剩余 ${m} 分 ${s} 秒`;
        }
        if (untilEl) untilEl.textContent = '到期：' + Store.getValidUntilStr();
      } else {
        statusEl.textContent = '广告模式';
        statusEl.className = 'up-unlock-status locked';
        lockedBox.style.display = 'flex';
        activeBox.style.display = 'none';
      }
    },

    createBall() {
      this.injectStyles();
      const ball = document.createElement('div');
      ball.id = 'unipus-ball';
      ball.innerText = '📚';
      ball.title = 'U校园刷课助手';
      ball.onclick = () => {
        if (this.panelEl) {
          const isHidden = this.panelEl.style.display === 'none';
          this.panelEl.style.display = isHidden ? 'flex' : 'none';
          Store.setPanelOpen(isHidden);
        } else {
          this.createPanel();
        }
      };
      document.body.appendChild(ball);
      this.ballEl = ball;
    },

    createPanel() {
      this.injectStyles();
      const cfg = Store.getFeatureConf();
      const envLabel = IS_LEGACY ? '普通版' : (IS_IPUB ? '新版' : '内容页');

      const panel = document.createElement('div');
      panel.id = 'unipus-panel';
      panel.setAttribute('data-unipus-helper', '1');
      panel.innerHTML = `
        <div class="up-header">
          <div class="up-title">
            <span class="up-dot ok"></span>
            <span>📚 U校园助手</span>
            <span style="font-size:10px;color:#64748b;font-weight:400;">v${Config.version} · ${envLabel}</span>
          </div>
          <div style="display:flex;gap:4px;">
            <button class="up-iconbtn" id="up-refresh-btn" title="重新扫描目录">🔄</button>
            <button class="up-iconbtn" id="up-settings-btn" title="高级设置">⚙️</button>
            <button class="up-iconbtn" id="up-min-btn" title="最小化">─</button>
            <button class="up-iconbtn" id="up-close-btn" title="关闭">✕</button>
          </div>
        </div>

        <div class="up-wechat-tip">
          ⚠️ BUG 反馈 请加微信
          <span class="up-wechat-copy" id="up-wechat-copy" title="点击复制">C919irt 📋</span>
        </div>

        <div class="up-announce" id="up-announce">
          <span class="up-announce-icon">📢</span>
          <div class="up-announce-body">
            <div class="up-announce-title" id="up-announce-title">公告</div>
            <div class="up-announce-content" id="up-announce-content"></div>
          </div>
          <span class="up-announce-close" id="up-announce-close" title="关闭">×</span>
        </div>

        <div class="up-body">
          <!-- 起始目录 + 时长 -->
          <div class="up-section">
            <div class="up-section-title">▶ 任务设置</div>
            <div class="up-row" style="flex-direction:column;align-items:stretch;gap:6px;">
              <span class="up-label" style="flex:none;">📖 起始目录</span>
              <select id="up-menu-select" class="up-select"></select>
            </div>
            <div class="up-row" style="margin-top:8px;flex-direction:column;align-items:stretch;gap:6px;">
              <span class="up-label" style="flex:none;">⏱ 总时长（分钟）</span>
              <input id="up-time-input" class="up-input" type="number" min="1" value="60"/>
            </div>
          </div>

          <!-- 常用设置（明面）-->
          <div class="up-section">
            <div class="up-section-title">⚡ 常用设置</div>
            <div class="up-row">
              <span class="up-label">自动作答</span>
              <label class="up-switch">
                <input type="checkbox" id="up-autoAnswer" ${cfg.autoAnswer ? 'checked' : ''}/>
                <span class="up-switch-slider"></span>
              </label>
            </div>
            <div class="up-row" style="flex-direction:column;align-items:stretch;gap:6px;">
              <span class="up-label" style="flex:none;">📝 文本 AI（普通题目）</span>
              <select id="up-aiProvider" class="up-select">
                ${Object.entries(AI_PROVIDERS).filter(([, v]) => v.type === 'text').map(([k, v]) => `<option value="${k}" ${Store.getAIProvider() === k ? 'selected' : ''}>${v.name}${v.free ? ' [免费]' : ''}</option>`).join('')}
              </select>
            </div>
            <div class="up-row" style="flex-direction:column;align-items:stretch;gap:4px;">
              <span class="up-label" style="flex:none;">文本 AI Key</span>
              <div class="up-key-row">
                <input id="up-aiKey" class="up-input" type="password" placeholder="粘贴 API Key" value="${(Store.getAIApiKey() || '').replace(/"/g, '&quot;')}"/>
                <button class="up-key-toggle" id="up-key-toggle" title="显示/隐藏">👁</button>
              </div>
              <a id="up-ai-link" target="_blank" style="font-size:10px;color:#06b6d4;text-decoration:none;"></a>
            </div>
            <div class="up-row" style="flex-direction:column;align-items:stretch;gap:6px;margin-top:8px;">
              <span class="up-label" style="flex:none;display:flex;align-items:center;flex-wrap:wrap;gap:6px;">
                🎧 音频 AI（听力题）
                <span style="font-size:10px;font-weight:600;color:#34d399;background:rgba(16,185,129,.14);border:1px solid rgba(16,185,129,.35);padding:1px 6px;border-radius:10px;">
                  ⭐ 推荐千问 · 基本满分
                </span>
                <span style="font-size:10px;font-weight:500;color:#fbbf24;">智谱限流严，备选</span>
              </span>
              <select id="up-audioProvider" class="up-select">
                ${Object.entries(AI_PROVIDERS).filter(([, v]) => v.type === 'audio').map(([k, v]) => `<option value="${k}" ${Store.getAudioProvider() === k ? 'selected' : ''}>${v.name}${v.free ? ' [免费]' : ''}</option>`).join('')}
              </select>
            </div>
            <div class="up-row" style="flex-direction:column;align-items:stretch;gap:4px;">
              <span class="up-label" style="flex:none;">音频 AI Key</span>
              <div class="up-key-row">
                <input id="up-audioKey" class="up-input" type="password" placeholder="粘贴 API Key" value="${(Store.getAudioApiKey() || '').replace(/"/g, '&quot;')}"/>
                <button class="up-key-toggle" id="up-audio-key-toggle" title="显示/隐藏">👁</button>
              </div>
              <a id="up-audio-link" target="_blank" style="font-size:10px;color:#06b6d4;text-decoration:none;"></a>
            </div>
          </div>

          <!-- 广告模式 / 解锁码 -->
          <div class="up-section">
            <div class="up-section-title" style="display:flex;align-items:center;justify-content:space-between;">
              <span>🚀 加速模式（广告 / 解锁码）</span>
              <span id="up-unlock-status" class="up-unlock-status"></span>
            </div>
            <div id="up-unlock-locked" style="display:flex;gap:10px;align-items:flex-start;">
              <div class="up-qr-box">
                <img src="${Config.qrImageUrl}" id="up-qr-img" alt="扫码看广告获取解锁码"
                  onerror="this.style.display='none';this.nextElementSibling.style.display='flex';"/>
                <div class="up-qr-fallback">
                  <div style="font-size:28px;">📱</div>
                  <div style="font-size:10px;color:#94a3b8;text-align:center;">扫码看广告<br/>获取解锁码</div>
                </div>
              </div>
              <div style="flex:1;display:flex;flex-direction:column;gap:6px;">
                <div style="font-size:11px;color:#94a3b8;line-height:1.5;">
                  当前题间 <b style="color:#f59e0b;">35 秒</b><br/>
                  解锁后 <b style="color:#10b981;">1.5 秒</b>
                </div>
                <input id="up-unlock-input" class="up-input" type="text" placeholder="4 位解锁码" maxlength="6"
                  style="text-align:center;letter-spacing:3px;font-weight:600;font-size:13px;text-transform:uppercase;"/>
                <button class="up-btn up-btn-success" id="up-unlock-btn" style="padding:7px 10px;font-size:12px;">🔓 解锁</button>
              </div>
            </div>
            <div id="up-unlock-active" style="display:none;text-align:center;padding:8px 0;">
              <div style="font-size:13px;color:#10b981;font-weight:600;margin-bottom:4px;">✓ 已解锁加速模式</div>
              <div id="up-unlock-remaining" style="font-size:11px;color:#94a3b8;"></div>
              <div id="up-unlock-until" style="font-size:10px;color:#64748b;margin-top:2px;"></div>
              <button class="up-btn up-btn-ghost up-btn-sm" id="up-unlock-clear" style="margin-top:8px;">注销解锁</button>
            </div>
          </div>

          <!-- 控制按钮 -->
          <div style="display:flex;gap:6px;">
            <button id="up-start-btn" class="up-btn" style="flex:2;">🚀 开始刷课</button>
            <button id="up-pause-btn" class="up-btn up-btn-warn" style="flex:1;display:none;">⏸ 暂停</button>
            <button id="up-stop-btn" class="up-btn up-btn-danger" style="flex:1;display:none;">⏹ 停止</button>
          </div>

          <!-- 日志 -->
          <div>
            <div class="up-section-title" style="margin-bottom:6px;display:flex;justify-content:space-between;">
              <span>📜 运行日志</span>
              <button class="up-btn up-btn-ghost up-btn-sm" id="up-clear-log" title="清空">清空</button>
            </div>
            <div id="unipus-log"></div>
          </div>
        </div>

        <div class="up-footer">
          <span>叶屿 · GPL3</span>
          <a href="https://github.com/uxudjs/UnipusAIAutoPlayer" target="_blank">架构参考</a>
        </div>
      `;
      document.body.appendChild(panel);
      this.panelEl = panel;
      this.menuSelectEl = panel.querySelector('#up-menu-select');
      this.timeInputEl = panel.querySelector('#up-time-input');
      this.startBtn = panel.querySelector('#up-start-btn');
      this.pauseBtn = panel.querySelector('#up-pause-btn');
      this.stopBtn = panel.querySelector('#up-stop-btn');
      this.logEl = panel.querySelector('#unipus-log');

      // 恢复输入
      this.timeInputEl.value = Store.getLastTimeValue();

      // 事件
      panel.querySelector('#up-close-btn').onclick = () => {
        panel.style.display = 'none';
        Store.setPanelOpen(false);
      };
      // 最小化：收回悬浮球
      panel.querySelector('#up-min-btn').onclick = () => {
        panel.style.display = 'none';
      };
      // 拖动面板
      (() => {
        const header = panel.querySelector('.up-header');
        let dragging = false, ox = 0, oy = 0;
        header.addEventListener('mousedown', (e) => {
          if (e.target.closest('.up-iconbtn')) return; // 不拦截按钮点击
          dragging = true;
          ox = e.clientX - panel.getBoundingClientRect().left;
          oy = e.clientY - panel.getBoundingClientRect().top;
          e.preventDefault();
        });
        document.addEventListener('mousemove', (e) => {
          if (!dragging) return;
          let x = e.clientX - ox;
          let y = e.clientY - oy;
          // 限制不超出视口
          x = Math.max(0, Math.min(window.innerWidth - panel.offsetWidth, x));
          y = Math.max(0, Math.min(window.innerHeight - 40, y));
          panel.style.left = x + 'px';
          panel.style.top = y + 'px';
          panel.style.right = 'auto';
          panel.style.bottom = 'auto';
        });
        document.addEventListener('mouseup', () => { dragging = false; });
      })();
      panel.querySelector('#up-settings-btn').onclick = () => this.openSettings();
      panel.querySelector('#up-refresh-btn').onclick = () => {
        this.addLog('🔄 重新扫描目录...');
        _menuListCache = [];
        IframeRPC.requestScan();
      };
      panel.querySelector('#up-clear-log').onclick = () => {
        if (this.logEl) this.logEl.innerHTML = '';
      };
      // 微信号复制
      const wechatEl = panel.querySelector('#up-wechat-copy');
      if (wechatEl) {
        wechatEl.onclick = async () => {
          const wechat = 'C919irt';
          let ok = false;
          try {
            if (navigator.clipboard && navigator.clipboard.writeText) {
              await navigator.clipboard.writeText(wechat);
              ok = true;
            }
          } catch (_) {}
          if (!ok) {
            // 回退到 execCommand
            try {
              const ta = document.createElement('textarea');
              ta.value = wechat;
              ta.style.cssText = 'position:fixed;opacity:0;pointer-events:none;';
              document.body.appendChild(ta);
              ta.select();
              ok = document.execCommand('copy');
              document.body.removeChild(ta);
            } catch (_) {}
          }
          wechatEl.classList.add('copied');
          wechatEl.textContent = ok ? '✅ 已复制 C919irt' : '❌ 复制失败，请手动';
          setTimeout(() => {
            wechatEl.classList.remove('copied');
            wechatEl.textContent = 'C919irt 📋';
          }, 1800);
        };
      }

      // 常用设置自动保存
      const autoAnswerEl = panel.querySelector('#up-autoAnswer');
      autoAnswerEl.onchange = () => {
        const c = Store.getFeatureConf();
        Store.setFeatureConf({ ...c, autoAnswer: autoAnswerEl.checked });
        this.addLog(`✅ 自动作答：${autoAnswerEl.checked ? '开' : '关'}`);
      };
      const aiProviderEl = panel.querySelector('#up-aiProvider');
      const aiLinkEl = panel.querySelector('#up-ai-link');
      const updateAILink = () => {
        const conf = AI_PROVIDERS[aiProviderEl.value];
        if (!conf) return;
        aiLinkEl.href = conf.link;
        aiLinkEl.textContent = `${conf.linkText} · ${conf.keyHint}`;
      };
      updateAILink();
      aiProviderEl.onchange = () => {
        Store.setAIProvider(aiProviderEl.value);
        updateAILink();
        this.addLog(`✅ AI 模型：${AI_PROVIDERS[aiProviderEl.value]?.name || aiProviderEl.value}`);
      };
      const aiKeyEl = panel.querySelector('#up-aiKey');
      aiKeyEl.onblur = () => {
        const v = aiKeyEl.value.trim();
        if (v !== Store.getAIApiKey()) {
          Store.setAIApiKey(v);
          this.addLog('✅ 文本 AI Key 已保存');
        }
      };
      panel.querySelector('#up-key-toggle').onclick = () => {
        aiKeyEl.type = aiKeyEl.type === 'password' ? 'text' : 'password';
      };

      // ---- 音频 AI 控件 ----
      const audioProviderEl = panel.querySelector('#up-audioProvider');
      const audioLinkEl = panel.querySelector('#up-audio-link');
      const updateAudioLink = () => {
        const conf = AI_PROVIDERS[audioProviderEl.value];
        if (!conf) return;
        audioLinkEl.href = conf.link;
        audioLinkEl.textContent = `${conf.linkText} · ${conf.keyHint}`;
      };
      updateAudioLink();
      audioProviderEl.onchange = () => {
        Store.setAudioProvider(audioProviderEl.value);
        updateAudioLink();
        this.addLog(`✅ 音频 AI：${AI_PROVIDERS[audioProviderEl.value]?.name || audioProviderEl.value}`);
      };
      const audioKeyEl = panel.querySelector('#up-audioKey');
      audioKeyEl.onblur = () => {
        const v = audioKeyEl.value.trim();
        if (v !== Store.getAudioApiKey()) {
          Store.setAudioApiKey(v);
          this.addLog('✅ 音频 AI Key 已保存');
        }
      };
      panel.querySelector('#up-audio-key-toggle').onclick = () => {
        audioKeyEl.type = audioKeyEl.type === 'password' ? 'text' : 'password';
      };

      // ---- 广告模式 / 解锁码 ----
      const unlockInput = panel.querySelector('#up-unlock-input');
      const unlockBtn = panel.querySelector('#up-unlock-btn');
      unlockBtn.onclick = async () => {
        const code = unlockInput.value.trim();
        if (!code) {
          this.addLog('⚠️ 请输入解锁码');
          unlockInput.focus();
          return;
        }
        unlockBtn.disabled = true;
        unlockBtn.textContent = '验证中...';
        try {
          const r = await Solver.verifyUnlockCode(code);
          Store.setVerifyValidUntil(r.validUntil);
          unlockInput.value = '';
          this.addLog(`✅ 解锁成功！有效期至 ${r.validUntilStr}`);
          this.refreshUnlockUI();
        } catch (err) {
          this.addLog(`❌ 解锁失败：${err}`);
        } finally {
          unlockBtn.disabled = false;
          unlockBtn.textContent = '🔓 解锁';
        }
      };
      unlockInput.addEventListener('keydown', (e) => {
        if (e.key === 'Enter') unlockBtn.click();
      });
      panel.querySelector('#up-unlock-clear').onclick = () => {
        if (confirm('确定注销当前解锁？')) {
          Store.setVerifyValidUntil(0);
          this.addLog('✅ 已注销解锁，恢复广告模式');
          this.refreshUnlockUI();
        }
      };

      this.refreshUnlockUI();
      // 每秒刷新一次倒计时
      if (this._unlockTimer) clearInterval(this._unlockTimer);
      this._unlockTimer = setInterval(() => this.refreshUnlockUI(), 1000);

      this.startBtn.onclick = () => this.onStart();
      this.pauseBtn.onclick = () => this.onPause();
      this.stopBtn.onclick = () => this.onStop();

      // 监听菜单就绪
      window.addEventListener('UNIPUS_MENU_READY', (e) => {
        this.populateMenu(e.detail);
      });
      if (_menuListCache.length) this.populateMenu(_menuListCache);
      else this.populateMenu([]);

      // 监听日志（去重防止 panel 重建时重复绑定）
      if (!Panel._logBound) {
        Panel._logBound = true;
        IframeRPC.onLog((msg) => this.addLog(msg));
      }

      // 远程公告
      this._fetchAnnounce(panel);
    },

    _fetchAnnounce(panel) {
      if (typeof GM_xmlhttpRequest !== 'function') return;
      try {
        GM_xmlhttpRequest({
          method: 'GET',
          url: Config.announceUrl,
          timeout: 8000,
          onload: (resp) => {
            try {
              const res = JSON.parse(resp.responseText);
              if (res.code !== 1 || !res.data || !res.data.enabled) return;
              this._renderAnnounce(panel, res.data);
            } catch (_) {}
          },
          onerror: () => {}, ontimeout: () => {},
        });
      } catch (_) {}
    },

    _renderAnnounce(panel, data) {
      const root = panel.querySelector('#up-announce');
      const titleEl = panel.querySelector('#up-announce-title');
      const contentEl = panel.querySelector('#up-announce-content');
      const closeEl = panel.querySelector('#up-announce-close');
      const iconEl = root && root.querySelector('.up-announce-icon');
      if (!root || !titleEl || !contentEl) return;
      const type = ['info','warning','error','success'].includes(data.type) ? data.type : 'info';
      const icon = { info: '📢', warning: '⚠️', error: '❌', success: '✅' }[type];
      if (iconEl) iconEl.textContent = icon;
      titleEl.textContent = data.title || '公告';
      // 简易白名单 sanitizer
      const tmp = document.createElement('div');
      tmp.innerHTML = String(data.content || '');
      tmp.querySelectorAll('*').forEach(el => {
        const tag = el.tagName.toLowerCase();
        if (!['br','b','i','u','strong','em','span'].includes(tag)) {
          el.replaceWith(document.createTextNode(el.textContent || ''));
          return;
        }
        [...el.attributes].forEach(attr => {
          if (/^on/i.test(attr.name) || attr.name === 'style') el.removeAttribute(attr.name);
        });
      });
      contentEl.innerHTML = tmp.innerHTML;
      root.classList.remove('info','warning','error','success');
      root.classList.add(type, 'show');
      if (closeEl) closeEl.onclick = () => { root.classList.remove('show'); };
    },

    async onStart() {
      if (isRunning) {
        this.addLog('⚠️ 已经在运行中...');
        return;
      }
      // 如果在 u.unipus.cn 目录页，自动点击"继续学习"进入内容页
      if (IS_LEGACY && location.pathname.includes('courseCatalog')) {
        const continueBtn = document.querySelector('a[class*="continue"], button[class*="continue"], a.start-btn, .course-info a, a[href*="ucontent"]');
        // 也尝试按文本找
        if (!continueBtn) {
          let found = null;
          document.querySelectorAll('a, button').forEach(el => {
            const t = (el.innerText || '').trim();
            if (/^(继续学习|开始学习|进入课程|Start)$/i.test(t)) found = el;
          });
          if (found) {
            this.addLog('🔗 检测到目录页，正在跳转到课程内容...');
            found.click();
            return;
          }
        } else {
          this.addLog('🔗 检测到目录页，正在跳转到课程内容...');
          continueBtn.click();
          return;
        }
        this.addLog('⚠️ 当前在目录页，请先点击"继续学习"进入课程内容页面');
        return;
      }
      if (!_menuListCache.length) {
        this.addLog('⚠️ 目录未加载，正在重新扫描...');
        await IframeRPC.requestScan();
        await Utils.sleep(1500);
        if (!_menuListCache.length) {
          this.addLog('⚠️ 目录扫描失败，请确认已进入课程内容页面');
          return;
        }
      }
      const totalMin = Math.max(1, parseInt(this.timeInputEl.value || '60', 10));
      const startIdx = parseInt(this.menuSelectEl.value || '0', 10);
      Store.setLastTimeValue(totalMin);
      this.startBtn.style.display = 'none';
      this.pauseBtn.style.display = 'inline-flex';
      this.pauseBtn.textContent = '⏸ 暂停';
      this.pauseBtn.className = 'up-btn up-btn-warn';
      this.stopBtn.style.display = 'inline-flex';
      this.setStatus('running');

      try {
        await MenuRunner.run(_menuListCache, totalMin, startIdx, (msg, isCD) => this.addLog(msg, isCD));
        this.setStatus('ok');
      } catch (e) {
        this.addLog(`❌ 运行异常：${e.message || e}`);
        this.setStatus('error');
      } finally {
        this.startBtn.style.display = 'inline-flex';
        this.pauseBtn.style.display = 'none';
        this.stopBtn.style.display = 'none';
        isPaused = false;
      }
    },

    onPause() {
      isPaused = !isPaused;
      if (isPaused) {
        this.pauseBtn.textContent = '▶ 继续';
        this.pauseBtn.className = 'up-btn up-btn-success';
        this.setStatus('paused');
        this.addLog('⏸ 已暂停（再次点击继续）');
      } else {
        this.pauseBtn.textContent = '⏸ 暂停';
        this.pauseBtn.className = 'up-btn up-btn-warn';
        this.setStatus('running');
        this.addLog('▶ 继续运行');
      }
    },

    async onStop() {
      this.addLog('⏹ 正在停止...');
      stopRequested = true;
      isPaused = false;
      this.setStatus('idle');
      try { await IframeRPC.stop(); } catch (_) {}
    },

    openSettings() {
      if (this.settingsPanel) {
        this.settingsPanel.style.display = 'flex';
        return;
      }
      const cfg = Store.getFeatureConf();
      const overlay = document.createElement('div');
      overlay.id = 'unipus-settings-overlay';
      overlay.setAttribute('data-unipus-helper', '1');
      const rate = Store.getPlaybackRate();
      overlay.innerHTML = `
        <div class="up-dialog">
          <div style="display:flex;justify-content:space-between;align-items:center;margin-bottom:14px;">
            <h3>⚙️ 高级设置</h3>
            <button class="up-iconbtn" id="cfg-close">✕</button>
          </div>

          <div class="up-section" style="margin-bottom:10px;">
            <div class="up-section-title">媒体播放</div>
            <div class="up-row" style="flex-direction:column;align-items:stretch;gap:6px;">
              <span class="up-label" style="flex:none;">视频/音频倍速</span>
              <select id="cfg-playbackRate" class="up-select">
                ${[1, 1.25, 1.5, 1.75, 2, 2.5, 3].map(r => `<option value="${r}" ${rate === r ? 'selected' : ''}>${r}x</option>`).join('')}
              </select>
            </div>
          </div>

          <div class="up-section" style="margin-bottom:10px;">
            <div class="up-section-title">自动化行为</div>
            <div class="up-row">
              <span class="up-label">自动关闭"我知道了"等弹窗</span>
              <label class="up-switch">
                <input type="checkbox" id="cfg-autoPopup" ${cfg.autoPopup ? 'checked' : ''}/>
                <span class="up-switch-slider"></span>
              </label>
            </div>
          </div>

          <div class="up-section" style="margin-bottom:14px;">
            <div class="up-section-title">数据管理</div>
            <div class="up-row" style="gap:6px;">
              <button class="up-btn up-btn-ghost" id="cfg-reset-key" style="flex:1;">清空 API Key</button>
              <button class="up-btn up-btn-ghost" id="cfg-reset-all" style="flex:1;">重置全部设置</button>
            </div>
          </div>

          <div style="display:flex;gap:8px;justify-content:flex-end;">
            <button class="up-btn up-btn-ghost" id="cfg-cancel">关闭</button>
            <button class="up-btn" id="cfg-save">保存</button>
          </div>
        </div>
      `;
      document.body.appendChild(overlay);
      this.settingsPanel = overlay;

      const close = () => { overlay.remove(); this.settingsPanel = null; };
      overlay.addEventListener('click', (e) => { if (e.target === overlay) close(); });
      overlay.querySelector('#cfg-close').onclick = close;
      overlay.querySelector('#cfg-cancel').onclick = close;

      overlay.querySelector('#cfg-reset-key').onclick = () => {
        if (confirm('确定清空所有 API Key（文本 + 音频）？')) {
          Store.setAIApiKey('');
          Store.setAudioApiKey('');
          this.addLog('✅ API Key 已清空');
          // 同步主面板
          const k = this.panelEl?.querySelector('#up-aiKey'); if (k) k.value = '';
          const k2 = this.panelEl?.querySelector('#up-audioKey'); if (k2) k2.value = '';
        }
      };
      overlay.querySelector('#cfg-reset-all').onclick = () => {
        if (confirm('确定重置所有设置？（不可恢复）')) {
          Object.values(Config.storageKeys).forEach(k => {
            try { localStorage.removeItem(k); } catch (_) {}
            try { GM_setValue(k, ''); } catch (_) {}
          });
          this.addLog('✅ 已重置，请刷新页面');
          close();
        }
      };
      overlay.querySelector('#cfg-save').onclick = () => {
        const newConf = {
          autoAnswer: Store.getFeatureConf().autoAnswer,
          autoPopup: overlay.querySelector('#cfg-autoPopup').checked,
        };
        Store.setFeatureConf(newConf);
        Store.setPlaybackRate(parseFloat(overlay.querySelector('#cfg-playbackRate').value));
        this.addLog('✅ 高级设置已保存');
        close();
      };
    },

    init() {
      window.__unipusPanel = this;
      this.createBall();
      if (Store.getPanelOpen()) {
        this.createPanel();
      }
      this.addLog?.(`✨ U校园刷课助手 v${Config.version} 已就绪`);
    },
  };

  // ---- 早期返回：iframe 子页面 ----
  if (IS_IFRAME && IS_UCONTENT) {
    setupIframeChild();
    console.log('[U校园助手] iframe 子页面已激活');
    return;
  }

  // ---- 主页面（ipub/uai/普通版）：初始化 ----
  if (IS_MAIN || (!IS_IFRAME && IS_UCONTENT)) {
    const envName = IS_LEGACY ? '普通版' : (IS_IPUB ? '新版(ipub/uai)' : 'ucontent');
    // 等待 DOM 准备
    const initMainPage = () => {
      try {
        IframeRPC.init();
        Panel.init();
        // 定时自动关闭弹窗
        setInterval(clickIKnow, 1500);
        const _log = (msg) => { console.log('[U校园助手]', msg); Panel.addLog?.(msg); };
        _log(`🌐 环境: ${envName} | host: ${location.hostname}`);

        // 诊断：检查 iframe 状况
        const iframes = document.querySelectorAll('iframe');
        _log(`📦 iframe 数量: ${iframes.length}${iframes.length ? (' | src: ' + [...iframes].map(f => (f.src || '').slice(0, 60)).join(', ')) : ''}`);

        const iw = IframeRPC.getIframeWin();
        if (iw) {
          _log('✅ 已找到 ucontent iframe，通过 postMessage 通信');
        } else {
          _log('⚠️ 未找到 iframe，将本地扫描当前页面目录');
        }

        // 首次延迟扫描
        const _scanDelay = IS_LEGACY ? 2500 : 3000;
        let _autoStarted = false;
        const _tryAutoStart = () => {
          if (_autoStarted || !_menuListCache.length) return;
          // 在 ucontent 内容页自动开始刷课（不在目录页）
          if (IS_UCONTENT || (IS_LEGACY && !location.pathname.includes('courseCatalog'))) {
            _autoStarted = true;
            _log(`🚀 自动开始刷课...`);
            // 最小化面板到悬浮球
            if (Panel.panelEl) Panel.panelEl.style.display = 'none';
            setTimeout(() => Panel.onStart(), 500);
          }
        };
        setTimeout(() => {
          IframeRPC.requestScan().then(r => {
            if (_menuListCache.length) {
              _log(`✅ 目录扫描成功: ${_menuListCache.length} 项`);
              _tryAutoStart();
            } else {
              _log('⚠️ 首次扫描未找到目录项，等待重试...');
            }
          }).catch(() => {});
        }, _scanDelay);

        // 每 3 秒再试一次，最多重试 8 次（共 ~27s）
        let _scanRetry = 0;
        const _scanTimer = setInterval(() => {
          if (_menuListCache.length || ++_scanRetry > 8) {
            clearInterval(_scanTimer);
            if (_menuListCache.length) {
              _tryAutoStart();
            } else {
              _log('❌ 目录扫描失败（8次重试后仍未找到）。请确认已进入课程学习页面（点击"开始学习"）。');
            }
            return;
          }
          IframeRPC.requestScan().catch(() => {});
        }, 3000);
        console.log(`[U校园助手] 主页面已初始化（${envName}）`);
      } catch (e) {
        console.error('[U校园助手] 初始化失败:', e);
      }
    };
    if (document.readyState === 'loading') {
      document.addEventListener('DOMContentLoaded', initMainPage);
    } else {
      initMainPage();
    }
  } else {
    console.log('[U校园助手] 当前页面不属于支持范围');
  }

})();