import 'reflect-metadata';

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

import {
    empty,
    of,
} from 'rxjs';

import {
    BleedAreaFillService,
} from './bleed-area-fill.service';

import {
    CanvasUtilitiesService,
    CoordinateUtilitiesService,
    ImagePreloaderService,
} from './../index';

import {
    CoordsInterface,
    DimensionsInterface,
    MaskImageMapInterface,
} from '../../../models';

const initBleedAreaFillService = (
    canvasUtilitiesService?: CanvasUtilitiesService,
    coordinateUtilitiesService?: CoordinateUtilitiesService,
    imagePreloaderService?: ImagePreloaderService,
) => {
    return new BleedAreaFillService(
        canvasUtilitiesService,
        coordinateUtilitiesService,
        imagePreloaderService,
    );
};

describe('doesUserImageFillBleedArea$', () => {
    test('Calls the load method for the expected images', () => {
        const imagePreloaderService = {} as ImagePreloaderService;
        imagePreloaderService.load = jest.fn().mockReturnValue(
            empty(),
        );
        const bleedAreaFillService = initBleedAreaFillService(
            undefined,
            undefined,
            imagePreloaderService,
        );
        const maskImageMap = {
            imageEditorImage: {
                urlToRender: 'testUrl',
            },
            mask: {
                mask: 'mask',
            },
        } as MaskImageMapInterface;
        const dpi = 300;

        bleedAreaFillService.doesUserImageFillBleedArea$(
            maskImageMap,
            {} as DimensionsInterface,
            dpi,
        ).subscribe((resp) => {
            expect(imagePreloaderService.load).toHaveBeenCalledWith([
                'testUrl', 'mask', dpi,
            ]);
        });
    });

    // tslint:disable-next-line
    test('Calls doesUserImageDimensionsFillMask with the loaded images', () => {
        const imagePreloaderService = {} as ImagePreloaderService;
        const loadedImages = [{}, {}] as HTMLImageElement[];
        imagePreloaderService.load = jest.fn().mockReturnValue(
            of(loadedImages),
        );
        const bleedAreaFillService = initBleedAreaFillService(
            undefined,
            undefined,
            imagePreloaderService,
        );
        bleedAreaFillService.doesUserImageDimensionsFillMask = jest.fn();
        const maskImageMap = {
            imageEditorImage: {
                urlToRender: 'testUrl',
            },
            mask: {
                mask: 'mask',
            },
        } as MaskImageMapInterface;
        const assetDimensions = {} as DimensionsInterface;

        bleedAreaFillService.doesUserImageFillBleedArea$(
            maskImageMap,
            assetDimensions,
            300,
        ).subscribe((resp) => {
            expect(bleedAreaFillService.doesUserImageDimensionsFillMask)
            .toHaveBeenCalledWith(
                maskImageMap,
                assetDimensions,
                loadedImages[0],
                loadedImages[1],
            );
        });
    });
});

describe('doesUserImageDimensionsFillMask', () => {
    const getSetupVarsForDoesUserImageDimensionsFillMask = () => {
        const canvasUtilitiesService = {} as CanvasUtilitiesService;
        canvasUtilitiesService.getScaledEnclosingQuad = jest.fn()
            .mockReturnValue({
                size: {
                    height: 10,
                    width: 5,
                },
                topLeft: {x: 0, y: 0},
            });
        canvasUtilitiesService.getAdjustedGuideAreaPoints = jest.fn()
            .mockReturnValue([{}]);
        canvasUtilitiesService.toCanvasCoordinateSystem = jest.fn();
        const coordinateUtilitiesService = {} as CoordinateUtilitiesService;
        coordinateUtilitiesService.doRotatedCoordsFillArea = jest.fn();
        const bleedAreaFillService = initBleedAreaFillService(
            canvasUtilitiesService,
            coordinateUtilitiesService,
        );
        const maskImageMap = {
            imageEditorImage: {
                rotate_degrees: 76,
                scale: 2,
                tx: 10,
                ty: 11,
            },
            mask: {
                bleed_area: {
                    heightAdjustedForNegativeBleed: 45,
                    widthAdjustedForNegativeBleed: 90,
                },
            },
        } as MaskImageMapInterface;
        const realAssetDimensions = {
            height: 100,
            width: 50,
        } as DimensionsInterface;
        const userImageDimensions = {
            height: 50,
            width: 50,
        } as DimensionsInterface;
        const maskImageDimensions = {} as DimensionsInterface;

        return {
            bleedAreaFillService,
            canvasUtilitiesService,
            coordinateUtilitiesService,
            maskImageDimensions,
            maskImageMap,
            realAssetDimensions,
            userImageDimensions,
            dpi: 300,
        };
    };

    test('Calls canvasUtilitiesService.getScaledEnclosingQuad with the expected arguments', () => {
        const {
            bleedAreaFillService,
            canvasUtilitiesService,
            maskImageMap,
            realAssetDimensions,
            userImageDimensions,
            maskImageDimensions,
            dpi,
        } = getSetupVarsForDoesUserImageDimensionsFillMask();

        bleedAreaFillService.doesUserImageDimensionsFillMask(
            maskImageMap,
            realAssetDimensions,
            userImageDimensions,
            maskImageDimensions,
            dpi,
        );

        expect(canvasUtilitiesService.getScaledEnclosingQuad)
            .toHaveBeenCalledWith(
                realAssetDimensions,
                maskImageDimensions,
                maskImageMap,
                realAssetDimensions,
                dpi,
            );
    });

    test('Calls canvasUtilitiesService.getAdjustedGuideAreaPoints with the expected arguments', () => {
        const {
            bleedAreaFillService,
            canvasUtilitiesService,
            maskImageMap,
            realAssetDimensions,
            userImageDimensions,
            maskImageDimensions,
            dpi,
        } = getSetupVarsForDoesUserImageDimensionsFillMask();

        bleedAreaFillService.doesUserImageDimensionsFillMask(
            maskImageMap,
            realAssetDimensions,
            userImageDimensions,
            maskImageDimensions,
            dpi,
        );

        expect(canvasUtilitiesService.getAdjustedGuideAreaPoints)
            .toHaveBeenCalledWith(
                maskImageMap.mask.bleed_area,
                realAssetDimensions.width,
                realAssetDimensions.height,
                maskImageMap.mask.bleed_area.widthAdjustedForNegativeBleed,
                maskImageMap.mask.bleed_area.heightAdjustedForNegativeBleed,
            );
    });

    test('Calls canvasUtilitiesService.toCanvasCoordinateSystem with the expected arguments for the x coord', () => {
        const {
            bleedAreaFillService,
            canvasUtilitiesService,
            maskImageMap,
            realAssetDimensions,
            userImageDimensions,
            maskImageDimensions,
            dpi,
        } = getSetupVarsForDoesUserImageDimensionsFillMask();

        bleedAreaFillService.doesUserImageDimensionsFillMask(
            maskImageMap,
            realAssetDimensions,
            userImageDimensions,
            maskImageDimensions,
            dpi,
        );

        expect(canvasUtilitiesService.toCanvasCoordinateSystem)
            .toHaveBeenCalledWith(
                realAssetDimensions,
                maskImageMap.imageEditorImage.tx,
                maskImageMap,
                maskImageDimensions,
                realAssetDimensions,
                dpi,
            );
    });

    test('Calls canvasUtilitiesService.toCanvasCoordinateSystem with the expected arguments for the x coord', () => {
        const {
            bleedAreaFillService,
            canvasUtilitiesService,
            maskImageMap,
            realAssetDimensions,
            userImageDimensions,
            maskImageDimensions,
            dpi,
        } = getSetupVarsForDoesUserImageDimensionsFillMask();

        bleedAreaFillService.doesUserImageDimensionsFillMask(
            maskImageMap,
            realAssetDimensions,
            userImageDimensions,
            maskImageDimensions,
            dpi,
        );

        expect(canvasUtilitiesService.toCanvasCoordinateSystem)
            .toHaveBeenCalledWith(
                realAssetDimensions,
                maskImageMap.imageEditorImage.ty,
                maskImageMap,
                maskImageDimensions,
                realAssetDimensions,
                dpi,
            );
    });

    test('Calls coordinateUtilitiesService.doRotatedCoordsFillArea with the expected arguments', () => {
        const {
            bleedAreaFillService,
            canvasUtilitiesService,
            coordinateUtilitiesService,
            maskImageMap,
            realAssetDimensions,
            userImageDimensions,
            maskImageDimensions,
            dpi,
        } = getSetupVarsForDoesUserImageDimensionsFillMask();
        const coords = [{
            x: 0,
            y: 0,
        }, {
            x: 50,
            y: 50,
        }] as CoordsInterface[];
        canvasUtilitiesService.getAdjustedGuideAreaPoints = jest.fn()
            .mockReturnValue([coords] as CoordsInterface[][]);
        canvasUtilitiesService.toCanvasCoordinateSystem = jest.fn()
            .mockReturnValueOnce(5)
            .mockReturnValueOnce(10);

        bleedAreaFillService.doesUserImageDimensionsFillMask(
            maskImageMap,
            realAssetDimensions,
            userImageDimensions,
            maskImageDimensions,
            dpi,
        );

        expect(coordinateUtilitiesService.doRotatedCoordsFillArea)
            .toHaveBeenCalledWith(
                coords,
                {
                    x: -2,
                    y: 5,
                },
                {
                    x: 18,
                    y: 25,
                },
                76,
                {
                    x: 8,
                    y: 15,
                },
            );
    });

    test('Returns the result of canvasUtilitiesService.doRotatedCoordsFillArea', () => {
        const {
            bleedAreaFillService,
            canvasUtilitiesService,
            coordinateUtilitiesService,
            maskImageMap,
            realAssetDimensions,
            userImageDimensions,
            maskImageDimensions,
            dpi,
        } = getSetupVarsForDoesUserImageDimensionsFillMask();
        coordinateUtilitiesService.doRotatedCoordsFillArea = jest.fn()
            .mockReturnValue(true);

        const result = bleedAreaFillService.doesUserImageDimensionsFillMask(
            maskImageMap,
            realAssetDimensions,
            userImageDimensions,
            maskImageDimensions,
            dpi,
        );

        expect(result).toBe(true);
    });
});