/**
 * 语言管理器 - 处理网站的中英文切换和翻译
 * @class LanguageManager
 * @description 管理网站的翻译数据加载、缓存、更新和应用
 */
class LanguageManager {
    constructor() {
        // 先从localStorage获取保存的语言设置，避免闪烁
        const savedLang = localStorage.getItem('language');
        this.currentLang = savedLang && (savedLang === 'zh' || savedLang === 'en') ? savedLang : 'zh';
        this.translations = {};
        this.isLoaded = false;
        // 设置html根元素的lang属性
        document.documentElement.lang = this.currentLang;
        // 添加防抖定时器
        this.translateDebounceTimer = null;
        // 翻译数据版本控制
        this.version = localStorage.getItem('translationsVersion') || '0';
        // 缓存过期时间（10分钟）
        this.cacheExpiration = 10 * 60 * 1000;
        // 初始化
        this.init();
    }

    /**
     * 初始化语言管理器
     * @async
     * @description 加载翻译数据，初始化页面翻译，更新语言切换按钮，设置定期同步
     */
    async init() {
        // 加载翻译数据
        await this.loadTranslations();

        // 更新语言切换按钮文本
        this.updateLanguageButtons();

        // 页面初始化完成后，自动翻译页面
        this.translatePage();

        // 标记为已加载
        this.isLoaded = true;

        // 初始化定期同步功能
        this.initPeriodicSync();
    }

    async loadTranslations() {
        try {
            // 1. 检查缓存是否有效
            const cachedTranslations = localStorage.getItem('cachedTranslations');
            let isCacheValid = false;
            let cachedData = null;
            
            if (cachedTranslations) {
                try {
                    cachedData = JSON.parse(cachedTranslations);
                    
                    // 检查缓存是否包含必要字段
                    if (cachedData.data && cachedData.timestamp) {
                        // 检查缓存是否过期
                        const now = Date.now();
                        const cacheAge = now - cachedData.timestamp;
                        
                        if (cacheAge < this.cacheExpiration) {
                            isCacheValid = true;
                            console.log('使用有效缓存，缓存年龄:', Math.floor(cacheAge / 1000), '秒');
                            
                            // 使用缓存数据
                            this.translations = cachedData.data;
                            
                            // 更新版本号
                            if (cachedData.version) {
                                this.version = cachedData.version;
                            }
                        } else {
                            console.log('缓存已过期，缓存年龄:', Math.floor(cacheAge / 1000), '秒');
                        }
                    }
                } catch (cacheError) {
                    console.error('解析缓存数据失败:', cacheError);
                    // 缓存数据损坏，清除缓存
                    localStorage.removeItem('cachedTranslations');
                }
            }
            
            // 2. 异步从API获取最新翻译数据，无论缓存是否有效
            console.log('开始获取最新翻译数据...');
            await this.fetchLatestTranslations();
            
            // 3. 如果API请求失败或没有返回数据，且缓存无效，从texts.json加载
            if (Object.keys(this.translations).length === 0) {
                if (!isCacheValid) {
                    // 如果没有缓存数据或缓存无效，从texts.json文件加载作为备选
                    await this.loadFallbackTranslations();
                }
            }
        } catch (error) {
            console.error('Error loading translations:', error);
            
            // 从texts.json文件加载作为备选
            await this.loadFallbackTranslations();
        }
    }
    
    // 异步获取最新的翻译数据
    async fetchLatestTranslations() {
        try {
            // 尝试从配置API加载最新的文本数据，传递当前语言和版本参数
            // 添加时间戳参数，避免浏览器缓存
            const timestamp = new Date().getTime();
            const configResponse = await fetch(`/api/config?lang=${this.currentLang}&version=${this.version}&t=${timestamp}`, {
                headers: {
                    'Cache-Control': 'no-cache, no-store, must-revalidate',
                    'Pragma': 'no-cache',
                    'Expires': '0'
                }
            });
            
            if (configResponse.ok) {
                const configData = await configResponse.json();
                if (configData.success && configData.config) {
                    // 检查版本号，如果版本号没有变化，不需要更新
                    if (configData.version && configData.version === this.version) {
                        console.log('翻译数据版本未变化，当前版本:', this.version);
                        return;
                    }
                    
                    // 1. 从API获取最新的文本数据
                    const apiTextData = configData.config.texts || {};
                    
                    // 2. 应用XSS过滤
                    const filteredApiData = this.filterXSS(apiTextData);
                    
                    // 3. 构建翻译对象，只包含当前语言的数据
                    const fullTranslations = {
                        [this.currentLang]: filteredApiData
                    };
                    
                    // 4. 更新翻译数据并应用到页面
                    this.updateTranslations(fullTranslations, configData.version);
                }
            }
        } catch (error) {
            console.error('Error fetching latest translations:', error);
        }
    }
    
    // 更新翻译数据并应用到页面
    updateTranslations(newTranslations, version) {
        // 检查翻译数据是否有变化
        const oldTranslations = JSON.stringify(this.translations);
        const newTranslationsStr = JSON.stringify(newTranslations);
        
        if (oldTranslations !== newTranslationsStr) {
            this.translations = newTranslations;
            
            // 缓存翻译数据到localStorage，提升下次加载性能
            // 添加缓存时间和版本信息
            const cacheData = {
                data: newTranslations,
                version: version || Date.now(), // 使用API返回的版本号或当前时间戳
                timestamp: Date.now()
            };
            localStorage.setItem('cachedTranslations', JSON.stringify(cacheData));
            
            // 更新版本号
            if (version) {
                this.version = version;
                localStorage.setItem('translationsVersion', version);
            }
            
            // 更新语言切换按钮
            this.updateLanguageButtons();
            
            // 翻译数据更新后，重新翻译页面
            this.translatePage();
            
            console.log('翻译数据已更新，当前语言:', this.currentLang, '版本:', this.version);
        }
    }
    
    // XSS过滤方法，防止恶意翻译数据攻击
    filterXSS(data) {
        if (!data || typeof data !== 'object') {
            return data;
        }
        
        if (Array.isArray(data)) {
            return data.map(item => this.filterXSS(item));
        }
        
        const filteredData = {};
        for (const key in data) {
            if (Object.prototype.hasOwnProperty.call(data, key)) {
                let value = data[key];
                
                if (typeof value === 'string') {
                    // 移除HTML标签，防止XSS攻击
                    value = value.replace(/<[^>]*>/g, '');
                    // 转义特殊字符
                    value = value
                        .replace(/&/g, '&amp;')
                        .replace(/</g, '&lt;')
                        .replace(/>/g, '&gt;')
                        .replace(/"/g, '&quot;')
                        .replace(/'/g, '&#039;');
                } else if (typeof value === 'object') {
                    // 递归过滤嵌套对象
                    value = this.filterXSS(value);
                }
                
                filteredData[key] = value;
            }
        }
        
        return filteredData;
    }
    
    // 加载备选翻译数据
    async loadFallbackTranslations() {
        try {
            // 从后台获取翻译数据
            console.log('尝试从后台获取所有页面文本信息...');
            
            // 发送请求到配置API端点，获取最新的文本数据
            const timestamp = new Date().getTime();
            const configResponse = await fetch(`/api/config?lang=${this.currentLang}&t=${timestamp}`, {
                headers: {
                    'Cache-Control': 'no-cache, no-store, must-revalidate',
                    'Pragma': 'no-cache',
                    'Expires': '0'
                }
            });
            
            if (configResponse.ok) {
                const configData = await configResponse.json();
                if (configData.success && configData.config) {
                    console.log('从后台获取配置数据成功');
                    
                    // 从配置数据中获取文本信息
                    const texts = configData.config.texts || {};
                    
                    // 应用XSS过滤
                    const filteredTexts = this.filterXSS(texts);
                    
                    // 更新翻译数据
                    this.updateTranslations({ [this.currentLang]: filteredTexts });
                } else {
                    // 使用空翻译数据
                    this.updateTranslations({ [this.currentLang]: {} });
                }
            } else {
                console.error('Failed to load config data:', configResponse.status);
                // 使用空翻译数据
                this.updateTranslations({ [this.currentLang]: {} });
            }
        } catch (error) {
            console.error('Error loading fallback translations:', error);
            // 使用默认的空翻译数据
            this.updateTranslations({ [this.currentLang]: {} });
        }
    }
    
    // 从当前页面提取中文文本
    extractChineseTexts() {
        const zhTexts = {};
        
        try {
            // 获取所有带有data-lang-key属性的元素
            const langElements = document.querySelectorAll('[data-lang-key]');
            console.log(`从页面提取中文文本，共 ${langElements.length} 个元素`);
            
            langElements.forEach(element => {
                const key = element.getAttribute('data-lang-key');
                if (!key) return;
                
                // 获取元素的文本内容
                let text;
                if (element.tagName === 'INPUT' || element.tagName === 'TEXTAREA') {
                    text = element.placeholder || '';
                } else {
                    // 只使用textContent，避免获取HTML或JavaScript代码
                    text = element.textContent.trim();
                }
                
                // 跳过空文本和只包含空白字符的文本
                if (!text || /^\s*$/.test(text)) {
                    return;
                }
                
                // 检查文本是否包含中文
                if (text && /[\u4e00-\u9fa5]/.test(text)) {
                    zhTexts[key] = text;
                    console.log(`提取到: ${key} = ${text}`);
                }
            });
        } catch (error) {
            console.error('提取中文文本失败:', error);
        }
        
        return zhTexts;
    }

    // 将提取的中文文本同步到后端
    async syncTranslations() {
        try {
            // 提取当前页面的中文文本
            const zhTexts = this.extractChineseTexts();
            
            if (Object.keys(zhTexts).length === 0) {
                console.log('没有提取到中文文本，跳过同步');
                return;
            }
            
            console.log('开始同步中文文本到后端...');
            
            // 发送请求到后端同步翻译数据
            const response = await fetch('/api/sync-translations', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify({ zhTexts })
            });
            
            if (response.ok) {
                const result = await response.json();
                console.log('翻译数据同步成功:', result.message);
                console.log(`更新了 ${result.data.updatedZhKeys} 个中文文本键`);
                console.log(`总共有 ${result.data.totalZhKeys} 个中文文本键`);
                console.log(`已翻译 ${result.data.totalEnKeys} 个英文文本键`);
            } else {
                console.error('同步翻译数据失败:', response.statusText);
            }
        } catch (error) {
            console.error('同步翻译数据时发生错误:', error);
        }
    }

    // 初始化定期同步功能
    initPeriodicSync() {
        // 设置同步间隔（1小时 = 3600000毫秒）
        const syncInterval = 3600000;
        
        console.log(`设置定期同步，间隔 ${syncInterval / 60000} 分钟`);
        
        // 立即执行一次同步
        this.syncTranslations();
        
        // 设置定时器，定期执行同步
        setInterval(() => {
            console.log('执行定期同步...');
            this.syncTranslations();
        }, syncInterval);
    }

    // 切换语言
    async changeLanguage(lang) {
        if (lang !== 'zh' && lang !== 'en') {
            return;
        }

        // 添加调试信息
        console.log('开始切换语言，当前语言:', this.currentLang, '，目标语言:', lang);
        
        this.currentLang = lang;
        localStorage.setItem('language', lang);
        document.documentElement.lang = lang;

        // 同步语言设置到后端
        this.syncLanguageToBackend();

        // 重新加载翻译数据，确保使用最新的语言数据
        await this.loadTranslations();

        // 更新语言切换按钮文本
        this.updateLanguageButtons();

        // 关闭移动端菜单（如果打开的话）
        const mobileMenu = document.getElementById('mobile-menu');
        if (mobileMenu && !mobileMenu.classList.contains('hidden')) {
            mobileMenu.classList.add('hidden');
            mobileMenu.style.opacity = '0';
            mobileMenu.style.transform = 'translateY(-10px)';
        }

        // 关闭移动端产品下拉菜单（如果打开的话）
        const mobileProductsDropdown = document.getElementById('mobile-products-dropdown');
        if (mobileProductsDropdown && !mobileProductsDropdown.classList.contains('hidden')) {
            mobileProductsDropdown.classList.add('hidden');
            mobileProductsDropdown.style.opacity = '0';
            mobileProductsDropdown.style.transform = 'translateY(-10px)';
        }

        // 重新初始化移动端菜单事件监听器
        if (typeof window.initMobileMenu === 'function') {
            window.initMobileMenu();
        }

        // 触发语言变更事件，让页面重新从API获取数据
        window.dispatchEvent(new Event('languageChanged'));

        // 刷新页面以获取对应语言的内容
        location.reload();
    }
    
    // 显示语言切换提示
    showLanguageSwitchAlert(targetLang) {
        // 检查是否已存在提示元素
        let alertEl = document.getElementById('language-switch-alert');
        
        if (!alertEl) {
            // 创建提示元素
            alertEl = document.createElement('div');
            alertEl.id = 'language-switch-alert';
            alertEl.className = 'fixed top-4 right-4 bg-secondary text-white px-6 py-3 rounded-md shadow-lg z-50 opacity-0 transform translate-y-[-20px] transition-all duration-300';
            document.body.appendChild(alertEl);
        }
        
        // 设置提示文本
        const langText = targetLang === 'en' ? 'English' : '中文';
        alertEl.textContent = `已切换到${langText}`;
        
        // 显示提示
        alertEl.classList.remove('opacity-0', 'translate-y-[-20px]');
        alertEl.classList.add('opacity-100', 'translate-y-0');
        
        // 3秒后隐藏提示
        setTimeout(() => {
            alertEl.classList.remove('opacity-100', 'translate-y-0');
            alertEl.classList.add('opacity-0', 'translate-y-[-20px]');
        }, 3000);
    }

    // 翻译整个页面 - 添加防抖功能，避免短时间内多次调用导致闪烁
    translatePage() {
        // 只有切换到英文时才执行翻译，中文使用后端数据
        if (this.currentLang !== 'en') {
            console.log('当前为中文模式，不执行翻译，使用后端提供的数据');
            return;
        }
        
        // 清除之前的定时器
        clearTimeout(this.translateDebounceTimer);
        
        // 设置新的定时器，延迟执行翻译，避免闪烁
        this.translateDebounceTimer = setTimeout(() => {
            try {
                // 获取所有带有data-lang-key属性的元素
                const langElements = document.querySelectorAll('[data-lang-key]');
                console.log(`开始翻译页面，共 ${langElements.length} 个元素需要翻译`);
                
                langElements.forEach(element => {
                    try {
                        const key = element.getAttribute('data-lang-key');
                        
                        // 支持两种翻译数据格式：1) { zh: {...}, en: {...} } 2) { key1: value1, key2: value2 }
                        const translationData = this.translations[this.currentLang] || this.translations;
                        
                        if (translationData && translationData[key]) {
                            // 特殊处理表单占位符
                            if (element.tagName === 'INPUT' || element.tagName === 'TEXTAREA') {
                                element.placeholder = translationData[key];
                            } else {
                                element.innerHTML = translationData[key];
                            }
                            console.log(`元素 ${key} 翻译成功: ${translationData[key]}`);
                        } else {
                            console.log(`元素 ${key} 没有找到翻译数据`);
                        }
                    } catch (error) {
                        console.error(`翻译元素时发生错误:`, error);
                        // 继续处理其他元素，不中断整个翻译过程
                    }
                });
                
                // 更新meta标签，增强SEO支持
                this.updateMetaTags();
            } catch (error) {
                console.error('翻译页面时发生错误:', error);
            }
        }, 50); // 50ms延迟，避免闪烁
    }
    
    // 更新meta标签
    updateMetaTags() {
        // 支持两种翻译数据格式：1) { zh: {...}, en: {...} } 2) { key1: value1, key2: value2 }
        const translationData = this.translations[this.currentLang] || this.translations;
        
        // 更新页面标题
        const titleElement = document.querySelector('title');
        if (titleElement && translationData && translationData.site_title) {
            titleElement.textContent = translationData.site_title;
        }
        
        // 更新meta描述
        const descElement = document.querySelector('meta[name="description"]');
        if (descElement && translationData && translationData.site_description) {
            descElement.setAttribute('content', translationData.site_description);
        }
        
        // 更新meta关键词
        const keywordsElement = document.querySelector('meta[name="keywords"]');
        if (keywordsElement && translationData && translationData.site_keywords) {
            keywordsElement.setAttribute('content', translationData.site_keywords);
        }
        
        // 更新og:title
        const ogTitleElement = document.querySelector('meta[property="og:title"]');
        if (ogTitleElement && translationData && translationData.site_title) {
            ogTitleElement.setAttribute('content', translationData.site_title);
        }
        
        // 更新og:description
        const ogDescElement = document.querySelector('meta[property="og:description"]');
        if (ogDescElement && translationData && translationData.site_description) {
            ogDescElement.setAttribute('content', translationData.site_description);
        }
    }

    // 更新语言切换按钮文本
    updateLanguageButtons() {
        const desktopBtn = document.getElementById('desktop-lang-btn');
        const mobileBtn = document.getElementById('mobile-lang-btn');
        
        if (desktopBtn) {
            desktopBtn.textContent = this.currentLang === 'zh' ? 'English' : '中文';
            // 添加调试信息
            console.log('更新桌面语言按钮文本为:', desktopBtn.textContent);
        }
        
        if (mobileBtn) {
            mobileBtn.textContent = this.currentLang === 'zh' ? 'English' : '中文';
            // 添加调试信息
            console.log('更新移动端语言按钮文本为:', mobileBtn.textContent);
        }
    }
    
    // 重新初始化语言管理器，用于动态加载组件后
    reinit() {
        // 添加调试信息
        console.log('执行languageManager.reinit()，当前语言:', this.currentLang);
        this.updateLanguageButtons();
        // 直接翻译页面，不重新加载数据
        this.translatePage();
    }

    // 同步语言设置到后端
    syncLanguageToBackend() {
        try {
            fetch('/api/sync', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify({
                    type: 'language',
                    data: {
                        current: this.currentLang,
                        saved: this.currentLang
                    }
                })
            });
        } catch (error) {
            console.error('Error syncing language to backend:', error);
        }
    }

    // 获取指定键的翻译
    getTranslation(key) {
        // 支持两种翻译数据格式：1) { zh: {...}, en: {...} } 2) { key1: value1, key2: value2 }
        const translationData = this.translations[this.currentLang] || this.translations;
        if (translationData && translationData[key]) {
            return translationData[key];
        }
        // 如果获取不到翻译，则返回空字符串
        return '';
    }

    // 翻译后台动态加载的内容
    translateDynamicContent(content, type) {
        if (!content || typeof content !== 'object') {
            return content;
        }

        // 克隆内容以避免修改原始数据
        const translatedContent = Array.isArray(content) ? [...content] : { ...content };

        // 根据内容类型进行翻译
        if (Array.isArray(translatedContent)) {
            // 数组类型，如产品列表、新闻列表
            return translatedContent.map(item => this.translateDynamicContent(item, type));
        } else if (type === 'product') {
            // 产品类型翻译
            return {
                ...translatedContent,
                name: this.translateContent(translatedContent.name, `product_${translatedContent.id || 'default'}_name`),
                desc: this.translateContent(translatedContent.desc, `product_${translatedContent.id || 'default'}_desc`),
                // 可以根据需要添加更多字段的翻译
            };
        } else if (type === 'news') {
            // 新闻类型翻译
            return {
                ...translatedContent,
                title: this.translateContent(translatedContent.title, `news_${translatedContent.newsId || 'default'}_title`),
                content: this.translateContent(translatedContent.content, `news_${translatedContent.newsId || 'default'}_content`),
                // 可以根据需要添加更多字段的翻译
            };
        } else if (type === 'service') {
            // 服务类型翻译
            return {
                ...translatedContent,
                title: this.translateContent(translatedContent.title, `service_${translatedContent.id || 'default'}_title`),
                desc: this.translateContent(translatedContent.desc, `service_${translatedContent.id || 'default'}_desc`),
                // 可以根据需要添加更多字段的翻译
            };
        }

        return translatedContent;
    }

    // 翻译单个内容
    translateContent(content, key) {
        // 首先检查是否有实际内容，如果有则直接返回，不进行翻译
        // 只有当内容为空时，才使用翻译文件中的默认值
        if (content && content.trim() !== '') {
            return content;
        }
        
        // 支持两种翻译数据格式：1) { zh: {...}, en: {...} } 2) { key1: value1, key2: value2 }
        const translationData = this.translations[this.currentLang] || this.translations;
        if (translationData && translationData[key]) {
            return translationData[key];
        }
        // 如果没有翻译，返回原始内容
        return content;
    }

    // 重新翻译动态内容
    retranslateDynamicContent() {
        // 重新翻译产品内容
        this.retranslateProducts();
        // 重新翻译新闻内容
        this.retranslateNews();
        // 重新翻译服务内容
        this.retranslateServices();
        // 重新翻译关于区内容
        this.retranslateAboutSection();
        // 重新翻译聊天欢迎语
        this.retranslateChatWelcome();
    }
    
    // 重新翻译关于区内容 - 不再覆盖从API获取的内容
    retranslateAboutSection() {
        console.log('重新翻译关于区内容，当前语言:', this.currentLang);
        // 不再覆盖从API获取的关于区内容，只在需要时更新
    }
    
    // 重新翻译聊天欢迎语
    retranslateChatWelcome() {
        console.log('重新翻译聊天欢迎语');
        
        // 检查聊天服务是否已初始化
        if (window.chatService) {
            // 只清除欢迎消息，保留其他消息
            window.chatService.messages = window.chatService.messages.filter(msg => !msg.id.startsWith('welcome_'));
            window.chatService.saveToLocalStorage();
            window.chatService.displayMessages();
            
            // 重新显示当前语言的欢迎语
            window.chatService.showWelcomeMessage();
        }
    }

    // 重新翻译产品内容
    retranslateProducts() {
        // 获取所有产品容器
        const productContainers = document.querySelectorAll('.product-item, [data-product-id]');
        productContainers.forEach(container => {
            // 支持两种翻译数据格式：1) { zh: {...}, en: {...} } 2) { key1: value1, key2: value2 }
            const translationData = this.translations[this.currentLang] || this.translations;
            
            // 翻译产品名称
            const productName = container.querySelector('[data-lang-key^="product_"]');
            if (productName) {
                const key = productName.getAttribute('data-lang-key');
                if (translationData && translationData[key]) {
                    productName.innerHTML = translationData[key];
                }
            }
            
            // 翻译产品描述
            const productDesc = container.querySelector('.product-desc, [data-lang-key^="product_"] + p');
            if (productDesc && !productDesc.hasAttribute('data-lang-key')) {
                // 查找产品名称对应的key，然后生成描述key
                const productNameKey = container.querySelector('[data-lang-key^="product_"]')?.getAttribute('data-lang-key');
                if (productNameKey) {
                    const descKey = productNameKey.replace('_name', '_desc');
                    if (translationData && translationData[descKey]) {
                        productDesc.innerHTML = translationData[descKey];
                    }
                }
            }
        });
    }

    // 重新翻译新闻内容
    retranslateNews() {
        // 获取所有新闻容器
        const newsContainers = document.querySelectorAll('.news-item, [data-news-id]');
        newsContainers.forEach(container => {
            // 支持两种翻译数据格式：1) { zh: {...}, en: {...} } 2) { key1: value1, key2: value2 }
            const translationData = this.translations[this.currentLang] || this.translations;
            
            // 翻译新闻标题
            const newsTitle = container.querySelector('h3, [data-lang-key^="news_"]');
            if (newsTitle) {
                const key = newsTitle.getAttribute('data-lang-key');
                if (translationData && translationData[key]) {
                    newsTitle.innerHTML = translationData[key];
                }
            }
            
            // 翻译新闻摘要
            const newsExcerpt = container.querySelector('.news-excerpt, [data-lang-key^="news_"] + p');
            if (newsExcerpt && !newsExcerpt.hasAttribute('data-lang-key')) {
                // 查找新闻标题对应的key，然后生成摘要key
                const newsTitleKey = container.querySelector('[data-lang-key^="news_"]')?.getAttribute('data-lang-key');
                if (newsTitleKey) {
                    const excerptKey = newsTitleKey.replace('_title', '_excerpt');
                    if (translationData && translationData[excerptKey]) {
                        newsExcerpt.innerHTML = translationData[excerptKey];
                    }
                }
            }
        });
    }
    
    // 重新翻译服务内容
    retranslateServices() {
        // 获取所有服务容器
        const serviceContainers = document.querySelectorAll('.service-item, [data-service-id]');
        serviceContainers.forEach(container => {
            // 支持两种翻译数据格式：1) { zh: {...}, en: {...} } 2) { key1: value1, key2: value2 }
            const translationData = this.translations[this.currentLang] || this.translations;
            
            // 翻译服务标题
            const serviceTitle = container.querySelector('[data-lang-key^="service_"]');
            if (serviceTitle) {
                const key = serviceTitle.getAttribute('data-lang-key');
                if (translationData && translationData[key]) {
                    serviceTitle.innerHTML = translationData[key];
                }
            }
            
            // 翻译服务描述
            const serviceDesc = container.querySelector('.service-desc, [data-lang-key^="service_"] + p');
            if (serviceDesc && !serviceDesc.hasAttribute('data-lang-key')) {
                // 查找服务标题对应的key，然后生成描述key
                const serviceTitleKey = container.querySelector('[data-lang-key^="service_"]')?.getAttribute('data-lang-key');
                if (serviceTitleKey) {
                    const descKey = serviceTitleKey.replace('_title', '_desc');
                    if (translationData && translationData[descKey]) {
                        serviceDesc.innerHTML = translationData[descKey];
                    }
                }
            }
        });
    }
}

// 初始化语言管理器
let languageManager;

// 在DOM加载完成后初始化
if (document.readyState === 'loading') {
    document.addEventListener('DOMContentLoaded', () => {
        languageManager = new LanguageManager();
        window.languageManager = languageManager;
        initPageVisibilityListener();
    });
} else {
    languageManager = new LanguageManager();
    window.languageManager = languageManager;
    initPageVisibilityListener();
}

// 初始化页面可见性监听器
function initPageVisibilityListener() {
    // 当页面重新可见时，重新加载翻译数据
    document.addEventListener('visibilitychange', () => {
        if (document.visibilityState === 'visible' && window.languageManager) {
            console.log('页面重新可见，重新加载翻译数据...');
            // 延迟加载，避免频繁调用API
            setTimeout(() => {
                window.languageManager.loadTranslations();
            }, 500);
        }
    });
    
    // 当页面获得焦点时，重新加载翻译数据
    window.addEventListener('focus', () => {
        if (window.languageManager) {
            console.log('页面获得焦点，重新加载翻译数据...');
            // 延迟加载，避免频繁调用API
            setTimeout(() => {
                window.languageManager.loadTranslations();
            }, 500);
        }
    });
}

// 全局语言切换函数，供导航栏调用
window.changeLanguage = function(lang) {
    if (window.languageManager) {
        window.languageManager.changeLanguage(lang);
    }
};

// 全局语言切换函数别名，兼容旧代码
window.toggleLanguage = function() {
    if (window.languageManager) {
        const newLang = window.languageManager.currentLang === 'zh' ? 'en' : 'zh';
        window.languageManager.changeLanguage(newLang);
    }
};

// 处理联系我们点击事件
window.handleContactClick = function(event) {
    // 阻止默认跳转
    event.preventDefault();
    
    // 获取当前页面URL
    const currentUrl = window.location.href;
    const isHomePage = currentUrl.includes('wqzn.html') || currentUrl.endsWith('/');
    
    if (isHomePage) {
        // 选项2：执行2次联系我们跳转操作
        // 第一次跳转：跳转到联系我们区域
        window.location.href = 'wqzn.html#contact';
        
        // 第二次跳转：再次跳转到联系我们区域（模拟用户要求的第二次点击）
        setTimeout(() => {
            window.location.href = 'wqzn.html#contact';
        }, 1000); // 延迟1秒执行第二次跳转
    } else {
        // 选项1：先执行跳转到主页然后再执行一次点击跳转联系我们
        // 第一次跳转：跳转到主页
        window.location.href = 'wqzn.html';
        
        // 使用localStorage标记需要执行第二次跳转
        localStorage.setItem('needContactRedirect', 'true');
    }
};

// 在页面加载完成后检查是否需要执行第二次跳转
window.addEventListener('load', function() {
    // 检查localStorage
    const needRedirect = localStorage.getItem('needContactRedirect');
    
    if (needRedirect === 'true') {
        // 清除localStorage标记
        localStorage.removeItem('needContactRedirect');
        
        // 第二次跳转：跳转到联系我们区域（模拟用户要求的第二次点击）
        setTimeout(() => {
            window.location.href = 'wqzn.html#contact';
        }, 1000); // 延迟1秒执行第二次跳转
    }
});