import 'reflect-metadata';

import {
    requiredMocks,
} from './../../../../test-mocks';
requiredMocks(jest);

import {
    WindowResizeEventsService,
} from './window-resize-events.service';

const initWindowResizeEventsService = (
    nativeWindow = {} as Window,
) => {
    if (!nativeWindow.addEventListener) {
        nativeWindow.addEventListener
            = jest.fn();
    }
    return new WindowResizeEventsService(
        nativeWindow,
    );
};

describe('constructor', () => {
    // tslint:disable-next-line
    test('It calls addEventListener with resize', () => {
        const window = {} as Window;
        const addEventListenerMock = jest.fn();
        window.addEventListener = addEventListenerMock;

        const windowResizeEventsService =
            initWindowResizeEventsService(
                window,
            );

        expect(addEventListenerMock.mock.calls[0][0])
        .toBe('resize');
    });

    // tslint:disable-next-line
    test('It calls each event in the events map when resize is triggered', () => {
        const window = {} as Window;
        const addEventListenerMock = jest.fn();
        window.addEventListener = addEventListenerMock;
        const windowResizeEventsService =
            initWindowResizeEventsService(
                window,
            );
        jest.useFakeTimers();
        const resizeEvent = jest.fn();
        windowResizeEventsService.events.set(
            0, resizeEvent,
        );

        addEventListenerMock.mock.calls[0][1]();
        jest.runAllTimers();

        expect(resizeEvent).toHaveBeenCalled();
    });

    // tslint:disable-next-line
    test('It does not call the events before the timers have finished', () => {
        const window = {} as Window;
        const addEventListenerMock = jest.fn();
        window.addEventListener = addEventListenerMock;
        const windowResizeEventsService =
            initWindowResizeEventsService(
                window,
            );
        jest.useFakeTimers();
        const resizeEvent = jest.fn();
        windowResizeEventsService.events.set(
            0, resizeEvent,
        );

        addEventListenerMock.mock.calls[0][1]();

        expect(resizeEvent).not.toHaveBeenCalled();
    });

    // tslint:disable-next-line
    test('It only runs the event once if two resize events are triggered before the timer finishes', () => {
        const window = {} as Window;
        const addEventListenerMock = jest.fn();
        window.addEventListener = addEventListenerMock;
        const windowResizeEventsService =
            initWindowResizeEventsService(
                window,
            );
        jest.useFakeTimers();
        const resizeEvent = jest.fn();
        windowResizeEventsService.events.set(
            0, resizeEvent,
        );

        addEventListenerMock.mock.calls[0][1]();
        addEventListenerMock.mock.calls[0][1]();
        jest.runAllTimers();

        expect(resizeEvent).toHaveBeenCalledTimes(1);
    });
});

describe('addEvent', () => {
    // tslint:disable-next-line
    test('It adds the function to the events map', () => {
        const windowResizeEventsService =
            initWindowResizeEventsService();
        const func = () => undefined;

        windowResizeEventsService.addEvent(
            func,
        );

        expect(
            windowResizeEventsService.events.get(
                0,
            ),
        ).toBe(func);
    });

    // tslint:disable-next-line
    test('It returns the currentEventId plus 1', () => {
        const windowResizeEventsService =
            initWindowResizeEventsService();

        const firstEventNumber =
            windowResizeEventsService.addEvent(
                () => undefined,
            );
        const secondEventNumber =
            windowResizeEventsService.addEvent(
                () => undefined,
            );

        expect(
            firstEventNumber,
        ).toBe(1);
        expect(
            secondEventNumber,
        ).toBe(2);
    });
});

describe('removeEvent', () => {
    // tslint:disable-next-line
    test('It removes the event with the corresponding eventKey', () => {
        const windowResizeEventsService =
            initWindowResizeEventsService();
        windowResizeEventsService.events.set(
            1, () => undefined,
        );

        windowResizeEventsService.removeEvent(1);

        expect(
            windowResizeEventsService.events.get(
                1,
            ),
        ).toBe(undefined);
    });
});