* Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

*  Version     : %version: e002sa33#9 %

#include <calrrule.h>

    const CalCommon::TCalViewFilter instanceFilter =

    if ( TTime(start) == endTime ||

        TTime entryEndTimeLocal = instance->EndTimeL().TimeLocalL();

        if ( ERemoveSameUID == aFilterType &&

            conflictingInstance = EFalse;

            delete instance;

    TInt instanceCount( instanceArray.Count() );

        {

        CCalEntry* entry = ESMRHelper::CopyEntryLC( parent,

        aConflictingEntries.AppendL( entry );

/**

 * Checks if entry is repeating.

 * @return ETrue if entry is repeating

 */

TBool IsRepeatingMeetingL( const CCalEntry& aEntry,

                           MESMRCalDbMgr& aDb )

    {

    FUNC_LOG;

    TBool recurrent( EFalse );

    CCalInstance* instance = aDb.FindInstanceL( aEntry );

    if ( instance )

        {

        CleanupStack::PushL( instance );

        recurrent = ESMREntryHelper::IsRepeatingMeetingL( instance->Entry() );

        CleanupStack::PopAndDestroy( instance );

        }

    else

        {

        recurrent = ESMREntryHelper::IsRepeatingMeetingL( aEntry );

        }

    return recurrent;

    }

/**

 * Finds conflicts for entry

 */

void FindConflictsForEntryL(

        const CCalEntry& aEntry,

        RPointerArray< CCalInstance >& aInstances,

        MESMRCalDbMgr& aDb )

    {

    FUNC_LOG;

    // Get instance views of all calendar

    RPointerArray<CCalInstanceView> allCalenInstanceView =

            aDb.NormalDbAllCalenInstanceView();

    // Check if there is any conflict in each calendar

    for( TInt i = 0; i < allCalenInstanceView.Count(); i++ )

        {

        CalCommon::TCalTimeRange timeRange =

                    ResolveFetchTimeRangeL(

                                    aEntry.StartTimeL().TimeUtcL(),

                                    aEntry.EndTimeL().TimeUtcL(),

                                    allCalenInstanceView[i] );

        allCalenInstanceView[i]->FindInstanceL(

                aInstances,

                CalCommon::EIncludeAppts,

                timeRange );

        }

    RemoveAndDeleteNonConflictingInstancesL(

            aInstances,

            aEntry.StartTimeL(),

            aEntry.EndTimeL(),

            aEntry.UidL(),

            ERemoveSameUID );

    }

/**

 * Moves instances from an array to another.

 */

void MoveInstancesL(

        RPointerArray< CCalInstance >& aFrom,

        RPointerArray< CCalInstance >& aTo )

    {

    FUNC_LOG;

    aTo.ReserveL( aTo.Count() + aFrom.Count() );

    while ( aFrom.Count() )

        {

        aTo.AppendL( aFrom[ 0 ] );

        aFrom.Remove( 0 );

        }

    }

/**

 * Finds conflicts based on Daily recurrence.

 *

 */

void FindConflictsForDailyRRuleL(

        CCalEntry& aEntry,

        RPointerArray< CCalInstance >& aInstances,

        MESMRCalDbMgr& aDb,

        TBool aFindAllConflicts )

    {

    FUNC_LOG;

    TCalRRule rRule;

    aEntry.GetRRuleL( rRule );

    RCPointerArray< CCalInstance > tmpInstanceArray;

    CleanupClosePushL( tmpInstanceArray );

    // Entry start and end time

    TTime start( aEntry.StartTimeL().TimeUtcL() );

    TTime end( aEntry.EndTimeL().TimeUtcL() );

    if ( rRule.Count() )

        {

        for ( TInt i = 0; i < rRule.Count(); ++i )

            {

            // Set each occurence start and end time on entry

            TTimeIntervalDays interval( i * rRule.Interval() );

            TCalTime startTime;

            startTime.SetTimeUtcL( start + interval );

            TCalTime endTime;

            endTime.SetTimeUtcL( end + interval );

            aEntry.SetStartAndEndTimeL(

                    startTime,

                    endTime );

            // Find conflicts for this occurence

            FindConflictsForEntryL( aEntry, tmpInstanceArray, aDb );

            if ( tmpInstanceArray.Count() )

                {

                MoveInstancesL( tmpInstanceArray, aInstances );

                if ( !aFindAllConflicts )

                    {

                    break;

                    }

                }

            }

        }

    else if ( rRule.Until().TimeUtcL() != Time::NullTTime() )

        {

        TTime until( rRule.Until().TimeUtcL() );

        TTime start( aEntry.StartTimeL().TimeUtcL() );

        TTime end( aEntry.EndTimeL().TimeUtcL() );

        TTimeIntervalDays interval( rRule.Interval() );

        // Loop while start time is before until time

        while ( start <= until )

            {

            // Set start and end time for occurence

            TCalTime startTime;

            startTime.SetTimeUtcL( start );

            TCalTime endTime;

            endTime.SetTimeUtcL( end );

            aEntry.SetStartAndEndTimeL(

                    startTime,

                    endTime );

            // Find conflicts

            FindConflictsForEntryL( aEntry, tmpInstanceArray, aDb );

            if ( tmpInstanceArray.Count() )

                {

                MoveInstancesL( tmpInstanceArray, aInstances );

                if ( !aFindAllConflicts )

                    {

                    break;

                    }

                }

            // Move to next occurence

            start += interval;

            end += interval;

            }

        }

    CleanupStack::PopAndDestroy( &tmpInstanceArray );

    }

/**

 * Finds conflicts based on Weekly recurrence.

 */

void FindConflictsForWeeklyRRuleL(

        CCalEntry& aEntry,

        RPointerArray< CCalInstance >& aInstances,

        MESMRCalDbMgr& aDb,

        TBool aFindAllConflicts )

    {

    FUNC_LOG;

    TCalRRule rRule;

    aEntry.GetRRuleL( rRule );

    // Tmp array for conflic instances

    RCPointerArray< CCalInstance > tmpInstanceArray;

    CleanupClosePushL( tmpInstanceArray );

    // Array of recurrence days

    RArray< TDay > days;

    CleanupClosePushL( days );

    rRule.GetByDayL( days );

    // Recurrence start time

    TTime start( aEntry.StartTimeL().TimeUtcL() );

    // Recurrence end time

    TTime end( aEntry.EndTimeL().TimeUtcL() );

    const TTimeIntervalDays KWeek( 7 );

    TDay startDayOfWeek( start.DayNoInWeek() );

    // Instance duration

    TTimeIntervalMinutes duration;

    end.MinutesFrom( start, duration );

    if ( rRule.Count() )

        {

        for ( TInt i = 0; i < rRule.Count(); ++i )

            {

            // Calculate weekly start time

            TTimeIntervalDays interval( i* KWeek.Int() );

            TDateTime date( TTime( start + interval ).DateTime() );

            date.SetDay( date.Day() - startDayOfWeek );

            TTime weekStartTime( date );

            for ( TInt j = 0; j < days.Count(); ++j )

                {

                // Iterate through days of week

                TTime entryStartTime( weekStartTime + TTimeIntervalDays( days[ j ] ) );

                if ( start <= entryStartTime )

                    {

                    // Start time is in recurrence range

                    // Calcualte end time

                    TCalTime startCalTime;

                    startCalTime.SetTimeUtcL( entryStartTime );

                    TCalTime endCalTime;

                    endCalTime.SetTimeUtcL( entryStartTime + duration );

                    aEntry.SetStartAndEndTimeL( startCalTime, endCalTime );

                    // Find conflicts of for entry and move them to result array

                    FindConflictsForEntryL( aEntry, tmpInstanceArray, aDb );

                    if ( tmpInstanceArray.Count() )

                        {

                        MoveInstancesL( tmpInstanceArray, aInstances );

                        if ( !aFindAllConflicts )

                            {

                            break;

                            }

                        }

                    }

                }

            if ( !aFindAllConflicts && aInstances.Count() )

                {

                break;

                }

            }

        }

    else if ( rRule.Until().TimeUtcL() != Time::NullTTime() )

        {

        TDateTime date( start.DateTime() );

        date.SetDay( date.Day() - startDayOfWeek );

        TTime weekStartTime( date );

        TTime until( rRule.Until().TimeUtcL() );

        while ( weekStartTime < until )

            {

            for ( TInt j = 0; j < days.Count(); ++j )

                {

                // Iterate through days of week

                TTime entryStartTime( weekStartTime + TTimeIntervalDays( days[ j ] ) );