/*

* 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),

    mHorizontalSnapPosition(0.0), mVerticalSnapPosition(0.0),

    mHorizontalSnapFound(false),

    mVerticalSnapFound(false),

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

    mMinVerticalEdgesDistance(0.0), mVerticalDistance(0.0),

    mVerticalDistanceFromSelectedRect(0.0), mContainerVerticalEdgeDistance(0.0),

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

    mMinHorizontalEdgesDistance(0.0), mHorizontalDistance(0.0),

    mHorizontalDistanceFromSelectedRect(0.0), mContainerHorizontalEdgeDistance(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[SNAPENABLED].toBool();

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

    mSnapForce = configuration[SNAPFORCE].toDouble(&canConvert);

    mSnapGap = configuration[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)

{

    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;

        checkForCenterSnapping();

        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.

                //TODO: Move the above check to another function...

                // X - Direction Snapping

                compareLeftSideOfMovingRectForSnapping();

                compareRightSideOfMovingRectForSnapping();

                // Y - 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 center of moving rect is in the snap force in the middle of continer rect.

*/

void HsSnapToLines::checkForCenterSnapping()

{

    QPointF centerOfContainerRect = mContainerRect.center();

    QRectF verticalSnapField = QRectF(QPointF(centerOfContainerRect.x() - (mSnapForce/2), mContainerRect.top()),

         QPointF(centerOfContainerRect.x() + (mSnapForce/2), mContainerRect.bottom()));

    //Check that the widget lies in the container rect, if the snapping position is proposed... is not required,

    //unless some widget is bigger than the page width

    QPointF centerOfMovingRect = mMovingRect.center();

    if (verticalSnapField.contains(centerOfMovingRect)) {

        mHorizontalSnapFound = true;

        mHorizontalSnapPosition = centerOfContainerRect.x() - mActiveRectWidth/2;

        mMinVerticalEdgesDistance = qAbs(centerOfContainerRect.x() - centerOfMovingRect.x());

        //save the points for the Vertical line

        mVerticalLine.setP1(QPointF(centerOfContainerRect.x(), mMovingRect.top()));

        mVerticalLine.setP2(QPointF(centerOfContainerRect.x(), mMovingRect.bottom()));

    }

}

/*!

    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 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();

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

    qreal leftToLeftOfInactiveRect = qAbs(mInactiveRectToCompare.left() - mMovingRect.left());

    qreal leftToRightOfInactiveRect = qAbs(mInactiveRectToCompare.right() - mMovingRect.left());

    mLeftInRange = false;

    mRightInRange = false;

    if (leftToLeftOfInactiveRect <= mMinVerticalEdgesDistance) {

        if (mRectLieAbove && mInactiveSnapRectToCompare.isLeftSnapableForBelow

         || !mRectLieAbove && mInactiveSnapRectToCompare.isLeftSnapableForAbove) { 

            mLeftInRange = true;

        }

    }

    if (leftToRightOfInactiveRect <= mMinVerticalEdgesDistance) {

        if (mRectLieAbove && mInactiveSnapRectToCompare.isRightSnapableForBelow

         || !mRectLieAbove && mInactiveSnapRectToCompare.isRightSnapableForAbove) {

            mRightInRange = true;

        }

    }

    //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 minDistancePosition = 0.0;

    qreal distanceVerticalEdges = 0.0;

    qreal xSnapGapAdjustment = 0.0;

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

    if ((mLeftInRange && !mRightInRange)

        || !mLeftInRange && mRightInRange) {

        if (mLeftInRange) {

            minDistancePosition = mInactiveRectToCompare.left();

            distanceVerticalEdges = leftToLeftOfInactiveRect;

            xSnapGapAdjustment = 0.0;

        }

        else {

            minDistancePosition = mInactiveRectToCompare.right();

            distanceVerticalEdges = leftToRightOfInactiveRect;

            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 (leftToLeftOfInactiveRect < leftToRightOfInactiveRect) {

            minDistancePosition = mInactiveRectToCompare.left();

            distanceVerticalEdges = leftToLeftOfInactiveRect;

            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 (leftToLeftOfInactiveRect == leftToRightOfInactiveRect) {

            //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) { 

                minDistancePosition = mInactiveRectToCompare.left();

                distanceVerticalEdges = leftToLeftOfInactiveRect;

                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 {

                minDistancePosition = mInactiveRectToCompare.right();

                distanceVerticalEdges = leftToRightOfInactiveRect;

                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{

            minDistancePosition = mInactiveRectToCompare.right();

            distanceVerticalEdges = leftToRightOfInactiveRect;

            xSnapGapAdjustment = mSnapGap;

            mLeftInRange = false;

        }

    }

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

    bool horizontalSnappingBetterFit = false;

    if (mLeftInRange || mRightInRange) {

        if (distanceVerticalEdges < mMinVerticalEdgesDistance) {

            horizontalSnappingBetterFit = true;

        }

        else if (distanceVerticalEdges == mMinVerticalEdgesDistance) { //the distance in the vertical edges is same as from the selected rectangle

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

            checkInactiveRectPositionToVerticalLine();

            //if horizontal snap position was previously found the rect's edges are 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 inactive widgets.

            else {

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

                if (mVerticalDistance < mVerticalDistanceFromSelectedRect) {

                    horizontalSnappingBetterFit = true;

                }

                else if (mVerticalDistance == mVerticalDistanceFromSelectedRect) {

                    //Prioritize next if this Inactive rect is closer to the left edge of the container rect, then the previously selected rect

                    if (differenceContainerLeftEdgeToInactiveRectLeftEdge < mContainerVerticalEdgeDistance) {

                        horizontalSnappingBetterFit = true;

                    }

                    //Prioritize next if the Inactive widget's left edge lies near to left edge of the container rect

                    else if (differenceContainerLeftEdgeToInactiveRectLeftEdge < differenceContainerRightEdgeToInactiveRectRightEdge) {

                        horizontalSnappingBetterFit = true;

                    }

                    else {

                        //This else will happen if this rectangle being compared is exactly the same as the selected rectangle for snapping.

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

                    }

                }

            }

        }

    }

    if (horizontalSnappingBetterFit) {

        qreal proposedRightOfActiveRect = minDistancePosition + xSnapGapAdjustment + mActiveRectWidth;

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

            == proposedRightOfActiveRect) {

            mHorizontalSnapFound = true;

            mHorizontalSnapPosition = minDistancePosition + xSnapGapAdjustment;

            mMinVerticalEdgesDistance = distanceVerticalEdges;

            mVerticalDistanceFromSelectedRect = mVerticalDistance;

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

            mContainerVerticalEdgeDistance = differenceContainerLeftEdgeToInactiveRectLeftEdge;

            if (mRectLieAbove) {

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

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

            }

            else {

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

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

            }

        }

    }

}

/*!

    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();

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

    qreal rightToLeftOfInactiveRect = qAbs(mInactiveRectToCompare.left() - mMovingRect.right());

    qreal rightToRightOfInactiveRect = qAbs(mInactiveRectToCompare.right() - mMovingRect.right());

    mLeftInRange = false;

    mRightInRange = false;

    if (rightToLeftOfInactiveRect <= mMinVerticalEdgesDistance) {

        if (mRectLieAbove && mInactiveSnapRectToCompare.isLeftSnapableForBelow

         || !mRectLieAbove && mInactiveSnapRectToCompare.isLeftSnapableForAbove) {

            mLeftInRange = true;

        }

    }

    if (rightToRightOfInactiveRect <= mMinVerticalEdgesDistance) {

        if (mRectLieAbove && mInactiveSnapRectToCompare.isRightSnapableForBelow

         || !mRectLieAbove && mInactiveSnapRectToCompare.isRightSnapableForAbove) {

            mRightInRange = true;

        }

    }

    //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 minDistancePosition = 0.0;

    qreal distanceVerticalEdges = 0.0;

    qreal xSnapGapAdjustment = 0.0;

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

    if ((mLeftInRange && !mRightInRange)

        || !mLeftInRange && mRightInRange) {

        if (mLeftInRange) {

            minDistancePosition = mInactiveRectToCompare.left();

            distanceVerticalEdges = rightToLeftOfInactiveRect;

            xSnapGapAdjustment = mSnapGap;

        }

        else {

            minDistancePosition = mInactiveRectToCompare.right();

            distanceVerticalEdges = rightToRightOfInactiveRect;

            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 (rightToRightOfInactiveRect < rightToLeftOfInactiveRect) {

            minDistancePosition = mInactiveRectToCompare.right();

            distanceVerticalEdges = rightToRightOfInactiveRect;

            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 (rightToRightOfInactiveRect == rightToLeftOfInactiveRect) {

            //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 ) { 

                minDistancePosition = mInactiveRectToCompare.right();

                distanceVerticalEdges = rightToRightOfInactiveRect;

                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 {

                minDistancePosition = mInactiveRectToCompare.left();

                distanceVerticalEdges = rightToLeftOfInactiveRect;

                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{

            minDistancePosition = mInactiveRectToCompare.left();

            distanceVerticalEdges = rightToLeftOfInactiveRect;

            xSnapGapAdjustment = mSnapGap;

            mRightInRange = false;

        }

    }

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

    bool horizontalSnappingBetterFit = false;

    if (mLeftInRange || mRightInRange) {

        if (distanceVerticalEdges < mMinVerticalEdgesDistance) {

            horizontalSnappingBetterFit = true;

        }

        else if (distanceVerticalEdges == mMinVerticalEdgesDistance) { //the distance in the vertical edge is same as from the selected rectangle

            //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 inactive widgets.

            else {

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

                if (mVerticalDistance < mVerticalDistanceFromSelectedRect) {

                    horizontalSnappingBetterFit = true;

                }

                else if (mVerticalDistance == mVerticalDistanceFromSelectedRect) {

                    //Prioritize next if this Inactive rect is closer to the right edge of the container rect, then the previously selected rect

                    if (differenceContainerRightEdgeToInactiveRectRightEdge < mContainerVerticalEdgeDistance) {

                        horizontalSnappingBetterFit = true;

                    }

                    //Prioritize next if the Inactive rect's right edge lies near to right edge of the container rect

                    else if (differenceContainerRightEdgeToInactiveRectRightEdge < differenceContainerLeftEdgeToInactiveRectLeftEdge) {

                        horizontalSnappingBetterFit = 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.

                    }

                }