import { defineStore } from 'pinia';
import api from '../services/api';
import router from '../routes/router';
import { useAuthStore } from './auth';
import { ca } from 'date-fns/locale';

export const useShiftStore = defineStore('shifts', {
  state: () => ({
    shifts: [],
    total: 0,
    page: 1,
    perPage: 10,
    error: null,
    loading: false,
  }),

  getters: {
    currentPage(state) {
      return state.page;
    },
    totalPages(state) {
      return Math.ceil(state.total / state.perPage);
    },
  },

  actions: {
    /**
     * Busca os turnos (shifts) registrados na API
     */
    async fetchShifts() {
      const authStore = useAuthStore();
      const serviceInstanceId = authStore.service_instance_id;
    
      if (!serviceInstanceId) {
        this.error = 'Nenhuma instância de serviço selecionada';
        return;
      }
    
      this.loading = true;
      this.error = null;
    
      try {
        const response = await api.get('/shift/', {
          params: {}
        });
        console.log('Requisição de turnos:', response.data);
        console.log('ID da instância de serviço:', serviceInstanceId); // Exibe o ID da instância de serviço no console
        // Filtra os shifts que pertencem à serviceInstanceId
        const filteredShifts = response.data.filter(shift => {
          return String(shift.service_instance_id) === String(serviceInstanceId);
        });
        console.log('Turnos filtrados:', filteredShifts); // Exibe os turnos filtrados no console
        this.$patch({
          shifts: filteredShifts,
          //total: response.data,
        });
    
        console.log('Shifts filtrados:', filteredShifts);
        return filteredShifts;
      } catch (error) {
        const status = error?.response?.status;
    
        if (status === 401) {
          console.warn('Não autorizado. Redirecionando para login...');
          router.push('/login');
        }
    
        this.error = error?.response?.data?.message || error.message || 'Erro ao buscar turnos';
        console.error('Erro ao buscar turnos', error);
        throw error;
      } finally {
        this.loading = false;
      }
    },
    /*
    async getShifts() {
     try{
        const authStore = useAuthStore();
        const service_instance_id = authStore.service_instance_id; // Obtém o ID da instância de serviço do store
        const response = await api.get('/shift/');
        console.log('Escalas recebidas:', response.data) // Exibe as câmeras recebidas no console
        console.log('ID da instância de serviço:', service_instance_id) // Exibe o ID da instância de serviço no console
        
        const filteredShifts = response.data.filter(shift => {
          // Filtra câmeras que não estão deletadas
          return String(shift.service_instance_id) === String(service_instance_id)
        })
        this.shifts = filteredShifts // Atualiza o estado com as câmeras filtradas
        return filteredShifts
    }catch (error) {
        console.error('Erro ao buscar turnos:', error)
        throw error
      }
    },*/

    /**
     * Busca um turno específico pelo ID
     */
    async fetchShiftById(shift_id) {
      const url = `/shift/${shift_id}`;
      this.loading = true;
      this.error = null;

      try {
        const response = await api.get(url);
        console.log('requisicao: ',response.data);
        return response.data;
      } catch (error) {
        this.error = error?.response?.data?.message || error.message || 'Erro ao buscar turno';
        console.error('Erro ao buscar turno', error);
        throw error;
      } finally {
        this.loading = false;
      }
    },

    /**
     * Cria um novo turno
     */
    async createShift(shift) {
      const url = '/shift/';
      this.loading = true;
      this.error = null;

      try {
        const response = await api.post(url, shift, {
          headers: {
            'Content-Type': 'application/json'
          }
        });

        this.shifts.push(response.data);
        return response.data;
      } catch (error) {
        this.error = error?.response?.data?.message || error.message || 'Erro ao criar turno';
        console.error('Erro ao criar turno', error);
        throw error;
      } finally {
        this.loading = false;
      }
    },

    /**
     * Atualiza os dados de um turno
     */
    async updateShift(id, shift) {
      const url = `/shift/${id}`;
      this.loading = true;
      this.error = null;

      try {
        const response = await api.put(url, {
          name: shift.name,
          days: shift.days,
          break_time: shift.break_time,
          break_type: shift.break_type,
          status: shift.status,
        });

        const index = this.shifts.findIndex((s) => s.id === id);
        if (index !== -1) {
          this.shifts[index] = response.data;
        }

        return response.data;
      } catch (error) {
        this.error = error?.response?.data?.message || error.message || 'Erro ao atualizar turno';
        console.error('Erro ao atualizar turno', error);
        throw error;
      } finally {
        this.loading = false;
      }
    },

    /**
     * Exclui um turno
     */
    async deleteShift(id) {
      const url = `/shift/${id}`;
      this.loading = true;
      this.error = null;

      try {
        await api.delete(url);
        this.shifts = this.shifts.filter((shift) => shift.id !== id);
      } catch (error) {
        this.error = error?.response?.data?.message || error.message || 'Erro ao excluir turno';
        console.error('Erro ao excluir turno', error);
        throw error;
      } finally {
        this.loading = false;
      }
    },
  },
});
