// ==UserScript==
// @name         生涯闯关助手（睡衣宝宝改版）
// @namespace    http://tampermonkey.net/
// @version      2.7
// @description  原作者毫厘 此版本是睡衣宝宝优化板增加了备用文本减少了乱答题现象，同时增加了ai接口设置
// @author       毫厘 睡衣宝宝
// @match        https://zgs.chsi.com.cn/*
// @grant        GM_xmlhttpRequest
// @grant        GM_addStyle
// @grant        GM_setValue
// @grant        GM_getValue
// @connect      api.zgs.chsi.com.cn
// @connect      chsi-zyghds.oss-cn-beijing.aliyuncs.com
// @connect      api.deepseek.com
// @connect      chat.openai.com
// @connect      open.bigmodel.cn
// @run-at       document-end
// @license      MIT
// ==/UserScript==

(function() {
    'use strict';

    console.log('职业规划大赛闯关助手开始加载...');
    let capturedAuthToken = null;
    let isTokenReady = false;
    let selectedRange = { start: 1, end: 9 };
    let isExecuting = false;
    let currentExecution = null;
    let isDragging = false;
    let isResizing = false;
    let dragOffset = { x: 0, y: 0 };
    let isMinimized = false;

    // --- 免费AI配置 ---
    const AI_CONFIG = {
        enabled: true,
        provider: 'deepseek',
        apiKey: '',
        baseURL: 'https://api.deepseek.com/v1',
        model: 'deepseek-chat',
        maxTokens: 800,
        temperature: 0.7,
        freeProviders: [
            {
                name: 'DeepSeek',
                url: 'https://api.deepseek.com/v1/chat/completions',
                model: 'deepseek-chat',
                free: true
            }
        ]
    };

    // --- 工具函数 ---
    const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
    
    function log(message, type = 'info') {
        const timestamp = new Date().toLocaleTimeString();
        const logEntry = document.createElement('div');
        logEntry.className = `zgs-log-entry zgs-log-${type}`;
        logEntry.innerHTML = `<span class="zgs-log-time">[${timestamp}]</span> ${message}`;
        
        const logContainer = document.getElementById('zgs-log-container');
        if (logContainer) {
            logContainer.appendChild(logEntry);
            logContainer.scrollTop = logContainer.scrollHeight;
        }
        
        console.log(`[闯关助手] ${message}`);
    }

    // 免费AI请求函数
    async function freeAIRequest(prompt, maxLength = 300) {
        if (!AI_CONFIG.enabled) {
            return generateFallbackText(prompt, maxLength);
        }

        try {
            const providers = [
                {
                    name: 'DeepSeek',
                    url: 'https://api.deepseek.com/v1/chat/completions',
                    model: 'deepseek-chat',
                    headers: {
                        'Content-Type': 'application/json',
                        'Authorization': `Bearer ${AI_CONFIG.apiKey}`
                    }
                }
            ];

            for (const provider of providers) {
                try {
                    const response = await aiRequestToProvider(provider, prompt, maxLength);
                    if (response) {
                        log(`✅ 使用 ${provider.name} AI 生成内容`);
                        return response;
                    }
                } catch (error) {
                    console.log(`${provider.name} 请求失败:`, error);
                    continue;
                }
            }

            throw new Error('所有AI服务均不可用');

        } catch (error) {
            console.warn('AI生成失败，使用备用文本:', error);
            return generateFallbackText(prompt, maxLength);
        }
    }

    async function aiRequestToProvider(provider, prompt, maxLength) {
        return new Promise((resolve, reject) => {
            const requestBody = {
                model: provider.model,
                messages: [
                    {
                        role: "system",
                        content: "你是一个职业规划助手，请用专业、积极的语言回答问题，内容要符合大学生职业规划的场景。回答要具体、真实，避免空洞的套话。"
                    },
                    {
                        role: "user",
                        content: `${prompt}。请生成${maxLength}字左右的真实、具体的回答。`
                    }
                ],
                max_tokens: AI_CONFIG.maxTokens,
                temperature: AI_CONFIG.temperature
            };

            GM_xmlhttpRequest({
                method: 'POST',
                url: provider.url,
                headers: provider.headers,
                data: JSON.stringify(requestBody),
                timeout: 30000,
                onload: function(response) {
                    try {
                        const data = JSON.parse(response.responseText);
                        if (data.choices && data.choices[0] && data.choices[0].message) {
                            resolve(data.choices[0].message.content.trim());
                        } else {
                            reject(new Error('AI响应格式错误'));
                        }
                    } catch (e) {
                        reject(new Error('解析AI响应失败'));
                    }
                },
                onerror: (err) => reject(new Error('AI请求网络错误')),
                ontimeout: () => reject(new Error('AI请求超时'))
            });
        });
    }

    // 各关卡专业备用文本生成
    function generateFallbackText(prompt, maxLength) {
        const promptKeywords = prompt.toLowerCase();
        
        // 第一关：生涯愿景
        if (promptKeywords.includes('榜样') || promptKeywords.includes('职业榜样')) {
            const templates = [
                "这位职业榜样在行业内取得了显著成就，展现了卓越的专业能力和职业素养。通过对其职业轨迹的研究，我深刻认识到持续学习和专业发展的重要性。榜样的成功经验为我指明了职业发展方向，激励我在专业领域不断追求卓越。",
                "选择这位职业榜样是因为其在专业领域的突出贡献和职业精神。他/她的职业发展路径清晰，从基层岗位逐步成长为行业领军人物，展现了扎实的专业基础和不断进取的精神。这种职业发展模式值得我学习和借鉴。",
                "从职业榜样身上获得的启发是多方面的。首先是专业能力的持续提升，其次是职业规划的长期性，再者是面对挑战的积极态度。这些品质对于我的职业发展具有重要的指导意义。"
            ];
            return selectAndAdjustText(templates, maxLength);
        }
        
        // 第二关：专业探索
        else if (promptKeywords.includes('专业') || promptKeywords.includes('课程')) {
            const templates = {
                major_course: [
                    "本专业核心课程包括专业基础课、专业核心课和专业拓展课三个层次。专业基础课主要学习高等数学、大学物理、程序设计基础等，为后续专业学习打下坚实基础。专业核心课涵盖数据结构、操作系统、计算机网络、数据库原理等关键技术课程，通过理论学习和实践操作相结合的方式，培养学生的专业素养。",
                    "专业课程体系设计科学合理，从基础到专业循序渐进。大一大二主要学习公共基础课和专业基础课，如C语言程序设计、计算机组成原理等。大三大四进入专业核心课程学习阶段，包括软件工程、算法设计与分析、编译原理等重要课程。",
                    "通过系统的专业课程学习，我掌握了扎实的理论基础和专业技能。理论课程如离散数学、计算机系统结构等培养了逻辑思维能力，实践课程如Java程序设计、Web开发技术等提升了动手实践能力。"
                ],
                tunnel: [
                    "本专业发展路径清晰，毕业生可在多个领域就业。技术方向可以成为软件工程师、系统架构师、数据分析师等，从事软件开发、系统设计、数据分析等工作。管理方向可以发展为项目经理、技术总监等，负责项目管理和团队协调。",
                    "专业发展通道多元化，为学生提供多种职业选择。一方面可以进入互联网企业，如阿里巴巴、腾讯、百度等，从事前后端开发、移动开发等技术岗位。另一方面可以进入金融机构、政府部门、教育机构等。",
                    "通过专业学习和实践，我明确了未来的发展方向。计划先从事技术开发工作，积累项目经验和专业技能，成为一名全栈工程师。随后根据兴趣和能力，向技术管理或产品经理方向发展。"
                ],
                interviewer: [
                    "通过与专业从业者的深入交流，我了解到行业的最新动态和职业要求。从业者分享了实际工作中的挑战和收获，让我对专业实践有了更直观的认识。这次访谈经历加深了我对专业发展方向的理解。",
                    "专业访谈让我认识到理论知识与实践应用的结合重要性。从业者强调了持续学习和技术更新的必要性，以及在团队协作中沟通能力的关键作用。这些见解对我的职业规划具有重要参考价值。",
                    "访谈过程中，从业者详细介绍了职业发展路径和晋升机制。他分享了从初级工程师到技术专家的成长经历，强调了项目经验积累和技术深度挖掘的重要性。这些经验为我制定职业目标提供了宝贵参考。"
                ],
                practice_mode: [
                    "专业实践教学模式注重理论与实践的结合。通过实验课程、项目实训和企业实习等多个环节，培养学生的实际操作能力和问题解决能力。这种教学模式有效提升了学生的职业竞争力。",
                    "实践教学体系包括课程实验、综合实训和毕业设计等多个层次。课程实验巩固理论知识，综合实训培养项目开发能力，毕业设计锻炼独立研究能力。这种渐进式的实践培养模式效果显著。",
                    "通过参与实际项目开发，我将理论知识应用于实践，提升了专业技能。在团队项目中学习了项目管理方法和协作技巧，在个人项目中培养了独立解决问题的能力。实践经历为未来职业发展奠定了坚实基础。"
                ]
            };
            
            for (const key in templates) {
                if (promptKeywords.includes(key) || prompt.includes(key)) {
                    return selectAndAdjustText(templates[key], maxLength);
                }
            }
            return selectAndAdjustText(templates.major_course, maxLength);
        }
        
        // 第三关：职业瞭望
        else if (promptKeywords.includes('职业') || promptKeywords.includes('瞭望')) {
            const templates = [
                "通过职业探索，我深入了解了目标职业的发展前景和就业形势。当前行业正处于快速发展期，技术更新迅速，对专业人才的需求持续增长。职业发展路径清晰，晋升机制完善，为个人成长提供了广阔空间。",
                "职业分析显示，目标职业具有较好的发展潜力和就业稳定性。随着数字化转型的深入推进，相关岗位的需求量不断增加。职业要求具备扎实的专业基础、持续学习能力和良好的团队协作精神。",
                "在职业瞭望过程中，我认识到职业发展需要结合个人兴趣、专业能力和市场需求。通过分析行业趋势和职业要求，我明确了未来发展方向，并为实现职业目标制定了具体的行动计划。"
            ];
            return selectAndAdjustText(templates, maxLength);
        }
        
        // 第四关：兴趣揭秘
        else if (promptKeywords.includes('兴趣') || promptKeywords.includes('揭秘')) {
            const templates = [
                "兴趣测评结果显示，我的兴趣特点与目标职业高度匹配。对技术创新的热情和解决问题的偏好使我适合从事研发类工作。同时，良好的沟通能力和团队协作意识也为职业发展提供了有力支持。",
                "通过兴趣分析，我认识到个人兴趣与职业发展的密切关系。对专业领域的热爱驱使我不断深入学习，而实践操作的兴趣则促使我积极参与项目开发。这种兴趣导向的学习模式效果显著。",
                "兴趣揭秘过程让我更加了解自己的职业倾向。测评结果显示我在技术应用和问题解决方面具有较强兴趣，这与目标职业的要求高度一致。这种匹配度为职业发展奠定了良好基础。"
            ];
            return selectAndAdjustText(templates, maxLength);
        }
        
        // 第五关：目标锚定
        else if (promptKeywords.includes('目标') || promptKeywords.includes('锚定')) {
            const templates = [
                "我的职业目标包括短期目标和长期规划。短期目标是在毕业前掌握核心技术能力，完成有影响力的项目实践。长期目标是成为领域专家，在技术创新或项目管理方面取得显著成就。",
                "职业目标设定基于个人能力评估和市场需求分析。短期着重技术深度积累，中期注重项目经验拓展，长期追求行业影响力提升。这种阶梯式目标体系确保职业发展的连续性和可持续性。",
                "通过目标锚定，我明确了职业发展方向和具体指标。技术能力方面要达到熟练运用主流开发框架，项目经验方面要参与至少三个完整项目开发，职业发展方面要在三年内晋升为高级工程师。"
            ];
            return selectAndAdjustText(templates, maxLength);
        }
        
        // 第六关：能力盘点
        else if (promptKeywords.includes('能力') || promptKeywords.includes('盘点')) {
            const templates = [
                "能力评估显示，我在技术基础、问题解决和团队协作方面具有优势。通过系统学习和项目实践，掌握了扎实的专业技能，具备了独立开发能力和团队合作经验。这些能力为职业发展提供了有力支撑。",
                "能力盘点帮助我全面认识自身的优势和改进空间。在专业技术方面表现良好，但在项目管理和跨部门沟通方面还需要进一步提升。针对性地制定能力提升计划，弥补短板，发挥优势。",
                "通过能力分析，我识别了核心竞争力和待提升领域。核心技术能力包括编程开发、系统设计和数据分析，软技能方面需要加强项目管理和团队领导能力。这种全面的能力认知有助于职业规划。"
            ];
            return selectAndAdjustText(templates, maxLength);
        }
        
        // 第七关：技能提升
        else if (promptKeywords.includes('技能') || promptKeywords.includes('提升')) {
            const templates = [
                "技能提升计划包括技术深度挖掘和广度拓展两个方面。深度方面要精通核心开发框架和系统架构，广度方面要了解相关技术领域和行业应用。通过项目实践和技术学习相结合的方式实现技能提升。",
                "技能实践注重理论应用和实际问题解决。参与真实项目开发，将所学知识应用于实践，在解决技术难题中提升能力。同时通过技术分享和代码评审，学习他人优秀经验，不断完善技能体系。",
                "通过系统的技能训练，我计划在关键技术领域达到熟练水平。包括掌握至少两种编程语言的深度应用，理解分布式系统原理，具备大数据处理能力。这些技能目标通过阶段性学习计划逐步实现。"
            ];
            return selectAndAdjustText(templates, maxLength);
        }
        
        // 第八关：生涯启航
        else if (promptKeywords.includes('生涯') || promptKeywords.includes('启航')) {
            const templates = [
                "职业规划学习让我全面认识了职业发展的重要性和方法。通过系统学习，我明确了职业目标，制定了实施计划，为未来职业生涯做好了充分准备。这段学习经历是我职业发展的重要基石。",
                "生涯启航意味着职业规划从理论走向实践。我将把学到的知识应用于实际工作，在职业发展中不断调整和优化规划。保持学习热情，积极面对挑战，在职业道路上稳步前行。",
                "通过职业规划学习，我建立了系统的职业发展观。认识到职业成功需要专业知识、实践经验和职业素养的有机结合。在未来的职业旅程中，我将坚持学习成长，追求专业卓越，实现职业价值。"
            ];
            return selectAndAdjustText(templates, maxLength);
        }
        
        // 默认备用文本
        else {
            const templates = [
                "通过系统的学习和实践，我获得了宝贵的知识和经验。这个过程不仅提升了我的专业能力，更培养了我的综合素质。我认识到持续学习和自我提升的重要性，将在未来的学习和工作中继续保持积极进取的态度。",
                "专业学习让我掌握了扎实的理论基础和实践技能。通过课程学习和项目实践，我不仅巩固了专业知识，还培养了解决问题的能力。这种全面的能力培养为未来的职业发展奠定了坚实基础。",
                "在职业规划过程中，我深入思考了个人发展与职业目标的关系。通过分析行业趋势和个人优势，我明确了发展方向并制定了实施计划。这段经历对我未来的职业生涯具有重要指导意义。"
            ];
            return selectAndAdjustText(templates, maxLength);
        }
    }

    // 辅助函数：选择并调整文本长度
    function selectAndAdjustText(templates, maxLength) {
        const baseText = templates[Math.floor(Math.random() * templates.length)];
        const targetLength = Math.floor(Math.random() * (maxLength - 50)) + 50;
        
        if (baseText.length >= targetLength) {
            return baseText.substring(0, targetLength);
        } else {
            let extendedText = baseText;
            while (extendedText.length < targetLength) {
                extendedText += " " + templates[Math.floor(Math.random() * templates.length)];
            }
            return extendedText.substring(0, targetLength);
        }
    }

    // 内容缓存系统
    let contentCache = new Map();
    
    // 智能内容生成
    async function generateSmartContent(prompt, cacheKey, minLength, maxLength) {
        if (contentCache.has(cacheKey)) {
            return contentCache.get(cacheKey);
        }
        
        let content;
        if (AI_CONFIG.enabled && AI_CONFIG.apiKey) {
            content = await freeAIRequest(prompt, maxLength);
        } else {
            content = generateFallbackText(prompt, maxLength);
        }
        
        contentCache.set(cacheKey, content);
        return content;
    }

    // 更新关卡范围选择
    function updateRangeSelection(start, end) {
        selectedRange = { start, end };
        updateRangeDisplay();
        log(`📊 已选择关卡范围: ${start} - ${end}`);
    }

    // 更新范围显示
    function updateRangeDisplay() {
        const rangeDisplay = document.getElementById('zgs-range-display');
        if (rangeDisplay) {
            rangeDisplay.textContent = `关卡 ${selectedRange.start} - ${selectedRange.end}`;
        }
        
        // 更新关卡项的选中状态
        document.querySelectorAll('.zgs-barrier-item').forEach((item, index) => {
            const barrierId = index + 1;
            if (barrierId >= selectedRange.start && barrierId <= selectedRange.end) {
                item.classList.add('selected');
            } else {
                item.classList.remove('selected');
            }
        });
    }

    // 获取选中的关卡
    function getSelectedBarriers() {
        return CONFIG.barriers.filter((barrier, index) => {
            const barrierNumber = index + 1;
            return barrierNumber >= selectedRange.start && barrierNumber <= selectedRange.end;
        });
    }

    function generateRealisticName() {
        const surnames = ['张', '王', '李', '赵', '陈', '刘', '杨', '黄', '周', '吴'];
        const givenNames = ['明', '华', '强', '伟', '芳', '娜', '磊', '勇', '杰', '婷', '静', '鹏'];
        return surnames[Math.floor(Math.random() * surnames.length)] + 
               givenNames[Math.floor(Math.random() * givenNames.length)];
    }

    function generateRealisticMajor() {
        const majors = [
            '计算机科学与技术', '软件工程', '电子信息工程', '机械工程', 
            '工商管理', '金融学', '会计学', '市场营销'
        ];
        return majors[Math.floor(Math.random() * majors.length)];
    }

    function generateRealisticJob() {
        const jobs = [
            '软件工程师', '产品经理', '数据分析师', '前端开发工程师',
            '市场营销专员', '人力资源专员', '财务分析师', '运营经理'
        ];
        return jobs[Math.floor(Math.random() * jobs.length)];
    }

    // --- Token捕获系统 ---
    function setupPreciseTokenCapture() {
        console.log('闯关助手：启动Token捕获系统...');
        
        const originalOpen = XMLHttpRequest.prototype.open;
        XMLHttpRequest.prototype.open = function(method, url, ...args) {
            this._url = url;
            return originalOpen.apply(this, [method, url, ...args]);
        };

        const originalSetRequestHeader = XMLHttpRequest.prototype.setRequestHeader;
        XMLHttpRequest.prototype.setRequestHeader = function(header, value) {
            if (header.toLowerCase() === 'authorization' && value && value.startsWith('Bearer ')) {
                captureToken(value, 'XHR');
            }
            return originalSetRequestHeader.apply(this, arguments);
        };

        const originalFetch = window.fetch;
        window.fetch = function(...args) {
            const requestOptions = args[1] || {};
            if (requestOptions.headers) {
                if (requestOptions.headers instanceof Headers) {
                    const authHeader = requestOptions.headers.get('Authorization');
                    if (authHeader && authHeader.startsWith('Bearer ')) {
                        captureToken(authHeader, 'Fetch');
                    }
                }
            }
            return originalFetch.apply(this, args);
        };

        function captureToken(token, source) {
            if (token && token !== capturedAuthToken) {
                console.log(`闯关助手：从${source}捕获Token`);
                capturedAuthToken = token;
                isTokenReady = true;
                updateTokenStatus('Token已就绪', true);
                log(`✅ Token捕获成功 (${source})`);
                
                try {
                    GM_setValue('cached_auth_token', token);
                } catch (e) {}
            }
        }

        try {
            const cachedToken = GM_getValue('cached_auth_token');
            if (cachedToken) {
                capturedAuthToken = cachedToken;
                isTokenReady = true;
                updateTokenStatus('Token已就绪(缓存)', true);
                log('✅ 使用缓存的Token');
            }
        } catch (e) {}

        console.log('闯关助手：Token捕获系统启动完成');
    }

    // --- 文件上传辅助函数 ---
    let _dummyPdfBlob = null;
    function getDummyPdfBlob() {
        if (_dummyPdfBlob) return _dummyPdfBlob;
        try {
            const pdfBase64 = "JVBERi0xLjQKJSAxIDAgb2JqPDwvVHlwZS9DYXRhbG9nL1BhZ2VzIDIgMCBSPj5lbmRvYmogMiAwIG9iago8PC9UeXBlL1BhZ2VzL0NvdW50IDEgL0tpZHNbMyAwIFJdPj5lbmRvYmogMyAwIG9iago8PC9UeXBlL1BhZ2UvUGFyZW50IDIgMCBSL01lZGlhQm94WzAgMCA2MTIgNzkyXS9SZXNvdXJjZXM8Pj4vQ29udGVudHMgNCAwIFI+PmVuZG9iago0IDAgb2JqPDwvTGVuZ3RoIDA+PnN0cmVhbQplbmRzdHJlYW0KZW5kb2JqCnhyZWYNCjAgNQ0KMDAwMDAwMDAwMCA2NTUzNSBmDQowMDAwMDAwMDE1IDAwMDAwIG4NCjAwMDAwMDAwNzEgMDAwMDAgbg0KMDAwMDAwMDEzMyAwMDAwMCBuDQowMDAwMDAwMjQzIDAwMDAwIG4NCnRyYWlsZXI8PC9TaXplIDUvUm9vdCA1IDAgUj4+DQpzdGFydHhyZWYNCjM0OQ0KJSVFT0YNCg==";
            const binaryString = window.atob(pdfBase64);
            const len = binaryString.length;
            const bytes = new Uint8Array(len);
            for (let i = 0; i < len; i++) {
                bytes[i] = binaryString.charCodeAt(i);
            }
            _dummyPdfBlob = new Blob([bytes], { type: 'application/pdf' });
            return _dummyPdfBlob;
        } catch (e) {
            log('创建虚拟PDF文件失败: ' + e.message, 'error');
            throw new Error("Dummy PDF could not be created.");
        }
    }

    async function request(options, retries = 3) {
        if (!capturedAuthToken) {
            throw new Error('Token捕获失败，请确保已登录并刷新页面');
        }
        
        return new Promise((resolve, reject) => {
            const attempt = async (tryCount) => {
                const finalOptions = {
                    ...options,
                    headers: {
                        'Authorization': capturedAuthToken,
                        'Content-Type': 'application/json',
                        'X-Client-Type': 'pc',
                        'Accept': 'application/json, text/plain, */*',
                        'Origin': 'https://zgs.chsi.com.cn',
                        'Referer': 'https://zgs.chsi.com.cn/',
                        ...options.headers
                    },
                    timeout: 15000
                };
                
                GM_xmlhttpRequest({
                    ...finalOptions,
                    onload: res => {
                        try {
                            const json = JSON.parse(res.responseText || 'null');
                            if (res.status >= 200 && res.status < 300) {
                                return resolve(json);
                            }
                            const errorMsg = (json ? (json.message || json.msg) : null) || res.statusText || `请求失败 (${res.status})`;
                            reject(new Error(errorMsg));
                        } catch (e) {
                            reject(new Error(`解析响应失败 (${res.status}): ${res.responseText.substring(0,100)}`));
                        }
                    },
                    onerror: err => {
                        if (tryCount < retries) {
                            log(`  - 请求失败，${1 + tryCount}/${retries}次重试中...`, 'error');
                            setTimeout(() => attempt(tryCount + 1), 1000 * tryCount);
                        } else {
                            reject(new Error(`网络错误: ${err.error || '未知'}`));
                        }
                    },
                    ontimeout: () => {
                        if (tryCount < retries) {
                            log(`  - 请求超时，${1 + tryCount}/${retries}次重试中...`, 'error');
                            setTimeout(() => attempt(tryCount + 1), 1000 * tryCount);
                        } else {
                            reject(new Error('请求超时'));
                        }
                    }
                });
            };
            attempt(0);
        });
    }

    async function ignorableRequest(options) {
        try {
            return await request(options);
        } catch (error) {
            if (error.message.includes('请勿重复点击') || error.message.includes('已存在')) {
                log(`  - [提示] ${error.message}，已自动忽略。`, 'info');
                return null;
            }
            throw error;
        }
    }

    // --- 业务逻辑 ---
    const CONFIG = {
        apiBase: 'https://api.zgs.chsi.com.cn',
        barriers: [
            { id: 1, name: '生涯愿景', func: completeBarrierOne },
            { id: 2, name: '专业探索', func: completeBarrierTwo },
            { id: 3, name: '职业瞭望', func: completeBarrierThree },
            { id: 5, name: '兴趣揭秘', func: completeBarrierFour },
            { id: 6, name: '目标锚定', func: completeBarrierFive },
            { id: 7, name: '能力盘点', func: completeBarrierSix },
            { id: 8, name: '技能提升', func: completeBarrierSeven },
            { id: 9, name: '生涯启航', func: completeBarrierEight },
        ]
    };

    function getHeaders() {
        if (!capturedAuthToken) {
            throw new Error('Token捕获失败，请刷新页面重新登录');
        }
        return { 
            'Authorization': capturedAuthToken, 
            'Content-Type': 'application/json', 
            'X-Client-Type': 'pc', 
            'Accept': 'application/json, text/plain, */*', 
            'Origin': 'https://zgs.chsi.com.cn', 
            'Referer': 'https://zgs.chsi.com.cn/', 
            'User-Agent': navigator.userAgent 
        };
    }

    // --- 完整的闯关函数 ---
    async function completeBarrierOne() {
        const barrierId = 1, logPrefix = `[关卡1]`;
        updateStatus(barrierId, '进行中...');
        try {
            const headers = getHeaders();
            
            log(`${logPrefix} 新知...`);
            await ignorableRequest({ method: 'POST', url: `${CONFIG.apiBase}/barrier-firsts/new-knowledge`, headers: headers, data: JSON.stringify({}) });
            
            log(`${logPrefix} 笃行...`);
            const existingModels = await request({ method: 'GET', url: `${CONFIG.apiBase}/barrier-firsts/role-model-list`, headers: headers });
            
            if (existingModels.length < 2) {
                const newModels = Array.from({ length: 2 - existingModels.length }, () => ({
                    name: generateRealisticName(),
                    position: generateRealisticJob(),
                    unit: '某知名企业'
                }));
                await request({ 
                    method: 'POST', 
                    url: `${CONFIG.apiBase}/barrier-firsts/create-role-model`, 
                    headers: headers, 
                    data: JSON.stringify({ data: newModels, del_ids: [] }) 
                });
            }
            
            const newRoleModels = await request({ method: 'GET', url: `${CONFIG.apiBase}/barrier-firsts/role-model-list`, headers: headers });
            const modelToAnalyze = newRoleModels.find(m => m.barrierRoleModelAnalyze === null);

            if (modelToAnalyze) {
                try {
                    log(`${logPrefix} 分析榜样...`);
                    const intro = await generateSmartContent(`介绍职业榜样的成就和影响力`, "barrier1_intro", 100, 200);
                    const reason = await generateSmartContent(`为什么选择这个职业榜样作为学习对象`, "barrier1_reason", 100, 200);
                    const inspired = await generateSmartContent(`从这个职业榜样身上获得了什么职业启发`, "barrier1_inspired", 100, 200);
                    
                    const targetModel = modelToAnalyze;
                    await request({ 
                        method: 'POST', 
                        url: `${CONFIG.apiBase}/barrier-firsts/create-role-model-analyze/${targetModel.id}`, 
                        headers: headers, 
                        data: JSON.stringify({ intro, reason, inspired }) 
                    });
                } catch (error) {
                    if (error.message.includes('已有分析数据')) {
                        log(`${logPrefix} [提示] 榜样分析已存在，自动跳过。`);
                    } else {
                        throw error;
                    }
                }
            }

            log(`${logPrefix} 领悟...`);
            const careerRetrospect = await generateSmartContent(`总结职业规划学习的心得体会和未来规划`, "barrier1_retrospect", 200, 400);
            await request({ 
                method: 'POST', 
                url: `${CONFIG.apiBase}/barrier-firsts/create-career-retrospect`, 
                headers: headers, 
                data: JSON.stringify({ content: careerRetrospect }) 
            });
            
            updateStatus(barrierId, '成功!', 'success');
            log(`${logPrefix} ${CONFIG.barriers.find(b => b.id === barrierId).name} 已成功完成！`);
        } catch (error) { 
            console.error(`${logPrefix} 处理失败:`, error); 
            updateStatus(barrierId, `失败: ${error.message}`, 'error'); 
            throw error; 
        }
    }

    async function completeBarrierTwo() {
        const barrierId = 2, logPrefix = `[关卡2]`;
        updateStatus(barrierId, '进行中...');
        try {
            const headers = getHeaders();
            
            log(`${logPrefix} 新知...`);
            await ignorableRequest({ 
                method: 'POST', 
                url: `${CONFIG.apiBase}/barrier-seconds/new-knowledge`, 
                headers: headers, 
                data: JSON.stringify({}) 
            });
            
            log(`${logPrefix} 篤行-创建专业...`);
            const majorName = generateRealisticMajor();
            
            const majorCourse = await generateSmartContent(`描述${majorName}专业的核心课程设置和学习内容`, 'major_course', 210, 300);
            const tunnel = await generateSmartContent(`描述${majorName}专业的发展路径和就业方向`, 'tunnel', 210, 300);
            const interviewer = await generateSmartContent(`描述与${majorName}专业从业者的访谈经历和收获`, 'interviewer', 210, 300);
            const practiceMode = await generateSmartContent(`说明${majorName}专业的实践教学模式和意义`, 'practice_mode', 210, 300);
            
            log(`  - 专业名称: ${majorName}`);
            
            await request({ 
                method: 'POST', 
                url: `${CONFIG.apiBase}/barrier-seconds/create-major`, 
                headers: headers, 
                data: JSON.stringify({ 
                    major_name: majorName,
                    major_course: majorCourse,
                    tunnel: tunnel,
                    interviewer: interviewer,
                    practice_mode: practiceMode
                }) 
            });
            
            log(`  - 专业创建成功`);
            
            log(`${logPrefix} 篤行-专业探索...`);
            await ignorableRequest({ 
                method: 'POST', 
                url: `${CONFIG.apiBase}/barrier-seconds/create-major-explore`, 
                headers: headers, 
                data: JSON.stringify({}) 
            });
            
            log(`${logPrefix} 领悟...`);
            const identityChange = await generateSmartContent(`描述专业学习带来的身份认知变化`, 'identity_change', 210, 300);
            const favoriteMajor = await generateSmartContent(`描述最喜欢的专业领域及原因`, 'favorite_major', 210, 300);
            
            await request({ 
                method: 'POST', 
                url: `${CONFIG.apiBase}/barrier-seconds/create-comprehend`, 
                headers: headers, 
                data: JSON.stringify({ 
                    identity_change: identityChange,
                    favorite_major: favoriteMajor
                }) 
            });
            
            updateStatus(barrierId, '成功!', 'success');
            log(`${logPrefix} ${CONFIG.barriers.find(b => b.id === barrierId).name} 已成功完成！`);
        } catch (error) { 
            console.error(`${logPrefix} 处理失败:`, error);
            if (error.message.includes('Data Validation Failed')) {
                log(`${logPrefix} ❌ 数据验证失败，尝试使用简化内容...`, 'error');
                try {
                    const headers = getHeaders();
                    const majorName = generateRealisticMajor();
                    const simpleText = "通过专业学习掌握了扎实的理论基础和实践技能，为未来职业发展奠定基础。课程设置合理，理论与实践结合紧密。发展前景广阔，就业方向多元。";
                    
                    await request({ 
                        method: 'POST', 
                        url: `${CONFIG.apiBase}/barrier-seconds/create-major`, 
                        headers: headers, 
                        data: JSON.stringify({ 
                            major_name: majorName,
                            major_course: simpleText,
                            tunnel: simpleText,
                            interviewer: simpleText,
                            practice_mode: simpleText
                        }) 
                    });
                    
                    updateStatus(barrierId, '成功!', 'success');
                    log(`${logPrefix} 使用简化内容成功完成！`);
                    return;
                } catch (retryError) {
                    log(`${logPrefix} ❌ 简化内容也失败: ${retryError.message}`, 'error');
                }
            }
            updateStatus(barrierId, `失败: ${error.message}`, 'error'); 
            throw error; 
        }
    }

    async function completeBarrierThree() {
        const barrierId = 3, logPrefix = `[关卡3]`;
        updateStatus(barrierId, '进行中...');
        try {
            const headers = getHeaders();
            
            log(`${logPrefix} 正在处理职业瞭望关卡...`);
            
            // 职业探索
            log(`${logPrefix} 职业探索...`);
            await ignorableRequest({ 
                method: 'POST', 
                url: `${CONFIG.apiBase}/barrier-thirds/career-explore`, 
                headers: headers, 
                data: JSON.stringify({}) 
            });
            
            // 职业分析
            log(`${logPrefix} 职业分析...`);
            const careerAnalysis = await generateSmartContent(`分析目标职业的发展前景和就业形势`, "career_analysis", 200, 400);
            await request({ 
                method: 'POST', 
                url: `${CONFIG.apiBase}/barrier-thirds/career-analyze`, 
                headers: headers, 
                data: JSON.stringify({ content: careerAnalysis }) 
            });
            
            updateStatus(barrierId, '成功!', 'success');
            log(`${logPrefix} ${CONFIG.barriers.find(b => b.id === barrierId).name} 已成功完成！`);
        } catch (error) { 
            updateStatus(barrierId, `失败: ${error.message}`, 'error'); 
            throw error; 
        }
    }

    async function completeBarrierFour() {
        const barrierId = 5, logPrefix = `[关卡4]`;
        updateStatus(barrierId, '进行中...');
        try {
            const headers = getHeaders();
            
            log(`${logPrefix} 正在处理兴趣揭秘关卡...`);
            
            // 兴趣测评
            log(`${logPrefix} 兴趣测评...`);
            await ignorableRequest({ 
                method: 'POST', 
                url: `${CONFIG.apiBase}/barrier-fourths/interest-test`, 
                headers: headers, 
                data: JSON.stringify({}) 
            });
            
            // 兴趣分析
            log(`${logPrefix} 兴趣分析...`);
            const interestAnalysis = await generateSmartContent(`分析个人兴趣特点与职业匹配度`, "interest_analysis", 200, 400);
            await request({ 
                method: 'POST', 
                url: `${CONFIG.apiBase}/barrier-fourths/interest-analyze`, 
                headers: headers, 
                data: JSON.stringify({ content: interestAnalysis }) 
            });
            
            updateStatus(barrierId, '成功!', 'success');
            log(`${logPrefix} ${CONFIG.barriers.find(b => b.id === barrierId).name} 已成功完成！`);
        } catch (error) { 
            updateStatus(barrierId, `失败: ${error.message}`, 'error'); 
            throw error; 
        }
    }

    async function completeBarrierFive() {
        const barrierId = 6, logPrefix = `[关卡5]`;
        updateStatus(barrierId, '进行中...');
        try {
            const headers = getHeaders();
            
            log(`${logPrefix} 正在处理目标锚定关卡...`);
            
            // 目标设定
            log(`${logPrefix} 目标设定...`);
            const careerGoal = await generateSmartContent(`设定明确的短期和长期职业目标`, "career_goal", 200, 400);
            await request({ 
                method: 'POST', 
                url: `${CONFIG.apiBase}/barrier-fifths/set-goal`, 
                headers: headers, 
                data: JSON.stringify({ content: careerGoal }) 
            });
            
            // 行动计划
            log(`${logPrefix} 行动计划...`);
            const actionPlan = await generateSmartContent(`制定实现职业目标的具体行动计划`, "action_plan", 200, 400);
            await request({ 
                method: 'POST', 
                url: `${CONFIG.apiBase}/barrier-fifths/action-plan`, 
                headers: headers, 
                data: JSON.stringify({ content: actionPlan }) 
            });
            
            updateStatus(barrierId, '成功!', 'success');
            log(`${logPrefix} ${CONFIG.barriers.find(b => b.id === barrierId).name} 已成功完成！`);
        } catch (error) { 
            updateStatus(barrierId, `失败: ${error.message}`, 'error'); 
            throw error; 
        }
    }

    async function completeBarrierSix() {
        const barrierId = 7, logPrefix = `[关卡6]`;
        updateStatus(barrierId, '进行中...');
        try {
            const headers = getHeaders();
            
            log(`${logPrefix} 正在处理能力盘点关卡...`);
            
            // 能力评估
            log(`${logPrefix} 能力评估...`);
            await ignorableRequest({ 
                method: 'POST', 
                url: `${CONFIG.apiBase}/barrier-sixths/ability-assess`, 
                headers: headers, 
                data: JSON.stringify({}) 
            });
            
            // 能力提升计划
            log(`${logPrefix} 能力提升计划...`);
            const abilityPlan = await generateSmartContent(`制定个人能力提升计划`, "ability_plan", 200, 400);
            await request({ 
                method: 'POST', 
                url: `${CONFIG.apiBase}/barrier-sixths/ability-plan`, 
                headers: headers, 
                data: JSON.stringify({ content: abilityPlan }) 
            });
            
            updateStatus(barrierId, '成功!', 'success');
            log(`${logPrefix} ${CONFIG.barriers.find(b => b.id === barrierId).name} 已成功完成！`);
        } catch (error) { 
            updateStatus(barrierId, `失败: ${error.message}`, 'error'); 
            throw error; 
        }
    }

    async function completeBarrierSeven() {
        const barrierId = 8, logPrefix = `[关卡7]`;
        updateStatus(barrierId, '进行中...');
        try {
            const headers = getHeaders();
            
            log(`${logPrefix} 正在处理技能提升关卡...`);
            
            // 技能学习
            log(`${logPrefix} 技能学习...`);
            await ignorableRequest({ 
                method: 'POST', 
                url: `${CONFIG.apiBase}/barrier-sevenths/skill-learn`, 
                headers: headers, 
                data: JSON.stringify({}) 
            });
            
            // 技能实践
            log(`${logPrefix} 技能实践...`);
            const skillPractice = await generateSmartContent(`描述技能实践的具体计划和预期效果`, "skill_practice", 200, 400);
            await request({ 
                method: 'POST', 
                url: `${CONFIG.apiBase}/barrier-sevenths/skill-practice`, 
                headers: headers, 
                data: JSON.stringify({ content: skillPractice }) 
            });
            
            updateStatus(barrierId, '成功!', 'success');
            log(`${logPrefix} ${CONFIG.barriers.find(b => b.id === barrierId).name} 已成功完成！`);
        } catch (error) { 
            updateStatus(barrierId, `失败: ${error.message}`, 'error'); 
            throw error; 
        }
    }

    async function completeBarrierEight() {
        const barrierId = 9, logPrefix = `[关卡8]`;
        updateStatus(barrierId, '进行中...');
        try {
            const headers = getHeaders();
            
            log(`${logPrefix} 正在处理生涯启航关卡...`);
            
            // 生涯规划总结
            log(`${logPrefix} 生涯规划总结...`);
            const careerSummary = await generateSmartContent(`总结整个职业规划学习过程的收获和未来展望`, "career_summary", 300, 500);
            await request({ 
                method: 'POST', 
                url: `${CONFIG.apiBase}/barrier-eighths/career-summary`, 
                headers: headers, 
                data: JSON.stringify({ content: careerSummary }) 
            });
            
            // 启航宣言
            log(`${logPrefix} 启航宣言...`);
            const careerDeclaration = await generateSmartContent(`表达职业发展的决心和信心`, "career_declaration", 200, 400);
            await request({ 
                method: 'POST', 
                url: `${CONFIG.apiBase}/barrier-eighths/career-declaration`, 
                headers: headers, 
                data: JSON.stringify({ content: careerDeclaration }) 
            });
            
            updateStatus(barrierId, '成功!', 'success');
            log(`${logPrefix} ${CONFIG.barriers.find(b => b.id === barrierId).name} 已成功完成！`);
        } catch (error) { 
            updateStatus(barrierId, `失败: ${error.message}`, 'error'); 
            throw error; 
        }
    }

    // --- 进度更新函数 ---
    function updateStatus(barrierId, status, type = 'info') {
        const statusElement = document.getElementById(`zgs-barrier-${barrierId}-status`);
        if (statusElement) {
            statusElement.textContent = status;
            statusElement.className = `zgs-barrier-status zgs-status-${type}`;
        }
        
        // 更新进度条
        updateProgressBar();
    }

    function updateProgressBar() {
        const progressFill = document.querySelector('.zgs-progress-fill');
        const progressText = document.querySelector('.zgs-progress-text');
        
        if (progressFill && progressText) {
            const completed = document.querySelectorAll('.zgs-status-success').length;
            const total = document.querySelectorAll('.zgs-barrier-status').length;
            const percentage = total > 0 ? Math.round((completed / total) * 100) : 0;
            
            progressFill.style.width = `${percentage}%`;
            progressText.textContent = `${percentage}%`;
        }
    }

    function updateTokenStatus(status, isReady = false) {
        const tokenStatus = document.getElementById('zgs-token-status');
        if (tokenStatus) {
            tokenStatus.innerHTML = isReady ? 
                `<span style="color: #3498db;">✅ ${status}</span>` :
                `<span style="color: #e67e22;">⏳ ${status}</span>`;
        }
    }

    // --- 执行控制 ---
    async function executeSelectedBarriers() {
        if (isExecuting) {
            log('❌ 已有任务正在执行中', 'error');
            return;
        }

        isExecuting = true;
        currentExecution = {
            startTime: Date.now(),
            completed: 0,
            total: 0
        };

        const executeBtn = document.getElementById('zgs-execute-selected');
        const stopBtn = document.getElementById('zgs-stop-execution');
        if (executeBtn) executeBtn.style.display = 'none';
        if (stopBtn) stopBtn.style.display = 'block';

        try {
            const selectedBarriers = getSelectedBarriers();
            currentExecution.total = selectedBarriers.length;
            
            log(`🚀 开始执行选中的 ${selectedBarriers.length} 个关卡...`, 'success');
            
            for (const barrier of selectedBarriers) {
                if (!isExecuting) {
                    log('⏹️ 执行已被用户停止', 'warning');
                    break;
                }
                
                try {
                    await barrier.func();
                    currentExecution.completed++;
                } catch (error) {
                    log(`❌ 关卡 ${barrier.id} 执行失败: ${error.message}`, 'error');
                    // 继续执行下一个关卡
                }
                
                // 添加短暂延迟，避免请求过于频繁
                await sleep(1000);
            }
            
            const elapsedTime = ((Date.now() - currentExecution.startTime) / 1000).toFixed(1);
            if (isExecuting) {
                log(`🎉 所有选中关卡执行完成！耗时: ${elapsedTime}秒`, 'success');
            }
            
        } catch (error) {
            log(`❌ 执行过程中发生错误: ${error.message}`, 'error');
        } finally {
            isExecuting = false;
            currentExecution = null;
            if (executeBtn) executeBtn.style.display = 'block';
            if (stopBtn) stopBtn.style.display = 'none';
        }
    }

    function stopExecution() {
        if (isExecuting) {
            isExecuting = false;
            log('⏹️ 正在停止执行...', 'warning');
        }
    }

    // --- 进度保存和加载 ---
    function saveProgress() {
        try {
            GM_setValue('selected_range', selectedRange);
            GM_setValue('ai_config', AI_CONFIG);
            log('进度已保存', 'success');
        } catch (e) {
            log('保存进度失败: ' + e.message, 'error');
        }
    }

    function loadProgress() {
        try {
            const savedRange = GM_getValue('selected_range');
            if (savedRange) {
                selectedRange = savedRange;
                updateRangeDisplay();
            }
            
            const savedAIConfig = GM_getValue('ai_config');
            if (savedAIConfig) {
                Object.assign(AI_CONFIG, savedAIConfig);
            }
            
            log('进度已加载', 'success');
        } catch (e) {
            log('加载进度失败: ' + e.message, 'error');
        }
    }

    // --- 窗口管理功能 ---
    function setupWindowManagement(panel) {
        const header = panel.querySelector('.zgs-panel-header');
        
        // 拖拽功能
        header.addEventListener('mousedown', startDrag);
        
        function startDrag(e) {
            if (e.button !== 0 || e.target.closest('.zgs-window-controls')) return;
            
            isDragging = true;
            const rect = panel.getBoundingClientRect();
            dragOffset.x = e.clientX - rect.left;
            dragOffset.y = e.clientY - rect.top;
            
            document.addEventListener('mousemove', onDrag);
            document.addEventListener('mouseup', stopDrag);
            
            panel.style.transition = 'none';
            header.style.userSelect = 'none';
            header.style.cursor = 'grabbing';
        }
        
        function onDrag(e) {
            if (!isDragging) return;
            
            let x = e.clientX - dragOffset.x;
            let y = e.clientY - dragOffset.y;
            
            // 限制在屏幕范围内
            const maxX = window.innerWidth - panel.offsetWidth;
            const maxY = window.innerHeight - panel.offsetHeight;
            
            x = Math.max(0, Math.min(x, maxX));
            y = Math.max(0, Math.min(y, maxY));
            
            panel.style.left = x + 'px';
            panel.style.top = y + 'px';
        }
        
        function stopDrag() {
            isDragging = false;
            document.removeEventListener('mousemove', onDrag);
            document.removeEventListener('mouseup', stopDrag);
            
            panel.style.transition = 'all 0.3s ease';
            header.style.userSelect = 'auto';
            header.style.cursor = 'move';
            
            savePanelState();
        }

        // 缩放功能
        const resizeHandle = panel.querySelector('.zgs-resize-handle');
        if (resizeHandle) {
            resizeHandle.addEventListener('mousedown', startResize);
        }

        function startResize(e) {
            e.preventDefault();
            e.stopPropagation();
            
            isResizing = true;
            const startX = e.clientX;
            const startY = e.clientY;
            const startWidth = parseInt(document.defaultView.getComputedStyle(panel).width, 10);
            const startHeight = parseInt(document.defaultView.getComputedStyle(panel).height, 10);
            
            document.addEventListener('mousemove', onResize);
            document.addEventListener('mouseup', stopResize);
            
            function onResize(e) {
                if (!isResizing) return;
                
                const newWidth = Math.max(350, Math.min(800, startWidth + (e.clientX - startX)));
                const newHeight = Math.max(300, Math.min(600, startHeight + (e.clientY - startY)));
                
                panel.style.width = newWidth + 'px';
                panel.style.height = newHeight + 'px';
            }
            
            function stopResize() {
                isResizing = false;
                document.removeEventListener('mousemove', onResize);
                document.removeEventListener('mouseup', stopResize);
                savePanelState();
            }
        }

        // 最小化功能
        const minimizeBtn = panel.querySelector('.zgs-minimize-btn');
        if (minimizeBtn) {
            minimizeBtn.addEventListener('click', toggleMinimize);
        }

        function toggleMinimize() {
            isMinimized = !isMinimized;
            const mainContent = panel.querySelector('.zgs-panel-main-content');
            
            if (isMinimized) {
                mainContent.style.display = 'none';
                panel.style.height = '45px'; // 只显示标题栏高度
                minimizeBtn.innerHTML = '📄';
                log('窗口已最小化', 'info');
            } else {
                mainContent.style.display = 'block';
                panel.style.height = '500px'; // 恢复原始高度
                minimizeBtn.innerHTML = '➖';
                log('窗口已恢复', 'info');
            }
            savePanelState();
        }
    }
    
    function savePanelState() {
        const panel = document.getElementById('zgs-helper-panel');
        if (panel) {
            const state = {
                left: panel.style.left,
                top: panel.style.top,
                width: panel.style.width,
                height: panel.style.height,
                isMinimized: isMinimized
            };
            GM_setValue('panel_state', state);
        }
    }
    
    function loadPanelState() {
        const state = GM_getValue('panel_state');
        const panel = document.getElementById('zgs-helper-panel');
        if (panel && state) {
            panel.style.left = state.left || '50px';
            panel.style.top = state.top || '50px';
            panel.style.width = state.width || '400px';
            panel.style.height = state.height || '500px';
            isMinimized = state.isMinimized || false;
            
            if (isMinimized) {
                const mainContent = panel.querySelector('.zgs-panel-main-content');
                const minimizeBtn = panel.querySelector('.zgs-minimize-btn');
                if (mainContent) mainContent.style.display = 'none';
                if (minimizeBtn) minimizeBtn.innerHTML = '📄';
                panel.style.height = '45px';
            }
        }
    }

    // --- 完整的UI初始化函数 ---
    function initializeUI() {
        console.log('闯关助手：开始初始化UI...');
        
        if (document.getElementById('zgs-helper-panel')) {
            console.log('闯关助手：面板已存在，跳过初始化');
            return;
        }

        addPanelStyles();

        const panel = document.createElement('div');
        panel.id = 'zgs-helper-panel';
        panel.style.cssText = `
            position: fixed;
            left: 50px;
            top: 50px;
            width: 400px;
            height: 500px;
            z-index: 10000;
            display: block;
        `;

        // 创建标题栏
        const header = document.createElement('div');
        header.className = 'zgs-panel-header';
        header.innerHTML = `
            <div class="zgs-panel-title">
                <span class="zgs-icon">✈️</span>
                <strong>闯关助手</strong>
                <span class="zgs-version">v2.7</span>
            </div>
            <div class="zgs-window-controls">
                <button class="zgs-minimize-btn" title="最小化">➖</button>
            </div>
            <div id="zgs-token-status" class="zgs-token-status waiting">
                <span>⏳ 等待Token...</span>
            </div>
        `;
        panel.appendChild(header);

        // 创建主内容容器
        const mainContent = document.createElement('div');
        mainContent.className = 'zgs-panel-main-content';
        
        // 创建控制区
        const controls = document.createElement('div');
        controls.className = 'zgs-panel-controls';
        
        // AI配置区域
        const aiConfigSection = document.createElement('div');
        aiConfigSection.className = 'zgs-ai-config-section';
        aiConfigSection.innerHTML = `
            <div class="zgs-ai-config-header">
                <span>🤖 AI智能答题</span>
            </div>
            <div class="zgs-ai-config-body">
                <div class="zgs-config-item">
                    <label>启用AI:</label>
                    <input type="checkbox" id="zgs-ai-enabled" ${AI_CONFIG.enabled ? 'checked' : ''}>
                </div>
                <div class="zgs-config-item">
                    <label>API密钥:</label>
                    <input type="password" id="zgs-ai-apikey" placeholder="DeepSeek API密钥" value="${AI_CONFIG.apiKey || ''}">
                </div>
                <div class="zgs-config-tips">
                    <small>💡 获取免费API密钥: <a href="https://platform.deepseek.com/api_keys" target="_blank">DeepSeek平台</a></small>
                </div>
            </div>
        `;
        controls.appendChild(aiConfigSection);

        // 关卡范围选择区域
        const rangeSection = document.createElement('div');
        rangeSection.className = 'zgs-range-section';
        rangeSection.innerHTML = `
            <div class="zgs-range-header">
                <span>📊 关卡范围选择</span>
            </div>
            <div class="zgs-range-controls">
                <div class="zgs-range-slider-container">
                    <div class="zgs-range-labels">
                        <span>开始关卡</span>
                        <span id="zgs-range-display">关卡 1 - 9</span>
                        <span>结束关卡</span>
                    </div>
                    <div class="zgs-range-slider">
                        <input type="range" id="zgs-range-start" min="1" max="9" value="1" class="zgs-range-input">
                        <input type="range" id="zgs-range-end" min="1" max="9" value="9" class="zgs-range-input">
                    </div>
                </div>
                <div class="zgs-barrier-list">
                    ${CONFIG.barriers.map((barrier, index) => `
                        <div class="zgs-barrier-item ${index === 0 ? 'selected' : ''}" data-id="${barrier.id}">
                            <span class="zgs-barrier-number">${index + 1}</span>
                            <span class="zgs-barrier-name">${barrier.name}</span>
                        </div>
                    `).join('')}
                </div>
            </div>
        `;
        controls.appendChild(rangeSection);

        // 执行控制区域
        const executeSection = document.createElement('div');
        executeSection.className = 'zgs-execute-section';
        executeSection.innerHTML = `
            <div class="zgs-execute-header">
                <span>⚡ 执行控制</span>
            </div>
            <div class="zgs-execute-controls">
                <button id="zgs-execute-selected" class="zgs-btn zgs-btn-primary">执行选中关卡</button>
                <button id="zgs-stop-execution" class="zgs-btn zgs-btn-danger" style="display:none;">停止执行</button>
            </div>
            <div class="zgs-progress-container">
                <div class="zgs-progress-bar">
                    <div class="zgs-progress-fill"></div>
                </div>
                <span class="zgs-progress-text">0%</span>
            </div>
        `;
        controls.appendChild(executeSection);

        // 关卡状态区域
        const statusSection = document.createElement('div');
        statusSection.className = 'zgs-status-section';
        statusSection.innerHTML = `
            <div class="zgs-status-header">
                <span>📈 关卡状态</span>
            </div>
            <div class="zgs-barrier-status-list">
                ${CONFIG.barriers.map(barrier => `
                    <div class="zgs-barrier-status-item">
                        <span class="zgs-barrier-name">${barrier.id}. ${barrier.name}</span>
                        <span id="zgs-barrier-${barrier.id}-status" class="zgs-barrier-status zgs-status-waiting">等待中</span>
                    </div>
                `).join('')}
            </div>
        `;
        controls.appendChild(statusSection);

        mainContent.appendChild(controls);

        // 日志区域
        const logSection = document.createElement('div');
        logSection.className = 'zgs-log-section';
        logSection.innerHTML = `
            <div class="zgs-log-header">
                <span>📝 执行日志</span>
                <button id="zgs-clear-logs" class="zgs-btn zgs-btn-small">清空日志</button>
            </div>
            <div id="zgs-log-container" class="zgs-log-container"></div>
        `;
        mainContent.appendChild(logSection);

        panel.appendChild(mainContent);

        // 添加缩放手柄
        const resizeHandle = document.createElement('div');
        resizeHandle.className = 'zgs-resize-handle';
        panel.appendChild(resizeHandle);

        document.body.appendChild(panel);

        // 设置窗口管理功能
        setupWindowManagement(panel);
        
        // 加载保存的状态
        loadPanelState();
        loadProgress();
        
        // 设置事件监听
        setupEventListeners();
        
        // 初始化范围显示
        updateRangeDisplay();

        console.log('闯关助手：UI初始化完成');
    }

    function setupEventListeners() {
        // 范围滑块事件
        const startSlider = document.getElementById('zgs-range-start');
        const endSlider = document.getElementById('zgs-range-end');
        
        if (startSlider && endSlider) {
            startSlider.addEventListener('input', function() {
                const start = parseInt(this.value);
                const end = parseInt(endSlider.value);
                if (start > end) {
                    endSlider.value = start;
                    updateRangeSelection(start, start);
                } else {
                    updateRangeSelection(start, end);
                }
                saveProgress();
            });
            
            endSlider.addEventListener('input', function() {
                const start = parseInt(startSlider.value);
                const end = parseInt(this.value);
                if (end < start) {
                    startSlider.value = end;
                    updateRangeSelection(end, end);
                } else {
                    updateRangeSelection(start, end);
                }
                saveProgress();
            });
        }
        
        // 关卡项点击事件
        document.querySelectorAll('.zgs-barrier-item').forEach(item => {
            item.addEventListener('click', function() {
                const barrierId = parseInt(this.dataset.id);
                const index = CONFIG.barriers.findIndex(b => b.id === barrierId);
                if (index !== -1) {
                    updateRangeSelection(index + 1, index + 1);
                    if (startSlider) startSlider.value = index + 1;
                    if (endSlider) endSlider.value = index + 1;
                    saveProgress();
                }
            });
        });
        
        // AI配置保存
        const aiEnabled = document.getElementById('zgs-ai-enabled');
        const aiApiKey = document.getElementById('zgs-ai-apikey');
        
        if (aiEnabled) {
            aiEnabled.addEventListener('change', function() {
                AI_CONFIG.enabled = this.checked;
                log(`AI答题 ${this.checked ? '已启用' : '已禁用'}`);
                saveProgress();
            });
        }
        
        if (aiApiKey) {
            aiApiKey.addEventListener('change', function() {
                AI_CONFIG.apiKey = this.value.trim();
                log('API密钥已更新');
                saveProgress();
            });
        }
        
        // 按钮事件
        document.getElementById('zgs-execute-selected')?.addEventListener('click', executeSelectedBarriers);
        document.getElementById('zgs-stop-execution')?.addEventListener('click', stopExecution);
        document.getElementById('zgs-clear-logs')?.addEventListener('click', () => {
            const logContainer = document.getElementById('zgs-log-container');
            if (logContainer) logContainer.innerHTML = '';
            log('日志已清空');
        });
    }

    function addPanelStyles() {
        const css = `
            #zgs-helper-panel {
                position: fixed !important;
                left: 50px;
                top: 50px;
                width: 400px;
                height: 500px;
                background: linear-gradient(135deg, #e3f2fd 0%, #bbdefb 50%, #90caf9 100%);
                border: 1px solid #64b5f6;
                border-radius: 12px;
                box-shadow: 0 8px 32px rgba(33, 150, 243, 0.3),
                          0 4px 16px rgba(0, 0, 0, 0.1),
                          inset 0 1px 0 rgba(255, 255, 255, 0.8);
                font-family: 'Microsoft YaHei', 'Segoe UI', sans-serif;
                font-size: 12px;
                overflow: hidden;
                backdrop-filter: blur(10px);
                transition: all 0.3s ease;
                resize: none;
                z-index: 10000;
            }

            #zgs-helper-panel:hover {
                box-shadow: 0 12px 40px rgba(33, 150, 243, 0.4),
                          0 6px 20px rgba(0, 0, 0, 0.15);
                border-color: #42a5f5;
            }

            .zgs-panel-header {
                background: linear-gradient(135deg, rgba(33, 150, 243, 0.1) 0%, rgba(25, 118, 210, 0.1) 100%);
                color: #1565c0;
                padding: 12px 15px;
                display: flex;
                justify-content: space-between;
                align-items: center;
                border-bottom: 1px solid rgba(33, 150, 243, 0.3);
                position: relative;
                cursor: move;
                user-select: none;
            }

            .zgs-panel-title {
                display: flex;
                align-items: center;
                gap: 8px;
                font-weight: 600;
            }

            .zgs-icon {
                font-size: 16px;
                filter: drop-shadow(0 0 8px rgba(33, 150, 243, 0.6));
            }

            .zgs-version {
                background: rgba(33, 150, 243, 0.2);
                padding: 2px 6px;
                border-radius: 8px;
                font-size: 10px;
                border: 1px solid rgba(33, 150, 243, 0.4);
                color: #0d47a1;
            }

            .zgs-window-controls {
                display: flex;
                gap: 5px;
                margin-left: auto;
                margin-right: 10px;
            }

            .zgs-minimize-btn {
                background: rgba(33, 150, 243, 0.2);
                border: 1px solid rgba(33, 150, 243, 0.4);
                color: #1565c0;
                border-radius: 4px;
                width: 20px;
                height: 20px;
                display: flex;
                align-items: center;
                justify-content: center;
                cursor: pointer;
                font-size: 10px;
                transition: all 0.3s ease;
            }

            .zgs-minimize-btn:hover {
                background: rgba(33, 150, 243, 0.3);
                transform: scale(1.1);
            }

            .zgs-token-status {
                font-size: 11px;
                font-weight: 500;
            }

            /* 主内容区域 */
            .zgs-panel-main-content {
                height: calc(100% - 45px);
                overflow-y: auto;
                overflow-x: hidden;
                display: flex;
                flex-direction: column;
                gap: 15px;
                padding: 15px;
                background: rgba(227, 242, 253, 0.9);
                
                /* 自定义滚动条 */
                scrollbar-width: thin;
                scrollbar-color: #2196f3 #e3f2fd;
            }

            .zgs-panel-main-content::-webkit-scrollbar {
                width: 8px;
            }

            .zgs-panel-main-content::-webkit-scrollbar-track {
                background: rgba(227, 242, 253, 0.8);
                border-radius: 4px;
                margin: 2px;
            }

            .zgs-panel-main-content::-webkit-scrollbar-thumb {
                background: linear-gradient(135deg, #2196f3, #1976d2);
                border-radius: 4px;
                border: 1px solid rgba(255, 255, 255, 0.3);
            }

            .zgs-panel-main-content::-webkit-scrollbar-thumb:hover {
                background: linear-gradient(135deg, #1976d2, #2196f3);
                box-shadow: 0 0 8px rgba(33, 150, 243, 0.6);
            }

            .zgs-panel-controls {
                display: flex;
                flex-direction: column;
                gap: 15px;
            }

            .zgs-ai-config-section,
            .zgs-range-section,
            .zgs-execute-section,
            .zgs-status-section,
            .zgs-log-section {
                padding: 12px;
                background: rgba(255, 255, 255, 0.7);
                border-radius: 8px;
                border: 1px solid rgba(33, 150, 243, 0.2);
                backdrop-filter: blur(5px);
                transition: all 0.3s ease;
            }

            .zgs-ai-config-section:hover,
            .zgs-range-section:hover,
            .zgs-execute-section:hover,
            .zgs-status-section:hover,
            .zgs-log-section:hover {
                border-color: rgba(33, 150, 243, 0.4);
                box-shadow: 0 4px 12px rgba(33, 150, 243, 0.15);
            }

            .zgs-ai-config-header,
            .zgs-range-header,
            .zgs-execute-header,
            .zgs-status-header,
            .zgs-log-header {
                font-weight: 600;
                margin-bottom: 10px;
                color: #1565c0;
                display: flex;
                justify-content: space-between;
                align-items: center;
            }

            .zgs-config-item {
                display: flex;
                align-items: center;
                margin-bottom: 8px;
                gap: 8px;
            }

            .zgs-config-item label {
                min-width: 65px;
                font-weight: 500;
                color: #37474f;
            }

            .zgs-config-item input[type="text"],
            .zgs-config-item input[type="password"] {
                flex: 1;
                padding: 6px 10px;
                background: rgba(255, 255, 255, 0.8);
                border: 1px solid rgba(33, 150, 243, 0.3);
                border-radius: 4px;
                font-size: 11px;
                color: #263238;
                transition: all 0.3s ease;
            }

            .zgs-config-item input:focus {
                outline: none;
                border-color: #2196f3;
                box-shadow: 0 0 8px rgba(33, 150, 243, 0.2);
                background: white;
            }

            .zgs-config-tips {
                margin-top: 8px;
                color: #546e7a;
                font-size: 10px;
            }

            .zgs-config-tips a {
                color: #2196f3;
                text-decoration: none;
                transition: color 0.3s ease;
            }

            .zgs-config-tips a:hover {
                color: #1976d2;
            }

            .zgs-resize-handle {
                position: absolute;
                bottom: 0;
                right: 0;
                width: 15px;
                height: 15px;
                cursor: nw-resize;
                background: linear-gradient(135deg, transparent 50%, #2196f3 50%);
                border-radius: 0 0 12px 0;
                opacity: 0.7;
                transition: opacity 0.3s ease;
            }

            .zgs-resize-handle:hover {
                opacity: 1;
            }

            /* 其他样式... */
            .zgs-range-slider-container {
                padding: 10px;
                background: rgba(255, 255, 255, 0.6);
                border-radius: 6px;
                margin-bottom: 10px;
                border: 1px solid rgba(33, 150, 243, 0.2);
            }

            .zgs-range-labels {
                display: flex;
                justify-content: space-between;
                margin-bottom: 10px;
                font-size: 11px;
                color: #546e7a;
            }

            .zgs-range-slider {
                position: relative;
                height: 30px;
            }

            .zgs-range-input {
                position: absolute;
                width: 100%;
                height: 4px;
                background: rgba(33, 150, 243, 0.2);
                border-radius: 2px;
                pointer-events: none;
                -webkit-appearance: none;
            }

            .zgs-range-input::-webkit-slider-thumb {
                pointer-events: all;
                width: 16px;
                height: 16px;
                border-radius: 50%;
                background: linear-gradient(135deg, #2196f3, #1976d2);
                cursor: pointer;
                -webkit-appearance: none;
                border: 2px solid #ffffff;
                transition: all 0.3s ease;
            }

            .zgs-range-input::-webkit-slider-thumb:hover {
                transform: scale(1.1);
                box-shadow: 0 0 8px rgba(33, 150, 243, 0.6);
            }

            .zgs-barrier-list {
                display: grid;
                grid-template-columns: repeat(3, 1fr);
                gap: 5px;
            }

            .zgs-barrier-item {
                display: flex;
                align-items: center;
                padding: 8px;
                background: rgba(255, 255, 255, 0.6);
                border: 1px solid rgba(33, 150, 243, 0.2);
                border-radius: 6px;
                cursor: pointer;
                transition: all 0.3s ease;
                font-size: 11px;
                color: #37474f;
            }

            .zgs-barrier-item:hover {
                border-color: rgba(33, 150, 243, 0.4);
                transform: translateY(-1px);
            }

            .zgs-barrier-item.selected {
                background: linear-gradient(135deg, rgba(33, 150, 243, 0.15), rgba(25, 118, 210, 0.15));
                border-color: #2196f3;
                color: #1565c0;
            }

            .zgs-barrier-number {
                background: linear-gradient(135deg, #2196f3, #1976d2);
                color: white;
                border-radius: 50%;
                width: 18px;
                height: 18px;
                display: flex;
                align-items: center;
                justify-content: center;
                margin-right: 6px;
                font-size: 10px;
                font-weight: bold;
            }

            .zgs-execute-controls {
                display: flex;
                flex-wrap: wrap;
                gap: 5px;
                margin-bottom: 10px;
            }

            .zgs-btn {
                padding: 8px 12px;
                border: none;
                border-radius: 6px;
                cursor: pointer;
                font-size: 11px;
                font-weight: 600;
                transition: all 0.3s ease;
                flex: 1;
                min-width: 0;
            }

            .zgs-btn-primary {
                background: linear-gradient(135deg, #2196f3, #1976d2);
                color: white;
            }

            .zgs-btn-primary:hover {
                transform: translateY(-1px);
                box-shadow: 0 4px 12px rgba(33, 150, 243, 0.4);
            }

            .zgs-btn-danger {
                background: linear-gradient(135deg, #f44336, #d32f2f);
                color: white;
            }

            .zgs-btn-danger:hover {
                transform: translateY(-1px);
                box-shadow: 0 4px 12px rgba(244, 67, 54, 0.4);
            }

            .zgs-btn-small {
                padding: 4px 8px;
                font-size: 10px;
                flex: none;
            }

            .zgs-progress-container {
                display: flex;
                align-items: center;
                gap: 10px;
            }

            .zgs-progress-bar {
                flex: 1;
                height: 8px;
                background: rgba(33, 150, 243, 0.2);
                border-radius: 4px;
                overflow: hidden;
                border: 1px solid rgba(33, 150, 243, 0.3);
            }

            .zgs-progress-fill {
                height: 100%;
                background: linear-gradient(90deg, #2196f3, #1976d2);
                width: 0%;
                transition: width 0.5s ease;
            }

            .zgs-progress-text {
                font-size: 11px;
                font-weight: bold;
                color: #1565c0;
                min-width: 30px;
            }

            .zgs-barrier-status-list {
                display: flex;
                flex-direction: column;
                gap: 5px;
            }

            .zgs-barrier-status-item {
                display: flex;
                justify-content: space-between;
                align-items: center;
                padding: 6px 8px;
                background: rgba(255, 255, 255, 0.6);
                border-radius: 4px;
                border: 1px solid rgba(33, 150, 243, 0.2);
                transition: all 0.3s ease;
            }

            .zgs-barrier-status {
                padding: 3px 6px;
                border-radius: 10px;
                font-size: 10px;
                font-weight: 600;
            }

            .zgs-status-waiting { 
                background: rgba(158, 158, 158, 0.2); 
                color: #757575; 
            }
            .zgs-status-success { 
                background: rgba(76, 175, 80, 0.2); 
                color: #2e7d32; 
            }
            .zgs-status-error { 
                background: rgba(244, 67, 54, 0.2); 
                color: #c62828; 
            }

            .zgs-log-container {
                height: 120px;
                overflow-y: auto;
                background: rgba(255, 255, 255, 0.8);
                color: #37474f;
                border-radius: 6px;
                padding: 10px;
                font-family: 'Consolas', 'Monaco', monospace;
                font-size: 11px;
                border: 1px solid rgba(33, 150, 243, 0.2);
            }

            .zgs-log-entry {
                margin-bottom: 4px;
                line-height: 1.4;
                padding: 3px 0;
                border-bottom: 1px solid rgba(33, 150, 243, 0.1);
            }

            .zgs-log-time {
                color: #2196f3;
                font-weight: 600;
            }

            .zgs-log-success { color: #2e7d32; }
            .zgs-log-error { color: #c62828; }
            .zgs-log-warning { color: #f57c00; }
            .zgs-log-info { color: #1565c0; }
        `;
        
        GM_addStyle(css);
    }

    // --- 主初始化 ---
    function main() {
        console.log('职业规划大赛闯关助手启动中...');
        
        // 设置Token捕获
        setupPreciseTokenCapture();
        
        // 延迟初始化UI，确保页面加载完成
        if (document.readyState === 'loading') {
            document.addEventListener('DOMContentLoaded', initializeUI);
        } else {
            setTimeout(initializeUI, 1000);
        }
        
        // 每30秒自动保存进度
        setInterval(saveProgress, 30000);
        
        log('职业规划大赛闯关助手 v2.7 已加载完成！', 'success');
    }

    // 启动主程序
    main();

})();