import {
  GetAccountPageBreadcrumbs,
  GetAccountPageBreadcrumbsRefs,
} from "@/lib/graphql/Query/BreadcrumbsAccountPage.graphql"
import {
  GetLoyaltyPageBreadcrumbs,
  GetLoyaltyPageBreadcrumbsRefs,
} from "@/lib/graphql/Query/BreadcrumbsLoyaltyPage.graphql"
import { request } from "@/lib/graphql/request"
import { internalServerError, notFound } from "@/server/errors/trpc"
import { contentstackProcedure, router } from "@/server/trpc"

import {
  generateRefsResponseTag,
  generateTag,
  generateTags,
} from "@/utils/generateTag"
import { removeMultipleSlashes } from "@/utils/url"

import { PageTypeEnum, PageTypes } from "./input"
import {
  getBreadcrumbsSchema,
  validateBreadcrumbsContentstackSchema,
  validateBreadcrumbsRefsContentstackSchema,
} from "./output"
import { affix, getConnections, homeBreadcrumbs } from "./utils"

import type {
  GetMyPagesBreadcrumbsData,
  GetMyPagesBreadcrumbsRefsData,
} from "@/types/requests/myPages/breadcrumbs"

export const breadcrumbsQueryRouter = router({
  get: contentstackProcedure
    .input(PageTypeEnum)
    .query(async ({ ctx, input }) => {
      let refsResponse, GetPageBreadcrumbs, GetPageBreadcrumbRefs

      if (input.pageType == PageTypes.Account) {
        GetPageBreadcrumbs = GetAccountPageBreadcrumbs
        GetPageBreadcrumbRefs = GetAccountPageBreadcrumbsRefs
      } else if (input.pageType == PageTypes.Loyalty) {
        GetPageBreadcrumbs = GetLoyaltyPageBreadcrumbs
        GetPageBreadcrumbRefs = GetLoyaltyPageBreadcrumbsRefs
      } else {
        return []
      }
      refsResponse = await request<GetMyPagesBreadcrumbsRefsData>(
        GetPageBreadcrumbRefs,
        { locale: ctx.lang, url: ctx.pathname },
        {
          next: {
            tags: [generateRefsResponseTag(ctx.lang, ctx.pathname, affix)],
          },
        }
      )
      if (!refsResponse.data) {
        throw notFound(refsResponse)
      }

      const validatedRefsData =
        validateBreadcrumbsRefsContentstackSchema.safeParse(refsResponse.data)
      if (!validatedRefsData.success) {
        throw internalServerError(validatedRefsData.error)
      }

      const connections = getConnections(validatedRefsData.data)
      const tags = generateTags(ctx.lang, connections)
      const page = validatedRefsData.data.all_page.items[0]
      tags.push(generateTag(ctx.lang, page.system.uid, affix))

      const response = await request<GetMyPagesBreadcrumbsData>(
        GetPageBreadcrumbs,
        { locale: ctx.lang, url: ctx.pathname },
        { next: { tags } }
      )
      if (!response.data) {
        throw notFound(response)
      }

      const validatedBreadcrumbsData =
        validateBreadcrumbsContentstackSchema.safeParse(response.data)

      if (!validatedBreadcrumbsData.success) {
        throw internalServerError(validatedBreadcrumbsData.error)
      }

      const parentBreadcrumbs =
        validatedBreadcrumbsData.data.all_page.items[0].web.breadcrumbs.parentsConnection.edges.map(
          (breadcrumb) => {
            return {
              href: removeMultipleSlashes(
                `/${breadcrumb.node.system.locale}/${breadcrumb.node.url}`
              ),
              title: breadcrumb.node.breadcrumbs.title,
              uid: breadcrumb.node.system.uid,
            }
          }
        )

      const pageBreadcrumb = validatedBreadcrumbsData.data.all_page.items.map(
        (breadcrumb) => {
          return {
            title: breadcrumb.web.breadcrumbs.title,
            uid: breadcrumb.system.uid,
          }
        }
      )

      const breadcrumbs = [
        homeBreadcrumbs[ctx.lang],
        parentBreadcrumbs,
        pageBreadcrumb,
      ].flat()

      const validatedBreadcrumbs = getBreadcrumbsSchema.safeParse(breadcrumbs)
      if (!validatedBreadcrumbs.success) {
        throw internalServerError(validatedBreadcrumbs.error)
      }

      return validatedBreadcrumbs.data
    }),
})