// Copyright (c) 1999-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:
//

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
#include "vwsinternal.h"
#include "vwsdefpartner.h"
#endif //SYMBIAN_ENABLE_SPLIT_HEADERS
#include "VWSQUEUE.H"


//
// CVwsEventQueue.
//

CVwsEventQueue::CVwsEventQueue() 
	{
	}

#ifdef __DO_LOGGING__
CVwsEventQueue::CVwsEventQueue(const TDesC& aName) : iQueueName(aName)
	{
	}

void CVwsEventQueue::SetName(const TDesC& aName)
	{
	iQueueName=aName;
	}
#endif

CVwsEventQueue::~CVwsEventQueue()
	{
	do
		{
		delete Head();
		}
	while (RemoveHead() == KErrNone);
	}

void CVwsEventQueue::ProcessEventL(CVwsEvent* aEvent)
	{
	TInt err=AddToTail(aEvent);
	if(err!=KErrNone)
		{
		if(aEvent!=NULL)
			{
			delete aEvent;
			aEvent=NULL;
			}
		User::Leave(err);
		}

	if (aEvent)
		{
		switch (iState)
			{
			case EEmpty:
				{
				iState=EProcessing;
				TRAPD(err,aEvent->ProcessEventL());
				if (err)
					{
					DeleteHead();
					iState=EEmpty;
					}
				User::LeaveIfError(err);
				}
				break;
			case EProcessing:
				// Wait until current event has finished being processed.
				break;
			default:
				ASSERT(EFalse);
			}
		}
	}

void CVwsEventQueue::HandleEventProcessed()
	{
	if (iQueueSize==1)
		{
		Head()->HandleLastOnQueue();
		DeleteHead();
		LOG3(CVwsLog::ELoud,_L("Completed event at head of %S, queue empty"),&iQueueName);
		iState=EEmpty;
		}
	else if (iQueueSize>0)
		{
		DeleteHead();
		LOG4(CVwsLog::ELoud,_L("Completed event at head of %S, processing next [queue size %d]"),&iQueueName,iQueueSize);
		// Start processing next event in the queue.
		TInt err=KErrGeneral;
		while (iQueueSize>0 && err)
				{
				TRAP(err, Head()->ProcessEventL());
				if (err)
					{
					DeleteHead();
					if (0==iQueueSize)
						{
						iState=EEmpty;
						}
					}
				}
		}
	}

CVwsEvent* CVwsEventQueue::Head() const
	{
	if (iQueueSize==0)
		return NULL;

	return iQueue[iQueueStart];
	}

CVwsEvent* CVwsEventQueue::Tail() const
	{
	if (iQueueSize==0)
		return NULL;

	return iQueue[(iQueueEnd+KQueueSize-1)%KQueueSize];
	}

TInt CVwsEventQueue::Count() const
	{
	return iQueueSize;
	}

void CVwsEventQueue::DeleteHead()
	{
	delete Head();
	RemoveHead();
	}

void CVwsEventQueue::HandleSessionRemoval(const TThreadId& aClientThreadId)
	{
	if (iQueueSize>0)
		{
		LOG4(CVwsLog::ELoud,_L("Session removed - handling removal in head event of %S [queue size %d]"),&iQueueName,iQueueSize);
		Head()->HandleSessionRemoval(aClientThreadId);
		}
	}

TInt CVwsEventQueue::AddToTail(CVwsEvent*& aEvent)
	{
	switch (aEvent->Type())
		{
		case CVwsEvent::ENormal:
			return DoAddToTail(aEvent);
		case CVwsEvent::ERejectPairs:
			return AddToTailIfNotPair(aEvent);
		default:
			ASSERT(EFalse);
			return KErrGeneral;
		}
	}

TInt CVwsEventQueue::RemoveHead()
	{
	if (iQueueSize>0)
		{
		iQueue[iQueueStart]=NULL;
		iQueueStart=(iQueueStart+1)%KQueueSize;
		iQueueSize--;
		return KErrNone;
		}

	return KErrUnderflow;
	}

TInt CVwsEventQueue::DoAddToTail(CVwsEvent* aEvent)
	{
	if (iQueueSize<KQueueSize)
		{
		iQueue[iQueueEnd]=aEvent;
		iQueueEnd=(iQueueEnd+1)%KQueueSize;
		iQueueSize++;
		aEvent->HandleAddedToQueue();
		LOG4(CVwsLog::ELoud,_L("Added event to tail of %S [queue size %d]"),&iQueueName,iQueueSize);
		return KErrNone;
		}

	return KErrOverflow;
	}

TInt CVwsEventQueue::AddToTailIfNotPair(CVwsEvent*& aEvent)
	{
	if (iQueueSize==0)
		{
		// Nothing in queue, so safe to add.
		return DoAddToTail(aEvent);
		}

	// Check for type match in queue.
	if (iQueueSize>2)
		{
		if ((Tail()->Type()==aEvent->Type()) && (At(iQueueSize-2)->Type()==aEvent->Type()) && (At(iQueueSize-3)->Type()==aEvent->Type()))
			{
			LOG3(CVwsLog::ENormal,_L("Discarded event - one already in %S"),&iQueueName);
			delete aEvent;
			aEvent=NULL;
			return KErrNone;
			}
		}

	// No match, do add to tail.
	return DoAddToTail(aEvent);
	}

CVwsEvent* CVwsEventQueue::At(TInt aIndex)
	{
	CVwsEvent* event=NULL;

	if (aIndex<iQueueSize)
		{
		event=iQueue[(iQueueStart+aIndex)%KQueueSize];
		}

	return event;
	}

void CVwsEventQueue::KickStart()
	{
	//Attempt to restart stalled q
	DeleteHead();
	iState=EEmpty;
	TInt err = KErrGeneral;
	while(iQueueSize>0 && err)
		{
		iState=EProcessing;
		TRAP(err, Head()->ProcessEventL());
		if (err)
			{
			DeleteHead();
			iState=EEmpty;
			}
		}
	}

//
// CVwsEvent.
//

CVwsEvent::CVwsEvent(TType aType,CVwsEventQueue& aQueue)
	:iType(aType),iQueue(aQueue)
	{
	}

CVwsEvent::~CVwsEvent()
	{
	}

CVwsEvent::TType CVwsEvent::Type()
	{
	return iType;
	}

void CVwsEvent::ReportEventProcessed()
	{
	iQueue.HandleEventProcessed();
	}

void CVwsEvent::HandleAddedToQueue()
	{
	}

void CVwsEvent::HandleLastOnQueue()
	{
	}

void CVwsEvent::HandleSessionRemoval(const TThreadId& /*aClientThreadId*/)
	{
	}