/*
* 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:  ESMR mrinfo recurrence handler implementation
*
*/

#include "emailtrace.h"
#include "cesmrinforecurrencehandler.h"
#include "tesmrinputparams.h"
#include "esmrconfig.hrh"

//<cmail>
#include "mmrinfoobject.h"
#include "mmrrecurrencerule.h"
#include "esmrdef.h"
//</cmail>
#include <calentry.h>
#include <calrrule.h>

// Unnamed namespace for local definitions
namespace {

/**
 * Converts MRINFO day into Symbian date.
 * @param aDay MRINFO day
 * @return Symbian date
 */
TDay MRInfoDay( MRRecurrenceRule::TMRRecurrentDay aDay )
    {
    TDay day( EMonday );

    switch( aDay )
        {
        case MRRecurrenceRule::EMRRecurrenceMonday:
            {
            day = EMonday;
            break;
            }
        case MRRecurrenceRule::EMRRecurrenceTuesday:
            {
            day = ETuesday;
            break;
            }
        case MRRecurrenceRule::EMRRecurrenceWednesday:
            {
            day = EWednesday;
            break;
            }
        case MRRecurrenceRule::EMRRecurrenceThursday:
            {
            day =  EThursday;
            break;
            }
        case MRRecurrenceRule::EMRRecurrenceFriday:
            {
            day = EFriday;
            break;
            }
        case MRRecurrenceRule::EMRRecurrenceSaturday:
            {
            day = ESaturday;
            break;
            }
        case MRRecurrenceRule::EMRRecurrenceSunday:
            {
            day = ESunday;
            break;
            }
        default:
           break;
        }

    return day;
    }

} // namespace

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

// ---------------------------------------------------------------------------
// CESMRInfoRecurrenceHandler::CESMRInfoRecurrenceHandler
// ---------------------------------------------------------------------------
//
inline CESMRInfoRecurrenceHandler::CESMRInfoRecurrenceHandler()
    {
    FUNC_LOG;
    //do nothing
    }

// ---------------------------------------------------------------------------
// CESMRInfoRecurrenceHandler::~CESMRInfoRecurrenceHandler
// ---------------------------------------------------------------------------
//
CESMRInfoRecurrenceHandler::~CESMRInfoRecurrenceHandler()
    {
    FUNC_LOG;
    //do nothing
    }

// ---------------------------------------------------------------------------
// CESMRInfoRecurrenceHandler::NewL
// ---------------------------------------------------------------------------
//
CESMRInfoRecurrenceHandler* CESMRInfoRecurrenceHandler::NewL()
    {
    FUNC_LOG;
    CESMRInfoRecurrenceHandler* self = NewLC();
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// CESMRInfoRecurrenceHandler::NewLC
// ---------------------------------------------------------------------------
//
CESMRInfoRecurrenceHandler* CESMRInfoRecurrenceHandler::NewLC()
    {
    FUNC_LOG;
    CESMRInfoRecurrenceHandler* self =
        new (ELeave) CESMRInfoRecurrenceHandler();
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }

// ---------------------------------------------------------------------------
// CESMRInfoRecurrenceHandler::ConstructL
// ---------------------------------------------------------------------------
//
void CESMRInfoRecurrenceHandler::ConstructL()
    {
    FUNC_LOG;
    //do nothing
    }

// ---------------------------------------------------------------------------
// CESMRInfoRecurrenceHandler::ParseRecurrenceInforationL
// ---------------------------------------------------------------------------
//
void CESMRInfoRecurrenceHandler::ParseRecurrenceInforationL(
        CCalEntry& aCalEntry,
        const MMRInfoObject& aInfoObject )
    {
    FUNC_LOG;

    TTime until;

    aCalEntry.ClearRepeatingPropertiesL();
    GetRecurrenceL(
            aCalEntry,
            aInfoObject );

    }

// ---------------------------------------------------------------------------
// CESMRInfoRecurrenceHandler::GetRecurrenceL
//
// ---------------------------------------------------------------------------
//
void CESMRInfoRecurrenceHandler::GetRecurrenceL(
        CCalEntry& aCalEntry,
        const MMRInfoObject& aInfoObject)
    {
    FUNC_LOG;

    const MRRecurrenceRule& recurrenceRule =
            aInfoObject.RecurrenceRuleL();

    MRRecurrenceRule::TMRRecurrenceType rType(
            recurrenceRule.Type() );

    if ( MRRecurrenceRule::EMRRecurrenceInvalid != rType )
        {
        switch ( rType )
            {
            case MRRecurrenceRule::EMRRecurrenceDaily:
                {
                HandleDailyRecurrenceL(
                        aCalEntry,
                        aInfoObject );
                }
                break;

            case MRRecurrenceRule::EMRRecurrenceWeekly:
                {
                HandleWeeklyRecurrenceL(
                        aCalEntry,
                        aInfoObject );
                }
                break;

            case MRRecurrenceRule::EMRRecurrenceMonthly://fallthrough
            case MRRecurrenceRule::EMRRecurrenceMonthlyByDay:
                {
                HandleMonthlyRecurrenceL(
                        aCalEntry,
                        aInfoObject );
                }
                break;

            case MRRecurrenceRule::EMRRecurrenceYearly:
                {
                HandleYearlyRecurrenceL(
                        aCalEntry,
                        aInfoObject );
                }
                break;
            default:
               break;
            }
        }

    }

// ---------------------------------------------------------------------------
// CESMRInfoRecurrenceHandler::HandleDailyRecurrenceL
// ---------------------------------------------------------------------------
//
void CESMRInfoRecurrenceHandler::HandleDailyRecurrenceL(
        CCalEntry& aCalEntry,
        const MMRInfoObject& aInfoObject )
    {
    FUNC_LOG;
    const MRRecurrenceRule& recurrenceRule =
            aInfoObject.RecurrenceRuleL();

    TCalRRule rRule;
    rRule.SetType( TCalRRule::EDaily );

    TCalTime meetingStartTime = aCalEntry.StartTimeL();
    rRule.SetDtStart( meetingStartTime );


    TTime until( recurrenceRule.RecurrentUntil() );
    if ( Time::NullTTime() != until )
        {
        TDateTime untilDt = until.DateTime();

        TDateTime endTime =
            aCalEntry.EndTimeL().TimeLocalL().DateTime();
        untilDt.SetHour( endTime.Hour() );
        untilDt.SetMinute( endTime.Minute() );
        untilDt.SetSecond( endTime.Second() );

        TCalTime rEndTime;
        rEndTime.SetTimeLocalL( TTime(untilDt) );

        rRule.SetUntil( rEndTime );
        }
    else
        {
        TInt interval( recurrenceRule.RecurrentInterval() );
        TInt count( recurrenceRule.RecurrentCount() );

        rRule.SetCount( count );
        rRule.SetInterval( interval );
        }

    aCalEntry.SetRRuleL( rRule );
    }

// ---------------------------------------------------------------------------
// CESMRInfoRecurrenceHandler::HandleWeeklyRecurrenceL
// ---------------------------------------------------------------------------
//
void CESMRInfoRecurrenceHandler::HandleWeeklyRecurrenceL(
        CCalEntry& aCalEntry,
        const MMRInfoObject& aInfoObject )
    {
    FUNC_LOG;
    const MRRecurrenceRule& recurrenceRule =
            aInfoObject.RecurrenceRuleL();

    TCalRRule rRule;
    rRule.SetType( TCalRRule::EWeekly );
    TCalTime meetingStartTime = aCalEntry.StartTimeL();
    rRule.SetDtStart( meetingStartTime );
    TInt interval( recurrenceRule.RecurrentInterval() );

    TTime until( recurrenceRule.RecurrentUntil() );
    if ( Time::NullTTime() != until )
        {
        TDateTime untilDt = until.DateTime();

        TDateTime endTime =
            aCalEntry.EndTimeL().TimeLocalL().DateTime();
        untilDt.SetHour( endTime.Hour() );
        untilDt.SetMinute( endTime.Minute() );
        untilDt.SetSecond( endTime.Second() );

        TCalTime rEndTime;
        rEndTime.SetTimeLocalL( TTime(untilDt) );

        rRule.SetUntil( rEndTime );
        
        rRule.SetInterval( interval );
        }
    else
        {
        TInt count( recurrenceRule.RecurrentCount() );

        rRule.SetCount( count );
        rRule.SetInterval( interval );

        }
    const RArray<MRRecurrenceRule::TMRRecurrentDay>&
    recurrenceDays(
            recurrenceRule.RecurrentWeekDays() );

    if ( recurrenceDays.Count() )
        {
        RArray<TDay> dDays;
        CleanupClosePushL( dDays );
        for ( TInt i(0); i < recurrenceDays.Count(); ++i )
            {
            dDays.Append( MRInfoDay( recurrenceDays[i] ) );
            }

        rRule.SetByDay( dDays );
        CleanupStack::PopAndDestroy( &dDays );
        }

    aCalEntry.SetRRuleL( rRule );
    }

// ---------------------------------------------------------------------------
// CESMRInfoRecurrenceHandler::HandleMonthlyRecurrenceL
// ---------------------------------------------------------------------------
//
void CESMRInfoRecurrenceHandler::HandleMonthlyRecurrenceL(
        CCalEntry& aCalEntry,
        const MMRInfoObject& aInfoObject )
    {
    FUNC_LOG;
    const MRRecurrenceRule& recurrenceRule =
            aInfoObject.RecurrenceRuleL();

    TCalRRule rRule;
    rRule.SetType( TCalRRule::EMonthly );
    TCalTime meetingStartTime = aCalEntry.StartTimeL();
    rRule.SetDtStart( meetingStartTime );

    TInt interval( recurrenceRule.RecurrentInterval() );

    TTime until( recurrenceRule.RecurrentUntil() );
    if ( Time::NullTTime() != until )
        {
        TDateTime untilDt = until.DateTime();

        TDateTime endTime =
            aCalEntry.EndTimeL().TimeLocalL().DateTime();
        untilDt.SetHour( endTime.Hour() );
        untilDt.SetMinute( endTime.Minute() );
        untilDt.SetSecond( endTime.Second() );

        TCalTime rEndTime;
        rEndTime.SetTimeLocalL( TTime(untilDt) );

        rRule.SetUntil( rEndTime );
        }
    else
        {
        TInt count( recurrenceRule.RecurrentCount() );
        rRule.SetCount( count );
        rRule.SetInterval( interval );
        }

    const RArray<MRRecurrenceRule::TRecurrentDaysofMonth>&
    recurrenceDays(
            recurrenceRule.RecurrentDaysofMonth() );

    const RArray<TInt>& recurrenceDaysInMonth(
            recurrenceRule.RecurrentMonthDays() );

    if ( recurrenceDays.Count() )
        {
        RArray<TCalRRule::TDayOfMonth> dDays;
        CleanupClosePushL( dDays );
        for ( TInt i(0); i < recurrenceDays.Count(); ++i )
            {
            TCalRRule::TDayOfMonth dayOfMonth(
                    MRInfoDay( recurrenceDays[i].iDayOfWeek ),
                    static_cast<TInt8>( recurrenceDays[i].iWeekOfMonth ) );
            }

        rRule.SetByDay( dDays );
        CleanupStack::PopAndDestroy( &dDays );
        }
    else if ( recurrenceDaysInMonth.Count() )
        {
        rRule.SetByMonthDay( recurrenceDaysInMonth );
        }

    aCalEntry.SetRRuleL( rRule );
    }

// ---------------------------------------------------------------------------
// CESMRInfoRecurrenceHandler::HandleYearlyRecurrenceL
// ---------------------------------------------------------------------------
//
void CESMRInfoRecurrenceHandler::HandleYearlyRecurrenceL(
        CCalEntry& aCalEntry,
        const MMRInfoObject& aInfoObject )
    {
    FUNC_LOG;
    const MRRecurrenceRule& recurrenceRule =
            aInfoObject.RecurrenceRuleL();

    TCalRRule rRule;
    rRule.SetType( TCalRRule::EYearly );
    TCalTime meetingStartTime = aCalEntry.StartTimeL();
    rRule.SetDtStart( meetingStartTime );

    TInt interval( recurrenceRule.RecurrentInterval() );

    TTime until( recurrenceRule.RecurrentUntil() );
    if ( Time::NullTTime() != until )
        {
        TDateTime untilDt = until.DateTime();

        TDateTime endTime =
            aCalEntry.EndTimeL().TimeLocalL().DateTime();
        untilDt.SetHour( endTime.Hour() );
        untilDt.SetMinute( endTime.Minute() );
        untilDt.SetSecond( endTime.Second() );

        TCalTime rEndTime;
        rEndTime.SetTimeLocalL( TTime(untilDt) );

        rRule.SetUntil( rEndTime );
        }
    else
        {
        TInt count( recurrenceRule.RecurrentCount() );
        rRule.SetCount( count );
        }

    const RArray<MRRecurrenceRule::TMRRecurrenceMonth>&
    recurrenceMonths(
            recurrenceRule.RecurrentMonths() );

    TInt recurrenceMonthCount( recurrenceMonths.Count() );
    if ( recurrenceMonthCount )
        {
        RArray<TMonth> months;
        CleanupClosePushL( months );
        for ( TInt i(0); i < recurrenceMonthCount; ++i )
            {
            months.Append(
                    static_cast<TMonth>(recurrenceMonths[i]) );
            }

        rRule.SetByMonth( months );
        CleanupStack::PopAndDestroy( &months );
        }

    aCalEntry.SetRRuleL( rRule );
    }

// EOF