/*

* 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 importer implementation.

*                Converts iCal data to symbian agenda entry.

*

*/

// Class include.

#include "AgnVersit2Importer.h"

//debug

#include "calendarengines_debug.h"

// Agenda includes.

#include <calalarm.h>			// For CCalAlarm

#include <calcategory.h>		// For CCalCategory

#include <calentry.h>			// For CCalEntry

#include <calrrule.h>			// For CCalRRule

#include <caltime.h>			// For CCalTime

#include <caluser.h>			// For CCalUser

#include <tzdefines.h>			// For TTzRuleDay

#include <vtzrules.h>			// For CTzRules and TTzRule

#include <CalenInterimUtils2.h>

// Versit includes.

#include "ICal.h"				// For CICal

#include "ICalComponent.h"		// For CICalComponent

#include "ICalKeyWords.h"		// For CICalKeyWords

#include "ICalParser.h"			// For CICalParser

#include "ICalProperty.h"		// For CICalProperty

#include "ICalPropertyParam.h"	// For CICalPropertyParam

#include "ICalRuleSegment.h"	// For CICalRuleSegment

#include "ICalValue.h"			// For CICalValue

// AgnVersit2 includes.

#include "AgnVersit2StringProvider.h"	// For CAgnVersit2StringProvider

#include "CleanupPointerArray.h"		// For TCleanupPointerArray

#include "AgnRRuleImporter.h"           // For CAgnRRuleImporter

// Constants.

/** A semi-colon character. */

const TUint KAgnVersitTokenSemiColonVal =';';

//

//    CTzNamedRules

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

//

/**

Constructor.

@internalTechnology

*/

CAgnVersit2Importer::CTzNamedRules::CTzNamedRules()

	{

	TRACE_ENTRY_POINT;

	TRACE_EXIT_POINT;

	}

/**

Destructor.

@internalTechnology

*/

CAgnVersit2Importer::CTzNamedRules::~CTzNamedRules()

	{

	TRACE_ENTRY_POINT;

	delete iRules;

	delete iName;

	TRACE_EXIT_POINT;

	}

//

//     CAgnVersit2Importer

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

//

/**

Constructs a new CAgnVersit2Importer and returns it.

@param aStringProvider A string provider for obtaining resource strings from.

@return a new CAgnVersit2Importer.

@internalTechnology

*/

CAgnVersit2Importer* CAgnVersit2Importer::NewL(CAgnVersit2StringProvider& aStringProvider)

	{

	TRACE_ENTRY_POINT;

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

	CleanupStack::Pop(self);

	TRACE_EXIT_POINT;

	return self;

	}

/**

Constructs a new CAgnVersit2Importer and returns it. The object is left on the

cleanup stack.

@param aStringProvider A string provider for obtaining resource strings from.

@return a new CAgnVersit2Importer.

@internalTechnology

*/

CAgnVersit2Importer* CAgnVersit2Importer::NewLC(CAgnVersit2StringProvider& aStringProvider)

	{

	TRACE_ENTRY_POINT;

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

	CleanupStack::PushL(self);

	self->ConstructL();

	TRACE_EXIT_POINT;

	return self;

	}

/**

Destructor.

@internalTechnology

*/

CAgnVersit2Importer::~CAgnVersit2Importer()

	{

	TRACE_ENTRY_POINT;

	iTzRules.ResetAndDestroy();

	TRACE_EXIT_POINT;

	}

/**

Uses Versit2 to parse an input stream, and then converts the result into

CCalEntry objects.

@param aEntries The array to append entries to.

@param aReadStream The stream to read iCalendar data from.

@param aObserver Application interface for error reporting.

@internalTechnology

*/

void CAgnVersit2Importer::ImportL( RPointerArray<CCalEntry>& aEntries,

                                   RReadStream& aReadStream,

                                   MAgnImportObserver& aObserver )

	{

	TRACE_ENTRY_POINT;

	iImportObserver = &aObserver;

	CICalParser* parser = CICalParser::NewLC();

	parser->InternalizeL(aReadStream);

	const TInt count = parser->CalCount();

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

		{

		CICal& calendar = parser->Cal(cal);

		TRAPD(err, ImportICalL(aEntries, calendar));

		iTzRules.ResetAndDestroy();

		User::LeaveIfError(err);

		}

	CleanupStack::PopAndDestroy(parser);

	TRACE_EXIT_POINT;

	}

/**

Constructor.

@internalTechnology

*/

CAgnVersit2Importer::CAgnVersit2Importer(CAgnVersit2StringProvider& aStringProvider)

	: iStringProvider(aStringProvider)

	{

	TRACE_ENTRY_POINT;

	TRACE_EXIT_POINT;

	}

/**

Internal construction.

@internalTechnology

*/

void CAgnVersit2Importer::ConstructL()

	{

	TRACE_ENTRY_POINT;

	TRACE_EXIT_POINT;

	}

/**

Takes a calendar object from Versit2 and converts it into a set of CCalEntry

objects.

@param aEntries The array to append entries to.

@param aCal An object of type CICal from which to obtain data.

@leave KErrAbort, or any other system wide error code.

@internalTechnology

*/

void CAgnVersit2Importer::ImportICalL(RPointerArray<CCalEntry>& aEntries, CICal& aCal)

	{

	TRACE_ENTRY_POINT;

	const RPointerArray<CICalComponent>& components = aCal.Components();

	// Run through the timezones so that we know what other components are referring to:

	iTzRules.ResetAndDestroy();

	TInt com; // current component number

	TInt comCount = components.Count();

	for (com = 0; com < comCount && iResponse == MAgnImportObserver::EImpResponseContinue; ++com)

		{

		CICalComponent* component = components[com];

		// We are only interested in timezones:

		if (component->Type() == CICalBase::EICalTimeZone)

			{

			TRAPD(err, ImportTimezoneL(*component));

			if (err)

				{

				// If there isn't a response, then it isn't a recoverable leave:

				if (iResponse == MAgnImportObserver::EImpResponseContinue)

					{

					User::Leave(err);

					}

				// If there is a response, then we threw this after reporting an

				// error to the observer, and we may be able to continue:

				else if(iResponse == MAgnImportObserver::EImpResponseSkip)

					{

					iResponse = MAgnImportObserver::EImpResponseContinue;

					}

				}

			}

		}

	// Run through the other components:

	for (com = 0; com < comCount && iResponse == MAgnImportObserver::EImpResponseContinue; ++com)

		{

		CICalComponent* component = components[com];

		// We aren't interested in timezones:

		if (component->Type() != CICalBase::EICalTimeZone)

			{

			TRAPD(err, ImportComponentL(aCal, *component, aEntries));

			if (err)

				{

				// If there isn't a response, then it isn't a recoverable leave:

				if (iResponse == MAgnImportObserver::EImpResponseContinue)

					{

					User::Leave(err);

					}

				// If there is a response, then we threw this after reporting an

				// error to the observer, and we may be able to continue:

				else if(iResponse == MAgnImportObserver::EImpResponseSkip)

					{

					iResponse = MAgnImportObserver::EImpResponseContinue;

					}

				}

			}

		}

	// If we have been asked to leave after an error, do so:

	if (iResponse == MAgnImportObserver::EImpResponseLeave)

		{

		User::Leave(KErrAbort);

		}

	TRACE_EXIT_POINT;

	}

/**

*     IMPORT COMPONENT FUNCTIONS

*     ==========================

*/

/**

Handles the importing of a single component, other than a timezone.

@param aCal The calendar object from which we are importing

@param aComponent The specific component we are importing

@param aEntries The agenda entries onto which this component is to be appended.

@internalTechnology

*/

void CAgnVersit2Importer::ImportComponentL( const CICal& aCal,

                                            const CICalComponent& aComponent,

                                            RPointerArray<CCalEntry>& aEntries )

	{

	TRACE_ENTRY_POINT;

	// Get the UID:

	HBufC8* entryUid = NULL;

	const CICalProperty* propUid = aComponent.FindProperty(KICalUid());

	if (!propUid)//(propUid && propUid->Values().Count() < 1)

		{

		// if UID is not present,generate using caleninterimutils api

		CCalenInterimUtils2* interimUtils = CCalenInterimUtils2::NewL();

		CleanupStack::PushL(interimUtils);

		// get the global uid

		entryUid = interimUtils->GlobalUidL();

		CleanupStack::PopAndDestroy(interimUtils);

		CleanupStack::PushL(entryUid);

		}

	else

		{

		entryUid = propUid->Values()[0]->BinaryLC();

		}

	if(entryUid)

	    {

		// Import entry-type specific data:

		switch (aComponent.Type())

			{

			case CICalBase::EICalEvent :

				{

				CCalEntry::TType eventType = CCalEntry::EEvent;

				//Check if we have a DTEND or DURATION

				if (aComponent.FindProperty(KICalDtend()) || aComponent.FindProperty(KICalDuration()))

					{

					eventType = CCalEntry::EAppt;

					}

				else

					{

					//Check if we have a DTSTART

					if (aComponent.FindProperty(KICalDtstart()))

						{

						eventType = CCalEntry::EReminder;

						}

					//Check if this is a yearly repeat

					if (aComponent.FindProperty(KICalRRule()))

						{

						const CICalProperty* rrule = aComponent.FindProperty(KICalRRule());

						const RPointerArray<CICalValue>& rulevalues = rrule->Values();

						if (rulevalues.Count() >= 1)

							{

							CICalRuleSegment::TFreq freq = CICalRuleSegment::EFreqDaily;

							RPointerArray<CICalRuleSegment> recRules;

							CleanupPointerArrayPushL(recRules);

							// At this point we take ownership of the things which rules contains:

							rulevalues[0]->GetRecurrenceRuleL(recRules);

							// An RRule must have a frequency.

							TInt pos = FindRuleSegment(recRules, CICalRuleSegment::ESegFreq);

							if (pos != KErrNotFound)

								{

								ASSERT(recRules.Count() >= pos + 1);

								freq = recRules[pos]->FreqL();

								}

							// Find the interval.

							pos = FindRuleSegment(recRules, CICalRuleSegment::ESegInterval);

							TInt interval = 1; //default value if no INTERVAL specified

							if (pos != KErrNotFound)

								{

								ASSERT(recRules[pos]->Values().Count() >= 0);

								interval = recRules[pos]->Values()[0]->IntegerL();

								}

							if ((freq == CICalRuleSegment::EFreqYearly) && (interval == 1))

								{

								//Anniversary repeats once a year

								eventType = CCalEntry::EAnniv;

								}

							CleanupStack::PopAndDestroy(&recRules);

							}

						}

					}

				CleanupStack::Pop(entryUid);

				// Passing ownership of entryUid

				ImportEntryL(aCal, aComponent, aEntries, entryUid, eventType);

				}

				break;

			case CICalBase::EICalTodo :

				CleanupStack::Pop(entryUid);

				// Passing ownership of entryUid

				ImportEntryL(aCal, aComponent, aEntries, entryUid, CCalEntry::ETodo);

				break;

			case CICalBase::EICalJournal :

				ReportErrorL(MAgnImportObserver::EImpErrorNotSupported, *entryUid, KICalJournal, EFalse);

				// Continue equates to skip in this instance.

				break;

			case CICalBase::EICalAlarm :

				ReportErrorL(MAgnImportObserver::EImpErrorInvalidData, *entryUid, KICalAlarm, EFalse);

				// Continue equates to skip in this instance.

				break;

			case CICalBase::EICalFreeBusy :

				ReportErrorL(MAgnImportObserver::EImpErrorNotSupported, *entryUid, KICalFreeBusy, EFalse);

				// Continue equates to skip in this instance.

				break;

			case CICalBase::EICalInvalid :	// not valid here, fall through

			case CICalBase::EICalCalendar :	// not valid here, fall through

			case CICalBase::EICalTimeZone :	// not valid here, fall through

			case CICalBase::EICalStandard :	// not valid here, fall through

			case CICalBase::EICalDaylight :	// not valid here, fall through

			default :

				ReportErrorL( MAgnImportObserver::EImpErrorInvalidData,

				              *entryUid,

				              aComponent.TypeStringL(),

				              EFalse );

				// Continue equates to skip in this instance.

				break;

			}

		}

	TRACE_EXIT_POINT;

	}

/**

Checks for a VALARM in a component. If a valid one is found, it is added to the

specified entry.

@param aComponent Component to search for a VALARM in.

@param aEntry Alarm is added to this calendar entry.

@param aUid UID of the component.

@param aStartTime A pointer to the DTSTART of the parent component, if it has

one, or NULL if it does not. This does not take ownership.

@return MAgnImportObserver::TImpResponse indicating application response to errors, if any.

@internalTechnology

*/

void CAgnVersit2Importer::ImportAlarmL( const CICalComponent& aComponent,

                                        CCalEntry& aEntry,

                                        const HBufC8& aUid,

                                        const TCalTime* aStartTime )

	{

	TRACE_ENTRY_POINT;

	if (aComponent.ComponentExists(CICalBase::EICalAlarm))

		{

		// Check the outer component is a VEVENT or a VTODO

		if (aComponent.Type() == CICalBase::EICalEvent || aComponent.Type() == CICalBase::EICalTodo)

			{

			const RPointerArray<CICalComponent>& nestedComponents = aComponent.Components();

			// Iterate through all the nested components and create a new alarm for each VALARM component

			TInt nestedComCount = nestedComponents.Count();

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

				{

				if (nestedComponents[i]->Type() == CICalBase::EICalAlarm)

					{

					CCalAlarm* alarm = CCalAlarm::NewL();

					CleanupStack::PushL(alarm);

					const RPointerArray<CICalProperty>& nestedProperties = nestedComponents[i]->Properties();

					// Go through all the nested properties until we find the TRIGGER

					// Ignore REPEAT and DURATION + any others

					TBool foundTrigger=EFalse;

					TInt nestedPropCount = nestedProperties.Count();

					for (TInt j = 0; j < nestedPropCount; j++)

						{

						if (nestedProperties[j]->Type() == KICalTrigger)

							{

							const RPointerArray<CICalValue>& values = nestedProperties[j]->Values();

							// There should only be one value, don't try to add the alarm if there are more

							if (values.Count() == 1)

								{

								const CICalPropertyParam* valueType = nestedProperties[j]->FindParam(KICalValue);

								TTimeIntervalMinutes duration;

								if (valueType) // Only DATE-TIME is legal here - assume it's that one.

									{

									if (!aStartTime)

										{

										ReportErrorL( MAgnImportObserver::EImpErrorMissingData,

										              aUid,

										              iStringProvider.StringL(EICalErrValarmNoStart),

										              EFalse );

										// On continue, we skip the alarm.

										}

									else

										{

										TCalTime absTime;

										GetCalTimeL(*nestedProperties[j], absTime, EDateTime);

										aStartTime->TimeUtcL().MinutesFrom(absTime.TimeUtcL(), duration);

										}

									}

								else

									{

									duration = values[0]->DurationL().Int() / KSecondsInOneMinute;

									}

								// Only negative durations are allowed (the alarm must be *before* the event).

								if (duration.Int() > 0)

									{

									ReportErrorL( MAgnImportObserver::EImpErrorNotSupported,

									              aUid,

									              iStringProvider.StringL(EICalErrAlarmAfterEvent) );

									// On continue, the duration will be made "negative".

									}

								// Agenda expects a positive duration - convert the sign.

								if (duration.Int() < 0)

									{

									duration = -(duration.Int());

									}

								alarm->SetTimeOffset(duration);

								foundTrigger=ETrue;

								}

							}

						}

					if (foundTrigger)

						{

						aEntry.SetAlarmL(alarm);// Doesn't take ownership

						}

					else

						{

						ReportErrorL( MAgnImportObserver::EImpErrorMissingData,

						              aUid,

						              iStringProvider.StringL(EICalErrValarmNoTrigger),

						              EFalse );

						// On continue, the alarm will be skipped.

						}

					CleanupStack::PopAndDestroy(alarm);

					}

				}

			}

		else

			{

			ReportErrorL( MAgnImportObserver::EImpErrorInvalidData,

			              aUid,

			              iStringProvider.StringL(EICalErrValarmNotAllowed),

			              EFalse );

			// On continue, the alarm will be skipped.

			}