import { computed, ref, type ComputedRef, type Ref } from 'vue'
import { useExperimentSave, type UseExperimentSaveOptions } from './useExperimentSave'
import {
  createTemplateCollection,
  ensureTemplateFromCollection,
  extractTemplateCollection,
  type BioTemplateEnvelope,
  type TemplateCollection,
  type TemplateCollectionEnvelope,
} from '../templates'

export type TemplateCollectionInput =
  | TemplateCollectionEnvelope
  | BioTemplateEnvelope<unknown>
  | Array<BioTemplateEnvelope<unknown>>

export interface UseTemplateCollectionOptions extends UseExperimentSaveOptions {
  /** Initial template collection or factory; defaults to an empty collection. */
  initial?: TemplateCollectionInput | (() => TemplateCollectionInput)
}

export interface UseTemplateCollectionReturn {
  /** Current experiment id from platform injection, URL query, or URL path. */
  currentExperimentId: ComputedRef<number | undefined>
  /** Whether a current experiment id is available. */
  hasCurrentExperiment: ComputedRef<boolean>
  /** Full template collection envelope ready to save into design_data. */
  templateCollection: Ref<TemplateCollectionEnvelope>
  /** Template map keyed by template_id. */
  templates: ComputedRef<TemplateCollection>
  /** Collection-level metadata, or an empty object. */
  metadata: ComputedRef<Record<string, unknown>>
  /** Template ids currently present in the collection. */
  templateIds: ComputedRef<string[]>
  /** Whether the collection contains at least one template. */
  hasTemplates: ComputedRef<boolean>
  /** Whether a load or delete operation is in progress. */
  isLoading: Ref<boolean>
  /** Whether a save operation is in progress. */
  isSaving: Ref<boolean>
  /** Error message from the last failed operation, or null. */
  error: Ref<string | null>
  /** Timestamp of the last successful load, or null. */
  lastLoadedAt: Ref<Date | null>
  /** Timestamp of the last successful save, or null. */
  lastSavedAt: Ref<Date | null>
  /** Replace local state from a template envelope, collection envelope, or raw design_data. */
  apply: (value: unknown, metadata?: Record<string, unknown>) => TemplateCollectionEnvelope
  /** Reset local state to the configured initial collection. */
  reset: () => TemplateCollectionEnvelope
  /** Add or replace one template in the local collection. */
  setTemplate: (template: BioTemplateEnvelope<unknown>) => TemplateCollectionEnvelope
  /** Remove one template from the local collection. */
  removeTemplate: (templateId: string) => boolean
  /** Read one template from the local collection, returning null when missing. */
  getTemplate: <TTemplate extends BioTemplateEnvelope<unknown> = BioTemplateEnvelope<unknown>>(
    templateId: string,
  ) => TTemplate | null
  /** Read one template from the local collection, throwing when missing or mismatched. */
  requireTemplate: <TTemplate extends BioTemplateEnvelope<unknown> = BioTemplateEnvelope<unknown>>(
    templateId: string,
  ) => TTemplate
  /** Load template design_data for an experiment and apply it locally. */
  load: (experimentId: number) => Promise<TemplateCollectionEnvelope | null>
  /** Load template design_data for the current experiment and apply it locally. */
  loadCurrent: () => Promise<TemplateCollectionEnvelope | null>
  /** Save the local template collection as experiment design_data. */
  save: (experimentId: number) => Promise<boolean>
  /** Save the local template collection as current experiment design_data. */
  saveCurrent: () => Promise<boolean>
  /** Require and return the current experiment id, or throw when missing. */
  requireCurrentExperimentId: () => number
}

/**
 * Manages a biology template collection in the current experiment's design_data.
 *
 * @deprecated Scheduled for removal in MINT 1.4; no SDK replacement.
 */
export function useTemplateCollection(
  options: UseTemplateCollectionOptions = {},
): UseTemplateCollectionReturn {
  const experimentSave = useExperimentSave(options)
  const templateCollection = ref<TemplateCollectionEnvelope>(createInitialCollection(options))
  const templates = computed(() => extractTemplateCollection(templateCollection.value))
  const metadata = computed(() => templateCollection.value.metadata ?? {})
  const templateIds = computed(() => Object.keys(templates.value))
  const hasTemplates = computed(() => templateIds.value.length > 0)

  function apply(value: unknown, metadata?: Record<string, unknown>): TemplateCollectionEnvelope {
    templateCollection.value = normalizeTemplateCollection(value, metadata)
    return templateCollection.value
  }

  function reset(): TemplateCollectionEnvelope {
    templateCollection.value = createInitialCollection(options)
    return templateCollection.value
  }

  function setTemplate(template: BioTemplateEnvelope<unknown>): TemplateCollectionEnvelope {
    const nextTemplates = {
      ...templates.value,
      [template.template_id]: template,
    }
    templateCollection.value = createTemplateCollectionEnvelope(
      Object.values(nextTemplates),
      templateCollection.value.metadata,
    )
    return templateCollection.value
  }

  function removeTemplate(templateId: string): boolean {
    if (!templates.value[templateId]) return false
    const nextTemplates = { ...templates.value }
    delete nextTemplates[templateId]
    templateCollection.value = createTemplateCollectionEnvelope(
      Object.values(nextTemplates),
      templateCollection.value.metadata,
    )
    return true
  }

  function getTemplate<
    TTemplate extends BioTemplateEnvelope<unknown> = BioTemplateEnvelope<unknown>,
  >(templateId: string): TTemplate | null {
    return (templates.value[templateId] as TTemplate | undefined) ?? null
  }

  function requireTemplate<
    TTemplate extends BioTemplateEnvelope<unknown> = BioTemplateEnvelope<unknown>,
  >(templateId: string): TTemplate {
    return ensureTemplateFromCollection<TTemplate>(templateCollection.value, templateId)
  }

  async function load(experimentId: number): Promise<TemplateCollectionEnvelope | null> {
    const data = await experimentSave.loadDesign(experimentId)
    return data === null ? null : apply(data)
  }

  async function loadCurrent(): Promise<TemplateCollectionEnvelope | null> {
    const data = await experimentSave.loadCurrentDesign()
    return data === null ? null : apply(data)
  }

  async function save(experimentId: number): Promise<boolean> {
    return experimentSave.saveDesign(
      experimentId,
      templateCollection.value as unknown as Record<string, unknown>,
    )
  }

  async function saveCurrent(): Promise<boolean> {
    return experimentSave.saveCurrentDesign(
      templateCollection.value as unknown as Record<string, unknown>,
    )
  }

  return {
    currentExperimentId: experimentSave.currentExperimentId,
    hasCurrentExperiment: experimentSave.hasCurrentExperiment,
    templateCollection,
    templates,
    metadata,
    templateIds,
    hasTemplates,
    isLoading: experimentSave.isLoading,
    isSaving: experimentSave.isSaving,
    error: experimentSave.error,
    lastLoadedAt: experimentSave.lastLoadedAt,
    lastSavedAt: experimentSave.lastSavedAt,
    apply,
    reset,
    setTemplate,
    removeTemplate,
    getTemplate,
    requireTemplate,
    load,
    loadCurrent,
    save,
    saveCurrent,
    requireCurrentExperimentId: experimentSave.requireCurrentExperimentId,
  }
}

function createInitialCollection(options: UseTemplateCollectionOptions): TemplateCollectionEnvelope {
  const initial = typeof options.initial === 'function' ? options.initial() : options.initial
  if (initial === undefined) return { templates: {} }
  return normalizeTemplateCollection(initial)
}

function normalizeTemplateCollection(
  value: unknown,
  metadata?: Record<string, unknown>,
): TemplateCollectionEnvelope {
  if (Array.isArray(value)) {
    return createTemplateCollectionEnvelope(value, metadata)
  }

  return createTemplateCollectionEnvelope(
    Object.values(extractTemplateCollection(value)),
    readCollectionMetadata(value) ?? metadata,
  )
}

function createTemplateCollectionEnvelope(
  templates: Array<BioTemplateEnvelope<unknown>>,
  metadata?: Record<string, unknown>,
): TemplateCollectionEnvelope {
  return metadata === undefined
    ? createTemplateCollection(templates)
    : createTemplateCollection(templates, metadata)
}

function readCollectionMetadata(value: unknown): Record<string, unknown> | undefined {
  if (
    typeof value !== 'object'
    || value === null
    || Array.isArray(value)
    || !('metadata' in value)
  ) {
    return undefined
  }

  const metadata = (value as { metadata?: unknown }).metadata
  if (
    typeof metadata === 'object'
    && metadata !== null
    && !Array.isArray(metadata)
  ) {
    return metadata as Record<string, unknown>
  }
  return undefined
}