import {
  useInfiniteQuery,
  useMutation,
  useQuery,
  useQueryClient,
} from "@tanstack/react-query";
import { ServiceProjectRepository } from "../repositories/ServiceProjectRepository";
import showToast from "../services/toastService";

//#region Service Project
export const useServiceProjects = (pageSize, pageNumber) => {
  return useQuery({
    queryKey: ["serviceProjects", pageSize, pageNumber],
    queryFn: async () => {
      const response = await ServiceProjectRepository.GetServiceProjects(
        pageSize,
        pageNumber
      );
      return response.data;
    },
  });
};
export const useServiceProject = (projectId) => {
  return useQuery({
    queryKey: ["serviceProject", projectId],
    queryFn: async () => {
      const response = await ServiceProjectRepository.GetServiceProject(
        projectId
      );
      return response.data;
    },
    enabled: !!projectId,
  });
};

export const useServiceProjectTeam = (projectId, isActive) => {
  return useQuery({
    queryKey: ["serviceProjectTeam", projectId, isActive],
    queryFn: async () => {
      const response = await ServiceProjectRepository.GetAllocatedEmployees(
        projectId,
        isActive
      );
      return response.data;
    },
    enabled: !!projectId,
  });
};
export const useCreateServiceProject = (onSuccessCallback) => {
  const queryClient = useQueryClient();
  return useMutation({
    mutationFn: async (playload) =>
      await ServiceProjectRepository.CreateServiceProject(playload),
    onSuccess: (data, variables) => {
      queryClient.invalidateQueries({ queryKey: ["serviceProjects"] });
      if (onSuccessCallback) onSuccessCallback();
      showToast("Project created successfully", "success");
    },
    onError: (error) => {
      showToast(
        error?.response?.data?.message ||
          error.message ||
          "Failed to delete task",
        "error"
      );
    },
  });
};
export const useUpdateServiceProject = (onSuccessCallback) => {
  const queryClient = useQueryClient();

  return useMutation({
    mutationFn: async ({ id, payload }) => {
      return await ServiceProjectRepository.UpdateServiceProject(id, payload);
    },
    onSuccess: (data, variables) => {
      queryClient.invalidateQueries({ queryKey: ["serviceProjects"] });
      queryClient.invalidateQueries({
        queryKey: ["serviceProject", variables.id],
      });
      if (onSuccessCallback) onSuccessCallback();
      showToast("Project updated successfully", "success");
    },
    onError: (error) => {
      showToast(
        error?.response?.data?.message ||
          error.message ||
          "Failed to update project",
        "error"
      );
    },
  });
};

export const useActiveInActiveServiceProject = (onSuccessCallback) => {
  const queryClient = useQueryClient();

  return useMutation({
    mutationFn: async (id, status) => {
      return await ServiceProjectRepository.DeleteServiceProject(id, status);
    },
    onSuccess: (data, variables) => {
      queryClient.invalidateQueries({ queryKey: ["serviceProjects"] });
      if (onSuccessCallback) onSuccessCallback();
      showToast(
        `Project ${status ? "restored" : "deleted"} successfully`,
        "success"
      );
    },
    onError: (error) => {
      showToast(
        error?.response?.data?.message ||
          error.message ||
          "Failed to update project",
        "error"
      );
    },
  });
};

export const useAllocationServiceProjectTeam = (onSuccessCallback) => {
  const queryClient = useQueryClient();
  return useMutation({
    mutationFn: async ({ payload, isActive }) =>
      await ServiceProjectRepository.AllocateEmployee(payload),
    onSuccess: (data, variables) => {
      queryClient.invalidateQueries({ queryKey: ["serviceProjectTeam"] });
      if (onSuccessCallback) onSuccessCallback();
      if (variables.isActive) {
        showToast(
          `${variables?.payload.length} Employee allocated successfully`,
          "success"
        );
      } else {
        showToast(`Employee removed successfully`, "success");
      }
    },
    onError: (error) => {
      showToast(
        error?.response?.data?.message ||
          error.message ||
          "Failed to update project",
        "error"
      );
    },
  });
};

//#endregion

//#region Service Jobs

export const useServiceProjectJobs = (
  pageSize,
  pageNumber,
  isActive = true,
  project
) => {
  return useQuery({
    queryKey: ["serviceProjectJobs", pageSize, pageNumber, isActive, project],
    queryFn: async () => {
      const resp = await ServiceProjectRepository.GetJobList(
        pageSize,
        pageNumber,
        isActive,
        project
      );
      return resp.data;
    },
  });
};
export const useJobComments = (jobId, pageSize, pageNumber) => {
  return useInfiniteQuery({
    queryKey: ["jobComments", jobId, pageSize],

    queryFn: async ({ pageParam = pageNumber }) => {
      const resp = await ServiceProjectRepository.GetJobComment(
        jobId,
        pageSize,
        pageParam
      );
      return resp.data;
    },
    enabled: !!jobId,

    initialPageParam: pageNumber,

    getNextPageParam: (lastPage, allPages) => {
      if (!lastPage?.data?.length) return null;

      return allPages.length + pageNumber;
    },
  });
};
export const useJobTags = () => {
  return useQuery({
    queryKey: ["Job_Tags"],
    queryFn: async () => await ServiceProjectRepository.GetJobTags(),
  });
};

export const useServiceProjectJobDetails = (job) => {
  return useQuery({
    queryKey: ["service-job", job],
    queryFn: async () => {
      const resp = await ServiceProjectRepository.GetJobDetails(job);
      return resp.data;
    },
    enabled: !!job,
  });
};
export const useAddCommentJob = (onSuccessCallback) => {
  const queryClient = useQueryClient();
  return useMutation({
    mutationFn: async (data) => await ServiceProjectRepository.AddComment(data),
    onSuccess: (data, variables) => {
      queryClient.invalidateQueries({
        queryKey: ["jobComments", variables?.jobTicketId],
      });
      if (onSuccessCallback) onSuccessCallback();
      showToast("Comment added successfully", "success");
    },
    onError: (error) => {
      showToast(
        error?.response?.data?.message ||
          error.message ||
          "Failed to update project",
        "error"
      );
    },
  });
};

export const useCreateServiceProjectJob = (onSuccessCallback) => {
  const queryClient = useQueryClient();

  return useMutation({
    mutationFn: async (payload) => {
      return await ServiceProjectRepository.CreateJob(payload);
    },
    onSuccess: (data, variables) => {
      queryClient.invalidateQueries({ queryKey: ["serviceProjectJobs"] });

      if (onSuccessCallback) onSuccessCallback();
      showToast("Job Created successfully", "success");
    },
    onError: (error) => {
      showToast(
        error?.response?.data?.message ||
          error.message ||
          "Failed to update project",
        "error"
      );
    },
  });
};

export const useUpdateServiceProjectJob = (onSuccessCallback) => {
  const queryClient = useQueryClient();
  return useMutation({
    mutationFn: async ({ id, payload }) => {
      // Call the repository patch
      const resp = await ServiceProjectRepository.UpdateJob(id, payload);

      return resp;
    },
    onSuccess: () => {
      queryClient.invalidateQueries({ queryKey: ["serviceProjectJobs"] });
      queryClient.invalidateQueries({ queryKey: ["service-job"] });
      if (onSuccessCallback) onSuccessCallback();
      showToast("Job Updated successfully", "success");
    },
    onError: (error) => {
      showToast(
        error?.response?.data?.message ||
          error.message ||
          "Failed to update project",
        "error"
      );
    },
  });
};

//#endregion

//#region Branch
export const useBranches = (
  projectId,
  isActive,
  pageSize,
  pageNumber,
  searchString
) => {
  return useQuery({
    queryKey: [
      "branches",
      projectId,
      isActive,
      pageSize,
      pageNumber,
      searchString,
    ],
    queryFn: async () => {
      const resp = await ServiceProjectRepository.GetBranchList(
        projectId,
        isActive,
        pageSize,
        pageNumber,
        searchString
      );
      return resp.data;
    },
    enabled: !!projectId,
  });
};

export const useBranch = (id)=>{
  return useQuery({
    queryKey:["branch",id],
    queryFn:async()=>{
      const resp = await ServiceProjectRepository.GetBranchDetail(id);
      return resp.data ?? resp;
    },
    enabled:!!id
  })
}

export const useCreateBranche =()=>{
  const queryClient = useQueryClient();
  return useMutation({
    mutationFn:async(payload)=> await ServiceProjectRepository.CreateBranch(payload),
     onSuccess: (data, variables) => {
      queryClient.invalidateQueries({
        queryKey: ["branches"],
      });
      if (onSuccessCallback) onSuccessCallback();
      showToast("Branch created successfully", "success");
    },
    onError: (error) => {
      showToast(
        error?.response?.data?.message ||
          error.message ||
          "Failed to create branch",
        "error"
      );
    },
  })
}

export const useUpdateBranch=()=>{
  const queryClient = useQueryClient();
  return useMutation({
    mutationFn:async({id,payload})=> await ServiceProjectRepository.UpdateBranch(id,payload),
    onSuccess: (_,variables) => {
      queryClient.invalidateQueries({ queryKey: ["branches"] });
      queryClient.invalidateQueries({ queryKey: ["branch",variables.id] });
      if (onSuccessCallback) onSuccessCallback();
      showToast("Branch Updated successfully", "success");
    },
    onError: (error) => {
      showToast(
        error?.response?.data?.message ||
          error.message ||
          "Failed to update branch",
        "error"
      );
    },
  })
}

export const useDeleteBranch=()=>{
  const queryClient = useQueryClient();
  return useMutation({
    mutationFn:async(id)=> await ServiceProjectRepository.DeleteBranch(id),
     onSuccess: (_,variables) => {
      queryClient.invalidateQueries({ queryKey: ["branches"] });
      if (onSuccessCallback) onSuccessCallback();
      showToast("Branch Deleted successfully", "success");
    },
    onError: (error) => {
      showToast(
        error?.response?.data?.message ||
          error.message ||
          "Failed to delete branch",
        "error"
      );
    },
  })
}