import fs from 'node:fs';
import path from 'node:path';
import { getMessages } from '../../../core/messages/index.js';
export function gerarRelatorioJson(dados, options = {}) {
    const opts = {
        escapeAscii: options.escapeAscii ?? true,
        includeDetails: options.includeDetails ?? true,
        includeContext: options.includeContext ?? false,
        compact: options.compact ?? false,
        maxOcorrencias: options.maxOcorrencias
    };
    let ocorrencias = dados.ocorrencias || [];
    if (opts.maxOcorrencias && ocorrencias.length > opts.maxOcorrencias) {
        ocorrencias = ocorrencias.slice(0, opts.maxOcorrencias);
    }
    const relatorio = {
        metadata: dados.metadata || {
            timestamp: new Date().toISOString(),
            schemaVersion: '1.0.0',
            modo: 'full',
            flags: [],
            tutanusVersion: (() => {
                try {
                    const pkg = JSON.parse(fs.readFileSync(path.join(process.cwd(), 'package.json'), 'utf-8'));
                    return pkg.version || 'unknown';
                }
                catch {
                    return 'unknown';
                }
            })(),
            projectNome: (() => {
                try {
                    const pkg = JSON.parse(fs.readFileSync(path.join(process.cwd(), 'package.json'), 'utf-8'));
                    return pkg.name || 'unknown';
                }
                catch {
                    return 'unknown';
                }
            })()
        },
        stats: dados.stats || {
            arquivosAnalisados: 0,
            arquivosComProblemas: 0,
            totalOcorrencias: 0,
            porNivel: {
                erro: 0,
                aviso: 0,
                info: 0
            },
            porCategoria: {}
        },
        ocorrencias: opts.includeDetails ? ocorrencias : [],
        ...(dados.guardian && {
            guardian: dados.guardian
        }),
        ...(dados.arquetipos && {
            arquetipos: dados.arquetipos
        }),
        ...(dados.autoFix && {
            autoFix: dados.autoFix
        }),
        ...(dados.linguagens && {
            linguagens: dados.linguagens
        }),
        ...(dados.sugestoes && {
            sugestoes: dados.sugestoes
        })
    };
    const indent = opts.compact ? 0 : 2;
    let json = JSON.stringify(relatorio, null, indent);
    if (opts.escapeAscii) {
        json = escapeNonAscii(json);
    }
    json = traduzirRelatorioJson(json);
    return json;
}
function escapeNonAscii(str) {
    let resultado = '';
    let indice = 0;
    while (indice < str.length) {
        const code = str.charCodeAt(indice);
        if (code < 128) {
            resultado += str[indice];
            indice++;
            continue;
        }
        if (code >= 0xd800 && code <= 0xdbff) {
            if (indice + 1 < str.length) {
                const nextCodigo = str.charCodeAt(indice + 1);
                if (nextCodigo >= 0xdc00 && nextCodigo <= 0xdfff) {
                    resultado += `\\u${code.toString(16).padStart(4, '0')}`;
                    resultado += `\\u${nextCodigo.toString(16).padStart(4, '0')}`;
                    indice += 2;
                    continue;
                }
            }
        }
        resultado += `\\u${code.toString(16).padStart(4, '0')}`;
        indice++;
    }
    return resultado;
}
export function traduzirRelatorioJson(json) {
    try {
        const { CAMPO_ROTULOS } = getMessages();
        if (!CAMPO_ROTULOS || Object.keys(CAMPO_ROTULOS).length === 0)
            return json;
        const obj = JSON.parse(json);
        const traduzido = traduzirObjeto(obj, CAMPO_ROTULOS);
        return JSON.stringify(traduzido, null, 2);
    }
    catch {
        return json;
    }
}
function traduzirObjeto(obj, rotulos) {
    if (Array.isArray(obj)) {
        return obj.map(item => traduzirObjeto(item, rotulos));
    }
    if (obj !== null && typeof obj === 'object') {
        const result = {};
        for (const [key, value] of Object.entries(obj)) {
            const novaChave = rotulos[key] ?? key;
            result[novaChave] = traduzirObjeto(value, rotulos);
        }
        return result;
    }
    return obj;
}
export function validarJson(json) {
    try {
        JSON.parse(json);
        return {
            valido: true
        };
    }
    catch (erro) {
        const mensagem = erro instanceof Error ? erro.message : String(erro);
        return {
            valido: false,
            erro: mensagem
        };
    }
}
export function criarMetadata(modo, flags, filtros) {
    return {
        timestamp: new Date().toISOString(),
        schemaVersion: '1.0.0',
        modo,
        flags,
        ...(filtros && {
            filtros
        })
    };
}
export function criarStats(ocorrencias) {
    const porNivel = {
        erro: 0,
        aviso: 0,
        info: 0
    };
    const porCategoria = {};
    const porRegra = {};
    const arquivosSet = new Set();
    for (const ocorrencia of ocorrencias) {
        const nivel = ocorrencia.nivel || 'info';
        if (nivel === 'erro' || nivel === 'aviso' || nivel === 'info') {
            porNivel[nivel] = porNivel[nivel] + 1;
        }
        const tipo = ocorrencia.tipo || 'outros';
        porCategoria[tipo] = (porCategoria[tipo] || 0) + 1;
        porRegra[tipo] = (porRegra[tipo] || 0) + 1;
        if (ocorrencia.relPath) {
            arquivosSet.add(ocorrencia.relPath);
        }
    }
    const arquivosComProblemas = arquivosSet.size;
    return {
        arquivosAnalisados: arquivosSet.size,
        arquivosComProblemas,
        totalOcorrencias: ocorrencias.length,
        porNivel,
        porCategoria,
        byRule: porRegra
    };
}
export function criarLinguagens(extensoes) {
    const total = Object.values(extensoes).reduce((sum, count) => sum + count, 0);
    return {
        total,
        extensoes
    };
}
//# sourceMappingURL=json-exporter.js.map