/*

* Copyright (c) 2002 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:  The model part of popup

*/

#include <calinstance.h>

#include <calenagendautils.h>

#include <caleninstanceid.h>            // TCalenInstanceId

#include <calenviewutils.h>

#include <calenservices.h>

#include <centralrepository.h>

#include <calcalendarinfo.h>

#include "calendarui_debug.h"

#include "calenpreviewdata.h"

#include "calenpreviewlayoutmanager.h"

#include "calenpreviewentry.h"

#include "calenglobaldata.h"

#include "calendateutils.h"

#include "CalendarPrivateCRKeys.h"

#include "calenglobaldata.h"

#include "calennativeview.h"

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

// ?classname::?member_function

// ?implementation_description

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

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

//

CCalenPreviewData::CCalenPreviewData(

    CCalenPreviewLayoutManager *aLayoutManager,

    MCalenServices& aServices,

    TInt aMaxInstances)

    : iLayoutManager(aLayoutManager), 

      iNotShownEntries(EFalse),

      iMaxInstances(aMaxInstances),

      iServices( aServices )

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    }

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

// ?classname::?member_function

// ?implementation_description

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

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

//

void CCalenPreviewData::ConstructL(const TTime& aDay)

    {

    TRACE_ENTRY_POINT;

    FindInstancesL(aDay);

    TRACE_EXIT_POINT;

    }

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

// ?classname::?member_function

// ?implementation_description

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

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

//

CCalenPreviewData* CCalenPreviewData::NewL(

    CCalenPreviewLayoutManager *aLayoutManager,

    MCalenServices& aServices,

    TInt aMaxInstances,

    TTime aFocusedTime)

    {

    TRACE_ENTRY_POINT;

    CCalenPreviewData* self = new( ELeave ) CCalenPreviewData(aLayoutManager,

                                                              aServices,

                                                              aMaxInstances);

    CleanupStack::PushL( self );

    self->ConstructL(aFocusedTime);

    CleanupStack::Pop( self );

    TRACE_EXIT_POINT;

    return self;

    }

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

// ?classname::?member_function

// ?implementation_description

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

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

//

CCalenPreviewData* CCalenPreviewData::NewL(

    CCalenPreviewLayoutManager *aLayoutManager,

    MCalenServices& aServices,

    TInt aMaxInstances,

    CCalInstance* aInst)

    {

    TRACE_ENTRY_POINT;

    CCalenPreviewData* self = new( ELeave ) CCalenPreviewData(aLayoutManager,

                                                              aServices, 

                                                              aMaxInstances);

    CleanupStack::PushL( self );

    self->iSingleInstance = ETrue;

    self->iInstances.Append(aInst);

    CleanupStack::Pop( self );

    TRACE_EXIT_POINT;

    return self;

    }

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

// ?classname::?member_function

// ?implementation_description

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

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

//

CCalenPreviewData::~CCalenPreviewData()

    {

    TRACE_ENTRY_POINT;

    if(iLayoutManager)

        iLayoutManager->SetLinesUsed(0);

    /* Single instance is not owned by CalenPreviewData 

       so it is not deleted here*/

    iTodoPriorityOrder.Close();

    if(!iSingleInstance)

        iInstances.ResetAndDestroy();

    iInstances.Close();

    iEntries.ResetAndDestroy();

    iEntries.Close();

    TRACE_EXIT_POINT;

    }

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

// ?classname::?member_function

// ?implementation_description

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

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

//

TInt CCalenPreviewData::InstanceCount() const

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    return iInstances.Count();

    }

TInt CCalenPreviewData::EntryCount() const

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    return iEntries.Count();

    }

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

// ?classname::?member_function

// ?implementation_description

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

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

//

TBool CCalenPreviewData::NotShownEntries() const

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    return iNotShownEntries;

    }

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

// ?classname::?member_function

// ?implementation_description

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

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

//

void CCalenPreviewData::SetToday(TBool aToday) 

    {

    TRACE_ENTRY_POINT;

    iToday = aToday;

    TRACE_EXIT_POINT;

    }

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

// ?classname::?member_function

// ?implementation_description

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

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

//

TBool CCalenPreviewData::Today() 

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    return iToday;

    }

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

// CCalenPreviewData::RemoveInstancesL

// ?implementation_description

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

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

//

void CCalenPreviewData::RemoveInstancesL(const CCalEntry::TType aType)

    {

    TRACE_ENTRY_POINT;

    TInt i( iInstances.Count() - 1 );

    if(aType == CCalEntry::ETodo)

        {

        for(TInt i(0); i < iTodoPriorityOrder.Count() && iInstances.Count() > iMaxInstances; i++)

            {

            for(TInt j(0); j < iInstances.Count() && iInstances.Count() > iMaxInstances; j++)

                {

                if( iTodoPriorityOrder[i] == iInstances[j] )

                    {

                    delete iInstances[j];

                    iInstances.Remove(j);

                    iTodoPriorityOrder.Remove(i);

                    i--;

                    iNotShownEntries = ETrue;

                    break;

                    }   

                }

            }

        }

    else

        {

        TInt i( iInstances.Count() - 1 );

        while( i >= 0 && 

               iInstances.Count() > iMaxInstances )

            {

            if( iInstances[i]->Entry().EntryTypeL() == aType )

                {

                delete iInstances[i];

                iInstances.Remove(i);

                iNotShownEntries = ETrue;

                }

            i--;

            }

        }

    TRACE_EXIT_POINT;

    }

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

// CCalenPreviewData::RemoveInstances

// ?implementation_description

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

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

//

void CCalenPreviewData::RemoveInstances()

    {

    TRACE_ENTRY_POINT;

    TInt i( 0 );

    while( iInstances.Count() > iMaxInstances )

        {

        i = iInstances.Count() - 1;

        delete iInstances[i];

        iInstances.Remove( i );

        iNotShownEntries = ETrue;

        }

    TRACE_EXIT_POINT;

    }

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

// CCalenPreviewData::RemoveInstance

// ?implementation_description

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

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

//

void CCalenPreviewData::RemoveInstance(TInt aIndex)

    {

    TRACE_ENTRY_POINT;

    if( aIndex < iInstances.Count() && aIndex >= 0 )

        {

        delete iInstances[aIndex];

        iInstances.Remove(aIndex);

        }

    TRACE_EXIT_POINT;

    }

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

// CCalenPreviewData::DeleteInstances

// ?implementation_description

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

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

//

void CCalenPreviewData::DeleteInstances()

    {

    TRACE_ENTRY_POINT;

    iInstances.ResetAndDestroy();

    TRACE_EXIT_POINT;

    }

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

// CCalenPopupDataBuilder::FindInstancesL

// ?implementation_description

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

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

//

void CCalenPreviewData::FindInstancesL(const TTime& aDay)

    {

    TRACE_ENTRY_POINT;

    iInstances.ResetAndDestroy();

    RArray<TInt> colIdArray;

    CCalenNativeView::GetActiveCollectionidsL( iServices, colIdArray );

    if(colIdArray.Count() > 0)

        {  

          CalenAgendaUtils::CreateEntryIdListForDayL( iInstances,

                                iServices.InstanceViewL(colIdArray),

                                aDay,

                              ETrue/*custom sort for popup*/ );

        }

    else

          {

          CalenAgendaUtils::CreateEntryIdListForDayL( iInstances,

                                            iServices.InstanceViewL(),

                                            aDay,

                                          ETrue/*custom sort for popup*/ );      

          }

    colIdArray.Reset();

    TRACE_EXIT_POINT;  

    }

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

// CCalenPreviewData::GetInstance

// ?implementation_description

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

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

//

CCalInstance* CCalenPreviewData::Instance(TInt aIndex)

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    return iInstances[aIndex];

    }

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

// CCalenPreviewData::GetInstance

// ?implementation_description

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

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

//

CCalenPreviewEntry* CCalenPreviewData::Entry(TInt aIndex)

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    return iEntries[aIndex];

    }

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

// ?classname::?member_function

// ?implementation_description

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

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

//

void CCalenPreviewData::CreateEntriesL(const TTime& aDay)

    {

    TRACE_ENTRY_POINT;

    TInt rowsUsed(0);

    CCalenPreviewEntry* temp = NULL;

    /* Calculate need for each row */    

    TInt maxRows = iLayoutManager->UsePreview() ? 

    (iMaxInstances - iInstances.Count() + 1) : 1;

    TInt count = iInstances.Count();

    if(iInstances.Count() > 0)

        {

        RPointerArray<CCalCalendarInfo> calendarInfoList;

        iServices.GetAllCalendarInfoL(calendarInfoList);

        CleanupClosePushL(calendarInfoList); 

        for( TInt i(0); i < iInstances.Count(); i++)

            {

            CCalEntry& aEntry = iInstances[i]->Entry();

            TCalCollectionId colId = iInstances[i]->InstanceIdL().iCollectionId;

            HBufC* calendarFileName = iServices.GetCalFileNameForCollectionId(colId).AllocLC();

            TInt calIndex = calendarInfoList.Find(*calendarFileName, 

                        CCalenPreviewData::CalendarInfoIdentifierL);

            CleanupStack::PopAndDestroy(calendarFileName);

            if(calIndex != KErrNotFound && calendarInfoList[calIndex]->Enabled())

                {

                temp = CCalenPreviewEntry::NewL(iInstances[i], iLayoutManager,

                aDay, maxRows,calendarInfoList[calIndex]->Color().Value());

                iEntries.AppendL(temp);

                rowsUsed += temp->LineCount();

                }

            }

        CleanupStack::PopAndDestroy(&calendarInfoList);

        }

    else if(iLayoutManager->UsePreview())

        {

        /* Create entry for empty text */

        temp = CCalenPreviewEntry::NewL(

        iLayoutManager,

        CCalenPreviewEntry::ECalenPreviewEntryEmpty,0);

        iEntries.AppendL(temp);

        rowsUsed += temp->LineCount();

        }

    /* Calculate row division */

    TInt rows = maxRows;

    while(rowsUsed > iMaxInstances)

        {

        RemoveLine( CCalEntry::ETodo, rowsUsed, rows );

        if(rowsUsed == iMaxInstances)

            break;

        RemoveLine( CCalEntry::EAnniv, rowsUsed, rows );

        if(rowsUsed == iMaxInstances)

            break;

        RemoveLine( CCalEntry::EEvent, rowsUsed, rows );

        if(rowsUsed == iMaxInstances)

            break;

        RemoveMeetingLineL( rowsUsed, rows );

        rows--;

        }

    for(TInt i(0); i < iEntries.Count(); i++)

        {

        TBool lastLine(EFalse);

        if( i == iEntries.Count() - 1 &&

            NotShownEntries())

            lastLine = ETrue;

        iEntries[i]->FormatTextL(lastLine);

        }

    iLayoutManager->SetLinesUsed(rowsUsed);

    TRACE_EXIT_POINT;

    }

void CCalenPreviewData::RemoveLine(const CCalEntry::TType aType,

                                   TInt& aRowsUsed, TInt aRows)

    {

    TRACE_ENTRY_POINT;

    if(aType == CCalEntry::ETodo)

        {

        // use todo priority list

        for(TInt i(0); i < iTodoPriorityOrder.Count() && aRowsUsed > iMaxInstances; i++)

            {

            for(TInt j(0); j < iInstances.Count() && aRowsUsed > iMaxInstances; j++)

                {

                if( iTodoPriorityOrder[i] == iInstances[j] &&

                    iEntries[j]->LineCount() == aRows && 

                    iEntries[j]->RemoveLine())

                    {

                    aRowsUsed--;

                    break;

                    }

                }   

            }

        }

    else

        {

        for(TInt i = iEntries.Count()-1; 

            i >= 0 && aRowsUsed > iMaxInstances; i--)

            {

            if( iEntries[i]->EventType() == aType &&

                iEntries[i]->LineCount() == aRows && 

                iEntries[i]->RemoveLine())

                {

                aRowsUsed--;

                }

            }

        }

    TRACE_EXIT_POINT;

    }

void CCalenPreviewData::RemoveMeetingLineL(TInt& aRowsUsed, TInt aRows)

    {

    TRACE_ENTRY_POINT;

    if(iToday)

        {

        // Past events

        for(TInt i(0); i < iEntries.Count() && aRowsUsed > iMaxInstances; i++)

            {

            if( ( iEntries[i]->EventType() == CCalEntry::EAppt ||

                  iEntries[i]->EventType() == CCalEntry::EReminder ) &&

                iInstances[i]->EndTimeL().TimeLocalL() < iCurrent)

                {

                if(iEntries[i]->LineCount() == aRows && 

                   iEntries[i]->RemoveLine())

                    {

                    aRowsUsed--;

                    }

                }

            }

        // Ongoing meetings, start time less than 30 from current time

        TTime range(iCurrent - TTimeIntervalMinutes(iRange));

        for(TInt i(0); i < iEntries.Count() && aRowsUsed > iMaxInstances; i++)

            {

            if( (iEntries[i]->EventType() == CCalEntry::EAppt ||

                 iEntries[i]->EventType() == CCalEntry::EReminder) &&

                iInstances[i]->EndTimeL().TimeLocalL() > iCurrent &&

                iInstances[i]->StartTimeL().TimeLocalL() < range)

                {

                if(iEntries[i]->LineCount() == aRows && 

                   iEntries[i]->RemoveLine())

                    {

                    aRowsUsed--;

                    }

                }

            }

        // Upcoming events

        for(TInt i(iEntries.Count()-1); i >= 0  && aRowsUsed > iMaxInstances; i--)

            {

            if( (iEntries[i]->EventType() == CCalEntry::EAppt ||

                 iEntries[i]->EventType() == CCalEntry::EReminder) &&

                iInstances[i]->StartTimeL().TimeLocalL() > iCurrent)

                {

                if(iEntries[i]->LineCount() == aRows && 

                   iEntries[i]->RemoveLine())

                    {

                    aRowsUsed--;

                    }