import { metrics } from "@opentelemetry/api"
import { cache } from "react"

import { GetAccountPageMetadata } from "@/lib/graphql/Query/AccountPage/Metadata.graphql"
import { GetCollectionPageMetadata } from "@/lib/graphql/Query/CollectionPage/Metadata.graphql"
import { GetContentPageMetadata } from "@/lib/graphql/Query/ContentPage/Metadata.graphql"
import { GetDestinationCityPageMetadata } from "@/lib/graphql/Query/DestinationCityPage/Metadata.graphql"
import { GetDestinationCountryPageMetadata } from "@/lib/graphql/Query/DestinationCountryPage/Metadata.graphql"
import { GetDestinationOverviewPageMetadata } from "@/lib/graphql/Query/DestinationOverviewPage/Metadata.graphql"
import { GetHotelPageMetadata } from "@/lib/graphql/Query/HotelPage/Metadata.graphql"
import { GetLoyaltyPageMetadata } from "@/lib/graphql/Query/LoyaltyPage/Metadata.graphql"
import { request } from "@/lib/graphql/request"
import { notFound } from "@/server/errors/trpc"
import { contentStackUidWithServiceProcedure, router } from "@/server/trpc"

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

import { getHotel } from "../../hotels/query"
import { getMetadataInput } from "./input"
import { metadataSchema } from "./output"
import { affix, getCityData } from "./utils"

import { PageContentTypeEnum } from "@/types/requests/contentType"
import type { RawMetadataSchema } from "@/types/trpc/routers/contentstack/metadata"
import type { Lang } from "@/constants/languages"

const meter = metrics.getMeter("trpc.metadata")

// OpenTelemetry metrics
const fetchMetadataCounter = meter.createCounter(
  "trpc.contentstack.metadata.get"
)
const fetchMetadataSuccessCounter = meter.createCounter(
  "trpc.contentstack.metadata.get-success"
)
const fetchMetadataFailCounter = meter.createCounter(
  "trpc.contentstack.metadata.get-fail"
)
const transformMetadataCounter = meter.createCounter(
  "trpc.contentstack.metadata.transform"
)
const transformMetadataSuccessCounter = meter.createCounter(
  "trpc.contentstack.metadata.transform-success"
)
const transformMetadataFailCounter = meter.createCounter(
  "trpc.contentstack.metadata.transform-fail"
)

const fetchMetadata = cache(async function fetchMemoizedMetadata<T>(
  query: string,
  { uid, lang }: { uid: string; lang: Lang }
) {
  fetchMetadataCounter.add(1, { lang, uid })
  console.info(
    "contentstack.metadata fetch start",
    JSON.stringify({ query: { lang, uid } })
  )
  const response = await request<T>(
    query,
    { locale: lang, uid },
    {
      cache: "force-cache",
      next: {
        tags: [generateTag(lang, uid, affix)],
      },
    }
  )
  if (!response.data) {
    const notFoundError = notFound(response)
    fetchMetadataFailCounter.add(1, {
      lang,
      uid,
      error_type: "not_found",
      error: JSON.stringify({ code: notFoundError.code }),
    })
    console.error(
      "contentstack.metadata fetch not found error",
      JSON.stringify({
        query: { lang, uid },
        error: { code: notFoundError.code },
      })
    )
    throw notFoundError
  }

  fetchMetadataSuccessCounter.add(1, { lang, uid })
  console.info(
    "contentstack.metadata fetch success",
    JSON.stringify({ query: { lang, uid } })
  )

  return response.data
})

async function getTransformedMetadata(data: unknown) {
  transformMetadataCounter.add(1)
  console.info("contentstack.metadata transform start")
  const validatedMetadata = await metadataSchema.safeParseAsync(data)

  if (!validatedMetadata.success) {
    transformMetadataFailCounter.add(1, {
      error_type: "validation_error",
      error: JSON.stringify(validatedMetadata.error),
    })
    console.error(
      "contentstack.metadata validation error",
      JSON.stringify({
        error: validatedMetadata.error,
      })
    )
    return null
  }

  transformMetadataSuccessCounter.add(1)
  console.info("contentstack.metadata transform success")

  return validatedMetadata.data
}

export const metadataQueryRouter = router({
  get: contentStackUidWithServiceProcedure
    .input(getMetadataInput)
    .query(async ({ ctx, input }) => {
      const variables = {
        lang: ctx.lang,
        uid: ctx.uid,
      }

      switch (ctx.contentType) {
        case PageContentTypeEnum.accountPage:
          const accountPageResponse = await fetchMetadata<{
            account_page: RawMetadataSchema
          }>(GetAccountPageMetadata, variables)
          return getTransformedMetadata(accountPageResponse.account_page)
        case PageContentTypeEnum.collectionPage:
          const collectionPageResponse = await fetchMetadata<{
            collection_page: RawMetadataSchema
          }>(GetCollectionPageMetadata, variables)
          return getTransformedMetadata(collectionPageResponse.collection_page)
        case PageContentTypeEnum.contentPage:
          const contentPageResponse = await fetchMetadata<{
            content_page: RawMetadataSchema
          }>(GetContentPageMetadata, variables)
          return getTransformedMetadata(contentPageResponse.content_page)
        case PageContentTypeEnum.destinationOverviewPage:
          const destinationOverviewPageResponse = await fetchMetadata<{
            destination_overview_page: RawMetadataSchema
          }>(GetDestinationOverviewPageMetadata, variables)
          return getTransformedMetadata(
            destinationOverviewPageResponse.destination_overview_page
          )
        case PageContentTypeEnum.destinationCountryPage:
          const destinationCountryPageResponse = await fetchMetadata<{
            destination_country_page: RawMetadataSchema
          }>(GetDestinationCountryPageMetadata, variables)
          return getTransformedMetadata(
            destinationCountryPageResponse.destination_country_page
          )
        case PageContentTypeEnum.destinationCityPage:
          const destinationCityPageResponse = await fetchMetadata<{
            destination_city_page: RawMetadataSchema
          }>(GetDestinationCityPageMetadata, variables)
          const cityData = await getCityData(
            destinationCityPageResponse.destination_city_page,
            input,
            ctx.serviceToken,
            ctx.lang
          )
          return getTransformedMetadata({
            ...destinationCityPageResponse.destination_city_page,
            ...cityData,
          })
        case PageContentTypeEnum.loyaltyPage:
          const loyaltyPageResponse = await fetchMetadata<{
            loyalty_page: RawMetadataSchema
          }>(GetLoyaltyPageMetadata, variables)
          return getTransformedMetadata(loyaltyPageResponse.loyalty_page)
        case PageContentTypeEnum.hotelPage:
          const hotelPageResponse = await fetchMetadata<{
            hotel_page: RawMetadataSchema
          }>(GetHotelPageMetadata, variables)
          const hotelPageData = hotelPageResponse.hotel_page
          const hotelData = hotelPageData.hotel_page_id
            ? await getHotel(
                {
                  hotelId: hotelPageData.hotel_page_id,
                  isCardOnlyPayment: false,
                  language: ctx.lang,
                },
                ctx.serviceToken
              )
            : null

          return getTransformedMetadata({
            ...hotelPageData,
            hotelData: hotelData?.hotel,
          })
        default:
          return null
      }
    }),
})