// Copyright (c) 2008-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 <ssm/ssmswppolicy.h>

#include "ssmdebug.h"
#include "ssmserverpanic.h"
#include "clesessionproxy.h"
#include "ssmswptransitionengine.h"
#include "ssmswptransitionscheduler.h"
#include "ssmswpindividualtransitionscheduler.h"


//
//Construction/Destruction
//


/**
Create a scheduler
*/
CSsmSwpIndividualTransitionScheduler* CSsmSwpIndividualTransitionScheduler::NewLC(TUint aSwpKey, MCleSessionProxy* aCleSession, CSsmSwpTransitionScheduler& aParent)
	{
	CSsmSwpIndividualTransitionScheduler* self = new (ELeave) CSsmSwpIndividualTransitionScheduler(aSwpKey, aParent);
	CleanupStack::PushL(self);
	self->ConstructL(aCleSession);
	return self;
	}

void CSsmSwpIndividualTransitionScheduler::ConstructL(MCleSessionProxy* aCleSession)
	{
	// Need to create an individual CLE session proxy for each transition scheduler
	iCleSession = aCleSession->CreateNewProxyL();
	
	// Need to create an individual swppolicy session for each transition scheduler
	iSsmSwpPolicySession = CSsmSwpPolicyCliSession::NewL();
	}

CSsmSwpIndividualTransitionScheduler::CSsmSwpIndividualTransitionScheduler(TUint aSwpKey, CSsmSwpTransitionScheduler& aParent)
	: 	CActive(CActive::EPriorityStandard),
		iSchedulerState(EIdle),
		iSwpKey(aSwpKey),
		iParent(aParent)
	{
	CActiveScheduler::Add(this);
	}

/**
Deactivate
Destroy queue
*/
CSsmSwpIndividualTransitionScheduler::~CSsmSwpIndividualTransitionScheduler()
	{
	CActive::Cancel();
	__ASSERT_DEBUG(iTransitionQueue.Count() == 0, PanicNow(KPanicSysStateMgr,ESwpTransitionSchedulerError1));
	DestroyTransitionQueue();
	if(iCleSession)
		{
		iCleSession->Close();
		iCleSession->ReleaseCle();
		iCleSession = NULL;
		}
	if(iSsmSwpPolicySession)
		{
		delete iSsmSwpPolicySession;
		}
	}

/**
Take ownership of the transition engine and prepare to run it
@param aEngine - the engine to run
*/
void CSsmSwpIndividualTransitionScheduler::SubmitL(CSsmSwpTransitionEngine* aEngine)
	{
	if(!aEngine)
		{
		SSMLOGLEAVE(KErrArgument); //lint !e527 Suppress Unreachable. Lint is just confused by macro, warning goes away when code in macro gets expanded
		}
	// Change aEngine to having the cle proxy from this scheduler
	// This allows multiple SwP transitions
	aEngine->SetCleSessionProxy(iCleSession);

	// Change aEngine to have the SsmSwpPolicySession from this scheduler. i.e, same SsmSwpPolicySession
	// instance will be used for the all the individual Swp transitions.(the same swp policy session would be used).
	// This allows multiple SwP transitions
	aEngine->SetSsmSwpPolicySession(iSsmSwpPolicySession);
	DoSubmitL(aEngine);
	}

void CSsmSwpIndividualTransitionScheduler::Cancel(CSession2* aSession)
	{
	//Cancel all queued requests that originates from aSession
	CancelTransitionQueue(aSession);

	// Cancel iCurrentTransition if it originates from aSession && still possible to Cancel (i.e. not started)
	if(CurrentTransitionOriginatesFrom(aSession) && !iCurrentTransition->InTransition())
		{
		iCancellingSession = aSession;
		CActive::Cancel();
		iCancellingSession = NULL;

		//We cancelled the currently running engine, see if there is anything left in the queue
		iCurrentTransition = GetNextFromQueue();
		if(iCurrentTransition != NULL) // we have more
			{
			ScheduleTransition();
			}
		}
	}

TBool CSsmSwpIndividualTransitionScheduler::CurrentTransitionOriginatesFrom(CSession2* aSession)
	{
	return (iCurrentTransition != NULL) && (iCurrentTransition->OriginatingSesssion() == aSession);
	}

TUint CSsmSwpIndividualTransitionScheduler::SwpKey() const
	{
	return iSwpKey;
	}

TBool CSsmSwpIndividualTransitionScheduler::IsIdle() const
	{
	return iTransitionQueue.Count() == 0 && iCurrentTransition == NULL;
	}

//
// from CActive
//

/**
Cancel running transition if any and destroy any transition in the queue that originates from the cancelling session
*/
void CSsmSwpIndividualTransitionScheduler::DoCancel()
	{
	// Cancel the running transition if it originates from the calling session
	if(CurrentTransitionOriginatesFrom(iCancellingSession))
		{
		iCurrentTransition->Cancel();
		delete iCurrentTransition;
		iCurrentTransition = NULL;
		}
	}

/**
The only valid event at the moment is completion of engine for any reason.
Except few errors (for example, when a transition is not allowed),
most of the unexpected transition errors are identified and dealt in the engine. 
Notes: Tries to start the next engine even if there was an error.
*/
void CSsmSwpIndividualTransitionScheduler::RunL()
	{
	if(KErrNone == iStatus.Int())
		{
		NotifyTransitionCompleted();
		}
	else
		{
		NotifyTransitionFailed();
		}

	// try to start the next transition
	delete iCurrentTransition;
	iCurrentTransition = NULL;
	iCurrentTransition = GetNextFromQueue();
	if(iCurrentTransition != NULL) // we have more
		{
		ScheduleTransition();
		}
	}

/**
Log an error occured

@param aError the error

*/
TInt CSsmSwpIndividualTransitionScheduler::RunError(TInt aError)
	{
	(void)aError;
	DEBUGPRINT2(_L("CSsmSwpIndividualTransitionScheduler leave detected in RunL, error: %d"), aError);
	PanicNow(KPanicSysStateMgr,ESwpTransitionSchedulerError5);
	return KErrNone;
	}

//
// private: methods
//

/**
Start a transition if none is running, otherwise put it into the queue

@param aEngine the transition engine to submit
@leave one of the system wide error codes if insert fails

*/
void CSsmSwpIndividualTransitionScheduler::DoSubmitL(CSsmSwpTransitionEngine* aEngine)
	{
	if(IsActive())
		{
		// add to Queue
		iTransitionQueue.InsertL(aEngine, 0);
		NotifyTransitionQueued();
		}
	else
		{
		// start immediately
		__ASSERT_DEBUG(iCurrentTransition == NULL,  PanicNow(KPanicSysStateMgr,ESwpTransitionSchedulerError2));
		iCurrentTransition = aEngine;
		ScheduleTransition();
		}
	}

/**
Start the transition running and make it current

@param aEngine the transition engine to submit
@leave one of the system wide error codes
*/
void CSsmSwpIndividualTransitionScheduler::ScheduleTransition()
	{
	__ASSERT_DEBUG(!IsActive() && IsAdded(), PanicNow(KPanicSysStateMgr,ESwpTransitionSchedulerError3));
	__ASSERT_DEBUG(iCurrentTransition != NULL, PanicNow(KPanicSysStateMgr,ESwpTransitionSchedulerError4));

	iCurrentTransition->Submit(iStatus);
	NotifyTransitionStarted();
	SetActive();
	}

/**
Retrieve the next transition engine from the queue
return NULL if the queue is empty

@return - the next transition engine or NULL
*/
CSsmSwpTransitionEngine* CSsmSwpIndividualTransitionScheduler::GetNextFromQueue()
	{
	TInt nextPos = iTransitionQueue.Count() - 1;
	if(nextPos < 0) // Q empty
		{
		return NULL;
		}
	CSsmSwpTransitionEngine* ret = iTransitionQueue[nextPos];
	iTransitionQueue.Remove(nextPos);
	return ret;
	}

/**
Remove and delete all queue entries, cancel any pending entries
*/
void CSsmSwpIndividualTransitionScheduler::DestroyTransitionQueue()
	{
	const TInt count = iTransitionQueue.Count();
	for(TInt i=0; i<count; i++)
		{
		iTransitionQueue[i]->CompleteClientMessage(KErrCancel);
		}
	iTransitionQueue.ResetAndDestroy();
	}

/**
Cancel, remove and delete all queue entries originating from aSession
*/
void CSsmSwpIndividualTransitionScheduler::CancelTransitionQueue(CSession2* aSession)
	{
	TInt count = iTransitionQueue.Count();
	while(count--)
		{
		CSsmSwpTransitionEngine* engine = iTransitionQueue[count];
		if( engine && (engine->OriginatingSesssion() == aSession) )
			{
			engine->CompleteClientMessage(KErrCancel);
			iTransitionQueue.Remove(count);
			delete engine;
			}
		}
	}

/**
Notify the monitor (if set) that one of the transition events has occured
*/
void CSsmSwpIndividualTransitionScheduler::NotifyTransitionQueued()
	{
	iParent.NotifyTransitionQueued();
	}

void CSsmSwpIndividualTransitionScheduler::NotifyTransitionStarted()
	{
	iParent.NotifyTransitionStarted();
	}

void CSsmSwpIndividualTransitionScheduler::NotifyTransitionCompleted()
	{
	DEBUGPRINT1(_L("ERequestSwpChange Completed"));
	iParent.NotifyTransitionCompleted();
	}

void CSsmSwpIndividualTransitionScheduler::NotifyTransitionFailed()
	{
	DEBUGPRINT1(_L("Error: ERequestSwpChange Failed"));
	iParent.NotifyTransitionFailed();
	}