testes/src/services/fornecedoresService.js

import api from './api';
import { handleRequest, simulateLatency } from './serviceUtils';

/**
 * Service de Fornecedores do Financeiro V2
 * Gerencia comunicação com as rotas de fornecedores
 * Baseado na lógica antiga: Consult_Get para listar, POST para criar/editar
 */
export const fornecedoresService = {
  /**
   * Busca todos os fornecedores
   * Baseado na lógica antiga: Consult_Get com Resulte: "Status_fornecedores"
   * Tenta múltiplas rotas possíveis:
   * - /Status_fornecedores/apresentar (baseado no Resulte)
   * - /fornecedores/apresentar (rota padrão)
   * Retorna: Base_Dados_API com array de fornecedores
   * @returns {Promise<Array>}
   */
  fetchFornecedores: () => handleRequest({
    mockFn: () => simulateLatency([]),
    apiFn: async () => {
      console.log('[fornecedoresService] Iniciando busca de fornecedores...');
      
      // Tenta primeiro a rota baseada no Resulte da lógica antiga
      const rotasPossiveis = [
        '/fornecedores',
        '/fornecedores/apresentar',
        '/status_fornecedores/apresentar'
      ];
      
      for (const rota of rotasPossiveis) {
        try {
          console.log(`[fornecedoresService] Tentando rota: ${rota}`);
          const response = await api.get(rota);
          console.log('[fornecedoresService] Resposta recebida:', response.data);
          
          // Novo formato: { dados: [...], total: number }
          if (response.data?.dados && Array.isArray(response.data.dados)) {
            console.log(`[fornecedoresService] Dados extraídos do novo formato (dados):`, response.data.dados.length, 'itens', `(total: ${response.data.total})`);
            return response.data.dados;
          }
          
          // Se retornar Base_Dados_API (estrutura antiga), extrai o array
          if (response.data?.Base_Dados_API) {
            const dados = Array.isArray(response.data.Base_Dados_API) 
              ? response.data.Base_Dados_API 
              : Object.values(response.data.Base_Dados_API || {});
            console.log(`[fornecedoresService] Dados extraídos de Base_Dados_API:`, dados.length, 'itens');
            return dados;
          }
          
          // Se vier como array direto
          if (Array.isArray(response.data)) {
            console.log(`[fornecedoresService] Dados recebidos como array:`, response.data.length, 'itens');
            return response.data;
          }
          
          // Se vier como objeto com chaves numéricas
          if (typeof response.data === 'object' && response.data !== null) {
            const dados = Object.values(response.data);
            console.log(`[fornecedoresService] Dados extraídos de objeto:`, dados.length, 'itens');
            return dados;
          }
          
          console.warn(`[fornecedoresService] Formato de resposta não reconhecido para rota ${rota}`);
        } catch (err) {
          console.warn(`[fornecedoresService] Erro na rota ${rota}:`, err.message);
          // Continua para próxima rota
          if (rota === rotasPossiveis[rotasPossiveis.length - 1]) {
            // Se é a última rota, lança o erro
            console.error('[fornecedoresService] Todas as rotas falharam');
            throw err;
          }
        }
      }
      
      console.warn('[fornecedoresService] Nenhuma rota funcionou, retornando array vazio');
      return [];
    }
  }),

  /**
   * Cria um novo fornecedor
   * Rota: POST /fornecedores/create
   * Payload: objeto com campos do formulário
   * @param {Object} fornecedorData - Dados do fornecedor
   * @returns {Promise<Object>}
   */
  createFornecedor: (fornecedorData) => handleRequest({
    mockFn: () => simulateLatency({
      ...fornecedorData,
      idfornecedores: Date.now(),
      id: Date.now()
    }),
    apiFn: async () => {
      // Mapeia campos do formulário para o formato esperado pelo backend
      const payload = {
        nome_da_empresa: fornecedorData.nome_da_empresa || fornecedorData.nome || '',
        email: fornecedorData.email || '',
        cpf_cnpj: fornecedorData.cpf_cnpj || '',
        telefone: fornecedorData.telefone || '',
        tipo_pessoa: fornecedorData.tipo_pessoa || 'JURIDICA',
        servico: fornecedorData.servico || '',
        obs: fornecedorData.obs || '',
        endereco: fornecedorData.endereco || '',
        bairro: fornecedorData.bairro || '',
        cidade: fornecedorData.cidade || '',
        uf: fornecedorData.uf || '',
        cep: fornecedorData.cep || '',
        // idregra enviado como lista
        idregra: Array.isArray(fornecedorData.idregra) ? fornecedorData.idregra : (fornecedorData.idregra ? [fornecedorData.idregra] : [])
      };
      
      const response = await api.post('/fornecedores/create', payload);
      return response.data;
    }
  }),

  /**
   * Atualiza um fornecedor existente
   * Rota: POST /fornecedores/edit
   * Payload: objeto com campos do formulário incluindo idfornecedores
   * @param {number|string} id - idfornecedores
   * @param {Object} fornecedorData - Dados atualizados do fornecedor
   * @returns {Promise<Object>}
   */
  updateFornecedor: (id, fornecedorData) => handleRequest({
    mockFn: () => simulateLatency({
      ...fornecedorData,
      idfornecedores: id,
      id: id
    }),
    apiFn: async () => {
      // Mapeia campos do formulário para o formato esperado pelo backend
      const payload = {
        idfornecedores: id,
        nome_da_empresa: fornecedorData.nome_da_empresa || fornecedorData.nome || '',
        email: fornecedorData.email || '',
        cpf_cnpj: fornecedorData.cpf_cnpj || '',
        telefone: fornecedorData.telefone || '',
        tipo_pessoa: fornecedorData.tipo_pessoa || 'JURIDICA',
        servico: fornecedorData.servico || '',
        obs: fornecedorData.obs || '',
        endereco: fornecedorData.endereco || '',
        bairro: fornecedorData.bairro || '',
        cidade: fornecedorData.cidade || '',
        uf: fornecedorData.uf || '',
        cep: fornecedorData.cep || '',
        // idregra enviado como lista
        idregra: Array.isArray(fornecedorData.idregra) ? fornecedorData.idregra : (fornecedorData.idregra ? [fornecedorData.idregra] : [])
      };
      
      const response = await api.post('/fornecedores/edit', payload);
      return response.data;
    }
  }),

  /**
   * Exclui um fornecedor
   * Rota: POST /fornecedores/delete (ou conforme element.Manipuladores[2].Route)
   * @param {number|string} id - idfornecedores
   * @returns {Promise<any>}
   */
  deleteFornecedor: (id) => handleRequest({
    mockFn: () => simulateLatency({ success: true }),
    apiFn: async () => {
      try {
        console.log('[fornecedoresService] Tentando excluir fornecedor via DELETE /fornecedores/delete:', id);
        const response = await api.delete('/fornecedores/delete', { 
          data: { idfornecedores: id } 
        });
        return response.data;
      } catch (err) {
        console.warn('[fornecedoresService] Falha no DELETE /fornecedores/delete, tentando fallback DELETE com ID na URL:', err.message);
        // Fallback: tenta DELETE /fornecedores/:id
        try {
          const response = await api.delete(`/fornecedores/${id}`);
          return response.data;
        } catch (err2) {
          console.error('[fornecedoresService] Erro ao excluir fornecedor (todas as rotas):', err2);
          throw err2;
        }
      }
    }
  }),

  /**
   * Busca movimentações aplicadas a uma ou mais regras (usado no extrato do fornecedor)
   * Rota: POST /regra_aplicada
   * @param {number|string|Array} idregra - ID ou lista de IDs de regra
   * @param {string} tipoOperacao - 'C' ou 'D'
   * @param {Array} [idempresa] - Lista de IDs de empresa (opcional)
   * @returns {Promise<Array>}
   */
  fetchRegraAplicada: (idregra, tipoOperacao, idempresa) => handleRequest({
    mockFn: () => simulateLatency([]),
    apiFn: async () => {
      // Normaliza idregra como array
      const regraIds = Array.isArray(idregra) ? idregra : (idregra ? [idregra] : []);

      const payload = {
        idregra: regraIds,
        tipoOperacao: tipoOperacao,
        ...(idempresa && Array.isArray(idempresa) && idempresa.length > 0 ? { idempresa } : {})
      };
      
      const response = await api.post('/regra_aplicada', payload);
      
      // Ajuste conforme estrutura de retorno da rota
      if (response.data?.linha_tempo) {
        return response.data.linha_tempo;
      }
      
      if (response.data?.Base_Dados_API) {
        return Array.isArray(response.data.Base_Dados_API) 
          ? response.data.Base_Dados_API 
          : Object.values(response.data.Base_Dados_API);
      }
      return Array.isArray(response.data) ? response.data : [];
    }
  })
};