/*

* Copyright (c) 2005-2007 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:  Part of SyncML Data Synchronization Plug In Adapter

*

*/

#include <e32std.h>

#include <msvids.h>

#include <txtrich.h>

#include "VMessageParser.h"

#include "Logger.h"

const TInt KVersionMaxLength = 4;

const TInt KDateMaxLength = 48;

const TInt KTagAndValueMaxLength = 48;

const TInt KDefaultWriteBufSize = 1024;

// ============================ MEMBER FUNCTIONS ===============================

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

// CVMessageParser* CVMessageParser::NewL()

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

//

CVMessageParser* CVMessageParser::NewL()

	{

	CVMessageParser* self = NewLC();

    CleanupStack::Pop( self );

    return self;

	}

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

// CVMessageParser* CVMessageParser::NewLC()

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

//

CVMessageParser* CVMessageParser::NewLC()

	{

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

	}

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

// CVMessageParser::~CVMessageParser()

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

//

CVMessageParser::~CVMessageParser()

	{

	iRecipients.Close();

	delete iMessageBody;

	iMessageBody = NULL;

	}

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

// CVMessageParser::CVMessageParser()

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

//

CVMessageParser::CVMessageParser()

	{

	}

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

// CVMessageParser::ConstructL()

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

//

void CVMessageParser::ConstructL()

	{

	}

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

// CVMessageParser::ReadMessage()

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

//

TInt CVMessageParser::ParseMessageL( const TDesC8& aVMessage )

	{

	LOGGER_ENTERFN( "CVMessageParser::ParseMessageL" );

	const TUint8* ptr8 = aVMessage.Ptr();	

	const TUint16* ptr16 = reinterpret_cast<const TUint16*>( ptr8 );

	iReadBuf.Set( ptr16, aVMessage.Length()/2 );

	LOG(iReadBuf);	

	iReadBufPosition = 0;

	TInt err = ReadMessageHeader();

	if (err < 0)

		{

		LOGGER_WRITE_1( "ReadMessageHeader() failed with %d", err );

		}

	else

		{

		err = ReadMessageBodyL();

		LOGGER_WRITE_1( "ReadMessageBody() result: %d", err );

		}

    LOGGER_LEAVEFN( "CVMessageParser::ParseMessageL" );

	return err;

	}

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

// CVMessageParser::ConstructMessageL()

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

//

void CVMessageParser::ConstructMessageL( CBufBase& aVMessage )

	{

	LOGGER_ENTERFN( "CVMessageParser::ConstructMessageL" );

	LOGGER_WRITE_1( "Initial buffer size: %d", aVMessage.Size() );

	iWriteBuf = &aVMessage;

	iWriteBufPosition = 0,

	iWriteIndentLevel = 0;

	iWriteBufSize = KDefaultWriteBufSize;

	if (iMessageBody)

		{

		iWriteBufSize += iMessageBody->Size();

		}

	iWriteBuf->ResizeL( iWriteBufSize );

	LOGGER_WRITE_1( "Buffer size resized to %d", iWriteBuf->Size() );

	WriteMessageLineL( KVMsgTagBegin, KVMsgSectionVMsg ); // BEGIN:VMSG

	WriteMessagePropertiesL();

	WriteMessageVCARDL( iSender.iName, iSender.iNumber );

	WriteMessageEnvelopeL();

	WriteMessageLineL( KVMsgTagEnd, KVMsgSectionVMsg ); // END:VMSG

	iWriteBuf->ResizeL( iWriteBufPosition );

	LOGGER_WRITE_1( "Message length: %d", iWriteBufPosition );

	LOGGER_LEAVEFN( "CVMessageParser::ConstructMessageL" );

	}

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

// CVMessageParser::ResetAll()

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

//

void CVMessageParser::ResetAll()

	{

	// Public data 

	iHomeTime = 0;

	iUniversalTime = 0;

	iFolder.Zero();

	iStatus.Zero();

	iSender.iNumber.Zero();

	iSender.iName.Zero();

	iRecipients.Reset();

	if (iMessageBody)

		{

		delete iMessageBody;

		iMessageBody = NULL;

		}

	// Private variables

	iReadBufPosition = 0;

	iWriteBufPosition = 0;

	iWriteIndentLevel = 0;

	iWriteBuf = NULL;

	}

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

// CVMessageParser::LoadMessageBodyL()

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

//

void CVMessageParser::LoadMessageBodyL( CRichText &aMsgBody )

	{

	if (iMessageBody)

		{

		aMsgBody.InsertL(0, *iMessageBody);

		}

	}

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

// CVMessageParser::StoreMessageBodyL()

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

//

void CVMessageParser::StoreMessageBodyL( CRichText &aMsgBody )

	{

	if (iMessageBody)

		{

		LOGGER_WRITE( "Message body not empty" );

		User::Leave( KErrGeneral );

		}

	TInt bodyLenght =  aMsgBody.DocumentLength();

	if (bodyLenght > 0)

		{

		iMessageBody = HBufC::NewL( bodyLenght );

		TPtr16 ptrBody = iMessageBody->Des();

		aMsgBody.Extract( ptrBody );

		}

	}

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

// CVMessageParser::ParseTelephoneNumber()

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

//

TBool CVMessageParser::ParseTelephoneNumber( const TDesC &aNumberString, TTelephoneNumber &aNumberStore )

	{

	_LIT( KStartMarker, "<" );

	_LIT( KEndMarker, ">" );

    LOGGER_WRITE_1("aNumberString: %S", &aNumberString );

	TInt startMarker = aNumberString.Find( KStartMarker );

	if (startMarker >= 0)

		{

		TInt endMarker = aNumberString.Find( KEndMarker );

		if (endMarker <= (startMarker + 1))

			{

			LOGGER_WRITE( "Incorrect number" );

			return EFalse;

			}

		else // case 1: Abc Pqr <+01234567890>

			{

			TPtrC16 name = aNumberString.Left( startMarker );

			TPtrC16 number = aNumberString.Mid( (startMarker + 1), (endMarker - startMarker - 1) ); 

			AssignDataToBuffer( name, aNumberStore.iName );

			AssignDataToBuffer( number, aNumberStore.iNumber );

			}

		}

	else // just number

		{

		AssignDataToBuffer( aNumberString, aNumberStore.iNumber );

		aNumberStore.iName.Zero();

		}

    LOGGER_WRITE_1("aNumberStore.iName: %S", &aNumberStore.iName);

	return ETrue;

	}

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

// CVMessageParser::ReadMessageHeader()

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

//

TInt CVMessageParser::ReadMessageHeader()

	{

	LOGGER_WRITE( "CVMessageParser::ReadMessageHeader()" );

	TInt err;

	err = FindMessageTagWithValue( KVMsgTagBegin, KVMsgSectionVMsg );

	if (err < 0)

		{

		return err;

		}

	err = ReadTaggedTimeStamp( iUniversalTime );

	if ( err == KErrNone )

		{

		LOGGER_WRITE( "Time stamp tag found, universal time set" );

		}		

	err = GetMessageTagValue( KVMsgTagStatus, iStatus );

	if (err < 0)

		{

		return err;

		}		

	err = GetMessageTagValue( KVMsgTagBox, iFolder );

	if (err < 0)

		{

		return err;

		}

	err = FindMessageTagWithValue( KVMsgTagBegin, KVMsgSectionVCard );

	if (err < 0)

		{

		return err;

		}

	err = ReadVCard( iSender );

	if (err < 0)

		{

		return err;

		}

	err = FindMessageTagWithValue( KVMsgTagBegin, KVMsgSectionVEnv );

	if (err < 0)

		{

		return err;

		}

	else

		{

		err = ReadEnvelope();

		}

	return err;

	}

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

// CVMessageParser::ReadEnvelope()

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

//

TInt CVMessageParser::ReadEnvelope()

	{

	TBuf<KTagAndValueMaxLength> tagValue;

	TInt err( KErrNone );

	err = GetMessageTagValue( KVMsgTagBegin, tagValue );

	if (err < 0)

		{

		return err;

		}

	else if (tagValue.Compare( KVMsgSectionVCard ) == 0)

		{

		TTelephoneNumber recipient;

		err = ReadVCard( recipient );

		if (err < 0)

			{

			return err;

			}

		else

			{

			if (recipient.iNumber.Length() > 0)

			    {

			    iRecipients.Append( recipient );

			    }

			err = FindMessageTagWithValue( KVMsgTagBegin, KVMsgSectionVEnv );

			if (err >= 0)

				{

				err = ReadEnvelope();

				}

			}

		}

	else if (tagValue.Compare( KVMsgSectionVBody ) == 0)

		{

		err = KErrNone;

		}

	else

		{

		LOGGER_WRITE( "Unexpected message tag value" );

		return KErrGeneral;

		}

	return err;

	}

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

// CVMessageParser::ReadTaggedTimestamp()

// Read and parse tagged timestamp from vMessage (optional feature)

// Format: X-NOK-DT:yyyymmddThhmmssZ (example: X-NOK-DT:20060329T091530Z)

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

//	

TInt CVMessageParser::ReadTaggedTimeStamp( TTime& aUniversalTime )

	{

	LOGGER_WRITE( "CVMessageParser::ReadTaggedTimestamp" );	

	TInt err( KErrNone );

	TBuf<20> timeStamp;

	err = GetMessageTagValue( KVMsgTagDateTime, timeStamp, EFalse );

	if ( err < 0 )

		{

		return KErrNotFound;

		}

	LOG( timeStamp );

	if (timeStamp.Length() != 16 || timeStamp[8] != 'T' || timeStamp[15] != 'Z')

		{

		return KErrNotSupported;

		}

	TLex lexYear( timeStamp.Mid( 0, 4 ) );

	TLex lexMonth( timeStamp.Mid( 4, 2 ) );

	TLex lexDay( timeStamp.Mid( 6, 2 ) );

	TLex lexHour( timeStamp.Mid( 9, 2 ) );

	TLex lexMinute( timeStamp.Mid( 11, 2 ) );

	TLex lexSecond( timeStamp.Mid( 13, 2 ) );		

	TInt valYear( 0 );

	TInt valMonth( 0 );

	TInt valDay( 0 );

	TInt valHour( 0 );

	TInt valMinute( 0 );

	TInt valSecond( 0 );

	TBool parseDone( EFalse );		

	if ( lexYear.Val( valYear ) == KErrNone )

		{

		if ( lexMonth.Val( valMonth ) == KErrNone )

			{

			if ( lexDay.Val( valDay ) == KErrNone )

				{

				if ( lexHour.Val( valHour ) == KErrNone )

					{

					if ( lexMinute.Val( valMinute ) == KErrNone )

						{

						if ( lexSecond.Val( valSecond ) == KErrNone )

							{

							parseDone = ETrue;

							}

						}

					}

				}

			}		

		}

	if ( !parseDone )

		{

		return KErrNotSupported;

		}

	TDateTime dateTime;

	TMonth month = static_cast<TMonth>(--valMonth);

	err = dateTime.Set( valYear, month, --valDay, valHour, valMinute, valSecond, 0 );	

	if ( err != KErrNone )

		{

		return KErrNotSupported;

		}

	aUniversalTime = dateTime;	

	return KErrNone; 	

	}		

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

// CVMessageParser::ReadVCard()

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

//

TInt CVMessageParser::ReadVCard( TTelephoneNumber &aResult )

	{		

	TInt err = KErrNone;

	TBuf<KVersionMaxLength> version;

	err = GetMessageTagValue( KVMsgTagVersion, version );

	if (err < 0)

		{

		return err;

		}

	err = GetMessageTagValue( KVMsgTagName, aResult.iName );

	if (err < 0)

		{

		return err;

		}

	err = GetMessageTagValue( KVMsgTagTelephone, aResult.iNumber );

	if (err < 0)

		{

		return err;

		}

	err = FindMessageTagWithValue( KVMsgTagEnd, KVMsgSectionVCard );

	if (err < 0)

		{

		return err;

		}

	return KErrNone;

	}

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

// CVMessageParser::ReadMessageBody()

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

//

TInt CVMessageParser::ReadMessageBodyL()

	{

	LOGGER_WRITE( "CVMessageParser::ReadMessageBody()" );

	TInt err;

	TPtrC pBuf = iReadBuf.Mid( iReadBufPosition );

	err = pBuf.Find( KVMsgLineFeed );

	if (err < 0)

		{

		return err;

		}

	iReadBufPosition += ( err + KVMsgLineFeed().Length() );

	TInt bodyStart = iReadBufPosition;

	TBuf<KDateMaxLength> dateBuf;

	err = GetMessageTagValue(KVMsgTagDate, dateBuf);

	if (err < 0)

		{

		LOGGER_WRITE( "No date field in message body" );

		iReadBufPosition = bodyStart;

		}

	else

		{

		for (TInt i = 0; i < dateBuf.Length(); i++)

			{

			// This is needed, because TTime::Parse() can not handle

			// situation where '.' character is used as a delimiter in date.

			// Expected date format is like 18.1.2005 17:32:50.

			//

			if (dateBuf[i] == ' ')

				{

				break;

				}

			else if (dateBuf[i] == '.')

				{

				dateBuf[i] = '/';

				}

			}

        TLocale locale;

        TDateFormat originalFormat = locale.DateFormat();

        locale.SetDateFormat( EDateEuropean );

        locale.Set(); // transfer the new locale settings to the system

		err = iHomeTime.Parse( dateBuf );

		if ( err < 0 )

			{

			LOGGER_WRITE_1( "Parsing date from message body failed with %d", err );

			iHomeTime = 0;

			}

		locale.SetDateFormat( originalFormat );

		locale.Set(); // transfer the original locale settings back to the system

		TPtrC pDateStart = iReadBuf.Mid( iReadBufPosition );

		err = pDateStart.Find( KVMsgLineFeed );

		if (err < 0)

			{