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

import { router } from "../../.."
import { notFound } from "../../../errors"
import {
  GetAccountPage,
  GetAccountPageRefs,
} from "../../../graphql/Query/AccountPage/AccountPage.graphql"
import { request } from "../../../graphql/request"
import { contentstackExtendedProcedureUID } from "../../../procedures"
import {
  generateRefsResponseTag,
  generateTag,
  generateTagsFromSystem,
} from "../../../utils/generateTag"
import { accountPageRefsSchema, accountPageSchema } from "./output"
import { getConnections } from "./utils"

import type {
  GetAccountPageRefsSchema,
  GetAccountPageSchema,
} from "../../../types/accountPage"
import type { TrackingPageData } from "../../types"

export const accountPageQueryRouter = router({
  get: contentstackExtendedProcedureUID.query(async ({ ctx }) => {
    const { lang, uid } = ctx

    const getAccountPageRefsCounter = createCounter(
      "trpc.contentstack",
      "accountPage.get.refs"
    )
    const metricsRefs = getAccountPageRefsCounter.init({ lang, uid })
    metricsRefs.start()

    const refsResponse = await request<GetAccountPageRefsSchema>(
      GetAccountPageRefs,
      {
        locale: lang,
        uid,
      },
      {
        key: generateRefsResponseTag(lang, uid),
        ttl: "max",
      }
    )

    if (!refsResponse.data) {
      const notFoundError = notFound(refsResponse)
      metricsRefs.noDataError()
      throw notFoundError
    }

    const validatedAccountPageRefs = accountPageRefsSchema.safeParse(
      refsResponse.data
    )
    if (!validatedAccountPageRefs.success) {
      metricsRefs.validationError(validatedAccountPageRefs.error)
      return null
    }

    const connections = getConnections(validatedAccountPageRefs.data)

    const tags = [
      generateTagsFromSystem(lang, connections),
      generateTag(lang, validatedAccountPageRefs.data.account_page.system.uid),
    ].flat()

    metricsRefs.success()

    const getAccountPageCounter = createCounter(
      "trpc.contentstack",
      "accountPage.get"
    )
    const metrics = getAccountPageCounter.init({ lang, uid })
    metrics.start()

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

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

    const validatedAccountPage = accountPageSchema.safeParse(response.data)

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

    metrics.success()

    const parsedtitle = response.data.account_page.title
      .replaceAll(" ", "")
      .toLowerCase()

    const tracking: TrackingPageData = {
      pageId: validatedAccountPage.data.account_page.system.uid,
      domainLanguage: lang,
      publishDate: validatedAccountPage.data.account_page.system.updated_at,
      createDate: validatedAccountPage.data.account_page.system.created_at,
      channel: "scandic-friends",
      pageType: `member${parsedtitle}page`,
      pageName: validatedAccountPage.data.trackingProps.url,
      siteSections: validatedAccountPage.data.trackingProps.url,
      siteVersion: "new-web",
    }

    return {
      accountPage: validatedAccountPage.data.account_page,
      tracking,
    }
  }),
})