import { traverse } from '../../core/config/index.js';
import { messages } from '../../core/messages/index.js';
import * as path from 'path';
import { criarOcorrencia } from '../../types/index.js';
export const analistaArquitetura = {
    nome: 'arquitetura',
    categoria: 'estrutura',
    descricao: 'Analisa padrões arquiteturais e detecta violações de design',
    test: (relPath) => {
        return /\.(js|jsx|ts|tsx|mjs|cjs)$/.test(relPath);
    },
    aplicar: async (src, relPath, ast, fullCaminho, contexto) => {
        if (!ast || !src || !contexto) {
            return [];
        }
        try {
            const estatisticasArquivo = analisarArquivo(ast, relPath, src);
            let analiseCompleta;
            const ocorrencias = [];
            try {
                analiseCompleta = await analisarArquiteturaCompleta(contexto, estatisticasArquivo);
            }
            catch (erro) {
                if (typeof contexto.report === 'function') {
                    contexto.report({
                        code: 'ARQ_ERRO',
                        tipo: 'erro-analise',
                        nivel: 'aviso',
                        relPath,
                        linha: 1,
                        data: {
                            erro
                        },
                        origem: 'arquitetura'
                    });
                    return [];
                }
                const { DetectorArquiteturaMensagens } = messages;
                return [criarOcorrencia({
                        tipo: 'erro-analise',
                        nivel: 'aviso',
                        mensagem: DetectorArquiteturaMensagens.erroAnalisarArquitetura(erro),
                        relPath,
                        linha: 1
                    })];
            }
            if (typeof contexto.report === 'function') {
                contexto.report({
                    code: 'ARQ_PADRAO',
                    tipo: 'analise-arquitetura',
                    nivel: (analiseCompleta.violacoes?.length ?? 0) > 0 ? 'aviso' : 'info',
                    relPath,
                    linha: 1,
                    data: {
                        padraoIdentificado: analiseCompleta.padraoIdentificado,
                        confianca: analiseCompleta.confianca ?? 0
                    },
                    origem: 'arquitetura'
                });
            }
            else {
                const { DetectorArquiteturaMensagens } = messages;
                ocorrencias.push(criarOcorrencia({
                    tipo: 'analise-arquitetura',
                    nivel: (analiseCompleta.violacoes?.length ?? 0) > 0 ? 'aviso' : 'info',
                    mensagem: DetectorArquiteturaMensagens.padraoArquitetural(analiseCompleta.padraoIdentificado, analiseCompleta.confianca ?? 0),
                    relPath,
                    linha: 1
                }));
            }
            if ((analiseCompleta.caracteristicas?.length ?? 0) > 0) {
                if (typeof contexto.report === 'function') {
                    contexto.report({
                        code: 'ARQ_CARACTERISTICAS',
                        tipo: 'caracteristicas-arquitetura',
                        nivel: 'info',
                        relPath,
                        linha: 1,
                        data: {
                            caracteristicas: analiseCompleta.caracteristicas || []
                        },
                        origem: 'arquitetura'
                    });
                }
                else {
                    const { DetectorArquiteturaMensagens } = await import('../../core/messages/pt/analysts/detector-architecture-messages.js');
                    ocorrencias.push(criarOcorrencia({
                        tipo: 'caracteristicas-arquitetura',
                        nivel: 'info',
                        mensagem: DetectorArquiteturaMensagens.caracteristicas(analiseCompleta.caracteristicas || []),
                        relPath,
                        linha: 1
                    }));
                }
            }
            for (const violacao of (analiseCompleta.violacoes ?? []).slice(0, 3)) {
                if (typeof contexto.report === 'function') {
                    contexto.report({
                        code: 'ARQ_VIOLACAO',
                        tipo: 'violacao-arquitetura',
                        nivel: 'aviso',
                        relPath,
                        linha: 1,
                        data: {
                            violacao
                        },
                        origem: 'arquitetura'
                    });
                }
                else {
                    const { DetectorArquiteturaMensagens } = await import('../../core/messages/pt/analysts/detector-architecture-messages.js');
                    ocorrencias.push(criarOcorrencia({
                        tipo: 'violacao-arquitetura',
                        nivel: 'aviso',
                        mensagem: DetectorArquiteturaMensagens.violacao(violacao),
                        relPath,
                        linha: 1
                    }));
                }
            }
            const metricas = analiseCompleta.metricas;
            if (metricas && typeof metricas === 'object' && 'acoplamento' in metricas && 'coesao' in metricas) {
                if ((metricas.acoplamento ?? 0) > 0.7 || (metricas.coesao ?? 1) < 0.3) {
                    if (typeof contexto.report === 'function') {
                        contexto.report({
                            code: 'ARQ_METRICAS',
                            tipo: 'metricas-arquitetura',
                            nivel: 'aviso',
                            relPath,
                            linha: 1,
                            data: {
                                acoplamento: metricas.acoplamento ?? 0,
                                coesao: metricas.coesao ?? 0
                            },
                            origem: 'arquitetura'
                        });
                    }
                    else {
                        const { DetectorArquiteturaMensagens } = await import('../../core/messages/pt/analysts/detector-architecture-messages.js');
                        ocorrencias.push(criarOcorrencia({
                            tipo: 'metricas-arquitetura',
                            nivel: 'aviso',
                            mensagem: DetectorArquiteturaMensagens.metricas(metricas.acoplamento ?? 0, metricas.coesao ?? 0),
                            relPath,
                            linha: 1
                        }));
                    }
                }
            }
            return ocorrencias;
        }
        catch (erro) {
            if (typeof contexto.report === 'function') {
                contexto.report({
                    code: 'ARQ_ERRO',
                    tipo: 'erro-analise',
                    nivel: 'aviso',
                    relPath,
                    linha: 1,
                    data: {
                        erro
                    },
                    origem: 'arquitetura'
                });
                return [];
            }
            const { DetectorArquiteturaMensagens } = await import('../../core/messages/pt/analysts/detector-architecture-messages.js');
            return [criarOcorrencia({
                    tipo: 'erro-analise',
                    nivel: 'aviso',
                    mensagem: DetectorArquiteturaMensagens.erroAnalisarArquitetura(erro),
                    relPath,
                    linha: 1
                })];
        }
    }
};
function analisarArquivo(ast, relPath, _src) {
    const imports = [];
    const exports = [];
    const dependenciasExternas = [];
    const dependenciasInternas = [];
    const aliases = {};
    let complexidade = 0;
    traverse(ast.node, {
        ImportDeclaration(path) {
            const origem = path.node.source.value;
            const items = path.node.specifiers.map((spec) => {
                if (spec.type === 'ImportDefaultSpecifier')
                    return 'default';
                if (spec.type === 'ImportNamespaceSpecifier')
                    return '*';
                return spec.local.name;
            });
            let tipo = 'external';
            if (origem.startsWith('@')) {
                tipo = 'alias';
                const alias = origem.split('/')[0];
                aliases[alias] = (aliases[alias] || 0) + 1;
                dependenciasInternas.push(origem);
            }
            else if (origem.startsWith('.')) {
                tipo = 'relative';
                dependenciasInternas.push(origem);
            }
            else {
                dependenciasExternas.push(origem);
            }
            imports.push({
                origem,
                tipo,
                items
            });
        },
        ExportNamedDeclaration(path) {
            if (path.node.declaration) {
                const decl = path.node.declaration;
                if ('id' in decl && decl.id && 'name' in decl.id) {
                    exports.push({
                        nome: decl.id.name,
                        tipo: 'named'
                    });
                }
                else if ('declarations' in decl && decl.declarations) {
                    for (const declarator of decl.declarations) {
                        if (declarator.id && 'name' in declarator.id) {
                            exports.push({
                                nome: declarator.id.name,
                                tipo: 'named'
                            });
                        }
                    }
                }
            }
            else {
                for (const spec of path.node.specifiers) {
                    const name = 'exported' in spec && spec.exported.type === 'Identifier' && 'name' in spec.exported ? spec.exported.name : 'exported';
                    exports.push({
                        nome: name,
                        tipo: 'named'
                    });
                }
            }
        },
        ExportDefaultDeclaration() {
            exports.push({
                nome: 'default',
                tipo: 'default'
            });
        },
        'IfStatement|WhileStatement|ForStatement|DoWhileStatement|SwitchCase|CatchClause'() {
            complexidade++;
        },
        'ConditionalExpression|LogicalExpression'() {
            complexidade++;
        }
    });
    return {
        caminho: relPath,
        imports,
        exports,
        dependenciasExternas,
        dependenciasInternas,
        aliases,
        complexidade: complexidade || 1
    };
}
async function analisarArquiteturaCompleta(contexto, arquivoAtual) {
    const todasEstatisticas = [];
    for (const arquivo of contexto.arquivos.slice(0, 50)) {
        if (arquivo.ast && arquivo.content && arquivo.relPath.match(/\.(js|jsx|ts|tsx)$/)) {
            if ('parent' in arquivo.ast && 'node' in arquivo.ast) {
                const stats = analisarArquivo(arquivo.ast, arquivo.relPath, arquivo.content);
                todasEstatisticas.push(stats);
            }
        }
    }
    todasEstatisticas.push(arquivoAtual);
    const padraoDetectado = detectarPadraoArquitetural(todasEstatisticas);
    const cleanArchResultado = detectarCleanArchitecture(contexto, todasEstatisticas, arquivoAtual);
    const distributedArchResultado = detectarArquiteturaDistribuida(contexto, todasEstatisticas, arquivoAtual);
    const melhoresPadroes = [
        { tipo: cleanArchResultado.tipo, confianca: cleanArchResultado.confianca },
        { tipo: distributedArchResultado.tipo, confianca: distributedArchResultado.confianca },
        padraoDetectado
    ].sort((a, b) => b.confianca - a.confianca);
    const padraoFinal = melhoresPadroes[0];
    const metricas = calcularMetricas(todasEstatisticas);
    const violacoes = detectarViolacoes(todasEstatisticas, padraoDetectado);
    const caracteristicas = [
        ...gerarCaracteristicas(todasEstatisticas),
        ...cleanArchResultado.caracteristicas,
        ...distributedArchResultado.caracteristicas
    ];
    const recomendacoes = [];
    if (cleanArchResultado.confianca >= 50) {
        recomendacoes.push(...cleanArchResultado.recomendacoes);
    }
    if (distributedArchResultado.confianca >= 50) {
        recomendacoes.push(...distributedArchResultado.recomendacoes);
    }
    return {
        padraoIdentificado: padraoFinal.tipo || padraoDetectado.tipo,
        confianca: padraoFinal.confianca || padraoDetectado.confianca,
        caracteristicas,
        violacoes,
        recomendacoes,
        metricas,
        imports: [],
        exports: [],
        stats: arquivoAtual
    };
}
function detectarPadraoArquitetural(estatisticas) {
    const aliases = new Set();
    let temNucleo = false;
    let temAnalistas = false;
    let temShared = false;
    let temTipos = false;
    for (const stats of estatisticas) {
        if (stats.aliases) {
            Object.keys(stats.aliases).forEach(alias => aliases.add(alias));
            if (stats.aliases['@nucleo'])
                temNucleo = true;
            if (stats.aliases['@analistas'])
                temAnalistas = true;
            if (stats.aliases['@shared'])
                temShared = true;
            if (stats.aliases['@types'])
                temTipos = true;
        }
    }
    const temDependenciasCirculares = detectarDependenciasCirculares(estatisticas);
    if (temNucleo && temAnalistas && !temDependenciasCirculares) {
        if (temShared && temTipos) {
            return {
                tipo: 'Arquitetura Hexagonal com Clean Architecture',
                confianca: 90
            };
        }
        return {
            tipo: 'Arquitetura Hexagonal (Ports and Adapters)',
            confianca: 85
        };
    }
    if (aliases.size >= 4 && temTipos) {
        return {
            tipo: 'Arquitetura Modular Bem Estruturada',
            confianca: 80
        };
    }
    if (aliases.size >= 2) {
        return {
            tipo: 'Arquitetura Modular',
            confianca: 70
        };
    }
    if (temDependenciasCirculares) {
        return {
            tipo: 'Arquitetura com Problemas de Acoplamento',
            confianca: 60
        };
    }
    return {
        tipo: 'Arquitetura Simples ou Monolítica',
        confianca: 50
    };
}
function calcularMetricas(estatisticas) {
    if (estatisticas.length === 0) {
        return {
            modularidade: 0,
            acoplamento: 0,
            coesao: 0,
            complexidadeMedia: 0
        };
    }
    const totalImports = estatisticas.reduce((sum, string) => {
        if (Array.isArray(string.imports)) {
            return sum + string.imports.length;
        }
        else if (typeof string.imports === 'number') {
            return sum + string.imports;
        }
        return sum;
    }, 0);
    const importsAlias = estatisticas.reduce((sum, string) => {
        if (Array.isArray(string.imports)) {
            return sum + string.imports.filter((indice) => indice.tipo === 'alias').length;
        }
        return sum;
    }, 0);
    const modularidade = totalImports > 0 ? importsAlias / totalImports : 0;
    const totalDeps = estatisticas.reduce((sum, string) => {
        const externas = string.dependenciasExternas?.length ?? 0;
        const internas = string.dependenciasInternas?.length ?? 0;
        return sum + externas + internas;
    }, 0);
    const depsExternas = estatisticas.reduce((sum, string) => {
        return sum + (string.dependenciasExternas?.length ?? 0);
    }, 0);
    const acoplamento = totalDeps > 0 ? depsExternas / totalDeps : 0;
    const totalExports = estatisticas.reduce((sum, string) => {
        if (Array.isArray(string.exports)) {
            return sum + string.exports.length;
        }
        else if (typeof string.exports === 'number') {
            return sum + string.exports;
        }
        return sum;
    }, 0);
    const ratio = totalImports > 0 ? totalExports / totalImports : 0;
    const coesao = ratio > 0 ? Math.min(ratio, 1 / ratio) : 0;
    const complexidadeMedia = estatisticas.reduce((sum, string) => sum + (string.complexidade ?? 0), 0) / estatisticas.length;
    return {
        modularidade: Math.max(0, Math.min(1, modularidade)),
        acoplamento: Math.max(0, Math.min(1, acoplamento)),
        coesao: Math.max(0, Math.min(1, coesao)),
        complexidadeMedia
    };
}
function detectarViolacoes(estatisticas, _padrao) {
    const violacoes = [];
    const totalImports = estatisticas.reduce((sum, string) => {
        if (Array.isArray(string.imports)) {
            return sum + string.imports.length;
        }
        else if (typeof string.imports === 'number') {
            return sum + string.imports;
        }
        return sum;
    }, 0);
    const importsRelativos = estatisticas.reduce((sum, string) => {
        if (Array.isArray(string.imports)) {
            return sum + string.imports.filter((indice) => indice.tipo === 'relative').length;
        }
        return sum;
    }, 0);
    if (totalImports > 0 && importsRelativos / totalImports > 0.3) {
        violacoes.push('Uso excessivo de imports relativos (>30%)');
    }
    for (const stats of estatisticas) {
        const importsContagem = Array.isArray(stats.imports) ? stats.imports.length : typeof stats.imports === 'number' ? stats.imports : 0;
        if (importsContagem > 20) {
            const caminho = stats.caminho ?? 'arquivo-desconhecido';
            violacoes.push(`Arquivo ${path.basename(caminho)} com muitas dependências (${importsContagem})`);
        }
    }
    return violacoes;
}
function gerarCaracteristicas(estatisticas) {
    const caracteristicas = [];
    const aliases = new Set();
    estatisticas.forEach(string => {
        if (string.aliases) {
            Object.keys(string.aliases).forEach(arquivo => aliases.add(arquivo));
        }
    });
    if (aliases.size > 0) {
        caracteristicas.push(`Uso de ${aliases.size} aliases de importação`);
    }
    const mediaComplexidade = estatisticas.reduce((sum, string) => sum + (string.complexidade ?? 0), 0) / estatisticas.length;
    caracteristicas.push(`Complexidade média: ${mediaComplexidade.toFixed(1)}`);
    const totalExports = estatisticas.reduce((sum, string) => {
        if (Array.isArray(string.exports)) {
            return sum + string.exports.length;
        }
        else if (typeof string.exports === 'number') {
            return sum + string.exports;
        }
        return sum;
    }, 0);
    caracteristicas.push(`${totalExports} exports públicos`);
    return caracteristicas;
}
function detectarDependenciasCirculares(estatisticas) {
    const dependencias = new Map();
    for (const stats of estatisticas) {
        const caminho = stats.caminho ?? 'arquivo-desconhecido';
        const deps = new Set();
        if (stats.dependenciasInternas) {
            stats.dependenciasInternas.forEach(dep => deps.add(dep));
        }
        dependencias.set(caminho, deps);
    }
    for (const [arquivo, deps] of dependencias) {
        for (const dep of deps) {
            const depsDoDepdep = dependencias.get(dep);
            if (depsDoDepdep?.has(arquivo)) {
                return true;
            }
        }
    }
    return false;
}
function detectarCleanArchitecture(contexto, _estatisticas, _arquivoAtual) {
    const caracteristicas = [];
    const recomendacoes = [];
    let pontuacao = 0;
    const totalChecagens = 10;
    const caminhos = contexto.arquivos.map(a => a.relPath.toLowerCase());
    const temEntities = caminhos.some(c => c.includes('/domain/') || c.includes('/entities/') || c.endsWith('entity.ts') || c.endsWith('entity.js'));
    const temValueObjects = caminhos.some(c => c.includes('/value-object') || c.includes('value-object'));
    const temRepoInterfaces = caminhos.some(c => c.includes('/domain/') && (c.includes('repository') || c.includes('port')));
    if (temEntities) {
        pontuacao++;
        caracteristicas.push('Camada de domínio com entidades detectada');
    }
    if (temValueObjects) {
        pontuacao++;
        caracteristicas.push('Value Objects presentes no domínio');
    }
    if (temRepoInterfaces) {
        pontuacao++;
        caracteristicas.push('Interfaces de repositório no domínio');
    }
    const temUseCases = caminhos.some(c => c.includes('/use-case') || c.includes('/use-cases/') || c.includes('/application/'));
    const temDtos = caminhos.some(c => c.includes('/dto') || c.endsWith('.dto.ts') || c.endsWith('.dto.js'));
    const temPorts = caminhos.some(c => c.includes('/ports') || c.includes('/application/port'));
    if (temUseCases) {
        pontuacao++;
        caracteristicas.push('Casos de uso (use-cases) detectados');
    }
    if (temDtos) {
        pontuacao++;
        caracteristicas.push('DTOs na camada de aplicação');
    }
    if (temPorts) {
        pontuacao++;
        caracteristicas.push('Ports de aplicação detectados');
    }
    const temInfra = caminhos.some(c => c.includes('/infrastructure/') || c.includes('/infra/'));
    const temReposImpl = caminhos.some(c => c.includes('/infrastructure/repositories') || c.includes('/infra/repositories'));
    if (temInfra) {
        pontuacao++;
        caracteristicas.push('Camada de infraestrutura presente');
    }
    if (temReposImpl) {
        pontuacao++;
        caracteristicas.push('Implementações de repositórios na infra');
    }
    const temPresentation = caminhos.some(c => c.includes('/presentation/') || c.includes('/presenters/'));
    const temControllers = caminhos.some(c => c.includes('/presentation/controllers') || c.includes('/controllers'));
    if (temPresentation || temControllers) {
        pontuacao++;
        caracteristicas.push('Camada de apresentação/controllers detectada');
    }
    const temDependencyInversion = caminhos.some(c => c.includes('/domain/') && (c.includes('repository') || c.includes('port') || c.includes('interface')));
    if (temDependencyInversion) {
        pontuacao++;
        caracteristicas.push('Princípio de Inversão de Dependência identificado');
    }
    for (const stats of _estatisticas) {
        if (stats.caminho?.includes('/domain/') && stats.dependenciasInternas) {
            const importsParaInfra = stats.dependenciasInternas.filter(d => d.includes('infrastructure') || d.includes('infra') || d.includes('presentation'));
            if (importsParaInfra.length > 0) {
                pontuacao -= 2;
                recomendacoes.push('Domínio não deve importar camadas de infraestrutura (violação da Clean Architecture)');
            }
        }
    }
    if (!temEntities && !temValueObjects) {
        recomendacoes.push('Considere criar uma camada de domínio com entidades e value-objects');
    }
    if (!temUseCases) {
        recomendacoes.push('Adicione casos de uso (use-cases) na camada de aplicação para orquestrar regras de negócio');
    }
    if (!temRepoInterfaces && temReposImpl) {
        recomendacoes.push('Defina interfaces de repositório no domínio e implemente na infraestrutura');
    }
    if (!temInfra && (temReposImpl || temControllers)) {
        recomendacoes.push('Organize implementações concretas em uma camada de infraestrutura separada');
    }
    const confianca = Math.min(100, Math.round((pontuacao / totalChecagens) * 100));
    return {
        tipo: confianca >= 70 ? 'Clean Architecture (Arquitetura Limpa)' : 'Clean Architecture Parcial',
        confianca,
        caracteristicas,
        recomendacoes
    };
}
function detectarArquiteturaDistribuida(contexto, _estatisticas, _arquivoAtual) {
    const caracteristicas = [];
    const recomendacoes = [];
    let pontuacao = 0;
    const totalChecagens = 10;
    const caminhos = contexto.arquivos.map(a => a.relPath.toLowerCase());
    const conteudos = contexto.arquivos.map(a => a.content?.toLowerCase() || '');
    const temMultiplosServicos = caminhos.some(c => c.includes('/services/') || c.includes('/service-') || c.includes('/microservice'));
    const temServicosSeparados = new Set(caminhos.filter(c => c.includes('/services/'))
        .map(c => c.split('/services/')[1]?.split('/')[0])
        .filter(Boolean)).size > 1;
    if (temMultiplosServicos) {
        pontuacao++;
        caracteristicas.push('Múltiplos serviços/módulos detectados');
    }
    if (temServicosSeparados) {
        pontuacao++;
        caracteristicas.push(`${temServicosSeparados} boundaries de serviço identificados`);
    }
    const temMensageria = caminhos.some(c => c.includes('message-queue') || c.includes('event-bus') || c.includes('rabbitmq') ||
        c.includes('kafka') || c.includes('nats') || c.includes('sqs') || c.includes('pub-sub'));
    const temMensageriaDeps = conteudos.some(c => c.includes('kafkajs') || c.includes('amqplib') || c.includes('ioredis') ||
        c.includes('bull') || c.includes('bullmq') || c.includes('nats') || c.includes('grpc'));
    if (temMensageria || temMensageriaDeps) {
        pontuacao++;
        caracteristicas.push('Sistema de mensageria/eventos detectado');
    }
    const temGateway = caminhos.some(c => c.includes('/gateway') || c.includes('/api-gateway') || c.includes('gateway.ts') || c.includes('gateway.js'));
    if (temGateway) {
        pontuacao++;
        caracteristicas.push('API Gateway presente');
    }
    const temDiscovery = caminhos.some(c => c.includes('/discovery') || c.includes('service-discovery') || c.includes('consul') || c.includes('eureka'));
    if (temDiscovery) {
        pontuacao++;
        caracteristicas.push('Service Discovery detectado');
    }
    const temDocker = caminhos.some(c => c.endsWith('dockerfile') || c.includes('docker-compose'));
    const temK8s = caminhos.some(c => c.includes('kubernetes') || c.includes('k8s') || c.includes('.yaml') || c.includes('.yml'));
    if (temDocker) {
        pontuacao++;
        caracteristicas.push('Docker presente para conteinerização');
    }
    if (temK8s) {
        pontuacao++;
        caracteristicas.push('Kubernetes para orquestração');
    }
    const temEventos = caminhos.some(c => c.includes('/events/') || c.includes('/event-handlers') || c.includes('/handlers/'));
    const temAsyncPatterns = conteudos.filter(c => c.includes('eventemitter') || c.includes('observable') || c.includes('pubsub') ||
        c.includes('publish') || c.includes('subscribe') || c.includes('webhook')).length > 2;
    if (temEventos || temAsyncPatterns) {
        pontuacao++;
        caracteristicas.push('Padrões de comunicação assíncrona detectados');
    }
    const temShared = caminhos.some(c => c.includes('/shared/'));
    const temMonitoring = caminhos.some(c => c.includes('/monitoring') || c.includes('/health') || c.includes('/metrics'));
    if (temShared) {
        pontuacao += 0;
    }
    if (temMonitoring) {
        pontuacao++;
        caracteristicas.push('Monitoramento/health checks detectados');
    }
    if (!temMensageria && !temMensageriaDeps && temMultiplosServicos) {
        recomendacoes.push('Considere adicionar mensageria (Kafka, RabbitMQ) para comunicação assíncrona entre serviços');
    }
    if (!temGateway && temServicosSeparados) {
        recomendacoes.push('Implemente um API Gateway para rotear requisições aos serviços');
    }
    if (!temDocker && temMultiplosServicos) {
        recomendacoes.push('Adicione Docker para conteinerizar os serviços e facilitar deploy');
    }
    if (temMultiplosServicos && !temMonitoring) {
        recomendacoes.push('Implemente health checks e monitoramento centralizado');
    }
    const confianca = Math.min(100, Math.round((pontuacao / totalChecagens) * 100));
    return {
        tipo: confianca >= 60 ? 'Arquitetura Distribuída / Microsserviços' : 'Arquitetura Monolítica com Tendências Distribuídas',
        confianca,
        caracteristicas,
        recomendacoes
    };
}
//# sourceMappingURL=detector-architecture.js.map