import { Sorter } from '../app/utils/sorter';

let sorter: Sorter;

describe('SorterTest', () => {

    beforeEach(() => {
        sorter = new Sorter();
    });

    it('Should sort number values', () => {
        let initialArray = [
            {a: '3', b: 2},
            {a: '1', b: -1},
            {a: '1.5', b: 3}
        ];
        let sortedArray = [
            {a: '1', b: -1},
            {a: '1.5', b: 3},
            {a: '3', b: 2}
        ];

        sorter.sort('a', initialArray, false, 'number');

        expect(initialArray).toEqual(sortedArray);
    });

    it('Should sort number values in reverse order', () => {
        let initialArray = [
            {a: '3', b: 2},
            {a: '1', b: -1},
            {a: '1.5', b: 3}
        ];
        let sortedArray = [
            {a: '1', b: -1},
            {a: '1.5', b: 3},
            {a: '3', b: 2}
        ].reverse();
        sorter.key = 'a';

        sorter.sort('a', initialArray, -1, 'number');

        expect(initialArray).toEqual(sortedArray);
    });

    it('Should sort by rawValue if present', () => {
            let initialArray = [
                { key: {value: '12Byte', rawValue: '12'} },
                { key: {value: 'SomeValue', rawValue: '192'} },
                { key: {value: true, rawValue: '31020'} },
                { key : {value: {}, rawValue: '275'} }
            ];
            let sortedArray = [
                { key: {value: '12Byte', rawValue: '12'} },
                { key: {value: 'SomeValue', rawValue: '192'} },
                { key : {value: {}, rawValue: '275'} },
                { key: {value: true, rawValue: '31020'} }
            ];

        sorter.sort('key', initialArray, null, 'byte-amount');

        expect(initialArray).toEqual(sortedArray);
    });

    it('Should sort by rawValue if present in reverse order', () => {
        let initialArray = [
            { key: {value: '12Byte', rawValue: '12'} },
            { key: {value: 'SomeValue', rawValue: '192'} },
            { key: {value: true, rawValue: '31020'} },
            { key : {value: {}, rawValue: '275'} }
        ];
        let sortedArray = [
            { key: {value: '12Byte', rawValue: '12'} },
            { key: {value: 'SomeValue', rawValue: '192'} },
            { key : {value: {}, rawValue: '275'} },
            { key: {value: true, rawValue: '31020'} }
        ].reverse();
        sorter.key = 'key';

        sorter.sort('key', initialArray, -1, 'byte-amount');

        expect(initialArray).toEqual(sortedArray);
    });

    it('Should sort by value if object', () => {
        let initialArray = [
            { key : {value: 'z-test-data', field: true} },
            { key: {value: 'some', object: false} },
            { key: {value: 'very long strning', convertToFormat: 'byte'} },
            { key: {value: 'abs', array: [1, 2]} }
        ];
        let sortedArray = [
            { key: {value: 'abs', array: [1, 2]} },
            { key: {value: 'some', object: false} },
            { key: {value: 'very long strning', convertToFormat: 'byte'} },
            { key : {value: 'z-test-data', field: true} }
        ];

        sorter.sort('key', initialArray, null, 'string');

        expect(initialArray).toEqual(sortedArray);
    });

    it('Should sort by value if object in reverse order', () => {
        let initialArray = [
            { key : {value: 'z-test-data', field: true} },
            { key: {value: 'some', object: false} },
            { key: {value: 'very long strning', convertToFormat: 'byte'} },
            { key: {value: 'abs', array: [1, 2]} }
        ];
        let sortedArray = [
            { key: {value: 'abs', array: [1, 2]} },
            { key: {value: 'some', object: false} },
            { key: {value: 'very long strning', convertToFormat: 'byte'} },
            { key : {value: 'z-test-data', field: true} }
        ].reverse();
        sorter.key = 'key';

        sorter.sort('key', initialArray, -1, 'string');

        expect(initialArray).toEqual(sortedArray);
    });

    it('If value is empty string should sort as zero', () => {
        let initialArray = [
            { key : '12' },
            { key: '13' },
            { key: '' },
        ];
        let sortedArray = [
            { key: '' },
            { key : '12' },
            { key: '13' }
        ];

        sorter.sort('key', initialArray, null, 'number');

        expect(initialArray).toEqual(sortedArray);
    });

    it('If value is empty string should sort as zero in reverse order', () => {
        let initialArray = [
            { key : '12' },
            { key: '13' },
            { key: '' },
        ];
        let sortedArray = [
            { key: '' },
            { key : '12' },
            { key: '13' }
        ].reverse();
        sorter.key = 'key';

        sorter.sort('key', initialArray, -1, 'number');

        expect(initialArray).toEqual(sortedArray);
    });

    it('Should sort mixed data', () => {
        let initialArray = [
            { key: {value: '12Byte', rawValue: '1780'} },
            { key: {value: '15550', object: false} },
            { key: '' },
            { key: '255' },
            { key: {value: '1512'} }
            ];
        let sortedArray = [
            { key: '' },
            { key: '255' },
            { key: {value: '1512'} },
            { key: {value: '12Byte', rawValue: '1780'} },
            { key: {value: '15550', object: false} },
        ];

        sorter.sort('key', initialArray, null, 'byte-amount');

        expect(initialArray).toEqual(sortedArray);
    });

    it('Should sort mixed data in reverse order', () => {
        let initialArray = [
            { key: {value: '12Byte', rawValue: '1780'} },
            { key: {value: '15550', object: false} },
            { key: '' },
            { key: '255' },
            { key: {value: '1512'} }
        ];
        let sortedArray = [
            { key: '' },
            { key: '255' },
            { key: {value: '1512'} },
            { key: {value: '12Byte', rawValue: '1780'} },
            { key: {value: '15550', object: false} },
        ].reverse();
        sorter.key = 'key';

        sorter.sort('key', initialArray, -1, 'byte-amount');

        expect(initialArray).toEqual(sortedArray);
    });

});