import { ref, watch, unref, type Ref } from 'vue'
import type { ProFormSchema, ProFormProps, FormActionType } from '../types'

export interface UseFormProps extends ProFormProps {
  schemas?: ProFormSchema[]
}

/** 支持 ref/computed 的 props（参考 Vben Admin：参数 props 内的值可以是 computed 或者 ref 类型） */
export type UseFormPropsReactive = UseFormProps | Ref<UseFormProps | undefined>

export interface UseFormReturn {
  /** 用于 @register，接收表单实例的 formAction */
  register: (formAction: FormActionType) => void
  formAction: { value: FormActionType | null }
  getFieldsValue: () => Record<string, unknown>
  setFieldsValue: (values: Record<string, unknown>) => Promise<void>
  resetFields: () => Promise<void>
  validate: (nameList?: string[]) => Promise<Record<string, unknown> | { errors: Record<string, unknown> }>
  validateFields: (nameList?: string[]) => Promise<unknown>
  submit: () => Promise<void>
  scrollToField: (name: string, options?: import('../types').ScrollToFieldOptions) => Promise<void>
  clearValidate: (name?: string | string[]) => void
  updateSchema: (data: Partial<ProFormSchema> | Partial<ProFormSchema>[]) => Promise<void>
  appendSchemaByField: (schema: ProFormSchema, prefixField?: string, first?: boolean) => Promise<void>
  removeSchemaByField: (field: string | string[]) => Promise<void>
  setProps: (props: Partial<ProFormProps>) => Promise<void>
  getComponentInstance: FormActionType['getComponentInstance']
  getFieldOptions: FormActionType['getFieldOptions']
  isFieldLoading: FormActionType['isFieldLoading']
}

export function useForm(props?: UseFormPropsReactive): [UseFormReturn['register'], Omit<UseFormReturn, 'register'>] {
  const formAction = ref<FormActionType | null>(null)
  const formPropsRef = ref<UseFormProps | undefined>(props ? unref(props as Ref<UseFormProps | undefined>) : undefined)

  const getFormProps = () => (props ? unref(props as Ref<UseFormProps | undefined>) : undefined) as UseFormProps | undefined

  const register = (action: FormActionType) => {
    formAction.value = action
    const formProps = getFormProps()
    if (formProps && Object.keys(formProps).length > 0) {
      action.setProps(formProps)
    }
  }

  if (props) {
    watch(
      () => getFormProps(),
      (formProps) => {
        formPropsRef.value = formProps
        if (formProps && formAction.value) {
          formAction.value.setProps(formProps)
        }
      },
      { deep: true }
    )
  }

  const getFieldsValue = () => formAction.value?.getFieldsValue() ?? {}

  const setFieldsValue = async (values: Record<string, unknown>) => {
    await formAction.value?.setFieldsValue(values)
  }

  const resetFields = async () => {
    await formAction.value?.resetFields()
  }

  const validate = (nameList?: string[]) =>
    formAction.value?.validate(nameList) ?? Promise.resolve({} as Record<string, unknown>)

  const validateFields = (nameList?: string[]) =>
    formAction.value?.validateFields(nameList) ?? Promise.resolve()

  const submit = () => formAction.value?.submit() ?? Promise.resolve()

  const scrollToField = (name: string, options?: import('../types').ScrollToFieldOptions) =>
    formAction.value?.scrollToField(name, options) ?? Promise.resolve()

  const clearValidate = (name?: string | string[]) => {
    formAction.value?.clearValidate(name)
  }

  const updateSchema = (data: Partial<ProFormSchema> | Partial<ProFormSchema>[]) =>
    formAction.value?.updateSchema(data) ?? Promise.resolve()

  const appendSchemaByField = (schema: ProFormSchema, prefixField?: string, first?: boolean) =>
    formAction.value?.appendSchemaByField(schema, prefixField, first) ?? Promise.resolve()

  const removeSchemaByField = (field: string | string[]) =>
    formAction.value?.removeSchemaByField(field) ?? Promise.resolve()

  const setProps = async (formProps: Partial<ProFormProps>) => {
    formPropsRef.value = { ...formPropsRef.value, ...formProps }
    await formAction.value?.setProps(formProps)
  }

  const getComponentInstance: FormActionType['getComponentInstance'] = (field) =>
    formAction.value?.getComponentInstance(field) ?? null

  function getFieldOptions(field: string): Array<{ label: string; value: unknown }>
  function getFieldOptions(field: string, raw: false): Array<{ label: string; value: unknown }>
  function getFieldOptions(field: string, raw: true): unknown[]
  function getFieldOptions(field: string, raw = false): Array<{ label: string; value: unknown }> | unknown[] {
    if (!formAction.value) return []
    if (raw) return formAction.value.getFieldOptions(field, true)
    return formAction.value.getFieldOptions(field)
  }

  const isFieldLoading: FormActionType['isFieldLoading'] = (field) =>
    formAction.value?.isFieldLoading(field) ?? false

  const result: UseFormReturn = {
    register,
    formAction,
    getFieldsValue,
    setFieldsValue,
    resetFields,
    validate,
    validateFields,
    submit,
    scrollToField,
    clearValidate,
    updateSchema,
    appendSchemaByField,
    removeSchemaByField,
    setProps,
    getComponentInstance,
    getFieldOptions,
    isFieldLoading,
  }

  return [register, result]
}