import api from './api';
import { handleRequest, simulateLatency } from './serviceUtils';
import { MOCK_PENDING_TRANSACTIONS } from '../features/workspace/mockData';

// Força uso da API real para conciliação (ignora VITE_USE_MOCK)
const USE_REAL_API = true;

/**
 * Converte valor string do backend para número.
 * O backend envia valores no formato americano (ponto como decimal): "1350.00"
 * Esta função detecta o formato e converte corretamente.
 * 
 * @param {string|number} valorStr - Valor a ser convertido
 * @returns {number} - Valor numérico convertido
 */
function parseValorBackend(valorStr) {
  if (typeof valorStr === 'number') {
    return valorStr;
  }
  
  if (!valorStr || typeof valorStr !== 'string') {
    return 0;
  }
  
  const trimmed = valorStr.trim();
  if (!trimmed) {
    return 0;
  }
  
  // Se contém vírgula, assume formato brasileiro (1.350,00)
  if (trimmed.includes(',')) {
    // Remove pontos (separadores de milhares) e substitui vírgula por ponto
    return parseFloat(trimmed.replace(/\./g, '').replace(',', '.')) || 0;
  }
  
  // Se contém apenas ponto, assume formato americano (1350.00)
  // O backend envia neste formato, então fazemos parseFloat direto
  return parseFloat(trimmed) || 0;
}

/**
 * @typedef {Object} TransacaoPendente
 * @property {number} id
 * @property {string} data
 * @property {string} descricao
 * @property {number} valor
 * @property {string} tipo
 */

/**
 * @typedef {Object} Cruzamento
 * @property {number} id
 * @property {string} descricao
 * @property {number} valor
 * @property {string} data
 * @property {number} [caixinha]
 * @property {number} [mes]
 * @property {number} [ano]
 */

/**
 * @typedef {Object} CruzamentoDetalhe
 * @property {number} id
 * @property {string} descricao
 * @property {number} valor
 * @property {string} data
 * @property {Object} [detalhes]
 */

/**
 * Service de Conciliação para o ambiente Workspace
 * Gerencia comunicação com as rotas específicas de conciliação bancária
 */
export const workspaceConciliacaoService = {
  /**
   * Busca todas as transações do extrato
   * Rota: GET /extrato/apresentar
   * @returns {Promise<TransacaoExtrato[]>}
   */
  fetchExtrato: async (filters = {}) => {
    console.log('[workspaceConciliacaoService] fetchExtrato chamado com filtros:', filters);
    console.log('[workspaceConciliacaoService] USE_REAL_API:', USE_REAL_API);
    
    if (USE_REAL_API) {
      try {
        const params = new URLSearchParams();
        if (filters.mes) params.append('mes', filters.mes);
        if (filters.ano) params.append('ano', filters.ano);
        
        const queryString = params.toString();
        const url = `/extrato/apresentar${queryString ? `?${queryString}` : ''}`;
        
        console.log('[workspaceConciliacaoService] Chamando GET', url);
        const response = await api.get(url);
        console.log('[workspaceConciliacaoService] Resposta completa:', response);
        console.log('[workspaceConciliacaoService] response.data:', response.data);
        
        const raw = response?.data ?? response;
        // Trata Base_Dados_API (objeto de objetos ou array)
        let data = raw?.dados ?? raw?.Base_Dados_API ?? raw;
        if (!Array.isArray(data)) {
          data = Object.values(data || {});
        }
        console.log('[workspaceConciliacaoService] Dados normalizados:', data);
        console.log('[workspaceConciliacaoService] Quantidade de itens:', data.length);
        
        const mapped = data.map(item => ({
          id: item.idextrato || item.id || 0,
          idextrato: item.idextrato || item.id || 0,
          data: item.dataEntrada || item.data || '',
          dataEntrada: item.dataEntrada || item.data || '',
          descricao: item.descricao || item.titulo || '',
          valor: parseValorBackend(item.valor),
          tipo: item.tipoOperacao === 'D' ? 'DEBITO' : item.tipoOperacao === 'C' ? 'CREDITO' : 'DEBITO',
          tipoOperacao: item.tipoOperacao || 'D',
          tipoTransacao: item.tipoTransacao || '',
          titulo: item.titulo || '',
          caixaId: item.caixinha ? parseInt(item.caixinha) : null,
          caixinha: item.caixinha || null,
          categoriaId: item.categoria && item.categoria !== '0' && item.categoria !== 0 ? parseInt(item.categoria) : null,
          categoria: item.categoria || null,
          regraId: item.regra && item.regra !== '0' && item.regra !== 0 ? parseInt(item.regra) : null,
          regra: item.regra || null,
          beneficiario: item.beneficiario_pagador || null,
          beneficiario_pagador: item.beneficiario_pagador || null,
          cpfCnpjPagador: item.cpfCnpjPagador || '',
          cpfCnpjRecebedor: item.cpfCnpjRecebedor || '',
          status: item.categoria && item.categoria !== '0' && item.categoria !== 0 ? 'CONCILIADA' : 'PENDENTE',
          // Campos financeiros detalhados
          juros: parseValorBackend(item.juros),
          multa: parseValorBackend(item.multa),
          abatimento: parseValorBackend(item.abatimento),
          imposto: parseValorBackend(item.imposto),
          adicionado: item.adicionado || "0.00",
          desconto1: parseValorBackend(item.desconto1),
          desconto2: parseValorBackend(item.desconto2),
          desconto3: parseValorBackend(item.desconto3),
          valorTotal: parseValorBackend(item.valorTotal || item.valor),
          tag: item.tag || ''
        }));
        console.log('[workspaceConciliacaoService] Dados mapeados:', mapped);
        return mapped;
      } catch (error) {
        console.error('[workspaceConciliacaoService] Erro ao buscar extrato:', error);
        console.error('[workspaceConciliacaoService] Erro detalhado:', {
          message: error.message,
          response: error.response,
          status: error.response?.status,
          data: error.response?.data
        });
        throw error;
      }
    }
    
    // Fallback para handleRequest se USE_REAL_API for false
    return handleRequest({
      mockFn: () => simulateLatency(MOCK_PENDING_TRANSACTIONS),
      apiFn: async () => {
        const params = new URLSearchParams();
        if (filters.mes) params.append('mes', filters.mes);
        if (filters.ano) params.append('ano', filters.ano);
        
        const queryString = params.toString();
        const url = `/extrato/apresentar${queryString ? `?${queryString}` : ''}`;
        
        const response = await api.get(url);
        const raw = response?.data ?? response;
        let data = raw?.dados ?? raw?.Base_Dados_API ?? raw;
        if (!Array.isArray(data)) {
          data = Object.values(data || {});
        }
        return data.map(item => ({
          id: item.idextrato || item.id || 0,
          data: item.dataEntrada || item.data || '',
          descricao: item.descricao || item.titulo || '',
          valor: parseValorBackend(item.valor),
          tipo: item.tipoOperacao === 'D' ? 'DEBITO' : item.tipoOperacao === 'C' ? 'CREDITO' : 'DEBITO',
          tipoOperacao: item.tipoOperacao || 'D',
          caixaId: item.caixinha ? parseInt(item.caixinha) : null,
          categoriaId: item.categoria && item.categoria !== '0' ? parseInt(item.categoria) : null,
          regraId: item.regra && item.regra !== '0' && item.regra !== 0 ? parseInt(item.regra) : null,
          beneficiario: item.beneficiario_pagador || null,
          status: item.categoria && item.categoria !== '0' && item.categoria !== 0 ? 'CONCILIADA' : 'PENDENTE',
          tag: item.tag || ''
        }));
      }
    });
  },

  /**
   * Busca transações conciliadas detalhadas (hierarquia completa)
   * Rota: GET /extrato/apresentar/caixinha/detalhado?caixinha={id}&mes={mes}&ano={ano}
   * @param {number|string} caixinhaId - ID da caixinha
   * @param {Object} [filters] - Filtros adicionais (mes, ano)
   * @returns {Promise<Object>} - Estrutura hierárquica completa
   */
  fetchExtratoDetalhado: async (caixinhaId, filters = {}) => {
    console.log('[workspaceConciliacaoService] fetchExtratoDetalhado chamado para caixinha:', caixinhaId, filters);
    try {
      const params = new URLSearchParams();
      params.append('caixinha', caixinhaId);
      if (filters.mes) params.append('mes', filters.mes);
      if (filters.ano) params.append('ano', filters.ano);
      
      const response = await api.get(`/extrato/apresentar/caixinha/detalhado?${params.toString()}`);
      console.log('[workspaceConciliacaoService] fetchExtratoDetalhado resposta:', response.data);
      return response.data;
    } catch (error) {
      console.error('[workspaceConciliacaoService] Erro ao buscar extrato detalhado:', error);
      throw error;
    }
  },
  /**
   * Busca transações pendentes de conciliação
   * Rota: GET /categorias/transacoes/pendentes
   * @returns {Promise<TransacaoPendente[]>}
   */
  fetchPendentes: async () => {
    console.log('[workspaceConciliacaoService] fetchPendentes chamado');
    console.log('[workspaceConciliacaoService] USE_REAL_API:', USE_REAL_API);
    
    if (USE_REAL_API) {
      try {
        console.log('[workspaceConciliacaoService] Chamando GET /categorias/transacoes/pendentes');
        const response = await api.get('/categorias/transacoes/pendentes');
        console.log('[workspaceConciliacaoService] Resposta completa:', response);
        console.log('[workspaceConciliacaoService] response.data:', response.data);
        
        const raw = response?.data ?? response;
        // Trata Base_Dados_API (objeto de objetos ou array) ou dados diretos
        let data = raw?.dados ?? raw?.Base_Dados_API ?? raw;
        if (!Array.isArray(data)) {
          data = Object.values(data || {});
        }
        console.log('[workspaceConciliacaoService] Dados normalizados:', data);
        console.log('[workspaceConciliacaoService] Quantidade de itens:', data.length);
        
        const mapped = data.map(item => ({
          id: item.idextrato || item.id || 0,
          data: item.dataEntrada || item.data || '',
          descricao: item.descricao || '',
          valor: parseValorBackend(item.valor),
          tipo: item.tipoOperacao === 'D' ? 'DEBITO' : item.tipoOperacao === 'C' ? 'CREDITO' : item.tipo || 'DEBITO',
          tipoOperacao: item.tipoOperacao || 'D',
          caixaId: item.caixinha ? parseInt(item.caixinha) : null,
          categoriaId: null,
          regraId: null,
          beneficiario: item.beneficiario_pagador || null,
          status: 'PENDENTE'
        }));
        console.log('[workspaceConciliacaoService] Dados mapeados:', mapped);
        return mapped;
      } catch (error) {
        console.warn('[workspaceConciliacaoService] Rota /categorias/transacoes/pendentes não disponível (404). Retornando array vazio.');
        console.warn('[workspaceConciliacaoService] Erro:', error.response?.status, error.message);
        // Retorna array vazio ao invés de lançar erro, pois a rota pode não estar implementada ainda
        return [];
      }
    }
    
    // Fallback para handleRequest se USE_REAL_API for false
    return handleRequest({
      mockFn: () => simulateLatency(MOCK_PENDING_TRANSACTIONS),
      apiFn: async () => {
        const response = await api.get('/categorias/transacoes/pendentes');
        const raw = response?.data ?? response;
        let data = raw?.Base_Dados_API ?? raw;
        if (!Array.isArray(data)) {
          data = Object.values(data || {});
        }
        return data.map(item => ({
          id: item.idextrato || item.id || 0,
          data: item.dataEntrada || item.data || '',
          descricao: item.descricao || '',
          valor: parseValorBackend(item.valor),
          tipo: item.tipoOperacao === 'D' ? 'DEBITO' : item.tipoOperacao === 'C' ? 'CREDITO' : item.tipo || 'DEBITO',
          tipoOperacao: item.tipoOperacao || 'D',
          caixaId: item.caixinha ? parseInt(item.caixinha) : null,
          categoriaId: null,
          regraId: null,
          beneficiario: item.beneficiario_pagador || null,
          status: 'PENDENTE'
        }));
      }
    });
  },

  /**
   * Busca cruzamentos com filtros opcionais
   * Rota: GET /categorias/cruzamentos?caixinha=1&mes=10&ano=2025
   * @param {Object} [filters] - Filtros de busca
   * @param {number} [filters.caixinha] - ID da caixinha
   * @param {number} [filters.mes] - Mês (1-12)
   * @param {number} [filters.ano] - Ano (ex: 2025)
   * @returns {Promise<Cruzamento[]>}
   */
  fetchCruzamentos: async (filters = {}) => {
    console.log('[workspaceConciliacaoService] fetchCruzamentos chamado com filters:', filters);
    console.log('[workspaceConciliacaoService] USE_REAL_API:', USE_REAL_API);
    
    if (USE_REAL_API) {
      try {
        const params = new URLSearchParams();
        if (filters.caixinha) params.append('caixinha', filters.caixinha);
        if (filters.mes) params.append('mes', filters.mes);
        if (filters.ano) params.append('ano', filters.ano);
        
        const queryString = params.toString();
        const url = `/categorias/cruzamentos${queryString ? `?${queryString}` : ''}`;
        console.log('[workspaceConciliacaoService] Chamando GET', url);
        
        const response = await api.get(url);
        console.log('[workspaceConciliacaoService] Resposta completa:', response);
        console.log('[workspaceConciliacaoService] response.data:', response.data);
        
        const raw = response?.data ?? response;
        // A resposta de cruzamentos tem estrutura: { dados: [...], filtro: {...}, total_registros: N }
        let data = raw?.dados ?? raw?.Base_Dados_API ?? raw;
        if (!Array.isArray(data)) {
          data = Object.values(data || {});
        }
        console.log('[workspaceConciliacaoService] Dados normalizados:', data);
        console.log('[workspaceConciliacaoService] Quantidade de itens:', data.length);
        
        // Função para converter data de DD/MM/YYYY para YYYY-MM-DD
        const convertDate = (dateStr) => {
          if (!dateStr) return '';
          // Se já está no formato YYYY-MM-DD, retorna direto
          if (/^\d{4}-\d{2}-\d{2}$/.test(dateStr)) return dateStr;
          // Se está no formato DD/MM/YYYY, converte
          const parts = dateStr.split('/');
          if (parts.length === 3) {
            return `${parts[2]}-${parts[1].padStart(2, '0')}-${parts[0].padStart(2, '0')}`;
          }
          return dateStr;
        };
        
        // Usa a função parseValorBackend para converter valores corretamente
        const convertValor = parseValorBackend;
        
        const mapped = data.map((item, index) => {
          // Para cruzamentos, os dados são agregações, não transações individuais
          // Precisamos criar uma estrutura que represente a agregação
          const dataEntrada = convertDate(item.data_entrada || item.dataEntrada || item.data);
          const valor = convertValor(item.total_valor || item.valor);
          const tipoOperacao = item.tipo_operacao || item.tipoOperacao || '';
          const tipo = tipoOperacao.toLowerCase().includes('saída') || tipoOperacao.toLowerCase().includes('saidas') 
            ? 'DEBITO' 
            : tipoOperacao.toLowerCase().includes('entrada') || tipoOperacao.toLowerCase().includes('entradas')
            ? 'CREDITO'
            : 'DEBITO';
          
          return {
            id: item.idextrato || item.id || index + 1000,
            data: dataEntrada,
            descricao: item.nome_categoria || item.descricao || `Agregação ${item.idcategoria || index}`,
            valor: valor,
            tipo: tipo,
            tipoOperacao: tipo === 'DEBITO' ? 'D' : 'C',
            caixaId: item.caixinha ? parseInt(item.caixinha) : (filters.caixinha ? parseInt(filters.caixinha) : 1),
            categoriaId: item.idcategoria ? parseInt(item.idcategoria) : null,
            regraId: null, // Cruzamentos são agregações, não têm regra específica
            beneficiario: item.beneficiario_pagador || null,
            status: 'CONCILIADA',
            // Campos adicionais da agregação
            totalItens: item.total_itens || 0,
            nomeCategoria: item.nome_categoria || ''
          };
        });
        console.log('[workspaceConciliacaoService] Dados mapeados:', mapped);
        return mapped;
      } catch (error) {
        console.error('[workspaceConciliacaoService] Erro ao buscar cruzamentos:', error);
        console.error('[workspaceConciliacaoService] Erro detalhado:', {
          message: error.message,
          response: error.response,
          status: error.response?.status,
          data: error.response?.data
        });
        throw error;
      }
    }
    
    // Fallback para handleRequest se USE_REAL_API for false
    return handleRequest({
      mockFn: () => {
        const mockCruzamentos = MOCK_PENDING_TRANSACTIONS.map((t, i) => ({
          id: 1000 + i,
          descricao: t.descricao,
          valor: t.valor,
          data: t.data,
          caixinha: filters.caixinha || 1,
          mes: filters.mes || new Date().getMonth() + 1,
          ano: filters.ano || new Date().getFullYear()
        }));
        return simulateLatency(mockCruzamentos);
      },
      apiFn: async () => {
        const params = new URLSearchParams();
        if (filters.caixinha) params.append('caixinha', filters.caixinha);
        if (filters.mes) params.append('mes', filters.mes);
        if (filters.ano) params.append('ano', filters.ano);
        
        const queryString = params.toString();
        const url = `/categorias/cruzamentos${queryString ? `?${queryString}` : ''}`;
        const response = await api.get(url);
        const raw = response?.data ?? response;
        let data = raw?.Base_Dados_API ?? raw;
        if (!Array.isArray(data)) {
          data = Object.values(data || {});
        }
        return data.map(item => ({
          id: item.idextrato || item.id || 0,
          data: item.dataEntrada || item.data || '',
          descricao: item.descricao || '',
          valor: parseValorBackend(item.valor),
          tipo: item.tipoOperacao === 'D' ? 'DEBITO' : item.tipoOperacao === 'C' ? 'CREDITO' : 'DEBITO',
          tipoOperacao: item.tipoOperacao || 'D',
          caixaId: item.caixinha ? parseInt(item.caixinha) : (filters.caixinha ? parseInt(filters.caixinha) : 1),
          categoriaId: item.categoria && item.categoria !== '0' ? parseInt(item.categoria) : null,
          regraId: item.regra && item.regra !== '0' && item.regra !== 0 ? parseInt(item.regra) : null,
          beneficiario: item.beneficiario_pagador || null,
          status: 'CONCILIADA',
          caixinha: item.caixinha || filters.caixinha || null
        }));
      }
    });
  },

  /**
   * Busca detalhes de cruzamentos com filtros opcionais
   * @param {Object} [filters] - Filtros de busca
   * @param {number} [filters.caixinha] - ID da caixinha
   * @param {number} [filters.mes] - Mês (1-12)
   * @param {number} [filters.ano] - Ano (ex: 2025)
   * @returns {Promise<CruzamentoDetalhe[]>}
   */
  fetchCruzamentosDetalhes: async (filters = {}) => {
    console.log('[workspaceConciliacaoService] fetchCruzamentosDetalhes chamado com filters:', filters);
    console.log('[workspaceConciliacaoService] USE_REAL_API:', USE_REAL_API);
    
    if (USE_REAL_API) {
      try {
        const params = new URLSearchParams();
        if (filters.caixinha) params.append('caixinha', filters.caixinha);
        if (filters.mes) params.append('mes', filters.mes);
        if (filters.ano) params.append('ano', filters.ano);
        
        const queryString = params.toString();
        const url = `/categorias/cruzamentos/detalhes${queryString ? `?${queryString}` : ''}`;
        console.log('[workspaceConciliacaoService] Chamando GET', url);
        
        const response = await api.get(url);
        console.log('[workspaceConciliacaoService] Resposta completa:', response);
        console.log('[workspaceConciliacaoService] response.data:', response.data);
        
        const raw = response?.data ?? response;
        // A resposta pode ter estrutura: { dados: [...], filtro: {...}, total_registros: N } ou Base_Dados_API
        let data = raw?.dados ?? raw?.Base_Dados_API ?? raw;
        if (!Array.isArray(data)) {
          data = Object.values(data || {});
        }
        console.log('[workspaceConciliacaoService] Dados normalizados:', data);
        console.log('[workspaceConciliacaoService] Quantidade de itens:', data.length);
        
        const mapped = data.map((item, index) => ({
          id: item.idextrato || item.id || index + 2000,
          descricao: item.descricao || '',
          valor: parseValorBackend(item.valor),
          data: item.dataEntrada || item.data || '',
          detalhes: {
            categoria: item.categoria || item.nome_categoria || '',
            beneficiario: item.beneficiario_pagador || item.beneficiario || '',
            caixinha: item.caixinha || filters.caixinha || null
          }
        }));
        console.log('[workspaceConciliacaoService] Dados mapeados:', mapped);
        return mapped;
      } catch (error) {
        console.error('[workspaceConciliacaoService] Erro ao buscar detalhes:', error);
        console.error('[workspaceConciliacaoService] Erro detalhado:', {
          message: error.message,
          response: error.response,
          status: error.response?.status,
          data: error.response?.data
        });
        throw error;
      }
    }
    
    // Fallback para handleRequest se USE_REAL_API for false
    return handleRequest({
      mockFn: () => {
        const mockDetalhes = MOCK_PENDING_TRANSACTIONS.map((t, i) => ({
          id: 2000 + i,
          descricao: t.descricao,
          valor: t.valor,
          data: t.data,
          detalhes: {
            categoria: 'Categoria Exemplo',
            beneficiario: 'Beneficiário Exemplo',
            caixinha: filters.caixinha || 1
          }
        }));
        return simulateLatency(mockDetalhes);
      },
      apiFn: async () => {
        const params = new URLSearchParams();
        if (filters.caixinha) params.append('caixinha', filters.caixinha);
        if (filters.mes) params.append('mes', filters.mes);
        if (filters.ano) params.append('ano', filters.ano);
        
        const queryString = params.toString();
        const url = `/categorias/cruzamentos/detalhes${queryString ? `?${queryString}` : ''}`;
        const response = await api.get(url);
        const raw = response?.data ?? response;
        let data = raw?.dados ?? raw?.Base_Dados_API ?? raw;
        if (!Array.isArray(data)) {
          data = Object.values(data || {});
        }
        return data.map(item => ({
          id: item.idextrato || item.id || 0,
          descricao: item.descricao || '',
          valor: parseValorBackend(item.valor),
          data: item.dataEntrada || item.data || '',
          detalhes: {
            categoria: item.categoria || '',
            beneficiario: item.beneficiario_pagador || '',
            caixinha: item.caixinha || filters.caixinha || null
          }
        }));
      }
    });
  },

  /**
   * Busca detalhes de cruzamentos por descrição com filtros opcionais
   * Rota: GET /categorias/cruzamentos/detalhes/descricao?caixinha=1&mes=10&ano=2025&descricao=texto
   * @param {Object} [filters] - Filtros de busca
   * @param {number} [filters.caixinha] - ID da caixinha
   * @param {number} [filters.mes] - Mês (1-12)
   * @param {number} [filters.ano] - Ano (ex: 2025)
   * @param {string} [filters.descricao] - Descrição para filtrar
   * @returns {Promise<CruzamentoDetalhe[]>}
   */
  fetchCruzamentosDetalhesDescricao: async (filters = {}) => {
    console.log('[workspaceConciliacaoService] fetchCruzamentosDetalhesDescricao chamado com filters:', filters);
    console.log('[workspaceConciliacaoService] USE_REAL_API:', USE_REAL_API);
    
    if (USE_REAL_API) {
      try {
        const params = new URLSearchParams();
        if (filters.caixinha) params.append('caixinha', filters.caixinha);
        if (filters.mes) params.append('mes', filters.mes);
        if (filters.ano) params.append('ano', filters.ano);
        if (filters.descricao) params.append('descricao', filters.descricao);
        
        const queryString = params.toString();
        const url = `/categorias/cruzamentos/detalhes/descricao${queryString ? `?${queryString}` : ''}`;
        console.log('[workspaceConciliacaoService] Chamando GET', url);
        
        const response = await api.get(url);
        console.log('[workspaceConciliacaoService] Resposta completa:', response);
        console.log('[workspaceConciliacaoService] response.data:', response.data);
        
        const raw = response?.data ?? response;
        let data = raw?.dados ?? raw?.Base_Dados_API ?? raw;
        if (!Array.isArray(data)) {
          data = Object.values(data || {});
        }
        console.log('[workspaceConciliacaoService] Dados normalizados:', data);
        console.log('[workspaceConciliacaoService] Quantidade de itens:', data.length);
        
        const mapped = data.map((item, index) => ({
          id: item.idextrato || item.id || index + 3000,
          descricao: item.descricao || '',
          valor: parseValorBackend(item.valor),
          data: item.dataEntrada || item.data || '',
          tipo: item.tipoOperacao === 'D' ? 'DEBITO' : item.tipoOperacao === 'C' ? 'CREDITO' : 'DEBITO',
          tipoOperacao: item.tipoOperacao || 'D',
          caixaId: item.caixinha ? parseInt(item.caixinha) : (filters.caixinha ? parseInt(filters.caixinha) : null),
          categoriaId: item.categoria && item.categoria !== '0' ? parseInt(item.categoria) : null,
          regraId: item.regra && item.regra !== '0' && item.regra !== 0 ? parseInt(item.regra) : null,
          beneficiario: item.beneficiario_pagador || item.beneficiario || null,
          status: 'CONCILIADA',
          tag: item.tag || ''
        }));
        console.log('[workspaceConciliacaoService] Dados mapeados:', mapped);
        return mapped;
      } catch (error) {
        console.error('[workspaceConciliacaoService] Erro ao buscar transações por descrição:', error);
        throw error;
      }
    }
    
    // Fallback para handleRequest se USE_REAL_API for false
    return handleRequest({
      mockFn: () => {
      // Mock filtrado por descrição se fornecido
      let mockDetalhes = MOCK_PENDING_TRANSACTIONS.map((t, i) => ({
        id: 3000 + i,
        descricao: t.descricao,
        valor: t.valor,
        data: t.data,
        detalhes: {
          categoria: 'Categoria Exemplo',
          beneficiario: 'Beneficiário Exemplo',
          caixinha: filters.caixinha || 1
        }
      }));

      if (filters.descricao) {
        mockDetalhes = mockDetalhes.filter(t => 
          t.descricao.toLowerCase().includes(filters.descricao.toLowerCase())
        );
      }

      return simulateLatency(mockDetalhes);
    },
    apiFn: async () => {
      const params = new URLSearchParams();
      if (filters.caixinha) params.append('caixinha', filters.caixinha);
      if (filters.mes) params.append('mes', filters.mes);
      if (filters.ano) params.append('ano', filters.ano);
      if (filters.descricao) params.append('descricao', filters.descricao);
      
      const queryString = params.toString();
      const url = `/categorias/cruzamentos/detalhes/descricao${queryString ? `?${queryString}` : ''}`;
      const response = await api.get(url);
      const raw = response?.data ?? response;
      // Trata Base_Dados_API (objeto de objetos ou array)
      let data = raw?.Base_Dados_API ?? raw;
      if (!Array.isArray(data)) {
        data = Object.values(data || {});
      }
      return data.map(item => ({
        id: item.idextrato || item.id || 0,
        descricao: item.descricao || '',
        valor: parseValorBackend(item.valor),
        data: item.dataEntrada || item.data || '',
        tipo: item.tipoOperacao === 'D' ? 'DEBITO' : item.tipoOperacao === 'C' ? 'CREDITO' : 'DEBITO',
        tipoOperacao: item.tipoOperacao || 'D',
        caixaId: item.caixinha ? parseInt(item.caixinha) : (filters.caixinha ? parseInt(filters.caixinha) : null),
        categoriaId: item.categoria && item.categoria !== '0' ? parseInt(item.categoria) : null,
        regraId: item.regra && item.regra !== '0' && item.regra !== 0 ? parseInt(item.regra) : null,
        beneficiario: item.beneficiario_pagador || item.beneficiario || null,
        status: 'CONCILIADA',
        tag: item.tag || ''
      }));
    }
  })
  }
};
