#ifndef UITIMER_H_
#define UITIMER_H_

#include <QDateTime>
#include <QDebug>
#include "qstmfilelogger.h"

#define TIMESTAMP() QDateTime::currentDateTime().toString("hh:mm:ss:zzz")

#ifdef Q_OS_SYMBIAN
#include <e32base.h>
#include <e32const.h>

class CUiTimer : public CTimer
{
public:
    enum CUiTimerType
    {
        AfterType,
        HighResType,
        LockType
    };
    
    CUiTimer(int priority) : CTimer(priority), m_timerType(AfterType)
    {
    }
    
    
    
    static CUiTimer* New(int priority)
    {
        CUiTimer* uitao = new CUiTimer(priority);
        if (uitao) {            
            TRAPD(r, uitao->ConstructL());
            if (r == KErrNone) {
                CActiveScheduler::Add(uitao);
            }
            else {
                delete uitao;
                uitao = NULL;
            }
        }
        return uitao;
    }
    
    ~CUiTimer() {}
    
    void Start(TTimeIntervalMicroSeconds32 delay,TTimeIntervalMicroSeconds32 interval,TCallBack callBack)
    {
        __ASSERT_ALWAYS(interval.Int()>=0,User::Panic(_L("Interval < 0"), -1));
        __ASSERT_ALWAYS(delay.Int()>=0,User::Panic(_L("Delay < 0"), -2));
        m_interval = interval.Int();
        m_callback = callBack;
        m_timerType = AfterType;
        After(delay);
    }
    
    void StartHighRes(TTimeIntervalMicroSeconds32 delay,TTimeIntervalMicroSeconds32 interval,TCallBack callBack)
    {
        __ASSERT_ALWAYS(interval.Int()>=0,User::Panic(_L("Interval < 0"), -1));
        __ASSERT_ALWAYS(delay.Int()>=0,User::Panic(_L("Delay < 0"), -2));
        m_interval = interval.Int();
        m_callback = callBack;
        m_timerType = HighResType;
        HighRes(delay);
    }
        
    void StartLock(TTimerLockSpec lockSpec,TCallBack callBack)
    {
        m_lockSpec = lockSpec;
        m_callback = callBack;
        m_timerType = LockType;
        Lock(m_lockSpec);
    }

    
    void RunL()
    {
        switch (m_timerType) {
        case HighResType:
            HighRes(m_interval);
            m_callback.CallBack();
            break;
        case LockType:
            Lock(m_lockSpec);
            m_callback.CallBack();
            break;
        case AfterType:
            After(m_interval);
            m_callback.CallBack();
            break;
        }
    }
    
private:    
    uint            m_interval; 
    TCallBack       m_callback;
    CUiTimerType    m_timerType;
    TTimerLockSpec  m_lockSpec;
};

class UiTimer : QObject
{
    enum UiTimerType
    {
        AfterType,
        HighResType,
        LockType
    };

public:
    static UiTimer*  New() 
    { 
        return new UiTimer(); 
    }
  
    inline UiTimer(): QObject(), m_id(0), m_requestedTicks(-1), 
                      m_ticksCount(0), m_cbName("uiTimerCallback") 
    {    
        m_timer = CUiTimer::New(20);
    }
  
    inline void setPriority(int priority) { m_timer->SetPriority(priority); }
    inline ~UiTimer() { m_timer->Cancel(); delete m_timer;}
    
    inline int timerId() const { return m_id; }

    static int timercallback(TAny* ptr)
    {
        UiTimer* uitimer = static_cast<UiTimer*>(ptr);
        uitimer->doTimerCallback();
        return 0;
    }
    
    void doTimerCallback()
    {
       if (isActive() && (m_requestedTicks < 0 || m_ticksCount++ < m_requestedTicks)) {  
           
           QMetaObject::invokeMethod(m_obj, m_cbName, Qt::DirectConnection);
           if (m_ticksCount == m_requestedTicks) {
               stop();
           }
       }
       return;
    }
    
    void start(int msec, QObject *obj, UiTimerType timerType = HighResType) 
    {
        m_delay = msec;
        m_obj = obj;
        m_ticksCount = 0;
        switch (timerType)
        {
        case HighResType:
            m_timer->StartHighRes((msec + 1) * 1000, (msec + 1) * 1000, TCallBack(timercallback, this));
            break;
        case AfterType:
            m_timer->Start(msec * 1000, msec * 1000, TCallBack(timercallback, this));
            break;
        case LockType:
            TTimerLockSpec lockSpec = static_cast<TTimerLockSpec>(msec);
            m_timer->StartLock(lockSpec, TCallBack(timercallback, this));
            break;
        }
    }
    
    void stop() 
    { 
        m_timer->Cancel(); 
    }
    
    bool isActive() { return m_timer->IsActive(); }
    
    void setRequestedTicks(int ticksCount) { m_requestedTicks = ticksCount; }
    int ticksCount() { return m_ticksCount; }
    
    void setSingleShot(bool isOneShot) { isOneShot ?  m_requestedTicks = 1 : m_requestedTicks = -1; }
    bool isSingleShot() { return m_requestedTicks == 1; }
    
    void setTimerCallback(char* cbName) { m_cbName = cbName; }
    
private:
    int         m_id;
    int         m_delay;
    QObject*    m_obj;
    CUiTimer*   m_timer;
    int         m_requestedTicks;
    int         m_ticksCount;
    char*       m_cbName;
    
};
#else
class UiTimer : public QObject
{
public:
    static UiTimer* New() { return new UiTimer(); }
    UiTimer() : QObject(), m_requestedTicks(-1), m_cbName(0)
    {
    }
    inline void setPriority(int priority) {}
    inline void start(int msec, QObject *obj) 
    {
        m_delay = msec;
        m_obj = obj;
        m_ticksCount = 0;
        m_timer.start(msec, this);
    }
    inline ~UiTimer() {}
        
    inline int timerId() const { return m_timer.timerId(); }

    inline void timerEvent(QTimerEvent *event)
    {
        if (m_requestedTicks < 0 || m_ticksCount++ < m_requestedTicks) {
            QMetaObject::invokeMethod(m_obj, m_cbName ? m_cbName : "uiTimerCallback", Qt::DirectConnection);
        }
        else {
            stop();
        }
        return;
    }

    inline void stop() { m_timer.stop(); }
        
    inline bool isActive() { return m_timer.isActive(); }

    void setRequestedTicks(int ticksCount) { m_requestedTicks = ticksCount; }
    int ticksCount() { return m_ticksCount; }
    
    void setSingleShot(bool isOneShot) { isOneShot ?  m_requestedTicks = 1 : m_requestedTicks = -1; }
    bool isSingleShot() { return m_requestedTicks == 1; }
    void setTimerCallback(char* cbName) { m_cbName = cbName; }

private:
    QBasicTimer  m_timer; 
    int          m_delay;
    QObject*     m_obj;
    int         m_requestedTicks;
    int         m_ticksCount;
    char*       m_cbName;
};

#endif




#endif /* UITIMER_H_ */