// 表单验证工具类
class Validator {
  constructor() {
    this.rules = {}
    this.messages = {}
    this.errors = {}
  }

  // 添加验证规则
  addRule(field, rules) {
    this.rules[field] = Array.isArray(rules) ? rules : [rules]
    return this
  }

  // 添加错误消息
  addMessage(field, message) {
    this.messages[field] = message
    return this
  }

  // 验证单个字段
  validateField(field, value) {
    const rules = this.rules[field] || []
    const errors = []

    for (const rule of rules) {
      const result = this.applyRule(rule, value, field)
      if (result !== true) {
        errors.push(result)
      }
    }

    if (errors.length > 0) {
      this.errors[field] = errors
      return false
    } else {
      delete this.errors[field]
      return true
    }
  }

  // 验证所有字段
  validate(data) {
    this.errors = {}
    let isValid = true

    Object.keys(this.rules).forEach(field => {
      const value = data[field]
      if (!this.validateField(field, value)) {
        isValid = false
      }
    })

    return isValid
  }

  // 应用验证规则
  applyRule(rule, value, field) {
    if (typeof rule === 'function') {
      return rule(value, field)
    }

    if (typeof rule === 'object') {
      const { type, message, ...params } = rule
      const validator = this.getValidator(type)
      
      if (validator) {
        const result = validator(value, params)
        return result === true ? true : (message || this.getDefaultMessage(type, params))
      }
    }

    if (typeof rule === 'string') {
      const validator = this.getValidator(rule)
      if (validator) {
        const result = validator(value)
        return result === true ? true : this.getDefaultMessage(rule)
      }
    }

    return true
  }

  // 获取验证器
  getValidator(type) {
    const validators = {
      // 必填
      required: (value) => {
        if (value === null || value === undefined || value === '') {
          return false
        }
        if (Array.isArray(value) && value.length === 0) {
          return false
        }
        return true
      },

      // 邮箱
      email: (value) => {
        if (!value) return true
        const emailReg = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
        return emailReg.test(value)
      },

      // 手机号
      phone: (value) => {
        if (!value) return true
        const phoneReg = /^1[3-9]\d{9}$/
        return phoneReg.test(value)
      },

      // 身份证号
      idCard: (value) => {
        if (!value) return true
        const idCardReg = /(^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$)/
        return idCardReg.test(value)
      },

      // 最小长度
      minLength: (value, { min }) => {
        if (!value) return true
        return value.length >= min
      },

      // 最大长度
      maxLength: (value, { max }) => {
        if (!value) return true
        return value.length <= max
      },

      // 长度范围
      length: (value, { min, max }) => {
        if (!value) return true
        const len = value.length
        return len >= min && len <= max
      },

      // 最小值
      min: (value, { min }) => {
        if (value === null || value === undefined || value === '') return true
        return Number(value) >= min
      },

      // 最大值
      max: (value, { max }) => {
        if (value === null || value === undefined || value === '') return true
        return Number(value) <= max
      },

      // 数值范围
      range: (value, { min, max }) => {
        if (value === null || value === undefined || value === '') return true
        const num = Number(value)
        return num >= min && num <= max
      },

      // 正则表达式
      pattern: (value, { pattern }) => {
        if (!value) return true
        const reg = new RegExp(pattern)
        return reg.test(value)
      },

      // 数字
      number: (value) => {
        if (!value) return true
        return !isNaN(Number(value))
      },

      // 整数
      integer: (value) => {
        if (!value) return true
        return Number.isInteger(Number(value))
      },

      // 正数
      positive: (value) => {
        if (!value) return true
        return Number(value) > 0
      },

      // URL
      url: (value) => {
        if (!value) return true
        const urlReg = /^https?:\/\/.+/
        return urlReg.test(value)
      },

      // 中文
      chinese: (value) => {
        if (!value) return true
        const chineseReg = /^[\u4e00-\u9fa5]+$/
        return chineseReg.test(value)
      },

      // 英文
      english: (value) => {
        if (!value) return true
        const englishReg = /^[a-zA-Z]+$/
        return englishReg.test(value)
      },

      // 字母数字
      alphanumeric: (value) => {
        if (!value) return true
        const alphanumericReg = /^[a-zA-Z0-9]+$/
        return alphanumericReg.test(value)
      }
    }

    return validators[type]
  }

  // 获取默认错误消息
  getDefaultMessage(type, params = {}) {
    const messages = {
      required: '此字段为必填项',
      email: '请输入有效的邮箱地址',
      phone: '请输入有效的手机号码',
      idCard: '请输入有效的身份证号码',
      minLength: `最少输入${params.min}个字符`,
      maxLength: `最多输入${params.max}个字符`,
      length: `请输入${params.min}-${params.max}个字符`,
      min: `最小值为${params.min}`,
      max: `最大值为${params.max}`,
      range: `请输入${params.min}-${params.max}之间的数值`,
      pattern: '格式不正确',
      number: '请输入有效的数字',
      integer: '请输入整数',
      positive: '请输入正数',
      url: '请输入有效的URL地址',
      chinese: '请输入中文',
      english: '请输入英文',
      alphanumeric: '请输入字母或数字'
    }

    return messages[type] || '验证失败'
  }

  // 获取错误信息
  getErrors() {
    return this.errors
  }

  // 获取第一个错误信息
  getFirstError() {
    const fields = Object.keys(this.errors)
    if (fields.length > 0) {
      const field = fields[0]
      const errors = this.errors[field]
      return errors[0]
    }
    return null
  }

  // 清除错误信息
  clearErrors() {
    this.errors = {}
    return this
  }

  // 清除指定字段错误信息
  clearFieldError(field) {
    delete this.errors[field]
    return this
  }

  // 检查是否有错误
  hasErrors() {
    return Object.keys(this.errors).length > 0
  }

  // 检查指定字段是否有错误
  hasFieldError(field) {
    return !!this.errors[field]
  }
}

// 创建验证器实例
const createValidator = () => {
  return new Validator()
}

// 快速验证方法
const validate = {
  // 验证邮箱
  email: (value) => {
    const emailReg = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
    return emailReg.test(value)
  },

  // 验证手机号
  phone: (value) => {
    const phoneReg = /^1[3-9]\d{9}$/
    return phoneReg.test(value)
  },

  // 验证身份证号
  idCard: (value) => {
    const idCardReg = /(^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$)/
    return idCardReg.test(value)
  },

  // 验证密码强度
  password: (value) => {
    // 至少8位，包含大小写字母和数字
    const passwordReg = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[a-zA-Z\d@$!%*?&]{8,}$/
    return passwordReg.test(value)
  },

  // 验证URL
  url: (value) => {
    const urlReg = /^https?:\/\/.+/
    return urlReg.test(value)
  },

  // 验证IP地址
  ip: (value) => {
    const ipReg = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/
    return ipReg.test(value)
  },

  // 验证银行卡号
  bankCard: (value) => {
    const bankCardReg = /^[1-9]\d{12,18}$/
    return bankCardReg.test(value)
  },

  // 验证车牌号
  licensePlate: (value) => {
    const licensePlateReg = /^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领A-Z]{1}[A-Z]{1}[A-Z0-9]{4}[A-Z0-9挂学警港澳]{1}$/
    return licensePlateReg.test(value)
  }
}

export {
  Validator,
  createValidator,
  validate
}