import { NextRequest, NextResponse } from "next/server"
import { prisma } from "@/lib/prisma"
import { requireFrontendServiceToken } from "@/lib/api/public-auth"
import { mapToPublicArticle, PUBLIC_ARTICLE_SELECT } from "@/lib/api/public-article"
import {
  buildArticleTranslations,
  parseArticleLocale,
  parseArticleTagsFromDb,
  resolveLocalizedArticle,
} from "@/lib/article-db"

type RouteContext = { params: Promise<{ slug: string }> }

type ArticleTranslationDelegate = {
  findMany: (args: {
    where: { articleId: string }
    select: {
      locale: true
      title: true
      subTitle: true
      author: true
      content: true
      faqHeading: true
      overview: true
      faq: true
      tags: true
    }
  }) => Promise<Array<{
    locale: string
    title: string | null
    subTitle: string | null
    author: string | null
    content: string | null
    faqHeading: string | null
    overview: unknown
    faq: unknown
    tags: unknown
  }>>
}

export const dynamic = "force-dynamic"
export const revalidate = 0

const NO_CACHE_HEADERS = {
  "Cache-Control": "no-store, no-cache, must-revalidate, proxy-revalidate",
  Pragma: "no-cache",
  Expires: "0",
}

export async function GET(req: NextRequest, context: RouteContext) {
  const authError = requireFrontendServiceToken(req)
  if (authError) return authError

  try {
    const locale = parseArticleLocale(req.nextUrl.searchParams.get("locale"))
    const { slug } = await context.params
    if (!slug) {
      return NextResponse.json({ success: false as const, error: "Missing slug" }, { status: 400 })
    }

    const article = await prisma.article.findFirst({
      where: { slug, status: "published" },
      select: PUBLIC_ARTICLE_SELECT,
    })

    if (!article) {
      return NextResponse.json({ success: false as const, error: "Article not found" }, { status: 404 })
    }
    const translationClient = (prisma as unknown as { articleTranslation?: ArticleTranslationDelegate }).articleTranslation
    const translationRows = translationClient
      ? await translationClient.findMany({
          where: { articleId: article.id },
          select: { locale: true, title: true, subTitle: true, author: true, content: true, faqHeading: true, overview: true, faq: true, tags: true },
        })
      : []
    const translations = buildArticleTranslations(
      {
        title: article.title,
        subTitle: article.subTitle,
        author: article.author,
        content: article.content,
        faqHeading: article.faqHeading ?? "",
        overview: article.overview,
        faq: article.faq,
        tags: article.tags,
      },
      translationRows
    )
    const localized = resolveLocalizedArticle(translations, locale)

    return NextResponse.json({
      success: true as const,
      article: mapToPublicArticle({
        ...article,
        title: localized.title || article.title,
        subTitle: localized.subTitle ?? article.subTitle,
        author: localized.author || article.author,
        content: localized.content || article.content,
        faqHeading: localized.faqHeading || article.faqHeading || "",
        overview: localized.overview ?? article.overview,
        faq: localized.faq ?? article.faq,
        tags: localized.tags.length > 0 ? localized.tags : parseArticleTagsFromDb(article.tags),
      }, translations),
    }, { headers: NO_CACHE_HEADERS })
  } catch (error) {
    console.error("[public/articles/[slug]] GET error:", error)
    return NextResponse.json(
      { success: false as const, error: "Failed to load article" },
      { status: 500 }
    )
  }
}