import { create } from 'zustand';
import { prafrotService } from '../services/prafrotService';
import { toast } from 'sonner';
import { extractFriendlyMessage } from '../utils/errorMessages';

export const useFleetLists = create((set, get) => ({
  listsConfig: null,
  statusFrotaOptions: [],
  statusManutencaoOptions: [],
  motivoAtendimentoOptions: [],
  responsaveisOptions: [],
  validacaoOptions: [],
  aprovacaoOptions: [],
  loading: false,
  error: null,

  fetchListsConfig: async () => {
    set({ loading: true, error: null });
    try {
      const config = await prafrotService.getListasConfig();
      set({ listsConfig: config });
      
      // Se tivermos a configuração para status_frota, já buscamos as opções
      if (config && config.status_frota && config.status_frota.rota) {
        await get().fetchListOptions('status_frota', config.status_frota.rota);
      }

      // Se tivermos a configuração para status_manutencao, buscamos as opções
      if (config && config.status_manutencao && config.status_manutencao.rota) {
        await get().fetchListOptions('status_manutencao', config.status_manutencao.rota);
      }

      // Se tivermos a configuração para motivo_atendimento, buscamos as opções
      if (config && config.motivo_atendimento && config.motivo_atendimento.rota) {
        await get().fetchListOptions('motivo_atendimento', config.motivo_atendimento.rota);
      }

      // Se tivermos a configuração para responsaveis, buscamos as opções
      if (config && config.responsaveis && config.responsaveis.rota) {
        await get().fetchListOptions('responsaveis', config.responsaveis.rota);
      }

      // Se tivermos a configuração para validacao, buscamos as opções
      if (config && config.validacao && config.validacao.rota) {
        await get().fetchListOptions('validacao', config.validacao.rota);
      }

      // Se tivermos a configuração para aprovacao, buscamos as opções
      if (config && config.aprovacao && config.aprovacao.rota) {
        await get().fetchListOptions('aprovacao', config.aprovacao.rota);
      }
      
    } catch (error) {
      console.error('Erro ao buscar configuração de listas:', error);
      const friendlyMsg = extractFriendlyMessage(error);
      set({ error: friendlyMsg });
    } finally {
      set({ loading: false });
    }
  },

  fetchListOptions: async (listName, route) => {
    try {
      const data = await prafrotService.getListasByRoute(route);
      let options = Array.isArray(data) ? data : (data.data || []);
      
      if (options.length > 0 && typeof options[0] === 'object') {
        if (listName === 'status_frota') {
            options = options.map(item => item.status_frota).filter(Boolean);
        } else if (listName === 'status_manutencao') {
            options = options.map(item => item.status_manutencao || item.status || Object.values(item)[0]).filter(Boolean);
        } else if (listName === 'motivo_atendimento') {
            options = options.map(item => item.motivo_atendimento || item.motivo || Object.values(item)[0]).filter(Boolean);
        } else if (listName === 'responsaveis') {
            options = options.map(item => item.responsaveis || item.responsavel || item.nome || Object.values(item)[0]).filter(Boolean);
        } else if (listName === 'validacao') {
            options = options.map(item => item.validacao || item.validacao_financeiro || Object.values(item)[0]).filter(Boolean);
        } else if (listName === 'aprovacao') {
            options = options.map(item => item.aprovacao || item.nome || item.responsavel || Object.values(item)[0]).filter(Boolean);
        } else {
            options = options.map(item => Object.values(item)[0] || JSON.stringify(item));
        }
      } else {
         options = options.map(String);
      }
      
      if (listName === 'status_frota') {
        set({ statusFrotaOptions: options });
      } else if (listName === 'status_manutencao') {
        set({ statusManutencaoOptions: options });
      } else if (listName === 'motivo_atendimento') {
        set({ motivoAtendimentoOptions: options });
      } else if (listName === 'responsaveis') {
        set({ responsaveisOptions: options });
      } else if (listName === 'validacao') {
        set({ validacaoOptions: options });
      } else if (listName === 'aprovacao') {
        set({ aprovacaoOptions: options });
      }
      
      return options;
    } catch (error) {
      console.error(`Erro ao buscar opções para ${listName}:`, error);
      return [];
    }
  }
}));



