import { describe, expect, it } from 'vitest'
import { buildParameter } from '../../../script/buildParameter'

describe('buildParameter', () => {
  it('默认参数会生成默认分页、默认排序且无条件', () => {
    const result = buildParameter()

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

  it('显式传空对象时沿用构造函数默认分页与排序', () => {
    const result = buildParameter({})

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

  it('会忽略空字符串以及 limit/offset 字段，并处理普通字段', () => {
    const result = buildParameter({
      limit: 20,
      offset: 4,
      keyword: 'tom',
      count: 3,
      emptyText: ''
    })

    expect(result.limit).toBe(20)
    expect(result.offset).toBe(4)
    expect(result.fieldList).toEqual([
      {
        logicalOperator: 'AND',
        fieldName: 'keyword',
        comparatorOperator: 'EQUAL',
        fieldValue: 'tom'
      },
      {
        logicalOperator: 'AND',
        fieldName: 'count',
        comparatorOperator: 'EQUAL',
        fieldValue: 3
      }
    ])
  })

  it('普通字段支持 Date 类型', () => {
    const date = new Date('2024-01-01T00:00:00.000Z')
    const result = buildParameter({
      limit: 8,
      offset: 0,
      createdAt: date
    })

    expect(result.fieldList).toEqual([
      {
        logicalOperator: 'AND',
        fieldName: 'createdAt',
        comparatorOperator: 'EQUAL',
        fieldValue: date
      }
    ])
  })

  it('对象值分支支持 realField、oper、andOr，并在 model 有值时写入条件', () => {
    const result = buildParameter({
      limit: 10,
      offset: 2,
      keyword: {
        model: 'search',
        oper: 'LIKE',
        andOr: 'OR',
        realField: 'realKeyword'
      }
    })

    expect(result.fieldList).toEqual([
      {
        logicalOperator: 'OR',
        fieldName: 'realKeyword',
        comparatorOperator: 'LIKE',
        fieldValue: '%search%'
      }
    ])
  })

  it('对象值分支在未传 oper、andOr 和 realField 时使用默认值', () => {
    const result = buildParameter({
      limit: 8,
      offset: 0,
      keyword: {
        model: 'abc'
      }
    })

    expect(result.fieldList).toEqual([
      {
        logicalOperator: 'AND',
        fieldName: 'keyword',
        comparatorOperator: 'EQUAL',
        fieldValue: 'abc'
      }
    ])
  })

  it('对象值分支支持数组 model，并在 LIKE 时包装每一项', () => {
    const result = buildParameter({
      limit: 8,
      offset: 0,
      tags: {
        model: ['alpha', 'beta'],
        oper: 'LIKE',
        realField: 'tagName'
      }
    })

    expect(result.fieldList).toEqual([
      {
        logicalOperator: 'AND',
        fieldName: 'tagName',
        comparatorOperator: 'LIKE',
        fieldValue: ['%alpha%', '%beta%']
      }
    ])
  })

  it('对象值分支在 model 为空时默认跳过，但 still=true 时仍会写入', () => {
    const result = buildParameter({
      limit: 8,
      offset: 0,
      skipped: {
        model: '',
        oper: 'EQUAL'
      },
      kept: {
        model: '',
        oper: 'IS_NULL',
        still: true,
        realField: 'deletedAt'
      }
    })

    expect(result.fieldList).toEqual([
      {
        logicalOperator: 'AND',
        fieldName: 'deletedAt',
        comparatorOperator: 'IS_NULL',
        fieldValue: ''
      }
    ])
  })

  it('groupBy 存在时即使未传 limit/offset 也会补默认分页并写入 groupBy', () => {
    const result = buildParameter({}, {}, 'deptId')

    expect(result.limit).toBe(8)
    expect(result.offset).toBe(0)
    expect(result.groupBy).toBe('deptId')
  })

  it('sort 对象会覆盖默认排序', () => {
    const result = buildParameter(
      {
        limit: 8,
        offset: 0,
        code: 'A001'
      },
      {
        createTime: 'ASC'
      }
    )

    expect(result.fieldList).toEqual([
      {
        logicalOperator: 'AND',
        fieldName: 'code',
        comparatorOperator: 'EQUAL',
        fieldValue: 'A001'
      }
    ])
    expect(result.sortObject).toEqual({
      field: 'createTime',
      orderDirection: 'ASC'
    })
  })

  it('非法对象 oper 会透传底层异常', () => {
    expect(() => {
      buildParameter({
        limit: 8,
        offset: 0,
        keyword: {
          model: 'abc',
          oper: 'CONTAINS'
        }
      })
    }).toThrow(/oper/)
  })

  it('非法对象 andOr 会透传底层异常', () => {
    expect(() => {
      buildParameter({
        limit: 8,
        offset: 0,
        keyword: {
          model: 'abc',
          oper: 'EQUAL',
          andOr: 'XOR'
        }
      })
    }).toThrow(/andOr/)
  })

  it('非法分页参数会透传底层异常', () => {
    expect(() => {
      buildParameter({
        limit: '8a' as any,
        offset: 0,
        code: 'A001'
      })
    }).toThrow(/只能是整数/)
  })

  it('非法 sort 值会透传底层异常', () => {
    expect(() => {
      buildParameter(
        {
          limit: 8,
          offset: 0,
          code: 'A001'
        },
        {
          createTime: 'UP' as any
        }
      )
    }).toThrow(/ASC \|\| DESC/)
  })

  it('对象分支空数组 model 会透传底层异常', () => {
    expect(() => {
      buildParameter({
        limit: 8,
        offset: 0,
        ids: {
          model: [],
          oper: 'IN'
        }
      })
    }).toThrow(/数组的值不能为空/)
  })

  it('普通字段传布尔值会透传底层类型异常', () => {
    expect(() => {
      buildParameter({
        limit: 8,
        offset: 0,
        enabled: true as any
      })
    }).toThrow(/value 不是/)
  })

  it('当前实现会跳过对象分支里的 0 和 false model', () => {
    const result = buildParameter({
      limit: 8,
      offset: 0,
      count: {
        model: 0,
        oper: 'EQUAL'
      },
      enabled: {
        model: false,
        oper: 'EQUAL',
        still: false
      }
    })

    expect(result.fieldList).toEqual([])
  })
})