import { detectarArquetipos } from '../../../analysts/architects/index.js';
import { config } from '../../../core/config/index.js';
import { messages } from '../../../core/messages/index.js';
const log = messages.log;
const PADRAO_TEMPO_LIMITE_MS = process.env.VITEST ? 1000 : 30000;
export async function executarDeteccaoArquetipos(entries, baseDir, options) {
    if (!options.enabled) {
        return {
            executado: false
        };
    }
    try {
        if (!options.silent) {
            log.info(messages.MENSAGENS_ARQUETIPOS.detectando);
        }
        const ctx = {
            arquivos: entries,
            baseDir
        };
        const timeoutMs = options.timeout || PADRAO_TEMPO_LIMITE_MS;
        const resultado = await executarComTimeout(detectarArquetipos(ctx, baseDir), timeoutMs);
        if (!resultado) {
            if (!options.silent) {
                log.aviso(messages.CliArquetipoHandlerMensagens.timeoutDeteccao);
            }
            return {
                executado: true,
                erro: 'timeout'
            };
        }
        const arquetipos = resultado.candidatos || [];
        const principal = arquetipos.length > 0 ? arquetipos[0] : undefined;
        if (!options.silent && principal) {
            log.info(messages.MENSAGENS_ARQUETIPOS.identificado(principal.nome, principal.confidence));
            if (arquetipos.length > 1) {
                log.info(messages.MENSAGENS_ARQUETIPOS.multiplos(arquetipos.length));
            }
        }
        let salvo = false;
        if (options.salvar && resultado) {
            salvo = await salvarArquetipo(resultado, baseDir, options.silent);
        }
        return {
            executado: true,
            arquetipos: arquetipos.map(arquivo => ({
                tipo: arquivo.nome,
                confianca: arquivo.confidence,
                caracteristicas: arquivo.matchedRequired || []
            })),
            principal: principal ? {
                tipo: principal.nome,
                confianca: principal.confidence
            } : undefined,
            salvo
        };
    }
    catch (erro) {
        const mensagem = erro instanceof Error ? erro.message : String(erro);
        if (!options.silent) {
            log.aviso(messages.CliArquetipoHandlerMensagens.erroDeteccao(mensagem));
        }
        if (config.DEV_MODE) {
            console.error(messages.CliArquetipoHandlerMensagens.devErroPrefixo, erro);
        }
        return {
            executado: true,
            erro: mensagem
        };
    }
}
async function executarComTimeout(promise, timeoutMs) {
    try {
        const timeoutPromise = new Promise(resolve => setTimeout(() => resolve(undefined), timeoutMs));
        return await Promise.race([promise, timeoutPromise]);
    }
    catch {
        return undefined;
    }
}
async function salvarArquetipo(resultado, baseDir, silent) {
    try {
        if (!silent) {
            log.info(messages.MENSAGENS_ARQUETIPOS.salvando);
        }
        const fs = await import('node:fs/promises');
        const path = await import('node:path');
        const arquetipo = {
            timestamp: new Date().toISOString(),
            projeto: path.basename(baseDir),
            arquetipos: resultado.candidatos,
            baseline: resultado.baseline,
            drift: resultado.drift
        };
        const outputCaminho = path.join(baseDir, 'tutanus.repo.arquetipo.json');
        await fs.writeFile(outputCaminho, JSON.stringify(arquetipo, null, 2), 'utf-8');
        if (!silent) {
            log.sucesso(messages.MENSAGENS_ARQUETIPOS.salvo(outputCaminho));
        }
        return true;
    }
    catch (erro) {
        const mensagem = erro instanceof Error ? erro.message : String(erro);
        if (!silent) {
            log.aviso(messages.CliArquetipoHandlerMensagens.falhaSalvar(mensagem));
        }
        return false;
    }
}
export function formatarArquetiposParaJson(result) {
    if (!result.executado) {
        return {
            executado: false
        };
    }
    if (result.erro) {
        return {
            executado: true,
            erro: result.erro
        };
    }
    return {
        executado: true,
        arquetipos: result.arquetipos || [],
        principal: result.principal || null,
        salvo: result.salvo || false
    };
}
export function gerarSugestoesArquetipo(result) {
    const sugestoes = [];
    if (!result.executado || !result.principal) {
        return sugestoes;
    }
    const { tipo, confianca } = result.principal;
    switch (tipo.toLowerCase()) {
        case 'monorepo':
            sugestoes.push('[IDEIA] Monorepo detectado: considere usar filtros por workspace');
            sugestoes.push('[IDEIA] Use --include packages/* para analisar workspaces específicos');
            break;
        case 'biblioteca':
        case 'library':
            sugestoes.push('[IDEIA] Biblioteca detectada: foque em exports públicos e documentação');
            sugestoes.push('[IDEIA] Use --guardian para verificar API pública');
            break;
        case 'cli':
        case 'cli-tool':
            sugestoes.push('[IDEIA] CLI detectado: priorize testes de comandos e flags');
            break;
        case 'api':
        case 'api-rest':
        case 'api-server':
            sugestoes.push('[IDEIA] API detectada: foque em endpoints e contratos');
            sugestoes.push('[IDEIA] Considere testes de integração para rotas');
            break;
        case 'frontend':
        case 'web-app':
            sugestoes.push('[IDEIA] Frontend detectado: priorize componentes e state management');
            break;
    }
    if (confianca < 70) {
        sugestoes.push('[AVISO]  Confiança baixa na detecção: estrutura pode ser híbrida');
        sugestoes.push('[IDEIA] Use --criar-arquetipo --salvar-arquetipo para personalizar');
    }
    return sugestoes;
}
//# sourceMappingURL=archetype-handler.js.map