/*
* Copyright (c) 2005-2006 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:  
 *
*/

#include "aicalendarplugin2data.h"
#include "aicalendarplugin2contentmodel.h"
#include "aicalendarplugin2constants.hrh"
#include <aicontentmodel.h>
#include <e32cmn.h>

// Helper for sort method
TInt TimeDetermination( const CAiCalendarPlugin2EventItem& aOne,
                        const CAiCalendarPlugin2EventItem& aTwo )
    {
    if( aOne.Time() == aTwo.Time() )
        {
        TTime time_1 = aOne.LastModifiedTime();
        TTime time_2 = aTwo.LastModifiedTime();
        if( time_1 == time_2 )
            {
            return  0;
            }
        else if( time_1 > time_2 )
            {
            return  1; // oldest first
            }
        else
            {
            return -1;
            }
        }
    else if( aOne.Time() < aTwo.Time() )
        {
        return -1;
        }
    return 1;
    }

TInt TypeDetermination( const CAiCalendarPlugin2EventItem& aOne,
                        const CAiCalendarPlugin2EventItem& aTwo )
    {
    TBool oneIsMeeting = EFalse;
    TBool twoIsMeeting = EFalse;
    if( ( ( aOne.Type() == EPluginItemMeeting ) ||
          ( aOne.Type() == EPluginItemUpcomingMeeting ) ||
          ( aOne.Type() == EPluginItemOnGoingEvent ) ||
          ( aOne.Type() == EPluginItemOlderOnGoingEvent ) ) )
        {
        oneIsMeeting = ETrue;
        }
    if( ( aTwo.Type() == EPluginItemMeeting ) ||
        ( aTwo.Type() == EPluginItemUpcomingMeeting ) ||
        ( aTwo.Type() == EPluginItemOnGoingEvent ) ||
        ( aTwo.Type() == EPluginItemOlderOnGoingEvent ) )
        {
        twoIsMeeting = ETrue;
        }
        
    if( oneIsMeeting || twoIsMeeting )
        {
        // Meetings always overrule non timed
        return( ( oneIsMeeting == twoIsMeeting ) ? ( 0 ) : ( oneIsMeeting * -1 + twoIsMeeting ) );
        }
    else
        {
        // Both are non timed
        if( aOne.Type() == aTwo.Type() )
            {
            return 0;
            }
        else if( aOne.Type() == EPluginItemToDo )
            {
            return -1;
            }
        else if( aTwo.Type() == EPluginItemToDo )
            {
            return 1;
            }
        else if( aOne.Type() == EPluginItemDayNote )
            {
            return -1;
            }
        else if( aTwo.Type() == EPluginItemDayNote )
            {
            return 1;
            }
        }
    // Should never happed...
    return 0;
    }
    
// Sort method
TInt CompareEventItems( const CAiCalendarPlugin2EventItem& aOne,
                        const CAiCalendarPlugin2EventItem& aTwo )
    {
    if( aOne.Type() != aTwo.Type() )
        {
        if( aOne.OnSameDay( aOne.Time(), aTwo.Time() ) )
            {
            // Different types, same day
            TInt typeDetermination = TypeDetermination( aOne, aTwo );
            if( typeDetermination != 0 )
                {
                return typeDetermination;
                }
            }
        }
    // Same types or different types different day or both meetings(not same category)
    return TimeDetermination(  aOne, aTwo );
    }
    
// ============================ MEMBER FUNCTIONS ===============================

CAICalendarPlugin2Data* CAICalendarPlugin2Data::NewL()
    {
    CAICalendarPlugin2Data* self = new( ELeave )CAICalendarPlugin2Data;
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

CAICalendarPlugin2Data::CAICalendarPlugin2Data()
  : iSpaceTakenByTimedEvent( 1 ),
    iSpaceTakenByNonTimedEvent( 1 ),
    iHadExpiredEvents( EFalse )
    {
    }

void CAICalendarPlugin2Data::ConstructL()
    {
    }

CAICalendarPlugin2Data::~CAICalendarPlugin2Data()
    {
    ClearDataArrays();

    iUpcoming2HrsItemData.Close();
    iUpcomingItemData.Close();
    iOngoing30MinItemData.Close();
    iOngoingItemData.Close();
    iNonTimedItemData.Close();
    iTomorrowItemData.Close();
    iNotTodayItemData.Close();
    iFutureItemData.Close();
    iLongOngoingItemData.Close();

    iEventFocusData.Reset();
    iEventFocusData.Close();

    iObservers.Reset();
    iObservers.Close();
    }
    
void CAICalendarPlugin2Data::ClearDataArrays()
    {
    // cleanup
    iUpcoming2HrsItemData.ResetAndDestroy();
    iUpcomingItemData.ResetAndDestroy();
    iOngoing30MinItemData.ResetAndDestroy();
    iOngoingItemData.ResetAndDestroy();
    iNonTimedItemData.ResetAndDestroy();
    iTomorrowItemData.ResetAndDestroy();
    iNotTodayItemData.ResetAndDestroy();
    iFutureItemData.ResetAndDestroy();
    iLongOngoingItemData.ResetAndDestroy();
    }
    
RPointerArray<CAiCalendarPlugin2EventItem>& CAICalendarPlugin2Data::Upcoming2HrsArray()
    {
    return iUpcoming2HrsItemData;
    }

RPointerArray<CAiCalendarPlugin2EventItem>& CAICalendarPlugin2Data::UpcomingArray()
    {
    return iUpcomingItemData;
    }

RPointerArray<CAiCalendarPlugin2EventItem>& CAICalendarPlugin2Data::Ongoing30MinArray()
    {
    return iOngoing30MinItemData;
    }

RPointerArray<CAiCalendarPlugin2EventItem>& CAICalendarPlugin2Data::OngoingArray()
    {
    return iOngoingItemData;
    }

RPointerArray<CAiCalendarPlugin2EventItem>& CAICalendarPlugin2Data::NonTimedEventArray()
    {
    return iNonTimedItemData;
    }

RPointerArray<CAiCalendarPlugin2EventItem>& CAICalendarPlugin2Data::TomorrowEventArray()
    {
    return iTomorrowItemData;
    }

RPointerArray<CAiCalendarPlugin2EventItem>& CAICalendarPlugin2Data::NotTodayItemArray()
    {
    return iNotTodayItemData;
    }

RPointerArray<CAiCalendarPlugin2EventItem>& CAICalendarPlugin2Data::FutureItemArray()
    {
    return iFutureItemData;
    }

RPointerArray<CAiCalendarPlugin2EventItem>& CAICalendarPlugin2Data::LongOngoingArray()
    {
    return iLongOngoingItemData;
    }

TInt CAICalendarPlugin2Data::AppendItemToCorrectArray( CAiCalendarPlugin2EventItem& aItem,
                                                        TInt& aDayNoteIndex )
    {
    TInt err;
    if( aItem.IsTomorrow() && aItem.IsFutureEvent() )
        {
        err = iTomorrowItemData.Append( &aItem );
        return err;
        }
    else if( !aItem.IsToday() && !aItem.IsFutureEvent() &&
             aItem.Type() == EPluginItemOlderOnGoingEvent )
        {
        err = iLongOngoingItemData.Append( &aItem );
        return err;
        }
    else if( !aItem.IsToday() && aItem.IsNotTodayEvent() &&
             !aItem.IsFutureEvent() &&
             ( aItem.Type() == EPluginItemDayNote || 
               aItem.Type() == EPluginItemToDo || 
               aItem.Type() == EPluginItemAnniv ) )
        {
        if( aItem.Type() == EPluginItemDayNote || 
               aItem.Type() == EPluginItemToDo )
            {
            // insert...just to make sure day notes are always first
            err = iNonTimedItemData.Insert( &aItem, aDayNoteIndex++ );
            }
        else
            {
            // append...just to make sure day notes are always first
            err = iNonTimedItemData.Append( &aItem );
            }
        return err;
        }
    else if( !aItem.IsToday() && aItem.IsNotTodayEvent() )
        {
        err = iNotTodayItemData.Append( &aItem );
        return err;
        }
    else if( !aItem.IsToday() && aItem.IsFutureEvent() )
        {
        err = iFutureItemData.Append( &aItem );
        return err;
        }
    switch( aItem.Type() )
        {
        case EPluginItemMeeting:
            {
            // Meetings starting within 2 hrs
            err = iUpcoming2HrsItemData.Append( &aItem );
            break;
            }
        case EPluginItemUpcomingMeeting:
            {
            // Meetings starting more than 2 hrs current time
            err = iUpcomingItemData.Append( &aItem );
            break;
            }
        case EPluginItemOnGoingEvent:
            {
            // Meetings that have started with 30 mon before current time
            // and are still on going.
            err = iOngoing30MinItemData.Append( &aItem );
            break;
            }
        case EPluginItemOlderOnGoingEvent:
            {
            // Meetings that have started more that 30 minutes ago and
            // are still ongoing
            err = iOngoingItemData.Append( &aItem );
            break;
            }
        case EPluginItemDayNote: // fallthrough
        case EPluginItemToDo:
            {
            // insert...just to make sure day notes are always first
            err = iNonTimedItemData.Insert( &aItem, aDayNoteIndex++ );
            break;
            }
        case EPluginItemAnniv:
            {
            // append...just to make sure day notes are always first
            err = iNonTimedItemData.Append( &aItem );
            break;
            }
        default:
            {
            err = KErrNotSupported;
            break;
            }
        }
    return err;
    }

void CAICalendarPlugin2Data::SortArrayByTime( RPointerArray<CAiCalendarPlugin2EventItem>& aArray )
    {
    // Sort
    aArray.Sort( TLinearOrder<CAiCalendarPlugin2EventItem>( CompareEventItems ) );
    }

TInt CAICalendarPlugin2Data::TotalTimedTodaySpaceReservation()
    {
    return
    ( iUpcoming2HrsItemData.Count() * iSpaceTakenByTimedEvent ) +
    ( iUpcomingItemData.Count() * iSpaceTakenByTimedEvent ) +
    ( iOngoing30MinItemData.Count() * iSpaceTakenByTimedEvent ) +
    ( iOngoingItemData.Count() * iSpaceTakenByTimedEvent );
    }

TInt CAICalendarPlugin2Data::TotalTodayItemCount()
    {
    return
    ( iUpcoming2HrsItemData.Count() ) +
    ( iUpcomingItemData.Count() ) +
    ( iOngoing30MinItemData.Count() ) +
    ( iOngoingItemData.Count() ) +
    iNonTimedItemData.Count();
    }

TInt CAICalendarPlugin2Data::TotalTimedTodayItemCount()
    {
    return
    ( iUpcoming2HrsItemData.Count() ) +
    ( iUpcomingItemData.Count() ) +
    ( iOngoing30MinItemData.Count() ) +
    ( iOngoingItemData.Count() );
    }

RPointerArray<MAiContentObserver>& CAICalendarPlugin2Data::ObserverArray()
    {
    return iObservers;
    }

void CAICalendarPlugin2Data::AppendObserverL( MAiContentObserver& aObserver )
    {
    // make sure that 1 obs only subscribed once
    for( TInt i( 0 ); i < iObservers.Count(); ++i )
        {
        if( iObservers[i] == &aObserver )
            {
            User::Leave( KErrAlreadyExists );
            }
        }
    iObservers.AppendL( &aObserver );
    }
    
RArray<TAiCalendarFocusData>& CAICalendarPlugin2Data::FocusDataArray()
    {
    return iEventFocusData;
    }

void CAICalendarPlugin2Data::LaunchCalendarApplication( TInt aIndex, TBool aLaunchFirstValid )
    {
    if( aIndex < 0 ||
        aIndex >= iEventFocusData.Count() )
        {
        // invalid index
        return;
        }

    TInt indexToLaunch = aIndex;
    if( aLaunchFirstValid )
        {
        for( TInt i = 0; i < iEventFocusData.Count(); ++i )
            {
            if( iEventFocusData[i].iType != EAI2CalOpenToday )
                {
                indexToLaunch = i;
                break;
                }
            }
        }

    TRAP_IGNORE(            
        iEventFocusData[indexToLaunch].LaunchCalendarApplicationL();
    );
    }
    
TBool CAICalendarPlugin2Data::HadExpiredEvents()
    {
    return iHadExpiredEvents;
    }

void CAICalendarPlugin2Data::SetHadExpiredEvents( TBool aHadExpired )
    {
    iHadExpiredEvents = aHadExpired;
    }