/*

* 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 entry processor implementation

*  Version     : %version: tr1sido#12 %

*

*/

// INCLUDE FILES

#include "emailtrace.h"

#include "cesmrentryprocessor.h"

#include "cesmrcaldbmgr.h"

#include "cesmrmeetingrequestentry.h"

#include "cesmrconflictchecker.h"

#include "esmrhelper.h"

#include "esmrinternaluid.h"

#include "cesmrfsmailboxutils.h"

//<cmail>

#include "esmrdef.h"

//</cmail>

#include <e32std.h>

#include <calentry.h>

#include <calinstance.h>

#include <calrrule.h>

#include <caluser.h>

#include <caltime.h>

#include <CalenInterimUtils2.h>

#include <cmrmailboxutils.h>

#include <MAgnEntryUi.h>

//<cmail>

#include "FreestyleEmailUiConstants.h"

#include "cesmrrecurrenceinfohandler.h"

//</cmail>

#include "esmrentryhelper.h"

#include "tesmrinputparams.h"

/// Unnamed namespace for local definitions

namespace {

// Definition for first item index

const TInt KFirstEntryIndex = 0;

// Definition for zero interval

const TInt KZeroInterval = 0;

#ifdef _DEBUG

// Definition for module panic text

_LIT( KESMRProcessorPanicTxt, "ESMREntryProcessor" );

/**

 * ESMREntryProcessor panic codes

 */

enum TESMREntryProcessorPanic

    {

    // Input entry array is empty

    EESMRProcessorEmptyEntryArray = 1,

    // Too many input entries

    EESMRProcessorTooManyEntries = 2,

    // entries are not processed

    EESMRProcessorEntriesNotProcessed,

    // View mode for policy resolving

    // cannot be check.

    EESMRProcessorCannotCheckViewMode,

    };

/**

 * Raises panic.

 * @param aPanic Panic code

 */

void Panic(TESMREntryProcessorPanic aPanic)

    {

    User::Panic( KESMRProcessorPanicTxt(),

                 aPanic);

    }

/**

 * Logs scenatio data

 * @param aData Reference to scenario data.

 */

void LogScenatioData(

        const TESMRScenarioData& /*aScenarioData*/ )

    {

    }

#endif // _DEBUG

/**

 * Cleanup operation for RPointerArray.

 *

 * @param aArray Pointer to RPointerArray.

 */

void CalEntryPointerArrayCleanup( TAny* aArray )

    {

    RPointerArray<CCalEntry>* entryArray =

        static_cast<RPointerArray<CCalEntry>*>( aArray );

    entryArray->ResetAndDestroy();

    entryArray->Close();

    }

/**

 * Sets child entry's start and end time.

 *

 * @param aChild Reference to child entry

 * @param aParent Reference to parent entry

 * @param aChildEnd Child entry's start time

 */

void SetInstanceStartAndEndL(

        CCalEntry& aChild,

        const CCalEntry& aParent,

        const TCalTime& aChildStart )

    {

    TTime parentStart( aParent.StartTimeL().TimeUtcL() );

    TTime parentEnd( aParent.EndTimeL().TimeUtcL() );

    TTime childStart( aChildStart.TimeUtcL() );

    const TTime KNullTime( Time::NullTTime() );

    if ( KNullTime == parentStart ||

         KNullTime == parentEnd ||

         KNullTime == childStart )

        {

        // Invalid time --> Leaving

        User::Leave( KErrArgument );

        }

    TTimeIntervalMicroSeconds duration( KZeroInterval );

    duration = parentEnd.MicroSecondsFrom( parentStart );

    TCalTime childEnd;

    childEnd.SetTimeUtcL( childStart + duration );

    aChild.SetStartAndEndTimeL( aChildStart, childEnd );

    }

void CheckRepeatUntilValidityL(

        CCalEntry& aEntry,

        const TCalTime& aInstanceTime )

    {

    if ( ESMREntryHelper::IsRepeatingMeetingL(aEntry) &&

         !ESMREntryHelper::IsModifyingEntryL(aEntry) )

        {

        TCalRRule originalRRule;

        if ( aEntry.GetRRuleL( originalRRule ) )

            {

            TCalTime endTime = aEntry.EndTimeL();

            TCalTime startTime = aEntry.StartTimeL();

            TTimeIntervalMicroSeconds duration =

                endTime.TimeLocalL().MicroSecondsFrom(

                        startTime.TimeLocalL() );

            TTime instanceEndTime( aInstanceTime.TimeLocalL() );

            instanceEndTime += duration;

            TCalTime repeatUntilTime = originalRRule.Until();

            TDateTime repeat = repeatUntilTime.TimeLocalL().DateTime();

            TDateTime instanceEndDatetime = instanceEndTime.DateTime();

            if ( repeatUntilTime.TimeLocalL() < instanceEndTime )

                {

                // reset the recurrence so, that the repeat until

                // time is included in repeat range. This is done,

                // because when setting the instance start and end

                // time, the CCalEntry implementation clears the

                // recurrence information if the end time is

                // after repeat until end time.

                // CCalEntry forces the repeat until time to be

                // same than last entry's start time when storing the

                // entry to db. Reason uknown.

                TCalRRule rRule;

                rRule.SetDtStart( originalRRule.DtStart() );

                rRule.SetType( originalRRule.Type() );

                TCalTime newUntil;

                newUntil.SetTimeLocalL( instanceEndTime );

                rRule.SetUntil( newUntil );

                rRule.SetInterval( originalRRule.Interval() );

                aEntry.SetRRuleL( rRule );

                }

            }

        }

    }

}  // namespace

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

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

// CESMREntryProcessor::CESMREntryProcessor

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

//

inline CESMREntryProcessor::CESMREntryProcessor(

    CMRMailboxUtils& aMRMailboxUtils,

    MESMRCalDbMgr& aDbMgr )

:   iMRMailboxUtils( aMRMailboxUtils ),

    iDbMgr( aDbMgr )

    {

    FUNC_LOG;

    }

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

// CESMREntryProcessor::~CESMREntryProcessor

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

//

EXPORT_C CESMREntryProcessor::~CESMREntryProcessor()

    {

    FUNC_LOG;

    delete iESMREntry;

    delete iMbUtils;

    }

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

// CESMREntryProcessor::ConstructL

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

//

void CESMREntryProcessor::ConstructL()

    {

    FUNC_LOG;

    iMbUtils =

            CESMRFsMailboxUtils::NewL( iMRMailboxUtils );

    }

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

// CESMREntryProcessor::NewL

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

//

EXPORT_C CESMREntryProcessor* CESMREntryProcessor::NewL(

        CMRMailboxUtils& aMRMailboxUtils,

        MESMRCalDbMgr& aDbMgr )

    {

    FUNC_LOG;

    CESMREntryProcessor* self =

        new (ELeave) CESMREntryProcessor(

            aMRMailboxUtils, aDbMgr );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CESMREntryProcessor::ExtensionUid

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

//

EXPORT_C TUid CESMREntryProcessor::ExtensionUid()

    {

    FUNC_LOG;

    return TUid::Uid( KESMRMREntryProcessorUid );

    }

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

// CESMREntryProcessor::ProcessL

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

//

EXPORT_C void CESMREntryProcessor::ProcessL(

        const MAgnEntryUi::TAgnEntryUiInParams* aParams,

        RPointerArray<CCalEntry>* aEntries )

    {

    FUNC_LOG;

    iParams = aParams;

    ProcessL( aEntries );

    CheckViewModeL();

    if ( !IsDataOk() )

        {

        // Data is not ok --> Leave

        User::Leave( KErrArgument );

        }

    // Check mail parameters

    if ( iParams && iParams->iSpare )

        {

        CCalEntry* entry = &iESMREntry->Entry();

        if(entry)

            {

            TBool recurrent(EFalse);

            recurrent = iESMREntry->IsRecurrentEventL();

            if(recurrent)

                {                

                if ( !ESMREntryHelper::IsModifyingEntryL(*entry) )

                    {

                    iESMREntry->SetModifyingRuleL( MESMRMeetingRequestEntry::EESMRAllInSeries );

                    SetPhoneOwnerToOwnEntryL();

                    }

                }

            }

        }

    }

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

// CESMREntryProcessor::ProcessL

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

//

EXPORT_C void CESMREntryProcessor::ProcessL(

            RPointerArray<CCalEntry>* aEntries )

    {

    FUNC_LOG;

    __ASSERT_DEBUG( aEntries->Count() > 0,

                    Panic( EESMRProcessorEmptyEntryArray ) );

    iMREntries = aEntries;

    // Set initial values to scenario data

    iScenData.iRole       = EESMRRoleUndef;

    iScenData.iViewMode   = EESMRViewUndef;

    iScenData.iCallingApp = EESMRAppUndef;

    SetPhoneOwnerL();

    CreateESMREntryL();

    CheckOrganizerL();

    iESMREntry->SetModifyingRuleL(

            MESMRMeetingRequestEntry::EESMRThisOnly );

    if ( iParams && MAgnEntryUi::ECreateNewEntry == iParams->iEditorMode )

        {

        iESMREntry->SetDefaultValuesToEntryL();

        }

    }

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

// CESMREntryProcessor::ProcessL

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

//

EXPORT_C void CESMREntryProcessor::ProcessL(

            CCalInstance& aInstance )

    {

    FUNC_LOG;

    RPointerArray<CCalEntry> entries;

    CleanupStack::PushL(

                TCleanupItem(

                    CalEntryPointerArrayCleanup,

                    &entries    ) );

    // Fetches parent entry. We need to construct entry with

    // correct time.

    CCalEntry &entry = aInstance.Entry();

    CCalEntry* instanceEntry = ESMRHelper::CopyEntryL(

            entry,

            entry.MethodL(),

            ESMRHelper::ECopyFull );

    entries.Append(instanceEntry);

    // Setting start and end time for child entry

    CheckRepeatUntilValidityL(

            *instanceEntry,

            aInstance.StartTimeL() );

    SetInstanceStartAndEndL(

            *instanceEntry,

            entry,

            aInstance.StartTimeL() );

    // Filling child with correct data

    // This can be replaced withCCalenInterimUtils2::PopulateChildFromParentL

    // after its memory leak has been fixed.

    ESMRHelper::PopulateChildFromParentL(

            *instanceEntry,

            entry );

    ProcessL( &entries );

    if ( !iESMREntry )

        {

        User::Leave( KErrArgument );

        }

    // Mark only this entry to be affected.

    iESMREntry->SetModifyingRuleL(

            MESMRMeetingRequestEntry::EESMRThisOnly );

    CleanupStack::PopAndDestroy( &entries );

    }

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

// CESMREntryProcessor::SwitchToForwardL

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

//

EXPORT_C void CESMREntryProcessor::SwitchToForwardL()

    {

    FUNC_LOG;

    if ( !iESMREntry )

        {

        // No entries has been processed yet.

        User::Leave( KErrNotReady );

        }

    iESMREntry->SwitchToForwardL();

    // Rest of the scenario data remains as it is

    iScenData.iViewMode   = EESMRForwardMR;

    }

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

// CESMREntryProcessor::SwitchToViewL

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

//

EXPORT_C void CESMREntryProcessor::SwitchToEditL()

    {

    FUNC_LOG;

    if ( !iESMREntry )

        {

        // No entries has been processed yet.

        User::Leave( KErrNotReady );

        }

    iESMREntry->SwitchToOrginalL();

    // Rest of the scenario data remains as it is

    iScenData.iViewMode   = EESMREditMR;

    }

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

// CESMREntryProcessor::SwitchToViewL

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

//

EXPORT_C void CESMREntryProcessor::SwitchToViewL()

    {

    FUNC_LOG;

    if ( !iESMREntry )

        {

        // No entries has been processed yet.

        User::Leave( KErrNotReady );

        }

    iESMREntry->SwitchToOrginalL();

    // Rest of the scenario data remains as it is

    iScenData.iViewMode   = EESMRViewMR;

    }

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

// CESMREntryProcessor::SwitchToTrackL

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

//

EXPORT_C void CESMREntryProcessor::SwitchToTrackL()

    {

    FUNC_LOG;

    if ( !iESMREntry )

        {

        // No entries has been processed yet.

        User::Leave( KErrNotReady );

        }

    iESMREntry->SwitchToOrginalL();

    // Rest of the scenario data remains as it is

    iScenData.iViewMode   = EESMRTrackingViewMR;

    iScenData.iRole       = EESMRRoleOrganizer;

    iScenData.iEntryType  = EESMREventTypeAppt;

    }

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

// CESMREntryProcessor::ESMREntryL

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

//

EXPORT_C MESMRMeetingRequestEntry& CESMREntryProcessor::ESMREntryL()

    {

    FUNC_LOG;

    CreateESMREntryL();

    return *iESMREntry;

    }

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

// CESMREntryProcessor::ResetL

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

//

EXPORT_C void CESMREntryProcessor::ResetL()

    {

    FUNC_LOG;

    iScenData.iRole       = EESMRRoleUndef;

    iScenData.iViewMode   = EESMRViewUndef;

    iScenData.iCallingApp = EESMRAppUndef;

    delete iESMREntry;

    iESMREntry = NULL;

    }

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

// CESMREntryProcessor::ProcessOutputParametersL

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

//

EXPORT_C void CESMREntryProcessor::ProcessOutputParametersL(

        MAgnEntryUi::TAgnEntryUiOutParams& aOutParams,

        TESMRCommand aCommand )

    {

    FUNC_LOG;