import { GetContactConfig } from "@/lib/graphql/Query/ContactConfig.graphql"
import {
  GetCurrentFooter,
  GetCurrentFooterRef,
} from "@/lib/graphql/Query/CurrentFooter.graphql"
import {
  GetCurrentHeader,
  GetCurrentHeaderRef,
} from "@/lib/graphql/Query/CurrentHeader.graphql"
import { request } from "@/lib/graphql/request"
import { notFound } from "@/server/errors/trpc"
import {
  contentstackBaseProcedure,
  publicProcedure,
  router,
} from "@/server/trpc"

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

import { langInput } from "./input"
import {
  type ContactConfigData,
  FooterDataRaw,
  FooterRefDataRaw,
  HeaderData,
  HeaderDataRaw,
  HeaderRefDataRaw,
  validateContactConfigSchema,
  validateFooterConfigSchema,
  validateHeaderConfigSchema,
} from "./output"

export const baseQueryRouter = router({
  contact: contentstackBaseProcedure.query(async ({ ctx }) => {
    const { lang } = ctx
    console.info("contentstack.config start ", JSON.stringify({ lang }))
    const response = await request<ContactConfigData>(GetContactConfig, {
      locale: lang,
    })

    if (!response.data) {
      console.error(
        "contentstack.config not found error ",
        JSON.stringify({ lang }),
        JSON.stringify(response)
      )
      throw notFound(response)
    }

    const validatedContactConfigConfig = validateContactConfigSchema.safeParse(
      response.data
    )

    if (!validatedContactConfigConfig.success) {
      console.error(
        "contentstack.config validation error ",
        JSON.stringify({ lang }),
        JSON.stringify(validatedContactConfigConfig.error)
      )
      return null
    }
    console.info("contentstack.config success ", JSON.stringify({ lang }))
    return validatedContactConfigConfig.data.all_contact_config.items[0]
  }),
  header: contentstackBaseProcedure
    .input(langInput)
    .query(async ({ input }) => {
      console.info(
        "contentstack.header.ref start ",
        JSON.stringify({ lang: input.lang })
      )
      const responseRef = await request<HeaderRefDataRaw>(GetCurrentHeaderRef, {
        locale: input.lang,
      })
      console.info(
        "contentstack.header. start ",
        JSON.stringify({
          lang: input.lang,
        })
      )

      // There's currently no error handling/validation for the responseRef, should it be added?
      const response = await request<HeaderDataRaw>(
        GetCurrentHeader,
        { locale: input.lang },
        {
          tags: [
            generateTag(
              input.lang,
              responseRef.data.all_current_header.items[0].system.uid
            ),
          ],
        }
      )

      if (!response.data) {
        console.error(
          "contentstack.header not found error ",
          JSON.stringify({
            lang: input.lang,
          }),
          JSON.stringify(response)
        )
        throw notFound(response)
      }

      const validatedHeaderConfig = validateHeaderConfigSchema.safeParse(
        response.data
      )

      if (!validatedHeaderConfig.success) {
        console.error(
          "contentstack.header validation error",
          JSON.stringify({
            lang: input.lang,
          }),
          JSON.stringify(validatedHeaderConfig.error)
        )
        return null
      }
      console.info(
        "contentstack.header success ",
        JSON.stringify({
          lang: input.lang,
        })
      )
      const logo =
        validatedHeaderConfig.data.all_current_header.items[0].logoConnection
          .edges?.[0]?.node

      return {
        ...validatedHeaderConfig.data.all_current_header.items[0],
        logo,
      } as HeaderData
    }),
  footer: contentstackBaseProcedure
    .input(langInput)
    .query(async ({ input }) => {
      console.info("contentstack.footer.ref start ", { lang: input.lang })
      const responseRef = await request<FooterRefDataRaw>(GetCurrentFooterRef, {
        locale: input.lang,
      })
      // There's currently no error handling/validation for the responseRef, should it be added?
      console.info(
        "contentstack.footer start ",
        JSON.stringify({
          lang: input.lang,
        })
      )
      const response = await request<FooterDataRaw>(
        GetCurrentFooter,
        {
          locale: input.lang,
        },
        {
          tags: [
            generateTag(
              input.lang,
              responseRef.data.all_current_footer.items[0].system.uid
            ),
          ],
        }
      )

      if (!response.data) {
        console.error(
          "contentstack.footer not found error ",
          JSON.stringify({
            lang: input.lang,
          }),
          JSON.stringify(response)
        )
        throw notFound(response)
      }

      const validatedFooterConfig = validateFooterConfigSchema.safeParse(
        response.data
      )

      if (!validatedFooterConfig.success) {
        console.error(
          "contentstack.footer validation error",
          JSON.stringify({ lang: input.lang }),
          JSON.stringify(validatedFooterConfig.error)
        )
        return null
      }
      console.info("contentstack.footer success ", { lang: input.lang })
      return validatedFooterConfig.data.all_current_footer.items[0]
    }),
})