/*
* 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 <QDebug>
#include <glxfilterfactory.h>


#include <hblistwidget.h>
#include <hbview.h>
#include <hbpushbutton.h>
#include <QGraphicsGridLayout>
#include <hbdialog.h>

TInt GlxCommandHandlerAddToContainer::iSelectionCount = 0;

const TInt KSelectionPopupListHierarchy = 5;

GlxQueryContentWidget::GlxQueryContentWidget(QGraphicsItem* parent):QGraphicsWidget(parent),
						mButton(0), mListView(0), mGrid(0)
{
    mGrid = new QGraphicsGridLayout;
    mGrid->setContentsMargins(0,0,0,0);
    
    mButton = new HbPushButton("New Item");      
    mListView = new HbListView(this);
    mListView->setSelectionMode(HbAbstractItemView::MultiSelection);
    mListView->setMinimumSize(QSize(360, 180));
    mListView->setMaximumSize(QSize(360, 180));

    mGrid->addItem(mButton, 0,0);
    mGrid->addItem(mListView, 1,0);
    setLayout(mGrid); //ownership transfered
    
    setPreferredWidth(360);
}

GlxQueryContentWidget::~GlxQueryContentWidget()
{
    qDebug("GlxQueryContentWidget::~GlxQueryContentWidget() ");
    delete mListView;
    delete mButton;
    qDebug("GlxQueryContentWidget::~GlxQueryContentWidget() exit");
}

GlxCommandHandlerAddToContainer::GlxCommandHandlerAddToContainer():mNewMediaAdded(false)
{
    mTargetContainers = NULL;
    qDebug("GlxCommandHandlerAddToContainer::GlxCommandHandlerAddToContainer() ");
}

GlxCommandHandlerAddToContainer::~GlxCommandHandlerAddToContainer()
{
    delete mTargetContainers;
    qDebug("GlxCommandHandlerAddToContainer::~GlxCommandHandlerAddToContainer() ");
}

CMPXCommand* GlxCommandHandlerAddToContainer::CreateCommandL(TInt aCommandId, MGlxMediaList& aMediaList, TBool& aConsume) const 
{
    qDebug("GlxCommandHandlerAddToContainer::CreateCommandL");
    iSelectionCount = 0;

    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 );
    
    //QModelIndexList selectedModelIndexes;
    QModelIndexList modelList = GetSelectionList(albumMediaModel,&ok);
    
    CMPXCommand* command = NULL;
    qDebug("GlxCommandHandlerAddToContainer::CreateCommandL OK %d new media added %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;
    }

    MGlxMediaList::UnmarkAllL(*targetMediaList);
    targetMediaList->Close();
    CleanupStack::PopAndDestroy(sourceItems);
    delete albumMediaModel;
    return command;
}

QModelIndexList GlxCommandHandlerAddToContainer::GetSelectionList(GlxAlbumModel *model,bool *ok) const
{
    // Create a popup
    HbDialog popup;

    // 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("Selection List"));

    GlxQueryContentWidget* view = new GlxQueryContentWidget();
    view->mListView->setModel(model);
    
    qDebug("GlxCommandHandlerAddToContainer::GetSelectionList model setting done row count %d",model->rowCount() );
    connect(view->mButton, SIGNAL(released ()), &popup, SLOT(close()));
    connect(view->mButton, SIGNAL(released ()), this, SLOT(createNewMedia()));

    HbAction *primary = new HbAction("OK"); 
    popup.setPrimaryAction(primary);

    HbAction *secondary = new HbAction("Cancel"); 
    popup.setSecondaryAction(secondary);
    
    popup.setContentWidget(view); //ownership transfer
    qDebug("GlxCommandHandlerAddToContainer::GetSelectionList after popup.setContentWidget ");
    view->mListView->show();
    QModelIndexList selectedIndexes;
    
    do {
        HbAction* action = popup.exec();
        if(action == popup.primaryAction()){
            *ok = true;
        }
        else {
            *ok = false;
        }
        
        qDebug("GlxCommandHandlerAddToContainer::GetSelectionList after exec user action %d ", *ok);
    
        if( *ok ) {
            GlxQueryContentWidget* cWidget = qobject_cast<GlxQueryContentWidget*>(popup.contentWidget());
            QItemSelectionModel* selModel = cWidget->mListView->selectionModel();
            qDebug("GlxCommandHandlerAddToContainer::GetSelectionList selection model %d", selModel);
            selectedIndexes = selModel->selectedIndexes();
        }
    }  while ( *ok && selectedIndexes.count() == 0); //continue until user select one album list or new item

    delete primary;
    delete secondary;
    qDebug("GlxCommandHandlerAddToContainer::GetSelectionList exit ");  
    
    return selectedIndexes;
}

void GlxCommandHandlerAddToContainer::createNewMedia()
{
    qDebug("GlxCommandHandlerAddToContainer::createNewMedia ");
    GlxCommandHandlerNewMedia* commandHandlerNewMedia = new GlxCommandHandlerNewMedia();
    TGlxMediaId newMediaId;
    TInt 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;
    }
}