// ==UserScript==
// @name         Ultimate Web Optimizer
// @namespace    https://greasyfork.org/zh-CN/users/1474228-moyu001
// @version      1.1
// @description  全面的网页性能优化方案（含懒加载/预加载/预连接/资源回收/中国平台优化）
// @author       moyu001
// @match        *://*/*
// @grant        GM_getValue
// @grant        GM_setValue
// @grant        GM_log
// @grant        unsafeWindow
// @license      MIT
// @downloadURL none
// ==/UserScript==

(function() {
    'use strict';

    // ========================
    // 配置中心
    // ========================
    const config = {
        debug: false, // 确保调试模式已开启
        features: {
            lazyLoad: {
                enabled: true,
                minSize: 100,
                rootMargin: '200px',
                skipHidden: true
            },
            preconnect: {
                enabled: true,
                whitelist: [
                    'fonts.gstatic.com',
                    'cdnjs.cloudflare.com',
                    'unpkg.com',
                    'ajax.googleapis.com',
                    'maxcdn.bootstrapcdn.com',
                    'code.jquery.com',
                    'kit.fontawesome.com',
                    'fonts.googleapis.cn',
                    'fonts.loli.net',
                    'cdn.jsdelivr.net',
                    'cdn.bootcdn.net',
                    'cdn.bootcss.com',
                    'libs.baidu.com',
                    'cdn.staticfile.org',
                    'lf3-cdn-tos.bytecdntp.com',
                    'unpkg.zhimg.com',
                    'npm.elemecdn.com',
                    // 中国CDN优化
                    'alicdn.com',
                    'bdstatic.com',
                    'sinaimg.cn',
                    'sogoucdn.com',
                    'bytedance.com',
                    'bytecdn.cn',
                    'pstatp.com',
                    'qpic.cn',
                    'hdslb.com',
                    'bilivideo.com',
                    'tencent-cloud.net',
                    'qcloud.com'
                ],
                maxConnections: 8
            },
            preload: {
                enabled: true,
                types: ['css', 'js', 'woff2'],
                maxPreloads: 6
            },
            layout: {
                stableImages: true,
                stableIframes: true,
                stableVideos: true
            },
            captcha: {
                enabled: true,
                autoDetect: true,
                safeMode: true
            },
            resourceRecycling: {
                enabled: true,
                memoryThreshold: 75,
                scrollRecycleMargin: 500,
                videoRecycleMargin: 1000,
                monitorInterval: 5000,
                maxBackgroundVideos: 2
            },
            videoRecycling: {
                enabled: true,
                protectPlaying: true,
                protectVisible: true,
                restoreOnScroll: true
            }
        },
        networkAware: {
            enabled: true,
            connectionTypes: {
                'slow-2g': { 
                    preload: false, 
                    lazyMargin: '500px' 
                },
                '2g': { 
                    preload: true,
                    maxPreloads: 3
                },
                '3g': { 
                    preload: true,
                    maxPreloads: 4
                },
                '4g': { 
                    preload: true,
                    maxPreloads: 8
                }
            }
        },
        chinaPlatforms: {
            enabled: true,
            platforms: {
                taobao: ['taobao.com', 'tmall.com'],
                jd: ['jd.com'],
                douyin: ['douyin.com'],
                bilibili: ['bilibili.com'],
                baidu: ['baidu.com'],
                weibo: ['weibo.com'],
                tencent: ['qq.com'],
                pinduoduo: ['pinduoduo.com'],
                kuaishou: ['kuaishou.com']
            }
        }
    };

    // 公共API对象 - 用于暴露内部方法
    const publicAPI = {
        triggerRecycling: null
    };

    // 添加调试输出函数
    const debugLog = (...args) => {
        if (config.debug) {
            console.log('[Optimizer]', ...args);
        }
    };

    // 添加调试警告函数
    const debugWarn = (...args) => {
        if (config.debug) {
            console.warn('[Optimizer]', ...args);
        }
    };

    // ========================
    // 控制台调试命令系统
    // ========================
    const initConsoleCommands = () => {
        // 确保只初始化一次
        if (unsafeWindow.__optimizerCommands) {
            debugLog('控制台命令已初始化，跳过重复执行'); // 新增调试日志
            return;
        }
        unsafeWindow.__optimizerCommands = true; // 修改：挂载到 unsafeWindow
        
        // 优化状态查看
        unsafeWindow.optimizerStatus = () => { // 修改：挂载到 unsafeWindow
            const status = {
                lazyLoad: {
                    enabled: config.features.lazyLoad.enabled,
                    images: document.querySelectorAll('img[data-src]').length
                },
                preconnect: {
                    enabled: config.features.preconnect.enabled,
                    connections: document.querySelectorAll('link[rel="preconnect"]').length
                },
                preload: {
                    enabled: config.features.preload.enabled,
                    resources: document.querySelectorAll('link[rel="preload"]').length
                },
                resourceRecycling: {
                    enabled: config.features.resourceRecycling.enabled,
                    recycled: document.querySelectorAll('img[data-src]:not([src]), video[data-recycled-state]').length
                },
                chinaPlatform: isChinaPlatform() || '未检测到'
            };
            
            console.groupCollapsed('[Optimizer] 当前状态');
            console.table(status);
            console.groupEnd();
            return status;
        };
        
        // 中国平台检测
        unsafeWindow.checkChinaPlatform = () => {
            const platform = isChinaPlatform();
            if (platform) {
                console.log(`检测到中国平台: ${platform}`);
            } else {
                console.log('未检测到支持的中国平台');
            }
            return platform;
        };
        
        // 临时禁用优化器
        unsafeWindow.disableOptimizer = () => {
            Object.keys(config.features).forEach(key => {
                config.features[key].enabled = false;
            });
            console.warn('优化器已临时禁用，刷新页面后恢复');
        };
        
        // 强制资源回收
        unsafeWindow.forceRecycle = () => {
            if (publicAPI.triggerRecycling) {
                publicAPI.triggerRecycling();
                console.log('资源回收已手动触发');
            } else {
                console.warn('资源回收功能未启用');
            }
        };
        
        console.log('优化器控制台命令已启用: optimizerStatus(), checkChinaPlatform(), disableOptimizer(), forceRecycle()');
        debugLog('控制台命令初始化完成'); // 新增调试日志
    };

    // 在脚本加载后立即初始化控制台命令
    initConsoleCommands();

    // ========================
    // 工具函数
    // ========================
    function throttle(func, limit) {
        let inThrottle;
        return function() {
            const args = arguments;
            const context = this;
            if (!inThrottle) {
                func.apply(context, args);
                inThrottle = true;
                setTimeout(() => inThrottle = false, limit);
            }
        };
    }
    
    function isElementInViewport(el, margin = 0) {
        if (!el) return false;
        const rect = el.getBoundingClientRect();
        return (
            rect.top <= (window.innerHeight + margin) &&
            rect.left <= (window.innerWidth + margin) &&
            rect.bottom >= -margin &&
            rect.right >= -margin
        );
    }
    
    const recyclingGuard = (() => {
        let lastRecycleTime = 0;
        const minRecycleInterval = 10000;
        
        return {
            canRecycle: () => {
                const now = Date.now();
                if (now - lastRecycleTime > minRecycleInterval) {
                    lastRecycleTime = now;
                    return true;
                }
                return false;
            }
        };
    })();

    // ========================
    // 中国平台检测与优化
    // ========================
    const isChinaPlatform = () => {
        const host = window.location.hostname;
        const platforms = config.chinaPlatforms.platforms;
        
        for (const platform in platforms) {
            if (platforms[platform].some(domain => host.includes(domain))) {
                debugLog(`检测到中国平台: ${platform}`);
                return platform;
            }
        }
        debugLog('未检测到中国平台');
        return false;
    };
    
    const applyChinaPlatformOptimizations = () => {
        if (!config.chinaPlatforms.enabled) {
            debugLog('中国平台优化已禁用');
            return;
        }
        
        const platform = isChinaPlatform();
        if (!platform) return;
        
        debugLog(`应用中国平台优化策略: ${platform}`);
        
        // 平台特定优化
        switch(platform) {
            case 'taobao':
                config.features.lazyLoad.rootMargin = '500px';
                document.querySelectorAll('.J_ImgSwitcher, .detail-img').forEach(img => {
                    img.dataset.skipLazy = 'true';
                });
                debugLog('淘宝优化已应用');
                break;
                
            case 'jd':
                config.features.preload.maxPreloads = 8;
                document.querySelectorAll('#preview img').forEach(img => {
                    img.dataset.skipLazy = 'true';
                });
                debugLog('京东优化已应用');
                break;
                
            case 'douyin':
                config.features.resourceRecycling.maxBackgroundVideos = 1;
                const douyinPlayer = document.querySelector('.xgplayer-container video');
                if (douyinPlayer) douyinPlayer.dataset.protected = 'true';
                debugLog('抖音优化已应用');
                break;
                
            case 'bilibili':
                const bilibiliPlayer = document.querySelector('.bpx-player-video-wrap video');
                if (bilibiliPlayer) bilibiliPlayer.dataset.protected = 'true';
                
                // 弹幕优化
                const danmuContainer = document.querySelector('.bpx-player-dm-wrap');
                if (danmuContainer) danmuContainer.dataset.optimizeLayout = 'true';
                debugLog('哔哩哔哩优化已应用');
                break;
                
            case 'baidu':
                document.querySelectorAll('.c-img').forEach(img => {
                    img.loading = 'eager';
                });
                debugLog('百度优化已应用');
                break;
                
            case 'weibo':
                config.features.lazyLoad.rootMargin = '500px';
                document.querySelectorAll('.avator, .avatar').forEach(img => {
                    img.dataset.skipLazy = 'true';
                });
                debugLog('微博优化已应用');
                break;
                
            case 'pinduoduo':
                config.features.resourceRecycling.memoryThreshold = 70;
                document.querySelectorAll('.goods-img').forEach(img => {
                    img.dataset.skipLazy = 'true';
                });
                debugLog('拼多多优化已应用');
                break;
                
            case 'kuaishou':
                config.features.resourceRecycling.videoRecycleMargin = 1000;
                const kuaishouPlayer = document.querySelector('.player-container video');
                if (kuaishouPlayer) kuaishouPlayer.dataset.protected = 'true';
                
                // 快手视频列表优化
                const videoList = document.querySelector('.video-list');
                if (videoList) {
                    videoList.dataset.optimizeLayout = 'true';
                }
                debugLog('快手优化已应用');
                break;
                
            case 'tencent':
                // 腾讯视频优化
                const tencentPlayer = document.querySelector('#txp_player video');
                if (tencentPlayer) tencentPlayer.dataset.protected = 'true';
                
                // 腾讯视频CDN预连接
                config.features.preconnect.whitelist.push('qpic.cn', 'vpic.video.qq.com');
                debugLog('腾讯优化已应用');
                break;
        }
        
        // 通用中国平台优化
        config.features.preconnect.maxConnections = 8;
        config.features.preload.maxPreloads = 6;
        config.features.resourceRecycling.memoryThreshold = 80;
        debugLog('通用中国平台优化已应用');
    };

    // ========================
    // 核心优化模块
    // ========================

    // 图片懒加载系统
    const initLazyLoad = () => {
        if (!config.features.lazyLoad.enabled) {
            debugLog('图片懒加载已禁用');
            return;
        }

        debugLog('初始化图片懒加载系统');
        
        const isLazyCandidate = (img) => {
            if (img.loading === 'eager') return false;
            if (img.complete) return false;
            if (img.src.startsWith('data:')) return false;
            if (img.classList.contains('captcha-image')) return false;
            if (img.dataset.skipLazy === 'true') return false;
            if (config.features.lazyLoad.skipHidden &&
                window.getComputedStyle(img).display === 'none') return false;

            const rect = img.getBoundingClientRect();
            return rect.width > config.features.lazyLoad.minSize &&
                   rect.height > config.features.lazyLoad.minSize;
        };

        const processImage = (img) => {
            if (!img.dataset.src && img.src) {
                img.dataset.src = img.src;
                if (img.crossOrigin) {
                    img.dataset.crossOrigin = img.crossOrigin;
                }
                img.removeAttribute('src');
            }
            if (img.srcset && !img.dataset.srcset) {
                img.dataset.srcset = img.srcset;
                img.removeAttribute('srcset');
            }
            return img;
        };

        // 现代浏览器实现
        if ('IntersectionObserver' in window) {
            debugLog('使用IntersectionObserver实现懒加载');
            
            const observer = new IntersectionObserver((entries) => {
                entries.forEach(entry => {
                    if (entry.isIntersecting) {
                        const img = entry.target;
                        if (img.dataset.src) {
                            if (img.dataset.crossOrigin) {
                                img.crossOrigin = img.dataset.crossOrigin;
                            }
                            img.src = img.dataset.src;
                            debugLog(`懒加载图片: ${img.dataset.src}`);
                        }
                        if (img.dataset.srcset) {
                            img.srcset = img.dataset.srcset;
                            debugLog(`懒加载图片集: ${img.dataset.srcset}`);
                        }
                        observer.unobserve(img);
                    }
                });
            }, {
                rootMargin: config.features.lazyLoad.rootMargin,
                threshold: 0.01
            });

            // 初始图片
            const images = document.querySelectorAll('img');
            debugLog(`发现${images.length}张图片，正在筛选懒加载候选`);
            
            let lazyCount = 0;
            images.forEach(img => {
                if (isLazyCandidate(img)) {
                    observer.observe(processImage(img));
                    lazyCount++;
                }
            });
            debugLog(`已启用${lazyCount}张图片的懒加载`);

            // 动态加载监听
            const mutationObserver = new MutationObserver(mutations => {
                mutations.forEach(mutation => {
                    mutation.addedNodes.forEach(node => {
                        if (node.nodeName === 'IMG' && isLazyCandidate(node)) {
                            observer.observe(processImage(node));
                            debugLog('动态添加的图片已启用懒加载');
                        }
                    });
                });
            });
            
            mutationObserver.observe(document.body, {
                childList: true,
                subtree: true
            });
            
            debugLog('已启动动态图片监听');
            
            // 清理钩子
            window.addEventListener('beforeunload', () => {
                observer.disconnect();
                mutationObserver.disconnect();
                debugLog('懒加载系统已清理');
            });
        } else {
            debugLog('使用兼容模式实现懒加载');
            // 兼容模式实现
            const checkVisible = throttle(() => {
                document.querySelectorAll('img').forEach(img => {
                    if (isLazyCandidate(img) && !img.src) {
                        const rect = img.getBoundingClientRect();
                        if (rect.top < window.innerHeight +
                            parseInt(config.features.lazyLoad.rootMargin)) {
                            if (img.dataset.src) {
                                if (img.dataset.crossOrigin) {
                                    img.crossOrigin = img.dataset.crossOrigin;
                                }
                                img.src = img.dataset.src;
                                debugLog(`兼容模式加载图片: ${img.dataset.src}`);
                            }
                            if (img.dataset.srcset) {
                                img.srcset = img.dataset.srcset;
                                debugLog(`兼容模式加载图片集: ${img.dataset.srcset}`);
                            }
                        }
                    }
                });
            }, 200);
            
            // 添加动态图片监听
            const mutationObserver = new MutationObserver(() => checkVisible());
            mutationObserver.observe(document.body, { 
                childList: true, 
                subtree: true 
            });
            
            window.addEventListener('scroll', checkVisible);
            window.addEventListener('resize', checkVisible);
            checkVisible();
            debugLog('兼容模式懒加载已启动');
        }
    };

    // 智能预连接系统
    const initSmartPreconnect = () => {
        if (!config.features.preconnect.enabled) {
            debugLog('预连接系统已禁用');
            return;
        }

        debugLog('初始化智能预连接系统');
        
        const processed = new Set();
        const whitelist = config.features.preconnect.whitelist;

        const doPreconnect = (hostname) => {
            if (processed.size >= config.features.preconnect.maxConnections) {
                debugWarn(`已达到最大预连接数 (${config.features.preconnect.maxConnections})`);
                return;
            }
            if (processed.has(hostname)) {
                debugLog(`已存在预连接: ${hostname}`);
                return;
            }

            const link = document.createElement('link');
            link.rel = 'preconnect';
            link.href = `//${hostname}`;
            document.head.appendChild(link);
            processed.add(hostname);

            debugLog(`已创建预连接: ${hostname}`);
        };

        const scanResources = () => {
            debugLog('扫描资源进行预连接');
            const resources = [
                ...document.querySelectorAll('script[src], link[href], img[src]')
            ];

            let found = 0;
            resources.forEach(el => {
                try {
                    const url = new URL(el.src || el.href, window.location.href);
                    const hostname = url.hostname;
                    const matched = whitelist.find(domain => 
                        hostname.endsWith(domain)
                    );
                    if (matched) {
                        found++;
                        doPreconnect(hostname);
                    }
                } catch (e) {
                    debugWarn('资源URL解析失败', e);
                }
            });
            debugLog(`扫描完成，发现${found}个可预连接资源`);
        };

        // 三级触发机制
        scanResources();
        setTimeout(scanResources, 2000);
        const mutationObserver = new MutationObserver(() => {
            setTimeout(scanResources, 100);
        });
        
        mutationObserver.observe(document.body, {
            childList: true,
            subtree: true
        });
        
        debugLog('已启动资源变化监听');
    };

    // 资源预加载系统
    const initResourcePreload = () => {
        if (!config.features.preload.enabled) {
            debugLog('资源预加载已禁用');
            return;
        }

        debugLog('初始化资源预加载系统');
        
        const processed = new Set();
        const types = config.features.preload.types;
        const max = config.features.preload.maxPreloads;

        const shouldPreload = (url) => {
            const ext = url.split('.').pop().toLowerCase();
            return types.includes(ext);
        };

        const doPreload = (url, asType) => {
            if (processed.size >= max) {
                debugWarn(`已达到最大预加载数 (${max})`);
                return;
            }
            if (processed.has(url)) {
                debugLog(`资源已预加载: ${url}`);
                return;
            }

            const link = document.createElement('link');
            link.rel = 'preload';
            link.as = asType;
            link.href = url;

            // 跨域资源处理
            try {
                const parsedUrl = new URL(url, window.location.href);
                if (parsedUrl.origin !== window.location.origin) {
                    if (asType === 'font') {
                        link.setAttribute('crossorigin', 'anonymous');
                    } else if (asType === 'script' || asType === 'style') {
                        link.crossOrigin = 'anonymous';
                    }
                    debugLog(`跨域资源处理: ${url}`);
                }
            } catch (e) {
                debugWarn('URL解析失败', e);
            }

            document.head.appendChild(link);
            processed.add(url);

            debugLog(`已预加载资源: ${url} (类型: ${asType})`);
        };

        const processFont = (cssUrl, fontUrl) => {
            try {
                const absoluteUrl = new URL(fontUrl, cssUrl).href;
                if (fontUrl.startsWith('data:')) return;
                if (shouldPreload(absoluteUrl)) {
                    doPreload(absoluteUrl, 'font');
                }
            } catch (e) {
                debugWarn(`字体解析失败: ${fontUrl}`, e);
            }
        };

        const scanResources = () => {
            debugLog('扫描资源进行预加载');
            let preloadCount = 0;
            
            // 处理CSS
            document.querySelectorAll('link[rel="stylesheet"]').forEach(link => {
                const cssUrl = link.href;
                if (cssUrl && shouldPreload(cssUrl)) {
                    preloadCount++;
                    doPreload(cssUrl, 'style');

                    // 解析CSS中的字体
                    if (types.includes('woff2')) {
                        fetch(cssUrl, { mode: 'cors' })
                            .then(res => res.text())
                            .then(text => {
                                const fontUrls = text.match(/url$["']?([^)"']+\.woff2?)["']?$/gi) || [];
                                debugLog(`在CSS中发现${fontUrls.length}个字体资源`);
                                fontUrls.forEach(fullUrl => {
                                    const cleanUrl = fullUrl.replace(/url$["']?|["']?$/g, '');
                                    processFont(cssUrl, cleanUrl);
                                });
                            })
                            .catch(e => {
                                debugWarn(`CSS获取失败: ${cssUrl}`, e);
                            });
                    }
                }
            });

            // 处理JS
            document.querySelectorAll('script[src]').forEach(script => {
                const src = script.src;
                if (src && shouldPreload(src)) {
                    preloadCount++;
                    doPreload(src, 'script');
                }
            });
            
            debugLog(`扫描完成，预加载了${preloadCount}个资源`);
        };

        scanResources();
        const mutationObserver = new MutationObserver(() => {
            setTimeout(scanResources, 100);
        });
        
        mutationObserver.observe(document.body, {
            childList: true,
            subtree: true
        });
        
        debugLog('已启动资源变化监听');
    };

    // 布局稳定性优化
    const initLayoutStabilization = () => {
        debugLog('初始化布局稳定性优化');
        
        const styles = [];

        if (config.features.layout.stableImages) {
            styles.push(`
                img:not([width]):not([height]) {
                    min-height: 1px;
                }
                @supports (aspect-ratio: 1/1) {
                    img:not([width]):not([height]) {
                        aspect-ratio: attr(width) / attr(height);
                    }
                }
            `);
            debugLog('已添加图片布局稳定性规则');
        }

        if (config.features.layout.stableIframes) {
            styles.push(`
                iframe:not([width]):not([height]) {
                    width: 100%;
                    height: auto;
                    aspect-ratio: 16/9;
                }
            `);
            debugLog('已添加iframe布局稳定性规则');
        }

        if (config.features.layout.stableVideos) {
            styles.push(`
                video:not([width]):not([height]) {
                    max-width: 100%;
                    aspect-ratio: 16/9;
                }
            `);
            debugLog('已添加视频布局稳定性规则');
        }

        if (styles.length) {
            const style = document.createElement('style');
            style.textContent = styles.join('\n');
            document.head.appendChild(style);
            debugLog('布局稳定性样式已注入');
        } else {
            debugLog('未添加任何布局稳定性规则');
        }
    };

    // CAPTCHA 保护系统
    const initCaptchaProtection = () => {
        if (!config.features.captcha.enabled) {
            debugLog('验证码保护系统已禁用');
            return;
        }
        
        debugLog('初始化验证码保护系统');
        
        // 常见验证码特征库
        const CAPTCHA_FINGERPRINTS = [
            /recaptcha\/api\.js/i,
            /recaptcha\/enterprise\.js/i,
            /gstatic\.com\/recaptcha/,
            /recaptcha\/anchor\?/,
            /hcaptcha\.com\/1\/api\.js/,
            /hcaptcha\.com\/challenge\.css/,
            /challenges\.cloudflare\.com\/turnstile/,
            /challenges\.cloudflare\.com\/style/,
            /\/captcha\.(js|css)/i,
            /verify\.(png|jpg|gif)\?/i
        ];

        // 检测当前页面是否有验证码
        const hasCaptcha = () => {
            const htmlContent = document.documentElement.innerHTML;
            const scripts = Array.from(document.scripts);
            
            const found = CAPTCHA_FINGERPRINTS.some(pattern => 
                htmlContent.match(pattern) ||
                scripts.some(script => script.src && script.src.match(pattern))
            );
            
            if (found) {
                debugLog('检测到验证码系统');
            } else {
                debugLog('未检测到验证码系统');
            }
            
            return found;
        };

        // 暂停可能干扰验证码的功能
        const disableRiskyFeatures = () => {
            if (config.features.captcha.safeMode) {
                const originalLazyLoad = config.features.lazyLoad.enabled;
                const originalPreload = config.features.preload.enabled;
                
                config.features.lazyLoad.enabled = false;
                config.features.preload.enabled = false;
                
                debugWarn('验证码保护模式激活，已禁用懒加载和预加载');
                
                // 恢复原始状态（在页面卸载时）
                window.addEventListener('beforeunload', () => {
                    config.features.lazyLoad.enabled = originalLazyLoad;
                    config.features.preload.enabled = originalPreload;
                    debugLog('验证码保护模式已解除');
                });
            }
        };

        // 恢复验证码 iframe 的默认样式
        const restoreCaptchaFrames = () => {
            const frames = document.querySelectorAll('iframe');
            let restoredCount = 0;
            
            frames.forEach(frame => {
                if (frame.src && CAPTCHA_FINGERPRINTS.some(p => frame.src.match(p))) {
                    frame.style.aspectRatio = '';
                    frame.style.minHeight = '';
                    frame.classList.add('captcha-protected');
                    restoredCount++;
                }
            });
            
            if (restoredCount > 0) {
                debugLog(`已恢复${restoredCount}个验证码框架的默认样式`);
            }
        };

        if (hasCaptcha()) {
            disableRiskyFeatures();
            restoreCaptchaFrames();
        }
    };

    // 资源回收系统
    const initResourceRecycling = () => {
        if (!config.features.resourceRecycling.enabled) return;

        debugLog('初始化资源回收系统');
        
        let memoryMonitor;
        const resourceMap = new WeakMap();
        const recycleThreshold = config.features.resourceRecycling.memoryThreshold;
        
        // 视频资源回收策略
        const videoRecycling = {
            recycle: (video) => {
                video.dataset.recycledState = JSON.stringify({
                    currentTime: video.currentTime,
                    volume: video.volume,
                    playbackRate: video.playbackRate,
                    paused: video.paused,
                    crossOrigin: video.crossOrigin,
                    credentials: video.getAttribute('crossorigin')
                });
                
                video.pause();
                video.removeAttribute('src');
                video.load();
                
                debugLog(`视频资源已卸载: ${video.id || video.dataset.src || '匿名视频'}`);
            },
            condition: (video) => {
                if (video.dataset.protected === 'true') {
                    debugLog(`视频受保护，跳过回收: ${video.id || video.dataset.src || '匿名视频'}`);
                    return false;
                }
                
                if (config.features.videoRecycling.protectPlaying && !video.paused) {
                    debugLog(`视频正在播放，跳过回收: ${video.id || video.dataset.src || '匿名视频'}`);
                    return false;
                }
                
                if (video.webkitDisplayingFullscreen || 
                    video === document.pictureInPictureElement) {
                    debugLog(`视频全屏/PiP模式，跳过回收: ${video.id || video.dataset.src || '匿名视频'}`);
                    return false;
                }
                
                if (video.dataset.userActivated === 'true') {
                    debugLog(`视频用户激活，跳过回收: ${video.id || video.dataset.src || '匿名视频'}`);
                    return false;
                }
                
                const inViewport = isElementInViewport(video, config.features.resourceRecycling.videoRecycleMargin);
                if (inViewport) {
                    debugLog(`视频在可视区域内，跳过回收: ${video.id || video.dataset.src || '匿名视频'}`);
                    return false;
                }
                
                debugLog(`视频符合回收条件: ${video.id || video.dataset.src || '匿名视频'}`);
                return true;
            },
            restore: (video) => {
                if (video.dataset.src) {
                    video.src = video.dataset.src;
                    video.load();
                    
                    if (video.dataset.recycledState) {
                        const state = JSON.parse(video.dataset.recycledState);
                        video.currentTime = state.currentTime;
                        video.volume = state.volume;
                        video.playbackRate = state.playbackRate;
                        
                        if (state.crossOrigin) {
                            video.crossOrigin = state.crossOrigin;
                        }
                        if (state.credentials) {
                            video.setAttribute('crossorigin', state.credentials);
                        }
                        
                        if (!state.paused) {
                            video.play().catch(e => {
                                debugWarn(`视频自动播放失败: ${e.message}`);
                            });
                        }
                    }
                    
                    delete video.dataset.recycledState;
                    debugLog(`视频资源已恢复: ${video.id || video.src || '匿名视频'}`);
                }
            }
        };

        // 图片资源回收策略
        const imageRecycling = {
            recycle: (img) => {
                if (img.dataset.src && img.src) {
                    img.removeAttribute('src');
                    if (img.dataset.srcset) {
                        img.removeAttribute('srcset');
                    }
                    debugLog(`图片资源已卸载: ${img.dataset.src}`);
                }
            },
            condition: (img) => {
                if (img.classList.contains('captcha-image') || 
                    img.closest('.captcha-container')) {
                    debugLog('验证码图片，跳过回收');
                    return false;
                }
                
                if (img.dataset.skipRecycle === 'true') {
                    debugLog('图片标记为不可回收');
                    return false;
                }
                
                const rect = img.getBoundingClientRect();
                const shouldRecycle = rect.bottom < -config.features.resourceRecycling.scrollRecycleMargin || 
                                     rect.top > window.innerHeight + config.features.resourceRecycling.scrollRecycleMargin;
                
                if (shouldRecycle) {
                    debugLog(`图片符合回收条件: ${img.dataset.src || img.src}`);
                }
                
                return shouldRecycle;
            }
        };

        // 启动内存监控
        const startMemoryMonitor = () => {
            if (window.performance && performance.memory) {
                debugLog('启动内存监控');
                
                memoryMonitor = setInterval(() => {
                    const usedJSHeap = performance.memory.usedJSHeapSize;
                    const totalJSHeap = performance.memory.totalJSHeapSize;
                    
                    if (totalJSHeap > 0) {
                        const usagePercent = (usedJSHeap / totalJSHeap) * 100;
                        
                        if (usagePercent > recycleThreshold) {
                            debugWarn(`内存使用率过高: ${usagePercent.toFixed(1)}% > ${recycleThreshold}%，触发资源回收`);
                            triggerRecycling();
                        }
                    }
                }, config.features.resourceRecycling.monitorInterval);
            } else {
                debugWarn('浏览器不支持performance.memory，内存监控不可用');
            }
        };

        // 触发资源回收
        publicAPI.triggerRecycling = () => {
            if (!recyclingGuard.canRecycle()) {
                return;
            }
            
            debugLog('开始资源回收');
            let recycledCount = 0;
            
            // 图片资源回收
            document.querySelectorAll('img[data-src]').forEach(img => {
                if (imageRecycling.condition(img)) {
                    imageRecycling.recycle(img);
                    recycledCount++;
                }
            });
            
            // 视频资源回收
            if (config.features.videoRecycling.enabled) {
                const videos = Array.from(document.querySelectorAll('video'));
                
                // 按可见性排序（从最不可见到最可见）
                videos.sort((a, b) => {
                    const rectA = a.getBoundingClientRect();
                    const rectB = b.getBoundingClientRect();
                    
                    const distanceA = Math.min(
                        Math.abs(rectA.top - window.innerHeight),
                        Math.abs(rectA.bottom)
                    );
                    
                    const distanceB = Math.min(
                        Math.abs(rectB.top - window.innerHeight),
                        Math.abs(rectB.bottom)
                    );
                    
                    return distanceB - distanceA; // 降序排序
                });
                
                // 回收超出最大限制的视频
                const maxVideos = config.features.resourceRecycling.maxBackgroundVideos;
                for (let i = maxVideos; i < videos.length; i++) {
                    const video = videos[i];
                    if (videoRecycling.condition(video)) {
                        videoRecycling.recycle(video);
                        recycledCount++;
                    }
                }
            }
            
            // 强制垃圾回收
            if (window.gc) {
                window.gc();
                debugLog('已执行强制垃圾回收');
            }
            
            debugLog(`资源回收完成，释放了${recycledCount}个资源`);
        };

        // 集成到懒加载系统
        const patchLazyLoad = () => {
            if (!('IntersectionObserver' in window)) {
                debugLog('浏览器不支持IntersectionObserver，跳过懒加载补丁');
                return;
            }
            
            debugLog('修补懒加载系统以支持资源回收');
            
            const originalObserve = IntersectionObserver.prototype.observe;
            IntersectionObserver.prototype.observe = function(element) {
                resourceMap.set(element, this);
                originalObserve.call(this, element);
            };
            
            IntersectionObserver.prototype.unobserveAndRecycle = function(element) {
                if (imageRecycling.condition(element)) {
                    imageRecycling.recycle(element);
                }
                this.unobserve(element);
            };
        };

        // 视频恢复系统
        const initVideoRestoration = () => {
            if (!config.features.videoRecycling.restoreOnScroll) {
                debugLog('滚动恢复视频功能已禁用');
                return;
            }
            
            debugLog('初始化视频滚动恢复系统');
            
            const videoObserver = new IntersectionObserver((entries) => {
                entries.forEach(entry => {
                    if (entry.isIntersecting) {
                        const video = entry.target;
                        if (video.dataset.recycledState) {
                            videoRecycling.restore(video);
                            videoObserver.unobserve(video);
                        }
                    }
                });
            }, { rootMargin: '200px' });

            const videos = document.querySelectorAll('video[data-recycled-state]');
            videos.forEach(video => {
                videoObserver.observe(video);
            });
            
            debugLog(`已监控${videos.length}个回收的视频`);
        };

        // 关键视频保护
        const protectKeyVideos = () => {
            const players = document.querySelectorAll('.video-player, .player-container');
            let protectedCount = 0;
            
            players.forEach(container => {
                const video = container.querySelector('video');
                if (video) {
                    video.dataset.protected = 'true';
                    protectedCount++;
                }
            });
            
            document.addEventListener('play', (e) => {
                if (e.target.tagName === 'VIDEO') {
                    e.target.dataset.userActivated = 'true';
                    debugLog(`视频用户激活: ${e.target.id || e.target.src || '匿名视频'}`);
                }
            }, true);
            
            debugLog(`已保护${protectedCount}个关键视频播放器`);
        };

        // 初始化
        startMemoryMonitor();
        patchLazyLoad();
        initVideoRestoration();
        protectKeyVideos();
        
        // 清理钩子
        window.addEventListener('beforeunload', () => {
            if (memoryMonitor) clearInterval(memoryMonitor);
            debugLog('资源回收系统已清理');
        });
    };

    // ========================
    // 网络感知配置应用
    // ========================
    const applyNetworkAwareConfig = () => {
        if (!config.networkAware.enabled) {
            debugLog('网络感知配置已禁用');
            return;
        }
        
        if (!navigator.connection) {
            debugWarn('浏览器不支持网络连接API');
            return;
        }
        
        debugLog('应用网络感知配置');
        
        const connection = navigator.connection;
        const effectiveType = connection.effectiveType;
        const connectionConfig = config.networkAware.connectionTypes[effectiveType];
        
        if (connectionConfig) {
            if (connectionConfig.preload !== undefined) {
                const original = config.features.preload.enabled;
                config.features.preload.enabled = connectionConfig.preload;
                debugLog(`网络类型 ${effectiveType}: 预加载 ${original} -> ${connectionConfig.preload}`);
            }
            
            if (connectionConfig.lazyMargin) {
                const original = config.features.lazyLoad.rootMargin;
                config.features.lazyLoad.rootMargin = connectionConfig.lazyMargin;
                debugLog(`网络类型 ${effectiveType}: 懒加载边距 ${original} -> ${connectionConfig.lazyMargin}`);
            }
            
            if (connectionConfig.maxPreloads) {
                const original = config.features.preload.maxPreloads;
                config.features.preload.maxPreloads = connectionConfig.maxPreloads;
                debugLog(`网络类型 ${effectiveType}: 最大预加载数 ${original} -> ${connectionConfig.maxPreloads}`);
            }
        }
        
        // 节省数据模式
        if (connection.saveData) {
            const preloadOriginal = config.features.preload.enabled;
            const preconnectOriginal = config.features.preconnect.enabled;
            
            config.features.preload.enabled = false;
            config.features.preconnect.enabled = false;
            
            debugLog(`节省数据模式激活: 预加载 ${preloadOriginal} -> false, 预连接 ${preconnectOriginal} -> false`);
        }
    };

    // ========================
    // 错误处理
    // ========================
    const initErrorHandling = () => {
        debugLog('初始化错误处理系统');
        
        // 全局错误捕获
        window.addEventListener('error', (event) => {
            if (event.message && event.message.includes('cross-origin')) {
                debugWarn(`跨域资源加载错误: ${event.message}`, event.filename);
                
                // 尝试修复常见CORS问题
                if (event.target && event.target.tagName === 'IMG') {
                    event.target.crossOrigin = 'anonymous';
                    event.target.src = event.target.src + '?retry=' + Date.now();
                    debugLog(`尝试修复CORS问题: ${event.target.src}`);
                }
            }
        }, true);
        
        // 脚本执行错误
        window.addEventListener('error', (event) => {
            debugError(`脚本执行错误: ${event.message}`, event.filename, event.lineno);
        });
        
        // Promise未捕获错误
        window.addEventListener('unhandledrejection', (event) => {
            debugError(`未处理的Promise拒绝: ${event.reason}`);
        });
    };

    // ========================
    // CSP兼容性检测
    // ========================
    const checkCSPCompatibility = () => {
        debugLog('检测CSP兼容性');
        
        try {
            const testScript = document.createElement('script');
            testScript.textContent = 'window._cspTest = true;';
            document.head.appendChild(testScript);
            const isRestricted = !window._cspTest;
            delete window._cspTest;
            
            if (isRestricted) {
                debugWarn('页面有严格的CSP策略，禁用部分优化');
            }
            
            return isRestricted;
        } catch (e) {
            debugWarn('CSP检测失败', e);
            return true;
        }
    };

    // ========================
    // 中国平台后处理
    // ========================
    const applyChinaPlatformPostProcessing = () => {
        const platform = isChinaPlatform();
        if (!platform) return;
        
        debugLog(`执行中国平台后处理: ${platform}`);
        
        // 平台特定后处理
        switch(platform) {
            case 'taobao':
                // 轮播图优化
                const gallery = document.querySelector('.J_TModule');
                if (gallery) {
                    gallery.dataset.optimizeLayout = 'true';
                    debugLog('淘宝轮播图优化已应用');
                }
                break;
                
            case 'jd':
                // 预加载核心资源
                const jdLogo = '//img11.360buyimg.com/jdphoto/jfs/t1/123246/36/2096/17041/5ec2a9c6E0d7a4ff0/6d1e8d1e3e5b3b7f.png';
                if (!document.querySelector(`link[href="${jdLogo}"]`)) {
                    const link = document.createElement('link');
                    link.rel = 'preload';
                    link.href = jdLogo;
                    link.as = 'image';
                    document.head.appendChild(link);
                    debugLog('京东Logo已预加载');
                }
                break;
                
            case 'douyin':
                // 短视频列表优化
                const videoList = document.querySelector('.video-list');
                if (videoList) {
                    videoList.dataset.optimizeLayout = 'true';
                    debugLog('抖音视频列表优化已应用');
                }
                break;
                
            case 'bilibili':
                // 弹幕优化
                const danmu = document.querySelector('.bpx-player-dm-wrap');
                if (danmu) {
                    danmu.dataset.optimizeLayout = 'true';
                    debugLog('哔哩哔哩弹幕优化已应用');
                }
                break;
                
            case 'kuaishou':
                // 直播流优化
                const liveStream = document.querySelector('.live-player');
                if (liveStream) {
                    liveStream.dataset.optimizeLayout = 'true';
                    debugLog('快手直播流优化已应用');
                }
                break;
                
            case 'tencent':
                // 腾讯视频广告优化
                const adContainer = document.querySelector('.txp_ad');
                if (adContainer) {
                    adContainer.dataset.optimizeLayout = 'true';
                    debugLog('腾讯视频广告优化已应用');
                }
                break;
        }
    };

    // ========================
    // 初始化系统
    // ========================
    document.addEventListener('DOMContentLoaded', () => {
        // 调试日志初始化
        if (config.debug) {
            console.log('[Optimizer] 脚本初始化开始');
        }
        
        debugLog('DOMContentLoaded - 开始初始化');
        
        // 1. 错误处理
        initErrorHandling();
        
        // 2. 中国平台优化（最先执行）
        if (config.chinaPlatforms.enabled) {
            applyChinaPlatformOptimizations();
        }
        
        // 3. 网络感知配置
        applyNetworkAwareConfig();
        
        // 4. CSP检测
        const isStrictCSP = checkCSPCompatibility();
        
        // 5. 验证码保护
        initCaptchaProtection();
        
        // 6. 主优化模块
        if (!isStrictCSP) {
            initSmartPreconnect();
            initResourcePreload();
        }
        
        // 7. 其他优化
        initLazyLoad();
        initLayoutStabilization();
        
        // 8. 资源回收系统
        if (config.features.resourceRecycling.enabled) {
            initResourceRecycling();
        }
        
        // 9. 中国平台后处理
        if (config.chinaPlatforms.enabled && isChinaPlatform()) {
            setTimeout(applyChinaPlatformPostProcessing, 2000);
        }
        
        // 10. 添加控制台调试命令
        if (config.debug) {
            console.log('[Optimizer] 脚本初始化完成');
            console.log('控制台命令: optimizerStatus(), checkChinaPlatform(), disableOptimizer(), forceRecycle()');
        }    });
    
    // ========================
    // 控制台调试命令
    // ========================
    const addConsoleCommands = () => {
        debugLog('添加控制台调试命令');
        
        // 优化状态查看
        window.optimizerStatus = () => {
            const status = {
                lazyLoad: {
                    enabled: config.features.lazyLoad.enabled,
                    images: document.querySelectorAll('img[data-src]').length
                },
                preconnect: {
                    enabled: config.features.preconnect.enabled,
                    connections: document.querySelectorAll('link[rel="preconnect"]').length
                },
                preload: {
                    enabled: config.features.preload.enabled,
                    resources: document.querySelectorAll('link[rel="preload"]').length
                },
                resourceRecycling: {
                    enabled: config.features.resourceRecycling.enabled,
                    recycled: document.querySelectorAll('img[data-src]:not([src]), video[data-recycled-state]').length
                },
                chinaPlatform: isChinaPlatform() || '未检测到'
            };
            
            console.groupCollapsed('[Optimizer] 当前状态');
            console.table(status);
            console.groupEnd();
            return status;
        };
        
        // 中国平台检测
        window.checkChinaPlatform = () => {
            const platform = isChinaPlatform();
            if (platform) {
                console.log(`检测到中国平台: ${platform}`);
            } else {
                console.log('未检测到支持的中国平台');
            }
            return platform;
        };
        
        // 临时禁用优化器
        window.disableOptimizer = () => {
            Object.keys(config.features).forEach(key => {
                config.features[key].enabled = false;
            });
            console.warn('优化器已临时禁用，刷新页面后恢复');
        };
        
        // 强制资源回收
        window.forceRecycle = () => {
            if (config.features.resourceRecycling.enabled) {
                triggerRecycling();
            } else {
                console.warn('资源回收功能未启用');
            }
        };
        
        console.log('可用命令: optimizerStatus(), checkChinaPlatform(), disableOptimizer(), forceRecycle()');
    };
    
    // 添加调试错误函数
    const debugError = (...args) => {
        if (config.debug) {
            console.error('[Optimizer]', ...args);
        }
    };
})();