import 'reflect-metadata';

import {
    AppStateInterface,
    DimensionsInterface,
    LayoutBoxInterface,
    LayoutBoxModel,
    LayoutInterface,
    PictureInterface,
    ProductViewInterface,
    ProductViewItemInterface,
    ProductViewItemModel,
} from './../../../models/index';

import {
    ImageTransformFunctions,
} from './../index';

import LayoutLogicFunctions from './layout.logic.functions';

describe('fillFirstSpareBox', () => {
    // tslint:disable-next-line
    test('It does not change any layoutBoxes containedItems if none of them are text and none of them need pictures', () => {
        const newContainedItem = {} as ProductViewItemInterface;
        const layoutBoxes = [{}, {}, {}] as LayoutBoxInterface[];
        LayoutBoxModel.needsPicture = jest.fn().mockReturnValue(
            false,
        );
        LayoutBoxModel.isTextBox = jest.fn().mockReturnValue(
            false,
        );
        ProductViewItemModel.isText = jest.fn().mockReturnValue(
            false,
        );

        LayoutLogicFunctions.fillFirstSpareBox(
            newContainedItem,
            layoutBoxes,
            undefined,
        );

        layoutBoxes.forEach((layoutBox) => {
            expect(layoutBox.containedItem).toBeUndefined();
        });
    });

    // tslint:disable-next-line
    test('It changes the first layoutBox containedItem to the supplied containedItem if they are all text boxes', () => {
        const newContainedItem = {} as ProductViewItemInterface;
        const layoutBoxes = [{}, {}, {}] as LayoutBoxInterface[];
        LayoutBoxModel.needsPicture = jest.fn().mockReturnValue(
            false,
        );
        LayoutBoxModel.isTextBox = jest.fn().mockReturnValue(
            true,
        );
        ProductViewItemModel.isText = jest.fn().mockReturnValue(
            true,
        );

        LayoutLogicFunctions.fillFirstSpareBox(
            newContainedItem,
            layoutBoxes,
            undefined,
        );

        expect(
            layoutBoxes[0].containedItem,
        ).toBe(newContainedItem);
    });

    // tslint:disable-next-line
    test('If all contained items are text boxes it does not change any but the first layoutBox.containedItem', () => {
        const newContainedItem = {} as ProductViewItemInterface;
        const layoutBoxes = [{}, {}, {}] as LayoutBoxInterface[];
        LayoutBoxModel.needsPicture = jest.fn().mockReturnValue(
            false,
        );
        LayoutBoxModel.isTextBox = jest.fn().mockReturnValue(
            true,
        );
        ProductViewItemModel.isText = jest.fn().mockReturnValue(
            true,
        );

        LayoutLogicFunctions.fillFirstSpareBox(
            newContainedItem,
            layoutBoxes,
            undefined,
        );

        layoutBoxes.forEach((layoutBox, index) => {
            if (index) {
                expect(layoutBox.containedItem)
                .toBeUndefined();
            }
        });
    });

    // tslint:disable-next-line
    test('If all layoutBoxes are pictures it calls imageTransformsService.getLayoutBoxDimensions with the correct variables', () => {
        const layoutBoxDimensResponse = {};
        ImageTransformFunctions.getLayoutBoxDimensions =
            jest.fn();
        const expectedResponse = {};
        ImageTransformFunctions.setInitialImageTransforms =
            jest.fn();
        const newContainedItem = {} as ProductViewItemInterface;
        const layoutBoxes = [{}, {}, {}] as LayoutBoxInterface[];
        LayoutBoxModel.needsPicture = jest.fn().mockReturnValue(
            true,
        );
        LayoutBoxModel.isTextBox = jest.fn().mockReturnValue(
            false,
        );
        ProductViewItemModel.isText = jest.fn().mockReturnValue(
            false,
        );
        const dimensions = {
        } as DimensionsInterface;

        const layoutBoxResponse =
            LayoutLogicFunctions.fillFirstSpareBox(
                newContainedItem,
                layoutBoxes,
                dimensions,
            );

        expect(ImageTransformFunctions.getLayoutBoxDimensions)
        .toHaveBeenCalledWith(
            dimensions,
            layoutBoxes[0],
        );
    });

    // tslint:disable-next-line
    test('If all layoutBoxes are pictures it calls imageTransformsService.setInitialImageTransform with the correct variables', () => {
        const layoutBoxDimensResponse = {};
        ImageTransformFunctions.getLayoutBoxDimensions =
            jest.fn().mockReturnValue(layoutBoxDimensResponse);
        const expectedResponse = {};
        ImageTransformFunctions.setInitialImageTransforms =
            jest.fn();
        const newContainedItem = {} as ProductViewItemInterface;
        const layoutBoxes = [{}, {}, {}] as LayoutBoxInterface[];
        LayoutBoxModel.needsPicture = jest.fn().mockReturnValue(
            true,
        );
        LayoutBoxModel.isTextBox = jest.fn().mockReturnValue(
            false,
        );
        ProductViewItemModel.isText = jest.fn().mockReturnValue(
            false,
        );

        LayoutLogicFunctions.fillFirstSpareBox(
            newContainedItem,
            layoutBoxes,
            {} as DimensionsInterface,
        );

        expect(ImageTransformFunctions.setInitialImageTransforms)
        .toHaveBeenCalledWith(
            layoutBoxDimensResponse,
            newContainedItem,
        );
    });

    // tslint:disable-next-line
    test('If all layoutBoxes are pictures it sets the first to the result of imageTransformsService.setInitialImageTransform', () => {
        ImageTransformFunctions.getLayoutBoxDimensions =
            jest.fn();
        const expectedResponse = {};
        ImageTransformFunctions.setInitialImageTransforms =
            jest.fn().mockReturnValue(expectedResponse);
        const newContainedItem = {} as ProductViewItemInterface;
        const layoutBoxes = [{}, {}, {}] as LayoutBoxInterface[];
        LayoutBoxModel.needsPicture = jest.fn().mockReturnValue(
            true,
        );
        LayoutBoxModel.isTextBox = jest.fn().mockReturnValue(
            false,
        );
        ProductViewItemModel.isText = jest.fn().mockReturnValue(
            false,
        );

        LayoutLogicFunctions.fillFirstSpareBox(
            newContainedItem,
            layoutBoxes,
            {} as DimensionsInterface,
        );

        expect(
            layoutBoxes[0].containedItem,
        ).toBe(expectedResponse);
    });

    // tslint:disable-next-line
    test('If all layoutBoxes are pictures it does not alter anything but the first layoutBox needing a picture', () => {
        ImageTransformFunctions.getLayoutBoxDimensions =
            jest.fn();
        const expectedResponse = {};
        ImageTransformFunctions.setInitialImageTransforms =
            jest.fn().mockReturnValue(expectedResponse);
        const newContainedItem = {} as ProductViewItemInterface;
        const layoutBoxes = [{}, {}, {}] as LayoutBoxInterface[];
        LayoutBoxModel.needsPicture = jest.fn().mockReturnValue(
            true,
        );
        LayoutBoxModel.isTextBox = jest.fn().mockReturnValue(
            false,
        );
        ProductViewItemModel.isText = jest.fn().mockReturnValue(
            false,
        );

        LayoutLogicFunctions.fillFirstSpareBox(
            newContainedItem,
            layoutBoxes,
            {} as DimensionsInterface,
        );

        layoutBoxes.forEach((layoutBox, index) => {
            if (index > 0) {
                expect(layoutBox.containedItem)
                .toBeUndefined();
            }
        });
    });

    // tslint:disable-next-line
    test('It returns true if a picture box is filled', () => {
        ImageTransformFunctions.getLayoutBoxDimensions =
            jest.fn();
        ImageTransformFunctions.setInitialImageTransforms =
            jest.fn();
        const newContainedItem = {} as ProductViewItemInterface;
        const layoutBoxes = [{}, {}, {}] as LayoutBoxInterface[];
        LayoutBoxModel.needsPicture = jest.fn().mockReturnValue(
            true,
        );
        LayoutBoxModel.isTextBox = jest.fn().mockReturnValue(
            false,
        );
        ProductViewItemModel.isText = jest.fn().mockReturnValue(
            false,
        );

        const boxFilled =
            LayoutLogicFunctions.fillFirstSpareBox(
                newContainedItem,
                layoutBoxes,
                {} as DimensionsInterface,
            );

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

    // tslint:disable-next-line
    test('It returns true if a text box is filled', () => {
        ImageTransformFunctions.getLayoutBoxDimensions =
            jest.fn();
        ImageTransformFunctions.setInitialImageTransforms =
            jest.fn();
        const newContainedItem = {} as ProductViewItemInterface;
        const layoutBoxes = [{}, {}, {}] as LayoutBoxInterface[];
        LayoutBoxModel.needsPicture = jest.fn().mockReturnValue(
            false,
        );
        LayoutBoxModel.isTextBox = jest.fn().mockReturnValue(
            true,
        );
        ProductViewItemModel.isText = jest.fn().mockReturnValue(
            true,
        );

        const boxFilled =
            LayoutLogicFunctions.fillFirstSpareBox(
                newContainedItem,
                layoutBoxes,
                {} as DimensionsInterface,
            );

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

    // tslint:disable-next-line
    test('It returns false if no box is filled', () => {
        ImageTransformFunctions.getLayoutBoxDimensions =
            jest.fn();
        ImageTransformFunctions.setInitialImageTransforms =
            jest.fn();
        const newContainedItem = {} as ProductViewItemInterface;
        const layoutBoxes = [{}, {}, {}] as LayoutBoxInterface[];
        LayoutBoxModel.needsPicture = jest.fn().mockReturnValue(
            false,
        );
        LayoutBoxModel.isTextBox = jest.fn().mockReturnValue(
            false,
        );
        ProductViewItemModel.isText = jest.fn().mockReturnValue(
            false,
        );

        const boxFilled =
            LayoutLogicFunctions.fillFirstSpareBox(
                newContainedItem,
                layoutBoxes,
                {} as DimensionsInterface,
            );

        expect(boxFilled).toBe(false);
    });
});