import { NextRequest, NextResponse } from "next/server"
import { prisma } from "@/lib/prisma"
import { requireFrontendServiceToken } from "@/lib/api/public-auth"
import {
  buildHospitalTranslationsForPublic,
  groupHospitalTranslationsByHospitalId,
} from "@/lib/api/public-hospital-translations"
import { parseHospitalLocale } from "@/lib/hospital-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",
}

function parseJsonOr<T>(value: string | null | undefined, fallback: T): T {
  if (!value) return fallback
  try {
    return JSON.parse(value) as T
  } catch {
    return fallback
  }
}

type HospitalTranslationDelegate = {
  findMany: (args: {
    where: { hospitalId: { in: string[] } }
    select: {
      hospitalId: true
      locale: true
      name: true
      location: true
      hospitalType: true
      heroJson: true
      aboutJson: true
      galleryJson: true
      departmentsJson: true
      doctorsJson: true
      accreditationJson: true
      technologyJson: true
      visitProcessJson: true
      reviewsJson: true
      locationJson: true
      packagesJson: true
      faqJson: true
      ctaJson: true
      similarJson: true
    }
  }) => Promise<Array<{
    hospitalId: string
    locale: string
    name: string | null
    location: string | null
    hospitalType: string | null
    heroJson: string | null
    aboutJson: string | null
    galleryJson: string | null
    departmentsJson: string | null
    doctorsJson: string | null
    accreditationJson: string | null
    technologyJson: string | null
    visitProcessJson: string | null
    reviewsJson: string | null
    locationJson: string | null
    packagesJson: string | null
    faqJson: string | null
    ctaJson: string | null
    similarJson: string | null
  }>>
}

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

  try {
    const locale = parseHospitalLocale(req.nextUrl.searchParams.get("locale"))
    const rows = await prisma.hospital.findMany({
      where: { status: "published" },
      orderBy: { createdAt: "desc" },
      include: { Category: { select: { id: true, name: true, color: true, slug: true } } },
    })
    const ids = rows.map((row) => row.id)
    const translationClient = (prisma as unknown as { hospitalTranslation?: HospitalTranslationDelegate }).hospitalTranslation
    const allTrRows = ids.length && translationClient
      ? await translationClient.findMany({
          where: { hospitalId: { in: ids } },
          select: {
            hospitalId: true,
            locale: true,
            name: true,
            location: true,
            hospitalType: true,
            heroJson: true,
            aboutJson: true,
            galleryJson: true,
            departmentsJson: true,
            doctorsJson: true,
            accreditationJson: true,
            technologyJson: true,
            visitProcessJson: true,
            reviewsJson: true,
            locationJson: true,
            packagesJson: true,
            faqJson: true,
            ctaJson: true,
            similarJson: true,
          },
        })
      : []

    const byHospitalId = groupHospitalTranslationsByHospitalId(allTrRows)

    return NextResponse.json(
      {
        success: true as const,
        hospitals: rows.map((row) => {
          const translations = buildHospitalTranslationsForPublic(row, byHospitalId.get(row.id) ?? [])
          const en = translations.en
          const loc = translations[locale]
          return {
            id: row.id,
            slug: row.slug,
            name: loc.name || row.name,
            location: loc.location || row.location,
            type: loc.type || row.type,
            image: row.image,
            imagePublicId: row.imagePublicId,
            rating: row.rating,
            reviewCount: row.reviewCount,
            foundedYear: row.foundedYear ?? null,
            bedsCount: row.bedsCount,
            departmentsCount: row.departmentsCount,
            doctorsCount: row.doctorsCount,
            patientsPerYear: row.patientsPerYear,
            isFeatured: row.isFeatured,
            status: row.status,
            hero: en.hero,
            about: en.about,
            gallery: en.gallery,
            departments: en.departments,
            doctors: en.doctors,
            accreditation: en.accreditation,
            technology: en.technology,
            visitProcess: en.visitProcess,
            reviews: en.reviews,
            locationSection: en.locationSection,
            packages: en.packages,
            faq: en.faq,
            cta: en.cta,
            similar: en.similar,
            translations,
            category: row.Category,
            createdAt: row.createdAt.toISOString(),
            updatedAt: row.updatedAt.toISOString(),
          }
        }),
      },
      { headers: NO_CACHE_HEADERS }
    )
  } catch (error) {
    console.error("[public/hospitals] GET error:", error)
    return NextResponse.json({ success: false as const, error: "Failed to load hospitals" }, { status: 500 })
  }
}