"use strict";

const log = require('fliplog');

const _require = require("../src"),
      Chainable = _require.Chainable,
      ChainedSet = _require.ChainedSet;

let Lists = class Lists extends Chainable {
  constructor(parent) {
    super(parent);
    this.people = new ChainedSet(this);
    this.places = new ChainedSet(this);
  }

  add(type, value) {
    this[type].add(value);
    return this;
  }

  all() {
    const people = this.people,
          places = this.places;
    return new ChainedSet().merge(people).merge(places).values();
  }

};
let fns = {};

function add(lists) {
  // with a simple factory like method
  lists.add('people', 'sam').add('people', 'sue').add('places', 'moon');
  return fns;
}

function addDirect(lists) {
  // or with property
  lists.places.add('sun');
  lists.people.add('joe');
  return fns;
}

function prepend(lists) {
  lists.people.prepend('first');
  return fns;
}

function merge(lists) {
  lists.people.merge(['frank', 'john']);
  return fns;
}

function makeTests() {
  const lists = new Lists();
  fns = {};
  fns.add = add.bind(null, lists);
  fns.addDirect = addDirect.bind(null, lists);
  fns.prepend = prepend.bind(null, lists);
  fns.merge = merge.bind(null, lists);
  fns.result = lists;
  return fns;
}

test('add, merge, append, prepend', () => {
  const _makeTests$add$addDir = makeTests().add().addDirect().prepend().merge(),
        result = _makeTests$add$addDir.result;

  expect(result.all()).toEqual(['first', 'sam', 'sue', 'joe', 'frank', 'john', 'moon', 'sun']);
});
test('add, merge, append, prepend - raw', () => {
  const lists = new Lists();
  lists.add('people', 'sam').add('people', 'sue').add('places', 'moon'); // directly

  lists.places.add('sun'); // operations

  lists.people.add('joe');
  lists.people.prepend('first');
  lists.people.merge(['frank', 'john']);
  expect(lists.all()).toEqual(['first', 'sam', 'sue', 'joe', 'frank', 'john', 'moon', 'sun']);
});
test.skip('species', () => {
  const set = new ChainedSet();
  var fakeArray = new ChainedSet();
  fakeArray.add(100);
  fakeArray.add([200, 300]);
  var x = [1, 2, 3]; // x.concat(fakeArray)

  const vals = fakeArray.values();
  vals[Symbol.isConcatSpreadable] = true;
  expect(x.concat(vals)).toEqual([1, 2, 3100, 200, 300]);
}); // --- from webpack-chain

test('is Chainable', () => {
  const parent = {
    parent: true
  };
  const set = new ChainedSet(parent);
  expect(set.end()).toBe(parent);
});
test('creates a backing Set', () => {
  const set = new ChainedSet();
  expect(set.store instanceof Set).toBe(true);
});
test('add', () => {
  const set = new ChainedSet();
  expect(set.add('alpha')).toBe(set);
  expect(set.store.has('alpha')).toBe(true);
  expect(set.store.size).toBe(1);
});
test('prepend', () => {
  const set = new ChainedSet();
  set.add('alpha');
  expect(set.prepend('beta')).toBe(set);
  expect(set.store.has('beta')).toBe(true);
  expect([...set.store]).toEqual(['beta', 'alpha']);
  expect([...set.store]).toEqual(set.values());
});
test('clear', () => {
  const set = new ChainedSet();
  set.add('alpha');
  set.add('beta');
  set.add('gamma');
  expect(set.store.size).toBe(3);
  expect(set.clear()).toBe(set);
  expect(set.store.size).toBe(0);
});
test('delete', () => {
  const set = new ChainedSet();
  set.add('alpha');
  set.add('beta');
  set.add('gamma');
  expect(set.delete('beta')).toBe(set);
  expect(set.store.size).toBe(2);
  expect(set.store.has('beta')).toBe(false);
});
test('has', () => {
  const set = new ChainedSet();
  set.add('alpha');
  set.add('beta');
  set.add('gamma');
  expect(set.has('beta')).toBe(true);
  expect(set.has('delta')).toBe(false);
  expect(set.has('beta')).toBe(set.store.has('beta'));
});
test('values', () => {
  const set = new ChainedSet();
  set.add('alpha');
  set.add('beta');
  set.add('gamma');
  expect(set.values()).toEqual(['alpha', 'beta', 'gamma']);
});
test('merge with no values', () => {
  const set = new ChainedSet();
  const arr = ['alpha', 'beta', 'gamma'];
  expect(set.merge(arr)).toBe(set);
  expect(set.values()).toEqual(arr);
});
test('merge with existing values', () => {
  const set = new ChainedSet();
  const arr = ['alpha', 'beta', 'gamma'];
  set.add('delta');
  expect(set.merge(arr)).toBe(set);
  expect(set.values()).toEqual(['delta', 'alpha', 'beta', 'gamma']);
});
test('when true', () => {
  const set = new ChainedSet();

  const right = instance => {
    expect(instance).toBe(set);
    instance.add('alpha');
  };

  const left = instance => {
    instance.add('beta');
  };

  expect(set.when(true, right, left)).toBe(set);
  expect(set.has('alpha')).toBe(true);
  expect(set.has('beta')).toBe(false);
});
test('when false', () => {
  const set = new ChainedSet();

  const right = instance => {
    instance.add('alpha');
  };

  const left = instance => {
    expect(instance).toBe(set);
    instance.add('beta');
  };

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