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"

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

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

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) {
  const authError = requireFrontendServiceToken(req)
  if (authError) return authError

  try {
    const locale = parseArticleLocale(req.nextUrl.searchParams.get("locale"))
    const rows = await prisma.article.findMany({
      where: { status: "published" },
      orderBy: { publishDate: "desc" },
      select: PUBLIC_ARTICLE_SELECT,
    })
    const articleIds = rows.map((row) => row.id)
    const translationClient = (prisma as unknown as { articleTranslation?: ArticleTranslationDelegate }).articleTranslation
    const translationRows = articleIds.length
      ? translationClient
        ? await translationClient.findMany({
          where: { articleId: { in: articleIds } },
          select: { articleId: true, locale: true, title: true, subTitle: true, author: true, content: true, faqHeading: true, overview: true, faq: true, conversionCard: true, trustCard: true, tags: true },
        })
        : []
      : []
    const byArticleId = new Map<string, typeof translationRows>()
    for (const tr of translationRows) {
      const bucket = byArticleId.get(tr.articleId)
      if (bucket) bucket.push(tr)
      else byArticleId.set(tr.articleId, [tr])
    }

    return NextResponse.json({
      success: true as const,
      articles: rows.map((row) => {
        const translations = buildArticleTranslations(
          {
            title: row.title,
            subTitle: row.subTitle,
            author: row.author,
            content: row.content,
            faqHeading: row.faqHeading ?? "",
            overview: row.overview,
            faq: row.faq,
            tags: row.tags,
          },
          byArticleId.get(row.id) ?? []
        )
        const localized = resolveLocalizedArticle(translations, locale)
        return mapToPublicArticle({
          ...row,
          title: localized.title || row.title,
          subTitle: localized.subTitle ?? row.subTitle,
          author: localized.author || row.author,
          content: localized.content || row.content,
          faqHeading: localized.faqHeading || row.faqHeading || "",
          overview: localized.overview ?? row.overview,
          faq: localized.faq ?? row.faq,
          conversionCard: localized.conversionCard ?? row.conversionCard,
          trustCard: localized.trustCard ?? row.trustCard,
          tags: localized.tags.length > 0 ? localized.tags : parseArticleTagsFromDb(row.tags),
        }, translations)
      }),
    }, { headers: NO_CACHE_HEADERS })
  } catch (error) {
    console.error("[public/articles] GET error:", error)
    return NextResponse.json(
      { success: false as const, error: "Failed to load articles" },
      { status: 500 }
    )
  }
}