import type { Handle } from '@sveltejs/kit';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';

vi.mock('../../src/lib/server/db/migrate.js', () => ({ migrate: vi.fn() }));
vi.mock('../../src/lib/server/pipeline/worker.js', () => ({ startWorker: vi.fn() }));
vi.mock('../../src/lib/server/discord/worker.js', () => ({ startDiscordWorker: vi.fn() }));
vi.mock('../../src/lib/server/provisioning/history.js', () => ({ interruptDeployments: vi.fn() }));
vi.mock('../../src/lib/server/auth/guard.js', () => ({
    authenticationHandle: vi.fn(async () => new Response('OK'))
}));
vi.mock('../../src/lib/server/pipeline/bus.js', () => ({ invalidateFleet: vi.fn() }));
vi.mock('../../src/lib/server/performance.js', () => ({ startPerformanceMonitor: vi.fn() }));

let originalListeners = process.listeners('unhandledRejection');
beforeEach(() => {
    vi.resetModules();
    vi.resetAllMocks();
    originalListeners = process.listeners('unhandledRejection');
});
afterEach(() => {
    for (const listener of process.listeners('unhandledRejection')) {
        if (!originalListeners.includes(listener)) process.off('unhandledRejection', listener);
    }
    vi.restoreAllMocks();
});

describe('controller error handling', () => {
    it.each([
        'migration',
        'deployment recovery',
        'worker startup',
        'Discord startup',
        'performance monitor'
    ] as const)(
        'retries failed %s before serving requests and boots only once after recovery',
        async (phase) => {
            const { handle } = await import('../../src/hooks.server.js');
            const { migrate } = await import('../../src/lib/server/db/migrate.js');
            const { interruptDeployments } =
                await import('../../src/lib/server/provisioning/history.js');
            const { startWorker } = await import('../../src/lib/server/pipeline/worker.js');
            const { startDiscordWorker } = await import('../../src/lib/server/discord/worker.js');
            const { startPerformanceMonitor } = await import('../../src/lib/server/performance.js');
            const { authenticationHandle } = await import('../../src/lib/server/auth/guard.js');
            const steps = [
                migrate,
                interruptDeployments,
                startWorker,
                startDiscordWorker,
                startPerformanceMonitor
            ];
            const failedStep = [
                'migration',
                'deployment recovery',
                'worker startup',
                'Discord startup',
                'performance monitor'
            ].indexOf(phase);
            const failure = new Error('database or disk is full');
            vi.mocked(steps[failedStep])
                .mockImplementationOnce(() => {
                    throw failure;
                })
                .mockImplementationOnce(() => {
                    throw failure;
                });
            const input = {
                event: {
                    request: new Request('http://localhost/'),
                    route: { id: '/' },
                    locals: {}
                },
                resolve: vi.fn()
            } as unknown as Parameters<Handle>[0];

            for (let attempt = 1; attempt <= 2; attempt++) {
                await expect(handle(input)).rejects.toBe(failure);
                expect(authenticationHandle).not.toHaveBeenCalled();
                for (const [index, step] of steps.entries()) {
                    expect(step).toHaveBeenCalledTimes(index <= failedStep ? attempt : 0);
                }
            }

            expect((await handle(input)).status).toBe(200);
            expect((await handle(input)).status).toBe(200);
            expect(authenticationHandle).toHaveBeenCalledTimes(2);
            for (const [index, step] of steps.entries()) {
                expect(step).toHaveBeenCalledTimes(index <= failedStep ? 3 : 1);
                const lastCall = vi.mocked(step).mock.invocationCallOrder.at(-1)!;
                expect(lastCall).toBeLessThan(
                    vi.mocked(authenticationHandle).mock.invocationCallOrder[0]
                );
                if (index > 0) {
                    expect(lastCall).toBeGreaterThan(
                        vi.mocked(steps[index - 1]).mock.invocationCallOrder.at(-1)!
                    );
                }
            }
            const listeners = process
                .listeners('unhandledRejection')
                .filter((listener) => !originalListeners.includes(listener));
            expect(listeners).toHaveLength(1);
        }
    );

    it('registers one process rejection logger before starting workers, even across requests', async () => {
        const on = vi.spyOn(process, 'on');
        const log = vi.spyOn(console, 'error').mockImplementation(() => {});
        const { handle } = await import('../../src/hooks.server.js');
        const { startWorker } = await import('../../src/lib/server/pipeline/worker.js');
        const input = {
            event: { request: new Request('http://localhost/'), route: { id: '/' }, locals: {} },
            resolve: vi.fn()
        } as unknown as Parameters<Handle>[0];

        await handle(input);
        await handle(input);

        const listeners = process
            .listeners('unhandledRejection')
            .filter((listener) => !originalListeners.includes(listener));
        expect(listeners).toHaveLength(1);
        expect(startWorker).toHaveBeenCalledTimes(1);
        const registration = on.mock.calls.findIndex(([event]) => event === 'unhandledRejection');
        expect(on.mock.invocationCallOrder[registration]).toBeLessThan(
            vi.mocked(startWorker).mock.invocationCallOrder[0]
        );

        const failure = new Error('unexpected background failure');
        listeners[0](failure, Promise.resolve());
        listeners[0]('non-Error rejection', Promise.resolve());
        expect(log.mock.calls).toEqual([
            ['[process] unhandled rejection:', failure],
            ['[process] unhandled rejection:', 'non-Error rejection']
        ]);
    });
});