/**
 * 验证工具函数测试
 */

import { describe, it, expect } from 'vitest'
import {
  validateEmail,
  validatePhone,
  validatePassword,
  validateUsername,
  validateUrl,
  validateIdCard,
  validateRequired,
  validateLength,
  validateNumber,
  validateInteger,
  validatePositive,
  validateRange
} from '@/utils/validation'

describe('validation utils', () => {
  describe('validateEmail', () => {
    it('should validate correct email addresses', () => {
      expect(validateEmail('test@example.com')).toBe(true)
      expect(validateEmail('user.name@domain.co.uk')).toBe(true)
      expect(validateEmail('user+tag@example.org')).toBe(true)
      expect(validateEmail('123@456.com')).toBe(true)
    })

    it('should reject invalid email addresses', () => {
      expect(validateEmail('invalid-email')).toBe(false)
      expect(validateEmail('test@')).toBe(false)
      expect(validateEmail('@example.com')).toBe(false)
      expect(validateEmail('test..test@example.com')).toBe(false)
      expect(validateEmail('')).toBe(false)
    })
  })

  describe('validatePhone', () => {
    it('should validate correct phone numbers', () => {
      expect(validatePhone('13812345678')).toBe(true)
      expect(validatePhone('15987654321')).toBe(true)
      expect(validatePhone('18612345678')).toBe(true)
    })

    it('should reject invalid phone numbers', () => {
      expect(validatePhone('12345678901')).toBe(false) // 不是1开头
      expect(validatePhone('1381234567')).toBe(false) // 长度不够
      expect(validatePhone('138123456789')).toBe(false) // 长度过长
      expect(validatePhone('13a12345678')).toBe(false) // 包含字母
      expect(validatePhone('')).toBe(false)
    })
  })

  describe('validatePassword', () => {
    it('should validate correct passwords', () => {
      expect(validatePassword('abc123')).toBe(true)
      expect(validatePassword('Password1')).toBe(true)
      expect(validatePassword('test123456')).toBe(true)
    })

    it('should reject invalid passwords', () => {
      expect(validatePassword('12345')).toBe(false) // 长度不够
      expect(validatePassword('abcdef')).toBe(false) // 只有字母
      expect(validatePassword('123456')).toBe(false) // 只有数字
      expect(validatePassword('')).toBe(false)
      expect(validatePassword('a'.repeat(21))).toBe(false) // 长度过长
    })
  })

  describe('validateUsername', () => {
    it('should validate correct usernames', () => {
      expect(validateUsername('user123')).toBe(true)
      expect(validateUsername('test_user')).toBe(true)
      expect(validateUsername('用户名')).toBe(true)
      expect(validateUsername('user_123')).toBe(true)
    })

    it('should reject invalid usernames', () => {
      expect(validateUsername('ab')).toBe(false) // 长度不够
      expect(validateUsername('user-name')).toBe(false) // 包含连字符
      expect(validateUsername('user@name')).toBe(false) // 包含特殊字符
      expect(validateUsername('')).toBe(false)
      expect(validateUsername('a'.repeat(21))).toBe(false) // 长度过长
    })
  })

  describe('validateUrl', () => {
    it('should validate correct URLs', () => {
      expect(validateUrl('https://example.com')).toBe(true)
      expect(validateUrl('http://test.org')).toBe(true)
      expect(validateUrl('https://sub.domain.com/path?query=1')).toBe(true)
      expect(validateUrl('ftp://files.example.com')).toBe(true)
    })

    it('should reject invalid URLs', () => {
      expect(validateUrl('not-a-url')).toBe(false)
      expect(validateUrl('example.com')).toBe(false) // 缺少协议
      expect(validateUrl('http://')).toBe(false)
      expect(validateUrl('')).toBe(false)
    })
  })

  describe('validateIdCard', () => {
    it('should validate correct ID card numbers', () => {
      expect(validateIdCard('110101199003077777')).toBe(true)
      expect(validateIdCard('11010119900307777X')).toBe(true)
    })

    it('should reject invalid ID card numbers', () => {
      expect(validateIdCard('12345678901234567')).toBe(false) // 长度不够
      expect(validateIdCard('1234567890123456789')).toBe(false) // 长度过长
      expect(validateIdCard('11010119900307777Y')).toBe(false) // 最后一位不是X
      expect(validateIdCard('')).toBe(false)
    })
  })

  describe('validateRequired', () => {
    it('should validate required values', () => {
      expect(validateRequired('test')).toBe(true)
      expect(validateRequired(123)).toBe(true)
      expect(validateRequired(0)).toBe(true)
      expect(validateRequired(false)).toBe(true)
    })

    it('should reject empty values', () => {
      expect(validateRequired('')).toBe(false)
      expect(validateRequired('   ')).toBe(false) // 只有空格
      expect(validateRequired(null)).toBe(false)
      expect(validateRequired(undefined)).toBe(false)
    })
  })

  describe('validateLength', () => {
    it('should validate correct length', () => {
      expect(validateLength('test', 3, 5)).toBe(true)
      expect(validateLength('hello', 5, 10)).toBe(true)
      expect(validateLength('ab', 1, 3)).toBe(true)
    })

    it('should reject incorrect length', () => {
      expect(validateLength('ab', 3, 5)).toBe(false) // 太短
      expect(validateLength('toolong', 3, 5)).toBe(false) // 太长
      expect(validateLength('', 1, 5)).toBe(false) // 空字符串
    })

    it('should handle edge cases', () => {
      expect(validateLength('test', 4, 4)).toBe(true) // 正好等于边界
      expect(validateLength('test', 0, 10)).toBe(true) // 最小长度为0
    })
  })

  describe('validateNumber', () => {
    it('should validate numbers', () => {
      expect(validateNumber(123)).toBe(true)
      expect(validateNumber(0)).toBe(true)
      expect(validateNumber(-456)).toBe(true)
      expect(validateNumber(3.14)).toBe(true)
      expect(validateNumber('123')).toBe(true)
      expect(validateNumber('3.14')).toBe(true)
    })

    it('should reject non-numbers', () => {
      expect(validateNumber('abc')).toBe(false)
      expect(validateNumber('12abc')).toBe(false)
      expect(validateNumber('')).toBe(false)
      expect(validateNumber(null)).toBe(false)
      expect(validateNumber(undefined)).toBe(false)
      expect(validateNumber(NaN)).toBe(false)
    })
  })

  describe('validateInteger', () => {
    it('should validate integers', () => {
      expect(validateInteger(123)).toBe(true)
      expect(validateInteger(0)).toBe(true)
      expect(validateInteger(-456)).toBe(true)
      expect(validateInteger('123')).toBe(true)
      expect(validateInteger('-456')).toBe(true)
    })

    it('should reject non-integers', () => {
      expect(validateInteger(3.14)).toBe(false)
      expect(validateInteger('3.14')).toBe(false)
      expect(validateInteger('abc')).toBe(false)
      expect(validateInteger('')).toBe(false)
    })
  })

  describe('validatePositive', () => {
    it('should validate positive numbers', () => {
      expect(validatePositive(123)).toBe(true)
      expect(validatePositive(0.1)).toBe(true)
      expect(validatePositive('123')).toBe(true)
    })

    it('should reject non-positive numbers', () => {
      expect(validatePositive(0)).toBe(false)
      expect(validatePositive(-123)).toBe(false)
      expect(validatePositive('-123')).toBe(false)
      expect(validatePositive('abc')).toBe(false)
    })
  })

  describe('validateRange', () => {
    it('should validate numbers in range', () => {
      expect(validateRange(5, 1, 10)).toBe(true)
      expect(validateRange(1, 1, 10)).toBe(true) // 边界值
      expect(validateRange(10, 1, 10)).toBe(true) // 边界值
      expect(validateRange('5', 1, 10)).toBe(true)
    })

    it('should reject numbers out of range', () => {
      expect(validateRange(0, 1, 10)).toBe(false)
      expect(validateRange(11, 1, 10)).toBe(false)
      expect(validateRange(-5, 1, 10)).toBe(false)
      expect(validateRange('abc', 1, 10)).toBe(false)
    })
  })
})