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

#include "agmutil.h"

#include "agmentry.h"

#include "agmdebug.h"

#include <s32stor.h>

CAgnEntryManager::CAgnEntryManager()

//

// Constructor

//

	:iNextAvailableGeneralStreamId(KNullStreamId),

	iNextAvailableTodoStreamId(KNullStreamId),

	iNextAvailableRptStreamId(KNullStreamId),

	iCurrentGeneralStreamId(KNullStreamId),

	iCurrentTodoStreamId(KNullStreamId),

	iCurrentRptStreamId(KNullStreamId),

	iGeneralBufferHasBeenStored(EFalse),

	iTodoBufferHasBeenStored(EFalse),

	iRptBufferHasBeenStored(EFalse),

	iBufferHasBeenStored(EFalse),

	iBufferedDeleting(EFalse)

	{ 

	}

CAgnEntryManager* CAgnEntryManager::NewL()

//

// Create a CAgnEntryManager object

//

	{

	CAgnEntryManager* Self=new(ELeave)CAgnEntryManager();

	CleanupStack::PushL(Self);

	Self->iGeneralBuffer=new(ELeave) CBuffer(TAgnEntryId::EMaxNumEntriesPerStream);

	Self->iTodoBuffer=new(ELeave) CBuffer(TAgnEntryId::EMaxNumEntriesPerStream);

	Self->iRptBuffer=new(ELeave) CBuffer(TAgnEntryId::EMaxNumEntriesPerStream);

	Self->iIteratorBuffer=new(ELeave) CBuffer(TAgnEntryId::EMaxNumEntriesPerStream);

	CleanupStack::Pop();

	return (Self);

	}

CAgnEntryManager::~CAgnEntryManager()

//

// Destructor 

//

	{

	if (iGeneralBuffer)

		{

		FreeBuffer(EGeneral);

		delete iGeneralBuffer;

		}

	if (iTodoBuffer)

		{

		FreeBuffer(ETodo);

		delete iTodoBuffer;

		}

	if (iRptBuffer)

		{

		FreeBuffer(ERpt);

		delete iRptBuffer;

		}

	if (iIteratorBuffer)

		{

		FreeBuffer(EIterator);

		delete iIteratorBuffer;

		}

	}

TStreamId CAgnEntryManager::DoAddEntryL(CAgnEntry& aEntry, TStreamId& aCurrentStreamId,

										TStreamId& aNextAvailableStreamId, CBuffer* aBuffer, TBufferType aBufferType)

//

// Add an entry by either adding it to an existing stream or creating a new stream if necessary

//

	{

	if (aNextAvailableStreamId==KNullStreamId)  // create a new stream

		{

		if (aBuffer->Count() > 0) // clear out any previous entries loaded in memory

			FreeBuffer(aBufferType); 

		if (aEntry.EntryId().IsNullId()) // the entry might have already been assigned an id (via NextAvailableIdL)	

			aEntry.SetEntryId(NextAvailableIdL(aBufferType)); // this will create a new stream

		aNextAvailableStreamId = aEntry.EntryId().StreamId();

		CAgnEntry* entry = aEntry.CloneL();

		CleanupStack::PushL(entry);

 		aBuffer->AppendL(TBufItem(entry));

 		CleanupStack::Pop(entry);

		__ASSERT_DEBUG(aBuffer->Count()==1,Panic(EAgmErrOnlyOneEntryAllowedInBuffer));

		TRAPD(ret,StoreBufferL(aNextAvailableStreamId,aBuffer,aBufferType));		

		if (ret!=KErrNone)

			{

			FreeBuffer(aBufferType); 

			User::Leave(ret);

			}

		aCurrentStreamId = aNextAvailableStreamId;

		return (aNextAvailableStreamId);

		}

// else - the entry is to be added to an existing stream:

	TAgnEntryId entryId = NextAvailableIdL(aBufferType);	

	aEntry.SetEntryId(entryId);

	CAgnEntry* entry = aEntry.CloneL();

	CleanupStack::PushL(entry);

	aBuffer->AppendL(TBufItem(entry));

	CleanupStack::Pop(entry);

	TInt ret;

	TRAP(ret,StoreBufferL(entryId.StreamId(),aBuffer,aBufferType));

	if (ret!=KErrNone)

		{

		if (ret!=KErrNoMemory) 

			FreeBuffer(aBufferType);

		else

			{

			aBuffer->Delete(aBuffer->Count()-1); //!!! any reason why not resetanddestroy?

			delete entry;

			}

		User::Leave(ret);

		}

	if (aBuffer->Count()==TAgnEntryId::EMaxNumEntriesPerStream)

		aNextAvailableStreamId = KNullStreamId;

	return (KNullStreamId);	// indicate a new stream wasn't created during the addition 

	}

TStreamId CAgnEntryManager::AddEntryL(CAgnEntry& aEntry)

//

// Stores aEntry into a stream in iStore. If iNextAvailableStreamId is null then this indicates that the entry

// is to be inserted into a brand new stream, otherwise iNextAvailableStreamId should identify an existing stream

// which may contain other entries - if so then they are loaded into memory so that a unique id can be

// assigned to the new entry, the existing entries are then re-written back to the stream along with

// the new entry. The entries' details are kept loaded in memory. 

//

// An entry's id is a TStreamId which contains 28 bits for the stream id and 4 spare bits, it is necessary

// to look at any other entries' 4 bits so that a unique number can be assigned to the new entry.

//

	{

	__ASSERT_DEBUG(iStore,Panic(EAgmErrStreamStoreIsNull));

	if (aEntry.Type()==CCalEntry::ETodo)

		{

		return (DoAddEntryL(aEntry,iCurrentTodoStreamId,iNextAvailableTodoStreamId,iTodoBuffer,ETodo));

		}		

	else

		{

		if (aEntry.RptDef())

			{

			return (DoAddEntryL(aEntry,iCurrentRptStreamId,iNextAvailableRptStreamId,iRptBuffer,ERpt));

			}			

		}

	return (DoAddEntryL(aEntry,iCurrentGeneralStreamId,iNextAvailableGeneralStreamId,iGeneralBuffer,EGeneral));

	}

/**

 Update the details of the existing entry aEntry in the store

 Call SetHowRichTextIsStored() IF its loaded in memory (rich text object will panic otherwise)

 Notes:

 1) Was inline and still is -> simply rewrite to stream

 2) Was outline and still is

		a) its not loaded - can't have changed -> do nothing

		b) its loaded and has changed ->

			i ) delete the store in the child stream

			ii) store components as if it were a new entry

 3) Was inline and now is outline	 -> call StoreComponents

 4) Was outline and now is inline

		a) delete the store

		b) delete the child stream

		c) save as normal

If an entry moves from one stream to another and it was the last entry in the stream then

the id of that stream is returned otherwise KNullStreamId is returned. If when an entry moves

to a new stream the stream was not previoulsy existing then its id is returned via aNewStreamId

which is otherwise KNullStreamId;

@capability ReadUserData

*/

TStreamId CAgnEntryManager::UpdateEntryL(CAgnEntry& aEntry, TStreamId& aNewStreamId)

	{

	__ASSERT_DEBUG(iStore,Panic(EAgmErrStreamStoreIsNull));

	aNewStreamId = KNullStreamId;

	TAgnEntryId entryId = aEntry.EntryId();

	// If the entry isn't already loaded in memory then do so

	TInt pos;

	CAgnEntry* originalEntry=SearchBuffers(entryId,pos);

	if (!originalEntry)

		{	

		RestoreBufferL(entryId.StreamId());

		originalEntry=SearchBuffers(entryId,pos);

		}

	__ASSERT_ALWAYS(originalEntry,User::Leave(KErrNotFound));

	TBufferType type = EGeneral;

	if (originalEntry->Type() == CCalEntry::ETodo)

		type = ETodo;

	else

		{

		if (originalEntry->RptDef())

			type = ERpt;

		}		

	//delete original entry from buffer and add new one then save buffer

 	CAgnEntry* entry = NULL;

	switch (type)

		{

		case EGeneral:

			{

			delete (((*iGeneralBuffer)[pos]).Entry());

			iGeneralBuffer->Delete(pos);

			if (aEntry.RptDef())

				{	// move the entry to the repeat buffer (thus generating a new id)

				TAgnEntryId nullId;

				aEntry.SetEntryId(nullId);

				aNewStreamId = AddEntryL(aEntry);  

				}

			else

				{

				entry = aEntry.CloneL();

				CleanupStack::PushL(entry);

				iGeneralBuffer->AppendL(TBufItem(entry));

  				CleanupStack::Pop();

				}

			if (iGeneralBuffer->Count())

				StoreBufferL(iCurrentGeneralStreamId,iGeneralBuffer,EGeneral);

			else

				{

				iNextAvailableGeneralStreamId = KNullStreamId;

				return (iCurrentGeneralStreamId);

				}

			break;

			}

		case ETodo:

			{

			entry = aEntry.CloneL();

			delete (((*iTodoBuffer)[pos]).Entry());

			(*iTodoBuffer)[pos] = TBufItem(entry);

			StoreBufferL(iCurrentTodoStreamId,iTodoBuffer,ETodo);

			break;

			}

		case ERpt:

			{

			delete (((*iRptBuffer)[pos]).Entry());

			iRptBuffer->Delete(pos);

			if (aEntry.RptDef())

				{

  				entry = aEntry.CloneL();

  				CleanupStack::PushL(entry);

  				iRptBuffer->AppendL(TBufItem(entry));

  				CleanupStack::Pop();

				}

			else

				{ // move the entry to the general buffer (thus generating a new id)

				TAgnEntryId nullId2;

				aEntry.SetEntryId(nullId2);

				aNewStreamId = AddEntryL(aEntry);

				}

			if (iRptBuffer->Count())

				StoreBufferL(iCurrentRptStreamId,iRptBuffer,ERpt);

			else

				{

				iNextAvailableRptStreamId = KNullStreamId;

				return (iCurrentRptStreamId);

				}

			break;

			}

		}

	return (KNullStreamId);

	}

TStreamId CAgnEntryManager::DeleteEntryL(const TAgnEntryId& aEntryId)

//

// Delete the entry identified by aEntryId from the store. If the entry was the last entry in the

// stream then the stream's id is returned otherwise KNullStreamId is returned

//

	{

	__ASSERT_DEBUG(iStore,Panic(EAgmErrStreamStoreIsNull));

	// If the entry isn't already loaded in memory then do so

	TInt pos;

	CAgnEntry* pEntry=SearchBuffers(aEntryId,pos);

	if (!pEntry)

		{

		if (BufferedDeleting())

			{

			if (!iGeneralBufferHasBeenStored && iGeneralBuffer->Count())

				{

				DeleteEntriesInBufferFromStoreL(iGeneralBuffer,iNumGeneralEntriesToDelete);

				__ASSERT_DEBUG(iCurrentGeneralStreamId!=KNullStreamId,Panic(EAgmErrStreamIdIsNull));

				__ASSERT_DEBUG(iGeneralBuffer->Count(),Panic(EAgmErrExpectedEntriesInStore)); // There should have been at least 1 entry left over from the previous deletion

				StoreBufferL(iCurrentGeneralStreamId,iGeneralBuffer,EGeneral);

				SetBufferHasBeenStored(ETrue,EGeneral);

				}

			if (!iTodoBufferHasBeenStored && iTodoBuffer->Count())

				{

				DeleteEntriesInBufferFromStoreL(iTodoBuffer,iNumTodoEntriesToDelete);

				__ASSERT_DEBUG(iCurrentTodoStreamId!=KNullStreamId,Panic(EAgmErrStreamIdIsNull));

				__ASSERT_DEBUG(iTodoBuffer->Count(),Panic(EAgmErrExpectedEntriesInStore)); // There should have been at least 1 entry left over from the previous deletion

				StoreBufferL(iCurrentTodoStreamId,iTodoBuffer,ETodo);

				SetBufferHasBeenStored(ETrue,ETodo);

				}

			if (!iRptBufferHasBeenStored && iRptBuffer->Count())

				{

				DeleteEntriesInBufferFromStoreL(iRptBuffer,iNumRptEntriesToDelete);

				__ASSERT_DEBUG(iCurrentRptStreamId!=KNullStreamId,Panic(EAgmErrStreamIdIsNull));

				__ASSERT_DEBUG(iRptBuffer->Count(),Panic(EAgmErrExpectedEntriesInStore)); // There should have been at least 1 entry left over from the previous deletion

				StoreBufferL(iCurrentRptStreamId,iRptBuffer,ERpt);

				SetBufferHasBeenStored(ETrue,ERpt);

				}

			}

		RestoreBufferL(aEntryId.StreamId());

		pEntry=SearchBuffers(aEntryId,pos);

		}

	__ASSERT_ALWAYS(pEntry,User::Leave(KErrNotFound));

	if (pEntry->Type()==CCalEntry::ETodo)

		return (DoDeleteEntryL(pEntry,iTodoBuffer,iNumTodoEntriesToDelete,iNextAvailableTodoStreamId,iCurrentTodoStreamId,ETodo,pos));

	else

		{

		if (pEntry->RptDef())

			return (DoDeleteEntryL(pEntry,iRptBuffer,iNumRptEntriesToDelete,iNextAvailableRptStreamId,iCurrentRptStreamId,ERpt,pos));

		}

	return (DoDeleteEntryL(pEntry,iGeneralBuffer,iNumGeneralEntriesToDelete,iNextAvailableGeneralStreamId,iCurrentGeneralStreamId,EGeneral,pos));

	}

TStreamId CAgnEntryManager::DoDeleteEntryL(CAgnEntry* aEntry, CBuffer* aBuffer, TInt& aNumEntriesToDelete,

											TStreamId& aNextAvailableStreamId, const TStreamId& aCurrentStreamId,

											TBufferType aBufferType, TInt aPos)

//

// Delete the entry. 

// If the entry was the last entry in a stream then the stream's id is returned otherwise KNullStreamId

// is returned.

//

	{

	TStreamId streamId = aEntry->EntryId().StreamId();

	if (BufferedDeleting())

		{

		((*aBuffer)[aPos]).SetToBeDeleted(ETrue);

		if (++aNumEntriesToDelete == aBuffer->Count())

			{

			__ASSERT_DEBUG(aCurrentStreamId!=KNullStreamId,Panic(EAgmErrStreamIdIsNull));

			DeleteEntriesInBufferFromStoreL(aBuffer,aNumEntriesToDelete);

			__ASSERT_DEBUG(aBuffer->Count()==0,Panic(EAgmErrExpectedEntriesInStore)); // All the entries should have been marked for deletion

			SetBufferHasBeenStored(ETrue,aBufferType); // the removal of a stream is semantically the same as rewriting it

										// with a lesser number of entries - hence the call to SetBufferHasBeenStored

			aNextAvailableStreamId = KNullStreamId;

			return (aCurrentStreamId); // indicate the stream is empty

			}

		else

			SetBufferHasBeenStored(EFalse,aBufferType);

		}

	else

		{

		__ASSERT_DEBUG(aCurrentStreamId!=KNullStreamId,Panic(EAgmErrStreamIdIsNull));

		delete aEntry;

		aBuffer->Delete(aPos);

		if (aBuffer->Count()) // only write back to the stream if it contains entries

			StoreBufferL(aCurrentStreamId,aBuffer,aBufferType);

		else

			{

			SetBufferHasBeenStored(ETrue,aBufferType);

			aNextAvailableStreamId = KNullStreamId;

			return (streamId); // indicate the stream is empty

			}

		}

	return (KNullStreamId);

	}

CAgnEntry* CAgnEntryManager::FetchEntryL(const TAgnEntryId& aEntryId)

//

// Create, restore and return the entry identified by aEntryId. If the entry cannot be found or a problem

// is encountered reading the stream then the function leaves (with KErrNotFound in the former case).

//

	{

	__ASSERT_DEBUG(iStore, Panic(EAgmErrStreamStoreIsNull));

	TInt pos;

	TBool createdEntryFromStream(EFalse);

	CAgnEntry* pEntry = SearchBuffers(aEntryId, pos);

	if ( ! pEntry )

		{

		if ( BufferedDeleting() ) 

		// don't want to restore into the buffer during i.e. merging as this will slow things down dramatically 

			{			

			RStoreReadStream stream;

			stream.OpenLC(*iStore, aEntryId.StreamId());

			TBufferType type = TBufferType(stream.ReadInt8L());

			__ASSERT_ALWAYS(type == EGeneral || type == ETodo || type == ERpt, User::Leave(KErrCorrupt));

			TUint8 entryCount = stream.ReadUint8L();

			__ASSERT_ALWAYS(entryCount <= TAgnEntryId::EMaxNumEntriesPerStream, User::Leave(KErrCorrupt));

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

				{

				pEntry = CAgnEntry::NewL(stream);

				if ( pEntry->EntryId() == aEntryId )

					{

					createdEntryFromStream = ETrue;

					break;

					}

				delete pEntry;

				pEntry = NULL;

				}

			CleanupStack::PopAndDestroy();

			if (createdEntryFromStream)

				{

				CleanupStack::PushL(pEntry);

				}

			}

		else

			{

		   	RestoreBufferL(aEntryId.StreamId());

			pEntry = SearchBuffers(aEntryId, pos);

			}

		}

	// sanity check, if no entry found leave

	__ASSERT_ALWAYS(pEntry, User::Leave(KErrNotFound));

	// allocate a new entry, copy from the found one and return

	CAgnEntry* entry = pEntry->CloneL();

	if (createdEntryFromStream)

		{	

		CleanupStack::PopAndDestroy(pEntry);

		}

	return (entry);

	}

TInt CAgnEntryManager::RestoreBufferL(const TStreamId& aStreamId)

//

// Continuously reads entries from aStream until there are none left, and stores the

// details to an internal data structure.

//

	{

	__ASSERT_DEBUG(iStore,Panic(EAgmErrStreamStoreIsNull));

	RStoreReadStream stream;

	stream.OpenLC(*iStore,aStreamId);

	TBufferType type;

	if(iUseIteratorBuffer)

		{

		//need to read the type from the stream, but ignore it

		stream.ReadInt8L();

		type = EIterator;

		}

	else

		{

		type = TBufferType(stream.ReadInt8L());

		__ASSERT_ALWAYS(type == EGeneral || type == ETodo || type == ERpt,

						User::Leave(KErrCorrupt));

		}

	CBuffer* buffer = NULL;

	switch (type)

		{

		case EGeneral:	iCurrentGeneralStreamId = KNullStreamId;

						buffer = iGeneralBuffer;

						break;

		case ETodo:		iCurrentTodoStreamId = KNullStreamId; 

						buffer = iTodoBuffer;

						break;

		case ERpt:		iCurrentRptStreamId = KNullStreamId; 

						buffer = iRptBuffer;

						break;

		case EIterator:	buffer = iIteratorBuffer;

						break;

		default: 

			{

			_DBGLOG_ENTRY(AgmDebug::DebugLog("Entry Manager: CAgnEntryManager::RestoreBufferL Panic: Invalid Buffer Type - Unknown type");)

			DBG_PANIC(EAgmErrInvalidBufferType);

			}

		}

	TUint8 count = stream.ReadUint8L();

	__ASSERT_ALWAYS(count <= TAgnEntryId::EMaxNumEntriesPerStream,User::Leave(KErrCorrupt));

	FreeBuffer(type);

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