/*
* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, version 2.1 of the License.
* 
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program.  If not, 
* see "http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html/".
*
* Description:
*
*/

#ifndef QSTMSTATEENGINE_H_
#define QSTMSTATEENGINE_H_

#include "qstmuievent_if.h"
#include "qstmtimerinterface.h"
#include "qstmstatemachine_v2.h"
#include "qstmstateengineconfig.h"
#include "qstmuievent.h"

#include <QtCore>


namespace qstmUiEventEngine
{

class QStm_UiEvent;
/*!
 * Define THwEvent since we need the point, the type and timestamp to be stored.
 * The HW event is used also to handle the timer events so that the wrapper class calling the
 * state machine will handle the starting, canceling etc. of the timers and the state machine
 * sees the timers as messages.  This hopefully makes it easier to keep the core state machine as
 * OS agnostic as possible.
 */
class QStm_HwEvent
{
public:
    QStm_HwEvent() {} ;
    QStm_HwEvent(const QStm_HwEvent& ev):
        m_type(ev.m_type), m_position(ev.m_position),
        m_time(ev.m_time), m_target(ev.m_target), m_pointerNumber(ev.m_pointerNumber) {}
    QStm_HwEvent(QStm_StateMachineEvent code, const QPoint& pos, QTime time, void* target, int pointerNr):
        m_type(code), m_position(pos),
        m_time(time), m_target(target), m_pointerNumber(pointerNr) {}

    QStm_StateMachineEvent m_type ;
    QPoint  m_position ;
    QTime   m_time ;
    void*   m_target ;
	int	    m_pointerNumber ;
};


class QStm_StateEngine : public QObject
{
public:
    /**
     * constructor and destructor
     */
	QStm_StateEngine(QStm_StateEngineConfiguration* config, QStm_TimerInterfaceIf* timerif, int index) ;

    ~QStm_StateEngine() ;
    /**
     *  The methods needed for state machine
     */
    void consumeEvent() ;
    bool isTouchTimer() ;
    bool isHoldTimer() ;
    bool isSuppressTimer() ;
    bool isTouchTimeArea() ;
    bool isTouchArea() ;
    bool isHoldArea() ;
    bool insideTouchTimeArea() ;
    bool insideTouchArea() ;
    bool insideHoldArea() ;
    bool looksLikeHold() ;
    void errorEvent() ;
    void initTouchTimer() ;
    void initHoldTimer() ;
    void restartHoldTimer() ;
    void initTouchSuppressTimer() ;
    void initMoveSuppressTimer() ;
    void clearTouchTimer() ;
    void clearHoldTimer() ;
    void clearSuppressTimer() ;
    void produceTouch() ;
    void produceMove() ;
    void produceRelease() ;
    void produceHold() ;
    void renameToDrag() ;
    void prepareTouchTimeArea() ;
    void prepareTouchArea() ;
    void prepareHoldArea() ;
    void setCurrentPos() ;
    void setGestureStart() ;
    void addToTouch() ;
    void addDraggingPos() ;
    void storeMovePos() ;
    bool insideMoveThreshold();

    /**
     * The event interface
     */

    QStm_HwEvent& initEvent()
    {
        m_hwe.m_pointerNumber = m_index;
        return m_hwe;
    }

    // event returned by initEvent() must initialized first
	bool handleStateEvent()  ;

	QRect getTouchArea() ;
	QRect getHoldArea() ;
	bool  wasLastMessageFiltered() ;

private:
    bool m_eventConsumed ;
    QStm_HwEvent m_hwe ;

    bool isNewHoldingPoint() ;
    QList<QStm_HwEvent*>  m_dragPoints;        // LATER: change this into std::vector
    QStm_TimerInterfaceIf*  m_timerif ;                //

    QList<QStm_HwEvent>   m_touchPoints;      // LATER: change this into std::vector

    // Variables for running the state machine
    QStm_StateMachineState m_currentState ;
    bool m_isTimerEvent ;                   // We need to separate the pointer events and the timer events
    QPoint m_currentTouchXY ;               // This is the touching point
    QPoint m_gestureStartXY ;               // gesture started at this point
    QPoint m_uiEventXY ;                    // The UI event XY point.
    QPoint m_previousPointerEventPosition ;
    QPoint m_deltaVector ;
    QRect m_touchRect ;
    QRect m_holdRect ;

    bool m_wasFiltered ;
    void calculateDelta() ;
    void calculateTouchAverage() ;
    void calculateCurrentVector() ;
    QPoint calculateTouchAverageFromPoints() ;
    bool insideArea(const QPoint& point, const QRect& rect, QStm_AreaShape shape, const QPoint& tolerance);
    void setTolerance(long fingersize_mm, QPoint& tolerance, QStm_AreaShape shape) ;

    void debugPrintState(QStm_StateMachineState nextstate) ;
    inline static QRect toleranceRect( const QPoint& aCenterPoint, const QPoint& tolerance) ;
    void turnStateMachine() ;

    QPoint     m_touchCentre ;
    QPoint     m_holdCentre ;

    void*       m_gestureTarget ;
    long        getInterval() ;
    QTime       m_lastMessageTime ;
    QStm_UiEvent* createUIEvent(QStm_UiEventCode code, const QPoint& aPos) ;
    QPoint getPreviousXY(const QPoint& aXY) ;
    QPoint m_previousXY ;
    bool isTimerMessage() ;
    int  m_index ;
    // TPoint screenCoordinates(TPoint aPos, void* aGestureTarget) ;
    QStm_UiEventCode m_previousUiGenerated ;
    QPoint m_lastFilteredPosition ;
    QTime m_lastFilteredMessageTime ;

	QStm_StateEngineConfiguration* m_config ;

};

class QStm_UiEventSender: public QObject
{
public:
    enum EventSenderState
        {
        ENoEvents,
        EEventsReady,
        EBusy
        };

    QStm_UiEventSender();
    ~QStm_UiEventSender();

    int addEvent(QStm_UiEvent* gestureEvent);
    bool addObserver(QStm_UiEventObserverIf* observer );
    bool removeObserver(QStm_UiEventObserverIf* observer );
    bool isObserver(void* observer );
    void setLogging(bool a) {m_loggingenabled = a;} ;

private:
    void emitEvent( const QStm_UiEvent& gestureEvent );

    /*!
     * Should we be prepared for more than 5 pointers ?  Jos tulee Torvisen voittaja
     */
    QStm_UiEvent* m_events[qstmUiEventEngine::KMaxNumberOfPointers];
    void compressStack(QStm_UiEvent* uiEvent) ;

    /*
     * Let's be prepared for more than one observer,
     * although usually there is only the gesture engine
     */
    QList<QStm_UiEventObserverIf*> m_observers;
    bool m_loggingenabled ;

};
}   // namespace

#endif /* QSTMSTATEENGINE_H_ */