import assert from 'node:assert/strict';
import { request as httpRequest } from 'node:http';
import { afterEach, describe, it } from 'node:test';

import {
  ExternalAgentParser,
  collectSseOutput,
  normalizeParseResult,
  parseJsonObject,
  parseSseBlock
} from './external-agent-client.mjs';
import { createBusinessServer } from './server.mjs';

const servers = [];

afterEach(async () => {
  await Promise.all(servers.splice(0).map((server) => new Promise((resolve) => server.close(resolve))));
});

describe('external parser contract', () => {
  it('creates a task-isolated session and sends the raw input through SSE', async () => {
    const calls = [];
    const fetchImpl = async (url, options) => {
      calls.push({ url, options, body: options.body ? JSON.parse(options.body) : null });
      if (url.endsWith('/api/open/agent-sessions')) {
        return new Response(JSON.stringify({ session_id: 'open_sess_test', status: 'active' }), {
          status: 200,
          headers: { 'content-type': 'application/json' }
        });
      }
      const fragments = [
        '{"status":"agent_parse_passed","blockers":[],"operation":{"action":"team_order_create","data":{"product":{"name":"遇见老挝"}}',
        '}}'
      ];
      const sse = fragments.map((fragment) => (
        `event: message.delta\ndata: ${JSON.stringify({ content: fragment })}\n\n`
      )).join('');
      return new Response(sse, {
        status: 200,
        headers: { 'content-type': 'text/event-stream' }
      });
    };

    const parser = new ExternalAgentParser({
      baseUrl: 'https://superagent.nianxx.cn',
      apiKey: 'df_open_test',
      fetchImpl,
      now: () => new Date('2026-07-12T08:00:00.000Z'),
      csrfToken: 'csrf-test-token'
    });
    const result = await parser.parse({
      taskId: 'TASK-001',
      rawText: '产品名称：遇见老挝',
      receivedAt: '2026-07-12T08:00:00.000Z'
    });

    assert.equal(result.status, 'agent_parse_passed');
    assert.equal(result.operation.action, 'team_order_create');
    assert.equal(result.operation.data.product.name, '遇见老挝');
    assert.equal(result.operation.submit_mode, 'dry_run');
    assert.equal(result.operation.source.task_id, 'TASK-001');
    assert.equal(result.session_id, 'open_sess_test');
    assert.equal(result.external_request.service, 'external_parse_api');
    assert.equal(result.external_request.transport, 'sse');
    assert.equal(result.external_request.stage, 'stream_completed');
    assert.equal(result.external_request.session_id_present, true);
    assert.equal(result.external_request.event_count, 2);
    assert.equal(calls.length, 2);
    assert.equal(calls[0].options.headers.Authorization, 'Bearer df_open_test');
    assert.equal(calls[0].options.headers['X-CSRF-Token'], 'csrf-test-token');
    assert.equal(calls[0].options.headers.Cookie, 'csrf_token=csrf-test-token');
    assert.deepEqual(calls[0].body, {
      external_subject_id: 'business-task:TASK-001',
      idempotency_key: 'business-parser-session:TASK-001',
      metadata: {
        source: 'business_system',
        module: 'input_parser',
        task_id: 'TASK-001'
      }
    });
    assert.equal(calls[1].url, 'https://superagent.nianxx.cn/api/open/agent-sessions/open_sess_test/messages/stream');
    assert.equal(calls[1].options.headers.Accept, 'text/event-stream');
    assert.equal(calls[1].body.idempotency_key, 'business-parser-message:TASK-001');
    assert.match(calls[1].body.message, /产品名称：遇见老挝/);
    assert.equal(calls[1].body.metadata.session_id, 'open_sess_test');
  });

  it('returns a blocked result without making a request when the server key is absent', async () => {
    let requestCount = 0;
    const parser = new ExternalAgentParser({
      baseUrl: 'https://superagent.nianxx.cn',
      apiKey: '',
      fetchImpl: async () => {
        requestCount += 1;
        throw new Error('should not be called');
      }
    });

    const result = await parser.parse({ taskId: 'TASK-002', rawText: '测试输入' });

    assert.equal(result.status, 'agent_parse_blocked');
    assert.equal(result.error_code, 'external_service_not_configured');
    assert.equal(result.external_request.stage, 'not_configured');
    assert.equal(result.external_request.session_id_present, false);
    assert.equal(requestCount, 0);
    assert.match(result.blockers[0], /DEERFLOW_OPEN_API_KEY/);
  });

  it('probes the provider health endpoint without creating a session', async () => {
    const calls = [];
    const parser = new ExternalAgentParser({
      baseUrl: 'https://superagent.nianxx.cn',
      apiKey: 'df_open_test',
      fetchImpl: async (url, options) => {
        calls.push({ url, options });
        return new Response(JSON.stringify({ status: 'ok' }), {
          status: 200,
          headers: { 'content-type': 'application/json' }
        });
      }
    });

    const result = await parser.checkConnection({ timeoutMs: 100 });

    assert.equal(result.ok, true);
    assert.equal(result.authenticated, null);
    assert.equal(result.authentication_checked, false);
    assert.equal(result.http_status, 200);
    assert.equal(calls.length, 1);
    assert.equal(calls[0].url, 'https://superagent.nianxx.cn/health');
    assert.equal(calls[0].options.method, 'GET');
    assert.equal(calls[0].options.body, undefined);
    assert.equal(calls[0].options.headers.Authorization, 'Bearer df_open_test');
  });

  it('reports an unhealthy provider endpoint as disconnected', async () => {
    const parser = new ExternalAgentParser({
      baseUrl: 'https://superagent.nianxx.cn',
      apiKey: 'df_open_invalid',
      fetchImpl: async () => new Response(JSON.stringify({ detail: 'unauthorized' }), {
        status: 401,
        headers: { 'content-type': 'application/json' }
      })
    });

    const result = await parser.checkConnection({ timeoutMs: 100 });

    assert.equal(result.ok, false);
    assert.equal(result.authenticated, null);
    assert.equal(result.error_code, 'external_health_unhealthy');
  });

  it('maps external authorization and active-run errors without exposing the key', async () => {
    const parser = new ExternalAgentParser({
      baseUrl: 'https://superagent.nianxx.cn',
      apiKey: 'df_open_secret_value',
      fetchImpl: async () => new Response(JSON.stringify({ detail: 'Missing scope: agent_sessions:message; df_open_secret_value' }), {
        status: 403,
        headers: { 'content-type': 'application/json' }
      })
    });

    const result = await parser.parse({ taskId: 'TASK-003', rawText: '测试输入' });

    assert.equal(result.status, 'agent_parse_blocked');
    assert.equal(result.error_code, 'external_forbidden');
    assert.equal(result.external_status, 403);
    assert.match(result.blockers[0], /权限不足/);
    assert.doesNotMatch(JSON.stringify(result), /df_open_secret_value/);
  });

  it('returns a bounded cancellation result when an SSE body ignores cancel()', async () => {
    const hangingBody = {
      async *[Symbol.asyncIterator]() {
        await new Promise(() => {});
      },
      cancel() {
        return new Promise(() => {});
      }
    };
    const parser = new ExternalAgentParser({
      baseUrl: 'https://superagent.nianxx.cn',
      apiKey: 'df_open_test',
      timeoutMs: 2_000,
      totalTimeoutMs: 2_000,
      fetchImpl: async (url) => {
        if (url.endsWith('/api/open/agent-sessions')) {
          return new Response(JSON.stringify({ session_id: 'open_sess_hanging' }), { status: 200 });
        }
        return { status: 200, ok: true, body: hangingBody };
      }
    });
    const controller = new AbortController();
    const abortTimer = setTimeout(() => controller.abort(), 20);
    const startedAt = Date.now();
    try {
      const result = await parser.parse({ taskId: 'TASK-CANCEL', rawText: '测试输入', signal: controller.signal });
      assert.equal(result.status, 'agent_parse_blocked');
      assert.equal(result.error_code, 'external_cancelled');
      assert.ok(Date.now() - startedAt < 1_500);
    } finally {
      clearTimeout(abortTimer);
    }
  });
});

describe('SSE and result helpers', () => {
  it('parses CRLF SSE blocks and JSON objects wrapped in markdown', () => {
    assert.deepEqual(parseSseBlock('event: run.completed\r\ndata: {"status":"agent_parse_passed"}\r\n'), {
      event: 'run.completed',
      data: { status: 'agent_parse_passed' }
    });
    assert.deepEqual(parseJsonObject('```json\n{"status":"agent_parse_blocked","blockers":[]}\n```'), {
      status: 'agent_parse_blocked',
      blockers: []
    });
    assert.deepEqual(parseSseBlock('event: done\ndata: [DONE]\n\n'), {
      event: 'done',
      data: null,
      done: true
    });
  });

  it('returns after a terminal SSE event even if the provider keeps the stream open', async () => {
    const body = new ReadableStream({
      start(controller) {
        controller.enqueue(new TextEncoder().encode(
          'event: run.completed\ndata: {"status":"agent_parse_blocked","blockers":["test"]}\n\n'
        ));
      }
    });
    let timer;
    try {
      const timeout = new Promise((_, reject) => {
        timer = setTimeout(() => reject(new Error('SSE terminal event was not honored')), 200);
      });
      const collected = await Promise.race([collectSseOutput(body), timeout]);
      assert.equal(collected.eventCount, 1);
      assert.deepEqual(collected.result, { status: 'agent_parse_blocked', blockers: ['test'] });
    } finally {
      clearTimeout(timer);
      await body.cancel().catch(() => {});
    }
  });

  it('accepts a structured final event and preserves the operation contract', async () => {
    const body = new Response(
      'event: run.completed\ndata: {"status":"agent_parse_passed","blockers":[],"operation":{"action":"team_order_create","data":{}}}\n\n',
      { headers: { 'content-type': 'text/event-stream' } }
    ).body;
    const collected = await collectSseOutput(body);
    const result = normalizeParseResult(collected.result, {
      taskId: 'TASK-004',
      receivedAt: '2026-07-12T08:00:00.000Z',
      sessionId: 'open_sess_test'
    });

    assert.equal(collected.eventCount, 1);
    assert.equal(result.status, 'agent_parse_passed');
    assert.equal(result.session_id, 'open_sess_test');
    assert.equal(result.operation.source.parser_prompt_version, 'external-profile');
    assert.deepEqual(result.operation.data.attachments, []);
  });

  it('collects assistant chunks from the documented messages event shape', async () => {
    const events = [
      [{ type: 'human', content: 'ignore this input' }, { type: 'metadata', source: 'run' }],
      [{ type: 'AIMessageChunk', content: '{"status":"agent_parse_passed","operation":' }],
      [{ type: 'AIMessageChunk', content: '{"action":"team_order_create","data":{}}}' }]
    ].map((data) => `event: messages\ndata: ${JSON.stringify(data)}\n\n`).join('');
    const collected = await collectSseOutput(new Response(events).body);

    assert.equal(collected.eventCount, 3);
    assert.equal(parseJsonObject(collected.text).status, 'agent_parse_passed');
    assert.equal(parseJsonObject(collected.text).operation.action, 'team_order_create');
  });

  it('adapts the currently published flat parser shape into the business operation contract', () => {
    const result = normalizeParseResult({
      order_mode: '团队-单个下单',
      order_nature: '测试',
      product_name: '测试产品',
      departure_date: '2099-01-01',
      adult: 2,
      child_with_bed: 1,
      child_without_bed: 0,
      infant: 0,
      tour_leader: 0,
      op: '测试 OP',
      sales: '测试销售',
      remarks: '仅测试解析',
      test_marker: 'TEST-001'
    }, { taskId: 'TASK-006', receivedAt: '2026-07-12T08:00:00.000Z' });

    assert.equal(result.status, 'agent_parse_passed');
    assert.equal(result.operation.order_nature, 'test');
    assert.equal(result.operation.data.product.name, '测试产品');
    assert.deepEqual(result.operation.data.departure_dates, ['2099-01-01']);
    assert.equal(result.operation.data.passenger_counts.expected_total, 3);
    assert.equal(result.operation.data.op_user.name, '测试 OP');
    assert.equal(result.operation.data.sales_user.name, '测试销售');
  });

  it('accepts camelCase flat fields emitted by the external Profile', () => {
    const result = normalizeParseResult({
      action: 'team_order_create',
      orderMode: '团队-单个下单',
      orderNature: '测试',
      productName: '测试产品',
      departureDate: '2099-01-01',
      adults: 1,
      childrenWithBed: 2,
      childrenWithoutBed: 1,
      infants: 0,
      tourLeader: 0,
      operator: '测试 OP',
      salesperson: '测试销售',
      remarks: '仅测试解析'
    }, { taskId: 'TASK-007', receivedAt: '2026-07-12T08:00:00.000Z' });

    assert.equal(result.status, 'agent_parse_passed');
    assert.equal(result.operation.action, 'team_order_create');
    assert.equal(result.operation.data.passenger_counts.expected_total, 4);
    assert.equal(result.operation.data.op_user.name, '测试 OP');
    assert.equal(result.operation.data.sales_user.name, '测试销售');
  });

  it('blocks a generic Profile response instead of inventing an operation', () => {
    const result = normalizeParseResult({
      reply: '请补充订单信息',
      intent: 'order_help',
      missingFields: ['product']
    }, { taskId: 'TASK-008', receivedAt: '2026-07-12T08:00:00.000Z' });

    assert.equal(result.status, 'agent_parse_blocked');
    assert.equal(result.error_code, 'external_result_contract_mismatch');
    assert.deepEqual(result.response_keys, ['reply', 'intent', 'missingFields']);
    assert.equal(result.operation, null);
  });
});

describe('business-system HTTP boundary', () => {
  it('returns the real AI connectivity probe from /api/status', async () => {
    const parser = {
      async checkConnection() {
        return {
          ok: true,
          configured: true,
          reachable: true,
          authenticated: true,
          http_status: 422,
          probe: 'validation_response'
        };
      },
      async parse() {
        throw new Error('not used');
      }
    };
    const server = createBusinessServer({ parser });
    servers.push(server);
    await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
    const address = server.address();

    const response = await requestJson(address.port, 'GET', '/api/status');

    assert.equal(response.statusCode, 200);
    assert.equal(response.body.ai_configured, true);
    assert.equal(response.body.ai_connected, true);
    assert.equal(response.body.ai_probe.http_status, 422);
  });

  it('exposes /api/parse and no longer exposes /api/agent routes', async () => {
    const seen = [];
    const parser = {
      async parse(payload) {
        seen.push(payload);
        return { status: 'agent_parse_passed', blockers: [], operation: { action: 'team_order_create', data: {} } };
      }
    };
    const server = createBusinessServer({ parser });
    servers.push(server);
    await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
    const address = server.address();

    const response = await requestJson(address.port, 'POST', '/api/parse', {
      task_id: 'TASK-005',
      raw_text: '测试输入',
      received_at: '2026-07-12T08:00:00.000Z'
    });
    assert.equal(response.statusCode, 200);
    assert.equal(response.body.operation.action, 'team_order_create');
    assert.deepEqual(seen, [{
      rawText: '测试输入',
      taskId: 'TASK-005',
      receivedAt: '2026-07-12T08:00:00.000Z'
    }]);

    const oldRoute = await requestJson(address.port, 'POST', '/api/agent/parse', {});
    assert.equal(oldRoute.statusCode, 405);
  });
});

function requestJson(port, method, path, body) {
  return new Promise((resolve, reject) => {
    const request = httpRequest({
      host: '127.0.0.1',
      port,
      method,
      path,
      headers: { 'Content-Type': 'application/json' }
    }, (response) => {
      const chunks = [];
      response.on('data', (chunk) => chunks.push(chunk));
      response.on('end', () => {
        const text = Buffer.concat(chunks).toString('utf8');
        let parsed;
        try {
          parsed = text ? JSON.parse(text) : null;
        } catch (error) {
          parsed = text;
        }
        resolve({ statusCode: response.statusCode, body: parsed });
      });
    });
    request.on('error', reject);
    request.end(body === undefined ? undefined : JSON.stringify(body));
  });
}