// process/prompt-pool.js
// 翻译提示词池管理系统 - AI生成版本

/**
 * 翻译提示词池管理器 - AI生成版本 + 智能健康管理
 */
class TranslationPromptPool {
    constructor() {
        this.storageKey = 'paperBurnerPromptPool';
        this.healthConfigKey = 'paperBurnerPromptHealthConfig';
        this.defaultGenerationCount = 10;
        this.promptPool = this.loadPromptPool();
        this.healthConfig = this.loadHealthConfig();
        this.activeRequestsQueue = new Map(); // 跟踪正在进行的请求
        
        // 启动健康监控和复活机制
        this.startHealthMonitoring();

        // 一次性迁移：如果历史数据只有使用次数，没有请求统计，则将其回填为成功请求
        this.migrateUsageToRequestsIfNeeded();

        // 后端模式：异步从后端同步提示词池与健康配置（不阻塞）
        try {
            if (typeof window !== 'undefined' && window.storageAdapter && window.storageAdapter.isFrontendMode === false && typeof window.storageAdapter.loadPromptPool === 'function') {
                this._syncFromBackend();
            }
        } catch (e) {
            console.warn('[PromptPool] 初始化后端同步失败（忽略）:', e);
        }
    }

    /**
     * 加载健康管理配置
     */
    loadHealthConfig() {
        try {
            const stored = localStorage.getItem(this.healthConfigKey);
            const defaultConfig = {
                maxConsecutiveFailures: 2, // 最大连续失败次数
                deactivationEnabled: true, // 是否启用失活机制
                resurrectionTimeMinutes: 15, // 复活时间（分钟）
                resurrectionEnabled: true, // 是否启用自动复活
                switchOnFailure: true, // 失败时是否自动切换
                queueManagementEnabled: true // 是否启用队列管理
            };
            return stored ? { ...defaultConfig, ...JSON.parse(stored) } : defaultConfig;
        } catch (error) {
            console.error('Failed to load health config:', error);
            return {
                maxConsecutiveFailures: 2,
                deactivationEnabled: true,
                resurrectionTimeMinutes: 15,
                resurrectionEnabled: true,
                switchOnFailure: true,
                queueManagementEnabled: true
            };
        }
    }

    /**
     * 保存健康管理配置
     */
    saveHealthConfig() {
        try {
            this._persistLocalOnly();
            this._persistToBackend();
            this._notifyUpdated();
        } catch (error) {
            console.error('Failed to save health config:', error);
        }
    }

    /**
     * 启动健康监控定时器
     */
    startHealthMonitoring() {
        // 每分钟检查一次复活条件
        setInterval(() => {
            if (this.healthConfig.resurrectionEnabled) {
                this.checkForResurrection();
            }
        }, 60000); // 1分钟
    }

    /**
     * 从本地存储加载提示词池
     */
    loadPromptPool() {
        try {
            const stored = localStorage.getItem(this.storageKey);
            if (!stored) return [];

            const parsed = JSON.parse(stored);
            if (!Array.isArray(parsed)) return [];

            const dedupedMap = new Map();
            parsed.forEach(item => {
                if (!item || (!item.systemPrompt && !item.userPromptTemplate)) return;
                const key = this.getVariationKey(item);
                if (!key) return;

                if (!dedupedMap.has(key)) {
                    dedupedMap.set(key, item);
                    return;
                }

                const existing = dedupedMap.get(key);
                const existingUsage = existing?.usage_count || 0;
                const candidateUsage = item?.usage_count || 0;
                const existingRequests = existing?.healthStatus?.totalRequests || 0;
                const candidateRequests = item?.healthStatus?.totalRequests || 0;

                if (candidateUsage > existingUsage ||
                    (candidateUsage === existingUsage && candidateRequests > existingRequests)) {
                    dedupedMap.set(key, item);
                }
            });

            const deduped = Array.from(dedupedMap.values());
            if (deduped.length !== parsed.length) {
                console.info('[PromptPool] 去重提示词条目:', parsed.length - deduped.length);
                try {
                    localStorage.setItem(this.storageKey, JSON.stringify(deduped));
                } catch (persistError) {
                    console.warn('[PromptPool] 去重结果写回失败:', persistError);
                }
            }
            return deduped;
        } catch (error) {
            console.error('Failed to load prompt pool:', error);
            return [];
        }
    }

    /**
     * 保存提示词池到本地存储
     */
    savePromptPool() {
        try {
            this._persistLocalOnly();
            this._persistToBackend(); // fire-and-forget
            this._notifyUpdated();
        } catch (error) {
            console.error('Failed to save prompt pool:', error);
        }
    }

    /**
     * 迁移历史统计：当 totalRequests=0 且 success/failure 均为0，但 usage_count>0 时，
     * 将 usage_count 视为历史成功请求数进行回填，避免出现“使用>0，请求=0”的误导显示。
     */
    migrateUsageToRequestsIfNeeded() {
        let changed = false;
        try {
            this.promptPool.forEach(p => {
                const h = p.healthStatus;
                if (!h) return;
                if ((h.totalRequests || 0) === 0 && (h.successCount || 0) === 0 && (h.failureCount || 0) === 0 && (p.usage_count || 0) > 0) {
                    h.totalRequests = p.usage_count;
                    h.successCount = p.usage_count;
                    changed = true;
                }
            });
            if (changed) this.savePromptPool();
        } catch (e) {
            console.warn('migrateUsageToRequestsIfNeeded failed:', e);
        }
    }

    /**
     * 使用AI生成提示词变体
     * @param {string} referenceSystemPrompt - 参考的系统提示词
     * @param {string} referenceUserPrompt - 参考的用户提示词
     * @param {number} count - 生成数量，默认10个
     * @param {number} similarity - 相似度控制 (0.1-0.9，0.1=差异很大，0.9=非常相似)
     * @param {string} apiModel - 使用的AI模型
     * @param {string} apiKey - API密钥
     * @returns {Promise<Array>} 生成的提示词变体数组
     */
    async generateVariationsWithAI(referenceSystemPrompt, referenceUserPrompt, count = this.defaultGenerationCount, similarity = 0.7, apiModel = 'deepseek', apiKey, options = {}) {
        if (!apiKey) {
            throw new Error('需要提供API密钥来生成提示词变体');
        }

        // 构建AI生成提示词的系统提示（风格锁定：仅改写措辞/语序，不改变风格与约束）
        let aiSystemPrompt = options.generatorSystemPrompt || `你是资深提示词工程师，负责在不改变风格与约束的前提下，生成同风格的改写变体。

任务：基于参考提示词，生成 ${count} 个“同风格、同约束、同输出要求”的翻译提示词变体；仅在措辞、语序、句式、连接词与段落组织上做改写，以提升稳定性与一致性。

强制要求：
1. 返回 JSON，包含字段 variations（数组）。
2. 每个变体包含：name（名称）、systemPrompt（系统提示）、userPromptTemplate（用户提示模板）、description（简要说明）。
3. 相似度控制：${similarity}（${this.getSimilarityDescription(similarity)}）。注意：风格与约束必须完全一致，仅体现措辞与语序差异。
4. userPromptTemplate 必须且仅出现一次占位符：\${targetLangName} 与 \${content}。
5. 严禁改变参考提示词的风格、语气、规则、术语偏好与输出格式要求；严禁引入“学术/商务/口语/文学”等风格标签的切换或暗示。
6. 允许调整表述顺序、同义替换与句式变化，但要保持语义与约束等价。
7. 仅输出严格的 JSON 对象（不包含 Markdown 代码块、注释或额外文本）。
8. 使用单行（minified）JSON 输出：不得换行、不得缩进。

JSON 格式示例：
{
  "variations": [
    {
      "name": "同风格改写-1",
      "systemPrompt": "（与参考风格一致，仅改写措辞/语序）你是专业翻译助手...",
      "userPromptTemplate": "请将以下内容翻译为\${targetLangName}：\\n\\n\${content}",
      "description": "风格锁定；仅做同义改写与语序调整"
    }
  ]
}`;

        let aiUserPrompt = options.generatorUserPrompt || `参考提示词（须保持风格/规则/输出要求一致）：

**系统提示：**
${referenceSystemPrompt}

**用户提示模板：**
${referenceUserPrompt}

请基于以上参考提示词生成 ${count} 个“同风格改写”变体：保持风格、语气、规则与输出要求不变，仅做措辞/语序/句式的等价改写。相似度：${similarity}（${this.getSimilarityDescription(similarity)}）。

每个变体必须包含 systemPrompt 与 userPromptTemplate 两个字段；并确保 userPromptTemplate 都包含且仅包含一次 \${targetLangName} 与 \${content} 占位符。严格输出为单行 JSON（无任何额外文字/提示/代码块）。`;

        try {
            // 调用AI API生成变体
            const aiResponse = await this.callAIForGeneration(aiSystemPrompt, aiUserPrompt, apiModel, apiKey);
            
            // 解析AI返回的JSON
            const parsedResponse = this.parseAIResponse(aiResponse);
            
            // 验证和处理生成的变体
            const processedVariations = this.processGeneratedVariations(parsedResponse.variations);
            
            return processedVariations;
            
        } catch (error) {
            console.error('AI生成提示词变体失败:', error);
            throw new Error(`生成提示词变体失败: ${error.message}`);
        }
    }

    /**
     * 获取相似度描述
     */
    getSimilarityDescription(similarity) {
        // 在风格锁定前提下，对“措辞/语序”的差异程度描述
        if (similarity <= 0.3) return '改写幅度很大（语序与措辞差异显著）';
        if (similarity <= 0.5) return '改写幅度中等（保持等价约束，表达有明显变化）';
        if (similarity <= 0.7) return '改写幅度适中（整体表达有所变化）';
        return '改写幅度较小（细微措辞/顺序调整）';
    }

    /**
     * 调用AI API生成变体（复用现有的翻译API调用逻辑）
     */
    async callAIForGeneration(systemPrompt, userPrompt, apiModel, apiKey) {
        // 统一从 translation.js 的构建逻辑获取配置，避免端点不一致
        if (typeof callTranslationApi !== 'function') {
            throw new Error('callTranslationApi函数不可用，请确保 api.js 已加载');
        }

        // 优先使用独立的生成配置构建器
        let apiConfig;
        if (typeof window !== 'undefined' && typeof window.buildPromptPoolGenerationConfig === 'function') {
            apiConfig = window.buildPromptPoolGenerationConfig(apiModel, apiKey);
        } else if (typeof processModule !== 'undefined' && typeof processModule.buildCustomApiConfig === 'function') {
            // 回退（自定义站点）：尽量使用 buildCustomApiConfig 补全端点
            if (apiModel.includes(':')) {
                const separatorIndex = apiModel.indexOf(':');
                const siteId = apiModel.slice(0, separatorIndex);
                const modelId = apiModel.slice(separatorIndex + 1);
                const allSites = typeof loadAllCustomSourceSites === 'function' ? loadAllCustomSourceSites() : {};
                const site = allSites[siteId];
                if (!site) throw new Error(`未找到源站点配置：${siteId}`);
                apiConfig = processModule.buildCustomApiConfig(
                    apiKey,
                    site.apiEndpoint || site.apiBaseUrl,
                    modelId || site.modelId,
                    site.requestFormat || 'openai',
                    site.temperature !== undefined ? site.temperature : 0.5,
                    site.max_tokens !== undefined ? site.max_tokens : 8000,
                    {
                        endpointMode: site.endpointMode || 'auto'
                    }
                );
            } else {
                throw new Error('未能构建预设模型的配置，请检查脚本加载顺序');
            }
        } else {
            throw new Error('缺少构建 API 配置的函数，请检查脚本加载顺序');
        }

        const requestBody = apiConfig.bodyBuilder
            ? apiConfig.bodyBuilder(systemPrompt, userPrompt)
            : {
                model: apiConfig.modelName,
                messages: [
                    { role: 'system', content: systemPrompt },
                    { role: 'user', content: userPrompt }
                ],
                temperature: 0.8,
                max_tokens: 4000
            };

        try {
            const result = await callTranslationApi(apiConfig, requestBody);
            return result;
        } catch (error) {
            throw new Error(`API调用失败: ${error.message}`);
        }
    }

    /**
     * 构建生成API配置（集成现有的模型管理系统）
     */
    buildGenerationApiConfig(apiModel, apiKey) {
        // 已由独立模块统一实现，保留兼容入口
        if (typeof window !== 'undefined' && typeof window.buildPromptPoolGenerationConfig === 'function') {
            return window.buildPromptPoolGenerationConfig(apiModel, apiKey);
        }
        throw new Error('构建API配置失败：缺少 buildPromptPoolGenerationConfig');
    }

    /**
     * 解析AI返回的JSON响应
     */
    parseAIResponse(responseText) {
        if (!responseText || typeof responseText !== 'string') {
            throw new Error('AI响应为空或不是文本');
        }

        // 预清理：去掉 <think>...</think>、代码块围栏、前后杂项
        let text = responseText
            .replace(/<think>[\s\S]*?<\/think>/gi, '')
            .replace(/```json/gi, '```')
            .trim();

        // 尝试1：直接 JSON.parse（兼容单行/多行）
        try { return JSON.parse(text); } catch {}

        // 尝试2：```json 或 ``` 包裹的内容（逐块尝试）
        try {
            const blocks = text.match(/```\s*[\s\S]*?```/g);
            if (blocks) {
                for (const b of blocks) {
                    const body = b.replace(/```/g, '').trim();
                    // 允许裸换行修复
                    const obj = (function(raw){
                        let s = raw.replace(/,\s*(\}|\])/g, '$1');
                        let out = '', inStr=false, esc=false;
                        for (let i=0;i<s.length;i++){
                            const ch=s[i];
                            if(inStr){
                                if(esc){out+=ch;esc=false;continue;}
                                if(ch==='\\'){out+=ch;esc=true;continue;}
                                if(ch==='"'){inStr=false;out+=ch;continue;}
                                if(ch==='\n'||ch==='\r'){out+='\\n';continue;}
                                out+=ch;
                            }else{
                                if(ch==='"'){inStr=true;out+=ch;continue;}
                                out+=ch;
                            }
                        }
                        try{return JSON.parse(out);}catch{return null;}
                    })(body);
                    if (obj) {
                        if (Array.isArray(obj)) return {variations: obj};
                        if (Array.isArray(obj.variations)) return {variations: obj.variations};
                        if (obj.name && obj.systemPrompt && obj.userPromptTemplate) return {variations:[obj]};
                    }
                }
            }
        } catch {}

        // 尝试3：基于 "variations" 关键词做括号配对提取
        const keyIdx = text.indexOf('"variations"');
        if (keyIdx !== -1) {
            // 从 keyIdx 往左找到最近的 '{'
            let start = text.lastIndexOf('{', keyIdx);
            if (start !== -1) {
                // 自 start 往右做简单括号配对（不考虑字符串内花括号的极端情况，但一般足够）
                let depth = 0, end = -1;
                for (let i = start; i < text.length; i++) {
                    const ch = text[i];
                    if (ch === '{') depth++;
                    else if (ch === '}') depth--;
                    if (depth === 0) { end = i; break; }
                }
                if (end !== -1) {
                    let candidate = text.slice(start, end + 1);
                    // 去掉可能存在的尾随逗号
                    candidate = candidate.replace(/,\s*(\}|\])/g, '$1');
                    // 去掉可能存在的行内注释（简单处理）
                    candidate = candidate.replace(/(^|\n)\s*\/\/.*(?=\n|$)/g, '$1');
                    try { return JSON.parse(candidate); } catch {}
                }
            }
        }

        // 尝试4：宽泛匹配第一个 {...} 快，做配对
        {
            const first = text.indexOf('{');
            const last = text.lastIndexOf('}');
            if (first !== -1 && last !== -1 && last > first) {
                let candidate = text.slice(first, last + 1);
                candidate = candidate.replace(/,\s*(\}|\])/g, '$1');
                try { return JSON.parse(candidate); } catch {}
            }
        }

        // 尝试5：如果文本中包含有效的 JSON 片段行，拼接重尝试（保守）
        try {
            const lines = text.split(/\n|\r/).map(l => l.trim());
            // 仅保留可能是 JSON 的行
            const filtered = lines.filter(l => /^[\[\]{},:\"\w\s\-\$]/.test(l)).join('');
            if (filtered.includes('{') && filtered.includes('}')) {
                const cleaned = filtered.replace(/,\s*(\}|\])/g, '$1');
                const obj = JSON.parse(cleaned);
                const norm = (function(o){
                    if (!o) return null;
                    if (Array.isArray(o)) return {variations:o};
                    if (Array.isArray(o.variations)) return {variations:o.variations};
                    if (o.name && o.systemPrompt && o.userPromptTemplate) return {variations:[o]};
                    return null;
                })(obj);
                if (norm) return norm;
            }
        } catch {}

        console.error('解析AI响应失败:', responseText);
        throw new Error('AI返回的不是有效的JSON格式');
    }

    /**
     * 处理和验证生成的变体
     */
    processGeneratedVariations(variations) {
        if (!Array.isArray(variations)) {
            throw new Error('AI返回的variations不是数组格式');
        }

        const processedVariations = [];
        const baseId = Date.now();

        variations.forEach((variation, index) => {
            try {
                // 验证必要字段
                if (!variation.name || !variation.systemPrompt || !variation.userPromptTemplate) {
                    console.warn(`跳过无效变体 ${index}:`, variation);
                    return;
                }

                // 占位符修复策略
                let userTemplate = variation.userPromptTemplate || '';
                let targetLangCount = (userTemplate.match(/\$\{targetLangName\}/g) || []).length;
                let contentCount = (userTemplate.match(/\$\{content\}/g) || []).length;
                if (targetLangCount === 0) {
                    userTemplate = `所需语言：\${targetLangName}\n` + userTemplate;
                    targetLangCount = 1;
                }
                if (contentCount === 0) {
                    userTemplate = userTemplate.replace(/\s*$/, '') + `\n\n需要翻译的内容：\${content}`;
                    contentCount = 1;
                }
                variation.userPromptTemplate = userTemplate;

                // 构建标准变体对象
                const processedVariation = {
                    id: `${baseId}_${index}`,
                    name: variation.name || `同风格改写-${index+1}`,
                    systemPrompt: variation.systemPrompt,
                    userPromptTemplate: variation.userPromptTemplate,
                    description: variation.description || '',
                    // 固定为通用类别，避免引入“学术/商务/口语”等风格标签
                    category: 'general',
                    tags: this.generateTags(variation.name, variation.description || ''),
                    created_at: new Date().toISOString(),
                    usage_count: 0,
                    isActive: false,
                    userSelected: null,
                    aiGenerated: true,
                    // 健康状态信息
                    healthStatus: {
                        status: 'healthy', // healthy, degraded, failed, deactivated
                        totalRequests: 0,
                        successCount: 0,
                        failureCount: 0,
                        consecutiveFailures: 0,
                        lastUsed: null,
                        lastSuccess: null,
                        lastFailure: null,
                        deactivatedAt: null,
                        deactivationReason: null,
                        requestHistory: [], // 最近20次请求的记录
                        averageResponseTime: 0
                    }
                };

                processedVariations.push(processedVariation);
            } catch (error) {
                console.warn(`处理变体 ${index} 时出错:`, error);
            }
        });

        if (processedVariations.length === 0) {
            throw new Error('没有生成有效的提示词变体');
        }

        return processedVariations;
    }

    /**
     * 生成用于去重的提示词键
     */
    getVariationKey(prompt) {
        if (!prompt) return '';
        const system = typeof prompt.systemPrompt === 'string' ? prompt.systemPrompt.trim() : '';
        const user = typeof prompt.userPromptTemplate === 'string' ? prompt.userPromptTemplate.trim() : '';
        if (!system && !user) return '';
        return `${system}||${user}`;
    }

    /**
     * 推断变体类别
     */
    inferCategory(name, description) {
        const text = `${name} ${description}`.toLowerCase();
        
        if (text.includes('学术') || text.includes('论文') || text.includes('研究')) return 'academic';
        if (text.includes('技术') || text.includes('专业') || text.includes('工程')) return 'technical';
        if (text.includes('商务') || text.includes('正式') || text.includes('商业')) return 'business';
        if (text.includes('通俗') || text.includes('口语') || text.includes('简单')) return 'casual';
        if (text.includes('文学') || text.includes('创意') || text.includes('艺术')) return 'literary';
        
        return 'general';
    }

    /**
     * 生成标签
     */
    generateTags(name, description) {
        const text = `${name} ${description}`.toLowerCase();
        const tags = [];
        
        if (text.includes('准确') || text.includes('精确')) tags.push('准确');
        if (text.includes('详细') || text.includes('全面')) tags.push('详细');
        if (text.includes('简洁') || text.includes('简单')) tags.push('简洁');
        if (text.includes('专业') || text.includes('权威')) tags.push('专业');
        if (text.includes('创意') || text.includes('创新')) tags.push('创意');
        if (text.includes('AI生成')) tags.push('AI生成');
        
        return tags.length > 0 ? tags : ['AI生成'];
    }

    /**
     * 记录提示词使用结果
     * @param {string} promptId - 提示词ID
     * @param {boolean} success - 是否成功
     * @param {number} responseTime - 响应时间(ms)
     * @param {string} error - 错误信息（如果失败）
     * @param {Object} requestInfo - 请求相关信息
     */
    recordPromptUsage(promptId, success, responseTime = 0, error = null, requestInfo = {}) {
        const promptIndex = this.promptPool.findIndex(p => p.id === promptId);
        if (promptIndex === -1) return;

        const prompt = this.promptPool[promptIndex];
        const now = new Date().toISOString();
        
        // 确保healthStatus存在
        if (!prompt.healthStatus) {
            prompt.healthStatus = {
                status: 'healthy',
                totalRequests: 0,
                successCount: 0,
                failureCount: 0,
                consecutiveFailures: 0,
                lastUsed: null,
                lastSuccess: null,
                lastFailure: null,
                deactivatedAt: null,
                deactivationReason: null,
                requestHistory: [],
                averageResponseTime: 0
            };
        }

        const health = prompt.healthStatus;
        
        // 更新基础统计
        health.totalRequests++;
        health.lastUsed = now;
        
        // 创建请求记录
        const requestRecord = {
            timestamp: now,
            success: success,
            responseTime: responseTime,
            error: error,
            consecutiveFailureCount: health.consecutiveFailures,
            ...requestInfo
        };
        
        // 添加到历史记录（保持最近20条）
        health.requestHistory.unshift(requestRecord);
        if (health.requestHistory.length > 20) {
            health.requestHistory = health.requestHistory.slice(0, 20);
        }
        
        if (success) {
            health.successCount++;
            health.consecutiveFailures = 0;
            health.lastSuccess = now;
            
            // 更新平均响应时间
            health.averageResponseTime = this.calculateAverageResponseTime(health.requestHistory);
            
            // 如果之前处于降级状态，考虑恢复
            if (health.status === 'degraded') {
                health.status = 'healthy';
                console.log(`[PromptPool] 提示词 ${prompt.name} 恢复健康状态`);
            }
            
        } else {
            health.failureCount++;
            health.consecutiveFailures++;
            health.lastFailure = now;
            
            console.warn(`[PromptPool] 提示词 ${prompt.name} 失败，连续失败次数: ${health.consecutiveFailures}`);
            
            // 更新健康状态
            this.updatePromptHealthStatus(promptId);
            
            // 如果启用了切换机制，处理队列替换
            if (this.healthConfig.switchOnFailure && this.healthConfig.queueManagementEnabled) {
                this.handleQueueReplacement(promptId);
            }

            // 会话锁场景：若当前会话锁定提示词即为失败项，则打破锁，允许后续任务挑选新提示词
            if (typeof window !== 'undefined' && window.promptPoolUI && typeof window.promptPoolUI.breakSessionLockIfMatches === 'function') {
                window.promptPoolUI.breakSessionLockIfMatches(promptId);
            }
        }
        
        this.savePromptPool();
        
        // 通知UI更新（如果存在）
        if (typeof window !== 'undefined' && window.promptPoolUI && window.promptPoolUI.updateHealthDisplay) {
            window.promptPoolUI.updateHealthDisplay(promptId);
        }
    }

    /**
     * 更新提示词健康状态
     */
    updatePromptHealthStatus(promptId) {
        const prompt = this.promptPool.find(p => p.id === promptId);
        if (!prompt || !prompt.healthStatus) return;
        
        const health = prompt.healthStatus;
        const config = this.healthConfig;
        
        // 检查是否需要失活
        if (config.deactivationEnabled && 
            health.consecutiveFailures >= config.maxConsecutiveFailures) {
            
            health.status = 'deactivated';
            health.deactivatedAt = new Date().toISOString();
            health.deactivationReason = `连续失败${health.consecutiveFailures}次`;
            prompt.isActive = false;
            
            console.warn(`[PromptPool] 提示词 ${prompt.name} 已失活: ${health.deactivationReason}`);
            
            // 触发UI通知
            this.notifyPromptDeactivated(prompt);
            
        } else if (health.consecutiveFailures >= Math.floor(config.maxConsecutiveFailures / 2)) {
            // 进入降级状态
            health.status = 'degraded';
            console.warn(`[PromptPool] 提示词 ${prompt.name} 进入降级状态`);
        }
    }

    /**
     * 处理队列替换逻辑
     */
    handleQueueReplacement(failedPromptId) {
        try {
            // 获取使用失败提示词的待处理请求
            const pendingRequests = this.activeRequestsQueue.get(failedPromptId) || [];
            
            if (pendingRequests.length > 0) {
                // 选择新的提示词
                const newPrompt = this.selectHealthyPrompt(failedPromptId);
                
                if (newPrompt) {
                    console.log(`[PromptPool] 替换队列中的 ${pendingRequests.length} 个请求，从 ${failedPromptId} 到 ${newPrompt.id}`);
                    
                    // 将请求转移到新提示词
                    pendingRequests.forEach(request => {
                        request.promptId = newPrompt.id;
                        request.prompt = newPrompt;
                        request.replacedFrom = failedPromptId;
                        request.replacedAt = new Date().toISOString();
                    });
                    
                    // 更新队列
                    this.activeRequestsQueue.set(newPrompt.id, 
                        (this.activeRequestsQueue.get(newPrompt.id) || []).concat(pendingRequests));
                    this.activeRequestsQueue.delete(failedPromptId);
                    
                } else {
                    console.warn(`[PromptPool] 没有可用的健康提示词来替换失败的 ${failedPromptId}`);
                }
            }
            
        } catch (error) {
            console.error('[PromptPool] 队列替换失败:', error);
        }
    }

    /**
     * 将请求入队（在任务开始前调用）。仅记录待开始的请求，便于失败时迁移。
     * @param {string} promptId
     * @param {{requestId:string, model?:string, meta?:Object}} request
     */
    enqueueRequest(promptId, request) {
        try {
            const arr = this.activeRequestsQueue.get(promptId) || [];
            arr.push({ ...request, enqueuedAt: Date.now() });
            this.activeRequestsQueue.set(promptId, arr);
        } catch (e) { console.warn('enqueueRequest failed:', e); }
    }

    /**
     * 请求出队（在任务开始执行时或完成时调用，防止被当作待迁移）。
     * @param {string} promptId
     * @param {string} requestId
     */
    dequeueRequest(promptId, requestId) {
        try {
            const arr = this.activeRequestsQueue.get(promptId) || [];
            const next = arr.filter(r => r.requestId !== requestId);
            if (next.length === 0) this.activeRequestsQueue.delete(promptId);
            else this.activeRequestsQueue.set(promptId, next);
        } catch (e) { console.warn('dequeueRequest failed:', e); }
    }

    /**
     * 选择健康的提示词
     */
    selectHealthyPrompt(excludePromptId = null) {
        const healthyPrompts = this.promptPool.filter(prompt => 
            prompt.isActive && 
            prompt.userSelected === true &&
            prompt.id !== excludePromptId &&
            prompt.healthStatus &&
            ['healthy', 'degraded'].includes(prompt.healthStatus.status)
        );
        
        if (healthyPrompts.length === 0) return null;
        
        // 优先选择完全健康的
        const fullyHealthy = healthyPrompts.filter(p => p.healthStatus.status === 'healthy');
        if (fullyHealthy.length > 0) {
            // 按成功率排序
            fullyHealthy.sort((a, b) => {
                const aSuccessRate = a.healthStatus.totalRequests > 0 ? 
                    a.healthStatus.successCount / a.healthStatus.totalRequests : 1;
                const bSuccessRate = b.healthStatus.totalRequests > 0 ? 
                    b.healthStatus.successCount / b.healthStatus.totalRequests : 1;
                return bSuccessRate - aSuccessRate;
            });
            return fullyHealthy[0];
        }
        
        // 如果没有完全健康的，选择降级状态中最好的
        healthyPrompts.sort((a, b) => b.healthStatus.successCount - a.healthStatus.successCount);
        return healthyPrompts[0];
    }

    /**
     * 检查复活条件
     */
    checkForResurrection() {
        const now = new Date();
        const resurrectionTimeMs = this.healthConfig.resurrectionTimeMinutes * 60 * 1000;
        
        const deactivatedPrompts = this.promptPool.filter(prompt => 
            prompt.healthStatus && 
            prompt.healthStatus.status === 'deactivated' &&
            prompt.healthStatus.deactivatedAt
        );
        
        deactivatedPrompts.forEach(prompt => {
            const deactivatedAt = new Date(prompt.healthStatus.deactivatedAt);
            const timeSinceDeactivation = now - deactivatedAt;
            
            if (timeSinceDeactivation >= resurrectionTimeMs) {
                this.resurrectPrompt(prompt.id);
            }
        });
    }

    /**
     * 复活提示词
     */
    resurrectPrompt(promptId) {
        const prompt = this.promptPool.find(p => p.id === promptId);
        if (!prompt || !prompt.healthStatus) return;
        
        const health = prompt.healthStatus;
        
        // 重置健康状态
        health.status = 'healthy';
        health.consecutiveFailures = 0;
        health.deactivatedAt = null;
        health.deactivationReason = null;
        
        // 如果用户之前选择了这个提示词，重新激活
        if (prompt.userSelected === true) {
            prompt.isActive = true;
        }
        
        console.log(`[PromptPool] 提示词 ${prompt.name} 已自动复活`);
        
        this.savePromptPool();
        
        // 通知UI
        this.notifyPromptResurrected(prompt);
    }

    /**
     * 计算平均响应时间
     */
    calculateAverageResponseTime(history) {
        if (!history || history.length === 0) return 0;
        
        const validTimes = history.filter(record => record.success && record.responseTime > 0);
        if (validTimes.length === 0) return 0;
        
        const totalTime = validTimes.reduce((sum, record) => sum + record.responseTime, 0);
        return Math.round(totalTime / validTimes.length);
    }

    /**
     * 通知UI提示词失活
     */
    notifyPromptDeactivated(prompt) {
        if (typeof window !== 'undefined' && window.promptPoolUI && window.promptPoolUI.showNotification) {
            window.promptPoolUI.showNotification(
                `提示词"${prompt.name}"因连续失败已自动失活`, 
                'warning'
            );
        }
    }

    /**
     * 通知UI提示词复活
     */
    notifyPromptResurrected(prompt) {
        if (typeof window !== 'undefined' && window.promptPoolUI && window.promptPoolUI.showNotification) {
            window.promptPoolUI.showNotification(
                `提示词"${prompt.name}"已自动复活`, 
                'success'
            );
        }
    }

    /**
     * 批量添加变体到提示词池
     */
    addVariationsToPool(variations) {
        if (!Array.isArray(variations) || variations.length === 0) {
            return;
        }

        const existingKeys = new Set(this.promptPool.map(item => this.getVariationKey(item)).filter(Boolean));
        const newItems = [];

        for (const variation of variations) {
            if (!variation) continue;
            const key = this.getVariationKey(variation);
            if (!key || existingKeys.has(key)) continue;
            existingKeys.add(key);
            newItems.push(variation);
        }

        if (newItems.length === 0) {
            return;
        }

        this.promptPool.push(...newItems);
        this.savePromptPool();
    }

    /**
     * 更新提示词项目
     */
    updatePromptItem(id, updates) {
        const index = this.promptPool.findIndex(item => item.id === id);
        if (index !== -1) {
            this.promptPool[index] = { ...this.promptPool[index], ...updates };
            this.savePromptPool();
            return true;
        }
        return false;
    }

    /**
     * 批量更新提示词项目
     * @param {string[]} ids 
     * @param {Object} updates
     */
    updatePromptItems(ids, updates) {
        let changed = false;
        this.promptPool = this.promptPool.map(item => {
            if (ids.includes(item.id)) {
                changed = true;
                return { ...item, ...updates };
            }
            return item;
        });
        if (changed) this.savePromptPool();
        return changed;
    }

    /**
     * 批量复活提示词
     * @param {string[]} ids
     */
    resurrectPrompts(ids) {
        ids.forEach(id => this.resurrectPrompt(id));
    }

    /**
     * 删除提示词项目
     */
    deletePromptItem(id) {
        const index = this.promptPool.findIndex(item => item.id === id);
        if (index !== -1) {
            this.promptPool.splice(index, 1);
            this.savePromptPool();
            return true;
        }
        return false;
    }

    /**
     * 获取激活的提示词列表（健康状态感知）
     */
    getActivePrompts() {
        return this.promptPool.filter(item => 
            item.isActive && 
            item.userSelected === true &&
            item.healthStatus &&
            ['healthy', 'degraded'].includes(item.healthStatus.status)
        );
    }

    /**
     * 获取所有提示词
     */
    getAllPrompts() {
        return this.promptPool;
    }

    /**
     * 清空提示词池
     */
    clearPool() {
        this.promptPool = [];
        this.savePromptPool();
    }

    /**
     * 智能随机选择一个激活的提示词（带健康管理）
     */
    getRandomActivePrompt() {
        const activePrompts = this.getActivePrompts();
        if (activePrompts.length === 0) return null;
        
        // 按健康状态和成功率权重选择
        const weightedPrompts = this.calculatePromptWeights(activePrompts);
        const selectedPrompt = this.weightedRandomSelect(weightedPrompts);
        
        if (selectedPrompt) {
            // 更新使用次数
            this.updatePromptItem(selectedPrompt.id, { 
                usage_count: selectedPrompt.usage_count + 1 
            });
            
            // 记录选择到队列（用于失败时的队列管理）
            this.recordPromptSelection(selectedPrompt.id);
        }
        
        return selectedPrompt;
    }

    /**
     * 按轮换方式选择激活的提示词（带健康管理）
     */
    getRotationActivePrompt() {
        const activePrompts = this.getActivePrompts();
        if (activePrompts.length === 0) return null;
        
        // 优先选择健康状态最好的，使用次数最少的
        activePrompts.sort((a, b) => {
            // 首先按健康状态排序
            const healthPriority = { 'healthy': 0, 'degraded': 1 };
            const aPriority = healthPriority[a.healthStatus.status] || 2;
            const bPriority = healthPriority[b.healthStatus.status] || 2;
            
            if (aPriority !== bPriority) {
                return aPriority - bPriority;
            }
            
            // 然后按使用次数排序
            return a.usage_count - b.usage_count;
        });
        
        const selectedPrompt = activePrompts[0];
        
        // 更新使用次数
        this.updatePromptItem(selectedPrompt.id, { 
            usage_count: selectedPrompt.usage_count + 1 
        });
        
        // 记录选择到队列
        this.recordPromptSelection(selectedPrompt.id);
        
        return selectedPrompt;
    }

    /**
     * 计算提示词的权重（基于健康状态和成功率）
     */
    calculatePromptWeights(prompts) {
        return prompts.map(prompt => {
            let weight = 1;
            
            if (prompt.healthStatus) {
                const health = prompt.healthStatus;
                
                // 健康状态权重
                if (health.status === 'healthy') {
                    weight *= 1.0;
                } else if (health.status === 'degraded') {
                    weight *= 0.5; // 降级状态降低权重
                }
                
                // 成功率权重
                if (health.totalRequests > 0) {
                    const successRate = health.successCount / health.totalRequests;
                    weight *= (0.5 + successRate); // 0.5-1.5范围
                }
                
                // 响应时间权重（响应时间越短权重越高）
                if (health.averageResponseTime > 0) {
                    const timeWeight = Math.max(0.1, 1 - (health.averageResponseTime / 10000)); // 10秒为基准
                    weight *= timeWeight;
                }
            }
            
            return { prompt, weight: Math.max(0.1, weight) };
        });
    }

    /**
     * 权重随机选择
     */
    weightedRandomSelect(weightedPrompts) {
        if (weightedPrompts.length === 0) return null;
        if (weightedPrompts.length === 1) return weightedPrompts[0].prompt;
        
        const totalWeight = weightedPrompts.reduce((sum, item) => sum + item.weight, 0);
        let random = Math.random() * totalWeight;
        
        for (const item of weightedPrompts) {
            random -= item.weight;
            if (random <= 0) {
                return item.prompt;
            }
        }
        
        // 回退到最后一个
        return weightedPrompts[weightedPrompts.length - 1].prompt;
    }

    /**
     * 记录提示词选择（用于队列管理）
     */
    recordPromptSelection(promptId) {
        // 这里可以记录提示词被选择用于某个翻译任务
        // 在实际翻译失败时，可以使用这些信息进行队列替换
    }

    /**
     * 获取健康管理配置
     */
    getHealthConfig() {
        return this.healthConfig;
    }

    /**
     * 更新健康管理配置
     */
    updateHealthConfig(newConfig) {
        this.healthConfig = { ...this.healthConfig, ...newConfig };
        this.saveHealthConfig();
    }

    /**
     * 获取提示词健康统计
     */
    getHealthStats() {
        const stats = {
            total: this.promptPool.length,
            active: 0,
            healthy: 0,
            degraded: 0,
            deactivated: 0,
            totalRequests: 0,
            totalSuccesses: 0,
            totalFailures: 0,
            averageSuccessRate: 0
        };
        
        this.promptPool.forEach(prompt => {
            if (prompt.isActive && prompt.userSelected === true) {
                stats.active++;
            }
            
            if (prompt.healthStatus) {
                const health = prompt.healthStatus;
                
                switch (health.status) {
                    case 'healthy':
                        stats.healthy++;
                        break;
                    case 'degraded':
                        stats.degraded++;
                        break;
                    case 'deactivated':
                        stats.deactivated++;
                        break;
                }
                
                stats.totalRequests += health.totalRequests;
                stats.totalSuccesses += health.successCount;
                stats.totalFailures += health.failureCount;
            }
        });
        
        stats.averageSuccessRate = stats.totalRequests > 0 ? 
            (stats.totalSuccesses / stats.totalRequests) : 0;
        
        return stats;
    }

    // ==================== 持久化与后端同步 ====================
    _persistLocalOnly() {
        try {
            localStorage.setItem(this.storageKey, JSON.stringify(this.promptPool));
            localStorage.setItem(this.healthConfigKey, JSON.stringify(this.healthConfig));
        } catch (e) {
            console.warn('[PromptPool] 本地持久化失败（忽略）:', e);
        }
    }

    async _persistToBackend() {
        try {
            if (typeof window === 'undefined') return;
            const sa = window.storageAdapter;
            if (!sa || sa.isFrontendMode !== false || typeof sa.savePromptPool !== 'function') return;
            await sa.savePromptPool({ prompts: this.promptPool, healthConfig: this.healthConfig });
        } catch (e) {
            console.warn('[PromptPool] 后端保存失败（忽略）:', e?.message || e);
        }
    }

    async _syncFromBackend() {
        try {
            const sa = window.storageAdapter;
            const data = await sa.loadPromptPool();
            if (data && Array.isArray(data.prompts)) {
                this.promptPool = data.prompts;
            }
            if (data && data.healthConfig) {
                this.healthConfig = { ...this.healthConfig, ...data.healthConfig };
            }
            this._persistLocalOnly();
            this._notifyUpdated();
            console.log('[PromptPool] 已从后端同步最新提示词池');
        } catch (e) {
            console.warn('[PromptPool] 拉取后端提示词池失败（忽略）:', e?.message || e);
        }
    }

    _notifyUpdated() {
        try {
            if (typeof window !== 'undefined') {
                window.dispatchEvent(new CustomEvent('pb:prompt-pool-updated'));
            }
        } catch {}
    }
}

// 全局实例
if (typeof window !== 'undefined') {
    window.translationPromptPool = new TranslationPromptPool();
}

// 将类添加到processModule对象
if (typeof processModule !== 'undefined') {
    processModule.TranslationPromptPool = TranslationPromptPool;
}