/*

* 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 esmviewer controller implementation

*

*/

// INCLUDE FILES

//<cmail>

#include "emailtrace.h"

#include "cesmrpolicy.h"

#include "esmrdef.h"

#include "cesmrpolicymanager.h"

//</cmail>

#include "cesmrviewerctrl.h"

#include "cmrentryprocessor.h"

#include "mesmrmeetingrequestentry.h"

#include "mesmrtaskextension.h"

#include "esmrentryhelper.h"

#include "esmrhelper.h"

#include "cesmruifactory.h"

#include "mesmruibase.h"

#include "tesmrinputparams.h"

#include "tmroutputparams.h"

#include "esmrconfig.hrh"

#include "cesmrconfirmationquery.h"

#include "cesmrutils.h"

#include "cesmrcaluserutil.h"

#include "cesmrlistquery.h"

#include "cesmrcaldbmgr.h"

#include "cesmrtaskfactory.h"

#include "cesmrtaskextensionimpl.h"

// Logging utilities

// From System

//<cmail>

#include "esmrutilsapiext.h"

//</cmail>

#include <msvstd.h>

#include <msvids.h>

//<cmail>

#include "FreestyleEmailUiConstants.h"

//</cmail>

#include <eikappui.h>

#include <eikenv.h>

#include <calentry.h>

#include <calcommon.h>

// CONSTANTS

/// Unnamed namespace for local definitions

namespace { // codescanner::namespace

#if defined(_DEBUG)

// Definition for MR VIEWER ctrl panic text

_LIT(KMRViewerCtrlPanicTxt, "ESMRViewerCtrl" );

// MR VIEWER ctrl panic codes

enum TMRViewerCtrlPanicCode

    {

    EESMRViewerCtrlSyncher = 0, // Syncher is not created,

    EESMRViewerCtrlProcessor,

    EESMRViewerCtrlTaskExt,

    EESMRViewerCtrlPolicyMgr,

    EESMRViewerCtrlInvalidModifyingRule,

    EESMRViewerCtrlInvalidEntryType

    };

void Panic(TMRViewerCtrlPanicCode aPanicCode)

    {

    User::Panic( KMRViewerCtrlPanicTxt, aPanicCode );

    }

#endif

/**

 * Maps calendar entry type to MR entry type

 * @param aEntryType to be mapped to MR entry type

 * @return MR event type

 */

TESMRCalendarEventType MapType( const CCalEntry& aEntry )

    {

    TESMRCalendarEventType type( EESMREventTypeNone );

    switch ( aEntry.EntryTypeL() )

        {

        case CCalEntry::EAppt:

            {

            if( CCalenInterimUtils2::IsMeetingRequestL( 

                    ( const_cast<CCalEntry&>( aEntry ) ) ) )

                {

                type = EESMREventTypeMeetingRequest;

                }

            else

                {

                type = EESMREventTypeAppt;

                }

            break;

            }

        case CCalEntry::ETodo:

            {

            type = EESMREventTypeETodo;

            break;

            }

        case CCalEntry::EEvent:

            {

            type = EESMREventTypeEEvent;

            break;

            }

        case CCalEntry::EReminder:

            {

            type = EESMREventTypeEReminder;

            break;

            }

        case CCalEntry::EAnniv:

            {

            type = EESMREventTypeEAnniv;

            break;

            }

        default:

            {

            __ASSERT_DEBUG( EFalse, Panic( EESMRViewerCtrlInvalidEntryType ) );

            }

        }

    return type;

    }

/**

 * Creates calendar entry

 * @param required parameters for creating an entry

 * @return CCalEntry Created entry.

 */

CCalEntry* CreateEntryL(

        CCalEntry::TType aType,

        const TDesC8& aUid,

        CCalEntry::TMethod aMethod,

        CalCommon::TRecurrenceRange aRange )

    {

    HBufC8* guid = aUid.AllocLC();

    CCalEntry* entry = CCalEntry::NewL( aType, guid, aMethod, aRange );

    CleanupStack::Pop( guid );

    return entry;

    }

/**

 * Converts to-do specific priority to normal priority

 * @param Calendar entry, which priority is converted

 * @return The converted priority

 */

TInt ConvertTodoPriorityToNormalL( const CCalEntry& entry )

    {

    FUNC_LOG;

    TInt priority( 0 );

    if( entry.PriorityL() == EFSCalenTodoPriorityHigh )

        {

        priority = EFSCalenMRPriorityHigh;

        }

    else if( entry.PriorityL() == EFSCalenTodoPriorityNormal )

        {

        priority = EFSCalenMRPriorityNormal;

        }

    else if( entry.PriorityL() == EFSCalenTodoPriorityLow )

        {

        priority = EFSCalenMRPriorityLow;

        }

    else

        {

        // Priority unknown, let's set it to normal then

        priority = EFSCalenMRPriorityNormal;

        }

    return priority;

    }

/**

 * Converts normal priority to to-do specific priority

 * @param Calendar entry, which priority is converted

 * @return The converted priority

 */

TInt ConvertNormalPriorityToTodoL( const CCalEntry& entry )

    {

    FUNC_LOG;

    TInt priority( 0 );

    if( entry.PriorityL() == EFSCalenMRPriorityHigh )

        {

        priority = EFSCalenTodoPriorityHigh;

        }

    else if( entry.PriorityL() == EFSCalenMRPriorityNormal )

        {

        priority = EFSCalenTodoPriorityNormal;

        }

    else if( entry.PriorityL() == EFSCalenMRPriorityLow )

        {

        priority = EFSCalenTodoPriorityLow;

        }

    else

        {

        // Priority unknown, let's set it to normal then

        priority = EFSCalenMRPriorityNormal;

        }

    return priority;

    }

}  // namespace

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

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

// CESMRViewerController::CESMRViewerController

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CESMRViewerController::CESMRViewerController(

    RPointerArray<CCalEntry>& aEntries,

    const MAgnEntryUi::TAgnEntryUiInParams& aParams,

    MAgnEntryUi::TAgnEntryUiOutParams& aOutParams,

    MAgnEntryUiCallback& aCallback )

    : iInParams( aParams ),

      iOutParams( aOutParams ),

      iCallback( aCallback ),

      iEntries( aEntries )

    {

    FUNC_LOG;

    }

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

// CESMRViewerController::~CESMRViewerController

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

//

EXPORT_C CESMRViewerController::~CESMRViewerController()

    {

    FUNC_LOG;    

    delete iCtrlSyncher;

    delete iGuiFactory;

    delete iCalEntry;

    delete iESMRUtils;

    }

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

// CESMRViewerController::NewL

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

//

EXPORT_C CESMRViewerController* CESMRViewerController::NewL(

    const TDesC8& aMtmuid,

    RPointerArray<CCalEntry>& aEntries,

    const MAgnEntryUi::TAgnEntryUiInParams& aParams,

    MAgnEntryUi::TAgnEntryUiOutParams& aOutParams,

    MAgnEntryUiCallback& aCallback )

    {

    FUNC_LOG;

    CESMRViewerController* self =

        new( ELeave ) CESMRViewerController( aEntries,

                                             aParams,

                                             aOutParams,

                                             aCallback );

    CleanupStack::PushL( self );

    self->ConstructL(aMtmuid);

    CleanupStack::Pop( self );

    return self;

    }

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

// CESMRViewerController::ConstructL

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

//

void CESMRViewerController::ConstructL(const TDesC8& /*aMtmUid */)

    {

    FUNC_LOG;

    // This will create ESMR UTILS. Initialization is asynchronous.

    // Competion is signaled via CESMRViewerController::HandleCalEngStatus.

    iESMRUtils = CESMRUtils::NewL( *this );

    iESMRUtils->SessionSetupL(

            iInParams.iCalSession,

            iInParams.iMsgSession );

    iESMRUtils->CreateExtensionsL(

            ESMREntryHelper::EventTypeL( *(iEntries[0]) ) );

    iGuiFactory = CESMRUiFactory::NewL();

    }

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

// CESMRViewerController::ExecuteL

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

//

EXPORT_C void CESMRViewerController::ExecuteL()

    {

    FUNC_LOG;

    iExecutionError = KErrNone;

    // Initialization waiter is needed because MR VIEWER user expects

    // MR VIEWER operation to be synchronous.

    iCtrlSyncher = new (ELeave) CActiveSchedulerWait;

    // MR UTILS calls CESMRViewerController::HandleCalEngStatus after init is

    // complete. CESMRViewerController::HandleCalEngStatus also sets

    // iExectionError if there occurs error during MR UTILS init.

    iCtrlSyncher->Start();

    User::LeaveIfError( iExecutionError );

    iEntryProcessor =

        static_cast<CMREntryProcessor*>(

                iESMRUtils->ExtensionL(

                        TUid::Uid(KESMRMREntryProcessorUid) ) );

    iPolicyMgr =

        static_cast<CESMRPolicyManager*>(

                iESMRUtils->ExtensionL(

                        TUid::Uid(KESMRPolicyMgrUid) ) );

    iTaskExt =

        static_cast<MESMRTaskExtension*>(

                iESMRUtils->ExtensionL(

                        TUid::Uid(KESMRTaskExtensionUid) ) );

    // Check that all extensions are found

    if ( !iEntryProcessor || !iPolicyMgr || !iTaskExt )

        {

        // All extensions are not found --> Leave

        User::Leave( KErrNotSupported );

        }

    iEntryProcessor->ProcessL(

            &iInParams,

            &iEntries );

    LaunchCorrectOperationModeL();

    }

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

// CESMRViewerController::IsCommandAvailable

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

//

TBool CESMRViewerController::IsCommandAvailable( TInt aCommandId )

    {

    FUNC_LOG;

    TBool retValue( EFalse );

    if ( KFSEmailUiUid == iInParams.iCallingApp )

        {

        retValue = iCallback.IsCommandAvailable( aCommandId );

        }

    return retValue;

    }

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

// CESMRViewerController::ProcessCommandWithResultL

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

//

TInt CESMRViewerController::ProcessCommandWithResultL( TInt aCommandId )

    {

    FUNC_LOG;

    TInt result = ProcessCommandWithResultInternalL(aCommandId);

    return result;

    }

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

// CESMRViewerController::ProcessCommandL

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

//

void CESMRViewerController::ProcessCommandL( TInt aCommandId )

    {

    FUNC_LOG;

    ProcessCommandWithResultL( aCommandId );

    }

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

// CESMRViewerController::HandleCalEngStatus

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

//

void CESMRViewerController::HandleCalEngStatus( TMRUtilsCalEngStatus aStatus )

    {

    FUNC_LOG;

    __ASSERT_DEBUG( iCtrlSyncher, Panic(EESMRViewerCtrlSyncher) );

    if ( ENotReady == aStatus )

        {

        // cal db is not ready

        iExecutionError = KErrNotReady;

        }

    else if (ENotAvailable == aStatus )

        {

        // cal db cannot be found

        iExecutionError = KErrNotFound;

        }

// <cmail>

    if ( iCtrlSyncher &&

            iCtrlSyncher->IsStarted() &&

            iCtrlSyncher->CanStopNow() )

// </cmail>

        {

        // Exection continues in CESMRViewerController::ExecuteL

        iCtrlSyncher->AsyncStop();

        }

    }

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

// CESMRViewerController::HandleOperation

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

//

void CESMRViewerController::HandleOperation(

        TInt /*aType*/,

        TInt /*aPercentageCompleted*/,

        TInt /*aStatus*/ )

    {

    FUNC_LOG;

    }

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

// CESMRViewerController::PolicyProvider

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

//

MMRPolicyProvider& CESMRViewerController::PolicyProvider() const

    {

    return *iPolicyMgr;

    }

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

// CESMRViewerController::EntryL

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

//

MESMRCalEntry* CESMRViewerController::EntryL()

    {

    return &iEntryProcessor->ESMREntryL();

    }

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

// CESMRViewerController::ProcessCommandWithResultInternalL

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

//

TInt CESMRViewerController::ProcessCommandWithResultInternalL(

        TInt aCommandId )

    {

    FUNC_LOG;

    TInt ret = ProcessDefaultCommandL( aCommandId );

    if ( ret == KErrNotSupported )

        {

        ret = ProcessMeetingRequestCommandL( aCommandId );

        }

    return ret;

    }

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

// CESMRViewerController::ProcessDefaultCommandL

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

//

TInt CESMRViewerController::ProcessDefaultCommandL( TInt aCommandId )

    {

    FUNC_LOG;

    TESMRCommand command = static_cast<TESMRCommand>(aCommandId);

    TBool needToProcessOutputParams( ETrue );

    MESMRCalEntry& entry = iEntryProcessor->ESMREntryL();

    TInt ret = KErrNone;

    MESMRCalDbMgr& dbMgr = entry.GetDBMgr();

    switch( aCommandId )

        {

        case EESMRCmdSaveMR:            // Saves Entry

        case EESMRCmdCalEntryUISave:

            {

            // If we are editing an existing entry.