/****************************************************************************

**

** Copyright (C) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (developer.feedback@nokia.com)

**

** This file is part of the HbCore module of the UI Extensions for Mobile.

**

** GNU Lesser General Public License Usage

** This file may be used under the terms of the GNU Lesser General Public

** License version 2.1 as published by the Free Software Foundation and

** appearing in the file LICENSE.LGPL included in the packaging of this file.

** Please review the following information to ensure the GNU Lesser General

** Public License version 2.1 requirements will be met:

** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at developer.feedback@nokia.com.

**

****************************************************************************/

#include "hbanchorlayoutengine_p.h"

//Uncomment next define in order to get more debug prints.

//Similar define exists also in the layout side.

//#define HBANCHORLAYOUT_DEBUG

#ifdef HBANCHORLAYOUT_DEBUG

#include <QtDebug>

#endif

#define EPSILON 0.01f

#define MAX_SIZE 0xffffff

static inline bool myFuzzyCompare(double p1, double p2)

{

    return (qAbs(p1 - p2) <= 0.0001);

}

static inline bool myFuzzyCompare(float p1, float p2)

{

    return (qAbs(p1 - p2) <= EPSILON);

}

static inline qreal minSlope(const Variable &var, qreal coef )

{

    return var.sizeProp.pref + ( var.sizeProp.min - var.sizeProp.pref ) * coef;

}

static inline qreal maxSlope(const Variable &var, qreal coef )

{

    return var.sizeProp.pref + ( var.sizeProp.max - var.sizeProp.pref ) * coef;

}

static inline bool differentSignOrZero( qreal val1, qreal val2 )

{

    return ( ( val1 < EPSILON ) && ( val2 > -EPSILON ) ) || ( ( val1 > -EPSILON ) && ( val2 < EPSILON ) );

}

AnchorLayoutEngine::AnchorLayoutEngine()

{

}

AnchorLayoutEngine::~AnchorLayoutEngine()

{

}

AnchorLayoutEngine *AnchorLayoutEngine::instance()

{

    static AnchorLayoutEngine theAnchorLayoutSimplyfier;

    return &theAnchorLayoutSimplyfier;

}

bool AnchorLayoutEngine::processItems( QList<GraphEdge*> *edges, QList<GraphVertex*> *vertices, VariableSet *vs, QList<Expression*> *el )

{

    bool result = true;

    int oldEdgesNumber;

    int oldVerticesNumber;

    bool inLoop = true;

    enum {

        COMMON_ACTIONS,

        SPLIT_1,

        SPLIT_2,

        ERROR,

        DONE

    } state;

    state = COMMON_ACTIONS;

    while( inLoop ) {

        switch( state ) {

            case COMMON_ACTIONS:

                if( !findBranches( edges, vertices ) ) {

                    state = ERROR;

                    break;

                }

                oldEdgesNumber = edges->size();

                oldVerticesNumber = vertices->size();

                if( ! findSerialChains( edges, vertices, el ) ) {

                    state = ERROR;

                    break;

                }

                if( ! findParallelChains( edges, vertices, vs, el ) ) {

                    state = ERROR;

                    break;

                }

                if( ready( vertices ) ) {

                    state = DONE;

                    break;

                }

                if( ( oldEdgesNumber == edges->size() ) && ( oldVerticesNumber == vertices->size() ) ) {

                    state = SPLIT_1;

                    break;

                }

                break;

            case SPLIT_1:

                if( splitVertices( edges, vertices, 1 ) ) {

                    state = COMMON_ACTIONS;

                    break;

                }

                state = SPLIT_2;

                break;

            case SPLIT_2:

                if( splitVertices( edges, vertices, 2 ) ) {

                    state = COMMON_ACTIONS;

                    break;

                }

                state = ERROR;

                break;

            case ERROR:

                result = false;

                // cleanup;

            case DONE:

                inLoop = false;

                break;

            default:

                state = ERROR;

                break;

        }

    }

    return result;

}

GraphVertex *AnchorLayoutEngine::nextVertex( GraphVertex *currentVertex, GraphEdge *currentEdge, int *sign )

{

    if( currentEdge->startVertex == currentVertex ) {

        *sign = 1;

        return currentEdge->endVertex;

    }

    *sign = -1;

    return currentEdge->startVertex;

}

GraphEdge *AnchorLayoutEngine::nextEdge( GraphVertex *currentVertex, GraphEdge *currentEdge )

{

    if( currentVertex->edges.at(0) == currentEdge ) {

        return currentVertex->edges.at(1);

    }

    return currentVertex->edges.at(0);

}

bool AnchorLayoutEngine::findSerialChains( QList<GraphEdge*> *edges, QList<GraphVertex*> *vertices, QList<Expression*> *el )

{

    bool result = true;

    GraphEdge *newEdge;

    GraphEdge *currentEdge;

    GraphVertex *currentVertex;

    GraphVertex *initialVertex;

    GraphVertex *oldEndVertex, *oldStartVertex;

    GraphEdge *oldEndEdge, *oldStartEdge;

    GraphVertex *vertexToDelete;

    GraphEdge *edgeToDelete;

    GraphEdge *rightEdge, *leftEdge;

    int sign;

    Expression *expr;

    for( int i = 0; i < vertices->size(); i++ ) {

        initialVertex =  vertices->at(i);

        if( ( initialVertex->edges.size() == 2 ) && ( ! initialVertex->special ) ) {

            expr = new Expression();

            rightEdge = initialVertex->edges.at(1);

            leftEdge = initialVertex->edges.at(0);

            // left side

            currentEdge = rightEdge;

            currentVertex = initialVertex;

            edgeToDelete = 0;

            vertexToDelete = 0;

            do {

                vertices->removeOne( currentVertex );

                currentEdge = nextEdge( currentVertex, currentEdge );

                currentVertex = nextVertex( currentVertex, currentEdge, &sign );

                if( sign > 0 ) {

                    expr->minusExpression( currentEdge->expr );

                } else {

                    expr->plusExpression( currentEdge->expr );

                }

                edges->removeOne( currentEdge );

                delete vertexToDelete;

                if( edgeToDelete != leftEdge ) {

                    delete edgeToDelete;

                }

                vertexToDelete = currentVertex;

                edgeToDelete = currentEdge;

#ifdef HBANCHORLAYOUT_DEBUG

                qDebug() << "Adding one more left edge";

#endif //HBANCHORLAYOUT_DEBUG

            } while( ( currentVertex != initialVertex ) && ( currentVertex->edges.size() == 2 ) && ( ! currentVertex->special ) );

            if( currentVertex == initialVertex ) {

                el->append( expr );

                edges->removeOne( currentVertex->edges.at(0) );

                vertices->removeOne( currentVertex );

                qDeleteAll( initialVertex->edges );

                delete currentVertex;

                i--;

                continue;

            }

            oldStartVertex = currentVertex;

            oldStartEdge = currentEdge;

            // right side

            currentEdge = leftEdge;

            currentVertex = initialVertex;

            edgeToDelete = 0;

            vertexToDelete = 0;

            do {

                vertices->removeOne( currentVertex );

                currentEdge = nextEdge( currentVertex, currentEdge );

                currentVertex = nextVertex( currentVertex, currentEdge, &sign );

                edges->removeOne( currentEdge );

                if( sign < 0 ) {

                    expr->minusExpression( currentEdge->expr );

                } else {

                    expr->plusExpression( currentEdge->expr );

                }

                delete vertexToDelete;

                if( edgeToDelete != rightEdge ) {

                    delete edgeToDelete;

                }

                vertexToDelete = currentVertex;

                edgeToDelete = currentEdge;

#ifdef HBANCHORLAYOUT_DEBUG

                qDebug() << "Adding one more right edge";

#endif //HBANCHORLAYOUT_DEBUG

            } while( ( currentVertex->edges.size() == 2 ) && ( ! currentVertex->special ) );

            oldEndVertex = currentVertex;

            oldEndEdge = currentEdge;

            if( oldStartVertex == oldEndVertex ) {

                el->append( expr );

                currentVertex->edges.removeOne( currentEdge );

                currentVertex->edges.removeOne( oldStartEdge );

                edges->removeOne( currentEdge );

                edges->removeOne( oldStartEdge );

                if( ( rightEdge != currentEdge ) && ( leftEdge != currentEdge ) ) {

                    delete currentEdge;

                }

                if( ( rightEdge != oldStartEdge ) && ( leftEdge != oldStartEdge ) ) {

                    delete oldStartEdge;

                }

                delete rightEdge;

                delete leftEdge;

                if( currentVertex->edges.size() == 0 ) {

                    vertices->removeOne( currentVertex );

                    if( !currentVertex->special ) {

                        delete currentVertex;

                    }

                    i--;

                }

                continue;

            }

            newEdge = new GraphEdge( false );

            newEdge->startVertex = oldStartVertex;

            newEdge->endVertex = oldEndVertex;

            oldStartVertex->edges.removeOne( oldStartEdge );

            oldEndVertex->edges.removeOne( oldEndEdge );

            oldStartVertex->edges.append( newEdge );

            oldEndVertex->edges.append( newEdge );

            newEdge->expr = expr;

            edges->append( newEdge );

            i--;

            if( ( rightEdge != oldStartEdge ) && ( leftEdge != oldStartEdge ) ) {

                delete oldStartEdge;

            }

            if( ( rightEdge != oldEndEdge ) && ( leftEdge != oldEndEdge ) ) {

                delete oldEndEdge;

            }

            delete rightEdge;

            delete leftEdge;

            delete initialVertex;

#ifdef HBANCHORLAYOUT_DEBUG

            qDebug()<< "### Serial New Edge: start= " << newEdge->startVertex->itemSide << ", " << (int)(newEdge->startVertex->itemRef) << ", " << newEdge->startVertex->special;

            qDebug()<< "### Serial New Edge: end= " << newEdge->endVertex->itemSide << ", " << (int)(newEdge->endVertex->itemRef) << ", " << newEdge->endVertex->special;

            qDebug() << "### Serial New Edge size prop: min" << expr->minValue() << " pref:" << expr->prefValue() <<

                    " max:" << expr->maxValue() << " flags" << expr->flags();

#endif //HBANCHORLAYOUT_DEBUG

        }

    }

    return result;

}

bool AnchorLayoutEngine::findParallelChains( QList<GraphEdge*> *edges, QList<GraphVertex*> *vertices, VariableSet *vs, QList<Expression*> *el )

{

    Q_UNUSED( vertices );

    bool result = true;

    GraphEdge *newEdge = 0;

    GraphVertex *oldStart = 0;

    GraphVertex *oldEnd = 0;

    GraphEdge *current;

    GraphEdge *compared;

    bool found = false;

    int sign;

    int numberOfParallelEdges;

    QList<qreal> expandingPrefValues;

    Expression *expr;

    SizeProperty *newEdgeSizeProp(0);

    SimpleExpression se;

    uint comparedEdgeFlags;

    for( int i = 0; ( i < edges->size() ) && result; i++ ) {

        current = edges->at(i);

        numberOfParallelEdges = 1;

        expandingPrefValues.clear();

        for( int j = i + 1; j <  edges->size(); j++ ) {

            compared = edges->at(j);

            found = false;

            if( ( current->startVertex == compared->startVertex ) && ( current->endVertex == compared->endVertex ) ) {

                found = true;

                sign = 1;

            } else if( ( current->startVertex == compared->endVertex ) && ( current->endVertex == compared->startVertex ) ) {

                found = true;

                sign = -1;

            }

            if( found ) {

                numberOfParallelEdges++;

                j--;

                if( numberOfParallelEdges == 2 ) {

                    newEdge = new GraphEdge();

                    oldStart = current->startVertex;

                    oldEnd = current->endVertex;

                    se.mVar = vs->createVariable( 0 );

                    se.mCoef = 1;

                    newEdgeSizeProp = &( se.mVar->sizeProp );

                    newEdgeSizeProp->min = current->expr->minValue();

                    newEdgeSizeProp->max = current->expr->maxValue();

                    newEdgeSizeProp->flags = current->expr->flags();

                    if( newEdgeSizeProp->flags & SizeProperty::FlagExpanding ) {

                        expandingPrefValues.append( current->expr->prefValue() );

                        newEdgeSizeProp->pref = 0;

                    } else {

                        newEdgeSizeProp->pref = current->expr->prefValue();

                    }

                    oldStart->edges.removeOne( current );

                    oldEnd->edges.removeOne( current );

                    oldStart->edges.append( newEdge );

                    oldEnd->edges.append( newEdge );

                    newEdge->startVertex = oldStart;

                    newEdge->endVertex = oldEnd;

                    edges->removeOne( current );

                    el->append( current->expr->toEquation( se ) );

                }

                oldStart->edges.removeOne( compared );

                oldEnd->edges.removeOne( compared );

                edges->removeOne( compared );

                comparedEdgeFlags = compared->expr->flags();

                if( ~newEdgeSizeProp->flags & SizeProperty::FlagFixed ) {

                    if( comparedEdgeFlags & SizeProperty::FlagFixed ) {

                        newEdgeSizeProp->pref = sign * compared->expr->prefValue();

                        newEdgeSizeProp->flags |= SizeProperty::FlagFixed;

                    } else {

                        if( sign * compared->expr->minValue() < sign * compared->expr->maxValue()  ) {

                            newEdgeSizeProp->min = qMax( newEdgeSizeProp->min, sign * compared->expr->minValue() );

                            newEdgeSizeProp->max = qMin( newEdgeSizeProp->max, sign * compared->expr->maxValue() );

                        } else {

                            newEdgeSizeProp->min = qMax( newEdgeSizeProp->min, sign * compared->expr->maxValue() );

                            newEdgeSizeProp->max = qMin( newEdgeSizeProp->max, sign * compared->expr->minValue() );

                        }

                        if( comparedEdgeFlags & SizeProperty::FlagExpanding ) {

                            expandingPrefValues.append( sign * compared->expr->prefValue() );

                        } else {

                            newEdgeSizeProp->pref += sign * compared->expr->prefValue();

                        }

                    }

                    if( ~comparedEdgeFlags & SizeProperty::FlagExpanding ) {

                        newEdgeSizeProp->flags &= ~SizeProperty::FlagExpanding;

                    }

                    expr = new Expression();

                    if( sign < 0 ) {

                        expr->minusSimpleExpression( se );

                    } else {

                        expr->plusSimpleExpression( se );

                    }

                    expr->minusExpression( compared->expr );

                    el->append( expr );