import { NextRequest, NextResponse } from "next/server"
import { prisma } from "@/lib/prisma"
import { requireFrontendServiceToken } from "@/lib/api/public-auth"
import {
  CATEGORY_ENTITY_TYPE,
  buildCategoryTranslations,
  resolveLocalizedCategory,
} from "@/lib/category-db"

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",
}

type TranslationDelegate = {
  findMany: (args: {
    where: { entityType: string; entityId: { in: string[] } }
    select: { entityId: true; locale: true; name: true; description: true }
  }) => Promise<Array<{
    entityId: string
    locale: string
    name: string | null
    description: string | null
  }>>
}

function parseCategoryLocale(raw: string | null): "en" | "ar" | "tr" {
  if (raw === "ar" || raw === "tr" || raw === "en") return raw
  return "en"
}

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

  try {
    const locale = parseCategoryLocale(req.nextUrl.searchParams.get("locale"))
    const rows = await prisma.category.findMany({
      orderBy: { createdAt: "desc" },
      include: { _count: { select: { Article: true } } },
    })

    const categoryIds = rows.map((row) => row.id)
    const translationClient = (prisma as unknown as { translation?: TranslationDelegate }).translation
    const translationRows = categoryIds.length
      ? translationClient
        ? await translationClient.findMany({
            where: { entityType: CATEGORY_ENTITY_TYPE, entityId: { in: categoryIds } },
            select: { entityId: true, locale: true, name: true, description: true },
          })
        : []
      : []
    const byCategoryId = new Map<string, typeof translationRows>()
    for (const tr of translationRows) {
      const bucket = byCategoryId.get(tr.entityId)
      if (bucket) bucket.push(tr)
      else byCategoryId.set(tr.entityId, [tr])
    }

    return NextResponse.json(
      {
        success: true as const,
        categories: rows.map((row) => {
          const translations = buildCategoryTranslations(row, byCategoryId.get(row.id) ?? [])
          const localized = resolveLocalizedCategory(translations, locale)
          return {
            id: row.id,
            name: localized.name || row.name,
            slug: row.slug,
            description: localized.description,
            color: row.color,
            iconKey: row.iconKey ?? null,
            isVisible: row.isVisible,
            articleCount: row._count.Article,
            createdAt: row.createdAt.toISOString(),
            translations,
          }
        }),
      },
      { headers: NO_CACHE_HEADERS }
    )
  } catch (error) {
    console.error("[public/categories] GET error:", error)
    return NextResponse.json(
      { success: false as const, error: "Failed to load categories" },
      { status: 500 }
    )
  }
}