import { assert } from 'chai';
import {
    hashInt32,
    hashUint32,
    hashBoolean,
    hashChar,
    hashString,
    hashAsciiString,
    hashUint8Array,
    hashUint32Array,
    hashUint32Pair,
    combineHash,
    hashFloat64,
    fuzzyHashFloat64,
    hashNumber,
    fuzzyHashNumber
} from '../../../lib/functional/hash/qhash';

describe('functional.hash.qhash', () => {
    describe('hashInt32', () => {
        test.each([
            [0, 0, undefined],
            [1, 1, undefined],
            [-1, 4294967295, undefined],
            [100, 100, undefined],
            [-100, 4294967196, undefined],
            [2147483647, 2147483647, undefined],
            [-2147483648, 2147483648, undefined],
            [0, 31, 31],
            [1, 30, 31],
            [-1, 4294967264, 31],
            [100, 123, 31],
            [-100, 4294967171, 31],
            [2147483647, 2147483616, 31],
            [-2147483648, 2147483679, 31],
        ])('hashInt32#%#', (key: number, result: number, seed: number | undefined) => {
            assert.strictEqual(hashInt32(key, seed), result);
        });
    });

    describe('hashUint32', () => {
        test.each([
            [0, 0, undefined],
            [1, 1, undefined],
            [100, 100, undefined],
            [2147483647, 2147483647, undefined],
            [4294967295, 4294967295, undefined],
            [0, 31, 31],
            [1, 30, 31],
            [100, 123, 31],
            [2147483647, 2147483616, 31],
            [4294967295, 4294967264, 31],
        ])('hashUint32#%#', (key: number, result: number, seed: number | undefined) => {
            assert.strictEqual(hashUint32(key, seed), result);
        });
    });

    describe('hashBoolean', () => {
        test.each([
            [false, 0, undefined],
            [true, 1, undefined],
            [false, 31, 31],
            [true, 30, 31],
        ])('hashBoolean#%#', (key: boolean, result: number, seed: number | undefined) => {
            assert.strictEqual(hashBoolean(key, seed), result);
        });
    });

    describe('hashChar', () => {
        test.each([
            ['a', 97, undefined],
            ['A', 65, undefined],
            ['1', 49, undefined],
            ["\n", 10, undefined],
            ['ё', 1105, undefined],
            ['a', 126, 31],
            ['A', 94, 31],
            ['1', 46, 31],
            ["\n", 21, 31],
            ['ё', 1102, 31],
        ])('hashChar#%#', (key: string, result: number, seed: number | undefined) => {
            assert.strictEqual(hashChar(key, seed), result);
        });
    });

    describe('hashString', () => {
        test.each([
            ['', 0, undefined],
            ['test', 3556498, undefined],
            ['Hello, World!', 1498789909, undefined],
            ['привет', 2093147784, undefined],
            ['', 31, 31],
            ['test', 32185649, 31],
            ['Hello, World!', 3006341718, 31],
            ['привет', 3835958119, 31],
        ])('hashString#%#', (key: string, result: number, seed: number | undefined) => {
            assert.strictEqual(hashString(key, seed), result);
        });
    });

    describe('hashAsciiString', () => {
        test.each([
            ['', 0, undefined],
            ['test', 3556498, undefined],
            ['hello', 99162322, undefined],
            ['Hello, World!', 1498789909, undefined],
            ['', 31, 31],
            ['test', 32185649, 31],
            ['hello', 986666003, 31],
            ['Hello, World!', 3006341718, 31],
        ])('hashAsciiString#%#', (key: string, result: number, seed: number | undefined) => {
            assert.strictEqual(hashAsciiString(key, seed), result);
        });
    });

    describe('hashUint8Array', () => {
        test.each([
            [new Uint8Array(0), 0, undefined],
            [Uint8Array.from([104, 101, 108, 108, 111]), 99162322, undefined],
            [Uint8Array.from([0x3c, 0xb8, 0x64, 0x18, 0xca]), 60989850, undefined],
            [new Uint8Array(0), 31, 31],
            [Uint8Array.from([104, 101, 108, 108, 111]), 986666003, 31],
            [Uint8Array.from([0x3c, 0xb8, 0x64, 0x18, 0xca]), 948493531, 31],
        ])('hashUint8Array#%#', (key: Uint8Array, result: number, seed: number | undefined) => {
            assert.strictEqual(hashUint8Array(key, seed), result);
        });
    });

    describe('hashUint32Array', () => {
        test.each([
            [[], 0, undefined],
            [[1, 2], 3449077523, undefined],
            [[1, 2, 3, 4, 5], 4276739228, undefined],
            [[12345, 23456, 34567, 45678, 56789], 153899999, undefined],
            [[], 31, 31],
            [[1, 2], 3448913980, 31],
            [[1, 2, 3, 4, 5], 1539213084, 31],
            [[12345, 23456, 34567, 45678, 56789], 3018064609, 31],
        ])('hashUint32Array#%#', (key: number[], result: number, seed: number | undefined) => {
            assert.strictEqual(hashUint32Array(key, seed), result);
        });
    });

    describe('hashUint32Pair', () => {
        test.each([
            [[0, 0], 3449077726, undefined],
            [[1, 2], 3449077523, undefined],
            [[12345, 23456], 3448214951, undefined],
            [[0, 0], 3448914047, 31],
            [[1, 2], 3448913980, 31],
            [[12345, 23456], 3448085220, 31],
        ])('hashUint32Pair#%#', (key: [number, number], result: number, seed: number | undefined) => {
            assert.strictEqual(hashUint32Pair(key, seed), result);
        });
    });

    describe('combineHash', () => {
        test.each([
            [[], 0, 0, undefined],
            [[0, 0], 3449077726, 0, undefined],
            [[1, 2], 3449077523, 0, undefined],
            [[1, 2, 3, 4, 5], 4276739228, 0, undefined],
            [[12345, 23456], 3448214951, 0, undefined],
            [[12345, 23456, 34567, 45678, 56789], 153899999, 0, undefined],
            [[], 31, 31],
            [[0, 0], 3448914047, 31],
            [[1, 2], 3448913980, 31],
            [[1, 2, 3, 4, 5], 1539213084, 31],
            [[12345, 23456], 3448085220, 31],
            [[12345, 23456, 34567, 45678, 56789], 3018064609, 31],
        ])('combineHash#%#', (key: number[], result: number, seed: number) => {
            assert.strictEqual(key.reduce(combineHash, seed), result);
        });
    });

    describe('hashFloat64', () => {
        test.each([
            [0, 3449077726, undefined],
            [-0, 1301594078, undefined],
            [NaN, 1303166942, undefined],
            [Infinity, 1302642654, undefined],
            [-Infinity, 3450126302, undefined],
            [100, 231456734, undefined],
            [-100, 2378940382, undefined],
            [1, 228900830, undefined],
            [-1, 2376384478, undefined],
            [0.5, 229949406, undefined],
            [-0.5, 2377433054, undefined],
            [1.005, 2729340075, undefined],
            [-1.005, 581856427, undefined],
            [3.14159265358979323846, 1269997433, undefined],
            [-3.14159265358979323846, 3417481081, undefined],
            [Number.MAX_SAFE_INTEGER, 148160414, undefined],
            [Number.MIN_SAFE_INTEGER, 2295644062, undefined],
            [Number.EPSILON, 241483742, undefined],
            [Number.MAX_VALUE, 1302642590, undefined],
            [Number.MIN_VALUE, 3449077533, undefined],
            [0, 3448914047, 31],
            [-0, 1301430399, 31],
            [NaN, 1303003263, 31],
            [Infinity, 1302478975, 31],
            [-Infinity, 3449962623, 31],
            [100, 231293055, 31],
            [-100, 2378776703, 31],
            [1, 228737151, 31],
            [-1, 2376220799, 31],
            [0.5, 229785727, 31],
            [-0.5, 2377269375, 31],
            [1.005, 2729186142, 31],
            [-1.005, 581702494, 31],
            [3.14159265358979323846, 1269860242, 31],
            [-3.14159265358979323846, 3417343890, 31],
            [Number.MAX_SAFE_INTEGER, 147993456, 31],
            [Number.MIN_SAFE_INTEGER, 2295477104, 31],
            [Number.EPSILON, 241320063, 31],
            [Number.MAX_VALUE, 1302475632, 31],
            [Number.MIN_VALUE, 3448913982, 31],
        ])('hashFloat64#%#', (key: number, result: number, seed: number | undefined) => {
            assert.strictEqual(hashFloat64(key, seed), result);
        });
    });

    describe('fuzzyHashFloat64', () => {
        test.each([
            [0, 3449077726, undefined],
            [-0, 1301594078, undefined],
            [NaN, 1303166942, undefined],
            [Infinity, 1302642654, undefined],
            [-Infinity, 3450126302, undefined],
            [100, 231456734, undefined],
            [-100, 2378940382, undefined],
            [1, 228900830, undefined],
            [-1, 2376384478, undefined],
            [0.5, 229949406, undefined],
            [-0.5, 2377433054, undefined],
            [1.005, 2729340075, undefined],
            [-1.005, 581856427, undefined],
            [3.14159265358979323846, 1269997433, undefined],
            [-3.14159265358979323846, 3417481081, undefined],
            // [Number.MAX_SAFE_INTEGER, 148160414, undefined],
            // [Number.MIN_SAFE_INTEGER, 2295644062, undefined],
            [Number.EPSILON, 241483742, undefined],
            // [Number.MAX_VALUE, 1302642590, undefined],
            // [Number.MIN_VALUE, 3449077533, undefined],
            [0, 3448914047, 31],
            [-0, 1301430399, 31],
            [NaN, 1303003263, 31],
            [Infinity, 1302478975, 31],
            [-Infinity, 3449962623, 31],
            [100, 231293055, 31],
            [-100, 2378776703, 31],
            [1, 228737151, 31],
            [-1, 2376220799, 31],
            [0.5, 229785727, 31],
            [-0.5, 2377269375, 31],
            [1.005, 2729186142, 31],
            [-1.005, 581702494, 31],
            [3.14159265358979323846, 1269860242, 31],
            [-3.14159265358979323846, 3417343890, 31],
            // [Number.MAX_SAFE_INTEGER, 147993456, 31],
            // [Number.MIN_SAFE_INTEGER, 2295477104, 31],
            [Number.EPSILON, 241320063, 31],
            // [Number.MAX_VALUE, 1302475632, 31],
            // [Number.MIN_VALUE, 3448913982, 31],
        ])('fuzzyHashFloat64#%#', (key: number, result: number, seed: number | undefined) => {
            assert.strictEqual(fuzzyHashFloat64(key, seed), result);
        });
    });

    describe('hashNumber', () => {
        test.each([
            // ints
            [0, 0, undefined],
            [1, 1, undefined],
            [-1, 4294967295, undefined],
            [100, 100, undefined],
            [-100, 4294967196, undefined],
            [2147483647, 2147483647, undefined],
            [-2147483648, 2147483648, undefined],
            [0, 31, 31],
            [1, 30, 31],
            [-1, 4294967264, 31],
            [100, 123, 31],
            [-100, 4294967171, 31],
            [2147483647, 2147483616, 31],
            [-2147483648, 2147483679, 31],
            // uints
            [4294967295, 4294967295, undefined],
            [4294967295, 4294967264, 31],
            // floats
            // [0, 3449077726, undefined],
            [-0, 1301594078, undefined],
            [NaN, 1303166942, undefined],
            [Infinity, 1302642654, undefined],
            [-Infinity, 3450126302, undefined],
            // [100, 231456734, undefined],
            // [-100, 2378940382, undefined],
            // [1, 228900830, undefined],
            // [-1, 2376384478, undefined],
            [0.5, 229949406, undefined],
            [-0.5, 2377433054, undefined],
            [1.005, 2729340075, undefined],
            [-1.005, 581856427, undefined],
            [3.14159265358979323846, 1269997433, undefined],
            [-3.14159265358979323846, 3417481081, undefined],
            [Number.MAX_SAFE_INTEGER, 148160414, undefined],
            [Number.MIN_SAFE_INTEGER, 2295644062, undefined],
            [Number.EPSILON, 241483742, undefined],
            [Number.MAX_VALUE, 1302642590, undefined],
            [Number.MIN_VALUE, 3449077533, undefined],
            // [0, 3448914047, 31],
            [-0, 1301430399, 31],
            [NaN, 1303003263, 31],
            [Infinity, 1302478975, 31],
            [-Infinity, 3449962623, 31],
            // [100, 231293055, 31],
            // [-100, 2378776703, 31],
            // [1, 228737151, 31],
            // [-1, 2376220799, 31],
            [0.5, 229785727, 31],
            [-0.5, 2377269375, 31],
            [1.005, 2729186142, 31],
            [-1.005, 581702494, 31],
            [3.14159265358979323846, 1269860242, 31],
            [-3.14159265358979323846, 3417343890, 31],
            [Number.MAX_SAFE_INTEGER, 147993456, 31],
            [Number.MIN_SAFE_INTEGER, 2295477104, 31],
            [Number.EPSILON, 241320063, 31],
            [Number.MAX_VALUE, 1302475632, 31],
            [Number.MIN_VALUE, 3448913982, 31],
        ])('hashNumber#%#', (key: number, result: number, seed: number | undefined) => {
            assert.strictEqual(hashNumber(key, seed), result);
        });
    });

    describe('fuzzyHashNumber', () => {
        test.each([
            // ints
            [0, 0, undefined],
            [1, 1, undefined],
            [-1, 4294967295, undefined],
            [100, 100, undefined],
            [-100, 4294967196, undefined],
            [2147483647, 2147483647, undefined],
            [-2147483648, 2147483648, undefined],
            [0, 31, 31],
            [1, 30, 31],
            [-1, 4294967264, 31],
            [100, 123, 31],
            [-100, 4294967171, 31],
            [2147483647, 2147483616, 31],
            [-2147483648, 2147483679, 31],
            // uints
            [4294967295, 4294967295, undefined],
            [4294967295, 4294967264, 31],
            // floats
            // [0, 3449077726, undefined],
            [-0, 1301594078, undefined],
            [NaN, 1303166942, undefined],
            [Infinity, 1302642654, undefined],
            [-Infinity, 3450126302, undefined],
            // [100, 231456734, undefined],
            // [-100, 2378940382, undefined],
            // [1, 228900830, undefined],
            // [-1, 2376384478, undefined],
            [0.5, 229949406, undefined],
            [-0.5, 2377433054, undefined],
            [1.005, 2729340075, undefined],
            [-1.005, 581856427, undefined],
            [3.14159265358979323846, 1269997433, undefined],
            [-3.14159265358979323846, 3417481081, undefined],
            //  [Number.MAX_SAFE_INTEGER, 148160414, undefined],
            //  [Number.MIN_SAFE_INTEGER, 2295644062, undefined],
            [Number.EPSILON, 241483742, undefined],
            //  [Number.MAX_VALUE, 1302642590, undefined],
            //  [Number.MIN_VALUE, 3449077533, undefined],
            // [0, 3448914047, 31],
            [-0, 1301430399, 31],
            [NaN, 1303003263, 31],
            [Infinity, 1302478975, 31],
            [-Infinity, 3449962623, 31],
            // [100, 231293055, 31],
            // [-100, 2378776703, 31],
            // [1, 228737151, 31],
            // [-1, 2376220799, 31],
            [0.5, 229785727, 31],
            [-0.5, 2377269375, 31],
            [1.005, 2729186142, 31],
            [-1.005, 581702494, 31],
            [3.14159265358979323846, 1269860242, 31],
            [-3.14159265358979323846, 3417343890, 31],
            //  [Number.MAX_SAFE_INTEGER, 147993456, 31],
            //  [Number.MIN_SAFE_INTEGER, 2295477104, 31],
            [Number.EPSILON, 241320063, 31],
            //  [Number.MAX_VALUE, 1302475632, 31],
            //  [Number.MIN_VALUE, 3448913982, 31],
        ])('fuzzyHashNumber#%#', (key: number, result: number, seed: number | undefined) => {
            assert.strictEqual(fuzzyHashNumber(key, seed), result);
        });
    });
});