import { useEffect, useState } from "react";
import { cacheData, getCachedData, useSelectedProject } from "../slices/apiDataManager";
import AttendanceRepository from "../repositories/AttendanceRepository";
import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
import showToast from "../services/toastService";
import { useDispatch, useSelector } from "react-redux";
import { store } from "../store/store";
import { setDefaultDateRange } from "../slices/localVariablesSlice";



// ----------------------------Query-----------------------------


export const useAttendance = (projectId, organizationId, includeInactive = false, date = null) => {
  const dispatch = useDispatch();
// queryKey: ["attendance", projectId, organizationId, includeInactive, date], 
  const {
    data: attendance = [],
    isLoading: loading,
    error,
    refetch: recall,
    isFetching,
  } = useQuery({
    queryKey: ["attendance", projectId ], 
    queryFn: async () => {
      const response = await AttendanceRepository.getAttendance(
        projectId,
        organizationId,
        includeInactive,
        date
      );
      return response.data;
    },
    enabled: !!projectId, 
    onError: (error) => {
      showToast(error.message || "Error while fetching Attendance", "error");
    },
  });

  return { attendance, loading, error, recall, isFetching };
};

export const useAttendancesLogs = (projectId, fromDate, toDate,organizationId) => {
  const dispatch = useDispatch();
  const enabled = !!projectId && !!fromDate && !!toDate;

  const query = useQuery({
    queryKey: ['attendanceLogs', projectId, fromDate, toDate,organizationId],
    queryFn: async () => {
      const res = await AttendanceRepository.getAttendanceFilteredByDate(
        projectId,
        fromDate,
        toDate,
        organizationId
      );
      return res.data;
    },
    enabled,
  });
  
  useEffect(() => {
    if (query.data && fromDate && toDate) {
      dispatch(
        setDefaultDateRange({
          startDate: fromDate,
          endDate: toDate,
        })
      );
    }
  }, [dispatch, query.data, fromDate, toDate]);
  return query;
};



export const useEmployeeAttendacesLog = (id) => {
  const {
    data: logs = [],
    isLoading: loading,
    error,
    refetch: recall,
  } = useQuery({
    queryKey: ["employeeAttendanceLogs", id],
    queryFn: async () => {
      const response = await AttendanceRepository.getAttendanceLogs(id);
      return response.data;
    },
    enabled: !!id,
    onError: (error) => {
      showToast(error.message || "Error while fetching Attendance Logs", "error");
    },
  });

  return {
    logs,
    loading,
    error,
    recall,
  };
};

export const useAttendanceByEmployee = (employeeId, fromDate, toDate) => {
  const enabled = !!employeeId && !!fromDate && !!toDate;

  return useQuery({
    queryKey: ["employeeAttendance", employeeId, fromDate, toDate],
    queryFn: async () => {
      const res = await AttendanceRepository.getAttendanceByEmployee(employeeId, fromDate, toDate);
      return res.data;
    },
    enabled: !!fromDate && !! toDate,
  });
};


export const useRegularizationRequests = (projectId, organizationId, IncludeInActive = false) => {
  const dispatch = useDispatch();

  const {
    data: regularizes = [],
    isLoading: loading,
    error,
    refetch: recall,
    isFetching,
  } = useQuery({
    queryKey: ["regularizedList", projectId, organizationId, IncludeInActive], // include filters in cache key
    queryFn: async () => {
      const response = await AttendanceRepository.getRegularizeList(
        projectId,
        organizationId,
        IncludeInActive,      
      );
      return response.data;
    },
    enabled: !!projectId, // only run if projectId exists
    onError: (error) => {
      showToast(error.message || "Error while fetching regularizes", "error");
    },
  });

  return { regularizes, loading, error, recall, isFetching };
};


// -------------------Mutation--------------------------------------

export const useMarkAttendance = () => {
  const queryClient = useQueryClient();
  const selectedProject = useSelectedProject();
  const selectedDateRange = useSelector((store)=>store.localVariables.defaultDateRange)

  return useMutation({
    mutationFn: async ({payload,forWhichTab}) => {
      const res = await AttendanceRepository.markAttendance(payload);
      return res.data;
    },

    onSuccess: (data,variables) => {
      if(variables.forWhichTab == 1){
      queryClient.setQueryData(["attendance",selectedProject], (oldData) => {
        if (!oldData) return oldData;
        return oldData.map((emp) =>
          emp.employeeId === data.employeeId ? { ...emp, ...data } : emp
        );
      });
      // queryClient.invalidateQueries({queryKey:["attendance"]})
    }else if(variables.forWhichTab == 2){
      queryClient.invalidateQueries({
        queryKey: ["attendanceLogs"], 
     });
     queryClient.setQueryData(["attendanceLogs",selectedProject,selectedDateRange.startDate,selectedDateRange.endDate], (oldData) => {
        if (!oldData) return oldData;
        return oldData.map((record) =>
          record.id === data.id ? { ...record, ...data } : record
        );
      });
       queryClient.invalidateQueries({queryKey:["regularizedList"]})
    }else(
       queryClient.setQueryData(["regularizedList",selectedProject], (oldData) => {
        if (!oldData) return oldData;
        return oldData.filter((record) => record.id !== data.id)
      }),
      queryClient.invalidateQueries({queryKey:["attendanceLogs"]})
    )

     if(variables.forWhichTab !== 3) showToast("Attendance marked successfully", "success");
    },
    onError: (error) => {
      showToast(error.message || "Failed to mark attendance", "error");
    },
  });
};