/*

* Copyright (c) 2002-2004 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:   This file contains iCal exporter implementation.

*                Converts symbian agenda entries to iCal data.

*

*/

// Class include.

#include "AgnVersit2Exporter.h"

//debug

#include "calendarengines_debug.h"

// Agenda includes.

#include <calalarm.h>					// CCalAlarm

#include <calcategory.h>				// CCalCategory

#include <calentry.h>					// CCalEntry

#include <calrrule.h>					// TCalRRule

#include <caluser.h>					// CCalUser

#include <vtzrules.h>					// CVTzActualisedRules

// Versit includes.

#include "ICal.h"						// CICal

#include "ICalComponent.h"				// CICalComponent

#include "ICalKeyWords.h"				// Literals used during export

#include "ICalProperty.h"				// CICalProperty

#include "ICalValue.h"					// CICalValue

#include "ICalBase.h"					// TICalMethod

// AgnVersit2 includes.

#include "AgnVersit2StringProvider.h"	// CAgnVersit2StringProvider

#include "AgnExternalInterface.h"		// TAgnEntryExport

// Constants for timezone RRULE

_LIT(KRRuleFreqYearly, "FREQ=YEARLY;BYMONTH=");

_LIT(KRRuleByMonthDay, ";BYMONTHDAY=");

_LIT(KRRuleByDayPlus, ";BYDAY=+");

_LIT(KRRuleByDayPlusOne, ";BYDAY=+1");

_LIT(KRRuleByDayMinusOne, ";BYDAY=-1");

//iCalendar version number

_LIT(KICalVersionNumber,"2.0");

// Maximum characters in a GEO value should be 11 = -NNN.NNNNNN

const TUint KGEOMaxWidthOfGeoValue = 11;

/** A semi-colon character. */

const TUint KAgnVersitTokenSemiColonVal =';';

// Constant integer values

const TInt KMaxOffsetMinutes = 720; //12 hours * 60 minutes

const TInt KMinOffsetMinutes = -720; //-12 hours * 60 minutes

const TInt KSecondsInOneMinute = 60;

const TInt KInitialRRuleLength = 150; //RRule line length

const TInt KMaxBufLength = 80;	//Max time zone name length

/**

Constructs a new CAgnVersit2Exporter and returns it.

@param aObserver Application interface for error reporting.

@param aWriteStream Stream to write output to.

@param aStringProvider localisable string resources

@return The new CAgnVersit2Exporter

@internalTechnology

*/

CAgnVersit2Exporter* CAgnVersit2Exporter::NewL(CAgnVersit2StringProvider& aStringProvider)

	{

	TRACE_ENTRY_POINT;

	CAgnVersit2Exporter* self = CAgnVersit2Exporter::NewLC(aStringProvider);

	CleanupStack::Pop(self);

	TRACE_EXIT_POINT;

	return self;

	}

/**

Constructs a new CAgnVersit2Exporter and returns it.

A pointer to the new object is left on the cleanup stack.

@param aObserver Application interface for error reporting.

@param aWriteStream Stream to write output to.

@param aStringProvider localisable string resources

@return The new CAgnVersit2Exporter

@internalTechnology

*/

CAgnVersit2Exporter* CAgnVersit2Exporter::NewLC(CAgnVersit2StringProvider& aStringProvider)

	{

	TRACE_ENTRY_POINT;

	CAgnVersit2Exporter* self = new (ELeave) CAgnVersit2Exporter(aStringProvider);

	CleanupStack::PushL(self);

	self->ConstructL();

	TRACE_EXIT_POINT;

	return self;

	}

/**

Destructor.

@internalTechnology

*/

CAgnVersit2Exporter::~CAgnVersit2Exporter()

	{

	TRACE_ENTRY_POINT;

	iTzNameArray.ResetAndDestroy();

	iTimeZoneArray.ResetAndDestroy();

	TRACE_EXIT_POINT;

	}

/**

Exports an array of calendar entries to a single iCalendar

@param aEntries array of entries to export.

@param aFlags not used.

@internalTechnology

*/

void CAgnVersit2Exporter::ExportL( RPointerArray<CCalEntry>& aEntries,

                                   RWriteStream& aWriteStream,

                                   TUint aExportFlags,

                                   MAgnExportObserver& aObserver )

	{

	TRACE_ENTRY_POINT;

	//We are exporting more than one entry to a single iCalendar. 

	//Clear the time zone arrays, otherwise if this function is called twice

	//components in this iCalendar may reference timezone components in a preceding

	//iCalendar.

	iTzNameArray.ResetAndDestroy();

	iTimeZoneArray.ResetAndDestroy();

	iExportProperties = aExportFlags;

	iObserver = &aObserver;

	ASSERT( aEntries.Count() > 0 );

	CICal* cal = AddICalLC(*aEntries[0]);

	TInt entryCount = aEntries.Count();

	TRAPD(err,

		for (TInt x = 0; x < entryCount; ++x)

			{

			if (iExportProperties & KAgnExportTzRules)

				{

				AddTimezoneL(*cal, *aEntries[x]);

				}

			AddComponentL(*cal, *aEntries[x]);

			}

		); //End TRAP

	User::LeaveIfError(err);

	cal->ExternalizeL(aWriteStream);

	CleanupStack::PopAndDestroy(cal);

	TRACE_EXIT_POINT;

	}

/**

Exports a given calendar entry.

@param aEntry entry to export.

@param aFlags not used.

@internalTechnology

*/

void CAgnVersit2Exporter::ExportL( const CCalEntry& aEntry,

                                   RWriteStream& aWriteStream,

                                   TUint aExportFlags,

                                   MAgnExportObserver& aObserver )

	{

	TRACE_ENTRY_POINT;

	//If we are exporting a single iCalendar per entry, we want to include the timezone

	//even if we have previously encountered it.  We do this by clearing the time zone 

	//name array

	iTzNameArray.ResetAndDestroy();

	iTimeZoneArray.ResetAndDestroy();

	iExportProperties = aExportFlags;

	iObserver = &aObserver;

	CICal* cal = AddICalLC(aEntry);

	TRAPD(err,

		if (iExportProperties & KAgnExportTzRules)

			{

			AddTimezoneL(*cal, aEntry);

			}

			AddComponentL(*cal, aEntry);

		);

	User::LeaveIfError(err);

	cal->ExternalizeL(aWriteStream);

	CleanupStack::PopAndDestroy(cal);

	TRACE_EXIT_POINT;

	}

/**

Constructor.

@param aObserver Application interface for error reporting.

@param aWriteStream Stream to write output to.

@param aStringProvider localisable string resources

@internalTechnology

*/

CAgnVersit2Exporter::CAgnVersit2Exporter(CAgnVersit2StringProvider& aStringProvider) :

	iStringProvider(aStringProvider)

	{

	TRACE_ENTRY_POINT;

	TRACE_EXIT_POINT;

	}

/**

Internal construction.

@internalTechnology

*/

void CAgnVersit2Exporter::ConstructL()

	{

	TRACE_ENTRY_POINT;

	iTimezoneIndex = KErrNotFound;

	TRACE_EXIT_POINT;

	}

/**

Creates a new CICal*, adds any properties and returns it. The new object is

left on the cleanup stack.

@code

ICalendar components can have the following properties:

	PRODID: This is fixed for all exports from this device.

	VERSION: Should	only ever be 2.0 for iCalendar v1 (vCalendar 2).

	METHOD: Member data from aEntry.

@endcode

@param aEntry entry to export.

@return newly created CICal*.

@internalTechnology

*/

CICal* CAgnVersit2Exporter::AddICalLC(const CCalEntry& aEntry) const

	{

	TRACE_ENTRY_POINT;

	CICal* cal = CICal::NewLC();

	cal->AddPropertyL(KICalProdId, iStringProvider.StringL(EICalProdIdValue));

	cal->AddPropertyL(KICalVersion,KICalVersionNumber);

	switch (aEntry.MethodL())

		{

		case CCalEntry::EMethodPublish :

			cal->AddPropertyL(KICalMethod, KICalPublish);

			cal->SetMethodL(CICal::EMethodPublish);

			break;

		case CCalEntry::EMethodRequest :

			cal->AddPropertyL(KICalMethod, KICalRequest);

			cal->SetMethodL(CICal::EMethodRequest);

			break;

		case CCalEntry::EMethodReply :

			cal->AddPropertyL(KICalMethod, KICalReply);

			cal->SetMethodL(CICal::EMethodReply);

			break;

		case CCalEntry::EMethodAdd :

			cal->AddPropertyL(KICalMethod, KICalAdd);

			cal->SetMethodL(CICal::EMethodAdd);

			break;

		case CCalEntry::EMethodCancel :

			cal->AddPropertyL(KICalMethod, KICalCancel);

			cal->SetMethodL(CICal::EMethodCancel);

			break;

		case CCalEntry::EMethodRefresh :

			cal->AddPropertyL(KICalMethod, KICalRefresh);

			cal->SetMethodL(CICal::EMethodRefresh);

			break;

		case CCalEntry::EMethodCounter :

			cal->AddPropertyL(KICalMethod, KICalCounter);

			cal->SetMethodL(CICal::EMethodCounter);

			break;

		case CCalEntry::EMethodDeclineCounter :

			cal->AddPropertyL(KICalMethod, KICalDeclineCounter);

			cal->SetMethodL(CICal::EMethodDeclineCounter);

			break;

		case CCalEntry::EMethodNone :

			// fall through...

		default :

			//Add MEHTOD:PUBLISH as default if no method exists

			//needed by outlook

			cal->AddPropertyL(KICalMethod, KICalPublish);

			cal->SetMethodL(CICal::EMethodPublish);

			break;

		}

	TRACE_EXIT_POINT;

	return cal;

	}

//

//     ADD COMPONENT METHODS

//     =====================

//

/**

Exports an agenda Anniversary to an iCalendar component.

@param aAnniv component to add to.

@param aEntry Entry containing information about the anniversary.

@internalTechnology

*/

void CAgnVersit2Exporter::AddAnnivL(CICalComponent& aAnniv, const CCalEntry& /*aEntry*/) const

	{

	TRACE_ENTRY_POINT;

	//Add 'X-PARAM' identifier

	if (iExportProperties & KAgnExportXProp)

		{

		aAnniv.AddPropertyL( iStringProvider.StringL(EICalXParamType),

		                     iStringProvider.StringL(EICalXParamAnniversary) );

		}

	TRACE_EXIT_POINT;

	}

/**

Adds an alarm to a component.

@code

RFC 2445 states that an alarm MUST have an ACTION and TRIGGER property. We can

retrieve the trigger property value from the alarm offset, but Agenda does not

support the ACTION property.

An alarm is defined as:

	"BEGIN" ":" "VALARM" CRLF

	(audioprop / dispprop / emailprop / procprop)

	"END" ":" "VALARM" CRLF

where audioprop / dispprop / emailprop and procprop are all values of the

ACTION property.

An ACTION property value of AUDIO only requires an additional TRIGGER property,

all other properties are optional.  To comply with RFC 2445, all alarms will be

exported with the following property:

	ACTION:AUDIO

as to set ACTION to any other value would require more properties, which we do

not have values for.

@endcode

@param aComponent Component to add the VALARM component to

@param aEntry Entry to extract ALARM information from

@internalTechnology

*/

void CAgnVersit2Exporter::AddAlarmL(CICalComponent& aComponent, const CCalEntry& aEntry) const

	{

	TRACE_ENTRY_POINT;

	CCalAlarm* alarm = aEntry.AlarmL();

	if (alarm)

		{

		CleanupStack::PushL(alarm);

		CICalComponent& component = aComponent.AddComponentL(CICalBase::EICalAlarm);

		CICalValue* triggerVal = CICalValue::NewLC();

		triggerVal->SetDurationL(TTimeIntervalSeconds(-alarm->TimeOffset().Int() * KSecondsInOneMinute));

		CleanupStack::Pop(triggerVal);

		component.AddPropertyL(KICalTrigger, triggerVal); //Pass ownership

		component.AddPropertyL(KICalAction, KICalAudio);

		CleanupStack::PopAndDestroy(alarm);

		}

	TRACE_EXIT_POINT;

	}

/**

Adds an appointment to a component.

@param aAppt Component to add the appointment to.

@param aEntry Entry to extract the appointment information from.

@internalTechnology

*/

void CAgnVersit2Exporter::AddApptL(CICalComponent& aAppt, const CCalEntry& aEntry) const

	{

	TRACE_ENTRY_POINT;

	//Add 'DTEND' property

	if (iExportProperties & KAgnExportDtEnd)

		{

		TCalTime time(aEntry.EndTimeL());

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

			{

			AddDateTimePropertyL(aAppt, time, KICalDtend);

			}

		}

	if (iExportProperties & KAgnExportStatus)

		{

		//Add 'STATUS' property

		switch (aEntry.StatusL())

			{

			//VEvent supports TENTATIVE, CONFIRMED, CANCELLED

			case CCalEntry::ETentative:

				aAppt.AddPropertyL(KICalStatus, KICalTentative);

				break;

			case CCalEntry::EConfirmed:

				aAppt.AddPropertyL(KICalStatus, KICalConfirmed);

				break;

			case CCalEntry::ECancelled:

				aAppt.AddPropertyL(KICalStatus, KICalCancelled);

				break;

			case CCalEntry::ETodoNeedsAction :	// not supported, fall through

			case CCalEntry::ETodoCompleted :	// not supported, fall through

			case CCalEntry::ETodoInProcess :	// not supported, fall through

			default:

				//Do not add a status property

				break;

			}

		}

	//Add 'X-PARAM' identifier

	if (iExportProperties & KAgnExportXProp)

		{

		aAppt.AddPropertyL( iStringProvider.StringL(EICalXParamType),

		                    iStringProvider.StringL(EICalXParamAppointment) );

		}

	TRACE_EXIT_POINT;

	}

/**

Adds a component to aICal. The type of component added is determined by the

value of aEntry.EntryTypeL(). Generic properties (valid in both VEVENT and

VTODO components) are added first, followed by type specific properties.

@param aICal CICal object to add the component to.

@param aEntry CCalEntry containing information about the component.

@internalTechnology

*/

void CAgnVersit2Exporter::AddComponentL(CICal& aICal, const CCalEntry& aEntry) const

	{

	TRACE_ENTRY_POINT;

	//Add the  component

	CICalBase::TICalComponentType type(CICalBase::EICalEvent);

	switch (aEntry.EntryTypeL())

		{

		//The agenda types all map to an iCalendar 'VEVENT' component

		case CCalEntry::EAppt :

			// fall through...

		case CCalEntry::EEvent :

			// fall through...

		case CCalEntry::EReminder :

			// fall through...

		case CCalEntry::EAnniv :

			{

			type = CICalBase::EICalEvent;

			break;

			}

		case CCalEntry::ETodo :

			{

			type = CICalBase::EICalTodo;

			break;

			}

		default :

			User::Leave(KErrNotSupported); //For now at least

			break;

		}

	CICalComponent& comp = aICal.AddComponentL(type);

	//Add 'ATTENDEE' properties

	if (iExportProperties & KAgnExportAttendee)

		{

		AddAttendeePropertiesL(comp, aEntry);

		}

	//Add 'ORGANIZER' property

	if (iExportProperties & KAgnExportOrganizer)

		{

		AddOrganizerPropertyL(comp, aEntry);

		}

	//Add 'LOCATION' property.

	if (iExportProperties & KAgnExportLocation)

		{

		AddTextPropertyL(comp, aEntry.LocationL(), KICalLocation);

		}

	//Outlook puts TRANSP here. The default value is 'OPAQUE'.

	//Add 'SEQUENCE' property.  The default value is '0', so

	//the property is only added if there is a value.

	if (iExportProperties & KAgnExportSequence)

		{

		TInt sequence = aEntry.SequenceNumberL();

		if (sequence != 0)

			{

			AddIntegerPropertyL(comp, aEntry.SequenceNumberL(), KICalSequence);

			}

		}

	//Add 'UID' property

	if (iExportProperties & KAgnExportUID)

		{

		CICalValue* uidVal = CICalValue::NewLC();

		uidVal->SetBinaryL(aEntry.UidL());

		CleanupStack::Pop(uidVal);

		comp.AddPropertyL(KICalUid, uidVal); //Pass ownership

		}

    //Time for DTSTAMP, CREATED and LAST-MODIFIED

	TCalTime time;

	//Check if DTSTAMP exist

	if( aEntry.DTStampL().TimeUtcL() != Time::NullTTime() )

	    {

	    time = aEntry.DTStampL();    

	    }

	else //If not use current time

	    {

	    TTime currentTime;

	    currentTime.UniversalTime();