#include "hblineedit.h"

#include "hbmagnifier_p.h"

#include "hbdeviceprofile.h"

#include "hbiconitem.h"

#include <QTextBlock>

#include <QGraphicsWidget>

#define HB_DEBUG_PAINT_INFO 0

    static const int MAGNIFIER_OPEN_DELAY = 200;

    static const qreal MAGNIFIER_SCALE_FACTOR = 1.5;

class MyEditor: public HbAbstractEdit

{

public:

    using HbAbstractEdit::drawContents;

};

class HbMagnifierDelegateEditor : public HbMagnifierDelegate

{

public:

    HbMagnifierDelegateEditor(HbAbstractEdit * editor) {this->editor = editor;}

    virtual void drawContents(QPainter *painter, const QStyleOptionGraphicsItem *option)

    {

        if (option && editor) {

            static_cast<MyEditor*>(editor)->drawContents(painter,*option);

        }

    }

    void setEditor(HbAbstractEdit * editor){this->editor = editor;}

private:

    HbAbstractEdit * editor;

};

    enum InteractionMode {

        Selection,

        CursorPositioning

    };

    enum HandleType {

        DummyHandle,

        SelectionStartHandle,

        SelectionEndHandle

    };

    ~HbSelectionControlPrivate();

    void updateHandle(int cursorPos,

                      int newHandlePos,

                      QGraphicsItem *handleTouchArea);

    void updateMagnifier();

    void initMagnifier();

    QPointF constrainHitTestPoint(const QPointF& point);

    HbSelectionControlPrivate::HandleType handleForPoint(const QPointF& point);

    void gestureStarted(const QPointF &point);

    void tapGestureStarted(HbTapGesture *gesture);

    void tapGestureFinished();

    void delayedTapFinished();

    void panGestureCanceled();

#if HB_DEBUG_PAINT_INFO

    void updateDebugPaintInfo();

#endif

    HbMagnifierDelegateEditor *mMagnifierDelegate; // Owned by mMagnifier

    HbMagnifier* mMagnifier;

    QGraphicsItem *mTopLevelAncestor;    

    // The offset between the gesture start point and first hit test point

    QPointF mTouchOffsetFromHitTestPoint;

    HbIconItem *mSelectionStartHandle;

    HbIconItem *mSelectionEndHandle;

    InteractionMode mInteractionMode;

    HandleType mPressed;

    bool mScrollInProgress;

    QPointF mHitTestPoint;                 // HbSelectionControl's coordinate system

    QPointF mTouchPoint;                   // HbSelectionControl's coordinate system

    QPointF mStartHandleHitTestPoint;      // HbSelectionControl's coordinate system

    QPointF mEndHandleHitTestPoint;        // HbSelectionControl's coordinate system

    QBasicTimer mDelayedTapTimer;

    bool mMagnifierEnabled;

    qreal mLastCursorHeight;

    qreal mHandleMarginFromLine;

    qreal mMagnifierMarginFromLine;

    qreal mMagnifierLeftRightMarginFromHandle;

    qreal mMagnifierMaxDescent;

    qreal mVerticalScreenMargin;

    qreal mTouchYOffsetFromMagnifierReferenceLine; // HbSelectionControl's coordinate system

    qreal mStartHandleMagnifierReferenceLine;     // HbSelectionControl's coordinate system

    qreal mEndHandleMagnifierReferenceLine;       // HbSelectionControl's coordinate system

    qreal mMagnifierMaxYOffsetFromTouchPoint;

    qreal mMagnifierMinYOffsetFromTouchPoint;

    qreal mMaxHitTestPointOffsetYFromLine;

    bool mIsPanActive;

#if HB_DEBUG_PAINT_INFO

    QRectF  mDocRectDebug;      // HbSelectionControl's coordinate system

#endif

    mMagnifierDelegate(0),

    mMagnifier(0),

    mInteractionMode(InteractionMode(0)),

    mPressed(HandleType(0)),

    mScrollInProgress(false),

    mMagnifierEnabled(true),

    mLastCursorHeight(0.0),

    mHandleMarginFromLine(0.0),

    mMagnifierMarginFromLine(0.0),

    mMagnifierLeftRightMarginFromHandle(0.0),

    mMagnifierMaxDescent(0.0),

    mVerticalScreenMargin(0.0),

    mTouchYOffsetFromMagnifierReferenceLine(0.0),

    mStartHandleMagnifierReferenceLine(0.0),

    mEndHandleMagnifierReferenceLine(0.0),

    mMagnifierMaxYOffsetFromTouchPoint(0.0),

    mMagnifierMinYOffsetFromTouchPoint(0.0),

    mMaxHitTestPointOffsetYFromLine(0.0),

    mIsPanActive(false)

HbSelectionControlPrivate::~HbSelectionControlPrivate()

{

}

    // Set the size of the control to 0

    q->resize(0,0);

#if HB_DEBUG_PAINT_INFO

    // Override 0 size to be able to paint paint

    q->resize(1,1);

#endif

    q->style()->parameter(QLatin1String("hb-param-margin-gene-middle-vertical"), mVerticalScreenMargin);

        mSelectionStartHandle = new HbIconItem(q);

        mSelectionStartHandle->setIconName(QLatin1String("qtg_graf_editor_handle_begin"));

        HbStyle::setItemName(mSelectionStartHandle, QLatin1String("handle-icon"));

        mSelectionEndHandle = new HbIconItem(q);

        mSelectionEndHandle->setIconName(QLatin1String("qtg_graf_editor_handle_end"));

        HbStyle::setItemName(mSelectionEndHandle, QLatin1String("handle-icon"));

        HbStyle::setItemName(mSelectionStartTouchArea, QLatin1String("handle-toucharea"));

        mSelectionStartTouchArea->installEventFilter(q);

        HbStyle::setItemName(mSelectionEndTouchArea, QLatin1String("handle-toucharea"));

        mSelectionEndTouchArea->installEventFilter(q);

    }

    if(!mMagnifier) {

        mMagnifier = new HbMagnifier(q);

        mMagnifier->setFlag(QGraphicsItem::ItemIsPanel);

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

        mMagnifier->setActive(false);

        HbStyle::setItemName(mMagnifier, QLatin1String("magnifier"));

        mMagnifierDelegate = new HbMagnifierDelegateEditor(mEdit);

        mMagnifier->setContentDelegate(mMagnifierDelegate);

        mMagnifier->hide();

        initMagnifier();

void HbSelectionControlPrivate::updateHandle(

                  int cursorPos,

                  int newHandlePos,

                  QGraphicsItem *handleTouchArea)

    QRectF rect = mEdit->rectForPosition(newHandlePos,(Qt::AlignTop||mInteractionMode == CursorPositioning)?

                                                       QTextLine::Leading:QTextLine::Trailing);

    qreal lineHeight = rect.height();

    if(cursorPos == newHandlePos) {

        mLastCursorHeight = lineHeight;

    }

    // Store the current hit test point for the given handle

    // Convert rect to HbSelectionControl's coordinate system

    QRectF rectInSelectionControlCoord = q->mapRectFromItem(mEdit,rect);

    if (handleAlignment == Qt::AlignTop) {

        mStartHandleHitTestPoint = rectInSelectionControlCoord.center();

        mStartHandleHitTestPoint.setY(qMin(mStartHandleHitTestPoint.y(),

                                           rectInSelectionControlCoord.top()+mMaxHitTestPointOffsetYFromLine));

        mStartHandleMagnifierReferenceLine = rectInSelectionControlCoord.top();

    } else {

        mEndHandleHitTestPoint = rectInSelectionControlCoord.center();

        mEndHandleHitTestPoint.setY(qMax(mEndHandleHitTestPoint.y(),

                                         rectInSelectionControlCoord.bottom()-mMaxHitTestPointOffsetYFromLine));

        mEndHandleMagnifierReferenceLine = rectInSelectionControlCoord.bottom();

    }

    bool positionHandlesTouchEachOther = (boundingRect.height()*2 > lineHeight);

    // Position handle either on top of rect using margin mHandleMarginFromLine or so that

    // the two handles touch eachother

        if (positionHandlesTouchEachOther) {

            boundingRect.moveBottom(rect.center().y());

        } else {

            boundingRect.moveTop(rect.top()-mHandleMarginFromLine);

        }

        if (positionHandlesTouchEachOther) {

            boundingRect.moveTop(rect.center().y());

        } else {

            boundingRect.moveBottom(rect.bottom()+mHandleMarginFromLine);

        }

    // Position handle touch area around center-top of handle

    rect = boundingRect;

    if (handleAlignment != Qt::AlignTop) {

        boundingRect.moveTop(rect.top());

    }

    if (!mScrollInProgress) {

void HbSelectionControlPrivate::updateMagnifier()

{

    Q_Q(HbSelectionControl);

    if (mMagnifier->isVisible()) {

        QPointF canvasHitTestPos = q->mapToItem(HbAbstractEditPrivate::d_ptr(mEdit)->canvas,mHitTestPoint);

        QRectF canvasCursorRect = HbAbstractEditPrivate::d_ptr(mEdit)->rectForPositionInCanvasCoords(mEdit->textCursor().position(),QTextLine::Leading);

        QPointF centerOfMagnification = canvasCursorRect.center();

        centerOfMagnification.setX(canvasHitTestPos.x());

        canvasCursorRect.moveCenter(centerOfMagnification);

        // Set the visible content to be magnified

        qreal magnifierHeight = mMagnifier->boundingRect().height();

        // Check if the line fits vertically to the magnifier if not align the bottom of the line with the bottom of the

        // magnifier constraining a maximum line descent.

        if (magnifierHeight < canvasCursorRect.height()*mMagnifier->contentScale()) {

            const QTextCursor cursor = mEdit->textCursor();

            const QTextBlock block = cursor.block();

            const int positionInBlock = cursor.position() - block.position();

            QTextLine line = block.layout()->lineForTextPosition(positionInBlock);

            qreal lineDescent = line.descent();

            qreal lineBottom  = canvasCursorRect.bottom();

            if (mMagnifierMaxDescent < lineDescent) {

                lineBottom-= lineDescent-mMagnifierMaxDescent;

            }

            // Compensate for rounding error by adding +1

            centerOfMagnification.setY(lineBottom-magnifierHeight/(2*mMagnifier->contentScale())+1);

        }

        mMagnifier->centerOnContent(centerOfMagnification);

        // -- Position magnifier --

        // Convert cursorRect to HbSelectionControl's coordinate system

        QRectF rect = q->mapRectFromItem(HbAbstractEditPrivate::d_ptr(mEdit)->canvas,canvasCursorRect);

        QRectF boundingRect = mMagnifier->boundingRect();

        boundingRect.moveCenter(rect.center());

        const qreal KMagnifierBottomUpperBound = rect.top()-mMagnifierMarginFromLine+mTouchYOffsetFromMagnifierReferenceLine;

        const qreal KMagnifierBottomLowerBound = rect.bottom()-mMagnifierMarginFromLine+mTouchYOffsetFromMagnifierReferenceLine;

        qreal newMagnifierBottom = (mPressed == SelectionStartHandle?KMagnifierBottomUpperBound:KMagnifierBottomLowerBound);

        // -- Constrain vertical position --

        // Constrain maximum distance of bottom of the magnifier from touch point

        newMagnifierBottom = qMax(newMagnifierBottom,mTouchPoint.y()-mMagnifierMaxYOffsetFromTouchPoint);

        // Constrain minimum distance of bottom of the magnifier from touch point

        newMagnifierBottom = qMin(newMagnifierBottom,mTouchPoint.y()-mMagnifierMinYOffsetFromTouchPoint);

        // Constrain the bottom of the magnifier to be within the feasible bounds

        newMagnifierBottom = qMin(qMax(newMagnifierBottom,KMagnifierBottomUpperBound),KMagnifierBottomLowerBound);

        boundingRect.moveBottom(newMagnifierBottom);

        boundingRect.moveTop(qMax(mVerticalScreenMargin,boundingRect.top()));

        // Readjust magnifier position if there is not enough space at the top of the screen

        if (mTouchPoint.y()-mMagnifierMinYOffsetFromTouchPoint < boundingRect.bottom()) {

            boundingRect.moveRight(mTouchPoint.x()-mMagnifierLeftRightMarginFromHandle);

            if(boundingRect.left() < 0) {

                boundingRect.moveLeft(mTouchPoint.x()+mMagnifierLeftRightMarginFromHandle);

            }

        }

        mMagnifier->setPos(boundingRect.topLeft());

#if HB_DEBUG_PAINT_INFO

    updateDebugPaintInfo();

#endif

    }

}

void HbSelectionControlPrivate::initMagnifier()

{   

    mMagnifier->setContentScale(MAGNIFIER_SCALE_FACTOR);

    mMagnifier->setZValue(100); 

    mMagnifier->setMask(QLatin1String("qtg_fr_editor_magnifier_mask"));

    mMagnifier->setOverlay(QLatin1String("qtg_fr_editor_magnifier_overlay"));

    updateMagnifier();

}