import assert from 'node:assert/strict';
import test from 'node:test';
import {
    readSimulationApiJson,
    simulationApiErrorMessage,
    simulationApiFieldErrors,
    simulationPollingFailureMessage,
    simulationCatalogChoices,
} from '../../resources/js/lib/simulation-api.ts';

void test('snapshot API errors retain field identity and reject malformed responses', () => {
    assert.deepEqual(
        simulationApiFieldErrors({
            message: 'Invalid',
            errors: {
                'economic_snapshot.preferred_language': [
                    'Unsupported language',
                ],
                'personal_snapshot.email': ['Invalid email'],
                'economic_snapshot.required_documents.0': ['Invalid document'],
            },
        }),
        {
            preferred_language: 'Unsupported language',
            email: 'Invalid email',
            required_documents: 'Invalid document',
        },
    );
    assert.deepEqual(simulationApiFieldErrors({ errors: 'invalid' }), {});
});

void test('malformed and non-JSON API bodies do not leak parser exceptions', async () => {
    assert.equal(
        await readSimulationApiJson(
            new Response('<html>gateway error</html>', {
                headers: { 'Content-Type': 'text/html' },
                status: 502,
            }),
        ),
        null,
    );
    assert.equal(
        await readSimulationApiJson(
            new Response('{"truncated":', {
                headers: { 'Content-Type': 'application/json' },
                status: 500,
            }),
        ),
        null,
    );
});

void test('API error messages prefer validated field details and reject malformed shapes', () => {
    assert.equal(
        simulationApiErrorMessage({
            message: 'Validation failed',
            errors: { base: ['Base is required'], rate: ['Rate is invalid'] },
        }),
        'Base is required Rate is invalid',
    );
    assert.equal(
        simulationApiErrorMessage({ message: 'Try again' }),
        'Try again',
    );
    assert.equal(
        simulationApiErrorMessage({ errors: { base: 'invalid' } }),
        undefined,
    );
    assert.equal(simulationApiErrorMessage('<html>error</html>'), undefined);
});

void test('polling failures explain that an accepted calculation may still be pending', () => {
    assert.equal(
        simulationPollingFailureMessage(null),
        'O cenário foi recebido, mas não foi possível confirmar o estado do cálculo. Consulte o histórico antes de tentar novamente.',
    );
    assert.equal(
        simulationPollingFailureMessage({ message: 'Acesso expirado' }),
        'Acesso expirado',
    );
});

void test('catalog parser distinguishes a valid empty list and filters malformed options', () => {
    assert.deepEqual(simulationCatalogChoices({ data: [] }), []);
    assert.deepEqual(
        simulationCatalogChoices({
            data: [
                { id: 'country-1', label: 'Moçambique' },
                { value: 2, name: 'Província de Maputo' },
                { id: 'incomplete', label: '' },
                null,
            ],
        }),
        [
            { id: 'country-1', label: 'Moçambique' },
            { id: '2', label: 'Província de Maputo' },
        ],
    );
    assert.throws(() => simulationCatalogChoices('<html>gateway error</html>'));
});