'use strict';

// 智能问数智能体路由：运行生命周期（异步执行 + 轮询）与会话索引
//   POST /api/agent/runs            发起运行（agent/quick 双模式），立即返回 run 记录
//   GET  /api/agent/runs            会话内运行摘要列表（?entity&sessionId）
//   GET  /api/agent/runs/:id        运行详情（含步骤/产物；运行中为实时进度）
//   POST /api/agent/runs/:id/cancel 请求取消（回合间隙生效）
//   GET  /api/agent/sessions        会话列表（?entity）

const { sendJson, readBody } = require('../util.js');
const { ASK_CLIENT_CODES } = require('../middleware.js');
const { makeChatCfg } = require('../context.js');
const naposService = require('../../napos-service.js');
const aitableFactory = require('../services/aitable.js');
const agent = require('../agent/index.js');
const agentSkills = require('../agent/skills.js');

function requireEntity(query, body) {
  const entity = (body && body.entity) || query.entity
    || (naposService.store.listEntities()[0] || {}).key;
  if (!entity) {
    const e = new Error('暂无数据主体，请先完成一次同步');
    e.code = 'ASK_NO_ENTITY';
    throw e;
  }
  return entity;
}

function register(app, ctx) {
  // 云端协同（湖↔云比对工具用）：复用 server.js 装配的服务实例（无则兜底自建）
  const aitableSvc = ctx.aitable || aitableFactory.createAitableService(ctx);
  app.post('/api/agent/runs', async ({ req, res }) => {
    const body = await readBody(req);
    const entity = requireEntity({}, body);
    // 参数类错误（空问题/未配模型/无主体）→ 400；其余交给错误边界
    try {
      const rec = agent.startRun({
        entity,
        question: body.question,
        mode: ['quick', 'agent', 'auto'].includes(body.mode) ? body.mode : 'auto',
        sessionId: body.sessionId,
        skill: body.skill,
        cloud: aitableSvc,
        cfg: makeChatCfg(ctx),
        svc: naposService,
      });
      sendJson(res, 200, { run: rec });
    } catch (e) {
      if (!ASK_CLIENT_CODES.has(e.code)) e.status = 502;
      throw e;
    }
  });

  app.get('/api/agent/runs', async ({ res, query }) => {
    const entity = requireEntity(query);
    if (!query.sessionId) return sendJson(res, 400, { error: '缺少 sessionId 参数' });
    sendJson(res, 200, { entity, runs: agent.listRuns(entity, query.sessionId) });
  });

  app.get('/api/agent/runs/:id', async ({ res, query, params }) => {
    const entity = requireEntity(query);
    const rec = agent.getRun(entity, params.id);
    if (!rec) return sendJson(res, 404, { error: '运行记录不存在' });
    sendJson(res, 200, { run: rec });
  });

  app.post('/api/agent/runs/:id/cancel', async ({ req, res, params }) => {
    await readBody(req).catch(() => ({}));
    const rec = agent.cancelRun(params.id);
    if (!rec) return sendJson(res, 404, { error: '运行记录不存在' });
    sendJson(res, 200, { run: rec });
  });

  app.get('/api/agent/sessions', async ({ res, query }) => {
    const entity = requireEntity(query);
    sendJson(res, 200, { entity, sessions: agent.listSessions(entity) });
  });

  app.del('/api/agent/sessions/:id', async ({ res, query, params }) => {
    const entity = requireEntity(query);
    const ok = agent.deleteSession(entity, params.id);
    if (!ok) return sendJson(res, 404, { error: '会话不存在' });
    sendJson(res, 200, { ok: true });
  });

  app.get('/api/agent/skills', async ({ res }) => {
    sendJson(res, 200, { skills: agentSkills.SKILLS.map(({ key, name, desc }) => ({ key, name, desc })) });
  });
}

module.exports = { register };