import { ExitCode, sair } from '../helpers/index.js';
import { messages } from '../../core/messages/index.js';
import { buscarPacotesInstalados, info as remoteInfo, instalarPacote, listarPacotesInstalados, obterInfoPacote, removerPacote, resolverMelhorVersao, search as remoteSearch } from '../../shared/marketplace/index.js';
import { Command } from 'commander';
const log = messages.log;
const msgs = messages.CliComandoMarketplaceMensagens;
export function comandoMarketplace() {
    const marketplace = new Command('marketplace')
        .description(msgs.descricao);
    marketplace.command('search <termo>')
        .description(msgs.searchDescricao)
        .option('--json', msgs.jsonDescricao)
        .option('--registry <url>', msgs.registryDescricao)
        .action(async (termo, opts) => {
        try {
            log.info(msgs.buscando(termo));
            const { total, resultados } = await remoteSearch(termo);
            if (opts.json) {
                console.log(JSON.stringify({ total, resultados }, null, 2));
                return;
            }
            if (total === 0) {
                log.info(msgs.nenhumResultado);
                return;
            }
            log.info(msgs.tituloBusca);
            for (const r of resultados) {
                const desc = r.descricao || '(sem descrição)';
                const tags = r.tags || [];
                log.info(msgs.itemBusca(r.nome, desc, tags));
            }
            log.info(msgs.totalResultados(total));
        }
        catch (err) {
            log.erro(msgs.erroBuscar(err instanceof Error ? err.message : String(err)));
            sair(ExitCode.Failure);
        }
    });
    marketplace.command('install <nome>')
        .description(msgs.installDescricao)
        .option('--version <version>', msgs.versionDescricao)
        .option('--registry <url>', msgs.registryDescricao)
        .action(async (nome, opts) => {
        try {
            const instalado = await obterInfoPacote(nome);
            if (instalado) {
                log.info(msgs.jaInstalado(nome, instalado.versao));
                return;
            }
            const analista = await remoteInfo(nome);
            if (!analista) {
                log.erro(msgs.analistaNaoEncontrado(nome));
                sair(ExitCode.Failure);
                return;
            }
            const versaoReq = opts.version || 'latest';
            const melhorVersao = resolverMelhorVersao(analista.versoes, versaoReq);
            if (!melhorVersao) {
                log.erro(`Versão "${versaoReq}" não disponível para "${nome}".`);
                sair(ExitCode.Failure);
                return;
            }
            log.info(msgs.instalando(nome, melhorVersao.version));
            await instalarPacote(analista, melhorVersao.version, '');
            log.sucesso(msgs.instaladoComSucesso(nome, melhorVersao.version));
        }
        catch (err) {
            log.erro(msgs.erroInstalar(err instanceof Error ? err.message : String(err)));
            sair(ExitCode.Failure);
        }
    });
    marketplace.command('remove <nome>')
        .description(msgs.removeDescricao)
        .action(async (nome) => {
        try {
            log.info(msgs.removendo(nome));
            const ok = await removerPacote(nome);
            if (ok)
                log.sucesso(msgs.removidoComSucesso(nome));
        }
        catch (err) {
            log.erro(msgs.erroRemover(err instanceof Error ? err.message : String(err)));
            sair(ExitCode.Failure);
        }
    });
    marketplace.command('list')
        .description(msgs.listDescricao)
        .option('--json', msgs.jsonDescricao)
        .option('--filter <termo>', 'Filtra por termo')
        .action(async (opts) => {
        try {
            const pacotes = opts.filter
                ? await buscarPacotesInstalados(opts.filter)
                : await listarPacotesInstalados();
            if (opts.json) {
                console.log(JSON.stringify(pacotes, null, 2));
                return;
            }
            if (pacotes.length === 0) {
                log.info(msgs.semAnalistas);
                log.info(msgs.dicaBusca);
                return;
            }
            log.info(msgs.tituloLista);
            for (const p of pacotes) {
                const nome = p?.nome || '(sem nome)';
                const versao = p?.versao || '(sem versão)';
                const descricao = p?.descricao || '(sem descrição)';
                log.info(msgs.itemLista(nome, versao, descricao));
            }
            log.info(msgs.totalResultados(pacotes.length));
        }
        catch (err) {
            log.erro(msgs.erroListar(err instanceof Error ? err.message : String(err)));
            sair(ExitCode.Failure);
        }
    });
    marketplace.command('info <nome>')
        .description(msgs.infoDescricao)
        .option('--json', msgs.jsonDescricao)
        .action(async (nome, opts) => {
        try {
            const analista = await remoteInfo(nome);
            const local = await obterInfoPacote(nome);
            if (!analista && !local) {
                log.erro(msgs.analistaNaoEncontrado(nome));
                sair(ExitCode.Failure);
                return;
            }
            if (opts.json) {
                console.log(JSON.stringify({ remoto: analista, local }, null, 2));
                return;
            }
            if (local) {
                log.info(msgs.infoTitulo(nome));
                log.info(`  Versão instalada: ${local.versao}`);
                log.info(`  Descrição: ${local.descricao}`);
                log.info(`  Autor: ${local.autor}`);
                log.info(`  Licença: ${local.licenca}`);
                log.info(`  Categoria: ${local.categoria}`);
                log.info(`  Instalado em: ${new Date(local.dataInstalacao).toLocaleString()}`);
                if (local.tags.length > 0)
                    log.info(msgs.infoTags(local.tags));
                return;
            }
            if (analista) {
                const versoes = analista.versoes.map((v) => v.version).join(', ');
                const tags = analista.tags || [];
                log.info(msgs.infoTitulo(nome));
                log.info(`  Descrição: ${analista.descricao}`);
                log.info(`  Categoria: ${analista.categoria}`);
                log.info(msgs.infoVersoes(versoes));
                if (tags.length > 0)
                    log.info(msgs.infoTags(tags));
                log.info(`  ${msgs.infoDicaInstalar}`);
            }
        }
        catch (err) {
            log.erro(msgs.erroObterInformacoes(err instanceof Error ? err.message : String(err)));
            sair(ExitCode.Failure);
        }
    });
    marketplace.command('publish <caminho>')
        .description(msgs.publishDescricao)
        .action(async (caminho) => {
        try {
            log.info(`Validando analista em "${caminho}"...`);
            const stats = await import('node:fs').then(fs => fs.promises.stat(caminho));
            if (!stats.isFile()) {
                log.erro('O caminho deve ser um arquivo de definição de analista.');
                sair(ExitCode.Failure);
                return;
            }
            log.sucesso('Arquivo de analista validado.');
            log.info('');
            log.info('Para publicar no marketplace comunitário:');
            log.info('  1. Crie um fork do repositório tutanus-marketplace');
            log.info('  2. Adicione seu analista ao diretório "analistas/"');
            log.info('  3. Envie um Pull Request');
            log.info('');
            log.info('Documentação: https://github.com/mocoto-strike/tutanus/wiki/Marketplace');
        }
        catch (err) {
            log.erro(msgs.erroPublicar(err instanceof Error ? err.message : String(err)));
            sair(ExitCode.Failure);
        }
    });
    return marketplace;
}
//# sourceMappingURL=command-marketplace.js.map