const ChainedMap = require('../src/ChainedMap')
const clean = require('../src/deps/reduce/clean')

test('is Chainable', () => {
  const parent = {parent: true}
  const map = new ChainedMap(parent)

  expect(map.end()).toBe(parent)
})

test('creates a backing Map', () => {
  const map = new ChainedMap()

  expect(map.store instanceof Map).toBe(true)
})

test('set', () => {
  const map = new ChainedMap()

  expect(map.set('a', 'alpha')).toBe(map)
  expect(map.store.get('a')).toBe('alpha')
})

test('get', () => {
  const map = new ChainedMap()

  expect(map.set('a', 'alpha')).toBe(map)
  expect(map.get('a')).toBe('alpha')
})

function getMapToClear() {
  const map = new ChainedMap()
    .set('a', 'alpha')
    .set('b', 'beta')
    .set('c', 'gamma')

  map.map = new ChainedMap(map).set('clearme', 1)

  return map
}

test('.clear(false)', () => {
  const map = getMapToClear()

  expect(map.store.size).toBe(3)
  expect(map.clear(false)).toBe(map)
  expect(map.store.size).toBe(0)
  expect(map.map.length).toBe(1)
})

test('clear', () => {
  const map = getMapToClear()

  expect(map.length).toBe(3)
  expect(map.store.size).toBe(3)
  expect(map.clear()).toBe(map)
  expect(map.store.size).toBe(0)
})

test('clean', () => {
  const map = new ChainedMap()

  map.set('emptyArr', [])
  map.set('arr', [1])
  map.set('nill', null)
  map.set('emptyObj', {})
  map.set('obj', {keys: true})
  expect(clean(map.entries())).toEqual({arr: [1], obj: {keys: true}})
})

test('clear - with sub-chainable', () => {
  const map = new ChainedMap()
  map.map = new ChainedMap(map)
  map.map.set('clearme', 1)
  map.set('a', 'alpha')
  map.set('b', 'beta')
  map.set('c', 'gamma')

  expect(map.store.size).toBe(3)
  expect(map.clear()).toBe(map)
  expect(map.store.size).toBe(0)
  expect(map.map.store.size).toBe(0)
})

test('delete', () => {
  const map = new ChainedMap()

  map.set('a', 'alpha')
  map.set('b', 'beta')
  map.set('c', 'gamma')

  expect(map.delete('b')).toBe(map)
  expect(map.store.size).toBe(2)
  expect(map.store.has('b')).toBe(false)
})

test('has', () => {
  const map = new ChainedMap()

  map.set('a', 'alpha')
  map.set('b', 'beta')
  map.set('c', 'gamma')

  expect(map.has('b')).toBe(true)
  expect(map.has('d')).toBe(false)
  expect(map.has('b')).toBe(map.store.has('b'))
})

test('values', () => {
  const map = new ChainedMap()

  map.set('a', 'alpha')
  map.set('b', 'beta')
  map.set('c', 'gamma')

  expect(map.values()).toEqual(['alpha', 'beta', 'gamma'])
})

test('entries with values', () => {
  const map = new ChainedMap()

  map.set('a', 'alpha')
  map.set('b', 'beta')
  map.set('c', 'gamma')

  expect(map.entries()).toEqual({a: 'alpha', b: 'beta', c: 'gamma'})
})

test('entries with no values', () => {
  const map = new ChainedMap()

  expect(map.entries()).toEqual({})
})

test('merge with no values', () => {
  const map = new ChainedMap()
  const obj = {a: 'alpha', b: 'beta', c: 'gamma'}

  expect(map.merge(obj)).toBe(map)
  expect(map.entries()).toEqual(obj)
})

test('merge with existing values', () => {
  const map = new ChainedMap()
  const obj = {a: 'alpha', b: 'beta', c: 'gamma'}

  map.set('d', 'delta')

  expect(map.merge(obj)).toBe(map)
  expect(map.entries()).toEqual({a: 'alpha', b: 'beta', c: 'gamma', d: 'delta'})
})

test('merge with overriding values', () => {
  const map = new ChainedMap()
  const obj = {a: 'alpha', b: 'beta', c: 'gamma'}

  map.set('b', 'delta')

  expect(map.merge(obj)).toBe(map)
  expect(map.entries()).toEqual({a: 'alpha', b: 'beta', c: 'gamma'})
})

test('when(has)', () => {
  expect.assertions(6)
  const map = new ChainedMap()
  map.set('truth', true).set('lies', false)

  const right = instance => {
    expect(instance).toBe(map)
    instance.set('alpha', 'a')
  }
  const left = instance => {
    instance.set('beta', 'b')
  }

  expect(map.when('truth', right, left)).toBe(map)
  expect(map.has('alpha')).toBe(true)
  expect(map.has('beta')).toBe(false)

  expect(map.when('lies', right, left)).toBe(map)
  expect(map.has('beta')).toBe(false)
})

test('when true', () => {
  const map = new ChainedMap()
  const right = instance => {
    expect(instance).toBe(map)
    instance.set('alpha', 'a')
  }
  const left = instance => {
    instance.set('beta', 'b')
  }

  expect(map.when(true, right, left)).toBe(map)
  expect(map.has('alpha')).toBe(true)
  expect(map.has('beta')).toBe(false)
})

test('when false', () => {
  const map = new ChainedMap()
  const right = instance => {
    instance.set('alpha', 'a')
  }
  const left = instance => {
    expect(instance).toBe(map)
    instance.set('beta', 'b')
  }

  expect(map.when(false, right, left)).toBe(map)
  expect(map.has('alpha')).toBe(false)
  expect(map.has('beta')).toBe(true)
})