import {
  GetAccountPage,
  GetAccountPageRefs,
} from "@/lib/graphql/Query/AccountPage.graphql"
import { request } from "@/lib/graphql/request"
import { badRequestError, internalServerError } from "@/server/errors/trpc"
import { publicProcedure, router } from "@/server/trpc"

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

import { removeEmptyObjects } from "../../utils"
import { getAccountPageInput } from "./input"
import {
  type AccountPage,
  AccountPageRefsDataRaw,
  validateAccountPageRefsSchema,
  validateAccountPageSchema,
} from "./output"
import { getConnections } from "./utils"

import { ContentEntries } from "@/types/components/myPages/myPage/enums"
import { Embeds } from "@/types/requests/embeds"
import { Edges } from "@/types/requests/utils/edges"
import { RTEDocument } from "@/types/rte/node"

export const accountPageQueryRouter = router({
  get: publicProcedure.input(getAccountPageInput).query(async ({ input }) => {
    try {
      const { lang, url } = input

      const refsResponse = await request<AccountPageRefsDataRaw>(
        GetAccountPageRefs,
        {
          locale: lang,
          url,
        },
        {
          next: {
            tags: [generateRefsResponseTag(lang, "account_page")],
          },
        }
      )

      if (!refsResponse.data) {
        console.error("Bad response for `GetAccountPageRefs`")
        console.error({ refsResponse })
        throw internalServerError()
      }

      // Remove empty objects from a fetched content type. Needed since
      // Contentstack returns empty objects for all non queried blocks in modular blocks.
      // This is an ongoing support case in Contentstack, ticker number #00031579
      const cleanedData = removeEmptyObjects(refsResponse.data)

      const validatedAccountPageRefs =
        validateAccountPageRefsSchema.safeParse(cleanedData)
      if (!validatedAccountPageRefs.success) {
        console.error("Bad validation for `GetAccountPageRefs`")
        console.error(validatedAccountPageRefs.error)
        throw badRequestError()
      }

      const connections = getConnections(validatedAccountPageRefs.data)

      const tags = generateTags(lang, connections)

      tags.push(
        generateTag(
          lang,
          validatedAccountPageRefs.data.all_account_page.items[0].system.uid
        )
      )
      const response = await request<AccountPageRefsDataRaw>(
        GetAccountPage,
        {
          locale: lang,
          url,
        },
        { next: { tags } }
      )

      if (!response.data) {
        throw badRequestError()
      }

      const validatedAccountPage = validateAccountPageSchema.safeParse(
        response.data
      )

      if (!validatedAccountPage.success) {
        console.info(`Get Account Page Validation Error`)
        console.error(validatedAccountPage.error)
        throw badRequestError()
      }
      // TODO: Make returned data nicer
      const content =
        validatedAccountPage.data.all_account_page.items[0].content.map(
          (block) => {
            switch (block.__typename) {
              case ContentEntries.AccountPageContentDynamicContent:
                return block
              case ContentEntries.AccountPageContentShortcuts:
                return {
                  ...block,
                  shortcuts: {
                    ...block.shortcuts,
                    shortcuts: block.shortcuts.shortcuts.map((shortcut) => ({
                      text: shortcut.text,
                      openInNewTab: shortcut.open_in_new_tab,
                      ...shortcut.linkConnection.edges[0].node,
                      url:
                        shortcut.linkConnection.edges[0].node.original_url ||
                        `/${shortcut.linkConnection.edges[0].node.system.locale}${shortcut.linkConnection.edges[0].node.url}`,
                    })),
                  },
                }
              case ContentEntries.AccountPageContentTextContent:
                return {
                  ...block,
                  text_content: {
                    content: {
                      json: block.text_content.content.json as RTEDocument,
                      embedded_itemsConnection: block.text_content.content
                        .embedded_itemsConnection as Edges<Embeds>,
                    },
                  },
                }
              default:
                return null
            }
          }
        )

      const accountPage = {
        ...validatedAccountPage.data.all_account_page.items[0],
        content,
      } as AccountPage
      return accountPage
    } catch (error) {
      console.info(`Get Account Page Overview Error`)
      console.error(error)
      throw internalServerError()
    }
  }),
})