import 'dotenv/config';

export class HelloAgentsLLM {
  constructor({
    model = process.env.LLM_MODEL_ID,
    apiKey = process.env.LLM_API_KEY,
    baseUrl = process.env.LLM_BASE_URL,
    timeoutMs = Number(process.env.LLM_TIMEOUT_MS || 60_000)
  } = {}) {
    if (!model || !apiKey || !baseUrl) {
      throw new Error('LLM_MODEL_ID、LLM_API_KEY、LLM_BASE_URL 必须配置。');
    }

    this.model = model;
    this.apiKey = apiKey;
    this.baseUrl = baseUrl.replace(/\/$/, '');
    this.timeoutMs = timeoutMs;
  }

  async think(messages, { temperature = 0 } = {}) {
    const controller = new AbortController();
    const timer = setTimeout(() => controller.abort(), this.timeoutMs);

    try {
      const response = await fetch(`${this.baseUrl}/chat/completions`, {
        method: 'POST',
        signal: controller.signal,
        headers: {
          'content-type': 'application/json',
          authorization: `Bearer ${this.apiKey}`
        },
        body: JSON.stringify({
          model: this.model,
          messages,
          temperature
        })
      });

      if (!response.ok) {
        throw new Error(`LLM API failed: ${response.status} ${await response.text()}`);
      }

      const data = await response.json();
      return data.choices?.[0]?.message?.content?.trim() ?? '';
    } finally {
      clearTimeout(timer);
    }
  }
}

export class ToolExecutor {
  constructor() {
    this.tools = new Map();
  }

  registerTool(name, description, fn) {
    this.tools.set(name, { description, fn });
  }

  getAvailableToolsText() {
    return [...this.tools.entries()]
      .map(([name, tool]) => `- ${name}: ${tool.description}`)
      .join('\n');
  }

  async execute(name, input) {
    const tool = this.tools.get(name)?.fn;
    if (!tool) return `错误：未找到工具 ${name}`;
    return await tool(input);
  }
}

Thought: 我现在知道什么，还缺什么
Action: Search[要搜索的问题]

Thought: 信息已经足够
Action: Finish[最终答案]

const REACT_PROMPT = `
你是一个可以调用外部工具的智能助手。

可用工具：
{tools}

请严格按下面格式输出：
Thought: 你的思考
Action: 工具名[工具输入] 或 Finish[最终答案]

问题：
{question}

历史：
{history}
`;

function parseAction(text) {
  const match = text.match(/Action:\s*([A-Za-z_][\w]*)\[(.*)\]/s);
  if (!match) return null;
  return {
    toolName: match[1],
    toolInput: match[2].trim()
  };
}

export class ReActAgent {
  constructor({ llm, toolExecutor, maxSteps = 5 }) {
    this.llm = llm;
    this.toolExecutor = toolExecutor;
    this.maxSteps = maxSteps;
  }

  async run(question) {
    let history = '';

    for (let step = 1; step <= this.maxSteps; step += 1) {
      const prompt = REACT_PROMPT.replace('{tools}', this.toolExecutor.getAvailableToolsText())
        .replace('{question}', question)
        .replace('{history}', history || '无');

      const output = await this.llm.think([{ role: 'user', content: prompt }]);
      const action = parseAction(output);

      if (!action) {
        history += `\n模型输出无法解析：\n${output}\n`;
        continue;
      }

      if (action.toolName === 'Finish') {
        return action.toolInput;
      }

      const observation = await this.toolExecutor.execute(action.toolName, action.toolInput);
      history += `\n${output}\nObservation: ${observation}\n`;
    }

    return '达到最大步骤数，未得到稳定答案。';
  }
}

const PLAN_PROMPT = `
请把用户任务拆成可以依次执行的步骤。

只输出 JSON，不要输出解释。
JSON 格式：
{
  "steps": [
    { "id": 1, "goal": "这一步要完成什么", "instruction": "具体执行说明" }
  ]
}

用户任务：
{task}
`;

function extractJson(text) {
  const start = text.indexOf('{');
  const end = text.lastIndexOf('}');
  if (start === -1 || end === -1 || end <= start) {
    throw new Error('模型没有返回 JSON 对象。');
  }
  return JSON.parse(text.slice(start, end + 1));
}

export class PlanAndSolveAgent {
  constructor({ llm }) {
    this.llm = llm;
  }

  async plan(task) {
    const prompt = PLAN_PROMPT.replace('{task}', task);
    const output = await this.llm.think([{ role: 'user', content: prompt }]);
    return extractJson(output).steps ?? [];
  }

  async execute(task, steps) {
    const results = [];

    for (const step of steps) {
      const prompt = `
原始任务：
${task}

当前步骤：
${JSON.stringify(step, null, 2)}

之前结果：
${results.join('\n\n') || '无'}

请完成当前步骤，只输出本步骤结果。
`;

      const result = await this.llm.think([{ role: 'user', content: prompt }]);
      results.push(`Step ${step.id}: ${result}`);
    }

    return results;
  }

  async run(task) {
    const steps = await this.plan(task);
    const results = await this.execute(task, steps);
    return await this.llm.think([
      {
        role: 'user',
        content: `请根据以下步骤结果汇总最终答案：\n\n${results.join('\n\n')}`
      }
    ]);
  }
}

export class Memory {
  constructor() {
    this.records = [];
  }

  addRecord(type, content) {
    this.records.push({ type, content });
  }

  getLastExecution() {
    return [...this.records].reverse().find((record) => record.type === 'execution')?.content ?? '';
  }
}

const INITIAL_PROMPT = `
你是一位资深 Node.js 工程师。请根据要求编写 JavaScript 函数。
请只输出代码。

要求：
{task}
`;

const REFLECT_PROMPT = `
你是一位严格的代码评审专家。
请审查下面的 JavaScript 代码，重点找出算法效率、边界条件和可读性问题。

原始任务：
{task}

代码：
\`\`\`js
{code}
\`\`\`

如果有改进空间，请给出具体反馈。
如果已经足够好，请回答：无需改进。
`;

const REFINE_PROMPT = `
请根据评审反馈优化代码。

原始任务：
{task}

上一版代码：
\`\`\`js
{lastCode}
\`\`\`

评审反馈：
{feedback}

请只输出优化后的 JavaScript 代码。
`;

export class ReflectionAgent {
  constructor({ llm, maxIterations = 3 }) {
    this.llm = llm;
    this.maxIterations = maxIterations;
    this.memory = new Memory();
  }

  async run(task) {
    const firstDraft = await this.llm.think([
      {
        role: 'user',
        content: INITIAL_PROMPT.replace('{task}', task)
      }
    ]);
    this.memory.addRecord('execution', firstDraft);

    for (let i = 0; i < this.maxIterations; i += 1) {
      const lastCode = this.memory.getLastExecution();
      const feedback = await this.llm.think([
        {
          role: 'user',
          content: REFLECT_PROMPT.replace('{task}', task).replace('{code}', lastCode)
        }
      ]);

      this.memory.addRecord('reflection', feedback);
      if (feedback.includes('无需改进')) break;

      const nextDraft = await this.llm.think([
        {
          role: 'user',
          content: REFINE_PROMPT.replace('{task}', task)
            .replace('{lastCode}', lastCode)
            .replace('{feedback}', feedback)
        }
      ]);
      this.memory.addRecord('execution', nextDraft);
    }

    return this.memory.getLastExecution();
  }
}

export function findPrimes(n) {
  if (!Number.isInteger(n) || n < 2) return [];

  const isPrime = Array(n + 1).fill(true);
  isPrime[0] = false;
  isPrime[1] = false;

  for (let p = 2; p * p <= n; p += 1) {
    if (!isPrime[p]) continue;
    for (let current = p * p; current <= n; current += p) {
      isPrime[current] = false;
    }
  }

  return isPrime.map((value, index) => (value ? index : null)).filter((value) => value !== null);
}