import { registroAnalistas } from '../../analysts/registry/index.js';
import { executarGuardian as executarGuardianModular } from '../diagnostic/handlers/index.js';
import { ExitCode, sair } from '../helpers/index.js';
import { config } from '../../core/config/index.js';
import { iniciarInquisicao } from '../../core/execution/index.js';
import { messages } from '../../core/messages/index.js';
import { acceptNewBaseline } from '../../guardian/index.js';
import { Command } from 'commander';
import { asTecnicas, extrairMensagemErro, IntegridadeStatus } from '../../types/index.js';
const { log, logGuardian } = messages;
function getGuardianIgnorePatterns() {
    const raw = config.GUARDIAN_IGNORE_PATTERNS;
    return Array.isArray(raw) ? [...raw] : [];
}
function setGuardianIgnorePatterns(patterns) {
    config.GUARDIAN_IGNORE_PATTERNS = patterns;
}
function getCacheDiffHits() {
    const globalCache = globalThis;
    return globalCache.__TUTANUS_DIFF_CACHE_HITS__ || 0;
}
function mostrarErroDev(err) {
    if (!config.DEV_MODE)
        return;
    console.error(extrairMensagemErro(err));
    if (err && typeof err === 'object' && 'stack' in err) {
        console.error(err.stack);
    }
}
function converterParaFileEntry(entries) {
    return entries.map(entry => ({
        relPath: entry.relPath,
        fullCaminho: entry.fullCaminho,
        content: entry.content
    }));
}
async function executarModoDiff(guardianResultado, opts) {
    if (guardianResultado.drift && guardianResultado.drift > 0) {
        if (opts.json) {
            console.log(JSON.stringify({ status: 'alteracoes-detectadas', drift: guardianResultado.drift }));
        }
        else {
            logGuardian.diferencasDetectadas();
            log.aviso(messages.CliComandoGuardianMensagens.diffMudancasDetectadas(guardianResultado.drift));
            log.aviso(messages.CliComandoGuardianMensagens.diffComoAceitarMudancas);
        }
        sair(ExitCode.Failure);
        return;
    }
    if (opts.json) {
        console.log(JSON.stringify({ status: 'ok', drift: 0 }));
    }
    else {
        logGuardian.integridadePreservada();
    }
}
async function executarModoNormal(guardianResultado, opts) {
    const statusNorm = guardianResultado.status || IntegridadeStatus.Ok;
    switch (statusNorm) {
        case IntegridadeStatus.Ok:
            if (opts.json) {
                console.log(JSON.stringify({ status: 'ok', cacheDiffHits: getCacheDiffHits() }));
            }
            else {
                logGuardian.integridadeOk();
            }
            break;
        case IntegridadeStatus.Criado:
            if (opts.json) {
                console.log(JSON.stringify({ status: 'baseline-criado', cacheDiffHits: getCacheDiffHits() }));
            }
            else {
                logGuardian.baselineCriadoConsole();
            }
            log.aviso(messages.CliComandoGuardianMensagens.baselineCriadoComoAceitar);
            break;
        case IntegridadeStatus.Aceito:
            if (opts.json) {
                console.log(JSON.stringify({ status: 'baseline-aceito', cacheDiffHits: getCacheDiffHits() }));
            }
            else {
                logGuardian.baselineAtualizado();
            }
            break;
        case IntegridadeStatus.AlteracoesDetectadas:
            if (opts.json) {
                console.log(JSON.stringify({
                    status: 'alteracoes-detectadas',
                    temProblemas: guardianResultado.temProblemas,
                    drift: guardianResultado.drift
                }));
            }
            else {
                logGuardian.alteracoesSuspeitas();
            }
            sair(ExitCode.Failure);
            break;
    }
}
export function comandoGuardian(aplicarFlagsGlobais) {
    return new Command('guardian').description(messages.CliComandoGuardianMensagens.descricao)
        .allowUnknownOption(true).allowExcessArguments(true)
        .option('-a, --accept-baseline', 'Aceita o baseline atual como o novo baseline de integridade')
        .option('-d, --diff', 'Mostra as diferenças entre o estado atual e o baseline')
        .option('--full-scan', 'Executa verificação sem aplicar GUARDIAN_IGNORE_PATTERNS (não persistir baseline)')
        .option('--json', 'Saída em JSON estruturado (para CI/integracoes)')
        .action(async function (opts) {
        try {
            await aplicarFlagsGlobais(this.parent && typeof this.parent.opts === 'function' ? this.parent.opts() : {});
        }
        catch (err) {
            log.erro(`Falha ao aplicar flags: ${err instanceof Error ? err.message : String(err)}`);
            sair(ExitCode.Failure);
            return;
        }
        const baseDir = process.cwd();
        let fileEntries = [];
        try {
            const tecnicas = asTecnicas(registroAnalistas);
            const resultadoInquisicao = await iniciarInquisicao(baseDir, { incluirMetadados: false }, tecnicas);
            fileEntries = resultadoInquisicao.fileEntries;
            const ignoradosOriginais = getGuardianIgnorePatterns();
            if (opts.fullScan) {
                setGuardianIgnorePatterns([]);
                if (!opts.acceptBaseline) {
                    logGuardian.fullScanAviso();
                }
            }
            if (opts.acceptBaseline) {
                if (opts.fullScan) {
                    log.aviso(messages.CliComandoGuardianMensagens.baselineNaoPermitidoFullScan);
                    setGuardianIgnorePatterns(ignoradosOriginais);
                    sair(ExitCode.Failure);
                    return;
                }
                logGuardian.aceitandoBaseline();
                await acceptNewBaseline(fileEntries);
                if (opts.json) {
                    console.log(JSON.stringify({ status: IntegridadeStatus.Aceito, baseline: true }));
                }
                else {
                    logGuardian.baselineAceitoSucesso();
                }
            }
            else {
                const guardianOpts = {
                    enabled: true,
                    fullScan: Boolean(opts.fullScan),
                    saveBaseline: false,
                    silent: Boolean(opts.json)
                };
                const guardianResultado = await executarGuardianModular(converterParaFileEntry(fileEntries), guardianOpts);
                if (opts.diff) {
                    await executarModoDiff(guardianResultado, opts);
                }
                else {
                    await executarModoNormal(guardianResultado, opts);
                }
            }
            if (opts.fullScan) {
                setGuardianIgnorePatterns(ignoradosOriginais);
            }
        }
        catch (err) {
            logGuardian.erroGuardian(err.message ?? String(err));
            mostrarErroDev(err);
            if (opts.json) {
                console.log(JSON.stringify({ status: 'erro', mensagem: extrairMensagemErro(err) }));
            }
            sair(ExitCode.Failure);
        }
    });
}
//# sourceMappingURL=command-guardian.js.map