import { assert } from 'chai';
import { has } from '../../../../lib/core/object';
import { FastSet, FastKey } from '../../../../lib/experimental/containers/FastSet';

describe('experimental.containers.FastSet', () => {
    describe('construction', () => {
        it('no arguments', () => {
            const set = new FastSet();
            assert(set, 'set should exist');
            assert.instanceOf(set, FastSet, 'set should be instance of FastSet');
        });

        it('iterable', () => {
            const set = new FastSet([1, 2, 3, 2]);
            assert.isTrue(set.has(1));
            assert.isTrue(set.has(2));
            assert.isTrue(set.has(3));
            assert.strictEqual(set.size, 3);
        });

        it('array-like', () => {
            const set = new FastSet({ 0: 1, 1: 2, 2: 3, 3: 2, length: 4 });
            assert.isTrue(set.has(1));
            assert.isTrue(set.has(2));
            assert.isTrue(set.has(3));
            assert.strictEqual(set.size, 3);
        });
    });

    it('delete', () => {
        const set = new FastSet([1]);
        assert.isTrue(set.has(1), 'Should have member');
        assert.isFalse(set.delete(2), 'Should return false for missing memeber');
        assert.isTrue(set.delete(1), 'Should return true when member removed');
        assert.isFalse(set.delete(1), 'Should return false for already removed member');
        assert.isFalse(set.has(1), 'Should now return false');
    });

    it('iterable', () => {
        const source = [1, 2, 3];
        const set = new FastSet(source);
        const results: FastKey[] = [];
        for (const value of set) {
            results.push(value);
        }
        assert.deepEqual(results, source, 'results should match source');
    });

    it('values', () => {
        const source = [1, 2, 3];
        const set = new FastSet(source);
        const results: FastKey[] = [];
        for (const value of set.values()) {
            results.push(value);
        }
        assert.deepEqual(results, source, 'results should match source');
    });

    it('entries', () => {
        const set = new FastSet([1, 2, 3]);
        const results: [string, FastKey][] = [];
        for (const value of set.entries()) {
            results.push(value);
        }
        assert.deepEqual(results, [['1', 1], ['2', 2], ['3', 3]], 'results should match expected');
    });

    it('has', () => {
        const set = new FastSet([1, '2']);
        assert.isTrue(set.has(1));
        assert.isTrue(set.has('1'));
        assert.isTrue(set.has('2'));
        assert.isTrue(set.has(2));
    });

    it('add', () => {
        const set = new FastSet();
        set.add(1)
            .add('foo')
            .add(1)
            .add('foo');
        assert.strictEqual(set.size, 2, 'should have the right size');
        assert.isTrue(set.has(1));
        assert.isTrue(set.has('foo'));
    });

    it('clear', () => {
        const set = new FastSet([1, 2, 3]);
        set.add(4);
        assert.strictEqual(set.size, 4);
        assert.isTrue(set.has(1));
        assert.isTrue(set.has(4));
        set.clear();
        assert.strictEqual(set.size, 0);
        assert.isFalse(set.has(1));
        assert.isFalse(set.has(4));
        set
            .add(1)
            .add(2)
            .add(3)
            .add(4);
        assert.strictEqual(set.size, 4);
        assert.isTrue(set.has(1));
        assert.isTrue(set.has(4));
        set.clear();
        assert.strictEqual(set.size, 0);
        assert.isFalse(set.has(1));
        assert.isFalse(set.has(4));
    });

    it('forEach', () => {
        const source = [1, 2, 3, 'foo'];
        const scope = {};
        const set = new FastSet(source);
        const results: any[] = [];
        set.forEach(function (this: any, value: any, index: any, subject: any) {
            assert.strictEqual(set, subject);
            assert.strictEqual(this, scope);
            assert.equal(value, index);
            results.push(value);
        }, scope);
        assert.deepEqual(results, source);
    });
    
    it('reset', () => {
        const set = new FastSet();
        const objectLike = Object.create({ foo: 'bar' });
        objectLike[1] = 'a';
        objectLike[2] = 'b';
        set.reset(objectLike);
        for (const key in objectLike) {
            if (has(objectLike, key)) {
                assert.isTrue(set.has(key));
            }
        }
        set.reset();
        assert.strictEqual(set.size, 0);
        for (const key in objectLike) {
            if (has(objectLike, key)) {
                assert.isFalse(set.has(key));
            }
        }
    });
});