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

// cimencodeheader.cpp

//

#include "cimencodedheader.h"

#include "MIUT_ERR.H"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS  

#include "miut_errconsts.h"

#include "timrfc822datefield.h"

#endif

#if (defined SYMBIAN_MESSAGESTORE_HEADER_BODY_USING_SQLDB)

#include <msvstd.h>

#endif 

#if (defined SYMBIAN_MESSAGESTORE_HEADER_BODY_USING_SQLDB)

_LIT16(KComma, ",");

_LIT16(KDelimiter, ";");

#endif

const TInt KArrayGranularity = 16;

// Identifies which version of CImEncodedHeader has been stored in stream

const TUint16 KImEncodedHeaderVersion = 1; 

extern TPtrC8 LimitStringSize(const TPtrC8& aString, TInt aMaxSize);

extern TPtrC16 LimitStringSize(const TPtrC16& aString, TInt aMaxSize);

extern void ExternalizeL(const CDesC8Array& anArray,RWriteStream& aStream);

extern void InternalizeL(CDesC8Array& anArray,RReadStream& aStream);

extern void ExternalizeL(const CDesC16Array& anArray,RWriteStream& aStream);

extern void InternalizeL(CDesC16Array& anArray,RReadStream& aStream);

//------------------------------------------------------------------------------

//              Class  CImEncodedHeader  Functions

//------------------------------------------------------------------------------

CImEncodedHeader::CImEncodedHeader() : iDecodeCharset(0)

	{

	}

//------------------------------------------------------------------------------

CImEncodedHeader* CImEncodedHeader::NewLC()

/** Allocates and creates a new CImHeader object, leaving the object on the cleanup 

stack.

@return New CImEncodedHeader object */

	{

	CImEncodedHeader* self = new(ELeave) CImEncodedHeader;

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

//------------------------------------------------------------------------------

CImEncodedHeader* CImEncodedHeader::NewL()

/** Allocates and creates a new CImHeader object, leaving the object on the cleanup 

stack.

@return New CImEncodedHeader object */

	{

	CImEncodedHeader* self = CImEncodedHeader::NewLC();

	CleanupStack::Pop(self);

	return self;

	}

//------------------------------------------------------------------------------

void CImEncodedHeader::ConstructL()

	{

	iTo  = new (ELeave)CDesCArrayFlat(KArrayGranularity);

	iCc  = new (ELeave)CDesCArrayFlat(KArrayGranularity);	

	iBcc = new (ELeave)CDesCArrayFlat(KArrayGranularity);

	}

//------------------------------------------------------------------------------

CImEncodedHeader::~CImEncodedHeader()

	{

	Reset();

	delete iTo;

	delete iCc;

	delete iBcc;

	}

//------------------------------------------------------------------------------

void CImEncodedHeader::Reset()

	{

	iVersion = KImEncodedHeaderVersion;

	delete iFrom;    iFrom    = NULL;

	delete iSubject; iSubject = NULL;

	delete iReplyTo; iReplyTo = NULL;

	if (iTo)

		iTo->Reset();

	if (iCc)

		iCc->Reset();

	if (iBcc)

		iBcc->Reset();

	iDecodeCharset = 0;

	}

//------------------------------------------------------------------------------

const TPtrC8 CImEncodedHeader::Subject() const

/** Gets the "Subject" header field.

@return Field value */

	{

	return iSubject ? TPtrC8(*iSubject) : TPtrC8();

	}

//------------------------------------------------------------------------------

const TPtrC8 CImEncodedHeader::From() const

/** Gets the "From" header field. 

This consists of an address and (possibly) an alias.

@return Field value */

	{

	return iFrom ? TPtrC8(*iFrom) : TPtrC8();

	}

//------------------------------------------------------------------------------

const TPtrC8 CImEncodedHeader::ReplyTo() const

/** Gets the "ReplyTo" header field. 

@return Field value */

	{

	return iReplyTo ? TPtrC8(*iReplyTo) : TPtrC8();

	}

//------------------------------------------------------------------------------

void CImEncodedHeader::SetSubjectL( const TDesC8& aSubject )

/** Sets the "Subject" header field. 

@param aSubject Field value */

	{

	HBufC8* newSubject = aSubject.AllocL();

	delete iSubject;

	iSubject = newSubject;

	}

//------------------------------------------------------------------------------

void CImEncodedHeader::SetFromL( const TDesC8& aFrom )

/** Sets the "From" header field. 

@param aFrom Field value */

	{

	HBufC8* newFrom = aFrom.AllocL();

	delete iFrom;

	iFrom = newFrom;

	}

//------------------------------------------------------------------------------

void CImEncodedHeader::SetReplyToL( const TDesC8& aReplyTo )

/** Sets the "ReplyTo" header field. 

@param aReplyTo Field value */

	{

	HBufC8* newReplyTo = aReplyTo.AllocL();

	delete iReplyTo;

	iReplyTo = newReplyTo;

	}

//------------------------------------------------------------------------------

CDesCArray& CImEncodedHeader::ToRecipients ()

	{

	return *iTo;

	}

//------------------------------------------------------------------------------

CDesCArray& CImEncodedHeader::CcRecipients ()

/** Gets a list of "Cc" recipients.

@return Recipient list */

	{

	return *iCc;

	}

//------------------------------------------------------------------------------

CDesCArray& CImEncodedHeader::BccRecipients()

/** Gets a list of "Bcc" recipients.

@return Recipient list */

	{

	return *iBcc;

	}

//------------------------------------------------------------------------------

const CDesCArray& CImEncodedHeader::ToRecipients () const 

/** Gets a const list of "To" recipients.

@return Recipient list */

	{

	return *iTo;

	}

//------------------------------------------------------------------------------

const CDesCArray& CImEncodedHeader::CcRecipients () const

/** Gets a const list of "Cc" recipients.

@return Recipient list */

	{

	return *iCc;

	}

//------------------------------------------------------------------------------

const CDesCArray& CImEncodedHeader::BccRecipients() const

/** Gets a const list of "Bcc" recipients.

@return Recipient list */

	{

	return *iBcc;

	}

//------------------------------------------------------------------------------

void CImEncodedHeader::ExternalizeL( RMsvWriteStream& aWriteStream ) const

/** Externalises the settings to a specified stream.

@param aWriteStream Stream to write to */

	{

	aWriteStream.WriteUint16L(Version());	// This MUST be the 1st item written into the stream

	aWriteStream << LimitStringSize(From(), KMaxImHeaderStringLength);

	aWriteStream << LimitStringSize(ReplyTo(), KMaxImHeaderStringLength);

	aWriteStream << LimitStringSize(Subject(), KMaxImHeaderStringLength);

	aWriteStream << ToRecipients();

	aWriteStream << CcRecipients();

	aWriteStream << BccRecipients();

	aWriteStream.WriteUint32L(iDecodeCharset);

	}

//------------------------------------------------------------------------------

void CImEncodedHeader::InternalizeL( RMsvReadStream& aReadStream )

/** Internalises the settings from a specified stream.

@param aReadStream Stream to read from */

	{

	Reset();

	iVersion = aReadStream.ReadUint16L();

	iFrom    = HBufC8::NewL(aReadStream, KMaxImHeaderStringLength);

	iReplyTo = HBufC8::NewL(aReadStream, KMaxImHeaderStringLength);

	iSubject = HBufC8::NewL(aReadStream, KMaxImHeaderStringLength);

	aReadStream >> ToRecipients();

	aReadStream >> CcRecipients();

	aReadStream >> BccRecipients();

	iDecodeCharset = aReadStream.ReadUint32L();

	}

void CImEncodedHeader::StoreL(CMsvStore& aMessageStore) const

	/** Stores settings to a specified message store.

	@param aMessageStore Message store to write to */

	{

	//------------------------------------------------------------------------------

	RMsvWriteStream out;

	out.AssignLC(aMessageStore, KUidMsgFileIMailEncodedHeader);

	ExternalizeL(out);

	out.CommitL();

	CleanupStack::PopAndDestroy(&out);

	}

void CImEncodedHeader::RestoreL(CMsvStore& aMessageStore)

	/** Restores settings from a specified message store.

	@param aMessageStore Message store to read from */

	{

	RMsvReadStream in;

	in.OpenLC( aMessageStore, KUidMsgFileIMailEncodedHeader );

	InternalizeL(in);

	in.Close();

	CleanupStack::PopAndDestroy(&in);

	}

//------------------------------------------------------------------------------

TUint16 CImEncodedHeader::Version() const

	{

	return iVersion;

	}

//------------------------------------------------------------------------------

void CImEncodedHeader::SetVersion( TUint16 aVersion )

	{

	iVersion = aVersion;

	}

//------------------------------------------------------------------------------

TUint CImEncodedHeader::DecodeCharset() const

	{

	return iDecodeCharset;

	}

//------------------------------------------------------------------------------

void CImEncodedHeader::SetDecodeCharset(TUint aCharset)

	{

	iDecodeCharset = aCharset;

	}

//------------------------------------------------------------------------------

void CImEncodedHeader::CopyFromHeaderL(

	const CImHeader& aFromHeader, TBool aDeleteExistingData)

	{

	// From field

	const TPtrC& fromDes = aFromHeader.From();

	if (fromDes.Length() && (!iFrom || aDeleteExistingData))

		{

		HBufC8* buffer = HBufC8::NewL(fromDes.Length());

		buffer->Des().Copy(fromDes);

		delete iFrom;

		iFrom = buffer;

		}

	// Subject field

	const TPtrC& subjectDes = aFromHeader.Subject();

	if (subjectDes.Length() && (!iSubject || aDeleteExistingData))

		{

		HBufC8* buffer = HBufC8::NewL(subjectDes.Length());

		buffer->Des().Copy(subjectDes);

		delete iSubject;

		iSubject = buffer;

		}

	// ReplyTo field

	const TPtrC& replyToDes = aFromHeader.ReplyTo();

	if (replyToDes.Length() && (!iReplyTo || aDeleteExistingData))

		{

		HBufC8* buffer = HBufC8::NewL(replyToDes.Length());

		buffer->Des().Copy(replyToDes);

		delete iReplyTo;

		iReplyTo = buffer;

		}

	// Copy iTo, iCc, iBcc

	const CDesCArray& srcToArray = aFromHeader.ToRecipients();

	if (srcToArray.Count() && ((iTo->Count() == 0) || aDeleteExistingData))

		::CopyArrayL(srcToArray, *iTo);

	const CDesCArray& srcCcArray = aFromHeader.CcRecipients();

	if (srcCcArray.Count() && ((iCc->Count() == 0) || aDeleteExistingData))

		::CopyArrayL(srcCcArray, *iCc);

	const CDesCArray& srcBccArray = aFromHeader.BccRecipients();

	if (srcBccArray.Count() && ((iBcc->Count() == 0) || aDeleteExistingData))

		::CopyArrayL(srcBccArray, *iBcc);

	}

//------------------------------------------------------------------------------

void CImEncodedHeader::CopyToHeaderL(CImHeader& aToHeader) const

	{

	//

	aToHeader.SetFromL(From());

	aToHeader.SetSubjectL(Subject());

	aToHeader.SetReplyToL(ReplyTo());

	// Copy iTo, iCc, iBcc

	::CopyArrayL(*iTo, aToHeader.ToRecipients());

	::CopyArrayL(*iCc, aToHeader.CcRecipients());

	::CopyArrayL(*iBcc, aToHeader.BccRecipients());

	}

//------------------------------------------------------------------------------

TInt CImEncodedHeader::DataSize() const

/** Gets the combined length of all the field values stored. 

@return Combined length */

	{

	TInt headerSize = 2; // CRLF at end of header

	const CImEncodedHeader* self = this;

	headerSize += self->From().Length();

	headerSize += self->ReplyTo().Length();

	headerSize += self->Subject().Length();

	headerSize += sizeof(TUint);				// size of Charset

	TInt count;

	CDesCArray& toArray = *self->iTo;

	for (count = 0; count < toArray.Count(); count++)

		{

		headerSize += toArray[count].Length();

		}

	CDesCArray& ccArray = *self->iCc;

	for (count = 0; count < ccArray.Count(); count++)

		{

		headerSize += ccArray[count].Length(); 

		}

	CDesCArray& bccArray = *self->iBcc;

	for (count = 0; count < bccArray.Count(); count++)

		{

		headerSize += bccArray[count].Length();

		}

	return headerSize;

	}

#if (defined SYMBIAN_MESSAGESTORE_HEADER_BODY_USING_SQLDB)

/**Stores encoded header to a specified message store.

 * @param aMessageStore Message store to write to

 * @return None.

 */

void CImEncodedHeader::StoreEncodedDBL(CMsvStore& aMessageStore) const

	{

	CHeaderFields* emailHeaderFields = new (ELeave)CHeaderFields();

	CleanupStack::PushL(emailHeaderFields);

	emailHeaderFields->iUid = KUidMsgFileIMailEncodedHeader;

	//----------------------Encoded Info  19th Field ------------------------------	// 19

	CFieldPair* emaildetailField = new (ELeave)CFieldPair();

	CleanupStack::PushL(emaildetailField);

	//Make a string from  encoded header info.

	RBuf8 encodedheader;

	CleanupClosePushL(encodedheader);

	encodedheader.CreateL(EncodedBufSize()); //

	encodedheader.AppendNum(Version());	

	encodedheader.Append(KDelimiter);

	encodedheader.Append(LimitStringSize(From(), KMaxImHeaderStringLength));

	encodedheader.Append(KDelimiter);

	encodedheader.Append(LimitStringSize(ReplyTo(), KMaxImHeaderStringLength));

	encodedheader.Append(KDelimiter);

	encodedheader.Append(LimitStringSize(Subject(), KMaxImHeaderStringLength));

	encodedheader.Append(KDelimiter);

	//ToRecipients 

	for(TInt i=0 ; i<iTo->MdcaCount() ; i++)

		{

		encodedheader.Append(iTo->MdcaPoint(i));

		if(i< iTo->MdcaCount()-1)

			encodedheader.Append(KComma);

		}

	encodedheader.Append(KDelimiter);

	//CcRecipients

	for(TInt i=0 ; i<iCc->MdcaCount() ; i++)

		{

		encodedheader.Append(iCc->MdcaPoint(i));

		if(i< iCc->MdcaCount()-1)

			encodedheader.Append(KComma);

		}

	encodedheader.Append(KDelimiter);

	//BCcRecipients

	for(TInt i=0 ; i<iBcc->MdcaCount() ; i++)

		{

		encodedheader.Append(iBcc->MdcaPoint(i));

		if(i< iBcc->MdcaCount()-1)

			encodedheader.Append(KComma);

		}

	encodedheader.Append(KDelimiter);

	encodedheader.AppendNum(iDecodeCharset);	

	encodedheader.Append(KDelimiter);

	//8 bit to 16 bit

	HBufC* newFrom = HBufC::NewL(encodedheader.Length());

	newFrom->Des().Copy(encodedheader);

	emaildetailField->iFieldTextValue = newFrom;

	emailHeaderFields->iFieldPairList.AppendL(emaildetailField);

	CleanupStack::Pop();  //RBuf8 

	CleanupStack::Pop(emaildetailField);

	//---------------------------Encoded info end-------------------------------

	TMsvWriteStore storeWriter(aMessageStore);

	storeWriter.AssignL(emailHeaderFields);

	encodedheader.Close();

	CleanupStack::Pop(emailHeaderFields);

	}

/**

 * Restores encoded header to a specified message store.

 * @param aMessageStore Message store to read from.

 * @return NOne.

 */

void CImEncodedHeader::ReStoreEncodedDBL(CMsvStore& aMessageStore)

	{

	Reset();

	CHeaderFields* aEncodedHeader = NULL;

	TMsvReadStore storeReader(aMessageStore, KUidMsgFileIMailEncodedHeader);

	storeReader.ReadL(aEncodedHeader);

	TInt i = 0; // EncodedHeader field is on 19th coloum  of header table.