/* @flow */

import { areBBoxesIntersectedByY } from '../../../../../utils/bbox';

import makeEpic from '../../../../epics/makeEpic';
import { receiveOnly } from '../../../../epics/makeResolveWhenFulfilledSaga';
import { SelectionFrameBorderWidth, SelectionFrameMargin } from '../../../../constants/app';

import templateOffsetValueActionType from '../../../oneweb/Template/epics/templateOffset/valueActionType';
import propertiesPanelValueActionType from '../../../PropertiesPanel/epic/valueActionType';

import scrollValueActionType from '../scroll/valueActionType';
import workspaceBBoxValueActionType from '../workspaceBBox/valueActionType';
import { IDLE } from '../componentsEval/userInteractionMutations/interactionModes';
import selectedComponentValueActionType from '../selectedComponent/valueActionType';
import editModeComponentIdValueActionType from '../editModeComponentId/valueActionType';
import componentsDependenciesValueActionType from '../componentsDependencies/valueActionType';
import { UserInteractionModeSelectedComponentIdSelector, ReceiveOnlyComponentsMap } from '../componentsEval/selectorActionTypes'; // eslint-disable-line max-len

import { MCTA_WIDTH } from './actionTypes';
import valueActionType from './valueActionType';

import styles from '../../../../view/Workspace/Decorations/ComponentMainActions/ComponentMainActions.css';

import type { ComponentMainActionsEpicState } from './flowTypes';

import { SelectedComponentActionSelector } from '../componentsEval/selectorActionTypes';

const
    defaultState: ComponentMainActionsEpicState = {
        show: false,
        selectedComponentId: null,
        selectedComponent: null,
        dependencies: null
    },
    SECONDARY_MCTA_HEIGHT = parseInt(styles.SECONDARY_MCTA_HEIGHT, 10),
    MCTA_BOTTOM_GAP = 8,
    SelectionFrameWidth = SelectionFrameBorderWidth + SelectionFrameMargin,
    MIN_TOP_DISTANCE = 47,
    getMctaTop = (selectedComponent, bottomOnly = false) => {
        const
            { top, height } = selectedComponent,
            isLessTopDistance = top < MIN_TOP_DISTANCE,
            mctaGapFromTop = MCTA_BOTTOM_GAP + SelectionFrameWidth;
        return isLessTopDistance || bottomOnly ?
            top + height + mctaGapFromTop : top - mctaGapFromTop - SECONDARY_MCTA_HEIGHT;
    },
    getMCTALeftTop = (selectedComponent, scroll) => {
        const
            { left, top } = selectedComponent;
        let mctaTop = getMctaTop(selectedComponent);
        if (top >= MIN_TOP_DISTANCE && scroll.y > mctaTop) {
            mctaTop = getMctaTop(selectedComponent, true);
        }
        return {
            top: mctaTop,
            left
        };
    },
    positionReducer = ({
        values: [
            editModeComponentId,
            workspaceBBox,
            templateOffset,
            { state: { position, dimensions } },
            selectedComponent,
            mctaWidth,
            scroll
        ],
        state: prevState
    }) => {
        if (!prevState.selectedComponent) {
            return { state: prevState };
        }

        const
            component = (selectedComponent || prevState.selectedComponent),
            { left, width } = component,
            mctaLeftTop = getMCTALeftTop(component, scroll);

        let mctaBBox;

        if (editModeComponentId) {
            mctaBBox = {
                ...mctaLeftTop,
                bottom: mctaLeftTop.top + SECONDARY_MCTA_HEIGHT,
                right: mctaLeftTop.left + mctaWidth
            };

            const propertiesPanelBBox = {
                    top: position.y - templateOffset.y,
                    left: position.x - templateOffset.x,
                    right: position.x - templateOffset.x + dimensions.width,
                    bottom: position.y - templateOffset.y + dimensions.height
                },
                // right overlapping with properties panel
                isRightOverlap = propertiesPanelBBox.left <= mctaBBox.right
                    && areBBoxesIntersectedByY(propertiesPanelBBox, mctaBBox)
                    && propertiesPanelBBox.right > left,

                isBeyondWorkspaceRight = mctaBBox.right > workspaceBBox.right,
                mctaRightAlignedLeft = left - mctaWidth + width;

            if (isRightOverlap || isBeyondWorkspaceRight) {
                mctaBBox.left = mctaRightAlignedLeft;
            }
        }

        return {
            state: {
                ...prevState,
                selectedComponent: component,
                mctaLeft: (mctaBBox || mctaLeftTop).left,
                mctaTop: (mctaBBox || mctaLeftTop).top
            }
        };
    },
    epic = makeEpic({
        defaultState,
        valueActionType,
        updaters: [
            {
                conditions: [
                    receiveOnly(componentsDependenciesValueActionType),
                    SelectedComponentActionSelector
                ],
                reducer: ({
                    values: [componentDependencies, selectedComponent],
                    state: prevState
                }) => {
                    return {
                        state: {
                            ...prevState,
                            dependencies: selectedComponent ? componentDependencies[selectedComponent.kind] : null
                        }
                    };
                }
            },
            {
                conditions: [
                    receiveOnly(scrollValueActionType),
                    ReceiveOnlyComponentsMap,
                    UserInteractionModeSelectedComponentIdSelector
                ],
                reducer: ({
                    values: [scroll, componentsMap, { selectedComponentId, mode }],
                    state: prevState
                }) => {
                    if (!selectedComponentId) {
                        return { state: defaultState };
                    }

                    if (mode !== IDLE) {
                        if (prevState.show) {
                            return { state: { ...prevState, show: false } };
                        }
                        return { state: prevState };
                    }

                    const
                        component = componentsMap[selectedComponentId],
                        mctaLeftTop = getMCTALeftTop(component, scroll);

                    return {
                        state: {
                            ...prevState,
                            show: true,
                            selectedComponentId,
                            selectedComponent: component,
                            mctaLeft: mctaLeftTop.left,
                            mctaTop: mctaLeftTop.top
                        }
                    };
                }
            },
            {
                conditions: [
                    receiveOnly(editModeComponentIdValueActionType),
                    receiveOnly(workspaceBBoxValueActionType),
                    receiveOnly(templateOffsetValueActionType),
                    receiveOnly(propertiesPanelValueActionType),
                    selectedComponentValueActionType,
                    MCTA_WIDTH,
                    receiveOnly(scrollValueActionType)
                ],
                reducer: positionReducer
            },
            {
                conditions: [
                    receiveOnly(editModeComponentIdValueActionType),
                    receiveOnly(workspaceBBoxValueActionType),
                    receiveOnly(templateOffsetValueActionType),
                    receiveOnly(propertiesPanelValueActionType),
                    selectedComponentValueActionType,
                    receiveOnly(MCTA_WIDTH),
                    scrollValueActionType
                ],
                reducer: positionReducer
            }
        ]
    });

export {
    epic as default
};