// 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 "LogServViewChangeManager.h"
#include <s32mem.h>
#include "logservpanic.h"
#include "LogServDatabaseChangeInterface.h"

// Constants
const TInt KLogServViewChangeDefinitionGranularity = 10;
const TInt KLogServViewChangeQueueGranularity = 3;
const TInt KLogServViewChangeBufferGranularity = 40;


/////////////////////////////////////////////////////////////////////////////////////////
// -----> CLogServViewChangeManager (source)
/////////////////////////////////////////////////////////////////////////////////////////

CLogServViewChangeManager::CLogServViewChangeManager(MLogServDatabaseChangeInterface& aChangeInterface)
:	iChangeInterface(aChangeInterface), iPendingChanges(KLogServViewChangeQueueGranularity)
	{
	}

CLogServViewChangeManager::~CLogServViewChangeManager()
	{
	delete iTransientChangeDefinition;
	//
	iPendingChanges.ResetAndDestroy();
	iPendingChanges.Close();
	}

void CLogServViewChangeManager::ConstructL()
	{
	iTransientChangeDefinition = CLogChangeDefinition::NewL(KLogServViewChangeDefinitionGranularity);
	}

CLogServViewChangeManager* CLogServViewChangeManager::NewL(MLogServDatabaseChangeInterface& aChangeInterface)
	{
	CLogServViewChangeManager* self = new(ELeave) CLogServViewChangeManager(aChangeInterface);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

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

void CLogServViewChangeManager::ChangeTransactionPrepare()
	{
	iTransientChangeDefinition->Reset();
	}

void CLogServViewChangeManager::ChangeTransactionSubmitL(TLogId aId, TLogDatabaseChangeType aType, TInt aViewIndex)
	{
	iTransientChangeDefinition->AddL(aId, aType, aViewIndex);
	}

void CLogServViewChangeManager::ChangeTransactionCommitL()
	{
	// We can only tell the client-side view change observer about the changes if:
	//
	// (2) we actually have something to tell the client views (some changes)
	// (3) we have an outstanding client-side change message pointer
	//
	const TInt count = iTransientChangeDefinition->Count();
	if	(count > 0) // (2)
		{
		// Do we have any existing pending changes? We can't alter the contents of the
		// first pending change, since the client may already be preparing a client-side
		// buffer of the requisite size. We can, however, combine the 2nd batch of changes
		// with this new set so there is less IPC required (although more memory).
		const TInt pendingChangeCount = iPendingChanges.Count();
		if	(pendingChangeCount >= 2)
			{
			CLogChangeDefinition* changeDef = CLogChangeDefinition::NewL();
			CleanupStack::PushL(changeDef);
			//
			CBufBase* buffer = iPendingChanges[1];
			RBufReadStream readStream(*buffer);
			//
			readStream >> *changeDef;
			
			// Add new changes
			TLogId logId = KLogNullId;
			TLogDatabaseChangeType type = ELogChangeTypeUndefined;
			TInt viewIndex = 0;
			//
			for(TInt i=0; i<count; i++)
				{
				type = iTransientChangeDefinition->At(i, logId, viewIndex);
				changeDef->AddL(logId, type, viewIndex);
				}

			// Write the whole lot out again
			buffer->Delete(0, buffer->Size());

			RBufWriteStream writeStream(*buffer);
			writeStream << *changeDef;
			buffer->Compress();
			CleanupStack::PopAndDestroy(changeDef);
			}
		else
			{
			CBufBase* buffer = CBufFlat::NewL(KLogServViewChangeBufferGranularity);
			CleanupStack::PushL(buffer);

			// Externalize changes
			RBufWriteStream stream(*buffer);
			stream << *iTransientChangeDefinition; 
			buffer->Compress();

			// Add to container
			User::LeaveIfError(iPendingChanges.Append(buffer));
			CleanupStack::Pop(buffer);
			}

		// Notify if necessary - handles (3) implicitly
		NotifyClient();
		}

	// Free some memory
	iTransientChangeDefinition->Reset();
	}

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

void CLogServViewChangeManager::DeliverChangesL(const RMessage2& aMessage)
	{
	if	(iPendingChanges.Count())
		{
		CBufBase* headItem = iPendingChanges[0];
		//
		const TInt expectedChangesSize = aMessage.Int1();
		const TPtr8 pBufferContents(headItem->Ptr(0));

		// Check buffer size is as we expect
		if	(expectedChangesSize != pBufferContents.Size())
			::PanicClientL(aMessage, ELogViewBadClientSideChangeBufferSize);
		else
			{
			// Write back to client-side
			aMessage.WriteL(2, pBufferContents);

			// Remove the item
			iPendingChanges.Remove(0);
			delete headItem;
			}
		}
	else
		::PanicClientL(aMessage, ELogViewNoPendingChangesToDeliver);
	}

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

void CLogServViewChangeManager::RequestChangeNotifications(const RMessage2& aMessage)
	{
    if	(iClientSideChangeMessage == RMessagePtr2())
		{
		// Notify if we have any cached changes...
		iClientSideChangeMessage = aMessage;
		NotifyClient();
		}
	else
		PanicClient(aMessage, ELogViewChangeRequestAlreadyIssued);
	}

void CLogServViewChangeManager::RequestChangeNotificationsCancel()
	{
    if	(iClientSideChangeMessage != RMessagePtr2())
		CompleteClientChangeMessage(KErrCancel);

	// Zap all the pending changes too
	iPendingChanges.ResetAndDestroy();
	iPendingChanges.GranularCompress();
	}

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

void CLogServViewChangeManager::NotifyClient()
	{
	const TInt count = iPendingChanges.Count();
    if	(iClientSideChangeMessage != RMessagePtr2() && count)
		{
		CBufBase* headItem = iPendingChanges[0];
		const TInt messageSize = headItem->Size();
		CompleteClientChangeMessage(messageSize);
		}
	}

void CLogServViewChangeManager::CompleteClientChangeMessage(TInt aCompletionCode)
	{
	__ASSERT_ALWAYS(iClientSideChangeMessage != RMessagePtr2(), Panic(ELogViewNoClientChangeMessageOutstanding));
	iClientSideChangeMessage.Complete(aCompletionCode);
	}