import { api } from '@akinon/next/data/client/api';
import { buildClientRequestUrl } from '@akinon/next/utils';
import { setPaymentStepBusy } from '@akinon/next/redux/reducers/checkout';
import type { RewardItem } from '../types/payment.types';

export interface MasterpassRestTokenRequest {
  three_d?: boolean;
}

export interface MasterpassRestTokenResponse {
  msisdn: string;
  token: string;
  extras: {
    bank_ica: string | null;
    terminal_group_id: string;
  };
}

export interface SetMasterpassRestBinNumberRequest {
  is_masterpass_stored_card: boolean;
  bin_number: string;
}

export interface CheckoutMasterpassInstallmentRequest {
  installment: number;
}

export interface PrepareMasterpassOrderRequest {
  use_three_d: boolean;
}

export interface FinalizeMasterpassOrderRequest {
  responseCode: string;
  token: string;
  three_d_secure: boolean;
  transactionType:
    | 'DIRECT_PURCHASE'
    | 'DIRECT_PURCHASE_3D'
    | 'PURCHASE'
    | 'PURCHASE_3D'
    | 'REGISTER_AND_PURCHASE'
    | 'REGISTER_AND_PURCHASE_3D';
}

export interface CheckoutMasterpassInstallmentResponse {
  context_list: Array<{
    page_context: any;
    page_name: string;
    page_slug: string;
  }>;
  template_name: string;
  errors: any;
  pre_order: any;
}

export interface PrepareMasterpassOrderResponse {
  context_list: Array<{
    page_context: {
      msisdn: string;
      order_no: string;
      three_d: boolean;
      extras: {
        user_id: string;
        bank_ica: string | null;
        additional_fields?: any;
      };
    };
    page_name: string;
    page_slug: string;
  }>;
  template_name: string;
  errors: any;
  pre_order: any;
}

export interface FinalizeMasterpassOrderResponse {
  context_list: Array<{
    page_context: any;
    page_name: string;
    page_slug: string;
  }>;
  template_name: string;
  errors: any;
  pre_order: any;
}

interface Installment {
  pk: number;
  installment_count: number;
  label: string;
  price_with_accrued_interest: string;
  monthly_price_with_accrued_interest: string;
}

interface CardType {
  name: string;
  slug: string;
  logo: string;
}

export interface QueryMasterpassRewardsRequest {
  card_alias: string;
}

export interface QueryMasterpassRewardsResponse {
  context_list: Array<{
    page_context: {
      rewards: RewardItem[];
    };
    page_name: string;
    page_slug: string;
  }>;
  template_name: string;
  errors: any;
  pre_order: any;
}

export interface SelectMasterpassRewardsRequest {
  special: string;
  general: string;
}

export interface SelectMasterpassRewardsResponse {
  context_list: Array<{
    page_context: any;
    page_name: string;
    page_slug: string;
  }>;
  template_name: string;
  errors: any;
  pre_order: any;
}

export interface SetMasterpassRestBinNumberResponse {
  context_list: Array<{
    page_context: {
      installments: Installment[];
      card_type: CardType;
      installment_messages: any[];
    };
    page_name: string;
    page_slug: string;
  }>;
  template_name: string;
  errors: any;
  pre_order: any;
}

export const masterpassRestApi = api.injectEndpoints({
  endpoints: (build) => ({
    getMasterpassRestToken: build.query<
      MasterpassRestTokenResponse,
      MasterpassRestTokenRequest
    >({
      query: (arg) => {
        const baseUrl = '/orders/masterpass-rest-token/';
        const url =
          arg?.three_d === false ? `${baseUrl}?three_d=false` : baseUrl;
        return {
          url: buildClientRequestUrl(url, {
            useFormData: true
          })
        };
      },
      keepUnusedDataFor: 60,
      async onQueryStarted(_, { dispatch, queryFulfilled }) {
        dispatch(setPaymentStepBusy(true));
        await queryFulfilled;
        dispatch(setPaymentStepBusy(false));
      }
    }),
    setMasterpassRestBinNumber: build.mutation<
      SetMasterpassRestBinNumberResponse,
      SetMasterpassRestBinNumberRequest
    >({
      query: (arg) => ({
        url: buildClientRequestUrl('/orders/checkout/', {
          useFormData: true
        }),
        method: 'POST',
        params: {
          page: 'MasterpassRestBinNumberPage'
        },
        body: {
          is_masterpass_stored_card: arg.is_masterpass_stored_card,
          bin_number: arg.bin_number
        }
      }),
      async onQueryStarted(_, { dispatch, queryFulfilled }) {
        dispatch(setPaymentStepBusy(true));
        await queryFulfilled;
        dispatch(setPaymentStepBusy(false));
      }
    }),
    checkoutMasterpassInstallment: build.mutation<
      CheckoutMasterpassInstallmentResponse,
      CheckoutMasterpassInstallmentRequest
    >({
      query: (arg) => ({
        url: buildClientRequestUrl('/orders/checkout/', {
          useFormData: true
        }),
        method: 'POST',
        params: {
          page: 'MasterpassRestInstallmentPage'
        },
        body: {
          installment: arg.installment
        }
      }),
      async onQueryStarted(_, { dispatch, queryFulfilled }) {
        dispatch(setPaymentStepBusy(true));
        await queryFulfilled;
        dispatch(setPaymentStepBusy(false));
      }
    }),
    prepareMasterpassOrder: build.mutation<
      PrepareMasterpassOrderResponse,
      PrepareMasterpassOrderRequest
    >({
      query: (arg) => ({
        url: buildClientRequestUrl('/orders/checkout/', {
          useFormData: true
        }),
        method: 'POST',
        params: {
          page: 'MasterpassRestOrderNoPage'
        },
        body: {
          use_three_d: arg.use_three_d
        }
      }),
      async onQueryStarted(_, { dispatch, queryFulfilled }) {
        dispatch(setPaymentStepBusy(true));
        await queryFulfilled;
        dispatch(setPaymentStepBusy(false));
      }
    }),
    queryMasterpassRewards: build.mutation<
      QueryMasterpassRewardsResponse,
      QueryMasterpassRewardsRequest
    >({
      query: (arg) => ({
        url: buildClientRequestUrl('/orders/checkout/', {
          useFormData: true
        }),
        method: 'POST',
        params: {
          page: 'MasterpassRestRewardListPage'
        },
        body: {
          card_alias: arg.card_alias
        }
      }),
      async onQueryStarted(_, { dispatch, queryFulfilled }) {
        dispatch(setPaymentStepBusy(true));
        await queryFulfilled;
        dispatch(setPaymentStepBusy(false));
      }
    }),
    selectMasterpassRewards: build.mutation<
      SelectMasterpassRewardsResponse,
      SelectMasterpassRewardsRequest
    >({
      query: (arg) => ({
        url: buildClientRequestUrl('/orders/checkout/', {
          useFormData: true
        }),
        method: 'POST',
        params: {
          page: 'MasterpassRestRewardSelectionPage'
        },
        body: {
          special: arg.special,
          general: arg.general
        }
      }),
      async onQueryStarted(_, { dispatch, queryFulfilled }) {
        dispatch(setPaymentStepBusy(true));
        await queryFulfilled;
        dispatch(setPaymentStepBusy(false));
      }
    }),
    finalizeMasterpassOrder: build.mutation<
      FinalizeMasterpassOrderResponse,
      FinalizeMasterpassOrderRequest
    >({
      query: (arg) => ({
        url: buildClientRequestUrl('/orders/checkout/', {
          useFormData: true
        }),
        method: 'POST',
        params: {
          page: 'MasterpassRestCompletePage',
          responseCode: arg.responseCode,
          token: arg.token,
          three_d_secure: arg.three_d_secure
        },
        body: {
          token: arg.token,
          responseCode: arg.responseCode,
          transactionType: arg.transactionType,
          three_d_secure: arg.three_d_secure
        }
      }),
      async onQueryStarted(_, { dispatch, queryFulfilled }) {
        dispatch(setPaymentStepBusy(true));
        await queryFulfilled;
        dispatch(setPaymentStepBusy(false));
      }
    })
  })
});

export const {
  useGetMasterpassRestTokenQuery,
  useLazyGetMasterpassRestTokenQuery,
  useSetMasterpassRestBinNumberMutation,
  useCheckoutMasterpassInstallmentMutation,
  usePrepareMasterpassOrderMutation,
  useFinalizeMasterpassOrderMutation,
  useQueryMasterpassRewardsMutation,
  useSelectMasterpassRewardsMutation
} = masterpassRestApi;