/**
 * planFieldTransformers 单元测试
 * @description 测试字段值转换工具函数
 * @module utils/__tests__/planFieldTransformers.test
 */

import { describe, it, expect } from 'vitest'
import {
  fenToYuan,
  yuanToFen,
  formatAge,
  noneTransform,
  transformFieldValue,
  batchTransformFields,
  reverseTransformFields
} from '../planFieldTransformers'
import { TRANSFORM_TYPES } from '@/config/plan-fields'

describe('fenToYuan', () => {
  it('should convert fen to yuan correctly', () => {
    expect(fenToYuan(10000)).toBe('100.00')
    expect(fenToYuan(100)).toBe('1.00')
    expect(fenToYuan(1)).toBe('0.01')
  })

  it('should handle zero', () => {
    expect(fenToYuan(0)).toBe('0.00')
  })

  it('should handle null and undefined', () => {
    expect(fenToYuan(null)).toBe(null)
    expect(fenToYuan(undefined)).toBe(undefined)  // 保持原值
  })

  it('should handle string numbers', () => {
    expect(fenToYuan('10000')).toBe('100.00')
    expect(fenToYuan('100')).toBe('1.00')
  })

  it('should handle invalid values', () => {
    expect(fenToYuan('invalid')).toBe(null)
    expect(fenToYuan(NaN)).toBe(null)
  })
})

describe('yuanToFen', () => {
  it('should convert yuan to fen correctly', () => {
    expect(yuanToFen('100.00')).toBe(10000)
    expect(yuanToFen('1.00')).toBe(100)
    expect(yuanToFen('0.01')).toBe(1)
  })

  it('should handle zero', () => {
    expect(yuanToFen('0.00')).toBe(0)
    expect(yuanToFen(0)).toBe(0)
  })

  it('should handle null and undefined', () => {
    expect(yuanToFen(null)).toBe(null)
    expect(yuanToFen(undefined)).toBe(null)
  })

  it('should handle string numbers', () => {
    expect(yuanToFen('100.00')).toBe(10000)
    expect(yuanToFen('100')).toBe(10000)
  })
})

describe('formatAge', () => {
  it('should format age correctly', () => {
    expect(formatAge(25)).toBe('25岁')
    expect(formatAge(0)).toBe('0岁')
  })

  it('should handle null and undefined', () => {
    expect(formatAge(null)).toBe(null)
    expect(formatAge(undefined)).toBe(null)
  })
})

describe('transformFieldValue', () => {
  it('should transform fen to yuan', () => {
    expect(transformFieldValue(10000, TRANSFORM_TYPES.FEN_TO_YUAN)).toBe('100.00')
  })

  it('should transform yuan to fen', () => {
    expect(transformFieldValue('100.00', TRANSFORM_TYPES.YUAN_TO_FEN)).toBe(10000)
  })

  it('should pass through for none transform', () => {
    expect(transformFieldValue('test', TRANSFORM_TYPES.NONE)).toBe('test')
  })

  it('should handle null values', () => {
    expect(transformFieldValue(null, TRANSFORM_TYPES.FEN_TO_YUAN)).toBe(null)
  })
})

describe('batchTransformFields', () => {
  it('should transform multiple fields according to definitions', () => {
    const formData = {
      coverage: 10000,
      annual_withdrawal_amount: 5000,
      name: 'Test'
    }

    const fieldDefinitions = {
      coverage: {
        transform: TRANSFORM_TYPES.FEN_TO_YUAN
      },
      annual_withdrawal_amount: {
        transform: TRANSFORM_TYPES.FEN_TO_YUAN
      },
      name: {
        // 无 transform 属性
      }
    }

    const result = batchTransformFields(formData, fieldDefinitions)

    expect(result.coverage).toBe('100.00')
    expect(result.annual_withdrawal_amount).toBe('50.00')
    expect(result.name).toBe('Test') // 保持原值
  })

  it('should skip undefined values', () => {
    const formData = {
      coverage: undefined,
      name: 'Test'
    }

    const fieldDefinitions = {
      coverage: {
        transform: TRANSFORM_TYPES.FEN_TO_YUAN
      },
      name: {}
    }

    const result = batchTransformFields(formData, fieldDefinitions)

    // coverage 是 undefined，转换后应该仍然是 undefined
    expect(result.coverage).toBeUndefined()
    // name 没有变化，应该保持原值
    expect(result.name).toBe('Test')
  })
})

describe('reverseTransformFields', () => {
  it('should convert API data back to form format', () => {
    const apiData = {
      annual_premium: '100.00',
      annual_withdrawal_amount: '50.00',
      name: 'Test'
    }

    const fieldDefinitions = {
      annual_premium: {
        api_field: 'annual_premium',
        transform: TRANSFORM_TYPES.FEN_TO_YUAN
      },
      annual_withdrawal_amount: {
        api_field: 'annual_withdrawal_amount',
        transform: TRANSFORM_TYPES.FEN_TO_YUAN
      },
      name: {
        api_field: 'name'
      }
    }

    const result = reverseTransformFields(apiData, fieldDefinitions)

    // formKey 是 annual_premium，所以结果键是 annual_premium
    // 反向转换：yuan -> fen，返回整数（分）
    expect(result.annual_premium).toBe(10000)
    expect(result.annual_withdrawal_amount).toBe(5000)
    expect(result.name).toBe('Test')
  })

  it('should handle missing fields', () => {
    const apiData = {
      annual_premium: '100.00'
    }

    const fieldDefinitions = {
      annual_premium: {
        api_field: 'annual_premium',
        transform: TRANSFORM_TYPES.FEN_TO_YUAN
      },
      name: {
        api_field: 'name'
      }
    }

    const result = reverseTransformFields(apiData, fieldDefinitions)

    // annual_premium 反向转换：yuan -> fen，返回整数（分）
    expect(result.annual_premium).toBe(10000)
    // name 在 apiData 中不存在，所以 result.name 是 undefined
    expect(result.name).toBeUndefined()
  })
})