// ==UserScript==
// @name         山东省教师教育网继续教育自动学习助手
// @namespace    qlt-auto-study
// @version      0.8.8
// @description  山东省教师教育网（yxjc.qlteacher.com）继续教育自动挂机：解除暂停、自动切换章节、随机答题提交、课程间自动流转。兼容 Tampermonkey 与 ScriptCat。仅供个人学习交流，请遵守平台规则。
// @author       WorkBuddy
// @match        *://yxjc.qlteacher.com/project/*
// @match        *://player.qlteacher.com/learning/*
// @run-at       document-start
// @grant        GM_getValue
// @grant        GM_setValue
// @noframes
// @license      MIT
// ==/UserScript==

(function () {
  'use strict';

  /* ============================================================
   * 0. 常量与选择器表（平台改版时优先维护此处）
   * ==========================================================*/

  var LEARN_PATH_RE = /\/project\/([^/]+)\/lesson\/learn/;
  var PLAYER_URL_RE = /player\.qlteacher\.com\/learning\/([^/?#]+)\/([^/?#]+)/;
  var CATALOG_URL_RE = /yxjc\.qlteacher\.com\/project\/([^/]+)/;

  var SEL = {
    // 播放页
    countdown: ['.count-down.ng-star-inserted', '.count-down'],
    video: ['video'],
    // 弹题
    radio: ['.ant-radio-input', 'input[type="radio"].ant-radio-input'],
    checkbox: ['.ant-checkbox', 'input[type="checkbox"]'],
    btnPrimary: ['button.ant-btn-primary', '.ant-btn.ant-btn-primary', 'button.ant-btn.radius-4'],
    // 纯测试题/考试页
    courseTag: ['.segmented-text-ellipsis.mr-16'],
    // 课程进度（目录页/learning 页）：进度文案与进度条
    progressText: ['.ant-progress-text', '[class*="progress"] [class*="text"]', '[class*="percent"]', '[class*="rate"]'],
    progressBar: ['.ant-progress-bg', '[class*="progress-inner"]', '[class*="progress"] [class*="bar"]', '[class*="percent"] [class*="in"]'],
    // 章节条目（用于"全部章节都已勾完成"的兜底判定）
    chapterItem: ['li.ant-list-item', '.ant-list-item', '[class*="chapter-item"]', '[class*="chapter"]', '[class*="lesson-item"]'],
    quizItem: ['.mb-16.ng-star-inserted'],
    // 题目容器候选（策略1，按 class 特征找含成组选项的容器）
    quizContainer: ['.mb-16.ng-star-inserted', '[class*="question"]', '[class*="quiz-item"]', '[class*="exam-item"]', '.ant-list-item', 'li'],
    // 答题入口按钮文本（测试页可能需先点击进入才渲染题目）
    entryTexts: ['开始答题', '立即答题', '进入答题', '开始考试', '进入考试', '继续答题', '继续考试', '开始测试'],
    // 目录页/课程页
    anyButton: ['button', 'a.ant-btn', '.ant-btn'],
    // 通用确认弹窗按钮（按文本匹配）
    confirmTexts: ['确定', '确认', '提交', '知道了'],
    startTexts: ['继续学习', '开始学习'],
    startTextsFallback: ['温故知新'],
    doneTexts: ['已完成学习', '已完成', '100%'],
    // 答题相关按钮文本
    answerTexts: ['查看答案', '查看解析', '答案解析', '查看正确答案', '参考答案', '显示答案'],
    redoTexts: ['重新作答', '再答一次', '再做一次', '重新答题', '再次作答', '重新考试', '重新测试', '再考一次', '重做']
  };

  /* ============================================================
   * 1. Environment —— GM_* 能力探测与降级
   * ==========================================================*/

  var Env = (function () {
    var hasGM = typeof GM_getValue === 'function' && typeof GM_setValue === 'function';
    var LS_PREFIX = 'qlt_auto_';

    function gmGet(key, defVal) {
      if (hasGM) {
        var v = GM_getValue(key, undefined);
        return v === undefined ? defVal : v;
      }
      try {
        var raw = localStorage.getItem(LS_PREFIX + key);
        return raw === null ? defVal : JSON.parse(raw);
      } catch (e) { return defVal; }
    }
    function gmSet(key, val) {
      if (hasGM) { GM_setValue(key, val); return; }
      try { localStorage.setItem(LS_PREFIX + key, JSON.stringify(val)); } catch (e) {}
    }
    return { hasGM: hasGM, get: gmGet, set: gmSet };
  })();

  /* ============================================================
   * 2. ConfigStore —— 配置与运行状态持久化
   * ==========================================================*/

  var DEFAULTS = {
    running: false,          // 总开关
    pollMs: 1500,            // 主循环/轮询间隔（1.5s，兼顾响应速度与后台节流）
    watchdogTimeout: 120,    // 看门狗超时（秒）
    maxRetry: 3,             // 单节点重试上限
    skipExam: false,         // true 时考试页暂停转人工
    examSmart: true,         // true 时考试按"随机→读正确答案→重答"循环直到通过
    debug: false,            // 调试日志
    aiQuiz: { enabled: false, endpoint: '', apiKey: '' }  // AI 答题占位
  };

  var DEFAULT_RUNSTATE = {
    lastHeartbeat: 0,
    retryCount: 0,
    skipList: [],            // 跳过节点 key 列表
    catalogReload: null,     // {url, time} 目录页/learn页强制刷新记录
    lastDoneKey: null,       // 最近完成的视频 key（循环守卫用）
    lastDoneTime: 0,
    loopCount: 0,
    currentProject: null,    // 当前项目代号（cz2026 等），用于播放页兜底回跳
    currentCourseId: null,
    currentVideoId: null,
    lockOwner: null,         // 多标签锁
    lockTime: 0,
    navLock: null,           // {by,time,text,path} 点击跳转锁：点击"继续学习/开始学习"后本页长挂起，下游存活期间绝不再点
    catalogMiss: 0,          // 目录页连续未找到未完成章节的次数（≥2 判定本课程完成）
    catalogCourse: null,     // 当前目录页对应的课程编码（变化时重置计数）
    learnMiss: 0,            // learn 页连续未找到未完成课程的次数
    learnReturns: [],        // 最近"课程完成→回退 learn 页"的时间戳（循环守卫：学习页仍显示未完成时防打转）
    stats: { doneVideos: 0, doneCourses: 0, answeredQuizzes: 0 }
  };

  var Config = {
    get: function (k) { return Env.get('cfg_' + k, DEFAULTS[k]); },
    set: function (k, v) { Env.set('cfg_' + k, v); },
    all: function () {
      var o = {};
      for (var k in DEFAULTS) o[k] = this.get(k);
      return o;
    }
  };

  var RunState = {
    get: function () {
      var s = Env.get('runState', {});
      var out = {};
      for (var k in DEFAULT_RUNSTATE) out[k] = s[k] !== undefined ? s[k] : DEFAULT_RUNSTATE[k];
      if (!out.stats) out.stats = { doneVideos: 0, doneCourses: 0, answeredQuizzes: 0 };
      return out;
    },
    set: function (patch) {
      var s = this.get();
      for (var k in patch) s[k] = patch[k];
      Env.set('runState', s);
      return s;
    }
  };

  /* ============================================================
   * 3. 工具函数
   * ==========================================================*/

  function qs(selList, root) {
    root = root || document;
    var list = Array.isArray(selList) ? selList : [selList];
    for (var i = 0; i < list.length; i++) {
      try {
        var el = root.querySelector(list[i]);
        if (el) return el;
      } catch (e) {}
    }
    return null;
  }
  function qsa(selList, root) {
    root = root || document;
    var list = Array.isArray(selList) ? selList : [selList];
    var out = [];
    var seen = typeof Set !== 'undefined' ? new Set() : null;
    for (var i = 0; i < list.length; i++) {
      try {
        var nodes = root.querySelectorAll(list[i]);
        for (var j = 0; j < nodes.length; j++) {
          if (seen) {
            if (!seen.has(nodes[j])) { seen.add(nodes[j]); out.push(nodes[j]); }
          } else if (out.indexOf(nodes[j]) < 0) out.push(nodes[j]);
        }
      } catch (e) {}
    }
    return out;
  }
  function sleep(ms) { return new Promise(function (r) { setTimeout(r, ms); }); }
  function jitter(range) { return Math.floor(Math.random() * range); }
  // 条件轮询：条件一满足立即返回 true，超时返回 false。
  // 用"短步长 + 早走"替代固定 sleep，是提速的关键——内容快就早走，内容慢才等到上限
  async function waitFor(cond, timeoutMs, stepMs) {
    var step = stepMs || 250;
    var deadline = Date.now() + (timeoutMs || 3000);
    while (Date.now() < deadline) {
      try { if (cond()) return true; } catch (e) {}
      await sleep(step);
    }
    try { return !!cond(); } catch (e) { return false; }
  }
  function randItem(arr) { return arr[Math.floor(Math.random() * arr.length)]; }
  function textOf(el) { return el ? (el.innerText || el.textContent || '').trim() : ''; }
  function realClick(el) {
    if (!el) return false;
    try { el.scrollIntoView({ block: 'center', behavior: 'instant' }); } catch (e) {}
    try {
      ['mousedown', 'mouseup', 'click'].forEach(function (type) {
        el.dispatchEvent(new MouseEvent(type, { bubbles: true, cancelable: true, view: window }));
      });
    } catch (e) {}
    try { el.click(); } catch (e) {}
    return true;
  }
  function clickByText(root, selList, texts) {
    var btns = qsa(selList, root);
    for (var i = 0; i < btns.length; i++) {
      var t = textOf(btns[i]);
      for (var j = 0; j < texts.length; j++) {
        if (t.indexOf(texts[j]) >= 0 && !btns[i].disabled) {
          realClick(btns[i]);
          return btns[i];
        }
      }
    }
    return null;
  }
  function nowTime() {
    var d = new Date();
    function p(n) { return n < 10 ? '0' + n : '' + n; }
    return p(d.getHours()) + ':' + p(d.getMinutes()) + ':' + p(d.getSeconds());
  }
  // 视频元素是否真实可播（测试题页有时会残留一个空 <video> 标签）
  function isVideoPlayable(video) {
    if (!video) return false;
    try {
      if (video.currentSrc || video.src) return true;
      if (video.networkState === 3) return false; // NETWORK_NO_SOURCE
      if (video.readyState > 0) return true;
      if (video.querySelector('source[src]')) return true;
    } catch (e) {}
    return false;
  }
  var TAB_ID = 'tab_' + Date.now() + '_' + Math.floor(Math.random() * 1e6);
  var MY_BOOT = Date.now();

  // 主动刷新前打标记：刷新后同 URL 的新页面据此清掉上一代留下的 activeTab/handoff。
  // 否则刷新后 TAB_ID 变化，会把自己上一代误当成"别的标签页已接管"，直接永久停住。
  function markReload() {
    try { Env.set('reloadMark', { at: Date.now(), url: location.href, tab: TAB_ID }); } catch (e) {}
  }
  function reloadSelf() {
    markReload();
    location.reload();
  }
  function consumeReloadMark() {
    var m = Env.get('reloadMark', null);
    Env.set('reloadMark', null);
    if (!m || (Date.now() - (m.at || 0)) > 30000) return null;
    return m.url === location.href ? m : null;
  }

  /* ---------------- 标签页接力（点击即交权）----------------
   * 本平台每次点击都会开新标签页，同一时刻只允许一个标签页干活。共享状态（GM 存储）：
   *   activeTab = {id, hb}      —— 当前持牌人（干活的那个标签页），每轮主循环续约 hb
   *   handoff   = {from, at, to} —— 点击"继续学习/开始学习"的页面主动交权，45s 内有效
   *   reloadMark={at,url,tab}   —— 主动刷新前的标记，用于刷新后继承持牌权与交权
   * 规则：
   *   1) 交权后的 45s 内，交权页绝不动作（也不认领），等新标签页接手；
   *   2) 只有"交权之后新开 + 20s 内 + 页面类型符合 to"的标签页有资格接手；
   *   3) 持牌人 hb 新鲜且不是"让位给我的页面" → 本页立即停手，但绝不动全局 running；
   *   4) 所有点击入口统一走 canAct() 门禁，暂停/被接管/挂起期间任何点击都不会发生。
   *   5) 点击后进入"长挂起"（navLock）：只要下游标签页还在干活就不许重试，
   *      而不是"过了 45s 冷却就重试"——后者正是重复开标签页的根因。
   */
  function getHandoff() {
    var h = Env.get('handoff', null);
    if (!h || !h.from) return null;
    return (Date.now() - (h.at || 0) < 45000) ? h : null;
  }
  // 点击跳转按钮时调用：本页主动交权，等待新标签页接手
  // to = 预期接手页类型（PLAYER/CATALOG/LEARN），避免同域其他页面误抢
  function setHandoff(to) {
    Env.set('handoff', { from: TAB_ID, at: Date.now(), to: to || null });
  }
  // 本页已交权、正等新标签页接管的窗口期内，一律不动作
  function waitingHandoff() {
    var h = getHandoff();
    return !!(h && h.from === TAB_ID);
  }
  // 本页是否"有权接手"某个交权标记：必须①交权之后才打开 ②20s 窗口内 ③页面类型符合预期。
  // 否则停在目录页的旧标签页会把持牌人的交权误读成"给我让位"，反过来抢权重复点击
  function handoffTarget(h, route) {
    if (!h || !(MY_BOOT > (h.at || 0)) || (Date.now() - (h.at || 0) >= 20000)) return false;
    if (!h.to || !h.to.length) return true;
    var r = route;
    if (!r) { try { r = Router.current(); } catch (e) {} }
    return !!(r && h.to.indexOf(r.page) >= 0);
  }

  // 认领/续约：只在"没有持牌人 / 持牌人是自己 / 有权接手 / 记录已过期"时写入
  function claimActiveTab(route) {
    if (route && !(route.page === 'PLAYER' || route.page === 'CATALOG' || route.page === 'LEARN' || route.page === 'INDEX')) return;
    if (waitingHandoff()) return; // 已交权等别人接手，本页不认领也不动作
    var rec = Env.get('activeTab', null);
    var h = getHandoff();
    var canClaim = !rec
      || rec.id === TAB_ID
      || (h && h.from === rec.id && handoffTarget(h, route))
      || (Date.now() - (rec.hb || 0)) > LICENSE_TTL_MS;
    if (!canClaim) return;
    Env.set('activeTab', { id: TAB_ID, hb: Date.now() });
    // 消费掉别人的交权标记：否则"让位页"会一直认为自己是持牌人的交权来源而不让位
    if (h && h.from !== TAB_ID) Env.set('handoff', null);
  }
  function renewActiveTab() {
    var rec = Env.get('activeTab', null);
    if (rec && rec.id === TAB_ID) Env.set('activeTab', { id: TAB_ID, hb: Date.now() });
  }
  function isTakenOver() {
    var rec = Env.get('activeTab', null);
    if (!rec || rec.id === TAB_ID) return false;
    if ((Date.now() - (rec.hb || rec.time || 0)) >= LICENSE_TTL_MS) return false; // 陈旧记录不算
    var h = getHandoff();
    // 只有当持牌人正在交权、且本页是在交权之后新打开的，才算"让位给我"
    if (h && h.from === rec.id && handoffTarget(h)) return false;
    return true;
  }

  /* ---------------- 点击跳转锁（长挂起）----------------
   * 本平台每次点击"继续学习/开始学习/学习课程"都会打开新标签页，点击后本页必须彻底闭嘴。
   * 旧逻辑只有 45s 冷却：冷却一过就重试，只要此刻下游的持牌心跳恰好陈旧（播放页 study()
   * 长时间占用 busy 导致 tick 停跳就是典型），本页就误判"没人干活"，于是再次点击 —— 一次
   * 学习流程被点出好几个标签页，互相抢权。
   * 新逻辑：冷却期 60s 内必锁；冷却期过后，只要下游持牌心跳还新鲜就继续锁（不设上限，
   * 因为一门课的视频加起来可能长达数小时）；只有下游标签页真的没了（心跳超时）才允许重试。
   */
  var NAV_LOCK_MS = 60000;   // 新标签页加载宽限：期间无论下游是否已认领都不许重复点击
  var NAV_CLAIM_WAIT_MS = 180000; // 点击后一直没有页面认领（网络慢/弹窗被拦）→ 最多再等 3 分钟才重试
  // 持牌心跳有效期：后台标签页的定时器会被浏览器节流到约 60s/次，因此不能按 2s 轮询算，
  // 必须放宽到 120s，否则"播放页正在放视频"的标签页会被误判为已消失。
  var LICENSE_TTL_MS = 120000;

  function myNavLock() {
    var l = RunState.get().navLock;
    if (!l || l.by !== TAB_ID) return null;
    // 本页已跳到别的页面（SPA 路由/整页跳转），这把锁已无意义
    if (l.path && l.path !== location.pathname) return null;
    return l;
  }
  function navLocked() {
    var l = myNavLock();
    if (!l) return false;
    var age = Date.now() - (l.time || 0);
    if (age < NAV_LOCK_MS) return true; // 刚点过，等新标签页加载
    var rec = Env.get('activeTab', null);
    // 还没有任何页面认领（新标签页仍在加载 / 被浏览器拦截）→ 宁可多等，也别再点开一个
    if (!rec || rec.id === TAB_ID) return age < NAV_CLAIM_WAIT_MS;
    // 下游标签页还活着（持牌心跳新鲜）→ 本页继续挂起，绝不重复点击
    return (Date.now() - (rec.hb || 0)) < LICENSE_TTL_MS;
  }
  function setNavLock(text) {
    RunState.set({ navLock: { by: TAB_ID, time: Date.now(), text: text || '', path: location.pathname } });
  }
  function clearNavLock() {
    if (myNavLock()) RunState.set({ navLock: null });
  }

  // 统一门禁：暂停 / 已交权 / 已点击跳转挂起 / 已被接管 —— 任何点击都不得执行
  function canAct() {
    if (!Config.get('running')) return false;
    if (waitingHandoff()) return false;
    if (navLocked()) return false;
    if (isTakenOver()) return false;
    return true;
  }

  /* ============================================================
   * 4. AntiDetect —— 失焦/切后台暂停对抗（document-start 执行）
   * ==========================================================*/

  var AntiDetect = (function () {
    function apply() {
      // 沙箱世界改写
      try {
        Object.defineProperty(document, 'hidden', { get: function () { return false; }, configurable: true });
        Object.defineProperty(document, 'visibilityState', { get: function () { return 'visible'; }, configurable: true });
      } catch (e) {}
      ['visibilitychange', 'webkitvisibilitychange', 'blur', 'pagehide'].forEach(function (t) {
        window.addEventListener(t, function (e) { e.stopImmediatePropagation(); }, true);
        document.addEventListener(t, function (e) { e.stopImmediatePropagation(); }, true);
      });
      // 主世界注入（页面脚本绑定在主世界，沙箱改写可能不可见）
      try {
        var code = '(function(){try{Object.defineProperty(document,"hidden",{get:function(){return false},configurable:true});'
          + 'Object.defineProperty(document,"visibilityState",{get:function(){return "visible"},configurable:true});}catch(e){}'
          + '["visibilitychange","webkitvisibilitychange","blur"].forEach(function(t){'
          + 'document.addEventListener(t,function(e){e.stopImmediatePropagation()},true);});})();';
        var s = document.createElement('script');
        s.textContent = code;
        (document.head || document.documentElement).appendChild(s);
        s.remove();
      } catch (e) {}
      // hasFocus 伪装
      try {
        var origHasFocus = document.hasFocus.bind(document);
        document.hasFocus = function () { return true; };
      } catch (e) {}
    }
    return { apply: apply };
  })();

  AntiDetect.apply();

  /* ============================================================
   * 5. Router —— SPA 路由感知与页面分类
   * ==========================================================*/

  var Router = (function () {
    var listeners = [];
    var lastUrl = location.href;

    function classify(url) {
      var m = url.match(PLAYER_URL_RE);
      if (m) return { page: 'PLAYER', courseId: m[1], videoId: m[2] };
      // 课程目录页也在 player 子域，单段路径 /learning/{courseId}
      var mc = url.match(/player\.qlteacher\.com\/learning\/([^/?#]+)\/?(?:[?#].*)?$/);
      if (mc) return { page: 'CATALOG', courseId: mc[1], project: null };
      if (LEARN_PATH_RE.test(url)) return { page: 'LEARN', project: url.match(LEARN_PATH_RE)[1] };
      // 项目首页 /project/{代号}/index（或 /project/{代号} 裸路径）
      var ix = url.match(/yxjc\.qlteacher\.com\/project\/([^/]+)\/(index)?\/?(?:[?#].*)?$/);
      if (ix) return { page: 'INDEX', project: ix[1] };
      var c = url.match(CATALOG_URL_RE);
      if (c) return { page: 'CATALOG', project: c[1] };
      if (/passport\.qlteacher\.com/.test(url)) return { page: 'LOGIN' };
      return { page: 'OTHER' };
    }
    function fire() {
      var info = classify(location.href);
      listeners.forEach(function (fn) {
        try { fn(info); } catch (e) {}
      });
    }
    function check() {
      if (location.href !== lastUrl) {
        lastUrl = location.href;
        fire();
      }
    }
    function hookHistory() {
      ['pushState', 'replaceState'].forEach(function (name) {
        var orig = history[name];
        if (typeof orig !== 'function') return;
        history[name] = function () {
          var ret = orig.apply(this, arguments);
          setTimeout(check, 0);
          return ret;
        };
      });
      window.addEventListener('popstate', function () { setTimeout(check, 0); });
      window.addEventListener('hashchange', function () { setTimeout(check, 0); });
      setInterval(check, 1000); // 兜底轮询
    }
    return {
      classify: classify,
      current: function () { return classify(location.href); },
      onChange: function (fn) { listeners.push(fn); },
      start: hookHistory
    };
  })();

  /* ============================================================
   * 6. Panel —— Shadow DOM 浮动控制面板
   * ==========================================================*/

  var Panel = (function () {
    var host = null, shadow = null, els = {};
    var logs = [];
    var MAX_LOG = 50;
    var built = false;
    var examWarn = false;

    var CSS = [
      ':host{all:initial;}',
      '.qlt-panel{position:fixed;top:80px;right:16px;width:300px;z-index:2147483647;',
      'font:12px/1.5 -apple-system,"Segoe UI","Microsoft YaHei",sans-serif;color:#333;',
      'background:#fff;border:1px solid #d9d9d9;border-radius:8px;box-shadow:0 4px 16px rgba(0,0,0,.18);overflow:hidden;}',
      '.qlt-head{display:flex;align-items:center;justify-content:space-between;padding:6px 10px;',
      'background:#1677ff;color:#fff;cursor:move;user-select:none;font-weight:600;}',
      '.qlt-head .qlt-fold{cursor:pointer;padding:0 4px;}',
      '.qlt-body{padding:8px 10px;max-height:420px;overflow-y:auto;}',
      '.qlt-row{margin:4px 0;display:flex;align-items:center;gap:6px;flex-wrap:wrap;}',
      '.qlt-status{font-weight:600;}',
      '.qlt-btn{cursor:pointer;border:1px solid #d9d9d9;background:#fff;border-radius:4px;padding:2px 10px;font-size:12px;}',
      '.qlt-btn.primary{background:#1677ff;border-color:#1677ff;color:#fff;}',
      '.qlt-btn:hover{opacity:.85;}',
      '.qlt-select,.qlt-input{border:1px solid #d9d9d9;border-radius:4px;padding:1px 4px;font-size:12px;width:56px;}',
      '.qlt-log{margin-top:6px;background:#f5f5f5;border-radius:4px;padding:4px 6px;max-height:140px;overflow-y:auto;font-size:11px;}',
      '.qlt-log .warn{color:#d48806;}',
      '.qlt-log .error{color:#cf1322;}',
      '.qlt-log .ok{color:#389e0d;}',
      '.qlt-warnbar{display:none;background:#fffbe6;border-bottom:1px solid #ffe58f;color:#ad6800;',
      'padding:4px 10px;font-weight:600;}',
      '.qlt-warnbar.show{display:block;}',
      '.qlt-stats{color:#888;font-size:11px;}',
      '.qlt-collapsed .qlt-body{display:none;}'
    ].join('\n');

    function el(tag, cls, text) {
      var e = document.createElement(tag);
      if (cls) e.className = cls;
      if (text !== undefined) e.textContent = text;
      return e;
    }

    function build() {
      if (built) return;
      built = true;
      host = document.createElement('div');
      host.id = 'qlt-auto-study-panel';
      shadow = host.attachShadow ? host.attachShadow({ mode: 'open' }) : host;
      var style = document.createElement('style');
      style.textContent = CSS;
      shadow.appendChild(style);

      var panel = el('div', 'qlt-panel');
      var savedPos = Env.get('panelPos', null);
      if (savedPos) {
        panel.style.left = savedPos.x + 'px';
        panel.style.top = savedPos.y + 'px';
        panel.style.right = 'auto';
      }

      var head = el('div', 'qlt-head');
      head.appendChild(el('span', '', '挂机学习助手'));
      var foldBtn = el('span', 'qlt-fold', '—');
      head.appendChild(foldBtn);
      panel.appendChild(head);

      var warnbar = el('div', 'qlt-warnbar', '正在处理考试/测试题：随机作答→读取正确答案→重答');
      panel.appendChild(warnbar);

      var body = el('div', 'qlt-body');

      var rowStatus = el('div', 'qlt-row');
      rowStatus.appendChild(el('span', '', '状态：'));
      var statusEl = el('span', 'qlt-status', '初始化');
      rowStatus.appendChild(statusEl);
      body.appendChild(rowStatus);

      var rowCur = el('div', 'qlt-row');
      rowCur.appendChild(el('span', '', '当前：'));
      var curEl = el('span', '', '-');
      rowCur.appendChild(curEl);
      body.appendChild(rowCur);

      var rowBtn = el('div', 'qlt-row');
      var toggleBtn = el('button', 'qlt-btn primary', '开始');
      var retryBtn = el('button', 'qlt-btn', '重试本页');
      rowBtn.appendChild(toggleBtn);
      rowBtn.appendChild(retryBtn);
      body.appendChild(rowBtn);

      var rowExam = el('div', 'qlt-row');
      rowExam.appendChild(el('span', '', '考试处理'));
      var examSel = document.createElement('select');
      examSel.className = 'qlt-select';
      examSel.style.width = '140px';
      [['smart', '随机→看答案重答'], ['random', '仅随机作答'], ['manual', '人工处理']].forEach(function (kv) {
        var o = document.createElement('option');
        o.value = kv[0]; o.textContent = kv[1];
        examSel.appendChild(o);
      });
      rowExam.appendChild(examSel);
      body.appendChild(rowExam);

      var rowLogLabel = el('div', 'qlt-row');
      rowLogLabel.appendChild(el('span', '', '日志：'));
      body.appendChild(rowLogLabel);
      var logEl = el('div', 'qlt-log');
      body.appendChild(logEl);

      var rowStats = el('div', 'qlt-row qlt-stats');
      body.appendChild(rowStats);

      var rowAbout = el('div', 'qlt-row qlt-stats');
      rowAbout.textContent = '仅供学习交流，请遵守平台规则，后果自负。';
      body.appendChild(rowAbout);

      panel.appendChild(body);
      shadow.appendChild(panel);

      // 事件
      foldBtn.addEventListener('click', function () {
        panel.classList.toggle('qlt-collapsed');
        foldBtn.textContent = panel.classList.contains('qlt-collapsed') ? '+' : '—';
      });
      toggleBtn.addEventListener('click', function () {
        var running = !Config.get('running');
        Config.set('running', running);
        // 用户手动开始时重置"连续未找到"计数，避免上次的完成判定残留；
        // 同时解除本页的点击跳转挂起——用户主动点开始就是明确要这一页干活（若别的页面
        // 仍在持牌，isTakenOver 仍会拦住，不会因此重复开标签页）
        if (running) { RunState.set({ catalogMiss: 0, learnMiss: 0 }); clearNavLock(); }
        refreshButtons();
        log(running ? '用户点击开始' : '用户点击暂停', 'ok');
        if (running) MainLoop.kick();
      });
      retryBtn.addEventListener('click', function () {
        RunState.set({ retryCount: 0, lastHeartbeat: Date.now() });
        log('手动重试，刷新页面', 'warn');
        reloadSelf();
      });
      examSel.addEventListener('change', function () {
        var v = examSel.value;
        Config.set('skipExam', v === 'manual');
        Config.set('examSmart', v === 'smart');
        var desc = {
          smart: '随机作答→读取正确答案→重答，直到通过',
          random: '仅随机作答一次（成绩不保证）',
          manual: '人工处理（遇到考试暂停挂机）'
        };
        log('考试处理方式：' + desc[v], v === 'smart' ? 'ok' : 'warn');
      });

      // 拖拽
      var dragging = false, dx = 0, dy = 0;
      head.addEventListener('mousedown', function (e) {
        if (e.target === foldBtn) return;
        dragging = true;
        var rect = panel.getBoundingClientRect();
        dx = e.clientX - rect.left;
        dy = e.clientY - rect.top;
        e.preventDefault();
      });
      document.addEventListener('mousemove', function (e) {
        if (!dragging) return;
        panel.style.left = (e.clientX - dx) + 'px';
        panel.style.top = (e.clientY - dy) + 'px';
        panel.style.right = 'auto';
      });
      document.addEventListener('mouseup', function () {
        if (!dragging) return;
        dragging = false;
        var rect = panel.getBoundingClientRect();
        Env.set('panelPos', { x: rect.left, y: rect.top });
      });

      els = {
        panel: panel, status: statusEl, cur: curEl,
        toggle: toggleBtn, log: logEl,
        stats: rowStats, warnbar: warnbar, exam: examSel
      };

      function mount() {
        if (document.body && !host.isConnected) document.body.appendChild(host);
      }
      if (document.body) mount();
      else {
        var mo = new MutationObserver(function () {
          if (document.body) { mount(); mo.disconnect(); }
        });
        mo.observe(document.documentElement, { childList: true, subtree: true });
      }
      refreshButtons();
      refreshStats();
    }

    function refreshButtons() {
      if (!els.toggle) return;
      els.toggle.textContent = Config.get('running') ? '暂停' : '开始';
      els.exam.value = Config.get('skipExam') ? 'manual' : (Config.get('examSmart') ? 'smart' : 'random');
    }
    function refreshStats() {
      if (!els.stats) return;
      var s = RunState.get().stats;
      els.stats.textContent = '统计：视频 ' + s.doneVideos + ' | 课程 ' + s.doneCourses + ' | 答题 ' + s.answeredQuizzes;
    }

    function log(msg, level) {
      logs.push({ t: nowTime(), msg: msg, level: level || '' });
      if (logs.length > MAX_LOG) logs.shift();
      if (els.log) {
        var html = logs.map(function (l) {
          var cls = l.level ? ' class="' + l.level + '"' : '';
          return '<div' + cls + '>' + l.t + ' ' +
            String(l.msg).replace(/&/g, '&amp;').replace(/</g, '&lt;') + '</div>';
        }).join('');
        els.log.innerHTML = html;
        els.log.scrollTop = els.log.scrollHeight;
      }
    }

    return {
      init: function () {
        try { build(); } catch (e) { /* document-start 时 DOM 未就绪，延迟重试 */ setTimeout(function () { Panel.init(); }, 500); }
      },
      log: log,
      setStatus: function (s) { if (els.status) els.status.textContent = s; },
      setCurrent: function (s) { if (els.cur) els.cur.textContent = s; },
      refreshButtons: refreshButtons,
      refreshStats: refreshStats,
      setExamWarn: function (on) {
        examWarn = on;
        if (els.warnbar) els.warnbar.classList.toggle('show', on);
      }
    };
  })();

  /* ============================================================
   * 7. QuizEngine —— 随机答题引擎
   * ==========================================================*/

  var QuizEngine = (function () {
    var lastPopupSig = '';
    var examHandled = false;
    var examHandling = false;

    function signatureOf(root) {
      // 用题目文本前 80 字作签名，避免同一弹题重复作答
      return textOf(root).slice(0, 80);
    }

    function answerRadios(root) {
      var radios = qsa(SEL.radio, root);
      if (!radios.length) return 0;
      // 按 name 分组；无 name 时按最近题目容器分组
      var groups = {};
      var hasName = radios.some(function (r) { return r.name; });
      if (hasName) {
        radios.forEach(function (r) {
          var key = r.name || ('solo_' + Math.random());
          (groups[key] = groups[key] || []).push(r);
        });
      } else {
        // 无 name 时按最近题目容器分组（用 Map 以容器元素为键）
        var map = new Map();
        radios.forEach(function (r) {
          var container = r.closest('.mb-16') || r.closest('li') || r.closest('div') || root;
          if (!map.has(container)) map.set(container, []);
          map.get(container).push(r);
        });
        map.forEach(function (g, container) {
          var key = '__c' + Array.prototype.indexOf.call(root.querySelectorAll('*'), container);
          groups[key] = g;
        });
      }
      var n = 0;
      Object.keys(groups).forEach(function (k) {
        var g = groups[k];
        var unchecked = g.filter(function (r) { return !r.checked; });
        var pick = randItem(unchecked.length ? unchecked : g);
        var label = pick.closest('label');
        realClick(label || pick);
        n++;
      });
      return n;
    }

    function answerCheckboxes(root) {
      var checks = qsa(SEL.checkbox, root).filter(function (c) {
        return c.tagName === 'INPUT' || c.querySelector('input');
      });
      if (!checks.length) return 0;
      // 随机勾选 1~N 个（至少 1 个）
      var count = 1 + Math.floor(Math.random() * checks.length);
      var shuffled = checks.slice().sort(function () { return Math.random() - 0.5; });
      var picked = shuffled.slice(0, count);
      picked.forEach(function (c) {
        var input = c.tagName === 'INPUT' ? c : c.querySelector('input');
        if (input && input.checked) return;
        var label = c.closest ? c.closest('label') : null;
        realClick(label || input || c);
      });
      return picked.length;
    }

    function clickConfirm(root) {
      // 先找主按钮，找不到再放宽到所有按钮（提交按钮不一定带 ant-btn-primary 类）
      var btn = clickByText(root, SEL.btnPrimary, SEL.confirmTexts)
        || clickByText(document, SEL.btnPrimary, ['提交', '确认', '确定'])
        || clickByText(root, SEL.anyButton, ['提交', '交卷'])
        || clickByText(document, SEL.anyButton, ['提交', '交卷', '确认提交']);
      if (btn) {
        setTimeout(function () {
          clickByText(document, SEL.btnPrimary, ['确定', '确认', '继续'])
            || clickByText(document, SEL.anyButton, ['确定', '确认']);
        }, 800);
        return true;
      }
      return false;
    }

    function bumpStat() {
      var s = RunState.get();
      s.stats.answeredQuizzes++;
      RunState.set({ stats: s.stats });
      Panel.refreshStats();
    }

    // 有效题目容器识别（多策略，避免 .mb-16.ng-star-inserted 单一类名失效）
    var INPUT_SEL = ['input[type="radio"]', 'input[type="checkbox"]'];

    function visibleInputs(root) {
      return qsa(INPUT_SEL, root).filter(function (inp) {
        var r = inp.getBoundingClientRect();
        return r.width > 0 && r.height > 0;
      });
    }

    // 若干节点的最小公共祖先
    function commonAncestor(nodes) {
      var cur = nodes[0];
      while (cur && cur !== document.body) {
        var ok = true;
        for (var i = 0; i < nodes.length; i++) {
          if (cur !== nodes[i] && !cur.contains(nodes[i])) { ok = false; break; }
        }
        if (ok) return cur;
        cur = cur.parentElement;
      }
      return document.body;
    }

    function quizItems() {
      // 策略1：候选容器类 → 含 ≥2 个选项 input，且只保留最小容器（剔除嵌套父容器）
      var candidates = qsa(SEL.quizContainer);
      var items = candidates.filter(function (c) {
        return qsa(INPUT_SEL, c).length >= 2;
      });
      items = items.filter(function (c) {
        return !items.some(function (o) { return o !== c && c.contains(o); });
      });
      // 策略1 的容器可能一次装多题（如 question-list）：按单选 name 组再拆分
      if (items.length) {
        var refined = [];
        items.forEach(function (c) {
          var ins = qsa(INPUT_SEL, c);
          var byName = {};
          ins.forEach(function (inp) {
            if (inp.type === 'radio' && inp.name) (byName[inp.name] = byName[inp.name] || []).push(inp);
          });
          var nameKeys = Object.keys(byName);
          if (nameKeys.length > 1) {
            nameKeys.forEach(function (k) {
              if (byName[k].length >= 2) {
                var anc = commonAncestor(byName[k]);
                if (refined.indexOf(anc) < 0) refined.push(anc);
              }
            });
          } else if (refined.indexOf(c) < 0) {
            refined.push(c);
          }
        });
        if (refined.length) return refined;
      }
      // 策略2：按 input 分组兜底——单选按 name 分组；无 name 时按最近条目容器分组
      var inputs = visibleInputs(document);
      if (!inputs.length) return [];
      var ancKeys = [];
      var groups = {};
      inputs.forEach(function (inp) {
        var key = inp.name || '';
        if (!key) {
          var anc = inp.closest('li') || inp.closest('[class*="question"]')
            || inp.closest('.mb-16') || inp.parentElement;
          var idx = ancKeys.indexOf(anc);
          if (idx < 0) { ancKeys.push(anc); idx = ancKeys.length - 1; }
          key = '__anc_' + idx;
        }
        (groups[key] = groups[key] || []).push(inp);
      });
      var out = [];
      Object.keys(groups).forEach(function (k) {
        var g = groups[k];
        if (g.length >= 2) {
          var anc = commonAncestor(g);
          if (out.indexOf(anc) < 0) out.push(anc);
        }
      });
      return out;
    }

    // 答题入口按钮（开始答题/进入考试 等）
    function findEntryButton() {
      var btns = qsa(SEL.anyButton);
      for (var i = 0; i < btns.length; i++) {
        var r = btns[i].getBoundingClientRect();
        if (r.width <= 0 || r.height <= 0) continue;
        var t = textOf(btns[i]);
        for (var j = 0; j < SEL.entryTexts.length; j++) {
          if (t.indexOf(SEL.entryTexts[j]) >= 0) return btns[i];
        }
      }
      return null;
    }

    // 单个题目随机作答
    function randomAnswerItem(item) {
      var radios = qsa(SEL.radio, item);
      var checks = qsa(SEL.checkbox, item);
      if (radios.length) {
        var pick = randItem(radios);
        realClick(pick.closest('label') || pick);
        return true;
      }
      if (checks.length) {
        var c = randItem(checks);
        var input = c.tagName === 'INPUT' ? c : c.querySelector('input');
        realClick(c.closest('label') || input || c);
        return true;
      }
      var labels = qsa(['label'], item);
      if (labels.length) { realClick(labels[0]); return true; }
      return false;
    }

    /* ---------- 正确答案提取 ----------
     * 平台实际展示格式（已由用户截图确认）：
     *   单选题：【正确答案】：B
     *   多选题：【正确答案】：A,B,D,E
     *   下一行是【答案解析】：……（中文，可用来截断取值）
     * 旧正则要求"正确答案"后紧跟冒号，遇到"】"就失配 → 提取失败，只能随机答一轮。
     */

    // 解析一段文本里"正确答案"后的选项字母 → 序号数组（A=0,B=1...），无则 null
    function parseAnswerLetters(text) {
      if (!text) return null;
      var i = text.indexOf('正确答案');
      if (i < 0) return null;
      // 取"正确答案"之后片段，先剥掉 】 ] ： : 空格 等分隔符
      var tail = text.slice(i + 4, i + 4 + 80).replace(/^[\]】:：\s\-—=]*/, '');
      // 只认连续的字母序列（支持 B / ABC / A,B,D,E / A、B）
      var m = tail.match(/^([A-Ha-h](?:\s*[,，、\/]?\s*[A-Ha-h])*)/);
      if (!m) return null;
      var letters = m[1].toUpperCase().replace(/[^A-H]/g, '');
      if (!letters) return null;
      var idxs = [];
      for (var j = 0; j < letters.length; j++) {
        var idx = letters.charCodeAt(j) - 65;
        if (idxs.indexOf(idx) < 0) idxs.push(idx);
      }
      return idxs.length ? idxs : null;
    }

    // 题目指纹：题干前 40 字（去掉答案/解析部分），用于跨轮次、跨刷新复用已学到的答案
    function questionKey(item) {
      var t = textOf(item).replace(/\s+/g, '');
      var i = t.indexOf('正确答案');
      if (i > 0) t = t.slice(0, i);
      return t.slice(0, 40);
    }

    var answerCache = Env.get('answerCache', null) || {};
    function saveAnswerCache(key, idxs) {
      if (!key || !idxs || !idxs.length) return;
      var same = answerCache[key];
      if (same && same.join(',') === idxs.join(',')) return;
      answerCache[key] = idxs;
      // 控制缓存体积（保留最近 800 条）
      var keys = Object.keys(answerCache);
      if (keys.length > 800) {
        keys.slice(0, keys.length - 800).forEach(function (k) { delete answerCache[k]; });
      }
      Env.set('answerCache', answerCache);
    }

    // 选项 input 列表（按文档顺序，序号与 A/B/C/D 对应）
    function optionInputs(item) {
      return qsa(INPUT_SEL, item);
    }

    // 从单个题目容器里提取答案：文本 > 类名高亮 > 绿色文字
    function extractCorrectAnswers(item) {
      var idxs = parseAnswerLetters(textOf(item));
      if (idxs) return idxs;
      var opts = optionInputs(item);
      if (opts.length < 2) opts = qsa(['label', '.ant-radio-wrapper', '.ant-checkbox-wrapper'], item);
      if (!opts.length) return null;
      // 正确选项的高亮类名（correct/right/dui/success 等）
      var marked = [];
      opts.forEach(function (o, i) {
        var cls = String(o.className || '');
        var inner = o.querySelector('*');
        if (inner) cls += ' ' + String(inner.className || '');
        if (/correct|right|success|dui|green|is-right|answer-right/i.test(cls)) marked.push(i);
      });
      if (marked.length) return marked;
      // 正确选项的绿色文字样式
      var green = [];
      opts.forEach(function (o, i) {
        try {
          var c = (getComputedStyle(o).color.match(/\d+/g) || []).map(Number);
          if (c.length >= 3 && c[1] > c[0] + 30 && c[1] > 120) green.push(i);
        } catch (e) {}
      });
      return green.length ? green : null;
    }

    // 整页按文档顺序收集"正确答案：X"序列（答案块渲染在题目容器之外时的兜底）
    function globalAnswerList() {
      var t = textOf(document.body);
      var out = [];
      var pos = 0;
      while (pos < t.length) {
        var i = t.indexOf('正确答案', pos);
        if (i < 0) break;
        var seg = parseAnswerLetters(t.slice(i, i + 100));
        if (seg) out.push(seg);
        pos = i + 4;
      }
      return out;
    }

    // 答案序号是否适配当前题目（选项数量可能变化，缓存要防错位）
    function fitsItem(item, idxs) {
      var n = optionInputs(item).length;
      if (!n || !idxs || !idxs.length) return false;
      return idxs.every(function (i) { return i >= 0 && i < n; });
    }

    // 为一组题目构建答案数组（按题目顺序对齐）；同时写入缓存
    function buildAnswerSets(items) {
      var globals = null;
      return items.map(function (item, i) {
        var idxs = extractCorrectAnswers(item);
        if (!idxs) {
          if (!globals) globals = globalAnswerList();
          // 只有"答案块数量与题目数量完全一致"时才按顺序对齐，避免张冠李戴
          if (globals.length === items.length) idxs = globals[i];
          else if (items.length === 1 && globals.length >= 1) idxs = globals[0];
        }
        if (!idxs) {
          var cached = answerCache[questionKey(item)];
          if (cached && fitsItem(item, cached)) idxs = cached;
        }
        if (idxs && fitsItem(item, idxs)) saveAnswerCache(questionKey(item), idxs);
        return idxs;
      });
    }

    // 选项是否被冻结（交卷后禁用，需要先"重新作答"）
    function anyDisabled(items) {
      return items.some(function (item) {
        return optionInputs(item).some(function (inp) { return inp.disabled; });
      });
    }

    // 校验某题的勾选状态是否与答案一致
    function verifyItem(item, indexes) {
      var ins = optionInputs(item);
      if (!ins.length) return true;
      return ins.every(function (inp, i) {
        return (indexes.indexOf(i) >= 0) === !!inp.checked;
      });
    }

    // 按正确答案序号作答：序号对齐"选项 input 的文档顺序"（A=0,B=1...）
    // 单选只点目标项；多选把每项勾选状态调成与答案一致
    function applyAnswers(item, indexes) {
      var inputs = optionInputs(item);
      if (!inputs.length) return false;
      var isMulti = inputs.some(function (inp) { return (inp.type || '').toLowerCase() === 'checkbox'; });
      var touched = 0;
      for (var i = 0; i < inputs.length; i++) {
        var input = inputs[i];
        var want = indexes.indexOf(i) >= 0;
        if (!isMulti && !want) continue;             // 单选：非目标项不动
        if (want === !!input.checked) { touched++; continue; }
        if (input.disabled) continue;                // 冻结态交给"重新作答"
        var target = input.closest('label') || input.closest('.ant-radio-wrapper')
          || input.closest('.ant-checkbox-wrapper') || input.parentElement || input;
        realClick(target);
        touched++;
      }
      return touched > 0;
    }

    return {
      // 每 tick 调用：处理视频中弹题（返回是否处理过）
      tryHandlePopup: function () {
        var radios = qsa(SEL.radio);
        var checks = qsa(SEL.checkbox).filter(function (c) { return c.tagName === 'INPUT'; });
        if (!radios.length && !checks.length) return false;
        // 找弹题容器（含选项且可见的最近祖先弹层）
        var any = radios[0] || checks[0];
        var popup = any.closest('.ant-modal') || any.closest('.ant-popover')
          || any.closest('[class*="modal"]') || any.closest('[class*="dialog"]')
          || any.closest('[class*="quiz"]') || document.body;
        var sig = signatureOf(popup);
        if (sig === lastPopupSig) return true; // 已作答过，等待关闭
        var n = answerRadios(popup) + answerCheckboxes(popup);
        if (n > 0 && clickConfirm(popup)) {
          lastPopupSig = sig;
          bumpStat();
          Panel.log('检测到弹题，已随机作答并提交', 'ok');
        }
        return true;
      },

      // 是否纯测试题/考试页（严格判定，避免把普通视频页误判成答题页）
      isExamPage: function () {
        // 提交按钮：放宽到所有可见按钮，文本含"提交/交卷"即可（不再限定 ant-btn-primary 样式类）
        var hasSubmit = qsa(SEL.anyButton).some(function (b) {
          var r = b.getBoundingClientRect();
          return r.width > 0 && r.height > 0 && /提交|交卷/.test(textOf(b));
        });
        if (!hasSubmit) return false;
        if (!quizItems().length) return false;
        // 有明确"测试题/考试"标签（标签容器 / 页面标题 / 标题元素）→ 认定
        var tag = qs(SEL.courseTag);
        if (tag && /测试题|考试|测验|练习/.test(textOf(tag))) return true;
        if (/测试题|考试|测验/.test(document.title || '')) return true;
        var heads = qsa(['h1', 'h2', 'h3', '[class*="title"]']);
        for (var i = 0; i < heads.length; i++) {
          var ht = textOf(heads[i]);
          if (ht.length <= 30 && /测试题|考试|测验/.test(ht)) return true;
        }
        // 无标签时：页面没有可播放视频才认定（视频页的弹题不会走这里）
        var video = qs(SEL.video);
        if (!video) return true;
        return !isVideoPlayable(video);
      },

      // 页面是否出现答题信号（已渲染题目 或 存在答题入口按钮）
      hasQuizSignal: function () {
        return quizItems().length > 0 || !!findEntryButton();
      },

      // 整页考试/测试题作答：随机 → （可选）读正确答案重答 → 循环直到通过
      handleExamPage: async function () {
        if (examHandled || examHandling) return;
        if (Config.get('skipExam')) {
          Panel.log('检测到考试页，skipExam=true，暂停等待人工处理', 'error');
          Config.set('running', false);
          Panel.refreshButtons();
          Panel.setStatus('考试页待人工');
          return;
        }
        examHandling = true;
        Panel.setExamWarn(true);
        try {
          // 重新拉取一次答案缓存（其他标签页可能已积累新答案）
          answerCache = Env.get('answerCache', answerCache) || answerCache;
          // 先点"开始答题/进入考试"类入口按钮（若有），等待题目渲染（800ms 步长早走，上限 ~8s）
          for (var w = 0; w < 10 && !quizItems().length; w++) {
            var entry = findEntryButton();
            if (entry) {
              Panel.log('点击答题入口：' + textOf(entry));
              realClick(entry);
            }
            await sleep(800);
          }
          var smart = Config.get('examSmart');
          var maxRounds = smart ? 5 : 1;
          for (var round = 1; round <= maxRounds; round++) {
            var items = quizItems();
            if (!items.length) {
              var inputCount = qsa(INPUT_SEL).length;
              Panel.log('未找到题目（页面含选项 input ' + inputCount + ' 个），退出作答流程', 'error');
              break;
            }
            var pending = 0;
            if (round === 1) {
              // 第 1 轮：能命中历史答案的按答案答，其余随机
              var answered = 0, cached = 0;
              items.forEach(function (item) {
                var key = questionKey(item);
                var old = answerCache[key];
                if (old && fitsItem(item, old) && applyAnswers(item, old)) { cached++; answered++; }
                else if (randomAnswerItem(item)) answered++;
                else pending++;
              });
              Panel.log('第 1 轮：作答 ' + answered + ' 题（其中历史答案 ' + cached + ' 题），准备提交', 'warn');
            } else {
              // 第 2+ 轮：答案区可能需点"查看答案/解析"才展开
              if (!globalAnswerList().length) {
                clickByText(document, SEL.anyButton, SEL.answerTexts);
                await sleep(800);
              }
              var curItems = quizItems();
              var sets = buildAnswerSets(curItems);
              var known = sets.filter(function (s) { return s && s.length; }).length;
              // 一条答案都没读到：答案开关可能挂在每题上（逐题"查看答案/解析"）
              if (!known) {
                var toggles = 0;
                curItems.forEach(function (it) {
                  if (clickByText(it, ['a', 'button', 'span'], SEL.answerTexts)) toggles++;
                });
                if (toggles) {
                  Panel.log('逐题展开答案解析（' + toggles + ' 处）');
                  await sleep(800);
                  sets = buildAnswerSets(curItems);
                  known = sets.filter(function (s) { return s && s.length; }).length;
                }
              }
              if (!known) {
                Panel.log('未能从页面提取到正确答案（未找到"【正确答案】：X"文本），停止重答', 'error');
                break;
              }
              // 交卷后选项常被冻结 → 点"重新作答"解冻
              if (anyDisabled(curItems)) {
                var re1 = clickByText(document, SEL.anyButton, SEL.redoTexts);
                if (re1) {
                  Panel.log('选项已冻结，点击"' + textOf(re1) + '"重新作答');
                  await sleep(800);
                  // 可能弹出"确定重新作答？"确认框
                  clickByText(document, SEL.anyButton, ['确定', '确认', '是']);
                  await sleep(1000);
                  curItems = quizItems();
                } else {
                  Panel.log('选项已冻结且找不到"重新作答"按钮，停止重答', 'error');
                  break;
                }
              }
              // 按答案作答（sets 按题目顺序对齐）
              var fixed = 0;
              curItems.forEach(function (item, i) {
                var idxs = sets[i];
                if (idxs && idxs.length && applyAnswers(item, idxs)) fixed++;
              });
              await sleep(300);
              // 校验一轮：状态不符的再补点一次（Angular 变更检测可能吞掉首次点击）
              var mismatch = 0;
              curItems.forEach(function (item, i) {
                var idxs = sets[i];
                if (!idxs || !idxs.length) return;
                if (!verifyItem(item, idxs)) { applyAnswers(item, idxs); mismatch++; }
              });
              if (mismatch) {
                await sleep(400);
                var stillBad = 0;
                curItems.forEach(function (item, i) {
                  var idxs = sets[i];
                  if (idxs && idxs.length && !verifyItem(item, idxs)) stillBad++;
                });
                if (stillBad) Panel.log('有 ' + stillBad + ' 题勾选状态未能修正（可能是冻结或多选题交互特殊）', 'warn');
              }
              pending = curItems.length - fixed;
              Panel.log('第 ' + round + ' 轮：按正确答案重答 ' + fixed + '/' + curItems.length + ' 题'
                + (known < curItems.length ? '（' + (curItems.length - known) + ' 题未识别答案）' : ''), 'ok');
            }
            await sleep(500);
            if (!clickConfirm(document)) {
              Panel.log('未找到提交按钮，退出作答流程', 'error');
              break;
            }
            bumpStat();
            // 提交结果：题目消失或出现通过文案即视为出结果，最多等 2.5s（300ms 步长早走）
            await waitFor(function () {
              return !quizItems().length
                || /考试通过|成绩合格|恭喜.{0,10}通过|已通过|答题完成|练习完成|本次测试完成|全部答对/.test(textOf(document.body));
            }, 2500, 300);
            // 通过判定（严格）：题目消失 或 明确的通过文案。
            // 注意两个历史教训：①提交按钮不能只扫 ant-btn-primary（样式类可能不同）；②不能扫全页"已完成"（侧栏常驻该字样会误判）
            var leftItems = quizItems();
            var passText = /考试通过|成绩合格|恭喜.{0,10}通过|已通过|答题完成|练习完成|本次测试完成|全部答对/.test(textOf(document.body));
            // 补充判定：所有已知答案的题都已勾选正确 → 视为通过（有些页面不显示"通过"文案）
            var allCorrect = false;
            if (!passText && leftItems.length) {
              var verifySets = buildAnswerSets(leftItems);
              var withAns = 0, rightCnt = 0;
              leftItems.forEach(function (it, i) {
                var a = verifySets[i];
                if (a && a.length) { withAns++; if (verifyItem(it, a)) rightCnt++; }
              });
              allCorrect = withAns > 0 && rightCnt === withAns && withAns === leftItems.length;
              if (allCorrect) Panel.log('全部 ' + withAns + ' 题与正确答案一致', 'ok');
            }
            if (!leftItems.length || passText || allCorrect) {
              Panel.log('考试/测试题已通过（共 ' + round + ' 轮）', 'ok');
              break;
            }
            if (!smart) {
              Panel.log('仅随机作答模式：已提交，不再重答', 'warn');
              break;
            }
            Panel.log('本轮已提交（' + pending + ' 题未按答案填写），进入第 ' + (round + 1) + ' 轮');
          }
          examHandled = true;
        } finally {
          examHandling = false;
        }
      },

      resetExamFlag: function () { examHandled = false; Panel.setExamWarn(false); },
      resetPopupSig: function () { lastPopupSig = ''; }
    };
  })();

  /* ============================================================
   * 8. PlayerCtl —— 播放页控制器（真实播放：静音原速+暂停恢复）
   * ==========================================================*/

  var PlayerCtl = (function () {
    var studying = false;

    // 完成检测：只看本视频自己的倒计时元素与 video.ended
    // 注意：不能扫描全页"已完成学习"按钮——播放页侧栏列着已学完的其他章节，会导致误判
    function isVideoDone() {
      var video = qs(SEL.video);
      if (video && video.ended) return true;
      var cd = qs(SEL.countdown);
      if (cd) {
        var t = textOf(cd);
        if (/已完成/.test(t)) {
          // 双保险：视频才播了一小半时不采信"已完成"（可能是上一节残留的页面状态）
          try {
            if (video && video.duration > 0 && video.currentTime < video.duration * 0.5) return false;
          } catch (e) {}
          return true;
        }
        // 倒计时归零：形如 00:00 或 0秒
        if (/^0{1,2}[:：]0{2}([:：]0{2})?$/.test(t) || /^0\s*秒/.test(t)) return true;
      }
      return false;
    }

    async function safeModeStudy(video) {
      Panel.setStatus('播放中');
      try { video.muted = true; } catch (e) {}
      try { await video.play(); } catch (e) {
        // 自动播放策略拦截：模拟点击页面播放按钮
        var btn = qs(['.vjs-big-play-button', '[class*="play"]'], document);
        if (btn) realClick(btn);
      }
      Panel.log('开始播放（原速）');

      var stuckCount = 0;
      var enterAt = Date.now();
      while (Config.get('running')) {
        await sleep(Config.get('pollMs'));
        // 空 video 标签（无片源）且出现答题信号 → 实为测试题页，转答题流程
        if (video.networkState === 3 && QuizEngine.hasQuizSignal()) {
          Panel.log('检测到本页实为测试题（视频无片源），转作答流程', 'warn');
          return 'quiz';
        }
        // 进页面 8 秒内不采信倒计时状态（页面数据可能仍是上一节的）
        if (Date.now() - enterAt > 8000 && isVideoDone()) {
          Panel.log('检测到本视频已完成', 'ok');
          return true;
        }
        QuizEngine.tryHandlePopup();
        // 暂停自动恢复
        if (video.paused && Config.get('running')) {
          stuckCount++;
          if (stuckCount >= 2) {
            Panel.log('视频处于暂停，尝试恢复播放');
            video.play().catch(function () {});
            stuckCount = 0;
          }
        } else {
          stuckCount = 0;
          RunState.set({ lastHeartbeat: Date.now() });
        }
      }
      return false;
    }

    return {
      // 返回 true=完成，false=中止
      study: async function (courseId, videoId) {
        if (studying) return false;
        studying = true;
        QuizEngine.resetPopupSig();
        try {
          // 等待页面内容出现（800ms 步长早走，上限 ~12s）：可播放视频 或 答题信号（题目/答题入口按钮）
          var video = null, quizSignal = false;
          for (var i = 0; i < 15; i++) {
            video = qs(SEL.video);
            quizSignal = QuizEngine.hasQuizSignal();
            if (quizSignal && !(video && isVideoPlayable(video))) break; // 答题页（无真实视频）
            if (video && (isVideoPlayable(video) || i >= 4)) break;      // 有视频标签先按视频处理
            await sleep(800);
          }
          // 有答题信号且没有可播放视频 → 测试题/考试页
          if (quizSignal && !(video && isVideoPlayable(video))) {
            Panel.setCurrent('课程 ' + courseId + ' / 测试题 ' + videoId);
            Panel.log('识别为测试题/考试页，进入作答流程');
            await QuizEngine.handleExamPage();
            await sleep(1000);
            return true;
          }
          // 有视频 → 一律按视频学习处理（弹题在播放循环内处理）
          if (video) {
            Panel.setCurrent('课程 ' + courseId + ' / 视频 ' + videoId);
            var ok = await safeModeStudy(video);
            if (ok === 'quiz') {
              // 播放中发现实为答题页（空 video 标签 + 答题信号）
              Panel.setCurrent('课程 ' + courseId + ' / 测试题 ' + videoId);
              await QuizEngine.handleExamPage();
              await sleep(1000);
              return true;
            }
            return ok === true;
          }
          Panel.log('未找到视频元素，也非答题页，返回目录', 'warn');
          return false;
        } finally {
          studying = false;
        }
      },
      isStudying: function () { return studying; }
    };
  })();

  /* ============================================================
   * 9. CatalogCtl —— 目录页 / learn 页控制器
   * ==========================================================*/

  var CatalogCtl = (function () {

    // 按钮所在的行/条目容器（用于判断该章节是否已完成）
    function rowOf(el) {
      return el.closest('tr') || el.closest('li') || el.closest('.ant-list-item')
        || el.closest('[class*="chapter"]') || el.closest('[class*="lesson"]')
        || el.closest('[class*="item"]') || el.parentElement;
    }
    function isDoneRow(row) {
      return row && /已完成|100%/.test(textOf(row));
    }
    function isVisible(b) {
      var r = b.getBoundingClientRect();
      return r.width > 0 && r.height > 0;
    }

    /* ---------- 课程整体进度是否 100%（"本课程学完了"的显式判定）----------
     * 逻辑顺序：还有"继续学习/开始学习"按钮 → 未完成；否则看进度证据：
     *   ① 进度文案 100%（.ant-progress-text / [class*=percent] 等）
     *   ② 进度条满格（ant-progress-bg 的 style.width 或宽度≈父容器，或 transform scaleX(1)）
     *   ③ 章节条目全部带"已完成/100%"
     * 任一成立即认定 100%。刻意保守：只有拿不到任何证据时才返回 null，
     * 交给上层"连续未找到次数"的兜底流程（宁慢勿错）。
     */
    function progressPercent() {
      var els = qsa(SEL.progressText);
      for (var i = 0; i < els.length; i++) {
        var t = textOf(els[i]).replace(/\s/g, '');
        var m = t.match(/(\d{1,3})\s*%/);
        if (m) {
          var n = parseInt(m[1], 10);
          if (!isNaN(n)) return n;
        }
      }
      return null;
    }
    function progressBarFull() {
      var bars = qsa(SEL.progressBar);
      for (var i = 0; i < bars.length; i++) {
        var b = bars[i];
        var inlineW = String((b.style && b.style.width) || '');
        if (inlineW === '100%') return true;
        var scaleOne = false;
        try {
          var tr = getComputedStyle(b).transform || '';
          scaleOne = /^matrix\(1,\s*0,\s*0,\s*1,/.test(tr);
        } catch (e) {}
        if (scaleOne) return true;
        try {
          var pw = b.parentElement ? b.parentElement.getBoundingClientRect().width : 0;
          var bw = b.getBoundingClientRect().width;
          if (pw > 20 && bw >= pw - 2) return true;
        } catch (e) {}
      }
      return false;
    }
    function allChapterDone() {
      var items = qsa(SEL.chapterItem).filter(isVisible);
      if (items.length < 2) return false;
      for (var i = 0; i < items.length; i++) {
        if (!/已完成|100%/.test(textOf(items[i]))) return false;
      }
      return true;
    }
    // 返回认定依据字符串（用于日志）或 null
    function finishEvidence() {
      if (findNextChapter()) return null;     // 还能点"继续学习/开始学习" → 没学完
      var p = progressPercent();
      if (p !== null && p >= 100) return '进度文案 ' + p + '%';
      if (progressBarFull()) return '进度条已满';
      if (allChapterDone()) return '全部章节已完成';
      return null;                            // 拿不到证据 → 交给上层"连续未找到"兜底
    }

    // 点击跳转锁已提升为全局（见第 3 节 navLocked/setNavLock）：
    // 点击"继续学习/开始学习"会打开新标签页，点击后本页进入长挂起，
    // 只要下游标签页还在干活就绝不再点（否则一次开出多个标签页）

    // "我的课程"标签页：目录页默认可能停在其他 tab，需先切到"我的课程"再等列表加载
    var lastTabClick = 0;
    function findMyCourseTab() {
      var cands = qsa(['.ant-tabs-tab', '[class*="tab"]', 'button', 'a', 'li', 'span']);
      for (var i = 0; i < cands.length; i++) {
        // 精确匹配文本（容器内只有"我的课程"四个字，点击它事件会冒泡到 tab）
        if (textOf(cands[i]) === '我的课程' && isVisible(cands[i])) return cands[i];
      }
      return null;
    }
    // 返回 true=已在"我的课程"页可继续找按钮；false=刚点击切换，需等待列表加载
    function ensureMyCourseTab() {
      if (!canAct()) return false; // 暂停/被接管时连标签页切换也不做
      var tab = findMyCourseTab();
      if (!tab) return true; // 页面结构没有该标签 → 直接进入找按钮流程
      // 激活态判断：自身或最近的 tab 容器带 active/selected 类
      var host = tab.closest('.ant-tabs-tab') || tab.closest('[class*="tab"]') || tab;
      if (/active|selected|current/i.test(String(host.className || ''))) return true;
      if (Date.now() - lastTabClick < 3000) return false; // 刚点过，等待加载
      lastTabClick = Date.now();
      Panel.log('点击"我的课程"标签，等待课程列表加载');
      realClick(tab);
      return false;
    }

    function findNextChapter() {
      var btns = qsa(SEL.anyButton).filter(isVisible);
      var texts = SEL.startTexts; // 只用 继续学习/开始学习；"温故知新"属已完成章节，不参与自动流转
      var matched = btns.filter(function (b) {
        var t = textOf(b);
        return texts.some(function (x) { return t.indexOf(x) >= 0; });
      });
      if (!matched.length) return null;
      // 优先：所在行未标记"已完成/100%"的按钮（逐章按钮场景）
      var notDone = matched.filter(function (b) { return !isDoneRow(rowOf(b)); });
      // 回退：过滤后为空说明"继续学习"是课程级唯一入口（服务端按进度路由到下一未完成章节），直接点第一个
      return notDone[0] || matched[0];
    }

    // 刚学完的课程（15 分钟内）：学习页若因缓存仍把它显示为"继续学习"，必须跳过它，
    // 否则点进去 → 目录页 100% → 回退学习页 → 又点它，来回空转
    function recentlyFinished() {
      var m = Env.get('lastFinishedCourse', null);
      if (!m || !m.courseId) return null;
      return (Date.now() - (m.at || 0) < 15 * 60000) ? m : null;
    }
    // 按钮所在行是否指向指定课程（只按行内链接的 courseId 比对，命中不到就当作"不是它"）
    function rowPointsTo(el, courseId) {
      var row = rowOf(el);
      if (!row) return false;
      try {
        if (String(row.getAttribute && row.getAttribute('data-id') || '').indexOf(courseId) >= 0) return true;
        if (row.querySelectorAll) {
          var links = row.querySelectorAll('a[href]');
          for (var i = 0; i < links.length; i++) {
            if (String(links[i].getAttribute('href') || '').indexOf(courseId) >= 0) return true;
          }
        }
      } catch (e) {}
      return false;
    }

    function findNextCourse() {
      // learn 页：找课程卡片中未完成的
      var btns = qsa(SEL.anyButton).filter(isVisible);
      var target = null;
      var texts = ['继续学习', '开始学习', '去学习', '进入学习'];
      texts.forEach(function (t) {
        if (target) return;
        target = btns.find(function (b) {
          return textOf(b).indexOf(t) >= 0 && !isDoneRow(rowOf(b));
        }) || null;
      });
      if (!target) return null;
      // 命中"刚学完的课程"→ 让给别的课程；若全都指向它，本轮不点（交给上层走"未找到"流程）
      var fin = recentlyFinished();
      if (fin && rowPointsTo(target, fin.courseId)) {
        var others = btns.filter(function (b) {
          return texts.some(function (t) { return textOf(b).indexOf(t) >= 0; })
            && !isDoneRow(rowOf(b)) && !rowPointsTo(b, fin.courseId);
        });
        if (others.length) {
          Panel.log('跳过刚学完的课程（' + fin.courseId + '），改选下一门', 'warn');
          return others[0];
        }
        Panel.log('列表里只剩刚学完的课程（' + fin.courseId + '），本轮不点，等待列表刷新', 'warn');
        return null;
      }
      return target;
    }

    function nodeKey(route) {
      return route.page + ':' + (route.courseId || route.project || '') + ':' + (route.videoId || '');
    }

    return {
      // 在目录页找下一章节并点击；返回 'found' | 'waiting' | 'none'
      gotoNextChapter: function () {
        if (!canAct()) return 'halt';        // 暂停/已交权/被接管 → 一律不点击
        if (navLocked()) return 'waiting';   // 已点击过，等待新标签页加载
        var btn = findNextChapter();
        if (btn) {
          Panel.log('目录页点击：' + textOf(btn) + '（等待新标签页加载，不再重复点击）');
          realClick(btn);
          setNavLock(textOf(btn));
          setHandoff(['PLAYER', 'CATALOG']);  // 主动交权：只有播放页/目录页可接手
          return 'found';
        }
        // 兜底：检查是否整页都是"测试题"类型
        if (QuizEngine.isExamPage()) {
          QuizEngine.handleExamPage();
          return 'found';
        }
        return 'none';
      },
      // 在 learn 页找下一门课程并点击；返回 'found' | 'waiting' | 'halt' | 'none'
      gotoNextCourse: function () {
        if (!canAct()) return 'halt';
        if (navLocked()) return 'waiting';
        var btn = findNextCourse();
        if (btn) {
          Panel.log('learn 页进入课程：' + textOf(btn) + '（等待新标签页加载，不再重复点击）');
          realClick(btn);
          setNavLock(textOf(btn));
          setHandoff(['PLAYER', 'CATALOG']);
          return 'found';
        }
        return 'none';
      },
      // 项目首页(index)：点击"学习课程"等入口按钮；返回 'found' | 'waiting' | 'halt' | 'none'
      gotoIndexEntry: function () {
        if (!canAct()) return 'halt';
        if (navLocked()) return 'waiting';
        var btns = qsa(SEL.anyButton).filter(isVisible);
        var texts = ['学习课程', '进入学习', '开始学习', '继续学习', '去学习', '进入课程'];
        var btn = null;
        texts.forEach(function (t) {
          if (btn) return;
          btn = btns.find(function (b) { return textOf(b).indexOf(t) >= 0; }) || null;
        });
        if (btn) {
          Panel.log('index 页点击入口：' + textOf(btn) + '（等待新标签页加载，不再重复点击）');
          realClick(btn);
          setNavLock(textOf(btn));
          setHandoff(['LEARN', 'PLAYER', 'CATALOG']);
          return 'found';
        }
        return 'none';
      },
      nodeKey: nodeKey,
      ensureMyCourseTab: ensureMyCourseTab,
      // 课程整体进度 100% 的认定依据（null=没学完/无证据）
      finishEvidence: finishEvidence,
      progressPercent: progressPercent,
      recentlyFinished: recentlyFinished
    };
  })();

  /* ============================================================
   * 10. MainLoop —— 状态机 + 看门狗
   * ==========================================================*/

  var MainLoop = (function () {
    var busy = false;
    var eventQueue = [];
    var watchdogTimer = null;

    function setStatus(s) { Panel.setStatus(s); }

    function acquireLock() {
      var s = RunState.get();
      var expired = !s.lockTime || (Date.now() - s.lockTime > 60000);
      if (!s.lockOwner || s.lockOwner === TAB_ID || expired) {
        RunState.set({ lockOwner: TAB_ID, lockTime: Date.now() });
        return true;
      }
      return false;
    }

    // 离开播放页的统一出口：先回退到目录页；新标签页无历史时直接跳目录页（拿不到课程编码才跳 learn 页）
    async function leavePlayer() {
      // 同标签页内跳转会让脚本重新加载（TAB_ID 换新）。先交权给"下一张脸"，
      // 否则新实例要等旧持牌记录 120s 过期才能认领，每换一章都要空等两分钟
      setHandoff(['CATALOG', 'LEARN']);
      history.back();
      // URL 一变立刻走，不等满 4s（正常 0.3~1s 就离开了）
      await waitFor(function () { return !PLAYER_URL_RE.test(location.href); }, 4000, 250);
      if (PLAYER_URL_RE.test(location.href)) {
        Panel.log('history.back 无效，尝试关闭标签页', 'warn');
        try { window.close(); } catch (e) {}
        await sleep(800);
        if (PLAYER_URL_RE.test(location.href)) {
          var s = RunState.get();
          if (s.currentCourseId) {
            // 回课程目录页：该页会继续点"继续学习"进下一章，全部完成才回 learn 页
            Panel.log('无法关闭标签页，返回课程目录页（' + s.currentCourseId + '）', 'warn');
            setHandoff(['CATALOG']);
            location.href = 'https://player.qlteacher.com/learning/' + s.currentCourseId;
          } else {
            var project = s.currentProject || 'cz2026';
            Panel.log('无法关闭标签页，直接跳转 learn 页', 'warn');
            setHandoff(['LEARN']); // 整页跳转=同一标签页换页，预先交权给新生的 learn 页
            location.href = 'https://yxjc.qlteacher.com/project/' + project + '/lesson/learn';
          }
        }
      }
    }

    async function handlePlayer(route) {
      var key = 'PLAYER:' + route.courseId + ':' + route.videoId;
      var s = RunState.get();
      if (s.skipList.indexOf(key) >= 0) {
        Panel.log('该节点已被标记跳过，返回目录', 'warn');
        await leavePlayer();
        return;
      }
      // 循环守卫：同一视频刚判定完成又立刻被进入 → 计数，超限则跳过
      if (s.lastDoneKey === key && (Date.now() - (s.lastDoneTime || 0) < 120000)) {
        var count = (s.loopCount || 0) + 1;
        if (count >= 3) {
          var list = (s.skipList || []).slice();
          list.push(key);
          RunState.set({ skipList: list, loopCount: 0, lastDoneKey: null });
          Panel.log('同一视频反复进入，判定异常，标记跳过并返回目录', 'error');
          await leavePlayer();
          return;
        }
        RunState.set({ loopCount: count });
        Panel.log('同一视频重复进入（第 ' + count + ' 次），继续尝试', 'warn');
      } else {
        RunState.set({ loopCount: 0 });
      }
      RunState.set({
        currentCourseId: route.courseId,
        currentVideoId: route.videoId,
        lastHeartbeat: Date.now()
      });
      Panel.setCurrent('课程 ' + route.courseId + ' / 视频 ' + route.videoId);
      var ok = await PlayerCtl.study(route.courseId, route.videoId);
      if (!Config.get('running')) return;
      if (ok) {
        s = RunState.get();
        s.stats.doneVideos++;
        RunState.set({
          stats: s.stats, retryCount: 0,
          lastDoneKey: key, lastDoneTime: Date.now(),
          learnReturns: []   // 真的学完一个视频＝有实质进展，清掉"回退学习页"的循环计数
        });
        Panel.refreshStats();
        Panel.log('本视频学习完成，返回目录页', 'ok');
        await sleep(700 + jitter(500));
        await leavePlayer();
      } else {
        Panel.log('学习流程中止，返回目录', 'warn');
        await sleep(400);
        await leavePlayer();
      }
    }

    async function handleCatalog(route) {
      setStatus('目录页寻章');
      if (!canAct()) return;
      RunState.set({ currentProject: route.project || RunState.get().currentProject });
      // 换了课程（courseId 变化）→ 重置"连续未找到"计数，避免上一门课残留计数导致误判完成
      if (RunState.get().catalogCourse !== route.courseId) {
        RunState.set({ catalogCourse: route.courseId, catalogMiss: 0 });
      }
      // 先切到"我的课程"标签页：点击后等待列表加载，下一轮 tick 再找学习按钮
      if (!CatalogCtl.ensureMyCourseTab()) {
        setStatus('等待我的课程加载');
        RunState.set({ lastHeartbeat: Date.now() });
        await sleep(1500);
        return;
      }
      // 等待 Angular 渲染（800ms 步长早走，上限 ~12s）
      for (var i = 0; i < 15; i++) {
        if (!canAct()) return;
        var r = CatalogCtl.gotoNextChapter();
        if (r === 'halt') return;
        if (r === 'waiting') {
          // 已点击过"继续学习"：等待新标签页加载并接管（本页随后会被自动停止）
          setStatus('等待新标签页接管');
          RunState.set({ lastHeartbeat: Date.now() }); // 防止看门狗误刷
          return;
        }
        if (r === 'found') {
          RunState.set({ lastHeartbeat: Date.now(), retryCount: 0, catalogMiss: 0 });
          return; // 等待新标签页打开；若 45s 未接管，下一轮 tick 解锁后可重试
        }
        await sleep(800);
      }
      // 未找到未完成章节：先看有没有"进度 100%"的显式证据 → 有就直接回退 learn 页（不再多刷一次）
      var evidence = CatalogCtl.finishEvidence();
      if (evidence) {
        await finishCourseToLearn(route, evidence);
        return;
      }
      // 没有证据：先刷新一次同步状态，仍无则按"连续未找到次数"兜底回退 learn 页。
      // 用次数判定（不用 URL 比对——刷新后 URL 可能有斜杠/参数差异，会导致无限刷新）
      var s = RunState.get();
      var miss = (s.catalogMiss || 0) + 1;
      RunState.set({ catalogMiss: miss, lastHeartbeat: Date.now() });
      if (miss === 1) {
        Panel.log('目录页未找到未完成章节，刷新一次同步完成状态', 'warn');
        await sleep(800);
        reloadSelf();
        return;
      }
      // 刷新后仍无 → player 页所有章节已完成 → 回退 lesson/learn 页
      await finishCourseToLearn(route, '连续两次未找到未完成章节');
    }

    /* 课程完成统一出口：退回 lesson/learn 页 + 强制刷新该标签页
     * 为什么要"刷新"而不是直接 location.href：
     *   ① 平台是 Angular SPA，同源跳回时容易命中 bfcache/前端路由缓存，拿回一份"章节还是
     *      未完成"的旧 DOM，于是又点回刚学完的那一章，来回打转；
     *   ② 学习页的课程列表来自接口，页面不重新初始化就看不到"已完成"。
     * 做法：写 learnReturn 标记 + 带时间戳参数 navigate（真刷新），到岸后由 boot 消费标记。
     */
    async function finishCourseToLearn(route, reason) {
      setStatus('本课程已完成');
      Panel.log('检测到课程进度 100%（' + reason + '），退回 lesson/learn 页并刷新标签页', 'ok');
      clearNavLock();
      RunState.set({ catalogMiss: 0, catalogCourse: null, learnMiss: 0 });
      var s = RunState.get();
      s.stats.doneCourses++;
      // 循环守卫：学习页若仍把该课程显示为未完成，会"回退→再进→又 100%→再回退"打转。
      // 10 分钟内连续 6 次即判定异常并暂停，宁停不错跑。
      var now = Date.now();
      var rets = (s.learnReturns || []).filter(function (t) { return now - t < 10 * 60000; });
      rets.push(now);
      RunState.set({ stats: s.stats, learnReturns: rets });
      Panel.refreshStats();
      if (rets.length >= 6) {
        Config.set('running', false);
        Panel.refreshButtons();
        setStatus('疑似循环已暂停');
        Panel.log('10 分钟内连续 6 次"课程完成→回退学习页"，学习页仍把课程显示为未完成，已暂停挂机。请人工确认进度后点"开始"', 'error');
        return;
      }
      var project = detectProject(route);
      var url = 'https://yxjc.qlteacher.com/project/' + project + '/lesson/learn';
      Env.set('learnReturn', { at: Date.now(), url: url, project: project, reason: reason });
      // 记住刚学完的课程：学习页若因缓存仍显示"继续学习"，据此跳过，避免来回空转
      if (route && route.courseId) {
        Env.set('lastFinishedCourse', { courseId: route.courseId, at: Date.now() });
      }
      setHandoff(['LEARN']); // 本页即将变成 learn 页（新脚本实例），提前交权以便立刻认领
      await sleep(500 + jitter(400));
      setStatus('返回 learn 页');
      Panel.log('跳转 ' + url);
      navigateRefreshing(url);
    }

    // 带时间戳参数跳转：绕过 bfcache 与前端路由缓存，确保目标页是"真刷新"后的新文档
    function navigateRefreshing(url) {
      var sep = url.indexOf('?') >= 0 ? '&' : '?';
      var target = url + sep + '_qlt=' + Date.now();
      try { location.replace(target); } catch (e) { location.href = target; }
    }

    // 项目代号识别：路由 → 运行状态（learn/index 页记录） → 页面内 project 链接 → 兜底 cz2026
    function detectProject(route) {
      if (route && route.project) return route.project;
      var p = RunState.get().currentProject;
      if (p) return p;
      var as = qsa(['a[href*="/project/"]']);
      for (var i = 0; i < as.length; i++) {
        var m = String(as[i].getAttribute('href') || '').match(/\/project\/([^/?#]+)/);
        if (m) return m[1];
      }
      return 'cz2026';
    }

    async function handleIndex(route) {
      setStatus('index 页找入口');
      if (!canAct()) return;
      RunState.set({ currentProject: route.project || RunState.get().currentProject });
      // 800ms 步长早走，上限 ~12s
      for (var i = 0; i < 15; i++) {
        if (!canAct()) return;
        var r = CatalogCtl.gotoIndexEntry();
        if (r === 'halt') return;
        if (r === 'waiting') {
          setStatus('等待新标签页接管');
          RunState.set({ lastHeartbeat: Date.now() });
          return;
        }
        if (r === 'found') {
          RunState.set({ lastHeartbeat: Date.now(), retryCount: 0 });
          return; // 等待新标签页接管，本页随后自动暂停
        }
        await sleep(800);
      }
      Panel.log('index 页未找到"学习课程"入口按钮', 'warn');
    }

    async function handleLearn(route) {
      setStatus('learn 页选课');
      if (!canAct()) return;
      RunState.set({ currentProject: route.project || RunState.get().currentProject });
      var found = 'none';
      for (var i = 0; i < 15; i++) {
        if (!canAct()) return;
        found = CatalogCtl.gotoNextCourse();
        if (found === 'halt') return;
        if (found === 'waiting') {
          setStatus('等待新标签页接管');
          RunState.set({ lastHeartbeat: Date.now() });
          return;
        }
        if (found === 'found') break;
        await sleep(800);
      }
      if (found === 'found') {
        RunState.set({ lastHeartbeat: Date.now(), retryCount: 0, learnMiss: 0 });
        return;
      }
      // 未找到未完成课程：先刷新一次同步状态（用计数判定，避免 URL 差异导致反复刷新）
      var s = RunState.get();
      var miss = (s.learnMiss || 0) + 1;
      RunState.set({ learnMiss: miss, lastHeartbeat: Date.now() });
      if (miss === 1) {
        Panel.log('learn 页未找到未完成课程，刷新一次同步状态', 'warn');
        await sleep(800);
        reloadSelf();
        return;
      }
      // 全部课程完成
      Config.set('running', false);
      Panel.refreshButtons();
      setStatus('全部完成');
      var fin = CatalogCtl.recentlyFinished();
      if (fin) {
        Panel.log('学习页已无可点课程（刷新后仍只剩刚学完的 ' + fin.courseId + '）。若确认还有课程未学，请手动刷新本页后再点"开始"', 'warn');
      } else {
        Panel.log('所有课程均已完成，挂机结束', 'ok');
      }
    }

    async function tick() {
      if (!Config.get('running')) {
        setStatus('已暂停');
        return;
      }
      // 顺序敏感：先判"本页已交权等待接手"，再判"点击后长挂起"，最后才认领
      if (waitingHandoff()) {
        setStatus('等待新标签页接管');
        return;
      }
      // 已点击跳转并把接力棒交给下游：只要下游标签页还活着，本页就一直挂起，
      // 不认领、不续约、不点击（认领会抢走牌照，导致真正在干活的页面停手）
      if (navLocked()) {
        setStatus('等待新标签页接管');
        return;
      }
      // 续约心跳必须早于 busy 判断：播放页 study() 会长时间占用 busy，期间 tick 直接返回，
      // 若不在此续约，心跳 120s 后过期，闲置标签页就会误判"无持牌人"而抢权、重复点击
      renewActiveTab();
      if (busy) return;
      // 被接管时只让自己停手，绝不动全局 running（否则刚接手的新标签页会被连累暂停）
      if (isTakenOver()) {
        if (RunState.get().lockOwner === TAB_ID) RunState.set({ lockOwner: null, lockTime: 0 });
        setStatus('已由其他标签页接管');
        return;
      }
      claimActiveTab(Router.current()); // 没有持牌人 / 持牌人是让位给我的页面时，这里完成接管
      renewActiveTab();                 // 持牌人续约心跳，旧标签页随时能感知
      if (!acquireLock()) {
        setStatus('另一标签页运行中');
        return;
      }
      busy = true;
      try {
        var route = Router.current();
        switch (route.page) {
          case 'INDEX':
            await handleIndex(route);
            break;
          case 'PLAYER':
            await handlePlayer(route);
            break;
          case 'CATALOG':
            await handleCatalog(route);
            break;
          case 'LEARN':
            await handleLearn(route);
            break;
          case 'LOGIN':
            Config.set('running', false);
            Panel.refreshButtons();
            setStatus('登录已失效');
            Panel.log('检测到跳转登录页，请登录后点击开始', 'error');
            break;
          default:
            setStatus('等待目标页面');
        }
      } catch (e) {
        Panel.log('主循环异常：' + (e && e.message ? e.message : e), 'error');
      } finally {
        busy = false;
      }
    }

    function watchdog() {
      if (!Config.get('running')) return;
      // 只有"持牌人自己"才有资格自我刷新。交权后挂起的页面（learn/index/目录页）、
      // 被接管的页面都不许刷新自己 —— 一刷新 navLock 就被清空，随后它会重新认领并
      // 再点一次"开始学习"，这就是一个课程被点出多个标签页的直接来源。
      if (waitingHandoff() || navLocked() || isTakenOver()) return;
      var s = RunState.get();
      var timeout = (Config.get('watchdogTimeout') || 120) * 1000;
      if (s.lastHeartbeat && (Date.now() - s.lastHeartbeat > timeout)) {
        var retry = (s.retryCount || 0) + 1;
        if (retry <= (Config.get('maxRetry') || 3)) {
          RunState.set({ retryCount: retry, lastHeartbeat: Date.now() });
          Panel.log('看门狗：' + Math.round(timeout / 1000) + 's 无进展，刷新重试（第 ' + retry + ' 次）', 'warn');
          reloadSelf();
        } else {
          // 跳过当前节点
          var route = Router.current();
          var key = CatalogCtl.nodeKey(route);
          var skipList = s.skipList || [];
          skipList.push(key);
          RunState.set({ skipList: skipList, retryCount: 0, lastHeartbeat: Date.now() });
          Panel.log('重试超限，跳过当前节点：' + key, 'error');
          history.back();
          setTimeout(function () { if (Router.current().page === route.page) reloadSelf(); }, 5000);
        }
      }
    }

    return {
      emit: function (evt) {
        if (evt === 'AUTH_EXPIRED') {
          Config.set('running', false);
          Panel.refreshButtons();
          Panel.setStatus('登录已失效');
          Panel.log('认证失效，请重新登录后点击开始', 'error');
        } else {
          eventQueue.push(evt);
        }
      },
      kick: function () {
        RunState.set({ lastHeartbeat: Date.now(), retryCount: 0 });
        tick();
      },
      start: function () {
        setInterval(tick, Config.get('pollMs') || 1500);
        // 独立心跳：不受 busy / 睡眠等待影响，保证"持牌"状态在播放全程持续新鲜
        setInterval(function () {
          if (!Config.get('running')) return;
          if (waitingHandoff() || navLocked() || isTakenOver()) return;
          renewActiveTab();
        }, 10000);
        watchdogTimer = setInterval(watchdog, 30000);
      }
    };
  })();

  /* ============================================================
   * 11. 启动
   * ==========================================================*/

  function boot() {
    // 本页若是"自我刷新"（同 URL），清掉上一代留下的持牌记录；
    // 若上一代刚交权就被刷新，把接力棒传给本代——否则刷新后会抢先再点一次"开始学习"
    var rm = consumeReloadMark();
    if (rm) {
      var hOld = getHandoff();
      if (hOld && hOld.from === rm.tab) Env.set('handoff', { from: TAB_ID, at: hOld.at, to: hOld.to || null });
      else Env.set('handoff', null);
      // 持牌权继承：上一代是本页持牌人 → 直接把牌照换成新 ID，别丢掉，
      // 否则另一个停着的旧标签页会趁空档抢走并重复点击
      var recOld = Env.get('activeTab', null);
      if (recOld && recOld.id === rm.tab) Env.set('activeTab', { id: TAB_ID, hb: Date.now() });
      // 只清掉"上一代自己"的点击锁，别把别的标签页正在用的锁一起抹掉
      var nl = RunState.get().navLock;
      if (nl && nl.by === rm.tab) RunState.set({ navLock: null });
    }
    Panel.init();

    // 从"课程 100% 回退"过来：确认这是刷新后的新学习页，清掉上一门课的计数，立即重新扫描课程列表
    var lr = Env.get('learnReturn', null);
    if (lr) {
      Env.set('learnReturn', null);
      if ((Date.now() - (lr.at || 0)) < 60000 && location.pathname.indexOf('/lesson/learn') >= 0) {
        RunState.set({ catalogMiss: 0, learnMiss: 0, catalogCourse: null });
        Panel.log('已从课程完成回退到学习页（' + (lr.reason || '进度 100%') + '），刷新后重新扫描课程列表', 'ok');
      }
    }

    // 页面从 bfcache 恢复（history.back / 前进）：DOM 是几十秒前的旧快照、脚本不会重新 boot，
    // 直接用它会拿着"章节还没学完"的旧按钮再点回同一章。强制真刷新一次，让适配层重新判定。
    window.addEventListener('pageshow', function (e) {
      if (!e.persisted) return;
      if (!Config.get('running')) return;
      var rt = Router.current();
      if (rt.page === 'PLAYER') return; // 播放页在后（重载会打断进度上报），只刷新门户类页面
      var last = Env.get('bfReload', 0) || 0;
      if (Date.now() - last < 15000) return; // 防刷新循环
      Env.set('bfReload', Date.now());
      Panel.log('页面从缓存恢复（旧快照），强制刷新标签页', 'warn');
      markReload();
      location.reload();
    });

    Router.start();
    // 已交权等待接手的页面不认领，避免挡住真正该干活的新标签页
    if (!waitingHandoff()) claimActiveTab(Router.current());
    Router.onChange(function (info) {
      Panel.log('路由：' + info.page + (info.courseId ? ' ' + info.courseId : ''));
      claimActiveTab(info); // SPA 路由切换到业务页面时同样认领
      QuizEngine.resetExamFlag();
      if (Config.get('running')) MainLoop.kick();
    });
    MainLoop.start();
    var route = Router.current();
    Panel.setStatus(Config.get('running') ? '运行中' : '待机');
    Panel.log('脚本已加载，当前页面类型：' + route.page);
    if (route.page === 'LOGIN') {
      Panel.log('当前为登录页，请先登录', 'warn');
    }
    if (Config.get('running')) MainLoop.kick();
  }

  if (document.readyState === 'loading') {
    document.addEventListener('DOMContentLoaded', boot);
  } else {
    boot();
  }

})();