/*

* Copyright (c) 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: 

*

*/

#include <mpxcommandgeneraldefs.h>

#include <mpxcollectionpath.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxmessageprogressdefs.h>

#include <glxfilterfactory.h>

#include <glxcollectionpluginall.hrh>

#include <mglxmedialist.h>

#include <glxmpxcommandhandler.h>

#include <glxfetchcontextremover.h>

#include <glxmedialistiterator.h>

#include <glxattributecontext.h>

#include <glxattributeretriever.h>

#include <glxuistd.h>

#include <textresolver.h>

#include <hbmessagebox.h>

#include <hbnotificationdialog.h>

#include <e32debug.h>

#include <hbprogressdialog.h>

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "glxmpxcommandhandlerTraces.h"

#endif

#include <hbaction.h>

GlxMpxCommandHandler::GlxMpxCommandHandler() :

    iProgressComplete(EFalse)

    {

    OstTraceFunctionEntry0( GLXMPXCOMMANDHANDLER_GLXMPXCOMMANDHANDLER_ENTRY );

    iMediaList = NULL;

    OstTraceFunctionExit0( GLXMPXCOMMANDHANDLER_GLXMPXCOMMANDHANDLER_EXIT );

    }

GlxMpxCommandHandler::~GlxMpxCommandHandler()

    {

    OstTraceFunctionEntry0( DUP1_GLXMPXCOMMANDHANDLER_GLXMPXCOMMANDHANDLER_ENTRY );

    //close the existing instance of Media List

    if (iMediaList)

        {

        iMediaList->Close();

        iMediaList = NULL;

        }

    OstTraceFunctionExit0( DUP1_GLXMPXCOMMANDHANDLER_GLXMPXCOMMANDHANDLER_EXIT );

    }

void GlxMpxCommandHandler::executeCommand(int commandId, int collectionId,QList<QModelIndex>  indexList)

    {

    OstTraceFunctionEntry0( GLXMPXCOMMANDHANDLER_EXECUTECOMMAND_ENTRY );

    Q_UNUSED(indexList);

    int aHierarchyId = 0;

    TGlxFilterItemType aFilterType = EGlxFilterImage;

    if (collectionId != KGlxAlbumsMediaId)

        {

        OstTrace0( TRACE_NORMAL, DUP2_GLXMPXCOMMANDHANDLER_EXECUTECOMMAND, "GlxMpxCommandHandler::executeCommand::CreateMediaListL" );

        CreateMediaListL(collectionId, aHierarchyId, aFilterType);

        }

    else

        {

        OstTrace0( TRACE_NORMAL, DUP3_GLXMPXCOMMANDHANDLER_EXECUTECOMMAND, "GlxMpxCommandHandler::executeCommand::CreateMediaListAlbumItemL" );

        //for creating Medial List for Albums Media path Items

        CreateMediaListAlbumItemL(collectionId, aHierarchyId, aFilterType);

        }

    TBool consume = ETrue;

    iProgressComplete = EFalse;

    mProgressDialog = NULL;

    //Execute Command 

    DoExecuteCommandL(commandId, *iMediaList, consume);

    mCommandId = commandId;

    ConfirmationNoteL(*iMediaList);

    OstTraceFunctionExit0( GLXMPXCOMMANDHANDLER_EXECUTECOMMAND_EXIT );

    }

void GlxMpxCommandHandler::executeMpxCommand(bool execute)

    {

    if(execute && !iMediaList->IsCommandActive())            

        {

        TBool consume = ETrue;

        CMPXCommand* command = CreateCommandL(mCommandId, *iMediaList, consume);

        if (command)

            {

            command->SetTObjectValueL<TAny*> (KMPXCommandGeneralSessionId,

                    static_cast<TAny*> (this));

            iMediaList->AddMediaListObserverL(this);

            iMediaList->CommandL(*command);

            if(iMediaList->SelectionCount() > 1)

                {

                 ProgressNoteL(mCommandId);

                }

            }

        }

    else //command cancelled,so unmark all items

        {

        MGlxMediaList::UnmarkAllL(*iMediaList);

        }

    }

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

// CreateMediaListL()

// Creates a collection path

// Create a filter as requested filtertype

// Creates the medialist

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

void GlxMpxCommandHandler::CreateMediaListL(int aCollectionId,

        int aHierarchyId, TGlxFilterItemType aFilterType)

    {

    OstTraceFunctionEntry0( GLXMPXCOMMANDHANDLER_CREATEMEDIALISTL_ENTRY );

    Q_UNUSED(aHierarchyId);

    Q_UNUSED(aFilterType);

    //close the existing instance of Media List

    if (iMediaList)

        {

        iMediaList->Close();

        iMediaList = NULL;

        }

    // Create path to the list of images and videos

    CMPXCollectionPath* path = CMPXCollectionPath::NewL();

    CleanupStack::PushL(path);

    path->AppendL(aCollectionId);

    // Create filter to filter out either images or videos

    CMPXFilter* filter = TGlxFilterFactory::CreateItemTypeFilterL(

            EGlxFilterImage); //todo take actual filter type

    CleanupStack::PushL(filter);

    // Create the media list

    iMediaList = MGlxMediaList::InstanceL(*path, TGlxHierarchyId(0), filter); //todo take actual hierarchy 

    CleanupStack::PopAndDestroy(filter);

    CleanupStack::PopAndDestroy(path);

    OstTraceFunctionExit0( GLXMPXCOMMANDHANDLER_CREATEMEDIALISTL_EXIT );

    }

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

// CreateMediaListAlbumItemL()

// Creates the media list for the album Item 

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

void GlxMpxCommandHandler::CreateMediaListAlbumItemL(int aCollectionId,

        int aHierarchyId, TGlxFilterItemType aFilterType)

    {

    OstTraceFunctionEntry0( GLXMPXCOMMANDHANDLER_CREATEMEDIALISTALBUMITEML_ENTRY );

    Q_UNUSED(aCollectionId);

    Q_UNUSED(aHierarchyId);

    //retrieve the instance of Media list for ALBUMS LIST which will be saved in iMediaList

    CreateMediaListL(KGlxCollectionPluginAlbumsImplementationUid, 0,

            EGlxFilterAlbum);

    //retrieve the path of the focussed item of the MediaList

    CMPXCollectionPath* path = iMediaList->PathLC(

            NGlxListDefs::EPathFocusOrSelection);

    //close the existing instance of Media List

    iMediaList->Close();

    iMediaList = NULL;

    //create new media list with the derived path

    CMPXFilter* filter =

            TGlxFilterFactory::CreateItemTypeFilterL(aFilterType);

    CleanupStack::PushL(filter);

    iMediaList = MGlxMediaList::InstanceL(*path, TGlxHierarchyId(0), filter); //todo take actual hierarchy

    CleanupStack::PopAndDestroy(filter);

    CleanupStack::PopAndDestroy(path);

    OstTraceFunctionExit0( GLXMPXCOMMANDHANDLER_CREATEMEDIALISTALBUMITEML_EXIT );

    }

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

// HandleItemAddedL

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

//  

void GlxMpxCommandHandler::HandleItemAddedL(TInt /*aStartIndex*/,

        TInt /*aEndIndex*/, MGlxMediaList* /*aList*/)

    {

    OstTraceFunctionEntry0( GLXMPXCOMMANDHANDLER_HANDLEITEMADDEDL_ENTRY );

    // Do nothing

    OstTraceFunctionExit0( GLXMPXCOMMANDHANDLER_HANDLEITEMADDEDL_EXIT );

    }

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

// HandleMediaL

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

//	

void GlxMpxCommandHandler::HandleMediaL(TInt /*aListIndex*/, MGlxMediaList* /*aList*/)

    {

    OstTraceFunctionEntry0( GLXMPXCOMMANDHANDLER_HANDLEMEDIAL_ENTRY );

    // Do nothing

    OstTraceFunctionExit0( GLXMPXCOMMANDHANDLER_HANDLEMEDIAL_EXIT );

    }

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

// HandleItemRemovedL

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

//	

void GlxMpxCommandHandler::HandleItemRemovedL(TInt /*aStartIndex*/,

        TInt /*aEndIndex*/, MGlxMediaList* /*aList*/)

    {

    OstTraceFunctionEntry0( GLXMPXCOMMANDHANDLER_HANDLEITEMREMOVEDL_ENTRY );

    // Do nothing

    OstTraceFunctionExit0( GLXMPXCOMMANDHANDLER_HANDLEITEMREMOVEDL_EXIT );

    }

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

// HandleItemModifiedL

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

//	

void GlxMpxCommandHandler::HandleItemModifiedL(const RArray<TInt>& /*aItemIndexes*/, 

        MGlxMediaList* /*aList*/)

	{

	OstTraceFunctionEntry0( GLXMPXCOMMANDHANDLER_HANDLEITEMMODIFIEDL_ENTRY );

	// Do nothing

	OstTraceFunctionExit0( GLXMPXCOMMANDHANDLER_HANDLEITEMMODIFIEDL_EXIT );

	}	

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

// HandleAttributesAvailableL

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

//	

void GlxMpxCommandHandler::HandleAttributesAvailableL(TInt /*aItemIndex*/, 	

	const RArray<TMPXAttribute>& /*aAttributes*/, MGlxMediaList* /*aList*/)

	{

	OstTraceFunctionEntry0( GLXMPXCOMMANDHANDLER_HANDLEATTRIBUTESAVAILABLEL_ENTRY );

	// Do nothing

	OstTraceFunctionExit0( GLXMPXCOMMANDHANDLER_HANDLEATTRIBUTESAVAILABLEL_EXIT );

	}

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

// HandleFocusChangedL

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

//	

void GlxMpxCommandHandler::HandleFocusChangedL(NGlxListDefs::TFocusChangeType /*aType*/, 

        TInt /*aNewIndex*/, TInt /*aOldIndex*/, MGlxMediaList* /*aList*/) 

	{

	OstTraceFunctionEntry0( GLXMPXCOMMANDHANDLER_HANDLEFOCUSCHANGEDL_ENTRY );

	// Do nothing

	OstTraceFunctionExit0( GLXMPXCOMMANDHANDLER_HANDLEFOCUSCHANGEDL_EXIT );

	}

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

// HandleItemSelectedL

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

//	

void GlxMpxCommandHandler::HandleItemSelectedL(TInt /*aIndex*/, 

        TBool /*aSelected*/, MGlxMediaList* /*aList*/)

	{

	OstTraceFunctionEntry0( GLXMPXCOMMANDHANDLER_HANDLEITEMSELECTEDL_ENTRY );

	// Do nothing

	OstTraceFunctionExit0( GLXMPXCOMMANDHANDLER_HANDLEITEMSELECTEDL_EXIT );

	}

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

// HandleMessageL

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

//	

void GlxMpxCommandHandler::HandleMessageL(const CMPXMessage& aMessage,

        MGlxMediaList*/* aList*/)

    {

    OstTraceFunctionEntry0( GLXMPXCOMMANDHANDLER_HANDLEMESSAGEL_ENTRY );

    if ((aMessage.IsSupported(KMPXMessageGeneralId) && (aMessage.IsSupported(

            KMPXCommandGeneralSessionId))))

        {

        TInt msgId = aMessage.ValueTObjectL<TInt> (KMPXMessageGeneralId);

        TAny* sessionId = aMessage.ValueTObjectL<TAny*> (

                KMPXCommandGeneralSessionId);

        TInt error = KErrNone;

        // Check if this is a progress message and intended for this object

        TryExitL(error);

        }

    OstTraceFunctionExit0( GLXMPXCOMMANDHANDLER_HANDLEMESSAGEL_EXIT );

    }

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

// HandleCommandCompleteL

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

//	

void GlxMpxCommandHandler::HandleCommandCompleteL(TAny* aSessionId,

        CMPXCommand* aCommandResult, TInt aError, MGlxMediaList* aList)

    {

    OstTraceFunctionEntry0( GLXMPXCOMMANDHANDLER_HANDLECOMMANDCOMPLETEL_ENTRY );

    MGlxMediaList::UnmarkAllL(*iMediaList);

    DoHandleCommandCompleteL(aSessionId, aCommandResult, aError, aList);

    iProgressComplete = ETrue;

    TryExitL(aError);

    OstTraceFunctionExit0( GLXMPXCOMMANDHANDLER_HANDLECOMMANDCOMPLETEL_EXIT );

    }

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

// HandleError

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

//  

void GlxMpxCommandHandler::HandleError(TInt /*aError*/)

    {

    OstTraceFunctionEntry0( GLXMPXCOMMANDHANDLER_HANDLEERROR_ENTRY );

    OstTraceFunctionExit0( GLXMPXCOMMANDHANDLER_HANDLEERROR_EXIT );

    }

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

// Default implementation of advanced command handling does nothing

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

//	

void GlxMpxCommandHandler::DoHandleCommandCompleteL(TAny* /*aSessionId*/, 

        CMPXCommand* /*aCommandResult*/, TInt /*aError*/, MGlxMediaList* /*aList*/)

    {

    OstTraceFunctionEntry0( GLXMPXCOMMANDHANDLER_DOHANDLECOMMANDCOMPLETEL_ENTRY );

    OstTraceFunctionExit0( GLXMPXCOMMANDHANDLER_DOHANDLECOMMANDCOMPLETEL_EXIT );

    }

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

// Default implementation of advanced command handling does nothing

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

//

void GlxMpxCommandHandler::DoExecuteCommandL(TInt /*aCommandId*/,

        MGlxMediaList& /*aMediaList*/, TBool& /*aConsume*/)

    {

    OstTraceFunctionEntry0( GLXMPXCOMMANDHANDLER_DOEXECUTECOMMANDL_ENTRY );

    OstTraceFunctionExit0( GLXMPXCOMMANDHANDLER_DOEXECUTECOMMANDL_EXIT );

    }

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

// TryExitL

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

//  

void GlxMpxCommandHandler::TryExitL(TInt aErrorCode)

    {

    OstTraceFunctionEntry0( GLXMPXCOMMANDHANDLER_TRYEXITL_ENTRY );

    if (KErrNone != aErrorCode)

        {

        // @todo error received. Close progress note 

        DismissProgressNoteL();

        iMediaList->RemoveMediaListObserver(this);

        iMediaList->Close();

        iMediaList = NULL;

        // handle error

        HandleErrorL(aErrorCode);

        }

    else if (iProgressComplete)

        {

        DismissProgressNoteL();

        iMediaList->RemoveMediaListObserver(this);

        iMediaList->Close();

        iMediaList = NULL;

        CompletionNoteL();

        iProgressComplete = EFalse;

        }

    OstTraceFunctionExit0( GLXMPXCOMMANDHANDLER_TRYEXITL_EXIT );

    }

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

// Default implementation shows an error note

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

//	

void GlxMpxCommandHandler::HandleErrorL(TInt aErrorCode)

    {

    OstTraceFunctionEntry0( GLXMPXCOMMANDHANDLER_HANDLEERRORL_ENTRY );

    // show error note

    // TextResolver instance for error resolving.

    CTextResolver* textresolver = CTextResolver::NewLC();

    // Resolve the error text

    const TDesC& text = textresolver->ResolveErrorString(aErrorCode);

    QString qtText = QString::fromUtf16(text.Ptr(), text.Length());

	HbNotificationDialog::launchDialog(qtText);

    CleanupStack::PopAndDestroy(textresolver);

    OstTraceFunctionExit0( GLXMPXCOMMANDHANDLER_HANDLEERRORL_EXIT );

    }

void GlxMpxCommandHandler::CompletionNoteL() const

    {

    QString displayText = CompletionTextL();

    if (!displayText.isNull())

        {

		HbNotificationDialog::launchDialog(displayText);

        }

    }

QString GlxMpxCommandHandler::CompletionTextL() const

    {

    return QString();

    }

QString GlxMpxCommandHandler::ProgressTextL() const

    {

    return QString("Progressing...");

    }

void GlxMpxCommandHandler::ProgressNoteL(TInt /*aCommandId*/)

    {

    mProgressDialog = new HbProgressDialog(HbProgressDialog::WaitDialog);

    mProgressDialog->setText(ProgressTextL());

    mProgressDialog->show();

    }

void GlxMpxCommandHandler::DismissProgressNoteL()

    {

    if(mProgressDialog)

        {

        mProgressDialog->close();

        delete mProgressDialog;

        mProgressDialog = NULL;

        }

    }

void GlxMpxCommandHandler::ConfirmationNoteL(MGlxMediaList& aMediaList)

    {

	TInt selectionCount = aMediaList.SelectionCount();

    // If media list is not empty, treat focused item as selected

    // At this point can assume that the command was disabled 

    // if static items were not supported	

	if ( selectionCount == 0  )

		{

		selectionCount = 1;

		}

    // Show confirmation note

	if ( selectionCount == 1 )

	    {

		ConfirmationNoteSingleL(aMediaList);

	    }

	else

	    {

		ConfirmationNoteMultipleL(aMediaList);

	    }

    }

void GlxMpxCommandHandler::ConfirmationNoteSingleL(MGlxMediaList& aMediaList)

    {

    QString qtText = ConfirmationTextL();

    if(!qtText.isEmpty ())

        {

        // create fetch context

        TGlxSelectionIterator iterator;

        iterator.SetRange(1);

        CGlxAttributeContext* attributeContext = new(ELeave) CGlxAttributeContext(&iterator);

        CleanupStack::PushL(attributeContext);

        attributeContext->AddAttributeL(KMPXMediaGeneralTitle);

        // add context to media list

        aMediaList.AddContextL(attributeContext, KGlxFetchContextPriorityLow);

        // TGlxContextRemover will remove the context when it goes out of scope

        // Used here to avoid a trap and still have safe cleanup

        TGlxFetchContextRemover contextRemover(attributeContext, aMediaList);

        // put to cleanupstack as cleanupstack is emptied before stack objects

        // are deleted

        CleanupClosePushL( contextRemover);

        // retrieve title attribute

        TInt err = GlxAttributeRetriever::RetrieveL(*attributeContext, aMediaList, EFalse);

        // context off the list

        CleanupStack::PopAndDestroy( &contextRemover );

        if ( err == KErrNone )

            {

            // use iterator to get the index of the right item 

            iterator.SetToFirst(&aMediaList);

            const CGlxMedia* media = aMediaList.Item(iterator++).Properties();

            // noteText has a place for a title string in it

            const TDesC& itemName = media->ValueText(KMPXMediaGeneralTitle);

            QString qtItemName = QString::fromUtf16(itemName.Ptr(),itemName.Length());

            QString localisedString  = qtText.arg(qtItemName);

            qtText = localisedString;          

            }

            // (else) If error, assume confirmed anyway

        CleanupStack::PopAndDestroy(attributeContext);

        HbMessageBox::question(qtText, this, SLOT(messageDialogClose(HbAction*)),HbMessageBox::Ok | HbMessageBox::Cancel);

        }

    else{

        executeMpxCommand(true);

        }

    }

void GlxMpxCommandHandler::ConfirmationNoteMultipleL(MGlxMediaList& /*aMediaList*/)

    {

    QString qtText = ConfirmationTextL(true);

    if(!qtText.isEmpty ())

        {

        HbMessageBox::question(qtText, this, SLOT(messageDialogClose(HbAction*)),HbMessageBox::Ok |HbMessageBox::Cancel);

        }    

    else{

        executeMpxCommand(true);

        }

    }

void GlxMpxCommandHandler::messageDialogClose(HbAction* action)

    {

    HbMessageBox *dlg = static_cast<HbMessageBox*>(sender());

    if(action == dlg->actions().at(0)) 

        {

        executeMpxCommand(true);

        }

    else

        {

        // Cancellation is done.

        executeMpxCommand(false);

        }

    }

QString GlxMpxCommandHandler::ConfirmationTextL(bool /*multiSelection */) const

    {

    return QString();

    }