/*

* Copyright (c) 2002-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:   Static utility functions. 

 *                - date utils to help comparisions and calculations with

 *                  dates and times. 

 *

*/

#include <calinstance.h>

#include <calinstanceview.h>

#include <calrrule.h>

#include <calenagendautils.h>

#include <calendateutils.h>

//debug

#include "calendarui_debug.h"

#include "vstaticutils.h"

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

// ============================ CalenAgendaUtils ==============================

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

// CalenAgendaUtils::FindEventsForDayRangeL

// ?implementation_description

// (other items were commented in a header).

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

//

EXPORT_C void CalenAgendaUtils::FindEventsForDayRangeL( CCalInstanceView* aInstanceView, 

                                                        RPointerArray<CCalInstance>& aList, 

                                                        const CalCommon::TCalViewFilter& aFilter, 

                                                        const TTime& aStartDay,

                                                        const TTime& aEndDay )

    {

    TRACE_ENTRY_POINT;

    TCalTime dummy;

    CalCommon::TCalTimeRange dayRange( dummy, dummy );

    CalenDateUtils::GetDayRangeL( aStartDay, aEndDay, dayRange );

    if(CalenDateUtils::IsValidDay(aStartDay))

    {

        aInstanceView->FindInstanceL( aList, aFilter, dayRange );    

    }

    TRACE_EXIT_POINT;

    }

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

// CalenAgendaUtils::FindTodosForDayRangeL

// ?implementation_description

// (other items were commented in a header).

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

//

EXPORT_C void CalenAgendaUtils::FindTodosForDayRangeL( CCalInstanceView* aInstanceView, 

                                                       RPointerArray<CCalInstance>& aList, 

                                                       const TTime& aStartDay,

                                                       const TTime& aEndDay )

    {

    TRACE_ENTRY_POINT;

    const TCalTime dummy;

    CalCommon::TCalTimeRange dayRange( dummy, dummy );

    CalenDateUtils::GetDayRangeL( aStartDay, aEndDay, dayRange );

    TTime today;  today.HomeTime();

    const TTime tomorrow( today + TTimeIntervalDays(1) );

    const TTime rangeStart( dayRange.StartTime().TimeLocalL() );  // at 00:00.00

    const TTime rangeEnd( dayRange.EndTime().TimeLocalL() ); // at 23:59.59

    // fetch past uncompleted to-dos for today if today is included in the range

    if( rangeStart <= today && today <= rangeEnd )

        {

        // today includes today's to-dos + all past incompleted todos

        CalenDateUtils::GetDayRangeL( TCalTime::MinTime(), today, dayRange );

        if(CalenDateUtils::IsValidDay(aStartDay))

        {

        aInstanceView->FindInstanceL( aList, 

                                      CalCommon::EIncludeIncompletedTodos | 

                                      // only fetch the first instance for repeating to-dos!

                                      CalCommon::EIncludeRptsNextInstanceOnly, 

                                      dayRange );

        }

        // reset the time range for the remaining days

        CalenDateUtils::GetDayRangeL( tomorrow, aEndDay, dayRange );

        }

    // today already fetched, fetch the remaining range if any...

    // (including all the instances of repeating to-dos)

    if( rangeEnd > tomorrow )

        {

        aInstanceView->FindInstanceL( aList, 

                                      CalCommon::EIncludeIncompletedTodos, 

                                      dayRange );

        }

    TRACE_EXIT_POINT;

    }

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

// CalenAgendaUtils::RemoveEntriesStartingAtMidnight

// ?implementation_description

// (other items were commented in a header).

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

//

EXPORT_C void CalenAgendaUtils::RemoveEntriesEndingAtMidnightL( RPointerArray<CCalInstance>& aList, 

                                                                const TTime& aDay )

    {

    TRACE_ENTRY_POINT;

    // Remove events starting before aDay and ending at midnight

    TInt i( 0 );

    while( i < aList.Count() )

        {

        CCalInstance* item = aList[i];

        if( EndsAtStartOfDayL( item, aDay ) )

            {

            aList.Remove( i );

            delete item; // remember to delete before we lose the pointer

            }

        else

            {

            ++i;

            }

        }

    TRACE_EXIT_POINT;

    }

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

// CalenAgendaUtils::CreateEntryIdListForDayL

// ?implementation_description

// (other items were commented in a header).

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

//

EXPORT_C void CalenAgendaUtils::CreateEntryIdListForDayL( RPointerArray<CCalInstance>& aList, 

                                                          CCalInstanceView* aInstanceView, 

                                                          const TTime& aDay, 

                                                          const TBool aSortForPopup, 

                                                          const TBool aIncludeToDos )

    {

    TRACE_ENTRY_POINT;

    const CalCommon::TCalViewFilter filter = CalCommon::EIncludeAppts    | 

                                             CalCommon::EIncludeReminder | 

                                             CalCommon::EIncludeEvents   | 

                                             CalCommon::EIncludeAnnivs;

    CalenAgendaUtils::FindEventsForDayRangeL( aInstanceView, aList, filter, aDay, aDay );

    CalenAgendaUtils::RemoveEntriesEndingAtMidnightL( aList, aDay );

    if( aIncludeToDos )

        {

        CalenAgendaUtils::FindTodosForDayRangeL( aInstanceView, aList, aDay, aDay );

        }

    if( aSortForPopup )

        {

        CalenAgendaUtils::SortPopupInstanceList( aList );

        }

    else

        {

        CalenAgendaUtils::SortInstanceList( aList );

        }

    TRACE_EXIT_POINT;

    }

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

// CalenAgendaUtils::EndsAtStartOfDayL

// ?implementation_description

// (other items were commented in a header).

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

//

EXPORT_C TBool CalenAgendaUtils::EndsAtStartOfDayL( CCalInstance* aInstance,

                                                    const TTime& aDay )

    {

    TRACE_ENTRY_POINT;

    const TTime dayStart = CalenDateUtils::BeginningOfDay( aDay );

    const TTime startTime( aInstance->Time().TimeLocalL() );

    TTimeIntervalMinutes duration;

    aInstance->Entry().EndTimeL().TimeLocalL().MinutesFrom( aInstance->Entry().StartTimeL().TimeLocalL(), duration );

    const TTime endTime( startTime +duration );

    const TBool result( endTime > startTime && endTime == dayStart );

    TRACE_EXIT_POINT;

    return result;

    }

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

// CalenAgendaUtils::SortInstanceList

// ?implementation_description

// (other items were commented in a header).

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

//

EXPORT_C void CalenAgendaUtils::SortInstanceList( RPointerArray<CCalInstance>& aInstanceList )

    {

    TRACE_ENTRY_POINT;

    TLinearOrder<CCalInstance> instanceListOrder( CalenAgendaUtils::EntryCompare );

    aInstanceList.Sort( instanceListOrder );

    TRACE_EXIT_POINT;

    }

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

// CalenAgendaUtils::SortInstanceList

// ?implementation_description

// (other items were commented in a header).

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

//

EXPORT_C void CalenAgendaUtils::SortPopupInstanceList( RPointerArray<CCalInstance>& aInstanceList )

    {

    TRACE_ENTRY_POINT;

    TLinearOrder<CCalInstance> instanceListOrder( CalenAgendaUtils::PopupEntryCompare );

    aInstanceList.Sort( instanceListOrder );

    TRACE_EXIT_POINT;

    }

TInt CalenAgendaUtils::EntryCompare(const CCalInstance& aInstance1, const CCalInstance& aInstance2)

    {

    TRACE_ENTRY_POINT;

    TInt res = KErrArgument;

    TRAP_IGNORE( ( res = DoEntryCompareL( aInstance1, aInstance2 ) ) );

    TRACE_EXIT_POINT;    

    return res;

    }

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

// CalenAgendaUtils::DoEntryCompareL

// Common compare for all calendar entries. Order as follows:

//  1. ETodo

//  2. EEvent

//  3. EAnniv

//  4. EAppt, EReminder

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

//

TInt CalenAgendaUtils::DoEntryCompareL( const CCalInstance& aInstance1,

                                        const CCalInstance& aInstance2 )

    {

    TRACE_ENTRY_POINT;

    TInt ret( EEqual );

    const CCalEntry& entry1 = aInstance1.Entry();

    const CCalEntry& entry2 = aInstance2.Entry();

    const CCalEntry::TType type1 = entry1.EntryTypeL();

    const CCalEntry::TType type2 = entry2.EntryTypeL();

    // types are equal (reminders are handled as meetings)

    if( type1 == type2 ||

      ((type1 == CCalEntry::EAppt && type2 == CCalEntry::EReminder)  || 

      (type2 == CCalEntry::EAppt && type1 == CCalEntry::EReminder)) )

        {

        switch( type1 )

            {

            case CCalEntry::ETodo:

                ret = CalenAgendaUtils::CompareToDosL( entry1, entry2 );

                break;

            case CCalEntry::EAnniv:

            case CCalEntry::EEvent:

                ret = CalenAgendaUtils::CompareNonTimedNotesL( aInstance1, aInstance2 );

                break;

            case CCalEntry::EReminder:

            case CCalEntry::EAppt:

                ret = CalenAgendaUtils::CompareTimedNotesL( aInstance1, aInstance2 );

                break;

            default:

                ASSERT(EFalse);

            }

        }

        else // types are different

        {

#ifdef RD_CALENDAR_PREVIEW

        switch( type1 )

            {

            case CCalEntry::ETodo:

                // to-dos come always first...

                ret = ELessThan;

                break;

            case CCalEntry::EAnniv:

                // ...and then anniversaries...

                if( type2 == CCalEntry::ETodo )

                    {

                    ret = EGreaterThan;            

                    }

                else

                    {

                    ret = ELessThan;            

                    } 

                break;

            case CCalEntry::EEvent:

                // ...then day notes...

                if( (type2 == CCalEntry::ETodo) || (type2 == CCalEntry::EAnniv)) 

                    {

                    ret = EGreaterThan;            

                    }

                else

                    {

                    ret = ELessThan;            

                    }

                break;

            case CCalEntry::EReminder:

            case CCalEntry::EAppt:

                // ...and finally timed notes...

                ret = EGreaterThan;

                break;

            default:

                ASSERT(EFalse);

            }                

#else // !RD_CALENDAR_PREVIEW

        switch( type1 )

            {

            case CCalEntry::ETodo:

                // to-dos come always first...

                ret = ELessThan;

                break;

            case CCalEntry::EEvent:

                // ...then day notes...

                if( type2 == CCalEntry::ETodo )

                    {

                    ret = EGreaterThan;

                    }

                else

                    {

                    ret = ELessThan;

                    }                             

                break;

            case CCalEntry::EAnniv:

                // ...and anniversaries...

                if( (type2 == CCalEntry::ETodo) || (type2 == CCalEntry::EEvent)) 

                    {

                    ret = EGreaterThan;                    

                    }

                else

                    {

                    ret = ELessThan;                    

                    }

                break;

            case CCalEntry::EReminder:

            case CCalEntry::EAppt:

                // ...and finally timed notes.

                ret = EGreaterThan;

                break;

            default:

                ASSERT(EFalse);

            }

#endif // RD_CALENDAR_PREVIEW

        }

    TRACE_EXIT_POINT;

    return ret;

    }

TInt CalenAgendaUtils::PopupEntryCompare( const CCalInstance& aInstance1,

                                          const CCalInstance& aInstance2 )

    {

    TRACE_ENTRY_POINT;

    TInt res = KErrArgument;

    TRAP_IGNORE( ( res = DoPopupEntryCompareL( aInstance1, aInstance2 ) ) );

    TRACE_EXIT_POINT;    

    return res;

    }

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

// CalenAgendaUtils::DoPopupEntryCompareL

// Compare for calendar pop-up. Order as follows:

//  1. ETodo

//  2. EAnniv

//  3. EEvent

//  4. EAppt, EReminder

// (other items were commented in a header).

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

//

TInt CalenAgendaUtils::DoPopupEntryCompareL( const CCalInstance& aInstance1,

                                             const CCalInstance& aInstance2 )

    {

    TRACE_ENTRY_POINT;

    TInt ret( EEqual );

    const CCalEntry& entry1 = aInstance1.Entry();

    const CCalEntry& entry2 = aInstance2.Entry();

    const CCalEntry::TType type1 = entry1.EntryTypeL();

    const CCalEntry::TType type2 = entry2.EntryTypeL();

    // types are equal (reminders are handled as meetings)

    if( type1 == type2 ||

        ((type1 == CCalEntry::EAppt && type2 == CCalEntry::EReminder)  || 

        (type2 == CCalEntry::EAppt && type1 == CCalEntry::EReminder)) )

        {

        switch( type1 )

            {

            case CCalEntry::ETodo:

                ret = CalenAgendaUtils::CompareToDosL( entry1, entry2 );

                break;

            case CCalEntry::EAnniv:

            case CCalEntry::EEvent:

                ret = CalenAgendaUtils::CompareNonTimedNotesL( aInstance1, aInstance2 );

                break;

            case CCalEntry::EReminder:

            case CCalEntry::EAppt:

                ret = CalenAgendaUtils::CompareTimedNotesL( aInstance1, aInstance2 );

                break;

            default:

                ASSERT(EFalse);

            }

        }

     else // types are different

     {

         switch( type1 )

            {

            case CCalEntry::ETodo:

            // to-dos come always first...

            ret = ELessThan;

                break;

            case CCalEntry::EAnniv:

            // ...and then anniversaries...

            if( type2 == CCalEntry::ETodo )

                {

                ret = EGreaterThan;            

                }

            else

                {

                ret = ELessThan;            

                } 

                break;

            case CCalEntry::EEvent:

            // ...then day notes...

            if( (type2 == CCalEntry::ETodo) || (type2 == CCalEntry::EAnniv)) 

                {

                ret = EGreaterThan;            

                }

            else

                {

                ret = ELessThan;            

                }

            break;

            case CCalEntry::EReminder:

            case CCalEntry::EAppt:

                // ...and finally timed notes...

                ret = EGreaterThan;

                break;

            default:

                ASSERT(EFalse);

            }

        }

    TRACE_EXIT_POINT;

    return ret;

    }

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

// CalenAgendaUtils::CompareToDos

// Compares two to-do entries. Sort criteria:

//  1. Status: ETodoNeedsAction before ETodoCompleted

//  2. Due date: oldest first (1.1.2005 before 2.1.2005 )

//  3. Priority: highest first (1 before 2 )

//  4. Last modified: oldest first (1.1.2005 09:00 before 1.1.2005 10:00 )

// (other items were commented in a header).

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

//

TInt CalenAgendaUtils::CompareToDosL( const CCalEntry& aEntry1,

                                      const CCalEntry& aEntry2 )

    {

    TRACE_ENTRY_POINT;

    TInt ret( EEqual );

    CCalEntry::TStatus status1 = aEntry1.StatusL();

    CCalEntry::TStatus status2 = aEntry2.StatusL();

    if( status1 == CCalEntry::ENullStatus )

        {

        status1 = CCalEntry::ETodoNeedsAction;

        }

    if( status2 == CCalEntry::ENullStatus )

        {

        status2 = CCalEntry::ETodoNeedsAction;

        }

    if( status1 == status2 )

        {

        TTime time1 = aEntry1.EndTimeL().TimeUtcL();

        TTime time2 = aEntry2.EndTimeL().TimeUtcL();

        if( time1 == time2 )