import { DocumentNode } from "graphql"
import { NextResponse } from "next/server"

import { findLang } from "@/constants/languages"
import { env } from "@/env/server"
import GetContentTypeUid from "@/lib/graphql/Query/ContentTypeUid.graphql"

import type { NextMiddleware } from "next/server"

import { MiddlewareMatcher } from "@/types/middleware"

enum PageTypeEnum {
  CurrentBlocksPage = "CurrentBlocksPage",
  LoyaltyPage = "LoyaltyPage",
  ContentPage = "contentPage",
}

type GetContentTypeUidType = {
  all_content_page: {
    items: {
      __typename: PageTypeEnum.ContentPage
    }[]
  }
  all_loyalty_page: {
    items: {
      __typename: PageTypeEnum.LoyaltyPage
    }[]
  }
  all_current_blocks_page: {
    items: {
      __typename?: PageTypeEnum.CurrentBlocksPage
    }[]
  }
}

type PageType = keyof typeof PageTypeEnum

export const middleware: NextMiddleware = async (request) => {
  const { nextUrl } = request
  const lang = findLang(nextUrl.pathname)

  const pathNameWithoutLang = nextUrl.pathname.replace(`/${lang}`, "")
  const searchParams = new URLSearchParams(request.nextUrl.searchParams)

  const print = (await import("graphql/language/printer")).print
  const result = await fetch(env.CMS_URL, {
    method: "POST",
    headers: {
      access_token: env.CMS_ACCESS_TOKEN,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      query: print(GetContentTypeUid as DocumentNode),
      variables: {
        locale: lang,
        url: pathNameWithoutLang,
      },
    }),
  })

  const pageTypeData = await result.json()
  const pageType = pageTypeData.data as GetContentTypeUidType

  const contentType = Object.values(pageType)
    .map((val) => val.items[0])
    .find((item) => item?.__typename)?.__typename

  if (request.nextUrl.pathname.includes("preview")) {
    searchParams.set("uri", pathNameWithoutLang.replace("/preview", ""))
    return NextResponse.rewrite(
      new URL(`/${lang}/preview-current?${searchParams.toString()}`, nextUrl)
    )
  }

  searchParams.set("uri", pathNameWithoutLang)
  switch (contentType) {
    case PageTypeEnum.CurrentBlocksPage:
      return NextResponse.rewrite(
        new URL(
          `/${lang}/current-content-page?${searchParams.toString()}`,
          nextUrl
        )
      )
    case PageTypeEnum.LoyaltyPage:
      return NextResponse.rewrite(
        new URL(`/${lang}/loyalty-page?${searchParams.toString()}`, nextUrl)
      )
    default:
      return NextResponse.next()
  }
}

export const matcher: MiddlewareMatcher = (request) => {
  return true
}