// 初始化管理器 - 统一管理所有模块的初始化
class InitManager {
    constructor() {
        this.initSteps = [];
        this.isInitialized = false;
    }

    // 添加初始化步骤
    addInitStep(name, initFunction, dependencies = []) {
        this.initSteps.push({
            name,
            initFunction,
            dependencies,
            completed: false
        });
    }

    // 执行所有初始化步骤
    async initialize() {
        if (this.isInitialized) {
            console.warn('初始化管理器已经执行过，跳过重复初始化');
            return;
        }

        console.log('开始执行初始化步骤...');
        const startTime = performance.now();

        // 按照依赖关系排序步骤
        const sortedSteps = this.sortStepsByDependencies();

        // 逐步执行初始化步骤
        for (const step of sortedSteps) {
            try {
                console.log(`执行初始化步骤: ${step.name}`);
                await step.initFunction();
                step.completed = true;
                console.log(`初始化步骤完成: ${step.name}`);
            } catch (error) {
                console.error(`初始化步骤失败: ${step.name}`, error);
                throw error;
            }
        }

        this.isInitialized = true;
        const duration = performance.now() - startTime;
        console.log(`所有初始化步骤完成，耗时: ${duration.toFixed(2)}ms`);
    }

    // 根据依赖关系排序步骤
    sortStepsByDependencies() {
        const sorted = [];
        const visited = new Set();

        const visit = (step) => {
            if (visited.has(step.name)) return;
            visited.add(step.name);

            // 先遍历依赖
            for (const depName of step.dependencies) {
                const dep = this.initSteps.find(s => s.name === depName);
                if (dep && !dep.completed) {
                    visit(dep);
                }
            }

            // 添加到排序结果
            if (!sorted.find(s => s.name === step.name)) {
                sorted.push(step);
            }
        };

        // 遍历所有步骤
        for (const step of this.initSteps) {
            if (!step.completed) {
                visit(step);
            }
        }

        return sorted;
    }
}

// 全局初始化管理器实例
const initManager = new InitManager();

// 添加初始化步骤
initManager.addInitStep('configManager', () => {
    console.log('配置管理器已通过外部JS加载');
}, []);

initManager.addInitStep('helpers', () => {
    console.log('辅助函数已通过外部JS加载');
}, []);

initManager.addInitStep('accessLogger', () => {
    window.accessLogger = new AccessLogger();
    console.log('访问日志系统初始化完成');
}, []);

// brightnessDetector 已移除，所有背景都使用亮色背景模式

initManager.addInitStep('soundEffectManager', () => {
    initializeSoundEffects();
    console.log('音效管理器初始化完成');
}, []);

initManager.addInitStep('cialloEffectManager', () => {
    window.cialloEffectManager = new CialloEffectManager();
    console.log('Ciallo特效管理器初始化完成');
}, []);

initManager.addInitStep('backgroundManager', async () => {
    // 初始化背景管理器
    window.backgroundManager = new BackgroundManager();
    console.log('背景管理器实例已创建');

    // 检查当前背景类型
    const backgroundType = localStorage.getItem('backgroundType') || 'image';
    console.log('当前背景类型:', backgroundType);

    if (backgroundType === 'image') {
        // 图片模式：加载背景图片
        console.log('图片模式，加载背景图片...');
        
        // 等待背景管理器初始化完成（加载背景列表）
        await new Promise(resolve => {
            const checkInterval = setInterval(() => {
                if (window.backgroundManager.backgrounds && window.backgroundManager.backgrounds.length > 0) {
                    clearInterval(checkInterval);
                    resolve();
                }
            }, 100);
        });
        console.log('背景管理器初始化完成，背景列表已加载');

        // 恢复保存的背景
        const savedBg = localStorage.getItem('currentBg');
        if (savedBg) {
            console.log('恢复用户保存的背景:', savedBg);
            
            // 在背景列表中查找对应的背景实例
            // 需要同时检查file和webp属性，因为savedBg可能是webp文件名
            const bg = window.backgroundManager.backgrounds.find(b => 
                b.file === savedBg || (b.webp && b.webp === savedBg)
            );
            if (bg) {
                // 优先使用WebP格式
                const actualBgFile = bg.webp || bg.file;
                console.log('使用背景文件:', actualBgFile);

                // 获取背景URL，使用当前域名
                const bgUrl = `${window.location.origin}/resource/backgrounds/${actualBgFile}`;
                
                // 立即设置CSS变量，不等待图片加载
                document.body.style.setProperty('--bg-image', `url(${bgUrl})`);
                document.body.classList.remove('bg-fade');
                void document.body.offsetWidth;
                document.body.classList.add('bg-fade');
                
                // 应用亮色背景模式（背景是亮的，文字是暗的）
                document.body.classList.add('light-bg');
                document.body.classList.remove('dark-bg');

                // 确保标题是暗色的（但不要太暗）并添加发光效果
                const headerTitle = document.querySelector('header h1');
                if (headerTitle) {
                    headerTitle.classList.add('light-bg-glow');
                    headerTitle.classList.remove('dark-bg');
                }

                // 预加载图片，但不阻塞UI
                const img = new Image();
                img.onload = () => {
                    console.log('背景图片预加载完成:', actualBgFile);
                };
                img.onerror = () => {
                    console.warn('保存的背景文件可能不存在:', savedBg);
                    // 如果图片加载失败，设置随机背景
                    if (window.backgroundManager) {
                        window.backgroundManager.setRandomBackground();
                    }
                };
                img.src = bgUrl;
                
                lastBackground = savedBg;
                console.log('背景恢复成功:', savedBg);
            } else {
                console.warn('保存的背景不在背景列表中:', savedBg);
                localStorage.removeItem('currentBg');
                if (window.backgroundManager) {
                    window.backgroundManager.setRandomBackground();
                }
            }
        } else {
            console.log('没有保存的背景，设置随机背景');
            if (window.backgroundManager) {
                window.backgroundManager.setRandomBackground();
            }
        }
    } else {
        // 颜色模式：不加载背景图片
        console.log('颜色模式，跳过背景图片加载');
        
        // 应用颜色背景模式
        const themeMode = localStorage.getItem('themeMode') || 'light';
        const selectedColor = localStorage.getItem('selectedColor') || 
                             (themeMode === 'light' ? '#f5f5f5' : '#1a1a1a');
        
        document.body.style.setProperty('--bg-image', 'none');
        document.body.style.backgroundColor = selectedColor;
        
        // 根据主题模式设置文字颜色
        if (themeMode === 'light') {
            document.body.classList.add('light-bg');
            document.body.classList.remove('dark-bg');

            // 设置标题为暗色
            const headerTitle = document.querySelector('header h1');
            if (headerTitle) {
                headerTitle.classList.add('light-bg');
                headerTitle.classList.remove('dark-bg');
                headerTitle.classList.add('light-bg-glow');
            }
        } else {
            document.body.classList.add('dark-bg');
            document.body.classList.remove('light-bg');

            // 设置标题为亮色
            const headerTitle = document.querySelector('header h1');
            if (headerTitle) {
                headerTitle.classList.add('dark-bg');
                headerTitle.classList.remove('light-bg');
                headerTitle.classList.remove('light-bg-glow');
            }
        }
        
        console.log('颜色背景已应用:', selectedColor);
    }
    
    initMouseFollowBackground();
    console.log('背景管理器初始化完成');
}, []);

// 添加背景缓存管理器初始化步骤
initManager.addInitStep('backgroundCacheManager', async () => {
    // 初始化背景缓存管理器
    window.backgroundCacheManager = new BackgroundCacheManager();

    // 添加全局缓存函数
    window.cacheAllBackgrounds = async function() {
        if (!window.backgroundCacheManager) {
            console.error('背景缓存管理器未初始化');
            return;
        }

        // 显示进度条
        const progressContainer = document.getElementById('bgCacheProgressContainer');
        const progressText = document.getElementById('bgCacheProgressText');
        if (progressContainer) progressContainer.style.display = 'block';
        if (progressText) progressText.style.display = 'block';

        // 禁用缓存按钮
        const cacheBtn = document.getElementById('cacheAllBtn');
        if (cacheBtn) cacheBtn.disabled = true;

        // 开始缓存
        await window.backgroundCacheManager.cacheAllBackgrounds();

        // 缓存完成后隐藏进度条
        setTimeout(() => {
            if (progressContainer) progressContainer.style.display = 'none';
            if (progressText) progressText.style.display = 'none';

            // 重新启用缓存按钮
            if (cacheBtn) cacheBtn.disabled = false;
        }, 1000);
    };

    window.clearAllCache = async function() {
        if (!window.backgroundCacheManager) {
            console.error('背景缓存管理器未初始化');
            return;
        }

        // 确认操作
        if (confirm('确定要清除所有背景缓存吗？')) {
            const success = await window.backgroundCacheManager.clearAllCache();

            if (success) {
                // 显示成功提示
                const cacheStatusEl = document.getElementById('bgCacheStatus');
                if (cacheStatusEl) {
                    cacheStatusEl.textContent = '已清除';
                    cacheStatusEl.className = 'bg-cache-status cache-status-idle';

                    // 2秒后恢复隐藏状态
                    setTimeout(() => {
                        window.backgroundCacheManager.updateCacheStatusUI();
                    }, 2000);
                }
            }
        }
    };

    // 确保全局函数可用
    if (typeof verifyBackgroundCache === 'function' && typeof clearBackgroundCache === 'function') {
        console.log('背景缓存验证和清除全局函数已可用');
    } else {
        console.warn('背景缓存验证和清除全局函数不可用');
    }
    
    console.log('背景缓存管理器初始化完成');
}, ['backgroundManager']);

initManager.addInitStep('loadVideoData', async () => {
    // 检查loadVideoData函数是否存在
    if (typeof loadVideoData === 'function') {
        await loadVideoData();
        console.log('视频数据加载完成');
    } else {
        console.warn('loadVideoData函数未定义，跳过视频数据加载');
    }
}, []);

// 页面加载完成后执行初始化
document.addEventListener('DOMContentLoaded', async () => {
    try {
        await initManager.initialize();

        // 执行其他需要在页面加载后执行的代码
        console.log('页面初始化完成，开始执行后续操作...');

        // 初始化设置面板
        if (typeof initializeSettingsPanel === 'function') {
            initializeSettingsPanel();
        } else {
            console.warn('initializeSettingsPanel函数未定义，跳过设置面板初始化');
        }

        // 延迟初始化主题设置，确保ThemeSettings类已加载
        setTimeout(() => {
            if (typeof ThemeSettings !== 'undefined') {
                window.themeSettings = new ThemeSettings();
                window.themeSettings.initialize();
                console.log('主题设置模块已初始化');
            } else {
                console.warn('ThemeSettings类未定义，跳过主题设置初始化');
            }
        }, 500);

        // 初始化公告
        if (typeof initializeAnnouncements === 'function') {
            initializeAnnouncements();
        } else {
            console.warn('initializeAnnouncements函数未定义，跳过公告初始化');
        }

        // 恢复用户选择的模式
        const savedMode = localStorage.getItem('videoMode') || 'tag';
        if (typeof switchMode === 'function') {
            switchMode(savedMode);
        } else {
            console.warn('switchMode函数未定义，跳过模式切换');
        }

        // 初始化搜索功能
        if (typeof initializeSearch === 'function') {
            initializeSearch();
        } else {
            console.warn('initializeSearch函数未定义，跳过搜索功能初始化');
        }

        // 确保全局缓存函数可用
        if (window.backgroundCacheManager) {
            console.log('背景缓存管理器已初始化，可以使用 verifyBackgroundCache() 和 clearBackgroundCache() 函数');
        } else {
            console.warn('背景缓存管理器未初始化，缓存功能可能不可用');
        }
        
        console.log('应用初始化完成');
    } catch (error) {
        console.error('应用初始化失败', error);

        // 显示错误信息
        const errorDiv = document.createElement('div');
        errorDiv.style.cssText = `
            position: fixed;
            top: 20px;
            left: 50%;
            transform: translateX(-50%);
            background: rgba(220, 53, 69, 0.9);
            color: white;
            padding: 15px 25px;
            border-radius: 8px;
            z-index: 10000;
            max-width: 80%;
            text-align: center;
            box-shadow: 0 4px 12px rgba(0, 0, 0, 0.3);
        `;
        errorDiv.innerHTML = `
            <h3>应用初始化失败</h3>
            <p>错误信息: ${error.message}</p>
            <button onclick="location.reload()" style="
                margin-top: 10px;
                padding: 8px 16px;
                background: white;
                color: #dc3545;
                border: none;
                border-radius: 4px;
                cursor: pointer;
            ">重新加载</button>
        `;

        document.body.appendChild(errorDiv);

        // 5秒后自动移除错误信息
        setTimeout(() => {
            if (errorDiv.parentNode) {
                errorDiv.parentNode.removeChild(errorDiv);
            }
        }, 5000);
    }
});