web/apps/scandic-web/stores/select-rate/helper.ts

import { AvailabilityEnum } from "@/types/components/hotelReservation/selectHotel/selectHotel"
import type { RoomConfiguration } from "@/types/trpc/routers/hotel/roomAvailability"

/**
 * Get the lowest priced room for each room type that appears more than once.
 */

export function filterDuplicateRoomTypesByLowestPrice(
  roomConfigurations: RoomConfiguration[]
): RoomConfiguration[] {
  const roomTypeCount = roomConfigurations.reduce<Record<string, number>>(
    (roomTypeTally, currentRoom) => {
      const currentRoomType = currentRoom.roomType
      const currentCount = roomTypeTally[currentRoomType] || 0

      return {
        ...roomTypeTally,
        [currentRoomType]: currentCount + 1,
      }
    },
    {}
  )

  const duplicateRoomTypes = new Set(
    Object.keys(roomTypeCount).filter((roomType) => roomTypeCount[roomType] > 1)
  )

  const roomMap = new Map()

  roomConfigurations.forEach((room) => {
    const { roomType, products, status } = room

    if (!duplicateRoomTypes.has(roomType)) {
      roomMap.set(roomType, room)
      return
    }

    const previousRoom = roomMap.get(roomType)

    // Prioritize 'Available' status
    if (
      status === AvailabilityEnum.Available &&
      previousRoom?.status === AvailabilityEnum.NotAvailable
    ) {
      roomMap.set(roomType, room)
      return
    }

    if (
      status === AvailabilityEnum.NotAvailable &&
      previousRoom?.status === AvailabilityEnum.Available
    ) {
      return
    }

    if (previousRoom) {
      products.forEach((product) => {
        const publicProduct = product?.public || {
          requestedPrice: null,
          localPrice: null,
        }
        const memberProduct = product?.member || {
          requestedPrice: null,
          localPrice: null,
        }

        const {
          requestedPrice: publicRequestedPrice,
          localPrice: publicLocalPrice,
        } = publicProduct
        const {
          requestedPrice: memberRequestedPrice,
          localPrice: memberLocalPrice,
        } = memberProduct

        const previousLowest = roomMap.get(roomType)

        const currentRequestedPrice = Math.min(
          Number(publicRequestedPrice?.pricePerNight) ?? Infinity,
          Number(memberRequestedPrice?.pricePerNight) ?? Infinity
        )
        const currentLocalPrice = Math.min(
          Number(publicLocalPrice?.pricePerNight) ?? Infinity,
          Number(memberLocalPrice?.pricePerNight) ?? Infinity
        )

        if (
          !previousLowest ||
          currentRequestedPrice <
            Math.min(
              Number(
                previousLowest.products[0].public?.requestedPrice?.pricePerNight
              ) ?? Infinity,
              Number(
                previousLowest.products[0].member?.requestedPrice?.pricePerNight
              ) ?? Infinity
            ) ||
          (currentRequestedPrice ===
            Math.min(
              Number(
                previousLowest.products[0].public?.requestedPrice?.pricePerNight
              ) ?? Infinity,
              Number(
                previousLowest.products[0].member?.requestedPrice?.pricePerNight
              ) ?? Infinity
            ) &&
            currentLocalPrice <
              Math.min(
                Number(
                  previousLowest.products[0].public?.localPrice?.pricePerNight
                ) ?? Infinity,
                Number(
                  previousLowest.products[0].member?.localPrice?.pricePerNight
                ) ?? Infinity
              ))
        ) {
          roomMap.set(roomType, room)
        }
      })
    } else {
      roomMap.set(roomType, room)
    }
  })

  return Array.from(roomMap.values())
}