bookingApi

import { createApi, fetchBaseQuery } from '@reduxjs/toolkit/query/react';
import { compareDatesDesc, IParking } from './parking';
import { IBikeloop } from './bikeloop';
import { ParkingEventType } from './parkingEventType';
import { IBikeloopStatus } from './bikeloopStatus';
import { IUser } from './user';
import { IUserRequest } from './userRequest';
import { getAccessToken } from '../auth/auth';
import { IQueue } from './queue';
import { IPaymentMethodKey } from './paymentMethodKey';
import { IPaymentMethod } from './paymentMethod';
import { IPaymentMethods } from './paymentMethods';

export const bookingApi = createApi({
    reducerPath: 'bookingApi',
    baseQuery: fetchBaseQuery({
        baseUrl: 'https://api.bikeloop.io/',
        prepareHeaders: async (headers) => {
            const token = await getAccessToken();
            if (token) {
                headers.set('Authorization', `bearer ${token}`);
            }

            return headers;
        },
    }),
    tagTypes: ['PaymentMethods', 'Parking', 'UserInfo'],
    endpoints: (builder) => ({
        getParkings: builder.query<IParking[], void>({
            query: () => {
                return { url: 'parkings', params: { active: true } };
            },
            providesTags: ['Parking'],
        }),
        getParkingHistory: builder.query<IParking[], void>({
            query: () => {
                return { url: 'parkings', params: { active: false } };
            },
            transformResponse: (response) => {
                // Sort history descending
                const parkings = (response ?? []) as IParking[];

                return parkings.sort(compareDatesDesc);
            },
            providesTags: ['Parking'],
        }),
        postParking: builder.mutation<IParking, string>({
            query: (bikeloopId) => ({
                method: 'POST',
                url: 'parkings',
                body: { BikeloopId: bikeloopId },
            }),
            invalidatesTags: ['Parking'],
        }),
        cancelParking: builder.mutation<IParking, string>({
            query: (parkingId) => ({
                method: 'DELETE',
                url: `parkings/${parkingId}`,
            }),
        }),
        postParkingEvent: builder.mutation<IParking, { id: string; eventType: ParkingEventType }>({
            query: ({ id, eventType }) => ({
                method: 'POST',
                body: { type: eventType },
                url: `parkings/${id}/event`,
            }),
            invalidatesTags: ['Parking'],
        }),
        getBikeloops: builder.query<IBikeloop[], void>({
            query: () => ({
                method: 'GET',
                url: `bikeloops`,
            }),
            providesTags: ['Parking'],
        }),
        getBikeloopStatus: builder.query<IBikeloopStatus, string>({
            query: (bikeloopId) => ({
                method: 'GET',
                url: `bikeloops/${bikeloopId}/status`,
            }),
        }),
        getUser: builder.query<IUser, string | 'me'>({
            providesTags: ['UserInfo'],
            query: (userId) => ({
                method: 'GET',
                url: `users/${userId}`,
            }),
        }),
        postUser: builder.mutation<IUser, void>({
            invalidatesTags: ['UserInfo'],
            query: () => ({
                method: 'POST',
                url: `users`,
            }),
        }),
        putUser: builder.mutation<IUser, { userId: string | 'me'; userInfo: IUserRequest }>({
            invalidatesTags: ['UserInfo'],
            query: ({ userId, userInfo }) => ({
                method: 'PUT',
                url: `users/${userId}`,
                body: userInfo,
            }),
        }),
        deleteUser: builder.mutation<IUser, string | 'me'>({
            invalidatesTags: ['UserInfo'],
            query: (userId) => ({
                method: 'DELETE',
                url: `users/${userId}`,
            }),
        }),
        getQueue: builder.query<IQueue, string>({
            query: (parkingId) => ({
                method: 'GET',
                url: `parkings/${parkingId}/queue`,
            }),
        }),
        createPaymentMethodKey: builder.query<IPaymentMethodKey, void>({
            query: () => ({
                method: 'POST',
                url: `users/me/paymentmethod`,
            }),
        }),
        getPaymentMethods: builder.query<IPaymentMethods, void>({
            providesTags: ['PaymentMethods'],
            query: () => ({
                method: 'GET',
                url: `users/me/paymentmethods`,
            }),
        }),
        deletePaymentMethod: builder.mutation<void, IPaymentMethod>({
            invalidatesTags: ['PaymentMethods'],
            query: (paymentMethod) => ({
                method: 'DELETE',
                url: `users/me/paymentmethods/${paymentMethod.paymentMethodId}`,
            }),
        }),
        setPaymentMethodAsDefault: builder.mutation<void, IPaymentMethod>({
            invalidatesTags: ['PaymentMethods'],
            query: (paymentMethod) => ({
                method: 'POST',
                url: `users/me/paymentmethods/default`,
                body: {
                    id: paymentMethod.paymentMethodId,
                },
            }),
        }),
    }),
});

export const {
    useGetParkingsQuery,
    useLazyGetParkingsQuery,
    useGetParkingHistoryQuery,
    useLazyGetParkingHistoryQuery,
    useCancelParkingMutation,
    usePostParkingMutation,
    usePostParkingEventMutation,
    useGetBikeloopsQuery,
    useGetBikeloopStatusQuery,
    useLazyGetBikeloopStatusQuery,
    usePostUserMutation,
    usePutUserMutation,
    useDeleteUserMutation,
    useGetUserQuery,
    useLazyGetUserQuery,
    useGetQueueQuery,
    useLazyGetQueueQuery,
    useCreatePaymentMethodKeyQuery,
    useLazyCreatePaymentMethodKeyQuery,
    useGetPaymentMethodsQuery,
    useLazyGetPaymentMethodsQuery,
    useDeletePaymentMethodMutation,
    useSetPaymentMethodAsDefaultMutation,
} = bookingApi;