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 { useDispatch, useSelector } from "react-redux";
import { store } from "../store/store";
import { setDefaultDateRange } from "../slices/localVariablesSlice";

// 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 dispatch = useDispatch()
  const {
    data: attendance = [],
    isLoading: loading,
    error,
    refetch: recall,
    isFetching
  } = 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,
    isFetching
  };
};

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

  const query = useQuery({
    queryKey: ['attendanceLogs', projectId, fromDate, toDate],
    queryFn: async () => {
      const res = await AttendanceRepository.getAttendanceFilteredByDate(
        projectId,
        fromDate,
        toDate
      );
      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,
  });
};

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