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


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

export const useTaskList = (projectId, dateFrom, toDate) => {
  const enabled = !!projectId && !!dateFrom && !!toDate;

  const {
    data: TaskList = [],
    isLoading: loading,
    error,
    refetch,
  } = useQuery({
    queryKey: ["taskList", projectId, dateFrom, toDate],
    queryFn: async () => {
      const response = await TasksRepository.getTaskList(
        projectId,
        dateFrom,
        toDate
      );
      return response.data;
    },
    enabled,
 
  });

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

export const useTaskById = (TaskId) => {
  const {
    data: Task = null,
    isLoading: loading,
    error,
    refetch,
  } = useQuery({
    queryKey: ["taskDetails", TaskId],
    queryFn: async () => {
      const res = await TasksRepository.getTaskById(TaskId);
      return res.data;
    },
    enabled: !!TaskId, 
  });

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

// export const useActivities = () => {
//   return useQuery({
//     queryKey: ["activitiesMaster"],
//     queryFn: async () => {
//       const response = await ActivityRepository.getActivities();
//       return response.data;
//     },

//   });
// };

export const useAuditStatus = () => {
  const {
    data: status = [],
    isLoading: loading,
    error,
    refetch,
  } = useQuery({
    queryKey: ["AuditStatus"],
    queryFn: async () => {
      const res = await MasterRespository.getAuditStatus();
      return res.data;
    },

  });

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


// -----------------------Mutation------------------------
const toDate = new Date().toISOString().split('T')[0];
const dateFrom = new Date(Date.now() - 6 * 24 * 60 * 60 * 1000).toISOString().split('T')[0];



export const useReportTask = ( {onSuccessCallback, onErrorCallback} = {} ) =>
{
  const queryClient = useQueryClient();
  const {
    mutate,
    isPending,
    isSuccess,
    isError,
    error,
  } = useMutation({
    mutationFn: async ( {reportData,workAreaId} ) =>
    {
      debugger
      return await TasksRepository.reportTask(reportData);
    },
    onSuccess: ( data, variables ) =>
    {
      const {workAreaId} = variables;
      queryClient.invalidateQueries( {queryKey: [ "taskList" ]} ); 
      queryClient.invalidateQueries( {queryKey: [ "WorkItems", workAreaId ]} );
      queryClient.invalidateQueries( {queryKey: [ 'ProjectsList' ]} );
      showToast( "Task Reported Successfully.", "success" );
      if (onSuccessCallback) onSuccessCallback(data);
    },
    onError: (error) => {
      const msg =
        error?.response?.data?.message || error.message || "Error occurred during API call";
      showToast( msg, "error" );
    },
  });

  return {
    mutate,
    isPending,
    isSuccess,
    isError,
    error,
  };
};

export const useSubmitTaskComment = ({ actionAllow, onSuccessCallback }) => {
  const queryClient = useQueryClient();
  const { mutate, isPending } = useMutation({
    mutationFn: async ({ data, commentsData }) => {
      const payload = {
        ...data,
        [actionAllow ? "id" : "taskAllocationId"]: commentsData?.id,
        ...(actionAllow ? {} : { commentDate: new Date().toISOString() }),
      };

      const response = actionAllow
        ? await TasksRepository.auditTask(payload)
        : await TasksRepository.taskComments(payload);

      return response.data;
    },

    onSuccess: ( data,variables ) =>
    {

      const workAreaId = variables?.commentsData?.workItem?.workArea?.id;
      queryClient.invalidateQueries({ queryKey: ["taskList"] });
      if (actionAllow) {
        showToast( "Review submitted successfully.", "success" );
        
      } else
      {
        showToast("Comment sent successfully.", "success");
      }

      onSuccessCallback?.(data);
    },

    onError: (error) => {
      const msg = error?.response?.data?.message || error.message || "Error during API call";
      showToast(msg, "error");
    },
  });

  return { submitComment: mutate, isPending };
};

export const useCreateTask = ( {onSuccessCallback, onErrorCallback} = {} ) =>
{
  const queryClient = useQueryClient();
  return useMutation({
    mutationFn: async ({payload,workAreaId}) => {
      return await TasksRepository.assignTask(payload);
    },
    onSuccess: ( _, variables ) =>
    {
      queryClient.invalidateQueries( {queryKey: [ "taskList" ]} );
      queryClient.invalidateQueries( {queryKey: [ "WorkItems", variables?.workAreaId ]} );
      showToast( "Task Assigned Successfully.", "success" );
      if (onSuccessCallback) onSuccessCallback(variables);
    },
    onError: ( error ) =>
    {
      showToast("Something went wrong. Please try again.", "error");
      if (onErrorCallback) onErrorCallback(error);
    },
  });
};