#include "hbpangesture.h"

#include "hbtapgesture.h"

#include "hbevent.h"

#include "hbpopup.h"

#include "hbnamespace_p.h"

#include "hbmainwindow.h"

#include <QHash>

#include <QGraphicsScene>

typedef QHash<HbMainWindow*,HbSelectionControl*> HbSelectionControlHash;

Q_GLOBAL_STATIC(HbSelectionControlHash, globalSelectionControlHash)

    HbSelectionControlPrivate();

    void tapGestureFinished (const QPointF& point);

    void panGestureStarted (HbPanGesture *gesture);

    void panGestureUpdated (HbPanGesture *gesture);

    void panGestureFinished (HbPanGesture *gesture);

    void show();

    void _q_aboutToChangeView();

    QGraphicsItem *mTopLevelAncestor;

HbSelectionControlPrivate::HbSelectionControlPrivate():

    mEdit(0),

    mTopLevelAncestor(0),

    mPanInProgress(false)

{    

    q->setVisible(false);

    q->setFlag(QGraphicsItem::ItemIsFocusable,false);

    q->setFlag(QGraphicsItem::ItemIsPanel,true);

    q->setActive(false);

        mSelectionStartHandle = q->style()->createPrimitive(HbStyle::P_SelectionControl_selectionstart, q);

        mSelectionStartHandle->setFlag(QGraphicsItem::ItemIsPanel);

        mSelectionStartHandle->setFlag(QGraphicsItem::ItemIsFocusable,false);

        mSelectionStartHandle->setActive(false);

        mSelectionEndHandle = q->style()->createPrimitive(HbStyle::P_SelectionControl_selectionend, q);

        mSelectionEndHandle->setFlag(QGraphicsItem::ItemIsPanel);

        mSelectionEndHandle->setFlag(QGraphicsItem::ItemIsFocusable,false);

        mSelectionEndHandle->setActive(false);

        mSelectionStartTouchArea->setFlag(QGraphicsItem::ItemIsPanel);

        mSelectionStartTouchArea->setFlag(QGraphicsItem::ItemIsFocusable,false);

        mSelectionStartTouchArea->setActive(false);

        mSelectionStartTouchArea->grabGesture(Qt::TapGesture);

        mSelectionStartTouchArea->grabGesture(Qt::PanGesture);

        mSelectionEndTouchArea->setFlag(QGraphicsItem::ItemIsPanel);

        mSelectionEndTouchArea->setFlag(QGraphicsItem::ItemIsFocusable,false);

        mSelectionEndTouchArea->setActive(false);

        mSelectionEndTouchArea->grabGesture(Qt::TapGesture);

        mSelectionEndTouchArea->grabGesture(Qt::PanGesture);

   Reparents item to q if item's bounding rect intersects mEdit's viewPort rectangle or otherwise to

    QRectF scrollAreaRect = HbAbstractEditPrivate::d_ptr(mEdit)->scrollArea->geometry();

    if (rect.intersects(scrollAreaRect)) {

    Q_Q(HbSelectionControl);

        // If the item is parented to other then q we have to

        // turn off the QGraphicsItem::ItemIsPanel flag because

        // otherwise the new parent loses its activeness.

        bool enablePanel = (newParent == q);

        item->setFlag(QGraphicsItem::ItemIsPanel,enablePanel);

void HbSelectionControlPrivate::tapGestureFinished(const QPointF &pos)

{

    if (mEdit->contextMenuFlags().testFlag(Hb::ShowTextContextMenuOnSelectionClicked)) {

        mEdit->showContextMenu(pos);

    }

}

void HbSelectionControlPrivate::panGestureStarted(HbPanGesture *gesture)

{

    Q_Q(HbSelectionControl);

    QPointF point = q->mapFromScene(gesture->sceneStartPos());

    mPressed = HbSelectionControl::DummyHandle;

    // Find out which handle is being moved

    if (mSelectionStartTouchArea->contains(q->mapToItem(mSelectionStartTouchArea, point))) {

        mPressed = HbSelectionControl::SelectionStartHandle;

        mMouseOffset = mSelectionStartHandle->pos() - point;

    }

    if (mSelectionEndTouchArea->contains(q->mapToItem(mSelectionEndTouchArea, point))) {

        bool useArea = true;

        if(mPressed != HbSelectionControl::DummyHandle) {

            // The press point was inside in both of the touch areas

            // choose the touch area whose center is closer to the press point

            QRectF rect = mSelectionStartTouchArea->boundingRect();

            rect.moveTopLeft(mSelectionStartTouchArea->pos());

            QLineF  lineEventPosSelStartCenter(point,rect.center());

            rect = mSelectionEndTouchArea->boundingRect();

            rect.moveTopLeft(mSelectionEndTouchArea->pos());

            QLineF  lineEventPosSelEndCenter(point,rect.center());

            if (lineEventPosSelStartCenter.length() < lineEventPosSelEndCenter.length()) {

                useArea = false;

            }

        }

        if (useArea) {

            mPressed = HbSelectionControl::SelectionEndHandle;

            mMouseOffset = mSelectionEndHandle->pos() - point;

        }

    }

    if (mPressed == HbSelectionControl::DummyHandle) {

        // Hit is outside touch areas, ignore

        return;

    }

    // Position cursor at the pressed selection handle

    QTextCursor cursor = mEdit->textCursor();

    int selStartPos = qMin(mEdit->textCursor().anchor(),mEdit->textCursor().position());

    int selEndPos = qMax(mEdit->textCursor().anchor(),mEdit->textCursor().position());

    if (mPressed == HbSelectionControl::SelectionStartHandle) {

        cursor.setPosition(selEndPos);

        cursor.setPosition(selStartPos, QTextCursor::KeepAnchor);

    } else {

        cursor.setPosition(selStartPos);

        cursor.setPosition(selEndPos, QTextCursor::KeepAnchor);

    }

    mEdit->setTextCursor(cursor);

}

void HbSelectionControlPrivate::panGestureFinished(HbPanGesture *gesture)

{

    Q_Q(HbSelectionControl);

    Q_UNUSED(gesture)

    if (mWordSnapTimer.isActive()) {

        // Snap selection to word beginning or end

        QTextCursor cursor = mEdit->textCursor();

        int curPos = mEdit->textCursor().position();

        int anchPos = mEdit->textCursor().anchor();

        cursor.select(QTextCursor::WordUnderCursor);

        // Snap direction depends on cursor position

        curPos = ((curPos > anchPos)?cursor.position():cursor.anchor());

        cursor.setPosition(anchPos);

        cursor.setPosition(curPos, QTextCursor::KeepAnchor);

        mEdit->setTextCursor(cursor);

    }

    mPressed = HbSelectionControl::DummyHandle;

    q->updatePrimitives();

}

void HbSelectionControlPrivate::panGestureUpdated(HbPanGesture *gesture)

{

    Q_Q(HbSelectionControl);

    QPointF editPos = mEdit->mapFromScene(gesture->sceneStartPos() + gesture->sceneOffset());

    QRectF handleRect = mSelectionStartHandle->boundingRect();

    handleRect.moveTopLeft(editPos + mMouseOffset);

    QPointF hitTestPos = handleRect.center();

    if (mPressed == HbSelectionControl::SelectionStartHandle) {

        hitTestPos.setY(handleRect.bottom()+1);

    } else {

        hitTestPos.setY(handleRect.top()-1);

    }

    QTextCursor cursor = mEdit->textCursor();

    // Hit test for the center of current selection touch area

    int hitPos = HbAbstractEditPrivate::d_ptr(mEdit)->hitTest(hitTestPos,Qt::FuzzyHit);

    if (hitPos == -1 || hitPos == cursor.anchor()) {

        return;

    }

    bool handlesMoved(false);

    if (hitPos != cursor.position()) {

        handlesMoved = true;

    }

    cursor.setPosition(hitPos, QTextCursor::KeepAnchor);

    if (handlesMoved) {

        if (mEdit) {

            HbWidgetFeedback::triggered(mEdit, Hb::InstantDraggedOver);

        }

        // Restart timer every time when a selection handle moved

        mWordSnapTimer.start(SNAP_DELAY, q);

        mEdit->setTextCursor(cursor);

    }

    // Ensure that the hitPos is visible

    HbAbstractEditPrivate::d_ptr(mEdit)->ensurePositionVisible(hitPos);

    q->updatePrimitives();

}

void HbSelectionControlPrivate::show() {

    Q_Q(HbSelectionControl);

    // Set the z-value of the selection control above its top-level ancestor

    if (mTopLevelAncestor) {

        qreal zValue = mTopLevelAncestor->zValue() + HbPrivate::SelectionControlHandlesValueUnit;

        q->setZValue(zValue);

    }

    if (q->scene() != mEdit->scene() && mEdit->scene()) {

        mEdit->scene()->addItem(q);

    }

    q->show();    

    q->updatePrimitives();

}

void HbSelectionControlPrivate::_q_aboutToChangeView()

{

    Q_Q(HbSelectionControl);

    if (mEdit && q->isVisible()) {

        mEdit->deselect();

    }

}

HbSelectionControl::HbSelectionControl() : HbWidget(*new HbSelectionControlPrivate(),0)

HbSelectionControl* HbSelectionControl::attachEditor(HbAbstractEdit *edit)

{

    if(!edit || !edit->mainWindow()) {

        qWarning("HbSelectionControl: attempting to attach to null editor pointer!");

    }

    HbSelectionControl *control = globalSelectionControlHash()->value(edit->mainWindow());

    if (!control) {

        control = new HbSelectionControl();

        globalSelectionControlHash()->insert(edit->mainWindow(),control);

        QObject::connect(edit->mainWindow(), SIGNAL(aboutToChangeView(HbView *, HbView *)), control, SLOT(_q_aboutToChangeView()));

    }

    HbSelectionControlPrivate *d = control->d_func();

    if (edit != d->mEdit) {

        control->detachEditor();

        d->mEdit = edit;        

        QObject::connect(d->mEdit, SIGNAL(cursorPositionChanged(int, int)), control, SLOT(updatePrimitives()));

        QObject::connect(d->mEdit, SIGNAL(contentsChanged()), control, SLOT(updatePrimitives()));

        // find first top-level ancestor of d->mEdit

        for(d->mTopLevelAncestor = d->mEdit;

            d->mTopLevelAncestor->parentItem();

            d->mTopLevelAncestor = d->mTopLevelAncestor->parentItem()){};

    }

    return control;

}

void HbSelectionControl::detachEditor()

    if (d->mEdit) {

        hideHandles();

        d->reparentHandles(this);

        d->mEdit->disconnect(this);

        d->mEdit->d_func()->selectionControl = 0;        

        d->mEdit->deselect();

        d->mEdit = 0;

        d->mTopLevelAncestor = 0;