/**
 * 正则替换工具函数
 * 
 * 在前端应用正则规则到消息显示，不影响原始数据存储。
 * 参考 SillyTavern 的正则处理逻辑。
 */

/**
 * 应用正则规则到文本
 * 
 * @param {string} text - 原始文本
 * @param {Array} rules - 正则规则数组
 * @param {number} messageDepth - 消息深度（从最新消息开始计数，0表示最新）
 * @returns {string} - 处理后的文本（仅用于显示）
 */
export function applyRegexRules(text, rules, messageDepth = 0) {
  if (!text || !rules || rules.length === 0) {
    return text;
  }

  let result = text;

  // 按 order 排序规则
  const sortedRules = [...rules].sort((a, b) => a.order - b.order);

  for (const rule of sortedRules) {
    // 跳过禁用的规则
    if (!rule.enabled) {
      continue;
    }

    // 检查消息深度限制
    if (messageDepth < rule.minDepth) {
      continue;
    }
    if (rule.maxDepth !== null && rule.maxDepth !== undefined && messageDepth > rule.maxDepth) {
      continue;
    }

    // 应用单条规则
    result = applySingleRule(result, rule);
  }

  return result;
}

/**
 * 应用单条正则规则
 * 
 * @param {string} text - 输入文本
 * @param {Object} rule - 正则规则对象
 * @returns {string} - 处理后的文本
 */
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(`正则规则执行错误 [${rule.name}]:`, error);
    return text; // 出错时返回原文本
  }
}

/**
 * 根据作用域过滤适用的规则
 * 
 * @param {Array} allRules - 所有规则
 * @param {string|null} characterId - 当前角色卡 ID
 * @param {string|null} presetId - 当前预设 ID
 * @returns {Array} - 适用的规则数组
 */
export function filterRulesByScope(allRules, characterId = null, presetId = null) {
  if (!allRules || !Array.isArray(allRules)) {
    return [];
  }

  return allRules.filter(rule => {
    // 跳过禁用的规则
    if (!rule.enabled) {
      return false;
    }

    // 根据作用域过滤
    switch (rule.scope) {
      case 'global':
        return true;
      case 'character':
        return rule.characterId === characterId;
      case 'preset':
        return rule.presetId === presetId;
      default:
        return false;
    }
  });
}

/**
 * 隐藏思考标签的示例规则
 * 
 * @returns {Object} - 规则对象
 */
export function createHideThinkingRule() {
  return {
    id: 'rule-hide-thinking',
    name: '隐藏思考标签',
    findRegex: '<thinking>[\\s\\S]*?<\\/thinking>',
    replaceString: '',
    trimStrings: [],
    substituteRegex: 0, // REPLACE_ALL
    markdownOnly: false,
    promptOnly: false,
    runOnEdit: true,
    minDepth: 0,
    maxDepth: null,
    scope: 'global',
    characterId: null,
    presetId: null,
    enabled: true,
    order: 1,
    description: '隐藏 AI 回复中的 <thinking> 标签及其内容'
  };
}
