import { computed, reactive, watch } from 'vue'
import type { ComputedRef } from 'vue'
import type { PillNavItem } from '../types'
import type {
  ControlComponentBinding,
  ControlComponentBindingsById,
  ControlComponentBindingsConfig,
  ControlComponentPropsByIdMap,
  ControlComponentPropsMap,
  ControlModel,
  ControlModelBinding,
  ControlSchema,
  ControlWorkspaceOptions,
} from '../composables/useControlSchema'
import {
  controlValuesToComponentBindings,
  controlValuesToComponentBindingsById,
  controlValuesToComponentProps,
  controlsToViewItems,
  getControlDefaults,
  getDefaultControlView,
  mergeControlWorkspaceOptions,
  resolveControlModel,
} from '../composables/useControlSchema'

export interface PluginWorkspaceControlsOptions {
  model: () => ControlModel | ControlModelBinding | undefined
  controls: () => ControlSchema | undefined
  controlOptions: () => ControlWorkspaceOptions
  modelValue: () => Record<string, unknown> | undefined
  values: () => Record<string, unknown> | undefined
  componentBindings: () => ControlComponentBindingsConfig | undefined
  componentProps: () => ControlComponentPropsMap | undefined
  componentPropsById: () => ControlComponentPropsByIdMap | undefined
  emitValues: (values: Record<string, unknown>) => void
}

export interface PluginWorkspaceControls {
  resolvedModel: ComputedRef<ControlModelBinding | undefined>
  resolvedControls: ComputedRef<ControlSchema | undefined>
  resolvedControlOptions: ComputedRef<ControlWorkspaceOptions>
  generatedPillNav: ComputedRef<PillNavItem[]>
  generatedDefaultView: ComputedRef<string>
  internalControlValues: Record<string, unknown>
  resolvedComponentBindings: ComputedRef<ControlComponentBinding[]>
  resolvedComponentBindingsById: ComputedRef<ControlComponentBindingsById>
  resolvedComponentProps: ComputedRef<Record<string, unknown>>
  resolvedComponentPropsById: ComputedRef<Record<string, Record<string, unknown>>>
  handleControlValuesUpdate: (values: Record<string, unknown>) => void
}

export function usePluginWorkspaceControls(
  options: PluginWorkspaceControlsOptions,
): PluginWorkspaceControls {
  const resolvedModel = computed<ControlModelBinding | undefined>(() =>
    resolveControlModel(options.model()),
  )

  const resolvedControls = computed<ControlSchema | undefined>(() =>
    options.controls() ?? resolvedModel.value?.controls,
  )

  const resolvedControlOptions = computed<ControlWorkspaceOptions>(() =>
    mergeControlWorkspaceOptions(resolvedModel.value?.controlOptions ?? {}, options.controlOptions()),
  )

  const externalControlValues = computed(() => options.modelValue() ?? options.values())
  const internalControlValues = reactive<Record<string, unknown>>({})
  let syncingControlValues = false

  const generatedControlDefaults = computed<Record<string, unknown>>(() => {
    if (!resolvedControls.value) return {}
    return {
      ...getControlDefaults(resolvedControls.value),
      ...(resolvedControlOptions.value.initialValues ?? {}),
    }
  })

  function replaceControlValues(values: Record<string, unknown>) {
    for (const key of Object.keys(internalControlValues)) {
      if (!(key in values)) {
        delete internalControlValues[key]
      }
    }
    Object.assign(internalControlValues, values)
  }

  function emitControlValues() {
    options.emitValues({ ...internalControlValues })
  }

  function syncResolvedControlValues() {
    syncingControlValues = true
    replaceControlValues({
      ...generatedControlDefaults.value,
      ...(externalControlValues.value === undefined ? internalControlValues : externalControlValues.value),
    })
    syncingControlValues = false
  }

  function handleControlValuesUpdate(values: Record<string, unknown>) {
    syncingControlValues = true
    replaceControlValues({
      ...generatedControlDefaults.value,
      ...values,
    })
    syncingControlValues = false
    emitControlValues()
  }

  const resolvedComponentBindings = computed(() =>
    controlValuesToComponentBindings(
      internalControlValues,
      options.componentBindings() ?? resolvedModel.value?.componentBindings,
    ),
  )

  const resolvedComponentBindingsById = computed(() =>
    controlValuesToComponentBindingsById(
      internalControlValues,
      options.componentBindings() ?? resolvedModel.value?.componentBindings,
    ),
  )

  const resolvedComponentProps = computed(() => {
    const mapping = options.componentProps() ?? resolvedModel.value?.componentProps
    return mapping === undefined ? {} : controlValuesToComponentProps(internalControlValues, mapping)
  })

  const resolvedComponentPropsById = computed(() => {
    const mappings = options.componentPropsById() ?? resolvedModel.value?.componentPropsById
    if (mappings === undefined) return {}

    return Object.fromEntries(
      Object.entries(mappings).map(([id, mapping]) => [
        id,
        controlValuesToComponentProps(internalControlValues, mapping),
      ]),
    )
  })

  const generatedPillNav = computed<PillNavItem[]>(() => {
    if (!resolvedControls.value) return []
    return controlsToViewItems(resolvedControls.value, resolvedControlOptions.value)
  })

  const generatedDefaultView = computed(() => {
    if (!resolvedControls.value) return ''
    return getDefaultControlView(resolvedControls.value, resolvedControlOptions.value)
  })

  syncResolvedControlValues()

  watch(
    [generatedControlDefaults, externalControlValues],
    syncResolvedControlValues,
    { deep: true },
  )

  watch(
    internalControlValues,
    () => {
      if (syncingControlValues) return
      emitControlValues()
    },
    { deep: true, flush: 'sync' },
  )

  return {
    resolvedModel,
    resolvedControls,
    resolvedControlOptions,
    generatedPillNav,
    generatedDefaultView,
    internalControlValues,
    resolvedComponentBindings,
    resolvedComponentBindingsById,
    resolvedComponentProps,
    resolvedComponentPropsById,
    handleControlValuesUpdate,
  }
}