/*
* 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:
*
*/
#include "qstmstateengine.h"
#include "qstmuievent.h"

#include "qstmfilelogger.h"

using namespace qstmUiEventEngine;


QStm_UiEventSender::QStm_UiEventSender()
{
    m_loggingenabled = false ;
    for (int i = 0; i < qstmUiEventEngine::KMaxNumberOfPointers; i++)
    {
        m_events[i] = NULL ;
    }
}

QStm_UiEventSender::~QStm_UiEventSender()
{
    // remove the possible events from the buffers if release was missed
    for (int i = 0; i < qstmUiEventEngine::KMaxNumberOfPointers; i++)
    {
        if (m_events[i] != NULL) delete m_events[i] ;
    }
    m_observers.clear();
}

/*!
 * Add new UI event to the list or send it directly to the observers
 * depending on the m_directsending flag.
 * \param aUiEvent the new UI event to be sent to the observers.
 */
int QStm_UiEventSender::addEvent(QStm_UiEvent* uiEvent)
{
    int pointerIndex = uiEvent->index() ;
    // Store the new UI event.  Check what kind of event it is and compress the set of events
    // stored so far if possible
    compressStack(uiEvent) ;
    uiEvent->setPrevious(m_events[pointerIndex]) ;
    m_events[pointerIndex] = uiEvent ;  // Store the new event
    // TESTING: logging the speed calculations
    if (m_loggingenabled)
    {
        uiEvent->logSpeed() ;
    }
    emitEvent(*uiEvent) ;

    if (m_loggingenabled)
    {
        LOGARG("Sent event: %s: (ptr %d) (%d,%d)", qstmUiEventEngine::event_name(uiEvent->code()), pointerIndex, 
        		uiEvent->currentXY().x(), uiEvent->currentXY().y());
    }
    // If this was release event, then the chain can be removed
    if (uiEvent->code() == qstmUiEventEngine::ERelease)
    {
        delete uiEvent;    // This will delete the whole chain
        m_events[pointerIndex] = NULL ;
    }
    return 0;
}
/*!
 * Call each observer with the event
 */
void QStm_UiEventSender::emitEvent(const QStm_UiEvent& event)
{
	int count = m_observers.count();
    for (int i = 0; i < count; i++)
    {
        m_observers[i]->handleUiEvent(event);
    }
}

/*!
 * Add a new observer.  Note that current implementation is very rude:
 * max 5 observers in a simple array.
 */
bool QStm_UiEventSender::addObserver(QStm_UiEventObserverIf* observer )
{
    m_observers.append(observer) ;
    return true ;
}

// Check if the parameter refers to one of our observers
bool QStm_UiEventSender::isObserver(void* aObserver )
{
    QObject* pccToCheck = (QObject*) aObserver ;
    int count = m_observers.count();
    for (int i = 0; i < count; i++)
    {
        try
        {
            QObject* pcc = dynamic_cast<QObject*>(m_observers[i]) ;
            if (pcc == pccToCheck)
                return true ;
        }
        catch(...)
        {

        }
    }
    return false ; // Could not find observer
}

/*
 * remove observer from list
 */
bool QStm_UiEventSender::removeObserver(QStm_UiEventObserverIf* observer )
{
    int i = m_observers.indexOf(observer) ;
    if (i != -1)
    {
        m_observers.removeAt(i) ;
        return true ;

    }
    return false ; // Could not find observer
}


void QStm_UiEventSender::compressStack(QStm_UiEvent* uiEvent)
{
    int pointerIndex = uiEvent->index() ;
    QStm_UiEvent*& top = m_events[pointerIndex] ;
    if(!top)
    {
        return;
    }
    if (uiEvent->code() == qstmUiEventEngine::EHold)
    {
        // assumption: in case of hold, we can discard all previous messages
        delete top ;
        top = NULL ;
    }
    else
    {
        // Check if there would too many moves
        QStm_UiEvent* next = dynamic_cast<QStm_UiEvent*>(top->previousEvent()) ;
        if (next != 0 && next->code() == qstmUiEventEngine::EMove)
        {
            // leave only the topmost to the stack
            top->setPrevious(0) ;
            delete next ;
        }
    }
}