/*
 * This file is part of Treeunfe DFe.
 * 
 * Treeunfe DFe is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * Treeunfe DFe is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with Treeunfe DFe. If not, see <https://www.gnu.org/licenses/>.
 */
import { NFEGerarDanfe } from '@treeunfe/danfe';
import {
  Environment,
  GerarConsulta,
  applyDefaultTmpStoragePaths,
  logger,
  SaveFiles,
  Utility,
  XmlBuilder,
} from '@treeunfe/shared';
import {
  Cancelamento,
  CartaDeCorrecao,
  CienciaDaOperacao,
  ConfirmacaoDaOperacao,
  ConsultaCadastroNFe,
  ConsultaNFe,
  ConsGTIN,
  DesconhecimentoDaOperacao,
  DFePorChaveNFe,
  DFePorNSU,
  DFePorUltimoNSU,
  EPEC,
  EventoNFe,
  InutilizacaoData,
  NFeConfig,
  NFEGerarDanfeProps,
  NFe as NFeType,
  OperacaoNaoRealizada,
} from '@treeunfe/types';
import type { AxiosInstance } from 'axios';
import {
  NFEAutorizacao,
  NFECancelamento,
  NFECartaDeCorrecao,
  NFECienciaDaOperacao,
  NFEConfirmacaoDaOperacao,
  NFEConsultaGTIN,
  NFEConsultaProtocolo,
  NfeConsultaCadastro,
  NFEDesconhecimentoDaOperacao,
  NFEDistribuicaoDFe,
  NFEDistribuicaoDFePorChave,
  NFEDistribuicaoDFePorNSU,
  NFEDistribuicaoDFePorUltNSU,
  NFEEpec,
  NFEInutilizacao,
  NFEOperacaoNaoRealizada,
  NFERecepcaoEvento,
  NFEStatusServico,
} from '../operations';
import {
  NFEAutorizacaoService,
  NFECancelamentoService,
  NFECartaDeCorrecaoService,
  NFECienciaDaOperacaoService,
  NFEConfirmacaoDaOperacaoService,
  NFEconsultaProtocoloService,
  NFEConsultaGTINService,
  NfeConsultaCadastroService,
  NFEDesconhecimentoDaOperacaoService,
  NFEDistribuicaoDFePorChaveService,
  NFEDistribuicaoDFePorNSUService,
  NFEDistribuicaoDFePorUltNSUService,
  NFEDistribuicaoDFeService,
  NFEEpecService,
  NFEInutilizacaoService,
  NFEOperacaoNaoRealizadaService,
  NFERecepcaoEventoService,
  NFEStatusServicoService,
} from '../services';

export default class NFe {
  private environment: Environment;
  private axios!: AxiosInstance;
  private utility!: Utility;
  private xmlBuilder!: XmlBuilder;
  private saveFiles!: SaveFiles;
  private gerarConsulta!: GerarConsulta;
  private loadEnvironmentPromise: Promise<void>;

  constructor(config: NFeConfig) {
    // Valida se a configuração obrigatória foi fornecida
    if (!config.ambiente || !config.versaoDF) {
      throw new Error('Configuração NFe incompleta. Por favor, forneça "ambiente" e "versaoDF".');
    }

    const environment = new Environment(applyDefaultTmpStoragePaths(config, 'NFe'));
    this.environment = environment;

    // Carrega o environment automaticamente
    this.loadEnvironmentPromise = (async () => {
      try {
        const { axios: axiosInstance } = await environment.loadEnvironment();
        this.axios = axiosInstance;
        this.utility = new Utility(environment);
        this.saveFiles = new SaveFiles(environment, this.utility);
        this.xmlBuilder = new XmlBuilder(environment);
        this.gerarConsulta = new GerarConsulta(environment, this.utility, this.xmlBuilder);
      } catch (error) {
        logger.error(``, error, { context: 'NFe_LoadEnvironment' });
        throw new Error(`Erro ao inicializar a lib: ${error}`);
      }
    })();
  }

  /**
   * Status Serviço
   */
  async ConsultaStatusServico() {
    await this.loadEnvironmentPromise;
    try {
      const service = new NFEStatusServicoService(this.environment, this.utility, this.xmlBuilder, this.axios, this.saveFiles, this.gerarConsulta);
      const operation = new NFEStatusServico(service);
      const response = await operation.Exec();
      console.log('Retorno NFE_ConsultaStatusServico');
      console.log(`   ${response.xMotivo}`);
      console.log('===================================');
      return response;
    } catch (error: any) {
      logger.error(``, error, { context: 'NFE_ConsultaStatusServico' });
      throw new Error(`NFE_ConsultaStatusServico: ${error.message}`);
    }
  }

  /**
   * Consulta Protocolo
   */
  async ConsultaProtocolo(chave: string) {
    await this.loadEnvironmentPromise;
    try {
      const service = new NFEconsultaProtocoloService(this.environment, this.utility, this.xmlBuilder, this.axios, this.saveFiles, this.gerarConsulta);
      const operation = new NFEConsultaProtocolo(service);
      const response = await operation.Exec(chave);
      console.log('Retorno NFE_ConsultaProtocolo');
      console.log(`   ${response.xMotivo}`);
      console.log('===================================');
      return response;
    } catch (error: any) {
      logger.error(``, error, { context: 'NFE_ConsultaProtocolo' });
      throw new Error(`NFE_ConsultaProtocolo: ${error.message}`);
    }
  }

  /**
   * Consulta GTIN
   */
  async ConsultaGTIN(data: ConsGTIN) {
    await this.loadEnvironmentPromise;
    try {
      const service = new NFEConsultaGTINService(this.environment, this.utility, this.xmlBuilder, this.axios, this.saveFiles, this.gerarConsulta);
      const operation = new NFEConsultaGTIN(service);
      const response = await operation.Exec(data.GTIN);
      console.log('Retorno NFE_ConsultaGTIN');
      console.log(`   ${response.xMotivo}`);
      console.log('===================================');
      return response;
    } catch (error: any) {
      logger.error(``, error, { context: 'NFE_ConsultaGTIN' });
      throw new Error(`NFE_ConsultaGTIN: ${error.message}`);
    }
  }

  /**
   * Consulta cadastro de contribuinte (consCad 2.00 / CadConsultaCadastro).
   * A UF do pedido deve ser a mesma da configuração (`UF`), pois define o endpoint SEFAZ.
   */
  async ConsultaCadastro(data: ConsultaCadastroNFe) {
    await this.loadEnvironmentPromise;
    try {
      const service = new NfeConsultaCadastroService(this.environment, this.utility, this.xmlBuilder, this.axios, this.saveFiles, this.gerarConsulta);
      const operation = new NfeConsultaCadastro(service);
      const response = await operation.Exec(data);
      console.log('Retorno NFE_ConsultaCadastro');
      const cStat = response?.cStat ?? response?.infCons?.cStat;
      const msg = response?.xMotivo ?? response?.infCons?.xMotivo;
      console.log(`   cStat=${cStat ?? '?'} — ${msg ?? '(sem xMotivo)'}`);
      console.log('===================================');
      return response;
    } catch (error: any) {
      logger.error(``, error, { context: 'NFE_ConsultaCadastro' });
      throw new Error(`NFE_ConsultaCadastro: ${error.message}`);
    }
  }

  /**
   * Recepção de Eventos
   */
  async RecepcaoEvento(evento: EventoNFe) {
    await this.loadEnvironmentPromise;
    try {
      const service = new NFERecepcaoEventoService(this.environment, this.utility, this.xmlBuilder, this.axios, this.saveFiles, this.gerarConsulta);
      const operation = new NFERecepcaoEvento(service);
      const response = await operation.Exec(evento);
      console.log('Retorno NFE_RecepcaoEvento');
      console.table(response.xMotivos);
      console.log('===================================');
      return response.response;
    } catch (error: any) {
      logger.error(``, error, { context: 'NFE_RecepcaoEvento' });
      throw new Error(`NFE_RecepcaoEvento: ${error.message}`);
    }
  }

  async EventoPrevioDeEmissaoEmContingencia(evento: EPEC) {
    await this.loadEnvironmentPromise;
    try {
      const service = new NFEEpecService(this.environment, this.utility, this.xmlBuilder, this.axios, this.saveFiles, this.gerarConsulta);
      const operation = new NFEEpec(service);
      const response = await operation.Exec(evento);
      console.log('Retorno NFEEpec');
      console.table(response.xMotivos);
      console.log('===================================');
      return response.response;
    } catch (error: any) {
      logger.error(``, error, { context: 'NFE_EventoPrevioDeEmissaoEmContingencia' });
      throw new Error(`NFEEpec: ${error.message}`);
    }
  }

  async Cancelamento(evento: Cancelamento) {
    await this.loadEnvironmentPromise;
    try {
      const service = new NFECancelamentoService(this.environment, this.utility, this.xmlBuilder, this.axios, this.saveFiles, this.gerarConsulta);
      const operation = new NFECancelamento(service);
      const response = await operation.Exec(evento);
      console.log('Retorno NFE_Cancelamento');
      console.table(response.xMotivos);
      console.log('===================================');
      return response.response;
    } catch (error: any) {
      logger.error(``, error, { context: 'NFE_Cancelamento' });
      throw new Error(`NFE_Cancelamento: ${error.message}`);
    }
  }

  async CienciaDaOperacao(evento: CienciaDaOperacao) {
    await this.loadEnvironmentPromise;
    try {
      const service = new NFECienciaDaOperacaoService(this.environment, this.utility, this.xmlBuilder, this.axios, this.saveFiles, this.gerarConsulta);
      const operation = new NFECienciaDaOperacao(service);
      const response = await operation.Exec(evento);
      console.log('Retorno NFE_CienciaDaOperacao');
      console.table(response.xMotivos);
      console.log('===================================');
      return response.response;
    } catch (error: any) {
      logger.error(``, error, { context: 'NFE_CienciaDaOperacao' });
      throw new Error(`NFE_CienciaDaOperacao: ${error.message}`);
    }
  }

  async ConfirmacaoDaOperacao(evento: ConfirmacaoDaOperacao) {
    await this.loadEnvironmentPromise;
    try {
      const service = new NFEConfirmacaoDaOperacaoService(this.environment, this.utility, this.xmlBuilder, this.axios, this.saveFiles, this.gerarConsulta);
      const operation = new NFEConfirmacaoDaOperacao(service);
      const response = await operation.Exec(evento);
      console.log('Retorno NFE_ConfirmacaoDaOperacao');
      console.table(response.xMotivos);
      console.log('===================================');
      return response.response;
    } catch (error: any) {
      logger.error(``, error, { context: 'NFE_ConfirmacaoDaOperacao' });
      throw new Error(`NFE_ConfirmacaoDaOperacao: ${error.message}`);
    }
  }

  async OperacaoNaoRealizada(evento: OperacaoNaoRealizada) {
    await this.loadEnvironmentPromise;
    try {
      const service = new NFEOperacaoNaoRealizadaService(this.environment, this.utility, this.xmlBuilder, this.axios, this.saveFiles, this.gerarConsulta);
      const operation = new NFEOperacaoNaoRealizada(service);
      const response = await operation.Exec(evento);
      console.log('Retorno NFE_OperacaoNaoRealizada');
      console.table(response.xMotivos);
      console.log('===================================');
      return response.response;
    } catch (error: any) {
      logger.error(``, error, { context: 'NFE_OperacaoNaoRealizada' });
      throw new Error(`NFE_OperacaoNaoRealizada: ${error.message}`);
    }
  }

  async CartaDeCorrecao(evento: CartaDeCorrecao) {
    await this.loadEnvironmentPromise;
    try {
      const service = new NFECartaDeCorrecaoService(this.environment, this.utility, this.xmlBuilder, this.axios, this.saveFiles, this.gerarConsulta);
      const operation = new NFECartaDeCorrecao(service);
      const response = await operation.Exec(evento);
      console.log('Retorno NFE_CartaDeCorrecao');
      console.table(response.xMotivos);
      console.log('===================================');
      return response.response;
    } catch (error: any) {
      logger.error(``, error, { context: 'NFE_CartaDeCorrecao' });
      throw new Error(`NFE_CartaDeCorrecao: ${error.message}`);
    }
  }

  async DesconhecimentoDaOperacao(evento: DesconhecimentoDaOperacao) {
    await this.loadEnvironmentPromise;
    try {
      const service = new NFEDesconhecimentoDaOperacaoService(this.environment, this.utility, this.xmlBuilder, this.axios, this.saveFiles, this.gerarConsulta);
      const operation = new NFEDesconhecimentoDaOperacao(service);
      const response = await operation.Exec(evento);
      console.log('Retorno NFE_DesconhecimentoDaOperacao');
      console.table(response.xMotivos);
      console.log('===================================');
      return response.response;
    } catch (error: any) {
      logger.error(``, error, { context: 'NFE_DesconhecimentoDaOperacao' });
      throw new Error(`NFE_DesconhecimentoDaOperacao: ${error.message}`);
    }
  }

  /**
   * Distribuição DFe
   */
  async DistribuicaoDFe(data: ConsultaNFe) {
    await this.loadEnvironmentPromise;
    try {
      const service = new NFEDistribuicaoDFeService(this.environment, this.utility, this.xmlBuilder, this.axios, this.saveFiles, this.gerarConsulta);
      const operation = new NFEDistribuicaoDFe(service);
      const response = await operation.Exec(data);
      console.log('Retorno NFE_DistribuicaoDFe');
      console.log(`   ${response.xMotivo}`);
      console.log('===================================');
      return response.data;
    } catch (error: any) {
      logger.error(``, error, { context: 'NFE_DistribuicaoDFe' });
      throw new Error(`NFE_DistribuicaoDFe: ${error.message}`);
    }
  }

  async DistribuicaoDFePorUltNSU(data: DFePorUltimoNSU) {
    await this.loadEnvironmentPromise;
    try {
      const service = new NFEDistribuicaoDFePorUltNSUService(this.environment, this.utility, this.xmlBuilder, this.axios, this.saveFiles, this.gerarConsulta);
      const operation = new NFEDistribuicaoDFePorUltNSU(service);
      const response = await operation.Exec(data);
      console.log('Retorno NFE_DistribuicaoDFePorUltNSU');
      console.log(`   ${response.xMotivo}`);
      console.log('===================================');
      return response.data;
    } catch (error: any) {
      logger.error(``, error, { context: 'NFE_DistribuicaoDFePorUltNSU' });
      throw new Error(`NFE_DistribuicaoDFePorUltNSU: ${error.message}`);
    }
  }

  async DistribuicaoDFePorNSU(data: DFePorNSU) {
    await this.loadEnvironmentPromise;
    try {
      const service = new NFEDistribuicaoDFePorNSUService(this.environment, this.utility, this.xmlBuilder, this.axios, this.saveFiles, this.gerarConsulta);
      const operation = new NFEDistribuicaoDFePorNSU(service);
      const response = await operation.Exec(data);
      console.log('Retorno NFE_DistribuicaoDFePorNSU');
      console.log(`   ${response.xMotivo}`);
      console.log('===================================');
      return response.data;
    } catch (error: any) {
      logger.error(``, error, { context: 'NFE_DistribuicaoDFePorNSU' });
      throw new Error(`NFE_DistribuicaoDFePorNSU: ${error.message}`);
    }
  }

  async DistribuicaoDFePorChave(data: DFePorChaveNFe) {
    await this.loadEnvironmentPromise;
    try {
      const service = new NFEDistribuicaoDFePorChaveService(this.environment, this.utility, this.xmlBuilder, this.axios, this.saveFiles, this.gerarConsulta);
      const operation = new NFEDistribuicaoDFePorChave(service);
      const response = await operation.Exec(data);
      console.log('Retorno NFE_DistribuicaoDFePorChave');
      console.log(`   ${response.xMotivo}`);
      console.log('===================================');
      return response.data;
    } catch (error: any) {
      logger.error(``, error, { context: 'NFE_DistribuicaoDFePorChave' });
      throw new Error(`NFE_DistribuicaoDFePorChave: ${error.message}`);
    }
  }

  /**
   * Autorização
   */
  async Autorizacao(data: NFeType) {
    await this.loadEnvironmentPromise;
    try {
      const service = new NFEAutorizacaoService(this.environment, this.utility, this.xmlBuilder, this.axios, this.saveFiles, this.gerarConsulta);
      const operation = new NFEAutorizacao(service);
      const response = await operation.Exec(data);
      console.log('Retorno NFE_Autorizacao');
      console.table(response.xMotivo);
      console.log('===================================');
      return response.xmls;
    } catch (error: any) {
      logger.error(``, error, { context: 'NFE_Autorizacao' });
      throw new Error(`NFE_Autorizacao: ${error.message}`);
    }
  }

  /**
   * Inutilização
   */
  async Inutilizacao(data: InutilizacaoData) {
    await this.loadEnvironmentPromise;
    try {
      const service = new NFEInutilizacaoService(this.environment, this.utility, this.xmlBuilder, this.axios, this.saveFiles, this.gerarConsulta);
      const operation = new NFEInutilizacao(service);
      const response = await operation.Exec(data);
      console.log('Retorno NFE_Inutilizacao');
      console.log(`   ${response.xMotivo}`);
      console.log('===================================');
      return response;
    } catch (error: any) {
      logger.error(``, error, { context: 'NFE_Inutilizacao' });
      throw new Error(`NFE_Inutilizacao: ${error.message}`);
    }
  }

  /**
   * DANFE
   */
  async GerarDanfe(data: NFEGerarDanfeProps) {
    await this.loadEnvironmentPromise;
    try {
      const { exibirMarcaDaguaDanfe } = this.environment.getConfig();
      const danfe = new NFEGerarDanfe(data);
      const response = await danfe.generatePDF(exibirMarcaDaguaDanfe);
      console.log('Retorno NFE_GerarDanfe');
      console.log(response.message);
      console.log('===================================');
      return response;
    } catch (error: any) {
      logger.error(``, error, { context: 'NFE_GerarDanfe' });
      throw new Error(`NFE_GerarDanfe: ${error.message}`);
    }
  }
}