const { sanitizeInt, sanitizeFloat, sanitizeString } = require('../utils/validators')

describe('sanitizeInt', () => {
  it('应返回有效的整数', () => {
    expect(sanitizeInt(42)).toBe(42)
    expect(sanitizeInt('42')).toBe(42)
    expect(sanitizeInt(0)).toBe(0)
    expect(sanitizeInt(-5)).toBe(-5)
  })

  it('应在输入为 null/undefined/空字符串时返回 fallback', () => {
    expect(sanitizeInt(null, 0)).toBe(0)
    expect(sanitizeInt(undefined, 10)).toBe(10)
    expect(sanitizeInt('', 99)).toBe(99)
  })

  it('应在输入为 null/undefined/空字符串且无 fallback 时返回 undefined', () => {
    expect(sanitizeInt(null)).toBeUndefined()
    expect(sanitizeInt(undefined)).toBeUndefined()
    expect(sanitizeInt('')).toBeUndefined()
  })

  it('应在无法解析为整数时返回 null', () => {
    expect(sanitizeInt('abc')).toBeNull()
    expect(sanitizeInt('12.5')).toBe(12) // parseInt 截断小数
    expect(sanitizeInt({})).toBeNull()
    expect(sanitizeInt(NaN)).toBeNull()
  })

  it('应在值小于 min 时返回 null', () => {
    expect(sanitizeInt(3, undefined, 5)).toBeNull()
    expect(sanitizeInt(5, undefined, 5)).toBe(5)
    expect(sanitizeInt(6, undefined, 5)).toBe(6)
  })

  it('应在值大于 max 时返回 null', () => {
    expect(sanitizeInt(11, undefined, undefined, 10)).toBeNull()
    expect(sanitizeInt(10, undefined, undefined, 10)).toBe(10)
    expect(sanitizeInt(9, undefined, undefined, 10)).toBe(9)
  })

  it('应同时检查 min 和 max', () => {
    expect(sanitizeInt(5, undefined, 1, 10)).toBe(5)
    expect(sanitizeInt(0, undefined, 1, 10)).toBeNull()
    expect(sanitizeInt(11, undefined, 1, 10)).toBeNull()
  })

  it('应处理字符串形式的数字', () => {
    expect(sanitizeInt('100')).toBe(100)
    expect(sanitizeInt('  50  ')).toBe(50)
  })
})

describe('sanitizeFloat', () => {
  it('应返回有效的浮点数', () => {
    expect(sanitizeFloat(3.14)).toBeCloseTo(3.14)
    expect(sanitizeFloat('2.5')).toBeCloseTo(2.5)
    expect(sanitizeFloat(0)).toBe(0)
    expect(sanitizeFloat(-1.5)).toBeCloseTo(-1.5)
  })

  it('应在输入为 null/undefined/空字符串时返回 fallback', () => {
    expect(sanitizeFloat(null, 1.0)).toBeCloseTo(1.0)
    expect(sanitizeFloat(undefined, 2.5)).toBeCloseTo(2.5)
    expect(sanitizeFloat('', 0.0)).toBeCloseTo(0.0)
  })

  it('应在输入为 null/undefined/空字符串且无 fallback 时返回 undefined', () => {
    expect(sanitizeFloat(null)).toBeUndefined()
    expect(sanitizeFloat(undefined)).toBeUndefined()
    expect(sanitizeFloat('')).toBeUndefined()
  })

  it('应在无法解析为浮点数时返回 null', () => {
    expect(sanitizeFloat('abc')).toBeNull()
    expect(sanitizeFloat({})).toBeNull()
    expect(sanitizeFloat(NaN)).toBeNull()
  })

  it('应在值小于 min 时返回 null', () => {
    expect(sanitizeFloat(0.5, undefined, 1.0)).toBeNull()
    expect(sanitizeFloat(1.0, undefined, 1.0)).toBeCloseTo(1.0)
  })

  it('应在值大于 max 时返回 null', () => {
    expect(sanitizeFloat(11.0, undefined, undefined, 10.0)).toBeNull()
    expect(sanitizeFloat(10.0, undefined, undefined, 10.0)).toBeCloseTo(10.0)
  })

  it('应同时检查 min 和 max', () => {
    expect(sanitizeFloat(5.5, undefined, 1.0, 10.0)).toBeCloseTo(5.5)
    expect(sanitizeFloat(0.5, undefined, 1.0, 10.0)).toBeNull()
    expect(sanitizeFloat(10.5, undefined, 1.0, 10.0)).toBeNull()
  })
})

describe('sanitizeString', () => {
  it('应返回有效的字符串', () => {
    expect(sanitizeString('hello')).toBe('hello')
    expect(sanitizeString('你好世界')).toBe('你好世界')
  })

  it('应在输入为 null/undefined 时返回空字符串', () => {
    expect(sanitizeString(null)).toBe('')
    expect(sanitizeString(undefined)).toBe('')
  })

  it('应将非字符串类型转为字符串', () => {
    expect(sanitizeString(123)).toBe('123')
    expect(sanitizeString(true)).toBe('true')
  })

  it('应截断超过最大长度的字符串', () => {
    const longStr = 'a'.repeat(300)
    expect(sanitizeString(longStr).length).toBe(255)
    expect(sanitizeString(longStr)).toBe('a'.repeat(255))
  })

  it('应使用自定义最大长度', () => {
    const str = 'abcdefghij'
    expect(sanitizeString(str, 5)).toBe('abcde')
    expect(sanitizeString(str, 20)).toBe('abcdefghij')
  })

  it('应不截断等于最大长度的字符串', () => {
    const str = 'a'.repeat(255)
    expect(sanitizeString(str)).toBe(str)
  })

  it('应处理空字符串', () => {
    expect(sanitizeString('')).toBe('')
  })
})