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

export const useServices = () => {
  return useQuery({
    queryKey: ["services"],
    queryFn: async () => await MasterRespository.getMasterServices(),
  });
};

export const useGroups = (serviceId) => {
  return useQuery({
    queryKey: ["groups", serviceId],
    queryFn: async () => await MasterRespository.getActivityGrops(serviceId),
    enabled: !!serviceId,
  });
};
export const useActivitiesByGroups = (groupId) => {
  return useQuery({
    queryKey: ["activties", groupId],
    queryFn: async () => await MasterRespository.getActivitesByGroup(groupId),
   
    enabled: !!groupId,
   
  });
};
export const useGlobalServices = () => {
  return useQuery({
    queryKey: ["globalServices"],
    queryFn: async () => await MasterRespository.getGlobalServices(),
  });
};

export const useMasterMenu = () => {
  return useQuery({
    queryKey: ["MasterMenu"],
    queryFn: async () => {
      const resp = await MasterRespository.getMasterMenus();
      return resp.data;
    },
  });
};

export const useActivitiesMaster = () => {
  const {
    data: activities = [],
    isLoading: loading,
    error,
  } = useQuery({
    queryKey: ["ActivityMaster"],
    queryFn: async () => {
      const response = await MasterRespository.getActivites();
      return response.data;
    },
    onError: (error) => {
      showToast(
        error?.response?.data?.message ||
          error.message ||
          "Failed to fetch ActivityMasters",
        "error"
      );
    },
  });
  return { activities, loading, error };
};
export const useWorkCategoriesMaster = () => {
  const {
    data: categories = [],
    isLoading: categoryLoading,
    error: categoryError,
  } = useQuery({
    queryKey: ["Work Category"],
    queryFn: async () => {
      const response = await MasterRespository.getWorkCategory();
      return response.data;
    },
    onError: (error) => {
      showToast(
        error?.response?.data?.message ||
          error.message ||
          "Failed to fetch work categories",
        "error"
      );
    },
  });

  return { categories, categoryLoading, categoryError };
};

export const useContactCategory = () => {
  const {
    data: contactCategory = [],
    isLoading: loading,
    error: Error,
  } = useQuery({
    queryKey: ["Contact Category"],
    queryFn: async () => {
      let resp = await MasterRespository.getContactCategory();
      return resp.data;
    },
    onError: (error) => {
      showToast(
        error?.response?.data?.message ||
          error.message ||
          "Failed to fetch Contact categories",
        "error"
      );
    },
  });
  return { contactCategory, loading, Error };
};

export const useContactTags = () => {
  const {
    data: contactTags = [],
    isLoading: loading,
    error,
  } = useQuery({
    queryKey: ["Contact Tag"],
    queryFn: async () => {
      const res = await MasterRespository.getContactTag();
      return res.data;
    },
    onError: (error) => {
      showToast(
        error?.response?.data?.message ||
          error.message ||
          "Failed to fetch Contact Tag",
        "error"
      );
    },
  });

  return { contactTags, loading, error };
};

export const useExpenseType = () => {
  const {
    data: ExpenseTypes = [],
    isLoading: loading,
    error,
  } = useQuery({
    queryKey: ["Expense Type"],
    queryFn: async () => {
      const res = await MasterRespository.getExpenseType();
      return res.data;
    },
    onError: (error) => {
      showToast(
        error?.response?.data?.message ||
          error.message ||
          "Failed to fetch Expense Type",
        "error"
      );
    },
  });

  return { ExpenseTypes, loading, error };
};
export const usePaymentMode = () => {
  const {
    data: PaymentModes = [],
    isLoading: loading,
    error,
  } = useQuery({
    queryKey: ["Payment Mode"],
    queryFn: async () => {
      const res = await MasterRespository.getPaymentMode();
      return res.data;
    },
    onError: (error) => {
      showToast(
        error?.response?.data?.message ||
          error.message ||
          "Failed to fetch Payment Mode",
        "error"
      );
    },
  });

  return { PaymentModes, loading, error };
};
export const useExpenseStatus = () => {
  const {
    data: ExpenseStatus = [],
    isLoading: loading,
    error,
  } = useQuery({
    queryKey: ["Expense Status"],
    queryFn: async () => {
      const res = await MasterRespository.getExpenseStatus();
      return res.data;
    },
    onError: (error) => {
      showToast(
        error?.response?.data?.message ||
          error.message ||
          "Failed to fetch Expense Status",
        "error"
      );
    },
  });

  return { ExpenseStatus, loading, error };
};
export const useDocumentTypes = (category) => {
  const {
    data: DocumentTypes = [],
    error,
    isError,
    isLoading,
  } = useQuery({
    queryKey: ["Document Type", category],
    queryFn: async () => {
      const res = await MasterRespository.getDocumentTypes(category);
      return res.data;
    },
    enabled: !!category,
    onError: (error) => {
      showToast(
        error?.response?.data?.message ||
          error.message ||
          "Failed to fetch Expense Status",
        "error"
      );
    },
  });

  return { DocumentTypes, isError, isLoading, error };
};
export const useDocumentCategories = (EntityType) => {
  const {
    data: DocumentCategories = [],
    error,
    isError,
    isLoading,
  } = useQuery({
    queryKey: ["Document Category", EntityType],
    queryFn: async () => {
      const res = await MasterRespository.getDocumentCategories(EntityType);
      return res.data;
    },
    enabled: !!EntityType,
    onError: (error) => {
      showToast(
        error?.response?.data?.message ||
          error.message ||
          "Failed to fetch Expense Status",
        "error"
      );
    },
  });

  return { DocumentCategories, isError, isLoading, error };
};
export const useOrganizationType = () => {
  return useQuery({
    queryKey: ["orgType"],
    queryFn: async () => await MasterRespository.getOrganizationType(),
  });
};
// ===Application Masters Query=================================================

const fetchMasterData = async (masterType) => {
  switch (masterType) {
    case "Application Role":
      return (await MasterRespository.getRoles()).data;
    case "Job Role":
      return (await MasterRespository.getJobRole()).data;
    case "Activity":
      return (await MasterRespository.getActivites()).data;
    case "Services":
      return (await MasterRespository.getService()).data;
    case "Work Category":
      return (await MasterRespository.getWorkCategory()).data;
    case "Contact Category":
      return (await MasterRespository.getContactCategory()).data;
    case "Contact Tag":
      return (await MasterRespository.getContactTag()).data;
    case "Expense Type":
      return (await MasterRespository.getExpenseType()).data;
    case "Payment Mode":
      return (await MasterRespository.getPaymentMode()).data;
    case "Expense Status":
      return (await MasterRespository.getExpenseStatus()).data;
    case "Document Type":
      return (await MasterRespository.getDocumentTypes()).data;
    case "Document Category":
      return (await MasterRespository.getDocumentCategories()).data;
    case "Status":
      return [
        {
          description: null,
          featurePermission: null,
          id: "02dd4761-363c-49ed-8851-3d2489a3e98d",
          status: "status 1",
        },
        {
          description: null,
          featurePermission: null,
          id: "03dy9761-363c-49ed-8851-3d2489a3e98d",
          status: "status 2",
        },
        {
          description: null,
          featurePermission: null,
          id: "03dy7761-263c-49ed-8851-3d2489a3e98d",
          status: "Status 3",
        },
      ];
    default:
      return [];
  }
};

const useMaster = () => {
  const selectedMaster = useSelector(
    (store) => store.localVariables.selectedMaster
  );
  const queryFn = useCallback(
    () => fetchMasterData(selectedMaster),
    [selectedMaster]
  );
  const {
    data = [],
    isLoading,
    error,
  } = useQuery({
    queryKey: ["masterData", selectedMaster],
    queryFn,
    enabled: !!selectedMaster,
    staleTime: 1000 * 60 * 10,
    refetchOnWindowFocus: false,
    onError: (error) => {
      showToast(
        error?.response?.data?.message ||
          error.message ||
          `Failed to fetch ${selectedMaster} Maseter`,
        "error"
      );
    },
  });

  return { data, loading: isLoading, error };
};

export default useMaster;

// ================================Mutation====================================

// Job Role-----------------------------------
export const useUpdateJobRole = (onSuccessCallback, onErrorCallback) => {
  const queryClient = useQueryClient();

  return useMutation({
    mutationFn: async ({ id, payload }) => {
      const response = await MasterRespository.updateJobRole(id, payload);
      return response.data;
    },
    onSuccess: (data, variables) => {
      showToast("JobRole updated successfully.", "success");

      queryClient.invalidateQueries({
        queryKey: ["masterData", "Job Role"],
      });

      if (onSuccessCallback) onSuccessCallback(data);
    },
    onError: (error) => {
      showToast(error.message || "Something went wrong", "error");
      if (onErrorCallback) onErrorCallback(error);
    },
  });
};

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

  return useMutation({
    mutationFn: async (payload) => {
      const response = await MasterRespository.createJobRole(payload);
      return response.data;
    },
    onSuccess: (data) => {
      showToast("JobRole added successfully.", "success");

      queryClient.invalidateQueries({ queryKey: ["masterData", "Job Role"] });

      if (onSuccessCallback) onSuccessCallback(data);
    },
    onError: (error) => {
      showToast(error.message || "Something went wrong", "error");
    },
  });
};

// Application Role-------------------------------------------

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

  return useMutation({
    mutationFn: async (payload) => {
      const resp = await MasterRespository.createRole(payload);
      return resp.data;
    },
    onSuccess: (data) => {
      queryClient.invalidateQueries({
        queryKey: ["masterData", "Application Role"],
      });
      showToast("Application Role added successfully", "success");
      if (onSuccessCallback) onSuccessCallback(data);
    },
    onError: (error) => {
      showToast(error.message || "Something went wrong", "error");
    },
  });
};

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

  return useMutation({
    mutationFn: async ({ id, payload }) => {
      const response = await MasterRespository.updateRoles(id, payload);
      return response.data;
    },
    onSuccess: (data, variables) => {
      queryClient.invalidateQueries({
        queryKey: ["masterData", "Application Role"],
      });
      showToast("Application Role updated successfully.", "success");

      if (onSuccessCallback) onSuccessCallback(data);
    },
    onError: (error) => {
      showToast(error.message || "Something went wrong", "error");
    },
  });
};



//-----Create work Category-------------------------------
export const useCreateWorkCategory = (onSuccessCallback) => {
  const queryClient = useQueryClient();

  return useMutation({
    mutationFn: async (payload) => {
      const resp = await MasterRespository.createWorkCategory(payload);
      return resp.data;
    },
    onSuccess: (data) => {
      queryClient.invalidateQueries({
        queryKey: ["masterData", "Work Category"],
      });
      showToast("Work Category added successfully", "success");
      if (onSuccessCallback) onSuccessCallback(data);
    },
    onError: (error) => {
      showToast(error.message || "Something went wrong", "error");
    },
  });
};

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

  return useMutation({
    mutationFn: async ({ id, payload }) => {
      const response = await MasterRespository.updateWorkCategory(id, payload);
      return response.data;
    },
    onSuccess: (data, variables) => {
      queryClient.invalidateQueries({
        queryKey: ["masterData", "Work Category"],
      });
      showToast("Work Category updated successfully.", "success");

      if (onSuccessCallback) onSuccessCallback(data);
    },
    onError: (error) => {
      showToast(error.message || "Something went wrong", "error");
    },
  });
};

//-- Contact Category---------------------------

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

  return useMutation({
    mutationFn: async (payload) => {
      const resp = await MasterRespository.createContactCategory(payload);
      return resp.data;
    },
    onSuccess: (data) => {
      queryClient.invalidateQueries({
        queryKey: ["masterData", "Contact Category"],
      });
      showToast("Contact Category added successfully", "success");
      if (onSuccessCallback) onSuccessCallback(data);
    },
    onError: (error) => {
      showToast(error.message || "Something went wrong", "error");
    },
  });
};

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

  return useMutation({
    mutationFn: async ({ id, payload }) => {
      const response = await MasterRespository.updateContactCategory(
        id,
        payload
      );
      return response.data;
    },
    onSuccess: (data, variables) => {
      queryClient.invalidateQueries({
        queryKey: ["masterData", "Contact Category"],
      });
      showToast("Contact Category updated successfully.", "success");

      if (onSuccessCallback) onSuccessCallback(data);
    },
    onError: (error) => {
      showToast(error.message || "Something went wrong", "error");
    },
  });
};

// ---------Contact Tag-------------------

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

  return useMutation({
    mutationFn: async (payload) => {
      const resp = await MasterRespository.createContactTag(payload);
      return resp.data;
    },
    onSuccess: (data) => {
      queryClient.invalidateQueries({
        queryKey: ["masterData", "Contact Tag"],
      });
      showToast("Contact Tag added successfully", "success");
      if (onSuccessCallback) onSuccessCallback(data);
    },
    onError: (error) => {
      showToast(error.message || "Something went wrong", "error");
    },
  });
};

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

  return useMutation({
    mutationFn: async ({ id, payload }) => {
      debugger;
      const response = await MasterRespository.updateContactTag(id, payload);
      return response.data;
    },
    onSuccess: (data, variables) => {
      queryClient.invalidateQueries({
        queryKey: ["masterData", "Contact Tag"],
      });
      showToast("Contact Tag updated successfully.", "success");

      if (onSuccessCallback) onSuccessCallback(data);
    },
    onError: (error) => {
      showToast(error.message || "Something went wrong", "error");
    },
  });
};

// ----------------------Expense Type------------------
export const useCreateExpenseType = (onSuccessCallback) => {
  const queryClient = useQueryClient();

  return useMutation({
    mutationFn: async (payload) => {
      const resp = await MasterRespository.createExpenseType(payload);
      return resp.data;
    },
    onSuccess: (data) => {
      queryClient.invalidateQueries({
        queryKey: ["masterData", "Expense Type"],
      });
      showToast("Expense Type added successfully", "success");
      if (onSuccessCallback) onSuccessCallback(data);
    },
    onError: (error) => {
      showToast(error.message || "Something went wrong", "error");
    },
  });
};
export const useUpdateExpenseType = (onSuccessCallback) => {
  const queryClient = useQueryClient();

  return useMutation({
    mutationFn: async ({ id, payload }) => {
      const response = await MasterRespository.updateExpenseType(id, payload);
      return response.data;
    },
    onSuccess: (data, variables) => {
      queryClient.invalidateQueries({
        queryKey: ["masterData", "Expense Type"],
      });
      showToast("Expense Type updated successfully.", "success");

      if (onSuccessCallback) onSuccessCallback(data);
    },
    onError: (error) => {
      showToast(error.message || "Something went wrong", "error");
    },
  });
};

// -----------------Payment Mode -------------

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

  return useMutation({
    mutationFn: async (payload) => {
      const resp = await MasterRespository.createPaymentMode(payload);
      return resp.data;
    },
    onSuccess: (data) => {
      queryClient.invalidateQueries({
        queryKey: ["masterData", "Payment Mode"],
      });
      showToast("Payment Mode added successfully", "success");
      if (onSuccessCallback) onSuccessCallback(data);
    },
    onError: (error) => {
      showToast(error.message || "Something went wrong", "error");
    },
  });
};

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

  return useMutation({
    mutationFn: async ({ id, payload }) => {
      const resp = await MasterRespository.updatePaymentMode(id, payload);
      return resp.data;
    },
    onSuccess: (data) => {
      queryClient.invalidateQueries({
        queryKey: ["masterData", "Payment Mode"],
      });
      showToast("Payment Mode Updated successfully", "success");
      if (onSuccessCallback) onSuccessCallback(data);
    },
    onError: (error) => {
      showToast(error.message || "Something went wrong", "error");
    },
  });
};

// Services-------------------------------

// export const useCreateService = (onSuccessCallback) => {
//   const queryClient = useQueryClient();

//   return useMutation({
//     mutationFn: async (payload) => {
//       const resp = await MasterRespository.createService(payload);
//       return resp.data; // full API response
//     },
//     onSuccess: (data) => {
//       // Invalidate & refetch service list
//       queryClient.invalidateQueries({ queryKey: ["masterData", "Services"] });

//       showToast(data?.message || "Service added successfully", "success");

//       if (onSuccessCallback) onSuccessCallback(data?.data); // pass back new service object
//     },
//     onError: (error) => {
//       showToast(error.message || "Something went wrong", "error");
//     },
//   });
// };

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

  return useMutation({
    mutationFn: async (payload) => {
      debugger;
      const resp = await MasterRespository.createService(payload);
      debugger;
      return resp.data;
    },
    onSuccess: (data) => {
      debugger;
      queryClient.invalidateQueries({ queryKey: ["masterData", "Services"] });

      showToast(data?.message || "Service added successfully", "success");

      if (onSuccessCallback) onSuccessCallback(data?.data);
    },
    onError: (error) => {
      debugger;
      showToast( error?.response?.data?.message || error?.message  || "Something went wrong", "error");
    },
  });
};

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

  return useMutation({
    mutationFn: async ({ id, payload }) => {
      const response = await MasterRespository.updateService(id, payload);
      return response; // full response since it already has { success, message, data }
    },
    onSuccess: (data, variables) => {
      queryClient.invalidateQueries({
        queryKey: ["masterData", "Services"],
      });

      showToast(data.message || "Service updated successfully.", "success");

      if (onSuccessCallback) onSuccessCallback(data);
    },
    onError: (error) => {
      showToast(error?.response?.data?.message || error?.message || "Something went wrong", "error");
    },
  });
};

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

  return useMutation({
    mutationFn: async (payload) => {
      const response = await MasterRespository.createActivityGroup(payload);
      return response;
    },
    onSuccess: (data, variables) => {
      queryClient.invalidateQueries({
        queryKey: ["groups"],
      });
  debugger
      showToast( data?.message ||
        data?.response?.data?.message || "Activity Group created successfully.",
        "success"
      );

      if (onSuccessCallback) onSuccessCallback(data);
    },
    onError: (error) => {
      showToast(error?.response?.data?.message || error?.message  || "Something went wrong", "error");
    },
  });
};
export const useUpdateActivityGroup = (onSuccessCallback) => {
  const queryClient = useQueryClient();

  return useMutation({
    mutationFn: async ({id,payload}) => {
      const response = await MasterRespository.updateActivityGrop(id,payload);
      return response;
    },
    onSuccess: (data, variables) => {
      queryClient.invalidateQueries({
        queryKey: ["groups"],
      });

      showToast(
        data?.message ||
        data?.response?.data?.message|| "Activity Group Updated successfully.",
        "success"
      );

      if (onSuccessCallback) onSuccessCallback(data);
    },
    onError: (error) => {
      showToast(error?.message || "Something went wrong", "error");
    },
  });
};
// Activity------------------------------
export const useCreateActivity = (onSuccessCallback) => {
  const queryClient = useQueryClient();

  return useMutation({
    mutationFn: async (payload) => {
      const resp = await MasterRespository.createActivity(payload);
      return resp.data;
    },
    onSuccess: (data) => {
      queryClient.invalidateQueries({ queryKey: ["activties"] });
      showToast("Activity added successfully", "success");
      if (onSuccessCallback) onSuccessCallback(data);
    },
    onError: (error) => {
      showToast(error?.response?.data?.message || error?.message || "Something went wrong", "error");
    },
  });
};

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

  return useMutation({
    mutationFn: async ({ id, payload }) => {
      const response = await MasterRespository.updateActivity(id, payload);
      return response.data;
    },
    onSuccess: (data, variables) => {
      queryClient.invalidateQueries({
        queryKey: ["activties"],
      });
      showToast("Activity updated successfully.", "success");

      if (onSuccessCallback) onSuccessCallback(data);
    },
    onError: (error) => {
      showToast(error?.response?.data?.message || error?.message || "Something went wrong", "error");
    },
  });
};

// -------------------Expense Status----------------------------------
export const useCreateExpenseStatus = (onSuccessCallback) => {
  const queryClient = useQueryClient();

  return useMutation({
    mutationFn: async (payload) => {
      const resp = await MasterRespository.createExpenseStatus(payload);
      return resp.data;
    },
    onSuccess: (data) => {
      queryClient.invalidateQueries({
        queryKey: ["masterData", "Expense Status"],
      });
      showToast("Expense Status added successfully", "success");
      if (onSuccessCallback) onSuccessCallback(data);
    },
    onError: (error) => {
      showToast(error.message || "Something went wrong", "error");
    },
  });
};
export const useUpdateExpenseStatus = (onSuccessCallback) => {
  const queryClient = useQueryClient();

  return useMutation({
    mutationFn: async ({ id, payload }) => {
      const resp = await MasterRespository.updateExepnseStatus(id, payload);
      return resp.data;
    },
    onSuccess: (data) => {
      queryClient.invalidateQueries({
        queryKey: ["masterData", "Expense Status"],
      });
      showToast("Expense Status Updated successfully", "success");
      if (onSuccessCallback) onSuccessCallback(data);
    },
    onError: (error) => {
      showToast(error.message || "Something went wrong", "error");
    },
  });
};

// --------------------Document-Category--------------------------------
export const useCreateDocumentCatgory = (onSuccessCallback) => {
  const queryClient = useQueryClient();

  return useMutation({
    mutationFn: async (payload) => {
      const resp = await MasterRespository.createDocumenyCategory(payload);
      return resp.data;
    },
    onSuccess: (data) => {
      queryClient.invalidateQueries({
        queryKey: ["masterData", "Document Category"],
      });
      queryClient.invalidateQueries({ queryKey: ["Document Category"] });
      showToast("Document Category added successfully", "success");
      if (onSuccessCallback) onSuccessCallback(data);
    },
    onError: (error) => {
      showToast(error.message || "Something went wrong", "error");
    },
  });
};

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

  return useMutation({
    mutationFn: async ({ id, payload }) => {
      const resp = await MasterRespository.updateDocumentCategory(id, payload);
      return resp.data;
    },
    onSuccess: (data) => {
      queryClient.invalidateQueries({
        queryKey: ["masterData", "Document Category"],
      });
      queryClient.invalidateQueries({ queryKey: ["Document Category"] });
      showToast("Document Category Updated successfully", "success");
      if (onSuccessCallback) onSuccessCallback(data);
    },
    onError: (error) => {
      showToast(error.message || "Something went wrong", "error");
    },
  });
};

// ------------------------------Document-Type-----------------------------------
export const useCreateDocumentType = (onSuccessCallback) => {
  const queryClient = useQueryClient();

  return useMutation({
    mutationFn: async (payload) => {
      const resp = await MasterRespository.createDocumentType(payload);
      return resp.data;
    },
    onSuccess: (data) => {
      queryClient.invalidateQueries({
        queryKey: ["masterData", "Document Type"],
      });
      showToast("Document Type added successfully", "success");
      if (onSuccessCallback) onSuccessCallback(data);
    },
    onError: (error) => {
      showToast(error.message || "Something went wrong", "error");
    },
  });
};

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

  return useMutation({
    mutationFn: async ({ id, payload }) => {
      const resp = await MasterRespository.updateDocumentType(id, payload);
      return resp.data;
    },
    onSuccess: (data) => {
      queryClient.invalidateQueries({
        queryKey: ["masterData", "Document Type"],
      });
      showToast("Document Type Updated successfully", "success");
      if (onSuccessCallback) onSuccessCallback(data);
    },
    onError: (error) => {
      showToast(error.message || "Something went wrong", "error");
    },
  });
};
// -Delete Master --------
export const useDeleteMasterItem = () => {
  const queryClient = useQueryClient();

  return useMutation({
    mutationFn: async ({ masterType, item }) => {
      const deleteFn = MasterRespository[masterType];
      if (!deleteFn) {
        throw new Error(
          `No delete strategy defined for master type: ${masterType}`
        );
      }

      await deleteFn(item.id);
      return { masterType };
    },

    onSuccess: ({ masterType }) => {
      queryClient.invalidateQueries({ queryKey: ["masterData", masterType] });

      showToast(`${masterType} deleted successfully.`, "success");
    },

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


export const useDeleteServiceGroup =()=>{
   const queryClient = useQueryClient();

  return useMutation({
    mutationFn: async (id)=>await MasterRespository.deleteActivityGroup(id),
    onSuccess: ({_,variable}) => {
    
      queryClient.invalidateQueries({ queryKey: ["groups"] });

      showToast(`Group deleted successfully.`, "success");
    },

    onError: (error) => {
      const message =
        error?.response?.data?.message ||
        error?.message ||
        "Error occurred during deletion";
      showToast(message, "error");
    },
  });
}
export const useDeleteActivity =()=>{
   const queryClient = useQueryClient();

  return useMutation({
    mutationFn: async (id)=>await MasterRespository.deleteActivity(id),
    onSuccess: ({_,variable}) => {

    
      queryClient.invalidateQueries({ queryKey: ["activties"] });

      showToast(`Acivity deleted successfully.`, "success");
    },

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