import { FormRules } from 'element-plus'
import { IBaseForm } from './baseForm'

import { isValidKey, ObjectInterface } from '../../script/index'
import classComponents from './classComponents'
import {
    InputInterface,
    InputNumberInterface,
    SelectInterface,
    AutocompleteInterface,
    TreeSelectInterface,
    CascaderInterface,
    ButtonInterface,
    RadioInterface,
    CheckboxInterface,
    SliderInterface,
    SwitchInterface,
    TagInterface,
    DatePickerInterface,
    TimePickerInterface,
    DynamicInterface,
    AddFormInterface,
    UploadInterface,
    VueCronInterface
} from './index'

export interface IFormConfig {
    rule: Array<IBaseForm>,
    validate?: FormRules
}

type labelPosition = 'left' | 'right'

export interface IPropsConfig {
    ref?: string
    size?: string;
    labelWidth?: string
    labelI18n?: boolean
    tipsI18n?: boolean
    allCollapse?: boolean
    inline?: boolean
    validate?: FormRules
    disabled?: () => boolean
    validateCallback?: Function | undefined
    customFormStyle?: ObjectInterface | undefined
    labelPosition?: string
    gridColumns?: number
    mode?: string
    cardShadow?: string
}

export interface FormInterFace extends IFormConfig, IPropsConfig {
}

export interface CollapsesInterFace {
    title: string
    collapses: IBaseForm[]
    expandable: boolean
}
export class FormRule {
    rule: any[] = []
    // eslint-disable-next-line @typescript-eslint/no-useless-constructor
    constructor () {
    }
    setInputRule (rule: InputInterface) {
        return this.setRuleFn(rule)
    }
    setAutocompleteRule (rule: AutocompleteInterface) {
        return this.setRuleFn(rule)
    }
    setInputNumberRule (rule: InputNumberInterface) {
        return this.setRuleFn(rule)
    }
    setSelectRule (rule: SelectInterface) { // infoSelect & infoCustomSelect
        return this.setRuleFn(rule)
    }
    setTreeSelectRule (rule: TreeSelectInterface) {
        return this.setRuleFn(rule)
    }
    setCascaderRule (rule: CascaderInterface) {
        return this.setRuleFn(rule)
    }
    setButtonRule (rule: ButtonInterface) {
        return this.setRuleFn(rule)
    }
    setRadioRule (rule: RadioInterface) {
        return this.setRuleFn(rule)
    }
    setCheckboxRule (rule: CheckboxInterface) {
        return this.setRuleFn(rule)
    }
    setSliderRule (rule: SliderInterface) {
        return this.setRuleFn(rule)
    }
    setSwitchRule (rule: SwitchInterface) {
        return this.setRuleFn(rule)
    }
    setTagRule (rule: TagInterface) {
        return this.setRuleFn(rule)
    }
    setDatePickerRule (rule: DatePickerInterface) {
        return this.setRuleFn(rule)
    }
    setTimePickerRule (rule: TimePickerInterface) {
        return this.setRuleFn(rule)
    }
    setUploadRule (rule: UploadInterface) {
        return this.setRuleFn(rule)
    }
    setVueCronRule (rule: VueCronInterface) {
        return this.setRuleFn(rule)
    }
    setDynamicRule (rule: DynamicInterface) {
        return this.setRuleFn(rule)
    }
    protected setRuleFn (rule: ObjectInterface) {
        const rules = Reflect.construct((classComponents as any)[rule.type], [rule])
        this.rule.push(rules)
        return this
    }
}
export class FormConfig extends FormRule implements FormInterFace {
    // rule: Array<IBaseForm> = []
    rule: any[] = []
    size = ''
    validate: FormRules = {}
    labelI18n = false
    tipsI18n = false
    labelWidth: | string = '120px'
    // 值为 labelPosition 类型 被选值只能是left, right
    labelPosition: labelPosition = 'left'
    inline = false

    constructor (con: IPropsConfig) {
        super()
        for (const key in con) {
            if (isValidKey(key, con)) {
                this[key] = con[key]
            }
        }
    }
    disabled = (): boolean => false

    setRule (rule: any) {
        if (rule.type === 'infoSlot') {
            this.rule.push(rule)
            return
        }
        const rules = Reflect.construct((classComponents as any)[rule.type], [rule])
        // @ts-ignore
        this.rule.push(rules as IBaseForm)
    }

    setAddFormRule (rule: AddFormInterface) {
        return this.setRuleFn(rule)
    }

}