// ==UserScript==
// @name         六局云学堂学习助手 V1.0
// @namespace    Violentmonkey Scripts
// @match        *://crsg.jianxianexuetang.cn/study/sub_cm/course/detail*
// @match        *://crsg.jianxianexuetang.cn/study/sub_cm/content/detail*
// @grant        none
// @run-at       document-start
// @version      1.0
// @author       石港中心试验室出品
// @description  (v1.0 Refactored) 仅保留自动播放和跳转模块 (脚本 A)。实现课程自动播放、PPT 自动浏览及跨章跳转，并包含强制从第一节课启动逻辑。
// ==/UserScript==

(function() {
    "use strict";

    // =========================================================================
    // ## 常量配置
    // =========================================================================

    const CONFIG = {
        // 版本信息
        VERSION: "v1.0",
        
        // 时间间隔配置
        INTERVALS: {
            CHECK: 5000,
            REPORT: 5 * 60 * 1000,
            RETRY: 3000,
            VIDEO_WAIT: 5000,
            PPT_WAIT: 5000,
            MONITOR_DELAY: 10000,
            AUTO_JUMP_DELAY: 1500,
            AUTO_JUMP_TIMEOUT: 5000,
            STARTUP_DELAY: 1500,
            DETECT_DELAY: 1000,
            CONTENT_DETECT_DELAY: 3000,
            SCROLL_DELAY: 1000,
            TIME_EXPAND_DELAY: 1000,
            POPUP_CHECK_INTERVAL: 1000,
            POPUP_AUTO_CLOSE_DELAY: 500
        },

        // 选择器配置
        SELECTORS: {
            VIDEO: 'video',
            PPT_SLIDES: '.img-item.document-item',
            PPT_CONTAINER: '.content-box.y-box',
            PPT_TIME_CONTAINER: '.gapDiv.font-btn-color.pd-l-5',
            PPT_TIME_ELEMENT: '.theme-color1',
            VIDEO_REMAINING: 'div.gapDiv > div > span',
            PHASE_LIST: '.phase-list .phase-item',
            CONTENT_LIST: '.content-list .content-item',
            ACTIVE_ITEM: '.content-item.active',
            FIRST_ITEM: '.phase-list .content-item',
            PANEL_HEADER: '#xuexi-header',
            PANEL_BODY: '#xuexi-body',
            // 弹窗相关选择器
            POPUP_CONTAINER: '.el-dialog__wrapper, .ant-modal-root, .v-modal, .modal-mask, .popup-mask',
            POPUP_DIALOG: '.el-dialog, .ant-modal, .v-modal, .modal, .popup',
            POPUP_CONFIRM_BTN: '.el-button--primary, .ant-btn-primary, .confirm-btn, .ok-btn, .btn-primary',
            POPUP_CLOSE_BTN: '.el-dialog__headerbtn, .ant-modal-close, .close-btn, .modal-close',
            POPUP_OK_BTN: 'button:contains("确定"), button:contains("确认"), button:contains("OK"), button:contains("ok")',
            POPUP_YES_BTN: 'button:contains("是"), button:contains("Yes"), button:contains("yes")',
            POPUP_CONTENT: '.el-dialog__body, .ant-modal-body, .modal-body, .popup-content'
        },

        // UI配置
        UI: {
            PANEL_WIDTH: 260,
            PANEL_MIN_WIDTH: 120,
            PANEL_HEIGHT: 36,
            PANEL_POSITION: { top: '50px', left: '50px' },
            BACKGROUND_URL: 'https://picsum.photos/seed/professional-blue/800/600.jpg'
        },

        // 功能开关
        FLAGS: {
            SKIP_VIDEOS_WITHOUT_REQUIREMENT: false,
            AUTO_HANDLE_POPUP: true,
            POPUP_DEBUG_MODE: false
        }
    };

    // =========================================================================
    // ## 工具类和辅助函数
    // =========================================================================

    class Logger {
        constructor(container) {
            this.container = container;
            this.logs = [];
        }

        log(message, type = 'info') {
            const timestamp = new Date().toLocaleTimeString();
            const prefixes = {
                info: 'ℹ️',
                success: '✅',
                warn: '⚠️',
                error: '❌'
            };
            const prefix = prefixes[type] || '•';
            
            const logEntry = `[${timestamp}] ${prefix} ${message}`;
            this.logs.push(logEntry);

            if (this.container) {
                const line = document.createElement('div');
                line.textContent = logEntry;
                this.container.appendChild(line);
                this.container.scrollTo({ 
                    top: this.container.scrollHeight, 
                    behavior: 'smooth' 
                });
            }

            console.log(`[六局云学堂 ${CONFIG.VERSION}] ${message}`);
        }

        info(message) { this.log(message, 'info'); }
        success(message) { this.log(message, 'success'); }
        warn(message) { this.log(message, 'warn'); }
        error(message) { this.log(message, 'error'); }

        copyToClipboard() {
            return navigator.clipboard.writeText(this.logs.join('\n'));
        }

        getLogs() {
            return this.logs.join('\n');
        }
    }

    class TimeUtils {
        static formatSecondsToChinese(seconds) {
            seconds = Math.round(seconds);
            const minutes = Math.floor(seconds / 60);
            const remainingSeconds = seconds % 60;
            return `(${minutes}分${remainingSeconds}秒)`;
        }

        static parseTimeToSeconds(timeText) {
            let totalSeconds = 0;
            const minuteMatch = timeText.match(/(\d+)分/);
            if (minuteMatch?.[1]) {
                totalSeconds += parseInt(minuteMatch[1], 10) * 60;
            }
            const secondMatch = timeText.match(/(\d+)秒/);
            if (secondMatch?.[1]) {
                totalSeconds += parseInt(secondMatch[1], 10);
            }
            return totalSeconds;
        }
    }

    class DOMUtils {
        static waitForElement(selector, timeout = 10000) {
            return new Promise((resolve) => {
                const element = document.querySelector(selector);
                if (element) {
                    resolve(element);
                    return;
                }

                const observer = new MutationObserver(() => {
                    const element = document.querySelector(selector);
                    if (element) {
                        observer.disconnect();
                        resolve(element);
                    }
                });

                observer.observe(document.body, {
                    childList: true,
                    subtree: true
                });

                setTimeout(() => {
                    observer.disconnect();
                    resolve(null);
                }, timeout);
            });
        }

        static async scrollToElement(element, options = {}) {
            if (!element) return;
            element.scrollIntoView({ 
                behavior: 'smooth', 
                block: 'center',
                ...options 
            });
        }

        static async slowScroll(container, targetScrollTop, duration) {
            return new Promise(resolve => {
                const startScrollTop = container.scrollTop;
                const distance = targetScrollTop - startScrollTop;
                let startTime = null;

                function easeOutQuad(t) { 
                    return t * (2 - t); 
                }

                function animation(currentTime) {
                    if (startTime === null) startTime = currentTime;
                    const elapsedTime = currentTime - startTime;
                    const progress = Math.min(elapsedTime / duration, 1);
                    const easedProgress = easeOutQuad(progress);
                    container.scrollTop = startScrollTop + distance * easedProgress;
                    
                    if (elapsedTime < duration) {
                        requestAnimationFrame(animation);
                    } else {
                        container.scrollTop = targetScrollTop;
                        resolve();
                    }
                }

                requestAnimationFrame(animation);
            });
        }
    }

    // =========================================================================
    // ## 弹窗监控器类
    // =========================================================================

    class PopupMonitor {
        constructor(logger) {
            this.logger = logger;
            this.monitoringTimer = null;
            this.handledPopups = new Set();
            this.isMonitoring = false;
        }

        startMonitoring() {
            if (this.isMonitoring || !CONFIG.FLAGS.AUTO_HANDLE_POPUP) return;
            
            this.isMonitoring = true;
            this.logger.info('[弹窗] 开始监控弹窗...');
            
            this.monitoringTimer = setInterval(() => {
                this.checkAndHandlePopups();
            }, CONFIG.INTERVALS.POPUP_CHECK_INTERVAL);
        }

        stopMonitoring() {
            if (this.monitoringTimer) {
                clearInterval(this.monitoringTimer);
                this.monitoringTimer = null;
            }
            this.isMonitoring = false;
            this.handledPopups.clear();
            this.logger.info('[弹窗] 停止监控弹窗');
        }

        async checkAndHandlePopups() {
            try {
                // 检测各种类型的弹窗
                const popups = [
                    ...this.findElementsBySelectors([
                        CONFIG.SELECTORS.POPUP_CONTAINER,
                        CONFIG.SELECTORS.POPUP_DIALOG
                    ]),
                    ...this.findElementsByContent()
                ];

                for (const popup of popups) {
                    if (this.shouldHandlePopup(popup)) {
                        await this.handlePopup(popup);
                    }
                }
            } catch (error) {
                this.logger.error(`[弹窗] 检测过程中出错: ${error.message}`);
            }
        }

        findElementsBySelectors(selectors) {
            const elements = [];
            for (const selector of selectors) {
                try {
                    const found = document.querySelectorAll(selector);
                    elements.push(...Array.from(found));
                } catch (error) {
                    // 忽略无效选择器
                }
            }
            return elements;
        }

        findElementsByContent() {
            const elements = [];
            
            // 查找包含特定文本的元素
            const popupKeywords = ['确定', '确认', '提示', '警告', '通知', '消息', 'OK', 'ok', 'Yes', 'yes'];
            
            for (const keyword of popupKeywords) {
                const xpath = `//*[contains(text(), '${keyword}') and (self::div or self::p or self::span)]`;
                try {
                    const result = document.evaluate(xpath, document, null, XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE, null);
                    for (let i = 0; i < result.snapshotLength; i++) {
                        const element = result.snapshotItem(i);
                        // 检查是否是弹窗内容的一部分
                        const parentDialog = element.closest('.el-dialog, .ant-modal, .v-modal, .modal, .popup');
                        if (parentDialog) {
                            elements.push(parentDialog);
                        } else if (window.getComputedStyle(element).position === 'fixed') {
                            // 可能是独立弹窗
                            elements.push(element.parentElement || element);
                        }
                    }
                } catch (error) {
                    // 忽略xpath错误
                }
            }
            
            return elements;
        }

        shouldHandlePopup(popup) {
            if (!popup) return false;
            
            // 检查是否已经处理过
            const popupId = this.getPopupId(popup);
            if (this.handledPopups.has(popupId)) return false;
            
            // 检查是否可见
            if (!this.isPopupVisible(popup)) return false;
            
            return true;
        }

        getPopupId(popup) {
            // 生成弹窗的唯一标识
            const id = popup.id || popup.className || popup.textContent?.substring(0, 50) || Math.random().toString(36);
            return `${id}_${popup.tagName}`;
        }

        isPopupVisible(popup) {
            try {
                const style = window.getComputedStyle(popup);
                const rect = popup.getBoundingClientRect();
                
                return style.display !== 'none' && 
                       style.visibility !== 'hidden' && 
                       style.opacity !== '0' &&
                       rect.width > 0 && 
                       rect.height > 0 &&
                       rect.top >= 0;
            } catch (error) {
                return false;
            }
        }

        async handlePopup(popup) {
            const popupId = this.getPopupId(popup);
            this.handledPopups.add(popupId);
            
            try {
                // 记录弹窗信息
                const popupText = this.extractPopupText(popup);
                this.logger.info(`[弹窗] 检测到弹窗: "${popupText.substring(0, 50)}${popupText.length > 50 ? '...' : ''}"`);
                
                if (CONFIG.FLAGS.POPUP_DEBUG_MODE) {
                    this.logger.info(`[弹窗] 调试模式 - 弹窗信息: ${popup.outerHTML.substring(0, 200)}...`);
                }

                // 尝试自动处理弹窗
                const handled = await this.autoHandlePopup(popup);
                
                if (handled) {
                    this.logger.success(`[弹窗] 成功处理弹窗`);
                } else {
                    this.logger.warn(`[弹窗] 无法自动处理弹窗，将等待5秒后重试`);
                    // 5秒后从处理列表中移除，以便重试
                    setTimeout(() => {
                        this.handledPopups.delete(popupId);
                    }, 5000);
                }
                
            } catch (error) {
                this.logger.error(`[弹窗] 处理弹窗时出错: ${error.message}`);
                this.handledPopups.delete(popupId);
            }
        }

        extractPopupText(popup) {
            const textElements = popup.querySelectorAll('p, div, span, h1, h2, h3, h4, h5, h6');
            const texts = Array.from(textElements).map(el => el.textContent?.trim()).filter(text => text);
            return texts.join(' ').substring(0, 200);
        }

        async autoHandlePopup(popup) {
            // 策略1: 查找确认按钮
            let confirmButton = this.findConfirmButton(popup);
            if (confirmButton) {
                await this.clickButton(confirmButton, '确认');
                return true;
            }

            // 策略2: 查找OK按钮
            let okButton = this.findOkButton(popup);
            if (okButton) {
                await this.clickButton(okButton, 'OK');
                return true;
            }

            // 策略3: 查找是按钮
            let yesButton = this.findYesButton(popup);
            if (yesButton) {
                await this.clickButton(yesButton, '是');
                return true;
            }

            // 策略4: 查找主要按钮
            let primaryButton = this.findPrimaryButton(popup);
            if (primaryButton) {
                await this.clickButton(primaryButton, '主要');
                return true;
            }

            // 策略5: 查找关闭按钮
            let closeButton = this.findCloseButton(popup);
            if (closeButton) {
                await this.clickButton(closeButton, '关闭');
                return true;
            }

            // 策略6: 如果只有一个按钮，点击它
            const allButtons = popup.querySelectorAll('button, .btn, [role="button"]');
            if (allButtons.length === 1) {
                await this.clickButton(allButtons[0], '唯一');
                return true;
            }

            return false;
        }

        findConfirmButton(popup) {
            const selectors = CONFIG.SELECTORS.POPUP_CONFIRM_BTN.split(', ');
            for (const selector of selectors) {
                try {
                    const button = popup.querySelector(selector);
                    if (button && this.isButtonVisible(button)) {
                        return button;
                    }
                } catch (error) {
                    // 忽略选择器错误
                }
            }
            
            // 查找包含确认文本的按钮
            return this.findButtonByText(popup, ['确定', '确认', '确认']);
        }

        findOkButton(popup) {
            return this.findButtonByText(popup, ['OK', 'ok', '确定', '好的']);
        }

        findYesButton(popup) {
            return this.findButtonByText(popup, ['是', 'Yes', 'yes', '确定']);
        }

        findPrimaryButton(popup) {
            const selectors = [
                '.el-button--primary',
                '.ant-btn-primary',
                '.btn-primary',
                '.primary-btn',
                '[type="submit"]'
            ];
            
            for (const selector of selectors) {
                try {
                    const button = popup.querySelector(selector);
                    if (button && this.isButtonVisible(button)) {
                        return button;
                    }
                } catch (error) {
                    // 忽略选择器错误
                }
            }
            
            return null;
        }

        findCloseButton(popup) {
            const selectors = CONFIG.SELECTORS.POPUP_CLOSE_BTN.split(', ');
            for (const selector of selectors) {
                try {
                    const button = popup.querySelector(selector);
                    if (button && this.isButtonVisible(button)) {
                        return button;
                    }
                } catch (error) {
                    // 忽略选择器错误
                }
            }
            
            return null;
        }

        findButtonByText(popup, texts) {
            for (const text of texts) {
                // 使用CSS选择器查找包含文本的元素
                const xpath = `//button[contains(text(), '${text}')] | //*[@role="button"][contains(text(), '${text}')] | //*[contains(@class, 'btn')][contains(text(), '${text}')]`;
                try {
                    const result = document.evaluate(xpath, popup, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null);
                    const button = result.singleNodeValue;
                    if (button && this.isButtonVisible(button)) {
                        return button;
                    }
                } catch (error) {
                    // 忽略xpath错误
                }
            }
            
            // 备用方法：遍历所有按钮
            const allButtons = popup.querySelectorAll('button, .btn, [role="button"]');
            for (const button of allButtons) {
                if (button.textContent && button.textContent.trim().includes(texts[0]) && this.isButtonVisible(button)) {
                    return button;
                }
            }
            
            return null;
        }

        isButtonVisible(button) {
            try {
                const style = window.getComputedStyle(button);
                const rect = button.getBoundingClientRect();
                
                return style.display !== 'none' && 
                       style.visibility !== 'hidden' && 
                       !button.disabled &&
                       rect.width > 0 && 
                       rect.height > 0;
            } catch (error) {
                return false;
            }
        }

        async clickButton(button, buttonType) {
            try {
                this.logger.info(`[弹窗] 点击${buttonType}按钮: "${button.textContent?.trim() || button.className}"`);
                
                // 滚动到按钮位置
                button.scrollIntoView({ behavior: 'smooth', block: 'center' });
                
                // 等待一小段时间
                await this.delay(CONFIG.INTERVALS.POPUP_AUTO_CLOSE_DELAY);
                
                // 创建鼠标事件
                const clickEvent = new MouseEvent('click', {
                    view: window,
                    bubbles: true,
                    cancelable: true,
                    clientX: button.getBoundingClientRect().left + 5,
                    clientY: button.getBoundingClientRect().top + 5
                });
                
                // 触发点击事件
                button.dispatchEvent(clickEvent);
                
                // 备用方法：直接调用click方法
                if (typeof button.click === 'function') {
                    button.click();
                }
                
                return true;
            } catch (error) {
                this.logger.error(`[弹窗] 点击${buttonType}按钮失败: ${error.message}`);
                return false;
            }
        }

        delay(ms) {
            return new Promise(resolve => setTimeout(resolve, ms));
        }

        // 手动处理弹窗的方法
        async handleCurrentPopup() {
            const popups = [
                ...this.findElementsBySelectors([
                    CONFIG.SELECTORS.POPUP_CONTAINER,
                    CONFIG.SELECTORS.POPUP_DIALOG
                ]),
                ...this.findElementsByContent()
            ];

            if (popups.length === 0) {
                this.logger.info('[弹窗] 当前没有检测到弹窗');
                return false;
            }

            for (const popup of popups) {
                if (this.shouldHandlePopup(popup)) {
                    await this.handlePopup(popup);
                    return true;
                }
            }

            return false;
        }
    }

    // =========================================================================
    // ## UI管理类
    // =========================================================================

    class UIPanel {
        constructor() {
            this.panel = null;
            this.header = null;
            this.body = null;
            this.logger = null;
            this.isMinimized = false;
            this.isDragging = false;
            this.dragOffset = { x: 0, y: 0 };
        }

        init() {
            this.createPanel();
            this.setupStyles();
            this.setupDragFunctionality();
            this.setupMinimizeToggle();
            this.setupCopyButton();
            
            this.logger = new Logger(this.body);
            this.logger.info('[系统] 六局云学堂已启动，等待内容加载...');
            
            return this.logger;
        }

        createPanel() {
            this.panel = document.createElement('div');
            this.panel.innerHTML = `
                <div id="xuexi-header" style="text-align:center;font-weight:bold;font-size:14px;padding:6px 0;border-bottom:1px solid rgba(255,255,255,0.15);cursor:move;transition:all 0.3s ease;">
                    六局云学堂 ${CONFIG.VERSION}
                </div>
                <div id="xuexi-body" style="max-height:200px;overflow-y:auto;padding:8px;font-size:12px;line-height:1.5;scrollbar-width:thin;scrollbar-color:rgba(255,255,255,0.3) rgba(255,255,255,0.1);transition:all 0.3s ease;">
                </div>
            `;

            Object.assign(this.panel.style, {
                position: 'fixed',
                top: CONFIG.UI.PANEL_POSITION.top,
                left: CONFIG.UI.PANEL_POSITION.left,
                width: `${CONFIG.UI.PANEL_WIDTH}px`,
                background: 'rgba(30,30,30,0.35)',
                backgroundImage: `url("${CONFIG.UI.BACKGROUND_URL}")`,
                backgroundSize: 'cover',
                backgroundPosition: 'center',
                backgroundBlendMode: 'overlay',
                border: '1px solid rgba(255,255,255,0.25)',
                borderRadius: '10px',
                backdropFilter: 'blur(12px)',
                color: '#fff',
                zIndex: 9999999,
                userSelect: 'none',
                boxShadow: '0 4px 20px rgba(0,0,0,0.3)',
                overflow: 'hidden'
            });

            document.body.appendChild(this.panel);
            this.header = this.panel.querySelector(CONFIG.SELECTORS.PANEL_HEADER);
            this.body = this.panel.querySelector(CONFIG.SELECTORS.PANEL_BODY);
        }

        setupStyles() {
            const style = document.createElement('style');
            style.textContent = `
                #xuexi-body::-webkit-scrollbar { width: 6px; }
                #xuexi-body::-webkit-scrollbar-track { background: rgba(255,255,255,0.1); border-radius:10px; }
                #xuexi-body::-webkit-scrollbar-thumb { background: rgba(255,255,255,0.3); border-radius:10px; }
                #xuexi-body::-webkit-scrollbar-thumb:hover { background: rgba(255,255,255,0.5); }
            `;
            document.head.appendChild(style);
        }

        setupDragFunctionality() {
            this.header.addEventListener('mousedown', (e) => {
                this.isDragging = true;
                this.dragOffset.x = e.clientX - this.panel.offsetLeft;
                this.dragOffset.y = e.clientY - this.panel.offsetTop;

                const handleMouseMove = (e) => {
                    if (!this.isDragging) return;
                    this.panel.style.left = `${e.clientX - this.dragOffset.x}px`;
                    this.panel.style.top = `${e.clientY - this.dragOffset.y}px`;
                };

                const handleMouseUp = () => {
                    this.isDragging = false;
                    document.removeEventListener('mousemove', handleMouseMove);
                    document.removeEventListener('mouseup', handleMouseUp);
                };

                document.addEventListener('mousemove', handleMouseMove);
                document.addEventListener('mouseup', handleMouseUp);
            });
        }

        setupMinimizeToggle() {
            this.header.addEventListener('dblclick', () => {
                this.isMinimized = !this.isMinimized;
                
                if (this.isMinimized) {
                    this.body.style.display = 'none';
                    this.panel.style.width = `${CONFIG.UI.PANEL_MIN_WIDTH}px`;
                    this.panel.style.height = `${CONFIG.UI.PANEL_HEIGHT}px`;
                    this.panel.style.boxShadow = '0 2px 6px rgba(0,0,0,0.15)';
                    this.header.style.fontSize = '12px';
                    this.header.style.padding = '4px 0';
                    this.header.textContent = '六局云学堂（最小化）';
                    this.copyBtn.style.display = 'none';
                    this.popupBtn.style.display = 'none';
                } else {
                    this.body.style.display = 'block';
                    this.panel.style.width = `${CONFIG.UI.PANEL_WIDTH}px`;
                    this.panel.style.height = 'auto';
                    this.panel.style.boxShadow = '0 4px 20px rgba(0,0,0,0.3)';
                    this.header.style.fontSize = '14px';
                    this.header.style.padding = '6px 0';
                    this.header.textContent = `学六局云学堂 ${CONFIG.VERSION}`;
                    this.copyBtn.style.display = 'flex';
                    this.popupBtn.style.display = 'flex';
                }
            });
        }

        setupControlButtons() {
            // 复制日志按钮
            this.copyBtn = document.createElement('div');
            this.copyBtn.textContent = '📋';
            Object.assign(this.copyBtn.style, {
                position: 'absolute',
                top: '6px',
                right: '8px',
                cursor: 'pointer',
                color: '#fff',
                fontWeight: 'bold',
                userSelect: 'none',
                fontSize: '12px',
                width: '16px',
                height: '16px',
                display: 'flex',
                alignItems: 'center',
                justifyContent: 'center'
            });
            this.copyBtn.title = '点击复制日志';
            
            this.panel.appendChild(this.copyBtn);
            
            this.copyBtn.addEventListener('click', async () => {
                try {
                    await this.logger.copyToClipboard();
                    this.logger.success('日志已复制到剪贴板');
                } catch (error) {
                    this.logger.error('复制失败，请手动复制');
                }
            });

            // 弹窗处理按钮
            this.popupBtn = document.createElement('div');
            this.popupBtn.textContent = '🎯';
            Object.assign(this.popupBtn.style, {
                position: 'absolute',
                top: '6px',
                right: '30px',
                cursor: 'pointer',
                color: '#fff',
                fontWeight: 'bold',
                userSelect: 'none',
                fontSize: '12px',
                width: '16px',
                height: '16px',
                display: 'flex',
                alignItems: 'center',
                justifyContent: 'center'
            });
            this.popupBtn.title = '手动处理弹窗';
            
            this.panel.appendChild(this.popupBtn);
            
            // 弹窗按钮点击事件将在外部设置
        }

        setupCopyButton() {
            // 重定向到新的控制按钮设置方法
            this.setupControlButtons();
        }

        setPopupButtonCallback(callback) {
            if (this.popupBtn && callback) {
                this.popupBtn.addEventListener('click', callback);
            }
        }
    }

    // =========================================================================
    // ## 内容检测器类
    // =========================================================================

    class ContentDetector {
        constructor(logger) {
            this.logger = logger;
        }

        checkPptElements() {
            const slides = document.querySelectorAll(CONFIG.SELECTORS.PPT_SLIDES);
            if (slides.length === 0) return false;
            
            const scrollContainer = document.querySelector(CONFIG.SELECTORS.PPT_CONTAINER);
            const firstSlideImg = slides[0].querySelector('img');
            
            return !!(scrollContainer && firstSlideImg);
        }

        detectContentType() {
            if (this.checkPptElements()) {
                return 'ppt';
            } else if (document.querySelector(CONFIG.SELECTORS.VIDEO)) {
                return 'video';
            }
            return 'unknown';
        }

        getVideoElement() {
            return document.querySelector(CONFIG.SELECTORS.VIDEO);
        }

        getPptElements() {
            return {
                slides: document.querySelectorAll(CONFIG.SELECTORS.PPT_SLIDES),
                container: document.querySelector(CONFIG.SELECTORS.PPT_CONTAINER),
                timeContainer: document.querySelector(CONFIG.SELECTORS.PPT_TIME_CONTAINER),
                timeElement: document.querySelector(CONFIG.SELECTORS.PPT_TIME_ELEMENT)
            };
        }

        getVideoRemainingElement() {
            return document.querySelector(CONFIG.SELECTORS.VIDEO_REMAINING);
        }

        getCurrentActiveItem() {
            return document.querySelector(CONFIG.SELECTORS.ACTIVE_ITEM);
        }

        getFirstItem() {
            return document.querySelector(CONFIG.SELECTORS.FIRST_ITEM);
        }

        getCourseStructure() {
            const phaseList = [...document.querySelectorAll(CONFIG.SELECTORS.PHASE_LIST)];
            const currentActive = this.getCurrentActiveItem();
            
            if (!currentActive) return null;

            const currentPhase = currentActive.closest('.phase-item');
            const contentList = [...currentPhase.querySelectorAll(CONFIG.SELECTORS.CONTENT_LIST)];
            const currentIndex = contentList.indexOf(currentActive);
            const phaseIndex = phaseList.indexOf(currentPhase);

            return {
                phaseList,
                currentPhase,
                contentList,
                currentIndex,
                phaseIndex,
                currentActive
            };
        }
    }

    // =========================================================================
    // ## 视频处理器类
    // =========================================================================

    class VideoHandler {
        constructor(logger, detector) {
            this.logger = logger;
            this.detector = detector;
            this.lastVideoSrc = null;
            this.progressTimer = null;
            this.lastProgressReport = 0;
        }

        async handlePlayback() {
            const video = this.detector.getVideoElement();
            if (!video) {
                this.logger.error('[视频] 启动失败，<video> 元素丢失');
                return;
            }

            if (this.lastVideoSrc === video.src) return;
            this.lastVideoSrc = video.src;

            this.logger.info('检测到新视频，等待5秒以确保加载完成...');
            await this.delay(CONFIG.INTERVALS.VIDEO_WAIT);

            const videoDurationSec = video.duration || 0;
            this.logger.info(`[视频] 解析到视频时长: ${videoDurationSec.toFixed(0)} 秒 ${TimeUtils.formatSecondsToChinese(videoDurationSec)}`);

            // 开始播放并等待任务要求加载
            video.muted = true;
            video.playbackRate = 2.0; // 设置2倍速播放
            try {
                await video.play();
                this.logger.success('视频已开始播放（2倍速），将在10秒内加载任务要求...');
            } catch (error) {
                this.logger.warn('自动播放被阻止，3秒后重试...');
                setTimeout(() => this.handlePlayback(), CONFIG.INTERVALS.RETRY);
                return;
            }

            // 监控播放状态
            await this.monitorPlayback(video, CONFIG.INTERVALS.MONITOR_DELAY);

            // 检查任务要求并决定处理方式
            const taskSeconds = await this.checkTaskRequirement(video);
            
            if (taskSeconds === null && CONFIG.FLAGS.SKIP_VIDEOS_WITHOUT_REQUIREMENT) {
                this.logger.success('[视频] 10秒后仍未检测到任务要求 (已开启跳过)，等待5秒后跳转...');
                return { action: 'jump' };
            } else {
                if (taskSeconds === null) {
                    this.logger.info('[视频] 10秒后仍未检测到任务要求，将按 99% 进度播放。');
                } else {
                    this.logger.info(`[视频] 成功检测到任务要求: ${taskSeconds} 秒 ${TimeUtils.formatSecondsToChinese(taskSeconds)}`);
                }
                this.trackVideoProgress(video);
                return { action: 'monitoring' };
            }
        }

        async monitorPlayback(video, durationMs) {
            return new Promise(resolve => {
                let elapsed = 0;
                const checkInterval = 100;

                const monitor = setInterval(() => {
                    // 确保视频始终保持2倍速
                    video.playbackRate = 2.0;
                    
                    if (video.paused || video.ended || video.currentTime >= video.duration - 0.5) {
                        if (video.paused) {
                            video.playbackRate = 2.0;
                            video.play().catch(e => {
                                this.logger.warn('[视频] 尝试恢复播放失败');
                            });
                        }
                        
                        if (video.ended || video.currentTime >= video.duration - 0.5) {
                            video.currentTime = 0;
                            video.playbackRate = 2.0;
                            video.play();
                            this.logger.info('[视频] 循环播放 (等待任务要求加载)');
                        }
                    }

                    elapsed += checkInterval;
                    if (elapsed >= durationMs) {
                        clearInterval(monitor);
                        resolve();
                    }
                }, checkInterval);
            });
        }

        async checkTaskRequirement(video) {
            const remainElem = this.detector.getVideoRemainingElement();
            if (remainElem) {
                return TimeUtils.parseTimeToSeconds(remainElem.innerText);
            }
            return null;
        }

        trackVideoProgress(video) {
            if (this.progressTimer) clearInterval(this.progressTimer);

            this.progressTimer = setInterval(() => {
                // 确保视频始终保持2倍速
                video.playbackRate = 2.0;
                
                const percent = (video.currentTime / video.duration) * 100;
                const remainElem = this.detector.getVideoRemainingElement();
                const remainText = remainElem ? remainElem.textContent.trim() : null;
                const now = Date.now();

                if (now - this.lastProgressReport >= CONFIG.INTERVALS.REPORT) {
                    this.logger.info(`📈 [视频] 进度报告：${percent.toFixed(1)}% (2倍速)`);
                    this.lastProgressReport = now;
                }

                const taskDone = remainElem ? (percent >= 99 && /^(0|00:00)$/.test(remainText)) : false;
                const progressDone = !remainElem && percent >= 99;

                if (taskDone || progressDone) {
                    clearInterval(this.progressTimer);
                    this.progressTimer = null;
                    this.logger.success('[视频] 播放已完成，准备跳转下一节。');
                    this.onVideoComplete();
                }
            }, CONFIG.INTERVALS.CHECK);
        }

        onVideoComplete() {
            // 这个方法将被外部重写
        }

        cleanup() {
            if (this.progressTimer) {
                clearInterval(this.progressTimer);
                this.progressTimer = null;
            }
            this.lastVideoSrc = null;
        }

        delay(ms) {
            return new Promise(resolve => setTimeout(resolve, ms));
        }
    }

    // =========================================================================
    // ## PPT处理器类
    // =========================================================================

    class PptHandler {
        constructor(logger, detector) {
            this.logger = logger;
            this.detector = detector;
            this.lastPptSrc = null;
            this.progressTimer = null;
            this.lastProgressReport = 0;
        }

        async handleAutoBrowser() {
            const pptElements = this.detector.getPptElements();
            const { slides, container, firstSlideImg } = pptElements;

            if (!slides.length || !container || !firstSlideImg) {
                this.logger.warn('[PPT] 必要元素缺失');
                return { action: 'error' };
            }

            const currentPptSrc = firstSlideImg.src;
            if (this.lastPptSrc === currentPptSrc) return { action: 'duplicate' };
            
            this.lastPptSrc = currentPptSrc;

            this.logger.info('检测到新PPT，等待5秒以确保加载完成...');
            await this.delay(CONFIG.INTERVALS.PPT_WAIT);

            const totalSeconds = await this.checkPptTimer();
            
            if (totalSeconds > 0) {
                const result = await this.performScrollBrowsing(slides, container, totalSeconds);
                if (!result.success) {
                    this.lastPptSrc = null;
                    setTimeout(() => this.handleAutoBrowser(), CONFIG.INTERVALS.RETRY);
                    return { action: 'retry' };
                }
                
                this.trackPptProgress();
                return { action: 'monitoring' };
            } else {
                this.logger.success('[PPT] 无需计时或时间已为0，等待5秒后跳转到下一节。');
                return { action: 'jump' };
            }
        }

        async checkPptTimer() {
            const { timeContainer, timeElement } = this.detector.getPptElements();
            let totalSeconds = 0;

            if (timeContainer) {
                try {
                    if (!timeElement) {
                        timeContainer.click();
                        await this.delay(CONFIG.INTERVALS.TIME_EXPAND_DELAY);
                    }

                    const newTimeElement = timeContainer.querySelector(CONFIG.SELECTORS.PPT_TIME_ELEMENT);
                    if (newTimeElement) {
                        totalSeconds = TimeUtils.parseTimeToSeconds(newTimeElement.innerText);
                        this.logger.info(`[PPT] 解析到总时长: ${totalSeconds} 秒 ${TimeUtils.formatSecondsToChinese(totalSeconds)}`);
                    } else {
                        this.logger.info('[PPT] 找到时间容器，但未找到时间元素，视为无计时。');
                    }
                } catch (error) {
                    this.logger.warn(`[PPT] 尝试读取时间失败: ${error.message}，视为无计时。`);
                }
            } else {
                this.logger.info('[PPT] 未找到时间容器，视为无计时。');
            }

            return totalSeconds;
        }

        async performScrollBrowsing(slides, container, totalSeconds) {
            try {
                this.logger.info(`[PPT] 找到 ${slides.length} 张幻灯片。`);
                const timePerSlideMs = (totalSeconds / slides.length) * 1000 + 200;
                this.logger.info(`[PPT] 每张滚动时间: ${timePerSlideMs.toFixed(0)}ms`);

                for (let i = 0; i < slides.length; i++) {
                    this.logger.info(`[PPT] 正在滚动到第 ${i + 1} / ${slides.length} 张...`);
                    const targetSlide = slides[i];
                    const targetScrollTop = targetSlide.offsetTop;
                    await DOMUtils.slowScroll(container, targetScrollTop, timePerSlideMs);
                }

                this.logger.success('[PPT] 滚动浏览完毕。');
                return { success: true };
                
            } catch (error) {
                this.logger.warn(`[PPT] 自动滚动失败: ${error.message}，3秒后重试...`);
                return { success: false, error };
            }
        }

        trackPptProgress() {
            if (this.progressTimer) clearInterval(this.progressTimer);

            this.progressTimer = setInterval(() => {
                const { timeElement } = this.detector.getPptElements();
                const now = Date.now();

                if (now - this.lastProgressReport >= CONFIG.INTERVALS.REPORT) {
                    const timeText = timeElement ? timeElement.innerText : "未知";
                    this.logger.info(`📈 [PPT] 进度报告：剩余 ${timeText}`);
                    this.lastProgressReport = now;
                }

                const remainingTimeText = timeElement ? timeElement.innerText.trim() : null;
                const totalSeconds = timeElement ? TimeUtils.parseTimeToSeconds(remainingTimeText) : 0;

                if ((timeElement && totalSeconds <= 0) || !timeElement) {
                    clearInterval(this.progressTimer);
                    this.progressTimer = null;
                    this.logger.success('[PPT] 时间已完成，准备跳转下一节。');
                    this.onPptComplete();
                }
            }, CONFIG.INTERVALS.CHECK);
        }

        onPptComplete() {
            // 这个方法将被外部重写
        }

        cleanup() {
            if (this.progressTimer) {
                clearInterval(this.progressTimer);
                this.progressTimer = null;
            }
            this.lastPptSrc = null;
        }

        delay(ms) {
            return new Promise(resolve => setTimeout(resolve, ms));
        }
    }

    // =========================================================================
    // ## 导航控制器类
    // =========================================================================

    class NavigationController {
        constructor(logger, detector) {
            this.logger = logger;
            this.detector = detector;
            this.autoJumpTimer = null;
        }

        async jumpToNext() {
            this.autoJumpTimer = null;

            const structure = this.detector.getCourseStructure();
            if (!structure) {
                this.logger.warn('未找到课程结构');
                return false;
            }

            const { phaseList, currentPhase, contentList, currentIndex, phaseIndex } = structure;

            // 尝试跳转到下一节
            const nextItem = contentList[currentIndex + 1];
            if (nextItem) {
                return await this.jumpToItem(nextItem, '下一节');
            }

            // 尝试跳转到下一章第一节
            const nextPhase = phaseList[phaseIndex + 1];
            if (nextPhase) {
                const firstItem = nextPhase.querySelector('.content-list .content-item');
                if (firstItem) {
                    return await this.jumpToItem(firstItem, '下一章第一节');
                } else {
                    this.logger.warn('下一章没有小节');
                    return false;
                }
            }

            this.logger.warn('已到最后一章，无下一节');
            return false;
        }

        async jumpToFirst() {
            const firstItem = this.detector.getFirstItem();
            const currentActive = this.detector.getCurrentActiveItem();

            if (!firstItem) {
                this.logger.warn('未找到第一节课程');
                return false;
            }

            if (firstItem === currentActive) {
                this.logger.info('已在第一节课');
                return true;
            }

            const title = firstItem.getAttribute('title') || firstItem.textContent.trim();
            this.logger.info(`🔄 [启动] 检测到不在第一节课，强制跳转到：《${title}》`);

            await DOMUtils.scrollToElement(firstItem);
            await this.delay(CONFIG.INTERVALS.SCROLL_DELAY);
            
            firstItem.click();
            return true;
        }

        async jumpToItem(item, description) {
            const title = item.getAttribute('title') || item.textContent.trim();
            this.logger.success(`⏭️ 自动跳转到${description}：《${title}》`);
            
            await DOMUtils.scrollToElement(item);
            await this.delay(CONFIG.INTERVALS.AUTO_JUMP_DELAY);
            
            item.click();
            return true;
        }

        scheduleAutoJump(delay = CONFIG.INTERVALS.AUTO_JUMP_TIMEOUT) {
            this.clearAutoJump();
            this.autoJumpTimer = setTimeout(() => this.jumpToNext(), delay);
        }

        clearAutoJump() {
            if (this.autoJumpTimer) {
                clearTimeout(this.autoJumpTimer);
                this.autoJumpTimer = null;
            }
        }

        delay(ms) {
            return new Promise(resolve => setTimeout(resolve, ms));
        }
    }

    // =========================================================================
    // ## 主控制器类
    // =========================================================================

    class StudyAssistant {
        constructor() {
            this.uiPanel = new UIPanel();
            this.logger = this.uiPanel.init();
            this.detector = new ContentDetector(this.logger);
            this.videoHandler = new VideoHandler(this.logger, this.detector);
            this.pptHandler = new PptHandler(this.logger, this.detector);
            this.navigationController = new NavigationController(this.logger, this.detector);
            this.popupMonitor = new PopupMonitor(this.logger);
            
            this.isPageStable = false;
            this.lastActiveItem = null;
            this.observer = null;

            this.setupEventHandlers();
            this.setupPopupHandling();
            this.setupUIControls();
        }

        setupEventHandlers() {
            // 设置完成回调
            this.videoHandler.onVideoComplete = () => {
                this.navigationController.scheduleAutoJump();
            };

            this.pptHandler.onPptComplete = () => {
                this.navigationController.scheduleAutoJump();
            };

            // 设置内容变化观察者
            this.setupContentObserver();
        }

        setupContentObserver() {
            this.observer = new MutationObserver(() => {
                const currentItem = this.detector.getCurrentActiveItem();

                if (!currentItem || currentItem === this.lastActiveItem) {
                    return;
                }

                if (!this.isPageStable) {
                    this.lastActiveItem = currentItem;
                    return;
                }

                this.logger.info('ℹ️ [观察者] 检测到内容切换...');

                this.navigationController.clearAutoJump();
                this.logger.info('ℹ️ [观察者] 已取消过时的自动跳转。');

                this.resetState();
                this.lastActiveItem = currentItem;

                setTimeout(() => this.detectAndStart(), CONFIG.INTERVALS.DETECT_DELAY);
            });

            this.observer.observe(document.body, {
                childList: true,
                subtree: true
            });
        }

        setupPopupHandling() {
            // 启动弹窗监控
            if (CONFIG.FLAGS.AUTO_HANDLE_POPUP) {
                this.popupMonitor.startMonitoring();
            }

            // 在关键操作前检查弹窗
            const originalHandleVideoContent = this.handleVideoContent.bind(this);
            this.handleVideoContent = async () => {
                await this.popupMonitor.handleCurrentPopup();
                await originalHandleVideoContent();
            };

            const originalHandlePptContent = this.handlePptContent.bind(this);
            this.handlePptContent = async () => {
                await this.popupMonitor.handleCurrentPopup();
                await originalHandlePptContent();
            };

            const originalJumpToNext = this.navigationController.jumpToNext.bind(this.navigationController);
            this.navigationController.jumpToNext = async () => {
                await this.popupMonitor.handleCurrentPopup();
                return await originalJumpToNext();
            };

            const originalJumpToFirst = this.navigationController.jumpToFirst.bind(this.navigationController);
            this.navigationController.jumpToFirst = async () => {
                await this.popupMonitor.handleCurrentPopup();
                return await originalJumpToFirst();
            };
        }

        setupUIControls() {
            // 设置弹窗处理按钮的回调
            this.uiPanel.setPopupButtonCallback(async () => {
                this.logger.info('[弹窗] 手动触发弹窗检查...');
                const handled = await this.popupMonitor.handleCurrentPopup();
                if (handled) {
                    this.logger.success('[弹窗] 成功处理弹窗');
                } else {
                    this.logger.info('[弹窗] 当前没有弹窗需要处理');
                }
            });
        }

        resetState() {
            this.isPageStable = false;
            this.lastActiveItem = null;
            this.videoHandler.cleanup();
            this.pptHandler.cleanup();
            this.navigationController.clearAutoJump();
        }

        async detectAndStart() {
            const contentType = this.detector.detectContentType();
            
            switch (contentType) {
                case 'ppt':
                    this.logger.info('检测到PPT页面，启动PPT模组...');
                    this.handlePptContent();
                    break;
                case 'video':
                    this.logger.info('检测到视频页面，启动视频模组...');
                    this.handleVideoContent();
                    break;
                default:
                    this.logger.warn('未检测到内容元素，3秒后重试...');
                    setTimeout(() => this.detectAndStart(), CONFIG.INTERVALS.RETRY);
            }
        }

        async handleVideoContent() {
            const result = await this.videoHandler.handlePlayback();
            this.isPageStable = true;
            
            if (result.action === 'jump') {
                this.navigationController.scheduleAutoJump(CONFIG.INTERVALS.AUTO_JUMP_TIMEOUT);
            }
        }

        async handlePptContent() {
            const result = await this.pptHandler.handleAutoBrowser();
            this.isPageStable = true;
            
            if (result.action === 'jump') {
                this.navigationController.scheduleAutoJump(CONFIG.INTERVALS.AUTO_JUMP_TIMEOUT);
            }
        }

        async start() {
            this.logger.success(`学习助手 [自动播放 ${CONFIG.VERSION}] 模块已启动`);
            
            const currentActive = this.detector.getCurrentActiveItem();
            this.lastActiveItem = currentActive;

            // 强制跳转到第一节课
            const firstItem = this.detector.getFirstItem();
            if (firstItem && firstItem !== currentActive) {
                this.isPageStable = true; // 预先设置，让观察者知道这是预期切换
                await this.navigationController.jumpToFirst();
            } else {
                if (firstItem) {
                    this.logger.info('ℹ️ [启动] 已在第一节课，直接开始检测内容...');
                } else {
                    this.logger.warn('⚠️ [启动] 未找到课程列表，按原逻辑启动检测。');
                }
                setTimeout(() => this.detectAndStart(), CONFIG.INTERVALS.CONTENT_DETECT_DELAY);
            }
        }

        destroy() {
            this.resetState();
            if (this.popupMonitor) {
                this.popupMonitor.stopMonitoring();
            }
            if (this.observer) {
                this.observer.disconnect();
                this.observer = null;
            }
        }
    }

    // =========================================================================
    // ## 启动器和初始化
    // =========================================================================

    function initializeLogger() {
        if (window.self === window.top) {
            console.log(
                `%c🟢 六局云学堂 [ ${CONFIG.VERSION}] 脚本已启动
———————————————
• 自动播放/跳转 (等待 Load)
———————————————`,
                "color:#4CAF50;font-size:14px;font-weight:bold;"
            );
        } else {
            console.log(`%c🟢 六局云学堂 [ ${CONFIG.VERSION}] 脚本已注入 <iframe>`, "color:#4CAF50;");
        }
    }

    let studyAssistant = null;

    async function runScript() {
        try {
            studyAssistant = new StudyAssistant();
            await studyAssistant.start();
        } catch (error) {
            console.error('[六局云学堂] 启动失败:', error);
            if (studyAssistant) {
                studyAssistant.destroy();
                studyAssistant = null;
            }
        }
    }

    // 确保脚本只在主窗口运行
    if (window.self === window.top) {
        initializeLogger();
        window.addEventListener("load", runScript);
    }

})();