"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.palavrasNeutras = exports.gruposPalavrasParadigma = void 0;
exports.obterMapaLexemaParaParadigma = obterMapaLexemaParaParadigma;
exports.obterFormaAlternativa = obterFormaAlternativa;
exports.pertenceAoParadigma = pertenceAoParadigma;
const delegua_1 = __importDefault(require("../tipos-de-simbolos/delegua"));
/**
 * Grupos de palavras reservadas organizadas por paradigma.
 * Cada grupo representa diferentes formas de expressar a mesma funcionalidade.
 */
exports.gruposPalavrasParadigma = [
    {
        tipo: delegua_1.default.ESCREVA,
        imperativo: ['escreva'],
        infinitivo: ['escrever'],
    },
    {
        tipo: delegua_1.default.LEIA,
        imperativo: ['leia'],
        infinitivo: ['ler'],
    },
    {
        tipo: delegua_1.default.CONTINUA,
        imperativo: ['continua'],
        infinitivo: ['continuar'],
    },
    {
        tipo: delegua_1.default.RETORNA,
        imperativo: ['retorna', 'retorne'],
        infinitivo: ['retornar'],
    },
    {
        tipo: delegua_1.default.ESCOLHA,
        imperativo: ['escolha'],
        infinitivo: ['escolher'],
    },
    {
        tipo: delegua_1.default.TENTE,
        imperativo: ['tente'],
        infinitivo: ['tentar'],
    },
    {
        tipo: delegua_1.default.PEGUE,
        imperativo: ['pegue'],
        infinitivo: ['pegar'],
    },
    {
        tipo: delegua_1.default.QUEBRAR,
        imperativo: ['quebre'],
        infinitivo: ['quebrar'],
    },
    {
        tipo: delegua_1.default.IMPORTAR,
        imperativo: ['importe'],
        infinitivo: ['importar'],
    },
    {
        tipo: delegua_1.default.FAZER,
        imperativo: ['faca', 'faça'],
        infinitivo: ['fazer'],
    },
];
/**
 * Palavras neutras que não têm paradigma específico.
 * Estas palavras são aceitas em todos os modos de paradigma.
 */
exports.palavrasNeutras = {
    ajuda: delegua_1.default.AJUDA,
    cada: delegua_1.default.CADA,
    caso: delegua_1.default.CASO,
    classe: delegua_1.default.CLASSE,
    como: delegua_1.default.COMO,
    construtor: delegua_1.default.CONSTRUTOR,
    constante: delegua_1.default.CONSTANTE,
    const: delegua_1.default.CONSTANTE,
    contem: delegua_1.default.CONTEM,
    contém: delegua_1.default.CONTEM,
    de: delegua_1.default.DE,
    e: delegua_1.default.E,
    em: delegua_1.default.EM,
    enquanto: delegua_1.default.ENQUANTO,
    falhar: delegua_1.default.FALHAR,
    falso: delegua_1.default.FALSO,
    finalmente: delegua_1.default.FINALMENTE,
    fixo: delegua_1.default.CONSTANTE,
    funcao: delegua_1.default.FUNCAO,
    função: delegua_1.default.FUNÇÃO,
    herda: delegua_1.default.HERDA,
    isto: delegua_1.default.ISTO,
    nao: delegua_1.default.NAO,
    não: delegua_1.default.NAO,
    nulo: delegua_1.default.NULO,
    ou: delegua_1.default.OU,
    padrao: delegua_1.default.PADRAO,
    padrão: delegua_1.default.PADRAO,
    para: delegua_1.default.PARA,
    se: delegua_1.default.SE,
    senao: delegua_1.default.SENAO,
    senão: delegua_1.default.SENÃO,
    super: delegua_1.default.SUPER,
    sustar: delegua_1.default.SUSTAR,
    tendo: delegua_1.default.TENDO,
    tipo: delegua_1.default.TIPO,
    tudo: delegua_1.default.TUDO,
    var: delegua_1.default.VARIAVEL,
    variavel: delegua_1.default.VARIAVEL,
    variável: delegua_1.default.VARIAVEL,
    verdadeiro: delegua_1.default.VERDADEIRO,
};
/**
 * Retorna um mapa de lexema para paradigma.
 * Útil para verificar rapidamente se uma palavra pertence a um paradigma.
 */
function obterMapaLexemaParaParadigma() {
    const mapa = new Map();
    // Adiciona palavras neutras
    for (const lexema of Object.keys(exports.palavrasNeutras)) {
        mapa.set(lexema, 'neutro');
    }
    // Adiciona palavras de paradigmas
    for (const grupo of exports.gruposPalavrasParadigma) {
        if (grupo.imperativo) {
            for (const lexema of grupo.imperativo) {
                mapa.set(lexema, 'imperativo');
            }
        }
        if (grupo.infinitivo) {
            for (const lexema of grupo.infinitivo) {
                mapa.set(lexema, 'infinitivo');
            }
        }
    }
    return mapa;
}
/**
 * Obtém a forma alternativa de uma palavra para o paradigma especificado.
 * @param lexema A palavra original
 * @param paradigmaAlvo O paradigma desejado
 * @returns A forma alternativa ou undefined se não houver conversão
 */
function obterFormaAlternativa(lexema, paradigmaAlvo) {
    var _a, _b;
    const lexemaLower = lexema.toLowerCase();
    // Encontra o grupo que contém este lexema
    for (const grupo of exports.gruposPalavrasParadigma) {
        const temImperativo = (_a = grupo.imperativo) === null || _a === void 0 ? void 0 : _a.some((p) => p === lexemaLower);
        const temInfinitivo = (_b = grupo.infinitivo) === null || _b === void 0 ? void 0 : _b.some((p) => p === lexemaLower);
        if (temImperativo || temInfinitivo) {
            // Retorna a primeira forma do paradigma alvo
            if (paradigmaAlvo === 'imperativo' && grupo.imperativo && grupo.imperativo.length > 0) {
                return grupo.imperativo[0];
            }
            if (paradigmaAlvo === 'infinitivo' && grupo.infinitivo && grupo.infinitivo.length > 0) {
                return grupo.infinitivo[0];
            }
        }
    }
    return undefined;
}
/**
 * Verifica se um lexema pertence a um paradigma específico.
 * @param lexema A palavra a verificar
 * @param paradigma O paradigma a verificar
 * @returns true se o lexema pertence ao paradigma ou é neutro
 */
function pertenceAoParadigma(lexema, paradigma) {
    if (paradigma === 'ambos') {
        return true;
    }
    const mapa = obterMapaLexemaParaParadigma();
    const paradigmaLexema = mapa.get(lexema.toLowerCase());
    // Palavras neutras são aceitas em todos os paradigmas
    if (paradigmaLexema === 'neutro') {
        return true;
    }
    // Verifica se o paradigma corresponde
    return paradigmaLexema === paradigma;
}
//# sourceMappingURL=mapeamento-paradigmas.js.map