/*

* 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: e002sa33#14 %

*

*/

// INCLUDE FILES

#include "cesmrentryprocessor.h"

#include "esmrinternaluid.h"

#include "mesmrcalentry.h"

#include "esmrhelper.h"

#include "esmrentryhelper.h"

#include "cesmrfsmailboxutils.h"

#include "cesmrmeetingrequestentry.h"

#include "cesmrconflictchecker.h"

#include "FreestyleEmailUiConstants.h"

#include "cesmrrecurrenceinfohandler.h"

#include "emailtrace.h"

#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>

#include <ct/rcpointerarray.h>

/// Unnamed namespace for local definitions

namespace {

#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,

    // Invalid processor mode

    EESMRProcessorInvalidMode

    };

/**

 * Raises panic.

 * @param aPanic Panic code

 */

void Panic(TESMREntryProcessorPanic aPanic)

    {

    User::Panic( KESMRProcessorPanicTxt(), aPanic);

    }

#endif // _DEBUG

}  // namespace

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

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

// CESMREntryProcessor::CESMREntryProcessor

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

//

CESMREntryProcessor::CESMREntryProcessor(

        MESMRCalDbMgr& aDbMgr )

:   iDbMgr( aDbMgr )

    {

    FUNC_LOG;

    }

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

// CESMREntryProcessor::~CESMREntryProcessor

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

//

CESMREntryProcessor::~CESMREntryProcessor()

    {

    FUNC_LOG;

    delete iMRMailboxUtils;

    delete iESMREntry;

    delete iMbUtils;

    }

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

// CESMREntryProcessor::ConstructL

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

//

void CESMREntryProcessor::ConstructL()

    {

    FUNC_LOG;

    iMRMailboxUtils = CMRMailboxUtils::NewL();

    iMbUtils = CESMRFsMailboxUtils::NewL( *iMRMailboxUtils );

    }

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

// CESMREntryProcessor::NewL

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

//

CESMREntryProcessor* CESMREntryProcessor::NewL(

        TAny* aDbMgr )

    {

    FUNC_LOG;

    MESMRCalDbMgr* dbMgr = static_cast<MESMRCalDbMgr*>(aDbMgr);

    return CreateL( *dbMgr );

    }

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

// CESMREntryProcessor::CreateL

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

//

CESMREntryProcessor* CESMREntryProcessor::CreateL(

            MESMRCalDbMgr& aDbMgr )

    {

    FUNC_LOG;

    CESMREntryProcessor* self = new (ELeave) CESMREntryProcessor( aDbMgr );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CESMREntryProcessor::ScenarioData

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

//

const TESMRScenarioData& CESMREntryProcessor::ScenarioData() const

    {

    FUNC_LOG;

    return iScenData;

    }

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

// CESMREntryProcessor::ContainsProcessedEntry

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

//

TBool CESMREntryProcessor::ContainsProcessedEntry() const

    {

    FUNC_LOG;

    return (iESMREntry != NULL);

    }

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

// CESMREntryProcessor::ProcessL

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

//

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

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

//

void CESMREntryProcessor::ProcessL(

            const MAgnEntryUi::TAgnEntryUiInParams* aParams,

            CCalEntry& aEntry,

            TBool aSetDefaultValuesToEntry,

            const TBool aTypeChanging)

    {

    FUNC_LOG

    iParams = aParams;

    iMREntries = NULL;

    iCalEntry = &aEntry;

    // Set initial values to scenario data

    iScenData.iRole       = EESMRRoleUndef;

    iScenData.iViewMode   = EESMRViewUndef;

    iScenData.iCallingApp = EESMRAppUndef;

    SetPhoneOwnerL( aEntry, aEntry );

    CreateESMREntryL( aEntry, aSetDefaultValuesToEntry );

    CheckOrganizerL( aEntry );

    // When creating a new repeating meeting and adding participants,

    // meeting request editor is opened and all occurences should be edited

    if ( ( iESMREntry->IsRecurrentEventL() &&

            MAgnEntryUi::ECreateNewEntry == iParams->iEditorMode ) ||

         ( ESMREntryHelper::IsRepeatingMeetingL( aEntry ) && aTypeChanging ) )  

        {

        iESMREntry->SetModifyingRuleL(

                    MESMRMeetingRequestEntry::EESMRAllInSeries, aTypeChanging );

        }

    else //Default case

        {

        iESMREntry->SetModifyingRuleL(

                    MESMRMeetingRequestEntry::EESMRThisOnly, aTypeChanging );

        }

    if ( iParams && MAgnEntryUi::ECreateNewEntry ==

            iParams->iEditorMode &&

                aSetDefaultValuesToEntry )

        {

        iESMREntry->SetDefaultValuesToEntryL();

        }

    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

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

//

void CESMREntryProcessor::ProcessL(

            RPointerArray<CCalEntry>* aEntries )

    {

    FUNC_LOG;

    __ASSERT_DEBUG( aEntries->Count() > 0,

                    Panic( EESMRProcessorEmptyEntryArray ) );

    iMREntries = aEntries;

    iCalEntry = (*iMREntries)[ 0 ];

    // Set initial values to scenario data

    iScenData.iRole       = EESMRRoleUndef;

    iScenData.iViewMode   = EESMRViewUndef;

    iScenData.iCallingApp = EESMRAppUndef;

    for ( TInt i = 0; i < iMREntries->Count(); ++i )

        {

        SetPhoneOwnerL( *(*iMREntries)[ i ], *iCalEntry );

        }

    CreateESMREntryL( *iCalEntry, ETrue );

    CheckOrganizerL( *iCalEntry );

    // When creating a new repeating meeting and adding participants,

    // meeting request editor is opened and all occurences should be edited

    if ( iESMREntry->IsRecurrentEventL()

         && iParams

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

    	{

    	iESMREntry->SetModifyingRuleL(

    			    MESMRMeetingRequestEntry::EESMRAllInSeries );

    	}

    else //Default case

    	{

    	iESMREntry->SetModifyingRuleL(

    	            MESMRMeetingRequestEntry::EESMRThisOnly );

    	}

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

        {

        iESMREntry->SetDefaultValuesToEntryL();

        }

    }

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

// CESMREntryProcessor::ProcessL

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

//

void CESMREntryProcessor::ProcessL(

            CCalInstance& aInstance )

    {

    FUNC_LOG;

    RCPointerArray<CCalEntry> entries;

    CleanupClosePushL( 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

    ESMREntryHelper::CheckRepeatUntilValidityL(

            *instanceEntry,

            aInstance.StartTimeL() );

    ESMREntryHelper::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 );

    // entries

    CleanupStack::PopAndDestroy();

    }

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

// CESMREntryProcessor::SwitchProcessorToModeL

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

//

void CESMREntryProcessor::SwitchProcessorToModeL(

        TMRProcessorMode aMode )

    {

    FUNC_LOG;

    switch ( aMode )

        {

        case EMRProcessorModeView:

            SwitchToViewL();

            break;

        case EMRProcessorModeEdit:

            SwitchToEditL();

            break;

        case EMRProcessorModeForward:

            SwitchToForwardL();

            break;

        case EMRProcessorModeTrack:

            SwitchToTrackL();

            break;

        default:

            __ASSERT_DEBUG( EFalse, Panic( EESMRProcessorInvalidMode) );

        }

    }

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

// CESMREntryProcessor::ESMREntryL

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

//

MESMRCalEntry& CESMREntryProcessor::ESMREntryL()

    {

    FUNC_LOG;

    CreateESMREntryL( *iCalEntry, ETrue );

    return *iESMREntry;

    }

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

// CESMREntryProcessor::ResetL

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

//

void CESMREntryProcessor::ResetL()

    {

    FUNC_LOG;

    iScenData.iRole       = EESMRRoleUndef;

    iScenData.iViewMode   = EESMRViewUndef;

    iScenData.iCallingApp = EESMRAppUndef;

    delete iESMREntry;

    iESMREntry = NULL;

    }

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

// CESMREntryProcessor::ProcessOutputParametersL

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

//

void CESMREntryProcessor::ProcessOutputParametersL(

        MAgnEntryUi::TAgnEntryUiOutParams& aOutParams,

        TESMRCommand aCommand )

    {

    FUNC_LOG;

    __ASSERT_DEBUG( iESMREntry, Panic(EESMRProcessorEntriesNotProcessed) );

    if ( !iParams  ||

         EESMRForwardMR == iScenData.iViewMode  ||

         EESMRViewUndef == iScenData.iViewMode )

        {

        // No input parameters supplied --> Output parameters cannot be set

        return;

        }

    TBool handlingInstanceOnly(

            iESMREntry->IsRecurrentEventL() &&

            MESMRCalEntry::EESMRThisOnly == iESMREntry->RecurrenceModRule() );

    switch ( aCommand )

        {

        case EESMRCmdSendMR:

        case EESMRCmdSendMRUpdate:

        case EESMRCmdSaveMR:

        case EESMRCmdAcceptMR:

        case EESMRCmdTentativeMR:

            {

            aOutParams.iAction = MAgnEntryUi::EMeetingSaved;

            if ( handlingInstanceOnly )

                {

                aOutParams.iAction = MAgnEntryUi::EInstanceRescheduled;

                }

            }

            break;

        case EESMRCmdDeclineMR:

        case EESMRCmdDeleteMR:

            {

            aOutParams.iAction = MAgnEntryUi::EMeetingDeleted;

            if ( handlingInstanceOnly )

                {

                aOutParams.iAction = MAgnEntryUi::EInstanceDeleted;

                }

            }

            break;

        default:

            {

            aOutParams.iAction = MAgnEntryUi::ENoAction;

            }

            break;

        }

    if ( handlingInstanceOnly )

        {

        aOutParams.iNewInstanceDate =

                iESMREntry->Entry().StartTimeL();

        }

    else if ( MAgnEntryUi::ENoAction != aOutParams.iAction )

        {

        //Copy entry LocalUid to input entry

        iCalEntry->SetLocalUidL( iESMREntry->Entry().LocalUidL() );

        TCalTime instanceTime = iESMREntry->Entry().StartTimeL();

        if ( MESMRCalEntry::EESMRAllInSeries == iESMREntry->RecurrenceModRule() )

            {

            // For recurrent event there might be exceptions

            // and therefore the first possible start time

            // is set to putput params

            TCalTime end;

            CESMRRecurrenceInfoHandler* recurrenceHandler =

                    CESMRRecurrenceInfoHandler::NewLC( iESMREntry->Entry() );