import { FavoriteItem, Product } from '../../types';
import { buildClientRequestUrl } from '../../utils';
import { api } from './api';
import { wishlist } from '../urls';

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

interface GetFavoritesParams {
  limit?: number;
  page?: number;
}

interface GetStockParams {
  limit?: number;
  page?: number;
}

interface GetFavoritesResponse {
  next?: string | null;
  previous?: string | null;
  count: number;
  results: FavoriteItem[];
}

interface AddFavoriteResponse {
  pk: number;
  product: number;
}

interface RemoteFavoriteResponse {
  success: boolean;
}

interface AddStockAlertRequest {
  productPk: number;
  email?: string;
}

interface AddStockAlertResponse {
  pk: number;
  product: number;
}

interface GetStockAlertsResponse {
  count: number;
  results: FavoriteItem[];
  next?: string | null;
  previous?: string | null;
}

interface DeleteStockAlertResponse {
  success: boolean;
}
interface GetCollectionOOSResponse {
  count: number;
  results: CollectionItem[];
  next?: string | null;
  previous?: string | null;
}

export interface CollectionItem {
  pk: number;
  status: string;
  name: string;
  slug: string;
  items: Product[];
  public_url: string;
}

export interface CollectionItemsResponse {
  pk: number;
  product: Product;
}

export const wishlistApi = api.injectEndpoints({
  endpoints: (build) => ({
    getFavorites: build.query<GetFavoritesResponse, GetFavoritesParams>({
      query: ({ limit, page }) =>
        buildClientRequestUrl(wishlist.getFavorites({ page, limit })),
      providesTags: ['Favorite']
    }),
    addFavorite: build.mutation<AddFavoriteResponse, number>({
      query: (productPk: number) => ({
        url: buildClientRequestUrl(wishlist.addFavorite, {
          useFormData: true
        }),
        method: 'POST',
        body: {
          product: productPk
        }
      }),
      invalidatesTags: (_, error) => (error ? [] : ['Favorite'])
    }),
    removeFavorite: build.mutation<RemoteFavoriteResponse, number>({
      query: (favPk: number) => ({
        url: buildClientRequestUrl(wishlist.removeFavorite(favPk)),
        method: 'DELETE'
      }),
      invalidatesTags: (_, error) => (error ? [] : ['Favorite'])
    }),
    addStockAlert: build.mutation<AddStockAlertResponse, AddStockAlertRequest>({
      query: ({ productPk, email }) => ({
        url: buildClientRequestUrl(wishlist.addStockAlert, {
          useFormData: true
        }),
        method: 'POST',
        body: {
          product: productPk,
          ...(email ? { email } : {})
        }
      })
    }),
    getStockAlerts: build.query<GetStockAlertsResponse, GetStockParams>({
      query: ({ page, limit }) =>
        buildClientRequestUrl(wishlist.getStockAlerts({ page, limit })),
      providesTags: ['StockAlert']
    }),
    deleteStockAlert: build.mutation<DeleteStockAlertResponse, number>({
      query: (alertPk: number) => ({
        url: buildClientRequestUrl(wishlist.deleteStockAlert(alertPk)),
        method: 'DELETE'
      }),
      invalidatesTags: ['StockAlert']
    }),
    setCollectionOOS: build.mutation<
      CollectionItem,
      { name: string; status: string }
    >({
      query: ({ name, status = 'private' }) => ({
        url: buildClientRequestUrl(wishlist.setCollection(), {
          contentType: 'application/json'
        }),
        method: 'POST',
        body: {
          name,
          status
        }
      })
    }),
    setCollectionItems: build.mutation<
      CollectionItemsResponse,
      { usercollection_id: number; product_id: number | number[] }
    >({
      query: ({ usercollection_id, product_id }) => ({
        url: buildClientRequestUrl(wishlist.setCollectionItems, {
          contentType: 'application/json'
        }),
        method: 'POST',
        body: {
          usercollection_id,
          product_id
        }
      })
    }),
    getCollectionsOOS: build.query<
      GetCollectionOOSResponse,
      { search?: string; product_id?: number }
    >({
      query: ({ search, product_id }) => ({
        url: buildClientRequestUrl(wishlist.getCollections(search, product_id))
      })
    }),
    deleteCollection: build.query<void, number>({
      query: (pk: number) => ({
        url: buildClientRequestUrl(wishlist.deleteCollection(pk)),
        method: 'DELETE'
      })
    }),
    deleteCollectionItem: build.query<void, number>({
      query: (pk: number) => ({
        url: buildClientRequestUrl(wishlist.deleteCollectionItem(pk)),
        method: 'DELETE'
      })
    }),
    editCollection: build.mutation<
      CollectionItem,
      { name: string; pk: number }
    >({
      query: ({ name, pk }) => ({
        url: buildClientRequestUrl(wishlist.editCollection(pk), {
          contentType: 'application/json'
        }),
        method: 'PATCH',
        body: {
          name
        }
      })
    })
  }),
  overrideExisting: true
});

export const {
  useGetFavoritesQuery,
  useAddFavoriteMutation,
  useRemoveFavoriteMutation,
  useAddStockAlertMutation,
  useGetStockAlertsQuery,
  useDeleteStockAlertMutation,
  useSetCollectionOOSMutation,
  useSetCollectionItemsMutation,
  useGetCollectionsOOSQuery,
  useLazyGetCollectionsOOSQuery,
  useLazyDeleteCollectionQuery,
  useEditCollectionMutation,
  useLazyDeleteCollectionItemQuery
} = wishlistApi;