/** Merge persisted media URLs from save API responses back into dashboard forms. */

type HospitalLocaleMedia = {
  hero?: unknown
  gallery?: unknown
  accreditation?: unknown
}

function mergeHospitalLocaleMedia<T extends HospitalLocaleMedia>(
  prev: T,
  saved: HospitalLocaleMedia | undefined
): T {
  if (!saved) return prev
  return {
    ...prev,
    hero: saved.hero ?? prev.hero,
    gallery: saved.gallery ?? prev.gallery,
    accreditation: saved.accreditation ?? prev.accreditation,
  }
}

export function mergeHospitalFormMediaFromSavedForm<T>(form: T, savedForm: unknown): T {
  if (!savedForm || typeof savedForm !== "object") return form
  const current = form as {
    basicInfo: { slug?: string; image?: string; imagePublicId?: string }
    translations: {
      en: HospitalLocaleMedia
      ar: HospitalLocaleMedia
      tr: HospitalLocaleMedia
    }
  }
  const saved = savedForm as {
    basicInfo?: { slug?: unknown; image?: unknown; imagePublicId?: unknown }
    translations?: Record<string, HospitalLocaleMedia>
  }
  const savedBasic = saved.basicInfo
  const savedTr = saved.translations

  return {
    ...current,
    basicInfo: {
      ...current.basicInfo,
      slug: typeof savedBasic?.slug === "string" ? savedBasic.slug.trim() : current.basicInfo.slug,
      image: typeof savedBasic?.image === "string" ? savedBasic.image : current.basicInfo.image,
      imagePublicId:
        typeof savedBasic?.imagePublicId === "string"
          ? savedBasic.imagePublicId
          : current.basicInfo.imagePublicId,
    },
    translations: {
      en: mergeHospitalLocaleMedia(current.translations.en, savedTr?.en),
      ar: mergeHospitalLocaleMedia(current.translations.ar, savedTr?.ar),
      tr: mergeHospitalLocaleMedia(current.translations.tr, savedTr?.tr),
    },
  } as T
}

type ProcedureLocaleMedia = {
  overview?: unknown
  beforeAfterSection?: unknown
  reviews?: unknown
}

type ProcedureBasicBeforeAfterItem = {
  beforeImage?: string
  beforeImagePublicId?: string
  afterImage?: string
  afterImagePublicId?: string
}

function mergeProcedureLocaleMedia<T extends ProcedureLocaleMedia>(
  prev: T,
  saved: ProcedureLocaleMedia | undefined
): T {
  if (!saved) return prev
  return {
    ...prev,
    overview: saved.overview ?? prev.overview,
    beforeAfterSection: saved.beforeAfterSection ?? prev.beforeAfterSection,
    reviews: saved.reviews ?? prev.reviews,
  }
}

export function mergeProcedureFormMediaFromSavedForm<T>(form: T, savedForm: unknown): T {
  if (!savedForm || typeof savedForm !== "object") return form
  const current = form as {
    basicInfo: {
      slug?: string
      mainImage?: string
      mainImagePublicId?: string
      beforeAfterImages?: ProcedureBasicBeforeAfterItem[]
    }
    quickStats?: unknown
    translations: {
      en: ProcedureLocaleMedia
      ar: ProcedureLocaleMedia
      tr: ProcedureLocaleMedia
    }
  }
  const saved = savedForm as {
    basicInfo?: {
      slug?: unknown
      mainImage?: unknown
      mainImagePublicId?: unknown
      beforeAfterImages?: ProcedureBasicBeforeAfterItem[]
    }
    quickStats?: unknown
    translations?: Record<string, ProcedureLocaleMedia>
  }
  const savedBasic = saved.basicInfo
  const savedTr = saved.translations

  return {
    ...current,
    basicInfo: {
      ...current.basicInfo,
      slug: typeof savedBasic?.slug === "string" ? savedBasic.slug.trim() : current.basicInfo.slug,
      mainImage:
        typeof savedBasic?.mainImage === "string" ? savedBasic.mainImage : current.basicInfo.mainImage,
      mainImagePublicId:
        typeof savedBasic?.mainImagePublicId === "string"
          ? savedBasic.mainImagePublicId
          : current.basicInfo.mainImagePublicId,
      beforeAfterImages: Array.isArray(savedBasic?.beforeAfterImages)
        ? savedBasic.beforeAfterImages
        : current.basicInfo.beforeAfterImages,
    },
    quickStats: Array.isArray(saved.quickStats) ? saved.quickStats : current.quickStats,
    translations: {
      en: mergeProcedureLocaleMedia(current.translations.en, savedTr?.en),
      ar: mergeProcedureLocaleMedia(current.translations.ar, savedTr?.ar),
      tr: mergeProcedureLocaleMedia(current.translations.tr, savedTr?.tr),
    },
  } as T
}

type BeforeAfterItem = {
  image?: string
  imagePublicId?: string
}

function syncBeforeAfterMedia(
  prev: BeforeAfterItem[],
  saved: BeforeAfterItem[] | undefined
): BeforeAfterItem[] {
  if (!Array.isArray(saved) || saved.length === 0) return prev
  return prev.map((item, index) => {
    const savedItem = saved[index]
    if (!savedItem) return item
    return {
      ...item,
      image: typeof savedItem.image === "string" ? savedItem.image : item.image,
      imagePublicId:
        typeof savedItem.imagePublicId === "string" ? savedItem.imagePublicId : item.imagePublicId,
    }
  })
}

export function mergeDoctorFormMediaFromSavedDoctor<T>(form: T, savedDoctor: unknown): T {
  if (!savedDoctor || typeof savedDoctor !== "object") return form
  const current = form as {
    basicInfo: { image?: string; imagePublicId?: string }
    beforeAfter?: BeforeAfterItem[]
    translations: {
      en: { beforeAfter?: BeforeAfterItem[] }
      ar: { beforeAfter?: BeforeAfterItem[] }
      tr: { beforeAfter?: BeforeAfterItem[] }
    }
  }
  const saved = savedDoctor as {
    image?: unknown
    imagePublicId?: unknown
    beforeAfter?: BeforeAfterItem[]
    translations?: {
      en?: { beforeAfter?: BeforeAfterItem[] }
      ar?: { beforeAfter?: BeforeAfterItem[] }
      tr?: { beforeAfter?: BeforeAfterItem[] }
    }
  }

  const savedBeforeAfter = Array.isArray(saved.beforeAfter) ? saved.beforeAfter : undefined
  const savedTr = saved.translations

  return {
    ...current,
    basicInfo: {
      ...current.basicInfo,
      image: typeof saved.image === "string" ? saved.image : current.basicInfo.image,
      imagePublicId:
        typeof saved.imagePublicId === "string" ? saved.imagePublicId : current.basicInfo.imagePublicId,
    },
    beforeAfter: syncBeforeAfterMedia(current.beforeAfter ?? [], savedBeforeAfter),
    translations: {
      ...current.translations,
      en: {
        ...current.translations.en,
        beforeAfter: syncBeforeAfterMedia(
          current.translations.en.beforeAfter ?? [],
          savedTr?.en?.beforeAfter ?? savedBeforeAfter
        ),
      },
      ar: {
        ...current.translations.ar,
        beforeAfter: syncBeforeAfterMedia(
          current.translations.ar.beforeAfter ?? [],
          savedTr?.ar?.beforeAfter
        ),
      },
      tr: {
        ...current.translations.tr,
        beforeAfter: syncBeforeAfterMedia(
          current.translations.tr.beforeAfter ?? [],
          savedTr?.tr?.beforeAfter
        ),
      },
    },
  } as T
}