import type { FormRule } from '../../types/components/form'

/**
 * 内置验证规则
 */
export const builtInRules = {
  // 必填规则
  required: (message = '该字段是必填项'): FormRule => ({
    required: true,
    message
  }),

  // 邮箱规则
  email: (message = '请输入有效的邮箱地址'): FormRule => ({
    type: 'email',
    pattern: /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/,
    message
  }),

  // 手机号规则
  phone: (message = '请输入有效的手机号码'): FormRule => ({
    type: 'phone',
    pattern: /^1[3-9]\d{9}$/,
    message
  }),

  // URL规则
  url: (message = '请输入有效的URL地址'): FormRule => ({
    type: 'url',
    pattern: /^(https?:\/\/)?([\da-z.-]+)\.([a-z.]{2,6})([/\w .-]*)*\/?$/,
    message
  }),

  // 身份证规则
  idcard: (message = '请输入有效的身份证号码'): FormRule => ({
    type: 'idcard',
    pattern: /(^\d{15}$)|(^\d{17}([0-9]|X|x)$)/,
    message
  }),

  // 数字规则
  number: (message = '请输入数字'): FormRule => ({
    type: 'number',
    pattern: /^-?\d+(\.\d+)?$/,
    message
  }),

  // 整数规则
  integer: (message = '请输入整数'): FormRule => ({
    type: 'integer',
    pattern: /^-?\d+$/,
    message
  }),

  // 最小值
  min: (value: number, message?: string): FormRule => ({
    minValue: value,
    message: message || `不能小于 ${value}`
  }),

  // 最大值
  max: (value: number, message?: string): FormRule => ({
    maxValue: value,
    message: message || `不能大于 ${value}`
  }),

  // 最小长度
  minLength: (value: number, message?: string): FormRule => ({
    min: value,
    message: message || `长度不能少于 ${value} 个字符`
  }),

  // 最大长度
  maxLength: (value: number, message?: string): FormRule => ({
    max: value,
    message: message || `长度不能超过 ${value} 个字符`
  }),

  // 范围
  range: (min: number, max: number, message?: string): FormRule => ({
    minValue: min,
    maxValue: max,
    message: message || `请输入 ${min} 到 ${max} 之间的值`
  }),

  // 长度范围
  rangeLength: (min: number, max: number, message?: string): FormRule => ({
    min: min,
    max: max,
    message: message || `长度应在 ${min} 到 ${max} 个字符之间`
  }),

  // 正则表达式
  pattern: (pattern: RegExp, message: string): FormRule => ({
    pattern,
    message
  })
}

/**
 * 验证器函数
 */
export const validators = {
  // 必填验证
  required(value: any, rule: FormRule): boolean | string {
    if (rule.required) {
      if (value === undefined || value === null || value === '') {
        return false
      }
      if (Array.isArray(value) && value.length === 0) {
        return false
      }
      if (typeof value === 'string' && value.trim() === '' && !rule.whitespace) {
        return false
      }
    }
    return true
  },

  // 正则验证
  pattern(value: any, rule: FormRule): boolean | string {
    if (rule.pattern && value) {
      const strValue = String(value)
      if (!rule.pattern.test(strValue)) {
        return false
      }
    }
    return true
  },

  // 最小长度验证
  min(value: any, rule: FormRule): boolean | string {
    if (rule.min !== undefined && value !== undefined && value !== null) {
      const length = Array.isArray(value) ? value.length : String(value).length
      if (length < rule.min) {
        return false
      }
    }
    return true
  },

  // 最大长度验证
  max(value: any, rule: FormRule): boolean | string {
    if (rule.max !== undefined && value !== undefined && value !== null) {
      const length = Array.isArray(value) ? value.length : String(value).length
      if (length > rule.max) {
        return false
      }
    }
    return true
  },

  // 最小值验证
  minValue(value: any, rule: FormRule): boolean | string {
    if (rule.minValue !== undefined && value !== undefined && value !== null) {
      const numValue = Number(value)
      if (isNaN(numValue) || numValue < rule.minValue) {
        return false
      }
    }
    return true
  },

  // 最大值验证
  maxValue(value: any, rule: FormRule): boolean | string {
    if (rule.maxValue !== undefined && value !== undefined && value !== null) {
      const numValue = Number(value)
      if (isNaN(numValue) || numValue > rule.maxValue) {
        return false
      }
    }
    return true
  },

  // 类型验证
  type(value: any, rule: FormRule): boolean | string {
    if (!rule.type || !value) return true

    const strValue = String(value)
    const types: Record<string, RegExp> = {
      email: /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/,
      phone: /^1[3-9]\d{9}$/,
      url: /^(https?:\/\/)?([\da-z.-]+)\.([a-z.]{2,6})([/\w .-]*)*\/?$/,
      idcard: /(^\d{15}$)|(^\d{17}([0-9]|X|x)$)/,
      number: /^-?\d+(\.\d+)?$/,
      integer: /^-?\d+$/,
      float: /^-?\d+\.\d+$/
    }

    if (types[rule.type] && !types[rule.type].test(strValue)) {
      return false
    }

    return true
  }
}

/**
 * 执行验证
 */
export async function validateRule(value: any, rule: FormRule): Promise<string | boolean> {
  // 执行内置验证器
  for (const [key, validator] of Object.entries(validators)) {
    if (rule[key as keyof FormRule] !== undefined) {
      const result = validator(value, rule)
      if (result !== true) {
        return rule.message || '验证失败'
      }
    }
  }

  // 执行自定义验证器
  if (rule.validator) {
    const result = await rule.validator(value, rule)
    if (result !== true) {
      return typeof result === 'string' ? result : (rule.message || '验证失败')
    }
  }

  return true
}