/**
 * 意图路由工具管理器
 * 根据用户输入智能选择要传递给 LLM 的工具
 */

const { EventEmitter } = require('../utils/event-emitter');

/**
 * 内置意图分类
 */
const INTENT_PATTERNS = {
  file_operation: {
    keywords: [
      '读取文件',
      '写文件',
      '创建文件',
      '删除文件',
      '修改文件',
      '查看文件',
      'read',
      'write',
      'create',
      'delete',
      'modify',
      'file',
      '文件',
    ],
    tools: [
      'read_file',
      'write_file',
      'delete_file',
      'modify_file',
      'read_directory',
      'create_directory',
      'search_file',
    ],
  },
  code_development: {
    keywords: [
      '写代码',
      '开发',
      '编程',
      '创建插件',
      '编写函数',
      'code',
      'develop',
      'plugin',
      '编程',
    ],
    tools: ['loadSkill', 'read_file', 'write_file', 'execute_command', 'shell'],
  },
  system_info: {
    keywords: [
      '系统信息',
      '内存',
      'CPU',
      '磁盘',
      '进程',
      'system',
      'memory',
      'cpu',
      'disk',
      'process',
      'info',
    ],
    tools: [
      'get_system_info',
      'get_memory_usage',
      'get_cpu_info',
      'get_disk_space',
      'get_process_info',
    ],
  },
  data_analysis: {
    keywords: ['分析', '数据', '统计', '查询', 'analyze', 'data', 'statistics', 'query'],
    tools: ['execute_command', 'python', 'search_file'],
  },
  plugin_management: {
    keywords: ['插件', '重载', '加载插件', 'plugin', 'reload', 'load plugin'],
    tools: ['reload_plugins', 'list_plugins', 'loadSkill'],
  },
  shell_command: {
    keywords: ['命令', '终端', 'shell', '执行', 'command', 'terminal', 'bash', 'cmd'],
    tools: ['shell', 'powershell', 'execute_command'],
  },
  skill_usage: {
    keywords: ['技能', 'skill', '使用技能', '加载技能'],
    tools: ['loadSkill'],
  },
  scheduling: {
    keywords: [
      '定时',
      '提醒',
      '通知',
      'schedule',
      'remind',
      'notify',
      'cron',
      '任务',
      '稍后',
      '天后',
      '秒后',
      '分钟后',
      '小时后',
      '明天',
      '今天',
    ],
    tools: [
      'schedule_cron',
      'schedule_once',
      'schedule_list',
      'schedule_cancel',
      'schedule_get_results',
      'schedule_notify',
    ],
  },
  thinking: {
    keywords: [
      '思考',
      '反思',
      '想想',
      'think',
      'reflect',
      '分析一下',
      '头脑风暴',
      '持续思考',
      '自动思考',
    ],
    tools: ['think_now', 'think_continue', 'think_stop', 'think_get_thoughts'],
  },
};

class ToolRouter extends EventEmitter {
  constructor(tools = []) {
    super();
    this._tools = new Map();
    this._defaultTools = new Set();

    // 注册工具
    for (const tool of tools) {
      this.register(tool);
    }
  }

  /**
   * 注册工具
   */
  register(tool) {
    this._tools.set(tool.name, tool);
  }

  /**
   * 设置默认工具（每个请求都会包含）
   */
  setDefaultTools(toolNames) {
    this._defaultTools = new Set(toolNames);
  }

  /**
   * 判断是否为默认工具
   */
  isDefaultTool(name) {
    return this._defaultTools.has(name);
  }

  /**
   * 分析用户输入，识别意图
   */
  analyzeIntent(userMessage) {
    const message = userMessage.toLowerCase();

    const matchedIntents = [];

    for (const [intentName, intentConfig] of Object.entries(INTENT_PATTERNS)) {
      let score = 0;

      for (const keyword of intentConfig.keywords) {
        if (message.includes(keyword.toLowerCase())) {
          score++;
        }
      }

      if (score > 0) {
        matchedIntents.push({
          name: intentName,
          score,
          tools: intentConfig.tools,
        });
      }
    }

    // 按分数排序
    matchedIntents.sort((a, b) => b.score - a.score);

    return matchedIntents;
  }

  /**
   * 获取指定意图对应的工具
   */
  getToolsForIntent(intent) {
    const result = [];

    for (const toolName of intent.tools) {
      const tool = this._tools.get(toolName);
      if (tool) {
        result.push(tool);
      }
    }

    return result;
  }

  /**
   * 为用户消息选择合适的工具
   * @param {string} userMessage - 用户消息
   * @param {Object} options - 选项
   * @param {number} options.maxTools - 最大工具数量（默认10）
   * @param {boolean} options.forceIntent - 强制使用指定意图
   */
  selectTools(userMessage, options = {}) {
    const { maxTools = 10 } = options;

    // 如果没有工具，直接返回空的
    if (this._tools.size === 0) {
      return [];
    }

    // 如果消息为空，返回默认工具
    if (!userMessage || userMessage.trim() === '') {
      return this.getDefaultTools();
    }

    // 分析意图
    const intents = this.analyzeIntent(userMessage);

    // 如果没有匹配到意图，返回默认工具
    if (intents.length === 0) {
      return this.getDefaultTools();
    }

    const selectedTools = new Map();

    // 添加默认工具
    for (const tool of this.getDefaultTools()) {
      selectedTools.set(tool.name, tool);
    }

    // 按意图选择工具
    for (const intent of intents) {
      if (selectedTools.size >= maxTools) break;

      const intentTools = this.getToolsForIntent(intent);
      for (const tool of intentTools) {
        if (selectedTools.size >= maxTools) break;
        if (!selectedTools.has(tool.name)) {
          selectedTools.set(tool.name, tool);
        }
      }
    }

    return Array.from(selectedTools.values());
  }

  /**
   * 获取默认工具
   */
  getDefaultTools() {
    const result = [];
    for (const name of this._defaultTools) {
      const tool = this._tools.get(name);
      if (tool) {
        result.push(tool);
      }
    }
    return result;
  }

  /**
   * 获取所有工具
   */
  getAllTools() {
    return Array.from(this._tools.values());
  }

  /**
   * 按类别获取工具
   */
  getToolsByCategory(category) {
    const intent = INTENT_PATTERNS[category];
    if (!intent) return [];

    return intent.tools.map((name) => this._tools.get(name)).filter((t) => t !== undefined);
  }
}

module.exports = { ToolRouter, INTENT_PATTERNS };
