import { useMutation, useQuery } from "react-query";

import type { MutationOptions } from "@/@types/types/query.types";
import type { IServiceResponse } from "@/@types/types/strategy-service.types";
import { useHttp } from "@/hooks/useHttp";
import { useLocale } from "@/hooks/useLocale";
import {
  getServiceResponseFromStrategyResponse,
  setParametersToStrategyRunner,
} from "@/libs/helpers/strategy-service.helper";
import { useServerDataCtx } from "@/providers/server-data-provider/server-data-provider";
import { useStrategyMutation } from "@/services/eva-display/strategy/strategy-runner.service";

import { applyDiscountCouponResponseScheme } from "./payment-service.scheme";
import type {
  I3DParametersVariables,
  I3DPollResponse,
  I3DPollVariables,
  I3DResponse,
  IAllInstallmentsResponse,
  IApplyDiscountCouponResponse,
  IApplyDiscountCouponResponseResult,
  IApplyDiscountCouponVariables,
  IAvailableCampaignResponse,
  ICouponCodeLoyality,
  IDiscountCoupon,
  IGetCampaignsBody,
  IGetInstallmentsBody,
  IPayCCResponse,
} from "./payment-service.types";
import type { IPaymentInstallmentResult } from "./types/payment-installment-service.types";

export const useGetCampaignsMutation = () => {
  const http = useHttp("wl-display-api");
  const { getCultureCode } = useLocale();

  const service = (variables: IGetCampaignsBody) =>
    http.post<IAvailableCampaignResponse>(
      `/api/payment/availablecampaigns?culture=${getCultureCode()}`,
      {
        cartId: variables.cartId,
        transactionKey: variables.transactionKey,
        binNumber: variables.creditCartNumber,
      },
    );

  return useMutation(service);
};

export const useGetInstallmentsMutation = () => {
  const http = useHttp("wl-display-api");
  const { getCultureCode } = useLocale();

  const service = (variables: IGetInstallmentsBody) =>
    http.post<IPaymentInstallmentResult>(
      `/api/payment/installments?culture=${getCultureCode()}`,
      {
        cartId: variables.cartId,
        transactionKey: variables.transactionKey,
        creditCartNumber: variables.creditCartNumber,
        campaignKey: variables.campaignKey,
      },
    );

  return useMutation(service);
};

export const useGet3DParametersMutation = () => {
  const http = useHttp("wl-display-api");

  const service = (variables: I3DParametersVariables) =>
    http.post<I3DResponse>("/api/payment/get3dparameters", variables);

  return useMutation(service);
};

export const useGetPoll3DService = () => {
  const http = useHttp("wl-display-api");

  const service = ({ cartId }: I3DPollVariables) =>
    http.get<I3DPollResponse>(`/api/payment/poll3d/${cartId}`);

  return {
    get3DPollService: service,
  };
};

export const usePayCCMutation = () => {
  const http = useHttp("wl-display-api");

  const service = (variables: I3DParametersVariables) =>
    http
      .post<IPayCCResponse>("/api/payment/paycc", variables)
      .then((res) => res.data);

  return useMutation(service);
};

export const useBookMutation = () => {
  const http = useHttp("wl-booking");

  const service = (variables: {
    transactionKey: string;
    cartId: string;
    searchId: string;
  }) =>
    http.post<{
      result: boolean;
    }>("/api/booking/book", variables);

  return useMutation(service);
};

export const useBookStrategyMutation = () => {
  return useStrategyMutation<
    { bookingCode: string },
    {
      BaseCartProductRequest: {
        transactionKey: string;
        cartId: string;
        searchId: string;
        reservationNote: string;
      };
    }
  >({
    strategyKey: "bookCore",
  });
};

export const useGetMasterpassCidssRulesMutation = () => {
  const http = useHttp("wl-display-api");

  const service = (variables: { cartId: string }) =>
    http.post<any>(
      "/api/payment/getmasterpasspcidssrules?culture=tr-TR&v=2",
      variables,
    );

  return useMutation(service);
};

export const useGetMasterpassCidssRulesQuery = (
  variables: {
    cartId: string;
  },
  queryOptions?: MutationOptions<any>,
) => {
  const http = useHttp("wl-display-api");

  const service = () =>
    http.post<any>("/api/payment/getmasterpasspcidssrules", variables);

  return useQuery({
    queryFn: service,
    queryKey: "getmasterpasspcidssrules",
    ...queryOptions,
  });
};

export const useGetMasterpassInstallmentsMutation = (
  options?: MutationOptions<any>,
) => {
  const http = useHttp("wl-display-api");
  const { getCultureCode } = useLocale();

  const service = (variables: {
    amount: string;
    cardNumber: string;
    cartId: string;
    isDebitCard: boolean;
  }) =>
    http.post<any>(
      `/api/payment/getmasterpassinstallments?culture=${getCultureCode()}`,
      variables,
    );

  return useMutation({
    mutationFn: service,
    mutationKey: "getmasterpassinstallments",
    ...options,
  });
};

export const useGetMasterpassInstallmentsQuery = (variables: {
  amount: string;
  cardNumber: string;
  cartId: string;
  isDebitCard: boolean;
}) => {
  const http = useHttp("wl-display-api");
  const { getCultureCode } = useLocale();

  const service = () =>
    http.post<any>(
      `/api/payment/getmasterpassinstallments?culture=${getCultureCode()}`,
      variables,
    );

  return useQuery({
    queryFn: service,
    queryKey: "getmasterpassinstallments",
  });
};

export const useGetMasterpassDataForPhoneMutation = (
  options?: MutationOptions<any>,
) => {
  const http = useHttp("wl-display-api");

  const service = (variables: { phone: string; cartId: string }) =>
    http.post<any>("/api/payment/getmasterpassdataforphone", variables);

  return useMutation({
    mutationFn: service,
    mutationKey: "getmasterpassdataforphone",
    ...options,
  });
};

export const useGetMpToken = (options?: MutationOptions<any>) => {
  const http = useHttp("wl-display-api");

  const service = (variables: { cartId: string }) =>
    http.post<any>("/api/payment/getmptkn", variables);

  return useMutation({
    mutationFn: service,
    mutationKey: "getmptkn",
    ...options,
  });
};

export const useSetMasterpass3dPaymentStatusMutation = (
  options?: MutationOptions<any>,
) => {
  const http = useHttp("wl-display-api");

  const service = (variables: { cartId: string; status: string }) =>
    http.post<any>("/api/payment/setmasterpass3dpaymentstatus", variables);

  return useMutation({
    mutationFn: service,
    mutationKey: "setmasterpass3dpaymentstatus",
    ...options,
  });
};

export const useGetMasterpass3dPaymentStatusMutation = (
  options?: MutationOptions<any>,
) => {
  const http = useHttp("wl-display-api");

  const service = (variables: { cartId: string }) =>
    http.post<any>("/api/payment/getmasterpass3dpaymentstatus", variables);

  return useMutation({
    mutationFn: service,
    mutationKey: "getmasterpass3dpaymentstatus",
    ...options,
  });
};

export const useDomasterpassBooking = (options?: MutationOptions<any>) => {
  const http = useHttp("wl-display-api");

  const service = (variables: {
    cartId: string;
    amount: number;
    currency: string;
    balanceAmount: number;
    payToken: string;
    recurringPayToken?: any;
    cardName: string;
    cardUniqueId: string;
    installmentKey: string;
    phone: string;
    customerEmail: string;
    masterPassengerName: string;
    ecommerceAggrement: string;
    kvkkAggrement: string;
    isOther: boolean;
    is3dPayment: boolean;
  }) => http.post<any>("/api/payment/domasterpassbooking", variables);

  return useMutation({
    mutationFn: service,
    mutationKey: "domasterpassbooking",
    ...options,
  });
};

interface MasterpassBookingPayload {
  BaseCartProductRequest: {
    cartId: string;
    searchId: string;
    transactionKey: string;
  };
}

export const useMasterpassBookingMutation = (
  options?: MutationOptions<any>,
) => {
  const { strategyKeys } = useServerDataCtx();
  const http = useHttp("wl-display-api");

  const service = (variables: MasterpassBookingPayload) =>
    http
      .post(
        "/api/v1/strategy/run",
        setParametersToStrategyRunner(variables, strategyKeys.bookStrategy),
      )
      .then(
        (res) =>
          getServiceResponseFromStrategyResponse(res.data) as IServiceResponse<{
            bookingCode: string;
          }>,
      );

  return useMutation({
    mutationFn: service,
    ...options,
  });
};

export const useGetAllInstallmentsQuery = (params: {
  productKey: string;
  searchId: string;
}) => {
  const http = useHttp("wl-display-api");
  const { getCultureCode } = useLocale();

  const service = () =>
    http.post<IAllInstallmentsResponse>(
      `/api/payment/allinstallments?culture=${getCultureCode()}`,
      {
        SearchId: params.searchId,
        ProductKey: params.productKey,
      },
    );

  return useQuery({
    queryFn: service,
    queryKey: "getallinstallments",
  });
};

export const useAddCouponCodeMutation = () => {
  const http = useHttp("wl-display-api");

  const analyzeResponse = (
    response: IApplyDiscountCouponResponse,
  ): {
    isSuccess: boolean;
    message?: string;
    discountCoupons?: IDiscountCoupon[];
    loyalities?: ICouponCodeLoyality[];
  } => {
    const responseVerified =
      applyDiscountCouponResponseScheme.safeParse(response);

    if (!responseVerified.success) {
      return {
        isSuccess: false,
        message: "response not verifed",
      };
    }
    const resultData = responseVerified.data;

    if (!resultData.success) {
      return {
        isSuccess: false,
        message:
          resultData.errors?.[resultData.errors.length - 1]?.message ??
          undefined,
      };
    }

    if (
      !(resultData.result as IApplyDiscountCouponResponseResult).discountCoupons
    ) {
      return {
        isSuccess: false,
      };
    }

    return {
      isSuccess: true,
      discountCoupons: (resultData.result as IApplyDiscountCouponResponseResult)
        ?.discountCoupons,
      message:
        resultData.informations?.[resultData.informations.length - 1]
          ?.message ?? undefined,
      loyalities:
        (resultData.result as IApplyDiscountCouponResponseResult)?.loyalty
          ?.loyalities ?? [],
    };
  };

  const service = (variables: IApplyDiscountCouponVariables) =>
    http
      .post<IApplyDiscountCouponResponse>(
        "/api/discount/applydiscountcoupon",
        variables,
      )
      .then((res) => analyzeResponse(res.data));

  return useMutation({
    mutationFn: service,
    mutationKey: "applydiscountcoupon",
  });
};

export const useRemoveCouponCodeMutation = () => {
  const http = useHttp("wl-display-api");

  const service = (variables: IApplyDiscountCouponVariables) =>
    http.post<any>("/api/discount/removediscountcoupon", variables);

  return useMutation(service);
};