// ==UserScript==
// @name         学达云教育自动学习脚本
// @namespace    http://tampermonkey.net/
// @version      1.8
// @description  支持总课表自动选择和课程学习自动切换
// @author       Auto Learning Script
// @match        *://*.ok99ok99.com/stu/study_new_v3.aspx*
// @match        *://ok99ok99.com/stu/study_new_v3.aspx*
// @match        *://*.ok99ok99.com/stu/cls_courselist.aspx*
// @match        *://ok99ok99.com/stu/cls_courselist.aspx*
// @grant        none
// @run-at       document-idle
// ==/UserScript==

(function() {
    'use strict';

    // 判断当前页面类型
    const isCourseListPage = location.href.includes('cls_courselist.aspx');
    const isStudyPage = location.href.includes('study_new_v3.aspx');

    // ==================== 日志系统 ====================
    const LOG_KEY = 'autoLearning_logs';
    let logs = [];
    
    function log(msg, type = 'info') {
        const time = new Date().toLocaleTimeString();
        const entry = `[${time}] [${type.toUpperCase()}] ${msg}`;
        logs.push(entry);
        if (logs.length > 100) logs.shift();
        try { localStorage.setItem(LOG_KEY, JSON.stringify(logs)); } catch (e) {}
        
        const styles = { info: 'color: #2196F3', success: 'color: #4CAF50', warning: 'color: #FF9800', error: 'color: #F44336' };
        console.log(`%c[自动学习] ${msg}`, styles[type] || '');
        updateLogUI(entry, type);
    }
    
    function getLogs() {
        try { return JSON.parse(localStorage.getItem(LOG_KEY)) || logs; } catch (e) { return logs; }
    }
    
    function clearLogs() {
        logs = [];
        localStorage.removeItem(LOG_KEY);
        log('日志已清空', 'info');
    }

    // ==================== 配置 ====================
    const DEFAULT_CONFIG = {
        checkInterval: 10000,
        submitDelay: 10000,
        nextCourseDelay: 10000,
        refreshDelay: 10000,
        videoPlayRetry: 10000,
        autoStart: true,
        maxSwitchAttempts: 3
    };

    let CONFIG = { ...DEFAULT_CONFIG };
    
    function loadConfig() {
        try {
            const saved = localStorage.getItem('autoLearning_config');
            if (saved) CONFIG = { ...DEFAULT_CONFIG, ...JSON.parse(saved) };
        } catch (e) {}
    }
    
    function saveConfig() {
        try { localStorage.setItem('autoLearning_config', JSON.stringify(CONFIG)); } catch (e) {}
    }

    // ==================== 状态 ====================
    let state = {
        isRunning: false,
        timer: null,
        switchAttempts: 0,
        lastCourseName: '',
        submitButtonWasDisabled: false,  // 新增：记录提交按钮是否曾经可用过
        hasSubmitted: false              // 新增：记录是否已成功提交
    };

    // ==================== 工具函数 ====================
    function parseTime(str) {
        if (!str) return 0;
        const parts = str.split(':').map(Number);
        return parts.length === 3 ? parts[0] * 3600 + parts[1] * 60 + parts[2] : 0;
    }

    function formatTime(sec) {
        const h = Math.floor(sec / 3600);
        const m = Math.floor((sec % 3600) / 60);
        const s = sec % 60;
        return `${String(h).padStart(2, '0')}:${String(m).padStart(2, '0')}:${String(s).padStart(2, '0')}`;
    }

    function getStudyTime() {
        const h = document.querySelector('.study_time_hour')?.textContent || '0';
        const m = document.querySelector('.study_time_minute')?.textContent || '0';
        const s = document.querySelector('.study_time_second')?.textContent || '0';
        return parseInt(h) * 3600 + parseInt(m) * 60 + parseInt(s);
    }

    function getPlanTime() {
        return parseTime(document.querySelector('.plan_time')?.textContent || '0');
    }

    function getCurrentCourseName() {
        return document.querySelector('.chapter_name')?.textContent?.trim() || '未知';
    }

    // ==================== 核心功能 ====================

    function canSubmit() {
        const study = getStudyTime();
        const plan = getPlanTime();
        return study >= plan && plan > 0;
    }

    // 检查课程是否已完成（简化逻辑：学习时间>=计划时间 且 提交按钮禁用）
    function isCourseFinished() {
        const study = getStudyTime();
        const plan = getPlanTime();
        
        // 方式1: 检查完成提示是否显示
        const finishedDiv = document.querySelector('.study_finished');
        if (finishedDiv && finishedDiv.style.display !== 'none') {
            log('检测到完成提示显示', 'success');
            return true;
        }
        
        // 方式2: 学习时间已达标且提交按钮被禁用
        const submitBtn = document.querySelector('.submit_btn');
        if (study >= plan && plan > 0 && submitBtn && submitBtn.disabled) {
            log(`时间已达标(${formatTime(study)} >= ${formatTime(plan)}) 且提交按钮已禁用，判定为已完成`, 'success');
            return true;
        }
        
        // 方式3: 已成功提交过
        if (state.hasSubmitted && study >= plan && plan > 0) {
            log('已成功提交且时间已达标，判定为已完成', 'success');
            return true;
        }
        
        return false;
    }

    function submit() {
        log('尝试提交...', 'info');
        const btn = document.querySelector('.submit_btn');
        
        if (!btn) {
            log('未找到提交按钮!', 'error');
            return false;
        }
        
        log(`提交按钮状态: disabled=${btn.disabled}`, 'info');
        
        if (btn.disabled) {
            log('提交按钮被禁用，可能已提交过', 'warning');
            return false;
        }
        
        btn.click();
        log('已点击提交按钮', 'success');
        state.hasSubmitted = true;
        return true;
    }

    function getAllCourses() {
        const items = document.querySelectorAll('#chapter_tree .layui-tree-set');
        log(`找到 ${items.length} 个课程项`, 'info');
        
        const courses = [];
        items.forEach((item, index) => {
            const dataId = item.getAttribute('data-id');
            const txt = item.querySelector('.layui-tree-txt');
            if (!txt) return;
            
            const text = txt.textContent.trim();
            const hasGreenCheck = txt.querySelector('.ico_dui.color_green');
            const hasGreenText = txt.querySelector('.color_green');
            const hasVideoIcon = txt.querySelector('.ico_shipin2');
            const isFinished = hasGreenCheck || hasGreenText;
            
            log(`课程${index}: "${text.substring(0,15)}" 已完成=${!!isFinished} 视频=${!!hasVideoIcon}`, 'info');
            
            courses.push({
                index, dataId, text,
                isFinished: !!isFinished,
                hasVideo: !!hasVideoIcon,
                element: item
            });
        });
        
        return courses;
    }

    function getNextUnfinishedCourse() {
        log('查找下一节未完成课程...', 'info');
        const courses = getAllCourses();
        const unfinished = courses.filter(c => !c.isFinished && c.hasVideo);
        
        log(`未完成课程数量: ${unfinished.length}`, 'info');
        
        if (unfinished.length === 0) {
            log('没有未完成的视频课程', 'warning');
            return null;
        }
        
        const next = unfinished[0];
        log(`下一节课程: "${next.text.substring(0, 30)}"`, 'success');
        return next;
    }

    function switchCourse() {
        log('========== 开始切换课程 ==========', 'info');
        
        const next = getNextUnfinishedCourse();
        if (!next) {
            log('没有更多课程，学习完成!', 'success');
            stop();
            return false;
        }
        
        const item = next.element;
        let clickTarget = null;
        
        const selectors = ['.layui-tree-main', '.layui-tree-txt', '.layui-tree-entry'];
        for (const sel of selectors) {
            clickTarget = item.querySelector(sel);
            if (clickTarget) {
                log(`找到可点击元素: ${sel}`, 'info');
                break;
            }
        }
        
        if (!clickTarget) {
            log('未找到可点击元素，尝试点击整个项', 'warning');
            clickTarget = item;
        }
        
        state.lastCourseName = getCurrentCourseName();
        log(`当前课程: "${state.lastCourseName}"`, 'info');
        log(`目标课程: "${next.text.substring(0, 30)}"`, 'info');
        
        try {
            clickTarget.click();
            log('已执行点击操作', 'success');
            
            // 重置状态
            state.switchAttempts = 0;
            state.hasSubmitted = false;
            
            // 等待课程切换完成后再返回结果
            return new Promise((resolve) => {
                setTimeout(() => {
                    const newCourse = getCurrentCourseName();
                    log(`点击后当前课程: "${newCourse}"`, 'info');
                    
                    if (newCourse !== state.lastCourseName) {
                        log('课程切换成功!', 'success');
                        setTimeout(playVideo, 2000);
                        resolve(true);
                    } else {
                        log('课程切换失败，当前课程未变化', 'warning');
                        resolve(false);
                    }
                }, 2000);
            });
        } catch (e) {
            log('点击失败: ' + e.message, 'error');
            return false;
        }
    }

    function playVideo() {
        log('尝试播放视频...', 'info');
        
        const videoContainer = document.querySelector('.course_video');
        if (videoContainer && videoContainer.style.display !== 'none') {
            log('检测到视频内容', 'info');
            
            const iframe = document.querySelector('#iframeplay');
            if (iframe) {
                try {
                    const iframeDoc = iframe.contentDocument || iframe.contentWindow.document;
                    const video = iframeDoc.querySelector('video');
                    if (video) video.play().catch(() => {});
                    iframeDoc.querySelectorAll('.vjs-big-play-button, .play-button, [class*="play"]')
                        .forEach(btn => btn.click());
                } catch (e) {}
            }
            
            const video = videoContainer.querySelector('video');
            if (video) video.play().catch(() => {});
            
            videoContainer.querySelectorAll('[class*="play"], .vjs-big-play-button')
                .forEach(btn => btn.click());
        }
    }

    function refreshPage() {
        log('========== 准备刷新页面 ==========', 'warning');
        localStorage.setItem('autoLearning_needSwitch', 'true');
        localStorage.setItem('autoLearning_switchTime', Date.now().toString());
        
        setTimeout(() => {
            log('执行刷新...', 'warning');
            location.reload();
        }, CONFIG.refreshDelay);
    }

    function checkAutoSwitch() {
        const needSwitch = localStorage.getItem('autoLearning_needSwitch');
        const switchTime = localStorage.getItem('autoLearning_switchTime');
        
        if (needSwitch === 'true' && switchTime) {
            const elapsed = Date.now() - parseInt(switchTime);
            if (elapsed < 60000) {
                localStorage.removeItem('autoLearning_needSwitch');
                localStorage.removeItem('autoLearning_switchTime');
                log('检测到刷新标记，3秒后自动切换', 'info');
                setTimeout(switchCourse, 3000);
            }
        }
    }

    // ==================== 主循环 ====================

    function handleCourseFinished() {
        log('课程已完成，准备切换下一节', 'success');
        
        const result = switchCourse();
        
        if (result && typeof result.then === 'function') {
            // 返回 Promise，等待切换结果
            result.then(success => {
                if (!success) {
                    handleSwitchFailure();
                }
            });
        } else if (!result) {
            handleSwitchFailure();
        }
    }
    
    function handleSwitchFailure() {
        state.switchAttempts++;
        log(`切换失败，尝试次数: ${state.switchAttempts}/${CONFIG.maxSwitchAttempts}`, 'warning');
        
        if (state.switchAttempts < CONFIG.maxSwitchAttempts) {
            refreshPage();
        } else {
            log('达到最大重试次数，停止', 'error');
            stop();
        }
    }

    function check() {
        if (!state.isRunning) return;
        
        const study = getStudyTime();
        const plan = getPlanTime();
        const currentCourse = getCurrentCourseName();
        
        log(`--- 检查 --- 课程: "${currentCourse.substring(0,15)}" 学习: ${formatTime(study)} 计划: ${formatTime(plan)}`, 'info');
        
        updatePanel();
        
        // 检查课程是否已完成
        if (isCourseFinished()) {
            handleCourseFinished();
            return;
        }
        
        // 检查是否可以提交
        if (canSubmit()) {
            log('学习时间达标，准备提交', 'success');
            
            setTimeout(() => {
                if (submit()) {
                    log('提交成功', 'success');
                    // 提交成功后等待一段时间，然后检查是否需要切换课程
                    setTimeout(() => {
                        if (isCourseFinished()) {
                            handleCourseFinished();
                        }
                    }, CONFIG.nextCourseDelay);
                } else {
                    // 提交按钮被禁用，可能已提交过
                    log('提交按钮禁用，检查是否已完成', 'warning');
                    if (isCourseFinished()) {
                        handleCourseFinished();
                    }
                }
            }, CONFIG.submitDelay);
        }
    }

    function start() {
        if (state.isRunning) return;
        
        state.isRunning = true;
        state.switchAttempts = 0;
        state.hasSubmitted = false;
        state.submitButtonWasDisabled = false;
        
        log('========== 开始自动学习 ==========', 'success');
        updateStatus('学习中...');
        updateIndicator(true);
        
        state.timer = setInterval(check, CONFIG.checkInterval);
        check();
        setTimeout(playVideo, 2000);
    }

    function stop() {
        state.isRunning = false;
        if (state.timer) {
            clearInterval(state.timer);
            state.timer = null;
        }
        log('========== 停止自动学习 ==========', 'warning');
        updateStatus('已停止');
        updateIndicator(false);
    }

    // ==================== UI ====================

    function createPanel() {
        if (document.getElementById('al-panel')) return;
        
        const css = document.createElement('style');
        css.textContent = `
            #al-panel{position:fixed;top:10px;right:10px;background:linear-gradient(135deg,#667eea,#764ba2);color:#fff;padding:12px 16px;border-radius:10px;box-shadow:0 4px 16px rgba(0,0,0,.25);z-index:999999;font:13px/1.4 'Microsoft YaHei',sans-serif;min-width:280px;max-height:90vh;overflow-y:auto}
            #al-panel *{box-sizing:border-box}
            #al-panel h3{margin:0 0 8px;padding-bottom:6px;border-bottom:1px solid rgba(255,255,255,.3);display:flex;justify-content:space-between;align-items:center}
            #al-panel .row{display:flex;justify-content:space-between;margin:5px 0}
            #al-panel .val{color:#FFD700;font-weight:700;max-width:160px;overflow:hidden;text-overflow:ellipsis}
            #al-panel .bar{height:8px;background:rgba(255,255,255,.3);border-radius:4px;margin:8px 0;overflow:hidden}
            #al-panel .bar-in{height:100%;background:#FFD700;transition:width .3s}
            #al-panel .status{text-align:center;padding:4px;background:rgba(0,0,0,.15);border-radius:4px;margin:6px 0;font-size:12px}
            #al-panel .dot{display:inline-block;width:6px;height:6px;background:#4CAF50;border-radius:50%;margin-right:4px;animation:blink 1s infinite}
            @keyframes blink{0%,100%{opacity:1}50%{opacity:.4}}
            #al-panel .btns{display:flex;gap:6px;margin-top:8px}
            #al-panel button{flex:1;padding:6px 10px;border:none;border-radius:4px;cursor:pointer;font:inherit;font-size:12px;font-weight:700;color:#fff}
            #al-panel .btn1{background:#4CAF50}#al-panel .btn2{background:#f44336}
            #al-panel .btn3{background:#2196F3}#al-panel .btn4{background:#FF9800}
            #al-panel .btn5{background:#9C27B0}#al-panel .btn6{background:#607D8B}
            #al-panel button:hover{opacity:.9}
            #al-panel .set-icon{cursor:pointer;opacity:.8;font-size:16px}
            #al-panel .set-icon:hover{opacity:1}
            #al-panel .log-box{margin-top:10px;background:rgba(0,0,0,.2);border-radius:6px;max-height:150px;overflow-y:auto}
            #al-panel .log-title{padding:6px 8px;font-size:12px;border-bottom:1px solid rgba(255,255,255,.2);display:flex;justify-content:space-between;align-items:center}
            #al-panel .log-content{padding:4px 8px;font-size:10px;font-family:monospace;max-height:120px;overflow-y:auto}
            #al-panel .log-item{padding:2px 0;border-bottom:1px solid rgba(255,255,255,.1);word-break:break-all}
            #al-panel .log-item.info{color:#90CAF9}#al-panel .log-item.success{color:#A5D6A7}
            #al-panel .log-item.warning{color:#FFCC80}#al-panel .log-item.error{color:#EF9A9A}
            #al-set{position:fixed;top:50%;left:50%;transform:translate(-50%,-50%);background:#fff;color:#333;padding:16px;border-radius:10px;box-shadow:0 8px 24px rgba(0,0,0,.3);z-index:9999999;min-width:340px;font:13px/1.4 'Microsoft YaHei',sans-serif}
            #al-set h4{margin:0 0 12px;padding-bottom:8px;border-bottom:2px solid #667eea;color:#667eea;display:flex;justify-content:space-between}
            #al-set .s-row{display:flex;justify-content:space-between;align-items:center;margin:8px 0}
            #al-set .s-row input{width:80px;padding:4px 8px;border:1px solid #ddd;border-radius:4px;text-align:center}
            #al-set .s-row input:focus{border-color:#667eea;outline:none}
            #al-set .hint{font-size:11px;color:#999;margin-top:2px}
            #al-set .cb{display:flex;align-items:center;gap:6px;margin:8px 0}
            #al-set .cb input{width:14px;height:14px}
            #al-set .s-btns{display:flex;gap:8px;margin-top:12px;padding-top:10px;border-top:1px solid #eee}
            #al-set .s-btns button{flex:1;padding:8px;border:none;border-radius:4px;cursor:pointer;font:inherit;font-weight:700;color:#fff}
            #al-set .sv{background:#4CAF50}#al-set .rs{background:#FF9800}#al-set .cl{background:#9E9E9E}
            #al-set .bg{position:fixed;top:0;left:0;right:0;bottom:0;background:rgba(0,0,0,.4);z-index:-1}
        `;
        document.head.appendChild(css);
        
        const panel = document.createElement('div');
        panel.id = 'al-panel';
        panel.innerHTML = `
            <h3><span>📚 自动学习 v1.8</span><span class="set-icon" id="al-set-btn">⚙️</span></h3>
            <div class="row"><span>当前课程</span><span class="val" id="al-course">-</span></div>
            <div class="row"><span>学习进度</span><span class="val" id="al-progress">0%</span></div>
            <div class="row"><span>学习时间</span><span class="val" id="al-time">00:00:00</span></div>
            <div class="row"><span>计划时间</span><span class="val" id="al-plan">00:00:00</span></div>
            <div class="row"><span>剩余时间</span><span class="val" id="al-left">00:00:00</span></div>
            <div class="bar"><div class="bar-in" id="al-bar" style="width:0%"></div></div>
            <div class="status"><span id="al-dot" style="display:none"></span><span id="al-status">等待开始</span></div>
            <div class="btns">
                <button class="btn1" id="al-start">▶ 开始</button>
                <button class="btn2" id="al-stop">⏹ 停止</button>
            </div>
            <div class="btns">
                <button class="btn3" id="al-next">⏭ 下一节</button>
                <button class="btn4" id="al-refresh">🔄 刷新</button>
            </div>
            <div class="btns">
                <button class="btn5" id="al-export">📋 导出日志</button>
                <button class="btn6" id="al-clear">🗑️ 清空</button>
            </div>
            <div class="log-box">
                <div class="log-title"><span>📜 运行日志</span><span id="al-log-count">0条</span></div>
                <div class="log-content" id="al-logs"></div>
            </div>
        `;
        document.body.appendChild(panel);
        
        document.getElementById('al-start').onclick = start;
        document.getElementById('al-stop').onclick = stop;
        document.getElementById('al-next').onclick = () => { log('手动点击下一节', 'info'); switchCourse(); };
        document.getElementById('al-refresh').onclick = () => { log('手动点击刷新', 'info'); refreshPage(); };
        document.getElementById('al-set-btn').onclick = showSettings;
        document.getElementById('al-export').onclick = exportLogs;
        document.getElementById('al-clear').onclick = clearLogs;
        
        logs = getLogs();
        logs.forEach(entry => updateLogUI(entry));
    }

    function updatePanel() {
        const study = getStudyTime();
        const plan = getPlanTime();
        const left = Math.max(0, plan - study);
        const pct = plan > 0 ? Math.min(100, study / plan * 100) : 0;
        
        document.getElementById('al-course').textContent = getCurrentCourseName().substring(0, 12);
        document.getElementById('al-progress').textContent = pct.toFixed(1) + '%';
        document.getElementById('al-time').textContent = formatTime(study);
        document.getElementById('al-plan').textContent = formatTime(plan);
        document.getElementById('al-left').textContent = formatTime(left);
        document.getElementById('al-bar').style.width = pct + '%';
    }

    function updateStatus(txt) { document.getElementById('al-status').textContent = txt; }
    function updateIndicator(show) { document.getElementById('al-dot').style.display = show ? 'inline-block' : 'none'; }

    function updateLogUI(entry, type = 'info') {
        const logContent = document.getElementById('al-logs');
        const logCount = document.getElementById('al-log-count');
        if (!logContent) return;
        
        const logType = entry.includes('[SUCCESS]') ? 'success' : 
                       entry.includes('[ERROR]') ? 'error' :
                       entry.includes('[WARNING]') ? 'warning' : 'info';
        
        const div = document.createElement('div');
        div.className = 'log-item ' + logType;
        div.textContent = entry;
        logContent.insertBefore(div, logContent.firstChild);
        
        while (logContent.children.length > 50) logContent.removeChild(logContent.lastChild);
        logCount.textContent = logs.length + '条';
    }

    function exportLogs() {
        const text = getLogs().join('\n');
        const blob = new Blob([text], { type: 'text/plain;charset=utf-8' });
        const a = document.createElement('a');
        a.href = URL.createObjectURL(blob);
        a.download = `自动学习日志_${new Date().toISOString().slice(0,10)}.txt`;
        a.click();
        log('日志已导出', 'success');
    }

    // ==================== 设置 ====================

    function showSettings() {
        if (document.getElementById('al-set')) return;
        
        const div = document.createElement('div');
        div.id = 'al-set';
        div.innerHTML = `
            <div class="bg"></div>
            <div style="position:relative;z-index:1">
                <h4><span>⚙️ 参数设置</span><span style="cursor:pointer" onclick="this.closest('#al-set').remove()">×</span></h4>
                <div class="s-row"><span>检查间隔</span><input type="number" id="s-check" value="${CONFIG.checkInterval}"><span>毫秒</span></div>
                <div class="hint">定时检查学习状态（建议2000-5000）</div>
                <div class="s-row"><span>提交延迟</span><input type="number" id="s-submit" value="${CONFIG.submitDelay}"><span>毫秒</span></div>
                <div class="hint">时间达标后延迟提交（建议1000-3000）</div>
                <div class="s-row"><span>切换延迟</span><input type="number" id="s-next" value="${CONFIG.nextCourseDelay}"><span>毫秒</span></div>
                <div class="hint">提交后延迟切换课程（建议1000-3000）</div>
                <div class="s-row"><span>刷新延迟</span><input type="number" id="s-refresh" value="${CONFIG.refreshDelay}"><span>毫秒</span></div>
                <div class="hint">切换失败后延迟刷新（建议2000-5000）</div>
                <div class="s-row"><span>最大重试</span><input type="number" id="s-max" value="${CONFIG.maxSwitchAttempts}"><span>次</span></div>
                <div class="cb"><input type="checkbox" id="s-auto" ${CONFIG.autoStart?'checked':''}><span>自动开始学习</span></div>
                <div class="s-btns">
                    <button class="sv" id="s-save">💾 保存</button>
                    <button class="rs" id="s-reset">🔄 默认</button>
                    <button class="cl" id="s-close">取消</button>
                </div>
            </div>
        `;
        document.body.appendChild(div);
        
        document.getElementById('s-save').onclick = () => {
            CONFIG.checkInterval = parseInt(document.getElementById('s-check').value) || DEFAULT_CONFIG.checkInterval;
            CONFIG.submitDelay = parseInt(document.getElementById('s-submit').value) || DEFAULT_CONFIG.submitDelay;
            CONFIG.nextCourseDelay = parseInt(document.getElementById('s-next').value) || DEFAULT_CONFIG.nextCourseDelay;
            CONFIG.refreshDelay = parseInt(document.getElementById('s-refresh').value) || DEFAULT_CONFIG.refreshDelay;
            CONFIG.maxSwitchAttempts = parseInt(document.getElementById('s-max').value) || DEFAULT_CONFIG.maxSwitchAttempts;
            CONFIG.autoStart = document.getElementById('s-auto').checked;
            saveConfig();
            div.remove();
            log('设置已保存', 'success');
        };
        
        document.getElementById('s-reset').onclick = () => { CONFIG = { ...DEFAULT_CONFIG }; saveConfig(); div.remove(); showSettings(); };
        document.getElementById('s-close').onclick = () => div.remove();
        div.querySelector('.bg').onclick = () => div.remove();
    }

    // ==================== 总课表页面功能 ====================

    // 获取总课表页面中所有课程
    function getCourseList() {
        const rows = document.querySelectorAll('.jl table tbody tr');
        const courses = [];
        
        rows.forEach((row, index) => {
            const cells = row.querySelectorAll('td');
            if (cells.length < 5) return;
            
            const num = cells[0]?.textContent?.trim();
            const nameCell = cells[1];
            const name = nameCell?.querySelector('label')?.textContent?.trim() || 
                        nameCell?.textContent?.trim();
            const progressCell = cells[2];
            const progressText = progressCell?.textContent?.trim() || '';
            
            // 判断课程状态
            const isCompleted = progressText.includes('已完成');
            const isNotStarted = progressText.includes('未开始');
            const isStudying = progressText.includes('学习[');
            
            // 获取学习链接
            const studyLink = cells[4]?.querySelector('a[href*="study_new_v3.aspx"]');
            const studyUrl = studyLink?.href;
            
            courses.push({
                index,
                num,
                name,
                progressText,
                isCompleted,
                isNotStarted,
                isStudying,
                studyUrl,
                element: studyLink
            });
        });
        
        return courses;
    }

    // 获取下一个需要学习的课程
    function getNextCourseToStudy() {
        const courses = getCourseList();
        log(`总课表共有 ${courses.length} 门课程`, 'info');
        
        // 优先找正在学习中的课程（有进度但未完成）
        const studying = courses.find(c => c.isStudying);
        if (studying) {
            log(`找到正在学习的课程: ${studying.name}`, 'info');
            return studying;
        }
        
        // 然后找未开始的课程
        const notStarted = courses.find(c => c.isNotStarted);
        if (notStarted) {
            log(`找到未开始的课程: ${notStarted.name}`, 'info');
            return notStarted;
        }
        
        log('所有课程已完成！', 'success');
        return null;
    }

    // 在总课表页面自动选择课程
    function autoSelectCourse() {
        log('========== 总课表页面：自动选择课程 ==========', 'info');
        
        const nextCourse = getNextCourseToStudy();
        if (!nextCourse) {
            log('没有需要学习的课程', 'success');
            return;
        }
        
        if (!nextCourse.studyUrl) {
            log('未找到学习链接', 'error');
            return;
        }
        
        log(`准备进入课程: ${nextCourse.name}`, 'success');
        log(`学习链接: ${nextCourse.studyUrl}`, 'info');
        
        // 标记自动学习状态
        localStorage.setItem('autoLearning_active', 'true');
        localStorage.setItem('autoLearning_startTime', Date.now().toString());
        
        // 延迟后跳转
        setTimeout(() => {
            log('正在跳转到学习页面...', 'info');
            location.href = nextCourse.studyUrl;
        }, 2000);
    }

    // 创建总课表页面的控制面板
    function createCourseListPanel() {
        if (document.getElementById('al-course-panel')) return;
        
        const css = document.createElement('style');
        css.textContent = `
            #al-course-panel{position:fixed;top:10px;right:10px;background:linear-gradient(135deg,#667eea,#764ba2);color:#fff;padding:12px 16px;border-radius:10px;box-shadow:0 4px 16px rgba(0,0,0,.25);z-index:999999;font:13px/1.4 'Microsoft YaHei',sans-serif;min-width:280px}
            #al-course-panel h3{margin:0 0 8px;padding-bottom:6px;border-bottom:1px solid rgba(255,255,255,.3)}
            #al-course-panel .row{display:flex;justify-content:space-between;margin:5px 0}
            #al-course-panel .val{color:#FFD700;font-weight:700}
            #al-course-panel .btns{display:flex;gap:6px;margin-top:8px}
            #al-course-panel button{flex:1;padding:6px 10px;border:none;border-radius:4px;cursor:pointer;font:inherit;font-size:12px;font-weight:700;color:#fff}
            #al-course-panel .btn-start{background:#4CAF50}
            #al-course-panel .btn-stop{background:#f44336}
            #al-course-panel button:hover{opacity:.9}
        `;
        document.head.appendChild(css);
        
        const panel = document.createElement('div');
        panel.id = 'al-course-panel';
        panel.innerHTML = `
            <h3>📚 自动选课 v1.8</h3>
            <div class="row"><span>总课程数</span><span class="val" id="al-total">-</span></div>
            <div class="row"><span>已完成</span><span class="val" id="al-completed">-</span></div>
            <div class="row"><span>学习中</span><span class="val" id="al-studying">-</span></div>
            <div class="row"><span>未开始</span><span class="val" id="al-notstarted">-</span></div>
            <div class="btns">
                <button class="btn-start" id="al-start-course">🚀 自动选课</button>
            </div>
        `;
        document.body.appendChild(panel);
        
        // 更新统计
        const courses = getCourseList();
        const completed = courses.filter(c => c.isCompleted).length;
        const studying = courses.filter(c => c.isStudying).length;
        const notStarted = courses.filter(c => c.isNotStarted).length;
        
        document.getElementById('al-total').textContent = courses.length;
        document.getElementById('al-completed').textContent = completed;
        document.getElementById('al-studying').textContent = studying;
        document.getElementById('al-notstarted').textContent = notStarted;
        
        // 绑定按钮
        document.getElementById('al-start-course').onclick = autoSelectCourse;
        
        // 检查是否需要自动开始（从学习页面返回）
        const autoActive = localStorage.getItem('autoLearning_active');
        const startTime = localStorage.getItem('autoLearning_startTime');
        if (autoActive === 'true' && startTime) {
            const elapsed = Date.now() - parseInt(startTime);
            if (elapsed < 30 * 60 * 1000) { // 30分钟内有效
                log('检测到自动学习标记，3秒后自动选择课程', 'info');
                setTimeout(autoSelectCourse, 3000);
            } else {
                localStorage.removeItem('autoLearning_active');
            }
        }
    }

    // ==================== 学习页面：完成后返回总课表 ====================

    // 修改后的处理课程完成逻辑 - 返回总课表
    function handleCourseFinished() {
        log('课程已完成，准备返回总课表选择下一门课程', 'success');
        
        // 保存当前进度到本地存储
        saveCourseProgress();
        
        // 获取返回URL（从当前URL参数中提取）
        const returnUrl = getReturnUrl();
        
        if (returnUrl) {
            log(`3秒后返回总课表: ${returnUrl}`, 'info');
            setTimeout(() => {
                location.href = returnUrl;
            }, 3000);
        } else {
            log('未找到返回链接，尝试刷新页面', 'warning');
            refreshPage();
        }
    }

    // 保存课程进度
    function saveCourseProgress() {
        try {
            const courseName = getCurrentCourseName();
            const completedCourses = JSON.parse(localStorage.getItem('autoLearning_completed') || '[]');
            if (!completedCourses.includes(courseName)) {
                completedCourses.push(courseName);
                localStorage.setItem('autoLearning_completed', JSON.stringify(completedCourses));
                log(`已记录完成课程: ${courseName}`, 'success');
            }
        } catch (e) {}
    }

    // 从当前URL获取返回总课表的URL
    function getReturnUrl() {
        // 从URL参数中提取 signid 和 classId
        const urlParams = new URLSearchParams(window.location.search);
        const signid = urlParams.get('signid');
        const classId = urlParams.get('classId');
        
        if (signid && classId) {
            return `https://${location.host}/stu/cls_courselist.aspx?cid=${classId}&signid=${signid}`;
        }
        
        // 尝试从referer获取
        const referer = document.referrer;
        if (referer && referer.includes('cls_courselist.aspx')) {
            return referer;
        }
        
        return null;
    }

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

    function initCourseListPage() {
        log('========== 总课表页面初始化 v1.8 ==========', 'info');
        createCourseListPanel();
    }

    function initStudyPage() {
        loadConfig();
        log('========== 学习页面初始化 v1.8 ==========', 'info');
        
        let attempts = 0;
        const wait = setInterval(() => {
            attempts++;
            if (document.querySelector('.study_time_hour')) {
                clearInterval(wait);
                log('页面元素加载完成', 'success');
                createPanel();
                checkAutoSwitch();
                if (CONFIG.autoStart) setTimeout(start, 1000);
            } else if (attempts > 20) {
                clearInterval(wait);
                log('等待页面元素超时', 'error');
            }
        }, 500);
    }

    function init() {
        if (isCourseListPage) {
            initCourseListPage();
        } else if (isStudyPage) {
            initStudyPage();
        }
    }

    window.addEventListener('beforeunload', () => { if (state.timer) clearInterval(state.timer); });

    if (document.readyState === 'complete') init();
    else window.addEventListener('load', init);

})();