// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
//

#include "cmocksyengine.h"
#include "rotatingstrbuf.h"

#define KMaxLogEntries 30
#define KCallbackBaseTime (1*100*1000)	// 0.1S

/**
Constructor
*/
EXPORT_C CMockSYEngine::CMockSYEngine()
	:iWaitingEventQue(_FOFF(TMockSYEvent,iWaitingEventQueLink))
	,iPendingEventQue(_FOFF(TMockSYEvent,iPendingEventQueLink))
	{
	}

/**
2nd phase construction 
*/
EXPORT_C void CMockSYEngine::ConstructL()
	{
	iTimer = CPeriodic::NewL(EPriorityHigh);
	iRotatingLog = CRotatingStrBuf::NewL(KMaxLogEntries);
	iPaused = EFalse;
	}

/**
destructor
*/
EXPORT_C CMockSYEngine::~CMockSYEngine()
	{
	Reset();
	delete iTimer;
	delete iRotatingLog;
	iListeners.Close();
	}

/**
Add a new listener to the listener list
*/
void CMockSYEngine::AddListenerL(MMockSYEngineListener& aListener)
	{
	iListeners.AppendL(&aListener);
	}

void CMockSYEngine::RemoveListener(MMockSYEngineListener& aListener)
	{
	TInt idx=0;
	while (idx < iListeners.Count())
		{
		if (iListeners[idx]==&aListener)
			{
			iListeners.Remove(idx);
			break;
			}
		idx++;
		}
	}

void CMockSYEngine::NotifyListeners(MMockSYEngineListener::TNotificationType aNotification)
	{
	for (TInt idx=0; idx<iListeners.Count(); idx++)
		{
		iListeners[idx]->Notify(aNotification);
		}
	}

/**
Called by the SY, handle received command by verifing that is the expected command
and queuing the conresponding completions
Return KErrCorrupt it it's not the expected command
*/
EXPORT_C TInt CMockSYEngine::ExecuteCommandL(TInt aCmdId, MMockSyEngineData& aData)
	{
	return ExecuteCommandL(aCmdId, aData, ETrue);		
	}
	
EXPORT_C TInt CMockSYEngine::ExecuteCommandL(TInt aCmdId, MMockSyEngineData& aData, TBool aCheckData)
	{
	if (iWaitingEventQue.IsEmpty())
		{
		if(CanIgnoreUnexpectedIpc(aCmdId))
			{
			LogExpectError(aCmdId, aData, 0, KNullDesC8, ETrue); // ETrue means this error has been ignored
			return KErrNone;
			}
		LogExpectError(aCmdId,aData,0,KNullDesC8);
		Failure();
		return KErrCorrupt;
		}
	TMockSYEvent* event = iWaitingEventQue.First();
	// Top of the queue is supposed to be an EMessage event !
	ASSERT(event->iEventType == TMockSYEvent::EMessage);
	
	// validate expected call
	if ( (aCmdId!=  event->iCmdId) ||  (aCheckData ? !(aData == event->iData) : EFalse) )
		{
		if(CanIgnoreUnexpectedIpc(aCmdId))
			{
			LogExpectError(aCmdId, aData, event->iCmdId, KNullDesC8, ETrue); // ETrue means this error has been ignored
			return KErrNone;
			}
		// failure ! it's the wrong event
		LogExpectError(aCmdId,aData,event->iCmdId,event->iData);
		Failure();
		return KErrCorrupt;
		}
	else
		{		
		TInt resultCode = event->iResultCode;
		TBool leave = event->iLeave;
		LogRequest(aCmdId,aData,resultCode);
		// remove the event from the waiting queue
		event->iWaitingEventQueLink.Deque();
		event->iData.Close();
		delete event;
		
		// and push all following ECompletion events to the pending queue
		if (!iWaitingEventQue.IsEmpty())
			event = iWaitingEventQue.First();
		while (!iWaitingEventQue.IsEmpty() && (event->iEventType == TMockSYEvent::ECompletion))
			{
			event->iWaitingEventQueLink.Deque();
			iPendingEventQue.Add(*event,event->iDelay);
			if (!iWaitingEventQue.IsEmpty())
				event = iWaitingEventQue.First();
			}
		// start the timer
		if (!iPendingEventQue.IsEmpty() && !iTimer->IsActive())
			{
			iTimer->Start(KCallbackBaseTime,KCallbackBaseTime,TCallBack(CMockSYEngine::TimerCallbackL, this));
			}
		// notify when both queue are empty
		if (iPendingEventQue.IsEmpty() && iWaitingEventQue.IsEmpty())
			{
			NotifyListeners(MMockSYEngineListener::EHandlingTerminated);
			}
		if (leave)
			{
			User::Leave(resultCode);
			}
		return resultCode;
		}
	}


/**
Queue an event in the waiting event queue
*/
EXPORT_C void CMockSYEngine::DoQueueEventL(TMockSYEvent::TEventType aType, TInt aCmdId, HBufC8* aData, 
	TInt aResultCode, TBool aLeave, TInt aDelay)
	{
	TMockSYEvent* event = new (ELeave)TMockSYEvent;
	event->iEventType 	= aType;
	event->iCmdId 		= aCmdId;
	event->iResultCode 	= aResultCode;
	event->iDelay 		= aDelay;
	event->iLeave		= aLeave;
	event->iData.Assign(aData);
	if ((aType == TMockSYEvent::ECompletion) && iWaitingEventQue.IsEmpty())
		{
		// it's a ECompletion msg and the waiting queue is empty, put the event directly in pending queue
		iPendingEventQue.Add(*event,event->iDelay);
		if (!iTimer->IsActive())
			{
			iTimer->Start(KCallbackBaseTime,KCallbackBaseTime,TCallBack(CMockSYEngine::TimerCallbackL, this));
			}
		}
	else
		{
		iWaitingEventQue.AddLast(*event);
		}
	}

/**
	Returns EFalse indicating no IPC error can be ignored.
 */
EXPORT_C TBool CMockSYEngine::CanIgnoreUnexpectedIpc(TInt /*aCmdId*/)
	{
	return EFalse;
	}

/**
Return the next log line from the rotating log buffer
*/
HBufC* CMockSYEngine::GetNextLogLine()
	{
	return iRotatingLog->Get();
	}

/**
Periodical timer callback: generate completions
*/
void CMockSYEngine::DoTimerCallbackL()
	{
    if(iPaused)
        {
        return;
        }
	iPendingEventQue.CountDown();
	TMockSYEvent* event = iPendingEventQue.RemoveFirst();
	while(event != NULL )
		{
		LogCompletion(event->iCmdId,event->iData, event->iResultCode);
		this->DoCompleteEventL(*event);
		event->iData.Close();
		delete event;
		event = iPendingEventQue.RemoveFirst();
		}
	// stop the timer if there is no more pending messages
	if (iPendingEventQue.IsEmpty())
		{
		iTimer->Cancel();
		// notify when both queue are empty
		if (iWaitingEventQue.IsEmpty())
			{
			NotifyListeners(MMockSYEngineListener::EHandlingTerminated);
			}
		}
	}


/**
This function is called when an receive message doesn't correspond to the expected one
*/
EXPORT_C void CMockSYEngine::Failure()
	{
	iFailure = ETrue;
	NotifyListeners(MMockSYEngineListener::EFailure);
	Reset();
	}

/**
Reset waiting and pending event queue
*/
EXPORT_C void CMockSYEngine::Reset()
	{
    iPaused = EFalse;
	TMockSYEvent* event;
	while (!iWaitingEventQue.IsEmpty())
		{
		event = iWaitingEventQue.First();
		event->iWaitingEventQueLink.Deque();
		event->iData.Close();
		delete event;
		}
	while (!iPendingEventQue.IsEmpty())
		{
		iPendingEventQue.CountDown();
		event = iPendingEventQue.RemoveFirst();
		while(event != NULL )
			{
			event->iData.Close();
			delete event;
			event = iPendingEventQue.RemoveFirst();
			}
		}
	}

EXPORT_C void CMockSYEngine::LogRequest(TInt aCmdId, const MMockSyEngineData& /*aData*/,TInt aResultCode)
	{
	TBuf<KMaxLogLineSize> buffer;
	buffer.Format(_L(">>> Cmd=%d Err=%d"),aCmdId, aResultCode);
	Log(buffer);	
	}

EXPORT_C void CMockSYEngine::LogCompletion(TInt aCmdId, const TDesC8& /*aData*/,TInt aResultCode)
	{
	TBuf<KMaxLogLineSize> buffer;
	buffer.Format(_L("<<< Cmd=%d Err=%d"),aCmdId, aResultCode);
	Log(buffer);	
	}

EXPORT_C void CMockSYEngine::LogExpectError(TInt aCmdId, const MMockSyEngineData& /*aData*/,
	TInt aExpectedCmd,const TDesC8& /*aExpectedData*/, TBool /*aIsErrorIgnored*/)
	{
	TBuf<KMaxLogLineSize> buffer;
	buffer.Format(_L("ERROR: Expected Cmd=%d Received Cmd=%d"),aExpectedCmd, aCmdId);
	Log(buffer);	
	}

EXPORT_C void CMockSYEngine::Log(const TDesC& aDesc)
	{
	iRotatingLog->Put(aDesc);	
	}

TInt CMockSYEngine::TimerCallbackL(TAny* aPtr)
	{
	static_cast<CMockSYEngine*>(aPtr)->DoTimerCallbackL();
	return 0;
	}
EXPORT_C void CMockSYEngine::CheckAndUpdateTransId(TUint8 aTransId, TInt aCommandId)
    {
    TMockSYEvent* event = NULL;
    TDblQueIter<TMockSYEvent> iter(iWaitingEventQue);
    			
    while(iter)
        {
        event = (TMockSYEvent*)iter++;
        if((event->iCmdId == aCommandId) && (event->iData[0] == 0xFF) && (event->iEventType == TMockSYEvent::ECompletion))
            {
            event->iData[0] = aTransId;
            event->iData[1] = 1;
            break;
            }
        }
    }   

TInt CMockSYEngine::PauseCompletion()
    {
    TInt ret = (iPaused) ? KErrInUse : KErrNone;
    iPaused = ETrue;
    return ret;
    }
	
TInt CMockSYEngine::ResumeCompletion()
    {
    TInt ret = (!iPaused) ? KErrInUse : KErrNone;
    iPaused = EFalse;
    return ret;
    }