// 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 <s32strm.h>
#include <barsread2.h>

#include "ssmcommandparameters.h"
#include "cmdmultiplewait.h"
#include "ssmdebug.h"
#include "ssmpanic.h"

const TInt KMultipleWaitMilliToMicro = 1000;

/**
Used to create an instance of CCmdMultipleWait class from given parameters.
This method is used by SsmCommandFactory to create a command.

Creating multiple wait command with timeout value and 
Timer will be constructed only when command is executed through CLE

@param aTimeout Timeout specified for MULTIPLE_WAIT command
@return	A pointer to an object of type CCmdMultipleWait.
*/
CCmdMultipleWait* CCmdMultipleWait::NewL(TInt32 aTimeout)
	{
	CCmdMultipleWait* self = new (ELeave) CCmdMultipleWait(aTimeout);
	return self;
	}

#ifdef SYMBIAN_SSM_FLEXIBLE_MERGE
/**
Used to create an instance of CCmdMultipleWait class from given parameters.
This method is used by SsmCommandFactory to create a command.

Creating multiple wait command with timeout value and Priority
Timer will be constructed only when command is executed through CLE

@param aTimeout Timeout specified for MULTIPLE_WAIT command
@param aPriority The priority of command in the list
@return	A pointer to an object of type CCmdMultipleWait.
*/
CCmdMultipleWait* CCmdMultipleWait::NewL(TInt32 aTimeout, const TUint16 aPriority)
	{
	CCmdMultipleWait* self = new (ELeave) CCmdMultipleWait(aTimeout, aPriority);
	return self;
	}
#endif //SYMBIAN_SSM_FLEXIBLE_MERGE

/**
Used to create an instance of CCmdMultipleWait class from a read stream.
CSsmCommandList::InternalizeL() uses this method to construct a command from stream.

Creating multiple wait command with ReadStream and DeferredCommands 
Timer will be constructed only when command is executed through CLE

@param aReadStream Read stream containing data through which object can be created
@param aDeferredCommands List of deferred commands
@return	A pointer to an object of type CCmdMultipleWait.
*/
CCmdMultipleWait* CCmdMultipleWait::NewL(RReadStream& aReadStream, TArray<MSsmCommand*>& aDeferredCommands)
	{
	CCmdMultipleWait* self = new (ELeave) CCmdMultipleWait();
	CleanupStack::PushL(self);
	self->ConstructL(aDeferredCommands, aReadStream);
	CleanupStack::Pop(self);
	return self;
	}

/**
Used to create an instance of CCmdMultipleWait class from resource.

Creating multiple wait command with CommandParameters and 
Timer will be constructed only when command is executed through CLE

@param aCommandParameters Object data from a resource file
@return	A pointer to an object of type CCmdMultipleWait.
*/
CCmdMultipleWait* CCmdMultipleWait::NewL(TSsmCommandParameters& aCommandParameters)
	{
	CCmdMultipleWait* self = new (ELeave) CCmdMultipleWait();
	CleanupStack::PushL(self);
	self->ConstructL(aCommandParameters);
	CleanupStack::Pop(self);
	return self;
	}

/**
Used to create an instance of CCmdMultipleWait class from CCmdMultipleWait object
Must be used only by CLE
@param aCmdMultipleWait CCmdMultipleWait reference 
@param aDeferredCommands TArray<MSsmCommand*> reference 
@return A pointer to an object of type CCmdMultipleWait.
*/
CCmdMultipleWait* CCmdMultipleWait::NewLC(const CCmdMultipleWait& aCmdMultipleWait, TArray<MSsmCommand*>& aDeferredCommands)
    {
#ifdef SYMBIAN_SSM_FLEXIBLE_MERGE
    CCmdMultipleWait* self = new (ELeave) CCmdMultipleWait(aCmdMultipleWait.Timeout(),aCmdMultipleWait.Priority());
#else
    CCmdMultipleWait* self = new (ELeave) CCmdMultipleWait(aCmdMultipleWait.Timeout());
#endif
    CleanupStack::PushL(self);
    self->ConstructL(aCmdMultipleWait, aDeferredCommands);
    return self;
    }

void CCmdMultipleWait::ConstructL(const CCmdMultipleWait& aCmdMultipleWait, TArray<MSsmCommand*>& aDeferredCommands)
    {
    iConditionalResourceId = aCmdMultipleWait.ConditionalInformation();
#ifdef SYMBIAN_SSM_FLEXIBLE_MERGE
	if (iConditionalResourceId != 0)
        {
        SetCommandResourceFileNameL(aCmdMultipleWait.GetCommandResourceFileName());
        } 
#endif
    const TInt count = aDeferredCommands.Count();
    for (TInt i = 0; i < count; i++)
        {
        iDeferredCommands.AppendL(aDeferredCommands[i]);
        }
    ConstructL();   // Constructs the timer
    }

/**
Returns the version of the BIC
@return		The maximum supported version of the BIC
*/
TInt CCmdMultipleWait::MaxSupportedVersion()
	{
#ifdef SYMBIAN_SSM_FLEXIBLE_MERGE
	return (static_cast<TInt>(ECmdMultipleWaitVersionWithPriority));
#else
	return (static_cast<TInt>(ECmdMultipleWaitInitialVersion));
#endif //SYMBIAN_SSM_FLEXIBLE_MERGE
	}

/**
Destructor
*/
CCmdMultipleWait::~CCmdMultipleWait()
	{
	Cancel();
	iDeferredCommands.Close();
	delete iMultipleWaitTimer;
	}

/**
Execute this command
@param aStatus 	The TRequestStatus which is completed when value is set either 
				with KErrNone or with error value.
*/
void CCmdMultipleWait::Execute(TRequestStatus& aStatus)
	{
	aStatus = KRequestPending;
	iExecuteRequest = &aStatus;

	if (0 == iDeferredCommands.Count())
		{
		DEBUGPRINT1A("Deferred command list is empty, Multiple wait completing request with KErrNone");
		CompleteExecuteRequest(KErrNone);
		}
	else 
		{
		iCommandIndex = 0;	// start processing with first command in deferred command list
		MoveToNextState(EStateCheckCompletionStatus);
		}
	}

/**
Releases resources associated with this BIC
*/
void CCmdMultipleWait::Release()
	{
	delete this;
	}

/**
Cancels the BIC
*/
void CCmdMultipleWait::ExecuteCancel()
	{
	//cancel the outstanding request
	Cancel();
	//and complete the request with KErrCancel
	CompleteExecuteRequest(KErrCancel);
	}

/**
Returns the type of the BIC
@return Type of BIC
*/
TSsmCommandType CCmdMultipleWait::Type() const
	{
	return (ESsmCmdMultipleWait);
	}

/**
Externalises the configuration of the BIC
@param aWriteStream A write stream to write BIC data to
*/
void CCmdMultipleWait::ExternalizeL(RWriteStream& aWriteStream) const
	{
	aWriteStream.WriteInt32L(iTimeout);
#ifdef SYMBIAN_SSM_FLEXIBLE_MERGE
	aWriteStream.WriteUint16L(iPriority);
#endif //SYMBIAN_SSM_FLEXIBLE_MERGE
	}

/**
Handles command's request completion event.
@panic EInvalidRunLAction if the RunL action is invalid
*/
void CCmdMultipleWait::RunL()
	{
	switch (iInternalState)
		{
		case EStateCheckCompletionStatus:
			{
			CheckCompletion();
			break;
			}
		case EStateTakeAction:
			{
			// pending command is completed so take the proper action
			TakeProperAction();
			// and process remaining deferred commands
			iCommandIndex++;
			MoveToNextState(EStateCheckCompletionStatus);
			break;
			}
		case EStateTimerExpired:
			{
			// multiple wait will not consider the severity in this case,
			// it will just complete the request with KErrTimedOut.
			if (iExecuteRequest && (iExecuteRequest->Int() == KRequestPending))
				{
				CompleteRequest(*iExecuteRequest, KErrTimedOut);
				}
			iExecuteRequest = NULL;

			break;
			}
		default:
			{
			PanicNow(KPanicCmdMultipleWait, EInvalidRunLAction);
			break;
			}
		}
	}

/**
Cancellation of an outstanding request.
*/
void CCmdMultipleWait::DoCancel()
	{
	Cleanup();
	}

/**
Complete the command request with aError. It gets called when RunL leaves.

@param aError Error code with which RunL has left.
@return KErrNone as error is handled in this function.
*/
TInt CCmdMultipleWait::RunError(TInt aError)
	{
	DEBUGPRINT2A("CCmdMultipleWait::RunError called with reason %d", aError);
	CompleteExecuteRequest(aError);
	return KErrNone;
	}

/**
Helper function to check the completion code of a deferred command and move to the next state.
*/
void CCmdMultipleWait::CheckCompletion()
	{
	TInt count = iDeferredCommands.Count();
	for ( ; iCommandIndex < count; iCommandIndex++)
		{
		DEBUGPRINT2A("Processing command %d", iCommandIndex);
		MSsmCommand* cmd = iDeferredCommands[iCommandIndex];
		// Severity of multiple wait should be same as the current command,
		iSeverity = cmd->Severity();
		if (cmd->CompletionStatus() == KSsmCommandPending)
			{
			// Register for the command completion and wait for command to complete
			DEBUGPRINT2A("Command %d is pending, Register for completion", iCommandIndex);
			SetActive();
			iInternalState = EStateTakeAction;
			cmd->RegisterCompletionObserver(iStatus);
			//start timer if not yet started
			if (iMultipleWaitTimer && !iMultipleWaitTimer->IsActive())
				{
				if (iTimeout > 0)
					{
					DEBUGPRINT2A("Timer started for %d milliseconds", iTimeout);
					iMultipleWaitTimer->StartTimer(iTimeout * KMultipleWaitMilliToMicro);
					}
				}
			break;
			}
		else 
			{
			TakeProperAction();
			}
		}
	// processed all deferred command so complete the request
	if (iCommandIndex == count)
		{
		DEBUGPRINT1A("All commands processed!!!");
		CompleteExecuteRequest(iCommandError);
		}
	}

/**
Helper function to take the proper action and move to the next state.
*/
void CCmdMultipleWait::TakeProperAction()
	{
	MSsmCommand* cmd = iDeferredCommands[iCommandIndex];
	iCommandError = cmd->CompletionStatus();
	DEBUGPRINT4A("Pending command %d completed with error %d and Severity is %d", iCommandIndex, iCommandError, cmd->Severity());
	if (iCommandError != KErrNone && iSeverity != ECmdIgnoreFailure)
		{
		// means command has failed which has severity other then ECmdIgnoreFailure
		//cancel all pending commands if any
		Cleanup();
		CompleteExecuteRequest(iCommandError);
		}
	else 
		{
		// ignore the error if command has ECmdIgnoreFailure severity
		iCommandError = KErrNone;
		}
	}

#ifdef SYMBIAN_SSM_FLEXIBLE_MERGE
/**
Overloaded CTOR
@param aTimeout Timeout for this command
@param aPriority The priority for the command
*/
CCmdMultipleWait::CCmdMultipleWait( TInt32 aTimeout, const TUint16 aPriority)
	:iTimeout(aTimeout)
	{
	iPriority = aPriority;
	}
#endif //SYMBIAN_SSM_FLEXIBLE_MERGE

/**
Overloaded CTOR
@param aTimeout Timeout for this command
*/
CCmdMultipleWait::CCmdMultipleWait( TInt32 aTimeout)
	: iTimeout(aTimeout)
	{
	}

/**
Default CTOR
*/
CCmdMultipleWait::CCmdMultipleWait()
	{
	}

/**
Construct the command object with deferred commands and readstream.
@param aDeferredCommands List of deferred commands.
@param aReadStream Readstream containing data for this BIC.
*/
void CCmdMultipleWait::ConstructL(TArray<MSsmCommand*>&  aDeferredCommands, RReadStream& aReadStream)
	{
	TInt count = aDeferredCommands.Count();
	
	for (TInt i = 0; i < count; i++)
		{
		iDeferredCommands.AppendL(aDeferredCommands[i]);
		}
	InternalizeL(aReadStream);
	}

/**
Constructs an object from resource file.
@param aCommandParameters Object data from a resource file
*/
void CCmdMultipleWait::ConstructL(TSsmCommandParameters& aCommandParameters)
	{
	RResourceReader& reader = aCommandParameters.MainReader();
	const TSsmCommandType type = static_cast<TSsmCommandType>(reader.ReadInt16L());
	SSMLOGLEAVEIFFALSE(type == Type(), KErrNotSupported);
	const TInt version = reader.ReadInt16L();
	SSMLOGLEAVEIFFALSE(__COMPARE_VERSION(version, CCmdMultipleWait::MaxSupportedVersion()), KErrNotSupported);
	iTimeout = reader.ReadInt32L();
#ifdef SYMBIAN_SSM_FLEXIBLE_MERGE
	iPriority = (version > ECmdMultipleWaitInitialVersion) ? reader.ReadUint16L() : KDefaultCommandPriority;
#endif
	}

void CCmdMultipleWait::ConstructL()
	{
	iMultipleWaitTimer = CMultipleWaitTimer::NewL(*this);
	}
/**
Helper function to move to the next action.
@param aNextState Next action to be taken.
*/
void CCmdMultipleWait::MoveToNextState(TStates aNextState)
	{
	DEBUGPRINT2A("CCmdMultipleWait Moving to next state : %d", aNextState);
	iInternalState = aNextState;

	TRequestStatus* status = &iStatus;
	User::RequestComplete(status, KErrNone);
	SetActive();
	}

/**
Helper function to handle the timeout.
*/
void CCmdMultipleWait::HandleTimeoutCallback()
	{
	DEBUGPRINT1A("Timer has expired");
	Cleanup();

	iInternalState = EStateTimerExpired;
	if (iMultipleWaitTimer)
		{
		iMultipleWaitTimer->Cancel();
		}
	}

void CCmdMultipleWait::Cleanup()
	{
	// cancel all pending deferred commands, 
	// starting from the current command in the list
	TInt count = iDeferredCommands.Count();
	if (iCommandIndex < count && iCommandIndex >= 0)
		{
		MSsmCommand* cmd = iDeferredCommands[iCommandIndex];
		if (cmd)
			{
			DEBUGPRINT1A("Cancel  completion observer");
			cmd->RegisterCompletionObserverCancel();
			}

		for (; iCommandIndex < count; iCommandIndex++)
			{
			cmd = iDeferredCommands[iCommandIndex];
			if (KSsmCommandPending == cmd->CompletionStatus())
				{
				DEBUGPRINT2A("Cancelling command %d ", iCommandIndex);
				iDeferredCommands[iCommandIndex]->ExecuteCancel();				
				}
			}		
		}
	}

/**
Configures the BIC using data contained in a ReadStream
@param aReadStream 	A read stream containing BIC data
*/
void CCmdMultipleWait::InternalizeL(RReadStream& aReadStream)
	{
	iTimeout = aReadStream.ReadInt32L();
#ifdef SYMBIAN_SSM_FLEXIBLE_MERGE
	iPriority = aReadStream.ReadUint16L();
#endif
	}

CCmdMultipleWait::CMultipleWaitTimer* CCmdMultipleWait::CMultipleWaitTimer::NewL(CCmdMultipleWait& aMultipleWaitCmd)
	{
	CMultipleWaitTimer* self = new (ELeave) CMultipleWaitTimer(aMultipleWaitCmd);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

CCmdMultipleWait::CMultipleWaitTimer::~CMultipleWaitTimer()
	{
	Cancel();
	}

void CCmdMultipleWait::CMultipleWaitTimer::StartTimer(TInt32 aTimeout)
	{
	After(aTimeout);
	}

void CCmdMultipleWait::CMultipleWaitTimer::RunL()
	{
	iMultipleWaitCmd.HandleTimeoutCallback();
	}

void CCmdMultipleWait::CMultipleWaitTimer::ConstructL()
	{
	CTimer::ConstructL();
	}

CCmdMultipleWait::CMultipleWaitTimer::CMultipleWaitTimer(CCmdMultipleWait& aMultipleWaitCmd)
	: CTimer(EPriorityStandard), iMultipleWaitCmd(aMultipleWaitCmd)
	{
	CActiveScheduler::Add(this);
	}