/**
 * 正则处理工具
 * 
 * 在前端渲染消息时应用 markdownOnly 正则规则
 * markdownOnly=true 的规则只影响显示，不影响存储的数据
 */
import usePresetStore from '../Store/SideBarLeft/PresetSlice';

// 全局缓存正则规则
let cachedRules = [];
let lastFetchTime = 0;
const CACHE_DURATION = 5 * 60 * 1000; // 5分钟缓存

/**
 * 获取正则规则（带缓存）
 */
async function fetchRules() {
  const now = Date.now();
  
  // 如果缓存未过期，直接返回
  if (cachedRules.length > 0 && (now - lastFetchTime) < CACHE_DURATION) {
    return cachedRules;
  }
  
  try {
    const response = await fetch('/api/regex/rules');
    const data = await response.json();
    
    if (data.success && data.rules) {
      cachedRules = data.rules;
      lastFetchTime = now;
      return data.rules;
    }
  } catch (error) {
    console.error('[Regex Processor] 加载正则规则失败:', error);
  }
  
  return cachedRules;
}

/**
 * 应用正则规则到文本（用于前端显示）
 * 
 * @param {string} text - 原始文本
 * @param {Array} rules - 所有正则规则
 * @param {number} messageDepth - 消息深度
 * @returns {string} - 处理后的文本（仅用于显示）
 */
function applyRulesForDisplay(text, rules, messageDepth = 0) {
  if (!text || !rules || rules.length === 0) {
    return text;
  }

  let result = text;

  // 筛选出适用于前端显示的规则
  const displayRules = rules.filter(rule => {
    // 检查是否禁用了
    if (rule.disabled) return false;
    
    // 检查 placement 是否包含 AI_OUTPUT (2)
    const placements = rule.placement || [];
    if (!placements.includes(2)) return false;
    
    // ✅ SillyTavern 逻辑：
    // - 双 false：应用到所有场景（包括显示）
    // - markdownOnly=true：只应用于显示
    // - promptOnly=true：不应用于显示
    // - 双 true：应用到所有场景（包括显示）
    if (rule.promptOnly && !rule.markdownOnly) {
      // 只影响提示词，不影响显示
      return false;
    }
    
    // 其他情况都应用于显示
    // - 双 false：应用
    // - markdownOnly=true：应用
    // - 双 true：应用
    
    // 检查消息深度
    if (messageDepth < (rule.minDepth || 0)) return false;
    if (rule.maxDepth !== null && rule.maxDepth !== undefined && messageDepth > rule.maxDepth) {
      return false;
    }
    
    return true;
  });

  // 按 order 排序
  displayRules.sort((a, b) => a.order - b.order);

  // 应用规则
  for (const rule of displayRules) {
    result = applySingleRule(result, rule);
  }

  return result;
}

/**
 * 应用单条正则规则
 */
function applySingleRule(text, rule) {
  try {
    const { findRegex, replaceString, substituteRegex, trimStrings } = rule;

    if (!findRegex) {
      return text;
    }

    // 解析正则表达式和标志
    let pattern = findRegex;
    let flags = 'g'; // 默认全局匹配

    // 提取标志（如果格式为 /pattern/flags）
    if (findRegex.startsWith('/') && findRegex.lastIndexOf('/') > 0) {
      const lastSlashIndex = findRegex.lastIndexOf('/');
      pattern = findRegex.slice(1, lastSlashIndex);
      const extractedFlags = findRegex.slice(lastSlashIndex + 1);
      if (extractedFlags) {
        flags = extractedFlags;
      }
    }

    // 创建正则表达式对象
    const regex = new RegExp(pattern, flags);

    // 根据替换模式执行替换
    let replaced;
    if (substituteRegex === 1) {
      // REPLACE_FIRST: 仅替换首次匹配
      replaced = text.replace(regex, replaceString || '');
    } else {
      // REPLACE_ALL (0) 或 REPLACE_CAPTURED (2): 替换所有匹配
      replaced = text.replace(regex, replaceString || '');
    }

    // 应用 trimStrings（删除指定的字符串）
    if (trimStrings && Array.isArray(trimStrings)) {
      for (const trimStr of trimStrings) {
        replaced = replaced.split(trimStr).join('');
      }
    }

    return replaced;
  } catch (error) {
    console.error(`[Regex Processor] 正则规则执行错误 [${rule.scriptName}]:`, error);
    return text; // 出错时返回原文本
  }
}

/**
 * 处理文本的正则显示效果
 * 
 * @param {string} originalText - 原始文本（从后端获取的，未处理的）
 * @param {number} messageDepth - 消息深度（0=最新消息）
 * @param {boolean} isUserMessage - 是否为用户消息
 * @returns {Promise<string>} - 处理后的文本（用于显示）
 */
export async function processTextForDisplay(originalText, messageDepth = 0, isUserMessage = false) {
  if (isUserMessage) {
    // 用户消息不应用 markdownOnly 规则
    return originalText;
  }

  const rules = await fetchRules();
  return applyMarkdownOnlyRules(originalText, rules, messageDepth);
}

export default processTextForDisplay;
