import { describe, it, expect } from 'vitest'
import { cloneDeep, mergeDeep, mixDeep } from '../src/utils/object.js'
import { intersection } from 'lodash-es'

describe('Utils', () => {
  describe('deepMerge', () => {
    it('should merge keys', () => {
      expect(mergeDeep({}, { a: 1 })).toEqual({ a: 1 })
      expect(mergeDeep({ b: 2 }, { a: 1 })).toEqual({ b: 2, a: 1 })
      expect(mergeDeep({ b: 2 }, { a: 1, b: 3 })).toEqual({ b: 3, a: 1 })
      expect(mergeDeep({ b: 2, d: 4 }, { a: 1, b: 3 })).toEqual({ b: 3, d: 4, a: 1 })
      expect(mergeDeep({}, { a: [1] })).toEqual({ a: [1] })
      expect(mergeDeep({ a: [2] }, { a: [1] })).toEqual({ a: [1] })
      expect(mergeDeep({ a: [2] }, {})).toEqual({ a: [2] })
      expect(mergeDeep({ a: [2] }, {}).a).toEqual([2]) // typecheck
    })
    it('should assign deep objects', () => {
      expect(mergeDeep({}, { x: { a: 1 } })).toEqual({ x: { a: 1 } })
      expect(mergeDeep({ b: 2 }, { x: { a: 1 } })).toEqual({ b: 2, x: { a: 1 } })
      expect(mergeDeep({ b: 2 }, { x: { a: 1, b: 3 } })).toEqual({ b: 2, x: { a: 1, b: 3 } })
      expect(mergeDeep({ b: 2, d: 4 }, { x: { a: 1, b: 3 } })).toEqual({ b: 2, d: 4, x: { a: 1, b: 3 } })
    })
    it('should merge deep objects', () => {
      expect(mergeDeep({ x: {} }, { x: { a: 1 } })).toEqual({ x: { a: 1 } })
      expect(mergeDeep({ x: { b: 2 } }, { x: { a: 1 } })).toEqual({ x: { b: 2, a: 1 } })
      expect(mergeDeep({ x: { b: 2 } }, { x: { a: 1, b: 3 } })).toEqual({ x: { b: 3, a: 1 } })
      expect(mergeDeep({ x: { b: 2, d: 4 } }, { x: { a: 1, b: 3 } })).toEqual({ x: { b: 3, d: 4, a: 1 } })
      expect(mergeDeep({ x: {} }, { x: { a: [1] } })).toEqual({ x: { a: [1] } })
      expect(mergeDeep({ x: { a: [2] } }, { x: { a: [1] } })).toEqual({ x: { a: [1] } })
      expect(mergeDeep({ x: { a: [2] } }, { x: {} })).toEqual({ x: { a: [2] } })
      expect(mergeDeep({}, { x: { a: 1 } }).x.a).toEqual(1) // typecheck
      expect(mergeDeep({}, { x: { a: [1] } }).x.a).toEqual([1]) // typecheck
    })
  })
  describe('cloneDeep', () => {
    it('should clone objects', () => {
      const a = { a: 1 }
      expect(cloneDeep(a)).toEqual({ a: 1 })
      expect(a === cloneDeep(a)).toEqual(false)
      const x = { x: { a: 1 } }
      expect(cloneDeep(x)).toEqual({ x: { a: 1 } })
      expect(x.x === cloneDeep(x).x).toEqual(false)
      const z = { x: { a: [1] } }
      expect(cloneDeep(z)).toEqual({ x: { a: [1] } })
      expect(z.x === cloneDeep(z).x).toEqual(false)
      expect(z.x.a === cloneDeep(z).x.a).toEqual(false)
      const y = { x: { a: { y: 1 } } }
      expect(cloneDeep(y)).toEqual({ x: { a: { y: 1 } } })
      expect(y.x === cloneDeep(y).x).toEqual(false)
      expect(y.x.a === cloneDeep(y).x.a).toEqual(false)
    })
    it('should clone arrays', () => {
      const a = [{ a: 1 }, { b: 2 }]
      expect(cloneDeep(a)).toEqual([{ a: 1 }, { b: 2 }])
      expect(cloneDeep(a)).not.toBe(a)
    })
  })
  describe('combineDeepKeepingObjects', () => {
    it('should merge keys', () => {
      expect(mixDeep({}, { a: 1 })).toEqual({ a: 1 })
      expect(mixDeep({ b: 2 }, { a: 1 })).toEqual({ b: 2, a: 1 })
      expect(mixDeep({ b: 2 }, { a: 1, b: 3 })).toEqual({ b: 3, a: 1 })
      expect(mixDeep({ b: 2, d: 4 }, { a: 1, b: 3 })).toEqual({ b: 3, d: 4, a: 1 })
      expect(mixDeep({}, { a: [1] })).toEqual({ a: [1] })
      expect(mixDeep({ a: [2] }, {})).toEqual({ a: [2] })
      expect(mixDeep({ a: [2] }, {}).a).toEqual([2]) // typecheck
      expect(mixDeep({ a: [2] }, { a: { b: 2 } }).a).toEqual({ b: 2 })
    })
    it('should assign deep objects', () => {
      expect(mixDeep({}, { x: { a: 1 } })).toEqual({ x: { a: 1 } })
      expect(mixDeep({ b: 2 }, { x: { a: 1 } })).toEqual({ b: 2, x: { a: 1 } })
      expect(mixDeep({ b: 2 }, { x: { a: 1, b: 3 } })).toEqual({ b: 2, x: { a: 1, b: 3 } })
      expect(mixDeep({ b: 2, d: 4 }, { x: { a: 1, b: 3 } })).toEqual({
        b: 2,
        d: 4,
        x: { a: 1, b: 3 }
      })
    })
    it('should merge deep objects', () => {
      expect(mixDeep({ x: {} }, { x: { a: 1 } })).toEqual({ x: { a: 1 } })
      expect(mixDeep({ x: { b: 2 } }, { x: { a: 1 } })).toEqual({ x: { b: 2, a: 1 } })
      expect(mixDeep({ x: { b: 2 } }, { x: { a: 1, b: 3 } })).toEqual({ x: { b: 3, a: 1 } })
      expect(mixDeep({ x: { b: 2, d: 4 } }, { x: { a: 1, b: 3 } })).toEqual({
        x: { b: 3, d: 4, a: 1 }
      })
      expect(mixDeep({ x: {} }, { x: { a: [1] } })).toEqual({ x: { a: [1] } })
      expect(mixDeep({ x: { a: [2] } }, { x: {} })).toEqual({ x: { a: [2] } })
      expect(mixDeep({}, { x: { a: 1 } }).x.a).toEqual(1) // typecheck
      expect(mixDeep({}, { x: { a: [1] } }).x.a).toEqual([1]) // typecheck
    })
    it('should combine objects inside arrays', () => {
      expect(mixDeep({ x: [{ b: 2 }] }, { x: [{ a: 1 }] })).toEqual({ x: [{ b: 2, a: 1 }] })
      const array = [{ b: 1 }]
      expect(mixDeep({}, array)).not.toBe(array)
    })
    it('should handle top level arrays', () => {
      expect(mixDeep({}, [{ x: [{ a: 1 }] }])).toEqual([{ x: [{ a: 1 }] }])
      expect(mixDeep({ a: 1 }, [{ x: [{ a: 1 }] }])).toEqual([{ x: [{ a: 1 }] }])
    })

    it('unions arrays', () => {
      const array1 = ['1', 'ipsum', 'dolor']
      const array2 = ['Lorem', '1']
      const array3 = ['Jumps', '1', 'Lorem']
      const array4 = [1337, '1', 666]

      const result = intersection(array1, array2, array3, array4)

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