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

//

/**

 @file

 @internalComponent

 @released

*/

#include "cntviewprivate.h"

#include "CViewSubSessions.h"

#include "CCntIpcCodes.h"

#include "CCntDbManager.h"

#include "CCntServer.h"

#include <cntviewstore.h>

#include "CCntLogger.h"

#include "CCntStateMachine.h"

extern void DebugLogViewNotification(const TDesC& aMethod, const TContactViewEvent& aEvent);

CViewSubSessionQueue::CViewSubSessionQueue()

	{

	}

CViewSubSessionQueue::~CViewSubSessionQueue()

	{

	iEvents.Close();

	}

void CViewSubSessionQueue::QueueEvent(const TContactViewEvent& aEvent)

	{

	const TInt KInvalidValueForRemoteView = -1;

	TBool haveToAddEventInQueue = ETrue;

 	if (iRequestPending)

 		{

		if(aEvent.iEventType == TContactViewEvent::EItemAdded)

			{

			// is this first event sent? If yes and if the event is an 

			// EItemAdded event send first a fake event. 

			// This is because all EItemAdded should be sorted before send them

			TContactViewEvent event;

			event.iEventType = TContactViewEvent::EItemAdded;

			event.iContactId = KInvalidValueForRemoteView;

			event.iInt = KInvalidValueForRemoteView;

			SendEventL(event);

			}

		else

			{

			SendEventL(aEvent);

			haveToAddEventInQueue = EFalse;

			}

 		}

	if (haveToAddEventInQueue  && !iQueueError)

		{

		// There are two requirements for this queue of events:

		// 1. The iInt values for events in the Q at any given point in time

		//    should match the index of the underlying localview array. i.e If the addition/removal

		//    of a contact has caused the position of other contacts items to change in the underlying localview

		//    then previous events sent by them in this Q will have old iInt values and these need to be corrected.

		// 2. When the client gets these events in order, it should have a valid view after every event,

		//    ie. if we have 2 additions, at positions 0 and 1, 

		//    we cannot send the event for addition at position 1 before the addition at position 0.

		//	

		// These requirements are fulfilled using the following algorithm.

		// Events are inserted in the queue using following two condition

		// 1. EItemAdded -

		//    1.1 Find if an existing EItemAdded events iInt is greater or equal with incoming events iInt.

		//        if found,insert event before the found one and increment the iInt of the rest event by 1

		//    1.2 if no match is found with same iInt, modify its iInt value with incoming events iInt, 

		//        then append to the event queue.

		//	  1.3 If no EItemAdded events are in queue, append this one to Queue.

		// 2. EItemRemoved -

		//    2.1 Find if an existing EItemAdded events iInt matches with incoming EItemRemoved events iInt.

		//        if found, then remove that EItemAdded event from the Queue and decrement rest of the 

		//        events iInt by 1.

		//    2.2 if no match is found with same iInt, then insert the event before next greater iInt event

		//        and then decerement the iInt value of rest of the event by 1.

		//	  2.3 if no events greater than this  then append this one to Queue.

		TContactViewEvent event;

		event.iEventType = aEvent.iEventType;

		event.iContactId = aEvent.iContactId;

		event.iInt = aEvent.iInt;		

		TInt eventsCount = iEvents.Count();		

		TUint pos=0;		

		if( event.iEventType == TContactViewEvent::EItemAdded )

			{	

			TInt lastItemRemovedPosition = KErrNotFound;

			//first check if this add event is not generated by a contact item change

			for( pos=0; pos<eventsCount; ++pos ) 

				{

				if( iEvents[pos].iContactId == aEvent.iContactId && 

							iEvents[pos].iEventType == TContactViewEvent::EItemRemoved )

					{

					lastItemRemovedPosition = pos;

					}

				}

			if( lastItemRemovedPosition != KErrNotFound ) 

				{

				++lastItemRemovedPosition;

				if(lastItemRemovedPosition < eventsCount)

					{

					for( pos = lastItemRemovedPosition-1; pos < eventsCount;++pos ) 

						{

						if(iEvents[pos].iInt >= aEvent.iInt && 

								iEvents[pos].iContactId != aEvent.iContactId)

							{

							if( iEvents[pos].iEventType == TContactViewEvent::EItemRemoved || iEvents[pos].iEventType == TContactViewEvent::EItemAdded)  

								{

								iEvents[pos].iInt++;

								}

							}

						}

					iQueueError = iEvents.Insert(aEvent, lastItemRemovedPosition);		

					}

				else

					{

					iQueueError = iEvents.Append(aEvent);	

					}

				}

			else

				{				

				TBool haveToAppendEvent = ETrue; 			

				for( pos=0; pos<eventsCount; ++pos ) 

					{

					if(iEvents[pos].iEventType == TContactViewEvent::EItemAdded)

						{

						if(iEvents[pos].iInt >= event.iInt)

							{

							iQueueError = iEvents.Insert(event, pos);

							eventsCount=iEvents.Count();

							for(TUint loop=pos+1; loop<eventsCount; ++loop)

								{

								if( iEvents[pos].iEventType == TContactViewEvent::EItemRemoved || iEvents[pos].iEventType == TContactViewEvent::EItemAdded)

									{

									iEvents[loop].iInt++;

									}

								}						

							haveToAppendEvent = EFalse;										

							break;

							}				

						}

					}

				if( haveToAppendEvent )

					{

					iQueueError = iEvents.Append(event);

				 	}

				}

			}

		else 

			{

			iQueueError = iEvents.Append(event);	

			}

		DEBUG_PRINTVN2(__VERBOSE_DEBUG__,_L("[CNTMODEL] CViewSubSessionQueue::QueueEvent(): ->Q:"), event);

		}

	}

void CViewSubSessionQueue::RequestEvent(const RMessage2& aMessage)

	{

	__ASSERT_DEBUG(!iRequestPending,User::Leave(KErrAlreadyExists)); // can only leave in debug mode

	if (!iRequestPending)

		{

		iMessage=aMessage;

		iRequestPending=ETrue;

		if (iQueueError)

			{

			TContactViewEvent errorEvent(TContactViewEvent::EServerError,iQueueError);

			iQueueError=KErrNone;

			SendEventL(errorEvent);

			}

		else if (iEvents.Count()>0)

			{

			SendEventL(iEvents[0]);

			iEvents.Remove(0);

			}

		}

	}

void CViewSubSessionQueue::CancelEventRequest()

	{

	if (iRequestPending)

		{

		iMessage.Complete(KErrCancel);

		iRequestPending=EFalse;

		}

	}

/**

Send contact view event.

@leave KErrNotFound In debug mode only, if there is a queue error.

@leave KErrNotReady In debug mode only, if there is already an existing request still pending.

@leave KErrBadDescriptor If there is a error writing aEvent to the RMessage2 to be sent.

*/

void CViewSubSessionQueue::SendEventL(const TContactViewEvent& aEvent)

	{

	__ASSERT_DEBUG(!iQueueError,User::Leave(KErrNotFound));

	if (!iRequestPending)

		{

		return;

		}

   DEBUG_PRINTVN2(__VERBOSE_DEBUG__,_L("[CNTMODEL] CViewSubSessionQueue::SendEventL(): Q->:"), aEvent);

	TRAPD(err,iMessage.WriteL(KSlot0,TPckgC<TContactViewEvent>(aEvent)));

	if (err)

		{

		iRequestPending=EFalse;

		User::Leave(KErrBadDescriptor);//iMessage is completed in CCntSession::ServiceError()

		}

	else

		{

		iMessage.Complete(KErrNone);

		}

	iRequestPending=EFalse;

	}

/**

Called if derived class ServiceL()'s do not consume the opcode.

*/

TInt CViewSubSessionBase::ServiceL(const RMessage2& aMessage)

	{

	TInt reply(KErrNone);

	switch (aMessage.Function())

		{

		case ECntViewCount:

			CountL(aMessage);

			break;

		case ECntViewAt:

			reply=AtL(aMessage);

			break;

		case ECntViewContactAtLength:

			reply=ContactAtLengthL(aMessage);

			break;

		case ECntViewContactAt:

			ContactAtL(aMessage);

			break;

		case ECntViewFind:

			FindL(aMessage);

			break;

		case ECntAllFieldsLength:

			reply=GetAllFieldsLengthL(aMessage);

			break;

		case ECntAllFieldsText:

			GetAllFieldsTextL(aMessage);

			break;

		case ECntContactMatchingCriteriaExternalizedSize:

			ContactMatchingCriteriaExternalizedSizeL(aMessage);

			break;

		case ECntGetContactMatchingCriteria:

			GetContactMatchingCriteriaL(aMessage);

			break;

		case ECntGetIncludedTypes:

			GetIncludedTypesL(aMessage);

			break;

		case ECntRequestViewEvent:

			RequestViewEvent(aMessage);

			reply=KErrNoComplete;

			break;

		case ECntCancelRequestViewEvent:

			CancelRequestViewEvent();

			break;

		case ECntGetContactIds:

			GetContactIdsL(aMessage);

			break;

		case ECntSendPluginUidToServer:

			SendPluginUidToServer(aMessage);

			break;

		case ECntGetContactsMatchingFilter:

			GetContactsMatchingFilterL(aMessage);

			break;

		case ECntGetSortPluginUidFromServer:

			GetSortPluginUidFromServerL(aMessage);

			break;

		default:

			User::Leave(KErrNotFound);

			break;

		}

	return reply;

	}

CViewSubSessionBase::~CViewSubSessionBase()

	{

	delete iQueue;

	delete iSortableText;

	delete iContact;

	DeleteFindContacts();

	}

CViewSubSessionBase::CViewSubSessionBase(CViewManager& aViewManager) : iViewManager(aViewManager),iContact(0)

	{

	}

void CViewSubSessionBase::ConstructL()

	{

	iQueue = new(ELeave) CViewSubSessionQueue();

	}

void CViewSubSessionBase::CountL(const RMessage2& aMessage) const

	{

	TPckgBuf<TInt> pckg(iView->CountL());

	aMessage.WriteL(0,pckg);

	}

TInt CViewSubSessionBase::AtL(const RMessage2& aMessage) const

	{

	TInt reply = KErrNone;

	const TInt index=aMessage.Int0();

	__ASSERT_ALWAYS(index>=0,User::Leave(KErrUnderflow));

	if(!(index<iView->CountL()))

		{

		// Index is out of bounds.

		reply=KErrNotFound;

		return reply;

		}

	TPckgBuf<TContactItemId> pckg(iView->AtL(index));

	aMessage.WriteL(1,pckg);

	return reply;

	}

void CViewSubSessionBase::ContactAtL(const RMessage2& aMessage) const

	{

	const TInt externalizedSize=iContact->ExternalizedSize();

	HBufC8* buf=HBufC8::NewLC(externalizedSize);

	TPtr8 bufPtr(buf->Des());

	RDesWriteStream writeStream(bufPtr);

	CleanupClosePushL(writeStream);

	writeStream << *iContact;

	bufPtr.SetLength(externalizedSize);

	aMessage.WriteL(0,*buf);

	CleanupStack::PopAndDestroy(2); // writeStream, buf.

	}

/** 

Return the size of the externalized contact data.

@param aMessage.Int0() Index.

@param aMessage.Ptr1() Package buffer to return size.

*/

TInt CViewSubSessionBase::ContactAtLengthL(const RMessage2& aMessage) 

	{

	TInt reply=KErrNone;

	TInt index = aMessage.Int0();

	__ASSERT_ALWAYS(index>=0,User::Leave(KErrUnderflow));

	if(!(index<iView->CountL()))

		{

		// Index is out of bounds.

		reply=KErrNotFound;

		return reply;

		}

	const CViewContact& contact=iView->ContactAtL(index);

	delete iContact;

	iContact=NULL;

	iContact = CViewContact::NewL(contact);

	const TInt externalizedSize=iContact->ExternalizedSize();

	TPckgBuf<TInt> pckg(externalizedSize);

	aMessage.WriteL(1,pckg);

	return reply;

	}

void CViewSubSessionBase::GetIncludedTypesL(const RMessage2& aMessage)

	{

	TPckgBuf<TContactViewPreferences> pckg(iView->ContactViewPreferences());

	aMessage.WriteL(0,pckg);	

	}

void CViewSubSessionBase::DeleteFindContacts()

	{

	iContacts.ResetAndDestroy();

	}

#ifdef _DEBUG

void CViewSubSessionBase::HandleContactViewEvent(const CContactViewBase& aView,const TContactViewEvent& aEvent)

#else

void CViewSubSessionBase::HandleContactViewEvent(const CContactViewBase& /*aView*/,const TContactViewEvent& aEvent)

#endif

	{

	ASSERT(&aView==iView);

	iQueue->QueueEvent(aEvent);

	}

/** 

Match an array of search strings against the contacts in the view.

The descriptor from the client contains a flag at the start to indicate if a

prefix or substring search has been requested.

@param aMessage.Ptr0() Size of contact data to read (to client).

@param aMessage.Int1() Size of descriptor (from client).

@param aMessage.Ptr2() Descriptor (from client).

*/

void CViewSubSessionBase::ContactMatchingCriteriaExternalizedSizeL(const RMessage2& aMessage)

	{

	TPckgBuf<TInt> size;

	aMessage.ReadL(1,size);

	const TInt bufferSize = size();

	// Restore buffer.

	CBufFlat* buffer = CBufFlat::NewL(bufferSize);

	CleanupStack::PushL(buffer);

	buffer->ExpandL(0,bufferSize);

	TPtr8 des(buffer->Ptr(0));

	aMessage.ReadL(2,des);

	// Internalize the data from the stream.

	RBufReadStream readStream(*buffer);

	CleanupClosePushL(readStream);

	TBool prefixSearch = readStream.ReadUint32L(); 

	const TInt numFindWords = readStream.ReadUint32L();

	CPtrC16Array* findDesArray = new(ELeave) CPtrC16Array(numFindWords);

	CleanupStack::PushL(findDesArray);

	TInt findWordLength=0;

	for (TInt i=0; i<numFindWords; ++i)

		{

		findWordLength = readStream.ReadUint32L();

		HBufC* findword = HBufC::NewLC(readStream,findWordLength);

		findDesArray->AppendL(*findword);

		}

	DeleteFindContacts();

	if (prefixSearch)

		iView->ContactsMatchingPrefixL(*findDesArray,iContacts);

	else

		iView->ContactsMatchingCriteriaL(*findDesArray,iContacts);

	findDesArray->Reset();

	CleanupStack::PopAndDestroy(numFindWords);

	CleanupStack::PopAndDestroy(3, buffer);

	// Compute contacts externalized size.

	const TInt contactsCount = iContacts.Count();

	TInt contactsExternalizedSize=0;

	contactsExternalizedSize+=sizeof(TInt32);

	for (TInt jj=0;jj<contactsCount;++jj)

		{

		contactsExternalizedSize+=(iContacts)[jj]->ExternalizedSize();

		}

	TPckgBuf<TInt> pckg(contactsExternalizedSize);

	aMessage.WriteL(0,pckg);

	}

/** 

Write matching contacts back to client.

@param aMessage.Ptr0() Descriptor to write array of matching contacts.

*/

void CViewSubSessionBase::GetContactMatchingCriteriaL(const RMessage2& aMessage)

	{

	// Compute contacts externalized size.

	const TInt contactsCount = iContacts.Count();

	TInt contactsExternalizedSize=0;

	contactsExternalizedSize+=sizeof(TInt32);

	for (TInt jj=0;jj<contactsCount;++jj)

		{

		contactsExternalizedSize+=(iContacts)[jj]->ExternalizedSize();

		}

	HBufC8* buf=HBufC8::NewLC(contactsExternalizedSize);

	TPtr8 bufPtr(buf->Des());

	RDesWriteStream writeStream(bufPtr);

	CleanupClosePushL(writeStream);

	writeStream.WriteUint32L(contactsCount);

	for (TInt ii=0;ii<contactsCount;++ii)

		{

		CViewContact* thisContact = (iContacts)[ii];

		writeStream << *thisContact;

		}

	bufPtr.SetLength(contactsExternalizedSize);

	aMessage.WriteL(0,*buf);

	CleanupStack::PopAndDestroy(2, buf); //writeStream.Close(), buf

	DeleteFindContacts();

	}