import { normalizeText } from '../views/conciliacao/utils/ofxParser';

/**
 * Engine de Conciliação Otimizada
 * Implementa a lógica de indexação, propagação de regras e conciliação inteligente.
 */
export const runReconciliationLogic = async (parametro) => {
  console.time("⏱️ Tempo Total de Conciliação");
  
  const { 
    bankTransactions = [], 
    rules = [], 
    updateTransactionRule 
  } = parametro;

  try {
    // 1. Criação de Mapas (Indexação) para busca O(1)
    const regrasMap = new Map();
    const regrasLista = [];
    
    rules.forEach(r => {
      // Indexa por ID para propagação rápida
      if (r.id) regrasMap.set(String(r.id), r);
      
      // Prepara lista para busca por string (condicional)
      if (r.condition) {
        regrasLista.push({
          ...r,
          condNorm: normalizeText(r.condition).trim()
        });
      }
    });

    // Prioriza condicionais mais longas/específicas para evitar que regras curtas "roubem" o match
    regrasLista.sort((a, b) => b.condNorm.length - a.condNorm.length);

    let updates = [];

    console.groupCollapsed("📈 Processamento de Transações");

    for (const transacao of bankTransactions) {
      if (!transacao.raw) continue;
      
      const idExtrato = transacao.id;
      const descricaoNorm = normalizeText(transacao.description || "");

      // --- LÓGICA 1: PROPAGAÇÃO DE REGRAS (Transações já vinculadas) ---
      // Verifica se a transação tem uma regra vinculada que precisa ser atualizada
      if (transacao.externalRuleId && transacao.externalRuleId !== "0" && transacao.externalRuleId !== "2106") {
        const regraVinculada = regrasMap.get(String(transacao.externalRuleId));
        
        if (regraVinculada) {
          // Verifica se os dados da transação batem com a regra atual
          const precisaAtualizar =
            String(regraVinculada.categoryId) !== String(transacao.externalCategoryId) ||
            String(regraVinculada.beneficiario) !== String(transacao.raw.beneficiario_pagador) ||
            String(regraVinculada.caixinha) !== String(transacao.raw.caixinha);

          if (precisaAtualizar) {
            updates.push(prepararUpdate(idExtrato, regraVinculada));
          }
        } else {
          // REGRA DELETADA: Limpa os dados se o ID da regra não existe mais no sistema
          const regraReset = {
            id: "0",
            categoryId: "0",
            beneficiario: "0",
            caixinha: "0"
          };
          updates.push(prepararUpdate(idExtrato, regraReset));
        }
        // Independente se a regra existia ou foi limpa, interrompe o ciclo para esta transação
        continue;
      }

      // --- LÓGICA 2: CONCILIAÇÃO POR REGRAS EXISTENTES (Transações sem regra) ---
      // Se não tem regra vinculada, procura uma regra que bata com a descrição
      let regraEncontrada = null;
      for (const regra of regrasLista) {
        if (descricaoNorm.includes(regra.condNorm)) {
          regraEncontrada = regra;
          break; // Encontrou a regra mais específica (devido ao sort)
        }
      }

      if (regraEncontrada) {
        // Verifica se já está conciliado corretamente com essa regra
        // Nota: Comparando com categoryId da transação, se já estiver setado
        const jaConciliadoComEstaRegra =
          String(regraEncontrada.categoryId) === String(transacao.externalCategoryId) &&
          String(regraEncontrada.beneficiario) === String(transacao.raw.beneficiario_pagador);

        if (!jaConciliadoComEstaRegra) {
          updates.push(prepararUpdate(idExtrato, regraEncontrada));
        }
        continue;
      }

      // --- LÓGICA 3: CONCILIAÇÃO INTELIGENTE DE EMPRESAS (Scoring) ---
      // Implementação futura se necessário (requer dados de empresas)
    }

    console.groupEnd();

    // 4. Execução de Updates
    if (updates.length > 0) {
      console.log(`🚀 Executando ${updates.length} atualizações automáticas...`);
      // Executa updates em paralelo (simulando batching)
      await Promise.all(updates.map(up => updateTransactionRule(up.idextrato, up)));
      return { success: true, count: updates.length };
    }

    return { success: true, count: 0 };
  } catch (error) {
    console.error("Erro na engine de conciliação:", error);
    throw error;
  } finally {
    console.timeEnd("⏱️ Tempo Total de Conciliação");
  }
};

/**
 * Prepara o objeto de atualização padronizado
 */
function prepararUpdate(idExtrato, regra) {
  return {
    idextrato: idExtrato,
    regra: regra.id || 0,
    categoria: regra.categoryId,
    beneficiario_pagador: regra.beneficiario,
    caixinha: regra.caixinha,
    Result: true
  };
}
