// 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:

//

#ifndef CMOCKSYENGINE_H

#define CMOCKSYENGINE_H

#include <e32def.h>

#include <e32base.h>

class CRotatingStrBuf;

#define KMaxLogLineSize 255

/**

Listener to CMockSYEngine events

*/

class MMockSYEngineListener

	{

public:

	enum TNotificationType

		{

		EHandlingTerminated,	//< all messages are handled

		EFailure,				//< receive message doesn't correspond to the expected one

		};

	virtual void Notify(TNotificationType aNotification) =0;	

	};

/**

Abstract class for command data

*/

class MMockSyEngineData

	{

public:

	/**

	Comparator: compare the data with it packaged version from an Event

	*/

	virtual TBool operator ==(const TDesC8& aData) const =0;

	};

/**

Abstract class for the logger

*/

/**

Mock SY engine base class

*/

class CMockSYEngine : public CBase

	{

public:

	IMPORT_C virtual ~CMockSYEngine();

public:

	/**

	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

	*/

	IMPORT_C TInt ExecuteCommandL(TInt aCmdId, MMockSyEngineData& aData);

	/**

	Check data or not depending on the aCheckData

	*/

    IMPORT_C TInt ExecuteCommandL(TInt aCmdId, MMockSyEngineData& aData, TBool aCheckData);	

public:	

	inline void SessionClosed();

	inline void QueueEpectedCallL(TInt aCmdId, TInt aErrorCode, TBool aLeave, HBufC8* aData);

	inline void QueueReturnCallL(TInt aCmdId,  TInt aErrorCode, TInt aDelay, HBufC8* aData);

	HBufC* GetNextLogLine();

	inline TBool HasWaitingEvents() const;

	inline TBool HasPendingEvents() const;

	inline TBool HasFailure() const;

        IMPORT_C void CheckAndUpdateTransId(TUint8 aTransId, TInt aCommandId);

public: // listener API

	void AddListenerL(MMockSYEngineListener& aListener);

	void RemoveListener(MMockSYEngineListener& aListener);

    TInt PauseCompletion();

    TInt ResumeCompletion();

protected:

	IMPORT_C virtual void ConstructL();

	IMPORT_C CMockSYEngine();

protected:

	/**

	A LTSY event.

	It can be a message as received from the LTSY or a completion to send to CTSY

	*/

	class TMockSYEvent

		{

	public:

		enum TEventType

			{

			EMessage,

			ECompletion

			};

		TEventType	iEventType;					//< Event type

		TInt 		iCmdId;						//< expected cmdId or cmdId to complete

		TInt 		iResultCode;				//< Message or completion result code 

		TBool		iLeave;						//< If True, leave with iResultCode error

		TInt		iDelay;						//< for completion: delay before sending the completion

		RBuf8		iData;						//< Message or completion data

	public:

		TDblQueLink	iWaitingEventQueLink;		//< Link for the waiting event queue

		TDeltaQueLink iPendingEventQueLink;		//< Link for the pending event queue

		};

protected:

	/**

	Complete aEvent. Subclass must implement this function and complete the 

	SY request

	*/ 

	virtual void DoCompleteEventL(const TMockSYEvent& aEvent) =0;

	/**

	Queue an event. 

	*/

	IMPORT_C virtual void DoQueueEventL(TMockSYEvent::TEventType aType, TInt aCmdId, HBufC8* aData, 

		TInt aResultCode, TBool aLeave, TInt aDelay);

	/**

	 	Returns if MockSY can ignore a given unexpected IPC error.

	 */

	IMPORT_C virtual TBool CanIgnoreUnexpectedIpc(TInt aCmdId);

private:

	TDblQue<TMockSYEvent> 	iWaitingEventQue;

	TDeltaQue<TMockSYEvent>	iPendingEventQue;

	TBool iFailure;

	CPeriodic* iTimer;

	RPointerArray<MMockSYEngineListener> iListeners;

private:

	void DoTimerCallbackL();

protected:

	IMPORT_C virtual void Failure();

	IMPORT_C virtual void Reset();

private: // listener API

	void NotifyListeners(MMockSYEngineListener::TNotificationType aNotification);

protected: // logging: can be override to log specific informations

	IMPORT_C virtual void LogRequest(TInt aCmdId, const MMockSyEngineData& aData,TInt aResultCode);

	IMPORT_C virtual void LogCompletion(TInt aCmdId, const TDesC8& aData,TInt aResultCode);

	IMPORT_C virtual void LogExpectError(TInt aCmdId, const MMockSyEngineData& aData,TInt aExpectedCmd,const TDesC8& aExpectedData, TBool aIsErrorIgnored=EFalse);	

	IMPORT_C virtual void Log(const TDesC& aDesc);

private: // static timer callback

	CRotatingStrBuf* iRotatingLog;

	static TInt TimerCallbackL(TAny* aPtr);

	TBool iPaused;

	};

// inlines

inline void CMockSYEngine::QueueEpectedCallL(TInt aCmdId, TInt aErrorCode, TBool aLeave, HBufC8* aData)

	{

	DoQueueEventL(TMockSYEvent::EMessage, aCmdId, aData, aErrorCode, aLeave, 0);

	}

inline void CMockSYEngine::QueueReturnCallL(TInt aCmdId, TInt aErrorCode, TInt aDelay, HBufC8* aData)

	{

	DoQueueEventL(TMockSYEvent::ECompletion, aCmdId, aData, aErrorCode, EFalse, aDelay);

	}

inline TBool CMockSYEngine::HasWaitingEvents() const

	{

	return !iWaitingEventQue.IsEmpty();

	}

inline TBool CMockSYEngine::HasPendingEvents() const

	{

	return !iPendingEventQue.IsEmpty();

	}

inline TBool CMockSYEngine::HasFailure() const

	{

	return iFailure;

	}

/**

Called when the session using this engine is closed

*/

inline void CMockSYEngine::SessionClosed()

	{

	iFailure = EFalse;

	Reset();

	}

#endif