"use client";

import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
import { authApi, publicApi, userApi, type ListParams } from "@/lib/api/services";

export function useHomeQuery(params?: ListParams) {
  return useQuery({
    queryKey: ["home", params],
    queryFn: () => publicApi.home(params),
  });
}

export function useStoresQuery(params: ListParams) {
  return useQuery({
    queryKey: ["stores", params],
    queryFn: () => publicApi.stores(params),
  });
}

export function useCouponsQuery(params: ListParams) {
  return useQuery({
    queryKey: ["coupons", params],
    queryFn: () => publicApi.coupons(params),
  });
}

export function useCashbackStoresQuery(params: ListParams) {
  return useQuery({
    queryKey: ["cashback-stores", params],
    queryFn: () => publicApi.cashbackStores(params),
  });
}

export function useCashbackOffersQuery(params: ListParams) {
  return useQuery({
    queryKey: ["cashback-offers", params],
    queryFn: () => publicApi.cashbackOffers(params),
  });
}

export function useCategoriesQuery(params?: ListParams) {
  return useQuery({
    queryKey: ["categories", params],
    queryFn: () => publicApi.categories(params),
  });
}

export function useArticlesQuery(params: ListParams) {
  return useQuery({
    queryKey: ["articles", params],
    queryFn: () => publicApi.articles(params),
  });
}

export function useArticleDetailsQuery(articleId: number) {
  return useQuery({
    queryKey: ["article-details", articleId],
    queryFn: () => publicApi.articleDetails(articleId),
    enabled: Number.isFinite(articleId) && articleId > 0,
  });
}

export function useCountriesQuery() {
  return useQuery({
    queryKey: ["countries"],
    queryFn: publicApi.countries,
  });
}

export function useLanguagesQuery() {
  return useQuery({
    queryKey: ["languages"],
    queryFn: publicApi.languages,
  });
}

export function usePublicSettingsQuery(keys?: string[]) {
  return useQuery({
    queryKey: ["public-settings", keys],
    queryFn: () => publicApi.publicSettings(keys),
  });
}

export function useTrackingCodesQuery(position?: "head" | "body_end") {
  return useQuery({
    queryKey: ["tracking-codes", position],
    queryFn: () => publicApi.trackingCodes(position),
    staleTime: 60_000,
  });
}

export function useStoreDetailsQuery(storeId: number) {
  return useQuery({
    queryKey: ["store-details", storeId],
    queryFn: () => publicApi.storeDetails(storeId),
    enabled: Number.isFinite(storeId) && storeId > 0,
  });
}

export function useStoreCouponsQuery(storeId: number, params?: ListParams) {
  return useQuery({
    queryKey: ["store-coupons", storeId, params],
    queryFn: () => publicApi.storeCoupons(storeId, params),
    enabled: Number.isFinite(storeId) && storeId > 0,
  });
}

export function useStoreCashbackQuery(storeId: number, params?: ListParams) {
  return useQuery({
    queryKey: ["store-cashback", storeId, params],
    queryFn: () => publicApi.storeCashback(storeId, params),
    enabled: Number.isFinite(storeId) && storeId > 0,
  });
}

export function useCouponDetailsQuery(couponId: number) {
  return useQuery({
    queryKey: ["coupon-details", couponId],
    queryFn: () => publicApi.couponDetails(couponId),
    enabled: Number.isFinite(couponId) && couponId > 0,
  });
}

export function usePageByKeyQuery(key: string) {
  return useQuery({
    queryKey: ["page-content", key],
    queryFn: () => publicApi.pageByKey(key),
    enabled: key.length > 0,
  });
}

export function useLandingPageQuery(slug: string) {
  return useQuery({
    queryKey: ["landing-page", slug],
    queryFn: () => publicApi.landingPage(slug),
    enabled: slug.length > 0,
  });
}

export function useFavoritesQuery(enabled = true) {
  return useQuery({
    queryKey: ["favorites"],
    queryFn: () => userApi.favorites(),
    enabled,
  });
}

export function useNotificationsQuery(params: ListParams, enabled = true) {
  return useQuery({
    queryKey: ["notifications", params],
    queryFn: () => userApi.notifications(params),
    enabled,
  });
}

export function useProfileQuery(enabled = true) {
  return useQuery({
    queryKey: ["profile"],
    queryFn: userApi.profile,
    enabled,
  });
}

export function useLoginMutation() {
  return useMutation({
    mutationFn: authApi.login,
  });
}

export function useRegisterMutation() {
  return useMutation({
    mutationFn: authApi.register,
  });
}

export function useForgotPasswordMutation() {
  return useMutation({
    mutationFn: authApi.forgotPassword,
  });
}

export function useResetPasswordMutation() {
  return useMutation({
    mutationFn: authApi.resetPassword,
  });
}

export function useToggleFavoriteMutation() {
  const queryClient = useQueryClient();

  return useMutation({
    mutationFn: userApi.toggleFavorite,
    onSuccess: () => {
      void queryClient.invalidateQueries({ queryKey: ["favorites"] });
    },
  });
}

export function useCouponCopyMutation() {
  return useMutation({
    mutationFn: (couponId: number) => publicApi.couponCopy(couponId),
  });
}

export function useCouponClickMutation() {
  return useMutation({
    mutationFn: (couponId: number) => publicApi.couponClick(couponId),
  });
}

export function useLandingCopyMutation() {
  return useMutation({
    mutationFn: (slug: string) => publicApi.landingCopy(slug),
  });
}

export function useLandingCtaMutation() {
  return useMutation({
    mutationFn: (slug: string) => publicApi.landingCta(slug),
  });
}

export function useMarkNotificationReadMutation() {
  const queryClient = useQueryClient();

  return useMutation({
    mutationFn: (notificationId: number) => userApi.markNotificationRead(notificationId),
    onSuccess: () => {
      void queryClient.invalidateQueries({ queryKey: ["notifications"] });
    },
  });
}

export function useUpdateProfileMutation() {
  const queryClient = useQueryClient();

  return useMutation({
    mutationFn: userApi.updateProfile,
    onSuccess: () => {
      void queryClient.invalidateQueries({ queryKey: ["profile"] });
    },
  });
}

export function useUpdateLanguageMutation() {
  const queryClient = useQueryClient();

  return useMutation({
    mutationFn: userApi.updateLanguage,
    onSuccess: () => {
      void queryClient.invalidateQueries({ queryKey: ["profile"] });
    },
  });
}

export function useUpdateCountryMutation() {
  const queryClient = useQueryClient();

  return useMutation({
    mutationFn: userApi.updateCountry,
    onSuccess: () => {
      void queryClient.invalidateQueries({ queryKey: ["profile"] });
    },
  });
}

export function useUpdatePasswordMutation() {
  return useMutation({
    mutationFn: userApi.updatePassword,
  });
}

export function useActivateCashbackMutation() {
  return useMutation({
    mutationFn: ({ storeId, cashbackOfferId }: { storeId: number; cashbackOfferId?: number }) =>
      userApi.activateCashback(storeId, cashbackOfferId),
  });
}

export function useCashbackHistoryQuery(params: ListParams, enabled = true) {
  return useQuery({
    queryKey: ["cashback-history", params],
    queryFn: () => userApi.cashbackHistory(params),
    enabled,
  });
}

export function useCashbackSummaryQuery(enabled = true) {
  return useQuery({
    queryKey: ["cashback-summary"],
    queryFn: () => userApi.cashbackSummary(),
    enabled,
  });
}

export function useBankAccountsQuery(enabled = true) {
  return useQuery({
    queryKey: ["bank-accounts"],
    queryFn: () => userApi.bankAccounts(),
    enabled,
  });
}

export function useAddBankAccountMutation() {
  const queryClient = useQueryClient();

  return useMutation({
    mutationFn: userApi.addBankAccount,
    onSuccess: () => {
      void queryClient.invalidateQueries({ queryKey: ["bank-accounts"] });
    },
  });
}

export function useUpdateBankAccountMutation() {
  const queryClient = useQueryClient();

  return useMutation({
    mutationFn: ({ bankAccountId, payload }: {
      bankAccountId: number;
      payload: {
        bank_name?: string;
        account_holder_name?: string;
        iban?: string;
        account_number?: string;
        swift_code?: string;
        currency_code?: string;
        is_default?: boolean;
        is_active?: boolean;
      };
    }) => userApi.updateBankAccount(bankAccountId, payload),
    onSuccess: () => {
      void queryClient.invalidateQueries({ queryKey: ["bank-accounts"] });
    },
  });
}

export function useDeleteBankAccountMutation() {
  const queryClient = useQueryClient();

  return useMutation({
    mutationFn: (bankAccountId: number) => userApi.deleteBankAccount(bankAccountId),
    onSuccess: () => {
      void queryClient.invalidateQueries({ queryKey: ["bank-accounts"] });
    },
  });
}

export function useWithdrawalsQuery(params: ListParams, enabled = true) {
  return useQuery({
    queryKey: ["withdrawals", params],
    queryFn: () => userApi.withdrawals(params),
    enabled,
  });
}

export function useWalletTransactionsQuery(params: ListParams, enabled = true) {
  return useQuery({
    queryKey: ["wallet-transactions", params],
    queryFn: () => userApi.walletTransactions(params),
    enabled,
  });
}

export function useRequestWithdrawalMutation() {
  const queryClient = useQueryClient();

  return useMutation({
    mutationFn: userApi.requestWithdrawal,
    onSuccess: () => {
      void queryClient.invalidateQueries({ queryKey: ["withdrawals"] });
      void queryClient.invalidateQueries({ queryKey: ["cashback-summary"] });
      void queryClient.invalidateQueries({ queryKey: ["profile"] });
    },
  });
}

export function useAffiliateSummaryQuery(enabled = true) {
  return useQuery({
    queryKey: ["affiliate-summary"],
    queryFn: () => userApi.affiliateSummary(),
    enabled,
  });
}