/*
* Copyright (c) 2005 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:Implementation for meeting request utils calendar 
* data base
*/



// ----------------------------------------------------------------------------
// INCLUDE FILES
// ----------------------------------------------------------------------------
//
#include "CMRUtilsCalDbBase.h"
#include "MREntryConsultant.h"
#include "MRHelpers.h"
#include <ct/RCPointerArray.h>
#include <CalEntryView.h>
#include <CalInstanceView.h>
#include <CalEntry.h>
#include <CalInstance.h>
#include <CalUser.h>
#include <CalRRule.h>
#include <CalTime.h>

// CONSTANTS
/// Unnamed namespace for local definitions
namespace {

enum TPanicCode
    {
    EPanicNonEmptyParamArray = 1
    };

_LIT( KPanicMsg, "CMRUtilsCalDbBase" );

void Panic( TPanicCode aReason )
    {
    User::Panic( KPanicMsg, aReason );
    }
    
}  // namespace

// ----------------------------------------------------------------------------
// MEMBER FUNCTIONS
// ----------------------------------------------------------------------------
//

// ----------------------------------------------------------------------------
// CMRUtilsCalDbBase::CMRUtilsCalDbBase
//
// Constructor.
// ----------------------------------------------------------------------------
//
CMRUtilsCalDbBase::CMRUtilsCalDbBase(
    MMRUtilsCalDbObserver& aDbObserver,
    MCalProgressCallBack& aCmdObserver )
    : iDbObserver( aDbObserver ),
      iCmdObserver( aCmdObserver ),
      iDbStatus( MMRUtilsCalDbObserver::EUninitialized )
    {
    
    }
    
// ----------------------------------------------------------------------------
// CMRUtilsCalDbBase::~CMRUtilsCalDbBase
//
// Destructor.
// ----------------------------------------------------------------------------
//        
CMRUtilsCalDbBase::~CMRUtilsCalDbBase()
    {   
    // subclasses take care of deleting entry & instance view if they
    // create them!
    }

// ----------------------------------------------------------------------------
// CMRUtilsCalDbBase::EntryView
// ----------------------------------------------------------------------------
//    
const CCalEntryView* CMRUtilsCalDbBase::EntryView() const
    {
    return iCalEntryView;
    }

// ----------------------------------------------------------------------------
// CMRUtilsCalDbBase::InstanceView
// ----------------------------------------------------------------------------
//        
const CCalInstanceView* CMRUtilsCalDbBase::InstanceView() const
    {
    return iCalInstanceView;
    }

// ----------------------------------------------------------------------------
// CMRUtilsCalDbBase::Session
// ----------------------------------------------------------------------------
//        
const CCalSession* CMRUtilsCalDbBase::Session() const
    {
    return iCalSession;
    }

// ----------------------------------------------------------------------------
// CMRUtilsCalDbBase::EntryView
// ----------------------------------------------------------------------------
//    
CCalEntryView* CMRUtilsCalDbBase::EntryView()
    {
    return iCalEntryView;
    }

// ----------------------------------------------------------------------------
// CMRUtilsCalDbBase::InstanceView
// ----------------------------------------------------------------------------
//        
CCalInstanceView* CMRUtilsCalDbBase::InstanceView()
    {
    return iCalInstanceView;
    }

// ----------------------------------------------------------------------------
// CMRUtilsCalDbBase::Session
// ----------------------------------------------------------------------------
//        
CCalSession* CMRUtilsCalDbBase::Session()
    {
    return iCalSession;
    }
    
// ----------------------------------------------------------------------------
// CMRUtilsCalDbBase::DbStatus
// ----------------------------------------------------------------------------
//        
MMRUtilsCalDbObserver::TDbStatus CMRUtilsCalDbBase::DbStatus()
    {
    return iDbStatus;
    }

// ----------------------------------------------------------------------------
// CMRUtilsCalDbBase::ResetDbL
// ----------------------------------------------------------------------------
//        
void CMRUtilsCalDbBase::ResetDbL()
    {
    // By default database reseting is not supported
    User::Leave( KErrNotSupported );
    }

// ----------------------------------------------------------------------------
// CMRUtilsCalDbBase::FetchWithRangeL
// According to UI spec. we only remove a repeating entry if all occurences
// are within given timerange. This implementation however considers
// originating and modifying entries separately (i.e. modifying entry may
// be removed without originating entry being removed ). It is done like this
// because 1) it's faster and 2) they are semantically different requests.
// ----------------------------------------------------------------------------
//
void CMRUtilsCalDbBase::FetchWithRangeL(
    RPointerArray<CCalEntry>& aCalEntryArray,
    const CalCommon::TCalTimeRange& aCalTimeRange,
    TBool aFetchFullCopy )
    {
    __ASSERT_DEBUG( aCalEntryArray.Count() == 0,
                    Panic( EPanicNonEmptyParamArray ) );
    
    if ( !iCalInstanceView || !iCalEntryView )
        {
        User::Leave( KErrNotSupported );
        }
        
    RCPointerArray<CCalInstance> tmpFindArray;
    CleanupClosePushL( tmpFindArray );    

    iCalInstanceView->FindInstanceL( tmpFindArray, 
					   			     CalCommon::EIncludeAppts, 
					   			     aCalTimeRange );
					   			     
    TInt count( tmpFindArray.Count() );
    for ( TInt i( 0 ); i < count; ++i )
        {        
        const CCalEntry& entry( tmpFindArray[i]->Entry() );
        
        // This is used to ensure that if entry has already been added we don't
        // bother to try again:
        TInt alreadyExistsIndex( aCalEntryArray.FindInOrder( &entry,
                TLinearOrder<CCalEntry>( CMRUtilsCalDbBase::Compare ) ) );
        
        if ( alreadyExistsIndex < 0 &&
             IsCompletelyWithinRangeL( entry, aCalTimeRange ) )
            {
            // we create a full or a skeleton copy, based on given argument:
            MRHelpers::TCopyFields copyType( aFetchFullCopy ?
                MRHelpers::ECopyFull : MRHelpers::ECopySkeleton );
            CCalEntry* copy = MRHelpers::CopyEntryLC( entry,
                                                      entry.MethodL(),
                                                      copyType );
            aCalEntryArray.InsertInOrderL( copy, 
                TLinearOrder<CCalEntry>( CMRUtilsCalDbBase::Compare ) );
            CleanupStack::Pop( copy ); // ownership transferred to array
            }
        }

    CleanupStack::PopAndDestroy(); // tmpFindArray
    }
  
// ----------------------------------------------------------------------------
// CMRUtilsCalDbBase::IsCompletelyWithinRangeL
// To optimize performance we return from the method immediatelly when EFalse
// has been confirmed.
// ----------------------------------------------------------------------------
//          
TBool CMRUtilsCalDbBase::IsCompletelyWithinRangeL(
    const CCalEntry& aEntry,
    const CalCommon::TCalTimeRange& aCalTimeRange )
    {
    // 1. Check occurrences specified with a recurrence rule:

    TCalRRule rule;
    if ( aEntry.GetRRuleL( rule ) )
        {
        // In this implementation we don't check if end time of the last
        // occurrence exceeds the time range, we only check the start/until of
        // the rule (according to the standard the start time of the rule equals
        // the start time of the first occurrence).
        // Furthermore ex-dates are not considered at all.
                
        if ( rule.DtStart().TimeUtcL() < aCalTimeRange.StartTime().TimeUtcL() ||
             rule.Until().TimeUtcL() > aCalTimeRange.EndTime().TimeUtcL() )
            {
            return EFalse;
            }
        }
        
    // 2. Check occurrences specified with r-dates:
            
    RArray<TCalTime> rDateList;   
    aEntry.GetRDatesL( rDateList );
    TInt count( rDateList.Count() );
    for ( TInt i( 0 ); i < count; ++i )
        {
        // In this implementation we don't check if end time of r-date
        // occurence exceeds the time range.        
        
        if ( rDateList[i].TimeUtcL() < aCalTimeRange.StartTime().TimeUtcL() ||
             rDateList[i].TimeUtcL() > aCalTimeRange.EndTime().TimeUtcL() )
            {
            rDateList.Close();
            return EFalse;
            }
        }
    rDateList.Close();        
    return ETrue;        
    }
   
// ----------------------------------------------------------------------------
// CMRUtilsCalDbBase::Compare
// ----------------------------------------------------------------------------
//   
TInt CMRUtilsCalDbBase::Compare(
    const CCalEntry& aFirst,
    const CCalEntry& aSecond )
    {
    TInt retVal( 0 ); // default value is that items are equal
    TRAP_IGNORE( retVal = CompareL( aFirst, aSecond ) );
    return retVal;
    }
    
// ----------------------------------------------------------------------------
// CMRUtilsCalDbBase::CompareL
// ----------------------------------------------------------------------------
//   
TInt CMRUtilsCalDbBase::CompareL(
    const CCalEntry& aFirst,
    const CCalEntry& aSecond )
    {
    TInt result( aFirst.UidL().Compare( aSecond.UidL() ) );
    if ( result == 0 )
        { // UIDs were identical, how about recurrence id's then:
        TTime firstRec( aFirst.RecurrenceIdL().TimeUtcL() );
        TTime secondRec( aSecond.RecurrenceIdL().TimeUtcL() );
        if ( firstRec > secondRec )
            {
            result = 1;
            }
        else if ( firstRec < secondRec )
            {
            result = -1;
            }
        else
            {
            result = 0;
            }
        }
    return result;        
    }
    
// ----------------------------------------------------------------------------
// CMRUtilsCalDbBase::Progress
// ----------------------------------------------------------------------------
//    
void CMRUtilsCalDbBase::Progress( TInt /*aPercentageCompleted*/ )
    {
    // No interest currently
    }
    
// ----------------------------------------------------------------------------
// CMRUtilsCalDbBase::NotifyProgress
// ----------------------------------------------------------------------------
//
TBool CMRUtilsCalDbBase::NotifyProgress()
    { 
    // No interest currently
    return EFalse;
    }

// End of file