/**
 * 计划书字段条件引擎测试
 *
 * @description 测试条件操作符和评估逻辑
 * @module config/__tests__/plan-conditions.test
 */

import { describe, it, expect } from 'vitest'
import {
  CONDITION_OPERATORS,
  normalizeOperator,
  evaluateSingleCondition,
  evaluateAnd,
  evaluateOr,
  evaluateNot,
  evaluateCondition,
  getConditionDependencies,
  convertToNewFormat
} from '../plan-conditions'

describe('CONDITION_OPERATORS', () => {
  describe('比较操作符', () => {
    it('eq - 等于', () => {
      expect(CONDITION_OPERATORS.eq('是', '是')).toBe(true)
      expect(CONDITION_OPERATORS.eq('是', '否')).toBe(false)
      expect(CONDITION_OPERATORS.eq(1, 1)).toBe(true)
      expect(CONDITION_OPERATORS.eq(1, '1')).toBe(false) // 严格相等
    })

    it('ne - 不等于', () => {
      expect(CONDITION_OPERATORS.ne('是', '否')).toBe(true)
      expect(CONDITION_OPERATORS.ne('是', '是')).toBe(false)
    })

    it('gt - 大于', () => {
      expect(CONDITION_OPERATORS.gt(30, 18)).toBe(true)
      expect(CONDITION_OPERATORS.gt(18, 18)).toBe(false)
      expect(CONDITION_OPERATORS.gt(10, 18)).toBe(false)
    })

    it('gte - 大于等于', () => {
      expect(CONDITION_OPERATORS.gte(30, 18)).toBe(true)
      expect(CONDITION_OPERATORS.gte(18, 18)).toBe(true)
      expect(CONDITION_OPERATORS.gte(10, 18)).toBe(false)
    })

    it('lt - 小于', () => {
      expect(CONDITION_OPERATORS.lt(10, 18)).toBe(true)
      expect(CONDITION_OPERATORS.lt(18, 18)).toBe(false)
      expect(CONDITION_OPERATORS.lt(30, 18)).toBe(false)
    })

    it('lte - 小于等于', () => {
      expect(CONDITION_OPERATORS.lte(10, 18)).toBe(true)
      expect(CONDITION_OPERATORS.lte(18, 18)).toBe(true)
      expect(CONDITION_OPERATORS.lte(30, 18)).toBe(false)
    })
  })

  describe('集合操作符', () => {
    it('in - 包含于', () => {
      expect(CONDITION_OPERATORS.in('A', ['A', 'B', 'C'])).toBe(true)
      expect(CONDITION_OPERATORS.in('D', ['A', 'B', 'C'])).toBe(false)
      expect(CONDITION_OPERATORS.in('A', 'not-array')).toBe(false)
    })

    it('nin - 不包含于', () => {
      expect(CONDITION_OPERATORS.nin('D', ['A', 'B', 'C'])).toBe(true)
      expect(CONDITION_OPERATORS.nin('A', ['A', 'B', 'C'])).toBe(false)
    })
  })

  describe('字符串操作符', () => {
    it('contains - 包含子串', () => {
      expect(CONDITION_OPERATORS.contains('Hello World', 'World')).toBe(true)
      expect(CONDITION_OPERATORS.contains('Hello World', 'world')).toBe(false) // 大小写敏感
      expect(CONDITION_OPERATORS.contains(null, 'test')).toBe(false)
    })

    it('startsWith - 前缀匹配', () => {
      expect(CONDITION_OPERATORS.startsWith('Hello', 'Hel')).toBe(true)
      expect(CONDITION_OPERATORS.startsWith('Hello', 'hel')).toBe(false)
    })

    it('endsWith - 后缀匹配', () => {
      expect(CONDITION_OPERATORS.endsWith('Hello', 'llo')).toBe(true)
      expect(CONDITION_OPERATORS.endsWith('Hello', 'LLO')).toBe(false)
    })

    it('matches - 正则匹配', () => {
      expect(CONDITION_OPERATORS.matches('ABC123', '^[A-Z]+\\d+$')).toBe(true)
      expect(CONDITION_OPERATORS.matches('abc', '^[A-Z]+$')).toBe(false)
      expect(CONDITION_OPERATORS.matches('test', '[invalid')).toBe(false) // 无效正则
    })
  })

  describe('布尔/空值操作符', () => {
    it('truthy - 真值', () => {
      expect(CONDITION_OPERATORS.truthy(true)).toBe(true)
      expect(CONDITION_OPERATORS.truthy(1)).toBe(true)
      expect(CONDITION_OPERATORS.truthy('text')).toBe(true)
      expect(CONDITION_OPERATORS.truthy(false)).toBe(false)
      expect(CONDITION_OPERATORS.truthy(0)).toBe(false)
      expect(CONDITION_OPERATORS.truthy('')).toBe(false)
      expect(CONDITION_OPERATORS.truthy(null)).toBe(false)
    })

    it('falsy - 假值', () => {
      expect(CONDITION_OPERATORS.falsy(false)).toBe(true)
      expect(CONDITION_OPERATORS.falsy(0)).toBe(true)
      expect(CONDITION_OPERATORS.falsy('')).toBe(true)
      expect(CONDITION_OPERATORS.falsy(null)).toBe(true)
      expect(CONDITION_OPERATORS.falsy(true)).toBe(false)
    })

    it('empty - 空值', () => {
      expect(CONDITION_OPERATORS.empty('')).toBe(true)
      expect(CONDITION_OPERATORS.empty(null)).toBe(true)
      expect(CONDITION_OPERATORS.empty(undefined)).toBe(true)
      expect(CONDITION_OPERATORS.empty(0)).toBe(false)
      expect(CONDITION_OPERATORS.empty('text')).toBe(false)
    })

    it('notEmpty - 非空', () => {
      expect(CONDITION_OPERATORS.notEmpty('text')).toBe(true)
      expect(CONDITION_OPERATORS.notEmpty(0)).toBe(true)
      expect(CONDITION_OPERATORS.notEmpty('')).toBe(false)
      expect(CONDITION_OPERATORS.notEmpty(null)).toBe(false)
    })

    it('emptyArray - 空数组', () => {
      expect(CONDITION_OPERATORS.emptyArray([])).toBe(true)
      expect(CONDITION_OPERATORS.emptyArray(null)).toBe(true)
      expect(CONDITION_OPERATORS.emptyArray([1])).toBe(false)
    })

    it('notEmptyArray - 非空数组', () => {
      expect(CONDITION_OPERATORS.notEmptyArray([1])).toBe(true)
      expect(CONDITION_OPERATORS.notEmptyArray([])).toBe(false)
    })
  })
})

describe('normalizeOperator', () => {
  it('返回标准操作符', () => {
    expect(normalizeOperator('eq')).toBe('eq')
    expect(normalizeOperator('gt')).toBe('gt')
  })

  it('处理别名', () => {
    expect(normalizeOperator('equals')).toBe('eq')
    expect(normalizeOperator('==')).toBe('eq')
    expect(normalizeOperator('===')).toBe('eq')
    expect(normalizeOperator('!=')).toBe('ne')
    expect(normalizeOperator('>')).toBe('gt')
    expect(normalizeOperator('>=')).toBe('gte')
  })

  it('未知操作符返回 null', () => {
    expect(normalizeOperator('unknown')).toBe(null)
  })
})

describe('evaluateSingleCondition', () => {
  const formData = { smoker: '是', age: 30, name: 'John' }

  it('评估等于条件', () => {
    expect(evaluateSingleCondition(
      { field: 'smoker', op: 'eq', value: '是' },
      formData
    )).toBe(true)

    expect(evaluateSingleCondition(
      { field: 'smoker', op: 'eq', value: '否' },
      formData
    )).toBe(false)
  })

  it('评估大于条件', () => {
    expect(evaluateSingleCondition(
      { field: 'age', op: 'gt', value: 18 },
      formData
    )).toBe(true)
  })

  it('评估包含条件', () => {
    expect(evaluateSingleCondition(
      { field: 'name', op: 'contains', value: 'John' },
      formData
    )).toBe(true)
  })

  it('缺少字段或操作符返回 false', () => {
    expect(evaluateSingleCondition({ op: 'eq', value: 'x' }, formData)).toBe(false)
    expect(evaluateSingleCondition({ field: 'x', value: 'y' }, formData)).toBe(false)
  })

  it('未知操作符返回 false', () => {
    expect(evaluateSingleCondition(
      { field: 'smoker', op: 'unknown', value: '是' },
      formData
    )).toBe(false)
  })
})

describe('evaluateAnd', () => {
  const formData = { smoker: '是', age: 30 }

  it('所有条件满足返回 true', () => {
    expect(evaluateAnd([
      { field: 'smoker', op: 'eq', value: '是' },
      { field: 'age', op: 'gte', value: 18 }
    ], formData)).toBe(true)
  })

  it('任一条件不满足返回 false', () => {
    expect(evaluateAnd([
      { field: 'smoker', op: 'eq', value: '是' },
      { field: 'age', op: 'gte', value: 50 }
    ], formData)).toBe(false)
  })

  it('空数组返回 true', () => {
    expect(evaluateAnd([], formData)).toBe(true)
  })
})

describe('evaluateOr', () => {
  const formData = { smoker: '是', age: 30 }

  it('任一条件满足返回 true', () => {
    expect(evaluateOr([
      { field: 'smoker', op: 'eq', value: '否' },
      { field: 'age', op: 'gte', value: 18 }
    ], formData)).toBe(true)
  })

  it('所有条件不满足返回 false', () => {
    expect(evaluateOr([
      { field: 'smoker', op: 'eq', value: '否' },
      { field: 'age', op: 'gte', value: 50 }
    ], formData)).toBe(false)
  })

  it('空数组返回 false', () => {
    expect(evaluateOr([], formData)).toBe(false)
  })
})

describe('evaluateNot', () => {
  const formData = { smoker: '是' }

  it('条件不满足返回 true', () => {
    expect(evaluateNot(
      { field: 'smoker', op: 'eq', value: '否' },
      formData
    )).toBe(true)
  })

  it('条件满足返回 false', () => {
    expect(evaluateNot(
      { field: 'smoker', op: 'eq', value: '是' },
      formData
    )).toBe(false)
  })
})

describe('evaluateCondition', () => {
  const formData = {
    smoker: '是',
    age: 30,
    product_type: 'A',
    coverage: 100000,
    payment_period: '20年'
  }

  it('空条件返回 true', () => {
    expect(evaluateCondition(null, formData)).toBe(true)
    expect(evaluateCondition(undefined, formData)).toBe(true)
  })

  it('简单条件', () => {
    expect(evaluateCondition(
      { field: 'smoker', op: 'eq', value: '是' },
      formData
    )).toBe(true)
  })

  it('AND 逻辑', () => {
    expect(evaluateCondition({
      and: [
        { field: 'smoker', op: 'eq', value: '是' },
        { field: 'age', op: 'gte', value: 30 }
      ]
    }, formData)).toBe(true)

    expect(evaluateCondition({
      and: [
        { field: 'smoker', op: 'eq', value: '是' },
        { field: 'age', op: 'gt', value: 50 }
      ]
    }, formData)).toBe(false)
  })

  it('OR 逻辑', () => {
    expect(evaluateCondition({
      or: [
        { field: 'smoker', op: 'eq', value: '否' },
        { field: 'age', op: 'gte', value: 30 }
      ]
    }, formData)).toBe(true)

    expect(evaluateCondition({
      or: [
        { field: 'smoker', op: 'eq', value: '否' },
        { field: 'age', op: 'gt', value: 50 }
      ]
    }, formData)).toBe(false)
  })

  it('NOT 逻辑', () => {
    expect(evaluateCondition({
      not: { field: 'smoker', op: 'eq', value: '否' }
    }, formData)).toBe(true)
  })

  it('嵌套条件', () => {
    // (smoker == '是' OR age > 50) AND product_type in ['A', 'B']
    expect(evaluateCondition({
      and: [
        {
          or: [
            { field: 'smoker', op: 'eq', value: '是' },
            { field: 'age', op: 'gt', value: 50 }
          ]
        },
        { field: 'product_type', op: 'in', value: ['A', 'B'] }
      ]
    }, formData)).toBe(true)
  })

  it('数组默认为 AND', () => {
    expect(evaluateCondition([
      { field: 'smoker', op: 'eq', value: '是' },
      { field: 'age', op: 'gte', value: 30 }
    ], formData)).toBe(true)
  })

  it('旧格式兼容 - equals', () => {
    expect(evaluateCondition(
      { field: 'smoker', equals: '是' },
      formData
    )).toBe(true)
  })

  it('旧格式兼容 - 扁平对象', () => {
    expect(evaluateCondition(
      { smoker: '是', age: 30 },
      formData
    )).toBe(true)
  })
})

describe('getConditionDependencies', () => {
  it('提取简单条件的依赖', () => {
    const deps = getConditionDependencies({ field: 'smoker', op: 'eq', value: '是' })
    expect(deps.has('smoker')).toBe(true)
    expect(deps.size).toBe(1)
  })

  it('提取 AND 条件的依赖', () => {
    const deps = getConditionDependencies({
      and: [
        { field: 'smoker', op: 'eq', value: '是' },
        { field: 'age', op: 'gte', value: 30 }
      ]
    })
    expect(deps.has('smoker')).toBe(true)
    expect(deps.has('age')).toBe(true)
    expect(deps.size).toBe(2)
  })

  it('提取嵌套条件的依赖', () => {
    const deps = getConditionDependencies({
      and: [
        { field: 'a', op: 'eq', value: 1 },
        {
          or: [
            { field: 'b', op: 'eq', value: 2 },
            { field: 'c', op: 'eq', value: 3 }
          ]
        }
      ]
    })
    expect(deps.has('a')).toBe(true)
    expect(deps.has('b')).toBe(true)
    expect(deps.has('c')).toBe(true)
    expect(deps.size).toBe(3)
  })

  it('提取扁平对象的依赖', () => {
    const deps = getConditionDependencies({ smoker: '是', age: 30 })
    expect(deps.has('smoker')).toBe(true)
    expect(deps.has('age')).toBe(true)
  })
})

describe('convertToNewFormat', () => {
  it('已经是新格式则直接返回', () => {
    const condition = { field: 'smoker', op: 'eq', value: '是' }
    expect(convertToNewFormat(condition)).toEqual(condition)
  })

  it('转换旧格式 equals', () => {
    expect(convertToNewFormat(
      { field: 'smoker', equals: '是' }
    )).toEqual({ field: 'smoker', op: 'eq', value: '是' })
  })

  it('转换旧格式数组为 AND', () => {
    expect(convertToNewFormat([
      { field: 'a', equals: 'x' },
      { field: 'b', equals: 'y' }
    ])).toEqual({
      and: [
        { field: 'a', op: 'eq', value: 'x' },
        { field: 'b', op: 'eq', value: 'y' }
      ]
    })
  })

  it('单个条件的数组不包装 AND', () => {
    expect(convertToNewFormat([
      { field: 'a', equals: 'x' }
    ])).toEqual({ field: 'a', op: 'eq', value: 'x' })
  })

  it('转换扁平对象', () => {
    expect(convertToNewFormat({ smoker: '是' })).toEqual({
      field: 'smoker',
      op: 'eq',
      value: '是'
    })
  })

  it('转换多字段扁平对象为 AND', () => {
    expect(convertToNewFormat({ smoker: '是', age: 30 })).toEqual({
      and: [
        { field: 'smoker', op: 'eq', value: '是' },
        { field: 'age', op: 'eq', value: 30 }
      ]
    })
  })
})