"use client";

import {
  useMutation,
  useQuery,
  useQueryClient,
} from "@tanstack/react-query";

import {
  createMasterDataCategory,
  createMasterDataIndicator,
  deleteMasterDataCategory,
  deleteMasterDataIndicator,
  getMasterDataCategories,
  getMasterDataCategoryById,
  getMasterDataIndicators,
  getMasterDataStatuses,
  updateMasterDataCategory,
  updateMasterDataIndicator,
} from "../service/master-data-service";
import type {
  MasterDataFormValue,
  MasterDataTab,
} from "../types/master-data-types";

export const masterDataKeys = {
  all: ["admin-master-data"] as const,
  categories: ["admin-master-data", "categories"] as const,
  category: (id: number) =>
    ["admin-master-data", "categories", id] as const,
  indicators: ["admin-master-data", "indicators"] as const,
  statuses: ["admin-master-data", "statuses"] as const,
};

export function useMasterDataCategories(enabled = true) {
  return useQuery({
    queryKey: masterDataKeys.categories,
    queryFn: getMasterDataCategories,
    enabled,
  });
}

export function useMasterDataCategoryById(
  id: number | null,
  enabled = true,
) {
  return useQuery({
    queryKey: masterDataKeys.category(id ?? 0),
    queryFn: () => getMasterDataCategoryById(id as number),
    enabled: enabled && id !== null,
  });
}

export function useMasterDataIndicators(enabled = true) {
  return useQuery({
    queryKey: masterDataKeys.indicators,
    queryFn: getMasterDataIndicators,
    enabled,
  });
}

export function useMasterDataStatuses(enabled = true) {
  return useQuery({
    queryKey: masterDataKeys.statuses,
    queryFn: getMasterDataStatuses,
    enabled,
  });
}

export function useCreateMasterDataItem(tab: MasterDataTab) {
  const queryClient = useQueryClient();

  return useMutation({
    mutationFn: async (value: MasterDataFormValue) => {
      if (tab === "categories") {
        return createMasterDataCategory(value);
      }

      if (tab === "indicators") {
        return createMasterDataIndicator(value);
      }

      throw new Error(
        "Status create API is not connected yet.",
      );
    },

    onSuccess: async () => {
      if (tab === "categories") {
        await queryClient.invalidateQueries({
          queryKey: masterDataKeys.categories,
        });
      }

      if (tab === "indicators") {
        await queryClient.invalidateQueries({
          queryKey: masterDataKeys.indicators,
        });
      }
    },
  });
}

export function useUpdateMasterDataItem(tab: MasterDataTab) {
  const queryClient = useQueryClient();

  return useMutation({
    mutationFn: async ({
      id,
      value,
    }: {
      id: number;
      value: MasterDataFormValue;
    }) => {
      if (tab === "categories") {
        return updateMasterDataCategory(id, value);
      }

      if (tab === "indicators") {
        return updateMasterDataIndicator(id, value);
      }

      throw new Error(
        "Status update API is not connected yet.",
      );
    },

    onSuccess: async (_data, variables) => {
      if (tab === "categories") {
        await Promise.all([
          queryClient.invalidateQueries({
            queryKey: masterDataKeys.categories,
          }),
          queryClient.invalidateQueries({
            queryKey: masterDataKeys.category(variables.id),
          }),
        ]);
      }

      if (tab === "indicators") {
        await queryClient.invalidateQueries({
          queryKey: masterDataKeys.indicators,
        });
      }
    },
  });
}

export function useDeleteMasterDataItem(tab: MasterDataTab) {
  const queryClient = useQueryClient();

  return useMutation({
    mutationFn: async (id: number) => {
      if (tab === "categories") {
        return deleteMasterDataCategory(id);
      }

      if (tab === "indicators") {
        return deleteMasterDataIndicator(id);
      }

      throw new Error(
        "Status delete API is not connected yet.",
      );
    },

    onSuccess: async () => {
      if (tab === "categories") {
        await queryClient.invalidateQueries({
          queryKey: masterDataKeys.categories,
        });
      }

      if (tab === "indicators") {
        await queryClient.invalidateQueries({
          queryKey: masterDataKeys.indicators,
        });
      }
    },
  });
}