import { Input } from 'antd-mobile'
import BasicField from '../Basic'
import { FormControl } from '../../form'
import type {
  IBasicInputProps,
  ruleItem,
  ValidRepeatEventFcType
} from '@/types'
class BasicInput extends BasicField {
  props: IBasicInputProps
  validRepeatEvent?: ValidRepeatEventFcType
  constructor(
    props: IBasicInputProps,
    form: FormControl,
    validRepeatEvent?: ValidRepeatEventFcType
  ) {
    super(props, form)
    this.props = props
    this.form = form
    this.validRepeatEvent = validRepeatEvent
    this.rules = this.getRules(props.componentConfig)
  }
  getRules(config: IBasicInputProps['componentConfig']) {
    const rules = []
    if (config.required) {
      rules.push({
        required: true,
        message: `请输入${this.name}`
      })
    }
    const numberReg = /^(([0-9]*(\.[0-9]{1,})$)|([0-9]+$))/
    const phoneReg = /^1\d{10}$/
    const emailReg =
      /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9]+(\.[a-zA-Z0-9-]+)*\.([a-zA-Z]{2,})$/
    const testList: RegExp[] = []
    if (config.isNumber) testList.push(numberReg)
    if (config.isPhone) testList.push(phoneReg)
    if (config.isMail) testList.push(emailReg)

    rules.push(
      {
        validator: (_: any, value: string) => {
          if (!value) {
            return Promise.resolve()
          }
          const isTest = testList.some(item => item.test(value))
          if (!isTest && testList.length) {
            return Promise.reject(new Error('请填写正确的格式'))
          }
          if (config?.rulesOptions?.length) {
            const rulesList = config?.rulesOptions.filter((item: ruleItem) =>
              (config?.selectRules || []).includes(item.id)
            )

            const hasRule = rulesList.some(item => {
              const reg = new RegExp(item.value)
              return reg.test(value)
            })
            if (rulesList.length && !hasRule) {
              const rulesItem = rulesList.find(item => {
                const reg = new RegExp(item.value)
                return !reg.test(value)
              })
              return Promise.reject(new Error(rulesItem?.errorText))
            }
          }
          return Promise.resolve()
        }
      },
      {
        validateTrigger: 'onBlur',
        validator: async (_: any, value: string) => {
          if (!value) {
            return Promise.resolve()
          }
          if (config.replaceWarn && this.validRepeatEvent) {
            const result = await this.validRepeatEvent?.({
              needCheckComponentList: [
                {
                  componentKey: `${this.props.uniqueKey}_input`,
                  componentValue: value
                }
              ]
            })
            const { error, isRepeat } = result
            if (error) {
              return Promise.reject(error)
            }
            if (isRepeat) {
              return Promise.reject('内容已存在，不能重复提交')
            }
          }

          return Promise.resolve()
        }
      }
    )

    return rules
  }
  render() {
    return (
      <Input
        onBlur={() => {
          if (this.props.componentConfig?.replaceWarn) {
            // eslint-disable-next-line @typescript-eslint/no-floating-promises
            this.form.form?.validateFields([this.props.uniqueKey])
          }
        }}
        disabled={this.props.componentConfig?.disabled}
        placeholder={`请输入${this.name}`}
      />
    )
  }
}

export default BasicInput