// Copyright (c) 1997-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 <vcal.h>

#include <vutil.h>

#include <utf.h>

#include <charconv.h>

#include "verror.h"

#include <vstaticutils.h>

#include <vobserv.h>

#include <s32mem.h>

//

// CParserVCal

//

EXPORT_C CParserVCal* CParserVCal::NewL()

/** Allocates and constructs a vCalendar parser.

@return Pointer to the newly created vCalendar parser. */

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;	

	}

CParserVCal::CParserVCal() :CVersitParser(ESupportsVersion)

	{

	iDefaultVersion = KVersitTokenVCalVersionNo;

	}

EXPORT_C void CParserVCal::InternalizeL(RReadStream& aStream)

/** Internalises a vCalendar entity from a read stream.

The presence of this function means that the standard templated operator>>() 

(defined in s32strm.h) is available to internalise objects of this class.

@param aStream Stream from which the vCalendar should be internalised. 

@see CVersitParser::InternalizeL() */

	{

	CVersitParser::InternalizeL(aStream);

	}

EXPORT_C void CParserVCal::ExternalizeL(RWriteStream& aStream)

/** Externalises a vCalendar entity (and all sub-entities) to a write stream. 

Sets the entity name to KVersitVarTokenVCALENDAR if it hasn't already been 

set.

Adds a version property to the start of the current entity's array of properties 

if the entity supports this. (If there isn't an array of properties then one 

is made).

The presence of this function means that the standard templated operator<<() 

(defined in s32strm.h) is available to externalise objects of this class.

@param aStream Stream to which the vCalendar should be externalised. 

@see CVersitParser::ExternalizeL() */

	{

	if (!iEntityName)

		SetEntityNameL(KVersitVarTokenVCALENDAR);

	CVersitParser::ExternalizeL(aStream);

	}

EXPORT_C CVersitParser* CParserVCal::MakeEntityL(TInt aEntityUid,HBufC* aEntityName)

// From CVersitParser

	{

	CVersitParser* newEntity = NULL;

	switch (aEntityUid)

		{

		case KVCalEntityUidVEvent:

		case KVCalEntityUidVTodo:

			newEntity=CParserVCalEntity::NewL();

			CleanupStack::PushL(newEntity);

			break;

		default: //Allows it to read (and ignore) additional iCalendar entities

			newEntity = new(ELeave) CVersitParser(ENoVersionProperty);

			CleanupStack::PushL(newEntity);

			newEntity->ConstructL();

			break;

		}

	if (iObserver)

		iObserver->NewParser(newEntity);

	newEntity->SetAutoDetect(iFlags&EUseAutoDetection,iAutoDetectCharSets);

	if (iFlags&EImportSyncML)

		newEntity->SetFlags(EImportSyncML);

	// make child entries aware of default char set

    if (iFlags&EUseDefaultCharSetForAllProperties)

		newEntity->SetFlags(EUseDefaultCharSetForAllProperties);

	newEntity->SetDefaultCharSet(DefaultCharSet());

	if (iPlugIn)

		{

		newEntity->SetPlugIn(iPlugIn);

		}

	newEntity->InternalizeL(aEntityName, iLineReader);

	CleanupStack::Pop(newEntity);

	return newEntity;

	}

EXPORT_C TUid CParserVCal::RecognizeToken(const TDesC8& aToken) const

// From CVersitParser

/** Returns a UID that identifies a specified token's type.

For example, if aToken contains the property name DAYLIGHT the function returns 

KVersitPropertyDaylightUid. If the token is not recognized as vCalendar-specific, 

the function calls CVersitParser::RecognizeToken(), which recognizes generic Versit 

tokens.

@param aToken The token to be recognized.

@return A defined UID value if the token has been recognized, KVersitTokenUnknownUid 

otherwise. */

	{

	TUid uid = KNullUid;

	TChar firstChar(aToken.Ptr()[0]);

	firstChar=firstChar.GetUpperCase();

	switch (firstChar)

		{

	case 'D':

		if (!aToken.CompareF(KVersitTokenDAYLIGHT))

			uid.iUid = KVersitPropertyDaylightUid;

		break;

	case 'P':

		if (!aToken.CompareF(KVersitTokenPRODID))

			uid.iUid = KVersitPropertyHBufCUid;

		break;

	case 'T':

		if (!aToken.CompareF(KVersitTokenTZ))

			uid.iUid = KVersitPropertyTimeZoneUid;

		break;

	case 'V':

		if (!aToken.CompareF(KVersitTokenVERSION))

			uid.iUid = KVersitTokenVersionUid;

		break;

	default:

		break;

		}

	if (uid == KNullUid)

		return CVersitParser::RecognizeToken(aToken);

	return uid;

	}

EXPORT_C TInt CParserVCal::RecognizeEntityName() const

// From CVersitParser

/** Tests the current value to see if it a vEvent or vTodo entity.

@return KVCalEntityUidVEvent if it is a vEvent entity; KVersitVarTokenVTODO 

if it is a vTodo entity; zero if there is no current property or it has no value. */

	{

	if (iCurrentProperty && iCurrentProperty->Value())

		{

		TPtrC entityName=STATIC_CAST(CParserPropertyValueHBufC*,iCurrentProperty->Value())->Value();

		if (entityName==KVersitVarTokenVEVENT)

			return KVCalEntityUidVEvent;

		else if (entityName==KVersitVarTokenVTODO)

			return KVCalEntityUidVTodo;

		}

	return 0;

	}

EXPORT_C void CParserVCal::Reserved1()

	{}

EXPORT_C void CParserVCal::Reserved2()

	{}

//

// CParserVCalEntity

//

EXPORT_C CParserVCalEntity* CParserVCalEntity::NewL()

/** Allocates and constructs a vCalendar sub-entity parser.

@return A pointer to the new vCalendar sub-entity parser. */

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;	

	}

CParserVCalEntity::CParserVCalEntity()

	: CRecurrenceParser(EFalse)

/** Constructs a vCalendar sub-entity parser. */

	{}

EXPORT_C CParserVCalEntity::~CParserVCalEntity()

/** The destructor is empty. */

	{

	}

EXPORT_C void CParserVCalEntity::ExternalizeL(RWriteStream& aStream)

/** Externalises a vTodo or vEvent to a write stream.

Sets the entity's name to KVersitVarTokenVEVENT if it hasn't already been 

set.

Converts all date/time values from machine-local into universal time. 

The presence of this function means that the standard templated operator<<() 

(defined in s32strm.h) is available to externalise objects of this class. 

@param aStream Stream to which the vTodo or vEvent should be externalised. */

	{

	if (!iEntityName)

		SetEntityNameL(KVersitVarTokenVEVENT);

	CVersitParser::ExternalizeL(aStream);

	}

EXPORT_C CParserPropertyValue* CParserVCalEntity::MakePropertyValueL(const TUid& aPropertyUid,HBufC16*& aValue)

// From CVersitParser

	{

	if(!aValue && !iLargeDataBuf)

		return NULL;

	switch (aPropertyUid.iUid)

		{

		case KVCalPropertyAlarmUid: // won't be recognized except by subclass

			{

			CVersitAlarm* alarm = MakePropertyValueAlarmL(aValue->Des());

			CleanupStack::PushL(alarm);

			CParserPropertyValue* value = new(ELeave) CParserPropertyValueAlarm(alarm);

			CleanupStack::Pop(alarm);

			return value;

			}

		case KVCalPropertyExtendedAlarmUid: // won't be recognized except by subclass

			{

			CVersitExtendedAlarm* richAlarm = NULL;

			if (aValue)

				{

				richAlarm = MakePropertyValueExtendedAlarmL(aValue->Des());

				}

			else

				{

				richAlarm = MakePropertyValueExtendedAlarmL(*iLargeDataBuf);

				}

			CleanupStack::PushL(richAlarm);

			CParserPropertyValue* value = new(ELeave) CParserPropertyValueExtendedAlarm(richAlarm);

			CleanupStack::Pop(richAlarm);

			return value;

			}

		case KVCalPropertyRecurrenceUid:

			{

			TPtr val=aValue->Des();

			return MakePropertyValueRecurrenceL(val);

			}

		default:

			break;

		};

	return CVersitParser::MakePropertyValueL(aPropertyUid,aValue);

	}

EXPORT_C CVersitAlarm* CParserVCalEntity::MakePropertyValueAlarmL(TPtr16 aAlarmValue)

//Make an Alarm property from stream

	{

	TPtrC8 propName=iCurrentProperty->Name();

	TPtr16 field(NULL,0);

	FindFirstField(field,aAlarmValue);

	TVersitDateTime* runTime=NULL;

	if(field.Length()>0)

		runTime = DecodeDateTimeL(field);

	CleanupStack::PushL(runTime);

	FindFirstField(field,aAlarmValue);

	TTime* snoozeTime = NULL;

	if(field.Length()>0)

		snoozeTime = DecodeTimePeriodL(field);

	CleanupStack::PushL(snoozeTime);

	FindFirstField(field,aAlarmValue);

	TInt repeatCount=0;

	if(field.Length()>0)

		Val(field, repeatCount);

	if (propName==KVersitTokenAALARM || propName==KVersitTokenMALARM)

		FindFirstField(field,aAlarmValue);

	else

		field.Zero();

	TPtr16 note(NULL,0);

	if (propName!=KVersitTokenAALARM)

		FindFirstField(note,aAlarmValue);

	CVersitAlarm* alarm = CVersitAlarm::NewL(runTime, snoozeTime, repeatCount, field, note);

	CleanupStack::Pop(2,runTime);

	return alarm; //alarm takes ownership of runTime and snoozeTime

	}

/** Create a new extended alarm from a stream.

The MIME type is set to the creating object's MIME type.

The disposition is set to the creating object's disposition.  

@param aAlarmValue a pointer to a buffer containing the assocaited data for the alarm. Should not point to an empty 

descriptor.

@return The newly created extended alarm. */

EXPORT_C CVersitExtendedAlarm* CParserVCalEntity::MakePropertyValueExtendedAlarmL(TPtr16 aAlarmValue)

	{

	TPtrC8 propName=iCurrentProperty->Name();

	TPtr16 field(NULL,0);

	// Note: the presence of this property means that

	// the parameters VALUE and X-CONTENTTYPE should be present; if not

	// present, then INLINE rich data shall be assumed

	TPtrC8 mimeType(NULL,0);

	TPtrC8 dispositionField(NULL,0);

	// content-value-type assumes default is INLINE if parameter not present

	CVersitExtendedAlarm::TDisposition disposition = CVersitExtendedAlarm::EDispositionInline;

	// read in data content-type

	CParserParam* alarmParameter = iCurrentProperty->Param(KVersitTokenCONTENTTYPE);

	if (alarmParameter)

		{

		mimeType.Set(alarmParameter->Value());

		}

	// read in data content-value-type

	alarmParameter = iCurrentProperty->Param(KVersitTokenVALUE);

	if (alarmParameter)

		{

		dispositionField.Set(alarmParameter->Value());

		// if there is a value, convert from text to enum

		if (dispositionField.Length())

			{

			disposition = DecodeDisposition(dispositionField);

			}

		}

	FindRemainingField(field,aAlarmValue);

	CVersitExtendedAlarm* alarm = CVersitExtendedAlarm::NewL(field.Collapse(), mimeType, disposition);

	return alarm; 

	}

/** Create a new extended alarm from a buffer.

The MIME type is set to the creating object's MIME type.

The disposition is set to the creating object's disposition. 

@param aAlarmValue a reference to a buffer containing the assocaited data for the alarm. Should not be an empty 

buffer.

@return The newly created extended alarm. */	

EXPORT_C CVersitExtendedAlarm* CParserVCalEntity::MakePropertyValueExtendedAlarmL(CBufSeg& aAlarmValue)

	{

	TPtrC8 propName=iCurrentProperty->Name();

	TPtr16 field(NULL,0);

	// Note: the presence of this property means that

	// the parameters VALUE and CONTENTTYPE should be present; if not

	// present, then MIME rich data shall be assumed

	TPtrC8 mimeType(NULL,0);

	TPtrC8 dispositionField(NULL,0);

	// content-value-type assumes INLINE if parameter not present

	CVersitExtendedAlarm::TDisposition disposition = CVersitExtendedAlarm::EDispositionInline;

	// read in data content-type

	CParserParam* alarmParameter = iCurrentProperty->Param(KVersitTokenCONTENTTYPE);

	if (alarmParameter)

		{

		mimeType.Set(alarmParameter->Value());

		}

	// read in disposition

	alarmParameter = iCurrentProperty->Param(KVersitTokenVALUE);

	if (alarmParameter)

		{

		dispositionField.Set(alarmParameter->Value());

		// if there is a value, convert from text to enum

		if (dispositionField.Length())

			{

			disposition = DecodeDisposition(dispositionField);

			}

		}

	// read in rich data content

	// For this version of MakePropertyValueExtendedAlarmL, we have the 

	// data in a CBufSeg that should already have been decoded from BASE64

	// (assuming everything else works properly). So we need to get it into 

	// a TBufC8

	TInt segSize = aAlarmValue.Size();

	HBufC8* content = HBufC8::NewLC(segSize);

	TPtr8 ptrContent(content->Des());

	aAlarmValue.Read(0, ptrContent, segSize);

	CVersitExtendedAlarm* alarm = CVersitExtendedAlarm::NewL(ptrContent, mimeType, disposition);

	CleanupStack::PopAndDestroy(content);

	return alarm; 

	}

/** Used to find the type of the content disposition: inline, URL, or unknown.

Converts content-value-type token field to content-value-type enum.

@param aContentDisposition The disposition of the data for the alarm action.

@return decoded disposition type */

EXPORT_C CVersitExtendedAlarm::TDisposition CParserVCalEntity::DecodeDisposition(const TDesC8& aContentDisposition) const

	{

	if (!aContentDisposition.CompareF(KVersitTokenINLINE))

		{

		return CVersitExtendedAlarm::EDispositionInline;

		};

	if (!aContentDisposition.CompareF(KVersitTokenURL))

		{

		return CVersitExtendedAlarm::EDispositionUrl;

		};

	return CVersitExtendedAlarm::EDispositionUnknown;

	}

/*

 * Try to recognize aToken and return a UID for it. 

 * Call <code>CVersitParser::RecognizeToken()</code>

 * which recognizes generic Versit tokens if the token has not been 

 * recognized in this function 

 *

 * @param     " const TDesC8& aToken "

 *            The token to be recognized

 * @return    " TUid "

 *            a defined UID value if the token has been recognized, 

 *				<code>KVersitTokenUnknownUid</code>, otherwise

 */

EXPORT_C TUid CParserVCalEntity::RecognizeToken(const TDesC8& aToken) const

// From CVersitParser

	{

	TUid uid = KNullUid;

	TChar firstChar(aToken.Ptr()[0]);

	firstChar=firstChar.GetUpperCase();

	switch (firstChar)

		{

	case 'A':	

		if (!aToken.CompareF(KVersitTokenAALARM))

			uid.iUid = KVCalPropertyAlarmUid;

		else if (!aToken.CompareF(KVersitTokenATTENDEE))

			uid.iUid = KVersitPropertyHBufCUid;

		else if (!aToken.CompareF(KVersitTokenATTACH))

			{

			if(iCurrentProperty)

				{//If it is internalising, iCurrentProperty is set

				uid.iUid = KVersitPropertyBinaryUid;//In vCal standard, default value is binary

				CParserParam* valueParam = iCurrentProperty->Param(KVersitTokenVALUE);

				if (valueParam)

					{

					TPtrC8 pParameterValue(valueParam->Value());

					if (pParameterValue.CompareF(KVersitTokenINLINE) && pParameterValue.CompareF(KVersitTokenBINARY))

						{//If VALUE isn't specified as INLINE or BINARY, value is text type.

						uid.iUid = KVersitPropertyHBufCUid;			

						}

					}

				}

			}

		break;

	case 'C':

		if (!aToken.CompareF(KVersitTokenCATEGORIES))

			uid.iUid = KVersitPropertyCDesCArrayUid;

		else if (!aToken.CompareF(KVersitTokenCLASS))

			uid.iUid = KVersitPropertyHBufCUid;

		else if (!aToken.CompareF(KVersitTokenCOMPLETED))

			uid.iUid = KVersitPropertyDateTimeUid;

		break;

	case 'D':

		if (!aToken.CompareF(KVersitTokenDALARM))

			uid.iUid = KVCalPropertyAlarmUid;

		else if (!aToken.CompareF(KVersitTokenDCREATED) ||

				!aToken.CompareF(KVersitTokenDTEND) ||

				!aToken.CompareF(KVersitTokenDTSTART) ||

				!aToken.CompareF(KVersitTokenDUE))

			uid.iUid = KVersitPropertyDateTimeUid;

		else if(!aToken.CompareF(KVersitTokenDESCRIPTION))

			uid.iUid = KVersitPropertyHBufCUid;

		break;

	case 'E':

		if (!aToken.CompareF(KVersitTokenEXDATE))

			uid.iUid = KVersitPropertyMultiDateTimeUid;

		else if (!aToken.CompareF(KVersitTokenEXRULE))

			uid.iUid = KVCalPropertyRecurrenceUid;

		break;

	case 'G':

		if (!aToken.CompareF(KVersitTokenGEO))

			uid.iUid = KVersitPropertyHBufCUid;

		break;	

	case 'L':

		if (!aToken.CompareF(KVersitTokenLASTMODIFIED))

			uid.iUid = KVersitPropertyDateTimeUid;

		else if(!aToken.CompareF(KVersitTokenLOCATION))

			uid.iUid = KVersitPropertyHBufCUid;

		break;

	case 'M':

		if (!aToken.CompareF(KVersitTokenMALARM))

			uid.iUid = KVCalPropertyAlarmUid;

		break;

	case 'P':

		if (!aToken.CompareF(KVersitTokenPALARM))

			uid.iUid = KVCalPropertyAlarmUid;