import type {
  ComputedRef,
  Ref,
} from 'vue'
import type {
  PillNavItem,
  SidebarBadgeTone,
  SidebarToolSection,
  SidebarToolSectionAction,
  SelectOption,
  SettingsModalSchema,
  TopBarSettingsConfig,
} from '../types'
import type { AccessPolicy } from '../permissions'
import type {
  FieldCondition,
  FieldValidation,
  FormFieldSchema,
  FormFieldType,
  FormSchema,
  FormSectionSchema,
} from '../types/form-builder'
import type { WellConcentration } from './useDoseCalculator'

export type ControlOptionValue = string | number | boolean
export type ControlOption = ControlOptionValue | SelectOption<unknown>
export type ControlPrimitive = string | number | boolean
export type ControlShorthand = ControlPrimitive | readonly ControlOption[]
export type ControlInput = ControlDefinition | ControlShorthand

export interface ControlSectionConfig {
  id?: string
  label?: string
  title?: string
  description?: string
  subtitle?: string
  icon?: string | string[]
  iconColor?: string
  iconBg?: string
  badge?: string | number
  badgeTone?: SidebarBadgeTone
  actions?: SidebarToolSectionAction[]
  columns?: 1 | 2 | 3
  condition?: FieldCondition
  /** The access policy. */
  access?: AccessPolicy
  defaultOpen?: boolean
  showToggle?: boolean
}

export interface ControlViewConfig {
  label?: string
  icon?: string
  to?: string
  href?: string
  disabled?: boolean
  children?: PillNavItem['children']
}

export interface ControlSidebarConfig extends Omit<ControlSectionConfig, 'id' | 'title' | 'description' | 'columns'> {
  enabled?: boolean
}

export interface ControlDefinition {
  type?: FormFieldType
  label?: string
  default?: unknown
  defaultValue?: unknown
  placeholder?: string
  hint?: string
  icon?: string | string[]
  iconColor?: string
  iconBg?: string
  size?: 'sm' | 'md' | 'lg'
  disabled?: boolean
  readonly?: boolean
  required?: boolean | string
  min?: number | { value: number; message: string }
  max?: number | { value: number; message: string }
  minLength?: number | { value: number; message: string }
  maxLength?: number | { value: number; message: string }
  email?: boolean | string
  pattern?: string | { value: string; message: string }
  validation?: FieldValidation
  condition?: FieldCondition
  /** The access policy. */
  access?: AccessPolicy
  options?: readonly ControlOption[]
  section?: string
  sectionLabel?: string
  sectionDescription?: string
  sectionSubtitle?: string
  view?: string
  order?: number
  colSpan?: number
  props?: Record<string, unknown>
  sidebar?: boolean | ControlSidebarConfig
}

export type ControlSchema = Record<string, ControlInput>
export type ControlFormSchema = Extract<FormSchema, { sections: FormSectionSchema[] }>

export interface ControlSchemaOptions {
  view?: string
  views?: Record<string, ControlViewConfig>
  section?: string
  sectionLabel?: string
  sections?: Record<string, ControlSectionConfig>
  columns?: 1 | 2 | 3
  submitLabel?: string
  cancelLabel?: string
  showCancel?: boolean
}

export interface ControlWorkspaceOptions extends ControlSchemaOptions {
  initialValues?: Record<string, unknown>
  topBarSettings?: Omit<TopBarSettingsConfig, 'schema' | 'controls' | 'controlOptions' | 'values'>
}

export interface ControlModelSectionConfig extends ControlSectionConfig {
  controls: ControlSchema
  sidebar?: boolean | ControlSidebarConfig
}

export interface ControlModelViewConfig extends ControlViewConfig {
  controls?: ControlSchema
  section?: string
  sectionLabel?: string
  sectionDescription?: string
  sections?: Record<string, ControlModelSectionConfig>
}

export interface ControlModel extends Omit<ControlWorkspaceOptions, 'sections' | 'views'> {
  controls?: ControlSchema
  sections?: Record<string, ControlModelSectionConfig>
  views?: Record<string, ControlModelViewConfig>
  /** Optional SDK component bindings returned with generated component props for custom workspace slots. */
  componentBindings?: ControlComponentBindingsConfig
  /** Alias for componentBindings in raw control models. */
  components?: ControlComponentBindingsConfig
  /** Optional ControlWorkspaceView componentProps mapping returned with the generated controls/options. */
  componentProps?: ControlComponentPropsMap
  /** Optional named componentProps mappings returned for multiple SDK components. */
  componentPropsById?: ControlComponentPropsByIdMap
}

export interface ControlModelBinding {
  controls: ControlSchema
  controlOptions: ControlWorkspaceOptions
  componentBindings?: ControlComponentBindingsConfig
  componentProps?: ControlComponentPropsMap
  componentPropsById?: ControlComponentPropsByIdMap
}

export interface ControlSidebarBinding {
  panels: Record<string, SidebarToolSection[]>
  forms: Record<string, ControlFormSchema>
  viewIds: string[]
  viewItems: PillNavItem[]
  defaultView: string
}

export interface ControlFormBinding {
  schema: ControlFormSchema
}

export interface ControlSettingsBinding {
  schema: SettingsModalSchema
}

export interface ControlTopBarSettingsBinding {
  showSettings: true
  settingsConfig: TopBarSettingsConfig
}

export interface ControlWorkspaceFormBinding extends ControlFormBinding {
  modelValue: Record<string, unknown>
  'onUpdate:modelValue': (values: Record<string, unknown>) => void
}

export interface ControlWorkspaceSidebarBinding extends ControlSidebarBinding {
  activeView: string
  modelValue: Record<string, unknown>
  'onUpdate:modelValue': (values: Record<string, unknown>) => void
  values: Record<string, unknown>
  'onUpdate:values': (values: Record<string, unknown>) => void
}

export interface ControlWorkspaceTopBarSettingsBinding extends ControlTopBarSettingsBinding {
  onSettingsValuesChange: (values: Record<string, unknown>) => void
}

export interface ControlWorkspacePillNavBinding {
  items: PillNavItem[]
  currentItemId: string
  onSelect: (item: PillNavItem) => void
}

export interface ControlWorkspaceTopBarBinding extends ControlWorkspaceTopBarSettingsBinding {
  pillNav: PillNavItem[]
  currentPillId: string
  onPillSelect: (item: PillNavItem) => void
}

export type ControlWorkspaceAppTopBarPillBinding = ControlWorkspaceTopBarBinding

export interface ControlWorkspaceComponentBindings {
  form: ControlWorkspaceFormBinding
  sidebar: ControlWorkspaceSidebarBinding
  topBar: ComputedRef<ControlWorkspaceTopBarBinding>
  topBarSettings: ControlWorkspaceTopBarSettingsBinding
  pillNav: ControlWorkspacePillNavBinding
  componentBindings: ComputedRef<ControlComponentBinding[]>
  componentBindingsById: ComputedRef<ControlComponentBindingsById>
  componentProps: ComputedRef<Record<string, unknown>>
  componentPropsById: ComputedRef<Record<string, Record<string, unknown>>>
}

export type ControlComponentPropSource<TValues extends Record<string, unknown> = Record<string, unknown>> =
  | (keyof TValues & string)
  | ((values: TValues) => unknown)

export type ControlComponentPropsMap<TValues extends Record<string, unknown> = Record<string, unknown>> =
  | readonly (keyof TValues & string)[]
  | Record<string, ControlComponentPropSource<TValues>>

export type ControlComponentPropsByIdMap<TValues extends Record<string, unknown> = Record<string, unknown>> =
  Record<string, ControlComponentPropsMap<TValues>>

export interface ControlComponentBindingConfig<TValues extends Record<string, unknown> = Record<string, unknown>> {
  id?: string
  component: string
  props?: ControlComponentPropsMap<TValues>
}

export interface ControlComponentBindingRecordConfig<TValues extends Record<string, unknown> = Record<string, unknown>> {
  component: string
  props?: ControlComponentPropsMap<TValues>
}

export type ControlComponentBindingsConfig<TValues extends Record<string, unknown> = Record<string, unknown>> =
  | readonly ControlComponentBindingConfig<TValues>[]
  | Record<string, ControlComponentBindingRecordConfig<TValues>>

export interface ControlComponentBinding {
  id: string
  component: string
  props: Record<string, unknown>
}

export type ControlComponentBindingsById = Record<string, ControlComponentBinding>

export interface WellPlateControlPropsOptions<TValues extends Record<string, unknown> = Record<string, unknown>> {
  selectedWells?: ControlComponentPropSource<TValues>
  format?: ControlComponentPropSource<TValues>
  wells?: ControlComponentPropSource<TValues>
  disabled?: ControlComponentPropSource<TValues>
  readonly?: ControlComponentPropSource<TValues>
  showLegend?: ControlComponentPropSource<TValues>
  /** @deprecated WellPlate `showSampleTypeIndicator` is a no-op since MINT 1.3; removed in MINT 1.4. */
  showSampleTypeIndicator?: ControlComponentPropSource<TValues>
  /** Listener for WellPlate v-model updates. Set false to keep generated props one-way. */
  onUpdateModelValue?: ((values: TValues) => (wellIds: string[]) => void) | false
}

export interface DoseCalculatorControlPropsOptions<TValues extends Record<string, unknown> = Record<string, unknown>> {
  mode?: ControlComponentPropSource<TValues>
  targetWells?: ControlComponentPropSource<TValues>
  /** Control value key used by the default apply-to-wells handler. */
  wells?: ControlComponentPropSource<TValues>
  disabled?: ControlComponentPropSource<TValues>
  molecularWeight?: ControlComponentPropSource<TValues>
  /** Listener for DoseCalculator apply-to-wells. Set false to keep generated props one-way. */
  onApplyToWells?: ((values: TValues) => (results: WellConcentration[]) => void) | false
}

export interface WellPlateDoseControlPropsOptions<TValues extends Record<string, unknown> = Record<string, unknown>> {
  plateId?: string
  doseId?: string
  plate?: WellPlateControlPropsOptions<TValues>
  dose?: DoseCalculatorControlPropsOptions<TValues>
}

export interface DoseDesignControlModelOptions {
  viewId?: string
  viewLabel?: string
  sectionId?: string
  sectionLabel?: string
  sectionDescription?: string
  selectedWells?: readonly string[]
  plateFormat?: number
  plateFormats?: readonly number[]
  doseMode?: 'serial' | 'dilution' | 'conversion'
  doseModes?: readonly ('serial' | 'dilution' | 'conversion')[]
  disabled?: boolean
  includeMolecularWeight?: boolean
  molecularWeight?: number
  componentProps?: WellPlateDoseControlPropsOptions
}

export interface UseControlSchemaReturn<TControls extends ControlSchema> {
  controls: TControls
  fields: FormFieldSchema[]
  formSchema: ControlFormSchema
  form: ControlFormBinding
  settingsSchema: SettingsModalSchema
  settings: ControlSettingsBinding
  topBarSettingsConfig: TopBarSettingsConfig
  topBarSettings: ControlTopBarSettingsBinding
  sidebarPanels: Record<string, SidebarToolSection[]>
  viewIds: string[]
  viewItems: PillNavItem[]
  defaultView: string
  sectionSchemas: Record<string, ControlFormSchema>
  sidebar: ControlSidebarBinding
  initialValues: ControlValues<TControls>
  sectionSchema: (sectionId: string) => ControlFormSchema
}

export interface UseControlWorkspaceReturn<TControls extends ControlSchema>
  extends Omit<UseControlSchemaReturn<TControls>, 'form' | 'sidebar' | 'topBarSettings'> {
  schema: UseControlSchemaReturn<TControls>
  values: ControlValues<TControls> & Record<string, unknown>
  activeView: Ref<string>
  form: ControlWorkspaceFormBinding
  sidebar: ControlWorkspaceSidebarBinding
  topBar: ComputedRef<ControlWorkspaceTopBarBinding>
  pillNav: ControlWorkspacePillNavBinding
  topBarSettings: ControlWorkspaceTopBarSettingsBinding
  bindings: ControlWorkspaceComponentBindings
  componentBindings: ComputedRef<ControlComponentBinding[]>
  componentBindingsById: ComputedRef<ControlComponentBindingsById>
  componentProps: ComputedRef<Record<string, unknown>>
  componentPropsById: ComputedRef<Record<string, Record<string, unknown>>>
  setActiveView: (viewId: string) => void
  setValues: (values: Record<string, unknown>) => void
  resetValues: (values?: Record<string, unknown>) => void
  getComponentProps: (
    mapping?: ControlComponentPropsMap<ControlValues<TControls> & Record<string, unknown>>
  ) => Record<string, unknown>
  getComponentPropsById: (
    mappings?: ControlComponentPropsByIdMap<ControlValues<TControls> & Record<string, unknown>>
  ) => Record<string, Record<string, unknown>>
  getComponentBindings: (
    bindings?: ControlComponentBindingsConfig<ControlValues<TControls> & Record<string, unknown>>
  ) => ControlComponentBinding[]
  getComponentBindingsById: (
    bindings?: ControlComponentBindingsConfig<ControlValues<TControls> & Record<string, unknown>>
  ) => ControlComponentBindingsById
}

export type ControlValues<TControls extends ControlSchema> = {
  [K in keyof TControls]: ControlValue<TControls[K]>
}

type ControlValue<TControl> =
  TControl extends { default: infer TDefault }
    ? TDefault
    : TControl extends { defaultValue: infer TDefaultValue }
      ? TDefaultValue
      : TControl extends readonly [infer First, ...unknown[]]
        ? OptionValue<First>
        : TControl extends ControlPrimitive
          ? TControl
          : unknown

type OptionValue<TOption> = TOption extends SelectOption<infer TValue> ? TValue : TOption