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

describe('requestPayload', () => {
  it('pageable=false 分支仅写入关闭分页，并处理普通字段与默认排序', () => {
    const parameter: any = {
      pageable: false,
      keyword: 'tom'
    }

    const result = requestPayload(parameter)

    expect(result.pageable).toEqual({ pageable: false })
    expect(result.fieldGroup.fields).toEqual([
      {
        type: 'Field',
        group: false,
        andOr: 'AND',
        name: 'keyword',
        oper: 'EQUAL',
        value: ['tom'],
        label: ''
      }
    ])
    expect(result.ordSort).toEqual([
      {
        name: 'lastModifiedTime',
        order: 'DESC'
      }
    ])
  })

  it('默认分页会删除 limit/offset，并把普通 key/value 转为 AndFields', () => {
    const parameter: any = {
      pageNum: 2,
      pageSize: 10,
      limit: 999,
      offset: 20,
      name: 'Alice',
      age: 18
    }

    const result = requestPayload(parameter, {}, true)

    expect(parameter.limit).toBeUndefined()
    expect(parameter.offset).toBeUndefined()
    expect(result.pageable).toEqual({
      pageNum: 2,
      pageSize: 10,
      pageable: true
    })
    expect(result.fieldGroup.fields).toEqual([
      {
        type: 'Field',
        group: false,
        andOr: 'AND',
        name: 'name',
        oper: 'EQUAL',
        value: ['Alice'],
        label: ''
      },
      {
        type: 'Field',
        group: false,
        andOr: 'AND',
        name: 'age',
        oper: 'EQUAL',
        value: [18],
        label: ''
      }
    ])
    expect(result.ordSort).toEqual([])
  })

  it('会忽略空字符串、undefined 和分页控制字段', () => {
    const result = requestPayload(
      {
        pageNum: 1,
        pageSize: 20,
        pageable: true,
        emptyText: '',
        missing: undefined,
        code: 'A001'
      },
      {},
      true
    )

    expect(result.fieldGroup.fields).toEqual([
      {
        type: 'Field',
        group: false,
        andOr: 'AND',
        name: 'code',
        oper: 'EQUAL',
        value: ['A001'],
        label: ''
      }
    ])
  })

  it('对象值分支支持 model/oper/andOr/realField/label/realModel，且 realModel 优先覆盖 model', () => {
    const result = requestPayload(
      {
        pageNum: 1,
        pageSize: 20,
        keyword: {
          model: 'origin',
          oper: 'LIKE',
          andOr: 'OR',
          realField: 'realKeyword',
          label: '展示文案',
          realModel: 'actual'
        }
      },
      {},
      true
    )

    expect(result.fieldGroup.fields).toEqual([
      {
        type: 'Field',
        group: false,
        andOr: 'OR',
        name: 'realKeyword',
        oper: 'LIKE',
        value: ['%actual%'],
        label: ['%展示文案%']
      }
    ])
  })

  it('对象值分支在未传 realModel 时使用原始 model', () => {
    const result = requestPayload(
      {
        pageNum: 1,
        pageSize: 20,
        keyword: {
          model: 'origin',
          oper: 'LIKE',
          realField: 'realKeyword',
          label: '展示文案'
        }
      },
      {},
      true
    )

    expect(result.fieldGroup.fields[0]).toMatchObject({
      name: 'realKeyword',
      oper: 'LIKE',
      value: ['%origin%'],
      label: ['%展示文案%']
    })
  })

  it('对象值分支支持非空数组 model', () => {
    const result = requestPayload(
      {
        pageNum: 1,
        pageSize: 20,
        ids: {
          model: ['1', '2'],
          oper: 'IN',
          realField: 'id'
        }
      },
      {},
      true
    )

    expect(result.fieldGroup.fields[0]).toMatchObject({
      name: 'id',
      oper: 'IN',
      value: ['1', '2']
    })
  })

  it('oper 为空时跳过，对象 model 为空数组时也跳过', () => {
    const result = requestPayload(
      {
        pageNum: 1,
        pageSize: 20,
        emptyOper: {
          model: 'value',
          oper: ''
        },
        emptyArrayModel: {
          model: [],
          oper: 'IN'
        }
      },
      {},
      true
    )

    expect(result.fieldGroup.fields).toEqual([])
    expect(result.ordSort).toEqual([])
  })

  it('对象值分支当前会跳过 falsy 的 0 和 false model', () => {
    const result = requestPayload(
      {
        pageNum: 1,
        pageSize: 20,
        count: {
          model: 0,
          oper: 'EQUAL'
        },
        enabled: {
          model: false,
          oper: 'EQUAL'
        }
      },
      {},
      true
    )

    expect(result.fieldGroup.fields).toEqual([])
  })

  it('realModel 为 false 时会覆盖原始 model，并透传底层布尔值校验异常', () => {
    expect(() => {
      requestPayload(
        {
          pageNum: 1,
          pageSize: 20,
          enabled: {
            model: true,
            realModel: false,
            oper: 'EQUAL',
            realField: 'isEnabled'
          }
        },
        {},
        true
      )
    }).toThrow(/value 不是|布尔值/)
  })

  it('oper 以 NULL 结尾时允许 model 为空并写入字段', () => {
    const result = requestPayload(
      {
        pageNum: 1,
        pageSize: 20,
        deletedAt: {
          model: '',
          oper: 'IS_NULL',
          label: '忽略的标签'
        }
      },
      {},
      true
    )

    expect(result.fieldGroup.fields).toEqual([
      {
        type: 'Field',
        group: false,
        andOr: 'AND',
        name: 'deletedAt',
        oper: 'IS_NULL',
        value: [''],
        label: ['忽略的标签']
      }
    ])
  })

  it('非法 oper 会透传底层异常', () => {
    expect(() => {
      requestPayload(
        {
          pageNum: 1,
          pageSize: 20,
          keyword: {
            model: 'abc',
            oper: 'CONTAINS'
          }
        },
        {},
        true
      )
    }).toThrow(/oper/)
  })

  it('非法 andOr 会透传底层异常', () => {
    expect(() => {
      requestPayload(
        {
          pageNum: 1,
          pageSize: 20,
          keyword: {
            model: 'abc',
            oper: 'EQUAL',
            andOr: 'XOR'
          }
        },
        {},
        true
      )
    }).toThrow(/andOr/)
  })

  it('非法分页参数会透传底层异常', () => {
    expect(() => {
      requestPayload({
        pageNum: '1a' as any,
        pageSize: 20,
        code: 'A001'
      }, {}, true)
    }).toThrow(/只能是整数/)
  })

  it('非法 sort 值会透传底层异常', () => {
    expect(() => {
      requestPayload(
        {
          pageNum: 1,
          pageSize: 20,
          code: 'A001'
        },
        {
          createTime: 'UP' as any
        },
        true
      )
    }).toThrow(/ASC.*DESC/)
  })

  it('sort 对象会写入排序，且存在排序时不补默认排序', () => {
    const result = requestPayload(
      {
        pageNum: 3,
        pageSize: 30,
        code: 'A001'
      },
      {
        createTime: 'ASC',
        updateTime: 'DESC'
      }
    )

    expect(result.ordSort).toEqual([
      { name: 'createTime', order: 'ASC' },
      { name: 'updateTime', order: 'DESC' }
    ])
  })

  it('无排序且 noSort=false 时补默认 lastModifiedTime DESC', () => {
    const result = requestPayload(
      {
        pageNum: 1,
        pageSize: 20,
        code: 'B001'
      },
      {},
      false
    )

    expect(result.ordSort).toEqual([
      {
        name: 'lastModifiedTime',
        order: 'DESC'
      }
    ])
  })

  it('noSort=true 时不补默认排序', () => {
    const result = requestPayload(
      {
        pageNum: 1,
        pageSize: 20,
        code: 'C001'
      },
      {},
      true
    )

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