import { createCounter } from "@scandic-hotels/common/telemetry"

import { router } from "../../.."
import { notFound } from "../../../errors"
import {
  GetUsePointsModal,
  GetUsePointsModalRefs,
} from "../../../graphql/Query/UsePointsModal.graphql"
import { request } from "../../../graphql/request"
import { contentstackBaseProcedure } from "../../../procedures"
import {
  generateRefsResponseTag,
  generateTag,
  generateTagsFromSystem,
} from "../../../utils/generateTag"
import {
  type UsePointsModalData,
  type UsePointsModalRefsData,
  usePointsModalRefsSchema,
  usePointsModalSchema,
} from "./output"
import { getConnections } from "./utils"

export const usePointsModalQueryRouter = router({
  get: contentstackBaseProcedure.query(async ({ ctx }) => {
    const { lang, uid } = ctx
    const getRefsCounter = createCounter(
      "trpc.contentstack.usePointsModal.get.refs"
    )
    const metricsRefs = getRefsCounter.init({
      lang,
      uid,
    })

    metricsRefs.start()
    const refsTag = generateRefsResponseTag(lang, "usepointsmodal")
    const refsResponse = await request<UsePointsModalRefsData>(
      GetUsePointsModalRefs,
      { locale: lang },
      {
        key: refsTag,
        ttl: "max",
      }
    )
    if (!refsResponse.data) {
      const notFoundError = notFound(refsResponse)
      metricsRefs.noDataError()
      throw notFoundError
    }

    const validatedRefsData = usePointsModalRefsSchema.safeParse(
      refsResponse.data
    )

    if (!validatedRefsData.success) {
      metricsRefs.validationError(validatedRefsData.error)
      return null
    }

    metricsRefs.success()

    const getCounter = createCounter("trpc.contentstack.usePointsModal.get")

    const metrics = getCounter.init({
      lang,
      uid,
    })
    metrics.start()

    const connections = getConnections(validatedRefsData.data)

    const tags = [
      generateTagsFromSystem(lang, connections),
      generateTag(lang, "usepointsmodal"),
    ].flat()

    const response = await request<UsePointsModalData>(
      GetUsePointsModal,
      { locale: lang },
      {
        key: tags,
        ttl: "max",
      }
    )

    if (!response.data) {
      const notFoundError = notFound(response)
      metrics.noDataError()
      throw notFoundError
    }

    const validatedResponse = usePointsModalSchema.safeParse(response.data)

    if (!validatedResponse.success) {
      metrics.validationError(validatedResponse.error)
      return null
    }

    metrics.success()
    return validatedResponse.data
  }),
})