// Copyright (c) 2002-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 "LogServOperationQueue.h"

// User includes
#include "logservpanic.h"
#include "LogServOperationBase.h"
#include "LogServTaskInterface.h"


/////////////////////////////////////////////////////////////////////////////////////////
// -----> CLogServOperationQueue (source)
/////////////////////////////////////////////////////////////////////////////////////////

CLogServOperationQueue::CLogServOperationQueue(MLogServTaskInterface& aTaskInterface, TInt aPriority)
:	CActive(aPriority),
	iTaskInterface(aTaskInterface),
	iQueuePending(CLogServOperationBase::QueueOffset()),
	iQueueCompleted(CLogServOperationBase::QueueOffset())
	{
	CActiveScheduler::Add(this);
	}

CLogServOperationQueue::~CLogServOperationQueue()
	{
	Cancel();
	//
	CLogServOperationBase* item = NULL;
	//
	TSglQueIter<CLogServOperationBase> pendingIterator(iQueuePending);
	while ((item = pendingIterator++) != NULL)
		{
		delete item;
		}
	//
	TSglQueIter<CLogServOperationBase> completedIterator(iQueueCompleted);
	while ((item = completedIterator++) != NULL)
		{
		delete item;
		}
	}

CLogServOperationQueue* CLogServOperationQueue::NewL(MLogServTaskInterface& aTaskInterface, TInt aPriority)
	{
	CLogServOperationQueue* self = new(ELeave) CLogServOperationQueue(aTaskInterface, aPriority);
	return self;
	}

/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////

void CLogServOperationQueue::OMOperationQueueAdd(CLogServOperationBase& aOp)
//
//	Add a new event to the queue and restart processing if necessary
//
	{
	LOGTEXT3("CLogServOperationQueue::OMOperationQueueAdd() - Type: %d, Id: %d", aOp.Type(), aOp.Id());
	//
	iQueuePending.AddLast(aOp);
	if	(!IsActive())
		CompleteRequest();
	//
	LOGTEXT("CLogServOperationQueue::OMOperationQueueAdd() - end");
	}

//
//	Removes an operation from the relevant server queue
//
void CLogServOperationQueue::OMOperationQueueRemove(CLogServOperationBase& aOperation)
	{
	const TLogOperationId operationId = aOperation.Id();
	const TLogServSessionId sessionId = aOperation.SessionId();
	//
	LOGTEXT3("CLogServOperationQueue::OMOperationQueueRemove() - Id: %d, SessionId: %d", operationId, sessionId);
	//
	if(QueueContainsOperation(iQueuePending, operationId, sessionId))
		{
		iQueuePending.Remove(aOperation);
		}
	else
		{
		iQueueCompleted.Remove(aOperation);
		}
	//
	LOGTEXT("CLogServOperationQueue::OMOperationQueueRemove() - end");
	}

void CLogServOperationQueue::OMGetResultL(TLogOperationId aId, TLogServSessionId aSessionId, const RMessage2& aMessageToWriteTo)
//
//	Get the result of a specific operation
//
	{
	LOGTEXT3("CLogServOperationQueue::OMGetResultL() - Id: %d, SessionId: %d", aId, aSessionId);

	// Look for the op
	CLogServOperationBase* op = FindOperation(iQueueCompleted, aId, aSessionId);

	// If we found it, then return the result
	if	(op != NULL)
		{
		op->WriteL(aMessageToWriteTo);
		delete op;
		}
	//
	LOGTEXT("CLogServOperationQueue::OMGetResultL() - end");
	}

void CLogServOperationQueue::OMCancel(TLogOperationId aOpId, TLogServSessionId aSessionId, TBool aCompleteRequest)
//
//	Cancel a specific operation
//
	{
	LOGTEXT4("CLogServOperationQueue::OMCancel() - Id: %d, SessionId: %d, CompleteRequest: %d", aOpId, aSessionId, aCompleteRequest);

	if	(iCurrentOperation && iCurrentOperation->SessionId() == aSessionId && (aOpId == KLogNullOperationId || iCurrentOperation->Id() == aOpId))
		{
		// We need to cancel the current active operation because it belongs to this session
		//
		// This should complete the request with KErrCancel causing RunL to leave
		// RunError completes the request and removes the operation from the pending queue
		iTaskInterface.TaskCancelCurrent();

		//
		// Do not complete the message when the operation completes
		//
		if (!aCompleteRequest)
			{
			iCurrentOperation->SetMessageCompletion(aCompleteRequest);
			}
		}
	else
		{
		// The active operation doesn't belong to this session - just remove any relevant operations from the queues
		//
		// We are taking advantage of the fact that a session will only ever have one operation outstanding
		// so a cancel request basically means - cancel everything belonging to the session
		CLogServOperationBase* op = NULL;
		while((op = FindOperation(iQueuePending, aOpId, aSessionId)) != NULL)
			{
			if	(aCompleteRequest)
				{
				op->Cancel();
				}

			// The operation dequeues itself from the containing queue in its destructor via
			// the MLogServOperationManager abstract interface.
			delete op;

			// We can exit now if we were looking for a particular operation
			if	(aOpId > KLogNullOperationId)
				{
				return;
				}
			}

		// Just delete the completed operation
		DeleteFromQueue(iQueueCompleted, aOpId, aSessionId);
		}
	//
	LOGTEXT("CLogServOperationQueue::OMCancel() - end");
	}

//
//	Stop/cancel and delete all operations belonging to a particular session
//	If the session has just died we don't want to complete the request - the kernel would panic us
//
void CLogServOperationQueue::OMCancel(TLogServSessionId aSessionId, TBool aCompleteRequest)
	{
	OMCancel(KLogNullOperationId, aSessionId, aCompleteRequest);
	}

/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////

void CLogServOperationQueue::RunL()
//
//	Called to indicate that the operation has completed - so complete the client request
//
	{
	LOGTEXT2("CLogServOperationQueue::RunL(%d)", iStatus.Int());

	// If the queue has just been restarted there won't be an existing operation
	if (iCurrentOperation)
		{
		LOGTEXT3("CLogServOperationQueue::RunL() - Current operation Type: %d, Id: %d,", iCurrentOperation->Type(), iCurrentOperation->Id());

		// Handle errors in RunError
		User::LeaveIfError(iStatus.Int());

		// Remember the type of operation for later
		const TLogOperationType type = iCurrentOperation->Type();

		// Complete the operation
		if	(iCurrentOperation->CompleteProcessingL(iStatus.Int()) == CLogServOperationBase::EOperationComplete)
			{
			LOGTEXT("CLogServOperationQueue::RunL() - Operation is complete, deleting it");
			delete iCurrentOperation;
			iCurrentOperation = NULL;
			}
		else
			{
			// The client is going to ask for some results.
			//
			// Move the operation to another queue until it's done
			// The session will actually delete the operation
			LOGTEXT("CLogServOperationQueue::RunL() - Operation result awaiting client fetch");
			iQueuePending.Remove(*iCurrentOperation);
			iQueueCompleted.AddLast(*iCurrentOperation);
			}

		// Any errors from maintenance will be ignored because the operation is null
		iCurrentOperation = NULL;

		LOGTEXT("CLogServOperationQueue::RunL() - Starting maintenance");
		iTaskInterface.TaskMaintenanceStartL(iStatus, type != ELogOperationEventGet);
		SetActive();
		}
	else
		{
		LOGTEXT("CLogServOperationQueue::RunL() - finding next operation");

		// Start the next operation
		StartNextOpL();
		}

	LOGTEXT("CLogServOperationQueue::RunL() - end");
	}

void CLogServOperationQueue::DoCancel()
//
//	Implements cancel policy. Only called if the maintenance is active?
//
	{
	iTaskInterface.TaskCancelCurrent();
	}

TInt CLogServOperationQueue::RunError(TInt aError)
//
//	Handle errors
//
	{
	LOGTEXT2("CLogServOperationQueue::RunError(%d)", aError);

	if	(iCurrentOperation)
		{
		LOGTEXT3("CLogServOperationQueue::RunError() - Current operation Type: %d, Id: %d,", iCurrentOperation->Type(), iCurrentOperation->Id());

		// Fail the client request with the error
		if	(iCurrentOperation->HaveMessagePointer())
			iCurrentOperation->Complete(aError);
		delete iCurrentOperation;
		iCurrentOperation = NULL;
		}

	// Restart by mending the database if necessary
	TRAPD(mendError, iTaskInterface.TaskMaintenanceStartL(iStatus, ETrue));
	if	(mendError)
		{
		LOGTEXT2("CLogServOperationQueue::RunError() - mend error: %d)", mendError);

		// Just ignore the maintenance error and complete ourselves so we continue to execute operations
		CompleteRequest(KErrNone);
		}
	else
		{
		LOGTEXT("CLogServOperationQueue::RunError() - setting active again");
		SetActive();
		}

	LOGTEXT("CLogServOperationQueue::RunError() - end");
	return KErrNone;
	}

void CLogServOperationQueue::CompleteRequest(TInt aCompletionCode)
	{
	TRequestStatus* status = &iStatus;
	User::RequestComplete(status, aCompletionCode);
	SetActive();
	}

void CLogServOperationQueue::StartNextOpL()
//
//	Start the next operation on the queue
//
	{
	LOGTEXT("CLogServOperationQueue::StartNextOpL()");

	iCurrentOperation = NULL;
	if (!IsActive() && !iQueuePending.IsEmpty())
		{
		iCurrentOperation = iQueuePending.First();

		LOGTEXT3("CLogServOperationQueue::StartNextOpL() - New next operation, Type: %d, Id: %d", iCurrentOperation->Type(), iCurrentOperation->Id());

		iCurrentOperation->StartL(iStatus);
		SetActive();
		}

	LOGTEXT("CLogServOperationQueue::StartNextOpL() - end");
	}

void CLogServOperationQueue::DeleteFromQueue(TSglQue<CLogServOperationBase>& aQueue, TLogOperationId aOperationId, TLogServSessionId aSessionId)
//
//	Delete all operations belonging to a particular session from a queue
//
	{
	LOGTEXT3("CLogServOperationQueue::DeleteFromQueue() - aId: %d, aSessionId: %d", aOperationId, aSessionId);

	CLogServOperationBase* op = NULL;
	while((op = FindOperation(aQueue, aOperationId, aSessionId)) != NULL)
		{
		delete op;

		// We can exit now if we were looking for a particular operation
		if	(aOperationId > KLogNullOperationId)
			{
			LOGTEXT("CLogServOperationQueue::DeleteFromQueue() - operation found successfully");
			return;
			}
		}

#ifdef LOGGING_ENABLED
	if	(aOperationId != KLogNullOperationId)
		{
		LOGTEXT2("CLogServOperationQueue::DeleteFromQueue() - operation id '%d' wasn't found!", aOperationId);
		}
#endif

	LOGTEXT("CLogServOperationQueue::DeleteFromQueue() - end");
	}

TBool CLogServOperationQueue::QueueContainsOperation(TSglQue<CLogServOperationBase>& aQueue, TLogOperationId aOperationId, TLogServSessionId aSessionId)
//
//	Finds an operation in a queue
//
	{
	LOGTEXT3("CLogServOperationQueue::QueueContainsOperation() - aId: %d, aSessionId: %d", aOperationId, aSessionId);

	TSglQueIter<CLogServOperationBase> iter(aQueue);
	CLogServOperationBase* item = NULL;
	
	while ((item = iter++) != NULL)
		{
		if	(item->Id() == aOperationId && item->SessionId() == aSessionId)
			{
			LOGTEXT("CLogServOperationQueue::QueueContainsOperation() - operation found within queue");
			return ETrue;
			}
		}
	
	LOGTEXT("CLogServOperationQueue::QueueContainsOperation() - queue doesn't contain operation");
	return EFalse;
	}

CLogServOperationBase* CLogServOperationQueue::FindOperation(TSglQue<CLogServOperationBase>& aQueue, TLogOperationId aOperationId, TLogServSessionId aSessionId)
//
//	Find the first operation in a queue belonging to a particular session
//
	{
	LOGTEXT3("CLogServOperationQueue::FindOperation() - aId: %d, aSessionId: %d", aOperationId, aSessionId);

	TSglQueIter<CLogServOperationBase> iter(aQueue);
	CLogServOperationBase* item = NULL;
	
	while ((item = iter++) != NULL)
		{
		if	(item->SessionId() == aSessionId && (aOperationId == KLogNullOperationId || item->Id() == aOperationId))
			{
			LOGTEXT("CLogServOperationQueue::FindOperation() - operation found successfully");
			return item;
			}
		}

	LOGTEXT("CLogServOperationQueue::FindOperation() - operation not found");
	return NULL;	
	}