// 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 <s32mem.h>

#include <vtzrules.h>

#include <utf.h>

#include <tz.h>

#include <calentry.h>

#include <calcontent.h>

#include <calrrule.h>

#include <caluser.h>

#include <calalarm.h>

#include <calattachment.h>

#include "agmvcal.h"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <vpropbinaryfile.h>

#endif

/** Specifies number of years backward from current year for which DAYLIGHT properties are exported.*/

const TInt KDaylightPropertyYearsBackwards(2);

/** Specifies number of years forward from current year, or the repeat start year, for which DAYLIGHT properties are exported.*/

const TInt KDaylightPropertyYearsForwards(5);

// Utility method to ensure proper cleanup in OOM 

//

void CAgendaEntryToVCalConverter::ResetAndDestroyArrayOfParams(TAny* aObject)

	{

	CArrayPtr<CParserParam>* array=reinterpret_cast<CArrayPtr<CParserParam>*>(aObject);

	if (array)

		{

		array->ResetAndDestroy();

		}

	delete array;

	}

void CAgendaEntryToVCalConverter::ResetAndDestroyArrayOfVersitDateTime(TAny* aObject)

	{

	CArrayPtr<TVersitDateTime>* array=reinterpret_cast<CArrayPtr<TVersitDateTime>*>(aObject);

	if (array)

		{

		array->ResetAndDestroy();

		}

	delete array;

	}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

 *	Public

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

// Export agenda entry aEntry to the given parser

//

void CAgendaEntryToVCalConverter::ExportEntryL(CCalEntry* aEntry, CVersitParser& aParser)

	{

	CParserVCalEntity* entity = CParserVCalEntity::NewL();

	CleanupStack::PushL(entity);

	if (aEntry->EntryTypeL() == CCalEntry::ETodo)

		{

		entity->SetEntityNameL(KVersitVarTokenVTODO);

		}

	else

		{

		entity->SetEntityNameL(KVersitVarTokenVEVENT);

		}

	if ((aEntry->StartTimeL()).TimeMode() == TCalTime::EFloating)

		{

		iTimeType = TVersitDateTime::EIsMachineLocal;

		iTimeFlag = TVersitDateTime::EExportLeaveAsLocalTime;

		}

	else 

		{

		iTimeType=TVersitDateTime::EIsUTC;

		iTimeFlag=TVersitDateTime::EExportTimeZoneDesignator;

		}

	AddEntryPropertiesL(aEntry, *entity);

	CleanupStack::Pop(); // entity

	aParser.AddEntityL(entity); // takes ownership

	}

CAgendaEntryToVCalConverter::~CAgendaEntryToVCalConverter()

	{

	}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

 *	Private

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

/** AddTzPropertyL()

 *

 *	Adds TZ property to aParser.

 *

 *	@param aParser		- a vCal entity or sub-entity (VEVENT or VTODO);

 *	@param aStdOffset	- standard time zone offset from UTC in seconds.

 */

void CAgendaEntryToVCalConverter::AddTzPropertyL(CVersitParser& aParser, 

												 TTimeIntervalSeconds aStdOffsetInSeconds)

	{

	if (!iAddedTzProperty)

		{

		CParserPropertyValue* vValue = new (ELeave) CParserPropertyValueTimeZone(aStdOffsetInSeconds);

		CleanupStack::PushL(vValue);

		CParserProperty* vProp = CParserProperty::NewL(*vValue, KVersitTokenTZ, NULL); 

		CleanupStack::Pop(vValue);

		aParser.AddPropertyL(vProp);

		}

	iAddedTzProperty = ETrue;

	}

/** MapToRelativeTime()

 *

 *	Provides mapping between iTimeReference of TVTzActualisedRule and iRelativeTime of TVersitDateTime. 

 *

 *	CTzRules::AddActualisedRulesL() guarantees that TVTzActualisedRule is always UTC or 

 *	local(ETzWallTimeReference), and is never STD. The func maps everything to 

 *	TVersitDateTime::EIsMachineLocal, unless iTimeReference is ETzUtcTimeReference, which is mapped

 *  to TVersitDateTime::EIsUTC.

 *

 *	This is local helper function.

 *	Used exclusively by CAgendaEntryToVCalConverter::AddTimeZonePropertiesL() to export DAYLIGHT properties.

 */

static inline TVersitDateTime::TRelativeTime MapToRelativeTime(TTzTimeReference& aTzTimeRef)

	{

	return (aTzTimeRef==ETzUtcTimeReference) ? (TVersitDateTime::EIsUTC) : (TVersitDateTime::EIsMachineLocal);

	}

/*	AddDaylightPropertyL()

 *

 *	Export a DAYLIGHT property to describe the daylight saving period and its offset.

 *	There can be more than one DAYLIGHT property for a year (depenging on number of DST rules for the year).  

 *	Time designators (i.e EST, EDT) are not exported.

 *

 *	@param aParser		- a vCal entity or sub-entity (VEVENT or VTODO);

 *	@param aOffsetInSeconds	 - offset in seconds from UTC (i.e. STD + DST) for the period when the 

 					 	  daylight saving rule is in effect, 

 						  for instance, for time zone "Vancouver/America (PST)" aOffsetInSeconds is

 						  -480*60=-28800 secs in winter time, and -420*60=-25200 secs when DST is observed; 

 *	@param aStartTime	- exact time when a rule starts (usually 02:00:00 local time);

 *	@param aEndTime		- time when rule ends (usually 03:00:00 local time).

 */

void CAgendaEntryToVCalConverter::AddDaylightPropertyL(CVersitParser& aParser, 

													   TTimeIntervalSeconds aOffsetInSeconds,

													   TTimeWithReference aStartTime,

													   TTimeWithReference aEndTime)

	{

	TVersitDateTime* vStartTime = new(ELeave) TVersitDateTime(aStartTime.iTime.DateTime(),

															  MapToRelativeTime(aStartTime.iTimeReference));

	CleanupStack::PushL(vStartTime);

	TVersitDateTime* vEndTime = new (ELeave) TVersitDateTime(aEndTime.iTime.DateTime(),

															  MapToRelativeTime(aEndTime.iTimeReference));

	CleanupStack::PushL(vEndTime);

	CVersitDaylight* vDaylight = CVersitDaylight::NewL(ETrue, 

													  aOffsetInSeconds, 

													  vStartTime, 

													  vEndTime, 

													  KNullDesC(), 

													  KNullDesC());

	CleanupStack::Pop(vEndTime);   // CVersitDaylight takes ownership.

	CleanupStack::Pop(vStartTime); // CVersitDaylight takes ownership.

	CleanupStack::PushL(vDaylight);

	CParserPropertyValue* vValue = new (ELeave) CParserPropertyValueDaylight(vDaylight);

	CleanupStack::Pop(vDaylight);

	CleanupStack::PushL(vValue);

	CParserProperty* vProp = CParserProperty::NewL(*vValue, KVersitTokenDAYLIGHT, NULL); 

	CleanupStack::Pop(vValue);

	aParser.AddPropertyL(vProp);

	}

/**	Adds DAYLIGHT properties for a range of years from aStartYear to aEndYear inclusive to 

 *	a vCalendar entity (aParser).

 *	

 *	@param aParser		- a vCalendar object where properties added

 *	@param aRules		- time zone rules used to retrieve DST information

 *	@param aRepeatStartTime		- start of entry range, including the repeat rule

 *	@param aRepeatEndTime		- end of entry range, including the repeat rule

 *

 */

void CAgendaEntryToVCalConverter::AddDaylightPropertiesL(CVersitParser& aParser, const CTzRules* aRules, TInt aStdOffset, TTime aRepeatStartTime, TTime aRepeatEndTime)

	{

	const TInt KRepeatStartYear = aRepeatStartTime.DateTime().Year();

	const TInt KRepeatEndYear = aRepeatEndTime.DateTime().Year();

 	// actualise the rules starting a year before our period of interest

	CVTzActualisedRules* actRules = CVTzActualisedRules::NewL(KRepeatStartYear - 1, KRepeatEndYear + 1);

	if (actRules)

		{

		CleanupStack::PushL(actRules);

		aRules->GetActualisedRulesL(*actRules);

		TTime now;

		now.HomeTime();

		const TInt KThisYear = now.DateTime().Year();

		// Set up the time range for exported DAYLIGHT properties

		const TInt KRangeBeginYear(Max(KThisYear - KDaylightPropertyYearsBackwards, KRepeatStartYear));

		const TInt KRangeEndYear(Min(Max(KThisYear + KDaylightPropertyYearsForwards, KRepeatStartYear + KDaylightPropertyYearsForwards), KRepeatEndYear + 1));

		const TTime KRangeBeginTime(TDateTime(KRangeBeginYear, EJanuary, 0, 0, 0, 0, 0));

		const TTime KRangeEndTime(TDateTime(KRangeEndYear, EJanuary, 0, 0, 0, 0, 0));

		const TInt KRulesCount(actRules->Count());

		for (TInt i(0) ; i < KRulesCount - 1 ; ++i)

			{

			TVTzActualisedRule& actRule = (*actRules)[i];

			if (aStdOffset < actRule.iNewOffset)		// work with DST rules only

				{

				// End time of a rule is start time of the next rule

				TVTzActualisedRule& actRuleNext = (*actRules)[i+1];

				TTimeWithReference ruleStart(TTimeWithReference(actRule.iTimeOfChange, actRule.iTimeReference));

				TTimeWithReference ruleEnd(TTimeWithReference(actRuleNext.iTimeOfChange, actRuleNext.iTimeReference));

				TTime ruleStartTime = ruleStart.iTime;

				TTime ruleEndTime = ruleEnd.iTime;

				if (actRule.iTimeReference == ETzStdTimeReference)

					{

					ruleStartTime -= TTimeIntervalMinutes(aRules->InitialStdTimeOffset());

					}

				else if (actRule.iTimeReference == ETzWallTimeReference)

					{

					ruleStartTime -= TTimeIntervalMinutes(actRule.iNewOffset);

					}						

				if (actRule.iTimeReference == ETzStdTimeReference)

					{

					ruleEndTime -= TTimeIntervalMinutes(aRules->InitialStdTimeOffset());

					}

				else if (actRule.iTimeReference == ETzWallTimeReference)

					{

					ruleEndTime -= TTimeIntervalMinutes(actRule.iNewOffset);

					}	

				// Export rule if the first instance occours when dst is on

				// or if the rule covers the range defined above

				if ( (aRepeatStartTime >= ruleStartTime) && (aRepeatStartTime <= ruleEndTime) || (ruleEndTime >= KRangeBeginTime) && (ruleStartTime <= KRangeEndTime) )

					{

					// Export DAYLIGHT property for concrete DST rule

					AddDaylightPropertyL(aParser, actRule.iNewOffset * 60, ruleStart, ruleEnd);

					}

				}

			}

		CleanupStack::PopAndDestroy(actRules);

		}

	}

void CAgendaEntryToVCalConverter::NextVCalendarL()

	{

	iAddedTzProperty = EFalse;

	}

/**	CAgendaEntryToVCalConverter::AddTimeZonePropertiesL()

 *	 	

 *	Adds TZ and DAYLIGHT properties to a vCalendar entity. 

 *

 *	@param aEntry 	- an agenda entry which supplies timezone and tz rules information 

 *						(has to have a repeat definition, otherwise function will do nothing);

 *	@param aParser	- a vCalendar object to which the properties are added. 

 *	

 *	aParser can be 1) a vCalendar object (also referrred to as "vCalendar entity"), 

 *		as well as 2) a vEvent or vTodo objects (also referred to as "vCalendar sub-entities").

 *	

 *	TZ and DAYLIGHT properties (as per vCalendar v1.0 spec) apply to the vCalendar object as a whole; UNLESS 

 *	overriden by a property within the scope of an event or todo entity.

 *	

 *	@internalComponent

 */

void CAgendaEntryToVCalConverter::AddTimeZonePropertiesL(CVersitParser& aParser, CCalEntry* aEntry)

	{

	TCalRRule rrule;

  	if (aEntry->GetRRuleL(rrule) && aEntry->StartTimeL().TimeMode() != TCalTime::EFloating)

		{

		// Only export the TZ property when the entry is repeating.

		// Do not export TZ rules for floating entry.

		CTzRules* rules = aEntry->TzRulesL();

		if (rules)

			{

    		CleanupStack::PushL( rules );

            // find the standard offset for this time zone

            // which is the lowest offset from the rules for the entry's repeat range

            CVTzActualisedRules* actRules = CVTzActualisedRules::NewL(rrule.DtStart().TimeUtcL().DateTime().Year() - 1, rrule.Until().TimeUtcL().DateTime().Year() + 1);

        	CleanupStack::PushL(actRules);

        	rules->GetActualisedRulesL(*actRules);

        	TInt stdOffset(KMaxTInt);

        	const TInt KRulesCount = actRules->Count();

        	for (TInt i(0) ; i < KRulesCount ; ++i)

        		{

        		if ((*actRules)[i].iNewOffset < stdOffset)

        			{

        			stdOffset = (*actRules)[i].iNewOffset;

        			}

        		}

        	if (stdOffset == KMaxTInt)

        		{

        		// there were no offsets found so use the current system utc offset

        		stdOffset = (User::UTCOffset().Int() / 60);

        		}

        	CleanupStack::PopAndDestroy(actRules);

			AddTzPropertyL(aParser, stdOffset * 60);

			AddDaylightPropertiesL(aParser, rules, stdOffset, rrule.DtStart().TimeUtcL(), rrule.Until().TimeUtcL());

			CleanupStack::PopAndDestroy(rules);	

			}

		}

	}

// This function specifies the ordering of the vCalendar properties as exported by Versit.

//

// The UID property should be the first property. 

//

// The following three properties of a vCalendar should be DESCRIPTION, DTSTART and DTEND for appointments, 

// anniversaries & events. To-do entries should have DESCRIPTION and DUE as the following two properties.

// This is to assist processing by Connectivity (as requested by Time Technology)

//

void CAgendaEntryToVCalConverter::AddEntryPropertiesL(CCalEntry* aEntry, CVersitParser& aParser)

	{

	// UID 

	HBufC* guid16 = HBufC::NewLC(aEntry->UidL().Length());

	TPtr ptr16 = guid16->Des();

	CnvUtfConverter::ConvertToUnicodeFromUtf8(ptr16, aEntry->UidL());

	AddDesPropertyL(aParser, KVersitTokenUID, guid16->Des());

	CleanupStack::PopAndDestroy(guid16);

	// CAgnEntry::RichTextL()	=> SUMMARY 

	// CAgnEntry::NotesTextL()	=> DESCRIPTION 

	if (aEntry->DescriptionL().Length() > 0)

		{

		AddDesPropertyL(aParser, KVersitTokenDESCRIPTION, aEntry->DescriptionL());					

		}

	if (aEntry->SummaryL().Length() > 0)

		{

		AddDesPropertyL(aParser, KVersitTokenSUMMARY, aEntry->SummaryL());

		}

	// Add DTSTART and DTEND (or DUE, PRIORITY and todo list information for to-do items), then add X-EPOCAGENDAENTRYTYPE

	switch (aEntry->EntryTypeL())

		{

		case CCalEntry::EAppt:

			{

			AddEventPropertiesL(aParser, aEntry);

			AddDesPropertyL(aParser, KVCalToken8ENTRYTYPE, KVCalTokenTypeAPPT);	

			break;

			}

		case CCalEntry::EReminder:

			{

			AddEventPropertiesL(aParser, aEntry);

			AddDesPropertyL(aParser, KVCalToken8ENTRYTYPE, KVCalTokenTypeREMINDER);	

			break;

			}

		case CCalEntry::EAnniv:

			{

			AddEventPropertiesL(aParser, aEntry);

			AddDesPropertyL(aParser, KVCalToken8ENTRYTYPE, KVCalTokenTypeANNIV);

			break;

			}

		case CCalEntry::EEvent:

			{

			AddEventPropertiesL(aParser, aEntry);

			AddDesPropertyL(aParser, KVCalToken8ENTRYTYPE, KVCalTokenTypeEVENT);

			break;

			}

		case CCalEntry::ETodo:

			{

			AddTodoPropertiesL(aParser, aEntry);

			AddDesPropertyL(aParser, KVCalToken8ENTRYTYPE, KVCalTokenTypeTODO);

			break;

			}

		default: break;

		}

	// Class

	CCalEntry::TReplicationStatus status = aEntry->ReplicationStatusL();

	switch(status)

		{

		case CCalEntry::EOpen:

			AddDesPropertyL(aParser, KVersitTokenCLASS, KVCalTokenPUBLIC);

			break;

		case CCalEntry::EPrivate:

			AddDesPropertyL(aParser, KVersitTokenCLASS, KVCalTokenPRIVATE);

			break;

		case CCalEntry::ERestricted:

			AddDesPropertyL(aParser, KVersitTokenCLASS, KVCalTokenCONFIDENTIAL);

			break;

		}

	// Location

	const TDesC& location = aEntry->LocationL();

	if (location.Length() != 0)

		{

		AddDesPropertyL(aParser, KVersitTokenLOCATION, location);

		}

	// DTSTAMP

	TCalTime dTStamp = aEntry->DTStampL();

   	if ( dTStamp.TimeUtcL() != Time::NullTTime() )

      	{	

		AddDateTimePropertyL(aParser, KVersitTokenXDTSTAMP, dTStamp.TimeUtcL(), TVersitDateTime::EIsUTC, iTimeFlag);

      	}

	// Sequence Number

	AddIntegerPropertyL(aParser, KVersitTokenSEQUENCE, aEntry->SequenceNumberL());

	//X-Method property

	CCalEntry::TMethod methodStatus = aEntry->MethodL();

	TPtrC methodStr;

	switch(methodStatus)

		{

		case  CCalEntry::EMethodNone:

			methodStr.Set(KVCalTokenMethodStatusENone);

			break;

		case CCalEntry::EMethodPublish:

			methodStr.Set(KVCalTokenMethodStatusEPublish);

			break;

		case CCalEntry::EMethodRequest:

			methodStr.Set(KVCalTokenMethodStatusERequest);

			break;

		case CCalEntry::EMethodReply:

			methodStr.Set(KVCalTokenMethodStatusEReply);

			break;

		case CCalEntry::EMethodAdd:

			methodStr.Set(KVCalTokenMethodStatusEAdd);

			break;

		case CCalEntry::EMethodCancel:

			methodStr.Set(KVCalTokenMethodStatusECancel);

			break;

		case CCalEntry::EMethodRefresh:

			methodStr.Set(KVCalTokenMethodStatusERefresh);

			break;

		case CCalEntry::EMethodCounter:

			methodStr.Set(KVCalTokenMethodStatusECounter);

			break;

		case CCalEntry::EMethodDeclineCounter:

			methodStr.Set(KVCalTokenMethodStatusEDeclineCounter);

			break;	

		default:

			User::Leave(KErrArgument);	

		}

	AddDesPropertyL(aParser, KVersitTokenXMETHOD, methodStr);

	// X-Recurrence-ID

	TCalTime recurrenceDate = aEntry->RecurrenceIdL();

	if (recurrenceDate.TimeUtcL() != Time::NullTTime())

		{

		TTime recId;

		if(iTimeType==TVersitDateTime::EIsUTC)

			{

			recId = recurrenceDate.TimeUtcL();

			}

		else

			{

			recId = recurrenceDate.TimeLocalL();

			}

		AddDateTimePropertyL(aParser, KVersitTokenXRECURRENCEID, recId, iTimeType, iTimeFlag);	

		}

	// Attendees

	RPointerArray<CCalAttendee> attendees = aEntry->AttendeesL();

	TInt count=attendees.Count();

	CCalUser* phoneowner=aEntry->PhoneOwnerL();

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

		{

		if(phoneowner==attendees[ii])

			{

			AddAttendeePropertyL(aParser, attendees[ii],ETrue, EFalse);

			}

		else

			{

			AddAttendeePropertyL(aParser, attendees[ii],EFalse, EFalse);

			}

		}

	CCalUser* organizer=aEntry->OrganizerL();

	if(organizer)

		{

		if(phoneowner==organizer)

			{

			AddAttendeePropertyL(aParser, organizer,ETrue, ETrue);

			}

		else

			{

			AddAttendeePropertyL(aParser, organizer,EFalse, ETrue);

			}

		}