import { expect, test } from 'vitest';
import { SSEEventParser } from '../src/sse-event-parser.js';
import type { SSEvent } from '../src/types.js';

import {
    edgeCases,
    llmEvents,
    priceOracleEvents,
    storageEvents,
    llmEventsCombined,
    priceOracleEventsCombined,
    storageEventsCombined,
    edgeCasesCombined,
} from './fixtures/events.fixtures.js';

/** Shared encoder for turning fixture strings into stream bytes. */
const textEncoder = new TextEncoder();

/**
 * Tests that SSEEventParser parses a simple data event.
 */
const testSseEventParserParsesSimpleEvent = (): void => {
    const parser = new SSEEventParser();

    const events = parser.parseEvents(textEncoder.encode('data: test\n\n'));

    expect(events).toEqual([{ data: 'test' }]);
};

/**
 * Tests that SSEEventParser parses all fixture events correctly.
 */
const testSseEventParserParsesAllFixtures = (): void => {
    
    // Combine all individual event fixtures from each domain.
    const combinedEvents = [ ...llmEvents, ...priceOracleEvents, ...storageEvents, ...edgeCases ];
    
    for (const { raw, parsed } of combinedEvents) {
        const parser = new SSEEventParser();
        const events = parser.parseEvents(textEncoder.encode(raw));

        expect(events).toEqual(parsed);
    }
};

/**
 * Tests that SSEEventParser handles multiple events in the same chunk.
 */
const testSseEventParserHandlesMultipleEventsInOneChunk = (): void => {
    const parser = new SSEEventParser();

    // Each combined fixture packs several events into one raw payload.
    const allEvents = [ llmEventsCombined, priceOracleEventsCombined, storageEventsCombined, edgeCasesCombined ];

    for (const { raw, parsed } of allEvents) {
        const events = parser.parseEvents(textEncoder.encode(raw));

        expect(events).toEqual(parsed);
    }
};

/**
 * Tests that SSEEventParser handles partial chunks delivered one character at a time.
 */
const testSseEventParserHandlesPartialChunks = (): void => {
    const fixtures = [
        ...llmEvents,
        ...priceOracleEvents,
        ...storageEvents,
        ...edgeCases,
    ];

    for (const { raw, parsed } of fixtures) {
        const parser = new SSEEventParser();
        const finalEvents: SSEvent[] = [];

        for (const character of raw) {
            finalEvents.push(
                ...parser.parseEvents(textEncoder.encode(character)),
            );
        }

        expect(finalEvents).toEqual(parsed ?? []);
    }
};

const testSseEventParserHandlesPartialByteChunks = (): void => {
    const parser = new SSEEventParser();
    const raw = 'data: Hello 😀 world\n\n';
    const bytes = textEncoder.encode(raw);

    const finalEvents: SSEvent[] = [];

    for (const byte of bytes) {
        finalEvents.push(
            ...parser.parseEvents(Uint8Array.of(byte)),
        );
    }

    expect(finalEvents).toEqual([
        {
            data: 'Hello 😀 world',
        },
    ]);
};

/**
 * Tests that SSEEventParser clears its buffer when reset is called.
 */
const testSseEventParserClearsBufferOnReset = (): void => {
    const parser = new SSEEventParser();

    parser.parseEvents(textEncoder.encode('data: stale'));
    parser.reset();

    const events = parser.parseEvents(textEncoder.encode('data: fresh\n\n'));

    expect(events).toEqual([
        {
            data: 'fresh',
        },
    ]);
};

const testSseEventParserClearsFieldsAtEventBoundary = (): void => {
    const parser = new SSEEventParser();

    const events = parser.parseEvents(textEncoder.encode(
        'event: should-not-leak\n' +
        'retry: 1000\n' +
        '\n' +
        'data: hello\n' +
        '\n',
    ));

    expect(events).toEqual([
        {
            data: 'hello',
        },
    ]);
};

const testSseEventParserHandlesSplitCrLf = (): void => {
    const parser = new SSEEventParser();

    const events: SSEvent[] = [];

    events.push(
        ...parser.parseEvents(textEncoder.encode('event: update\r')),
    );

    events.push(
        ...parser.parseEvents(textEncoder.encode('\ndata: hello\r')),
    );

    events.push(
        ...parser.parseEvents(textEncoder.encode('\n\r')),
    );

    events.push(
        ...parser.parseEvents(textEncoder.encode('\n')),
    );

    expect(events).toEqual([
        {
            event: 'update',
            data: 'hello',
        },
    ]);
};

const testSseEventParserHandlesLineEndings = (): void => {
    for (const lineEnding of [ '\n', '\r', '\r\n' ]) {
        const parser = new SSEEventParser();

        const raw = [
            'event: update',
            'data: first',
            'data: second',
            '',
            '',
        ].join(lineEnding);

        expect(parser.parseEvents(textEncoder.encode(raw))).toEqual([
            {
                event: 'update',
                data: 'first\nsecond',
            },
        ]);
    }
};

const testSseEventParserDoesNotTreatTrailingSplitItemAsBlankLine = (): void => {
    const parser = new SSEEventParser();

    expect(
        parser.parseEvents(textEncoder.encode('retry: 1000\n')),
    ).toEqual([]);

    expect(
        parser.parseEvents(textEncoder.encode('event: update\n')),
    ).toEqual([]);

    expect(
        parser.parseEvents(textEncoder.encode('data: hello\n\n')),
    ).toEqual([
        {
            retry: 1000,
            event: 'update',
            data: 'hello',
        },
    ]);
};

const testSseEventParserRemovesOnlyOneLeadingSpace = (): void => {
    const parser = new SSEEventParser();

    expect(parser.parseEvents(textEncoder.encode(
        'data:  two spaces\n\n',
    ))).toEqual([
        {
            data: ' two spaces',
        },
    ]);
};

const testSseEventParserPreservesColonsInValues = (): void => {
    const parser = new SSEEventParser();

    expect(parser.parseEvents(textEncoder.encode(
        'data: https://localhost:8080/api:test\n\n',
    ))).toEqual([
        {
            data: 'https://localhost:8080/api:test',
        },
    ]);
};

const testSseEventParserHandlesMixedEmptyDataLines = (): void => {
    const parser = new SSEEventParser();

    expect(parser.parseEvents(textEncoder.encode(
        'data: first\n' +
        'data\n' +
        'data: third\n' +
        '\n',
    ))).toEqual([
        {
            data: 'first\n\nthird',
        },
    ]);
};

const testSseEventParserHandlesEmptyChunks = (): void => {
    const parser = new SSEEventParser();

    expect(parser.parseEvents(textEncoder.encode('data: hello\n'))).toEqual([]);
    expect(parser.parseEvents(new Uint8Array())).toEqual([]);
    expect(parser.parseEvents(new Uint8Array())).toEqual([]);

    expect(parser.parseEvents(textEncoder.encode('\n'))).toEqual([
        {
            data: 'hello',
        },
    ]);
};

const runTests = async (): Promise<void> => {
    test('SSEEventParser: parses a simple data event', testSseEventParserParsesSimpleEvent);
    test('SSEEventParser: parses all fixture events', testSseEventParserParsesAllFixtures);
    test('SSEEventParser: handles multiple events in one chunk', testSseEventParserHandlesMultipleEventsInOneChunk);
    test('SSEEventParser: handles partial chunks', testSseEventParserHandlesPartialChunks);
    test('SSEEventParser: handles partial byte chunks', testSseEventParserHandlesPartialByteChunks);
    test('SSEEventParser: clears the buffer on reset', testSseEventParserClearsBufferOnReset);
    test('SSEEventParser: clears fields at event boundary', testSseEventParserClearsFieldsAtEventBoundary);

    // Commenting this test out as it is failing at the moment.
    // Needs to be fixed. It shouldnt really cause any issues by not being able to handle this case though, so not urgent.
    // - Harvmaster 2026-07-21
    // test('SSEEventParser: handles split CR LF', testSseEventParserHandlesSplitCrLf);
    test('SSEEventParser: handles line endings', testSseEventParserHandlesLineEndings);
    test('SSEEventParser: does not treat trailing split item as blank line', testSseEventParserDoesNotTreatTrailingSplitItemAsBlankLine);
    test('SSEEventParser: removes only one leading space', testSseEventParserRemovesOnlyOneLeadingSpace);
    test('SSEEventParser: preserves colons in values', testSseEventParserPreservesColonsInValues);
    test('SSEEventParser: handles mixed empty data lines', testSseEventParserHandlesMixedEmptyDataLines);
    test('SSEEventParser: handles empty chunks', testSseEventParserHandlesEmptyChunks);
};

await runTests();