import { describe, expect, it } from 'vitest'
import { RequseBuildParmeter } from '../../../../script/help/requseBuildParmeter'

describe('RequseBuildParmeter', () => {
  it('constructor 会初始化默认结构并写入默认分页', () => {
    const instance = new RequseBuildParmeter() as any

    expect(instance.parameter).toEqual({
      fieldList: [],
      sortObject: {
        field: 'lastModifiedTime',
        orderDirection: 'DESC'
      },
      limit: 8,
      offset: 0,
      groupBy: null
    })
  })

  it('constructor 仅传单个参数时不会追加条件', () => {
    const withOnlyName = new RequseBuildParmeter('name') as any
    const withOnlyValue = new RequseBuildParmeter(undefined, 'tom') as any

    expect(withOnlyName.parameter.fieldList).toEqual([])
    expect(withOnlyValue.parameter.fieldList).toEqual([])
    expect(withOnlyName.parameter.limit).toBe(8)
    expect(withOnlyValue.parameter.limit).toBe(8)
  })

  it('constructor 传入 name 和 value 时会追加条件并补默认分页', () => {
    const instance = new RequseBuildParmeter('name', 'tom') as any

    expect(instance.parameter.fieldList).toEqual([
      {
        logicalOperator: 'AND',
        fieldName: 'name',
        comparatorOperator: 'EQUAL',
        fieldValue: 'tom'
      }
    ])
    expect(instance.parameter.limit).toBe(8)
    expect(instance.parameter.offset).toBe(0)
    expect(instance.parameter.groupBy).toBeNull()
  })

  it('AndFields 支持字符串、数字、Date、数组与 LIKE 包装，并支持链式调用', () => {
    const instance = new RequseBuildParmeter() as any
    const date = new Date('2024-01-01T00:00:00.000Z')

    const result = instance
      .AndFields('keyword', 'search', 'LIKE', 'OR')
      .AndFields('count', 10, 'GREATER_THAN', 'AND')
      .AndFields('createdAt', date, 'LESS_THAN_OR_EQUAL', 'AND')
      .AndFields('ids', ['alpha', 'beta'], 'LIKE', 'AND')

    expect(result).toBe(instance)
    expect(instance.parameter.fieldList).toEqual([
      {
        logicalOperator: 'OR',
        fieldName: 'keyword',
        comparatorOperator: 'LIKE',
        fieldValue: '%search%'
      },
      {
        logicalOperator: 'AND',
        fieldName: 'count',
        comparatorOperator: 'GREATER_THAN',
        fieldValue: 10
      },
      {
        logicalOperator: 'AND',
        fieldName: 'createdAt',
        comparatorOperator: 'LESS_THAN_OR_EQUAL',
        fieldValue: date
      },
      {
        logicalOperator: 'AND',
        fieldName: 'ids',
        comparatorOperator: 'LIKE',
        fieldValue: ['%alpha%', '%beta%']
      }
    ])
  })

  it('AndFields 对非法 andOr 抛错', () => {
    const instance = new RequseBuildParmeter()

    expect(() => {
      instance.AndFields('name', 'tom', 'EQUAL', 'XOR' as any)
    }).toThrow(/andOr/)
  })

  it('AndFields 对非法 oper 抛错', () => {
    const instance = new RequseBuildParmeter()

    expect(() => {
      instance.AndFields('name', 'tom', 'CONTAINS' as any, 'AND')
    }).toThrow(/oper/)
  })

  it('AndFields 对非法 value 类型和空数组抛错', () => {
    const instance = new RequseBuildParmeter()

    expect(() => {
      instance.AndFields('name', { text: 'tom' } as any, 'EQUAL', 'AND')
    }).toThrow(/value/)

    expect(() => {
      instance.AndFields('ids', [], 'IN', 'AND')
    }).toThrow(/数组的值不能为空/)
  })

  it('Sort 会覆盖排序对象并支持链式调用', () => {
    const instance = new RequseBuildParmeter() as any

    const result = instance.Sort('createTime', 'ASC').Sort('updateTime', 'DESC')

    expect(result).toBe(instance)
    expect(instance.parameter.sortObject).toEqual({
      field: 'updateTime',
      orderDirection: 'DESC'
    })
  })

  it('Sort 对非法排序值抛错', () => {
    const instance = new RequseBuildParmeter()

    expect(() => {
      instance.Sort('createTime', 'UP' as any)
    }).toThrow(/ASC \|\| DESC/)
  })

  it('Pageable 使用默认值并支持自定义 groupBy', () => {
    const instance = new RequseBuildParmeter() as any

    instance.Pageable()
    expect(instance.parameter.limit).toBe(8)
    expect(instance.parameter.offset).toBe(0)
    expect(instance.parameter.groupBy).toBeNull()

    instance.Pageable(20, 5, 'deptId')
    expect(instance.parameter.limit).toBe(20)
    expect(instance.parameter.offset).toBe(5)
    expect(instance.parameter.groupBy).toBe('deptId')
  })

  it('Pageable 接受数字字符串整数', () => {
    const instance = new RequseBuildParmeter() as any

    instance.Pageable('12' as any, '3' as any, null)

    expect(instance.parameter.limit).toBe('12')
    expect(instance.parameter.offset).toBe('3')
  })

  it('Pageable 对负数和非整数参数抛错', () => {
    const instance = new RequseBuildParmeter()

    expect(() => {
      instance.Pageable(-1 as any, 0)
    }).toThrow(/只能是整数/)

    expect(() => {
      instance.Pageable(1.5 as any, 0)
    }).toThrow(/只能是整数/)

    expect(() => {
      instance.Pageable(8, '2a' as any)
    }).toThrow(/只能是整数/)
  })
})