web/apps/scandic-web/lib/trpc/memoizedRequests/index.ts

import { getLang } from "@/i18n/serverContext"
import { cache } from "@/utils/cache"

import { serverClient } from "../server"

import type { Country } from "@/types/enums/country"
import type {
  AncillaryPackagesInput,
  BreackfastPackagesInput,
  PackagesInput,
} from "@/types/requests/packages"
import type {
  CityCoordinatesInput,
  HotelInput,
} from "@/types/trpc/routers/hotel/hotel"
import type { Lang } from "@/constants/languages"
import type {
  GetHotelsByCSFilterInput,
  GetSelectedRoomAvailabilityInput,
} from "@/server/routers/hotels/input"
import type { GetSavedPaymentCardsInput } from "@/server/routers/user/input"

export const getLocations = cache(async function getMemoizedLocations() {
  return serverClient().hotel.locations.get()
})

export const getProfile = cache(async function getMemoizedProfile() {
  return serverClient().user.get()
})

export const getName = cache(async function getMemoizedName() {
  return serverClient().user.name()
})

export const getProfileSafely = cache(
  async function getMemoizedProfileSafely() {
    return serverClient().user.getSafely()
  }
)

export const getSavedPaymentCardsSafely = cache(
  async function getMemoizedSavedPaymentCardsSafely(
    input: GetSavedPaymentCardsInput
  ) {
    return serverClient().user.safePaymentCards(input)
  }
)

export const getMembershipLevel = cache(
  async function getMemoizedMembershipLevel() {
    return serverClient().user.membershipLevel()
  }
)

export const getMembershipLevelSafely = cache(
  async function getMemoizedMembershipLevelSafely() {
    return serverClient().user.safeMembershipLevel()
  }
)

export const getMembershipCards = cache(
  async function getMemoizedMembershipCards() {
    return serverClient().user.membershipCards()
  }
)

export const getHotelsByCSFilter = cache(async function getMemoizedHotels(
  input: GetHotelsByCSFilterInput
) {
  return serverClient().hotel.hotels.byCSFilter.get(input)
})

export const getHotel = cache(async function getMemoizedHotelData(
  input: HotelInput
) {
  if (!input.isCardOnlyPayment) {
    input.isCardOnlyPayment = false
  }
  return serverClient().hotel.get(input)
})

export const getHotelPage = cache(async function getMemoizedHotelPage() {
  return serverClient().contentstack.hotelPage.get()
})

export const getSelectedRoomAvailability = cache(
  function getMemoizedSelectedRoomAvailability(
    input: GetSelectedRoomAvailabilityInput
  ) {
    return serverClient().hotel.availability.room(input)
  }
)

export const getFooter = cache(async function getMemoizedFooter() {
  return serverClient().contentstack.base.footer()
})

export const getHeader = cache(async function getMemoizedHeader() {
  return serverClient().contentstack.base.header()
})

export const getCurrentHeader = cache(async function getMemoizedCurrentHeader(
  lang: Lang
) {
  return serverClient().contentstack.base.currentHeader({ lang })
})

export const getCurrentFooter = cache(async function getMemoizedCurrentFooter(
  lang: Lang
) {
  return serverClient().contentstack.base.currentFooter({ lang })
})

export const getLanguageSwitcher = cache(
  async function getMemoizedLanguageSwitcher() {
    return serverClient().contentstack.languageSwitcher.get()
  }
)

export const getSiteConfig = cache(async function getMemoizedSiteConfig(
  lang: Lang
) {
  return serverClient().contentstack.base.siteConfig({ lang })
})

export const getBreakfastPackages = cache(
  async function getMemoizedBreakfastPackages(input: BreackfastPackagesInput) {
    return serverClient().hotel.packages.breakfast(input)
  }
)

export const getAncillaryPackages = cache(
  async function getMemoizedAncillaryPackages(input: AncillaryPackagesInput) {
    return serverClient().hotel.packages.ancillary(input)
  }
)

export const getPackages = cache(async function getMemoizedPackages(
  input: PackagesInput
) {
  return serverClient().hotel.packages.get(input)
})

export const getBookingConfirmation = cache(
  async function getMemoizedBookingConfirmation(confirmationNumber: string) {
    return serverClient().booking.confirmation({ confirmationNumber })
  }
)

export const getCityCoordinates = cache(
  async function getMemoizedCityCoordinates(input: CityCoordinatesInput) {
    return serverClient().hotel.map.city(input)
  }
)

export const getCurrentRewards = cache(
  async function getMemoizedCurrentRewards() {
    return serverClient().contentstack.rewards.current()
  }
)

export const getMeetingRooms = cache(
  async function getMemoizedMeetingRooms(input: {
    hotelId: string
    language: Lang
  }) {
    return serverClient().hotel.meetingRooms(input)
  }
)

export const getAdditionalData = cache(
  async function getMemoizedAdditionalData(input: {
    hotelId: string
    language: Lang
  }) {
    return serverClient().hotel.additionalData(input)
  }
)

export const getDestinationOverviewPage = cache(
  async function getMemoizedDestinationOverviewPage() {
    return serverClient().contentstack.destinationOverviewPage.get()
  }
)
export const getDestinationsList = cache(
  async function getMemoizedDestinationsList() {
    return serverClient().contentstack.destinationOverviewPage.destinations.get()
  }
)
export const getDestinationCountryPage = cache(
  async function getMemoizedDestinationCountryPage() {
    return serverClient().contentstack.destinationCountryPage.get()
  }
)
export const getDestinationCityPagesByCountry = cache(
  async function getMemoizedDestinationCityPagesByCountry(country: Country) {
    return serverClient().contentstack.destinationCountryPage.cityPages({
      country,
    })
  }
)
export const getHotelsByCountry = cache(
  async function getMemoizedHotelsByCountry(country: Country) {
    return serverClient().hotel.hotels.byCountry.get({
      country,
    })
  }
)
export const getHotelsByCityIdentifier = cache(
  async function getMemoizedHotelsByCityIdentifier(cityIdentifier: string) {
    return serverClient().hotel.hotels.byCityIdentifier.get({
      cityIdentifier,
    })
  }
)
export const getAllHotels = cache(async function getMemoizedAllHotels() {
  return serverClient().hotel.hotels.getAllHotels.get()
})
export const getDestinationCityPage = cache(
  async function getMemoizedDestinationCityPage() {
    return serverClient().contentstack.destinationCityPage.get()
  }
)

export const getStartPage = cache(async function getMemoizedStartPage() {
  return serverClient().contentstack.startPage.get()
})

export const getPageSettings = cache(async function getMemoizedPageSettings(
  lang: Lang
) {
  return serverClient().contentstack.pageSettings.get({ lang })
})

export const isBookingWidgetHidden = cache(
  async function isMemoizedBookingWidgetHidden() {
    const lang = getLang()
    const [pageSettingsResult, siteConfigResults] = await Promise.allSettled([
      getPageSettings(lang),
      getSiteConfig(lang),
    ])

    const pageSettings =
      pageSettingsResult.status === "fulfilled"
        ? pageSettingsResult.value
        : null
    const siteConfig =
      siteConfigResults.status === "fulfilled" ? siteConfigResults.value : null

    if (pageSettings) {
      return pageSettings.page.settings.hide_booking_widget
    }

    if (siteConfig) {
      return siteConfig.bookingWidgetDisabled
    }

    return false
  }
)