import { describe, expect, it } from 'vitest';
import { readLeadingDecisionFrame } from '../sse-decision-frame';

/** Build a `Response` whose body streams the given chunks back to the
 *  reader one tick at a time. Mirrors the way the chat-agent route
 *  emits frames over time. */
function streamingResponse(chunks: Uint8Array[]): Response {
  const encoder = new TextEncoder();
  void encoder; // not strictly used; kept to mirror call site idiom
  const body = new ReadableStream<Uint8Array>({
    async start(controller) {
      for (const chunk of chunks) {
        controller.enqueue(chunk);
        // Yield so the consumer's read loop interleaves the chunks
        // realistically (the loop awaits between reads).
        await Promise.resolve();
      }
      controller.close();
    },
  });
  return new Response(body);
}

function bytes(text: string): Uint8Array {
  return new TextEncoder().encode(text);
}

describe('readLeadingDecisionFrame', () => {
  it('returns the decision_resolved frame on a happy single-frame stream', async () => {
    const frame = {
      kind: 'decision_resolved',
      ok: true,
      action: 'approved',
      toolName: 'create_ticket',
      result: { ticket_id: '42', status: 'OPEN' },
    };
    const wire = bytes(JSON.stringify(frame) + '\0');
    const result = await readLeadingDecisionFrame(streamingResponse([wire]));
    expect(result.kind).toBe('decision_resolved');
    expect(result.ok).toBe(true);
    expect(result.action).toBe('approved');
    expect(result.toolName).toBe('create_ticket');
    expect(result.result?.ticket_id).toBe('42');
  });

  it('handles a rejected action', async () => {
    const frame = { kind: 'decision_resolved', ok: true, action: 'rejected' };
    const wire = bytes(JSON.stringify(frame) + '\0');
    const result = await readLeadingDecisionFrame(streamingResponse([wire]));
    expect(result.action).toBe('rejected');
  });

  it('drains the stream defensively when extra bytes arrive after the frame', async () => {
    const frame = { kind: 'decision_resolved', ok: true, action: 'approved' };
    const trailing = 'unexpected trailing bytes from a misbehaving server';
    const wire = bytes(JSON.stringify(frame) + '\0' + trailing);
    const result = await readLeadingDecisionFrame(streamingResponse([wire]));
    expect(result.action).toBe('approved');
    // No throw — the helper swallowed the trailing bytes.
  });

  it('rejects when the body is empty', async () => {
    const empty = streamingResponse([]);
    await expect(readLeadingDecisionFrame(empty)).rejects.toThrow(/closed before leading frame/i);
  });

  it('rejects when the first frame has the wrong kind', async () => {
    const frame = { kind: 'approval_request', proposalId: 'x' };
    const wire = bytes(JSON.stringify(frame) + '\0');
    await expect(readLeadingDecisionFrame(streamingResponse([wire]))).rejects.toThrow(/expected decision_resolved/i);
  });

  it('rejects when the leading JSON is malformed', async () => {
    const wire = bytes('not-json{\0');
    await expect(readLeadingDecisionFrame(streamingResponse([wire]))).rejects.toThrow(/leading JSON parse failed/i);
  });

  it('rejects when the text-body sentinel arrives before any frame', async () => {
    const wire = bytes('\x1Ehello');
    await expect(readLeadingDecisionFrame(streamingResponse([wire]))).rejects.toThrow(
      /text-body sentinel arrived before leading frame/i,
    );
  });

  it('rejects when the response has no body', async () => {
    const bodiless = new Response(null, { status: 204 });
    await expect(readLeadingDecisionFrame(bodiless)).rejects.toThrow(/response has no body/i);
  });

  it('handles a frame split across multiple chunks', async () => {
    const frame = {
      kind: 'decision_resolved',
      ok: true,
      action: 'approved',
      result: { ticket_id: '99', mirror_synced: false },
    };
    const text = JSON.stringify(frame) + '\0';
    // Split mid-JSON to simulate a network chunk boundary in the middle
    // of the payload.
    const split = Math.floor(text.length / 2);
    const result = await readLeadingDecisionFrame(
      streamingResponse([bytes(text.slice(0, split)), bytes(text.slice(split))]),
    );
    expect(result.result?.ticket_id).toBe('99');
    expect(result.result?.mirror_synced).toBe(false);
  });

  it('preserves all envelope fields the chat-agent route emits', async () => {
    const frame = {
      kind: 'decision_resolved',
      ok: true,
      action: 'approved',
      toolName: 'update_ticket',
      willAutoContinue: false,
      proposalId: 'prop-123',
      result: { ticket_id: 'tkt-7', status: 'CLOSED' },
      receiptText: 'Ticket closed.',
    };
    const wire = bytes(JSON.stringify(frame) + '\0');
    const result = await readLeadingDecisionFrame(streamingResponse([wire]));
    expect(result.toolName).toBe('update_ticket');
    expect(result.proposalId).toBe('prop-123');
    expect(result.receiptText).toBe('Ticket closed.');
  });
});