/* eslint-env mocha */
'use strict';

const assert = require('assert');

const check = require('./check');

check.init();

describe('Check', function () {
    const person = {name: 'John', age: 20};
    const numbers = [1, 2, 3];
    const func = function (a, b) {
        return a + b;
    };
    const str = 'some string';

    it('should check that target hasKeys', function () {
        assert.ok(person.check.hasKeys(['name', 'age']));
    });

    it('should check that target hasValueType', function () {
        assert.ok(person.check.hasValueType('name', String));
    });

    it('should check that target hasKeys', function () {
        assert.ok(numbers.check.hasKeys(['0', '1', '2']));
    });

    it('should check that target hasLength', function () {
        assert.ok(numbers.check.hasLength(3));
    });

    it('should check that target containsValues', function () {
        assert.ok(numbers.check.containsValues([2, 1]));
    });

    it('should check that target hasParamsCount', function () {
        assert.ok(func.check.hasParamsCount(2));
    });

    it('should check that target hasWordsCount', function () {
        assert.ok(str.check.hasWordsCount(2));
    });

    it('Объект containKeys', function () {
        const obj = {a: 'aaa', b: 'b'};
        assert.ok(obj.check.containsKeys(['a', 'b']));
        assert.ok(obj.check.containsKeys(['a']));
        assert.ok(obj.check.containsKeys(['b']));
        assert.ok(!obj.check.containsKeys(['c']));
        assert.ok(!obj.check.containsKeys(['a', 'b', 'c']));

        assert.ok(!obj.check.not.containsKeys(['a', 'b']));
        assert.ok(!obj.check.not.containsKeys(['a']));
        assert.ok(!obj.check.not.containsKeys(['b']));
        assert.ok(obj.check.not.containsKeys(['c']));
        assert.ok(obj.check.not.containsKeys(['a', 'b', 'c']));
    });

    it('Массив containKeys', function () {
        assert.ok(numbers.check.containsKeys(['0']));
        assert.ok(numbers.check.containsKeys(['0', '1', '2']));
        assert.ok(!numbers.check.containsKeys(['3']));
        assert.ok(!numbers.check.containsKeys(['0', '1', '2', '3']));

        assert.ok(!numbers.check.not.containsKeys(['0']));
        assert.ok(!numbers.check.not.containsKeys(['0', '1', '2']));
        assert.ok(numbers.check.not.containsKeys(['3']));
        assert.ok(numbers.check.not.containsKeys(['0', '1', '2', '3']));
    });

    it('Объект hasKeys', function () {
        const obj = {a: 'aaa', b: 'b'};
        assert.ok(obj.check.hasKeys(['a', 'b']));
        assert.ok(!obj.check.hasKeys(['a']));
        assert.ok(!obj.check.hasKeys(['b']));
        assert.ok(!obj.check.hasKeys(['c']));
        assert.ok(!obj.check.hasKeys(['a', 'b', 'c']));

        assert.ok(!obj.check.not.hasKeys(['a', 'b']));
        assert.ok(obj.check.not.hasKeys(['a']));
        assert.ok(obj.check.not.hasKeys(['b']));
        assert.ok(obj.check.not.hasKeys(['c']));
        assert.ok(obj.check.not.hasKeys(['a', 'b', 'c']));
    });

    it('Массив hasKeys', function () {
        assert.ok(!numbers.check.hasKeys(['0']));
        assert.ok(numbers.check.hasKeys(['0', '1', '2']));
        assert.ok(!numbers.check.hasKeys(['3']));
        assert.ok(!numbers.check.hasKeys(['0', '1', '2', '3']));

        assert.ok(numbers.check.not.hasKeys(['0']));
        assert.ok(!numbers.check.not.hasKeys(['0', '1', '2']));
        assert.ok(numbers.check.not.hasKeys(['3']));
        assert.ok(numbers.check.not.hasKeys(['0', '1', '2', '3']));
    });

    it('Объект containsValues', function () {
        assert.ok(person.check.containsValues(['John', 20]));
        assert.ok(person.check.containsValues(['John']));
        assert.ok(person.check.containsValues([20]));
        assert.ok(!person.check.containsValues(['smth']));
        assert.ok(!person.check.containsValues([20, 'smth']));

        assert.ok(!person.check.not.containsValues(['John', 20]));
        assert.ok(!person.check.not.containsValues(['John']));
        assert.ok(!person.check.not.containsValues([20]));
        assert.ok(person.check.not.containsValues(['smth']));
        assert.ok(person.check.not.containsValues([20, 'smth']));
    });

    it('Массив containsValues', function () {
        assert.ok(numbers.check.containsValues([1, 2, 3]));
        assert.ok(numbers.check.containsValues([1, 3]));
        assert.ok(numbers.check.containsValues([1]));
        assert.ok(!numbers.check.containsValues([4]));
        assert.ok(!numbers.check.containsValues([0, 1, 2]));

        assert.ok(!numbers.check.not.containsValues([1, 2, 3]));
        assert.ok(!numbers.check.not.containsValues([1, 3]));
        assert.ok(!numbers.check.not.containsValues([1]));
        assert.ok(numbers.check.not.containsValues([4]));
        assert.ok(numbers.check.not.containsValues([0, 1, 2]));
    });

    it('Объект hasValues', function () {
        assert.ok(person.check.hasValues(['John', 20]));
        assert.ok(!person.check.hasValues(['John']));
        assert.ok(!person.check.hasValues([20]));
        assert.ok(!person.check.hasValues(['smth']));
        assert.ok(!person.check.hasValues([20, 'smth']));

        assert.ok(!person.check.not.hasValues(['John', 20]));
        assert.ok(person.check.not.hasValues(['John']));
        assert.ok(person.check.not.hasValues([20]));
        assert.ok(person.check.not.hasValues(['smth']));
        assert.ok(person.check.not.hasValues([20, 'smth']));
    });

    it('Массив hasValues', function () {
        assert.ok(numbers.check.hasValues([1, 2, 3]));
        assert.ok(!numbers.check.hasValues([1, 3]));
        assert.ok(!numbers.check.hasValues([1]));
        assert.ok(!numbers.check.hasValues([4]));
        assert.ok(!numbers.check.hasValues([0, 1, 2]));

        assert.ok(!numbers.check.not.hasValues([1, 2, 3]));
        assert.ok(numbers.check.not.hasValues([1, 3]));
        assert.ok(numbers.check.not.hasValues([1]));
        assert.ok(numbers.check.not.hasValues([4]));
        assert.ok(numbers.check.not.hasValues([0, 1, 2]));
    });

    it('Объект hasValueType`', function () {
        assert.ok(person.check.hasValueType('name', String));
        assert.ok(!person.check.hasValueType('name', Number));
        assert.ok(person.check.hasValueType('age', Number));
        assert.ok(!person.check.hasValueType('age', String));

        assert.ok(!person.check.not.hasValueType('name', String));
        assert.ok(person.check.not.hasValueType('name', Number));
        assert.ok(!person.check.not.hasValueType('age', Number));
        assert.ok(person.check.not.hasValueType('age', String));
        let obj = {
            names: ['Dims', 'Nast'],
            getNums() {
                return '123';
            }
        };
        assert.ok(obj.check.hasValueType('names', Array));
        assert.ok(!obj.check.hasValueType('names', Function));
        assert.ok(obj.check.hasValueType('getNums', Function));
        assert.ok(!obj.check.hasValueType('getNums', Array));

        assert.ok(!obj.check.not.hasValueType('names', Array));
        assert.ok(obj.check.not.hasValueType('names', Function));
        assert.ok(!obj.check.not.hasValueType('getNums', Function));
        assert.ok(obj.check.not.hasValueType('getNums', Array));
    });
    // Если типа нет, то что делать?
    it('Массив hasValueType`', function () {
        let f = () => '123';
        const arr = [numbers, f, 123, '123'];
        assert.ok(arr.check.hasValueType('0', Array));
        assert.ok(!arr.check.hasValueType('0', Number));
        assert.ok(arr.check.hasValueType('1', Function));
        assert.ok(!arr.check.hasValueType('1', Number));
        assert.ok(arr.check.hasValueType('2', Number));
        assert.ok(!arr.check.hasValueType('2', String));
        assert.ok(arr.check.hasValueType('3', String));
        assert.ok(!arr.check.hasValueType('3', Array));

        assert.ok(!arr.check.not.hasValueType('0', Array));
        assert.ok(arr.check.not.hasValueType('0', Number));
        assert.ok(!arr.check.not.hasValueType('1', Function));
        assert.ok(arr.check.not.hasValueType('1', Number));
        assert.ok(!arr.check.not.hasValueType('2', Number));
        assert.ok(arr.check.not.hasValueType('2', String));
        assert.ok(!arr.check.not.hasValueType('3', String));
        assert.ok(arr.check.not.hasValueType('3', Array));
    });

    it('Массив hasLength`', function () {
        assert.ok(numbers.check.hasLength(3));
        assert.ok(!numbers.check.hasLength(0));
        assert.ok(!numbers.check.hasLength(4));

        assert.ok(!numbers.check.not.hasLength(3));
        assert.ok(numbers.check.not.hasLength(0));
        assert.ok(numbers.check.not.hasLength(4));
    });

    it('Строка hasLength`', function () {
        const s = '123';
        assert.ok(s.check.hasLength(3));
        assert.ok(!s.check.hasLength(0));
        assert.ok(!s.check.hasLength(4));

        assert.ok(!s.check.not.hasLength(3));
        assert.ok(s.check.not.hasLength(0));
        assert.ok(s.check.not.hasLength(4));
    });

    it('Строка hasWordsCount`', function () {
        assert.ok('1 2 3'.check.hasWordsCount(3));
        assert.ok(!'1 2 3'.check.hasWordsCount(2));
        assert.ok(''.check.hasWordsCount(0));
        assert.ok(!''.check.hasWordsCount(1));
        assert.ok('1  2'.check.hasWordsCount(2));
        assert.ok(!'1  2'.check.hasWordsCount(3));

        assert.ok(!'1 2 3'.check.not.hasWordsCount(3));
        assert.ok('1 2 3'.check.not.hasWordsCount(2));
        assert.ok(!''.check.not.hasWordsCount(0));
        assert.ok(''.check.not.hasWordsCount(1));
        assert.ok(!'1  2'.check.not.hasWordsCount(2));
        assert.ok('1  2'.check.not.hasWordsCount(3));
    });

    it('Функция hasParamsCount', function () {
        const f1 = function (a, b) {
            return a + b;
        };
        const f2 = function () {
            return 123;
        };
        const f3 = function (a, b, c) {
            let g = 6;

            return a + b + c + g;
        };
        assert.ok(f1.check.hasParamsCount(2));
        assert.ok(!f1.check.hasParamsCount(1));
        assert.ok(f2.check.hasParamsCount(0));
        assert.ok(!f2.check.hasParamsCount(1));
        assert.ok(f3.check.hasParamsCount(3));
        assert.ok(!f3.check.hasParamsCount(4));

        assert.ok(!f1.check.not.hasParamsCount(2));
        assert.ok(f1.check.not.hasParamsCount(1));
        assert.ok(!f2.check.not.hasParamsCount(0));
        assert.ok(f2.check.not.hasParamsCount(1));
        assert.ok(!f3.check.not.hasParamsCount(3));
        assert.ok(f3.check.not.hasParamsCount(4));
    });

    const wrappedNull = check.wrap(null);
    const wrappedNumbers = check.wrap([1, 2, 3]);
    const wrappedPerson = check.wrap({name: 'Dims', age: 20});
    const wrappedFunction = check.wrap((a, b) => a + b);
    const wrappedString = check.wrap('word1 word2 word3');

    it('wrap isNull', function () {
        assert.ok(wrappedNull.isNull());
        assert.ok(!wrappedFunction.isNull());
        assert.ok(!wrappedNumbers.isNull());
        assert.ok(!wrappedPerson.isNull());
        assert.ok(!wrappedString.isNull());

        assert.ok(!wrappedNull.not.isNull());
        assert.ok(wrappedFunction.not.isNull());
        assert.ok(wrappedNumbers.not.isNull());
        assert.ok(wrappedPerson.not.isNull());
        assert.ok(wrappedString.not.isNull());
    });

    it('wrap containsKeys', function () {
        assert.ok(wrappedPerson.containsKeys(['name']));
        assert.ok(wrappedNumbers.containsKeys(['0']));
        assert.ok(!wrappedNull.containsKeys(['0']));
        assert.ok(!wrappedFunction.containsKeys(['0']));
        assert.ok(!wrappedString.containsKeys(['0']));

        assert.ok(!wrappedPerson.not.containsKeys(['name']));
        assert.ok(!wrappedNumbers.not.containsKeys(['0']));
        assert.ok(!wrappedNull.not.containsKeys(['0']));
        assert.ok(!wrappedFunction.not.containsKeys(['0']));
        assert.ok(!wrappedString.not.containsKeys(['0']));
    });

    it('wrap hasKeys', function () {
        assert.ok(wrappedPerson.hasKeys(['name', 'age']));
        assert.ok(!wrappedPerson.hasKeys(['name']));
        assert.ok(wrappedNumbers.hasKeys(['0', '1', '2']));
        assert.ok(!wrappedNumbers.hasKeys(['0', '1']));

        assert.ok(!wrappedPerson.not.hasKeys(['name', 'age']));
        assert.ok(wrappedPerson.not.hasKeys(['name']));
        assert.ok(!wrappedNumbers.not.hasKeys(['0', '1', '2']));
        assert.ok(wrappedNumbers.not.hasKeys(['0', '1']));
    });


});