/*

* Copyright (c) 2007-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 CESMRRecurrenceInfoHandler.

*

*/

//<cmail>

#include "emailtrace.h"

#include "cesmrrecurrenceinfohandler.h"

#include "esmrdef.h"

//</cmail>

#include "mesmrmeetingrequestentry.h"

#include <calentry.h>

#include <calrrule.h>

#include <calcommon.h>

/// Unnamed namespace for local definitions

namespace {

// Definition for 0

const TInt KZero = 0;

// Definition for 1

const TInt KOne = 1;

// Definition for 2

const TInt KTwo = 2;

// Definition for days in week

const TInt KDaysInWeek = 7;

// Definition for days in two weeks

const TInt KDaysInTwoWeeks = 14;

// Definition for montsh in year

const TInt KMonthsInYear = 12;

/**

 * Compares two times and returns ETrue if they have same date components

 * @param aLhs Left hand side component

 * @param aRhs Right hand side component

 */

TBool IsSameDay(

        const TDateTime& aLhs,

        const TDateTime& aRhs )

    {

    TBool retValue(EFalse);

    if ( aLhs.Day() == aRhs.Day() &&

         aLhs.Month() == aRhs.Month() &&

         aLhs.Year() == aRhs.Year()   )

        {

        retValue = ETrue;

        }

    return retValue;

    }

/**

 * Checks if instance is included in exception list.

 * @param aInstanceTime Reference to instance time.

 * @param aExDateList Reference to exception list.

 */

TBool IsTimeIncluded(

        const TCalTime& aInstanceTime,

        const RArray<TCalTime>& aExDateList )

    {

    FUNC_LOG;

    TBool included( EFalse );

    TInt exceptionCount( aExDateList.Count() );

    if ( exceptionCount )

        {

        for (TInt i(0); (i < exceptionCount) && !included ; i++ )

            {

            const TCalTime& exceptionTime( aExDateList[i] );

            TDateTime exDate = exceptionTime.TimeLocalL().DateTime();

            if ( aInstanceTime.TimeLocalL() == exceptionTime.TimeLocalL() )

                {

                included = ETrue;

                }

            }

        }

    return included;

    }

/**

 * Calculates time for next instance for recurrent event.

 * @param aRecurrenceValue Defines the used recurrence.

 * @param aPrevInstanceStartTime Start time of the previous instance.

 */

TTime TimeForNextInstaceStartTime(

        TESMRRecurrenceValue aRecurrenceValue,

        TCalTime& aPrevInstanceStartTime )

    {

    TTime nextStartTime = aPrevInstanceStartTime.TimeLocalL();

    switch ( aRecurrenceValue )

        {

        case ERecurrenceDaily:

            {

            nextStartTime += TTimeIntervalDays( KOne );

            }

            break;

        case ERecurrenceWeekly:

            {

            nextStartTime += TTimeIntervalDays( KDaysInWeek );

            }

            break;

        case ERecurrenceEverySecondWeek:

            {

            nextStartTime += TTimeIntervalDays( KDaysInTwoWeeks );

            }

            break;

        case ERecurrenceMonthly:

            {

            nextStartTime += TTimeIntervalMonths( KOne );

            }

            break;

        case ERecurrenceYearly:

            {

            nextStartTime += TTimeIntervalYears( KOne );

            }

            break;

        default:

            {

            nextStartTime = aPrevInstanceStartTime.TimeLocalL();

            }

            break;

        }

    return nextStartTime;

    }

void CalculateUntilForUnknownRecurrenceL(

        TTime& aUntil,

        TCalRRule& aRule )

    {

    aUntil = aRule.Until().TimeLocalL();

    if ( Time::NullTTime() == aUntil )

        {

        aUntil = aRule.DtStart().TimeLocalL();

        TInt factor( aRule.Count() * aRule.Interval() );

        switch ( aRule.Type() )

            {

            case TCalRRule::EDaily:

                {

                aUntil += TTimeIntervalDays(factor );

                }

                break;

            case TCalRRule::EWeekly:

                {

                aUntil += TTimeIntervalDays(factor * KDaysInWeek );

                }

                break;

            case TCalRRule::EMonthly:

                {

                aUntil += TTimeIntervalMonths(factor );

                }

                break;

            case TCalRRule::EYearly:

                {

                aUntil += TTimeIntervalYears(factor );

                }

                break;

            }

        }

    }

}  // namespace

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

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

// CESMRRecurrenceInfoHandler::CESMRRecurrenceInfoHandler

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

//

inline CESMRRecurrenceInfoHandler::CESMRRecurrenceInfoHandler(

        CCalEntry& aEntry ) :

        iEntry( aEntry )

    {

    FUNC_LOG;

    // Not implementation yet

    }

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

// CESMRRecurrenceInfoHandler::~CESMRRecurrenceInfoHandler

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

//

EXPORT_C CESMRRecurrenceInfoHandler::~CESMRRecurrenceInfoHandler()

    {

    FUNC_LOG;

    // Not implementation yet

    }

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

// CESMRRecurrenceInfoHandler::NewL

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

//

EXPORT_C CESMRRecurrenceInfoHandler* CESMRRecurrenceInfoHandler::NewL(

        CCalEntry& aEntry )

    {

    FUNC_LOG;

    CESMRRecurrenceInfoHandler* self = NewLC( aEntry );

    CleanupStack::Pop( self );

    return self;

    }

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

// CESMRRecurrenceInfoHandler::NewLC

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

//

EXPORT_C CESMRRecurrenceInfoHandler* CESMRRecurrenceInfoHandler::NewLC(

        CCalEntry& aEntry )

    {

    FUNC_LOG;

    CESMRRecurrenceInfoHandler* self =

            new (ELeave) CESMRRecurrenceInfoHandler(aEntry);

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CESMRRecurrenceInfoHandler::ConstructL

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

//

void CESMRRecurrenceInfoHandler::ConstructL()

    {

    FUNC_LOG;

    // Not implementation yet

    }

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

// CESMRRecurrenceInfoHandler::SetRecurrenceL

//

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

//

EXPORT_C void CESMRRecurrenceInfoHandler::SetRecurrenceL(

        TESMRRecurrenceValue aRecurrence,

        TTime aUntil )

    {

    FUNC_LOG;

    // Recurrence until time needs to be in Utc mode, because comparison in

    // NeedToSetRecurrenceL is based on UTC times

    TCalTime until;

    until.SetTimeLocalL( aUntil );

    TTime recUntilUtc = until.TimeUtcL();

    // Check input parameters

    if ( ERecurrenceNot != aRecurrence &&

         Time::NullTTime() == aUntil )

        {

        // No until parameter set --> Leave

        User::Leave( KErrArgument );

        }

    else if ( ERecurrenceNot == aRecurrence )

        {

        // Clear all (recurrence, exceptions) repeating properties

        iEntry.ClearRepeatingPropertiesL();

        }

    else if ( NeedToSetRecurrenceL(aRecurrence, recUntilUtc) )

        {

        // Calculate 'correct' until time

        // Date component is taken from input parameter and

        // time component from meeting's end time.

        TDateTime until = aUntil.DateTime();

        TDateTime endTime = iEntry.EndTimeL().TimeLocalL().DateTime();

        until.SetHour( endTime.Hour() );

        until.SetMinute( endTime.Minute() );

        until.SetSecond( endTime.Second() );

        TCalTime rEndTime;

        rEndTime.SetTimeLocalL( TTime(until) );

        TCalTime meetingStartTime = iEntry.StartTimeL();

        TCalRRule rRule;

        rRule.SetDtStart( meetingStartTime );

        // Clear recurrence properties before setting the correct one

        iEntry.ClearRepeatingPropertiesL();

        switch ( aRecurrence )

            {

            case ERecurrenceDaily:

                {

                // Set daily recurrence

                rRule.SetType( TCalRRule::EDaily );

                TTimeIntervalDays daysBetween =

                    rEndTime.TimeLocalL().DaysFrom(

                            meetingStartTime.TimeLocalL() );

                // First occurence and days between

                rRule.SetCount( daysBetween.Int() + KOne);

                rRule.SetInterval( KOne );

                }

                break;

            case ERecurrenceWeekly:

                {

                // Set weekly recurrence.

                rRule.SetType( TCalRRule::EWeekly );

                TTimeIntervalDays weeksBetween =

                    rEndTime.TimeLocalL().DaysFrom(

                            meetingStartTime.TimeLocalL() );

                weeksBetween = weeksBetween.Int() / KDaysInWeek;

                RArray<TDay> dayArray;

                CleanupClosePushL( dayArray );

                dayArray.Append( rRule.DtStart().TimeLocalL().DayNoInWeek() );

                rRule.SetByDay( dayArray );

                CleanupStack::PopAndDestroy( &dayArray );

                // First occurence and weeks between

                rRule.SetCount(

                        weeksBetween.Int() + KOne);

                rRule.SetInterval( KOne );

                }

                break;

            case ERecurrenceEverySecondWeek:

                {

                // Set bi-weekly recurrence. This is weekly recurrence

                // with 2 weeks interval.

                rRule.SetType( TCalRRule::EWeekly );

                TTimeIntervalDays fortNightBetween =

                    rEndTime.TimeLocalL().DaysFrom(

                            meetingStartTime.TimeLocalL() );

                fortNightBetween =

                        fortNightBetween.Int() / KDaysInTwoWeeks;

                RArray<TDay> dayArray;

                CleanupClosePushL( dayArray );

                dayArray.Append( rRule.DtStart().TimeLocalL().DayNoInWeek() );

                rRule.SetByDay( dayArray );

                CleanupStack::PopAndDestroy( &dayArray );

                // First occurence and fortnights between

                rRule.SetCount(

                        fortNightBetween.Int() + KOne);

                rRule.SetInterval( KTwo );

                }

                break;

            case ERecurrenceMonthly:

                {

                // Set monthly recurrence.

                rRule.SetType( TCalRRule::EMonthly );

                RArray<TInt> dateArray;

                CleanupClosePushL( dateArray );

                dateArray.Append(

                    rRule.DtStart().TimeLocalL().DayNoInMonth() );

                rRule.SetByMonthDay( dateArray );

                CleanupStack::PopAndDestroy( &dateArray );

                TTimeIntervalMonths monthsBetween =

                    rEndTime.TimeLocalL().MonthsFrom(

                            meetingStartTime.TimeLocalL() );

                // First occurence and months between

                rRule.SetCount( monthsBetween.Int() + KOne);

                rRule.SetInterval( KOne );

                }

                break;

            case ERecurrenceYearly:

                {

                // Set yearly recurrence.

                rRule.SetType( TCalRRule::EYearly );

                TTimeIntervalYears yearsBetween =

                    rEndTime.TimeLocalL().YearsFrom(

                            meetingStartTime.TimeLocalL() );

                // First occurence and months between

                rRule.SetCount( yearsBetween.Int() + KOne);

                rRule.SetInterval( KOne );

                }

            default:

                break;

            }

        iEntry.SetRRuleL( rRule );

        }

    }

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

// CESMRRecurrenceInfoHandler::GetRecurrenceL

//

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

//

EXPORT_C void CESMRRecurrenceInfoHandler::GetRecurrenceL(

        TESMRRecurrenceValue& aRecurrence,

        TTime& aUntil) const

    {

    FUNC_LOG;

    TESMRRecurrenceValue recurrenceValue(ERecurrenceNot);

    // Let's get RDates of the entry also to see if entry is repeating

    RArray<TCalTime> rdates;

    CleanupClosePushL( rdates );

    iEntry.GetRDatesL( rdates );

    TBool hasRdates = rdates.Count() > 0;

    TCalRRule rRule;

    if ( iEntry.GetRRuleL(rRule) || hasRdates )

        {

        // Entry has recurrence

        recurrenceValue = ERecurrenceUnknown;

        TCalRRule::TType rType = rRule.Type();

        TInt interval          = rRule.Interval();

        switch ( rType )

            {

            case TCalRRule::EInvalid:

                {

                // Recurrence type has not yet been defined

                // --> Consider it then unknown.

                recurrenceValue = ERecurrenceUnknown;

                }

                break;

            case TCalRRule::EDaily:

                {

                HandleDailyRecurrenceL( recurrenceValue, rRule );

                }

                break;

            case TCalRRule::EWeekly:

                {

                HandleWeeklyRecurrenceL( recurrenceValue, rRule );

                }

                break;

            case TCalRRule::EMonthly:

                {

                HandleMonthlyRecurrenceL( recurrenceValue, rRule );

                }

                break;

            case TCalRRule::EYearly:

                {

                // Recurrence is based on a number of years

                if ( KOne == interval)

                    {

                    recurrenceValue = ERecurrenceYearly;

                    }

                }

                break;

            default:

                break;

            }

        if ( hasRdates )

            {

            // Getting the last RDates occurance time == Until time

            aUntil = rdates[ rdates.Count() - 1 ].TimeUtcL();

            }

        else

            {

            CalculateRecurrenceUntilDateL(

                    recurrenceValue,

                    aUntil,

                    rRule,

                    iEntry );

            }

        }

    CleanupStack::PopAndDestroy( &rdates );

    aRecurrence = recurrenceValue;

    }

EXPORT_C void CESMRRecurrenceInfoHandler::RemoveInstanceL(

        TCalTime aInstanceTime )

    {

    FUNC_LOG;

    RArray<TCalTime> exDateList;

    CleanupClosePushL( exDateList );

    TDateTime instanceException = aInstanceTime.TimeLocalL().DateTime();

    instanceException.SetHour( KZero );

    instanceException.SetMinute( KZero );

    instanceException.SetSecond( KZero );

    instanceException.SetMicroSecond( KZero );

    TCalTime exceptionTime;

    exceptionTime.SetTimeUtcL( TTime(instanceException) );

    iEntry.GetExceptionDatesL( exDateList );

    exDateList.Append( exceptionTime );

    iEntry.SetExceptionDatesL( exDateList );

    CleanupStack::PopAndDestroy( &exDateList );