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

export const conciliacaoService = {
  // ==================== FETCH ====================
  fetchCategories: () => handleRequest({
    mockFn: () => simulateLatency(conciliacaoMock.categories),
    apiFn: async () => {
      console.log('[conciliacaoService] Chamando GET /categorias/apresentar');
      const response = await api.get('/categorias/apresentar');
      console.log('[conciliacaoService] Resposta categorias:', response);
      return response;
    }
  }),

  fetchRules: () => handleRequest({
    mockFn: () => simulateLatency(conciliacaoMock.rules),
    apiFn: async () => {
      console.log('[conciliacaoService] Chamando GET /regras/apresentar');
      const response = await api.get('/regras/apresentar');
      console.log('[conciliacaoService] Resposta regras:', response);
      return response;
    }
  }),

  fetchStatement: () => handleRequest({
    mockFn: () => simulateLatency(conciliacaoMock.statement),
    apiFn: async () => {
      console.log('[conciliacaoService] Chamando GET /extrato/apresentar');
      const response = await api.get('/extrato/apresentar');
      console.log('[conciliacaoService] Resposta extrato:', response);
      return response;
    }
  }),

  fetchCaixinhas: () => handleRequest({
    mockFn: () => simulateLatency(conciliacaoMock.caixinhas),
    apiFn: async () => {
      console.log('[conciliacaoService] Chamando GET /caixinhas/apresentar');
      const response = await api.get('/caixinhas/apresentar');
      console.log('[conciliacaoService] Resposta caixinhas:', response);
      return response;
    }
  }),

  // ==================== CATEGORIAS ====================
  createCategory: (payload) => handleRequest({
    mockFn: () => simulateLatency({ ...payload, idcategoria: String(Date.now()) }),
    apiFn: () => api.post('/categorias/create', payload)
  }),

  updateCategory: (payload) => handleRequest({
    mockFn: () => simulateLatency({ success: true, ...payload }),
    apiFn: () => api.post('/categorias/edit', payload)
  }),

  deleteCategory: (id) => handleRequest({
    mockFn: () => simulateLatency({ success: true }),
    apiFn: () => api.delete('/categorias/delete', {
      data: { idcategoria: id }
    })
  }),

  // ==================== CAIXINHAS ====================
  createCaixinha: (payload) => handleRequest({
    mockFn: () => simulateLatency({ ...payload, idcaixinhas_financeiro: String(Date.now()) }),
    apiFn: () => api.post('/caixinha/create', payload)
  }),

  updateCaixinha: (payload) => handleRequest({
    mockFn: () => simulateLatency({ success: true, ...payload }),
    apiFn: () => api.post('/caixinha/edit', payload)
  }),

  deleteCaixinha: (id) => handleRequest({
    mockFn: () => simulateLatency({ success: true }),
    apiFn: () => api.delete('/caixinhas/delete', {
      data: { idcaixinhas_financeiro: id }
    })
  }),

  // ==================== REGRAS ====================
  createRule: (payload) => handleRequest({
    mockFn: () => simulateLatency({ ...payload, id: String(Date.now()) }),
    apiFn: () => api.post('/regra/create', payload)
  }),

  updateRule: (payload) => handleRequest({
    mockFn: () => simulateLatency({ success: true, ...payload }),
    apiFn: () => api.post('/regras/edit', payload)
  }),

  deleteRule: (id) => handleRequest({
    mockFn: () => simulateLatency({ success: true }),
    apiFn: () => api.delete('/regras/delete', {
      data: { idregras_financeiro: id }
    })
  }),

  // ==================== EXTRATO ====================
  updateTransactionRule: (id, payload) => handleRequest({
    mockFn: () => simulateLatency({ success: true }),
    // Payload contém idextrato, regra, categoria, beneficiario_pagador, caixinha
    // A rota principal de aplicação de regra parece ser o update de regra ou uma combinação
    // Baseado na engine, ela chama updates individuais, mas o updateTransactionRule é chamado com payload completo
    // Vou criar um método composto no hook, mas aqui preciso manter a consistência da chamada
    // Como a engine chama updateTransactionRule passando o payload completo, vou assumir POST manual
    // Mas o diff do usuário mudou para /extrato/apresentar/regra/${id} que deu 404
    // O código de referência diz que usa /regra_categoria/edit, /beneficiario_pagador/inserir, etc.
    // Vou manter como endpoint de regra específico se existir, senão usarei o composto no hook
    apiFn: () => api.put(`/extrato/apresentar/regra/${id}`, payload) 
  }),

  importOFX: (file) => handleRequest({
    mockFn: () => simulateLatency({ success: true, message: 'Mocked OFX Import' }),
    apiFn: () => {
      const formData = new FormData();
      formData.append('file', file);
      return api.post('/financeiro/importar-ofx', formData, {
        headers: { 'Content-Type': 'multipart/form-data' },
      });
    }
  }),

  updateTransactionCategory: (id, categoryId) => handleRequest({
    mockFn: () => simulateLatency({ success: true }),
    apiFn: () => api.post('/regra_categoria/edit', { idextrato: id, categoria: categoryId })
  }),

  updateTransactionBox: (id, boxId) => handleRequest({
    mockFn: () => simulateLatency({ success: true }),
    apiFn: () => api.put('/caixinha_extrato/inserir', { idextrato: id, caixinha: boxId })
  }),

  updateTransactionBeneficiary: (id, beneficiary) => handleRequest({
    mockFn: () => simulateLatency({ success: true }),
    apiFn: () => api.put('/beneficiario_pagador/inserir', { idextrato: id, beneficiario_pagador: beneficiary })
  }),

  updateTransactionTag: (id, tag) => handleRequest({
    mockFn: () => simulateLatency({ success: true }),
    apiFn: () => api.post('/tag/inserir', { idextrato: id, tag: tag })
  }),

  // ==================== NOVAS ROTAS ====================
  fetchRulesByCategory: (categoryId) => handleRequest({
    mockFn: () => simulateLatency(conciliacaoMock.rules.filter(r => String(r.categoria) === String(categoryId))),
    apiFn: async () => {
      console.log(`[conciliacaoService] Chamando GET /regras_financeiro/por_categoria?categoria=${categoryId}`);
      const response = await api.get('/regras_financeiro/por_categoria', {
        params: { categoria: categoryId }
      });
      return response;
    }
  })
};
