/*

* 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 conflict checker implementation

*  Version     : %version: e002sa33#10.1.2 %

*

*/

#include "emailtrace.h"

#include "cesmrconflictchecker.h"

#include "cesmrcaldbmgr.h"

#include "esmrhelper.h"

#include "esmrentryhelper.h"

#include "esmrinternaluid.h"

#include "cesmrcaluserutil.h"

#include <calcommon.h>

#include <calinstance.h>

#include <calentryview.h>

#include <calinstanceview.h>

#include <calinstanceiterator.h>

#include <ct/rcpointerarray.h>

#include <calrrule.h>

/// Unnamed namespace for local definitions

namespace { // codescanner::namespace

// Definition for zero

const TInt KZero(0);

/** Defines instace filter type */

enum TInstanceFilter

    {

    EIncludeSameUID,

    ERemoveSameUID

    };

#ifdef _DEBUG

// Literal for panic texts

_LIT( KESMRConflictCheckerTxt, "ESMRConflictChecker" );

/** Enumeration for panic codes */

enum TESMRConflictCheckerPanic

    {

    // Input entry is not appointment

    EESMRConflictCheckerInvalidEntryType

    };

/**

 * Thows system wide panic.

 * @param aPanic Panic code.

 */

void Panic( TESMRConflictCheckerPanic aPanic )

    {

    User::Panic( KESMRConflictCheckerTxt, aPanic );

    }

#else

/**

 * Thows system wide leave.

 * @param aError Leave code.

 */

void Leave( TInt aError )

    {

    User::Leave( aError );

    }

#endif

/**

 * Resolves time range for possible conflicting entries. Instance view

 * is used for resolving the time range.

 *

 * @param aStart Start time

 * @param aEnd End time

 * @param aInstanceView Pointer to calendar db instance view

 * @return Time range for possible conflicting entries

 */

CalCommon::TCalTimeRange ResolveFetchTimeRangeL(

        TTime aStart,

        TTime aEnd,

        CCalInstanceView* aInstanceView )

    {

    FUNC_LOG;

    const CalCommon::TCalViewFilter instanceFilter =

            CalCommon::EIncludeAppts | CalCommon::EIncludeEvents;

    TDateTime start = aStart.DateTime();

    TDateTime end   = aEnd.DateTime();

    start.SetHour( KZero );

    start.SetMinute( KZero );

    start.SetSecond( KZero );

    start.SetMicroSecond( KZero );

    end.SetHour( KZero );

    end.SetMinute( KZero );

    end.SetSecond( KZero );

    end.SetMicroSecond( KZero );

    TTime endTime = end;

    if ( TTime(start) == endTime ||

         endTime < aEnd )

        {

        endTime += TTimeIntervalDays(1);

        end = endTime.DateTime();

        }

    TCalTime rangeStart;

    rangeStart.SetTimeLocalL( start );

    TCalTime instanceTime = aInstanceView->PreviousInstanceL(

            instanceFilter,

            rangeStart );

    if (  Time::NullTTime() != instanceTime.TimeUtcL()  )

        {

        rangeStart = instanceTime;

        }

    TCalTime rangeEnd;

    rangeEnd.SetTimeLocalL( end );

    instanceTime = aInstanceView->NextInstanceL(

            instanceFilter,

            rangeEnd );

    if ( instanceTime.TimeLocalL() != Time::NullTTime() )

        {

        rangeEnd = instanceTime;

        }

    return CalCommon::TCalTimeRange( rangeStart, rangeEnd );

    }

/**

 * Removes and deletes the entries, which do not conflict with

 * entry. Entry is considered to be conflicting entry if starts or

 * ends between aEntry's start and end time.

 *

 * @param aEntries Reference to entries, which may conflict

 * @param aEntry Reference to entry, which confilcts are resolved.

 */

void RemoveAndDeleteNonConflictingInstancesL(

    RPointerArray<CCalInstance>& instanceArray,

    TCalTime aStartTime,

    TCalTime aEndTime,

    const TDesC8& aUid,

    TInstanceFilter aFilterType )

    {

    FUNC_LOG;

    TInt index(0);

    TTime startTimeLocal = aStartTime.TimeLocalL();

    TTime endTimeLocal = aEndTime.TimeLocalL();

    while( index < instanceArray.Count() )

        {

        TBool conflictingInstance( ETrue );

        CCalInstance* instance = instanceArray[index];

        TTime entryStartTimeLocal = instance->StartTimeL().TimeLocalL();

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

        TPtrC8 uid( instance->Entry().UidL() );

        if ( ERemoveSameUID == aFilterType &&

             0 == aUid.CompareF(uid) )

            {

            conflictingInstance = EFalse;

            }

        else if ( entryStartTimeLocal >= startTimeLocal &&

                  entryStartTimeLocal < endTimeLocal )

            {

            // Entry starts during another entry

            index++;

            }

        else if ( entryEndTimeLocal > startTimeLocal &&

                entryEndTimeLocal <= endTimeLocal )

            {

            // Entry ends during another entry

            index++;

            }

        else if ( entryStartTimeLocal < startTimeLocal &&

                  entryEndTimeLocal > endTimeLocal )

            {

            // Antry starts and ends during another entry

            index++;

            }

        else

            {

            conflictingInstance = EFalse;

            }

        // Remove non-conflicting instance from instance array

        if ( !conflictingInstance )

            {

            instanceArray.Remove(index);

            delete instance;

            instance = NULL;

            }

        }

    }

/**

 * Creates calendar entries from the conflicting instances

 * and stores the created entries into entry array.

 * Ownership of the created entries is transferred to caller.

 * @param aInstanceArray Reference to instance array

 * @param aConflictingEntries Reference to entry array.

 */

void CreateEntriesFromInstancesL(

        RPointerArray<CCalInstance>& instanceArray,

        RPointerArray<CCalEntry>& aConflictingEntries )

    {

    FUNC_LOG;

    TInt instanceCount( instanceArray.Count() );

    for ( TInt i(0); i < instanceCount; ++i )

        {

        CCalEntry& parent( instanceArray[i]->Entry() );

        CCalEntry* entry = ESMRHelper::CopyEntryLC( parent,

                                                    parent.MethodL(),

                                                    ESMRHelper::ECopyFull );

        entry->SetStartAndEndTimeL( instanceArray[i]->StartTimeL(),

                                    instanceArray[i]->EndTimeL() );

        aConflictingEntries.AppendL( entry );

        CleanupStack::Pop( 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 |

                CalCommon::EIncludeEvents ,

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

                if ( start <= entryStartTime )

                    {

                    // Start time is in recurrence range

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

                            {