import 'reflect-metadata';

import {
    ChangeDetectorRef,
    ElementRef,
} from '@angular/core';

import {
    ProgressLoadingSpinnerComponent,
} from './progress-loading-spinner.component';

const initProgressLoadingSpinner = (
    changeDetectorRef?: ChangeDetectorRef,
    elementRef?: ElementRef,
    window?: Window,
) => {
    return new ProgressLoadingSpinnerComponent(
        changeDetectorRef,
        elementRef,
        window,
    );
};

describe('ngOnChanges', () => {
    const ngOnChangesTests = (
        itCallsUnwindSpinner: boolean,
        spinnerProgress: number,
    ) => {
        const progressLoadingSpinnerComponent =
            initProgressLoadingSpinner();
        progressLoadingSpinnerComponent.initSpinnerRadius = jest.fn();
        progressLoadingSpinnerComponent.spinnerProgress =
            spinnerProgress;
        progressLoadingSpinnerComponent.unwindSpinner =
            jest.fn();

        progressLoadingSpinnerComponent.ngOnChanges();

        if (itCallsUnwindSpinner) {
            expect(
                progressLoadingSpinnerComponent
                    .unwindSpinner,
            ).toHaveBeenCalled();
        } else {
            expect(
                progressLoadingSpinnerComponent
                    .unwindSpinner,
            ).not.toHaveBeenCalled();
        }
    };

    // tslint:disable-next-line
    test('If spinner progress is equal to 100 it calls unwindSpinner', () => {
        ngOnChangesTests(
            true,
            100,
        );
    });

    // tslint:disable-next-line
    test('If spinner progress is more than 100 it calls unwindSpinner', () => {
        ngOnChangesTests(
            true,
            101,
        );
    });

    // tslint:disable-next-line
    test('If spinner progress is less than 100 it does not call unwindSpinner', () => {
        ngOnChangesTests(
            false,
            99,
        );
    });

    test('Calls initSpinnerRadius', () => {
        const progressLoadingSpinnerComponent = initProgressLoadingSpinner();
        progressLoadingSpinnerComponent.initSpinnerRadius = jest.fn();

        progressLoadingSpinnerComponent.ngOnChanges();

        expect(progressLoadingSpinnerComponent.initSpinnerRadius)
            .toHaveBeenCalled();
    });
});

describe('initSpinnerRadius', () => {
    const initInitSpinnerRadiusData = () => {
        const elementRef = {
            nativeElement: {},
        } as ElementRef;
        const window = {} as Window;
        window.getComputedStyle = jest.fn().mockReturnValue({
            width: '12px',
        });

        const progressLoadingSpinnerComponent = initProgressLoadingSpinner(
            undefined,
            elementRef,
            window,
        );

        return {
            elementRef,
            progressLoadingSpinnerComponent,
            window,
        };
    };

    test('Calls window.getComputedStyle on the element reference', () => {
        const {
            elementRef,
            progressLoadingSpinnerComponent,
            window,
        } = initInitSpinnerRadiusData();

        progressLoadingSpinnerComponent.initSpinnerRadius();

        expect(window.getComputedStyle).toHaveBeenCalledWith(
            elementRef.nativeElement,
        );
    });

    // tslint:disable-next-line
    test('Sets the spinnerRadius to half the computed width if window.getComputedStyle returns a width', () => {
        const {
            progressLoadingSpinnerComponent,
        } = initInitSpinnerRadiusData();

        progressLoadingSpinnerComponent.initSpinnerRadius();

        expect(progressLoadingSpinnerComponent.spinnerRadius).toBe(6);
    });

    // tslint:disable-next-line
    test('Does not change the spinnerRadius if window.getComputedStyle does not return a width', () => {
        const {
            progressLoadingSpinnerComponent,
            window,
        } = initInitSpinnerRadiusData();
        window.getComputedStyle = jest.fn().mockReturnValue({});

        progressLoadingSpinnerComponent.initSpinnerRadius();

        expect(progressLoadingSpinnerComponent.spinnerRadius).toBe(18);
    });
});

describe('unwindSpinner', () => {
    // tslint:disable-next-line
    test('It sets isUnwinding to true', () => {
        const progressLoadingSpinnerComponent =
            initProgressLoadingSpinner();
        progressLoadingSpinnerComponent.isUnwinding = false;

        progressLoadingSpinnerComponent.unwindSpinner();

        expect(progressLoadingSpinnerComponent.isUnwinding)
        .toBe(true);
    });

    // tslint:disable-next-line
    test('It sets spinnerProgress to 0', () => {
        const progressLoadingSpinnerComponent =
            initProgressLoadingSpinner();
        progressLoadingSpinnerComponent.spinnerProgress =
            null;

        progressLoadingSpinnerComponent.unwindSpinner();

        expect(progressLoadingSpinnerComponent.spinnerProgress)
        .toBe(0);
    });

    // tslint:disable-next-line
    test('After the timer it sets isUnwinding to false', () => {
        const changeDetectorRef = {} as ChangeDetectorRef;
        changeDetectorRef.markForCheck = jest.fn();
        const progressLoadingSpinnerComponent =
            initProgressLoadingSpinner(
                changeDetectorRef,
            );
        progressLoadingSpinnerComponent.isUnwinding =
            true;
        jest.useFakeTimers();

        progressLoadingSpinnerComponent.unwindSpinner();
        jest.runAllTimers();

        expect(progressLoadingSpinnerComponent.isUnwinding)
        .toBe(false);
    });

    // tslint:disable-next-line
    test('After the timer it calls changeDetectorRef.markForCheck', () => {
        const changeDetectorRef = {} as ChangeDetectorRef;
        changeDetectorRef.markForCheck = jest.fn();
        const progressLoadingSpinnerComponent =
            initProgressLoadingSpinner(
                changeDetectorRef,
            );
        jest.useFakeTimers();

        progressLoadingSpinnerComponent.unwindSpinner();
        jest.runAllTimers();

        expect(changeDetectorRef.markForCheck)
        .toHaveBeenCalled();
    });
});

describe('getAnimationDuration', () => {
    // tslint:disable-next-line
    test('It returns 1300 if isUnwinding is true', () => {
        const progressLoadingSpinnerComponent =
            initProgressLoadingSpinner();
        progressLoadingSpinnerComponent.isUnwinding = true;

        const animationDuration =
            progressLoadingSpinnerComponent.getAnimationDuration();

        expect(animationDuration).toBe(1300);
    });

    // tslint:disable-next-line
    test('It returns 300 if isUnwinding is false', () => {
        const progressLoadingSpinnerComponent =
            initProgressLoadingSpinner();
        progressLoadingSpinnerComponent.isUnwinding = false;

        const animationDuration =
            progressLoadingSpinnerComponent.getAnimationDuration();

        expect(animationDuration).toBe(300);
    });
});

describe('isProgressSpinnerVisible', () => {
    // tslint:disable-next-line
    test('It returns true if isUnwinding is true', () => {
        const progressLoadingSpinnerComponent =
            initProgressLoadingSpinner();
        progressLoadingSpinnerComponent.isUnwinding = true;
        progressLoadingSpinnerComponent.spinnerProgress = 0;

        expect(
            progressLoadingSpinnerComponent
            .isProgressSpinnerVisible(),
        ).toBe(true);
    });

    // tslint:disable-next-line
    test('It returns true if spinnerProgress > 0', () => {
        const progressLoadingSpinnerComponent =
            initProgressLoadingSpinner();
        progressLoadingSpinnerComponent.isUnwinding = false;
        progressLoadingSpinnerComponent.spinnerProgress = 1;

        expect(
            progressLoadingSpinnerComponent
            .isProgressSpinnerVisible(),
        ).toBe(true);
    });

    // tslint:disable-next-line
    test('It returns false if spinnerProgress is 0 and isUnwinding is false', () => {
        const progressLoadingSpinnerComponent =
            initProgressLoadingSpinner();
        progressLoadingSpinnerComponent.isUnwinding = false;
        progressLoadingSpinnerComponent.spinnerProgress = 0;

        expect(
            progressLoadingSpinnerComponent
            .isProgressSpinnerVisible(),
        ).toBe(false);
    });
});