/*

* 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 "cmrbcplugincreatenewmrcmd.h"

#include "cesmrviewerctrl.h"

#include "esmrcommands.h"

#include "tmroutputparams.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 <bldvariant.hrh>

#include "emailtrace.h"

namespace { // codescanner::namespace

/**

 * Literal for BC viewer / editor

 */

_LIT8( KBCViewer, "[2001F406]" );

/**

 * Default sequence number

 */

const TInt KDefaultSeqNo( 0 );

/**

 * Constant for default duration in minutes

 */

const TInt KDefaultDurationInMinutes( 60 );

#ifdef _DEBUG

/**

 * Panic literal

 */

_LIT( KMRBCPluginCreateNewMRCmd, "MRBCPluginCreateNewMRCmd" );

/**

 * Panic codes

 */

enum TMRBCPluginCreateNewMRCmdPanic

	{

	EInvalidCommand // Invalid command

	};

void Panic( TMRBCPluginCreateNewMRCmdPanic aPanic )

	{

	User::Panic( KMRBCPluginCreateNewMRCmd, aPanic );

	}

#endif // _DEBUG

/**

 * Fetches the supported mailboxes.

 * @param aMBUtils utils class

 * @param aMailBoxes to test

 */

void SupportedMailboxesL(

        CMRMailboxUtils& aMBUtils,

        RArray<CMRMailboxUtils::TMailboxInfo>& aMailBoxes )

    {

    FUNC_LOG;

    aMBUtils.ListMailBoxesL( aMailBoxes );

    RCPointerArray<CImplementationInformation> implArray;

    CleanupClosePushL( implArray );

    //Get all MRViewers Implementation

    const TUid mrViewersIface = TUid::Uid(KMRViewersInterfaceUID);

    REComSession::ListImplementationsL(mrViewersIface, implArray );

    TInt mrviewerCount( implArray.Count() );

    TInt index(0);

    TInt mailboxCount( aMailBoxes.Count() );

    while ( index < mailboxCount )

         {

         TBool supported( EFalse );

         for ( TInt i(0); (i < mrviewerCount) && !supported; ++ i )

             {

             TBuf16<KMaxUidName> mbName;

             CnvUtfConverter::ConvertToUnicodeFromUtf8(

                     mbName,

                     implArray[i]->DataType() );

             if( aMailBoxes[index].iMtmUid.Name().CompareF(mbName) == 0)

                  {

                  supported = ETrue;

                 }

             }

         if ( supported )

             {

             index++;

             }

         else

             {

             aMailBoxes.Remove( index );

             mailboxCount = aMailBoxes.Count();

             }

         }

    CleanupStack::PopAndDestroy( &implArray );

    }

/**

 * Prompts user to select default mailbox.

 * @param aMailBoxes Reference to mailbox list

 */

TInt PromptForDefaultMailboxL(

        RArray<CMRMailboxUtils::TMailboxInfo>& aMailBoxes )

    {

    FUNC_LOG;

    TInt selected( KErrCancel );

    TInt mbCount = aMailBoxes.Count();

    if( mbCount > 0)

        {

        CAknSinglePopupMenuStyleListBox* list =

            new (ELeave) CAknSinglePopupMenuStyleListBox;

        CleanupStack::PushL(list);

        CAknPopupList* popupList = CAknPopupList::NewL(

                                            list,

                                            R_AVKON_SOFTKEYS_OK_CANCEL);

        CleanupStack::PushL(popupList);

        list->ConstructL(popupList, CEikListBox::ELeftDownInViewRect);

        list->CreateScrollBarFrameL(ETrue);

        list->ScrollBarFrame()->SetScrollBarVisibilityL(

            CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto);

        CEikonEnv* eikEnv = CEikonEnv::Static();// codescanner::eikonenvstatic

        CDesCArrayFlat* items = new (ELeave)CDesCArrayFlat(mbCount);

        CleanupStack::PushL(items);

        for(TInt i=0; i<mbCount; ++i)

            {

            items->AppendL( aMailBoxes[i].iName );

            }

        CleanupStack::Pop(items);

        CTextListBoxModel* model = list->Model();

        //Pass ownersip of items to model

        model->SetItemTextArray(items);

        HBufC* title = KNullDesC().AllocLC();

        popupList->SetTitleL(*title);

        CleanupStack::PopAndDestroy(title);

        TBool accepted = popupList->ExecuteLD();

        CleanupStack::Pop( popupList );

        if(accepted)

            {

            selected = list->CurrentItemIndex();

            }

        else

            {

            selected = KErrCancel;

            }

        CleanupStack::PopAndDestroy( list );

        }

    else

        {

        //No mailboxes defined.  Could prompt user to define one here.

        selected = KErrCancel;

        }

    return selected;

    }

/**

 * Test if this is valid command to be executed by this object.

 * @param aCommand Reference to command object

 * @return ETrue if this is valid command, EFalse otherwise

 */

TBool IsValidCommand(

        const TCalenCommand& aCommand )

    {

    TBool retValue( EFalse );

    TInt aCommandId( aCommand.Command() );

    if ( ECalenNewMeetingRequest == aCommandId ||

            ECalenNewMeetingTimeSpan == aCommandId )

        {

        retValue = ETrue;

        }

    return retValue;

    }

}

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

// CMRBCPluginCreateNewMRCmd::CMRBCPluginCreateNewMRCmd

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

//

CMRBCPluginCreateNewMRCmd::CMRBCPluginCreateNewMRCmd(

		MCalenServices& aServices )

:	iServices( aServices )

	{

	FUNC_LOG;

	}

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

// CMRBCPluginCreateNewMRCmd::~CMRBCPluginCreateNewMRCmd

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

//

CMRBCPluginCreateNewMRCmd::~CMRBCPluginCreateNewMRCmd()

	{

	FUNC_LOG;

	delete iEntry;

	delete iEditor;

	}

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

// CMRBCPluginCreateNewMRCmd::ConstructL

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

//

CMRBCPluginCreateNewMRCmd* CMRBCPluginCreateNewMRCmd::NewL(

		MCalenServices& aServices )

	{

	FUNC_LOG;

	CMRBCPluginCreateNewMRCmd* self =

			new (ELeave) CMRBCPluginCreateNewMRCmd( aServices );

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop( self );

	return self;

	}

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

// CMRBCPluginCreateNewMRCmd::ConstructL

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

//

void CMRBCPluginCreateNewMRCmd::ConstructL()

	{

	FUNC_LOG;

	}

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

// CMRBCPluginCreateNewMRCmd::ExecuteCommandL

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

//

void CMRBCPluginCreateNewMRCmd::ExecuteCommandL(

		const TCalenCommand& aCommand )

	{

	FUNC_LOG;

	TBool validCommand( IsValidCommand(aCommand) );

	__ASSERT_DEBUG(

	        validCommand,

			Panic( EInvalidCommand ) );

	if ( !validCommand )

		{

		ERROR( KErrArgument, "Invalid command" );

		User::Leave( KErrArgument );

		}

	CreateEntryL( aCommand );

    LaunchMREditorL( aCommand );

	}

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

// CMRBCPluginCreateNewMRCmd::ProcessCommandL

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

//

void CMRBCPluginCreateNewMRCmd::ProcessCommandL(

		TInt /*aCommandId*/ )

	{

	FUNC_LOG;

	}

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

// CMRBCPluginCreateNewMRCmd::ProcessCommandWithResultL

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

//

TInt CMRBCPluginCreateNewMRCmd::ProcessCommandWithResultL( // codescanner::intleaves

		TInt /*aCommandId*/ )

	{

	FUNC_LOG;

	return KErrNone;

	}

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

// CMRBCPluginCreateNewMRCmd::LaunchMREditorL

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

//

void CMRBCPluginCreateNewMRCmd::LaunchMREditorL(

        const TCalenCommand& aCommand )

    {

    FUNC_LOG;

    const TUid KCalendarUid = { 0x10005901 };

    // Constructing input parameters

    INFO( "Constructing input parameters" );

    MAgnEntryUi::TAgnEntryUiInParams inParams(

            KCalendarUid,

            iServices.SessionL(),

            MAgnEntryUi::ECreateNewEntry );

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

        {

        inParams.iInstanceDate.SetTimeUtcL (

                startTime.TimeUtcL() );

        }

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

    AddOrganizerL();

    CCalenInterimUtils2& utils = iServices.InterimUtilsL();

    if ( utils.MRViewersEnabledL( ETrue ) )

        {

        iEditor = CESMRViewerController::NewL(

                KBCViewer(),

                entries,

                inParams,

                outParams,

                *this );

        }

    else

        {

        // MR is not supported --> Leave

        User::Leave (KErrNotSupported );

        }

    iEditor->ExecuteL();

    TCalenNotification notification( ECalenNotifyEntryClosed );

    if ( MAgnEntryUi::ENoAction != outParams.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,

                outParams.iNewInstanceDate );

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

        notification = ECalenNotifyEntrySaved;

        }

    else

        {

        TMROutputParams* params =

            ( TMROutputParams* )( outParams.iSpare );

        // If viewer options menu exit is desired

        if( params->iCommand == EMRDialogOptionsMenuExit )

            {

            notification = ECalenNotifyRealExit;

            }

        }

    iServices.IssueNotificationL( notification );

    IssueCommandL( outParams );

    CleanupStack::PopAndDestroy( &entries );

    iEntry = NULL;

    }

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

// CMRBCPluginCreateNewMRCmd::CreateEntryL

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

//

void CMRBCPluginCreateNewMRCmd::CreateEntryL(

		const TCalenCommand& aCommand )

    {

    FUNC_LOG;

    CCalenInterimUtils2& utils = iServices.InterimUtilsL();

    // Create unique ID.

    HBufC8* guid = utils.GlobalUidL();

    CleanupStack::PushL(guid);

    iEntry = CCalEntry::NewL(

    		CCalEntry::EAppt,

    		guid, CCalEntry::EMethodRequest,

    		KDefaultSeqNo );

    CleanupStack::Pop( guid );

    MCalenContext& context = iServices.Context();

    aCommand.GetContextL( context );

    TCalTime startTime, stopTime;

#ifdef RD_USE_PS2_APIS

    // Business Calendar day view with visual selection

    TTime start( 0 );

    TTime end( 0 );

    context.GetStartAndEndTimeForNewInstance( start, end );

    const TTime zeroTime(0);

    if ( start != zeroTime && end != zeroTime &&

            ECalenNewMeetingTimeSpan == aCommand.Command() )

        {

        startTime.SetTimeLocalL( start );

        stopTime.SetTimeLocalL( end );

        context.SetStartAndEndTimeForNewInstance( zeroTime, zeroTime ); //clean the start/end time in Context

        }

    else

#endif // RD_USE_PS2_APIS

        {

        startTime = context.FocusDateAndTimeL();

        TTimeIntervalMinutes interval = KDefaultDurationInMinutes;

        stopTime.SetTimeLocalL(

               startTime.TimeLocalL() +

               interval );

        }

    iEntry->SetStartAndEndTimeL( startTime, stopTime );

    iEntry->SetPriorityL( EFSCalenMRPriorityNormal );

    }

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

// CMRBCPluginCreateNewMRCmd::AddOrganizerL

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

//

void CMRBCPluginCreateNewMRCmd::AddOrganizerL()

    {

    FUNC_LOG;

    CMRMailboxUtils* mbUtils = CMRMailboxUtils::NewL( NULL );

    CleanupStack::PushL( mbUtils );

    CMRMailboxUtils::TMailboxInfo defaultMailBox;

    TInt err = mbUtils->GetDefaultMRMailBoxL( defaultMailBox );

    if ( KErrNone != err )

        {

        RArray<CMRMailboxUtils::TMailboxInfo> mailBoxes;

        CleanupClosePushL( mailBoxes );

        SupportedMailboxesL( *mbUtils, mailBoxes );

        TInt selectedMailbox( PromptForDefaultMailboxL(mailBoxes) );

        if ( KErrCancel != selectedMailbox )

            {

            mbUtils->SetDefaultMRMailBoxL(

                    mailBoxes[selectedMailbox].iEntryId ); // codescanner::accessArrayElementWithoutCheck2

            mbUtils->GetDefaultMRMailBoxL(defaultMailBox);

            }

        CleanupStack::PopAndDestroy( &mailBoxes );

        // This will leave if user cancelled the mailbox selection

        User::LeaveIfError( selectedMailbox );

        }

    //Set the organizer from the selected mailbox

    CCalUser* organizer = CCalUser::NewL( defaultMailBox.iEmailAddress );

    CleanupStack::PushL(organizer );

    iEntry->SetOrganizerL(organizer );

    CleanupStack::Pop( organizer ); // Ownership trasferred

    CleanupStack::PopAndDestroy( mbUtils );

    }

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

// CMRBCPluginCreateNewMRCmd::IssueCommandL

// Issue command for calendar to handle

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

//

void CMRBCPluginCreateNewMRCmd::IssueCommandL(

        MAgnEntryUi::TAgnEntryUiOutParams aOutParams )

    {

    FUNC_LOG;

    TInt command( KErrNotFound );