import { useEffect, useRef } from 'react'

type AsyncAction = () => Promise<unknown>
type ProjectAction = (projectId: string) => Promise<unknown>

interface WorkbenchBootstrapOptions {
  restrictedMode?: boolean
  /** Het werkblad dat nu open staat. Bepaalt wat er geladen mag worden. */
  activeWorkspace?: string
  /** Meldt een mislukte laadactie, zodat de gebruiker het verschil ziet tussen
      "er is niets" en "het is niet gelukt". */
  onLoadError?: (onderdeel: string, fout: unknown) => void
  selectedProjectId: string | null
  selectedDetectionRunId: string
  detectionClassFilter: string
  detectionMinConfidenceFilter: number
  selectedSegmentationRunId: string
  segmentationClassFilter: string
  segmentationMinConfidenceFilter: number
  loadProjects: AsyncAction
  loadCapabilities: AsyncAction
  loadDetectionModels: AsyncAction
  loadSegmentationModels: AsyncAction
  loadProjectData: ProjectAction
  loadDetectionRuns: ProjectAction
  loadSegmentationRuns: ProjectAction
  loadQualityChecks: ProjectAction
  loadExports: ProjectAction
  loadDetectionResults: AsyncAction
  loadSegmentationResults: AsyncAction
  resetProjectData: () => void
  resetDatasetForProject: () => void
  resetDetectionForProject: () => void
  resetSegmentationForProject: () => void
  resetExportsForProject: () => void
}

export function useWorkbenchBootstrap({
  restrictedMode = false,
  activeWorkspace = 'map',
  onLoadError,
  selectedProjectId,
  selectedDetectionRunId,
  detectionClassFilter,
  detectionMinConfidenceFilter,
  selectedSegmentationRunId,
  segmentationClassFilter,
  segmentationMinConfidenceFilter,
  loadProjects,
  loadCapabilities,
  loadDetectionModels,
  loadSegmentationModels,
  loadProjectData,
  loadDetectionRuns,
  loadSegmentationRuns,
  loadQualityChecks,
  loadExports,
  loadDetectionResults,
  loadSegmentationResults,
  resetProjectData,
  resetDatasetForProject,
  resetDetectionForProject,
  resetSegmentationForProject,
  resetExportsForProject,
}: WorkbenchBootstrapOptions): void {
  const foutMelder = useRef(onLoadError)
  foutMelder.current = onLoadError

  // Een mislukte laadactie werd overal met .catch(() => null) weggeslikt. De
  // gebruiker zag dan "Nog geen bronnen beschikbaar", precies hetzelfde scherm
  // als wanneer er echt niets is. Nu wordt de fout doorgegeven.
  const meld = (onderdeel: string) => (fout: unknown) => {
    foutMelder.current?.(onderdeel, fout)
    return null
  }

  useEffect(() => {
    loadProjects().catch(meld('werkruimtes'))
  }, [restrictedMode])

  useEffect(() => {
    if (activeWorkspace !== 'system') return
    loadCapabilities().catch(meld('bronkoppelingen'))
  }, [restrictedMode, activeWorkspace])

  useEffect(() => {
    if (activeWorkspace !== 'ai') return
    loadDetectionModels().catch(meld('detectiemodellen'))
    loadSegmentationModels().catch(meld('segmentatiemodellen'))
  }, [restrictedMode, activeWorkspace])

  useEffect(() => {
    if (!selectedProjectId) {
      resetProjectData()
      resetDatasetForProject()
      resetDetectionForProject()
      resetSegmentationForProject()
      resetExportsForProject()
      return
    }
    resetProjectData()
    resetDatasetForProject()
    resetDetectionForProject()
    resetSegmentationForProject()
    resetExportsForProject()
    loadProjectData(selectedProjectId).catch(meld('gebieden en bronnen'))
  }, [restrictedMode, selectedProjectId])

  useEffect(() => {
    if (!selectedProjectId || activeWorkspace !== 'analysis') return
    loadQualityChecks(selectedProjectId).catch(meld('kwaliteitscontroles'))
  }, [restrictedMode, selectedProjectId, activeWorkspace])

  useEffect(() => {
    if (!selectedProjectId || activeWorkspace !== 'ai') return
    loadDetectionRuns(selectedProjectId).catch(meld('detectieruns'))
    loadSegmentationRuns(selectedProjectId).catch(meld('segmentatieruns'))
  }, [restrictedMode, selectedProjectId, activeWorkspace])

  useEffect(() => {
    if (!selectedProjectId || activeWorkspace !== 'exports') return
    loadExports(selectedProjectId).catch(meld('downloads'))
  }, [restrictedMode, selectedProjectId, activeWorkspace])

  useEffect(() => {
    if (activeWorkspace !== 'ai') return
    loadDetectionResults().catch(meld('detectieresultaten'))
  }, [restrictedMode, activeWorkspace, selectedDetectionRunId, detectionClassFilter, detectionMinConfidenceFilter])

  useEffect(() => {
    if (activeWorkspace !== 'ai') return
    loadSegmentationResults().catch(meld('segmentatieresultaten'))
  }, [restrictedMode, activeWorkspace, selectedSegmentationRunId, segmentationClassFilter, segmentationMinConfidenceFilter])
}