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

// CMsvPlainBodyText.cpp

//

#include <cmsvplainbodytext.h>

#include "CMsvBodyText.h"

#include <mmsvstoremanager.h>

#include "MSVPANIC.H"

#include <txtrich.h>

#include <utf.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS  

#include "msvconsts.h"

#endif

/**

The number of characters that will be converted to Unicode at any one time.

*/

const TInt KMaxDecodeUnicodeLength = 20;

/**

The NewL factory function for Write operation.

@param aMsvStoreManager	 The MMsvStoreManager reference to call Store related RFile APIs

@param aStore 			 The CMsvStore object.

@param aIs8Bit			 TBool indicating whether to store bdy text as 8/16 bit.

@param aCharsetId		 The charset of the body part.

@param aDefaultCharsetId The default charset of the system.

@param aMessageId		 The Id of the message that is to be stored.

@param aFs				 The RFs for handling RFile related operations.

@return CMsvPlainBodyText.

*/

CMsvPlainBodyText* CMsvPlainBodyText::NewL(MMsvStoreManager& aMsvStoreManager, CMsvStore& aStore, TBool aIs8Bit, TUint aCharsetId, TUint aDefaultCharsetId, TMsvId aMessageId, RFs& aFs)

	{

	CMsvPlainBodyText* self = new(ELeave)CMsvPlainBodyText(aMsvStoreManager, aStore, aIs8Bit, aCharsetId, aDefaultCharsetId, aMessageId, aFs);

	CleanupStack::PushL(self);

	self->ConstructWriteL();

	CleanupStack::Pop(self);

	return self;

	}

/**

Overloaded NewL for Read operation.

@param aMsvStoreManager	 The MMsvStoreManager reference to call Store related RFile APIs

@param aStore			 The CMsvStore object.

@param aMessageId		 The Id of the message that is to be stored.

@param aFs				 The RFs for handling RFile related operations.

@param aChunkLength		 The length of the chunk that will be stored/restored in single operaion

@return CMsvPlainBodyText.

*/

CMsvPlainBodyText* CMsvPlainBodyText::NewL(MMsvStoreManager& aMsvStoreManager, CMsvStore& aStore, TMsvId aMessageId, RFs& aFs, TInt aChunkLength)

	{

	CMsvPlainBodyText* self = new(ELeave)CMsvPlainBodyText(aMsvStoreManager, aStore, aMessageId, aFs, aChunkLength);

	CleanupStack::PushL(self);

	self->ConstructReadL();

	CleanupStack::Pop(self);

	return self;

	}

/**

Default Constructor for write operation.

*/

CMsvPlainBodyText::CMsvPlainBodyText(MMsvStoreManager& aMsvStoreManager, CMsvStore& aStore, TBool aIs8Bit, TUint aCharsetId, TUint aDefaultCharsetId, TMsvId aMessageId,RFs& aFs)

: CMsgActive(EPriorityNormal), iMsvStoreManager(aMsvStoreManager), iStore(aStore), iIs8Bit(aIs8Bit), iCharsetId(aCharsetId), iDefaultCharsetId(aDefaultCharsetId), 

  iMessageId(aMessageId), iFSession(aFs), iMsvFileStatus(EMsvFileWriting)

  	{

  	iAvailable = CCnvCharacterSetConverter::ENotAvailable;

    CActiveScheduler::Add(this);

	}

/**

Default Constructor called for Read operation..

*/

CMsvPlainBodyText::CMsvPlainBodyText(MMsvStoreManager& aMsvStoreManager, CMsvStore& aStore, TMsvId aMessageId, RFs& aFs, TInt aChunkLength)

: CMsgActive(EPriorityNormal), iMsvStoreManager(aMsvStoreManager), iStore(aStore), iMessageId(aMessageId), iFSession(aFs), iPos(0), iChunkMaxLength(aChunkLength), 

   iStartPosOfNextChunk(0),  iMsvFileStatus(EMsvFileReading)

	{

	iAvailable = CCnvCharacterSetConverter::ENotAvailable;

	CActiveScheduler::Add(this);

	}

/**

ConstructWriteL for creating and writing to the plain bodytext file.

*/

void CMsvPlainBodyText::ConstructWriteL()

	{

	RMsvWriteStream out;

	if(iIs8Bit)

		{

		out.AssignLC(iStore, KMsvPlainBodyText8);

		out.WriteUint32L(iCharsetId);

		out.WriteUint32L(iDefaultCharsetId);

		}

	else

		{

		out.AssignLC(iStore, KMsvPlainBodyText16);

		}

	// 	iIsCommitted will be EFalse at this point.

	out.WriteUint32L(iIsCommitted);

    TBuf<KFileNameFixedWidth> fileName;

	fileName.NumFixedWidth(iMessageId, EHex, KFileNameFixedWidth);

	out << (TDes&)fileName;

	out.CommitL();

	out.Close();

	iStore.CommitL();

	iMsvStoreManager.CreatePlainTextFileL(iFile, iMessageId);

	iRemainingConvertedData.Create(KMaxDecodeUnicodeLength);

	CleanupStack::PopAndDestroy(&out);

	}

/**

ConstructL for Read operation.

*/

void CMsvPlainBodyText::ConstructReadL()

	{

	// Check whether the data is stored in old-style non-chunk storage mechanism.

	if(iStore.IsPresentL(KMsvEntryRichTextBody) || iStore.IsPresentL(KMsv8BitEncodedBodyData))

		{

		iParaLayer = CParaFormatLayer::NewL();

		iCharLayer = CCharFormatLayer::NewL();

		iRichText = CRichText::NewL(iParaLayer, iCharLayer);

		iStore.RestoreBodyTextL(*iRichText);

		}

	else // Data is stored using the new chunk storage mechanism.

		{

		RMsvReadStream in;

		if(iStore.IsPresentL(KMsvPlainBodyText8))

			{

			in.OpenLC(iStore, KMsvPlainBodyText8);

			iCharsetId = in.ReadUint32L();

			iDefaultCharsetId = in.ReadUint32L();

			iIs8Bit = ETrue;

			}

		else if(iStore.IsPresentL(KMsvPlainBodyText16))

			{

			in.OpenLC(iStore, KMsvPlainBodyText16);

			}

		else

			{

			// The stream is not found.

			User::Leave(KErrNotFound);

			}

		iIsCommitted = in.ReadUint32L();

		HBufC* filename = HBufC::NewLC(in,KMaxFileName);

		iFilePath = HBufC::NewL(KMaxFileName);

		TPtr16 fileNamePtr = iFilePath->Des();

		iMsvStoreManager.BodyTextFilePathL(iMessageId, fileNamePtr);

		fileNamePtr.Append(*filename);

		iMsvStoreManager.OpenBodyTextFileForReadL(iFile, iMessageId, *iFilePath);

		iRemainingConvertedData.Create(KMaxDecodeUnicodeLength);

		CleanupStack::PopAndDestroy(2,&in);// filename, in

		}

	}

/**

Destructor

*/

EXPORT_C CMsvPlainBodyText::~CMsvPlainBodyText()

	{

	delete iConverter;

	delete iParaLayer;

	delete iCharLayer;

	delete iRichText;

	delete iFilePath;

	iTempChunk16.Close();

	iRemainingConvertedData.Close();

	iStartPosOfEachChunkInFile.Close();

	iRfileReadBuf8.Close();

	// Cannot leave in destructor, so ignore any error.

	// iFile will be closed by a call to RevertL method.

	TRAP_IGNORE(RevertL());

	}

/**

Store the plain body text part in chunks.

@param aChunk. 				The 8 bit chunk that is to be stored.

@param aStatus. 			The TRequestStatus parameter for this request.

@leave KErrAccessDenied.	If CMsvStore was opened in Read mode or

							If CommitL is already called.

@leave Other 				Standard system-wide error codes.

@return void.

*/

EXPORT_C void CMsvPlainBodyText::StoreChunkL(const TDesC8& aChunk, TRequestStatus& aStatus)

	{

	iTempChunk16.Close();

	if(iIsCommitted || iMsvFileStatus == EMsvFileReading)

		{

		// Leave if CommitL is already called or CMsvStore is opened in Read mode.

		User::Leave(KErrAccessDenied);

		}

	if(iIs8Bit)

		{

		iFile.Write(aChunk, aStatus);

		}

	// convert to 16..........

	else

		{

		ConvertChunkToUnicodeForStoreL(aChunk);

		iFile.Write(iRfileWritePtr8, aStatus);

		}

	}

/**

Store the plain body text part in chunks,synchronous version.

@param aChunk. 				The 8 bit chunk that is to be stored.

@leave KErrAccessDenied.	If CMsvStore was opened in Read mode or

							If CommitL is already called.

@leave Other 				Standard system-wide error codes.

@return void.

*/

EXPORT_C void CMsvPlainBodyText::StoreChunkL(const TDesC8& aChunk)

	{

	iTempChunk16.Close();

	if(iIsCommitted || iMsvFileStatus == EMsvFileReading)

		{

		// Leave if CommitL is already called or CMsvStore is opened in Read mode.

		User::Leave(KErrAccessDenied);

		}

	if(iIs8Bit)

		{

		User::LeaveIfError(iFile.Write(aChunk));

		}

	else

		{

		ConvertChunkToUnicodeForStoreL(aChunk);

		User::LeaveIfError(iFile.Write(iRfileWritePtr8));

		}

	}

/**

Converts the 8 bit chunk to Unicode.

@param aChunk The 8bit chunk to be converted.

@return void.

*/

void CMsvPlainBodyText::ConvertChunkToUnicodeForStoreL(const TDesC8& aChunk)

	{

	TInt chunkLength = aChunk.Length();

	TPtrC8 chunkPtr8(aChunk);

	iTempChunk16.Create(chunkLength);

	PrepareToConvertL();

	TInt charsetState = CCnvCharacterSetConverter::KStateDefault;

	if (iAvailable == CCnvCharacterSetConverter::ENotAvailable)

		{

		// Copy data if character convertor not available

		iTempChunk16.Copy(chunkPtr8);

		}

	else

		{

		TInt rem = iConverter->ConvertToUnicode(iTempChunk16, chunkPtr8, charsetState);

		if (rem < 0)

			{

			// Copy the data without conversion,if there was error while converting.

			iTempChunk16.Copy(aChunk);

			}

		else if(rem > 0)

			{

			// Some of the characters were not converted because the output buffer

			// was not long enough, so reallocate the output buffer.

			do

				{

				TBuf<KMaxDecodeUnicodeLength> buf;

				chunkPtr8.Set(chunkPtr8.Right(rem));

				rem = iConverter->ConvertToUnicode(buf, chunkPtr8, charsetState);

				if(iTempChunk16.Length() + buf.Length() > iTempChunk16.MaxLength())

					{

					iTempChunk16.ReAllocL(iTempChunk16.Length() + buf.Length());

					}

				iTempChunk16.Append(buf);

				}while(rem > 0);

			}

		}

		TPtrC8 convertedChunk8((TUint8*)(iTempChunk16.Ptr()), iTempChunk16.Length()*2);

		iRfileWritePtr8.Set(convertedChunk8);

	}

/**

Store the body part in chunks(16 bit version).

@param aChunk 			 The 16 bit chunk that is to be stored.

@param aStatus	 		 The TRequestStatus parameter for this request.

@leave KErrNotSupported  If the 8-bit storage was enabled.

@leave KErrAccessDenied  If CMsvStore was opened in Read mode or

						 IfCommitL is already called.

@leave Other 			 Standard system-wide error codes.

@return void

*/

EXPORT_C void CMsvPlainBodyText::StoreChunkL(const TDesC16& aChunk, TRequestStatus& aStatus)

	{

	if(iIs8Bit)	

		{

		User::Leave(KErrNotSupported);

		}

	if(iIsCommitted || iMsvFileStatus == EMsvFileReading)

		{

		// Leave if CommitL is already called or CMsvStore is opened in Read mode.

		User::Leave(KErrAccessDenied);

		}	

	TPtrC8 inFileBuf8((TUint8*)(aChunk.Ptr()), aChunk.Length()*2);

	iFile.Write(inFileBuf8, aStatus);

	}

/**

Store the body part in chunks(16 bit synchronous version).

@param aChunk 			 The 16 bit chunk that is to be stored.

@leave KErrNotSupported  If the 8-bit storage was enabled.						 

@leave KErrAccessDenied  If CMsvStore was opened in Read mode or

						 If CommitL is already called.

@leave Other 			 Standard system-wide error codes.

@return void

*/

EXPORT_C void CMsvPlainBodyText::StoreChunkL(const TDesC16& aChunk)

	{

	if(iIs8Bit)	

		{

		User::Leave(KErrNotSupported);

		}

	if(iIsCommitted || iMsvFileStatus == EMsvFileReading)

		{

		// Leave if CommitL is already called or CMsvStore is opened in Read mode.

		User::Leave(KErrAccessDenied);

		}

	TPtrC8 inFileBuf8((TUint8*)(aChunk.Ptr()), aChunk.Length()*2);

	User::LeaveIfError(iFile.Write(inFileBuf8));

	}

/**

Returns the size of body text in bytes.

@param None.

@return TInt  The size of the plain body text stored in bytes.

*/

EXPORT_C TInt CMsvPlainBodyText::Size()

	{

	TInt size=0;

	if(iRichText)

		{

		size = iRichText->DocumentLength() * 2;// Since Unicode multiply by 2.

		}

	else

		{

		iFile.Size(size);

		}

	return size;

	}

/**

Converts and stores the CRichText contents to a plain text.

@param aRichText 		 The CRichText object that will be stored as plain body text.

@leave KErrNotSupported  If CMsvStore was opened in Read mode or

						 If CommitL is already called.

@leave Other 			 Standard system-wide error codes.

@return void.

*/

EXPORT_C void CMsvPlainBodyText::StoreRichTextAsPlainTextL(CRichText& aRichText)

	{

	if(iIs8Bit)	

		{

		User::Leave(KErrNotSupported);

		}

	if(iIsCommitted || iMsvFileStatus == EMsvFileReading)

		{

		// Leave if CommitL is already called or CMsvStore is opened in Read mode.

		User::Leave(KErrAccessDenied);

		}

  	// create a buffer of 512 bytes to extract data from a rich text instead of extracting

  	// the entire richtext so that 2 copies of the mail is not created in RAM.

	TBuf<KMsvDecodeChunkLength> richBuf;

	TInt currentPos = 0;

	TInt richTextLen = aRichText.DocumentLength();

	TInt lengthToExtract = richTextLen;

	while(richTextLen > 0)

	 	{

	 	if(lengthToExtract > KMsvDecodeChunkLength)

	 		{

	 		lengthToExtract = KMsvDecodeChunkLength;

	 		}

	 	aRichText.Extract(richBuf,currentPos,lengthToExtract);

	 	TPtrC8 richTextPtr1((TUint8*)(richBuf.Ptr()), richBuf.Length() * 2);

	 	User::LeaveIfError(iFile.Write(richTextPtr1));

	  	currentPos += lengthToExtract;

	  	richTextLen -=lengthToExtract;

	   	if(richTextLen <= lengthToExtract)

	 		{

	 		lengthToExtract = richTextLen;

	 		}

	 	 }

	}

/**

Retrieve the next chunk of the plain body text.

@param aChunk 			 The output parameter contains the requested chunk.

@param aStatus.			 The TRequestStatus for this request.

@leave KErrAccessDenied  If CMsvStore was opened in Write mode.

@leave KErrNotSupported  If 16-bit storage is enabled.

@leave KErrUnderflow 	 If aChunk MaxLength is less than iChunkMaxLength.

@leave Other 				Standard system-wide error codes.

@return void

*/

EXPORT_C void CMsvPlainBodyText::NextChunkL(TDes8& aChunk, TRequestStatus& aStatus)

	{

	if(!iIs8Bit)

		{

		// If 16-bit storage is enabled.

		User::Leave(KErrNotSupported);

		}

	if(iMsvFileStatus == EMsvFileWriting)

		{

		// Leave if CMsvStore is opened in Write mode.

		User::Leave(KErrAccessDenied);

		}	

	if(aChunk.MaxLength() < iChunkMaxLength)

		{

		User::Leave(KErrUnderflow);

		}

	iChunk8 = &aChunk;	

	iChunk8->SetLength(0);

	iRetrieving8bit = ETrue;

	//store the current position of the file so that if request cancels and for next 

	// call to NextChunkL() will attempt to read the same chunk that was cancelled

	iCurrentFilePos = 0;

	User::LeaveIfError(iFile.Seek(ESeekCurrent, iCurrentFilePos));

	Queue(aStatus);

	iFile.Read(aChunk, iChunkMaxLength, iStatus);

	SetActive();

	}

/**

Retrieve the next chunk of the plain body text.

@param aChunk 			 The output parameter contains the requested chunk.

@leave KErrNotSupported  If CMsvStore was opened in Write mode.

@leave KErrNotSupported  If 16-bit storage is enabled.

@leave KErrUnderflow	 If aChunk MaxLength is less than iChunkMaxLength.

@leave Other 			 Standard system-wide error codes.

@return void

*/

EXPORT_C void CMsvPlainBodyText::NextChunkL(TDes8& aChunk)

	{

	if(!iIs8Bit)

		{

		// If 16-bit storage is enabled.

		User::Leave(KErrNotSupported);

		}

	if(iMsvFileStatus == EMsvFileWriting)

		{

		// Leave if CMsvStore is opened in Write mode.

		User::Leave(KErrAccessDenied);

		}

	if(aChunk.MaxLength() < iChunkMaxLength)

		{

		User::Leave(KErrUnderflow);

		}

	aChunk.SetLength(0);

	User::LeaveIfError(iFile.Read(aChunk, iChunkMaxLength));

	if(aChunk.Length()>0)

		{

		iReadChunkLength = aChunk.Length();

		}

	}

/**

Retrieve  the next chunk of the plain body text. If body is stored as 8bit, the chunk is

converted to unicode.Unconverted bytes will be converted while reading the next chunk.

@param aChunk 			 The output parameter contains the requested chunk.If no more data is in Store this

						 contains NULL descriptor.

@param aStatus  		 The TRequestStatus for this request.

@leave KErrAccessDenied  If CMsvStore was opened in Write mode.

@leave KErrUnderflow	 If aChunk MaxLength is less than iChunkMaxLength.

@leave Other 			 Standard system-wide error codes.

@return void

*/

EXPORT_C void CMsvPlainBodyText::NextChunkL(TDes16& aChunk, TRequestStatus& aStatus)

	{

	if(iMsvFileStatus == EMsvFileWriting)

		{

		// Leave if CMsvStore is opened in Write mode.

		User::Leave(KErrAccessDenied);

		}

	if(aChunk.MaxLength() < iChunkMaxLength)

		{

		User::Leave(KErrUnderflow);

		}

	if(iRichText)

 		{

 		ExtractNextChunkFromRichText(aChunk);

	 	TRequestStatus *status=&aStatus;

		User::RequestComplete(status, KErrNone);

 		}

	else

		{

		iRfileReadBuf8.Close();

		iChunk16 = &aChunk;	

		iChunk16->SetLength(0);

		//store the current position of the file so that if request cancels and for next 

		// call to NextChunkL() will attempt to read the same chunk that was cancelled

		iCurrentFilePos = 0;

		User::LeaveIfError(iFile.Seek(ESeekCurrent, iCurrentFilePos));