import { assert } from 'chai';
import { MetaContext } from '../../../../../../lib/experimental/meta/MetaContext';
import { $CREATE, withRestore } from '../../../../../../lib/experimental/meta/operations/base/$restore';
import constructBuiltins from '../../../../../../lib/experimental/meta/operations/builtins/$construct';
import restoreBuiltins from '../../../../../../lib/experimental/meta/operations/builtins/$restore';

const create = (function () {
    const context = new (withRestore(MetaContext))();
    context.registerAll(constructBuiltins).registerAll(restoreBuiltins);
    function create<T>(state: any) {
        return context[$CREATE](state) as T;
    };
    return create;
})();

describe('experimental.meta.operations.builtins.$restore', () => {
    describe('string', () => {
        it('string', () => {
            const state = 'abc';
            const value = create<string>(state);

            assert.strictEqual(typeof value, 'string');
            assert.strictEqual(value, 'abc');
        });
    });

    describe('number', () => {
        it('number', () => {
            const state = 123;
            const value = create<number>(state);

            assert.strictEqual(typeof value, 'number');
            assert.strictEqual(value, 123);
        });
    });

    describe('boolean', () => {
        it('boolean', () => {
            const state = true;
            const value = create<boolean>(state);

            assert.strictEqual(typeof value, 'boolean');
            assert.strictEqual(value, true);
        });
    });

    describe('null', () => {
        it('null', () => {
            const state = null;
            const value = create<null>(state);

            assert.strictEqual(typeof value, 'object');
            assert.strictEqual(value, null);
        });
    });

    describe('Object', () => {
        test.each([
            [
                {},
                {},
                (obj: any) => {
                    obj.foo = 'bar';
                }
            ],
            [
                { a: 1, b: 2, c: 3 },
                { a: 1, b: 2, c: 3 },
                (obj: any) => {
                    delete obj.a;
                    obj.b = -2;
                }
            ],
            [
                { p: { x: 1, y: 2 }, x: 3, foo: 'bar', v: [1, 2, 3] },
                { p: { x: 1, y: 2 }, x: 3, foo: 'bar', v: [1, 2, 3] },
                (obj: any) => {
                    obj.p.x = -1;
                    obj.v[0] = -1;
                }
            ]
        ])('Object#%#', (state: any, result: any, mutate: (obj: any) => void) => {
            const object = create<any>(state);

            assert.instanceOf(object, Object);
            assert.deepEqual(object, result);
            mutate(state);
            assert.deepEqual(object, result);
        });
    });

    describe('Array', () => {
        test.each([
            [
                [],
                [],
                (array: any[]) => {
                    array.push(1);
                }
            ],
            [
                [1, 2, 3],
                [1, 2, 3],
                (array: any[]) => {
                    array.splice(1, 1);
                }
            ],
            [
                [1, { x: 1, y: 2 }, [1, 2, 3], 'foo'],
                [1, { x: 1, y: 2 }, [1, 2, 3], 'foo'],
                (array: any[]) => {
                    array[1].x = -1;
                    array[2][0] = -1;
                }
            ],
        ])('Array#%#', (state: any[], result: any[], mutate: (array: any[]) => void) => {
            const array = create<any[]>(state);

            assert.isTrue(array instanceof Array);
            assert.deepEqual(array, result);
            mutate(state);
            assert.deepEqual(array, result);
        });
    });
});