// Copyright (c) 2004-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 <csmsemailfields.h>

#include <msvstore.h>

const TInt KSmsEmailAddressesArrayGranularity	= 4;

const TUid KUidMsvSmsEmailFieldsStream	= {0x10204C9D};

const TInt KMsvSmsEmailFieldsVersion	= 1;

const TUint8 KSmsEmailComma			= ',';

const TUint8 KSmsEmailAtSign		= '@';

const TUint8 KSmsEmailSpace 		= ' ';

const TUint8 KSmsEmailOpenBracket	= '(';

const TUint8 KSmsEmailCloseBracket	= ')';

const TUint8 KSmsEmailHash			= '#';

#if (defined SYMBIAN_MESSAGESTORE_HEADER_BODY_USING_SQLDB)

_LIT16(KDelimiter, ";");

_LIT16(KComma, ",");

#endif

/**

Factory constructor.

@return

An empty email fields object.

*/

EXPORT_C CSmsEmailFields* CSmsEmailFields::NewL()

	{

	CSmsEmailFields* self = new (ELeave) CSmsEmailFields();

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

/**

Factory copy constructor.

@param	aEmailFields

The orginal email fields object from which a copy is made.

@return

A copy of aEmailFields.

*/

EXPORT_C CSmsEmailFields* CSmsEmailFields::NewL(const CSmsEmailFields& aEmailFields)

	{

	CSmsEmailFields* self = new (ELeave) CSmsEmailFields();

	CleanupStack::PushL(self);

	self->ConstructL(aEmailFields);

	CleanupStack::Pop(self);

	return self;

	}

/**

Destructor.

*/	

EXPORT_C CSmsEmailFields::~CSmsEmailFields()

	{

	Reset();

	delete iAddresses;

	}

/**

Resets the contents of the email fields object.

*/

EXPORT_C void CSmsEmailFields::Reset()

	{

	delete iSubject;

	iSubject = NULL;

	if( iAddresses!=NULL )

		{

		iAddresses->Reset();

		}

	}

/**

The number of characters in the email fields.

Calculates the number of characters that will be pre-pended to an SMS message

when SMS is set for interworking with email. The address and subject fields are

only valid if the their length is greater than zero.

The address field is a comma separated list of addresses.

It assumes that a subject will be added with the following format.

@code

	<address>(<subject>)<message>

@endcode

No validation of the contents of the fields is performed.

@return

The number of characters in the email fields.

*/

EXPORT_C TInt CSmsEmailFields::Length() const

	{

	// Get the address length and subject length

	TInt subject = Subject().Length();

	TInt address = 0;

	if( HasAddress() )

		{

		// Go through address list - there is at least one address...	

		address = (*iAddresses)[0].Length();

		TInt count = iAddresses->Count();

		for( TInt i=1; i < count; ++i )

			{

			// Any subsequent addresses are in a comma separated list - include

			// length of comma separator.

			address += (1 + (*iAddresses)[i].Length());

			}

		}

	if( subject > 0 )

		{

		// There is a subject - add the address and subject lengths plus the

		// two delimiters; the '(' and ')' delimiters.

		return (address + subject + 2);

		}

	if( address > 0 )

		{

		// There is no subject field, but there is an address field - add the

		// address length and the single space delimiter for the end of the 

		// address field.

		return (address + 1);

		}

	// There is neither an address nor a subject field - return zero length.

	return 0;

	}

/**

Indicates whether the address field contains at least one address

@return

A value of true if the address field contains at least one address, false if the

address field is empty.

*/

EXPORT_C TBool CSmsEmailFields::HasAddress() const

	{

	return (iAddresses->Count() > 0);

	}

/**

Composes the email fields.

The email fields are formatted into a buffer. The buffer is returned and left

on the cleanup stack.

If there is no address fields, then the function leaves with the error code 

KErrCorrupt.

The address field is a comma separate list of addresses.

If a subject field exists then the address fields is delimited by a open bracket

'(' and the subject is delimited by a close bracket ')'.

@return

A buffer contain the formatted email fields. A pointer to this buffer is left

on the cleanup stack.

@leave	KErrCorrupt

The email fields has a zero-length address field.

@internalTechnology

*/

EXPORT_C HBufC* CSmsEmailFields::ComposeLC() const

	{

	if( !HasAddress() )

		{

		User::Leave(KErrCorrupt);

		}

	HBufC* buf = HBufC::NewLC(Length());

	TPtr ptr(buf->Des());

	// Append the addresses - must have at least one address...

	ptr.Append((*iAddresses)[0]);

	// Append remaining addresses as comma separated list

	TInt count = iAddresses->Count();

	for( TInt i=1; i < count; ++i )

		{

		ptr.Append(KSmsEmailComma);

		ptr.Append((*iAddresses)[i]);

		}

	// The delimiter for the address depends on whether there is a subject.

	if( Subject().Length() > 0 )

		{

		// Append open bracket '(', followed by subject and then close bracket ')'.

		ptr.Append(KSmsEmailOpenBracket);

		ptr.Append(*iSubject);

		ptr.Append(KSmsEmailCloseBracket);

		}

	else

		{

		// No subject - address delimited by a space.

		ptr.Append(KSmsEmailSpace);		

		}

	return buf;

	}

/**

Parses the given buffer for email fields.

Supports the two address formats.

@code

	user@domain1.domain2

or

	User Name <user@domain1.domain2>

@endcode

Also, supports the two subject formats.

@code

	<address>(<subject>)<message>

or

	<address>##<subject>#<message>

@endcode

The parsed address and optional subject are set in the email fields object. Any

existing data in the object is deleted.

@param	aBuffer

The buffer to be parsed.

@return

If the email fields were successfully parsed the start position of the actual

body text from the start of aBuffer is returned. If the email fields could not

be parsed from aBuffer the error code KErrCorrupt is returned.

@internalComponent

*/	

TInt CSmsEmailFields::ParseL(const TDesC& aBuffer)

	{

	Reset();

	// The to-address or the from-address can have following two formats - 

	// 1. user@domain1.domain2

	// 2. User Name <user@domain1.domain2>

	// In the second format the <> brackets are part of the address.

	// The address is delimited by one of the following - 

	// 1. <space>

	// 2. (

	// 3. #

	// The later two cases imply that there is a subject field. These two 

	// delimiters are also mutually exclusive.

	//

	// First find the @ symbol - this will be the address.

	TPtrC buf(aBuffer);

	TInt pos = buf.Locate(KSmsEmailAtSign);

	if( pos <= 0 )

		{

		return KErrCorrupt;

		}

	// Found the address - search for the delimiters.

	TInt atPos = pos;

	buf.Set(buf.Mid(pos));

	pos = buf.Locate(KSmsEmailSpace);

	TInt spacePos	= pos != KErrNotFound ? pos : KMaxTInt;

	pos = buf.Locate(KSmsEmailOpenBracket);

	TInt bracketPos	= pos != KErrNotFound ? pos : KMaxTInt;

	pos = buf.Locate(KSmsEmailHash);

	TInt hashPos	= pos != KErrNotFound ? pos : KMaxTInt;

	TInt bodyPos = KErrNotFound;

	if( spacePos < bracketPos && spacePos < hashPos )

		{

		// There is no subject as the <space> is the first delimiter.

		pos = spacePos + atPos;

		// Set the start of the body text - need to move past the delimiter.

		bodyPos = pos + 1;

		}

	else 

		{

		// The delimiter is either the # or ( - this implies a subject field.

		TInt end = KErrNotFound;

		if( bracketPos < hashPos )

			{

			// Address delimited by the bracket position;

			pos = bracketPos + atPos;

			// Set the start of the body text - need to move past the delimiter.

			bodyPos = pos + 1;

			// Subject has the (subject) format - find the end of the subject

			// indicated by the closing bracket ')'. First move past delimiter.

			buf.Set(buf.Mid(bracketPos+1));

			end = buf.Locate(KSmsEmailCloseBracket);

			}

		else if( hashPos < KMaxTInt && buf[hashPos+1] == KSmsEmailHash )

			{

			// Address delimited by the hash position;

			pos = hashPos + atPos;

			// Set the start of the body text - need to move past the two # 

			// delimiters.

			bodyPos = pos + 2;

			// Subject has the ##subject# format - find the end of the subject

			// indicated by a final hash '#'. First move past the delimiters.

			buf.Set(buf.Mid(hashPos+2));

			end = buf.Locate(KSmsEmailHash);

			}

		if( end == KErrNotFound )

			{

			// In this case the email fields are corrupt - one of the following

			// has occurred - 

			// 1. The address had no delimiter - missing <space>, # or (.

			// 2. The subject had no delimiter - missing # or ).

			// 3. The address has only a single delimiting #.

			return KErrCorrupt;

			}

		SetSubjectL(buf.Left(end));

		// Update the start of the body text to get passed the subject - need

		// to move past the delimiter.

		bodyPos += end + 1;

		}

	// Add the address and return the position of the start of the body text.

	AddAddressL(aBuffer.Left(pos));

	return bodyPos;	

	}

/**

Adds the address to the list of addresses.

The address to be added must have a non-zero length. A zero-length address will

not be added to the address list.

@param	aAddress

The address to be added.

*/

EXPORT_C void CSmsEmailFields::AddAddressL(const TDesC& aAddress)

	{

	if( aAddress.Length() > 0 )

		{

		iAddresses->AppendL(aAddress);

		}

	}

/**

Removes the specified address.

@param	aIndex

The index for the address to be remvoed.

*/

EXPORT_C void CSmsEmailFields::RemoveAddress(TInt aIndex)

	{

	iAddresses->Delete(aIndex);

	}

/**

The array of email addresses.

@see	MDesCArray

@return

An array of email addresses.

*/

EXPORT_C const MDesCArray& CSmsEmailFields::Addresses() const

	{

	return *iAddresses;

	}

/**

Sets the email subject field.

Copies the contents of subject as the email subject field. If the copy is 

unsuccessful the current contents is left unchanged.

@param	aSubject

The subject to be copied into the email field.

*/

EXPORT_C void CSmsEmailFields::SetSubjectL(const TDesC& aSubject)

	{

	HBufC* subject = aSubject.AllocL();

	delete iSubject;

	iSubject = subject;	

	}

/**

The subject field.

@return

The subject field.

*/

EXPORT_C const TDesC& CSmsEmailFields::Subject() const

	{

	return (iSubject) ? static_cast<const TDesC&>(*iSubject) : KNullDesC();

	}

/**

Restores the email fields.

If the store does not contain email fields data, the current email data is reset.

@param	aStore

The store to be read.

@internalComponent

*/

void CSmsEmailFields::RestoreL(CMsvStore& aStore)

	{

	if( aStore.IsPresentL(KUidMsvSmsEmailFieldsStream) )

		{

		// The email fields stream exists - internalise from the stream.

		RMsvReadStream in;

		in.OpenLC(aStore, KUidMsvSmsEmailFieldsStream);

		InternalizeL(in);

		CleanupStack::PopAndDestroy(&in);	

		}

	else

		{

		// There is no stream - reset the email fields.

		Reset();

		}

	}

/**

Stores the email fields.

The email fields data will only be stored if there is at least some address or

subject data. If there is neither address nor subject data and the store already

contains email fields data, then this existing data is removed.

@param	aStore

The store to be written.

@internalComponent

*/

void CSmsEmailFields::StoreL(CMsvStore& aStore) const

	{

	if( HasAddress() || Subject().Length() > 0 )

		{

		// The email fields have some data - store them.

		RMsvWriteStream out;	

		out.AssignLC(aStore, KUidMsvSmsEmailFieldsStream);

		ExternalizeL(out);

		out.CommitL();

		CleanupStack::PopAndDestroy(&out);

		}

	else if( aStore.IsPresentL(KUidMsvSmsEmailFieldsStream) )

		{

		// Ok, the current email fields have no data, but the email fileds 

		// stream exists - remove it.

		aStore.Remove(KUidMsvSmsEmailFieldsStream);

		}

	}

/**

Internalizes the email fields from the given stream.

@param	aStream

The stream to be read.

*/

void CSmsEmailFields::InternalizeL(RReadStream& aStream)

	{

	Reset();

	aStream.ReadInt16L();	// read the version - to local as causes warning in EABI...

	TCardinality cardinality;

	aStream >> cardinality;

	TInt count = cardinality;

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

		{

		HBufC* buf = HBufC::NewLC(aStream, KMaxTInt);

		AddAddressL(*buf);

		CleanupStack::PopAndDestroy(buf);

		}

	iSubject = HBufC::NewL(aStream, KMaxTInt);	

	}

/**

Externalizes the email fields into the given stream.

@param	aStream

The stream to be written.

*/

void CSmsEmailFields::ExternalizeL(RWriteStream& aStream) const

	{

	aStream.WriteInt16L(KMsvSmsEmailFieldsVersion);

	TInt count = iAddresses->Count();	

	aStream << TCardinality(count);

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

		{

		aStream << (*iAddresses)[i];

		}

	aStream << Subject();

	}

CSmsEmailFields::CSmsEmailFields()

: CBase()

	{