import api from '@/services/api';
import { handleRequest } from '@/services/serviceUtils';

/**
 * Serviço para gestão de operações CNAB
 */
const cnabService = {
  /**
   * Busca lista de favorecidos PIX
   */
  async getFavorecidos() {
    return handleRequest({
      apiFn: async () => {
        const { data } = await api.get('/cnab/listagem');
        return data;
      }
    });
  },

  /**
   * Busca lista de favorecidos TED
   */
  async getFavorecidosTed() {
    return handleRequest({
      apiFn: async () => {
        const { data } = await api.get('/cnab/listagem/ted');
        return data;
      }
    });
  },

  /**
   * Cria um novo favorecido PIX
   * @param {Object} payload - Dados do favorecido
   */
  async createFavorecido(payload) {
    console.log('📤 [cnabService] createFavorecido (PIX) chamado');
    console.log('   - Payload:', payload);
    return handleRequest({
      apiFn: async () => {
        const { data } = await api.post('/cnab/listagem/include', payload);
        console.log('✅ [cnabService] createFavorecido (PIX) sucesso:', data);
        return data;
      }
    });
  },

  /**
   * Cria um novo favorecido TED
   * @param {Object} payload - Dados do favorecido
   */
  async createFavorecidoTed(payload) {
    console.log('📤 [cnabService] createFavorecidoTed (TED) chamado');
    console.log('   - Payload:', payload);
    return handleRequest({
      apiFn: async () => {
        const { data } = await api.post('/cnab/listagem/include/ted', payload);
        console.log('✅ [cnabService] createFavorecidoTed (TED) sucesso:', data);
        return data;
      }
    });
  },

  /**
   * Atualiza um favorecido PIX existente
   * @param {Object} payload - Dados do favorecido (deve incluir idcnab_pralog)
   */
  async updateFavorecido(payload) {
    return handleRequest({
      apiFn: async () => {
        const { data } = await api.put('/cnab/listagem/edit', payload);
        return data;
      }
    });
  },

  /**
   * Atualiza um favorecido TED existente
   * @param {Object} payload - Dados do favorecido (deve incluir idfavorecido)
   */
  async updateFavorecidoTed(payload) {
    return handleRequest({
      apiFn: async () => {
        const { data } = await api.put('/cnab/listagem/edit/ted', payload);
        return data;
      }
    });
  },

  /**
   * Atualiza status de um favorecido PIX (inativação)
   * @param {number|string} idcnab_pralog - ID do favorecido
   * @param {Object} payload - Objeto com idcnab_pralog, usuario, acao, descricao, data_envio
   */
  async updateFavorecidoStatus(idcnab_pralog, payload) {
    console.log('📤 [cnabService] updateFavorecidoStatus (PIX) chamado');
    console.log('   - ID:', idcnab_pralog);
    console.log('   - Payload:', payload);
    
    return handleRequest({
      apiFn: async () => {
        // Garante que o idcnab_pralog está no payload
        const fullPayload = {
          ...payload,
          idcnab_pralog: idcnab_pralog
        };
        
        const { data } = await api.put('/favorecido/status', fullPayload);
        console.log('✅ [cnabService] updateFavorecidoStatus (PIX) sucesso:', data);
        return data;
      }
    });
  },

  /**
   * Atualiza status de um favorecido TED (inativação)
   * @param {number|string} idcnab_pralog - ID do favorecido
   * @param {Object} payload - Objeto com idcnab_pralog, usuario, acao, descricao, data_envio
   */
  async updateFavorecidoStatusTed(idcnab_pralog, payload) {
    console.log('📤 [cnabService] updateFavorecidoStatusTed (TED) chamado');
    console.log('   - ID:', idcnab_pralog);
    console.log('   - Payload:', payload);
    
    return handleRequest({
      apiFn: async () => {
        // Garante que o idcnab_pralog está no payload
        const fullPayload = {
          ...payload,
          idcnab_pralog: idcnab_pralog
        };
        
        const { data } = await api.put('/favorecido/status/ted', fullPayload);
        console.log('✅ [cnabService] updateFavorecidoStatusTed (TED) sucesso:', data);
        return data;
      }
    });
  },

  /**
   * Exporta lista de favorecidos
   */
  async exportFavorecidos(metadata) {
    return handleRequest({
      apiFn: async () => {
        const { data } = await api.post('/cnab/listagem/export', metadata, {
          responseType: 'blob'
        });
        return data;
      }
    });
  },

  /**
   * Busca histórico de pagamentos PIX
   */
  async getHistoricoPagamentos() {
    return handleRequest({
      apiFn: async () => {
        const { data } = await api.get('/cnab/historico_pagamentos');
        return data;
      }
    });
  },

  /**
   * Busca histórico de pagamentos TED
   */
  async getHistoricoPagamentosTed() {
    return handleRequest({
      apiFn: async () => {
        const { data } = await api.get('/cnab/historico_pagamentos/ted');
        return data;
      }
    });
  },

  /**
   * Busca dados consolidados para o dashboard
   */
  async getDashboardData(isTed = false) {
    try {
      const stats = await api.get(isTed ? '/dashboards/total/ted' : '/dashboards/total');
      const remessas = await api.get(isTed ? '/dashboards/remessas/mes/ted' : '/dashboards/remessas/mes');
      const recent = await api.get('/remessas');

      return {
        stats: stats.data || [],
        chartData: remessas.data || [],
        pieData: [
          { name: 'TED', value: 400 },
          { name: 'PIX', value: 700 },
          { name: 'BOLETO', value: 300 },
        ],
        recentRemessas: recent.data?.Base_Dados_API?.arquivos?.map(id => ({
          id: id.split('.')[0],
          fullId: id,
          qtd: '-',
          valor: '-',
          data: '-',
          status: 'Concluído'
        })) || []
      };
    } catch (error) {
      console.warn('Backend endpoints not fully available, falling back to mock dashboard data', error);
      return new Promise((resolve) => {
        setTimeout(() => {
          resolve({
            stats: [
              { title: 'Total Favorecidos', value: '3.983', detail: 'Beneficiários cadastrados', trend: 12 },
              { title: 'Valor Total', value: 'R$ 12.654.033,77', detail: 'Movimentação global', trend: 8.4 },
              { title: 'Qtd. Remessas', value: '26', detail: 'Arquivos gerados', trend: 2.5 },
            ],
            chartData: [
              { name: 'Jan', valor: 4500000 }, { name: 'Fev', valor: 3000000 },
              { name: 'Mar', valor: 5000000 }, { name: 'Abr', valor: 2780000 },
              { name: 'Mai', valor: 1890000 }, { name: 'Jun', valor: 2390000 },
            ],
            pieData: [
              { name: 'TED', value: 400 }, { name: 'PIX', value: 700 }, { name: 'BOLETO', value: 300 },
            ],
            recentRemessas: [
              { id: '0000289', qtd: 20, valor: 'R$ 46.640,06', data: '18/01/2026', status: 'Concluído' },
              { id: '0000871', qtd: 55, valor: 'R$ 124.564,30', data: '16/01/2026', status: 'Concluído' },
              { id: '0000178', qtd: 259, valor: 'R$ 684.668,70', data: '15/01/2026', status: 'Concluído' },
              { id: '0000515', qtd: 259, valor: 'R$ 684.668,70', data: '15/01/2026', status: 'Concluído' },
              { id: '0000563', qtd: 177, valor: 'R$ 566.552,33', data: '14/01/2026', status: 'Concluído' },
            ]
          });
        }, 600);
      });
    }
  },

  /**
   * Busca detalhes de uma remessa específica
   */
  async getDetalhamentoRemessa(remessaId) {
    return handleRequest({
      apiFn: async () => {
        const { data } = await api.post('/cnab/detalhamento/remessa', {
          remessa: remessaId
        });
        return data;
      }
    });
  },

  /**
   * Busca a lista de arquivos de remessa
   */
  async getRemessaFileList(isTed = false) {
    return handleRequest({
      apiFn: async () => {
        const endpoint = isTed ? '/remessas/ted' : '/remessas';
        const { data } = await api.get(endpoint);
        return data?.Base_Dados_API?.arquivos || [];
      }
    });
  },

  /**
   * Busca o conteúdo de um arquivo de remessa específico
   */
  async getRemessaFileContent(filename, isTed = false) {
    return handleRequest({
      apiFn: async () => {
        const endpoint = isTed ? `/remessas/ted/${filename}` : `/remessas/${filename}`;
        const { data } = await api.get(endpoint, {
          responseType: 'text'
        });
        return data;
      }
    });
  },

  /**
   * Busca lista de arquivos de remessa disponíveis
   * Primeira etapa do processo de exportação
   * @param {string} bank - Banco selecionado ('INTER' ou 'BRADESCO')
   * @param {string} paymentType - Tipo de pagamento ('PIX' ou 'TED')
   * @returns {Promise<{arquivos: string[], quantidade_arquivos: number}>}
   */
  async getRemessaFilesList(bank = 'INTER', paymentType = 'PIX') {
    console.log('📋 [cnabService] getRemessaFilesList chamado');
    console.log('   - Banco:', bank);
    console.log('   - Tipo de pagamento:', paymentType);

    return handleRequest({
      apiFn: async () => {
        // Normaliza o nome do banco para minúsculas (inter ou bradesco)
        const bankLower = bank.toLowerCase();
        const endpoint = `/remessas/${bankLower}`;
        
        console.log('🌐 [cnabService] Fazendo GET para:', endpoint);
        
        const { data } = await api.get(endpoint);
        
        console.log('✅ [cnabService] Lista de arquivos recebida');
        
        // A resposta vem no formato:
        // {
        //   conteudo: {
        //     pix: { arquivos: [...], quantidade_arquivos: X },
        //     ted: { arquivos: [...], quantidade_arquivos: Y }
        //   }
        // }
        const paymentTypeLower = paymentType.toLowerCase();
        const filesData = data?.conteudo?.[paymentTypeLower] || {
          arquivos: [],
          quantidade_arquivos: 0
        };
        
        console.log(`   - Arquivos ${paymentType} encontrados:`, filesData.quantidade_arquivos);
        
        return filesData;
      }
    });
  },

  /**
   * Exporta arquivo de remessa específico usando o nome do arquivo
   * Segunda etapa do processo de exportação
   * @param {string} bank - Banco selecionado ('INTER' ou 'BRADESCO')
   * @param {string} paymentType - Tipo de pagamento ('PIX' ou 'TED')
   * @param {string} filename - Nome completo do arquivo (ex: 'CI240_001_0000744.REM')
   * @returns {Promise<Blob>} Arquivo blob para download
   */
  async exportRemessaFile(bank = 'INTER', paymentType = 'PIX', filename) {
    if (!filename) {
      throw new Error('Nome do arquivo é obrigatório para exportação');
    }

    console.log('📥 [cnabService] exportRemessaFile chamado');
    console.log('   - Banco:', bank);
    console.log('   - Tipo de pagamento:', paymentType);
    console.log('   - Nome do arquivo:', filename);

    return handleRequest({
      apiFn: async () => {
        // Normaliza o nome do banco para minúsculas
        const bankLower = bank.toLowerCase();
        const paymentTypeLower = paymentType.toLowerCase();
        
        // Monta a rota: /remessas/{banco}/{tipo}/{nome_arquivo}
        const endpoint = `/remessas/${bankLower}/${paymentTypeLower}/${encodeURIComponent(filename)}`;
        
        console.log('🌐 [cnabService] Fazendo GET para:', endpoint);
        
        const { data } = await api.get(endpoint, {
          responseType: 'blob'
        });
        
        console.log('✅ [cnabService] Arquivo recebido:', data?.size, 'bytes');
        
        return data;
      }
    });
  },

  /**
   * Exporta remessa PIX (método legado - mantido para compatibilidade)
   * @deprecated Use exportRemessaFile com o fluxo de duas etapas
   */
  async exportRemessaPix(nRemessa) {
    return handleRequest({
      apiFn: async () => {
        const { data } = await api.get(`/remessas/${nRemessa}`, {
          responseType: 'blob'
        });
        return data;
      }
    });
  },

  /**
   * Exporta remessa TED (método legado - mantido para compatibilidade)
   * @deprecated Use exportRemessaFile com o fluxo de duas etapas
   */
  async exportRemessaTed(nRemessa) {
    return handleRequest({
      apiFn: async () => {
        const { data } = await api.get(`/remessas/ted/${nRemessa}`, {
          responseType: 'blob'
        });
        return data;
      }
    });
  },

  /**
   * Busca pagamentos por documento
   * Usa GET com query parameter conforme a lógica legada
   */
  async getPagamentosPorDocumento(cpfCnpj) {
    return handleRequest({
      apiFn: async () => {
        // Usa GET conforme a lógica legada
        const { data } = await api.get(`/cnab/relatorio/pagamentos?cpf_cnpj=${encodeURIComponent(cpfCnpj)}`);
        // A resposta pode vir em diferentes formatos, normalizar para o formato esperado
        // Se vier com Base_Dados_API.dados, retornar como está
        // Se vier com Base_Dados_API como array, retornar como { Base_Dados_API: { dados: ... } }
        if (data?.Base_Dados_API) {
          // Se Base_Dados_API já é um objeto com 'dados', retornar como está
          if (data.Base_Dados_API.dados !== undefined) {
            return data;
          }
          // Se Base_Dados_API é um array, transformar para o formato esperado
          if (Array.isArray(data.Base_Dados_API)) {
            return {
              Base_Dados_API: {
                dados: data.Base_Dados_API
              }
            };
          }
        }
        return data;
      }
    });
  },

  /**
   * Métodos do Dashboard
   */
  async getDashboardTotal(params = {}, isTed = false) {
    return handleRequest({
      apiFn: async () => {
        const endpoint = isTed ? '/dashboards/total/ted' : '/dashboards/total';
        const { data } = await api.get(endpoint, { params });
        return data;
      }
    });
  },

  async getDashboardRemessasMes(isTed = false) {
    return handleRequest({
      apiFn: async () => {
        const endpoint = isTed ? '/dashboards/remessas/mes/ted' : '/dashboards/remessas/mes';
        const { data } = await api.get(endpoint);
        return data;
      }
    });
  },

  async getDashboardRemessasPorData(isTed = false) {
    return handleRequest({
      apiFn: async () => {
        const endpoint = isTed ? '/dashboards/remessas/por_data/ted' : '/dashboards/remessas/por_data';
        const { data } = await api.get(endpoint);
        return data;
      }
    });
  },

  async getRelatoriosLogs(isTed = false) {
    return handleRequest({
      apiFn: async () => {
        const endpoint = isTed ? '/cnab240/relatorios/ted' : '/cnab240/relatorios';
        const { data } = await api.get(endpoint);
        return data;
      }
    });
  },

  async exportRelatorioDashboard(isTed = false) {
    return handleRequest({
      apiFn: async () => {
        const endpoint = isTed ? '/relatorios/export/ted' : '/relatorios/export';
        const { data } = await api.get(endpoint, {
          responseType: 'blob'
        });
        return data;
      }
    });
  },

  /**
   * Faz upload e parse de arquivo Excel para geração de remessa
   * Segue o fluxo do código legado: primeiro GET para obter schema, depois POST com arquivo
   * @param {File} file - Arquivo Excel (.xlsx ou .xls)
   * @param {string} paymentType - Tipo de pagamento ('PIX' ou 'TED')
   * @returns {Promise<{html: string, headers: string[], rows: any[]}>}
   */
  async uploadAndParseExcel(file, paymentType = 'PIX') {
    console.log('📤 [CNAB Service] uploadAndParseExcel chamado');
    console.log('   - Arquivo:', file.name, file.size, 'bytes');
    console.log('   - Tipo:', paymentType);

    return handleRequest({
      apiFn: async () => {
        const formData = new FormData();
        formData.append('file', file);

        // Define a rota baseada no tipo de pagamento
        const endpoint = paymentType === 'PIX'
          ? '/planilha/cnab'
          : '/planilha/cnab/ted';

        console.log('🌐 [CNAB Service] Fazendo POST para:', endpoint);

        // Primeiro faz GET para obter o schema (se necessário)
        // Depois faz POST com o arquivo
        const { data } = await api.post(endpoint, formData, {
          headers: {
            'Content-Type': 'multipart/form-data'
          },
          responseType: 'text' // A resposta vem como HTML
        });

        console.log('✅ [CNAB Service] Resposta recebida:', data?.substring(0, 200), '...');
        console.log('   - Tamanho da resposta:', data?.length, 'caracteres');

        // Retorna o HTML da tabela para renderização
        return {
          html: data,
          Base_Dados_API: {
            Relatorio: data
          }
        };
      }
    });
  },

  /**
   * Valida o mapeamento de colunas
   * @param {Object} columnMapping - Mapeamento de colunas (ex: { NOME_FAVORECIDO: 'Nome', ... })
   * @param {Array} tableData - Dados da tabela em formato JSON
   * @param {string} paymentType - Tipo de pagamento ('PIX' ou 'TED')
   * @returns {Promise<string>} HTML da tabela validada
   */
  async validateColumns(columnMapping, tableData, paymentType = 'PIX') {
    console.log('🔍 [CNAB Service] validateColumns chamado');
    console.log('   - Mapeamento:', columnMapping);
    console.log('   - Total de linhas:', tableData.length);
    console.log('   - Tipo:', paymentType);

    return handleRequest({
      apiFn: async () => {
        const endpoint = paymentType === 'PIX'
          ? '/planilha/cnab/validar'
          : '/planilha/cnab/validar/ted';

        console.log('🌐 [CNAB Service] Fazendo POST para:', endpoint);
        console.log('   - Payload (primeiras 2 linhas):', {
          Colunas: columnMapping,
          Tabela: tableData.slice(0, 2)
        });

        // Primeiro tenta obter resposta como JSON (pode conter dados tratados)
        try {
          const jsonResponse = await api.post(endpoint, {
            Colunas: columnMapping,
            Tabela: tableData
          });

          // Verifica se a resposta contém dados tratados em JSON
          if (jsonResponse.data && typeof jsonResponse.data === 'object') {
            // Se retornar objeto JSON com Tabela tratada, usa esses dados
            if (jsonResponse.data.Tabela && Array.isArray(jsonResponse.data.Tabela)) {
              console.log('✅ [CNAB Service] Dados tratados recebidos do backend (JSON)');
              console.log('   - Total de linhas tratadas:', jsonResponse.data.Tabela.length);
              console.log('   - Primeira linha tratada:', jsonResponse.data.Tabela[0]);
              
              // Retorna objeto com dados tratados e HTML (se disponível)
              return {
                treatedData: jsonResponse.data.Tabela,
                columns: jsonResponse.data.Colunas || columnMapping,
                html: jsonResponse.data.html || jsonResponse.data.HTML || null,
                rawResponse: jsonResponse.data
              };
            }
            
            // Se retornar HTML como string dentro do objeto
            if (jsonResponse.data.html || jsonResponse.data.HTML) {
              const html = jsonResponse.data.html || jsonResponse.data.HTML;
              console.log('✅ [CNAB Service] HTML recebido dentro de objeto JSON');
              return html;
            }
          }
        } catch (jsonError) {
          console.log('⚠️ [CNAB Service] Resposta não é JSON válido, tentando como texto (HTML)...');
        }

        // Fallback: tenta obter como HTML (texto)
        const { data } = await api.post(endpoint, {
          Colunas: columnMapping,
          Tabela: tableData
        }, {
          responseType: 'text' // Retorna HTML
        });

        console.log('✅ [CNAB Service] HTML validado recebido:', data?.substring(0, 200), '...');
        console.log('   - Tamanho:', data?.length, 'caracteres');

        return data;
      }
    });
  },

  /**
   * Valida os dados em formato JSON antes de gerar o Excel
   * @param {Array} jsonData - Array de objetos com os dados validados
   * @param {string} paymentType - Tipo de pagamento ('PIX' ou 'TED')
   * @returns {Promise<{success: boolean, html?: string}>}
   */
  async validateJson(jsonData, paymentType = 'PIX') {
    return handleRequest({
      apiFn: async () => {
        const endpoint = paymentType === 'PIX'
          ? '/planilha/cnab/validar_json'
          : '/planilha/cnab/validar_json/ted';

        try {
          const { data, status } = await api.post(endpoint, jsonData, {
            responseType: 'text'
          });

          console.log('📊 [CNAB Service] Status da resposta:', status);

          if (status !== 200) {
            console.warn('⚠️ [CNAB Service] Validação falhou, tentando parsear JSON de erros');
            // Tenta parsear como JSON primeiro
            try {
              const errorJson = typeof data === 'string' ? JSON.parse(data) : data;
              console.log('📋 [CNAB Service] Erros parseados:', errorJson);
              return {
                success: false,
                html: data, // Mantém o HTML original também
                errors: errorJson // Adiciona objeto parseado
              };
            } catch (e) {
              // Se não for JSON, retorna como HTML
              return {
                success: false,
                html: data
              };
            }
          }

          console.log('✅ [CNAB Service] Validação JSON bem-sucedida');
          return {
            success: true
          };
        } catch (error) {
          console.error('❌ [CNAB Service] Erro na validação JSON:', error);
          // Se retornar erro, tenta parsear o JSON de erros
          const errorData = error.response?.data || '';

          try {
            const errorJson = typeof errorData === 'string' ? JSON.parse(errorData) : errorData;
            console.log('📋 [CNAB Service] Erros parseados do catch:', errorJson);
            return {
              success: false,
              html: typeof errorData === 'string' ? errorData : JSON.stringify(errorData),
              errors: errorJson
            };
          } catch (e) {
            console.log('   - HTML de erro recebido (não é JSON):', errorData?.substring(0, 200));
            return {
              success: false,
              html: typeof errorData === 'string' ? errorData : JSON.stringify(errorData)
            };
          }
        }
      }
    });
  },

  /**
   * Gera arquivo Excel validado a partir dos dados JSON
   * @param {Array} jsonData - Array de objetos com os dados validados
   * @param {string} paymentType - Tipo de pagamento ('PIX' ou 'TED')
   * @returns {Promise<Blob>} Arquivo Excel
   */
  async generateExcel(jsonData, paymentType = 'PIX') {
    console.log('📊 [CNAB Service] generateExcel chamado');
    console.log('   - Total de linhas:', jsonData.length);
    console.log('   - Tipo:', paymentType);

    return handleRequest({
      apiFn: async () => {
        const endpoint = paymentType === 'PIX'
          ? '/planilha/cnab/gerar_excel'
          : '/planilha/cnab/ted/gerar_excel';

        console.log('🌐 [CNAB Service] Fazendo POST para:', endpoint);

        const { data } = await api.post(endpoint, {
          json_data: jsonData
        }, {
          responseType: 'blob'
        });

        console.log('✅ [CNAB Service] Excel gerado:', data?.size, 'bytes');
        console.log('   - Tipo:', data?.type);

        return data;
      }
    });
  },

  /**
   * Gera arquivo de remessa CNAB 240 (.REM)
   * @param {Blob} excelBlob - Arquivo Excel gerado anteriormente
   * @param {Object} metadata - Metadados do usuário e ação
   * @param {string} paymentType - Tipo de pagamento ('PIX' ou 'TED')
   * @param {string} bank - Banco selecionado ('INTER' ou 'BRADESCO')
   * @param {string} [remessaVariant='ted'] - Variante TED no Bradesco: 'ted' ou 'folha_pagamento' (rota /cnab/bradesco/folha_pagamento)
   * @returns {Promise<{blob: Blob, filename: string}>}
   */
  async generateRemessaFile(excelBlob, metadata, paymentType = 'PIX', bank = 'INTER', remessaVariant = 'ted') {
    console.log('📦 [CNAB Service] generateRemessaFile chamado');
    console.log('   - Excel blob:', excelBlob?.size, 'bytes');
    console.log('   - Metadados:', metadata);
    console.log('   - Tipo:', paymentType);
    console.log('   - Banco:', bank);
    console.log('   - Variante (Bradesco TED):', remessaVariant);

    return handleRequest({
      apiFn: async () => {
        const formData = new FormData();
        formData.append('file', excelBlob, 'relatorio.xlsx');
        formData.append('dados_json', JSON.stringify(metadata));

        // Define a rota baseada no banco e tipo de pagamento
        // INTER: /cnab/inter/pix ou /cnab/inter/ted
        // BRADESCO: /cnab/bradesco/pix, /cnab/bradesco/ted ou /cnab/bradesco/folha_pagamento
        let endpoint;

        if (bank === 'INTER') {
          endpoint = paymentType === 'PIX'
            ? '/cnab/inter/pix'
            : '/cnab/inter/ted';
          console.log('🏦 [CNAB Service] Usando rotas do INTER');
        } else if (bank === 'BRADESCO') {
          if (paymentType === 'PIX') {
            endpoint = '/cnab/bradesco/pix';
          } else if (remessaVariant === 'folha_pagamento') {
            endpoint = '/cnab/bradesco/folha_pagamento';
            console.log('🏦 [CNAB Service] Usando rota Folha de Pagamento (Bradesco)');
          } else if (remessaVariant === 'cobranca') {
            endpoint = '/cnab/bradesco/cobranca';
            console.log('🏦 [CNAB Service] Usando rota Cobrança (Bradesco)');
          } else {
            endpoint = '/cnab/bradesco/ted';
          }
          console.log('🏦 [CNAB Service] Usando rotas do BRADESCO');
        } else {
          // Fallback para Inter
          endpoint = paymentType === 'PIX'
            ? '/cnab/inter/pix'
            : '/cnab/inter/ted';
          console.warn('⚠️ [CNAB Service] Banco desconhecido, usando fallback INTER');
        }

        console.log('🌐 [CNAB Service] Endpoint final:', endpoint);
        console.log('   - Banco:', bank);
        console.log('   - Tipo de pagamento:', paymentType);

        const response = await api.post(endpoint, formData, {
          responseType: 'blob',
          headers: {
            'Content-Type': 'multipart/form-data'
          }
        });

        console.log('✅ [CNAB Service] Arquivo REM recebido:', response.data?.size, 'bytes');

        // Extrai o nome do arquivo do header Content-Disposition
        const contentDisposition = response.headers['content-disposition'];
        let filename = `CNAB_teste.REM`;

        if (contentDisposition && contentDisposition.includes('filename=')) {
          filename = contentDisposition
            .split('filename=')[1]
            .replace(/['"]/g, '')
            .trim();
        }

        console.log('📄 [CNAB Service] Nome do arquivo:', filename);

        return {
          blob: response.data,
          filename
        };
      }
    });
  },

  /**
   * Método auxiliar para download de arquivo
   * @param {Blob} blob - Arquivo blob
   * @param {string} filename - Nome do arquivo
   */
  downloadFile(blob, filename) {
    const url = URL.createObjectURL(blob);
    const a = document.createElement('a');
    a.href = url;
    a.download = filename;
    document.body.appendChild(a);
    a.click();
    document.body.removeChild(a);
    URL.revokeObjectURL(url);
  },

  /**
   * Navega por uma pasta no Nextcloud
   * @param {Object} params - Parâmetros de navegação
   * @param {string} params.caminho_pasta - Caminho da pasta a navegar
   * @param {string} params.usuario - Usuário do Nextcloud
   * @param {string} params.senha - Senha do Nextcloud
   * @param {string} params.base_url - URL base do Nextcloud
   * @returns {Promise<{sucesso: boolean, caminho_atual: string, pastas: Array, arquivos: Array, total_pastas: number, total_arquivos: number}>}
   */
  async navegarPasta({ caminho_pasta }) {
    console.log('📁 [cnabService] navegarPasta chamado');
    console.log('   - Caminho:', caminho_pasta);

    return handleRequest({
      apiFn: async () => {
        try {
          const response = await api.post('/navegar_pasta', {
            caminho_pasta
            // Removido: usuario, senha, base_url - não devem ser enviados
          }, {
            timeout: 180000 // 3 minutos para operações de navegação
          });
          
          console.log('✅ [cnabService] Resposta recebida:', response);
          console.log('   - Status:', response.status);
          console.log('   - Data:', response.data);
          
          const data = response.data || response;
          
          // Normaliza a resposta para garantir o formato esperado
          const normalizedResponse = {
            sucesso: data.sucesso !== false, // Assume sucesso se não for explicitamente false
            caminho_atual: data.caminho_atual || caminho_pasta,
            pastas: data.pastas || data.Base_Dados_API?.pastas || [],
            arquivos: data.arquivos || data.Base_Dados_API?.arquivos || [],
            total_pastas: data.total_pastas || (data.pastas?.length || 0),
            total_arquivos: data.total_arquivos || (data.arquivos?.length || 0),
            mensagem: data.mensagem || 'Navegação realizada com sucesso'
          };
          
          console.log('✅ [cnabService] Resposta normalizada:', normalizedResponse);
          console.log('   - Pastas encontradas:', normalizedResponse.total_pastas);
          console.log('   - Arquivos encontrados:', normalizedResponse.total_arquivos);
          
          return normalizedResponse;
        } catch (error) {
          console.error('❌ [cnabService] Erro na requisição:', error);
          console.error('   - Response:', error.response?.data);
          console.error('   - Status:', error.response?.status);
          throw error;
        }
      }
    });
  },

  /**
   * Exporta/processa arquivos de uma pasta no Nextcloud
   * @param {Object} params - Parâmetros de exportação
   * @param {string} params.caminho_pasta - Caminho da pasta contendo os arquivos
   * @param {string} params.usuario - Usuário do Nextcloud
   * @param {string} params.senha - Senha do Nextcloud
   * @param {string} params.base_url - URL base do Nextcloud
   * @returns {Promise<Blob>} Arquivo Excel gerado
   */
  async processarPdfsPasta({ caminho_pasta }) {
    console.log('📥 [cnabService] processarPdfsPasta chamado');
    console.log('   - Caminho:', caminho_pasta);

    return handleRequest({
      apiFn: async () => {
        const { data } = await api.post('/processar_pdfs_pasta', {
          caminho_pasta
          // Removido: usuario, senha, base_url - não devem ser enviados
        }, {
          responseType: 'blob',
          timeout: 300000 // 5 minutos para processamento de PDFs (aumentado devido à lentidão)
        });
        console.log('✅ [cnabService] Arquivo processado:', data?.size, 'bytes');
        return data;
      }
    });
  }
};

export default cnabService;
