/*
* 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 <hbdialog.h>
#include <hbmessagebox.h>

#include <glxcommandhandlers.hrh>
#include "glxlocalisationstrings.h"

#include "OstTraceDefinitions.h"
#ifdef OST_TRACE_COMPILER_IN_USE
#include "glxcommandhandleraddtocontainerTraces.h"
#endif


TInt GlxCommandHandlerAddToContainer::iSelectionCount = 0;

const TInt KSelectionPopupListHierarchy = 5;
const TInt KListPrefferedHeight = 400;

GlxAlbumSelectionPopup::GlxAlbumSelectionPopup() 
    : mPopupDlg( 0 ), 
      mSelectionModel( 0 ),
      mEventLoop( 0 ),
      mResult( false )
{
}

GlxAlbumSelectionPopup::~GlxAlbumSelectionPopup()
{
}

QModelIndexList GlxAlbumSelectionPopup::GetSelectionList(GlxAlbumModel *model, bool *ok) 
{
    // Create a popup
    HbDialog popup;
    QEventLoop eventLoop;
    mEventLoop = &eventLoop;
    
    popup.setPreferredHeight( KListPrefferedHeight );
    // Set dismiss policy that determines what tap events will cause the popup
    // to be dismissed
    popup.setDismissPolicy(HbDialog::NoDismiss);

    // Set timeout to zero to wait user to either click Ok or Cancel
    popup.setTimeout(HbDialog::NoTimeout);
    popup.setHeadingWidget( new HbLabel("Select Album") );      
    
    mPopupDlg = &popup;
    HbListView *listview = new HbListView();
    listview->setSelectionMode(HbAbstractItemView::MultiSelection);
    listview->setModel(model);
    mSelectionModel = listview->selectionModel() ;
    connect( mSelectionModel, SIGNAL( selectionChanged( const QItemSelection &, const QItemSelection& ) ), this, SLOT( changeButtonText() ) );
    
    HbAction *primary = new HbAction( "New" );
    popup.addAction( primary ) ;

    HbAction *secondary = new HbAction( GLX_BUTTON_CANCEL );
    popup.addAction( secondary );
    
    popup.setContentWidget( listview ); //ownership transfer
    listview->show();
    
    popup.open( this, SLOT( dialogClosed( HbAction* ) ) ); 
    eventLoop.exec( );
    mEventLoop = 0 ;
    if ( ok ) {
        *ok = mResult ;
    }
    QModelIndexList selectedIndexes = mSelectionModel->selectedIndexes();       
    disconnect( mSelectionModel, SIGNAL( selectionChanged( const QItemSelection &, const QItemSelection& ) ), this, SLOT( changeButtonText() ) );
    delete primary;
    delete secondary;

    return selectedIndexes;
}

void GlxAlbumSelectionPopup::changeButtonText()
{
    if ( mSelectionModel->selectedIndexes().count() ) {
        mPopupDlg->actions().first()->setText( GLX_BUTTON_OK );
    }
    else {
        mPopupDlg->actions().first()->setText("New");
    }    
}


void GlxAlbumSelectionPopup::dialogClosed(HbAction *action)
{
    HbDialog *dlg = static_cast<HbDialog*>(sender());
    if( action == dlg->actions().first() ) {
        mResult = true ;
    }
    else {
        mResult = false ;
    }
    if ( mEventLoop && mEventLoop->isRunning( ) ) {
        mEventLoop->exit( 0 );
    }
}

GlxCommandHandlerAddToContainer::GlxCommandHandlerAddToContainer() :
    mNewMediaAdded(false)
    {
    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 );
    iSelectionCount = 0;
    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;
    TInt error = commandHandlerNewMedia->ExecuteLD(newMediaId);

    while (error == KErrAlreadyExists)
        {
        HbMessageBox::warning("Name Already Exist!!!", new HbLabel(
                "New Album"));
        error = KErrNone;
        error = commandHandlerNewMedia->ExecuteLD(newMediaId);
        }

    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
    {
	return QString();	
    }

QString GlxCommandHandlerAddToContainer::ProgressTextL() const
    {
    return QString("Adding album...");
    }