// ==UserScript==
// @name         气象继续教育 · 视频页自动刷课（精简版）
// @namespace    cma.jxjy.videoonly
// @version      1.5.0
// @description  只做一件事：你手动点进某个视频学习页后，自动把当前视频静音 + 倍速播放；播完自动点下一个未完成的节点继续刷。不碰课程列表、不碰班级页、不自动进下一门课 —— 所有跳转只发生在「视频/课件目录」内部。
// @author       WorkBuddy
// @match        https://cmatcpx-cmatc.cma.cn/*
// @match        https://pxkckj-cmatc.cma.cn/*
// @match        https://kjcourse-cmatc.cma.cn/*
// @match        https://kjkejian2-cmatc.cma.cn/*
// @grant        GM_getValue
// @grant        GM_setValue
// @grant        GM_registerMenuCommand
// @grant        GM_addStyle
// @grant        unsafeWindow
// @run-at       document-idle
// ==/UserScript==


 *
 * 触发方式：你【手动】点进一个视频/课件节点（学习页），脚本检测到目录和视频后才接管。
 * 自动跳转：只在这个课程的「节点目录」里往下跳（点下一个未完成节点），
 *          绝不跳出课程去选别的课。
 *
 * 完成判定（与 v2 同源，均来自真机逆向，非猜测）：
 *   · 权威接口 getSingleItemCompleteCase.json → result.completed == "1"
 *   · 目录里出现对号 .item_done_icon.done_icon_show
 *   · completestate 属性【不可信】，仅作诊断，不参与判定。
 *
 * 面板：右下角一个小卡片，可「开始/暂停」「静音开/关」「倍速 +/−」「日志」。
 * =====================================================================
 */
(function () {
    'use strict';

    var UW = (typeof unsafeWindow !== 'undefined' && unsafeWindow) ? unsafeWindow : window;

    /* ---------------- 常量（真机逆向，非猜测） ---------------- */
    var U = {
        ITEM_DONE: '/learnspace/learn/learnCourseware/getSingleItemCompleteCase.json'
    };
    var SEL = {
        FRAME_MENU: '#mainContent',
        POINT: 'div.s_point',
        POINT_ICON: '.item_done_icon',
        POINT_DONE_ICON: '.item_done_icon.done_icon_show',
        CW_VIDEO: '#course_player',
        CW_VIDEO_BOX: '#video_box',
        CW_START: '.continue .user_choise',
        /* 网页课件连播循环（天气动力学那类 #playerlist 目录，videoarr/playvideo/nowD） */
        PLAYER_LIST: '#playerlist',
        /* 专题列表页（getMyTopicPatternTheme）与专题详情页（mb0/index.html?classCode） */
        TOPIC_CARD: '#classList > li',
        TOPIC_TITLE: '.title',
        TOPIC_ENTER: 'a.btn-solid-primary[href*="classCode"], a.btn-solid-primary[href*="mb0"]',
        TOPIC_DONE_LAB: '.done-lab',
        TOPIC_COURSE_CARD: '.cma-card',
        TOPIC_COURSE_TITLE: '.title',
        TOPIC_COURSE_ENTER: 'a[onclick*="learnCourseUrl"]',
        TOPIC_COURSE_PROGRESS: '.split span[style*="width"]',
        /* 学习时长元素（等效显示：真实值 × 倍速） */
        LEARN_TIMER: '#learnTimer, #learnTime, .learnTime, [id*=learnTimer], [id*=learnTime]'
    };
    var T = {
        POINT_PREFIX: 's_point_',
        CS_ATTR: 'completestate',
        ITEM_TYPE_ATTR: 'itemtype'
    };

    /* ---------------- 可调参数 ---------------- */
    var CFG = {
        RATE: 16,              // 播放倍速（网页课件平台不限制，实测 16 都能跑满）
        MUTE: true,            // 默认静音
        POLL_MS: 1500,         // 轮询间隔
        DONE_WAIT_SEC: 360,    // 播完后等平台写完成状态的上限
        WC_REPORT_WAIT_MS: 22000, // 网页课件播完后等上报再切节点
        DONE_HTTP_TIMEOUT_MS: 8000, // 查完成接口超时
        DONE_CACHE_MS: 3000,   // 完成状态短缓存
        CW_CLICK_MAX: 3,       // 「开始学习」最多点几次
        CW_HEAL_MAX: 3,        // 空源视频自愈最多几次（重复点开始会把视频换成空源）
        CW_BADGE: true,        // 课件 iframe 里贴角标（跨站 iframe 父页面看不到里面）
        LAYER_POLL_MS: 1500,   // 弹窗轮询
        SEG_POLL_MS: 2000,     // 网页课件分段连播：段序号采样间隔
        SEG_SWITCH_WAIT_MS: 2000, // 分段切换后给播放器重建的时间
        EQ_TICK_MS: 500,       // 等效时长刷新间隔（比平台每秒写一次更快）
        EQ_TAIL: true          // 数值后挂小尾巴（倍速/真实值/已刷比例）
    };

    var GMKEY = {
        ON: 'jx2vo_on',
        MUTE: 'jx2vo_mute',
        RATE: 'jx2vo_rate'
    };

    /* ---------------- 工具 ---------------- */
    function $(sel, root) { try { return (root || document).querySelector(sel); } catch (e) { return null; } }
    function $$(sel, root) { try { return Array.prototype.slice.call((root || document).querySelectorAll(sel)); } catch (e) { return []; } }
    function txt(el) { return el ? String(el.innerText || el.textContent || '').replace(/\s+/g, ' ').trim() : ''; }
    function sleep(ms) { return new Promise(function (r) { setTimeout(r, ms); }); }
    function nowMs() { return Date.now(); }
    function rawGet(k, d) { try { var v = GM_getValue(k, undefined); return (v === undefined) ? d : v; } catch (e) { return d; } }
    function rawSet(k, v) { try { GM_setValue(k, v); } catch (e) { } }

    function waitFor(fn, timeoutMs, stepMs) {
        return new Promise(function (resolve) {
            var t0 = nowMs();
            (function tick() {
                var v = null;
                try { v = fn(); } catch (e) { v = null; }
                if (v) return resolve(v);
                if (nowMs() - t0 >= timeoutMs) return resolve(null);
                setTimeout(tick, stepMs || 400);
            })();
        });
    }

    /* ---------------- 日志与面板 ---------------- */
    var LOG = [];
    var log = {
        info: function (m) { LOG.push('[信息] ' + m); paintLog(); },
        ok: function (m) { LOG.push('[完成] ' + m); paintLog(); },
        warn: function (m) { LOG.push('[警告] ' + m); paintLog(); },
        err: function (m) { LOG.push('[错误] ' + m); paintLog(); }
    };
    function paintLog() {
        var lg = document.getElementById('jx2vo_log');
        if (lg && lg.style.display === 'block') { lg.textContent = LOG.slice(-40).join('\n'); lg.scrollTop = lg.scrollHeight; }
    }
    function setState(s) { var e = document.getElementById('jx2vo_state'); if (e) e.textContent = s; }
    function isRunning() { return rawGet(GMKEY.ON, false) === true; }
    function setRunning(v) {
        rawSet(GMKEY.ON, !!v);
        var b = document.getElementById('jx2vo_go');
        if (b) { b.className = v ? 'on' : ''; b.textContent = v ? '暂停' : '开始'; }
    }

    function buildPanel() {
        if (document.getElementById('jx2vo_panel')) return;
        var div = document.createElement('div');
        div.id = 'jx2vo_panel';
        div.innerHTML =
            '<div class="hd">视频自动刷课 <span class="st" id="jx2vo_state">—</span></div>'
            + '<div class="rows">'
            + '  <div class="row">倍速：<b id="jx2vo_rate">' + CFG.RATE + '</b>x　静音：<b id="jx2vo_mute">'
            + (CFG.MUTE ? '开' : '关') + '</b></div>'
            + '</div>'
            + '<div class="btns">'
            + '  <button id="jx2vo_go">开始</button>'
            + '  <button id="jx2vo_mutebtn">静音</button>'
            + '  <button id="jx2vo_rateup">倍速+</button>'
            + '  <button id="jx2vo_ratedn">倍速−</button>'
            + '  <button id="jx2vo_logbtn">日志</button>'
            + '</div>'
            + '<pre class="log" id="jx2vo_log" style="display:none"></pre>';
        div.style.cssText = 'position:fixed;right:16px;bottom:16px;z-index:2147483000;'
            + 'width:300px;background:#fff;border:1px solid #d8dee6;border-radius:10px;'
            + 'box-shadow:0 6px 24px rgba(0,0,0,.15);font:12px/1.5 "Microsoft YaHei",sans-serif;color:#333;';
        document.body.appendChild(div);

        var stl = document.createElement('style');
        stl.textContent =
            '#jx2vo_panel .hd{background:#1a4f96;color:#fff;padding:8px 12px;border-radius:10px 10px 0 0;font-weight:700}'
            + '#jx2vo_panel .hd .st{font-weight:400;opacity:.85;float:right}'
            + '#jx2vo_panel .rows{padding:8px 12px 4px}'
            + '#jx2vo_panel .row{padding:2px 0}'
            + '#jx2vo_panel .btns{display:flex;gap:4px;padding:0 12px 10px}'
            + '#jx2vo_panel button{flex:1 1 auto;min-width:0;padding:5px 2px;border:1px solid #d8dee6;background:#f7f9fc;border-radius:6px;cursor:pointer;font-size:12px;line-height:1.2;color:#333;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}'
            + '#jx2vo_panel button.on{background:#1a4f96;color:#fff;border-color:#1a4f96}'
            + '#jx2vo_panel .log{display:none;max-height:220px;overflow:auto;margin:0 12px 10px;padding:6px;background:#f6f8fa;border:1px solid #eee;border-radius:6px;white-space:pre-wrap}';
        document.head.appendChild(stl);

        document.getElementById('jx2vo_go').addEventListener('click', function () { setRunning(!isRunning()); });
        document.getElementById('jx2vo_mutebtn').addEventListener('click', function () {
            CFG.MUTE = !CFG.MUTE; rawSet(GMKEY.MUTE, CFG.MUTE);
            paintMute();
            log.info('静音 ' + (CFG.MUTE ? '开' : '关'));
        });
        document.getElementById('jx2vo_rateup').addEventListener('click', function () {
            CFG.RATE = Math.min(16, (CFG.RATE || 1) + 1); rawSet(GMKEY.RATE, CFG.RATE);
            paintRate(); log.info('倍速 → ' + CFG.RATE + 'x');
        });
        document.getElementById('jx2vo_ratedn').addEventListener('click', function () {
            CFG.RATE = Math.max(1, (CFG.RATE || 1) - 1); rawSet(GMKEY.RATE, CFG.RATE);
            paintRate(); log.info('倍速 → ' + CFG.RATE + 'x');
        });
        document.getElementById('jx2vo_logbtn').addEventListener('click', function () {
            var lg = document.getElementById('jx2vo_log');
            lg.style.display = (lg.style.display === 'block') ? 'none' : 'block';
            paintLog();
        });

        paintMute(); paintRate();
    }
    function paintMute() { var e = document.getElementById('jx2vo_mute'); if (e) e.textContent = CFG.MUTE ? '开' : '关'; }
    function paintRate() { var e = document.getElementById('jx2vo_rate'); if (e) e.textContent = CFG.RATE; }

    /* ---------------- 目录读取 ---------------- */
    function hasPoints(d) {
        if (!d) return false;
        try { return !!d.querySelector(SEL.POINT); } catch (e) { return false; }
    }
    function menuDoc() {
        if (hasPoints(document)) return document;
        var f = $(SEL.FRAME_MENU);
        if (f) { try { if (f.contentDocument && hasPoints(f.contentDocument)) return f.contentDocument; } catch (e) { } }
        return null;
    }
    function menuWin() {
        try { if (typeof UW.openLearnResItem === 'function') return UW; } catch (e) { }
        try { if (typeof window.openLearnResItem === 'function') return window; } catch (e) { }
        var f = $(SEL.FRAME_MENU);
        if (!f) return null;
        try { return f.contentWindow; } catch (e) { return null; }
    }

    function readPoints() {
        var d = menuDoc();
        if (!d) return null;
        var nodes = $$(SEL.POINT, d);
        if (!nodes.length) return null;
        return nodes.map(function (n) {
            var byAttr = n.getAttribute(T.CS_ATTR) === '1'; // 不可信，仅诊断
            var byIcon = false;
            try { byIcon = !!n.querySelector(SEL.POINT_DONE_ICON); } catch (e) { }
            return {
                id: String(n.id || '').replace(T.POINT_PREFIX, ''),
                type: n.getAttribute(T.ITEM_TYPE_ATTR) || '',
                done: byIcon,
                csFlag: byAttr,
                title: txt(n).replace(/^[^：]*：/, '').slice(0, 60),
                el: n
            };
        });
    }

    function forceTick(p) {
        try {
            var el = p.el;
            if (!el) return;
            el.setAttribute(T.CS_ATTR, '1');
            try { el.classList.remove('undo_item_bgc'); } catch (e) { }
            var icon = el.querySelector(SEL.POINT_ICON);
            if (icon) icon.classList.add('done_icon_show');
        } catch (e) { }
    }

    /* ---------------- 完成判定（权威接口） ---------------- */
    var DONE_CACHE = {};
    async function checkDone(courseId, itemId) {
        var ck = String(courseId) + '|' + String(itemId);
        try { var c = DONE_CACHE[ck]; if (c && nowMs() - c.t < CFG.DONE_CACHE_MS) return c.v; } catch (e) { }

        var val = null;
        var ctl = null, timer = 0;
        try {
            if (typeof AbortController === 'function') {
                ctl = new AbortController();
                timer = setTimeout(function () { try { ctl.abort(); } catch (e) { } }, CFG.DONE_HTTP_TIMEOUT_MS);
            }
            var r = await fetch(U.ITEM_DONE, {
                method: 'POST',
                headers: { 'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8', 'X-Requested-With': 'XMLHttpRequest' },
                body: new URLSearchParams({ 'params.courseId': courseId, 'params.itemId': itemId }).toString(),
                credentials: 'include',
                signal: ctl ? ctl.signal : undefined
            });
            var j = await r.json();
            if (j && j.success && j.result) val = (String(j.result.completed) === '1');
        } catch (e) { val = null; }
        try { if (timer) clearTimeout(timer); } catch (e) { }

        try { DONE_CACHE[ck] = { t: nowMs(), v: val }; } catch (e) { }
        return val;
    }

    /* ---------------- 媒体驱动 ---------------- */
    function eachDoc(cb, doc, depth) {
        doc = doc || document;
        depth = depth || 0;
        try { if (cb(doc) === false) return; } catch (e) { }
        if (depth >= 6) return;   /* 放宽到 6 层，覆盖深嵌套 iframe（跨域帧由各自域实例兜底） */
        var fs = null;
        try { fs = doc.querySelectorAll('iframe'); } catch (e) { return; }
        for (var i = 0; i < fs.length; i++) {
            var d = null;
            try { d = fs[i].contentDocument; } catch (e) { d = null; }
            if (d) eachDoc(cb, d, depth + 1);
        }
    }

    function mediaList() {
        var out = [];
        eachDoc(function (d) {
            try {
                var a = d.querySelectorAll('video,audio');
                for (var i = 0; i < a.length; i++) if (out.indexOf(a[i]) < 0) out.push(a[i]);
            } catch (e) { }
        }, document, 0);
        return out;
    }

    function driveAll() {
        var ms = mediaList();
        if (!ms.length) return null;
        var rate = CFG.RATE;
        var st = { n: 0, t: 0, dur: 0, ended: false, paused: false, el: null };
        for (var i = 0; i < ms.length; i++) {
            var m = ms[i];
            try {
                if (CFG.MUTE) { try { m.muted = true; m.defaultMuted = true; } catch (e) { } }
                var dur = Number(m.duration) || 0;
                var t = Number(m.currentTime) || 0;
                var atEnd = !!m.ended || (dur > 0 && t >= dur - 1);
                if (!atEnd && m.paused) {
                    var p = m.play();
                    if (p && p.catch) p.catch(function () { });
                }
                if (rate && rate !== 1 && m.playbackRate !== rate) { try { m.playbackRate = rate; } catch (e) { } }
                st.n++;
                if (dur >= st.dur) {
                    st.dur = Math.round(dur); st.t = Math.round(t);
                    st.el = m; st.ended = atEnd; st.paused = !!m.paused;
                }
            } catch (e) { }
        }
        return st.n ? st : null;
    }

    /* SCO 课件页的主视频 */
    function cwMainFrame() {
        var cands = [];
        try { cands.push(document.getElementById('mainFrame')); } catch (e) { }
        try { var f = $(SEL.FRAME_MENU); if (f && f.contentDocument) cands.push(f.contentDocument.getElementById('mainFrame')); } catch (e) { }
        for (var i = 0; i < cands.length; i++) { if (cands[i]) return cands[i]; }
        return null;
    }
    function wcVideo() {
        try {
            var mf = cwMainFrame();
            var d = mf && mf.contentDocument;
            return (d && d.querySelector('video')) || null;
        } catch (e) { return null; }
    }

    function wcDrive() {
        var v = wcVideo();
        var st = driveAll();
        if (!st) return null;
        if (v) {
            try {
                var d = Number(v.duration) || 0, t = Number(v.currentTime) || 0;
                st.el = v;
                st.dur = Math.round(d);
                st.t = Math.round(t);
                st.ended = !!v.ended || (d > 0 && t >= d - 1);
                st.paused = !!v.paused;
            } catch (e) { }
        }
        return st;
    }

    /* ---------------- SCO 单视频课件：getDuration 补丁 ----------------
       平台的 jquery.course.player.video.js 里 getDuration() 返回 player.duration，
       而 player.duration 从来没被赋过值（=undefined）→ doQuit() 里
       `player.getDuration() - 60 <= max_time` 恒为 `NaN <= x` = false，
       cmi.core.lesson_status="completed" 那一句【永远不执行】→ 白刷。
       这里只在平台自己算不出有限值时接管，改成动态读真实时长（与 v2 同源）。 */
    var DUR_PATCHED = false;
    function patchGetDuration() {
        if (DUR_PATCHED) return false;
        try {
            var pl = null;
            try { pl = UW.player; } catch (e) { pl = null; }
            if (!pl || typeof pl.getDuration !== 'function') return false;
            var cur = null;
            try { cur = pl.getDuration(); } catch (e) { cur = null; }
            if (cur !== null && isFinite(Number(cur)) && Number(cur) > 0) {
                DUR_PATCHED = true;   // 平台自己正常，别多事
                return false;
            }
            pl.getDuration = function () {
                try {
                    var v = document.getElementById('course_player') || document.querySelector('video');
                    var d = v ? Number(v.duration) : NaN;
                    return (isFinite(d) && d > 0) ? d : NaN;
                } catch (e) { return NaN; }
            };
            DUR_PATCHED = true;
            log.warn('平台 player.getDuration() 返回 ' + String(cur) + '（写不出完成状态的元凶），已改为动态读真实时长');
            return true;
        } catch (e) { return false; }
    }

    /* ---------------- SCO 单视频课件：自动刷课 + 上报 ----------------
       kjcourse 域课件（#course_player + .continue .user_choise）跑在跨域 iframe 里，
       顶层够不到它的 video 和 doQuit()，所以这个循环【必须在课件 iframe 内】运行。
       职责：点「开始学习」→ 保播放（静音+倍速）→ 播完 → doQuit() 上报完成。 */
    function scoLoop() {
        return (async function () {
            setState('SCO 视频课件');

            /* 先装静音补丁 —— 没有用户手势时带声音的 play() 会被浏览器自动播放策略拦掉 */
            patchMediaPlay();

            var t0 = nowMs();
            var startTries = 0;
            var lastStartTry = 0;
            var clicked = false;
            var started = false;
            var clickDone = false;
            var deadSince = 0;
            var lastReport = 0;
            var healTries = 0;
            var lastSeg = -1;        /* 上次采样到的分段序号（-1=未知），用于多段回绕判定 */
            var lastTime = -1;       /* 上次采样 currentTime，用于卡住检测 */
            var stuckSince = 0, stuckWarned = false;

            /* 等用户点「开始」（面板总开关，GM 存储跨 frame 共享）。没点之前只待命，不抢播。 */
            while (!isRunning()) {
                await sleep(1500);
                if (!$(SEL.CW_VIDEO) && !$(SEL.CW_START)) { setState('已离开课件'); return; }
            }
            log.info('SCO 课件开始驱动（已点开始）。');

            function curVideo() { return $(SEL.CW_VIDEO) || $('video'); }
            function videoAlive() {
                var v = curVideo();
                if (!v) return false;
                try {
                    if (v.currentSrc) return true;
                    if (v.getAttribute('src')) return true;
                    if (v.readyState > 0) return true;
                } catch (e) { }
                return false;
            }
            function findStartBtn() {
                var b = $(SEL.CW_START);
                if (b) return b;
                var all = $$('.continue div, .user_choise, #mask div, #mask span, #mask a, #mask button');
                for (var k = 0; k < all.length; k++) {
                    var t = String(all[k].textContent || '').replace(/\s+/g, '').trim();
                    if ((t === '开始学习' || t === '继续学习')) return all[k];
                }
                return null;
            }
            /* 空源视频自愈：重复点「开始学习」会让平台把 <video> 换成空源（永远不播）。
               检测到"有 video 元素但没有 src" → 按平台 switchPlayList 挂回 src 续播。 */
            function healDeadVideo() {
                if (healTries >= CFG.CW_HEAL_MAX) return false;
                var v = curVideo();
                if (!v) return false;
                try { if (v.getAttribute('src') || v.currentSrc) return false; } catch (e) { return false; }
                var list = null;
                try { list = UW.switchPlayList; } catch (e) { list = null; }
                if (!list || !list.length) return false;
                var idx = 0;
                try { idx = Math.min(Math.max(0, UW.player.currentIndex | 0), list.length - 1); } catch (e) { idx = 0; }
                var url = list[idx] && list[idx].url;
                if (!url) return false;
                healTries++;
                try {
                    v.setAttribute('src', url);
                    try { v.load(); } catch (e) { }
                    var pr = v.play();
                    if (pr && pr.catch) pr.catch(function () { });
                    log.warn('发现视频被换成空源（重复点「开始学习」的后果），已按播放列表自愈：' + url + '（第 ' + healTries + ' 次）');
                    return true;
                } catch (e) { log.err('视频自愈失败：' + e); return false; }
            }
            /* 多段 SCO：读 switchPlayList 是否还有下一段（单视频只有 1 段） */
            function hasNextClip() {
                try {
                    if (UW.player && UW.switchPlayList) {
                        return (UW.player.currentIndex + 1) < UW.switchPlayList.length;
                    }
                } catch (e) { }
                return false;
            }
            /* 课件 iframe 角标：跨站 iframe 父页面看不到里面，贴个小角标看出脚本活没活 */
            var BADGE = null;
            function badge(text, cls) {
                if (!CFG.CW_BADGE) return;
                try {
                    if (!BADGE || !document.documentElement.contains(BADGE)) {
                        BADGE = document.createElement('div');
                        BADGE.id = 'jx2vobadge';
                        BADGE.style.cssText = 'position:fixed;left:8px;top:8px;z-index:2147483647;font:12px/1.5 "Microsoft YaHei",sans-serif;'
                            + 'padding:2px 8px;border-radius:10px;color:#fff;background:rgba(184,28,34,.86);pointer-events:none;'
                            + 'box-shadow:0 1px 6px rgba(0,0,0,.25);opacity:.92';
                        (document.body || document.documentElement).appendChild(BADGE);
                    }
                    BADGE.textContent = text;
                    if (cls === 'ok') BADGE.style.background = 'rgba(22,140,80,.86)';
                    else if (cls === 'warn') BADGE.style.background = 'rgba(214,126,0,.9)';
                    else if (cls === 'err') BADGE.style.background = 'rgba(184,28,34,.9)';
                } catch (e) { }
            }

            /* 尽早上 getDuration 补丁，别等收尾 —— 平台自己 unload 那次的 doQuit 也要拿到有限时长 */
            if (!DUR_PATCHED) patchGetDuration();

            for (var i = 0; i < 40000; i++) {
                await sleep(2000);
                if (!isRunning()) { setState('已暂停'); return; }
                dismissLayers();

                /* 点「开始学习」是否已生效：平台 send_data=true 或视频已挂源即视为生效 */
                if (!clickDone) {
                    var sd = null;
                    try { sd = UW.send_data; } catch (e) { }
                    if (sd === true || videoAlive()) {
                        clickDone = true;
                        log.ok('「开始学习」已生效（共点 ' + startTries + ' 次），后续不再点击');
                    }
                }

                /* 点「开始学习」：只在未生效 + 视频未活 + 次数未用完时点 */
                var btn = null;
                if (!clickDone && !videoAlive() && startTries < CFG.CW_CLICK_MAX) {
                    btn = findStartBtn();
                    if (btn && (!clicked || nowMs() - lastStartTry > 5000)) {
                        lastStartTry = nowMs();
                        startTries++;
                        clicked = true;
                        try {
                            btn.click();
                            started = true;
                            log.info('已点击「' + txt(btn) + '」（第 ' + startTries + '/' + CFG.CW_CLICK_MAX + ' 次）');
                        } catch (e) { log.warn('点击失败：' + e); }
                    }
                } else if (!clickDone && startTries >= CFG.CW_CLICK_MAX && !videoAlive()) {
                    if (nowMs() - lastReport > 15000) {
                        lastReport = nowMs();
                        log.warn('已点满 ' + CFG.CW_CLICK_MAX + ' 次仍未起播，不再重试。');
                        badge('开始学习点了 ' + startTries + ' 次仍未起播', 'err');
                    }
                }

                /* 空源自愈：连续 4 秒"有 video 元素但无 src"才动手（平台切段瞬间也会短暂空源） */
                var vv = curVideo();
                if (vv && !videoAlive() && !findStartBtn() && (started || startTries > 0)) {
                    if (!deadSince) deadSince = nowMs();
                    else if (nowMs() - deadSince > 4000) { if (healDeadVideo()) deadSince = 0; }
                } else { deadSince = 0; }

                /* 兜底：页面没有「开始学习」弹窗时，改调平台 player.continuePlay() 起播 */
                var v = curVideo();
                if (!v && !btn && !started && (nowMs() - t0) > 30000) {
                    try {
                        if (UW.player && typeof UW.player.continuePlay === 'function') {
                            UW.player.continuePlay();
                            started = true;
                            log.info('页面上没有「开始学习」弹窗，改用平台 player.continuePlay() 启动');
                        }
                    } catch (e) { }
                }

                if (!v) {
                    badge('等待课件加载…', 'warn');
                    if (nowMs() - lastReport > 15000) {
                        lastReport = nowMs();
                        log.info('还没出现 video 元素，继续等…');
                    }
                    if (nowMs() - t0 > 150 * 60 * 1000) { log.warn('课件超时，收尾'); break; }
                    continue;
                }

                /* 保播放（静音 + 倍速 + 起播）；已播完的不再 play()（会从头重播） */
                var atEndNow = false;
                try { atEndNow = !!v.ended || (isFinite(v.duration) && v.duration > 0 && v.currentTime >= v.duration - 0.5); } catch (e) { }
                try {
                    if (CFG.MUTE) { v.muted = true; v.defaultMuted = true; }
                    if (CFG.RATE && CFG.RATE !== 1 && v.playbackRate !== CFG.RATE) v.playbackRate = CFG.RATE;
                    if (videoAlive() && v.paused && !atEndNow) {
                        var pr = v.play();
                        if (pr && pr.catch) pr.catch(function () { });
                    }
                } catch (e) { }

                var dur = 0, t = 0;
                try { dur = v.duration || 0; t = v.currentTime || 0; } catch (e) { }
                setState('播放中 ' + Math.floor(t) + '/' + Math.floor(dur) + 's');
                badge(v.paused ? ('已接管 · 暂停 ' + Math.floor(t) + '/' + Math.floor(dur) + 's')
                    : ('自动学习中 ' + Math.floor(t) + '/' + Math.floor(dur) + 's'), v.paused ? 'warn' : 'ok');

                /* 卡住检测：90 秒不前进就提醒（可能有需人工处理的提示） */
                if (lastTime >= 0 && Math.abs(t - lastTime) < 0.3) {
                    if (!stuckSince) stuckSince = nowMs();
                    else if (nowMs() - stuckSince > 90000 && !stuckWarned) {
                        stuckWarned = true;
                        log.warn('视频已 90 秒没有前进，可能页面上有需要人工处理的提示。');
                        badge('视频 90 秒没前进', 'err');
                    }
                } else { stuckSince = 0; stuckWarned = false; }
                lastTime = t;

                /* 多段回绕判定：段号比上次采样变小 = 一轮完整播完（平台自连播+循环类） */
                try {
                    var cwVa = UW.videoarr;
                    if (cwVa && cwVa.length) {
                        var dec = decodeURIComponent(v.currentSrc || v.src || '');
                        var seg = -1;
                        for (var si = 0; si < cwVa.length; si++) {
                            if (dec.indexOf(decodeURIComponent(String(cwVa[si]))) >= 0) { seg = si; break; }
                        }
                        if (seg >= 0) {
                            if (lastSeg >= 0 && seg < lastSeg) {
                                log.ok('课件分段一轮播完（第 ' + (lastSeg + 1) + '/' + cwVa.length + ' 段后平台循环回第 ' + (seg + 1) + ' 段），本节点收工');
                                break;
                            }
                            lastSeg = seg;
                        }
                    }
                } catch (e) { }

                /* 本段播完：单段 SCO 直接收工；多段 SCO 播完一段若还有下一段就继续 */
                var atEnd = false;
                try { atEnd = (dur > 0 && t >= dur - 1.5) || v.ended; } catch (e) { }
                if (atEnd) {
                    if (hasNextClip()) {
                        /* 多段 SCO：平台自己会切下一段（curr 自增），这里等它切，不主动收工 */
                        log.info('本段播完，还有下一段（' + (UW.player.currentIndex + 2) + '/' + UW.switchPlayList.length + '），等平台切段…');
                        badge('切下一段…', 'warn');
                        await sleep(3000);
                        continue;
                    }
                    log.ok('SCO 视频播完（' + Math.floor(dur) + ' 秒），提交学习记录…');
                    break;
                }

                if (nowMs() - t0 > 150 * 60 * 1000) { log.warn('课件超时，收尾'); break; }
            }

            /* 收尾：先 patchGetDuration，再调平台 doQuit() 写 completed（与 v2 cwLoop 同源） */
            var durPatched = patchGetDuration();
            try {
                if (typeof UW.doQuit === 'function') {
                    UW.doQuit();
                    log.info('已调用平台 doQuit() 提交学习记录（getDuration 修复=' + (durPatched ? '是' : '否（平台本来正常）') + '）');
                } else {
                    log.info('本课件没有 doQuit 入口，完成交由平台按播放位置自动判定');
                }
            } catch (e) { log.warn('doQuit 调用失败：' + e); }

            /* 通知顶层「本节点播完」，让顶层目录驱动切下一个节点 */
            try { window.top.postMessage({ __jx2: 'cw', ev: 'ended' }, '*'); } catch (e) { }
            try { if (window.parent !== window.top) window.parent.postMessage({ __jx2: 'cw', ev: 'ended' }, '*'); } catch (e) { }

            setState('SCO 节点已播完');

            /* 【v1.5.0】挂机判定型课件：播完视频后不立即收工，继续挂机扫弹窗。
               这类课件（kjcourse 跨域 SCORM 包，如专题课）的完成看【真实挂机时长】，
               由 content_webCourseware 帧每秒 totalStudyTime+1 自动累计。本帧要做的
               就是别让页面被 30 分钟一次的「学习确认」弹窗卡住 —— 持续点掉它，
               直到顶层 videoLoop 确认服务端 completed 后切节点（本帧随之被卸载）。
               上限 DONE_WAIT_SEC*2 就停，避免无限空转（顶层才是完成判定的主导）。 */
            var hang0 = nowMs();
            while (isRunning() && (nowMs() - hang0) < CFG.DONE_WAIT_SEC * 2 * 1000) {
                await sleep(CFG.LAYER_POLL_MS);
                dismissLayers();
                var hs = Math.round((nowMs() - hang0) / 1000);
                if (hs % 30 < 3) {
                    log.info('视频已播完，本课件为挂机判定型：正在挂机补学习时长（已 ' + hs + ' 秒），请保持页面开启。');
                    badge('挂机补时长中 · ' + Math.floor(hs / 60) + ' 分', 'warn');
                }
                /* 视频页已被顶层切走（节点完成）→ 本帧即将卸载，退出挂机 */
                if (!$(SEL.CW_VIDEO) && !$(SEL.CW_START)) { setState('已离开课件'); break; }
            }
            setState('SCO 节点已播完（挂机阶段结束）');
        })();
    }

    /* ---------------- 全局 16 倍速守护 ----------------
       不管什么课程样式、不管有没有目录识别，只要页面上有 video/audio，
       就静音 + 16 倍速 + 起播。应对所有"不同课程样式"——陌生播放器、
       没见过的目录结构，都能无条件 16 倍速推着走。
       独立于目录驱动：有目录的页面正常跑自动刷课，这个守护始终在底层保速。 */
    var _speedGuardOn = false;
    function globalSpeedGuard() {
        if (_speedGuardOn) return;
        _speedGuardOn = true;
        patchMediaPlay();
        (async function () {
            while (true) {
                try { driveAll(); } catch (e) { }
                await sleep(CFG.POLL_MS);
            }
        })();
    }

    /* ---------------- 静音补丁 ---------------- */
    var MEDIA_PATCHED = false;
    function patchMediaPlay() {
        if (MEDIA_PATCHED) return;
        var targets = [];
        try { if (UW.HTMLMediaElement) targets.push(UW.HTMLMediaElement.prototype); } catch (e) { }
        try { if (HTMLMediaElement && targets.indexOf(HTMLMediaElement.prototype) < 0) targets.push(HTMLMediaElement.prototype); } catch (e) { }
        for (var i = 0; i < targets.length; i++) {
            var proto = targets[i];
            if (!proto || proto.__jx2voPatched) continue;
            var orig = proto.play;
            if (typeof orig !== 'function') continue;
            proto.play = function () {
                try { if (CFG.MUTE) { this.muted = true; this.defaultMuted = true; this.setAttribute('muted', ''); } } catch (e) { }
                var r = orig.apply(this, arguments);
                if (r && typeof r.catch === 'function') r.catch(function () { });
                return r;
            };
            proto.__jx2voPatched = true;
            MEDIA_PATCHED = true;
        }
    }

    /* ---------------- 弹窗处理（学习确认弹窗等） ---------------- */
    var CLICK_WHITE = ['确定', '确认', '知道了', '我知道了', '继续学习', '开始学习', '继续', '关闭', '我已知晓'];
    var CLICK_BLACK = ['退出', '安全退出', '注销', '删除', '提交', '交卷', '报名', '立即报名', '退课', '取消选课', '支付', '结算', '评价', '问卷', '考试', '开始考试', '重置', '清空', '放弃'];
    function safeToClick(t) {
        if (!t) return false;
        for (var i = 0; i < CLICK_BLACK.length; i++) if (t.indexOf(CLICK_BLACK[i]) >= 0) return false;
        for (var j = 0; j < CLICK_WHITE.length; j++) if (t.indexOf(CLICK_WHITE[j]) >= 0) return true;
        return false;
    }
    /* 自动点掉学习确认弹窗（每 30 分钟一次的「确定」），只点安全按钮 */
    function dismissLayers() {
        try {
            var layers = $$('.layui-layer');
            for (var i = 0; i < layers.length; i++) {
                var btns = $$('.layui-layer-btn a', layers[i]);
                for (var j = 0; j < btns.length; j++) {
                    var t = txt(btns[j]);
                    if (safeToClick(t)) {
                        try { btns[j].click(); } catch (e) { }
                        return true;
                    }
                }
            }
        } catch (e) { }
        return false;
    }

    /* ---------------- 核心：视频页自动刷课循环 ---------------- */
    function videoLoop() {
        return (async function () {
            setState('视频页刷课');

            /* 拿 courseId：学习空间地址里带 params.courseId=… */
            var courseId = null;
            var m = location.search.match(/params\.courseId=([^&]+)/);
            if (m) courseId = decodeURIComponent(m[1]);

            patchMediaPlay();

            /* 等目录渲染出来（有 div.s_point 才算进了课件/视频目录） */
            var pts = await waitFor(function () { return readPoints(); }, 30000, 500);
            if (!pts) {
                setState('未发现视频目录');
                log.warn('没找到视频目录（div.s_point）。请确认已经点进了某个视频/课件的学习页。');
                return;
            }

            /* 每 30 分钟一次的学习确认弹窗，自动点「确定」 */
            setInterval(dismissLayers, CFG.LAYER_POLL_MS);

            for (var round = 0; round < 400; round++) {
                if (!isRunning()) { setState('已暂停'); return; }

                pts = readPoints();
                if (!pts) { setState('目录已关闭'); return; }

                /* 服务端权威校正：把已完成的节点打上对号 */
                var need = pts.filter(function (p) { return !p.done; });
                if (need.length && courseId) {
                    for (var b = 0; b < need.length; b += 5) {
                        if (!isRunning()) return;
                        var batch = need.slice(b, b + 5);
                        var res = await Promise.all(batch.map(function (p) { return checkDone(courseId, p.id); }));
                        for (var k = 0; k < batch.length; k++) {
                            if (res[k] === true) { batch[k].done = true; forceTick(batch[k]); }
                        }
                    }
                }

                var left = pts.filter(function (p) { return !p.done; });
                if (!left.length) {
                    log.ok('本课程所有节点已完成（平台已打勾）');
                    setState('本课程已学完');
                    return;   // 学完就停，不去别的课
                }

                /* 学第一个未完成节点 */
                var it = left[0];
                log.info('打开节点：' + (it.title || it.id) + '（' + it.type + '）');
                setState('学习中：' + (it.title || it.id).slice(0, 16));
                CW_MSG.endedAt = 0;   /* 每个节点重新清零，避免上个节点的 ended 信号残留 */

                var w = menuWin();
                var opened = false;
                if (w && typeof w.openLearnResItem === 'function') {
                    try { w.openLearnResItem(it.id, it.type, null, it.title); opened = true; } catch (e) { log.warn('openLearnResItem 失败：' + e); }
                }
                if (!opened) { try { it.el.click(); opened = true; } catch (e) { log.warn('点击节点失败：' + e); } }
                if (!opened) { log.err('打不开这个节点，跳过'); continue; }

                /* 等完成：权威接口为主，播完等上报 */
                var t0 = nowMs();
                var limit = 150 * 60 * 1000; // 150 分钟硬顶
                var okDone = false;
                var endedSeen = 0;
                while (nowMs() - t0 < limit) {
                    await sleep(CFG.POLL_MS);
                    if (!isRunning()) { setState('已暂停'); return; }
                    dismissLayers();

                    /* 驱动视频：静音 + 倍速 + 起播 */
                    var wc = wcDrive();
                    if (wc && wc.dur > 0 && nowMs() - t0 > 30000 && wc.t === 0) {
                        /* 视频一直没推进：可能是 SCO 需要点「开始学习」 */
                        var start = $(SEL.CW_START) || (function () {
                            var w_ = menuWin();
                            try { return w_ && w_.document && w_.document.querySelector(SEL.CW_START); } catch (e) { return null; }
                        })();
                        if (start) { try { start.click(); } catch (e) { } }
                    }

                    if (wc && wc.dur > 0 && wc.ended && !endedSeen) {
                        endedSeen = nowMs();
                        log.info('视频已播完，等平台写入完成状态（最多 ' + CFG.DONE_WAIT_SEC + ' 秒）…');
                    }
                    if (endedSeen && nowMs() - endedSeen > CFG.DONE_WAIT_SEC * 1000) {
                        log.warn('播完 ' + CFG.DONE_WAIT_SEC + ' 秒仍未判完成，本轮收手，下一轮重开续学。');
                        break;
                    }

                    var apiV = await checkDone(courseId, it.id);
                    if (apiV === true) { okDone = true; break; }

                    /* 权威接口拿不到时退回看目录对号 */
                    var fresh = readPoints();
                    if (fresh) {
                        var me = null;
                        for (var q = 0; q < fresh.length; q++) if (fresh[q].id === it.id) me = fresh[q];
                        if (apiV === null && me && me.done) { okDone = true; break; }
                        if (!me) { log.info('节点列表变化，重新读取'); break; }
                    }

                    /* 【v1.5.0】挂机判定型课件（形态 B：kjcourse 跨域 SCORM 包）——
                       视频已播完（课件帧发了 ended 信号，或顶层 wc 已 ended），
                       但服务端 completed 仍是 "2"（学习中）→ 说明这类课件不看视频进度、
                       只看【真实挂机时长】。此时不要急着收手，继续挂着让平台累计时长，
                       并明确提示用户「请勿关闭页面」。合规：不篡改任何上报，挂机是平台自己计秒。 */
                    var cwEnded = (CW_MSG.endedAt > 0) || (wc && wc.ended);
                    if (cwEnded && apiV === false) {
                        var hangSec = Math.round((nowMs() - t0) / 1000);
                        if (hangSec % 30 < 3) {
                            log.warn('视频已播完，但这是「挂机判定型」课件（完成看真实学习时长、不看视频进度）。'
                                + '正在挂机补学习时长（已 ' + hangSec + ' 秒），请保持本页面开启、勿切走，直到平台判完成。');
                        }
                        setState('挂机补时长中（已 ' + Math.floor(hangSec / 60) + ' 分 ' + (hangSec % 60) + ' 秒）· 请勿关闭页面');
                    } else {
                        setState('等待「' + (it.title || it.id).slice(0, 14) + '」完成（' + Math.round((nowMs() - t0) / 1000) + ' 秒）');
                    }
                }

                if (okDone) { log.ok('节点完成：' + (it.title || it.id)); }
                else { log.warn('未确认完成：' + (it.title || it.id) + '，稍后重开续学'); }

                /* 重新读树，判断是否全部完成 */
                var after = readPoints();
                if (after && after.length && after.every(function (p) { return p.done; })) {
                    log.ok('全部节点完成');
                    setState('本课程已学完');
                    return;
                }
                /* 否则下一轮循环会自动打开下一个未完成节点 —— 这就是「自动跳转」 */
            }

            setState('循环结束');
        })();
    }

    /* ---------------- 目录类型探测（多课程识别） ---------------- */
    /* 精简版 v1.1 支持三类课程结构；v1.3.0 加第四类 SCO：
       ① points   —— 常规 s_point 目录（SCO/网页课件，学习空间里）；
       ② webcourse —— 网页课件连播循环（天气动力学那类 #playerlist 目录，videoarr/playvideo）；
       ③ topic    —— 专题列表/详情（getMyTopicPatternTheme + mb0/index.html div.cma-card）；
       ④ sco      —— kjcourse 域 SCORM 单视频包（#course_player + .continue .user_choise）。 */
    function detectMenuType() {
        /* SCO 单视频课件：有 #course_player 或「开始/继续学习」弹窗（kjcourse 域 iframe） */
        if ($(SEL.CW_VIDEO) || $(SEL.CW_START)) return 'sco';
        /* 网页课件连播循环：有 #playerlist 目录，且 window 有 videoarr/playvideo */
        if ($(SEL.PLAYER_LIST)) {
            try { if (UW.videoarr && UW.videoarr.length) return 'webcourse'; } catch (e) { }
        }
        /* 专题详情页：有 .cma-card 课程卡片 */
        if ($(SEL.TOPIC_COURSE_CARD)) return 'topic';
        /* 专题列表页：有 #classList > li */
        if ($(SEL.TOPIC_CARD)) return 'topicList';
        /* 常规 s_point 目录 */
        if (menuDoc()) return 'points';
        return null;
    }

    /* ---------------- 网页课件连播循环驱动 ---------------- */
    /* 与 v2 的 cwLoop 段序号跟踪同源：不依赖平台 nowD（实测 playvideo(n) 不更新它），
       用 decodeURIComponent(currentSrc) 匹配 videoarr 推断当前段号；
       段号比上次采样【变小】= 一轮完整播完 → 收工（交完成）。 */
    function webCourseLoop() {
        return (async function () {
            setState('网页课件刷课');
            patchMediaPlay();

            var va = null;
            try { va = UW.videoarr; } catch (e) { va = null; }
            if (!va || !va.length) {
                setState('未识别课件目录');
                log.warn('检测到 #playerlist 但拿不到 videoarr，无法驱动。');
                return;
            }
            log.info('网页课件共 ' + va.length + ' 段，逐段连播。');

            setInterval(dismissLayers, CFG.LAYER_POLL_MS);

            var lastSeg = -1;
            var startedAt = nowMs();
            var limit = 150 * 60 * 1000; // 150 分钟硬顶

            while (nowMs() - startedAt < limit) {
                if (!isRunning()) { setState('已暂停'); return; }
                await sleep(CFG.SEG_POLL_MS);
                dismissLayers();

                /* 驱动当前视频：静音 + 倍速 + 起播 */
                var wc = wcDrive();
                if (!wc || wc.dur <= 0) { continue; }

                /* 段序号跟踪 + 回绕判定 */
                try {
                    var v = wcVideo() || wc.el;
                    if (v && va.length) {
                        var dec = decodeURIComponent(v.currentSrc || v.src || '');
                        var seg = -1;
                        for (var si = 0; si < va.length; si++) {
                            if (dec.indexOf(decodeURIComponent(String(va[si]))) >= 0) { seg = si; break; }
                        }
                        if (seg >= 0) {
                            if (lastSeg >= 0 && seg < lastSeg) {
                                log.ok('课件分段一轮播完（第 ' + (lastSeg + 1) + '/' + va.length
                                    + ' 段后平台循环回第 ' + (seg + 1) + ' 段），本节点收工');
                                setState('本节点已播完');
                                break;
                            }
                            lastSeg = seg;
                        }
                    }
                } catch (e) { }

                /* 平台自己不连播的课件（CKPlayer 分段连播）：第一段播完切下一段 */
                if (wc.ended || (wc.dur > 0 && wc.t >= wc.dur - 1.5)) {
                    try {
                        if (typeof UW.playvideo === 'function' && typeof UW.nowD === 'number') {
                            var nxt = UW.nowD + 1;
                            if (nxt < va.length) {
                                log.info('课件分段连播：第 ' + (UW.nowD + 1) + '/' + va.length
                                    + ' 段播完，自动切到下一段…');
                                UW.playvideo(nxt);
                                try { UW.nowD = nxt; } catch (e) { }
                                await sleep(CFG.SEG_SWITCH_WAIT_MS);
                                continue;
                            }
                        }
                    } catch (e) { }
                }

                setState('课件播放中 · ' + Math.floor(wc.t) + '/' + Math.floor(wc.dur) + 's'
                    + (lastSeg >= 0 ? ' · 第' + (lastSeg + 1) + '段' : ''));
            }

            /* 收尾上报：与 v2 的 cwLoop 同源 —— 调平台自己的 doQuit()（存在就调），
               它会 doLMSCommit/doLMSFinish 把学习位置与时长写回，节点才能真正判完成。
               只加速不调 doQuit = 白刷（这就是"光加速不上传"的断点）。 */
            try {
                if (typeof UW.doQuit === 'function') {
                    UW.doQuit();
                    log.info('已调用平台 doQuit() 提交学习记录');
                } else {
                    log.info('本课件没有 doQuit 入口，完成交由平台按播放位置自动判定');
                }
            } catch (e) { log.warn('doQuit 调用失败：' + e); }

            log.ok('网页课件节点处理完毕，返回目录继续下一个节点。');
            setState('本节点已播完');
        })();
    }

    /* ---------------- 裸视频驱动（陌生播放器兜底） ----------------
       有些视频课程用没见过的播放器/目录结构：没有 s_point、没有 #playerlist、
       没有 #course_player，页面上只有裸的 <video>/<audio>。
       老逻辑只靠 globalSpeedGuard 加速、从不判完成 —— 白刷。
       这里兜底：只要能解析出 courseId/itemId，就驱动所有媒体 + 靠权威接口判完成。 */
    function parseParam(key) {
        try {
            var m = location.search.match(new RegExp('params\\.' + key + '=([^&]+)'));
            if (m) return decodeURIComponent(m[1]);
            m = location.search.match(new RegExp('[?&]' + key + '=([^&]+)'));
            if (m) return decodeURIComponent(m[1]);
        } catch (e) { }
        return null;
    }
    function bareVideoLoop() {
        return (async function () {
            setState('裸视频刷课（陌生播放器）');
            patchMediaPlay();

            var courseId = parseParam('courseId');
            var itemId = parseParam('itemId');

            /* itemId 拿不到时，从目录 iframe 读当前节点 */
            if (!itemId) {
                try {
                    var d = menuDoc();
                    if (d) {
                        var cur = d.querySelector('.s_point.current, .s_point.item_now, .s_point[class*=current]');
                        if (cur) itemId = String(cur.id || '').replace(T.POINT_PREFIX, '');
                    }
                } catch (e) { }
            }

            if (!courseId) {
                log.warn('裸视频：解析不到 courseId，只能加速、无法判完成。请确认在标准学习空间里。');
                /* 即使没 courseId，也持续驱动，不让视频停 */
            } else {
                log.info('裸视频：courseId=' + courseId + (itemId ? (' itemId=' + itemId) : '（目录读取中）'));
            }

            var t0 = nowMs();
            var lastReport = 0;
            var lastDoneCheck = 0;
            setInterval(dismissLayers, CFG.LAYER_POLL_MS);

            while (nowMs() - t0 < 150 * 60 * 1000) {
                if (!isRunning()) { setState('已暂停'); return; }
                await sleep(CFG.POLL_MS);
                dismissLayers();

                var st = driveAll();
                if (!st) {
                    if (nowMs() - lastReport > 15000) {
                        lastReport = nowMs();
                        log.info('还没出现 video/audio，继续等…');
                    }
                    continue;
                }
                setState('播放中 ' + st.t + '/' + st.dur + 's');

                /* 有 courseId/itemId 就靠权威接口判完成 */
                if (courseId && itemId && nowMs() - lastDoneCheck > 5000) {
                    lastDoneCheck = nowMs();
                    var done = await checkDone(courseId, itemId);
                    if (done === true) {
                        log.ok('裸视频节点已判完成（平台已完成）');
                        setState('本节点已完成');
                        return;
                    }
                }

                /* itemId 还没拿到，重试从目录读 */
                if (courseId && !itemId && nowMs() - lastReport > 15000) {
                    lastReport = nowMs();
                    try {
                        var dd = menuDoc();
                        if (dd) {
                            var cc = dd.querySelector('.s_point.current, .s_point.item_now, .s_point[class*=current]');
                            if (cc) { itemId = String(cc.id || '').replace(T.POINT_PREFIX, ''); log.info('补读到 itemId=' + itemId); }
                        }
                    } catch (e) { }
                }
            }
            log.warn('裸视频超时收工');
        })();
    }

    /* ---------------- 专题驱动 ---------------- */
    /* 专题列表页：挑未通过专题点「进入专题」；详情页：挑未学完课程点「进入课程」。
       进入课程后是标准学习空间，自动落到 points 目录驱动（复用 videoLoop）。 */
    function topicLoop() {
        return (async function () {
            setState('专题刷课');

            /* 专题列表页 */
            if (detectMenuType() === 'topicList') {
                var cards = $$(SEL.TOPIC_CARD);
                log.info('专题共 ' + cards.length + ' 个');
                for (var i = 0; i < cards.length; i++) {
                    if (!isRunning()) { setState('已暂停'); return; }
                    var card = cards[i];
                    var name = txt($(SEL.TOPIC_TITLE, card)) || txt(card).slice(0, 40);
                    var done = !!$(SEL.TOPIC_DONE_LAB, card);
                    if (done) { log.info('专题「' + name + '」已通过，跳过'); continue; }
                    var btn = $(SEL.TOPIC_ENTER, card);
                    if (!btn) { log.warn('「' + name + '」没有进入按钮，跳过'); continue; }
                    log.info('进入专题：' + name);
                    try { btn.click(); } catch (e) { log.warn('点进入专题失败：' + e); }
                    /* 专题是新标签页，本页脚本实例的使命到此为止；新标签由油猴重新注入接管 */
                    setState('已打开专题：' + name.slice(0, 16));
                    return;
                }
                log.ok('所有专题都已通过');
                setState('专题全部已通过');
                return;
            }

            /* 专题详情页 */
            var cards = $$(SEL.TOPIC_COURSE_CARD);
            log.info('专题课程 ' + cards.length + ' 门');
            var todo = [];
            for (var j = 0; j < cards.length; j++) {
                var c = cards[j];
                var a = $(SEL.TOPIC_COURSE_ENTER, c);
                if (!a) continue;
                var nm = txt($(SEL.TOPIC_COURSE_TITLE, c)) || txt(c).slice(0, 30);
                var pct = 0;
                var bar = $(SEL.TOPIC_COURSE_PROGRESS, c);
                if (bar) {
                    var w = bar.style.width || '';
                    var mm = w.match(/(\d+(?:\.\d+)?)%/);
                    if (mm) pct = parseFloat(mm[1]);
                }
                if (pct >= 100) { log.info('课程「' + nm + '」进度 ' + pct + '%，已学完，跳过'); continue; }
                var oc = a.getAttribute('onclick') || '';
                var uu = oc.match(/learnCourseUrl\(\s*[^,]+,\s*'([^']+)'/);
                var learnUrl = uu ? uu[1] : '';
                var cm = learnUrl.match(/courseId=([^&]+)/);
                var courseId = cm ? decodeURIComponent(cm[1]) : '';
                if (!learnUrl || !courseId) { log.warn('「' + nm + '」解析不到学习地址，跳过'); continue; }
                todo.push({ name: nm, learnUrl: learnUrl, courseId: courseId, pct: pct, btn: a });
            }
            if (!todo.length) {
                log.ok('这个专题的课程都学完了');
                setState('专题课程全部学完');
                return;
            }
            todo.sort(function (x, y) { return x.pct - y.pct; });
            var pick = todo[0];
            log.info('选中学得最少的：' + pick.name + '（' + pick.pct + '%），进入学习');
            setState('进入课程：' + pick.name.slice(0, 14));
            try { pick.btn.click(); } catch (e) { log.warn('点进入课程失败：' + e); }
            /* 学习空间新窗口由油猴重新注入，走 points 目录驱动 */
        })();
    }

    /* ---------------- 等效学习时长显示（与 v2 同源算法） ----------------
       把页面平台的「学习时长」DOM 文本改成等效口径：真实增量 × 倍速 累加，
       显示"已经刷掉了多少内容"。⚠ 只改这一处显示，【不碰任何上报接口】。
       ⚠ 与完整版 v2 的协调：同页若 v2 在跑（window.__JX2_VER 存在），
       等效显示由 v2 负责（它用 data-jx2eq 认领计时元素），精简版直接让位 ——
       两个实例同抢一个元素会互相把对方写的等效值当成"平台新值"再乘一次倍速。 */
    var EQ_ID = 'vo' + Math.random().toString(36).slice(2, 8);
    var EQ = { extra: 0, lastRaw: -1, el: null, tail: null, shown: '' };

    /* "00:07:23" / "1:02:05" → 秒；格式对不上返回 null（不认识就不动它） */
    function parseHMS(s) {
        var m = /^(\d{1,3}):([0-5]?\d):([0-5]?\d)$/.exec(String(s == null ? '' : s).trim());
        if (!m) return null;
        return (Number(m[1]) * 3600) + (Number(m[2]) * 60) + Number(m[3]);
    }
    /* 秒 → "00:07:23"（两位时，与平台格式一致） */
    function fmtHMS2(s) {
        s = Math.max(0, Math.floor(Number(s) || 0));
        var h = Math.floor(s / 3600), mi = Math.floor((s % 3600) / 60), se = s % 60;
        var p = function (n) { return n < 10 ? '0' + n : String(n); };
        return p(h) + ':' + p(mi) + ':' + p(se);
    }

    /* 找计时器元素（认领制；v2 已认领的让位） */
    function findTimerEl() {
        var found = null;
        eachDoc(function (d) {
            var els = null;
            try { els = d.querySelectorAll(SEL.LEARN_TIMER); } catch (e) { return; }
            for (var i = 0; i < els.length; i++) {
                var el = els[i];
                var ownV2 = '', own = '';
                try { ownV2 = el.getAttribute('data-jx2eq') || ''; } catch (e) { }
                try { own = el.getAttribute('data-jx2voeq') || ''; } catch (e) { }
                if (ownV2) continue;                       /* v2 在管这个元素，让位 */
                if (own && own !== EQ_ID) continue;        /* 别的精简版实例已认领 */
                if (!own) { try { el.setAttribute('data-jx2voeq', EQ_ID); } catch (e) { } }
                found = el;
                return false;
            }
        }, document, 0);
        return found;
    }

    /* 数值后挂小尾巴：写明倍速、真实值、已刷比例（独立元素，不写进计时器本身） */
    function eqTail(el, raw) {
        if (!CFG.EQ_TAIL) return;
        try {
            var host = el.parentNode;
            if (!host) return;
            var t = EQ.tail;
            if (t && t.parentNode !== host) {
                try { if (t.parentNode) t.parentNode.removeChild(t); } catch (e) { }
                t = EQ.tail = null;
            }
            if (!t) {
                var kids = host.children || [];
                for (var i = 0; i < kids.length; i++) {
                    if (kids[i].getAttribute && kids[i].getAttribute('data-jx2votail') === EQ_ID) { t = kids[i]; break; }
                }
            }
            if (!t) {
                t = document.createElement('span');
                t.setAttribute('data-jx2votail', EQ_ID);
                t.style.cssText = 'margin-left:6px;font-size:12px;color:#b81c22;white-space:nowrap;';
                host.appendChild(t);
                EQ.tail = t;
            }
            var rate = Math.max(1, CFG.RATE || 1);
            var pct = '';
            try {
                var ms = mediaList(), best = null;
                for (var i = 0; i < ms.length; i++) {
                    if (Number(ms[i].duration) > 0 && (!best || Number(ms[i].duration) > Number(best.duration))) best = ms[i];
                }
                if (best && isFinite(best.duration) && best.duration > 0) {
                    pct = ' · 已刷 ' + Math.min(100, Math.round((Number(best.currentTime) || 0) / best.duration * 100)) + '%';
                }
            } catch (e) { }
            var s = '（等效 ' + rate + 'x · 真实 ' + fmtHMS2(raw) + pct + '）';
            if (t.textContent !== s) t.textContent = s;
        } catch (e) { }
    }

    function eqTick() {
        try {
            var el = EQ.el;
            if (el) {
                var dead = false;
                try { dead = !el.ownerDocument || !el.ownerDocument.documentElement.contains(el); } catch (e) { dead = true; }
                if (dead) { el = EQ.el = null; }
            }
            if (!el) { EQ.el = el = findTimerEl(); EQ.lastRaw = -1; }
            if (!el) return;

            /* 读到的还是我上回写的值 → 平台还没写新的，跳过（防自己吃自己） */
            if (EQ.shown && el.textContent === EQ.shown) return;

            var raw = parseHMS(el.textContent);
            if (raw === null) return;

            if (EQ.lastRaw < 0) {
                EQ.lastRaw = raw;
            } else {
                var d = raw - EQ.lastRaw;
                if (d > 0 && d <= 1800) {
                    /* 【与 v2.3.9 同源】倍速折算只对「真的有媒体在播」的时段生效；
                       图文节（无音视频）走真实时间，不加倍速额外量，否则顶部数字
                       飞涨、与当前节点完全脱节。 */
                    var playing = false;
                    try {
                        var ms2 = mediaList();
                        for (var mi = 0; mi < ms2.length; mi++) {
                            var mm2 = ms2[mi];
                            if (Number(mm2.duration) > 0 && !mm2.paused && !mm2.ended) { playing = true; break; }
                        }
                    } catch (e) { }
                    EQ.extra += d * (playing ? (Math.max(1, CFG.RATE || 1) - 1) : 0);
                }
                EQ.lastRaw = raw;
            }

            var shown = fmtHMS2(raw + EQ.extra);
            if (el.textContent !== shown) { el.textContent = shown; }
            EQ.shown = shown;
            try {
                el.title = '等效学习时长 ' + shown + '（真实 ' + fmtHMS2(raw) + ' + 倍速额外 '
                    + fmtHMS2(EQ.extra) + '，按 ' + Math.max(1, CFG.RATE || 1)
                    + ' 倍速折算；仅页面显示，未改动任何上报）';
            } catch (e) { }
            eqTail(el, raw);
        } catch (e) { }
    }

    function eqInstall() {
        /* v2 在跑就让位：等效显示归 v2 管（防双实例互乘） */
        try { if (UW.__JX2_VER) { log.info('检测到完整版 v2 在运行，等效时长显示由 v2 负责'); return; } } catch (e) { }
        setInterval(function () { try { eqTick(); } catch (e) { } }, CFG.EQ_TICK_MS);
    }

    /* ---------------- 启动 ---------------- */
    /* 是否顶层窗口（不在 iframe 里）。删掉 @noframes 后，脚本会注入到跨域 iframe
       （pxkckj/kjcourse/kjkejian2 课件域）—— 顶层负责面板+目录驱动，
       iframe 里只跑全局倍速守护（加速 iframe 里的 video），不重复建面板。 */
    function isTop() {
        try { return window.self === window.top; } catch (e) { return true; }
    }

    /* ---------------- 跨域消息监听（SCO 课件帧 → 顶层） ----------------
       kjcourse 跨域 iframe 里的 scoLoop 播完视频后发 {__jx2:'cw',ev:'ended'}，
       顶层收不到它的内部状态（跨域），只能靠这个消息知道「视频已经播完」。
       形态 B 专题课（挂机时长判定）在视频播完后还要继续挂机补时长，
       顶层据此把状态切成「挂机补学习时长中」，而不是误以为已完成/未响应。 */
    var CW_MSG = { endedAt: 0 };
    function installMsgListener() {
        try {
            window.addEventListener('message', function (e) {
                var d = e && e.data;
                if (!d || d.__jx2 !== 'cw') return;
                if (d.ev === 'ended') {
                    CW_MSG.endedAt = nowMs();
                    log.info('收到课件帧「视频已播完」信号，进入挂机补学习时长阶段（若为挂机判定型课件）。');
                }
            });
        } catch (err) { }
    }

    function boot() {
        try { CFG.MUTE = rawGet(GMKEY.MUTE, true) === true; } catch (e) { }
        try { var r = Number(rawGet(GMKEY.RATE, 16)); if (r >= 1 && r <= 16) CFG.RATE = r; } catch (e) { }

        /* 全局 16 倍速守护：无条件启动（顶层和 iframe 都跑），不挑课程样式。
           只要本网站页面出现 video/audio 就静音 + 16 倍速 + 起播，
           应对所有"不同课程样式"（陌生播放器、没见过的目录、跨域 iframe 里的视频都照常加速）。 */
        globalSpeedGuard();

        /* 顶层监听课件帧的「视频已播完」跨域信号（形态 B 挂机判定用） */
        installMsgListener();

        /* SCO 单视频课件：doQuit() 只存在于课件 iframe 的 window 上，顶层够不到，
           所以【必须在 iframe 里】跑 scoLoop。这里在 isTop() 判断之前先处理：
           当前 frame 里看到 #course_player / 「开始学习」弹窗 → 直接接管（点开始→保播→播完上报）。
           不在此处判 isRunning()：scoLoop 内部会等用户点「开始」后再真正驱动。
           ⚠ 若完整版 v2 也已注入本 frame（window.__JX2_VER 存在），它的 cwLoop 会负责
           doQuit 上报 —— 精简版让位，避免双实例重复 doQuit。 */
        if (detectMenuType() === 'sco') {
            try { if (UW.__JX2_VER) { log.info('检测到完整版 v2 在跑，SCO 上报由 v2 负责，精简版只做倍速兜底'); return; } } catch (e) { }
            scoLoop();
            return;
        }

        /* iframe 里到此为止：只做全局倍速，不建面板、不跑目录驱动（避免和顶层重复）。 */
        if (!isTop()) return;

        /* 等效学习时长显示（顶层才装；v2 在跑时自动让位） */
        eqInstall();

        buildPanel();
        setRunning(isRunning());

        /* 多课程识别：按目录类型分发到对应驱动。
           ① points   —— 常规 s_point 目录（学习空间）；
           ② webcourse —— 网页课件连播循环（#playerlist）；
           ③ topic/topicList —— 专题列表与详情（classCode/mb0）；
           ④ 裸视频    —— 没有已知目录、但页面上有 video/audio（陌生播放器）→ bareVideoLoop。
           都不匹配则不动作（课程列表、班级页等），不会误跳别的课。 */
        var mt = detectMenuType();
        if (mt === 'points') {
            log.info('检测到视频目录，脚本就绪。点「开始」后自动刷当前视频并依次往下跳。');
            if (isRunning()) videoLoop();
        } else if (mt === 'webcourse') {
            log.info('检测到网页课件连播目录（#playerlist），脚本就绪。');
            if (isRunning()) webCourseLoop();
        } else if (mt === 'topic' || mt === 'topicList') {
            log.info('检测到专题页，脚本就绪。点「开始」后自动挑未学课程刷课。');
            if (isRunning()) topicLoop();
        } else if (mediaList().length) {
            /* 陌生播放器：没有已知目录，但页面上有裸 video/audio → 兜底驱动 + 判完成 */
            log.info('检测到裸视频（陌生播放器样式），脚本就绪。点「开始」后自动加速并判完成。');
            if (isRunning()) bareVideoLoop();
        } else {
            setState('等待进入视频页');
            log.info('当前不是视频学习页。请手动点进某个视频/课件节点，脚本会自动接管。');
        }
    }

    try { GM_registerMenuCommand('查看日志', function () { alert(LOG.slice(-40).join('\n')); }); } catch (e) { }

    if (document.body) boot();
    else document.addEventListener('DOMContentLoaded', boot);
})();