marco.pms.web/src/hooks/useAttendance.js

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

// export const useAttendace =(projectId)=>{

//   const [attendance, setAttendance] = useState([]);
//   const[loading,setLoading] = useState(true)
//   const [error, setError] = useState(null); 

//    const fetchData =  () => {
//      const Attendance_cache = getCachedData("Attendance");
//      if(!Attendance_cache || Attendance_cache.projectId !== projectId){
      
//         setLoading(true);
//          AttendanceRepository.getAttendance(projectId)
//            .then((response) => {
//              setAttendance(response.data);
//              cacheData( "Attendance", {data: response.data, projectId} )
//              setLoading(false)
//            })
//            .catch((error) => {
//             setLoading(false)
//             setError("Failed to fetch data.");
//            })
//       }  else {
//         setAttendance(Attendance_cache.data);
//         setLoading(false)
//       }
//     };


//   useEffect(()=>{
//     if ( projectId && projectId != 1 )
//     {
//       fetchData(projectId);
//     }
//   },[projectId])

//   return {attendance,loading,error,recall:fetchData}
// }

// export const useEmployeeAttendacesLog = (id) => {
//   const [logs, setLogs] = useState([]);
//   const [loading, setLoading] = useState(false);
//   const [error, setError] = useState(null);

   
//   const fetchData =  () => {
//     const AttendanceLog_cache = getCachedData("AttendanceLogs");
//     if(!AttendanceLog_cache || AttendanceLog_cache.id !== id  ){
//        setLoading(true)
//        AttendanceRepository.getAttendanceLogs(id).then((response)=>{     
//         setLogs(response.data)
//         cacheData("AttendanceLogs", { data: response.data, id })
//         setLoading(false)
//         }).catch((error)=>{
//           setError("Failed to fetch data.");
//           setLoading(false);
//         })     
//     }else{
     
//       setLogs(AttendanceLog_cache.data);
//     }
//   };

//   useEffect(() => {
//     if (id) {
//       fetchData(); 
//     }

//   }, [id]);

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

// export const useRegularizationRequests = ( projectId ) =>
// {
//   const [regularizes, setregularizes] = useState([]);
//   const [loading, setLoading] = useState(false);
//   const [error, setError] = useState(null);

   
//   const fetchData =  () => {
//     const regularizedList_cache = getCachedData("regularizedList");
//     if(!regularizedList_cache || regularizedList_cache.projectId !== projectId  ){
//        setLoading(true)
//        AttendanceRepository.getRegularizeList(projectId).then((response)=>{     
//         setregularizes( response.data )
//         cacheData("regularizedList", { data: response.data, projectId })
//         setLoading(false)
//         }).catch((error)=>{
//           setError("Failed to fetch data.");
//           setLoading(false);
//         })     
//     }else{
     
//       setregularizes(regularizedList_cache.data);
//     }
//   };

//   useEffect(() => {
//     if (projectId) {
//       fetchData(); 
//     }

//   }, [ projectId ] );
//   return {regularizes,loading,error,refetch:fetchData}
// }


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


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

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

export const useAttendancesLogs = (projectId, fromDate, toDate) => {
  const enabled = !!projectId && !!fromDate && !!toDate;
  return useQuery({
    queryKey: ["attendanceLogs", projectId, fromDate, toDate],
    queryFn: async () => {
      const res = await AttendanceRepository.getAttendanceFilteredByDate(
        projectId,
        fromDate,
        toDate
      );
      return res.data;
    },
    enabled,
  });
};



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,
  });
};

export const useRegularizationRequests = (projectId) => {
  const {
    data: regularizes = [],
    isLoading: loading,
    error,
    refetch,
  } = useQuery({
    queryKey: ["regularizedList", projectId],
    queryFn: async () => {
      const response = await AttendanceRepository.getRegularizeList(projectId);
      return response.data;
    },
    enabled: !!projectId,
    onError: (error) => {
      showToast(error.message || "Error while fetching Regularization Requests", "error");
    },
  });

  return {
    regularizes,
    loading,
    error,
    refetch,
  };
};


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

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

  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
        );
      });
    }else{
      queryClient.invalidateQueries({
        queryKey: ["attendanceLogs"], 
     });
    }
     if(variables.forWhichTab !== 3) showToast("Attendance marked successfully", "success");
    },
    onError: (error) => {
      showToast(error.message || "Failed to mark attendance", "error");
    },
  });
};