// ==UserScript==
// @name         湖南教育综合评审系统自动审核脚本
// @namespace    https://zhpj.hnedu.cn
// @version      1.0.0
// @description  自动获取学生列表并进行批量审核，支持iframe架构，支持延迟操作避免请求过快
// @author       WekyJay
// @match        https://zhpj.hnedu.cn/other/home
// @match        https://zhpj.hnedu.cn/other/zx/js*
// @match        https://zhpj.hnedu.cn/other/verify/list_xs*
// @match        https://zhpj.hnedu.cn/other/verify/list_cl*
// @match        https://zhpj.hnedu.cn/other/verify/detail*
// @grant        GM_setValue
// @grant        GM_getValue
// @grant        GM_registerMenuCommand
// @grant        GM_log
// @run-at       document-end
// ==/UserScript==

(function() {
    'use strict';

    // ==================== 配置区域 ====================
    const CONFIG = {
        // 操作延迟（毫秒），建议 1000-3000
        DELAY_MS: 2000,
        // 是否开启调试日志
        DEBUG: true,
        // 最大重试次数
        MAX_RETRY: 3,
        // iframe ID
        IFRAME_ID: 'contentFrame'
    };

    // ==================== iframe工具 ====================
    const IframeUtils = {
        /**
         * 获取iframe的document对象
         * @returns {Document|null}
         */
        getIframeDoc: () => {
            const iframe = document.getElementById(CONFIG.IFRAME_ID);
            if (!iframe) {
                return null;
            }
            try {
                return iframe.contentDocument || iframe.contentWindow?.document;
            } catch (e) {
                Logger.error('无法访问iframe内容，可能是跨域限制:', e);
                return null;
            }
        },

        /**
         * 获取iframe的window对象
         * @returns {Window|null}
         */
        getIframeWin: () => {
            const iframe = document.getElementById(CONFIG.IFRAME_ID);
            if (!iframe) {
                return null;
            }
            try {
                return iframe.contentWindow;
            } catch (e) {
                Logger.error('无法访问iframe window:', e);
                return null;
            }
        },

        /**
         * 安全地在iframe中执行querySelector
         * @param {string} selector - CSS选择器
         * @returns {Element|null}
         */
        querySelector: (selector) => {
            const doc = IframeUtils.getIframeDoc();
            if (doc) {
                return doc.querySelector(selector);
            }
            // 如果iframe不可用，回退到主文档
            return document.querySelector(selector);
        },

        /**
         * 安全地在iframe中执行querySelectorAll
         * @param {string} selector - CSS选择器
         * @returns {NodeList}
         */
        querySelectorAll: (selector) => {
            const doc = IframeUtils.getIframeDoc();
            if (doc) {
                return doc.querySelectorAll(selector);
            }
            // 如果iframe不可用，回退到主文档
            return document.querySelectorAll(selector);
        },

        /**
         * 获取正确的document（iframe优先）
         * @returns {Document}
         */
        getDoc: () => {
            return IframeUtils.getIframeDoc() || document;
        },

        /**
         * 获取正确的body（iframe优先）
         * @returns {HTMLElement}
         */
        getBody: () => {
            const doc = IframeUtils.getIframeDoc();
            if (doc && doc.body) {
                return doc.body;
            }
            return document.body;
        },

        /**
         * 判断当前是否在iframe中运行
         * @returns {boolean}
         */
        isInIframe: () => {
            return window.self !== window.top;
        },

        /**
         * 获取当前页面的document（无论是否在iframe中）
         * @returns {Document}
         */
        getCurrentDoc: () => {
            if (IframeUtils.isInIframe()) {
                return document;
            }
            return IframeUtils.getIframeDoc() || document;
        }
    };

    // ==================== 状态管理 ====================
    const StateManager = {
        KEYS: {
            IS_PROCESSING: 'zhpj_is_processing',
            CURRENT_INDEX: 'zhpj_current_index',
            TOTAL_COUNT: 'zhpj_total_count',
            STUDENTS_DATA: 'zhpj_students_data',
            PROCESSED_COUNT: 'zhpj_processed_count',
            ERROR_COUNT: 'zhpj_error_count',
            IFRAME_MODE: 'zhpj_iframe_mode'
        },

        save: (key, value) => {
            try {
                GM_setValue(key, JSON.stringify(value));
            } catch (e) {
                Logger.error('保存状态失败:', e);
            }
        },

        load: (key, defaultValue = null) => {
            try {
                const data = GM_getValue(key);
                return data ? JSON.parse(data) : defaultValue;
            } catch (e) {
                return defaultValue;
            }
        },

        clear: () => {
            Object.values(StateManager.KEYS).forEach(key => {
                GM_setValue(key, '');
            });
        },

        isProcessing: () => StateManager.load(StateManager.KEYS.IS_PROCESSING, false)
    };

    // ==================== 日志工具 ====================
    const Logger = {
        log: (msg, ...args) => {
            if (CONFIG.DEBUG) {
                console.log(`[ZHPJ] ${msg}`, ...args);
            }
            UIPanel.addLog('log', msg, args);
        },
        error: (msg, ...args) => {
            console.error(`[ZHPJ] ✗ ${msg}`, ...args);
            UIPanel.addLog('error', msg, args);
        },
        info: (msg, ...args) => {
            console.info(`[ZHPJ] ${msg}`, ...args);
            UIPanel.addLog('info', msg, args);
        },
        warn: (msg, ...args) => {
            console.warn(`[ZHPJ] ⚠ ${msg}`, ...args);
            UIPanel.addLog('warn', msg, args);
        }
    };

    // ==================== 工具函数 ====================
    const Utils = {
        sleep: (ms) => new Promise(resolve => setTimeout(resolve, ms)),

        safeClick: (element) => {
            if (element) {
                element.click();
                Logger.log('点击操作已执行');
            } else {
                Logger.error('点击失败：元素不存在');
            }
        },

        extractOnclickParams: (element, funcName) => {
            const onclick = element.getAttribute('onclick');
            if (!onclick) return [];
            const regex = new RegExp(`${funcName}\\s*\\(([^)]+)\\)`);
            const match = onclick.match(regex);
            if (match && match[1]) {
                return match[1].split(',').map(p => p.trim().replace(/['"]/g, ''));
            }
            return [];
        },

        isPage: (pattern) => {
            // 检查iframe URL或主页面URL
            const iframeWin = IframeUtils.getIframeWin();
            const iframeUrl = iframeWin ? iframeWin.location.href : '';
            const mainUrl = window.location.href;
            return iframeUrl.includes(pattern) || mainUrl.includes(pattern);
        },

        getCurrentUrl: () => {
            if (IframeUtils.isInIframe()) {
                return window.location.href;
            }
            const iframeWin = IframeUtils.getIframeWin();
            return iframeWin ? iframeWin.location.href : window.location.href;
        }
    };

    // ==================== 学生数据管理 ====================
    const StudentManager = {
        students: [],
        currentIndex: 0,

        /**
         * 从当前页面解析学生数据
         */
        parseStudentList: () => {
            Logger.log('开始解析学生列表...');

            StudentManager.students = [];
            let skippedCount = 0;

            // 获取当前文档
            const doc = IframeUtils.isInIframe() ? document : IframeUtils.getIframeDoc();
            if (!doc) {
                Logger.error('无法访问文档');
                return [];
            }

            const enterButtons = doc.querySelectorAll('button[onclick^="list_cl"]');
            Logger.log(`找到 ${enterButtons.length} 个学生按钮`);

            enterButtons.forEach((btn, index) => {
                const params = Utils.extractOnclickParams(btn, 'list_cl');
                if (params.length >= 2) {
                    const row = btn.closest('tr');
                    let studentInfo = {};
                    let pendingCount = 0;

                    if (row) {
                        const cells = row.querySelectorAll('td');
                        studentInfo = {
                            name: cells[2]?.textContent?.trim() || '未知',
                            gender: cells[3]?.textContent?.trim() || '未知',
                            className: cells[4]?.textContent?.trim() || '未知',
                            totalMaterials: cells[5]?.textContent?.trim() || '0',
                            approvedCount: cells[6]?.textContent?.trim() || '0'
                        };

                        const pendingText = cells[7]?.textContent?.trim() || '0';
                        pendingCount = parseInt(pendingText) || 0;
                        studentInfo.pendingCount = pendingCount;
                    }

                    // 检查是否已存在（避免重复）
                    const exists = StudentManager.students.some(s => s.param2 === params[1]);
                    if (!exists) {
                        if (pendingCount > 0) {
                            StudentManager.students.push({
                                index: StudentManager.students.length,
                                param1: params[0],
                                param2: params[1],
                                info: studentInfo,
                                pendingCount: pendingCount,
                                onclickStr: btn.getAttribute('onclick')
                            });
                        } else {
                            skippedCount++;
                            Logger.log(`跳过学生 ${studentInfo.name}，待审核数为 0`);
                        }
                    }
                }
            });

            Logger.log(`成功解析 ${StudentManager.students.length} 条待审核学生数据，跳过 ${skippedCount} 条`);
            return StudentManager.students;
        },

        /**
         * 获取所有页面的学生数据（自动翻页）
         */
        fetchAllStudents: async () => {
            Logger.log('开始获取所有页面的学生数据...');

            StudentManager.students = [];
            let pageNum = 1;
            let maxPages = 20; // 防止无限循环

            // 获取当前文档（iframe内直接使用document，主框架使用iframe的document）
            const getCurrentDoc = () => {
                if (IframeUtils.isInIframe()) {
                    return document;
                }
                return IframeUtils.getIframeDoc();
            };

            while (pageNum <= maxPages) {
                Logger.log(`正在获取第 ${pageNum} 页数据...`);

                const doc = getCurrentDoc();
                if (!doc) {
                    Logger.error('无法访问文档');
                    break;
                }

                // 解析当前页
                const buttons = doc.querySelectorAll('button[onclick^="list_cl"]');
                Logger.log(`第 ${pageNum} 页找到 ${buttons.length} 个学生按钮`);

                if (buttons.length === 0) {
                    Logger.log('当前页无数据，结束获取');
                    break;
                }

                // 解析当前页学生
                buttons.forEach((btn) => {
                    const params = Utils.extractOnclickParams(btn, 'list_cl');
                    if (params.length >= 2) {
                        const row = btn.closest('tr');
                        let studentInfo = {};
                        let pendingCount = 0;

                        if (row) {
                            const cells = row.querySelectorAll('td');
                            studentInfo = {
                                name: cells[2]?.textContent?.trim() || '未知',
                                gender: cells[3]?.textContent?.trim() || '未知',
                                className: cells[4]?.textContent?.trim() || '未知',
                                totalMaterials: cells[5]?.textContent?.trim() || '0',
                                approvedCount: cells[6]?.textContent?.trim() || '0'
                            };

                            const pendingText = cells[7]?.textContent?.trim() || '0';
                            pendingCount = parseInt(pendingText) || 0;
                            studentInfo.pendingCount = pendingCount;
                        }

                        // 检查是否已存在
                        const exists = StudentManager.students.some(s => s.param2 === params[1]);
                        if (!exists && pendingCount > 0) {
                            StudentManager.students.push({
                                index: StudentManager.students.length,
                                param1: params[0],
                                param2: params[1],
                                info: studentInfo,
                                pendingCount: pendingCount,
                                onclickStr: btn.getAttribute('onclick')
                            });
                        }
                    }
                });

                // 查找下一页按钮
                const nextBtn = doc.querySelector('a[onclick*="next"], .paginate_button.next:not(.disabled), .pagination li:not(.disabled) a[aria-label="Next"], .pagination .next a');

                if (!nextBtn || nextBtn.classList.contains('disabled') || nextBtn.closest('li')?.classList.contains('disabled')) {
                    Logger.log('没有下一页了');
                    break;
                }

                // 点击下一页
                Logger.log('点击下一页...');
                nextBtn.click();
                await Utils.sleep(2000); // 等待页面加载
                pageNum++;
            }

            Logger.log(`共获取 ${StudentManager.students.length} 条待审核学生数据`);
            return StudentManager.students;
        },

        /**
         * 扩展列表到100条（通过提交隐藏表单）
         * 网站使用隐藏的POST表单#pageForm在主框架中来改变分页大小
         * 表单target="contentFrame"，提交后会刷新iframe
         */
        expandListTo100: async () => {
            Logger.log('尝试扩展列表到100条...');

            // 重要：#pageForm表单在主框架中，不在iframe里
            // 所以应该直接使用主框架的document
            const mainDoc = window.top.document;
            const iframeDoc = IframeUtils.getIframeDoc();

            Logger.log('正在查找分页表单...');

            // 方法1: 在主框架中查找隐藏的POST表单 #pageForm
            let pageForm = mainDoc.getElementById('pageForm');

            if (!pageForm && iframeDoc) {
                // 如果在主框架没找到，尝试在iframe中查找（以防万一）
                pageForm = iframeDoc.getElementById('pageForm');
                if (pageForm) {
                    Logger.log('在iframe中找到分页表单 #pageForm');
                }
            } else if (pageForm) {
                Logger.log('在主框架中找到分页表单 #pageForm');
            }

            if (pageForm) {
                // 查找 pageList.pageSize 输入字段
                let pageSizeInput = pageForm.querySelector('input[name="pageList.pageSize"]');

                if (!pageSizeInput) {
                    // 尝试其他选择器
                    pageSizeInput = pageForm.querySelector('input[name*="pageSize"]');
                }

                if (pageSizeInput) {
                    Logger.log('找到 pageSize 输入字段，当前值:', pageSizeInput.value);

                    // 设置值为100
                    pageSizeInput.value = '100';
                    Logger.log('已将 pageSize 设置为 100');

                    // 提交表单
                    pageForm.submit();
                    Logger.log('已提交分页表单，等待iframe刷新...');

                    // 等待页面刷新
                    await Utils.sleep(2500);
                    return true;
                } else {
                    Logger.log('未找到 pageList.pageSize 输入字段');
                }
            } else {
                Logger.log('未找到分页表单 #pageForm，尝试其他方法...');
            }

            // 方法2: 尝试查找并操作select下拉框（备用方案）
            // 下拉框通常在iframe中
            const doc = iframeDoc || document;
            let pageSizeSelect = doc.getElementById('spageSize');
            if (!pageSizeSelect) {
                pageSizeSelect = doc.querySelector('select[name="example_length"]');
            }
            if (!pageSizeSelect) {
                pageSizeSelect = doc.querySelector('select[name="pageSize"], select[name="limit"], .page-size select, select[onchange*="page"]');
            }

            if (pageSizeSelect) {
                Logger.log('找到分页选择器:', pageSizeSelect.id || pageSizeSelect.name);

                const option100 = Array.from(pageSizeSelect.options).find(opt =>
                    opt.value === '100' || opt.textContent.includes('100')
                );

                if (option100) {
                    Logger.log('找到100条选项，选择它');
                    pageSizeSelect.value = '100';

                    const nativeEvent = new Event('change', { bubbles: true });
                    pageSizeSelect.dispatchEvent(nativeEvent);

                    const win = IframeUtils.isInIframe() ? window : IframeUtils.getIframeWin();
                    if (win && win.$ && win.$(pageSizeSelect).trigger) {
                        win.$(pageSizeSelect).trigger('change');
                    }

                    if (pageSizeSelect.onchange) {
                        pageSizeSelect.onchange();
                    }

                    await Utils.sleep(1500);
                    Logger.log('已选择100条，等待页面刷新...');
                    return true;
                }
            }

            Logger.log('无法自动扩展列表，将使用自动翻页获取全部数据');
            return false;
        },

        loadFromStorage: () => {
            const students = StateManager.load(StateManager.KEYS.STUDENTS_DATA, []);
            const currentIndex = StateManager.load(StateManager.KEYS.CURRENT_INDEX, 0);
            StudentManager.students = students;
            StudentManager.currentIndex = currentIndex;
            Logger.log(`从存储恢复 ${students.length} 条学生数据，当前索引: ${currentIndex}`);
            return students;
        },

        getCurrentStudent: () => {
            if (StudentManager.currentIndex < StudentManager.students.length) {
                return StudentManager.students[StudentManager.currentIndex];
            }
            return null;
        },

        advanceIndex: () => {
            StudentManager.currentIndex++;
            StateManager.save(StateManager.KEYS.CURRENT_INDEX, StudentManager.currentIndex);
            Logger.log(`索引已递增到: ${StudentManager.currentIndex}`);
        },

        reset: () => {
            StudentManager.currentIndex = 0;
            StudentManager.students = [];
            StateManager.clear();
        }
    };

    // ==================== 审核流程控制器 ====================
    const VerifyController = {
        isProcessing: false,
        processedCount: 0,
        errorCount: 0,

        start: async () => {
            if (VerifyController.isProcessing) {
                Logger.info('审核流程已在运行中...');
                return;
            }

            VerifyController.isProcessing = true;
            VerifyController.processedCount = 0;
            VerifyController.errorCount = 0;

            // 禁用按钮
            UIPanel.setProcessingState(true);

            Logger.info('========== 开始自动审核流程 ==========');

            try {
                // 步骤1：解析学生列表
                if (!StudentManager.students.length) {
                    StudentManager.parseStudentList();
                }

                // 步骤2：逐个处理所有学生
                await VerifyController.processAllStudents();

            } catch (error) {
                Logger.error('审核流程异常:', error);
            } finally {
                VerifyController.isProcessing = false;
                // 恢复按钮状态
                UIPanel.setProcessingState(false);
                Logger.info(`========== 审核流程结束 ==========`);
                Logger.info(`成功处理: ${VerifyController.processedCount} 条`);
                Logger.info(`失败: ${VerifyController.errorCount} 条`);
            }
        },

        processAllStudents: async () => {
            const total = StudentManager.students.length;
            Logger.info(`========== 开始审核 ${total} 名学生 ==========`);

            // 第一个学生需要点击按钮进入
            if (StudentManager.currentIndex < total) {
                const firstStudent = StudentManager.students[StudentManager.currentIndex];
                Logger.info(`[1/${total}] ${firstStudent.info.name} - 开始审核`);

                try {
                    await VerifyController.enterVerifyList(firstStudent);
                    await Utils.sleep(CONFIG.DELAY_MS * 2);
                } catch (error) {
                    Logger.error(`进入审核失败: ${error.message}`);
                    VerifyController.errorCount++;
                }
            }

            while (StudentManager.currentIndex < total) {
                const student = StudentManager.students[StudentManager.currentIndex];
                if (!student) break;

                const progress = `[${StudentManager.currentIndex + 1}/${total}]`;

                try {
                    // 处理iframe内的审核列表
                    const itemCount = await VerifyController.processVerifyItemsInIframe();
                    Logger.info(`${progress} ${student.info.name} - 完成 (${itemCount}项材料)`);

                    VerifyController.processedCount++;
                    StudentManager.currentIndex++;

                    // 如果还有下一个学生，直接跳转到其审核页面
                    if (StudentManager.currentIndex < total) {
                        const nextStudent = StudentManager.students[StudentManager.currentIndex];
                        Logger.info(`[${StudentManager.currentIndex + 1}/${total}] ${nextStudent.info.name} - 开始审核`);

                        const jumpSuccess = await VerifyController.jumpToNextStudent(nextStudent);
                        if (!jumpSuccess) {
                            // 跳转失败则返回列表
                            Logger.warn('直接跳转失败，返回列表页');
                            await VerifyController.backToStudentList();
                            break;
                        }
                        await Utils.sleep(CONFIG.DELAY_MS * 2);
                    }

                } catch (error) {
                    Logger.error(`${progress} ${student.info.name} - 失败: ${error.message}`);
                    VerifyController.errorCount++;
                    StudentManager.currentIndex++;

                    // 失败后尝试直接跳到下一个或返回列表
                    if (StudentManager.currentIndex < total) {
                        const nextStudent = StudentManager.students[StudentManager.currentIndex];
                        const jumpSuccess = await VerifyController.jumpToNextStudent(nextStudent);
                        if (!jumpSuccess) {
                            await VerifyController.backToStudentList();
                            break;
                        }
                    }
                }

                await Utils.sleep(CONFIG.DELAY_MS);
            }

            // 最后一个学生审核完成后返回列表
            await VerifyController.backToStudentList();

            Logger.info(`========== 审核完成: ${VerifyController.processedCount}/${total} ==========`);
        },

        /**
         * 直接跳转到下一个学生的审核页面
         */
        jumpToNextStudent: async (student) => {
            try {
                const iframeWin = IframeUtils.getIframeWin();
                if (!iframeWin) {
                    return false;
                }

                // 从当前URL提取参数
                const currentUrl = iframeWin.location.href;
                const urlObj = new URL(currentUrl, window.location.origin);
                const xnxq = urlObj.searchParams.get('xnxq') || '2025-2026,1';
                const shjb = urlObj.searchParams.get('shjb') || '1';

                // 构建目标URL（注意：xsid是学生的param2，zszt=0是固定值）
                const targetUrl = `/other/verify/list_cl?shjb=${shjb}&zszt=0&xsid=${encodeURIComponent(student.param2)}&xnxq=${encodeURIComponent(xnxq)}&pageList.orderBy=cjsj&pageList.sort=desc`;

                Logger.log(`直接跳转到: ${targetUrl}`);
                iframeWin.location.href = targetUrl;
                return true;
            } catch (error) {
                Logger.error('跳转失败:', error);
                return false;
            }
        },

        /**
         * 点击进入审核（在iframe中点击）
         */
        enterVerifyList: async (student) => {
            Logger.log(`点击进入审核: param1=${student.param1}, param2=${student.param2}`);

            // 在iframe中查找按钮
            const buttons = IframeUtils.querySelectorAll('button[onclick^="list_cl"]');
            let targetBtn = null;

            for (const btn of buttons) {
                const onclick = btn.getAttribute('onclick');
                if (onclick && onclick.includes(student.param2)) {
                    targetBtn = btn;
                    break;
                }
            }

            if (targetBtn) {
                Logger.log('找到对应按钮，执行点击');
                targetBtn.click();
            } else {
                Logger.error('未找到对应按钮');
                throw new Error('未找到按钮');
            }
        },

        /**
         * 处理iframe内的审核列表
         * @returns {number} 处理的材料数量
         */
        processVerifyItemsInIframe: async () => {
            let processedCount = 0;
            let maxAttempts = 50;
            let emptyCount = 0; // 连续没找到按钮的次数

            // 首次进入页面，多等待一会儿让页面完全加载
            Logger.log('等待审核页面加载...');
            await Utils.sleep(CONFIG.DELAY_MS * 2);

            while (maxAttempts-- > 0) {
                // 在iframe内查找审核按钮
                const verifyButtons = IframeUtils.querySelectorAll('button[onclick^="verify"]');
                Logger.log(`找到 ${verifyButtons.length} 个审核按钮`);

                const availableButtons = Array.from(verifyButtons).filter(btn => {
                    return btn.offsetParent !== null && !btn.disabled;
                });

                Logger.log(`${availableButtons.length} 个按钮可用`);

                if (availableButtons.length === 0) {
                    emptyCount++;
                    // 如果连续3次都没找到，才真正认为没有待审核项了
                    if (emptyCount >= 3) {
                        Logger.log('连续3次未找到审核按钮，确认无待审核项');
                        break;
                    }
                    // 再等待一会儿重试
                    await Utils.sleep(CONFIG.DELAY_MS);
                    continue;
                }

                // 重置空计数
                emptyCount = 0;

                const btn = availableButtons[0];
                btn.click();
                processedCount++;
                Logger.log(`点击第 ${processedCount} 个审核项`);

                // 等待详情加载
                await Utils.sleep(CONFIG.DELAY_MS);

                // 在iframe内点击通过按钮
                const passSuccess = await VerifyController.clickPassInIframe();

                if (!passSuccess) {
                    Logger.warn('点击通过失败，继续下一个');
                    await Utils.sleep(1000);
                    continue;
                }

                await Utils.sleep(CONFIG.DELAY_MS);
            }

            return processedCount;
        },

        /**
         * 在iframe内点击通过按钮
         */
        clickPassInIframe: async () => {
            Logger.log('在iframe内查找并点击通过按钮...');

            const doc = IframeUtils.getIframeDoc();
            if (!doc) {
                Logger.error('无法访问iframe');
                return false;
            }

            const passButton =
                doc.querySelector('input[onclick^="verify(1)"]') ||
                doc.querySelector('input[value="通过"]') ||
                doc.querySelector('.btn-tjjk.btn-yellow') ||
                doc.querySelector('input.btn-yellow');

            if (passButton) {
                Logger.log('找到通过按钮，执行点击');
                passButton.click();

                await Utils.sleep(CONFIG.DELAY_MS / 2);
                await VerifyController.handleConfirmDialog();

                return true;
            } else {
                Logger.error('未找到通过按钮');
                return false;
            }
        },

        handleConfirmDialog: async () => {
            // 等待弹窗动画完成
            await Utils.sleep(500);

            // 检查是否是"审核成功"的bootbox弹窗 - 可能在主页面或iframe
            const docs = [document];
            const iframeDoc = IframeUtils.getIframeDoc();
            if (iframeDoc && iframeDoc !== document) {
                docs.push(iframeDoc);
            }

            // 先查找并记录弹窗内容
            for (const doc of docs) {
                const bootboxBody = doc.querySelector('.bootbox-body');
                if (bootboxBody) {
                    const msg = bootboxBody.textContent?.trim();
                    Logger.log(`检测到bootbox弹窗，内容: ${msg}`);
                    break;
                }
            }

            // 在多个文档中查找确认按钮
            for (const doc of docs) {
                // 多种方式查找确认按钮
                const confirmSelectors = [
                    'button[data-bb-handler="ok"]',           // bootbox OK按钮
                    '.modal-footer .btn-primary',              // 通用modal确认按钮
                    '.modal-dialog .btn-primary',              // modal内主按钮
                    '.bootbox .btn-primary',                   // bootbox主按钮
                    '.modal.in .btn-primary',                  // 显示的modal
                    '.modal.show .btn-primary',                // Bootstrap 4/5
                    '.layui-layer-btn0',                       // layui弹窗
                    '.btn-confirm',
                    'button.confirm',
                    '.swal2-confirm'
                ];

                for (const selector of confirmSelectors) {
                    const confirmBtn = doc.querySelector(selector);
                    if (confirmBtn && confirmBtn.offsetParent !== null) {
                        Logger.log(`检测到确认弹窗(选择器: ${selector})，自动点击确认`);
                        confirmBtn.click();
                        await Utils.sleep(500);
                        return;
                    }
                }

                // 如果没找到特定按钮，尝试查找包含"OK"或"确定"文本的按钮
                const allButtons = doc.querySelectorAll('.modal-dialog button, .modal-footer button, .bootbox button, button.btn-primary');
                for (const btn of allButtons) {
                    const text = btn.textContent?.trim();
                    if (text === 'OK' || text === '确定' || text === '确认') {
                        Logger.log(`找到确认按钮(文本: ${text})，自动点击`);
                        btn.click();
                        await Utils.sleep(500);
                        return;
                    }
                }
            }

            Logger.log('未检测到确认弹窗或已自动关闭');
        },

        /**
         * 返回学生列表页
         */
        backToStudentList: async () => {
            Logger.log('尝试返回学生列表页...');

            // 等待一段时间让页面稳定
            await Utils.sleep(1000);

            // 方法1：查找返回按钮
            const doc = IframeUtils.getIframeDoc();
            if (doc) {
                const backSelectors = [
                    'a[onclick*="back"]',
                    'a[onclick*="return"]',
                    'button[onclick*="back"]',
                    'button[onclick*="return"]',
                    '.btn-back',
                    '.btn-return'
                ];

                for (const selector of backSelectors) {
                    const backBtn = doc.querySelector(selector);
                    if (backBtn && backBtn.offsetParent !== null) {
                        Logger.log('找到返回按钮，执行点击');
                        backBtn.click();
                        await Utils.sleep(1500);
                        return true;
                    }
                }

                // 方法2：查找包含"返回"文字的链接或按钮
                const allLinks = doc.querySelectorAll('a, button');
                for (const link of allLinks) {
                    const text = link.textContent?.trim();
                    if (text === '返回' || text === '返回列表' || text === '<< 返回') {
                        Logger.log(`找到返回链接(文本: ${text})，执行点击`);
                        link.click();
                        await Utils.sleep(1500);
                        return true;
                    }
                }
            }

            // 方法3：通过修改iframe的URL直接返回（如果知道URL参数）
            const iframeWin = IframeUtils.getIframeWin();
            if (iframeWin && iframeWin.location.href.includes('list_cl')) {
                Logger.log('通过修改URL返回学生列表');
                // 从当前URL提取参数构建列表页URL
                const currentUrl = iframeWin.location.href;
                const urlObj = new URL(currentUrl);
                const xnxq = urlObj.searchParams.get('xnxq') || '2025-2026,1';
                const shjb = urlObj.searchParams.get('shjb') || '1';
                const listUrl = `/other/verify/list_xs?shjb=${shjb}&xnxq=${xnxq}`;
                iframeWin.location.href = listUrl;
                await Utils.sleep(2000);
                return true;
            }

            Logger.log('未找到返回按钮，可能需要手动返回');
            return false;
        },

        stop: () => {
            VerifyController.isProcessing = false;
            UIPanel.setProcessingState(false);
            Logger.info('已停止自动审核');
        }
    };

    // ==================== UI 控制面板 ====================
    const UIPanel = {
        panel: null,
        hasData: false,

        create: () => {
            const existingPanel = document.getElementById('zhpj-auto-panel');
            if (existingPanel) {
                Logger.log('控制面板已存在，跳过创建');
                UIPanel.panel = existingPanel;
                return;
            }

            const panel = document.createElement('div');
            panel.id = 'zhpj-auto-panel';
            panel.innerHTML = `
                <style>
                    #zhpj-auto-panel {
                        position: fixed;
                        top: 80px;
                        right: 20px;
                        width: 300px;
                        background: #ffffff;
                        border-radius: 8px;
                        padding: 16px;
                        box-shadow: 0 2px 12px rgba(0,0,0,0.15);
                        z-index: 999999;
                        font-family: 'Microsoft YaHei', sans-serif;
                        color: #333333;
                        border: 1px solid #e0e0e0;
                    }
                    #zhpj-auto-panel .panel-header {
                        font-size: 16px;
                        font-weight: bold;
                        margin-bottom: 12px;
                        text-align: center;
                        border-bottom: 1px solid #e0e0e0;
                        padding-bottom: 12px;
                        color: #2196F3;
                    }
                    #zhpj-auto-panel .panel-body {
                        margin-bottom: 12px;
                    }
                    #zhpj-auto-panel .info-row {
                        display: flex;
                        justify-content: space-between;
                        margin: 10px 0;
                        font-size: 14px;
                    }
                    #zhpj-auto-panel .info-row span:last-child {
                        font-weight: bold;
                        color: #2196F3;
                    }
                    #zhpj-auto-panel .btn-group {
                        display: flex;
                        gap: 8px;
                    }
                    #zhpj-auto-panel button {
                        flex: 1;
                        padding: 10px 12px;
                        border: none;
                        border-radius: 4px;
                        cursor: pointer;
                        font-size: 13px;
                        font-weight: 500;
                        transition: all 0.2s;
                    }
                    #zhpj-auto-panel button:disabled {
                        cursor: not-allowed;
                        opacity: 0.6;
                    }
                    #zhpj-auto-panel .btn-fetch {
                        background: #2196F3;
                        color: white;
                        width: 100%;
                        margin-bottom: 8px;
                    }
                    #zhpj-auto-panel .btn-fetch:hover:not(:disabled) {
                        background: #1976D2;
                    }
                    #zhpj-auto-panel .btn-start {
                        background: #4CAF50;
                        color: white;
                    }
                    #zhpj-auto-panel .btn-start:hover:not(:disabled) {
                        background: #45a049;
                    }
                    #zhpj-auto-panel .btn-start:disabled {
                        background: #cccccc;
                        color: #888888;
                    }
                    #zhpj-auto-panel .btn-stop {
                        background: #f44336;
                        color: white;
                    }
                    #zhpj-auto-panel .btn-stop:hover:not(:disabled) {
                        background: #da190b;
                    }
                    #zhpj-auto-panel .status {
                        text-align: center;
                        padding: 8px;
                        border-radius: 4px;
                        margin-top: 12px;
                        font-size: 13px;
                        background: #f5f5f5;
                        color: #666666;
                    }
                    #zhpj-auto-panel .status.running {
                        background: #e8f5e9;
                        color: #2e7d32;
                    }
                    #zhpj-auto-panel .status.warning {
                        background: #fff3e0;
                        color: #ef6c00;
                    }
                    #zhpj-auto-panel .config-section {
                        margin-top: 12px;
                        padding-top: 12px;
                        border-top: 1px solid #e0e0e0;
                    }
                    #zhpj-auto-panel .config-section input {
                        width: 70px;
                        padding: 4px 8px;
                        border-radius: 4px;
                        border: 1px solid #ddd;
                        text-align: center;
                    }
                    #zhpj-auto-panel .iframe-status {
                        font-size: 11px;
                        margin-top: 8px;
                        padding: 6px;
                        background: #f5f5f5;
                        border-radius: 4px;
                        color: #666;
                    }
                    #zhpj-auto-panel .log-container {
                        margin-top: 12px;
                        border-top: 1px solid #e0e0e0;
                        padding-top: 8px;
                        max-height: 200px;
                        overflow-y: auto;
                    }
                    #zhpj-auto-panel .log-item {
                        font-size: 12px;
                        padding: 4px 8px;
                        margin: 2px 0;
                        border-radius: 3px;
                        word-break: break-all;
                    }
                    #zhpj-auto-panel .log-item.info {
                        color: #333;
                        background: #f9f9f9;
                    }
                    #zhpj-auto-panel .log-item.error {
                        color: #c00;
                        background: #ffeaea;
                    }
                    #zhpj-auto-panel .log-item.warn {
                        color: #c78000;
                        background: #fff8e6;
                    }
                    #zhpj-auto-panel .log-item.log {
                        color: #666;
                        background: #fafafa;
                    }
                    #zhpj-auto-panel .log-time {
                        color: #999;
                        font-size: 11px;
                        margin-right: 4px;
                    }
                </style>
                <div class="panel-header">📋 自动审核助手 v1.0.0</div>
                <div class="panel-body">
                    <div class="info-row">
                        <span>待审核学生:</span>
                        <span id="zhpj-total">0</span>
                    </div>
                    <div class="info-row">
                        <span>已处理:</span>
                        <span id="zhpj-processed">0</span>
                    </div>
                    <div class="info-row">
                        <span>失败:</span>
                        <span id="zhpj-failed">0</span>
                    </div>
                    <div class="config-section">
                        <div class="info-row">
                            <span>操作延迟(ms):</span>
                            <input type="number" id="zhpj-delay" value="${CONFIG.DELAY_MS}" min="500" max="10000" step="100">
                        </div>
                    </div>
                    <div class="iframe-status" id="zhpj-iframe-status">检测iframe状态...</div>
                    <div class="status" id="zhpj-status">请先获取学生数据</div>
                </div>
                <button class="btn-fetch" id="zhpj-btn-fetch">📥 获取学生数据</button>
                <div class="btn-group">
                    <button class="btn-start" id="zhpj-btn-start" disabled>▶ 开始审核</button>
                    <button class="btn-stop" id="zhpj-btn-stop">⏹ 停止</button>
                </div>
                <div class="log-container" id="zhpj-logs"></div>
            `;

            document.body.appendChild(panel);
            UIPanel.panel = panel;

            // 绑定事件
            document.getElementById('zhpj-btn-fetch').addEventListener('click', async () => {
                const fetchBtn = document.getElementById('zhpj-btn-fetch');
                fetchBtn.disabled = true;
                fetchBtn.textContent = '⏳ 获取中...';

                try {
                    // 先尝试扩展列表到100条
                    Logger.info('正在扩展列表到100条...');
                    const expanded = await StudentManager.expandListTo100();
                    if (expanded) {
                        await Utils.sleep(2500); // 等待页面刷新
                    }

                    // 获取学生数据
                    Logger.info('正在获取学生数据...');
                    StudentManager.reset();
                    await StudentManager.fetchAllStudents();

                    // 更新UI状态
                    UIPanel.hasData = StudentManager.students.length > 0;
                    UIPanel.updateButtonState();
                    UIPanel.updateStatus();

                    if (UIPanel.hasData) {
                        Logger.info(`✓ 成功获取 ${StudentManager.students.length} 条学生数据`);
                    } else {
                        Logger.warn('未获取到学生数据，请检查页面');
                    }
                } catch (error) {
                    Logger.error('获取数据失败:', error);
                } finally {
                    fetchBtn.disabled = false;
                    fetchBtn.textContent = '📥 获取学生数据';
                }
            });

            document.getElementById('zhpj-btn-start').addEventListener('click', () => {
                if (!UIPanel.hasData) {
                    Logger.warn('请先获取学生数据');
                    return;
                }
                VerifyController.start();
            });

            document.getElementById('zhpj-btn-stop').addEventListener('click', () => {
                VerifyController.stop();
            });

            const delayInput = document.getElementById('zhpj-delay');
            if (delayInput) {
                delayInput.addEventListener('change', (e) => {
                    CONFIG.DELAY_MS = parseInt(e.target.value) || 2000;
                    Logger.log(`延迟已更新为: ${CONFIG.DELAY_MS}ms`);
                });
            }

            Logger.log('控制面板已创建');
            UIPanel.updateIframeStatus();
            UIPanel.detectPageStudents();
        },

        updateIframeStatus: () => {
            const statusEl = document.getElementById('zhpj-iframe-status');
            if (!statusEl) return;

            const doc = IframeUtils.getIframeDoc();
            const iframe = document.getElementById(CONFIG.IFRAME_ID);

            if (!iframe) {
                statusEl.textContent = '❌ 未找到iframe';
                statusEl.style.color = '#ff6b6b';
            } else if (!doc) {
                statusEl.textContent = '⚠️ iframe跨域限制';
                statusEl.style.color = '#ffd93d';
            } else {
                const url = IframeUtils.getIframeWin()?.location?.href || '未知';
                statusEl.textContent = `✅ iframe已连接 (${url.substring(url.lastIndexOf('/') + 1).substring(0, 20)})`;
                statusEl.style.color = '#6bcf7f';
            }
        },

        updateButtonState: () => {
            const startBtn = document.getElementById('zhpj-btn-start');
            if (startBtn) {
                startBtn.disabled = !UIPanel.hasData || VerifyController.isProcessing;
            }
        },

        setProcessingState: (isProcessing) => {
            const fetchBtn = document.getElementById('zhpj-btn-fetch');
            const startBtn = document.getElementById('zhpj-btn-start');
            const stopBtn = document.getElementById('zhpj-btn-stop');

            if (fetchBtn) fetchBtn.disabled = isProcessing;
            if (startBtn) startBtn.disabled = isProcessing || !UIPanel.hasData;
            if (stopBtn) stopBtn.disabled = false; // 停止按钮始终可用
        },

        addLog: (type, msg, args = []) => {
            // 在主框架中执行
            if (IframeUtils.isInIframe()) {
                // 通过存储传递日志到主框架
                try {
                    const logs = JSON.parse(localStorage.getItem('zhpj_logs') || '[]');
                    logs.push({
                        type,
                        msg: String(msg),
                        args: args.map(a => String(a)),
                        time: new Date().toLocaleTimeString()
                    });
                    // 只保留最近30条
                    while (logs.length > 30) logs.shift();
                    localStorage.setItem('zhpj_logs', JSON.stringify(logs));
                } catch (e) {}
                return;
            }

            const logsContainer = document.getElementById('zhpj-logs');
            if (!logsContainer) return;

            // 从 localStorage 读取 iframe 传来的日志
            try {
                const iframeLogs = JSON.parse(localStorage.getItem('zhpj_logs') || '[]');
                if (iframeLogs.length > 0) {
                    // 清空并重新渲染所有日志
                    logsContainer.innerHTML = '';
                    iframeLogs.forEach(log => {
                        UIPanel.renderLogItem(logsContainer, log.type, log.msg, log.args, log.time);
                    });
                    localStorage.removeItem('zhpj_logs');
                }
            } catch (e) {}

            // 添加当前日志
            const time = new Date().toLocaleTimeString();
            UIPanel.renderLogItem(logsContainer, type, msg, args, time);

            // 滚动到底部
            logsContainer.scrollTop = logsContainer.scrollHeight;
        },

        renderLogItem: (container, type, msg, args, time) => {
            const logItem = document.createElement('div');
            logItem.className = `log-item ${type}`;

            // 简化消息
            let displayMsg = String(msg);
            if (args && args.length > 0) {
                displayMsg += ' ' + args.join(' ');
            }
            // 截断过长的消息
            if (displayMsg.length > 100) {
                displayMsg = displayMsg.substring(0, 100) + '...';
            }

            logItem.innerHTML = `<span class="log-time">${time}</span>${displayMsg}`;
            container.appendChild(logItem);

            // 限制日志数量
            while (container.children.length > 30) {
                container.removeChild(container.firstChild);
            }
        },

        detectPageStudents: async () => {
            // 尝试获取所有页面的学生
            const buttons = IframeUtils.querySelectorAll('button[onclick^="list_cl"]');
            const totalStudents = buttons.length;

            Logger.log(`当前页显示 ${totalStudents} 个学生`);

            // 如果学生较少，提示扩展列表
            if (totalStudents < 20) {
                const statusEl = document.getElementById('zhpj-status');
                if (statusEl) {
                    statusEl.textContent = `当前显示 ${totalStudents} 人，建议获取数据`;
                    statusEl.className = 'status warning';
                }
            }
        },

        updateStatus: () => {
            if (!UIPanel.panel) return;

            const totalEl = document.getElementById('zhpj-total');
            const processedEl = document.getElementById('zhpj-processed');
            const failedEl = document.getElementById('zhpj-failed');
            const statusEl = document.getElementById('zhpj-status');

            if (totalEl) totalEl.textContent = StudentManager.students.length;
            if (processedEl) processedEl.textContent = VerifyController.processedCount;
            if (failedEl) failedEl.textContent = VerifyController.errorCount;

            if (statusEl) {
                if (VerifyController.isProcessing) {
                    statusEl.className = 'status running';
                    statusEl.textContent = `审核中... (${StudentManager.currentIndex}/${StudentManager.students.length})`;
                } else if (StudentManager.students.length > 0) {
                    statusEl.className = 'status';
                    statusEl.textContent = '✓ 就绪 - 可开始审核';
                } else {
                    statusEl.className = 'status';
                    statusEl.textContent = '请先点击"获取学生数据"';
                }
            }
        },

        startUpdateTimer: () => {
            setInterval(() => {
                UIPanel.updateStatus();
                UIPanel.updateIframeStatus();
                // 同步 iframe 日志
                UIPanel.syncIframeLogs();
            }, 1000);
        },

        syncIframeLogs: () => {
            if (IframeUtils.isInIframe()) return;

            try {
                const iframeLogs = JSON.parse(localStorage.getItem('zhpj_logs') || '[]');
                if (iframeLogs.length > 0) {
                    const logsContainer = document.getElementById('zhpj-logs');
                    if (logsContainer) {
                        iframeLogs.forEach(log => {
                            UIPanel.renderLogItem(logsContainer, log.type, log.msg, log.args, log.time);
                        });
                        // 滚动到底部
                        logsContainer.scrollTop = logsContainer.scrollHeight;
                    }
                    localStorage.removeItem('zhpj_logs');
                }
            } catch (e) {}
        }
    };

    // ==================== 页面路由处理 ====================
    const PageRouter = {
        handle: async () => {
            const url = Utils.getCurrentUrl();
            Logger.log(`当前页面: ${url}`);
            Logger.log(`运行环境: ${IframeUtils.isInIframe() ? 'iframe内' : '主框架'}`);

            // 只在主框架创建UI面板
            if (!IframeUtils.isInIframe()) {
                UIPanel.create();
                UIPanel.startUpdateTimer();
            }

            if (url.includes('/other/home')) {
                Logger.log('检测到首页');
                // 等待iframe加载完成
                setTimeout(() => {
                    PageRouter.handleHomePage();
                }, 2000);

            } else if (url.includes('/verify/list_xs?') || url.includes('/zx/js')) {
                Logger.log('检测到学生列表页');
                setTimeout(async () => {
                    // 解析当前页学生
                    StudentManager.parseStudentList();
                    if (!IframeUtils.isInIframe()) {
                        UIPanel.updateStatus();
                    }
                }, 1500);
            } else if (url.includes('/verify/list_cl')) {
                Logger.log('检测到学生审核列表页');
                // 不在这里自动处理，由 VerifyController 控制
            }
        },

        handleHomePage: () => {
            // 自动点击"数据审阅" -> "学校审核"菜单
            // 这里需要根据实际菜单结构调整选择器
            Logger.log('等待用户导航到审核页面...');
        }
    };

    // ==================== 初始化 ====================
    const init = () => {
        // 全局初始化标记
        if (window.ZHPJAutoVerify && window.ZHPJAutoVerify.initialized) {
            Logger.log('脚本已经初始化，跳过');
            return;
        }

        Logger.log('脚本已加载，版本 1.0.0 (iframe版)');
        Logger.log('配置:', CONFIG);

        // 暴露全局接口
        window.ZHPJAutoVerify = {
            start: VerifyController.start,
            stop: VerifyController.stop,
            config: CONFIG,
            students: () => StudentManager.students,
            iframeUtils: IframeUtils,
            initialized: true
        };

        // 注册菜单命令（只在主框架注册）
        if (!IframeUtils.isInIframe() && typeof GM_registerMenuCommand === 'function') {
            GM_registerMenuCommand('🚀 开始自动审核', VerifyController.start);
            GM_registerMenuCommand('⏹ 停止审核', VerifyController.stop);
            GM_registerMenuCommand('🔄 重新解析列表', () => {
                StudentManager.reset();
                StudentManager.parseStudentList();
            });
        }

        // 页面加载完成后执行
        if (document.readyState === 'loading') {
            document.addEventListener('DOMContentLoaded', PageRouter.handle);
        } else {
            PageRouter.handle();
        }

        // 监听iframe URL变化
        if (!IframeUtils.isInIframe()) {
            let lastIframeUrl = '';
            setInterval(() => {
                const iframeWin = IframeUtils.getIframeWin();
                if (iframeWin) {
                    const currentUrl = iframeWin.location.href;
                    if (currentUrl !== lastIframeUrl) {
                        Logger.log(`iframe URL变化: ${currentUrl}`);
                        lastIframeUrl = currentUrl;
                        // 重新解析学生列表（注意：list_cl 是审核页面，不是列表页）
                        if (currentUrl.includes('/verify/list_xs?') || currentUrl.includes('/zx/js')) {
                            setTimeout(() => {
                                StudentManager.parseStudentList();
                                UIPanel.updateStatus();
                            }, 1500);
                        }
                    }
                }
            }, 1000);
        }
    };

    // 启动脚本
    init();

})();