import { describe, it, expect } from 'vitest'
import { mergeOptions } from './merge-options'

describe('mergeOptions', () => {
  it('returns base unchanged when override is undefined', () => {
    const base = { a: 1, b: { c: 2 } }
    expect(mergeOptions(base)).toBe(base)
  })

  it('shallow-merges top-level keys', () => {
    const base: Record<string, unknown> = { a: 1, b: 2 }
    const out = mergeOptions(base, { b: 3, c: 4 })
    expect(out).toEqual({ a: 1, b: 3, c: 4 })
  })

  it('shallow-merges plain objects per key', () => {
    const base: Record<string, unknown> = { x: { p: 1, q: 2 } }
    const out = mergeOptions(base, { x: { q: 99, r: 3 } })
    expect(out).toEqual({ x: { p: 1, q: 99, r: 3 } })
  })

  it('merges arrays element-wise, deep-merging plain-object elements', () => {
    const base: Record<string, unknown> = {
      series: [{ type: 'bar', data: [1, 2] }, { type: 'line' }],
    }
    const out = mergeOptions(base, {
      series: [{ data: [3, 4] }, { name: 'second' }],
    })
    expect(out).toEqual({
      series: [
        { type: 'bar', data: [3, 4] },
        { type: 'line', name: 'second' },
      ],
    })
  })

  it('primitive override replaces primitive base', () => {
    expect(mergeOptions({ count: 1 }, { count: 99 })).toEqual({ count: 99 })
  })

  it('skips override values that are undefined', () => {
    expect(mergeOptions({ a: 1, b: 2 }, { a: undefined })).toEqual({
      a: 1,
      b: 2,
    })
  })

  it('uses base value when array is longer than override', () => {
    const base: Record<string, unknown> = { s: [1, 2, 3] }
    expect(mergeOptions(base, { s: [10] })).toEqual({ s: [10, 2, 3] })
  })
})