// engine/test-spec-generator/scenario-builders.ts — Build happy-path, error and edge-case scenarios
import { getLabels, hasEdgeCaseKeyword } from './labels.js';
import { suggestTestData, extractGiven, extractWhen, extractThen } from './criterion-parser.js';
function buildHappyPath(criterion, _criterionId, labels) {
    const testData = suggestTestData(criterion);
    const step = {
        type: 'happy-path',
        given: extractGiven(criterion, labels),
        when: extractWhen(criterion, labels),
        then: extractThen(criterion, labels),
    };
    if (testData !== undefined) {
        step.testData = testData;
    }
    return step;
}
function buildErrorScenario(criterion, _criterionId, labels) {
    const lower = criterion.toLowerCase();
    let errorWhen;
    if (lower.includes('valid') || lower.includes('valid')) {
        errorWhen = pick(labels, {
            es: 'se proporciona entrada inválida',
            pt: 'entrada inválida é fornecida',
            en: 'invalid input is provided',
        });
    }
    else if (lower.includes('exist') || lower.includes('existe')) {
        errorWhen = pick(labels, {
            es: 'el recurso requerido no existe',
            pt: 'o recurso necessário não existe',
            en: 'the required resource does not exist',
        });
    }
    else {
        errorWhen = pick(labels, {
            es: 'la condición requerida no se cumple',
            pt: 'a condição necessária não é atendida',
            en: 'the required condition is not met',
        });
    }
    const errorGiven = pick(labels, {
        es: 'un proyecto con configuración incorrecta o datos faltantes',
        pt: 'um projeto com configuração incorreta ou dados ausentes',
        en: 'a project with incorrect configuration or missing data',
    });
    return {
        type: 'error',
        given: errorGiven,
        when: errorWhen,
        then: `the operation ${labels.thenFails}`,
    };
}
// ---------------------------------------------------------------------------
// Edge-case scenario helpers
// ---------------------------------------------------------------------------
function pick(labels, l3) {
    if (labels.locale === 'es') {
        return l3.es;
    }
    if (labels.locale === 'pt') {
        return l3.pt;
    }
    return l3.en;
}
function edgeMaximum(labels) {
    return {
        given: pick(labels, {
            es: 'el sistema está al límite máximo permitido',
            pt: 'o sistema está no limite máximo permitido',
            en: 'the system is at the maximum allowed limit',
        }),
        when: pick(labels, {
            es: 'se intenta superar el límite máximo',
            pt: 'tenta-se exceder o limite máximo',
            en: 'an attempt is made to exceed the maximum limit',
        }),
        then: pick(labels, {
            es: 'se rechaza con el mensaje de error apropiado',
            pt: 'é rejeitado com a mensagem de erro apropriada',
            en: 'it is rejected with the appropriate error message',
        }),
    };
}
function edgeMinimum(labels) {
    return {
        given: pick(labels, {
            es: 'el sistema está al límite mínimo permitido',
            pt: 'o sistema está no limite mínimo permitido',
            en: 'the system is at the minimum allowed limit',
        }),
        when: pick(labels, {
            es: 'se intenta ir por debajo del mínimo',
            pt: 'tenta-se ficar abaixo do mínimo',
            en: 'an attempt is made to go below the minimum',
        }),
        then: pick(labels, {
            es: 'se rechaza con el mensaje de error apropiado',
            pt: 'é rejeitado com a mensagem de erro apropriada',
            en: 'it is rejected with the appropriate error message',
        }),
    };
}
function edgeAlways(labels) {
    return {
        given: pick(labels, {
            es: 'múltiples ejecuciones consecutivas bajo diferentes condiciones',
            pt: 'múltiplas execuções consecutivas sob diferentes condições',
            en: 'multiple consecutive executions under different conditions',
        }),
        when: pick(labels, {
            es: 'la operación se ejecuta repetidamente',
            pt: 'a operação é executada repetidamente',
            en: 'the operation is executed repeatedly',
        }),
        then: pick(labels, {
            es: 'el resultado es consistente en todas las ejecuciones',
            pt: 'o resultado é consistente em todas as execuções',
            en: 'the result is consistent across all executions',
        }),
    };
}
function edgeNever(labels) {
    return {
        given: pick(labels, {
            es: 'una condición que podría violar la restricción',
            pt: 'uma condição que poderia violar a restrição',
            en: 'a condition that could violate the constraint',
        }),
        when: pick(labels, {
            es: 'se ejecuta la operación con datos límite',
            pt: 'a operação é executada com dados limítrofes',
            en: 'the operation is executed with boundary data',
        }),
        then: pick(labels, {
            es: 'la restricción se mantiene sin excepciones',
            pt: 'a restrição é mantida sem exceções',
            en: 'the constraint is maintained without exceptions',
        }),
    };
}
function edgeGeneric(labels) {
    return {
        given: pick(labels, {
            es: 'una condición límite específica',
            pt: 'uma condição limite específica',
            en: 'a specific boundary condition',
        }),
        when: labels.whenExecuted,
        then: `the boundary ${labels.thenEdge}`,
    };
}
function buildEdgeCaseScenario(criterion, _criterionId, labels) {
    const lower = criterion.toLowerCase();
    let triplet;
    if (lower.includes('maximum') || lower.includes('max') || lower.includes('máximo')) {
        triplet = edgeMaximum(labels);
    }
    else if (lower.includes('minimum') || lower.includes('min') || lower.includes('mínimo')) {
        triplet = edgeMinimum(labels);
    }
    else if (lower.includes('always') || lower.includes('siempre') || lower.includes('sempre')) {
        triplet = edgeAlways(labels);
    }
    else if (lower.includes('never') || lower.includes('nunca') || lower.includes('jamais')) {
        triplet = edgeNever(labels);
    }
    else {
        triplet = edgeGeneric(labels);
    }
    return { type: 'edge-case', ...triplet };
}
export function buildScenarios(criterion, criterionId, locale) {
    const baseLabels = getLabels(locale);
    const labels = { ...baseLabels, locale };
    const steps = [
        buildHappyPath(criterion, criterionId, labels),
        buildErrorScenario(criterion, criterionId, labels),
    ];
    if (hasEdgeCaseKeyword(criterion)) {
        steps.push(buildEdgeCaseScenario(criterion, criterionId, labels));
    }
    return steps;
}
//# sourceMappingURL=scenario-builders.js.map