import { create } from 'zustand';
import { prafrotService } from '../services/prafrotService';
import { useFeedbackStore } from '../components/FeedbackNotification';
import { extractFriendlyMessage } from '../utils/errorMessages';

const notify = (type, title, message) => useFeedbackStore.getState().notify(type, title, message);

export const useMaintenance = create((set, get) => ({
  maintenances: [],
  loading: false,
  error: null,

  fetchMaintenances: async (type = 'total') => {
    set({ loading: true, error: null });
    try {
      let list = [];
      if (type === 'total') {
        const data = await prafrotService.getMaintenance();
        list = Array.isArray(data) ? data : (data.data || []);
      } else {
        const data = await prafrotService.getAbertoFechado();
        // Concatena abertas e fechadas para manter o estado global se necessário, 
        // mas a tela de manutenção gerencia o estado `abertoFechadoData` via hook.
        // No entanto, para padronizar as ações (save/update), vamos manter o fetchMaintenances funcional.
        const abertas = data.abertas || data.aberto || data.abertos || [];
        const fechadas = data.fechadas || data.fechado || data.fechados || [];
        list = [...abertas, ...fechadas];
      }
      
      const normalized = list.map(m => ({ ...m, previsao_entrega: m.previsao_entrega ?? m.previcao_entrega }));
      set({ maintenances: normalized });
    } catch (error) {
      const friendlyMsg = extractFriendlyMessage(error);
      set({ error: friendlyMsg });
      notify('error', 'Falha na Busca', friendlyMsg);
    } finally {
      set({ loading: false });
    }
  },

  // Helper para decidir qual rota atualizar baseado no contexto (geralmente chamado após mutações)
  refreshMaintenances: async (currentFilter = 'total') => {
    const fetch = get().fetchMaintenances;
    const getGroups = get().getAbertoFechado;
    
    if (currentFilter === 'total') {
      await fetch('total');
    } else {
      // Atualiza ambos para garantir consistência
      await fetch('total');
      await getGroups();
    }
  },

  createMaintenance: async (payload, files = null) => {
    set({ loading: true });
    try {
      await prafrotService.createMaintenance(payload, files);
      notify('success', 'Cadastro Concluído', 'Manutenção registrada com sucesso no sistema.');
      get().fetchMaintenances();
      return true;
    } catch (error) {
      const friendlyMsg = extractFriendlyMessage(error);
      notify('error', 'Falha no Registro', friendlyMsg);
      return false;
    } finally {
      set({ loading: false });
    }
  },

  updateMaintenance: async (id, payload, files = null) => {
    set({ loading: true });
    try {
      await prafrotService.updateMaintenance(id, payload, files);
      notify('success', 'Atualização!', 'Dados da manutenção atualizados.');
      get().fetchMaintenances();
      return true;
    } catch (error) {
      const friendlyMsg = extractFriendlyMessage(error);
      notify('error', 'Erro na Atualização', friendlyMsg);
      return false;
    } finally {
      set({ loading: false });
    }
  },

  updateMaintenanceBatch: async (ids, status) => {
    set({ loading: true });
    try {
      await prafrotService.updateMaintenanceBatch(ids, status);
      
      notify('success', 'Lote Atualizado', `${ids.length} manutenções foram atualizadas.`);
      get().fetchMaintenances();
      return true;
    } catch (error) {
      const friendlyMsg = extractFriendlyMessage(error);
      notify('error', 'Falha em Massa', friendlyMsg);
      return false;
    } finally {
      set({ loading: false });
    }
  },

  calcularDifOrcamento: async (orcamento_inicial, orcamento_final) => {
    try {
      const data = await prafrotService.calcularDifOrcamento(orcamento_inicial, orcamento_final);
      const valor = data?.dif_orcamento ?? data?.valor ?? (typeof data === 'number' ? data : null);
      return valor;
    } catch (error) {
      return null;
    }
  },

  deleteMaintenance: async (id) => {
    if (!window.confirm('Tem certeza que deseja excluir esta manutenção?')) return;
    set({ loading: true });
    try {
      await prafrotService.deleteMaintenance(id);
      notify('success', 'Removido', 'Registro de manutenção excluído.');
      get().fetchMaintenances();
      return true;
    } catch (error) {
      const friendlyMsg = extractFriendlyMessage(error);
      notify('error', 'Erro na Remoção', friendlyMsg);
      return false;
    } finally {
      set({ loading: false });
    }
  },

  fecharManutencao: async (id) => {
    set({ loading: true });
    try {
      await prafrotService.fecharManutencao(id);
      notify('success', 'Manutenção Fechada', 'Manutenção fechada com sucesso.');
      get().fetchMaintenances();
      return true;
    } catch (error) {
      const friendlyMsg = extractFriendlyMessage(error);
      notify('error', 'Erro ao Fechar', friendlyMsg);
      return false;
    } finally {
      set({ loading: false });
    }
  },

  abrirManutencao: async (id) => {
    set({ loading: true });
    try {
      await prafrotService.abrirManutencao(id);
      notify('success', 'Manutenção Aberta', 'Manutenção aberta com sucesso.');
      get().fetchMaintenances();
      return true;
    } catch (error) {
      const friendlyMsg = extractFriendlyMessage(error);
      notify('error', 'Erro ao Abrir', friendlyMsg);
      return false;
    } finally {
      set({ loading: false });
    }
  },

  getAbertoFechado: async () => {
    set({ loading: true });
    try {
      const data = await prafrotService.getAbertoFechado();
      // Atualiza também a lista principal 'maintenances' para refletir as mudanças
      const abertas = data.abertas || data.aberto || data.abertos || [];
      const fechadas = data.fechadas || data.fechado || data.fechados || [];
      const normalized = [...abertas, ...fechadas].map(m => ({ ...m, previsao_entrega: m.previsao_entrega ?? m.previcao_entrega }));
      set({ maintenances: normalized });
      return data;
    } catch (error) {
      const friendlyMsg = extractFriendlyMessage(error);
      notify('error', 'Erro na Busca', friendlyMsg);
      return null;
    } finally {
      set({ loading: false });
    }
  },

  // Histórico de manutenção
  getHistoricoCompleto: async () => {
    try {
      const data = await prafrotService.getHistoricoCompleto();
      return Array.isArray(data) ? data : (data.data || []);
    } catch (error) {
      const friendlyMsg = extractFriendlyMessage(error);
      notify('error', 'Erro ao Buscar Histórico', friendlyMsg);
      return [];
    }
  },

  getHistoricoDetalhado: async () => {
    try {
      const data = await prafrotService.getHistoricoDetalhado();
      return Array.isArray(data) ? data : (data.data || []);
    } catch (error) {
      const friendlyMsg = extractFriendlyMessage(error);
      notify('error', 'Erro ao Buscar Histórico', friendlyMsg);
      return [];
    }
  },

  getHistoricoResumido: async () => {
    try {
      const data = await prafrotService.getHistoricoResumido();
      return Array.isArray(data) ? data : (data.data || []);
    } catch (error) {
      const friendlyMsg = extractFriendlyMessage(error);
      notify('error', 'Erro ao Buscar Histórico', friendlyMsg);
      return [];
    }
  },

  getHistoricoEstatisticas: async () => {
    try {
      const data = await prafrotService.getHistoricoEstatisticas();
      return data;
    } catch (error) {
      const friendlyMsg = extractFriendlyMessage(error);
      notify('error', 'Erro ao Buscar Estatísticas', friendlyMsg);
      return null;
    }
  },

  getHistoricoPeriodo: async (params) => {
    try {
      const data = await prafrotService.getHistoricoPeriodo(params);
      return Array.isArray(data) ? data : (data.data || []);
    } catch (error) {
      const friendlyMsg = extractFriendlyMessage(error);
      notify('error', 'Erro ao Buscar Histórico', friendlyMsg);
      return [];
    }
  },

  getHistoricoTop: async () => {
    try {
      const data = await prafrotService.getHistoricoTop();
      return Array.isArray(data) ? data : (data.data || []);
    } catch (error) {
      const friendlyMsg = extractFriendlyMessage(error);
      notify('error', 'Erro ao Buscar Histórico', friendlyMsg);
      return [];
    }
  },

  getHistoricoPorPlaca: async (placa) => {
    try {
      const data = await prafrotService.getHistoricoPorPlaca(placa);
      return Array.isArray(data) ? data : (data.data || []);
    } catch (error) {
      const friendlyMsg = extractFriendlyMessage(error);
      notify('error', 'Erro ao Buscar Histórico', friendlyMsg);
      return [];
    }
  }
}));



