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

#include "MSVSTORE.H"

#include "MSVUTILS.H"

#include <mmsvstoremanager.h>

const TInt KMsvFlatBufferChunkSize=0x400;

enum TCMsvCachedStorePanic {

	EReadingWhileCommitingStream=1,

	EReadingWhileCommitingStore=2,

	EReadingOrWritingWhileRevertingStore=3,

	EReadingOrWritingWhileDeleteStream=4

	};

_LIT(KCachedStorePanic, "CMsvCachedStore");

void Panic(TCMsvCachedStorePanic aPanic)

	{

	User::Panic(KCachedStorePanic,aPanic);

	}

class HMsvReadBuf : public TMemBuf

	{

public:

	HMsvReadBuf(const TDesC8 &aBuf, CMsvCachedStore &aStore);

private:

	virtual void DoRelease();

private:

	CMsvCachedStore &iCachedStore;

	};

class HMsvWriteBuf : public TBufBuf

	{

public:

	static HMsvWriteBuf* NewL(TUid aUid,CMsvCachedStore& aStore);

private:

	HMsvWriteBuf(TUid aUid,CMsvCachedStore& aStore);

	virtual void DoRelease();

	virtual void DoSynchL();

private:

	CBufBase*        iBuf;

	CMsvCachedStore* iStore;

	TUid			 iUid;

	};

const TUid KMsvEntryFile={0x10003C68};

TPairedTUidHBufC8::TPairedTUidHBufC8() : iBuf(NULL) {}

void TPairedTUidHBufC8::ExternalizeL(RWriteStream &aStream) const

	{

	aStream << iUid;

	aStream << *iBuf;

	}

void TPairedTUidHBufC8::InternalizeL(RReadStream &aStream)

	{

	aStream >> iUid;

	// the 0x1000000 means that it will return KErrCorrupt

	// if the file says it contains a string of longer than 16 meg

	iBuf=HBufC8::NewL(aStream,0x1000000);

	}

CMsvCachedStore* CMsvCachedStore::OpenL(TMsvId aId, MMsvStoreManager& aStoreManager, TBool aReadOnly)

	{

	CMsvCachedStore* me = new(ELeave) CMsvCachedStore(aId, aStoreManager);

	CleanupStack::PushL(me);

	me->ConstructL(aReadOnly);

	CleanupStack::Pop(me);

	return(me);

	}

CMsvCachedStore::CMsvCachedStore(TMsvId aId, MMsvStoreManager& aStoreManager)

	: iEntryId(aId), iStoreManager(aStoreManager)

	{

	}

void CMsvCachedStore::ConstructL(TBool aReadOnly)

	{

	iStreams=new(ELeave) CArrayFixFlat<TPairedTUidHBufC8>(5);

	RFile storeFile;

	TInt err = iStoreManager.OpenFileStoreForRead(iEntryId, storeFile);

	if( err != KErrNotFound )

		{

		if( err==KErrNone )

			LoadL(storeFile); // the load takes ownership of the RFile

		else

			User::Leave(err);

		}

	else if(aReadOnly)

		User::Leave(err);

	}

TInt CMsvCachedStore::Size() const

	{

	return iSize;

	}

void CMsvCachedStore::DeleteL()

	{

#if (defined SYMBIAN_MESSAGESTORE_HEADER_BODY_USING_SQLDB)

	if(iHeaderFieldList.Count())

		{

		iStoreManager.DeleteHeaderEntryL(iMtmId, iEntryId);

		}	

#endif

	iStoreManager.DeleteFileStoreL(iEntryId);

	}

#if (defined SYMBIAN_MESSAGESTORE_HEADER_BODY_USING_SQLDB)

CMsvCachedStore* CMsvCachedStore::OpenL(TMsvId aId, MMsvStoreManager& aStoreManager, TBool aReadOnly,TUid aMtmId)

	{

	CMsvCachedStore* me = new(ELeave) CMsvCachedStore(aId, aStoreManager);

	CleanupStack::PushL(me);

	me->ConstructDBL(aReadOnly,aMtmId);

	CleanupStack::Pop(me);

	return(me);

	}

void CMsvCachedStore::ConstructDBL(TBool aReadOnly,TUid aMtmId)

	{

	iStreams=new(ELeave) CArrayFixFlat<TPairedTUidHBufC8>(5);

	RFile storeFile;

	TInt err = iStoreManager.OpenFileStoreForRead(iEntryId, storeFile);

	if(err != KErrNotFound)

		{

		if( err==KErrNone )

			{

			LoadL(storeFile); // the load takes ownership of the RFile

			if(aReadOnly)

				isNewEntry = EFalse;

			else

				isNewEntry = ETrue;

			TRAP_IGNORE(LoadHeaderEntryL(aMtmId,aReadOnly));

			}

		else

			{

			User::Leave(err);

			}

		}

	else 

		{

		TRAPD(err2, LoadHeaderEntryL(aMtmId,aReadOnly));

		if (err2 == KErrNotFound)

				{

				User::Leave(err);

				}

		}

	isDbStore=iStoreManager.DoesHeaderTableExist(aMtmId);	

	}

/**

Assign the  header Fields in to header Field list.

@param aHeaderFields : CHeaderFields*

@return None.

*/

void CMsvCachedStore::AssignL(CHeaderFields* aHeaderFields)

	{

	TUid uid = aHeaderFields->iUid;

	for(TInt index=0; index<iHeaderFieldList.Count(); index++)

		{

		if(iHeaderFieldList[index]->iUid == uid)

			{

			delete iHeaderFieldList[index];

			iHeaderFieldList[index] = aHeaderFields;

			return;

			}		

		}

	iHeaderFieldList.AppendL(aHeaderFields);

	}

/**

Get the header Fields for respective UID.

@param aUid : A Uid

@param aHeaderFields : CHeaderFields*&

@return None.

*/

void CMsvCachedStore::GetHeaderL(TUid aUid, CHeaderFields*& aHeaderFields)

	{

	for(TInt index=0; index<iHeaderFieldList.Count(); index++)

		{

		if(iHeaderFieldList[index]->iUid == aUid)

			{

			aHeaderFields = iHeaderFieldList[index];

			return;

			}	

		}

	User::Leave(KErrNotFound);

	}

/**

Load the Header Entry .

@param aMtmId A Mtm TUid.

@return None.

@internalComponent

*/

void CMsvCachedStore::LoadHeaderEntryL(const TUid aMtmId,TBool aReadOnly)

	{

	TRAPD (err ,iStoreManager.LoadHeaderEntryL(aMtmId, iEntryId, iHeaderFieldList));

	if((err == KErrNotFound) && aReadOnly)

		{

		User::Leave(err);

		}

	if(err == KErrNotFound)

		{

		isNewEntry = ETrue;

		iSize = 0;

		}

	else

		{

		isNewEntry = EFalse;

		if(err == KErrNone)

			{

			for(TInt index=0; index<iHeaderFieldList.Count(); index++)

				{

				for(TInt i =0 ; i < (iHeaderFieldList)[index]->iFieldPairList.Count() ;i++ )

					{

					if(((iHeaderFieldList)[index]->iFieldPairList[i]->iFieldTextValue) != NULL)

						iSize += (iHeaderFieldList)[index]->iFieldPairList[i]->iFieldTextValue->Length();

					}

				}

			}

		else

			{

			User::Leave(err);	

			}

		}

	}

#endif

/**

The CMsvCachedStore::Remove method

Removes the stream from the array, ignores the fact that

it might not exist.

@internalAll

@param				 aUid	Stream to remove

*/

void CMsvCachedStore::Remove(TUid aUid)

	{

#if (defined SYMBIAN_MESSAGESTORE_HEADER_BODY_USING_SQLDB)

	for(TInt index=0; index<iHeaderFieldList.Count(); index++)

		{

		if( (iHeaderFieldList)[index]->iUid == aUid )

			{

			iHeaderFieldList.Remove(index);

			TRAP_IGNORE(iStoreManager.UpdateHeaderEntryL(iMtmId, iEntryId, iHeaderFieldList)); 

			return;

			}

		}	

#endif

	DeleteStream(aUid);

	}

/**

The CMsvCachedStore::RemoveL method

Removes a stream from the array, leaves if the stream is not found

@leave 

@internalAll

@param				 aUid	Stream to remove

*/

void CMsvCachedStore::RemoveL(TUid aUid)

	{

	User::LeaveIfError(DeleteStream(aUid));

	}

/**

The CMsvCachedStore::Revert method

Reloads the array of streams from the store

ignores errors that might occur.

@internalAll

*/

void CMsvCachedStore::Revert()

	{

     TRAP_IGNORE(RevertL());

	}

/**

The CMsvCachedStore::RevertL method

  Reloads the streams from the file

@leave

@internalAll

*/

void CMsvCachedStore::RevertL()

	{

	__ASSERT_ALWAYS(iReaderCount==0 && iWriterCount==0, Panic(EReadingOrWritingWhileRevertingStore));

	CleanArray();

	iStreams=new(ELeave) CArrayFixFlat<TPairedTUidHBufC8>(5);

	RFile storeFile;

	User::LeaveIfError(iStoreManager.OpenFileStoreForRead(iEntryId, storeFile));

	LoadL(storeFile); // the load takes ownership of the RFile	

	}

/**

The CMsvCachedStore::Commit method

  Saves the current state of the stream array to the file

@return			error

@internalAll

*/

TInt CMsvCachedStore::Commit() 

	{

	TRAPD(error,CommitL());

	return(error);

	}

/**

The CMsvCachedStore::CommitL method

  Saves the current state of the stream array to the file

  leaves with if error occurs

@leave

@internalAll

*/

void CMsvCachedStore::CommitL()

	{

	__ASSERT_ALWAYS(iWriterCount==0,Panic(EReadingWhileCommitingStore));

	SaveL();

	}

void CMsvCachedStore::CleanArray()

	{

	if(iStreams!=NULL)

		{

		TInt count=iStreams->Count();

		while(count--) delete iStreams->At(count).iBuf;

		}

	delete iStreams;

	iStreams=NULL;

	}

/**

The CMsvCachedStore::~CMsvCachedStore method

@internalAll

*/

CMsvCachedStore::~CMsvCachedStore()

	{

#if (defined SYMBIAN_MESSAGESTORE_HEADER_BODY_USING_SQLDB)

	iHeaderFieldList.ResetAndDestroy();

	iHeaderFieldList.Close();

#endif

	CleanArray();

	}

TBool CMsvCachedStore::IsNullL() const

	{

#if (defined SYMBIAN_MESSAGESTORE_HEADER_BODY_USING_SQLDB)

	if(iStreams->Count()==0)

		{

		if(iHeaderFieldList.Count() ==0)

			{

			return ETrue;

			}

		else

			{

			return EFalse;

			}

		}

	else

		{

		return EFalse;

		}

#else

	return(iStreams->Count()==0);

#endif

	}

/**

The CMsvCachedStore::IsPresentL method

  checks to see if the stream is in the array

@return		ETrue if it exists EFalse if not.

@internalAll

@param				 aUid	stream to check for

*/

TBool CMsvCachedStore::IsPresentL(TUid aUid) const

	{

#if (defined SYMBIAN_MESSAGESTORE_HEADER_BODY_USING_SQLDB)

	for(TInt index=0; index<iHeaderFieldList.Count(); index++)

		{

		if(iHeaderFieldList[index]->iUid == aUid)

			{

			return ETrue;

			}

		}

#endif 	

	TInt pos;

	if(FindStream(aUid,pos)==KErrNone) return(ETrue);

	else return(EFalse);

	}

/**

The CMsvCachedStore::CreateOrReplaceStreamL method

  If a stream is present with this id it replaces the

  data in that stream with aBuf, otherwise it adds a new

  stream with the data in aBuf

@internalAll

@param				 aUid	stream id

@param				 *aBuf	data, takes ownership

*/

void CMsvCachedStore::CreateOrReplaceStreamL(TUid aUid, CBufBase &aBuf)

	{

	__ASSERT_ALWAYS(iReaderCount==0, Panic(EReadingWhileCommitingStream));

	TInt pos;

	HBufC8* buffer=FlattenLC(aBuf);

	if(FindStream(aUid,pos)==KErrNone)

		{

		delete iStreams->At(pos).iBuf;

		iStreams->At(pos).iBuf=buffer;

		}

	else

		{

		TPairedTUidHBufC8 entry;

		entry.iUid=aUid;

		entry.iBuf=buffer;

		iStreams->InsertL(pos,entry);

		}

	CleanupStack::Pop(buffer);

	}

HBufC8* CMsvCachedStore::FlattenLC(CBufBase &aBuf)

	{

	TInt size=aBuf.Size();

	HBufC8 *buffer=HBufC8::NewLC(size);

	TPtr8 ptr(buffer->Des());

	RDesWriteStream writer(ptr);

	RBufReadStream reader(aBuf);

	writer.WriteL(reader,size);

	writer.CommitL();

	return(buffer);

	}

/**

The CMsvCachedStore::GetStream method

  If it returns with KErrNone it sets aData to point to the

  data in the store this id

@return			error code if the stream was not found

@internalAll

@param				 aUid	stream id

@param				 *&aData	returned pointer to data

*/

HBufC8* CMsvCachedStore::GetStreamL(TUid aUid) const

	{

	TInt pos;

	if(FindStream(aUid, pos) != 0)

		User::Leave(KErrNotFound);

	return iStreams->At(pos).iBuf;

	}