/*

* 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 <mpxcollectionpath.h>

#include <mglxmedialist.h>

#include <glxcommandfactory.h>

#include <glxcommandhandleraddtocontainer.h>

#include <glxcommandhandlernewmedia.h>

#include <QStringListModel>

#include <hblabel.h>

#include <hbaction.h>

#include <glxalbummodel.h>

#include <glxcollectionpluginalbums.hrh>

#include <glxmodelparm.h>

#include <glxfilterfactory.h>

#include <QEventLoop>

#include <hblistwidget.h>

#include <hbview.h>

#include <hbpushbutton.h>

#include <QGraphicsGridLayout>

#include <hbmessagebox.h>

#include <glxcommandhandlers.hrh>

#include "glxlocalisationstrings.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "glxcommandhandleraddtocontainerTraces.h"

#endif

const TInt KSelectionPopupListHierarchy = 5;

GlxAlbumSelectionPopup::GlxAlbumSelectionPopup() 

      mEventLoop( 0 ),

      mResult( false )

{

}

GlxAlbumSelectionPopup::~GlxAlbumSelectionPopup()

{

}

QModelIndexList GlxAlbumSelectionPopup::GetSelectionList(GlxAlbumModel *model, bool *ok) 

{

    QEventLoop eventLoop;

    mEventLoop = &eventLoop;

    eventLoop.exec( );

    mEventLoop = 0 ;

    if ( ok ) {

        *ok = mResult ;

    }

    return selectedIndexes;

}

void GlxAlbumSelectionPopup::dialogClosed(HbAction *action)

{

    }

    else {

    }

    if ( mEventLoop && mEventLoop->isRunning( ) ) {

        mEventLoop->exit( 0 );

    }

}

GlxCommandHandlerAddToContainer::GlxCommandHandlerAddToContainer() :

    {

    OstTraceFunctionEntry0( GLXCOMMANDHANDLERADDTOCONTAINER_GLXCOMMANDHANDLERADDTOCONTAINER_ENTRY );

    mTargetContainers = NULL;

    OstTraceFunctionExit0( GLXCOMMANDHANDLERADDTOCONTAINER_GLXCOMMANDHANDLERADDTOCONTAINER_EXIT );

    }

GlxCommandHandlerAddToContainer::~GlxCommandHandlerAddToContainer()

    {

    OstTraceFunctionEntry0( DUP1_GLXCOMMANDHANDLERADDTOCONTAINER_GLXCOMMANDHANDLERADDTOCONTAINER_ENTRY );

    delete mTargetContainers;

    OstTraceFunctionExit0( DUP1_GLXCOMMANDHANDLERADDTOCONTAINER_GLXCOMMANDHANDLERADDTOCONTAINER_EXIT );

    }

CMPXCommand* GlxCommandHandlerAddToContainer::CreateCommandL(TInt aCommandId,

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

    {

    OstTraceFunctionEntry0( GLXCOMMANDHANDLERADDTOCONTAINER_CREATECOMMANDL_ENTRY );

    CMPXCommand* command = NULL;

    if(aCommandId == EGlxCmdAddToFav)

        {

           CMPXCollectionPath* targetCollection = CMPXCollectionPath::NewL();

           CleanupStack::PushL(targetCollection);

           // The target collection has to be appeneded with the albums plugin id

           targetCollection->AppendL(KGlxCollectionPluginAlbumsImplementationUid);

           // The target collection has also to be appeneded with the the relation id.

           // appending another level into the albums to get favourites and 1 is the relation id of albums

           targetCollection->AppendL( TMPXItemId(KGlxCollectionFavoritesId) );

           targetCollection->Set( 0 );

           CMPXCollectionPath* sourceItems = aMediaList.PathLC( NGlxListDefs::EPathFocusOrSelection );

           command = TGlxCommandFactory::AddToContainerCommandLC(

               *sourceItems, *targetCollection);

           CleanupStack::Pop(command); 

           CleanupStack::PopAndDestroy(sourceItems);

           CleanupStack::PopAndDestroy(targetCollection);

        }

    else

        {

            CMPXCollectionPath* sourceItems = aMediaList.PathLC(

            NGlxListDefs::EPathFocusOrSelection);

            bool ok = false;

            //create target medialist

            CMPXCollectionPath* path = CMPXCollectionPath::NewL();

            CleanupStack::PushL(path);

            path->AppendL(KGlxCollectionPluginAlbumsImplementationUid);

            CMPXFilter* filter =

            TGlxFilterFactory::CreateCameraAlbumExclusionFilterL();

            CleanupStack::PushL(filter);

            // Create the media list

            MGlxMediaList* targetMediaList = MGlxMediaList::InstanceL(*path,

                    TGlxHierarchyId(KSelectionPopupListHierarchy), filter); //todo take actual hierarchy 

            CleanupStack::PopAndDestroy(filter);

            CleanupStack::PopAndDestroy(path);

            //create target model

            GlxModelParm modelParm(KGlxCollectionPluginAlbumsImplementationUid,

                    KSelectionPopupListHierarchy, EGlxFilterExcludeCamera);

            GlxAlbumModel *albumMediaModel = new GlxAlbumModel(modelParm);

            albumMediaModel->setData(QModelIndex(), (int) GlxContextSelectionList,

                    GlxContextRole);

            GlxAlbumSelectionPopup popupWidget;

            QModelIndexList modelList = popupWidget.GetSelectionList(albumMediaModel, &ok);

            if(ok && modelList.count() == 0)

            {

                createNewMedia();

                ok = false;        

            }    

            OstTraceExt2( TRACE_NORMAL, GLXCOMMANDHANDLERADDTOCONTAINER_CREATECOMMANDL, "GlxCommandHandlerAddToContainer::CreateCommandL;ok=%d;newMedia=%d", ok, mNewMediaAdded );

            if (ok || mNewMediaAdded)

                {

                int count = modelList.count();

                for (int i = 0; i < count; i++)

                    {

                    albumMediaModel->setData(modelList[i], modelList[i].row(),

                            GlxSelectedIndexRole);

                    }

                if (!mNewMediaAdded)

                    {

                    CMPXCollectionPath* targetContainers = targetMediaList->PathLC(

                            NGlxListDefs::EPathFocusOrSelection);

                    CleanupStack::Pop(targetContainers);

                    delete mTargetContainers;

                    mTargetContainers = NULL;

                    mTargetContainers = targetContainers;

                    }

                command = TGlxCommandFactory::AddToContainerCommandLC(*sourceItems,

                        *mTargetContainers);

                CleanupStack::Pop(command);

                mNewMediaAdded = false;

                }

            else

                {

                MGlxMediaList::UnmarkAllL(aMediaList);

                }

            MGlxMediaList::UnmarkAllL(*targetMediaList);

            targetMediaList->Close();

            CleanupStack::PopAndDestroy(sourceItems);

            delete albumMediaModel;

        }

    OstTraceFunctionExit0( GLXCOMMANDHANDLERADDTOCONTAINER_CREATECOMMANDL_EXIT );

    return command;

    }

void GlxCommandHandlerAddToContainer::createNewMedia() const

    {

    OstTraceFunctionEntry0( GLXCOMMANDHANDLERADDTOCONTAINER_CREATENEWMEDIA_ENTRY );

    GlxCommandHandlerNewMedia* commandHandlerNewMedia =

            new GlxCommandHandlerNewMedia();

    TGlxMediaId newMediaId;

    while (error == KErrAlreadyExists)

        {

        HbMessageBox::warning("Name Already Exist!!!", new HbLabel(

                "New Album"));

        error = KErrNone;

        }

    if (error == KErrNone)

        {

        CMPXCollectionPath* path = CMPXCollectionPath::NewL();

        CleanupStack::PushL(path);

        path->AppendL(KGlxCollectionPluginAlbumsImplementationUid);

        path->AppendL(newMediaId.Value());

        CleanupStack::Pop(path);

        delete mTargetContainers;

        mTargetContainers = NULL;

        mTargetContainers = path;

        mNewMediaAdded = true;

        }

    OstTraceFunctionExit0( GLXCOMMANDHANDLERADDTOCONTAINER_CREATENEWMEDIA_EXIT );

    }

QString GlxCommandHandlerAddToContainer::CompletionTextL() const

    {

    }

QString GlxCommandHandlerAddToContainer::ProgressTextL() const

    {

    }