import { Injectable } from '@angular/core';

import {
    map,
} from 'rxjs/operators';

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

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

@Injectable()
export class BleedAreaFillService {
    constructor(
        private _canvasUtilitiesService: CanvasUtilitiesService,
        private _coordinateUtilitiesService: CoordinateUtilitiesService,
        private _imagePreloaderService: ImagePreloaderService,
    ) {}

    public doesUserImageFillBleedArea$(
        maskImageMap: MaskImageMapInterface,
        realAssetDimensions: DimensionsInterface,
        dpi: number,
    ) {
        return this._imagePreloaderService.load([
            maskImageMap.imageEditorImage.urlToRender,
            maskImageMap.mask.mask,
        ]).pipe(
            map(([ userImage, maskImage ]: HTMLImageElement[]) => {
                return this.doesUserImageDimensionsFillMask(
                    maskImageMap,
                    realAssetDimensions,
                    userImage,
                    maskImage,
                    dpi,
                );
            }),
        );
    }

    public doesUserImageDimensionsFillMask(
        maskImageMap: MaskImageMapInterface,
        realAssetDimensions: DimensionsInterface,
        userImageDimensions: DimensionsInterface,
        maskImageDimensions: DimensionsInterface,
        dpi: number,
    ) {
        const quad = this._canvasUtilitiesService.getScaledEnclosingQuad(
            realAssetDimensions,
            maskImageDimensions,
            maskImageMap,
            realAssetDimensions,
            dpi,
        );

        const hRatio = quad.size.width / userImageDimensions.width;
        const vRatio = quad.size.height / userImageDimensions.height;
        const ratio = Math.max(hRatio, vRatio);

        const w = userImageDimensions.width * ratio *
            maskImageMap.imageEditorImage.scale;
        const h = userImageDimensions.height * ratio *
            maskImageMap.imageEditorImage.scale;

        const guideAreaPoints = this._canvasUtilitiesService
        .getAdjustedGuideAreaPoints(
            maskImageMap.mask.bleed_area,
            realAssetDimensions.width,
            realAssetDimensions.height,
            maskImageMap.mask.bleed_area.widthAdjustedForNegativeBleed,
            maskImageMap.mask.bleed_area.heightAdjustedForNegativeBleed,
        );
        const allGuideAreaPoints = guideAreaPoints.reduce((prev, next) => (
            prev.concat(next)
        ));

        const imageStartPointX = quad.topLeft.x;
        const imageStartPointY = quad.topLeft.y;

        const centeredWidth = Math.round((quad.size.width - w) / 2);
        const centeredHeight = Math.round((quad.size.height - h) / 2);
        const roundedTx = Math.round(
            this._canvasUtilitiesService.toCanvasCoordinateSystem(
                realAssetDimensions,
                maskImageMap.imageEditorImage.tx,
                maskImageMap,
                maskImageDimensions,
                realAssetDimensions,
                dpi,
            ),
        );
        const roundedTy = Math.round(
            this._canvasUtilitiesService.toCanvasCoordinateSystem(
                realAssetDimensions,
                maskImageMap.imageEditorImage.ty,
                maskImageMap,
                maskImageDimensions,
                realAssetDimensions,
                dpi,
            ),
        );

        const xCoordMin = imageStartPointX + centeredWidth + roundedTx;
        const xCoordMax = xCoordMin + w;
        const yCoordMin = imageStartPointY + centeredHeight + roundedTy;
        const yCoordMax = yCoordMin + h;

        const centralPoints = {
            x: xCoordMin + w / 2,
            y: yCoordMin + h / 2,
        };

        return this._coordinateUtilitiesService.doRotatedCoordsFillArea(
            allGuideAreaPoints,
            {
                x: xCoordMin,
                y: yCoordMin,
            },
            {
                x: xCoordMax,
                y: yCoordMax,
            },
            maskImageMap.imageEditorImage.rotate_degrees,
            centralPoints,
        );
    }
}