/*
 * Copyright (c) 2008 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:  MBUtils ECOM implementation
 *
 */

#include "cmrbcpluginopenmrviewercmd.h"
#include "cesmrviewerctrl.h"
#include "esmrcommands.h"
#include "tmroutputparams.h"
#include "esmrhelper.h"
#include "esmrconfig.hrh"

#include <calenservices.h>
#include <calencommands.hrh>
#include <caleninterimutils2.h>
#include <cmrviewers.h>
#include <calentry.h>
#include <caluser.h>
#include <cmrmailboxutils.h>
#include <ct/rcpointerarray.h>
#include <aknlists.h>
#include <aknpopup.h>
#include <utf.h>
#include <calentryview.h>
#include <calinstanceview.h>

#include "emailtrace.h"


namespace {

/**
 * Literal for BC viewer / editor
 */
_LIT8( KBCViewer, "[2001F406]" );


#ifdef _DEBUG

/**
 * Panic literal
 */
_LIT( KMRBCPluginOpenMRViewerCmd, "MRBCPluginOpenMRViewerCmd" );

/**
 * Panic codes
 */
enum TMRBCPluginOpenMRViewerCmdPanic
    {
    EInvalidCommand // Invalid command
    };

void Panic( TMRBCPluginOpenMRViewerCmdPanic aPanic )
    {
    User::Panic( KMRBCPluginOpenMRViewerCmd, aPanic );
    }

#endif // _DEBUG

template <class T>
class CleanupResetAndDestroy
    {
    public:
        inline static void PushL( T& aRef )
            {
            CleanupStack::PushL( TCleanupItem( &ResetAndDestroy, &aRef ) );
            }

    private:
        inline static void ResetAndDestroy( TAny* aPtr )
            {
            static_cast< T*>( aPtr )->ResetAndDestroy();
            }
    };

template <class T>
inline void CleanupResetAndDestroyPushL( T& aRef )
    {
    CleanupResetAndDestroy<T>::PushL( aRef );
    }
}

//TODO:- displace after nokia provide RIGHT CalenActionUiUtils::FindPossibleInstance
CCalInstance* FindPossibleInstanceL(
        const TCalenInstanceId& aId, CCalInstanceView& aInstanceView )
        {
        FUNC_LOG;

        RPointerArray<CCalInstance> instances;
        CleanupResetAndDestroyPushL( instances );

        TCalTime moment;
        moment.SetTimeLocalL( aId.iInstanceTime );
        CalCommon::TCalTimeRange range( moment, moment );
        aInstanceView.FindInstanceL( instances, CalCommon::EIncludeAll, range );

        CCalInstance* result = NULL;

        // For instances finishing the next day (now possible with unified DateTime editor),
        // we have to do our best to match the instance time exactly - otherwise we could
        // match the LocalUid to the incorrect instance in a series.
        for ( TInt i=0; i < instances.Count() && !result; ++i )
            {
            if( instances[i]->Entry().LocalUidL() == aId.iEntryLocalUid )
                {
                // Check the instance time matches.
                if( instances[i]->StartTimeL().TimeLocalL() == aId.iInstanceTime )
                    {
                    result = instances[i];
                    instances.Remove(i);
                    }
                }
            }

        if( !result )
            {
            // Couldn't match the instance time exactly - just use the instance
            // with the same LocalUid as the one we're looking for.
            for ( TInt i=0; i < instances.Count() && !result; ++i )
                {
                if( instances[i]->Entry().LocalUidL() == aId.iEntryLocalUid )
                    {
                    result = instances[i];
                    instances.Remove(i);
                    }
                }
            }

        CleanupStack::PopAndDestroy( &instances );
        return result;
        }



// -----------------------------------------------------------------------------
// CMRBCPluginOpenMRViewerCmd::CMRBCPluginOpenMRViewerCmd
// -----------------------------------------------------------------------------
//
CMRBCPluginOpenMRViewerCmd::CMRBCPluginOpenMRViewerCmd(
        MCalenServices& aServices )
:   iServices( aServices )
            {
            FUNC_LOG;
            }

// -----------------------------------------------------------------------------
// CMRBCPluginOpenMRViewerCmd::~CMRBCPluginOpenMRViewerCmd
// -----------------------------------------------------------------------------
//
CMRBCPluginOpenMRViewerCmd::~CMRBCPluginOpenMRViewerCmd()
    {
    FUNC_LOG;
    delete iEntry;
    delete iEditor;
    }

        // -----------------------------------------------------------------------------
// CMRBCPluginOpenMRViewerCmd::NewL
// -----------------------------------------------------------------------------
//
CMRBCPluginOpenMRViewerCmd* CMRBCPluginOpenMRViewerCmd::NewL(
        MCalenServices& aServices)
    {
    FUNC_LOG;

    CMRBCPluginOpenMRViewerCmd* self = new (ELeave) CMRBCPluginOpenMRViewerCmd(
            aServices);
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
    }

// -----------------------------------------------------------------------------
// CMRBCPluginOpenMRViewerCmd::ConstructL
// -----------------------------------------------------------------------------
//
void CMRBCPluginOpenMRViewerCmd::ConstructL()
    {
    FUNC_LOG;
    }

// -----------------------------------------------------------------------------
// CMRBCPluginOpenMRViewerCmd::ExecuteCommandL
// -----------------------------------------------------------------------------
//
void CMRBCPluginOpenMRViewerCmd::ExecuteCommandL(
        const TCalenCommand& aCommand )
    {
    FUNC_LOG;

    __ASSERT_DEBUG(
            aCommand.Command() == ECalenEventView,
            Panic( EInvalidCommand ) );

    if (aCommand.Command() != ECalenEventView)
        {
        ERROR( KErrArgument, "Invalid command" );
        User::Leave(KErrArgument);
        }

    GetEntryL(aCommand);
    LaunchMRViewerL( aCommand );
    }

// ---------------------------------------------------------------------------
// CMRBCPluginOpenMRViewerCmd::ProcessCommandL
// ---------------------------------------------------------------------------
//
void CMRBCPluginOpenMRViewerCmd::ProcessCommandL( TInt /* aCommandId */ )
    {
    FUNC_LOG;
    }

// ---------------------------------------------------------------------------
// CMRBCPluginOpenMRViewerCmd::ProcessCommandWithResultL
// ---------------------------------------------------------------------------
//
TInt CMRBCPluginOpenMRViewerCmd::ProcessCommandWithResultL(TInt /*aCommandId*/)
    {
    FUNC_LOG;
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// CMRBCPluginOpenMRViewerCmd::LaunchMRViewerL
// ---------------------------------------------------------------------------
//
void CMRBCPluginOpenMRViewerCmd::LaunchMRViewerL(
        const TCalenCommand& aCommand )
    {
    FUNC_LOG;

    const TUid KCalendarUid =
        {
        0x10005901
        };
    // Constructing input parameters
    INFO( "Constructing input parameters" );
    MAgnEntryUi::TAgnEntryUiInParams inParams(
            KCalendarUid,
            iServices.SessionL(),
            MAgnEntryUi::EViewEntry);

    // Set time for input parameters
    INFO( "Set time for input parameters" );
    TCalTime startTime = iEntry->StartTimeL();
    TCalTime::TTimeMode timemode = startTime.TimeMode();
    if (timemode == TCalTime::EFloating)
        {
        inParams.iInstanceDate.SetTimeLocalFloatingL(startTime.TimeLocalL());
        }
    else
        {
        RArray<TInt> colIds;
        CleanupClosePushL( colIds );
        TInt colId = iServices.Context().InstanceId().iColId;
        colIds.AppendL( colId );
        CCalInstance* instance = FindPossibleInstanceL(
                iServices.Context().InstanceId(), *(iServices.InstanceViewL(colIds)));
        CleanupStack::PushL( instance );
        inParams.iInstanceDate.SetTimeUtcL(instance->Time().TimeUtcL());
        CleanupStack::PopAndDestroy( instance );
        CleanupStack::PopAndDestroy( &colIds );
        }

    inParams.iMsgSession = NULL;

    // Output parameters
    MAgnEntryUi::TAgnEntryUiOutParams outParams;
    TMROutputParams outputParams;
    outParams.iSpare = reinterpret_cast< TInt >( &outputParams );

    // Launch Entry UI
    INFO( "Launch Entry UI" );
    RPointerArray<CCalEntry> entries;
    CleanupClosePushL( entries );
    entries.AppendL( iEntry ); // Ownership not transferred.

    iEditor = CESMRViewerController::NewL(
            KBCViewer(),
            entries,
            inParams,
            outParams,
            *this );

    TRAPD( err, iEditor->ExecuteL() );
    if( KErrArgument == err )
        {
        delete iEditor;
        iEditor = NULL;

        // ES MR VIEWER controller was unable to show the
        // passed meeting request. Let's launch normal meeting viewer
        // for showing the entry
        CCalEntry* meetingEntry = ESMRHelper::CopyEntryLC(
                *entries[0],
                entries[0]->MethodL(),
                ESMRHelper::ECopyFull,
                EESMREventTypeAppt );

#ifdef RD_USE_PS2_APIS
        meetingEntry->ClearMRSpecificDataL();
#endif // RD_USE_PS2_APIS

        // Delete old entry and reset entry array
        delete iEntry;
        iEntry = NULL;
        entries.Reset();

        // Append entry to array.
        entries.AppendL( meetingEntry );

        // Take ownership of meeting entry
        iEntry = meetingEntry;
        CleanupStack::Pop( meetingEntry );

        iEditor = CESMRViewerController::NewL(
                KBCViewer(),
                entries,
                inParams,
                outParams,
                *this );

        iEditor->ExecuteL();
        }

    // Issue notification if required.
    IssueNotifyL( aCommand, outParams );

    // Issue command if required.
    IssueCommandL( outParams );

    // Close and reset entry array
    CleanupStack::PopAndDestroy( &entries );
    }

// ---------------------------------------------------------------------------
// CMRBCPluginOpenMRViewerCmd::GetEntryL
// ---------------------------------------------------------------------------
//
void CMRBCPluginOpenMRViewerCmd::GetEntryL(const TCalenCommand& /*aCommand*/ )
    {
    FUNC_LOG;

    if (iEntry)
        {
        delete iEntry;
        iEntry = NULL;
        }

    MCalenContext& context = iServices.Context();
    TCalLocalUid instanceId = context.InstanceId().iEntryLocalUid;
    TInt colId = context.InstanceId().iColId;

    iEntry = iServices.EntryViewL(colId)->FetchL(instanceId);
    }

// ---------------------------------------------------------------------------
// CMRBCPluginOpenMRViewerCmd::IssueNotifyL
// Handle notify message
// ---------------------------------------------------------------------------
//
void CMRBCPluginOpenMRViewerCmd::IssueNotifyL(
        const TCalenCommand& aCommand,
        MAgnEntryUi::TAgnEntryUiOutParams aOutParams )
    {
    FUNC_LOG;

    TCalenNotification notification = ECalenNotifyEntryClosed;
    switch ( aOutParams.iAction )
        {
        case MAgnEntryUi::EMeetingDeleted:
        case MAgnEntryUi::EInstanceDeleted:
            {
            notification = ECalenNotifyEntryDeleted;
            }
            break;

        case MAgnEntryUi::EMeetingSaved:
            {
            notification = ECalenNotifyEntrySaved;
            }
            break;

        case MAgnEntryUi::EInstanceRescheduled:
            {
            notification = ECalenNotifyEntrySaved;
            }
            break;

        case MAgnEntryUi::ENoAction:
            {
            TMROutputParams* params =
                ( TMROutputParams* )( aOutParams.iSpare );

            // If viewer options menu exit is desired
            if( params->iCommand == EMRDialogOptionsMenuExit )
                {
                notification = ECalenNotifyRealExit;
                }
            }
            break;

        default:
            break;
        }

    if ( MAgnEntryUi::ENoAction != aOutParams.iAction )
        {
        // Update context and issue notification before confirmation dialog
        // to avoid delay of updating title pane
        MCalenContext& context = iServices.Context();
        aCommand.GetContextL( context );

        // Update context and issue notification before confirmation dialog
        // to avoid delay of updating title pane
        TCalenInstanceId id = TCalenInstanceId::CreateL(
                *iEntry,
                aOutParams.iNewInstanceDate );

        context.SetInstanceIdL( id, context.ViewId() );
        }

    // Notify RECAL
    iServices.IssueNotificationL( notification );
    }

// ---------------------------------------------------------------------------
// CMRBCPluginOpenMRViewerCmd::IssueCommandL
// Issue command for calendar to handle
// ---------------------------------------------------------------------------
//
void CMRBCPluginOpenMRViewerCmd::IssueCommandL(
        MAgnEntryUi::TAgnEntryUiOutParams aOutParams )
    {
    FUNC_LOG;
    TInt command( KErrNotFound );

    TMROutputParams* params = ( TMROutputParams* )( aOutParams.iSpare );

    switch ( params->iCommand )
        {
        case EMRDialogOptionsMenuExit:
            {
            // Calendar app is not supposed to issue EAknCmdExit command.
            // It is always soft exit and faster app FW takes the call, and
            // decides the correct action.
            //
            // This is why we use command EAknSoftkeyExit, to exit
            // application from viewer options menu.

            command = EAknSoftkeyExit;
            }
            break;

        default:
            break;
        }

    // Issue command for RECAL
    if( command != KErrNotFound )
        {
        iServices.IssueCommandL( command );
        }
    }

// EOF