import { Lang } from "@/constants/languages"
import { batchRequest } from "@/lib/graphql/batchRequest"
import {
  GetDaDeEnUrlsAccountPage,
  GetFiNoSvUrlsAccountPage,
} from "@/lib/graphql/Query/AccountPage.graphql"
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 {
  GetDaDeEnUrlsCurrentBlocksPage,
  GetFiNoSvUrlsCurrentBlocksPage,
} from "@/lib/graphql/Query/LanguageSwitcherCurrent.graphql"
import {
  GetDaDeEnUrlsLoyaltyPage,
  GetFiNoSvUrlsLoyaltyPage,
} from "@/lib/graphql/Query/LoyaltyPage.graphql"
import { request } from "@/lib/graphql/request"
import { internalServerError, notFound } from "@/server/errors/trpc"
import { contentstackProcedure, publicProcedure, router } from "@/server/trpc"

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

import {
  type ContactConfigData,
  FooterDataRaw,
  FooterRefDataRaw,
  HeaderData,
  HeaderDataRaw,
  HeaderRefDataRaw,
  validateContactConfigSchema,
  validateFooterConfigSchema,
  validateHeaderConfigSchema,
  validateLanguageSwitcherData,
} from "./output"
import { languageSwitcherAffix } from "./utils"

import {
  LanguageSwitcherData,
  LanguageSwitcherQueryDataRaw,
} from "@/types/requests/languageSwitcher"
import { PageTypeEnum } from "@/types/requests/pageType"

export const configQueryRouter = router({
  contact: contentstackProcedure.query(async ({ ctx }) => {
    const { lang } = ctx

    const response = await request<ContactConfigData>(GetContactConfig, {
      locale: lang,
    })

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

    const validatedContactConfigConfig = validateContactConfigSchema.safeParse(
      response.data
    )

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

    return validatedContactConfigConfig.data.all_contact_config.items[0]
  }),
  header: publicProcedure.query(async ({ ctx }) => {
    const responseRef = await request<HeaderRefDataRaw>(GetCurrentHeaderRef, {
      locale: ctx.lang,
    })

    const response = await request<HeaderDataRaw>(
      GetCurrentHeader,
      { locale: ctx.lang },
      {
        next: {
          tags: [
            generateTag(
              ctx.lang,
              responseRef.data.all_current_header.items[0].system.uid
            ),
          ],
        },
      }
    )

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

    const validatedHeaderConfig = validateHeaderConfigSchema.safeParse(
      response.data
    )

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

    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: contentstackProcedure.query(async ({ ctx }) => {
    const responseRef = await request<FooterRefDataRaw>(GetCurrentFooterRef, {
      locale: ctx.lang,
    })

    const response = await request<FooterDataRaw>(
      GetCurrentFooter,
      {
        locale: ctx.lang,
      },
      {
        next: {
          tags: [
            generateTag(
              ctx.lang,
              responseRef.data.all_current_footer.items[0].system.uid
            ),
          ],
        },
      }
    )

    const validatedFooterConfig = validateFooterConfigSchema.safeParse(
      response.data
    )

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

    return validatedFooterConfig.data.all_current_footer.items[0]
  }),
  languageSwitcher: contentstackProcedure.query(async ({ ctx }) => {
    const variables = { uid: ctx.uid, locale: ctx.lang }
    let urls: LanguageSwitcherData

    const tagsDaDeEn = [
      generateTag(Lang.da, ctx.uid, languageSwitcherAffix),
      generateTag(Lang.de, ctx.uid, languageSwitcherAffix),
      generateTag(Lang.en, ctx.uid, languageSwitcherAffix),
    ]
    const tagsFiNoSv = [
      generateTag(Lang.fi, ctx.uid, languageSwitcherAffix),
      generateTag(Lang.no, ctx.uid, languageSwitcherAffix),
      generateTag(Lang.sv, ctx.uid, languageSwitcherAffix),
    ]

    switch (ctx.contentType) {
      case PageTypeEnum.accountPage:
        const accountPageRes = await batchRequest<LanguageSwitcherQueryDataRaw>(
          [
            {
              document: GetDaDeEnUrlsAccountPage,
              variables,
              tags: tagsDaDeEn,
            },
            {
              document: GetFiNoSvUrlsAccountPage,
              variables,
              tags: tagsFiNoSv,
            },
          ]
        )

        const accountPageUrls = Object.keys(
          accountPageRes.data
        ).reduce<LanguageSwitcherData>((acc, key) => {
          const item = accountPageRes.data[key as Lang]?.items?.[0]
          const url = item
            ? { url: `/${key}${item.url}`, isExternal: false }
            : undefined
          return { ...acc, [key]: url }
        }, {} as LanguageSwitcherData)

        const validatedAccountLanguageSwitcherData =
          validateLanguageSwitcherData.safeParse(accountPageUrls)

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

        urls = validatedAccountLanguageSwitcherData.data
        break
      case PageTypeEnum.loyaltyPage:
        const loyaltyPageRes = await batchRequest<LanguageSwitcherQueryDataRaw>(
          [
            {
              document: GetDaDeEnUrlsLoyaltyPage,
              variables,
              tags: tagsDaDeEn,
            },
            {
              document: GetFiNoSvUrlsLoyaltyPage,
              variables,
              tags: tagsFiNoSv,
            },
          ]
        )
        const loyaltyPageUrls = Object.keys(
          loyaltyPageRes.data
        ).reduce<LanguageSwitcherData>((acc, key) => {
          const item = loyaltyPageRes.data[key as Lang]?.items?.[0]
          const url = item
            ? {
                url: item.web?.original_url || `/${key}${item.url}`,
                isExternal: !!item?.web?.original_url,
              }
            : undefined

          return {
            ...acc,
            [key]: url,
          }
        }, {} as LanguageSwitcherData)

        const validatedLoyaltyLanguageSwitcherData =
          validateLanguageSwitcherData.safeParse(loyaltyPageUrls)

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

        urls = validatedLoyaltyLanguageSwitcherData.data
        break
      case PageTypeEnum.currentBlocksPage:
        const { data } = await batchRequest<LanguageSwitcherData>([
          {
            document: GetDaDeEnUrlsCurrentBlocksPage,
            variables,
            tags: tagsDaDeEn,
          },
          {
            document: GetFiNoSvUrlsCurrentBlocksPage,
            variables,
            tags: tagsFiNoSv,
          },
        ])

        urls = data
        break
      default:
        urls = [] as unknown as LanguageSwitcherData
    }
    return { urls, lang: ctx.lang }
  }),
})