import { config } from '../config/index.js';
import { lerEstado, salvarEstado } from '../../shared/persistence/index.js';
import XXH from 'xxhashjs';
export class AnalysisCache {
    cache = {};
    loaded = false;
    loadingPromise = null;
    async load() {
        if (this.loaded)
            return;
        if (this.loadingPromise)
            return this.loadingPromise;
        this.loadingPromise = this.doLoad();
        return this.loadingPromise;
    }
    async doLoad() {
        try {
            const data = await lerEstado(config.ANALISE_CACHE_STATE_PATH, {
                versao: config.ANALISE_CACHE_VERSION,
                entradas: {}
            });
            if (data.versao === config.ANALISE_CACHE_VERSION) {
                this.cache = data.entradas;
            }
        }
        catch {
        }
        finally {
            this.loaded = true;
            this.loadingPromise = null;
        }
    }
    async get(relPath, conteudo) {
        if (!config.ANALISE_CACHE_ENABLED)
            return null;
        await this.load();
        const hash = this.hashConteudo(conteudo);
        const entry = this.cache[relPath];
        if (!entry)
            return null;
        if (entry.hash !== hash)
            return null;
        if (config.ANALISE_CACHE_TTL_MS > 0) {
            const idade = Date.now() - entry.timestamp;
            if (idade > config.ANALISE_CACHE_TTL_MS) {
                delete this.cache[relPath];
                return null;
            }
        }
        return entry.ocorrencias;
    }
    async set(relPath, conteudo, ocorrencias) {
        if (!config.ANALISE_CACHE_ENABLED)
            return;
        await this.load();
        this.cache[relPath] = {
            hash: this.hashConteudo(conteudo),
            ocorrencias,
            timestamp: Date.now(),
            count: ocorrencias.length
        };
    }
    async invalidate(relPath) {
        await this.load();
        delete this.cache[relPath];
    }
    async clear() {
        this.cache = {};
        await this.persistir();
    }
    async persistir() {
        if (!config.ANALISE_CACHE_ENABLED)
            return;
        await this.limparExpirados();
        const data = {
            versao: config.ANALISE_CACHE_VERSION,
            entradas: this.cache
        };
        await salvarEstado(config.ANALISE_CACHE_STATE_PATH, data);
    }
    estatisticas() {
        const entradas = Object.keys(this.cache);
        const totalOcorrencias = entradas.reduce((acc, key) => acc + (this.cache[key]?.count ?? 0), 0);
        return {
            totalEntradas: entradas.length,
            totalOcorrencias,
            expiradas: 0
        };
    }
    hashConteudo(conteudo) {
        return XXH.h64(conteudo, 0xabcd).toString(16);
    }
    async limparExpirados() {
        if (config.ANALISE_CACHE_TTL_MS <= 0)
            return;
        const agora = Date.now();
        for (const [key, entry] of Object.entries(this.cache)) {
            if (agora - entry.timestamp > config.ANALISE_CACHE_TTL_MS) {
                delete this.cache[key];
            }
        }
    }
}
export const analysisCache = new AnalysisCache();
//# sourceMappingURL=analysis-cache.js.map