// ==UserScript==
// @name         软通学习平台-视频播完自动下一集
// @namespace    http://tampermonkey.net/
// @version      2026.08.05.1
// @description  在软通教育学习平台（eco.issedu365.com）课程详情页，视频播放结束后自动点击"下一个"播放下一课；支持后台保持播放、画中画模式（兼容Edge原生PiP按钮、跨集记忆状态）。
// @author       SmallRob
// @match        https://eco.issedu365.com/application/appcoursedetail/*
// @icon         data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSI2NCIgaGVpZ2h0PSI2NCIgdmlld0JveD0iMCAwIDY0IDY0Ij4KICA8ZGVmcz4KICAgIDxsaW5lYXJHcmFkaWVudCBpZD0iYmciIHgxPSIwJSIgeTE9IjAlIiB4Mj0iMCUiIHkyPSIxMDAlIj4KICAgICAgPHN0b3Agb2Zmc2V0PSIwJSIgc3RvcC1jb2xvcj0iIzNCODJGNiIvPgogICAgICA8c3RvcCBvZmZzZXQ9IjEwMCUiIHN0b3AtY29sb3I9IiMxRTQwQUYiLz4KICAgIDwvbGluZWFyR3JhZGllbnQ+CiAgICA8ZmlsdGVyIGlkPSJzaGFkb3ciIHg9Ii0yMCUiIHk9Ii0yMCUiIHdpZHRoPSIxNDAlIiBoZWlnaHQ9IjE0MCUiPgogICAgICA8ZmVEcm9wU2hhZG93IGR4PSIwIiBkeT0iMSIgc3RkRGV2aWF0aW9uPSIxIiBmbG9vZC1jb2xvcj0iIzAwMCIgZmxvb2Qtb3BhY2l0eT0iMC4zIi8+CiAgICA8L2ZpbHRlcj4KICA8L2RlZnM+CiAgPHJlY3Qgd2lkdGg9IjY0IiBoZWlnaHQ9IjY0IiByeD0iMTQiIGZpbGw9InVybCgjYmcpIi8+CiAgPGNpcmNsZSBjeD0iMzIiIGN5PSIxOCIgcj0iNS41IiBmaWxsPSIjRUY0NDQ0IiBmaWx0ZXI9InVybCgjc2hhZG93KSIvPgogIDxyZWN0IHg9IjI3LjUiIHk9IjI3IiB3aWR0aD0iOSIgaGVpZ2h0PSIyNiIgcng9IjQuNSIgZmlsbD0iI0VGNDQ0NCIgZmlsdGVyPSJ1cmwoI3NoYWRvdykiLz4KPC9zdmc+
// @grant        none
// @license MIT
// ==/UserScript==

(function() {
    'use strict';

    const CONFIG = {
        cooldownMs: 8000,              // 触发下一集后的冷却时间，防止重复点击
        nextDelayAfterEnded: 2000,    // 视频 ended 后延迟多久触发下一集
        keepPlayingInBackground: true,// 页面后台时保持视频播放
        keepAliveInterval: 3000,      // 后台保持播放检查间隔
        enablePiP: true,              // 是否显示画中画按钮
        pipReenterDelay: 2000,        // 切换集数后重新进入 PiP 的延迟
        pipStorageKey: 'softone-pip-wanted', // PiP 状态持久化 key
        debug: true                   // 是否打印调试日志
    };

    const log = (...args) => {
        if (CONFIG.debug) console.log('[软通自动下一集]', ...args);
    };

    const state = {
        lastNextAt: 0,
        playerEndedBound: false,      // 是否已绑定播放器 ended 事件
        autoPlayKeys: new Set(),      // 已尝试自动播放的视频源，避免重复
        keepAliveTimer: null,
        isBackground: false,
        pipWanted: false,             // 用户是否想用画中画（持久化到 localStorage）
        pipActive: false,             // 当前是否处于画中画
        pipButton: null,              // 画中画按钮元素
        pipBoundVideo: null,          // 已绑定 PiP 事件的 video 元素
        pipRequesting: false,         // PiP 请求防重入标记（避免同时多个 requestPictureInPicture）
        pipSwitchingEpisode: false    // 是否正在切换集数（区分"切集退出"和"用户手动退出"）
    };

    // ==================== 工具 ====================

    function safeClick(element) {
        if (!element) return false;
        try {
            element.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true, view: window }));
            return true;
        } catch (e) {
            log('点击失败:', e);
            return false;
        }
    }

    function canTriggerNext() {
        const now = Date.now();
        if (now - state.lastNextAt < CONFIG.cooldownMs) {
            log('冷却期内，忽略本次触发');
            return false;
        }
        state.lastNextAt = now;
        return true;
    }

    // ==================== 查找元素 ====================

    function getCurrentVideo() {
        // 页面使用 videojs + HWPlayer，视频元素 ID 为 streamVideoContent
        // videojs 会在 <video-js> 内部创建 <video> 子元素
        return document.querySelector(
            '#streamVideoContent_html5_api, #streamVideoContent video, .vjs-tech, ' +
            '#hwVideoContent_html5_api, #hwVideoContent video, ' +
            '#video video, #videoc video, .xgplayer video, video.xg-video, ' +
            '.video-js video, video'
        );
    }

    // 尝试从 Vue 组件中获取 videojsPlayer 实例
    function findVuePlayer() {
        // 遍历所有带 video-js 类的元素，查找 Vue 实例上挂载的 videojsPlayer
        for (const el of document.querySelectorAll('.video-js, video-js, [id$="Content"]')) {
            // Vue2 实例存储在 __vue__ 上
            const vue = el.__vue__;
            if (vue && vue.videojsPlayer && typeof vue.videojsPlayer.play === 'function') {
                return vue.videojsPlayer;
            }
            // 也检查父元素链
            let parent = el.parentElement;
            let depth = 0;
            while (parent && depth < 10) {
                const pv = parent.__vue__;
                if (pv && pv.videojsPlayer && typeof pv.videojsPlayer.play === 'function') {
                    return pv.videojsPlayer;
                }
                parent = parent.parentElement;
                depth++;
            }
        }
        return null;
    }

    // 绕过平台反自动播放机制：将 Vue 视频组件的 isTrustedAction 设为 true
    // 平台在 videoEnd() 中将 isTrustedAction 置为 false，videoStart()（playing 事件）
    // 检测到 false 时会暂停视频并回退到 lastPlayTime，导致脚本自动播放下一集失败。
    // 平台自身在 doSignHandler / notSignHandler / docVisualChange 中也用同样方式恢复播放。
    function markTrustedAction() {
        let found = false;
        const visited = new Set();
        const check = (vue) => {
            if (vue && !visited.has(vue) && 'isTrustedAction' in vue) {
                visited.add(vue);
                if (vue.isTrustedAction !== true) {
                    vue.isTrustedAction = true;
                    log('已设置 isTrustedAction = true（绕过反自动播放）');
                }
                found = true;
            }
        };
        for (const el of document.querySelectorAll('.video-js, video-js, [id$="Content"]')) {
            check(el.__vue__);
            let parent = el.parentElement;
            let depth = 0;
            while (parent && depth < 10) {
                check(parent.__vue__);
                parent = parent.parentElement;
                depth++;
            }
        }
        return found;
    }

    // 在多个位置查找播放器实例：全局变量 / iframe / Vue组件
    function findPlayer() {
        // 1. 检查常见的全局变量
        const names = ['player', 'xgplayer', 'playerInstance', 'videoPlayer'];
        for (const n of names) {
            const p = window[n];
            if (p && typeof p.play === 'function') return { player: p, fromIframe: false };
        }
        // 2. 检查 iframe 内的全局变量
        try {
            for (const f of document.querySelectorAll('iframe')) {
                const fw = f.contentWindow;
                for (const n of names) {
                    const p = fw[n];
                    if (p && typeof p.play === 'function') return { player: p, fromIframe: true };
                }
            }
        } catch (e) { /* 跨域 iframe 忽略 */ }
        // 3. 检查 DOM 元素上挂载的播放器
        for (const el of document.querySelectorAll('.xgplayer, [class*="xgplayer"], video, .xgplayer-container')) {
            for (const key of ['__player', 'player', '_player', 'xgplayer']) {
                const p = el[key];
                if (p && typeof p.play === 'function') return { player: p, fromIframe: false };
            }
        }
        // 4. 通过 Vue 组件查找 videojsPlayer（软通平台使用此方式）
        const vjsPlayer = findVuePlayer();
        if (vjsPlayer) return { player: vjsPlayer, fromIframe: false };
        return null;
    }

    function findNextButton() {
        // 1. Element UI $confirm 弹窗里的"下一个"（完成提示）
        //    Element UI 的 $confirm 会创建 .el-message-box__wrapper
        for (const wrapper of document.querySelectorAll(
            '.el-message-box__wrapper, .el-dialog__wrapper, .v-modal + div'
        )) {
            const style = window.getComputedStyle(wrapper);
            if (style.display === 'none' || style.visibility === 'hidden') continue;
            const text = wrapper.textContent || '';
            if (!(text.includes('当前任务已达到完成条件') ||
                  (text.includes('提示') && text.includes('完成条件')) ||
                  text.includes('恭喜你'))) continue;
            // Element UI 按钮在 .el-message-box__btns 内
            for (const btn of wrapper.querySelectorAll(
                '.el-message-box__btns button, .el-dialog__footer button, button, .el-button'
            )) {
                const t = (btn.textContent || '').trim();
                if (t === '下一个' || t === '下一节' || t === '下一章' || t === '确定') {
                    // 优先"下一个"，"确定" 只在弹窗明确包含完成条件时使用
                    if (t === '确定' && !text.includes('完成条件')) continue;
                    return btn;
                }
            }
        }

        // 2. 底部工具栏"下一个"（.nextChapter 由 Vue 绑定 @click="syncLearnTime(...)" ）
        const toolbar = document.querySelector('.nextChapter');
        if (toolbar) return toolbar;

        // 3. 文本精确匹配"下一个"（跳过已禁用/不可见的元素）
        for (const el of document.querySelectorAll('span, button, a, div')) {
            const text = (el.textContent || '').trim();
            if (text === '下一个' || text === '下一节' || text === '下一章') {
                // 检查元素是否可见
                const rect = el.getBoundingClientRect();
                if (rect.width === 0 && rect.height === 0) continue;
                const style = window.getComputedStyle(el);
                if (style.display === 'none' || style.visibility === 'hidden') continue;
                let target = el;
                while (target && target !== document.body) {
                    if (target.onclick || target.tagName === 'BUTTON' || target.tagName === 'A') return target;
                    target = target.parentElement;
                }
                return el;
            }
        }

        // 4. 目录树中"已选中"项的下一未学项
        const items = Array.from(document.querySelectorAll(
            '#tabcataloglist .course-hover.catalog-basic, #tabcataloglist .listBox .course-hover'
        ));
        const idx = items.findIndex(el => el.classList.contains('selected'));
        if (idx !== -1) {
            for (let i = idx + 1; i < items.length; i++) {
                if (!items[i].querySelector('.fa-check, .fa-check-circle, .learned, .finished, .completed')) {
                    log('点击目录树下一未学项:', items[i].textContent.trim().substring(0, 30));
                    return items[i];
                }
            }
        }
        return null;
    }

    // ==================== 核心：播放 + ended 跳下一课 ====================

    // 绑定播放器 ended 事件（videojsPlayer / 原生 video）
    function bindPlayerEnded() {
        const onEnded = () => {
            if (state._endedFired) return;
            state._endedFired = true;
            log('视频播放结束，准备跳下一课');
            setTimeout(() => goNext('视频ended事件'), CONFIG.nextDelayAfterEnded);
        };

        // 绑定 videojsPlayer ended 事件（通过 Vue 组件）
        if (!state.playerEndedBound) {
            const found = findPlayer();
            if (found) {
                state.playerEndedBound = true;
                const p = found.player;
                try {
                    if (typeof p.on === 'function') {
                        p.on('ended', onEnded);
                        log('已绑定 player ended 事件', found.fromIframe ? '(iframe内)' : '');
                    } else if (typeof p.addEventListener === 'function') {
                        p.addEventListener('ended', onEnded);
                        log('已绑定 player ended 事件(addEventListener)', found.fromIframe ? '(iframe内)' : '');
                    }
                } catch (e) { log('绑定 player ended 失败:', e.message); }
            }
        }

        // 绑定原生 video ended 事件
        const video = getCurrentVideo();
        if (video && !state._videoEndedBound) {
            state._videoEndedBound = true;
            video.addEventListener('ended', onEnded, { passive: true });
            video.addEventListener('loadstart', () => {
                // 切换章节时 video src 变化，重置状态并重新自动播放
                log('视频 loadstart 事件，重置状态');
                state._endedFired = false;
                state._videoEndedBound = false;
                state.playerEndedBound = false;
                state.autoPlayKeys.clear();
                setTimeout(() => {
                    bindPlayerEnded();
                    tryAutoPlay(getCurrentVideo());
                    // 如果用户想用 PiP，尝试重新进入画中画
                    maybeEnterPiP(CONFIG.pipReenterDelay);
                }, 1000);
            }, { passive: true });
            log('已绑定 video ended 事件');
            // 同时绑定 PiP 事件
            bindPiPEvents(video);
        }
    }

    // 自动播放当前视频（支持 videojs / HWPlayer / 原生 video）
    function tryAutoPlay(video) {
        const src = video ? (video.currentSrc || video.src || location.href) : location.href;
        const key = 'autoplay:' + src;
        if (state.autoPlayKeys.has(key)) {
            log('当前视频源已尝试过自动播放，跳过', src);
            return;
        }
        state.autoPlayKeys.add(key);

        const startTime = Date.now();
        const maxWait = 90000;   // 最多等 player 出现 90 秒
        const playDelay = 3000;  // 跳转后先等 3 秒再播放

        const isPlaying = () => {
            const v = getCurrentVideo();
            if (v) return !v.paused;
            const f = findPlayer();
            return f && f.player && f.player.paused === false;
        };

        // 视频已开始播放时的统一处理：停止重试 + 尝试进入 PiP
        const onPlaybackStarted = () => {
            log('视频已开始播放，停止自动播放');
            maybeEnterPiP(500);
        };

        let timer = null;
        let attemptCount = 0;
        const tryCallPlay = () => {
            if (Date.now() - startTime > maxWait) {
                if (timer) clearTimeout(timer);
                log('等待 player 超时，放弃自动播放');
                return;
            }
            if (isPlaying()) {
                onPlaybackStarted();
                return;
            }
            attemptCount++;
            markTrustedAction();  // 每次尝试前都重置，防止 videoStart() 暂停

            // 策略1：通过 videojsPlayer 实例播放（最可靠）
            const found = findPlayer();
            if (found && typeof found.player.play === 'function') {
                log(`第${attemptCount}次尝试: 调用 player.play()`, found.fromIframe ? '(iframe内)' : '');
                try {
                    // videojs 的 play() 返回 Promise
                    const result = found.player.play();
                    if (result && result.catch) result.catch(() => {});
                } catch (e) { log('player.play() 异常:', e.message); }
                bindPlayerEnded();
                // 如果仍然没有播放，继续重试
                if (!isPlaying()) {
                    timer = setTimeout(tryCallPlay, 1000);
                }
                return;
            }

            // 策略2：直接操作原生 video 元素
            const v = getCurrentVideo();
            if (v) {
                log(`第${attemptCount}次尝试: 直接调用 video.play()`);
                try {
                    // 尝试先静音再播放（绕过浏览器自动播放限制）
                    const wasMuted = v.muted;
                    v.muted = true;
                    const result = v.play();
                    if (result && result.catch) {
                        result.catch(() => {
                            // 静音播放也失败，继续重试
                            v.muted = wasMuted;
                        });
                    }
                    // 播放成功后恢复静音状态
                    setTimeout(() => {
                        if (!v.paused && wasMuted !== undefined) {
                            v.muted = wasMuted;
                        }
                    }, 200);
                } catch (e) { log('video.play() 异常:', e.message); }
                bindPlayerEnded();
                if (!isPlaying()) {
                    timer = setTimeout(tryCallPlay, 1000);
                }
                return;
            }

            log(`第${attemptCount}次尝试: player/video 尚未初始化，继续等待...`);
            timer = setTimeout(tryCallPlay, 500);
        };

        log('进入自动播放逻辑，video:', video ? '存在' : '不存在，等待加载...');
        timer = setTimeout(() => {
            if (isPlaying()) {
                onPlaybackStarted();
                return;
            }
            tryCallPlay();
        }, playDelay);
    }

    // 等待 video / player 出现后再绑定与播放
    function ensurePlaying() {
        const video = getCurrentVideo();
        const found = findPlayer();
        if (video || found) {
            if (CONFIG.enablePiP) createPiPButton();  // 找到视频后再创建 PiP 按钮
            tryAutoPlay(video);
            bindPlayerEnded();
            return true;
        }
        if (!state._waiting) {
            state._waiting = true;
            log('video/player 未找到，启动等待观察器');
            const poll = setInterval(() => {
                const f = findPlayer();
                const v = getCurrentVideo();
                if (v || f) {
                    clearInterval(poll);
                    state._waiting = false;
                    log('发现 player/video，开始自动播放');
                    ensurePlaying();
                }
            }, 500);
            const obs = new MutationObserver(() => {
                if (getCurrentVideo() || findPlayer()) {
                    clearInterval(poll);
                    obs.disconnect();
                    state._waiting = false;
                    ensurePlaying();
                }
            });
            obs.observe(document.body, { childList: true, subtree: true });
            setTimeout(() => {
                if (state._waiting) {
                    clearInterval(poll);
                    obs.disconnect();
                    state._waiting = false;
                }
            }, 30000);
        }
        return false;
    }

    // 触发下一集的唯一入口
    function goNext(reason) {
        if (!canTriggerNext()) return;
        state._endedFired = false;       // 重置，下一课重新等待 ended
        state.playerEndedBound = false;  // 下一课需重新绑定 ended
        state._videoEndedBound = false;
        state.autoPlayKeys.clear();      // 新章节需要重新尝试自动播放
        state.pipSwitchingEpisode = state.pipWanted;  // 仅在用户启用 PiP 时标记切集

        const btn = findNextButton();
        if (btn) {
            log(`触发下一集，原因: ${reason}，目标:`, (btn.textContent || '').trim().substring(0, 20));
            safeClick(btn);
            markTrustedAction();  // 预设 isTrustedAction=true，为下一课自动播放铺路
            // 跳转后等待新课时渲染，再尝试自动播放 + 绑定 ended
            // MutationObserver 也会检测到 DOM 变化并触发 ensurePlaying
            setTimeout(() => ensurePlaying(), 3000);
        } else {
            log('未找到"下一个"按钮，无法跳转');
        }
    }

    // ==================== 后台保持播放 ====================

    function keepVideoPlaying() {
        if (!state.isBackground) return;
        const video = getCurrentVideo();
        if (!video || video.ended || video.error) return;
        if (video.paused && video.readyState >= 2) {
            log('后台检测到视频被暂停，尝试恢复播放');
            markTrustedAction();  // 恢复播放前绕过反自动播放
            // 优先通过 videojsPlayer 恢复播放
            const vjsPlayer = findVuePlayer();
            if (vjsPlayer) {
                try {
                    const result = vjsPlayer.play();
                    if (result && result.catch) result.catch(() => {});
                    return;
                } catch (e) {}
            }
            const promise = video.play();
            if (promise && promise.catch) promise.catch(() => {});
        }
    }

    function startKeepAlive() {
        if (state.keepAliveTimer) return;
        state.isBackground = true;
        state.keepAliveTimer = setInterval(keepVideoPlaying, CONFIG.keepAliveInterval);
    }

    function stopKeepAlive() {
        state.isBackground = false;
        if (state.keepAliveTimer) {
            clearInterval(state.keepAliveTimer);
            state.keepAliveTimer = null;
        }
    }

    function installVisibilityHook() {
        if (!CONFIG.keepPlayingInBackground) return;
        let getRealHidden = () => false;
        try {
            const proto = Document.prototype || Object.getPrototypeOf(document);
            const desc = Object.getOwnPropertyDescriptor(proto, 'hidden') ||
                Object.getOwnPropertyDescriptor(document, 'hidden');
            if (desc && desc.get) getRealHidden = desc.get.bind(document);
        } catch (e) {}

        try {
            Object.defineProperty(document, 'hidden', { get() { return false; }, configurable: true });
            Object.defineProperty(document, 'visibilityState', { get() { return 'visible'; }, configurable: true });
        } catch (e) {}

        const update = () => {
            if (getRealHidden()) {
                log('页面进入后台，启动保持播放');
                startKeepAlive();
            } else {
                stopKeepAlive();
                log('页面回到前台，重新尝试自动播放');
                ensurePlaying();
            }
        };
        document.addEventListener('visibilitychange', update, true);
        window.addEventListener('blur', () => startKeepAlive(), true);
        window.addEventListener('focus', () => stopKeepAlive(), true);
        update();
    }

    // ==================== 画中画 (Picture-in-Picture) ====================

    function isPiPSupported() {
        return document.pictureInPictureEnabled === true ||
               (document.pictureInPictureEnabled !== false &&
                HTMLVideoElement.prototype.requestPictureInPicture);
    }

    // 持久化 / 读取 pipWanted，跨集、跨刷新记忆用户选择
    function persistPipState() {
        try { localStorage.setItem(CONFIG.pipStorageKey, state.pipWanted ? '1' : '0'); } catch (e) {}
    }
    function loadPipState() {
        try { return localStorage.getItem(CONFIG.pipStorageKey) === '1'; } catch (e) { return false; }
    }

    // 统一入口：在用户想用 PiP 且当前未处于 PiP 时，延迟进入画中画。
    // 消除原本散落在 tryAutoPlay / bindPlayerEnded 中的 3 处重复逻辑。
    // 防重入：pipRequesting 标记避免 leavepictureinpicture 回调和 tryAutoPlay 同时触发 requestPictureInPicture。
    function maybeEnterPiP(delay) {
        if (!state.pipWanted) return;
        if (document.pictureInPictureElement) return;
        if (state.pipRequesting) return;
        setTimeout(() => {
            if (state.pipWanted && !document.pictureInPictureElement && !state.pipRequesting) {
                enterPiP();
            }
        }, delay);
    }

    function enterPiP() {
        if (!isPiPSupported()) { log('PiP: 浏览器不支持画中画'); return; }
        const video = getCurrentVideo();
        if (!video) { log('PiP: 未找到 video 元素'); return; }
        if (document.pictureInPictureElement === video) return;
        if (state.pipRequesting) { log('PiP: 已有请求进行中，跳过'); return; }

        const doRequest = () => {
            if (!video.requestPictureInPicture) { log('PiP: video 不支持 requestPictureInPicture'); return; }
            state.pipRequesting = true;
            const promise = video.requestPictureInPicture();
            if (promise && promise.then) {
                promise.then(() => log('PiP: 已进入画中画'))
                       .catch(e => log('PiP: 进入失败:', e.message))
                       .finally(() => { state.pipRequesting = false; });
            } else {
                state.pipRequesting = false;
            }
        };

        if (video.readyState < 2) {
            log('PiP: video 未就绪(readyState=' + video.readyState + ')，等待 canplay 后进入');
            video.addEventListener('canplay', function onCanPlay() {
                video.removeEventListener('canplay', onCanPlay);
                doRequest();
            });
            return;
        }
        doRequest();
    }

    function exitPiP() {
        if (document.pictureInPictureElement) {
            document.exitPictureInPicture().then(() => log('PiP: 已退出画中画')).catch(() => {});
        }
    }

    // 用户点击脚本按钮切换 PiP
    function togglePiP() {
        state.pipWanted = !state.pipWanted;
        persistPipState();
        log('PiP: pipWanted =', state.pipWanted);
        if (state.pipWanted) {
            enterPiP();
        } else {
            state.pipSwitchingEpisode = false;  // 用户主动退出，取消切集标记
            exitPiP();
        }
        updatePiPButton();
    }

    function bindPiPEvents(video) {
        if (!video || state.pipBoundVideo === video) return;
        state.pipBoundVideo = video;

        // 视频加载完成后显示画中画按钮
        const showBtn = () => {
            if (state.pipButton) state.pipButton.style.display = 'block';
        };
        if (video.readyState >= 2) {
            showBtn();
        }
        video.addEventListener('loadeddata', showBtn, { passive: true });
        video.addEventListener('canplay', showBtn, { passive: true });

        // 兼容 Edge / Chrome 原生画中画按钮：
        // 用户通过浏览器原生 PiP 按钮进入时，同步 pipWanted = true
        video.addEventListener('enterpictureinpicture', () => {
            state.pipActive = true;
            state.pipSwitchingEpisode = false;  // 成功进入（含切集后重入），清除标记
            if (!state.pipWanted) {
                state.pipWanted = true;
                persistPipState();
                log('PiP: 检测到外部进入画中画（如Edge原生按钮），已同步 pipWanted = true');
            }
            updatePiPButton();
            log('PiP: enterpictureinpicture 事件');
        });

        video.addEventListener('leavepictureinpicture', () => {
            state.pipActive = false;
            updatePiPButton();
            log('PiP: leavepictureinpicture 事件');

            if (state.pipSwitchingEpisode) {
                // 切换集数导致的退出，自动重新进入
                log('PiP: 切集导致退出，尝试重新进入');
                maybeEnterPiP(CONFIG.pipReenterDelay);
            } else {
                // 用户手动退出（关闭 PiP 窗口 / Edge 原生按钮退出）
                if (state.pipWanted) {
                    state.pipWanted = false;
                    persistPipState();
                    log('PiP: 用户手动退出画中画，pipWanted = false');
                    updatePiPButton();
                }
            }
        });
        log('PiP: 已绑定 PiP 事件（含 canplay 显示按钮 + Edge 原生按钮兼容）');
    }

    // 创建画中画按钮（初始隐藏，视频加载完成后显示）
    // 使用 CSS :hover 替代 JS mouseenter/mouseleave，减少事件监听器
    function createPiPButton() {
        if (!isPiPSupported()) { log('PiP: 浏览器不支持画中画，跳过创建按钮'); return; }
        if (state.pipButton) return;

        const btn = document.createElement('div');
        btn.id = 'softone-pip-btn';
        btn.textContent = '\u29C9 画中画';
        btn.style.cssText = [
            'position:fixed', 'right:20px', 'bottom:20px', 'z-index:999999',
            'background:rgba(0,0,0,0.75)', 'color:#fff',
            'padding:8px 16px', 'border-radius:20px', 'font-size:13px',
            'cursor:pointer', 'user-select:none', 'transition:background 0.2s',
            'box-shadow:0 2px 8px rgba(0,0,0,0.3)', 'font-family:sans-serif',
            'display:none'  // 初始隐藏，等视频加载完成
        ].join(';');

        // CSS :hover 处理悬停效果（仅在非激活状态下生效）
        const style = document.createElement('style');
        style.textContent = [
            '#softone-pip-btn:hover { background:rgba(0,0,0,0.92) !important; }',
            '#softone-pip-btn[data-active="true"] { background:rgba(220,53,69,0.88) !important; }',
            '#softone-pip-btn[data-active="true"]:hover { background:rgba(220,53,69,1) !important; }'
        ].join('\n');
        document.head.appendChild(style);

        btn.addEventListener('click', (e) => {
            e.stopPropagation();
            togglePiP();
        });

        document.body.appendChild(btn);
        state.pipButton = btn;
        log('PiP: 按钮已创建（初始隐藏）');
    }

    function updatePiPButton() {
        if (!state.pipButton) return;
        state.pipButton.textContent = state.pipWanted ? '\u2715 退出画中画' : '\u29C9 画中画';
        state.pipButton.setAttribute('data-active', state.pipWanted ? 'true' : 'false');
    }

    // ==================== 重置所有播放状态 ====================
    function resetPlayState() {
        state.lastNextAt = 0;
        state._endedFired = false;
        state.playerEndedBound = false;
        state._videoEndedBound = false;
        state._waiting = false;
        state.pipBoundVideo = null;  // 新 video 需要重新绑定 PiP 事件
        // 不清除 pipWanted 和 pipSwitchingEpisode，让 PiP 跨集保持
        // 不清除 autoPlayKeys，避免同一视频重复尝试
    }

    // ==================== 完成条件弹窗检测 ====================
    // 监听"当前任务已达到完成条件"弹窗出现，自动播放下一集
    function checkCompleteDialog() {
        for (const wrapper of document.querySelectorAll(
            '.el-message-box__wrapper, .el-dialog__wrapper, .v-modal + div'
        )) {
            const style = window.getComputedStyle(wrapper);
            if (style.display === 'none' || style.visibility === 'hidden') continue;
            const text = wrapper.textContent || '';
            if (text.includes('当前任务已达到完成条件') ||
                (text.includes('提示') && text.includes('完成条件')) ||
                text.includes('恭喜你')) {
                log('检测到完成条件弹窗，自动触发下一集');
                goNext('完成条件弹窗');
                return true;
            }
        }
        return false;
    }

    // ==================== 初始化 ====================

    function init() {
        log('脚本已加载');
        // 读取用户上次选择的 PiP 状态
        state.pipWanted = loadPipState();
        if (state.pipWanted) log('PiP: 从 localStorage 恢复 pipWanted = true');
        installVisibilityHook();
        ensurePlaying();

        // SPA 切换章节：URL 变化时重置并重新绑定
        let lastUrl = location.href;
        new MutationObserver(() => {
            const url = location.href;
            if (url !== lastUrl) {
                lastUrl = url;
                log('页面URL变化:', url);
                resetPlayState();
                // SPA 路由变化后，Vue 需要时间渲染新组件
                setTimeout(() => ensurePlaying(), 2000);
            }
        }).observe(document.documentElement, { childList: true, subtree: true });

        // 监听视频容器 DOM 变化：视频元素可能被 Vue 销毁重建
        const videoContainerObs = new MutationObserver((mutations) => {
            for (const mutation of mutations) {
                // 检查是否有 video 元素被移除或添加
                for (const node of mutation.removedNodes) {
                    if (node.nodeName === 'VIDEO' || (node.querySelector && node.querySelector('video'))) {
                        log('检测到 video 元素被移除，准备重新绑定');
                        resetPlayState();
                        setTimeout(() => ensurePlaying(), 1500);
                        return;
                    }
                }
                for (const node of mutation.addedNodes) {
                    if (node.nodeName === 'VIDEO' || (node.querySelector && node.querySelector('video'))) {
                        log('检测到 video 元素被添加，准备自动播放');
                        resetPlayState();
                        setTimeout(() => ensurePlaying(), 1000);
                        return;
                    }
                }
            }
        });
        // 观察整个 body，因为 Vue 组件可能在任何位置渲染视频
        videoContainerObs.observe(document.body, { childList: true, subtree: true });

        // 监听"当前任务已达到完成条件"弹窗出现，自动播放下一集
        const dialogObs = new MutationObserver(() => {
            if (state._completeDialogHandled) return;
            if (checkCompleteDialog()) {
                // 防止同一弹窗重复触发（goNext 内部有冷却，这里再加一道保险）
                state._completeDialogHandled = true;
                setTimeout(() => { state._completeDialogHandled = false; }, CONFIG.cooldownMs + 1000);
            }
        });
        dialogObs.observe(document.body, { childList: true, subtree: true });
    }

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