web/server/routers/contentstack/destinationCountryPage/utils.ts

import { env } from "@/env/server"
import { GetDestinationCityListData } from "@/lib/graphql/Query/DestinationCityPage/DestinationCityListData.graphql"
import { GetCountryPageUrls } from "@/lib/graphql/Query/DestinationCountryPage/DestinationCountryPageUrl.graphql"
import { request } from "@/lib/graphql/request"
import { toApiLang } from "@/server/utils"

import { generateTag, generateTagsFromSystem } from "@/utils/generateTag"

import { getCitiesByCountry } from "../../hotels/utils"
import { destinationCityListDataSchema } from "../destinationCityPage/output"
import { countryPageUrlsSchema } from "./output"
import {
  getCityListDataCounter,
  getCityListDataFailCounter,
  getCityListDataSuccessCounter,
  getCountryPageUrlsCounter,
  getCountryPageUrlsFailCounter,
  getCountryPageUrlsSuccessCounter,
} from "./telemetry"

import { ApiCountry, type Country } from "@/types/enums/country"
import { DestinationCountryPageEnum } from "@/types/enums/destinationCountryPage"
import type { RequestOptionsWithOutBody } from "@/types/fetch"
import type { System } from "@/types/requests/system"
import type { GetDestinationCityListDataResponse } from "@/types/trpc/routers/contentstack/destinationCityPage"
import type {
  DestinationCountryPageRefs,
  GetCountryPageUrlsData,
} from "@/types/trpc/routers/contentstack/destinationCountryPage"
import type { Lang } from "@/constants/languages"

export function generatePageTags(
  validatedData: DestinationCountryPageRefs,
  lang: Lang
): string[] {
  const connections = getConnections(validatedData)
  return [
    generateTagsFromSystem(lang, connections),
    generateTag(lang, validatedData.destination_country_page.system.uid),
  ].flat()
}

export function getConnections({
  destination_country_page,
}: DestinationCountryPageRefs) {
  const connections: System["system"][] = [destination_country_page.system]
  if (destination_country_page.blocks) {
    destination_country_page.blocks.forEach((block) => {
      switch (block.__typename) {
        case DestinationCountryPageEnum.ContentStack.blocks.Accordion: {
          if (block.accordion.length) {
            connections.push(...block.accordion)
          }
          break
        }
        case DestinationCountryPageEnum.ContentStack.blocks.Content:
          {
            if (block.content.length) {
              // TS has trouble infering the filtered types
              // @ts-ignore
              connections.push(...block.content)
            }
          }
          break
      }
    })
  }
  if (destination_country_page.sidepeek_content) {
    destination_country_page.sidepeek_content.content.embedded_itemsConnection.edges.forEach(
      ({ node }) => {
        connections.push(node.system)
      }
    )
  }

  return connections
}

export async function getCityListDataByCityIdentifier(
  lang: Lang,
  cityIdentifier: string
) {
  getCityListDataCounter.add(1, { lang, cityIdentifier })
  console.info(
    "contentstack.cityListData start",
    JSON.stringify({ query: { lang, cityIdentifier } })
  )
  const tag = `${lang}:city_list_data:${cityIdentifier}`
  const response = await request<GetDestinationCityListDataResponse>(
    GetDestinationCityListData,
    {
      locale: lang,
      cityIdentifier,
    },
    {
      cache: "force-cache",
      next: {
        tags: [tag],
      },
    }
  )

  if (!response.data) {
    getCityListDataFailCounter.add(1, {
      lang,
      cityIdentifier,
      error_type: "not_found",
      error: `Destination city page not found for cityIdentifier: ${cityIdentifier}`,
    })
    console.error(
      "contentstack.cityListData not found error",
      JSON.stringify({ query: { lang, cityIdentifier } })
    )
    return null
  }

  const validatedResponse = destinationCityListDataSchema.safeParse(
    response.data
  )

  if (!validatedResponse.success) {
    getCityListDataFailCounter.add(1, {
      lang,
      cityIdentifier,
      error_type: "validation_error",
      error: JSON.stringify(validatedResponse.error),
    })
    console.error(
      "contentstack.cityListData validation error",
      JSON.stringify({
        query: { lang, cityIdentifier },
        error: validatedResponse.error,
      })
    )
    return null
  }
  getCityListDataSuccessCounter.add(1, { lang, cityIdentifier })
  console.info(
    "contentstack.cityListData success",
    JSON.stringify({ query: { lang, cityIdentifier } })
  )

  return validatedResponse.data
}

export async function getCityPages(
  lang: Lang,
  serviceToken: string,
  country: Country
) {
  const apiLang = toApiLang(lang)
  const params = new URLSearchParams({
    language: apiLang,
  })
  const options: RequestOptionsWithOutBody = {
    // needs to clear default option as only
    // cache or next.revalidate is permitted
    cache: undefined,
    headers: {
      Authorization: `Bearer ${serviceToken}`,
    },
    next: {
      revalidate: env.CACHE_TIME_HOTELS,
    },
  }
  const apiCountry = ApiCountry[lang][country]
  const cities = await getCitiesByCountry([apiCountry], options, params, lang)

  const publishedCities = cities[apiCountry].filter((city) => city.isPublished)

  const cityPages = await Promise.all(
    publishedCities.map(async (city) => {
      if (!city.cityIdentifier) {
        return null
      }

      const data = await getCityListDataByCityIdentifier(
        lang,
        city.cityIdentifier
      )
      return data ? { ...data, cityName: city.name } : null
    })
  )

  return cityPages
    .flat()
    .filter((city): city is NonNullable<typeof city> => !!city)
}

export async function getCountryPageUrls(lang: Lang) {
  getCountryPageUrlsCounter.add(1, { lang })
  console.info(
    "contentstack.countryPageUrls start",
    JSON.stringify({ query: { lang } })
  )

  const tag = `${lang}:country_page_urls`
  const response = await request<GetCountryPageUrlsData>(
    GetCountryPageUrls,
    {
      locale: lang,
    },
    {
      cache: "force-cache",
      next: {
        tags: [tag],
      },
    }
  )

  if (!response.data) {
    getCountryPageUrlsFailCounter.add(1, {
      lang,
      error_type: "not_found",
      error: `Country pages not found for lang: ${lang}`,
    })
    console.error(
      "contentstack.countryPageUrls not found error",
      JSON.stringify({ query: { lang } })
    )
    return []
  }

  const validatedCountryPageUrls = countryPageUrlsSchema.safeParse(
    response.data
  )

  if (!validatedCountryPageUrls.success) {
    getCountryPageUrlsFailCounter.add(1, {
      lang,
      error_type: "validation_error",
      error: JSON.stringify(validatedCountryPageUrls.error),
    })
    console.error(
      "contentstack.countryPageUrls validation error",
      JSON.stringify({
        query: { lang },
        error: validatedCountryPageUrls.error,
      })
    )
    return []
  }

  getCountryPageUrlsSuccessCounter.add(1, { lang })
  console.info(
    "contentstack.countryPageUrls success",
    JSON.stringify({ query: { lang } })
  )

  return validatedCountryPageUrls.data
}