import StateContainer, {lensTransformer} from '../src/state_container';

 import sinon from 'sinon';

 import * as R from 'ramda';

 
 test("initial state setting works", () => {
    const container = new StateContainer({foo: 'bar'});
 
    expect(container.get('foo')).toBe('bar')//, 'get works with initial data');
    expect(container.getState().foo).toBe('bar')//, 'getState works with initial data');
 });
 
 test("set updates state", () => {
     const container = new StateContainer({foo: 'bar'});
 
     container.set('foo', 'baz');
     expect(container.get('foo')).toBe('baz')//, 'set updated the data');
 
 });
 
 test("setState updates state", () => {
     const container = new StateContainer({foo: 'bar', moo: 'cow'});
 
     container.setState({foo: 'baz'});
     expect(container.get('foo')).toBe('baz')//, 'setState updated the data');
     expect(container.get('moo')).toBe('cow')//, 'setState did not lose data');
 
 });
 
 test("returned state cannot modify internal state", () => {
     const container = new StateContainer({foo: 'bar'});
 
     const outputState = container.getState();
     expect(container.get('foo')).toBe(outputState.foo)//, "output state matches container initially");
 
     outputState.foo = 'moo';
     expect(container.get('foo')).toBe('bar')//, "container state was not modified by output state");
 });
 

 test("onUpdate listeners are fired when set is called", () => {

     let container, listener;
 
     container = new StateContainer({foo: 'bar'});
     listener = sinon.spy();
 
     container.onUpdate(listener);
 
     container.set('foo', 'hi');
 
     expect(JSON.stringify(listener.args[0])).toBe(JSON.stringify([{foo: 'bar'}, {foo: 'hi'}]));
 
     container = new StateContainer({foo: 'bar'});
     const recorder = container.getRecorder();
     listener = sinon.spy();
 
     recorder.onUpdate(listener);
 
     recorder.set('foo', 'hi');
 
     expect(JSON.stringify(listener.args[0])).toBe(JSON.stringify([{foo: 'bar'}, {foo: 'hi'}]));
 });
 
 test("onUpdate listeners are fired when setState is called", () => {

     let container = new StateContainer({foo: 'bar'});

     let listener1 = sinon.spy();
     let listener2 = sinon.spy();

     let rfn1 = container.onUpdate(listener1);
     let rfn2 = container.onUpdate(listener2);

 
     container.setState({'foo': 'hi'});

     rfn1();
     container.setState({'foo': 'unfoo'});

     expect(listener1.args.length).toBe(1);
     expect(JSON.stringify(listener1.args[0]))

         .toEqual(JSON.stringify(
             [{ foo: 'bar' },
              { foo: 'hi' }]
         ));
 

     expect(listener2.args.length).toBe(2);
     expect(JSON.stringify(listener2.args[0]))
         .toEqual(JSON.stringify(
             [{ foo: 'bar' },
              { foo: 'hi' }]
         ));
     expect(JSON.stringify(listener2.args[1]))
         .toEqual(JSON.stringify(
             [{ foo: 'hi' },
              { foo: 'unfoo' }]
         ));
 

     container = new StateContainer({foo: 'bar'});
     const recorder = container.getRecorder();

     listener1 = sinon.spy();
     listener2 = sinon.spy();

     rfn1 = recorder.onUpdate(listener1);
     rfn2 = recorder.onUpdate(listener2);

 
     recorder.setState({'foo': 'hi'});

     rfn1();
     recorder.setState({'foo': 'unfoo'});
 
     expect(listener1.args.length).toBe(1);
     expect(JSON.stringify(listener1.args[0]))
         .toEqual(JSON.stringify(
             [{ foo: 'bar' },
              { foo: 'hi' }]
         ));

     expect(listener2.args.length).toBe(2);
     expect(JSON.stringify(listener2.args[0]))

         .toEqual(JSON.stringify(

             [{ foo: 'bar' },
              { foo: 'hi' }]
         ));

     expect(JSON.stringify(listener2.args[1]))
         .toEqual(JSON.stringify(
             [{ foo: 'hi' },
              { foo: 'unfoo' }]
         ));

 });
 
 test("recording works", () => {
     const container = new StateContainer({foo: 'bar'});
 
     const recorder = container.getRecorder();
 
     // recorder mirrors container
     container.set('foo', 3);
     expect(recorder.get('foo')).toBe(3);
 
     // copy on write - reads from local
     recorder.set('foo', 4);
     expect(recorder.get('foo')).toBe(4);
     expect(container.get('foo')).toBe(3);
 
     // copy on write - does not read from parent
     container.set('foo', 5);
     expect(recorder.get('foo')).toBe(4);
 
     container.commit(recorder);
     expect(container.get('foo')).toBe(4)//, 'changes commited affect parent');
 
     // after committing, reflects parent again
     container.set('foo', 5);
     expect(recorder.get('foo')).toBe(5);
 
     // getState works?
     let theState = recorder.getState();
     expect(theState).toEqual({foo: 5});
 
     recorder.setState({bar: 7});
     expect(recorder.getState()).toEqual({foo: 5, bar: 7});
     expect(container.getState()).toEqual({foo: 5});
 
     container.commit(recorder);
     expect(container.getState()).toEqual({foo: 5, bar: 7});
 
     // cannot commit a recorder into wrong container
     const otherContainer = new StateContainer({foo: 'bar'});
     let err = 42;
     try {
         otherContainer.commit(recorder);
     } catch (e) {
         err = e;
     }
     expect(err instanceof Error).toBe(true)//, 'throws an error on invalid commit');
 });
 
 test("recorder getState works as expected", () => {
     let container = new StateContainer({foo: {bar: 1, baz: 1}});
     let recorder = container.getRecorder();
 
     let lens = recorder.lensFor('foo');
     lens.set({bar: 2});
 
     expect(recorder.getState()).toEqual({foo: {bar: 2}}, 'replaces when set with complex value');
 
     container = new StateContainer({foo: {bar: 1, baz: 1}});
     recorder = container.getRecorder();
     lens = recorder.lensFor(['foo', 'bar']);
 
     lens.set(2);
     expect(recorder.getState()).toEqual({foo: {bar: 2, baz: 1}}, 'updates when set with simple value');
 
 });
 test("recorder playback works correctly", () => {
     let container = new StateContainer({foo: {bar: 1, baz: 1}});
     let recorder = container.getRecorder();
 
     let lens = recorder.lensFor('foo');
     lens.set({bar: 2});
 
     container.commit(recorder);
     expect(container.getState()).toEqual({foo: {bar: 2}}, 'replaces when set with complex value');
 
     container = new StateContainer({foo: {bar: 1, baz: 1}});
     recorder = container.getRecorder();
     lens = recorder.lensFor(['foo', 'bar']);
 
     lens.set(2);
     container.commit(recorder);
     expect(container.getState()).toEqual({foo: {bar: 2, baz: 1}}, 'updates when set with simple value');
 });
 
 test("recorder from recorder also records - infinite turtles", () => {
     let container = new StateContainer({foo: {bar: 1, baz: 1}});
     let recorder = container.getRecorder();
     let subRecorder = recorder.getRecorder();
 
 
     subRecorder.set(['foo', 'bar'], 2);
     recorder.commit(subRecorder);
 
     expect(subRecorder.get(['foo', 'bar'])).toBe(2);
     recorder.set(['foo', 'bar'], 3);
     expect(subRecorder.get(['foo', 'bar'])).toBe(3);
 });
 
 test("recorder from recorder also records - infinite turtles", () => {
     let container = new StateContainer({foo: {bar: 1, baz: 1}});
     let recorder = container.getRecorder();
     let subRecorder = recorder.getRecorder();
 
 
     expect(subRecorder.get(['foo', 'bar'])).toBe(1);
     subRecorder.set(['foo', 'bar'], 2);
 
     expect(subRecorder.get(['foo', 'bar'])).toBe(2);
     expect(recorder.get(['foo', 'bar'])).toBe(1);
     expect(container.get(['foo', 'bar'])).toBe(1);
 
     recorder.commit(subRecorder);
 
     expect(subRecorder.get(['foo', 'bar'])).toBe(2);
     expect(recorder.get(['foo', 'bar'])).toBe(2);
     expect(container.get(['foo', 'bar'])).toBe(1);
 
     container.commit(recorder);
     expect(subRecorder.get(['foo', 'bar'])).toBe(2);
     expect(recorder.get(['foo', 'bar'])).toBe(2);
     expect(container.get(['foo', 'bar'])).toBe(2);
 
     container.set(['foo', 'bar'], 3);
     expect(subRecorder.get(['foo', 'bar'])).toBe(3);
 });
 
 test("lenses work", () => {

     let container, lens, sublens;

     container = new StateContainer({ foo: { bar: 1, baz: 2 } });

     lens = container.lensFor('foo');
     expect(lens.get()).toEqual({bar:1, baz: 2});
 
     sublens = lens.lensFor('bar');
     expect(sublens.get()).toBe(1);
 
     sublens.set(2);
     expect(sublens.get()).toBe(2, 'changing a nested lens updates its value');
     expect(lens.get()).toEqual({bar:2, baz: 2}, 'changing a nested lens updates its parent\'s value');
     expect(container.getState()).toEqual({foo: {bar:2, baz: 2}}, 'changing a nested lens updates container state');
 
     lens.set({bar: 3});
     expect(sublens.get()).toBe(3, 'changing parent lens to complex value updates nested lens value');
     expect(lens.get()).toEqual({bar:3}, 'changing parent lens to complex value updates itself');
     expect(container.getState()).toEqual({foo: {bar:3}}, 'changing parent lens to complex value updates container');
 
     lens.set(3);
     expect(lens.get()).toBe(3);

     expect(lens.withValue(R.identity)).toBe(3);
     expect(lens.withValue((value,prop) => R.assoc(prop, value, {b: 2, a:1}), 'a')).toEqual({a:3, b:2});

     expect(container.getState()).toEqual({foo: 3});

 
     expect(lens.swap(R.assoc('a', R.__, {b: 2, a:1}))).toEqual({a:3, b:2});
     expect(lens.get()).toEqual({a:3, b:2});
 
     container = new StateContainer({ foo: { bar: 1, baz: 2 } });
     const recorder = container.getRecorder();
 
     lens = recorder.lensFor('foo');
     expect(lens.get()).toEqual({bar:1, baz: 2});
 
     sublens = lens.lensFor('bar');
     expect(sublens.get()).toBe(1);
 
     sublens.set(2);
     expect(sublens.get()).toBe(2, 'changing a nested lens updates its value');
     expect(lens.get()).toEqual({bar:2, baz: 2}, 'changing a nested lens updates its parent\'s value');
     expect(recorder.getState()).toEqual({foo: {bar:2, baz: 2}}, 'changing a nested lens updates recorder state');
 
     lens.set({bar: 3});
     expect(sublens.get()).toBe(3, 'changing parent lens to complex value updates nested lens value');
     expect(lens.get()).toEqual({bar:3}, 'changing parent lens to complex value updates itself');
     expect(recorder.getState()).toEqual({foo: {bar:3}}, 'changing parent lens to complex value updates recorder');
 
     lens.set(3);
     expect(lens.get()).toBe(3);
     expect(lens.withValue(R.identity)).toBe(3);
     expect(lens.withValue((value,prop) => R.assoc(prop, value, {b: 2, a:1}), 'a')).toEqual({a:3, b:2});
     expect(recorder.getState()).toEqual({foo: 3});
 
     expect(lens.swap(R.assoc('a', R.__, {b: 2, a:1}))).toEqual({a:3, b:2});
     expect(lens.get()).toEqual({a:3, b:2});

 });
 
 test("lenses treat undefined properly", () => {
     let container = new StateContainer({foo: undefined});
     let lens, sublens, recorder;
 
     lens = container.lensFor('foo');
     expect(lens.get()).toEqual(undefined);
 
     sublens = lens.lensFor('bar');
     expect(sublens.get()).toBe(undefined);
 
     try {
         sublens.set(2);
     } catch (e) {
         // nothing
     }
     expect(sublens.get()).toBe(2, 'changing a nested lens updates its value');
     expect(lens.get()).toEqual({bar:2}, 'changing a nested lens updates its parent\'s value');
     expect(container.getState()).toEqual({foo: {bar:2}}, 'changing a nested lens updates container state');
 
     container = new StateContainer({foo: undefined});
     recorder = container.getRecorder();
     lens = recorder.lensFor(['foo', 'bar']);
 
     try {
         lens.set(2);
     } catch (e) {
         // nothing
     }
     expect(lens.get()).toBe(2, 'changing a lens updates its value');
 
     container = new StateContainer({foo: {bar: undefined, qwerty: 2}});
     recorder = container.getRecorder();
     lens = recorder.lensFor(['foo', 'bar', 'baz']);
 
     try {
         lens.set(2);
     } catch (e) {
         // nothing
     }
     
     expect(lens.get()).toBe(2, 'changing a lens updates its value');
     expect(recorder.getState()).toEqual({foo: {bar: {baz: 2}, qwerty: 2}});
     container.commit(recorder);
     expect(container.getState()).toEqual({foo: {bar: {baz: 2}, qwerty: 2}});
 });
 
 test('returned values are just Javascript objects', () => {
     const container = new StateContainer({foo: {bar: {baz: 1}}});
     const recorder = container.getRecorder();
 
     expect(container.get('foo').bar).toEqual({baz: 1});
     expect(recorder.get('foo').bar).toEqual({baz: 1});
 
 });
 
 test("lensFor accepts array paths", () => {
     const container = new StateContainer({foo: {bar: 1, baz: {'qwerty': 2}}});
     let lens, sublens;
 
     lens = container.lensFor(['foo', 'bar']);
     expect(lens.get()).toBe(1);
     lens.set(2);
     expect(lens.get()).toBe(2);
 
     lens = container.lensFor('foo').lensFor(['baz', 'qwerty']);
     expect(lens.get()).toBe(2);
 });
 
 test("lensFor accepts objects nested in array paths", () => {
     const container = new StateContainer({foo: {bar: 1, baz: {}}});
     let lens;
 
     lens = container.lensFor('foo').lensFor(['baz', 'qwerty', 0, 'asdf']);
     lens.set(2);
     expect(lens.get()).toBe(2);
 });
 
 test("lensFor indexes into arrays", () => {
     const container = new StateContainer({foo: {bar: [1], baz: {'qwerty': 2}}});
     let lens, sublens;
 
     lens = container.lensFor(['foo', 'bar']).lensFor(0);
     expect(lens.get()).toBe(1);
     lens.set(2);
     expect(lens.get()).toBe(2);
 
     lens = container.lensFor(['foo', 'bar']).lensFor(2);
     lens.set(3);
     expect(lens.get()).toBe(3);
 });
 
 test("lens transformers work", () => {
     const container = new StateContainer({foo: {bar: 1, baz: {'qwerty': 2}}});
     let lens, transformer;
 
     lens = container.lensFor(['foo', 'bar']);
     transformer = lensTransformer(
         lens,
         v => v * 2,
         v => v / 2
     );
 
     expect(transformer.get()).toBe(2);
     transformer.set(4);
     expect(transformer.get()).toBe(4);
 });