import type { ToolWithMetadata } from '../types.js';
import { getAgentManager } from '../../agent/manager.js';

/**
 * Agent Output 工具
 * 用于获取后台 Agent 的执行结果
 */
export const agentOutputTool: ToolWithMetadata = {
  name: 'agent_output',
  description: `获取后台运行的 Agent 执行结果。

当使用 task 工具的 run_in_background 参数启动后台 Agent 后，
使用此工具查询执行状态和结果。

使用示例:
- 查询结果（阻塞等待）: agent_output({ agent_id: "abc123" })
- 检查状态（不阻塞）: agent_output({ agent_id: "abc123", block: false })
- 设置超时: agent_output({ agent_id: "abc123", timeout: 60 })`,
  parameters: {
    agent_id: {
      type: 'string',
      description: 'Agent ID（由 task 工具返回）',
      required: true,
    },
    block: {
      type: 'boolean',
      description: '是否阻塞等待结果完成（默认 true）。设为 false 可立即获取当前状态',
      required: false,
    },
    timeout: {
      type: 'number',
      description: '等待超时时间（秒），默认 150，最大 300',
      required: false,
    },
  },
  metadata: {
    name: 'agent_output',
    category: 'agent',
    description: '获取后台 Agent 执行结果',
    keywords: ['agent', 'output', 'result', 'background', '结果', '后台', '查询'],
    deferLoading: false, // 核心工具，始终加载
  },
  async execute(params) {
    const {
      agent_id,
      block = true,
      timeout = 150,
    } = params as {
      agent_id: string;
      block?: boolean;
      timeout?: number;
    };

    const agentManager = getAgentManager();

    // 验证超时参数
    const effectiveTimeout = Math.min(Math.max(timeout, 1), 300);

    // 获取 Agent 输出
    const agent = await agentManager.getAgentOutput(agent_id, block, effectiveTimeout);

    if (!agent) {
      return {
        success: false,
        output: '',
        error: `Agent ${agent_id} 不存在。请检查 agent_id 是否正确。`,
      };
    }

    // 根据状态返回不同结果
    if (agent.status === 'running') {
      const runningTime = Math.round((Date.now() - agent.startedAt.getTime()) / 1000);
      return {
        success: true,
        output: `Agent ${agent_id} 仍在运行中...\n` +
                `- 类型: ${agent.agentName}\n` +
                `- 任务: ${agent.description}\n` +
                `- 已运行: ${runningTime} 秒\n\n` +
                `稍后再次调用 agent_output 查询结果，或使用 block: true 等待完成。`,
        metadata: {
          agentId: agent.id,
          status: 'running',
          agentName: agent.agentName,
          runningTime,
        },
      };
    }

    if (agent.status === 'failed') {
      const duration = agent.completedAt
        ? Math.round((agent.completedAt.getTime() - agent.startedAt.getTime()) / 1000)
        : 0;
      return {
        success: false,
        output: '',
        error: `Agent ${agent_id} 执行失败:\n` +
               `- 类型: ${agent.agentName}\n` +
               `- 任务: ${agent.description}\n` +
               `- 耗时: ${duration} 秒\n` +
               `- 错误: ${agent.error || '未知错误'}`,
        metadata: {
          agentId: agent.id,
          status: 'failed',
          agentName: agent.agentName,
          duration,
        },
      };
    }

    // completed
    const duration = agent.completedAt
      ? Math.round((agent.completedAt.getTime() - agent.startedAt.getTime()) / 1000)
      : 0;

    return {
      success: true,
      output: `## Agent ${agent_id} 执行完成\n\n` +
              `- 类型: ${agent.agentName}\n` +
              `- 任务: ${agent.description}\n` +
              `- 耗时: ${duration} 秒\n` +
              `- 步数: ${agent.steps || 0}\n\n` +
              `### 结果\n\n${agent.result || '(无输出)'}`,
      metadata: {
        agentId: agent.id,
        status: 'completed',
        agentName: agent.agentName,
        duration,
        steps: agent.steps,
      },
    };
  },
};
