import { assert } from 'chai';
import { MetaContext } from '../../../../../../lib/experimental/meta/MetaContext';
import { $CONSTRUCT, withConstruct } from '../../../../../../lib/experimental/meta/operations/base/$construct';
import builtins from '../../../../../../lib/experimental/meta/operations/builtins/$construct';

const construct = (function () {
    const context = new (withConstruct(MetaContext))();
    context.registerAll(builtins);
    return function construct<T>(type: string, ...args: any[]) {
        return context[$CONSTRUCT](type, ...args) as T;
    };
})();

describe('experimental.meta.operations.builtins.$construct', () => {
    describe('string', () => {
        it('string#1', () => {
            const str = construct<string>('string');
            assert.typeOf(str, 'string');
            assert.strictEqual(str, '');
        });

        it('string#2', () => {
            const str = construct<string>('string', undefined);
            assert.typeOf(str, 'string');
            assert.strictEqual(str, 'undefined');
        });

        it('string#3', () => {
            const str = construct<string>('string', '');
            assert.typeOf(str, 'string');
            assert.strictEqual(str, '');
        });

        it('string#4', () => {
            const str = construct<string>('string', 'foo');
            assert.typeOf(str, 'string');
            assert.strictEqual(str, 'foo');
        });

        it('string#5', () => {
            const str = construct<string>('string', 123);
            assert.typeOf(str, 'string');
            assert.strictEqual(str, '123');
        });
    });

    describe('String', () => {
        it('String#1', () => {
            const str = construct<String>('String');
            assert.instanceOf(str, String);
            assert.strictEqual(str.valueOf(), '');
        });

        it('String#2', () => {
            const str = construct<String>('String', undefined);
            assert.instanceOf(str, String);
            assert.strictEqual(str.valueOf(), 'undefined');
        });

        it('String#3', () => {
            const str = construct<String>('String', '');
            assert.instanceOf(str, String);
            assert.strictEqual(str.valueOf(), '');
        });

        it('String#4', () => {
            const str = construct<String>('String', 'foo');
            assert.instanceOf(str, String);
            assert.strictEqual(str.valueOf(), 'foo');
        });

        it('String#5', () => {
            const str = construct<String>('String', 123);
            assert.instanceOf(str, String);
            assert.strictEqual(str.valueOf(), '123');
        });
    });

    describe('number', () => {
        it('number#1', () => {
            const num = construct<number>('number');
            assert.typeOf(num, 'number');
            assert.strictEqual(num, 0);
        });

        it('number#2', () => {
            const num = construct<number>('number', undefined);
            assert.typeOf(num, 'number');
            assert.isNaN(num);
        });

        it('number#3', () => {
            const num = construct<number>('number', 123);
            assert.typeOf(num, 'number');
            assert.strictEqual(num, 123);
        });

        it('number#4', () => {
            const num = construct<number>('number', '123');
            assert.typeOf(num, 'number');
            assert.strictEqual(num, 123);
        });
    });

    describe('Number', () => {
        it('Number#1', () => {
            const num = construct<Number>('Number');
            assert.instanceOf(num, Number);
            assert.strictEqual(num.valueOf(), 0);
        });

        it('Number#2', () => {
            const num = construct<Number>('Number', undefined);
            assert.instanceOf(num, Number);
            assert.isNaN(num.valueOf());
        });

        it('Number#3', () => {
            const str = construct<Number>('Number', 123);
            assert.instanceOf(str, Number);
            assert.strictEqual(str.valueOf(), 123);
        });

        it('Number#4', () => {
            const str = construct<Number>('Number', '123');
            assert.instanceOf(str, Number);
            assert.strictEqual(str.valueOf(), 123);
        });
    });

    describe('boolean', () => {
        it('boolean#1', () => {
            const bool = construct<boolean>('boolean');
            assert.typeOf(bool, 'boolean');
            assert.strictEqual(bool, false);
        });

        it('boolean#2', () => {
            const bool = construct<boolean>('boolean', true);
            assert.typeOf(bool, 'boolean');
            assert.strictEqual(bool, true);
        });

        it('boolean#3', () => {
            const bool = construct<boolean>('boolean', -1);
            assert.typeOf(bool, 'boolean');
            assert.strictEqual(bool, true);
        });
    });

    describe('Boolean', () => {
        it('Boolean#1', () => {
            const bool = construct<Boolean>('Boolean');
            assert.instanceOf(bool, Boolean);
            assert.strictEqual(bool.valueOf(), false);
        });

        it('Boolean#2', () => {
            const bool = construct<Boolean>('Boolean', true);
            assert.instanceOf(bool, Boolean);
            assert.strictEqual(bool.valueOf(), true);
        });

        it('Boolean#3', () => {
            const bool = construct<Boolean>('Boolean', -1);
            assert.instanceOf(bool, Boolean);
            assert.strictEqual(bool.valueOf(), true);
        });
    });

    describe('undefined', () => {
        it('undefined#1', () => {
            const val = construct<undefined>('undefined');
            assert.typeOf(val, 'undefined');
            assert.strictEqual(val, undefined);
        });
    });

    describe('null', () => {
        it('null#1', () => {
            const val = construct<null>('null');
            assert.isTrue(typeof val === 'object');
            assert.strictEqual(val, null);
        });
    });

    describe('Object', () => {
        it('Object#1', () => {
            const obj: any = construct<Object>('Object');
            assert.instanceOf(obj, Object);
            assert.typeOf(obj, 'object');
            assert.deepEqual(obj, {});
            obj['foo'] = 'bar';
            obj[1] = 2;
            assert.deepEqual(obj, {
                foo: 'bar',
                1: 2
            });
        });

        it('Object#2', () => {
            const obj: any = construct<Object>('Object', 123);
            assert.instanceOf(obj, Number);
            assert.isTrue(typeof obj === 'object');
            assert.strictEqual(obj.valueOf(), 123);
        });
    });

    describe('object', () => {
        it('object#1', () => {
            const obj: any = construct<any>('object');
            assert.isTrue(obj.constructor === undefined);
            assert.typeOf(obj, 'object');
            assert.deepEqual(obj, {});
            obj['foo'] = 'bar';
            obj[1] = 2;
            assert.deepEqual(obj, {
                foo: 'bar',
                1: 2
            });
        });
    });

    describe('function', () => {
        it('function#1', () => {
            const fn = construct<(...args: any[]) => any>('function', 'name', 'return `Hello ${name}!`;');
            assert.typeOf(fn, 'function');
            assert.instanceOf(fn, Function);
            assert.strictEqual(fn('World'), 'Hello World!');
        });
    });

    describe('Date', () => {
        it('Date#1', () => {
            const now = Date.now();
            const date = construct<Date>('Date', now);
            assert.isTrue(typeof date === 'object');
            assert.instanceOf(date, Date);
            assert.strictEqual(date.getTime(), now);
        });

        it('Date#2', () => {
            const date = construct<Date>('Date', 2014, 1, 1);
            assert.isTrue(typeof date === 'object');
            assert.instanceOf(date, Date);
            assert.strictEqual(date.getTime(), new Date(2014, 1, 1).getTime());
        });

        it('Date#3', () => {
            const date = construct<Date>('Date');
            assert.isTrue(typeof date === 'object');
            assert.instanceOf(date, Date);
            assert.approximately(date.getTime(), new Date().getTime(), 50);
        });
    });

    describe('Array', () => {
        it('Array#1', () => {
            const array = construct<any[]>('Array');
            assert.isTrue(typeof array === 'object');
            assert.instanceOf(array, Array);
            assert.deepEqual(array, []);
        });

        it('Array#2', () => {
            const array = construct<any[]>('Array', 5);
            assert.isTrue(typeof array === 'object');
            assert.instanceOf(array, Array);
            assert.deepEqual(array, [, , , , ,]);
        });

        it('Array#3', () => {
            const array = construct<any[]>('Array', 1, 2, 3);
            assert.isTrue(typeof array === 'object');
            assert.instanceOf(array, Array);
            assert.deepEqual(array, [1, 2, 3]);
        });
    });

    describe('Map', () => {
        it('Map#1', () => {
            const map = construct<Map<any, any>>('Map');
            assert.isTrue(typeof map === 'object');
            assert.instanceOf(map, Map);
            assert.deepEqual([...map.entries()], []);
        });

        it('Map#2', () => {
            const map = construct<Map<number, string>>('Map', [[1, 'a'], [2, 'b']]);
            assert.isTrue(typeof map === 'object');
            assert.instanceOf(map, Map);
            assert.deepEqual([...map.entries()], [[1, 'a'], [2, 'b']]);
        });
    });

    describe('Set', () => {
        it('Set#1', () => {
            const set = construct<Set<any>>('Set');
            assert.isTrue(typeof set === 'object');
            assert.instanceOf(set, Set);
            assert.deepEqual([...set.values()], []);
        });

        it('Set#2', () => {
            const set = construct<Set<string>>('Set', ['a', 'b', 'c']);
            assert.isTrue(typeof set === 'object');
            assert.instanceOf(set, Set);
            assert.deepEqual([...set.values()], ['a', 'b', 'c']);
        });
    });

    describe('TypedArrays', () => {
        describe('Uint8Array', () => {
            it('Uint8Array#1', () => {
                const array = construct<Uint8Array>('Uint8Array');
                assert.isTrue(typeof array === 'object');
                assert.instanceOf(array, Uint8Array);
                assert.deepEqual(array, new Uint8Array([]));
            });

            it('Uint8Array#2', () => {
                const array = construct<Uint8Array>('Uint8Array', [21, 31]);
                assert.isTrue(typeof array === 'object');
                assert.instanceOf(array, Uint8Array);
                assert.deepEqual(array, new Uint8Array([21, 31]));
            });
        });
    });
});