// ==UserScript==
// @name         华医网全能助手（修复版）
// @namespace    https://github.com/yourname/
// @version      3.1.1
// @description  自动静音播放、自动切换视频、自动关闭“检测到异常插件”拦截弹窗、智能考试；修复“有未学课程却提示没有更多未学课程”
// @match        *://*.91huayi.com/course_ware/course_ware_polyv.aspx?*
// @match        *://*.91huayi.com/course_ware/course_ware_cc.aspx?*
// @match        *://*.91huayi.com/pages/exam.aspx?*
// @match        *://*.91huayi.com/pages/exam_result.aspx?*
// @match        *://*.91huayi.com/pages/course.aspx*
// @match        *://*.91huayi.com/course_ware/course_list.aspx*
// @match        *://*.91huayi.com/course_ware/course.aspx*
// @match        *://*.91huayi.com/course_ware/course_ware.aspx*
// @match        *://*.91huayi.com/pages/*.aspx*
// @grant        GM_setValue
// @grant        GM_getValue
// @grant        GM_deleteValue
// @grant        GM_openInTab
// @grant        GM_addStyle
// @run-at       document-idle
// @license      MIT
// ==/UserScript==

/* ============================================================
 * 修复说明（v3.0.0）
 *
 * 【问题一】有未学课程，却提示“没有更多未学课程”
 *   这条提示只可能出现在“视频页目录扫描”这一段，旧版有三个致命限制：
 *   1. 判断可学状态时，要求目录项里的 <button> 文字严格等于
 *      "未学习" / "学习中" / ""，只要站点换成 <a>、<i>、图标、
 *      或文字变成“未开始 / 继续学习 / 待考试”，就会全部被判为“找不到”。
 *   2. 取链接时只认 h2 上的 onclick="window.location.href='xxx'" 这一种写法，
 *      换成 location.href= / window.open() / data-href / 纯 <a href> 就取不到。
 *   3. 折叠章节里的课程根本不在 DOM 里，扫不到。
 *   新版：先展开折叠目录 → 多选择器采集目录项 → 状态用正则归成
 *   todo/done/exam 三类 → 链接支持 <a href>、onclick、data-*、祖先 onclick、
 *   取不到链接就直接点击 → 一次找不到会重试多次 → 本章全部学完时自动
 *   回课程列表页继续找下一章（而不是原地停下）。
 *
 * 【问题二】弹窗“系统检测到安装异常插件”，点很多次才能继续
 *   站点用的弹层是 SweetAlert2 / layui-layer。旧版完全没有处理逻辑，
 *   所以只能手动点。
 *   新版：MutationObserver + 每 250ms 扫描，命中关键词后自动点
 *   “确定/关闭”，点不动就隐藏弹层和遮罩（隐藏而非删除：站点 onload 里会
 *   去 click 这些节点，删除会让站点抛 undefined.click 报错）；同时接管 alert/confirm/prompt；
 *   并把日志面板放进 Shadow DOM，页面脚本读不到面板文字，降低被识别概率。
 *
 * 【问题三】“温馨提示 · 观看课件不能拖拽”提示层
 *   原本完全没处理：文案不在关键词表里、选择器也还是老站点的写法，
 *   于是站点顺势刷新页面，这一节从头再播一遍。
 *   新版：每 500ms 扫描 [id^=div_tip] / .hidden_tips 这类站点提示层，
 *   命中文案优先点“确定”，点不到就整层隐藏，不触发站点的刷新逻辑。
 * ============================================================ */

(function () {
    'use strict';

    /* ==================== 全局配置 ==================== */
    const MODE_KEY = 'hy_mode_v2';
    let currentMode = GM_getValue(MODE_KEY, 'video_exam'); // 'video_exam' | 'video_only' | 'exam_only'

    const CFG = {
        // 弹窗文本命中这些关键词 → 自动关闭（“系统检测到安装异常插件”命中第 1 条）
        popupKeywords: [
            '异常插件', '检测到安装', '安装异常', '检测到异常', '异常环境',
            '请关闭插件', '请卸载', '请勿使用', '外挂', '作弊', '模拟器'
        ],
        popupScanMs: 250,          // 弹窗扫描间隔
        popupForceRemoveMs: 1200,  // 已点按钮但弹层没消失，多久后强拆
        rescan: 6,                 // 目录扫描重试次数
        rescanMs: 3000,            // 重试间隔
        videoGuardMs: 2500,        // 视频守护（防暂停）间隔
        autoQuality: false,        // 进页自动切“流畅”：实测疑似触发站点防拖拽检测，默认关闭
        panelHotkey: 'alt+h'       // 显示 / 隐藏日志面板
    };

    const STORAGE = {
        test: 'hy_test',
        result: 'hy_result',
        testAnswer: 'hy_testAnswer',
        rightAnswer: 'hy_rightAnswer',
        allAnswer: 'hy_allAnswer',
        thisTitle: 'hy_thisTitle'
    };
    const EXAMDONE_KEY = 'hy_exam_done';   // 记录“刚考完试的 cwid”，避免回视频页后重复播放 / 重复考试
    const LOOPGUARD_KEY = 'hy_loop_guard'; // 防止“视频页 ↔ 课程列表页”来回跳死循环

    const DELAY = { submit: 6800, retry: 3500, examEnter: 7000, random: 5000 };

    /* ==================== 工具：双 window（Tampermonkey 沙箱兼容） ==================== */
    // TM 带 @grant 时脚本运行在沙箱里，window 与页面真实 window 可能不是同一个对象，
    // 因此所有“影响页面行为”的改写都要同时作用到 unsafeWindow。
    const PAGE = (typeof unsafeWindow !== 'undefined' && unsafeWindow) ? unsafeWindow : window;
    function wins() { return PAGE === window ? [window] : [window, PAGE]; }

    /* ==================== 隐身层（降低“异常插件”检测概率） ==================== */
    const _fakeSrc = new WeakMap();
    wins().forEach(function (w) {
        try {
            const proto = w.Function && w.Function.prototype;
            if (!proto || proto.__hyPatched) return;
            const orig = proto.toString;
            const patched = function () {
                if (_fakeSrc.has(this)) return _fakeSrc.get(this);
                return orig.call(this);
            };
            _fakeSrc.set(patched, orig.toString());
            proto.toString = patched;
            try { Object.defineProperty(proto, '__hyPatched', { value: true, enumerable: false }); }
            catch (e) { proto.__hyPatched = true; }
        } catch (e) {}
    });
    function hideSource(fn, src) { try { if (src) _fakeSrc.set(fn, src); } catch (e) {} return fn; }

    /* ==================== 通用工具 ==================== */
    function log(msg) { try { console.log('[华医助手] ' + msg); } catch (e) {} }
    function sleep(ms) { return new Promise(function (r) { setTimeout(r, ms); }); }
    function randomDelay(min, max) {
        if (min === undefined) min = 1000;
        if (max === undefined) max = 3000;
        return Math.floor(Math.random() * (max - min + 1) + min);
    }
    function getBaseUrl() { return window.location.origin; }
    function getCwidFromUrl() { return new URLSearchParams(window.location.search).get('cwid'); }
    function textOf(el) { return ((el && (el.innerText || el.textContent)) || '').replace(/\s+/g, ''); }
    function isHidden(el) {
        try {
            const s = getComputedStyle(el);
            return s.display === 'none' || s.visibility === 'hidden';
        } catch (e) { return false; }
    }
    function absUrl(u) {
        if (!u) return '';
        let s = String(u).trim().replace(/^["']+|["']+$/g, '');
        if (!s || /^javascript:/i.test(s) || s === '#') return '';
        // 必须按“当前页面所在目录”解析相对路径：
        // 视频页目录里的链接是 course_ware.aspx?cwid=…（不带前导斜杠），
        // 它其实指向 /course_ware/course_ware.aspx?cwid=…，而不是根目录下的 /course_ware.aspx。
        try { return new URL(s, location.href).href; } catch (e) { return ''; }
    }

    /* ==================== 日志面板（Shadow DOM，页面读不到内容） ==================== */
    let panel = null, panelLog = null;
    function debugLog(msg) {
        log(msg);
        if (!panelLog) return;
        try {
            const t = new Date().toLocaleTimeString();
            panelLog.value = '[' + t + '] ' + msg + '\n' + panelLog.value;
            if (panelLog.value.length > 4000) panelLog.value = panelLog.value.slice(0, 4000);
        } catch (e) {}
    }

    function createDebugWindow() {
        if (panel) return;
        try {
            const host = document.createElement('div');
            host.id = 'hy-panel-' + Math.random().toString(36).slice(2, 8);
            host.setAttribute('style', 'position:fixed;top:12px;left:12px;z-index:2147483647;');
            const root = host.attachShadow({ mode: 'open' });
            root.innerHTML = '' +
                '<style>' +
                '  .box{width:420px;background:#1e293b;color:#e2e8f0;padding:14px;border-radius:14px;' +
                '       font:14px/1.5 -apple-system,"PingFang SC",sans-serif;box-shadow:0 8px 30px rgba(0,0,0,.5);' +
                '       border:1px solid #475569;max-height:80vh;display:flex;flex-direction:column;}' +
                '  .hd{display:flex;align-items:center;margin-bottom:8px;}' +
                '  .tt{flex:1;font-weight:600;color:#38bdf8;}' +
                '  .x{cursor:pointer;color:#94a3b8;padding:0 4px;}' +
                '  .row{display:flex;gap:8px;flex-wrap:wrap;margin-bottom:8px;align-items:center;}' +
                '  select,button{font:12px/1 inherit;border-radius:6px;border:1px solid #475569;' +
                '       background:#0f172a;color:#e2e8f0;padding:5px 9px;cursor:pointer;}' +
                '  #next{background:#22c55e;color:#fff;border:none;}' +
                '  #exam{background:#3b82f6;color:#fff;border:none;}' +
                '  textarea{background:#0f172a;color:#94a3b8;border:1px solid #334155;border-radius:8px;' +
                '       padding:8px;resize:vertical;font-size:12px;width:100%;box-sizing:border-box;}' +
                '</style>' +
                '<div class="box">' +
                '  <div class="hd"><span class="tt">🩺 华医全能助手 v3.1.1</span><span class="x" id="close">✕</span></div>' +
                '  <div class="row">' +
                '    <select id="mode">' +
                '      <option value="video_exam"' + (currentMode === 'video_exam' ? ' selected' : '') + '>📺+📝 视频+考试</option>' +
                '      <option value="video_only"' + (currentMode === 'video_only' ? ' selected' : '') + '>📺 仅视频</option>' +
                '      <option value="exam_only"' + (currentMode === 'exam_only' ? ' selected' : '') + '>📝 仅考试</option>' +
                '    </select>' +
                '    <button id="next">⏩ 下一课</button>' +
                '    <button id="exam">📝 考试</button>' +
                '  </div>' +
                '  <textarea id="log" rows="8" readonly></textarea>' +
                '</div>';
            (document.body || document.documentElement).appendChild(host);

            panel = host;
            panelLog = root.getElementById('log');
            root.getElementById('close').onclick = function () {
                host.style.display = 'none';
                debugLog('面板已隐藏，按 ' + CFG.panelHotkey + ' 可再次显示');
            };
            root.getElementById('mode').onchange = function () {
                currentMode = this.value;
                GM_setValue(MODE_KEY, currentMode);
                debugLog('模式切换为: ' + this.options[this.selectedIndex].text);
            };
            root.getElementById('next').onclick = function () { jumpToNextCourse(true); }; // 手动强制跳
            root.getElementById('exam').onclick = function () { startExamQueueManually(); };

            document.addEventListener('keydown', function (ev) {
                if (ev.altKey && (ev.key === 'h' || ev.key === 'H')) {
                    panel.style.display = (panel.style.display === 'none') ? '' : 'none';
                }
            });

            debugLog('🚀 脚本启动成功（v3.1.1）');
        } catch (e) {
            log('面板创建失败: ' + e.message);
        }
    }

    /* ==================== 弹窗猎杀（修复“检测到异常插件”） ==================== */
    let popupKilled = 0;

    function hitKeyword(t) {
        if (!t) return false;
        for (let i = 0; i < CFG.popupKeywords.length; i++) {
            if (t.indexOf(CFG.popupKeywords[i]) >= 0) return true;
        }
        return false;
    }

    function installDialogBlockers() {
        wins().forEach(function (w) {
            ['alert', 'confirm', 'prompt'].forEach(function (name) {
                try {
                    const raw = w[name];
                    if (typeof raw !== 'function' || raw.__hyBlocked) return;
                    const faked = function (msg) {
                        const t = String(msg == null ? '' : msg);
                        if (hitKeyword(t.replace(/\s+/g, ''))) {
                            debugLog('拦截 ' + name + '()：' + t.slice(0, 60));
                            popupKilled++;
                            return name === 'confirm' ? true : (name === 'prompt' ? '' : undefined);
                        }
                        try { return raw.apply(w, arguments); } catch (e) { return undefined; }
                    };
                    hideSource(faked, raw.toString());
                    try { faked.__hyBlocked = true; } catch (e) {}
                    w[name] = faked;
                } catch (e) {}
            });
        });
    }

    // 只隐藏、不删除：站点自己的 window.onload 里会去 click 这些节点，
    // 直接 remove 会让站点抛出 "Cannot read properties of undefined (reading 'click')"。
    function suppressPopup(el) {
        try {
            el.style.setProperty('display', 'none', 'important');
            el.style.setProperty('visibility', 'hidden', 'important');
            el.style.setProperty('pointer-events', 'none', 'important');
            el.setAttribute('aria-hidden', 'true');
            const parent = el.parentElement;
            if (parent && parent.classList && parent.classList.contains('layui-layer-shade')) {
                parent.style.setProperty('display', 'none', 'important');
                parent.style.setProperty('pointer-events', 'none', 'important');
            }
        } catch (e) {}
    }
    function isSuppressed(el) { return el.getAttribute && el.getAttribute('aria-hidden') === 'true'; }

    // 返回本次扫描关闭的弹窗数量
    function swallowPopupOnce() {
        let killed = 0;

        // 1) SweetAlert2（站点全站加载了 sweetalert2-7.28.4）
        document.querySelectorAll('.swal2-container, .swal2-popup').forEach(function (el) {
            if (!hitKeyword(textOf(el))) return;
            killed++;
            const btn = el.querySelector('.swal2-confirm') || el.querySelector('.swal2-cancel') || el.querySelector('.swal2-close');
            if (btn) { try { btn.click(); } catch (e) {} }
            setTimeout(function () { if (!isSuppressed(el)) suppressPopup(el); }, CFG.popupForceRemoveMs);
        });

        // 2) layui layer（考试相关弹窗都是这一套）
        document.querySelectorAll('.layui-layer').forEach(function (el) {
            if (!hitKeyword(textOf(el))) return;
            killed++;
            const btn = el.querySelector('.layui-layer-btn0') || el.querySelector('.layui-layer-btn1') || el.querySelector('.layui-layer-close');
            if (btn) { try { btn.click(); } catch (e) {} }
            setTimeout(function () { if (!isSuppressed(el)) suppressPopup(el); }, CFG.popupForceRemoveMs);
        });

        // 3) 其它通用遮罩层 / 自定义弹窗
        document.querySelectorAll('[role="dialog"], .modal, .dialog, .popup, .mask-layer').forEach(function (el) {
            if (!hitKeyword(textOf(el))) return;
            killed++;
            const txt = ['确定', '知道了', '我已知晓', '关闭', '继续', 'OK'];
            let clicked = false;
            const btns = el.querySelectorAll('button, input[type=button], input[type=submit], a');
            btns.forEach(function (b) {
                if (clicked) return;
                const s = ((b.tagName === 'INPUT' ? b.value : b.innerText) || '').replace(/\s+/g, '');
                if (txt.indexOf(s) >= 0) { try { b.click(); clicked = true; } catch (e) {} }
            });
            if (!clicked) setTimeout(function () { if (!isSuppressed(el)) suppressPopup(el); }, CFG.popupForceRemoveMs);
        });

        // 没有“还在显示”的 layui 弹层了，顺手隐藏残留遮罩（避免页面被灰罩挡住点不动）
        let liveLayer = false;
        document.querySelectorAll('.layui-layer').forEach(function (el) {
            if (!isSuppressed(el)) liveLayer = true;
        });
        if (!liveLayer) {
            document.querySelectorAll('.layui-layer-shade').forEach(function (s) { suppressPopup(s); });
        }

        if (killed) {
            popupKilled += killed;
            debugLog('已自动关闭拦截弹窗 x' + killed + '（累计 ' + popupKilled + '）');
        }
        return killed;
    }

    function isPopupish(node) {
        try {
            const cls = (typeof node.className === 'string' ? node.className : '') + ' ' + (node.id || '');
            return /swal2|layui|modal|dialog|popup|mask|shade/i.test(cls);
        } catch (e) { return false; }
    }

    function initPopupKiller() {
        installDialogBlockers();
        swallowPopupOnce();
        setInterval(swallowPopupOnce, CFG.popupScanMs);

        // 只对“看起来像弹窗”的新增节点做即时补刀，避免视频页高频变动导致空转
        let timer = null;
        const schedule = function (delay) {
            if (timer) return;
            timer = setTimeout(function () { timer = null; swallowPopupOnce(); }, delay);
        };
        const observer = new MutationObserver(function (mutations) {
            for (let i = 0; i < mutations.length; i++) {
                const nodes = mutations[i].addedNodes;
                for (let j = 0; j < nodes.length; j++) {
                    const node = nodes[j];
                    if (node.nodeType === 1 && isPopupish(node)) { schedule(0); return; }
                }
            }
        });
        const target = document.body || document.documentElement;
        if (target) observer.observe(target, { childList: true, subtree: true });
    }

    /* ==================== 弹窗拦截（问答 / 签到 / 温馨提示 / 答题模式） ==================== */
    // 站点自己的“温馨提示”层（拖拽提醒 / 付费提醒等）。
    // 结构线索来自实测：页面上有 #div_tip / #div_tip1，class 都是 hidden_tips，
    // 靠去掉 hidden_tips（或改 display）来显示。命中文案后优先点“确定”，
    // 点不到就整层隐藏——这样不会走到站点那套刷新逻辑、把这一节从头再放一遍。
    const TIP_TEXT_RE = /温馨提示|不能拖拽|完整地学完|耐心地听|不能快进|认真观看|解锁全部内容/;
    const TIPCLICK_KEY = 'hy_tip_clicks';

    function findConfirm(el) {
        const cands = el.querySelectorAll('input[type=button], input[type=submit], button, a, span, div');
        for (let i = 0; i < cands.length; i++) {
            const c = cands[i];
            const t = (c.tagName === 'INPUT' ? (c.value || '') : (c.innerText || '')).replace(/\s+/g, '');
            if (/^(确定|知道了|我已知晓|我知道了|好的|关闭|继续观看|OK)$/i.test(t)) return c;
        }
        return el.querySelector('.layui-layer-btn0, .pv-tip-ok, [class*=confirm]');
    }

    // “确定”按钮本身如果就是刷新/跳转，点了反而会丢掉本节进度
    function confirmLooksLikeReload(btn) {
        const oc = (btn.getAttribute && btn.getAttribute('onclick')) || '';
        return /reload|refresh|location\s*\.\s*href|location\s*\.\s*replace/i.test(oc);
    }

    // 一分钟内点过几次“确定”（跨刷新保留，用来防刷新死循环）
    function tipClickHistory() {
        const now = Date.now();
        const arr = loadData(TIPCLICK_KEY) || [];
        return arr.filter(function (t) { return now - t < 60000; });
    }

    function closeSiteTips() {
        let n = 0;
        const list = document.querySelectorAll('[id^=div_tip], .hidden_tips, .pv-tip, [class*=tipbox], [class*=tip_box]');
        list.forEach(function (el) {
            if (isHidden(el) || isSuppressed(el)) return;
            if (!TIP_TEXT_RE.test(textOf(el))) return;
            n++;
            const btn = findConfirm(el);

            // 同一个 DOM 节点只点一次；点完没消失，下一轮直接隐藏
            if (btn && !el._hyClicked) {
                if (confirmLooksLikeReload(btn)) {
                    debugLog('提示层的“确定”看着会刷新页面，跳过点击，直接隐藏');
                    suppressPopup(el);
                    return;
                }
                const hist = tipClickHistory();
                if (hist.length >= 5) {
                    debugLog('提示层一分钟内已点 5 次还在弹，判定点“确定”会刷新页面，改为只隐藏');
                    suppressPopup(el);
                    return;
                }
                el._hyClicked = true;
                hist.push(Date.now());
                saveData(TIPCLICK_KEY, hist);
                try { btn.click(); debugLog('已点掉站点提示层（“确定”）'); return; } catch (e) {}
            }
            suppressPopup(el);
            debugLog('已隐藏站点提示层');
        });
        return n;
    }

    function initPopupBlocker() {
        setInterval(closeSiteTips, 500); // 拖拽提醒一来就立刻处理
        setInterval(function () {
            try {
                if (window.player && typeof window.player.j2s_pauseVideo === 'function' && !window.player.j2s_pauseVideo.__hyBlocked) {
                    const raw = window.player.j2s_pauseVideo;
                    const faked = function () { debugLog('拦截 pauseVideo'); return false; };
                    hideSource(faked, raw.toString());
                    try { faked.__hyBlocked = true; } catch (e) {}
                    window.player.j2s_pauseVideo = faked;
                }
                if (typeof window.initialSign !== 'undefined' && !window.initialSign.__hyBlocked) {
                    const faked = function () {
                        debugLog('自动签到');
                        if (typeof window.addPlaySign === 'function') window.addPlaySign();
                        window.isInitialSign = true;
                    };
                    try { faked.__hyBlocked = true; } catch (e) {}
                    window.initialSign = faked;
                }
            } catch (e) {}
        }, 500);

        setInterval(function () {
            try {
                const ask = document.querySelector('.pv-ask-head');
                if (ask) {
                    const skip = document.querySelector('.pv-ask-skip');
                    if (skip) { skip.click(); debugLog('已跳过课堂问答'); }
                }
                const sign = document.querySelector('.signBtn');
                if (sign) { sign.click(); debugLog('已跳过签到'); }
                const tip = document.querySelector('button[onclick="closeBangZhu()"], button[onclick="closeProcessbarTip()"]');
                if (tip) { tip.click(); debugLog('已关闭温馨提示'); }
                const know = document.querySelector('input.rig_btn[value="知道了"]');
                if (know && document.getElementById('div_processbar_tip') &&
                    document.getElementById('div_processbar_tip').style.display !== 'none') {
                    know.click();
                }
                // “选择答题模式”弹窗 → 自动选“正式考试”
                const modeDialog = document.querySelector('.layui-layer-content');
                if (modeDialog) {
                    const text = modeDialog.innerText || '';
                    if (text.indexOf('选择答题模式') >= 0 || text.indexOf('考试模式') >= 0 || text.indexOf('练习模式') >= 0) {
                        const btns = modeDialog.parentElement.querySelectorAll('.layui-layer-btn0, .layui-layer-btn1');
                        for (let i = 0; i < btns.length; i++) {
                            const t = btns[i].innerText || '';
                            if (t.indexOf('正式考试') >= 0 || t.indexOf('考试') >= 0) {
                                btns[i].click();
                                debugLog('已选择“正式考试”模式');
                                break;
                            }
                        }
                    }
                }
            } catch (e) {}

            try {
                const video = document.querySelector('video');
                if (video && video.paused && video.currentTime > 0 && video.currentTime < video.duration - 1) {
                    video.muted = true;
                    video.volume = 0;
                    video.play().catch(function () {});
                    debugLog('视频意外暂停，已恢复');
                }
            } catch (e) {}
        }, 3000);

        const observer = new MutationObserver(function (mutations) {
            for (let i = 0; i < mutations.length; i++) {
                const nodes = mutations[i].addedNodes;
                for (let j = 0; j < nodes.length; j++) {
                    const node = nodes[j];
                    if (node.nodeType !== 1) continue;
                    const text = node.innerText || '';
                    if (text.indexOf('选择答题模式') >= 0) {
                        const btns = node.querySelectorAll('.layui-layer-btn0, .layui-layer-btn1');
                        for (let k = 0; k < btns.length; k++) {
                            const t = btns[k].innerText || '';
                            if (t.indexOf('正式考试') >= 0 || t.indexOf('考试') >= 0) {
                                btns[k].click();
                                debugLog('自动选择“正式考试”');
                                break;
                            }
                        }
                    }
                    if (node.classList && node.classList.contains('study_diaog')) {
                        suppressPopup(node); // 隐藏即可，删除会让站点 onload 里的 click 报错
                        debugLog('已隐藏 study_diaog');
                    }
                }
            }
        });
        if (document.body) observer.observe(document.body, { childList: true, subtree: true });
    }

    /* ==================== 视频播放 ==================== */
    function setupVideo(video) {
        if (video._hySetup) return;
        video._hySetup = true;
        video.muted = true;
        video.volume = 0;

        const playVideo = function () {
            if (video.readyState >= 2) {
                video.play().catch(function () {});
            } else {
                video.addEventListener('canplay', function () { video.play().catch(function () {}); }, { once: true });
            }
        };
        setTimeout(playVideo, 1000);

        setInterval(function () {
            // 注意：这里不再要求 currentTime > 0——刚进页面时它是 0，
            // 之前那条限制导致“视频压根没起来”时守护完全不起作用。
            const d = video.duration;
            const notAtEnd = !isFinite(d) || d <= 0 || video.currentTime < d - 1;
            if (video.paused && !video.ended && notAtEnd) {
                video.muted = true;
                video.volume = 0;
                const p = video.play();
                if (p && p.catch) p.catch(function () {});
                debugLog('守护恢复播放');
            }
        }, CFG.videoGuardMs);

        let endHandled = false;
        video.addEventListener('ended', function () {
            // 防御：占位视频、试看片段、播放器切源都会触发 ended。
            // 必须确认真播到了结尾，否则就是“本节没学完就跳走”。
            const d = video.duration, c = video.currentTime;
            if (isFinite(d) && d > 0 && d < 60) { debugLog('忽略过短的 ended（时长 ' + Math.round(d) + 's）'); return; }
            if (isFinite(d) && d > 0 && c < d - 3) { debugLog('忽略未播到结尾的 ended'); return; }
            if (endHandled) return;
            endHandled = true;
            debugLog('视频播放结束');
            setTimeout(function () {
                // 先看本课状态，能识别就按状态走
                const entries = collectEntries();
                const idx = currentIndex(entries);
                const st = idx >= 0 ? entryStatus(entries[idx]) : '';
                debugLog('本课状态：' + (st || '未知'));

                if (st === 'exam' && currentMode === 'video_exam') {
                    const cwid = getCwidFromUrl();
                    if (cwid) {
                        markExamPending(cwid);
                        debugLog('进入考试: /pages/exam.aspx?cwid=' + cwid);
                        setTimeout(function () { window.location.href = '/pages/exam.aspx?cwid=' + cwid; }, randomDelay(1000, 3000));
                        return;
                    }
                }
                // 其它情况统一走“找下一课”
                jumpToNextCourse();
            }, 2000);
        });
    }

    function observeVideos() {
        const obs = new MutationObserver(function () {
            document.querySelectorAll('video').forEach(function (v) { setupVideo(v); });
        });
        if (document.body) obs.observe(document.body, { childList: true, subtree: true });
        document.querySelectorAll('video').forEach(function (v) { setupVideo(v); });
    }

    // 页面里是否还有播放器（polyv 播放器可能渲染在 iframe 里，只看 <video> 会误判成“没有视频”）
    function hasPlayerOnPage() {
        return !!document.querySelector('video, .pv-video, #player, iframe[src*=polyv], iframe[id*=player], iframe[class*=player]');
    }
    // 是否正在播放：用来阻止“本节没学完就跳走”
    function videoIsPlaying() {
        const vids = document.querySelectorAll('video');
        for (let i = 0; i < vids.length; i++) {
            const v = vids[i];
            if (v.paused || v.ended) continue;
            const d = v.duration;
            if (!isFinite(d) || d <= 0) { if (v.currentTime > 0.5) return true; continue; }
            if (v.currentTime > 0.5 && v.currentTime < d - 2) return true;
        }
        return false;
    }

    // Chrome 的自动播放策略要求页面已经有过“用户交互”，否则 video.play() 会被拒绝。
    // 旧版是进页 3 秒点“画质→流畅”顺带满足了这一点；那条关掉之后就不自动播了。
    // 这里补一次真实的合成点击（点击本身也常常就让播放器开始播）。
    function kickUserActivation() {
        const playBtns = ['.pv-play-btn', '.pv-icon-play', '.pv-controls-play', '.pv-play-big', '.pv-player-play'];
        for (let i = 0; i < playBtns.length; i++) {
            const el = document.querySelector(playBtns[i]);
            if (el && !isHidden(el)) {
                try { el.click(); debugLog('点击播放按钮（激活自动播放）'); return true; } catch (e) {}
            }
        }
        if (clickTextButton(['开始学习', '继续学习', '点击播放'])) {
            debugLog('点击“开始学习”类按钮（激活自动播放）');
            return true;
        }
        const target = document.querySelector('.pv-video') || document.querySelector('.pv-player') ||
                       document.querySelector('#player') || document.querySelector('video');
        if (target) {
            try { target.click(); debugLog('点击播放器区域（激活自动播放）'); return true; } catch (e) {}
        }
        return false;
    }

    /* ==================== 课程完成页面 ==================== */
    function handleCourseCompletePage() {
        let learnBtn = document.querySelector('input[value="立即学习"]');
        if (!learnBtn) learnBtn = document.querySelector('a[value="立即学习"]');
        if (!learnBtn) {
            const btns = Array.from(document.querySelectorAll('button, input, a'));
            for (let i = 0; i < btns.length; i++) {
                const t = (btns[i].innerText || '').trim();
                if (t === '立即学习') { learnBtn = btns[i]; break; }
            }
        }
        if (!learnBtn) return false;

        const href = learnBtn.getAttribute('href');
        if (href && !/^javascript:/i.test(href)) {
            debugLog('点击“立即学习”跳转到: ' + href);
            window.location.href = absUrl(href);
        } else {
            debugLog('点击“立即学习”按钮');
            learnBtn.click();
        }
        return true;
    }

    /* ==================== 目录扫描（核心修复区） ==================== */
    const RE_DONE = /已完成|已学完|已学习|已通过|学习完毕/;
    const RE_TODO = /未学习|未开始|未学完|未完成|未通过|学习中|继续学习|开始学习|去学习|可学习|立即学习/;
    const RE_EXAM = /待考试|待考|可考试|参加考试/;

    // 把任意一行状态文字归成 done / todo / exam / ''（认不出）
    function classify(text) {
        const t = (text || '').replace(/\s+/g, '');
        if (!t || t.length > 14) return '';
        if (/未学习|未开始|未学完|未完成|未通过/.test(t)) return 'todo'; // 必须先判“未完成”，否则会被“完成”吃掉
        if (RE_EXAM.test(t)) return 'exam';
        if (RE_DONE.test(t)) return 'done';
        if (RE_TODO.test(t)) return 'todo';
        return '';
    }

    // 采集本页所有可能的“课程目录项”
    function collectEntries() {
        const sels = [
            'li.lis-inside-content',
            '.lis-inside-content',
            'li[class*=lis-inside]',
            '.pv-list li',
            '.catalog-list li',
            '.course',
            '.course-item'
        ];
        const seen = new Set();
        const out = [];
        sels.forEach(function (s) {
            document.querySelectorAll(s).forEach(function (el) {
                if (seen.has(el)) return;
                seen.add(el);
                out.push(el);
            });
        });
        return out;
    }

    // 判断某个目录项的状态：优先看它内部的小元素（状态位），再兜底看整段文本
    function entryStatus(li) {
        let result = '';
        const kids = li.querySelectorAll('button, i, em, span, a, [class*=state], [class*=status]');
        kids.forEach(function (el) {
            let t = '';
            el.childNodes.forEach(function (nd) { if (nd.nodeType === 3) t += nd.textContent; });
            t = t.replace(/\s+/g, '');
            const c = classify(t);
            if (c) result = c; // 取最后一个能识别的（通常是行尾的状态位）
        });
        if (result) return result;

        // 兜底：去掉标题后剩下的文字
        let t = textOf(li);
        const titleEl = li.querySelector('h2, h3, .title');
        const title = textOf(titleEl);
        if (title && t.indexOf(title) === 0) t = t.slice(title.length);
        return classify(t);
    }

    // 当前正在播放的那一项在目录里的下标
    function currentIndex(entries) {
        for (let i = 0; i < entries.length; i++) {
            if (entries[i].querySelector('#top_play, [id*=top_play]')) return i;
        }
        for (let i = 0; i < entries.length; i++) {
            const cls = ' ' + ((entries[i].className || '').toString()) + ' ';
            if (/\s(on|active|current|now|playing|selected)\s/.test(cls)) return i;
        }
        return -1;
    }

    // 从“当前项之后”开始排，再绕回开头
    function pickOrder(n, cur) {
        const order = [];
        for (let i = cur + 1; i < n; i++) order.push(i);
        for (let i = 0; i < n; i++) { if (i !== cur) order.push(i); }
        return order;
    }

    function shortTitle(li) {
        const t = (((li.innerText || '').split('\n')[0]) || '').replace(/\s+/g, ' ').trim();
        return t.slice(0, 30) || '(无标题)';
    }

    const URL_RE = /(?:https?:\/\/[^\s'"<>()]+)|(?:[A-Za-z0-9_\-./]*[A-Za-z0-9_\-]\.aspx[^\s'"<>()]*)/i;

    // 从一个目录项里挖出目标链接：a[href] / 自身及祖先的 onclick / data-*
    function extractUrl(el) {
        const a = el.matches('a[href]') ? el : el.querySelector('a[href]');
        if (a) {
            const href = a.getAttribute('href') || '';
            const u = absUrl(href);
            if (u) return u;
            const m = href.match(URL_RE);
            if (m) return absUrl(m[0]);
        }
        const attrs = ['onclick', 'data-href', 'data-url', 'data-target', 'href', 'onmouseup'];
        let node = el;
        for (let depth = 0; node && depth < 3; depth++, node = node.parentElement) {
            for (let i = 0; i < attrs.length; i++) {
                const v = node.getAttribute ? node.getAttribute(attrs[i]) : null;
                if (!v) continue;
                const m = v.match(URL_RE);
                if (m) {
                    const u = absUrl(m[0]);
                    if (u && !/\.(png|jpg|gif|css|js)$/i.test(u)) return u;
                }
            }
        }
        return '';
    }

    let navigating = false;
    function go(url, why) {
        if (navigating) return true;
        const u = absUrl(url);
        if (!u) return false;
        navigating = true;
        debugLog('跳转' + (why ? '（' + why + '）' : '') + '：' + u);
        setTimeout(function () { window.location.href = u; }, randomDelay(400, 1500));
        setTimeout(function () { navigating = false; }, 8000); // 兜底解锁
        return true;
    }

    function clickEntry(li) {
        const target = li.querySelector('h2') || li.querySelector('a[href]') || li.querySelector('button') || li;
        try { target.click(); return true; } catch (e) { return false; }
    }

    // 按文字点按钮（“下一节 / 下一课 / 下一章”）
    function clickTextButton(texts) {
        const wanted = texts.map(function (t) { return t.replace(/\s+/g, ''); });
        const els = document.querySelectorAll('a, button, input[type=button], input[type=submit], span, li, div');
        for (let i = 0; i < els.length; i++) {
            const el = els[i];
            const raw = (el.tagName === 'INPUT') ? (el.value || '') : (el.innerText || '');
            const t = raw.replace(/\s+/g, '');
            if (!t || t.length > 12) continue;
            if (wanted.indexOf(t) >= 0) {
                try { el.click(); debugLog('点击「' + t + '」'); return true; } catch (e) {}
            }
        }
        return false;
    }

    // 展开折叠章节（旧版漏课的根因之一：折叠的课程根本不在 DOM 里）
    function expandCollapsed() {
        let n = 0;
        const sel = '.lis-title, .chapter-title, .lis-inside-title, [class*=chapter][onclick], ' +
                    '[class*=fold], [class*=collapse], [class*=zhang], h3[onclick], li[class*=title][onclick]';
        document.querySelectorAll(sel).forEach(function (el) {
            if (el._hyExpanded || el.tagName === 'A') return;
            const cls = (el.className || '').toString();
            const next = el.nextElementSibling;
            const siblingHidden = !!(next && next.nodeType === 1 && isHidden(next));
            const closedCls = /close|fold|collapse/i.test(cls);
            const hasOnclick = el.hasAttribute('onclick');
            if (!(siblingHidden || (closedCls && hasOnclick))) return;
            el._hyExpanded = true;
            try { el.click(); n++; } catch (e) {}
        });
        if (n) debugLog('已展开折叠目录 ' + n + ' 处');
        return n;
    }

    function loopGuard(key) {
        const now = Date.now();
        let m = {};
        try { m = JSON.parse(GM_getValue(LOOPGUARD_KEY, '{}')) || {}; } catch (e) { m = {}; }
        const rec = m[key] || { n: 0, t: 0 };
        if (now - rec.t > 5 * 60 * 1000) rec.n = 0;
        rec.n++; rec.t = now;
        m[key] = rec;
        try { GM_setValue(LOOPGUARD_KEY, JSON.stringify(m)); } catch (e) {}
        return rec.n;
    }

    // 回课程列表页的正确地址：
    // 实测 cme28.91huayi.com/pages/course.aspx 不带参数会直接 alert('参数错误') 然后关窗，
    // 所以优先用来路地址（一般就是带参数的课程列表页），退而求其次把当前查询参数带过去。
    function courseListFallbackUrl() {
        try {
            const ref = document.referrer || '';
            if (/^https?:\/\//i.test(ref) && ref.indexOf(location.host) >= 0 &&
                !/course_ware_polyv|course_ware_cc|exam\.aspx|exam_result/i.test(ref) &&
                /course|list|index|project/i.test(ref)) {
                return ref;
            }
        } catch (e) {}
        const qs = (location.search || '').replace(/^\?/, '');
        return '/pages/course.aspx' + (qs ? '?' + qs : '');
    }

    /* ---------- 视频页：找下一节 ---------- */
    async function scanVideoPage() {
        for (let attempt = 1; attempt <= CFG.rescan; attempt++) {
            expandCollapsed();
            const entries = collectEntries();

            if (entries.length === 0) {
                debugLog('未找到目录列表，尝试“下一节/下一课”按钮…');
                if (clickTextButton(['下一节', '下一课', '下一章', '下一个'])) return true;
                await sleep(CFG.rescanMs);
                continue;
            }

            const cur = currentIndex(entries);
            const order = pickOrder(entries.length, cur);
            let fallback = null;
            let examFallback = '';

            for (let i = 0; i < order.length; i++) {
                const idx = order[i];
                const li = entries[idx];
                const st = entryStatus(li);
                if (st === 'done') continue; // 已完成，跳过
                const url = extractUrl(li);
                debugLog('候选[' + idx + '] ' + shortTitle(li) + ' [' + (st || '未知') + '] → ' + (url || '未解析出链接'));
                if (st === 'exam') {
                    // 待考试课件：先记下它的 cwid，等没有未学课件时再进它的考试
                    const m = (url || '').match(/cwid=([A-Za-z0-9\-]+)/i);
                    if (m && currentMode !== 'video_only' && !examFallback) examFallback = m[1];
                    continue;
                }
                if (url) { go(url, '下一节'); return true; }
                if (!fallback) fallback = li;
            }

            if (examFallback) {
                debugLog('没有未学课件了，进入待考课件的考试：' + examFallback);
                return go('/pages/exam.aspx?cwid=' + examFallback, '待考课件');
            }

            if (fallback) {
                debugLog('找到未学课程但没解析出链接，改为直接点击');
                if (clickEntry(fallback)) { await sleep(2500); return true; }
            }
            if (clickTextButton(['下一节', '下一课', '下一章'])) return true;

            debugLog('第 ' + attempt + ' 次扫描没找到可跳转的下一节，' + (CFG.rescanMs / 1000) + 's 后重试');
            await sleep(CFG.rescanMs);
        }

        // 本章确实学完了 → 回课程列表页继续找下一章
        const path = window.location.pathname;
        if (/\/pages\/course\.aspx/i.test(path)) {
            debugLog('已在课程列表页，没有更多未学课程');
            return false;
        }
        if (loopGuard('to-list') > 8) {
            debugLog('回列表页次数过多，已停止，防止死循环');
            return false;
        }
        debugLog('本章目录已学完，返回课程列表继续找下一章');
        return go(courseListFallbackUrl(), '回课程列表');
    }

    /* ---------- 列表页：找下一门 ---------- */
    async function scanListPage() {
        for (let attempt = 1; attempt <= CFG.rescan; attempt++) {
            expandCollapsed();
            const entries = collectEntries();
            let todoWithUrl = null, todoNoUrl = null, unknownWithUrl = null;

            for (let i = 0; i < entries.length; i++) {
                const li = entries[i];
                const st = entryStatus(li);
                if (st === 'done' || st === 'exam') continue;
                const url = extractUrl(li);
                debugLog('列表项[' + i + '] ' + shortTitle(li) + ' [' + (st || '未知') + '] → ' + (url || '未解析出链接'));
                if (st === 'todo') {
                    if (url) { if (!todoWithUrl) todoWithUrl = url; }
                    else if (!todoNoUrl) todoNoUrl = li;
                } else if (!unknownWithUrl && url) {
                    unknownWithUrl = url; // 状态认不出的，作为次选
                }
            }

            if (todoWithUrl) { go(todoWithUrl, '未学课程'); return true; }
            if (todoNoUrl) {
                debugLog('有未学课程但没解析出链接，改为直接点击');
                if (clickEntry(todoNoUrl)) { await sleep(2500); return true; }
            }
            if (unknownWithUrl) { go(unknownWithUrl, '状态未知课程'); return true; }

            debugLog('第 ' + attempt + ' 次扫描没找到未学课程，' + (CFG.rescanMs / 1000) + 's 后重试');
            await sleep(CFG.rescanMs);
        }
        debugLog('扫描结束：本页没有找到未学课程（若确实有未学课程，请把上面的候选日志发我）');
        return false;
    }

    // 统一入口：跳下一课（force=true 时跳过“正在播放”保护，只给面板手动按钮用）
    async function jumpToNextCourse(force) {
        if (!force && videoIsPlaying()) {
            debugLog('视频还在播放，暂不跳转（防止本节没学完就跳走）');
            return false;
        }
        debugLog('查找下一门未学课程…');
        if (handleCourseCompletePage()) return true;

        const path = window.location.pathname;
        if (/\/pages\/course\.aspx/i.test(path) || /course_list\.aspx/i.test(path) || /course_ware\/course\.aspx/i.test(path)) {
            return await scanListPage();
        }
        return await scanVideoPage();
    }

    /* ==================== 考试模块 ==================== */
    function loadData(key) { try { return JSON.parse(GM_getValue(key, 'null')); } catch (e) { return null; } }
    function saveData(key, data) { GM_setValue(key, JSON.stringify(data)); }
    function removeData(key) { GM_deleteValue(key); }
    function normalize(txt) {
        return txt ? txt.trim().replace(/^\d+、\s*/, '').replace(/[()（）\s]/g, '') : '';
    }

    // 记录“视频看完，等考试”
    function markExamPending(cwid) {
        if (!cwid) return;
        const m = loadData(EXAMDONE_KEY) || {};
        m['pending_' + cwid] = Date.now();
        saveData(EXAMDONE_KEY, m);
    }
    // 记录“这门课的考试刚考完”
    function markExamDone(cwid) {
        const m = loadData(EXAMDONE_KEY) || {};
        const now = Date.now();
        if (cwid) {
            m[cwid] = now;
            delete m['pending_' + cwid];
        }
        m.__last = now; // 全局“刚考完”时间戳
        saveData(EXAMDONE_KEY, m);
    }
    // 刚考完（3 分钟内）→ 回视频页时直接跳下一课，避免重复播放、重复交卷
    function isExamDoneRecently(cwid) {
        const m = loadData(EXAMDONE_KEY) || {};
        if (cwid && m[cwid] && Date.now() - m[cwid] < 180 * 1000) return true;
        // 实测 exam_result.aspx 的 cwid 和视频页的 cwid 并不一致，所以再兜一层全局时间戳
        return !!m.__last && (Date.now() - m.__last < 180 * 1000);
    }

    async function handleExamPage() {
        debugLog('开始考试');
        const questions = document.querySelectorAll('.tablestyle');
        if (questions.length === 0) {
            debugLog('未找到题目');
            return;
        }

        const allAnswers = loadData(STORAGE.allAnswer) || {};
        const title = document.title || '未知章节';
        let rightAnswers = loadData(STORAGE.rightAnswer) || {};
        if (Object.keys(rightAnswers).length === 0 && allAnswers[title]) {
            rightAnswers = allAnswers[title];
        }

        let currentTest = loadData(STORAGE.test) || {};
        const testAnswers = {};

        for (let index = 0; index < questions.length; index++) {
            const qEl = questions[index];
            const qText = normalize((qEl.querySelector('.q_name') || {}).innerText || '');
            if (!qText) continue;

            const options = qEl.querySelectorAll('tbody label');
            if (options.length === 0) continue;

            if (rightAnswers[qText]) {
                const answerText = rightAnswers[qText];
                for (let i = 0; i < options.length; i++) {
                    if (normalize(options[i].innerText) === answerText) {
                        options[i].click();
                        debugLog('题目「' + qText + '」已选答案: ' + answerText);
                        break;
                    }
                }
                continue;
            }

            let selected = false;
            const wrongs = loadData(STORAGE.result) || {};
            const wrongList = wrongs[qText] || [];

            for (let i = 0; i < options.length; i++) {
                const content = normalize(options[i].innerText);
                if (wrongList.indexOf(content) < 0) {
                    options[i].click();
                    testAnswers[qText] = content;
                    if (!currentTest[qText]) currentTest[qText] = [];
                    currentTest[qText].push(content);
                    selected = true;
                    debugLog('试错选择: 「' + qText + '」 → 「' + content + '」');
                    break;
                }
            }

            if (!selected) {
                options[0].click();
                testAnswers[qText] = normalize(options[0].innerText);
                debugLog('所有选项试过，选第一个: 「' + qText + '」');
            }

            await sleep(randomDelay(500, 1500));
        }

        saveData(STORAGE.test, currentTest);
        saveData(STORAGE.testAnswer, testAnswers);

        setTimeout(function () {
            const btn = document.getElementById('btn_submit');
            if (btn) { btn.click(); debugLog('已交卷'); }
            else debugLog('找不到提交按钮');
        }, DELAY.submit + randomDelay(0, DELAY.random));
    }

    async function handleResultPage() {
        debugLog('处理考试结果');
        const tipText = ((document.querySelector('.tips_text') || {}).innerText || '');
        const bodyText = (((document.body || {}).innerText) || '').replace(/\s+/g, '');
        // 有“重新考试”入口 → 基本就是没过；一个重考入口都没有 → 当作已通过（否则会卡在这一页）
        const hasRetry = !!document.querySelector('input[value="重新考试"], input[value="再考一次"], button[value="重新考试"], input[value="再考"]');
        // 实测这页写的是“本课件已学习完毕”，旧脚本只认“考试通过/完成项目学习”，
        // 结果把“已通过”误判成“未通过”，再去找不存在的“重新考试”按钮，就卡死在这页。
        let isPassed = /考试通过|完成项目学习|恭喜|合格|已通过|通过考试|学习完毕|学习完成/.test(tipText + bodyText);
        if (!isPassed && !hasRetry) {
            isPassed = true;
            debugLog('结果页没有任何“重新考试”入口，按已通过处理');
        }

        const wrongs = loadData(STORAGE.result) || {};
        const testAnswers = loadData(STORAGE.testAnswer) || {};
        const rightAnswers = loadData(STORAGE.rightAnswer) || {};
        const allAnswers = loadData(STORAGE.allAnswer) || {};
        const title = document.title || '未知章节';
        const cwid = getCwidFromUrl();

        if (isPassed) {
            debugLog('考试通过，记录正确答案');
            for (const q in testAnswers) {
                if (!wrongs[q]) rightAnswers[q] = testAnswers[q];
            }
            if (!allAnswers[title]) allAnswers[title] = {};
            Object.assign(allAnswers[title], rightAnswers);
            saveData(STORAGE.allAnswer, allAnswers);
            saveData(STORAGE.rightAnswer, rightAnswers);
            removeData(STORAGE.test);
            removeData(STORAGE.testAnswer);
            removeData(STORAGE.result);
            markExamDone(cwid);

            // 实测这个“考试结果”页其实是项目进度页（.state_cour_ul 列表），
            // 列表里就有下个课件的入口，直接用它继续，不用绕回视频页。
            const prog = collectProgressItems();
            if (prog.length) {
                debugLog('这是项目进度页（共 ' + prog.length + ' 项），直接从列表继续');
                if (handleProgressPage()) return;
                debugLog('进度页已无“未学/待考”课件，本流程结束');
                return;
            }

            if (cwid) {
                const videoUrl = '/course_ware/course_ware_polyv.aspx?cwid=' + cwid;
                debugLog('跳回视频页（该课考试已完成，会自动进入下一课）: ' + videoUrl);
                setTimeout(function () { window.location.href = videoUrl; }, 2000);
            } else {
                debugLog('未找到 cwid，跳转到课程列表');
                setTimeout(function () { window.location.href = courseListFallbackUrl(); }, 2000);
            }
        } else {
            debugLog('考试未通过，记录错题');
            const items = document.querySelectorAll('.state_cour_lis');
            const newWrongs = {};
            for (let i = 0; i < items.length; i++) {
                const item = items[i];
                const qEl = item.querySelector('.state_lis_text:first-of-type');
                const qTitle = qEl ? qEl.title : '';
                if (!qTitle) continue;
                const ansEl = item.querySelectorAll('.state_lis_text')[1];
                const ansText = (ansEl ? ansEl.innerText : '').replace(/【您的答案：|】/g, '') || '';
                const errImg = item.querySelector('.state_error');
                const isCorrect = !!(errImg && errImg.src && errImg.src.indexOf('bar_img.png') >= 0);
                const qKey = normalize(qTitle);
                if (!isCorrect && qKey) {
                    if (!newWrongs[qKey]) newWrongs[qKey] = [];
                    newWrongs[qKey].push(normalize(ansText));
                }
            }
            for (const q in newWrongs) {
                if (!wrongs[q]) wrongs[q] = [];
                for (let i = 0; i < newWrongs[q].length; i++) {
                    if (wrongs[q].indexOf(newWrongs[q][i]) < 0) wrongs[q].push(newWrongs[q][i]);
                }
            }
            saveData(STORAGE.result, wrongs);
            const retryBtn = document.querySelector('input[value="重新考试"]');
            if (retryBtn) {
                setTimeout(function () { retryBtn.click(); }, DELAY.retry + randomDelay(0, DELAY.random));
                debugLog('点击重新考试');
            } else {
                debugLog('未找到重新考试按钮');
            }
        }
    }

    /* ============ 项目进度页（exam_result.aspx 的“本课件已学习完毕”版） ============
     * 实测结构：
     *   .tips_text              = “本课件已学习完毕”
     *   .state_cour_ul > li.state_cour_lis
     *        p.state_lis_text   （title 属性 = 课件名）
     *        input.state_lis_btn（value = 已完成 / 待考试 / 立即学习）
     *   只有“立即学习”的按钮带
     *        onclick="javascript: window.location.href='../course_ware/course_ware.aspx?cwid=...'"
     *   “已完成”“待考试”的按钮没有 onclick，页面本身不提供入口。
     */
    function collectProgressItems() {
        const out = [];
        document.querySelectorAll('.state_cour_lis').forEach(function (li) {
            const btn = li.querySelector('.state_lis_btn') || li.querySelector('input[type=button]');
            const value = btn ? ((btn.value || btn.innerText || '') + '').trim() : '';
            const oc = (btn && btn.getAttribute && btn.getAttribute('onclick')) || '';
            const m = oc.match(/cwid=([A-Za-z0-9\-]+)/i);
            const tEl = li.querySelector('.state_lis_text');
            const title = (tEl && tEl.getAttribute && tEl.getAttribute('title')) || (tEl ? tEl.innerText : '') || '';
            const u = (oc.match(URL_RE) || [])[0] || '';
            out.push({
                li: li, btn: btn, title: title.replace(/\s+/g, ' ').trim(),
                raw: value, status: classify(value),
                cwid: m ? m[1] : '', url: u ? absUrl(u) : ''
            });
        });
        return out;
    }

    function handleProgressPage() {
        const items = collectProgressItems();
        if (!items.length) return false;

        const todo = items.filter(function (x) { return x.status === 'todo'; });
        const exam = items.filter(function (x) { return x.status === 'exam'; });
        debugLog('进度页：共 ' + items.length + ' 项，未学 ' + todo.length + ' 项，待考 ' + exam.length + ' 项');

        // 1) 有未学课件 → 直接用它自带的 onclick 地址进去
        if (todo.length) {
            const t = todo[0];
            const url = t.url || (t.cwid ? '/course_ware/course_ware.aspx?cwid=' + t.cwid : '');
            if (url) {
                debugLog('进入未学课件：' + t.title.slice(0, 26));
                return go(url, '进度页→未学课件');
            }
            if (t.btn) {
                try { t.btn.click(); debugLog('点击“立即学习”：' + t.title.slice(0, 26)); return true; } catch (e) {}
            }
        }

        // 2) 没有未学、但有“待考试” → 回课件页；那页的左侧目录里带 cwid，
        //    由 scanVideoPage 负责把这些待考课件送进考试
        if (exam.length) {
            const cwid = getCwidFromUrl();
            if (cwid) {
                debugLog('没有未学课件了，但还有 ' + exam.length + ' 个待考课件，回课件页取它们的 cwid');
                return go('/course_ware/course_ware_polyv.aspx?cwid=' + cwid, '进度页→回课件页处理待考');
            }
        }

        debugLog('进度页已无“未学/待考”课件');
        return false;
    }

    function startExamQueueManually() {
        debugLog('扫描待考课程');
        const path = window.location.pathname;

        if (/\/pages\/course\.aspx/i.test(path) || /course_list\.aspx/i.test(path)) {
            const entries = collectEntries();
            for (let i = 0; i < entries.length; i++) {
                const li = entries[i];
                if (entryStatus(li) !== 'exam') continue;
                let url = extractUrl(li);
                if (!/exam/i.test(url)) {
                    const m = (li.innerHTML || '').match(/cwid=([A-Za-z0-9\-]+)/i);
                    if (m) url = '/pages/exam.aspx?cwid=' + m[1];
                }
                if (url && /exam/i.test(url)) { go(url, '进入待考课程'); return true; }
            }
            debugLog('没有待考课程');
            return false;
        }

        const cwid = getCwidFromUrl();
        if (cwid) { go('/pages/exam.aspx?cwid=' + cwid, '直接进入考试'); return true; }
        debugLog('未找到 cwid');
        return false;
    }

    /* ==================== 主路由 ==================== */
    function main() {
        createDebugWindow();
        initPopupKiller();   // 先装弹窗猎杀，保证“异常插件”弹窗第一时间被关掉
        initPopupBlocker();

        const path = window.location.pathname;
        const cwid = getCwidFromUrl();

        // 课程列表 / 课程详情页
        if (/\/pages\/course\.aspx/i.test(path) || /course_ware\/course\.aspx/i.test(path) || /course_list\.aspx/i.test(path)) {
            debugLog('课程页面');
            if (handleCourseCompletePage()) return;

            if (currentMode === 'exam_only') {
                debugLog('仅考试模式');
                setTimeout(startExamQueueManually, 2000);
            } else {
                setTimeout(async function () {
                    const jumped = await jumpToNextCourse();
                    // 视频都学完了，且是“视频+考试”模式 → 接着找待考课程
                    if (!jumped && currentMode === 'video_exam') startExamQueueManually();
                }, 2000);
            }
            return;
        }

        // 视频页（含目录项链接指向的 course_ware.aspx）
        if (/course_ware_polyv\.aspx/i.test(path) || /course_ware_cc\.aspx/i.test(path) || /course_ware\/course_ware\.aspx/i.test(path)) {
            debugLog('视频页面');
            if (currentMode === 'exam_only') {
                debugLog('仅考试模式，不播放视频');
                return;
            }
            observeVideos();

            // 刚考完试回来 → 这门课已经结束，直接找下一课（避免重复播放/重复交卷）
            if (currentMode === 'video_exam' && isExamDoneRecently(cwid)) {
                const entries0 = collectEntries();
                const idx0 = currentIndex(entries0);
                const st0 = idx0 >= 0 ? entryStatus(entries0[idx0]) : '';
                if (st0 === 'todo') {
                    debugLog('刚考完试，但本节状态是“还没学完”，继续播放本课');
                } else {
                    debugLog('本课考试刚刚完成（本节状态：' + (st0 || '未知') + '），直接进入下一课');
                    // 这里用 force：本课考试已通过，属于“确定已学完”，
                    // 否则会被“视频正在播放”保护挡住，又把整节视频重播一遍。
                    setTimeout(function () { jumpToNextCourse(true); }, 3000);
                    return;
                }
            }

            // 进入考试按钮（视频看完后启用）
            const examBtn = document.getElementById('jrks');
            if (examBtn) {
                const check = setInterval(function () {
                    if (examBtn.getAttribute('disabled') === null) {
                        clearInterval(check);
                        debugLog('考试按钮已激活');
                        if (currentMode === 'video_exam') {
                            if (cwid) setTimeout(function () {
                                window.location.href = '/pages/exam.aspx?cwid=' + cwid;
                            }, DELAY.examEnter + randomDelay(0, DELAY.random));
                        } else {
                            setTimeout(function () { jumpToNextCourse(); }, 3000);
                        }
                    }
                }, 2000);
            }

            // 自动播放：直接 play() 若被自动播放策略拦下，就补一次合成点击，
            // 每 1.5s 一轮、最多 4 轮；只要已经在播就立刻停手，
            // 每轮都以 play() 收尾，避免“点击把已播的视频切回暂停”。
            let kickTries = 0;
            const kickTimer = setInterval(function () {
                kickTries++;
                const v = document.querySelector('video');
                if (!v) {
                    // 取不到 <video>（播放器可能在跨域 iframe 里），少量尝试后放弃，避免乱点
                    if (kickTries >= 3) clearInterval(kickTimer);
                    return;
                }
                if (!v.paused && !v.ended) { clearInterval(kickTimer); return; }   // 已经在播
                v.muted = true;
                v.volume = 0;
                kickUserActivation();
                setTimeout(function () {
                    const v2 = document.querySelector('video');
                    if (v2 && v2.paused && !v2.ended) {
                        const p = v2.play();
                        if (p && p.catch) p.catch(function () {});
                    }
                }, 400);
                if (kickTries >= 4) clearInterval(kickTimer);
            }, 1500);

            // 进页自动切“流畅”：切画质会让播放器重载媒体、位置被判定成跳变，
            // 实测疑似就是“刚进页面就弹‘不能拖拽’”的诱因，而它只是为了省流量，默认关闭。
            // 需要时把 CFG.autoQuality 改成 true。
            if (CFG.autoQuality) {
                setTimeout(function () {
                    const qBtn = document.querySelector('.pv-quality-btn');
                    if (!qBtn) return;
                    qBtn.click();
                    setTimeout(function () {
                        const list = document.querySelectorAll('.pv-quality-select div');
                        for (let i = 0; i < list.length; i++) {
                            if (list[i].innerText === '流畅') { list[i].click(); break; }
                        }
                    }, 500);
                }, 3000);
            }

            // 页面自检（45s 后）：没播放器 + 考试入口没激活 + 站点明确标注本节“已完成”，才跳下一课。
            // 旧版这里用的是 20s 且只看 <video>，播放器稍晚加载就会被误判成“没视频”，
            // 结果就是“本节没学完就跳走”。
            setTimeout(function () {
                const eb = document.getElementById('jrks');
                const examReady = !!(eb && eb.getAttribute('disabled') === null);
                if (examReady || hasPlayerOnPage() || videoIsPlaying()) {
                    debugLog('自检：仍有播放器或考试入口，保持在本节');
                    return;
                }
                const entries = collectEntries();
                const idx = currentIndex(entries);
                const st = idx >= 0 ? entryStatus(entries[idx]) : '';
                debugLog('自检：本节状态 = ' + (st || '未知'));
                if (st === 'done') { debugLog('本节已学完，跳下一课'); jumpToNextCourse(); }
            }, 45000);
            return;
        }

        // 考试页
        if (/\/exam\.aspx/i.test(path)) {
            debugLog('考试页面');
            if (currentMode !== 'video_only') handleExamPage();
            else debugLog('仅视频模式，跳过考试');
            return;
        }

        // 考试结果页
        if (/\/exam_result\.aspx/i.test(path)) {
            debugLog('考试结果页面');
            if (currentMode !== 'video_only') handleResultPage();
            else debugLog('仅视频模式，跳过考试结果处理');
            // 兜底：25s 后还停在这一页，说明既没跳下一课也没点“重新考试”，强行继续
            setTimeout(function () {
                debugLog('结果页停留超过 25s，兜底继续下一课');
                jumpToNextCourse(true);
            }, 25000);
            return;
        }

        // 未知页面：像课程页的（统计页 / 完成页 / 列表变体…）原来直接“不执行任务”，
        // 表现出来的就是“学完一课卡在这不跳了”。这里补一个兜底继续。
        const looksCoursey = /course|exam|cwid|study|stat|project|ware/i.test(path) ||
                             !!document.querySelector('li.lis-inside-content, a[href*=course_ware], #jrks');
        if (looksCoursey) {
            debugLog('未识别但像课程页（' + path + '），20s 后兜底继续下一课');
            setTimeout(function () {
                debugLog('兜底：尝试继续下一课');
                jumpToNextCourse();
            }, 20000);
        } else {
            debugLog('未知页面，不执行任务');
        }
    }

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