/*

* Copyright (c) 2002-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: This file implements classes CTzNamedRules, CESMRAgnVersit2Importer. 

*

*/

// Class include.

#include "emailtrace.h"

#include "cesmragnversit2importer.h"

#include "cesmragnversit2exporter.h"

//debug

//<cmail>

// 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

// Versit includes.

#include "cesmrical.h"              // for cical

#include "cesmricalcomponent.h"     // for cicalcomponent

#include "esmricalkeywords.h"       // for cicalkeywords

#include "cesmricalparser.h"            // for cicalparser

#include "cesmricalproperty.h"      // for cicalproperty

#include "cesmricalpropertyparam.h" // for cicalpropertyparam

#include "cesmricalrulesegment.h"   // for cicalrulesegment

#include "cesmricalvalue.h"         // for cicalvalue

// ESMRAgnVersit2 includes.

#include "mesmragnimportobserver.h"         // For MESMRAgnImportObserver

#include "cesmragnversit2stringprovider.h"  // For CESMRAgnVersit2StringProvider

#include "esmrcleanuppointerarray.h"        // For TCleanupPointerArray

#include "cesmragnrruleimporter.h"           // For CESMRAgnRRuleImporter

#include "esmrhelper.h"

// MRUI includes

#include "esmrdef.h"

//</cmail>

// Constants.

//

//    CTzNamedRules

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

//

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

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

// CESMRAgnVersit2Importer::CTzNamedRules::CTzNamedRules

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

//

CESMRAgnVersit2Importer::CTzNamedRules::CTzNamedRules()

    {

    FUNC_LOG;

    //do nothing

    }

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

// CESMRAgnVersit2Importer::CTzNamedRules::~CTzNamedRules

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

//

CESMRAgnVersit2Importer::CTzNamedRules::~CTzNamedRules()

    {

    FUNC_LOG;

    delete iRules;

    delete iName;

    }

//

//     CESMRAgnVersit2Importer

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

//

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

// CESMRAgnVersit2Importer::NewL

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

//

CESMRAgnVersit2Importer* CESMRAgnVersit2Importer::NewL(CESMRAgnVersit2StringProvider& aStringProvider)

    {

    FUNC_LOG;

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

    CleanupStack::Pop(self);

    return self;

    }

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

// CESMRAgnVersit2Importer::NewLC

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

//

CESMRAgnVersit2Importer* CESMRAgnVersit2Importer::NewLC(CESMRAgnVersit2StringProvider& aStringProvider)

    {

    FUNC_LOG;

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

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

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

// CESMRAgnVersit2Importer::NewL

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

//

CESMRAgnVersit2Importer::~CESMRAgnVersit2Importer()

    {

    FUNC_LOG;

    iTzRules.ResetAndDestroy();

    }

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

// CESMRAgnVersit2Importer::ImportL

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

//

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

                                   RReadStream& aReadStream,

                                   MESMRAgnImportObserver& aObserver )

    {

    FUNC_LOG;

    iImportObserver = &aObserver;

    CESMRICalParser* parser = CESMRICalParser::NewLC();

    parser->InternalizeL(aReadStream);

    const TInt count = parser->CalCount();

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

        {

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

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

        iTzRules.ResetAndDestroy();

        User::LeaveIfError(err);

        }

    CleanupStack::PopAndDestroy(parser);

    }

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

// CESMRAgnVersit2Importer::CESMRAgnVersit2Importer

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

//

CESMRAgnVersit2Importer::CESMRAgnVersit2Importer(CESMRAgnVersit2StringProvider& aStringProvider)

    : iStringProvider(aStringProvider)

    {

    FUNC_LOG;

    //do nothing

    }

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

// CESMRAgnVersit2Importer::ConstructL

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

//

void CESMRAgnVersit2Importer::ConstructL()

    {

    FUNC_LOG;

    //do nothing

    }

/**

 * 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 CESMRICal from which to obtain data.

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

 * @internalTechnology

 */

void CESMRAgnVersit2Importer::ImportICalL(RPointerArray<CCalEntry>& aEntries, CESMRICal& aCal)

    {

    FUNC_LOG;

    const RPointerArray<CESMRICalComponent>& 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 == MESMRAgnImportObserver::EImpResponseContinue; ++com)

        {

        CESMRICalComponent* component = components[com];

        // We are only interested in timezones:

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

            {

            TRAPD(err, ImportTimezoneL(*component));

            if (err)

                {

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

                if (iResponse == MESMRAgnImportObserver::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 == MESMRAgnImportObserver::EImpResponseSkip)

                    {

                    iResponse = MESMRAgnImportObserver::EImpResponseContinue;

                    }

                }

            }

        }

    // Run through the other components:

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

        {

        CESMRICalComponent* component = components[com];

        // We aren't interested in timezones:

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

            {

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

            if (err)

                {

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

                if (iResponse == MESMRAgnImportObserver::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 == MESMRAgnImportObserver::EImpResponseSkip)

                    {

                    iResponse = MESMRAgnImportObserver::EImpResponseContinue;

                    }

                }

            }

        }

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

    if (iResponse == MESMRAgnImportObserver::EImpResponseLeave)

        {

        User::Leave(KErrAbort);

        }

    }

/**

*     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 CESMRAgnVersit2Importer::ImportComponentL( const CESMRICal& aCal,

                                            const CESMRICalComponent& aComponent,

                                            RPointerArray<CCalEntry>& aEntries )

    {

    FUNC_LOG;

    // Get the UID:

    HBufC8* entryUid = NULL;

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

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

        {

        ReportErrorL(MESMRAgnImportObserver::EImpErrorInvalidData, KNullDesC8, KICalUid, EFalse);

        // We do not continue without a UID.

        }

    //if (propUid)

    else

        {

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

        // Import entry-type specific data:

        switch (aComponent.Type())

            {

            case CESMRICalBase::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 CESMRICalProperty* rrule = aComponent.FindProperty(KICalRRule());

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

                        if (rulevalues.Count() >= 1)

                            {

                            CESMRICalRuleSegment::TFreq freq = CESMRICalRuleSegment::EFreqDaily;

                            RPointerArray<CESMRICalRuleSegment> 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, CESMRICalRuleSegment::ESegFreq);

                            if (pos != KErrNotFound)

                                {

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

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

                                }

                            // Find the interval.

                            pos = FindRuleSegment(recRules, CESMRICalRuleSegment::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 == CESMRICalRuleSegment::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 CESMRICalBase::EICalTodo :

                CleanupStack::Pop(entryUid);

                // Passing ownership of entryUid

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

                break;

            case CESMRICalBase::EICalJournal :

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

                // Continue equates to skip in this instance.

                break;

            case CESMRICalBase::EICalAlarm :

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

                // Continue equates to skip in this instance.

                break;

            case CESMRICalBase::EICalFreeBusy :

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

                // Continue equates to skip in this instance.

                break;

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

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

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

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

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

            default :

                ReportErrorL( MESMRAgnImportObserver::EImpErrorInvalidData,

                              *entryUid,

                              aComponent.TypeStringL(),

                              EFalse );

                // Continue equates to skip in this instance.

                break;

            }

        }

    }

/**

 * 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 MESMRAgnImportObserver::TImpResponse indicating application response to errors, if any.

 * @internalTechnology

 */

void CESMRAgnVersit2Importer::ImportAlarmL( const CESMRICalComponent& aComponent,

                                        CCalEntry& aEntry,

                                        const HBufC8& aUid,

                                        const TCalTime* aStartTime )

    {

    FUNC_LOG;

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

        {

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

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

            {

            const RPointerArray<CESMRICalComponent>& 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() == CESMRICalBase::EICalAlarm)

                    {

                    CCalAlarm* alarm = CCalAlarm::NewL();

                    CleanupStack::PushL(alarm);

                    const RPointerArray<CESMRICalProperty>& 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<CESMRICalValue>& 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 CESMRICalPropertyParam* valueType = nestedProperties[j]->FindParam(KICalValue);

                                TTimeIntervalMinutes duration;

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

                                    {

                                    if (!aStartTime)

                                        {

                                        ReportErrorL( MESMRAgnImportObserver::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( MESMRAgnImportObserver::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( MESMRAgnImportObserver::EImpErrorMissingData,

                                      aUid,

                                      iStringProvider.StringL(EICalErrValarmNoTrigger),

                                      EFalse );

                        // On continue, the alarm will be skipped.

                        }

                    CleanupStack::PopAndDestroy(alarm);

                    }

                }

            }

        else

            {

            ReportErrorL( MESMRAgnImportObserver::EImpErrorInvalidData,

                          aUid,

                          iStringProvider.StringL(EICalErrValarmNotAllowed),

                          EFalse );

            // On continue, the alarm will be skipped.

            }

        }

    }

/**

 * Performs most of the work of importing a component from an iCalendar, provided

 * that the component is one which can be handled as a CCalEntry. Timezone and

 * Alarm components are not imported in this manner.

 * @param aCal The calendar object containing the component.

 * @param aComponent The component to be imported.

 * @param aEntries The array onto which to append the new entry.

 * @param aUid The UID of the component (takes ownership).

 * @param aType The type of entry being imoported

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

 * @internalTechnology

 */