/*

* Copyright (c) 2008 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:  PIM item repeat rule converter class.

 *

*/

// INCLUDE FILES

#include    "pimrepeatruleconverter.h"

#include "logger.h"

// CONSTANTS

const TInt KPIMRepeatDatesArrayGranularity = 8;

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

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

// PIMRepeatRuleConverter::Dates

// Calculates which dates occur on given date subset.

// Returns: the dates without exception dates.

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

//

CArrayFixFlat<TPIMDate>* PIMRepeatRuleConverter::DatesL(

    const MPIMRepeatRuleData& aRepeatRuleData, const TPIMDate& aStartDate,

    const TPIMDate& aSubsetBeginning, const TPIMDate& aSubsetEnding,

    CArrayFixFlat<TPIMDate>& aExceptionDates,

    const TPIMDate& aRepeatRuleEndDate, const TPIMField& aRepeatRuleCount)

{

    JELOG2(EPim);

    CArrayFixFlat<TPIMDate> * repeatDates =

        new(ELeave) CArrayFixFlat<TPIMDate> (KPIMRepeatDatesArrayGranularity);

    CleanupStack::PushL(repeatDates);

    CArrayFix<TPIMField>* fields = aRepeatRuleData.GetFieldsL();

    CleanupStack::PushL(fields);

    // Make sure that only date part of the TTime is included, not the time part

    TDateTime startDateTime = aStartDate.DateTime();

    TTime newStartDate(startDateTime);

    TDateTime subsetBeginningDateTime = aSubsetBeginning.DateTime();

    TTime newSubsetBeginning(subsetBeginningDateTime);

    TDateTime subsetEndingDateTime = aSubsetEnding.DateTime();

    TTime newSubsetEnding(subsetEndingDateTime);

    TTime date = newStartDate;

    TInt countIndex = 0;

    TInt newInterval;

    if (IsRepeatFieldPresentL(EPIMRepeatRuleInterval, *fields))

    {

        newInterval = aRepeatRuleData.GetIntL(EPIMRepeatRuleInterval);

    }

    else

    {

        newInterval = 1;

    }

    TInt frequency = EPIMRepeatRuleDaily; // default if not present

    if (IsRepeatFieldPresentL(EPIMRepeatRuleFrequency, *fields))

    {

        frequency = aRepeatRuleData.GetIntL(EPIMRepeatRuleFrequency);

    }

    switch (frequency)

    {

    case(EPIMRepeatRuleDaily):

    {

        // Calculate the first repeat after the subset beginning date

        if (newSubsetBeginning > date)

        {

            while (date < newSubsetBeginning)

            {

                date = date + TTimeIntervalDays(newInterval);

                countIndex++;

            }

        }

        // First fill the array with all repeat dates

        for (; date < newSubsetEnding + TTimeIntervalDays(1); date = date

                + TTimeIntervalDays(newInterval))

        {

            if (!AddRepeatDateL(*fields, date, newSubsetBeginning,

                                newSubsetEnding, aRepeatRuleEndDate, aRepeatRuleCount,

                                &repeatDates, &countIndex))

            {

                break;

            }

        }

        break;

    }

    case(EPIMRepeatRuleWeekly):

    {

        // Calculate the first repeat after the subset beginning date

        if (newSubsetBeginning > date)

        {

            while (date < newSubsetBeginning)

            {

                date = date + TTimeIntervalDays(7 * newInterval);

                countIndex++;

            }

        }

        // First fill the array with all repeat dates

        for (; date < newSubsetEnding + TTimeIntervalDays(1); date = date

                + TTimeIntervalDays(7 * newInterval))

        {

            if (IsRepeatFieldPresentL(EPIMRepeatRuleDayInWeek, *fields))

            {

                if (!CheckDaysInWeekL(*fields, date, newSubsetBeginning,

                                      newSubsetEnding, aRepeatRuleEndDate, aRepeatRuleCount,

                                      aRepeatRuleData.GetIntL(EPIMRepeatRuleDayInWeek),

                                      &repeatDates, &countIndex))

                {

                    break;

                }

            }

            else

            {

                if (!AddRepeatDateL(*fields, date, newSubsetBeginning,

                                    newSubsetEnding, aRepeatRuleEndDate, aRepeatRuleCount,

                                    &repeatDates, &countIndex))

                {

                    break;

                }

            }

        }

        break;

    }

    case(EPIMRepeatRuleMonthly):

    {

        // If DAY_IN_MONTH is present, shift the start date into it

        if (IsRepeatFieldPresentL(EPIMRepeatRuleDayInMonth, *fields))

        {

            TInt repeatRuleDayInMonth = aRepeatRuleData.GetIntL(

                                            EPIMRepeatRuleDayInMonth);

            if (repeatRuleDayInMonth >= (newStartDate.DayNoInMonth() + 1))

            {

                // The following check puts the DAY_IN_MONTH field to

                // correct place when handling different lenght months

                if (repeatRuleDayInMonth > (newStartDate.DaysInMonth() + 1))

                {

                    date = newStartDate + TTimeIntervalDays(

                               newStartDate.DaysInMonth()

                               - (newStartDate.DayNoInMonth() + 1));

                }

                else

                {

                    date = newStartDate + TTimeIntervalDays(

                               repeatRuleDayInMonth

                               - (newStartDate.DayNoInMonth() + 1));

                }

            }

            else

            {

                date = newStartDate - TTimeIntervalDays(

                           (newStartDate.DayNoInMonth() + 1) - repeatRuleDayInMonth);

            }

        }

        // Calculate the first repeat after the subset beginning date

        if (newSubsetBeginning > date)

        {

            while (date < newSubsetBeginning)

            {

                date = date + TTimeIntervalMonths(newInterval);

                countIndex++;

            }

        }

        // First fill the array with all repeat dates

        for (; date < newSubsetEnding + TTimeIntervalDays(1); date = date

                + TTimeIntervalMonths(newInterval))

        {

            if (IsRepeatFieldPresentL(EPIMRepeatRuleWeekInMonth, *fields)

                    && IsRepeatFieldPresentL(EPIMRepeatRuleDayInWeek, *fields))

            {

                if (!CheckWeeksInMonthL(*fields, date, newSubsetBeginning,

                                        newSubsetEnding, aRepeatRuleEndDate, aRepeatRuleCount,

                                        aRepeatRuleData.GetIntL(EPIMRepeatRuleWeekInMonth),

                                        aRepeatRuleData.GetIntL(EPIMRepeatRuleDayInWeek),

                                        &repeatDates, &countIndex))

                {

                    break;

                }

            }

            else

            {

                // The following check puts the DAY_IN_MONTH field to

                // correct place when handling different lenght months

                if (IsRepeatFieldPresentL(EPIMRepeatRuleDayInMonth, *fields))

                {

                    TInt repeatRuleDayInMonth = aRepeatRuleData.GetIntL(

                                                    EPIMRepeatRuleDayInMonth);

                    if (repeatRuleDayInMonth > (date.DayNoInMonth() + 1))

                    {

                        if (repeatRuleDayInMonth < (date.DaysInMonth() + 1))

                        {

                            date = date + TTimeIntervalDays(

                                       repeatRuleDayInMonth

                                       - (date.DayNoInMonth() + 1));

                        }

                        else

                        {

                            date = date + TTimeIntervalDays(date.DaysInMonth()

                                                            - (date.DayNoInMonth() + 1));

                        }

                    }

                }

                if (!AddRepeatDateL(*fields, date, newSubsetBeginning,

                                    newSubsetEnding, aRepeatRuleEndDate, aRepeatRuleCount,

                                    &repeatDates, &countIndex))

                {

                    break;

                }

            }

        }

        break;

    }

    case(EPIMRepeatRuleYearly):

    {

        // If DAY_IN_YEAR is present, shift the start date into it

        if (IsRepeatFieldPresentL(EPIMRepeatRuleDayInYear, *fields))

        {

            TInt repeatRuleDayInYear = aRepeatRuleData.GetIntL(

                                           EPIMRepeatRuleDayInYear);

            if (repeatRuleDayInYear >= newStartDate.DayNoInYear())

            {

                date = newStartDate + TTimeIntervalDays(repeatRuleDayInYear

                                                        - newStartDate.DayNoInYear());

                // If DAY_IN_YEAR was set to 366 and this is not a leap year

                // substract one day from the calculated value

                if (repeatRuleDayInYear == 366 && !Time::IsLeapYear(

                            newStartDate.DateTime().Year()))

                {

                    date = date - TTimeIntervalDays(1);

                }

            }

            else

            {

                date = newStartDate - TTimeIntervalDays(

                           newStartDate.DayNoInYear() - repeatRuleDayInYear);

            }

        }

        // Calculate the first repeat after the subset beginning date

        if (newSubsetBeginning > date)

        {

            while (date < newSubsetBeginning)

            {

                date = date + TTimeIntervalYears(newInterval);

                countIndex++;

            }

        }

        // First fill the array with all repeat dates

        for (; date < newSubsetEnding + TTimeIntervalDays(1); date = date

                + TTimeIntervalYears(newInterval))

        {

            TInt repeatRuleWeekInMonth = 0;

            TInt repeatRuleDayInWeek = 0;

            TInt repeatRuleMonthInYear = 0;

            TInt repeatRuleDayInMonth = 0;

            if (IsRepeatFieldPresentL(EPIMRepeatRuleMonthInYear, *fields))

            {

                repeatRuleMonthInYear = aRepeatRuleData.GetIntL(

                                            EPIMRepeatRuleMonthInYear);

            }

            if (IsRepeatFieldPresentL(EPIMRepeatRuleWeekInMonth, *fields))

            {

                repeatRuleWeekInMonth = aRepeatRuleData.GetIntL(

                                            EPIMRepeatRuleWeekInMonth);

            }

            if (IsRepeatFieldPresentL(EPIMRepeatRuleDayInWeek, *fields))

            {

                repeatRuleDayInWeek = aRepeatRuleData.GetIntL(

                                          EPIMRepeatRuleDayInWeek);

            }

            if (IsRepeatFieldPresentL(EPIMRepeatRuleDayInMonth, *fields))

            {

                repeatRuleDayInMonth = aRepeatRuleData.GetIntL(

                                           EPIMRepeatRuleDayInMonth);

            }

            if (IsRepeatFieldPresentL(EPIMRepeatRuleMonthInYear, *fields))

            {

                if (!CheckMonthsInYearL(*fields, date, newSubsetBeginning,

                                        newSubsetEnding, aRepeatRuleEndDate, aRepeatRuleCount,

                                        repeatRuleWeekInMonth, repeatRuleDayInWeek,

                                        repeatRuleMonthInYear, repeatRuleDayInMonth, &repeatDates,

                                        &countIndex))

                {

                    break;

                }

            }

            else

            {

                // The following check moves the DAY_IN_YEAR field from 365

                // to 366 if DAY_IN_YEAR is set 366 and this is a leap year

                if (IsRepeatFieldPresentL(EPIMRepeatRuleDayInYear, *fields))

                {

                    if (aRepeatRuleData.GetIntL(EPIMRepeatRuleDayInYear)

                            > date.DayNoInYear())

                    {

                        if (Time::IsLeapYear(date.DateTime().Year()))

                        {

                            date = date + TTimeIntervalDays(1);

                        }

                    }

                }

                if (!AddRepeatDateL(*fields, date, newSubsetBeginning,

                                    newSubsetEnding, aRepeatRuleEndDate, aRepeatRuleCount,

                                    &repeatDates, &countIndex))

                {

                    break;

                }

            }

        }

        break;

    }

    } // switch( iRepeatRuleFrequency )

    // Finally remove any possible exception dates from the repeat dates array

    TInt exceptionDateFinder;

    TInt fetchIndex = 0;

    TKeyArrayFix key(0, ECmpTInt64);

    for (TInt index = 0; index < aExceptionDates.Count(); index++)

    {

        const TPIMDate& exceptDate = aExceptionDates.At(index);

        exceptionDateFinder = repeatDates->Find(exceptDate, key, fetchIndex);

        if (exceptionDateFinder == 0) // 0 means that the element was found

        {

            repeatDates->Delete(fetchIndex);

            // Deleting elements from the array does not cause the

            // array buffer to be automatically compressed.

            // Compress() method returns excess space to the heap.

            repeatDates->Compress();

        }

    }

    CleanupStack::PopAndDestroy(fields);

    CleanupStack::Pop(repeatDates);

    return repeatDates;

}

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

// PIMRepeatRuleConverter::IsValidAgendaDate

// Tells whether given date is ok for Agenda

// (between 1st January 1980 and 31st December 2100).

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

//

TBool PIMRepeatRuleConverter::IsValidAgendaDate(const TPIMDate& aDate)

{

    JELOG2(EPim);

    return ((aDate >= TCalTime::MinTime()) && (aDate <= TCalTime::MaxTime()));

}

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

// PIMRepeatRuleConverter::ConvertRepeatToAgnL

// Converts a PIM repeat rule to Agenda Model repeat definition.

// Frequency is resolved first, as it affects rule formation.

// Then frequency-dependent parts are resolved by frequencty.

// Finally common parts are resolved.

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

//

TCalRRule PIMRepeatRuleConverter::ConvertSupportedRepeatToAgnL(

    const MPIMRepeatRuleData& aSrcPimRRule, TPIMDate aStartDate)

{

    JELOG2(EPim);

    TCalTime calStartDate;

    calStartDate.SetTimeUtcL(aStartDate);

    TCalRRule dstAgnRRule;

    if (IsRepeatFieldPresentL(EPIMRepeatRuleFrequency, aSrcPimRRule))

    {

        const TInt pimFrequency = aSrcPimRRule.GetIntL(EPIMRepeatRuleFrequency);

        if (pimFrequency == EPIMRepeatRuleDaily)

        {

            dstAgnRRule.SetType(TCalRRule::EDaily);

        }

        else if (pimFrequency == EPIMRepeatRuleWeekly)

        {

            dstAgnRRule.SetType(TCalRRule::EWeekly);

            RArray<TDay> weekDays; // put in current weekday

            CleanupClosePushL(weekDays);

            User::LeaveIfError(weekDays.Append(aStartDate.DayNoInWeek()));

            dstAgnRRule.SetByDay(weekDays);

            CleanupStack::PopAndDestroy(&weekDays);

        }

        else if (pimFrequency == EPIMRepeatRuleMonthly)

        {

            dstAgnRRule.SetType(TCalRRule::EMonthly);

            RArray<TInt> monthDays; // put in current month day number

            CleanupClosePushL(monthDays);

            User::LeaveIfError(monthDays.Append(aStartDate.DayNoInMonth()));

            dstAgnRRule.SetByMonthDay(monthDays);

            CleanupStack::PopAndDestroy(&monthDays);

        }

        else if (pimFrequency == EPIMRepeatRuleYearly)

        {

            dstAgnRRule.SetType(TCalRRule::EYearly);

        }

        else

        {

            User::Leave(KErrCorrupt); // invalid frequency

        }

    }

    else // frequency not present

    {

        User::Leave(KErrAbort);

    }

    AddCommonRulesToAgnL(aSrcPimRRule, aStartDate, dstAgnRRule);

    return dstAgnRRule;

}

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

// PIMRepeatRuleConverter::ConvertRepeatToPIM

// Converts an Agenda Model repeat definition to PIM repeat rule

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

//

void PIMRepeatRuleConverter::ConvertSupportedRepeatToPIML(

    MPIMRepeatRuleData& aDstPimRRule, TCalRRule& aSrcAgnRRule)

{

    JELOG2(EPim);

    aDstPimRRule.clear();

    // Frequency

    if (aSrcAgnRRule.Type() == TCalRRule::EDaily)

    {

        aDstPimRRule.SetIntL(EPIMRepeatRuleFrequency, EPIMRepeatRuleDaily);

    }

    else if (aSrcAgnRRule.Type() == TCalRRule::EWeekly)

    {

        aDstPimRRule.SetIntL(EPIMRepeatRuleFrequency, EPIMRepeatRuleWeekly);

    }

    else if (aSrcAgnRRule.Type() == TCalRRule::EMonthly)

    {

        aDstPimRRule.SetIntL(EPIMRepeatRuleFrequency, EPIMRepeatRuleMonthly);

    }

    else if (aSrcAgnRRule.Type() == TCalRRule::EYearly)

    {

        aDstPimRRule.SetIntL(EPIMRepeatRuleFrequency, EPIMRepeatRuleYearly);

    }

    else

    {

        User::Leave(KErrCorrupt); // repeatrule without frequency

    }

    // Interval

    aDstPimRRule.SetIntL(EPIMRepeatRuleInterval, aSrcAgnRRule.Interval());

    // End time

    TCalTime calEndDate = aSrcAgnRRule.Until();

    TTime pimEndDate(calEndDate.TimeUtcL());

    aDstPimRRule.SetDateL(EPIMRepeatRuleEnd, pimEndDate);

}

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

// PIMRepeatRuleConverter::IsRepeatFieldPresentL

// Checks if a field is present in the repeat rule.

// Use the other overload instead if you are checking multiple fields.

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

//

TBool PIMRepeatRuleConverter::IsRepeatFieldPresentL(TPIMField aRepeatRuleField,

        const MPIMRepeatRuleData& aRepeat)

{

    JELOG2(EPim);

    CArrayFix<TPIMField>* repeatFields = aRepeat.GetFieldsL();

    CleanupStack::PushL(repeatFields);

    TBool retVal = IsRepeatFieldPresentL(aRepeatRuleField, *repeatFields);

    CleanupStack::PopAndDestroy(repeatFields);

    return retVal;

}

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

// PIMRepeatRuleConverter::IsRepeatFieldPresentL

// Checks if a field is present in the array of repeat fields.

// Optimizes speed if called repeatedly instead of the overload

// which takes a MPIMRepeatRuleData.

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

//

TBool PIMRepeatRuleConverter::IsRepeatFieldPresentL(TPIMField aRepeatRuleField,

        const CArrayFix<TPIMField>& aRepeatFields)

{

    JELOG2(EPim);

    TInt fetchIndex = 0;

    TKeyArrayFix key(0, ECmpTInt);

    TInt found = aRepeatFields.Find(aRepeatRuleField, key, fetchIndex);

    return (found == KErrNone);

}

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

// PIMRepeatRuleConverter::AddRepeatDateL

// Checks if a single date is qualified as a repeat date, and adds it to array.

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

//

TBool PIMRepeatRuleConverter::AddRepeatDateL(

    const CArrayFix<TPIMField>& /*aFields*/, TTime aDate,

    TTime aSubsetBeginning, TTime aSubsetEnding,

    const TTime& aRepeatRuleEndDate, const TInt aRepeatRuleCount,

    CArrayFixFlat<TPIMDate>** aRepeatDates, TInt* aCountIndex)

{

    JELOG2(EPim);

    if (aDate < aSubsetBeginning)

    {

        return ETrue; // Here it is possible to still continue (no date added)