/*

* 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 class CESMRAgnVersit2Exporter.

*

*/

// Class include.

#include "emailtrace.h"

#include "cesmragnversit2exporter.h"

//debug

//<cmail>

// 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 "cesmrical.h"                      // cesmrical

#include "cesmricalcomponent.h"             // cesmricalcomponent

#include "esmricalkeywords.h"               // literals used during export

#include "cesmricalproperty.h"              // cesmricalproperty

#include "cesmricalvalue.h"                 // cesmricalvalue

#include "cesmricalbase.h"                  // ticalmethod

#include <tzlocalizer.h>

#include <tzconverter.h>

// MRUI includes

#include "esmrdef.h"

//</cmail>

// AgnVersit2 includes.

#include "cesmragnversit2stringprovider.h"  // CESMRAgnVersit2StringProvider

#include "cesmragnexternalinterface.h"      // TAgnEntryExport

// Unnamed namespace for local definitions and functions

namespace {

// 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");

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

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

// CESMRAgnVersit2Exporter::ConstructMailtoPropertyLC

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

//

TTime StartDateUtcL( const CCalEntry& aEntry )

    {

    return aEntry.StartTimeL().TimeUtcL();

    }

TTime EndDateUtcL( const CCalEntry& aEntry )

    {

    TTime endTime = aEntry.EndTimeL().TimeUtcL();

    TCalRRule rrule;

    if ( aEntry.GetRRuleL(rrule) )

        {

        endTime = rrule.Until().TimeUtcL();

        }

    return endTime;

    }

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

// CESMRAgnVersit2Exporter::ConstructMailtoPropertyLC

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

//

void FilterTimezoneInformationL(

        CTzRules& aTzRules,

        TTime aStartTime )

    {

    FUNC_LOG;

    TInt index(0);

    while ( index < aTzRules.Count() )

        {

        TTzRule& singleRule = aTzRules[ index ];

        if ( ETzFixedDate == singleRule.iDayRule)

            {

            aTzRules.RemoveRule( index );

            }

        else

            {

            TTime startTime = singleRule.iFrom.iTime;

            //Check whether the year is 0, if so set it to 1970

            if( !startTime.DateTime().Year() )//Year == 0000

                {

                TDateTime dateTime = startTime.DateTime();

                dateTime.SetYear( 1970 );

                singleRule.iFrom.iTime = dateTime;

                }

            ++index;

            }

        }

    if ( aTzRules.Count() >= 2 )

        {

        // Only one STANDARD / DAYLIGHT PAIR is accepted by exchange

        // We need to locate the one, which corresponds to this one

        TTzRule standard;

        TTzRule dayLight;

        TInt daylightFound( KErrNotFound );

        TInt standardFound( KErrNotFound );

        index = 0;

        while ( index < aTzRules.Count() )

            {

            TTzRule& singleRule = aTzRules[ index ];

            TDateTime meetingStart = aStartTime.DateTime();

            TDateTime ruleStart = singleRule.iFrom.iTime.DateTime();

            TBool standardTimeZone( ETrue );

            if ( singleRule.iNewLocalTimeOffset > singleRule.iOldLocalTimeOffset )

                {

                // Daylight timezone

                standardTimeZone = EFalse;

                }

            // singleRule.iFrom.iTime

            if ( standardTimeZone )

                {

                if ( KErrNotFound == standardFound )

                    {

                    standard = singleRule;

                    standardFound = KErrNone;

                    }

                else if ( standard.iFrom.iTime < singleRule.iFrom.iTime &&

                        singleRule.iFrom.iTime <= aStartTime )

                    {

                    standard = singleRule;

                    }

                aTzRules.RemoveRule( index );

                }

            else

                {

                if ( KErrNotFound == daylightFound )

                    {

                    dayLight = singleRule;

                    daylightFound = KErrNone;

                    }

                else if ( dayLight.iFrom.iTime < singleRule.iFrom.iTime &&

                        singleRule.iFrom.iTime <= aStartTime )

                    {

                    dayLight = singleRule;

                    }

                aTzRules.RemoveRule( index );

                }

            }

        if ( KErrNotFound != standardFound &&  KErrNotFound != daylightFound )

            {

            // Add STANDARD / DAYLIGHT pair into timezone information

            aTzRules.AddRuleL( standard );

            aTzRules.AddRuleL( dayLight );

            }

        }

    else

        {

        // Not enough timezone areas --> Remove all

        index = 0;

        while ( index < aTzRules.Count() )

            {

            aTzRules.RemoveRule( index );

            }

        }

    }

} // namespace

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

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

// CESMRAgnVersit2Exporter::ConstructMailtoPropertyLC

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

//

HBufC* CESMRAgnVersit2Exporter::ConstructMailtoPropertyLC(

        const TDesC& aAddress )

    {

    FUNC_LOG;

    // "MAILTO:" prefix

    _LIT( KMailTo, "MAILTO:" );

    // Making the value to MAILTO:<address>

    HBufC* addressBuffer = HBufC::NewLC( KMailTo().Length() + aAddress.Length() );

    TPtr ptrAddressBuffer( addressBuffer->Des() );

    if ( aAddress.Find( KMailTo ) == KErrNotFound )

        {

        ptrAddressBuffer.Copy( KMailTo );

        } // find

    ptrAddressBuffer.Append( aAddress );

    return addressBuffer;

    }

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

// CESMRAgnVersit2Exporter::NewL

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

//

CESMRAgnVersit2Exporter* CESMRAgnVersit2Exporter::NewL(CESMRAgnVersit2StringProvider& aStringProvider)

    {

    FUNC_LOG;

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

    CleanupStack::Pop(self);

    return self;

    }

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

// CESMRAgnVersit2Exporter::NewLC

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

//

CESMRAgnVersit2Exporter* CESMRAgnVersit2Exporter::NewLC(CESMRAgnVersit2StringProvider& aStringProvider)

    {

    FUNC_LOG;

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

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

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

// CESMRAgnVersit2Exporter::~CESMRAgnVersit2Exporter

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

//

CESMRAgnVersit2Exporter::~CESMRAgnVersit2Exporter()

    {

    FUNC_LOG;

    iTzNameArray.ResetAndDestroy();

    iTimeZoneArray.ResetAndDestroy();

    }

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

// CESMRAgnVersit2Exporter::ExportL

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

//

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

                                   RWriteStream& aWriteStream,

                                   TUint aExportFlags,

                                   MESMRAgnExportObserver& aObserver )

    {

    FUNC_LOG;

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

    CESMRICal* 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);

    }

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

// CESMRAgnVersit2Exporter::ExportL

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

//

void CESMRAgnVersit2Exporter::ExportL( const CCalEntry& aEntry,

                                   RWriteStream& aWriteStream,

                                   TUint aExportFlags,

                                   MESMRAgnExportObserver& aObserver )

    {

    FUNC_LOG;

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

    CESMRICal* cal = AddICalLC(aEntry);

    TRAPD(err,

        if (iExportProperties & KAgnExportTzRules)

            {

            AddTimezoneL(*cal, aEntry);

            }

            AddComponentL(*cal, aEntry);

        );

    User::LeaveIfError(err);

    cal->ExternalizeL(aWriteStream);

    CleanupStack::PopAndDestroy(cal);

    }

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

// CESMRAgnVersit2Exporter::CESMRAgnVersit2Exporter

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

//

CESMRAgnVersit2Exporter::CESMRAgnVersit2Exporter(CESMRAgnVersit2StringProvider& aStringProvider) :

    iStringProvider(aStringProvider)

    {

    FUNC_LOG;

    //do nothing

    }

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

// CESMRAgnVersit2Exporter::ConstructL

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

//

void CESMRAgnVersit2Exporter::ConstructL()

    {

    FUNC_LOG;

    iTimezoneIndex = KErrNotFound;

    }

/**

 * Creates a new CESMRICal*, 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 CESMRICal*.

 * @internalTechnology

 */

CESMRICal* CESMRAgnVersit2Exporter::AddICalLC(const CCalEntry& aEntry) const

    {

    FUNC_LOG;

    CESMRICal* cal = CESMRICal::NewLC();

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

    cal->AddPropertyL(KICalVersion,KICalVersionNumber);

    switch (aEntry.MethodL())

        {

        case CCalEntry::EMethodPublish :

            cal->AddPropertyL(KICalMethod, KICalPublish);

            cal->SetMethodL(CESMRICal::EMethodPublish);

            break;

        case CCalEntry::EMethodRequest :

            cal->AddPropertyL(KICalMethod, KICalRequest);

            cal->SetMethodL(CESMRICal::EMethodRequest);

            break;

        case CCalEntry::EMethodReply :

            cal->AddPropertyL(KICalMethod, KICalReply);

            cal->SetMethodL(CESMRICal::EMethodReply);

            break;

        case CCalEntry::EMethodAdd :

            cal->AddPropertyL(KICalMethod, KICalAdd);

            cal->SetMethodL(CESMRICal::EMethodAdd);

            break;

        case CCalEntry::EMethodCancel :

            cal->AddPropertyL(KICalMethod, KICalCancel);

            cal->SetMethodL(CESMRICal::EMethodCancel);

            break;

        case CCalEntry::EMethodRefresh :

            cal->AddPropertyL(KICalMethod, KICalRefresh);

            cal->SetMethodL(CESMRICal::EMethodRefresh);

            break;

        case CCalEntry::EMethodCounter :

            cal->AddPropertyL(KICalMethod, KICalCounter);

            cal->SetMethodL(CESMRICal::EMethodCounter);

            break;

        case CCalEntry::EMethodDeclineCounter :

            cal->AddPropertyL(KICalMethod, KICalDeclineCounter);

            cal->SetMethodL(CESMRICal::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(CESMRICal::EMethodPublish);

            break;

        }

    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 CESMRAgnVersit2Exporter::AddAnnivL(CESMRICalComponent& aAnniv, const CCalEntry& /*aEntry*/) const

    {

    FUNC_LOG;

    //Add 'X-PARAM' identifier

    if (iExportProperties & KAgnExportXProp)

        {

        aAnniv.AddPropertyL( iStringProvider.StringL(EICalXParamType),

                             iStringProvider.StringL(EICalXParamAnniversary) );

        }

    }

/**

 * 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 CESMRAgnVersit2Exporter::AddAlarmL(CESMRICalComponent& aComponent, const CCalEntry& aEntry) const

    {

    FUNC_LOG;

    CCalAlarm* alarm = aEntry.AlarmL();

    if (alarm)

        {

        CleanupStack::PushL(alarm);

        CESMRICalComponent& component = aComponent.AddComponentL(CESMRICalBase::EICalAlarm);

        CESMRICalValue* triggerVal = CESMRICalValue::NewLC();

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

        CleanupStack::Pop(triggerVal);

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

        component.AddPropertyL(KICalAction, KICalAudio);

        CleanupStack::PopAndDestroy(alarm);

        }

    }

/**

 * 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 CESMRAgnVersit2Exporter::AddApptL(CESMRICalComponent& aAppt, const CCalEntry& aEntry) const

    {

    FUNC_LOG;

    //Add 'DTEND' property

    if (iExportProperties & KAgnExportDtEnd)

        {

        TCalTime time(aEntry.EndTimeL());