web/packages/trpc/lib/routers/contentstack/metadata/utils.ts

import { ApiCountry } from "../../../types/country"
import { HotelSortOption } from "../../../types/hotel"
import { getSortedCities } from "../../../utils/getSortedCities"
import { mergeHotelFiltersAndSeoFilters } from "../../../utils/mergeHotelFiltersAndSeoFilters"
import { getHotelFilters } from "../../hotels/filters/utils"
import {
  getCityByCityIdentifier,
  getHotelIdsByCityIdentifier,
} from "../../hotels/services/getCityByCityIdentifier"
import { getHotelIdsByCountry } from "../../hotels/services/getHotelIdsByCountry"
import { getCityPages } from "../destinationCountryPage/utils"
import { transformDestinationFiltersResponse } from "../schemas/destinationFilters"

import type { Lang } from "@scandic-hotels/common/constants/language"

import type { MetadataInputSchema } from "./input"
import type { RawMetadataSchema } from "./output"

export const affix = "metadata"

export async function getCityData(
  data: RawMetadataSchema,
  input: MetadataInputSchema,
  serviceToken: string,
  lang: Lang
) {
  const destinationSettings = data.destination_settings
  const seoFilters = transformDestinationFiltersResponse(data.seo_filters)
  const filter = input.filterFromUrl

  if (destinationSettings) {
    const {
      city_sweden,
      city_norway,
      city_denmark,
      city_finland,
      city_germany,
      city_poland,
    } = destinationSettings
    const cities = [
      city_denmark,
      city_finland,
      city_germany,
      city_poland,
      city_norway,
      city_sweden,
    ].filter((city): city is string => Boolean(city))

    const cityIdentifier = cities[0]

    if (cityIdentifier) {
      const cityData = await getCityByCityIdentifier({
        cityIdentifier,
        serviceToken,
        lang,
      })
      const hotelIds = await getHotelIdsByCityIdentifier(
        cityIdentifier,
        serviceToken
      )

      let filterType
      if (filter) {
        const hotelFilters = await getHotelFilters(lang)
        const allFilters = mergeHotelFiltersAndSeoFilters(
          hotelFilters,
          seoFilters
        )

        const facilityFilter = allFilters.facilityFilters.find(
          (f) => f.slug === filter
        )
        const surroundingsFilter = allFilters.surroundingsFilters.find(
          (f) => f.slug === filter
        )

        if (facilityFilter) {
          filterType = "facility"
        } else if (surroundingsFilter) {
          filterType = "surroundings"
        }
      }

      return {
        location: cityData?.name,
        filter,
        filterType,
        hotelCount: hotelIds.length,
      }
    }
  }
  return null
}

export async function getCountryData(
  data: RawMetadataSchema,
  input: MetadataInputSchema,
  serviceToken: string,
  lang: Lang
) {
  const country = data.destination_settings?.country
  const seoFilters = transformDestinationFiltersResponse(data.seo_filters)
  const filter = input.filterFromUrl

  if (country) {
    const translatedCountry = ApiCountry[lang][country]
    let filterType

    const cities = await getCityPages(lang, serviceToken, country)
    const sortedCities = getSortedCities(cities, HotelSortOption.Recommended)
    const hotelIds = await getHotelIdsByCountry({
      country,
      serviceToken,
    })

    if (filter) {
      const hotelFilters = await getHotelFilters(lang)
      const allFilters = mergeHotelFiltersAndSeoFilters(
        hotelFilters,
        seoFilters
      )

      const facilityFilter = allFilters.facilityFilters.find(
        (f) => f.slug === filter
      )
      const surroundingsFilter = allFilters.surroundingsFilters.find(
        (f) => f.slug === filter
      )

      if (facilityFilter) {
        filterType = "facility"
      } else if (surroundingsFilter) {
        filterType = "surroundings"
      }
    }
    return {
      location: translatedCountry,
      filter,
      filterType,
      cities: sortedCities.slice(0, 2).map(({ cityName }) => cityName),
      hotelCount: hotelIds.length,
    }
  }
  return null
}