Automação Fiscal Completa

import { ValidaNFeSDK } from 'validanfe-sdk';
import { ERPIntegrator } from './erp-integrator';
import { ContabilIntegrator } from './contabil-integrator';
import { ClassificadorIA } from './classificador-ia';

class ProcessadorFiscalAutomatizado {
  constructor() {
    this.validanfe = new ValidaNFeSDK({
      apiKey: process.env.VALIDANFE_API_KEY
    });
    
    this.erpIntegrator = new ERPIntegrator();
    this.contabilIntegrator = new ContabilIntegrator();
    this.classificador = new ClassificadorIA();
    
    this.filaProcessamento = [];
    this.processandoAtualmente = false;
  }

  async adicionarNFe(dadosNFe) {
    this.filaProcessamento.push({
      id: dadosNFe.id,
      chave: dadosNFe.chave,
      xml: dadosNFe.xml,
      origem: dadosNFe.origem,
      timestamp: new Date()
    });

    if (!this.processandoAtualmente) {
      await this.processarFila();
    }
  }

  async processarFila() {
    this.processandoAtualmente = true;

    while (this.filaProcessamento.length > 0) {
      const nfe = this.filaProcessamento.shift();
      
      try {
        await this.processarNFeCompleta(nfe);
      } catch (error) {
        console.error(`Erro ao processar NFe ${nfe.chave}:`, error);
        await this.tratarErroProcessamento(nfe, error);
      }
    }

    this.processandoAtualmente = false;
  }

  async processarNFeCompleta(nfe) {
    console.log(`Iniciando processamento automatizado da NFe ${nfe.chave}`);

    // Etapa 1: Validação na Receita Federal
    const dadosReceita = await this.validarNaReceita(nfe);
    
    // Etapa 2: Extração e enriquecimento de dados
    const dadosEnriquecidos = await this.extrairEEnriquecerDados(nfe, dadosReceita);
    
    // Etapa 3: Classificação automática
    const dadosClassificados = await this.classificarAutomaticamente(dadosEnriquecidos);
    
    // Etapa 4: Integração com ERP
    const entradaERP = await this.integrarComERP(dadosClassificados);
    
    // Etapa 5: Lançamentos contábeis
    const lancamentosContabeis = await this.gerarLancamentosContabeis(dadosClassificados);
    
    // Etapa 6: Atualizar obrigações acessórias
    await this.atualizarObrigacoesAcessorias(dadosClassificados);
    
    // Etapa 7: Notificar conclusão
    await this.notificarProcessamentoConcluido({
      nfe: nfe,
      resultado: {
        erp_entrada_id: entradaERP.id,
        lancamentos_contabeis: lancamentosContabeis,
        classificacao: dadosClassificados.classificacao
      }
    });

    console.log(`NFe ${nfe.chave} processada com sucesso`);
  }

  async validarNaReceita(nfe) {
    return await this.validanfe.nfe.consultar({
      chave: nfe.chave,
      tipo: 'completa'
    });
  }

  async extrairEEnriquecerDados(nfe, dadosReceita) {
    const parser = new XMLParser();
    const nfeObj = parser.parse(nfe.xml);
    
    // Extrair dados principais
    const dadosExtraidos = {
      chave: nfe.chave,
      numero: nfeObj.NFe.infNFe.ide.nNF,
      serie: nfeObj.NFe.infNFe.ide.serie,
      data_emissao: new Date(nfeObj.NFe.infNFe.ide.dhEmi),
      
      emitente: {
        cnpj: nfeObj.NFe.infNFe.emit.CNPJ,
        nome: nfeObj.NFe.infNFe.emit.xNome,
        endereco: this.extrairEndereco(nfeObj.NFe.infNFe.emit.enderEmit)
      },
      
      destinatario: {
        cnpj: nfeObj.NFe.infNFe.dest.CNPJ,
        nome: nfeObj.NFe.infNFe.dest.xNome,
        endereco: this.extrairEndereco(nfeObj.NFe.infNFe.dest.enderDest)
      },
      
      produtos: this.extrairProdutos(nfeObj.NFe.infNFe.det),
      impostos: this.calcularImpostos(nfeObj.NFe.infNFe),
      totais: this.extrairTotais(nfeObj.NFe.infNFe.total),
      
      dados_receita: dadosReceita
    };

    // Enriquecer com dados externos
    dadosExtraidos.emitente.dados_complementares = await this.buscarDadosCNPJ(
      dadosExtraidos.emitente.cnpj
    );
    
    return dadosExtraidos;
  }

  async classificarAutomaticamente(dados) {
    const classificacao = await this.classificador.classificar({
      emitente: dados.emitente,
      produtos: dados.produtos,
      valor_total: dados.totais.vNF,
      historico_fornecedor: await this.buscarHistoricoFornecedor(dados.emitente.cnpj)
    });

    return {
      ...dados,
      classificacao: {
        centro_custo: classificacao.centro_custo,
        conta_contabil: classificacao.conta_contabil,
        categoria_despesa: classificacao.categoria_despesa,
        projeto: classificacao.projeto,
        confianca: classificacao.confianca
      }
    };
  }
}

class ERPIntegrator {
  constructor() {
    this.apiERP = new ERPApiClient({
      baseURL: process.env.ERP_API_URL,
      apiKey: process.env.ERP_API_KEY
    });
  }

  async integrarComERP(dadosNFe) {
    // Verificar se fornecedor existe no ERP
    let fornecedor = await this.buscarFornecedor(dadosNFe.emitente.cnpj);
    
    if (!fornecedor) {
      fornecedor = await this.criarFornecedor(dadosNFe.emitente);
    }

    // Criar entrada de compra/despesa
    const entradaCompra = {
      tipo: 'entrada_nfe',
      numero_nfe: dadosNFe.numero,
      serie_nfe: dadosNFe.serie,
      chave_nfe: dadosNFe.chave,
      
      fornecedor_id: fornecedor.id,
      
      data_emissao: dadosNFe.data_emissao,
      data_entrada: new Date(),
      
      valor_total: dadosNFe.totais.vNF,
      valor_produtos: dadosNFe.totais.vProd,
      valor_impostos: dadosNFe.totais.vTotTrib,
      
      centro_custo: dadosNFe.classificacao.centro_custo,
      projeto: dadosNFe.classificacao.projeto,
      
      itens: await this.processarItensERP(dadosNFe.produtos, dadosNFe.classificacao),
      
      observacoes: `Processamento automático - NFe ${dadosNFe.chave}`
    };

    const entradaCriada = await this.apiERP.criarEntrada(entradaCompra);

    // Atualizar estoque se necessário
    if (dadosNFe.classificacao.categoria_despesa === 'material') {
      await this.atualizarEstoque(dadosNFe.produtos, entradaCriada.id);
    }

    return entradaCriada;
  }

  async processarItensERP(produtos, classificacao) {
    return await Promise.all(produtos.map(async (produto) => {
      // Buscar produto no ERP ou criar se não existir
      let produtoERP = await this.buscarProdutoPorCodigo(produto.cProd);
      
      if (!produtoERP) {
        produtoERP = await this.criarProdutoERP({
          codigo: produto.cProd,
          descricao: produto.xProd,
          ncm: produto.NCM,
          unidade: produto.uCom,
          preco_unitario: produto.vUnCom
        });
      }

      return {
        produto_id: produtoERP.id,
        quantidade: produto.qCom,
        valor_unitario: produto.vUnCom,
        valor_total: produto.vProd,
        centro_custo: classificacao.centro_custo,
        conta_contabil: classificacao.conta_contabil
      };
    }));
  }

  async criarFornecedor(dadosEmitente) {
    const fornecedor = {
      cnpj: dadosEmitente.cnpj,
      razao_social: dadosEmitente.nome,
      nome_fantasia: dadosEmitente.dados_complementares?.nome_fantasia,
      
      endereco: dadosEmitente.endereco,
      
      atividade_principal: dadosEmitente.dados_complementares?.atividade_principal,
      situacao_cadastral: dadosEmitente.dados_complementares?.situacao,
      
      categoria: 'fornecedor',
      status: 'ativo',
      
      dados_fiscais: {
        regime_tributario: this.identificarRegimeTributario(dadosEmitente),
        inscricao_estadual: dadosEmitente.IE,
        inscricao_municipal: dadosEmitente.IM
      }
    };

    return await this.apiERP.criarFornecedor(fornecedor);
  }
}

class ContabilIntegrator {
  constructor() {
    this.sistemaContabil = new SistemaContabilClient({
      url: process.env.CONTABIL_API_URL,
      credentials: {
        usuario: process.env.CONTABIL_USER,
        senha: process.env.CONTABIL_PASSWORD
      }
    });
  }

  async gerarLancamentosContabeis(dadosNFe) {
    const lancamentos = [];

    // Lançamento principal - débito da despesa/ativo
    lancamentos.push({
      tipo: 'debito',
      conta: dadosNFe.classificacao.conta_contabil,
      valor: dadosNFe.totais.vProd,
      centro_custo: dadosNFe.classificacao.centro_custo,
      historico: `Aquisição - NFe ${dadosNFe.numero}/${dadosNFe.serie} - ${dadosNFe.emitente.nome}`,
      documento: dadosNFe.chave
    });

    // Lançamentos de impostos
    if (dadosNFe.impostos.ICMS && dadosNFe.impostos.ICMS.vICMS > 0) {
      lancamentos.push({
        tipo: 'debito',
        conta: this.obterContaICMS(dadosNFe.impostos.ICMS),
        valor: dadosNFe.impostos.ICMS.vICMS,
        centro_custo: dadosNFe.classificacao.centro_custo,
        historico: `ICMS a Recuperar - NFe ${dadosNFe.numero}/${dadosNFe.serie}`,
        documento: dadosNFe.chave
      });
    }

    if (dadosNFe.impostos.IPI && dadosNFe.impostos.IPI.vIPI > 0) {
      lancamentos.push({
        tipo: 'debito',
        conta: this.obterContaIPI(),
        valor: dadosNFe.impostos.IPI.vIPI,
        centro_custo: dadosNFe.classificacao.centro_custo,
        historico: `IPI a Recuperar - NFe ${dadosNFe.numero}/${dadosNFe.serie}`,
        documento: dadosNFe.chave
      });
    }

    // Lançamento de crédito - fornecedor a pagar
    const valorTotal = dadosNFe.totais.vNF;
    lancamentos.push({
      tipo: 'credito',
      conta: this.obterContaFornecedor(dadosNFe.emitente),
      valor: valorTotal,
      centro_custo: dadosNFe.classificacao.centro_custo,
      historico: `A Pagar - NFe ${dadosNFe.numero}/${dadosNFe.serie} - ${dadosNFe.emitente.nome}`,
      documento: dadosNFe.chave,
      vencimento: await this.calcularVencimento(dadosNFe)
    });

    // Criar o lançamento contábil
    const lancamentoContabil = {
      data: dadosNFe.data_emissao,
      documento: dadosNFe.chave,
      tipo_documento: 'NFe',
      historico_geral: `Registro NFe ${dadosNFe.numero}/${dadosNFe.serie} - ${dadosNFe.emitente.nome}`,
      
      itens: lancamentos,
      
      dados_complementares: {
        nfe_chave: dadosNFe.chave,
        nfe_numero: dadosNFe.numero,
        nfe_serie: dadosNFe.serie,
        fornecedor_cnpj: dadosNFe.emitente.cnpj,
        fornecedor_nome: dadosNFe.emitente.nome,
        valor_total: valorTotal
      }
    };

    const resultado = await this.sistemaContabil.criarLancamento(lancamentoContabil);

    // Registrar para auditoria
    await this.registrarLancamentoParaAuditoria({
      nfe_chave: dadosNFe.chave,
      lancamento_id: resultado.id,
      sistema: 'automatico',
      usuario: 'sistema_fiscal',
      timestamp: new Date()
    });

    return resultado;
  }

  obterContaICMS(icmsData) {
    // Lógica para determinar conta ICMS baseada no CST
    const cst = icmsData.CST || icmsData.CSOSN;
    
    const mapeamentoContas = {
      '000': '1.1.3.01.001', // ICMS a Recuperar - Compras
      '010': '1.1.3.01.001', // ICMS a Recuperar - Compras
      '020': '1.1.3.01.002', // ICMS a Recuperar - Redução
      '101': '1.1.3.01.003', // ICMS a Recuperar - Simples
      // ... outros CSTs
    };

    return mapeamentoContas[cst] || '1.1.3.01.999'; // Conta genérica
  }

  async calcularVencimento(dadosNFe) {
    // Buscar dados de prazo do fornecedor
    const fornecedor = await this.buscarDadosFornecedor(dadosNFe.emitente.cnpj);
    const prazoDefault = fornecedor?.prazo_pagamento || 30;
    
    const vencimento = new Date(dadosNFe.data_emissao);
    vencimento.setDate(vencimento.getDate() + prazoDefault);
    
    return vencimento;
  }
}

class ClassificadorIA {
  constructor() {
    this.modeloClassificacao = new TensorFlowModel({
      modelPath: './models/classificador_fiscal.json'
    });
    
    this.regrasManuais = new Map();
    this.historicoClassificacoes = new Map();
  }

  async classificar(dadosNFe) {
    // Verificar regras manuais primeiro
    const classificacaoManual = this.verificarRegrasManuais(dadosNFe);
    if (classificacaoManual) {
      return { ...classificacaoManual, confianca: 1.0, origem: 'regra_manual' };
    }

    // Usar histórico de classificações similares
    const classificacaoHistorico = await this.buscarClassificacaoSimilar(dadosNFe);
    if (classificacaoHistorico && classificacaoHistorico.confianca > 0.9) {
      return { ...classificacaoHistorico, origem: 'historico' };
    }

    // Usar modelo de IA
    const features = this.extrairFeatures(dadosNFe);
    const predicao = await this.modeloClassificacao.predict(features);
    
    const classificacao = {
      centro_custo: predicao.centro_custo,
      conta_contabil: predicao.conta_contabil,
      categoria_despesa: predicao.categoria_despesa,
      projeto: predicao.projeto,
      confianca: predicao.confianca,
      origem: 'ia'
    };

    // Salvar no histórico para aprendizado
    await this.salvarClassificacao(dadosNFe, classificacao);

    return classificacao;
  }

  extrairFeatures(dadosNFe) {
    const features = {
      // Features do emitente
      cnpj_emitente: this.encodeCNPJ(dadosNFe.emitente.cnpj),
      atividade_emitente: this.encodeAtividade(dadosNFe.emitente.dados_complementares?.atividade_principal),
      
      // Features dos produtos
      ncm_principal: this.encodeNCM(this.obterNCMPrincipal(dadosNFe.produtos)),
      descricao_produtos: this.encodeDescricao(dadosNFe.produtos.map(p => p.xProd).join(' ')),
      
      // Features financeiras
      valor_total: dadosNFe.totais.vNF,
      valor_medio_item: dadosNFe.totais.vNF / dadosNFe.produtos.length,
      quantidade_itens: dadosNFe.produtos.length,
      
      // Features temporais
      mes_compra: dadosNFe.data_emissao.getMonth(),
      dia_semana: dadosNFe.data_emissao.getDay(),
      
      // Features de histórico
      frequencia_fornecedor: await this.calcularFrequenciaFornecedor(dadosNFe.emitente.cnpj),
      valor_medio_fornecedor: await this.calcularValorMedioFornecedor(dadosNFe.emitente.cnpj)
    };

    return this.normalizarFeatures(features);
  }

  async treinarModelo() {
    console.log('Iniciando treinamento do modelo de classificação...');

    // Buscar dados históricos de classificações aprovadas
    const dadosTreinamento = await this.buscarDadosTreinamento();
    
    const features = dadosTreinamento.map(d => this.extrairFeatures(d.dados_nfe));
    const labels = dadosTreinamento.map(d => ({
      centro_custo: d.classificacao.centro_custo,
      conta_contabil: d.classificacao.conta_contabil,
      categoria_despesa: d.classificacao.categoria_despesa
    }));

    await this.modeloClassificacao.train(features, labels, {
      epochs: 100,
      batchSize: 32,
      validationSplit: 0.2
    });

    console.log('Treinamento concluído');
  }
}

// API para dashboard de automação fiscal
app.get('/api/dashboard/automacao', async (req, res) => {
  const stats = await Promise.all([
    calcularEstatisticasProcessamento(),
    obterIndicadoresPerformance(),
    verificarStatusIntegracoes(),
    analisarTendenciasClassificacao()
  ]);

  res.json({
    processamento: stats[0],
    performance: stats[1],
    integracoes: stats[2],
    tendencias: stats[3],
    ultima_atualizacao: new Date()
  });
});

async function calcularEstatisticasProcessamento() {
  const hoje = new Date();
  const inicioMes = new Date(hoje.getFullYear(), hoje.getMonth(), 1);

  return {
    nfes_processadas_mes: await database.nfes.countDocuments({
      processado_em: { $gte: inicioMes },
      status: 'processada'
    }),
    
    tempo_medio_processamento: await database.nfes.aggregate([
      { $match: { processado_em: { $gte: inicioMes } } },
      {
        $group: {
          _id: null,
          tempo_medio: {
            $avg: {
              $subtract: ['$processado_em', '$recebido_em']
            }
          }
        }
      }
    ]),
    
    taxa_automatizacao: await calcularTaxaAutomatizacao(inicioMes),
    
    economia_tempo: await calcularEconomiaTempo(inicioMes)
  };
}