web/components/HotelReservation/SelectRate/utils.ts

import { trpc } from "@/lib/trpc/client"

import { RoomPackageCodeEnum } from "@/types/components/hotelReservation/selectRate/roomFilter"
import type { Child } from "@/types/components/hotelReservation/selectRate/selectRate"
import type { RoomsAvailability } from "@/types/trpc/routers/hotel/roomAvailability"
import type { Lang } from "@/constants/languages"

export function combineRoomAvailabilities(
  availabilityResults: PromiseSettledResult<RoomsAvailability | null>[]
) {
  return availabilityResults.reduce<RoomsAvailability | null>((acc, result) => {
    if (result.status === "fulfilled" && result.value) {
      if (acc) {
        acc.roomConfigurations.push(...result.value.roomConfigurations)
      } else {
        acc = result.value
      }
    }

    // Ping monitoring about fail?
    if (result.status === "rejected") {
      console.info(`RoomAvailability fetch failed`)
      console.error(result.reason)
    }

    return acc
  }, null)
}

export function getRates(
  rateDefinitions: RoomsAvailability["rateDefinitions"]
) {
  return {
    change: rateDefinitions.filter(
      (rate) => rate.cancellationRule === "Changeable"
    ),
    flex: rateDefinitions.filter(
      (rate) => rate.cancellationRule === "CancellableBefore6PM"
    ),
    save: rateDefinitions.filter(
      (rate) => rate.cancellationRule === "NotCancellable"
    ),
  }
}

export function useRoomsAvailability(
  uniqueAdultsCount: number[],
  hotelId: number,
  fromDateString: string,
  toDateString: string,
  lang: Lang,
  childArray?: Child[]
) {
  const returnValue =
    trpc.hotel.availability.roomsCombinedAvailability.useQuery({
      hotelId,
      roomStayStartDate: fromDateString,
      roomStayEndDate: toDateString,
      uniqueAdultsCount,
      childArray,
      lang,
    })

  const combinedAvailability = returnValue.data?.length
    ? combineRoomAvailabilities(
        returnValue.data as PromiseSettledResult<RoomsAvailability | null>[]
      )
    : null

  return {
    ...returnValue,
    data: combinedAvailability,
  }
}

export function useHotelPackages(
  adultArray: number[],
  childArray: Child[] | undefined,
  fromDateString: string,
  toDateString: string,
  hotelId: number,
  lang: Lang
) {
  return trpc.hotel.packages.get.useQuery({
    adults: adultArray[0], // Using the first adult count
    children: childArray ? childArray.length : undefined,
    endDate: toDateString,
    hotelId: hotelId.toString(),
    packageCodes: [
      RoomPackageCodeEnum.ACCESSIBILITY_ROOM,
      RoomPackageCodeEnum.PET_ROOM,
      RoomPackageCodeEnum.ALLERGY_ROOM,
    ],
    startDate: fromDateString,
    lang: lang,
  })
}