import { describe, test, expect } from 'vitest'
import { calculateTotal, toRelativeData } from './utils'
import type { EchartWidgetData } from '../../echart/types'

describe('calculateTotal', () => {
  test('calculates sum of all numeric values in single series', () => {
    const data: EchartWidgetData = [
      [
        { category: 'A', value: 25 },
        { category: 'B', value: 75 },
      ],
    ]

    expect(calculateTotal(data)).toBe(100)
  })

  test('calculates sum across multiple series', () => {
    const data: EchartWidgetData = [
      [
        { name: 'X', count: 10 },
        { name: 'Y', count: 20 },
      ],
      [
        { name: 'X', count: 30 },
        { name: 'Y', count: 40 },
      ],
    ]

    expect(calculateTotal(data)).toBe(100)
  })

  test('returns zero for empty data', () => {
    const data: EchartWidgetData = []

    expect(calculateTotal(data)).toBe(0)
  })

  test('returns zero for empty series', () => {
    const data: EchartWidgetData = [[]]

    expect(calculateTotal(data)).toBe(0)
  })

  test('handles data with only zero values', () => {
    const data: EchartWidgetData = [
      [
        { category: 'A', value: 0 },
        { category: 'B', value: 0 },
      ],
    ]

    expect(calculateTotal(data)).toBe(0)
  })

  test('handles negative values', () => {
    const data: EchartWidgetData = [
      [
        { category: 'A', value: -25 },
        { category: 'B', value: 75 },
      ],
    ]

    expect(calculateTotal(data)).toBe(50)
  })

  test('ignores string values in calculation', () => {
    const data: EchartWidgetData = [
      [
        { label: 'First', value: 50, extra: 'text' },
        { label: 'Second', value: 50, extra: 'more' },
      ],
    ]

    expect(calculateTotal(data)).toBe(100)
  })

  test('handles multiple numeric fields per item', () => {
    const data: EchartWidgetData = [
      [
        { category: 'A', value1: 10, value2: 20 },
        { category: 'B', value1: 30, value2: 40 },
      ],
    ]

    expect(calculateTotal(data)).toBe(100)
  })
})

describe('toRelativeData', () => {
  test('transforms values to percentages (25/100 = 25%, 75/100 = 75%)', () => {
    const data: EchartWidgetData = [
      [
        { category: 'A', value: 25 },
        { category: 'B', value: 75 },
      ],
    ]
    const total = 100

    const result = toRelativeData(data, total)

    // With total 100, 25 becomes 25% and 75 becomes 75%
    expect(result[0]?.[0]?.value).toBe(25)
    expect(result[0]?.[1]?.value).toBe(75)
  })

  test('transforms values to percentages with non-100 total (50/200 = 25%)', () => {
    const data: EchartWidgetData = [
      [
        { category: 'A', value: 50 },
        { category: 'B', value: 150 },
      ],
    ]
    const total = 200

    const result = toRelativeData(data, total)

    // 50/200 = 25%, 150/200 = 75%
    expect(result[0]?.[0]?.value).toBe(25)
    expect(result[0]?.[1]?.value).toBe(75)
  })

  test('returns original data when total is zero', () => {
    const data: EchartWidgetData = [
      [
        { category: 'A', value: 0 },
        { category: 'B', value: 0 },
      ],
    ]
    const total = 0

    const result = toRelativeData(data, total)

    expect(result).toEqual(data)
  })

  test('preserves string values during transformation', () => {
    const data: EchartWidgetData = [
      [
        { label: 'First', value: 50, extra: 'text' },
        { label: 'Second', value: 50, extra: 'more' },
      ],
    ]
    const total = 100

    const result = toRelativeData(data, total)

    expect(result[0]?.[0]?.label).toBe('First')
    expect(result[0]?.[0]?.extra).toBe('text')
    expect(result[0]?.[1]?.label).toBe('Second')
    expect(result[0]?.[1]?.extra).toBe('more')
  })

  test('transforms data with multiple series', () => {
    const data: EchartWidgetData = [
      [
        { name: 'X', count: 10 },
        { name: 'Y', count: 20 },
      ],
      [
        { name: 'X', count: 30 },
        { name: 'Y', count: 40 },
      ],
    ]
    const total = 100

    const result = toRelativeData(data, total)

    expect(result[0]?.[0]?.count).toBe(10)
    expect(result[0]?.[1]?.count).toBe(20)
    expect(result[1]?.[0]?.count).toBe(30)
    expect(result[1]?.[1]?.count).toBe(40)
  })

  test('handles fractional percentages correctly', () => {
    const data: EchartWidgetData = [
      [
        { category: 'A', value: 1 },
        { category: 'B', value: 2 },
        { category: 'C', value: 3 },
      ],
    ]
    const total = 6

    const result = toRelativeData(data, total)

    expect(result[0]?.[0]?.value).toBeCloseTo(16.6667, 4)
    expect(result[0]?.[1]?.value).toBeCloseTo(33.3333, 4)
    expect(result[0]?.[2]?.value).toBeCloseTo(50, 4)
  })

  test('handles negative values', () => {
    const data: EchartWidgetData = [
      [
        { category: 'A', value: -25 },
        { category: 'B', value: 75 },
      ],
    ]
    const total = 50

    const result = toRelativeData(data, total)

    expect(result[0]?.[0]?.value).toBe(-50)
    expect(result[0]?.[1]?.value).toBe(150)
  })

  test('handles empty data', () => {
    const data: EchartWidgetData = []
    const total = 100

    const result = toRelativeData(data, total)

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

  test('handles empty series', () => {
    const data: EchartWidgetData = [[]]
    const total = 100

    const result = toRelativeData(data, total)

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