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

import { produce } from "immer"
import { ReadonlyURLSearchParams } from "next/navigation"
import { useContext } from "react"
import { create, useStore } from "zustand"

import { filterDuplicateRoomTypesByLowestPrice } from "@/stores/select-rate/helper"

import { RatesContext } from "@/contexts/Rates"

import { AvailabilityEnum } from "@/types/components/hotelReservation/selectHotel/selectHotel"
import { RoomPackageCodeEnum } from "@/types/components/hotelReservation/selectRate/roomFilter"
import { RateTypeEnum } from "@/types/enums/rateType"
import type { InitialState, RatesState } from "@/types/stores/rates"
import type { RoomConfiguration } from "@/types/trpc/routers/hotel/roomAvailability"

const statusLookup = {
  [AvailabilityEnum.Available]: 1,
  [AvailabilityEnum.NotAvailable]: 2,
}

function findSelectedRate(
  rateCode: string,
  roomTypeCode: string,
  rooms: RoomConfiguration[]
) {
  return rooms.find(
    (room) =>
      room.roomTypeCode === roomTypeCode &&
      room.products.find(
        (product) =>
          product.public?.rateCode === rateCode ||
          product.member?.rateCode === rateCode
      )
  )
}

export function createRatesStore({
  booking,
  hotelType,
  isUserLoggedIn,
  labels,
  packages,
  pathname,
  roomCategories,
  roomsAvailability,
  searchParams,
  vat,
}: InitialState) {
  const filterOptions = [
    {
      code: RoomPackageCodeEnum.ACCESSIBILITY_ROOM,
      description: labels.accessibilityRoom,
      itemCode: packages.find(
        (pkg) => pkg.code === RoomPackageCodeEnum.ACCESSIBILITY_ROOM
      )?.itemCode,
    },
    {
      code: RoomPackageCodeEnum.ALLERGY_ROOM,
      description: labels.allergyRoom,
      itemCode: packages.find(
        (pkg) => pkg.code === RoomPackageCodeEnum.ALLERGY_ROOM
      )?.itemCode,
    },
    {
      code: RoomPackageCodeEnum.PET_ROOM,
      description: labels.petRoom,
      itemCode: packages.find(
        (pkg) => pkg.code === RoomPackageCodeEnum.PET_ROOM
      )?.itemCode,
    },
  ]

  let allRooms: RoomConfiguration[] = []
  if (roomsAvailability?.roomConfigurations) {
    allRooms = filterDuplicateRoomTypesByLowestPrice(
      roomsAvailability.roomConfigurations
    ).sort(
      // @ts-expect-error - array indexing
      (a, b) => statusLookup[a.status] - statusLookup[b.status]
    )
  }

  const rateSummary: RatesState["rateSummary"] = []
  booking.rooms.forEach((room, idx) => {
    if (room.rateCode && room.roomTypeCode) {
      const selectedRoom = roomsAvailability?.roomConfigurations.find(
        (roomConf) =>
          roomConf.roomTypeCode === room.roomTypeCode &&
          roomConf.products.find(
            (product) =>
              product.public?.rateCode === room.rateCode ||
              product.member?.rateCode === room.rateCode
          )
      )

      const product = selectedRoom?.products.find(
        (p) =>
          p.public?.rateCode === room.rateCode ||
          p.member?.rateCode === room.rateCode
      )
      if (selectedRoom && product) {
        rateSummary[idx] = {
          features: selectedRoom.features,
          member: product.member,
          public: product.public,
          rate: product.rate,
          roomType: selectedRoom.roomType,
          roomTypeCode: selectedRoom.roomTypeCode,
        }
      }
    }
  })

  let activeRoom = rateSummary.length
  if (searchParams.has("modifyRateIndex")) {
    activeRoom = Number(searchParams.get("modifyRateIndex"))
  } else if (rateSummary.length === booking.rooms.length) {
    // Since all rooms has selections, all sections should be
    // closed on load
    activeRoom = -1
  }

  return create<RatesState>()((set) => ({
    actions: {
      closeSection(idx) {
        return function () {
          return set(
            produce((state: RatesState) => {
              if (state.rateSummary.length === state.booking.rooms.length) {
                state.activeRoom = -1
              } else {
                state.activeRoom = idx + 1
              }
            })
          )
        }
      },
      modifyRate(idx) {
        return function () {
          return set(
            produce((state: RatesState) => {
              state.activeRoom = idx
            })
          )
        }
      },
      selectFilter(idx) {
        return function (code) {
          return set(
            produce((state: RatesState) => {
              state.rooms[idx].selectedPackage = code
              const searchParams = new URLSearchParams(state.searchParams)
              if (code) {
                state.rooms[idx].rooms = state.allRooms.filter((room) =>
                  room.features.find((feat) => feat.code === code)
                )
                searchParams.set(`room[${idx}].packages`, code)

                if (state.rateSummary[idx]) {
                  state.rateSummary[idx].package = code
                }
              } else {
                state.rooms[idx].rooms = state.allRooms
                searchParams.delete(`room[${idx}].packages`)

                if (state.rateSummary[idx]) {
                  state.rateSummary[idx].package = undefined
                }
              }

              state.searchParams = new ReadonlyURLSearchParams(searchParams)
              window.history.pushState(
                {},
                "",
                `${state.pathname}?${searchParams}`
              )
            })
          )
        }
      },
      selectRate(idx) {
        return function (selectedRate) {
          return set(
            produce((state: RatesState) => {
              const memberRate = selectedRate.product.member
              const publicRate = selectedRate.product.public
              if (!memberRate && !publicRate) {
                return
              }

              state.rooms[idx].selectedRate = selectedRate
              state.rateSummary[idx] = {
                features: selectedRate.features,
                member: selectedRate.product.member,
                package: state.rooms[idx].selectedPackage,
                rate: selectedRate.product.rate,
                public: selectedRate.product.public,
                roomType: selectedRate.roomType,
                roomTypeCode: selectedRate.roomTypeCode,
              }

              const isBookingCodeRate =
                selectedRate.product.public?.rateType !== RateTypeEnum.Regular

              const roomNr = idx + 1
              const isMainRoom = roomNr + 1
              const isMemberRate =
                isUserLoggedIn && isMainRoom && memberRate && !isBookingCodeRate
              const searchParams = new URLSearchParams(state.searchParams)
              const counterratecode = isMemberRate
                ? (publicRate?.rateCode ?? "")
                : (memberRate?.rateCode ?? "")
              if (counterratecode) {
                searchParams.set(
                  `room[${idx}].counterratecode`,
                  counterratecode
                )
              }

              const rateCode = isMemberRate
                ? memberRate.rateCode
                : (publicRate?.rateCode ?? "")
              if (rateCode) {
                searchParams.set(`room[${idx}].ratecode`, rateCode)
              }

              searchParams.set(
                `room[${idx}].roomtype`,
                selectedRate.roomTypeCode
              )

              if (state.rateSummary.length === state.booking.rooms.length) {
                state.activeRoom = -1
              } else {
                state.activeRoom = idx + 1
              }

              state.searchParams = new ReadonlyURLSearchParams(searchParams)
              window.history.pushState(
                {},
                "",
                `${state.pathname}?${searchParams}`
              )
            })
          )
        }
      },
    },
    activeRoom,
    allRooms,
    booking,
    filterOptions,
    hotelType,
    isUserLoggedIn,
    packages,
    pathname,
    petRoomPackage: packages.find(
      (pkg) => pkg.code === RoomPackageCodeEnum.PET_ROOM
    ),
    rateSummary,
    rooms: booking.rooms.map((room) => {
      const selectedRate =
        findSelectedRate(room.rateCode, room.roomTypeCode, allRooms) ?? null

      const product = selectedRate?.products.find(
        (prd) =>
          prd.public?.rateCode === room.rateCode ||
          prd.member?.rateCode === room.rateCode
      )

      const selectedPackage = room.packages?.[0]

      return {
        bookingRoom: room,
        rooms: selectedPackage
          ? allRooms.filter((r) =>
              r.features.find((f) => f.code === selectedPackage)
            )
          : allRooms,
        selectedPackage,
        selectedRate:
          selectedRate && product
            ? {
                features: selectedRate.features,
                product,
                roomType: selectedRate.roomType,
                roomTypeCode: selectedRate.roomTypeCode,
              }
            : null,
      }
    }),
    roomCategories,
    roomsAvailability,
    searchParams,
    vat,
  }))
}

export function useRatesStore<T>(selector: (store: RatesState) => T) {
  const store = useContext(RatesContext)

  if (!store) {
    throw new Error("useRatesStore must be used within RatesProvider")
  }

  return useStore(store, selector)
}