/**
 * 一级注释：本地缓存服务模块
 * 统一管理历史记录和标签的本地缓存
 */

import { logger } from '../utils/logger.js';
import { PromptFormatter } from "../utils/promptFormatter.js";

// ---缓存配置---
const CACHE_CONFIG = {
    // 统一前缀
    GLOBAL_PREFIX: "PromptAssistant_",

    // 历史缓存配置
    HISTORY_CACHE_KEY: "PromptAssistant_history_cache_all",
    MAX_HISTORY_PER_NODE: 20,  // 每个节点最多保存的历史条数
    MAX_HISTORY_GLOBAL: 100,   // 全局最多保存的历史条数
    MAX_CONTENT_LENGTH: 5000,  // 单条历史最大长度限制

    // 标签缓存配置
    TAG_CACHE_KEY: "PromptAssistant_tag_cache_all",
    MAX_TAGS_PER_INPUT: 100,    // 每个输入框最多保存的标签数量
    MAX_TAGS_GLOBAL: 500,      // 全局最多保存的标签数量

    // 翻译缓存配置
    TRANSLATE_CACHE_KEY: "PromptAssistant_translate_cache",
    MAX_TRANSLATE_CACHE: 200,  // 最多保存的翻译缓存条数
};

/**
 * 通用缓存服务
 * 提供基础的缓存操作方法
 */
class CacheService {
    /**
     * 从localStorage获取数据
     */
    static get(key) {
        try {
            const data = localStorage.getItem(key);
            return data ? JSON.parse(data) : null;
        } catch (error) {
            logger.error(`缓存服务 | 读取失败 | 键:${key} | 错误:${error.message}`);
            return null;
        }
    }

    /**
     * 将数据存储到localStorage
     */
    static set(key, value) {
        try {
            localStorage.setItem(key, JSON.stringify(value));
            return true;
        } catch (error) {
            logger.error(`缓存服务 | 写入失败 | 键:${key} | 错误:${error.message}`);
            return false;
        }
    }

    /**
     * 从localStorage删除数据
     */
    static remove(key) {
        try {
            localStorage.removeItem(key);
        } catch (error) {
            logger.error(`缓存服务 | 删除失败 | 键:${key} | 错误:${error.message}`);
        }
    }

    /**
     * 清除指定前缀的所有缓存
     */
    static clearByPrefix(prefix) {
        try {
            const keysToRemove = [];
            for (let i = 0; i < localStorage.length; i++) {
                const key = localStorage.key(i);
                if (key && key.startsWith(prefix)) {
                    keysToRemove.push(key);
                }
            }
            keysToRemove.forEach(key => this.remove(key));
            // logger.debug(`缓存服务 | 清除前缀缓存 | 前缀:${prefix} | 数量:${keysToRemove.length}`);
        } catch (error) {
            logger.error(`缓存服务 | 清除前缀缓存失败 | 前缀:${prefix} | 错误:${error.message}`);
        }
    }
}

/**
 * 历史缓存服务
 * 管理历史记录的缓存操作
 */
class HistoryCacheService {
    // 添加撤销/重做状态记录
    static undoStates = new Map(); // 格式: { "nodeId_inputId": { currentIndex: number, records: array } }

    /**
     * 获取所有历史记录
     */
    static getAllHistory() {
        const key = CACHE_CONFIG.HISTORY_CACHE_KEY;
        return CacheService.get(key) || [];
    }

    /**
     * 保存所有历史记录
     */
    static saveAllHistory(history) {
        const key = CACHE_CONFIG.HISTORY_CACHE_KEY;
        CacheService.set(key, history);
    }

    /**
     * 获取历史记录列表
     */
    static getHistoryList({ nodeId = null, limit = 50, workflowId = null } = {}) {
        try {
            const allHistory = this.getAllHistory();

            let filteredHistory = allHistory;
            if (workflowId) {
                filteredHistory = allHistory.filter(item => item.workflow_id === workflowId);
            }

            // 确保每条历史记录都有必要的字段
            const validHistory = filteredHistory.filter(item => {
                const isValid = item && item.node_id && item.input_id &&
                    item.content && item.timestamp && item.operation_type;
                if (!isValid) {
                    logger.debug(`历史缓存 | 跳过无效记录 | 节点:${item?.node_id}`);
                }
                return isValid;
            });

            if (!nodeId) {
                return validHistory
                    .sort((a, b) => b.timestamp - a.timestamp)
                    .slice(0, limit);
            }

            const currentNodeHistory = [];
            const otherNodesHistory = [];

            validHistory.forEach(item => {
                if (item.node_id === nodeId) {
                    currentNodeHistory.push(item);
                } else {
                    otherNodesHistory.push(item);
                }
            });

            currentNodeHistory.sort((a, b) => b.timestamp - a.timestamp);
            otherNodesHistory.sort((a, b) => b.timestamp - a.timestamp);

            return [...currentNodeHistory, ...otherNodesHistory].slice(0, limit);
        } catch (error) {
            logger.error(`历史缓存 | 获取历史失败 | 错误:${error.message}`);
            return [];
        }
    }

    /**
     * 获取指定节点和输入框的历史记录
     */
    static getInputHistory(nodeId, inputId, oldToNew = false) {
        try {
            const allHistory = this.getAllHistory();
            const workflowId = app.graph?._workflow_id;

            const filtered = allHistory.filter(item =>
                item.node_id === nodeId &&
                item.input_id === inputId &&
                (!workflowId || item.workflow_id === workflowId) // 如果有workflowId，则匹配
            );
            // 根据参数决定排序方向
            return filtered.sort((a, b) =>
                oldToNew ? a.timestamp - b.timestamp : b.timestamp - a.timestamp
            );
        } catch (error) {
            logger.error(`历史缓存 | 获取输入框历史失败 | 节点:${nodeId} | 输入框:${inputId} | 错误:${error.message}`);
            return [];
        }
    }

    /**
     * 检查是否为重复的翻译记录
     */
    static isRepeatedTranslation(nodeId, inputId, content, operationType) {
        try {
            if (operationType !== 'translate') {
                return false;
            }

            // 获取该节点和输入框的历史记录
            const history = this.getInputHistory(nodeId, inputId, false);
            if (!history || history.length === 0) {
                return false;
            }

            // 获取最近的一条记录
            const lastRecord = history[0];
            if (!lastRecord || lastRecord.operation_type !== 'translate') {
                return false;
            }

            // 检查内容是否匹配
            const currentContent = content.trim();
            const lastContent = lastRecord.content.trim();

            // 查询翻译缓存
            const cacheResult = TranslateCacheService.queryTranslateCache(currentContent);
            if (!cacheResult) {
                return false;
            }

            // 检查是否为原文-译文或译文-原文的切换
            if (cacheResult.type === 'source' && cacheResult.translatedText === lastContent) {
                return true;
            }
            if (cacheResult.type === 'translated' && cacheResult.sourceText === lastContent) {
                return true;
            }

            return false;
        } catch (error) {
            logger.error(`历史缓存 | 检查重复翻译失败 | 节点:${nodeId} | 输入框:${inputId} | 错误:${error.message}`);
            return false;
        }
    }

    /**
     * 添加历史记录
     */
    static addHistory(historyItem) {
        try {
            // 验证必要字段
            if (!historyItem.node_id || !historyItem.input_id || historyItem.content === undefined) {
                logger.error("历史缓存 | 添加历史失败 | 缺少必要字段");
                return false;
            }

            // 如果内容为空或只包含空白字符，跳过记录
            if (!historyItem.content || historyItem.content.trim() === '') {
                logger.debug(`历史缓存 | 跳过添加 | 节点:${historyItem.node_id} | 原因:空内容`);
                return false;
            }

            // 内容长度限制
            let content = historyItem.content;
            if (content.length > CACHE_CONFIG.MAX_CONTENT_LENGTH) {
                content = content.substring(0, CACHE_CONFIG.MAX_CONTENT_LENGTH) + "...";
            }

            // 检查是否为重复的翻译记录
            if (this.isRepeatedTranslation(historyItem.node_id, historyItem.input_id, content, historyItem.operation_type)) {
                logger.debug(`历史缓存 | 跳过添加 | 节点:${historyItem.node_id} | 原因:重复的翻译记录`);
                return false;
            }

            const allHistory = this.getAllHistory();

            // 获取当前节点和输入框的历史记录
            const nodeHistory = allHistory.filter(item =>
                item.node_id === historyItem.node_id &&
                item.input_id === historyItem.input_id
            );

            // 检查是否与最近的一条历史记录内容相同
            if (nodeHistory.length > 0) {
                // 按时间戳降序排序，获取最新的记录
                const latestHistory = nodeHistory.sort((a, b) => b.timestamp - a.timestamp)[0];
                if (latestHistory.content === content) {
                    logger.debug(`历史缓存 | 跳过添加 | 节点:${historyItem.node_id} | 原因:与上一条记录相同`);
                    return false;
                }
            }

            // 创建新的历史记录
            const newItem = {
                workflow_id: app.graph?._workflow_id || 'unknown',
                node_id: historyItem.node_id,
                input_id: historyItem.input_id,
                content: content,
                operation_type: historyItem.operation_type || null,
                timestamp: Date.now() + 1, // 确保时间戳唯一
                request_id: historyItem.request_id || null
            };

            // 添加到历史记录末尾
            allHistory.push(newItem);

            // 限制每个节点的历史记录数量
            const currentNodeHistory = allHistory.filter(item => item.node_id === historyItem.node_id);
            if (currentNodeHistory.length > CACHE_CONFIG.MAX_HISTORY_PER_NODE) {
                // 按时间戳排序
                currentNodeHistory.sort((a, b) => b.timestamp - a.timestamp);
                // 获取要保留的记录的时间戳
                const cutoffTimestamp = currentNodeHistory[CACHE_CONFIG.MAX_HISTORY_PER_NODE - 1].timestamp;
                // 移除旧记录
                const filteredHistory = allHistory.filter(item =>
                    item.node_id !== historyItem.node_id ||
                    item.timestamp >= cutoffTimestamp
                );
                allHistory.length = 0;
                allHistory.push(...filteredHistory);
            }

            // 限制全局历史记录数量
            if (allHistory.length > CACHE_CONFIG.MAX_HISTORY_GLOBAL) {
                // 按时间戳排序
                allHistory.sort((a, b) => b.timestamp - a.timestamp);
                allHistory.length = CACHE_CONFIG.MAX_HISTORY_GLOBAL;
            }

            this.saveAllHistory(allHistory);
            // logger.debug(`历史缓存 | 添加历史 | 节点:${historyItem.node_id} | 内容长度:${content.length}`);
            return true;
        } catch (error) {
            logger.error(`历史缓存 | 添加历史失败 | 错误:${error.message}`);
            return false;
        }
    }

    /**
     * 初始化撤销状态
     */
    static initUndoState(nodeId, inputId, currentContent) {
        try {
            const key = `${nodeId}_${inputId}`;

            // 获取该输入框的历史记录（从旧到新）
            const inputHistory = this.getInputHistory(nodeId, inputId, true);

            // 创建撤销状态，指向最新的记录
            const undoState = {
                currentIndex: inputHistory.length - 1, // 指向最后一条记录
                currentContent: currentContent,    // 保存当前内容
                lastHistoryTimestamp: inputHistory.length > 0 ? inputHistory[inputHistory.length - 1].timestamp : 0
            };

            // 更新撤销状态
            this.undoStates.set(key, undoState);

            // logger.debug(`历史缓存 | 初始化撤销状态 | 节点:${nodeId} | 输入框:${inputId} | 历史数:${inputHistory.length} | 当前位置:${undoState.currentIndex}`);
        } catch (error) {
            logger.error(`历史缓存 | 初始化撤销状态失败 | 节点:${nodeId} | 输入框:${inputId} | 错误:${error.message}`);
        }
    }

    /**
     * 执行撤销操作
     */
    static undo(nodeId, inputId) {
        try {
            const key = `${nodeId}_${inputId}`;
            const state = this.undoStates.get(key);

            if (!state) {
                return null;
            }

            // 获取历史记录（从旧到新）
            const history = this.getInputHistory(nodeId, inputId, true);

            // 如果没有历史记录，返回null
            if (history.length === 0) {
                return null;
            }

            // 如果已经是第一条记录，无法继续撤销
            if (state.currentIndex <= 0) {
                return null;
            }

            // 更新当前位置
            state.currentIndex--;

            // 从历史记录中获取内容
            const content = history[state.currentIndex]?.content || '';

            // 更新状态
            this.undoStates.set(key, state);

            // logger.debug(`历史缓存 | 撤销操作 | 节点:${nodeId} | 输入框:${inputId} | 位置:${state.currentIndex}/${history.length - 1} | 内容:${content}`);
            return content;
        } catch (error) {
            logger.error(`历史缓存 | 撤销操作失败 | 节点:${nodeId} | 输入框:${inputId} | 错误:${error.message}`);
            return null;
        }
    }

    /**
     * 执行重做操作
     */
    static redo(nodeId, inputId) {
        try {
            const key = `${nodeId}_${inputId}`;
            const state = this.undoStates.get(key);

            if (!state) {
                return null;
            }

            // 获取历史记录（从旧到新）
            const history = this.getInputHistory(nodeId, inputId, true);

            // 如果没有历史记录，返回null
            if (history.length === 0) {
                return null;
            }

            // 如果已经是最后一条记录，无法重做
            if (state.currentIndex >= history.length - 1) {
                return null;
            }

            // 更新当前位置
            state.currentIndex++;

            // 从历史记录中获取内容
            const content = history[state.currentIndex]?.content || '';

            // 更新状态
            this.undoStates.set(key, state);

            logger.debug(`历史缓存 | 重做操作 | 节点:${nodeId} | 输入框:${inputId} | 位置:${state.currentIndex}/${history.length - 1} | 内容:${content}`);
            return content;
        } catch (error) {
            logger.error(`历史缓存 | 重做操作失败 | 节点:${nodeId} | 输入框:${inputId} | 错误:${error.message}`);
            return null;
        }
    }

    /**
     * 检查是否可以撤销
     */
    static canUndo(nodeId, inputId) {
        try {
            const key = `${nodeId}_${inputId}`;
            const state = this.undoStates.get(key);
            return state && state.currentIndex > 0;
        } catch (error) {
            logger.error(`历史缓存 | 检查撤销状态失败 | 节点:${nodeId} | 输入框:${inputId} | 错误:${error.message}`);
            return false;
        }
    }

    /**
     * 检查是否可以重做
     */
    static canRedo(nodeId, inputId) {
        try {
            const key = `${nodeId}_${inputId}`;
            const state = this.undoStates.get(key);
            if (!state) return false;

            const history = this.getInputHistory(nodeId, inputId, true);
            return state.currentIndex < history.length - 1;
        } catch (error) {
            logger.error(`历史缓存 | 检查重做状态失败 | 节点:${nodeId} | 输入框:${inputId} | 错误:${error.message}`);
            return false;
        }
    }

    /**
     * 清除所有历史记录
     */
    static clearAllHistory() {
        try {
            // 清除所有历史记录
            this.saveAllHistory([]);
            // 清除所有撤销状态
            this.undoStates.clear();
            // logger.debug("历史缓存 | 清除所有历史");
        } catch (error) {
            logger.error(`历史缓存 | 清除所有历史失败 | 错误:${error.message}`);
        }
    }

    /**
     * 清除指定节点的历史记录
     */
    static clearNodeHistory(nodeId) {
        try {
            // 获取所有历史记录
            const allHistory = this.getAllHistory();

            // 过滤出不属于该节点的记录
            const filteredHistory = allHistory.filter(item => item.node_id !== nodeId);

            // 保存过滤后的历史记录
            this.saveAllHistory(filteredHistory);

            // 清除该节点的撤销状态
            for (const [key] of this.undoStates) {
                if (key.startsWith(nodeId + "_")) {
                    this.undoStates.delete(key);
                }
            }

            // logger.debug(`历史缓存 | 清除节点历史 | 节点:${nodeId}`);
        } catch (error) {
            logger.error(`历史缓存 | 清除节点历史失败 | 节点:${nodeId} | 错误:${error.message}`);
        }
    }

    /**
     * 清除指定工作流的所有历史记录
     */
    static clearWorkflowHistory(workflowId) {
        if (!workflowId) return;
        try {
            const allHistory = this.getAllHistory();
            const filteredHistory = allHistory.filter(item => item.workflow_id !== workflowId);
            this.saveAllHistory(filteredHistory);
            // logger.debug(`历史缓存 | 清除工作流历史 | 工作流ID:${workflowId}`);
        } catch (error) {
            logger.error(`历史缓存 | 清除工作流历史失败 | 工作流ID:${workflowId} | 错误:${error.message}`);
        }
    }

    /**
     * 添加历史记录并更新撤销状态
     */
    static addHistoryAndUpdateUndoState(nodeId, inputId, content, operationType = 'input') {
        // 首先尝试添加历史记录
        const success = this.addHistory({
            node_id: nodeId,
            input_id: inputId,
            content: content,
            operation_type: operationType,
            timestamp: Date.now()
        });

        if (success) {
            // 更新撤销状态
            const key = `${nodeId}_${inputId}`;
            const state = this.undoStates.get(key) || {
                currentIndex: 0,
                currentContent: content,
                lastHistoryTimestamp: 0
            };

            // 获取最新的历史记录
            const history = this.getInputHistory(nodeId, inputId, true);

            // 更新状态
            state.currentIndex = history.length - 1;
            state.currentContent = content;
            state.lastHistoryTimestamp = Date.now();

            // 保存状态
            this.undoStates.set(key, state);

            // logger.debug(`历史缓存 | 更新撤销状态 | 节点:${nodeId} | 输入框:${inputId} | 位置:${state.currentIndex}`);
        }

        return success;
    }

    /**
     * 获取历史记录统计信息
     */
    static getHistoryStats() {
        try {
            const allHistory = this.getAllHistory();
            const stats = {
                total: allHistory.length,
                byNode: {}
            };

            // 按节点统计
            allHistory.forEach(item => {
                if (!stats.byNode[item.node_id]) {
                    stats.byNode[item.node_id] = 0;
                }
                stats.byNode[item.node_id]++;
            });

            // logger.debug(`历史缓存 | 获取统计 | 总数:${stats.total} | 节点数:${Object.keys(stats.byNode).length}`);
            return stats;
        } catch (error) {
            logger.error(`历史缓存 | 获取统计失败 | 错误:${error.message}`);
            return { total: 0, byNode: {} };
        }
    }

    /**
     * 修改历史记录项的操作类型
     */
    static updateHistoryItemType(nodeId, inputId, timestamp, newType) {
        try {
            // 获取所有历史记录
            const allHistory = this.getAllHistory();

            // 查找匹配的历史记录
            const itemIndex = allHistory.findIndex(item =>
                item.node_id === nodeId &&
                item.input_id === inputId &&
                item.timestamp === timestamp
            );

            // 如果找到匹配的记录，修改其操作类型
            if (itemIndex !== -1) {
                allHistory[itemIndex].operation_type = newType;

                // 保存修改后的历史记录
                this.saveAllHistory(allHistory);

                // logger.debug(`历史缓存 | 修改操作类型 | 节点:${nodeId} | 输入框:${inputId} | 类型:${newType}`);
                return true;
            } else {
                // logger.debug(`历史缓存 | 修改操作类型失败 | 未找到匹配记录 | 节点:${nodeId} | 输入框:${inputId}`);
                return false;
            }
        } catch (error) {
            logger.error(`历史缓存 | 修改操作类型失败 | 错误:${error.message}`);
            return false;
        }
    }

    /**
     * 更新历史记录项
     */
    static updateHistoryItem(nodeId, inputId, timestamp, updates) {
        try {
            // 获取所有历史记录
            const allHistory = this.getAllHistory();

            // 查找匹配的历史记录
            const itemIndex = allHistory.findIndex(item =>
                item.node_id === nodeId &&
                item.input_id === inputId &&
                item.timestamp === timestamp
            );

            // 如果找到匹配的记录，更新指定字段
            if (itemIndex !== -1) {
                // 更新所有提供的字段
                Object.assign(allHistory[itemIndex], updates);

                // 保存修改后的历史记录
                this.saveAllHistory(allHistory);

                logger.debug(`历史缓存 | 更新记录 | 节点:${nodeId} | 输入框:${inputId} | 字段:${Object.keys(updates).join(',')}`);
                return true;
            } else {
                logger.debug(`历史缓存 | 更新失败 | 未找到匹配记录 | 节点:${nodeId} | 输入框:${inputId}`);
                return false;
            }
        } catch (error) {
            logger.error(`历史缓存 | 更新记录失败 | 错误:${error.message}`);
            return false;
        }
    }

    /**
     * 根据请求ID获取相关联的历史记录
     */
    static getHistoryByRequestId(requestId) {
        try {
            if (!requestId) return [];

            const allHistory = this.getAllHistory();
            return allHistory.filter(item =>
                item.request_id === requestId
            ).sort((a, b) => b.timestamp - a.timestamp);
        } catch (error) {
            logger.error(`历史缓存 | 获取请求关联历史失败 | 请求ID:${requestId} | 错误:${error.message}`);
            return [];
        }
    }
}

/**
 * 标签缓存服务
 * 管理标签的缓存操作
 */
class TagCacheService {
    /**
     * 获取或创建标签格式
     */
    static getOrCreateFormats(rawTag) {
        return PromptFormatter.formatTag(rawTag);
    }

    /**
     * 获取所有标签缓存
     */
    static getAllTagCache() {
        try {
            const data = CacheService.get(CACHE_CONFIG.TAG_CACHE_KEY);
            return data || {};
        } catch (error) {
            logger.error(`标签缓存 | 获取所有缓存失败 | 错误:${error.message}`);
            return {};
        }
    }

    /**
     * 保存所有标签缓存
     */
    static saveAllTagCache(cache) {
        try {
            CacheService.set(CACHE_CONFIG.TAG_CACHE_KEY, cache);
        } catch (error) {
            logger.error(`标签缓存 | 保存所有缓存失败 | 错误:${error.message}`);
        }
    }

    /**
     * 获取标签缓存
     */
    static getTagCache(nodeId, inputId) {
        try {
            const allCache = this.getAllTagCache();
            const workflowId = app.graph?._workflow_id || 'unknown';
            const key = `${workflowId}_${nodeId}_${inputId}`;
            const data = allCache[key] || {};
            return new Map(Object.entries(data));
        } catch (error) {
            logger.error(`标签缓存 | 获取缓存失败 | 节点:${nodeId} | 输入框:${inputId} | 错误:${error.message}`);
            return new Map();
        }
    }

    /**
     * 添加标签到缓存
     */
    static addTag(nodeId, inputId, rawTag, formats) {
        try {
            const allCache = this.getAllTagCache();
            const workflowId = app.graph?._workflow_id || 'unknown';
            const key = `${workflowId}_${nodeId}_${inputId}`;
            const cache = this.getTagCache(nodeId, inputId);

            // 确保formats包含所有必要的格式
            const format1 = formats.format1 || ` ${rawTag}`;
            const format2 = formats.format2 || ` ${rawTag},`;
            const format3 = formats.format3 || `, ${rawTag}`;
            const format4 = formats.format4 || `, ${rawTag},`;
            const insertedFormat = formats.insertedFormat || null;

            // 如果标签已存在，直接更新
            if (cache.has(rawTag)) {
                cache.set(rawTag, {
                    format1,
                    format2,
                    format3,
                    format4,
                    insertedFormat
                });
                allCache[key] = Object.fromEntries(cache);
                this.saveAllTagCache(allCache);
                logger.debug(`标签缓存 | 更新标签 | 节点:${nodeId} | 输入框:${inputId} | 标签:${rawTag}`);
                return true;
            }

            // 检查当前输入框的标签数量限制
            if (cache.size >= CACHE_CONFIG.MAX_TAGS_PER_INPUT) {
                // 获取所有标签及其最后使用时间
                const tagEntries = Array.from(cache.entries()).map(([tag, formats]) => ({
                    tag,
                    formats,
                    lastUsed: formats.lastUsed || 0
                }));

                // 按最后使用时间排序
                tagEntries.sort((a, b) => a.lastUsed - b.lastUsed);

                // 删除最旧的标签
                const oldestTag = tagEntries[0].tag;
                cache.delete(oldestTag);
                logger.debug(`标签缓存 | 自动淘汰 | 节点:${nodeId} | 输入框:${inputId} | 淘汰标签:${oldestTag}`);
            }

            // 检查全局标签数量限制
            let totalTags = 0;
            const allTags = [];
            for (const [cacheKey, inputTags] of Object.entries(allCache)) {
                const [wfId, nId, iId] = cacheKey.split('_');
                for (const [tag, tagFormats] of Object.entries(inputTags)) {
                    allTags.push({
                        workflowId: wfId,
                        nodeId: nId,
                        inputId: iId,
                        tag,
                        lastUsed: tagFormats.lastUsed || 0
                    });
                }
                totalTags += Object.keys(inputTags).length;
            }

            if (totalTags >= CACHE_CONFIG.MAX_TAGS_GLOBAL) {
                // 按最后使用时间排序
                allTags.sort((a, b) => a.lastUsed - b.lastUsed);

                // 删除最旧的标签
                const oldest = allTags[0];
                const oldKey = `${oldest.workflowId}_${oldest.nodeId}_${oldest.inputId}`;
                const oldCache = new Map(Object.entries(allCache[oldKey] || {}));
                oldCache.delete(oldest.tag);

                if (oldCache.size > 0) {
                    allCache[oldKey] = Object.fromEntries(oldCache);
                } else {
                    delete allCache[oldKey];
                }

                logger.debug(`标签缓存 | 自动淘汰 | 全局限制 | 淘汰标签:${oldest.tag} | 位置:${oldKey}`);
            }

            // 添加新标签
            cache.set(rawTag, {
                format1,
                format2,
                format3,
                format4,
                insertedFormat,
                lastUsed: Date.now() // 添加最后使用时间
            });

            // 更新全局缓存
            allCache[key] = Object.fromEntries(cache);
            this.saveAllTagCache(allCache);

            logger.debug(`标签缓存 | 添加标签 | 节点:${nodeId} | 输入框:${inputId} | 标签:${rawTag}`);
            return true;
        } catch (error) {
            logger.error(`标签缓存 | 添加标签失败 | 节点:${nodeId} | 输入框:${inputId} | 标签:${rawTag} | 错误:${error.message}`);
            return false;
        }
    }

    /**
     * 从缓存中移除标签
     */
    static removeTag(nodeId, inputId, rawTag) {
        try {
            const allCache = this.getAllTagCache();
            const workflowId = app.graph?._workflow_id || 'unknown';
            const key = `${workflowId}_${nodeId}_${inputId}`;
            const cache = this.getTagCache(nodeId, inputId);

            const result = cache.delete(rawTag);
            if (result) {
                // 更新全局缓存
                if (cache.size > 0) {
                    allCache[key] = Object.fromEntries(cache);
                } else {
                    delete allCache[key];
                }
                this.saveAllTagCache(allCache);
                logger.debug(`标签缓存 | 移除标签 | 节点:${nodeId} | 输入框:${inputId} | 标签:${rawTag}`);
            }
            return result;
        } catch (error) {
            logger.error(`标签缓存 | 移除标签失败 | 节点:${nodeId} | 输入框:${inputId} | 标签:${rawTag} | 错误:${error.message}`);
            return false;
        }
    }

    /**
     * 检查标签是否在输入框中
     */
    static isTagInInput(nodeId, inputId, rawTag, inputValue) {
        try {
            const formats = this.getTagFormats(nodeId, inputId, rawTag);
            if (!formats) {
                return false;
            }

            // 按优先级顺序检查各种格式
            const checkOrder = ['insertedFormat', 'format4', 'format3', 'format2', 'format1'];

            for (const formatKey of checkOrder) {
                const format = formats[formatKey];
                if (format && inputValue.includes(format)) {
                    // logger.debug(`标签检查 | 结果:已存在 | 节点:${nodeId} | 输入框:${inputId} | 标签:${rawTag} | 匹配格式:${formatKey}`);
                    return true;
                }
            }

            return false;
        } catch (error) {
            logger.error(`标签检查 | 结果:异常 | 节点:${nodeId} | 输入框:${inputId} | 标签:${rawTag} | 错误:${error.message}`);
            return false;
        }
    }

    /**
     * 获取标签的所有格式
     */
    static getTagFormats(nodeId, inputId, rawTag) {
        try {
            const cache = this.getTagCache(nodeId, inputId);
            return cache.get(rawTag) || null;
        } catch (error) {
            logger.error(`标签缓存 | 获取标签格式失败 | 节点:${nodeId} | 输入框:${inputId} | 标签:${rawTag} | 错误:${error.message}`);
            return null;
        }
    }

    /**
     * 获取标签的插入格式
     */
    static getInsertedFormat(nodeId, inputId, rawTag) {
        try {
            const formats = this.getTagFormats(nodeId, inputId, rawTag);
            return formats ? formats.insertedFormat : null;
        } catch (error) {
            logger.error(`标签缓存 | 获取插入格式失败 | 节点:${nodeId} | 输入框:${inputId} | 标签:${rawTag} | 错误:${error.message}`);
            return null;
        }
    }

    /**
     * 获取所有原始标签
     */
    static getAllRawTags(nodeId, inputId) {
        try {
            const cache = this.getTagCache(nodeId, inputId);
            return Array.from(cache.keys());
        } catch (error) {
            logger.error(`标签缓存 | 获取所有标签失败 | 节点:${nodeId} | 输入框:${inputId} | 错误:${error.message}`);
            return [];
        }
    }

    /**
     * 清除标签缓存
     */
    static clearCache(nodeId, inputId) {
        try {
            const allCache = this.getAllTagCache();
            const workflowId = app.graph?._workflow_id || 'unknown';
            const key = `${workflowId}_${nodeId}_${inputId}`;

            // 删除指定节点的缓存
            if (allCache[key]) {
                delete allCache[key];
                this.saveAllTagCache(allCache);
            }

            // logger.debug(`标签缓存 | 清除缓存 | 节点:${nodeId} | 输入框:${inputId}`);
        } catch (error) {
            logger.error(`标签缓存 | 清除缓存失败 | 节点:${nodeId} | 输入框:${inputId} | 错误:${error.message}`);
        }
    }

    /**
     * 获取标签统计信息
     */
    static getTagStats() {
        try {
            const allCache = this.getAllTagCache();
            let total = 0;
            const byNode = {};

            // 遍历所有缓存计算统计信息
            for (const [key, tags] of Object.entries(allCache)) {
                const [workflowId, nodeId, inputId] = key.split('_');
                const count = Object.keys(tags).length;

                total += count;
                if (!byNode[nodeId]) {
                    byNode[nodeId] = {};
                }
                byNode[nodeId][inputId] = count;
            }

            const stats = { total, byNode };
            // logger.debug(`标签缓存 | 获取统计 | 总数:${total} | 节点数:${Object.keys(byNode).length}`);
            return stats;
        } catch (error) {
            logger.error(`标签缓存 | 获取统计失败 | 错误:${error.message}`);
            return { total: 0, byNode: {} };
        }
    }

    /**
     * 更新标签的插入格式
     */
    static updateInsertedFormat(nodeId, inputId, rawTag, insertedFormat) {
        try {
            const allCache = this.getAllTagCache();
            const workflowId = app.graph?._workflow_id || 'unknown';
            const key = `${workflowId}_${nodeId}_${inputId}`;
            const cache = this.getTagCache(nodeId, inputId);
            const formats = cache.get(rawTag);

            if (!formats) {
                logger.debug(`标签缓存 | 更新插入格式失败 | 原因:标签不存在 | 节点:${nodeId} | 输入框:${inputId} | 标签:${rawTag}`);
                return false;
            }

            // 更新插入格式
            formats.insertedFormat = insertedFormat;
            cache.set(rawTag, formats);

            // 更新全局缓存
            allCache[key] = Object.fromEntries(cache);
            this.saveAllTagCache(allCache);

            logger.debug(`标签缓存 | 更新插入格式 | 节点:${nodeId} | 输入框:${inputId} | 标签:${rawTag} | 新格式:${insertedFormat}`);
            return true;
        } catch (error) {
            logger.error(`标签缓存 | 更新插入格式失败 | 节点:${nodeId} | 输入框:${inputId} | 标签:${rawTag} | 错误:${error.message}`);
            return false;
        }
    }

    /**
     * 更新标签的最后使用时间
     */
    static updateTagLastUsed(nodeId, inputId, rawTag) {
        try {
            const allCache = this.getAllTagCache();
            const workflowId = app.graph?._workflow_id || 'unknown';
            const key = `${workflowId}_${nodeId}_${inputId}`;
            const cache = this.getTagCache(nodeId, inputId);

            if (cache.has(rawTag)) {
                const tagData = cache.get(rawTag);
                tagData.lastUsed = Date.now();
                cache.set(rawTag, tagData);
                allCache[key] = Object.fromEntries(cache);
                this.saveAllTagCache(allCache);
                logger.debug(`标签缓存 | 更新使用时间 | 节点:${nodeId} | 输入框:${inputId} | 标签:${rawTag}`);
            }
        } catch (error) {
            logger.error(`标签缓存 | 更新使用时间失败 | 节点:${nodeId} | 输入框:${inputId} | 标签:${rawTag} | 错误:${error.message}`);
        }
    }

    /**
     * 清除指定工作流的所有标签
     */
    static clearWorkflowTags(workflowId) {
        if (!workflowId) return;
        try {
            const allCache = this.getAllTagCache();
            const newCache = {};
            for (const key in allCache) {
                // key format is `${workflowId}_${nodeId}_${inputId}`
                if (!key.startsWith(workflowId + '_')) {
                    newCache[key] = allCache[key];
                }
            }
            this.saveAllTagCache(newCache);
            logger.debug(`标签缓存 | 清除工作流标签 | 工作流ID:${workflowId}`);
        } catch (error) {
            logger.error(`标签缓存 | 清除工作流标签失败 | 工作流ID:${workflowId} | 错误:${error.message}`);
        }
    }

    /**
     * 清除所有标签缓存
     */
    static clearAllTagCache() {
        try {
            CacheService.remove(CACHE_CONFIG.TAG_CACHE_KEY);
            logger.debug("标签缓存 | 清除所有缓存");
        } catch (error) {
            logger.error(`标签缓存 | 清除缓存失败 | 错误:${error.message}`);
        }
    }
}

/**
 * 翻译缓存服务
 * 管理翻译结果的缓存操作
 */
class TranslateCacheService {
    /**
     * 获取所有翻译缓存
     */
    static getAllTranslateCache() {
        try {
            const data = CacheService.get(CACHE_CONFIG.TRANSLATE_CACHE_KEY);
            if (data) {
                return new Map(Object.entries(data));
            }
            return new Map();
        } catch (error) {
            logger.error(`翻译缓存 | 获取缓存失败 | 错误:${error.message}`);
            return new Map();
        }
    }

    /**
     * 保存所有翻译缓存
     */
    static saveAllTranslateCache(cache) {
        try {
            // 将Map转换为普通对象
            const data = Object.fromEntries(cache);
            CacheService.set(CACHE_CONFIG.TRANSLATE_CACHE_KEY, data);
        } catch (error) {
            logger.error(`翻译缓存 | 保存缓存失败 | 错误:${error.message}`);
        }
    }

    /**
     * 添加翻译缓存
     */
    static addTranslateCache(sourceText, translatedText) {
        try {
            // 验证参数
            if (!sourceText || !translatedText) {
                logger.error("翻译缓存 | 添加缓存失败 | 缺少必要参数");
                return false;
            }

            // 获取现有缓存
            const cache = this.getAllTranslateCache();

            // 添加或更新缓存
            cache.set(sourceText, translatedText);

            // 如果缓存过大，删除最旧的条目
            if (cache.size > CACHE_CONFIG.MAX_TRANSLATE_CACHE) {
                // 将Map转换为数组以便操作
                const entries = Array.from(cache.entries());
                // 删除最早的条目，保留最新的MAX_TRANSLATE_CACHE条
                const newEntries = entries.slice(-CACHE_CONFIG.MAX_TRANSLATE_CACHE);
                // 重建缓存
                cache.clear();
                newEntries.forEach(([key, value]) => cache.set(key, value));
            }

            // 保存缓存
            this.saveAllTranslateCache(cache);
            logger.debug(`翻译缓存 | 添加缓存 | 原文长度:${sourceText.length} | 译文长度:${translatedText.length}`);
            return true;
        } catch (error) {
            logger.error(`翻译缓存 | 添加缓存失败 | 错误:${error.message}`);
            return false;
        }
    }

    /**
     * 查询翻译缓存
     */
    static queryTranslateCache(text) {
        try {
            if (!text) return null;

            const cache = this.getAllTranslateCache();

            // 检查是否为原文(key)
            if (cache.has(text)) {
                const translatedText = cache.get(text);
                // logger.debug(`翻译缓存 | 查询结果:命中原文 | 原文长度:${text.length} | 译文长度:${translatedText.length}`);
                return {
                    type: 'source',
                    text: text,
                    translatedText: translatedText
                };
            }

            // 检查是否为译文(value)
            for (const [source, translated] of cache.entries()) {
                if (translated === text) {
                    logger.debug(`翻译缓存 | 查询结果:命中译文 | 原文长度:${source.length} | 译文长度:${text.length}`);
                    return {
                        type: 'translated',
                        text: text,
                        sourceText: source
                    };
                }
            }

            // 未命中缓存
            logger.debug(`翻译缓存 | 查询结果:未命中 | 文本长度:${text.length}`);
            return null;
        } catch (error) {
            logger.error(`翻译缓存 | 查询缓存失败 | 错误:${error.message}`);
            return null;
        }
    }

    /**
     * 清除所有翻译缓存
     */
    static clearAllTranslateCache() {
        try {
            CacheService.remove(CACHE_CONFIG.TRANSLATE_CACHE_KEY);
            logger.debug("翻译缓存 | 清除所有缓存");
        } catch (error) {
            logger.error(`翻译缓存 | 清除缓存失败 | 错误:${error.message}`);
        }
    }

    /**
     * 获取翻译缓存统计信息
     */
    static getTranslateCacheStats() {
        try {
            const cache = this.getAllTranslateCache();
            const stats = {
                total: cache.size,
                sourceTextLengths: 0,
                translatedTextLengths: 0
            };

            // 计算原文和译文的总长度
            for (const [source, translated] of cache.entries()) {
                stats.sourceTextLengths += source.length;
                stats.translatedTextLengths += translated.length;
            }

            logger.debug(`翻译缓存 | 获取统计 | 总数:${stats.total} | 原文总长度:${stats.sourceTextLengths} | 译文总长度:${stats.translatedTextLengths}`);
            return stats;
        } catch (error) {
            logger.error(`翻译缓存 | 获取统计失败 | 错误:${error.message}`);
            return { total: 0, sourceTextLengths: 0, translatedTextLengths: 0 };
        }
    }
}

export { CacheService, HistoryCacheService, TagCacheService, TranslateCacheService, CACHE_CONFIG };