import type { HospitalLocale } from "@/lib/hospital-db"

export type PublicHospitalLocalePayload = {
  name: string
  location: string
  /** Localized hospital kind label (`HospitalTranslation.hospitalType`), fallback to canonical `Hospital.type` */
  type: string
  hero: Record<string, unknown>
  about: unknown
  gallery: unknown
  departments: unknown
  doctors: unknown
  accreditation: unknown
  technology: unknown
  visitProcess: unknown
  reviews: unknown
  locationSection: unknown
  packages: unknown
  faq: unknown
  cta: unknown
  similar: unknown
}

function parseString(value: unknown): string {
  return typeof value === "string" ? value.trim() : ""
}

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

function emptyLocale(): PublicHospitalLocalePayload {
  return {
    name: "",
    location: "",
    type: "",
    hero: {},
    about: {},
    gallery: {},
    departments: {},
    doctors: {},
    accreditation: {},
    technology: {},
    visitProcess: {},
    reviews: {},
    locationSection: {},
    packages: {},
    faq: {},
    cta: {},
    similar: {},
  }
}

type HospitalRowLike = {
  name: string
  location: string
  type: string
  heroJson: string
  aboutJson: string
  galleryJson: string
  departmentsJson: string
  doctorsJson: string
  accreditationJson: string
  technologyJson: string
  visitProcessJson: string
  reviewsJson: string
  locationJson: string
  packagesJson: string
  faqJson: string
  ctaJson: string
  similarJson: string
}

type HospitalTrRowLike = {
  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
}

function payloadFromMainRow(row: HospitalRowLike): PublicHospitalLocalePayload {
  const hero = parseJsonOr<Record<string, unknown>>(row.heroJson, {})
  const locationSection = parseJsonOr(row.locationJson, {})
  return {
    name: row.name,
    location: row.location,
    type: parseString(row.type),
    hero,
    about: parseJsonOr(row.aboutJson, {}),
    gallery: parseJsonOr(row.galleryJson, {}),
    departments: parseJsonOr(row.departmentsJson, {}),
    doctors: parseJsonOr(row.doctorsJson, {}),
    accreditation: parseJsonOr(row.accreditationJson, {}),
    technology: parseJsonOr(row.technologyJson, {}),
    visitProcess: parseJsonOr(row.visitProcessJson, {}),
    reviews: parseJsonOr(row.reviewsJson, {}),
    locationSection,
    packages: parseJsonOr(row.packagesJson, {}),
    faq: parseJsonOr(row.faqJson, {}),
    cta: parseJsonOr(row.ctaJson, {}),
    similar: parseJsonOr(row.similarJson, {}),
  }
}

function payloadFromTranslationRow(row: HospitalRowLike, tr: HospitalTrRowLike): PublicHospitalLocalePayload {
  const hero = parseJsonOr<Record<string, unknown>>(tr.heroJson ?? row.heroJson, {})
  const locationSection = parseJsonOr(tr.locationJson ?? row.locationJson, {})
  const displayName =
    parseString(tr.name) || parseString(hero.title) || row.name
  const displayLocation =
    parseString(tr.location) ||
    parseString((locationSection as Record<string, unknown>).title) ||
    row.location

  const displayType = parseString(tr.hospitalType) || parseString(row.type)

  return {
    name: displayName,
    location: displayLocation,
    type: displayType,
    hero,
    about: parseJsonOr(tr.aboutJson ?? row.aboutJson, {}),
    gallery: parseJsonOr(tr.galleryJson ?? row.galleryJson, {}),
    departments: parseJsonOr(tr.departmentsJson ?? row.departmentsJson, {}),
    doctors: parseJsonOr(tr.doctorsJson ?? row.doctorsJson, {}),
    accreditation: parseJsonOr(tr.accreditationJson ?? row.accreditationJson, {}),
    technology: parseJsonOr(tr.technologyJson ?? row.technologyJson, {}),
    visitProcess: parseJsonOr(tr.visitProcessJson ?? row.visitProcessJson, {}),
    reviews: parseJsonOr(tr.reviewsJson ?? row.reviewsJson, {}),
    locationSection,
    packages: parseJsonOr(tr.packagesJson ?? row.packagesJson, {}),
    faq: parseJsonOr(tr.faqJson ?? row.faqJson, {}),
    cta: parseJsonOr(tr.ctaJson ?? row.ctaJson, {}),
    similar: parseJsonOr(tr.similarJson ?? row.similarJson, {}),
  }
}

/** Same pattern as doctor `translations`: always `en`/`ar`/`tr`; fill ar/tr only when rows exist. */
export function buildHospitalTranslationsForPublic(
  row: HospitalRowLike,
  translationRows: HospitalTrRowLike[]
): Record<HospitalLocale, PublicHospitalLocalePayload> {
  const baseEn = payloadFromMainRow(row)
  const out: Record<HospitalLocale, PublicHospitalLocalePayload> = {
    en: { ...baseEn },
    ar: emptyLocale(),
    tr: emptyLocale(),
  }

  const byLocale = new Map<string, HospitalTrRowLike>()
  for (const tr of translationRows) {
    if (tr.locale === "en" || tr.locale === "ar" || tr.locale === "tr") {
      byLocale.set(tr.locale, tr)
    }
  }

  const enTr = byLocale.get("en")
  if (enTr) {
    out.en = payloadFromTranslationRow(row, enTr)
  }

  const arTr = byLocale.get("ar")
  if (arTr) {
    out.ar = payloadFromTranslationRow(row, arTr)
  }

  const trTr = byLocale.get("tr")
  if (trTr) {
    out.tr = payloadFromTranslationRow(row, trTr)
  }

  return out
}

export function groupHospitalTranslationsByHospitalId(
  rows: Array<HospitalTrRowLike & { hospitalId: string }>
): Map<string, HospitalTrRowLike[]> {
  const map = new Map<string, HospitalTrRowLike[]>()
  for (const r of rows) {
    const list = map.get(r.hospitalId) ?? []
    list.push(r)
    map.set(r.hospitalId, list)
  }
  return map
}