/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:

*

*/

#include <QVector2D>

#include "hswidgetpositioningonwidgetmove.h"

#include "hsapp_defs.h"

/*!

    The distance by which the line is extended on each side of reference points

*/

#define SNAP_LINE_EXTEND_VALUE 10.0

/*!

    Sets the snap method instance. The existing instance

    will be deleted.

*/

void HsWidgetPositioningOnWidgetMove::setInstance(HsWidgetPositioningOnWidgetMove *instance)

{

    if (mInstance)

        delete mInstance;

    mInstance = instance;

}

/*!

    Returns the snap method instance.

*/

HsWidgetPositioningOnWidgetMove *HsWidgetPositioningOnWidgetMove::instance()

{

    return mInstance;

}

/*!

    Points to the snap method instance.

*/

HsWidgetPositioningOnWidgetMove *HsWidgetPositioningOnWidgetMove::mInstance = 0;

/*!

    Constructor.

*/

HsSnapToLines::HsSnapToLines() :

    mActiveRectWidth(0.0), mActiveRectHeight(0.0), mMinDistancePosition(0.0),

    mHorizontalSnapPosition(0.0), mVerticalSnapPosition(0.0),

    mHorizontalSnapFound(false), mVerticalSnapFound(false),

    mRectLieAbove(false), mLeftInRange(false), mRightInRange(false), mIsBetterFitHorizontalSnap(false),

    mDistanceVerticalEdges(0.0), mVerticalEdgeToLeftOfInactiveRect(0.0), mVerticalEdgeToRightOfInactiveRect(0.0),

    mMinVerticalEdgesDistance(0.0), mVerticalDistance(0.0),

    mVerticalDistanceFromSelectedRect(0.0), mContainerVerticalEdgeDistance(0.0),

    mRectLieLeft(false), mTopInRange(false), mBottomInRange(false), mIsBetterFitVerticalSnap(false),

    mDistanceHorizontalEdges(0.0), mHorizontalEdgeToTopOfInactiveRect(0.0), mHorizontalEdgeToBottomOfInactiveRect(0.0),

    mMinHorizontalEdgesDistance(0.0), mHorizontalDistance(0.0),

    mHorizontalDistanceFromSelectedRect(0.0), mContainerHorizontalEdgeDistance(0.0),

    mSnapEnabled(false), mSnapForce(0.0), mSnapGap(0.0),

    mRectVerticalEdgeLiesInLineWithVerticalLine(false), mRectLieAboveVerticalLine(false), mRectLieBelowVerticalLine(false),

    mRectHorizontalEdgeLiesInLineWithHorizontalLine(false), mRectLieLeftOfHorizontalLine(false), mRectLiesRightOfHorizontalLine(false)

{

}

/*!

    Configures the snap-to-lines algorithm.

*/

void HsSnapToLines::setConfiguration(const QVariantHash &configuration)

{

    bool canConvert = false;

    mSnapEnabled = configuration[Hs::snapEnabled].toBool();

    //The following values should be in qreal, so the status received in canConvert is ignored

    mSnapForce = configuration[Hs::snapForce].toDouble(&canConvert);

    mSnapGap = configuration[Hs::snapGap].toDouble(&canConvert);

}

/*!

    Set the dimensions of container rect, active rect and position of Inactive Rects

    on the page.

*/

void HsSnapToLines::setPagePresentation(const QRectF &containerRect, 

                                        const QList<QRectF> &inactiveRects,

                                        const QRectF &activeRect)

{

    mContainerRect = containerRect;

    mActiveRectWidth = activeRect.width();

    mActiveRectHeight = activeRect.height();

    createSnappableRectangles(inactiveRects);

}

/*!

    Create the list of rects and flag if their sides are snappable from top or bottom or left or right,

    depending on other rects overlapping with the rect.

*/

void HsSnapToLines::createSnappableRectangles(const QList<QRectF> &inactiveRects)

{

    mInactiveSnapRects.clear();

    int i;

    for (i = 0; i<inactiveRects.count(); ++i) {

        QRectF rect = inactiveRects[i];

        HsSnapRectangle snapRectangle(rect);

        int j;

        for (j = 0; j<inactiveRects.count(); ++j) {

            QRectF rectToCompare = inactiveRects[j];

            if (rect != rectToCompare) {

                //Check if the rectangles being compared intersect each other

                if (rectToCompare.intersects(rect)) {

                    //As the widgets intersect, check which corner is contained,

                    //The corner that is contained is not snappable, when the moving widget is in the same position

                    if (rectToCompare.contains(rect.topLeft())) {

                        snapRectangle.isLeftSnapableForAbove = false;

                        snapRectangle.isTopSnapableForLeft = false;

                    }

                    if (rectToCompare.contains(rect.topRight())) {

                        snapRectangle.isRightSnapableForAbove = false;

                        snapRectangle.isTopSnapableForRight = false;

                    }

                    if (rectToCompare.contains(rect.bottomRight())) {

                        snapRectangle.isRightSnapableForBelow = false;

                        snapRectangle.isBottomSnapableForRight = false;

                    }

                    if (rectToCompare.contains(rect.bottomLeft())) {

                        snapRectangle.isLeftSnapableForBelow = false;

                        snapRectangle.isBottomSnapableForLeft = false;

                    }

                }

            }

        }

        if (snapRectangle.isLeftSnapableForAbove || snapRectangle.isLeftSnapableForBelow ||

            snapRectangle.isRightSnapableForAbove || snapRectangle.isRightSnapableForBelow ||

            snapRectangle.isTopSnapableForLeft || snapRectangle.isTopSnapableForRight ||

            snapRectangle.isBottomSnapableForLeft || snapRectangle.isBottomSnapableForRight) {

                mInactiveSnapRects.append(snapRectangle);

        }

    }

}

/*!

    Run the snap algorithm to with the position of moving rect, to get a snap result.

*/

HsWidgetPositioningOnWidgetMove::Result HsSnapToLines::run(const QRectF &movingRect)

{

    HsWidgetPositioningOnWidgetMove::Result result;

    if (mSnapEnabled) {

        mMovingRect = movingRect;

        mHorizontalSnapPosition = 0.0;

        mVerticalSnapPosition = 0.0;

        mVerticalLine = QLineF();

        mMinVerticalEdgesDistance = mSnapForce;

        mVerticalDistanceFromSelectedRect = 0.0;

        mContainerVerticalEdgeDistance = 0.0;

        mHorizontalSnapFound = false;

        mHorizontalLine = QLineF();

        mMinHorizontalEdgesDistance = mSnapForce;

        mHorizontalDistanceFromSelectedRect = 0.0;

        mContainerHorizontalEdgeDistance = 0.0;

        mVerticalSnapFound = false;

        for (int i = 0; i < mInactiveSnapRects.count(); ++i) {

            mInactiveSnapRectToCompare = mInactiveSnapRects[i];

            mInactiveRectToCompare = mInactiveSnapRectToCompare.rectangle;

            if (!movingRect.intersects(mInactiveRectToCompare)) { //Only compare if Inactive Rect and moving rect do not overlap.

                // Horizontal - Direction Snapping

                compareLeftSideOfMovingRectForSnapping();

                compareRightSideOfMovingRectForSnapping();

                // Vertical - Direction Snapping

                compareTopOfMovingRectForSnapping();

                compareBottomOfMovingRectForSnapping();

            }

        }

        if (mHorizontalSnapFound) {

            result.hasHorizontalSnap = true;

            result.horizontalSnapPosition = mHorizontalSnapPosition;

            extendVerticalLine();

            result.verticalSnapLine = mVerticalLine;

        }

        if (mVerticalSnapFound) {

            result.hasVerticalSnap = true;

            result.verticalSnapPosition = mVerticalSnapPosition;

            extendHorizontalLine();

            result.horizontalSnapLine = mHorizontalLine;

        }

    }

    return result;

}

/*!

    Check if the inactive rect being compared with moving rect lies above or below of moving rect.

*/

void HsSnapToLines::checkInactiveRectLieAboveOrBelowOfMovingRect()

{

    //Check if the inactive rect lies below or above of the moving rect

    mRectLieAbove = false;

    mVerticalDistance = 0.0;

    //Inactive Rect lies above or at the save Y position as the Moving Rect

    if (mInactiveRectToCompare.top() <= mMovingRect.top()) {

        mRectLieAbove = true;

        if (mInactiveRectToCompare.bottom() <= mMovingRect.top()) {

            mVerticalDistance = mMovingRect.top() - mInactiveRectToCompare.bottom();

        }

        else {

            mVerticalDistance = mMovingRect.top() - mInactiveRectToCompare.top();

        }

    }

    //Inactive Rect lies below the Moving Rect

    else {

        mRectLieAbove = false;

        if (mMovingRect.bottom() <= mInactiveRectToCompare.top()) {

            mVerticalDistance = mInactiveRectToCompare.top() - mMovingRect.bottom();

        }

        else {

            mVerticalDistance = mInactiveRectToCompare.bottom() - mMovingRect.bottom();

        }

    }

}

/*!

    Check if the Vertical edges (Left and Right Edges) of the inactive rect being compared

    is in range of the snapping distance of the vertical edge of moving rect

    \param movingRectVerticalEdgePosition Position of the Vertical edge(either left or right) of moving rect.

*/

void HsSnapToLines::checkInactiveRectVerticalEdgesInRange(qreal movingRectVerticalEdgePosition)

{

    mLeftInRange = false;

    mRightInRange = false;

    //calculate the distance of the moving rect's vertical edge to the inactive rect's left and right edges

    mVerticalEdgeToLeftOfInactiveRect = qAbs(mInactiveRectToCompare.left() - movingRectVerticalEdgePosition);

    mVerticalEdgeToRightOfInactiveRect = qAbs(mInactiveRectToCompare.right() - movingRectVerticalEdgePosition);

    if (mVerticalEdgeToLeftOfInactiveRect <= mMinVerticalEdgesDistance 

        && (mRectLieAbove && mInactiveSnapRectToCompare.isLeftSnapableForBelow

        || !mRectLieAbove && mInactiveSnapRectToCompare.isLeftSnapableForAbove)) { 

        mLeftInRange = true;

    }

    if (mVerticalEdgeToRightOfInactiveRect <= mMinVerticalEdgesDistance

        && (mRectLieAbove && mInactiveSnapRectToCompare.isRightSnapableForBelow

        || !mRectLieAbove && mInactiveSnapRectToCompare.isRightSnapableForAbove)) {

        mRightInRange = true;

    }

}

/*!

    Check if this inactive rect is better fit for Horizontal snapping

    \param containerVerticalEdgeToInactiveRectVerticalEdge

           difference between the vertical edge of the container and same vertical edge of inactive rect

    \param containerOtherVerticalEdgeToInactiveRectOtherVerticalEdge

           difference between the opposite vertical edges of continer and the inactive rect

*/

void HsSnapToLines::checkInactiveRectBetterFitForHorizontalSnapping(qreal containerVerticalEdgeToInactiveRectVerticalEdge,

                                                                    qreal containerOtherVerticalEdgeToInactiveRectOtherVerticalEdge)

{

    //Check if the inactive rect is better fit or if it is inline with already selected position and hence is also a better fit

    mIsBetterFitHorizontalSnap = false;

    if (mLeftInRange || mRightInRange) {

        if (mDistanceVerticalEdges < mMinVerticalEdgesDistance) {

            mIsBetterFitHorizontalSnap = true;

        }

        else if (mDistanceVerticalEdges == mMinVerticalEdgesDistance) { //the distance in the vertical edges is same as from the previously selected rect

            //check the position of rect with respect to Vertical line

            checkInactiveRectPositionToVerticalLine();

            //if horizontal snap position was previously found and the rect's edge is in line with Vertical line

            if (mHorizontalSnapFound && mRectVerticalEdgeLiesInLineWithVerticalLine) {

                if (mRectLieAboveVerticalLine || mRectLieBelowVerticalLine) {

                    extendVerticalLineToIncludeInactiveRect();

                }

            }

            //here the case is that moving rect lies exactly in middle of two same sides of two different inactive widgets.

            else {

                //Prioritize first on the fact if the inactive rect is closer to the moving rect in Y - direction.

                if (mVerticalDistance < mVerticalDistanceFromSelectedRect) {

                    mIsBetterFitHorizontalSnap = true;

                }

                else if (mVerticalDistance == mVerticalDistanceFromSelectedRect) {

                    //Prioritize next if this Inactive rect's vertical edge is closer to the same vertical edge of the container rect, then the previously selected rect

                    if (containerVerticalEdgeToInactiveRectVerticalEdge < mContainerVerticalEdgeDistance) {

                        mIsBetterFitHorizontalSnap = true;

                    }

                    //Prioritize next if the Inactive rect's vertical edge lies near to same vertical edge of the container rect than the other pair

                    else if (containerVerticalEdgeToInactiveRectVerticalEdge < containerOtherVerticalEdgeToInactiveRectOtherVerticalEdge) {

                        mIsBetterFitHorizontalSnap = true;

                    }

                    else {

                        //This else will happen if this rectangle being compared is exactly the same as the selected rectangle for snapping, but in opposite Y direction.

                        //In that case it does not matter which is the selected rectangle. Hece we leave the already selected rectangle as the better fit.

                    }

                }

            }

        }

    }

}

/*!

    Check if the left edge of moving rect is snappable to the incative rect's left or right edge.

    The inactive rect's edge is only chosen if it is a better fit for horizontal snapping.

*/

void HsSnapToLines::compareLeftSideOfMovingRectForSnapping()

{

    checkInactiveRectLieAboveOrBelowOfMovingRect();

    checkInactiveRectVerticalEdgesInRange(mMovingRect.left());

    //calculate the distance of inactive rect's left edge and container rect's left edge

    qreal differenceContainerLeftEdgeToInactiveRectLeftEdge = mInactiveRectToCompare.left() - mContainerRect.left();

    //calculate the distance of inactive rect's right edge and container rect's right edge

    qreal differenceContainerRightEdgeToInactiveRectRightEdge = mContainerRect.right() - mInactiveRectToCompare.right();

    qreal xSnapGapAdjustment = 0.0;

    mDistanceVerticalEdges = 0.0;

    mMinDistancePosition = 0.0;

    //If only one edge of inactive rect is in snappable range, save that position

    if ((mLeftInRange && !mRightInRange)

        || !mLeftInRange && mRightInRange) {

        if (mLeftInRange) {

            mMinDistancePosition = mInactiveRectToCompare.left();

            mDistanceVerticalEdges = mVerticalEdgeToLeftOfInactiveRect;

            xSnapGapAdjustment = 0.0;

        }

        else {

            mMinDistancePosition = mInactiveRectToCompare.right();

            mDistanceVerticalEdges = mVerticalEdgeToRightOfInactiveRect;

            xSnapGapAdjustment = mSnapGap;

        }

    }

    //else both edges of inactive rect are in range, check which is a better fit

    else if (mLeftInRange && mRightInRange) {

        //if left edge of moving rect to the left of the inactive rect is closer than the left edge of moving rect to the right of the inactive rect

        if (mVerticalEdgeToLeftOfInactiveRect < mVerticalEdgeToRightOfInactiveRect) {

            mMinDistancePosition = mInactiveRectToCompare.left();

            mDistanceVerticalEdges = mVerticalEdgeToLeftOfInactiveRect;

            xSnapGapAdjustment = 0.0;

            mRightInRange = false;

        }

        //if the left edge of inactive rect to left of moving rect is at the same distance as the right edge of inactive rect to the right of moving rect

        else if (mVerticalEdgeToLeftOfInactiveRect == mVerticalEdgeToRightOfInactiveRect) {

            //if inactive rect lies towards the left or middle of container rect, then the left edge is priortized as the selected edge for outside snapping 

            if (differenceContainerLeftEdgeToInactiveRectLeftEdge <= differenceContainerRightEdgeToInactiveRectRightEdge) { 

                mMinDistancePosition = mInactiveRectToCompare.left();

                mDistanceVerticalEdges = mVerticalEdgeToLeftOfInactiveRect;

                xSnapGapAdjustment = 0.0;

                mRightInRange = false;

            }

            //else right of the inactive rect lies more close to the right of the container rect, and hence prioritize it for snapping.

            else {

                mMinDistancePosition = mInactiveRectToCompare.right();

                mDistanceVerticalEdges = mVerticalEdgeToRightOfInactiveRect;

                xSnapGapAdjustment = mSnapGap;

                mLeftInRange = false;

            }

        }

        //else right edge of inactive rect to the left of the moving rect is closer than the left edge of inactive rect to the left of the moving rect

        else{

            mMinDistancePosition = mInactiveRectToCompare.right();

            mDistanceVerticalEdges = mVerticalEdgeToRightOfInactiveRect;

            xSnapGapAdjustment = mSnapGap;

            mLeftInRange = false;

        }

    }

    //Check if this inactive rect is better fit than the previous selected rect for Horizontal - snapping

    checkInactiveRectBetterFitForHorizontalSnapping(differenceContainerLeftEdgeToInactiveRectLeftEdge,

                                                    differenceContainerRightEdgeToInactiveRectRightEdge);

    if (mIsBetterFitHorizontalSnap) {

        qreal proposedRightOfActiveRect = mMinDistancePosition + xSnapGapAdjustment + mActiveRectWidth;

        if (qBound(mContainerRect.left(), proposedRightOfActiveRect, mContainerRect.right())

            == proposedRightOfActiveRect) {

            mHorizontalSnapFound = true;

            mHorizontalSnapPosition = mMinDistancePosition + xSnapGapAdjustment;

            mMinVerticalEdgesDistance = mDistanceVerticalEdges;

            mVerticalDistanceFromSelectedRect = mVerticalDistance;

            //Save the new distance of the Chosen Rectangle's left edge from Container's left edge

            mContainerVerticalEdgeDistance = differenceContainerLeftEdgeToInactiveRectLeftEdge;

            createVerticalLine();

        }

    }

}

/*!

    Check if the right edge of moving rect is snappable to the incative rect's left or right edge.

    The inactive rect's edge is only chosen if it is a better fit for horizontal snapping.

*/

void HsSnapToLines::compareRightSideOfMovingRectForSnapping()

{

    checkInactiveRectLieAboveOrBelowOfMovingRect();

    checkInactiveRectVerticalEdgesInRange(mMovingRect.right());

    //calculate the distance of inactive rect's left edge and container rect's left edge

    qreal differenceContainerLeftEdgeToInactiveRectLeftEdge = mInactiveRectToCompare.left() - mContainerRect.left();

    //calculate the distance of inactive rect's right edge and container rect's right edge

    qreal differenceContainerRightEdgeToInactiveRectRightEdge = mContainerRect.right() - mInactiveRectToCompare.right();

    qreal xSnapGapAdjustment = 0.0;

    mDistanceVerticalEdges = 0.0;

    mMinDistancePosition = 0.0;

    //If only one edge of inactive rect is in snappable range, save that position

    if ((mLeftInRange && !mRightInRange)

        || !mLeftInRange && mRightInRange) {

        if (mLeftInRange) {

            mMinDistancePosition = mInactiveRectToCompare.left();

            mDistanceVerticalEdges = mVerticalEdgeToLeftOfInactiveRect;

            xSnapGapAdjustment = mSnapGap;

        }

        else {

            mMinDistancePosition = mInactiveRectToCompare.right();

            mDistanceVerticalEdges = mVerticalEdgeToRightOfInactiveRect;

            xSnapGapAdjustment = 0.0;

        }

    }

    //else both edges of inactive rect are in range, check which is a better fit

    else if (mLeftInRange && mRightInRange) {

        //if right edge of moving rect to the right of the inactive rect is closer than the right edge of moving rect to the left of inactive rect

        if (mVerticalEdgeToRightOfInactiveRect < mVerticalEdgeToLeftOfInactiveRect) {

            mMinDistancePosition = mInactiveRectToCompare.right();

            mDistanceVerticalEdges = mVerticalEdgeToRightOfInactiveRect;

            xSnapGapAdjustment = 0.0;

            mLeftInRange = false;

        }

        //if the right edge of moving rect to right of inactive rect is at the same distance as the right edge of moving rect to the left of inactive rect

        else if (mVerticalEdgeToRightOfInactiveRect == mVerticalEdgeToLeftOfInactiveRect) {

            //if inactive rect lies towards the right of container rect, then the right edge is priortized as the selected edge for outside snapping

            if (differenceContainerRightEdgeToInactiveRectRightEdge < differenceContainerLeftEdgeToInactiveRectLeftEdge ) { 

                mMinDistancePosition = mInactiveRectToCompare.right();

                mDistanceVerticalEdges = mVerticalEdgeToRightOfInactiveRect;

                xSnapGapAdjustment = 0.0;

                mLeftInRange = false;

            }

            //else left of the inactive rect lies more close to the left or middle of the container rect, and hence prioritize it

            else {

                mMinDistancePosition = mInactiveRectToCompare.left();

                mDistanceVerticalEdges = mVerticalEdgeToLeftOfInactiveRect;

                xSnapGapAdjustment = mSnapGap;

                mRightInRange = false;

            }

        }

        //else right edge of moving rect to the left of the inactive rect is closer than the right edge of moving rect to the right of the incoming rect

        else{

            mMinDistancePosition = mInactiveRectToCompare.left();

            mDistanceVerticalEdges = mVerticalEdgeToLeftOfInactiveRect;

            xSnapGapAdjustment = mSnapGap;

            mRightInRange = false;

        }

    }

    //Check if this inactive rect is better fit than the previous selected rect 

    checkInactiveRectBetterFitForHorizontalSnapping(differenceContainerRightEdgeToInactiveRectRightEdge,

                                                    differenceContainerLeftEdgeToInactiveRectLeftEdge);

    if (mIsBetterFitHorizontalSnap) {

        qreal proposedLeftOfActiveRect = mMinDistancePosition - mActiveRectWidth - xSnapGapAdjustment;

        if (qBound(mContainerRect.left(), proposedLeftOfActiveRect, mContainerRect.right())

            == proposedLeftOfActiveRect) {

            mHorizontalSnapFound = true;

            mHorizontalSnapPosition = proposedLeftOfActiveRect;

            mMinVerticalEdgesDistance = mDistanceVerticalEdges;

            mVerticalDistanceFromSelectedRect = mVerticalDistance;

            //Save the new distance of the Chosen Rectangle's right edge from Container's right edge

            mContainerVerticalEdgeDistance = differenceContainerRightEdgeToInactiveRectRightEdge;

            createVerticalLine();

        }

    }

}

/*!

    Create the vertical line for horizontal snap guidance

*/

void HsSnapToLines::createVerticalLine()

{

    if (mRectLieAbove) {

        mVerticalLine.setP1(QPointF(mMinDistancePosition, mInactiveRectToCompare.top()));

        mVerticalLine.setP2(QPointF(mMinDistancePosition, mMovingRect.bottom()));

    }

    else {

        mVerticalLine.setP1(QPointF(mMinDistancePosition, mInactiveRectToCompare.bottom()));

        mVerticalLine.setP2(QPointF(mMinDistancePosition, mMovingRect.top()));

    }

}

/*!

    Check if the inactive rect being compared with moving rect lies on left or right of moving rect.

*/

void HsSnapToLines::checkInactiveRectLieLeftOrRightOfMovingRect()

{

    mRectLieLeft = false;

    mHorizontalDistance = 0.0;

    //Inactive Rect lies left of the Moving Rect

    if (mInactiveRectToCompare.left() < mMovingRect.left()) {

        mRectLieLeft = true;

        if (mInactiveRectToCompare.right() <= mMovingRect.left()) {

            mHorizontalDistance = mMovingRect.left() - mInactiveRectToCompare.right();

        }

        else {

            mHorizontalDistance = mMovingRect.left() - mInactiveRectToCompare.left();

        }

    }

    //Inactive Rect lies right of the Moving Rect

    else {

        mRectLieLeft = false;

        if (mMovingRect.right() <= mInactiveRectToCompare.left()) {

            mHorizontalDistance = mInactiveRectToCompare.left() - mMovingRect.right();

        }

        else {

            mHorizontalDistance = mInactiveRectToCompare.right() - mMovingRect.right();

        }

    }

}