import { describe, expect, it } from 'vitest';

import type { RouteDefinition, RouteModule } from '../../source/routes/types.ts';
import { ApplicationRouter } from '../../source/services/router.ts';
import { TestConnection } from '../helpers/test-connection.ts';

const moduleWith = (routes: RouteDefinition[]): RouteModule => {
    return {
        async getRoutes(): Promise<RouteDefinition[]> {
            return routes;
        },
    };
};

describe('ApplicationRouter initialization', (): void => {
    it('rejects duplicate exact paths during startup', async (): Promise<void> => {
        const route = { url: '/echo', handler: (): void => undefined };

        await expect(ApplicationRouter.create([ moduleWith([ route ]), moduleWith([ route ]) ])).rejects.toThrow('Duplicate application route: /echo');
    });

    it.each([ 'echo', '/', '/items/:id', '/items?active=true', '/items#active' ])('rejects the invalid route path %s', async (url): Promise<void> => {
        await expect(ApplicationRouter.create([ moduleWith([{ url, handler: (): void => undefined }]) ])).rejects.toThrow('Invalid application route');
    });
});

describe('ApplicationRouter dispatch', (): void => {
    it('binds the connection, body, and request ID to one route stream', async (): Promise<void> => {
        const connection = new TestConnection(false, false);
        const router = await ApplicationRouter.create([
            moduleWith([
                {
                    url: '/echo',
                    handler: async (stream): Promise<void> => {
                        expect(stream.connection).toBe(connection);
                        await stream.send(stream.body);
                    },
                },
            ]),
        ]);

        await router.dispatch({ path: '/echo', body: { value: 1 }, requestId: 'request-1' }, connection);

        expect(connection.messages).toEqual([
            {
                id: 'request-1',
                type: 'response',
                statusCode: 200,
                body: { value: 1 },
            },
        ]);

        await expect(router.dispatch({ path: '/echo/other', body: {} }, connection)).rejects.toMatchObject({ statusCode: 404 });
    });

    it('preserves correlation when concurrent requests finish out of order', async (): Promise<void> => {
        const completions = new Map<string, () => void>();
        const router = await ApplicationRouter.create([
            moduleWith([
                {
                    url: '/delayed',
                    handler: async (stream): Promise<void> => {
                        const key = (stream.body as { key: string }).key;
                        await new Promise<void>((resolve) => completions.set(key, resolve));
                        await stream.send({ key });
                    },
                },
            ]),
        ]);
        const connection = new TestConnection(true, true);

        const first = router.dispatch({ path: '/delayed', body: { key: 'A' }, requestId: 'A' }, connection);
        const second = router.dispatch({ path: '/delayed', body: { key: 'B' }, requestId: 'B' }, connection);

        completions.get('B')?.();
        await second;
        completions.get('A')?.();
        await first;

        expect(connection.messages).toEqual([
            {
                id: 'B',
                type: 'response',
                statusCode: 200,
                body: { key: 'B' },
            },
            {
                id: 'A',
                type: 'response',
                statusCode: 200,
                body: { key: 'A' },
            },
        ]);
    });

    it('propagates route failures without infrastructure-specific cleanup', async (): Promise<void> => {
        const error = new Error('route failed');
        const router = await ApplicationRouter.create([
            moduleWith([
                {
                    url: '/failure',
                    handler: (): void => {
                        throw error;
                    },
                },
            ]),
        ]);

        await expect(router.dispatch({ path: '/failure' }, new TestConnection(false, false))).rejects.toBe(error);
    });
});