// oxlint-disable typescript/no-explicit-any

import type {
  BaseInputorContext,
  BaseInputorControllerOptions,
  BaseInputorSchema,
  InputorControllerInitializeHooks,
} from "./base.ts"
import { BaseInputorController } from "./base.ts"

export const SELECT_INPUTOR_TYPE_NAME = "select" as const
export type SelectInputorTypeName = typeof SELECT_INPUTOR_TYPE_NAME

export interface SelectOption<Value = any> {
  name: string
  label: string
  value: Value
  isSelected: boolean
  description?: string | undefined
  isDisabled?: boolean | undefined
}
export type SelectOptions<Value = any> = Array<SelectOption<Value>>
export type SelectInputorExternalValue<Value = any> = SelectOptions<Value>
export type SelectInputorInternalValue<Value = any> = SelectOptions<Value>
export interface SelectInputorSchema<Value = any> extends BaseInputorSchema<
  SelectInputorExternalValue<Value>
> {
  inputorTypeName: SelectInputorTypeName
}
export interface SelectInputorContext<Value = any> extends BaseInputorContext<
  SelectInputorExternalValue<Value>,
  SelectInputorInternalValue<Value>
> {}

export interface SelectInputorControllerOptions<Value = any> extends BaseInputorControllerOptions<
  SelectInputorExternalValue<Value>,
  SelectInputorSchema<Value>
> {
  /**
   * @description 是否允许取消选择。
   *
   * @default false
   */
  enableUnselect?: boolean
}
export class SelectInputorController<Value = any> extends BaseInputorController<
  SelectInputorExternalValue<Value>,
  SelectInputorInternalValue<Value>,
  SelectInputorSchema<Value>,
  SelectInputorContext<Value>
> {
  declare schemaType: SelectInputorSchema<Value>
  declare optionsType: SelectInputorControllerOptions<Value>
  declare constructorType: typeof SelectInputorController<Value>

  static inputorTypeName: SelectInputorTypeName = SELECT_INPUTOR_TYPE_NAME

  inputorTypeName: SelectInputorTypeName = SELECT_INPUTOR_TYPE_NAME
  voidExternalValue = [] as SelectInputorExternalValue<Value>
  voidInternalValue = [] as SelectInputorInternalValue<Value>

  private enableUnselect!: boolean

  constructor(options: SelectInputorControllerOptions<Value>) {
    super(options)
  }

  protected override async initialize(
    options: SelectInputorControllerOptions<Value>,
    hooks?: InputorControllerInitializeHooks,
  ): Promise<void> {
    await super.initialize(options, {
      ...hooks,
      onSchemaReady: async () => {
        this.enableUnselect = options.enableUnselect ?? false
        await hooks?.onSchemaReady?.()
      },
    })
  }

  async select(name: string): Promise<void> {
    if (this.isDisabled === true) {
      return
    }

    const internalValue = this.getInternalValue()
    const disabledSelectedName = internalValue.find((option) => {
      return option.isSelected && option.isDisabled === true
    })?.name
    const updatedInternalValue = internalValue.map((option) => {
      const { name: optionName, isSelected: _isSelected, isDisabled } = option

      if (disabledSelectedName !== undefined) {
        return {
          ...option,
          isSelected: optionName === disabledSelectedName,
        }
      }

      if (isDisabled === true) {
        return option
      }

      if (optionName !== name) {
        return {
          ...option,
          isSelected: false,
        }
      }

      return {
        ...option,
        isSelected: this.enableUnselect ? !option.isSelected : true,
      }
    })
    await this.updateInternalValue(updatedInternalValue)
  }
}