// 初始化管理器 - 统一管理所有模块的初始化
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('背景管理器对象已创建');

    // 等待背景管理器初始化完成
    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);
        
        // 直接获取背景URL，使用当前域名
        const bgUrl = `${window.location.origin}/background/${savedBg}?t=${Date.now()}`;
        
        const img = new Image();
        img.onload = async () => {
            document.body.style.setProperty('--bg-image', `url(${img.src})`);
            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');
            }

            // 亮背景样式已应用
            
            lastBackground = savedBg;
            console.log('背景恢复成功:', savedBg);
        };
        img.onerror = () => {
            console.warn('保存的背景文件不存在:', savedBg);
            localStorage.removeItem('currentBg');
            if (window.backgroundManager) {
                window.backgroundManager.setRandomBackground();
            }
        };
        img.src = bgUrl;
    } else {
        console.log('没有保存的背景，设置随机背景');
        if (window.backgroundManager) {
            window.backgroundManager.setRandomBackground();
        }
    }
    
    initMouseFollowBackground();
    console.log('背景管理器初始化完成');
}, ['brightnessDetector']);

// 添加背景缓存管理器初始化步骤
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函数未定义，跳过设置面板初始化');
        }

        // 初始化公告
        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);
    }
});
