import { api } from './api';
import { Basket } from '../../types';
import { buildClientRequestUrl } from '../../utils';
import { basket } from '../urls';

export type UpdateQuantityResponse = {
  basket: Basket;
  osessionid: string;
};

export type UpdateQuantityRequest = {
  product: number;
  quantity: number;
  attributes: any;
};

export const basketApi = api.injectEndpoints({
  endpoints: (build) => ({
    getBasket: build.query<Basket, void>({
      query: () =>
        buildClientRequestUrl(basket.getBasket, {
          contentType: 'application/json'
        }),
      transformResponse: (response: { basket: Basket }) => response.basket,
      providesTags: ['Basket']
    }),
    getMiniBasket: build.query<
      { pk: number | null; total_quantity: number },
      void
    >({
      query: () =>
        buildClientRequestUrl(basket.getMiniBasket, {
          contentType: 'application/json'
        }),
      providesTags: ['MiniBasket']
    }),
    getMiniBasketDetail: build.query<
      { pk: number | null; total_quantity: number },
      { namespace: string }
    >({
      query: ({ namespace }) =>
        buildClientRequestUrl(basket.getMiniBasketDetail(namespace), {
          contentType: 'application/json'
        }),
      providesTags: ['MiniBasket']
    }),
    getBasketDetail: build.query<Basket, { namespace: string }>({
      query: ({ namespace }) =>
        buildClientRequestUrl(basket.getBasketDetail(namespace)),
      transformResponse: (response: { basket: Basket }) => response.basket,
      providesTags: ['MultiBasket']
    }),
    getAllBaskets: build.query<Basket[], void>({
      query: () =>
        buildClientRequestUrl(basket.getAllBaskets, {
          contentType: 'application/json'
        }),
      transformResponse: (response: { baskets: Basket[] }) => response.baskets,
      providesTags: ['MultiBasket']
    }),
    removeBasket: build.mutation<Basket, { pk: number }>({
      query: ({ pk }) => ({
        url: buildClientRequestUrl(basket.removeBasket(pk), {
          contentType: 'application/json'
        }),
        method: 'DELETE',
        body: { pk }
      }),
      invalidatesTags: ['MultiBasket', 'Basket', 'MiniBasket']
    }),
    selectMainBasket: build.mutation<Basket, { pk: number }>({
      query: ({ pk }) => ({
        url: buildClientRequestUrl(basket.selectMainBasket(pk), {
          contentType: 'application/json'
        }),
        method: 'POST',
        body: { pk }
      }),
      transformResponse: (response: { baskets: Basket }) => response.baskets,
      invalidatesTags: ['MultiBasket', 'Basket', 'MiniBasket']
    }),
    selectNameSpaceMainBasket: build.mutation<Basket, { namespace: string }>({
      query: ({ namespace }) => ({
        url: buildClientRequestUrl(
          basket.selectNameSpaceMainBasket(namespace),
          {
            contentType: 'application/json'
          }
        ),
        method: 'POST',
        body: { namespace }
      }),
      transformResponse: (response: { baskets: Basket }) => response.baskets,
      invalidatesTags: ['MultiBasket', 'Basket', 'MiniBasket']
    }),
    updateQuantity: build.mutation<
      UpdateQuantityResponse,
      UpdateQuantityRequest
    >({
      query: (body) => ({
        url: buildClientRequestUrl(basket.getBasket, {
          contentType: 'application/json'
        }),
        method: 'PUT',
        body
      }),
      async onQueryStarted(_, { dispatch, queryFulfilled }) {
        try {
          const { data } = await queryFulfilled;

          dispatch(
            basketApi.util.updateQueryData(
              'getBasket',
              undefined,
              () => data.basket
            )
          );

          if (data.basket.namespace) {
            dispatch(
              basketApi.util.updateQueryData(
                'getBasketDetail',
                { namespace: data.basket.namespace },
                () => data.basket
              )
            );
          }

          dispatch(
            basketApi.util.updateQueryData(
              'getAllBaskets',
              undefined,
              (baskets) => {
                if (!baskets) return baskets;

                return baskets.map((basket) =>
                  basket.pk === data.basket.pk ? data.basket : basket
                );
              }
            )
          );
        } catch (error) {
          console.error('Error updating quantity:', error);
        }
      },
      invalidatesTags: ['MultiBasket', 'Basket', 'MiniBasket']
    }),
    clearBasket: build.mutation<Basket, void>({
      query: (body) => ({
        url: buildClientRequestUrl(basket.getBasket, {
          contentType: 'application/json'
        }),
        method: 'DELETE',
        body
      }),
      transformResponse: (response: { basket: Basket }) => response.basket,
      invalidatesTags: ['Basket', 'MiniBasket', 'MiniBasket']
    }),
    applyVoucherCode: build.mutation<Basket, { voucher_code: string }>({
      query: (body) => ({
        url: buildClientRequestUrl(basket.getBasket, {
          contentType: 'application/json'
        }),
        method: 'PATCH',
        body
      }),
      transformResponse: (response: { basket: Basket }) => response.basket
    }),
    removeVoucherCode: build.mutation<Basket, void>({
      query: () => ({
        url: buildClientRequestUrl(basket.getBasket, {
          contentType: 'application/json'
        }),
        method: 'PATCH',
        body: {
          remove_voucher_code: true
        }
      }),
      transformResponse: (response: { basket: Basket }) => response.basket
    })
  }),
  overrideExisting: true
});

export const {
  useGetBasketQuery,
  useGetMiniBasketQuery,
  useGetMiniBasketDetailQuery,
  useLazyGetBasketDetailQuery,
  useGetAllBasketsQuery,
  useRemoveBasketMutation,
  useSelectMainBasketMutation,
  useSelectNameSpaceMainBasketMutation,
  useUpdateQuantityMutation,
  useClearBasketMutation,
  useApplyVoucherCodeMutation,
  useRemoveVoucherCodeMutation
} = basketApi;