/*

* 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:   ?Description

*

*/

#include <glxstatemanager.h>

#include <glxviewmanager.h>

#include <glxviewids.h>

#include <glxmediamodel.h>

#include <glxgridstate.h>

#include <glxliststate.h>

#include <glxfullscreenstate.h>

#include <glxdetailstate.h>

#include <glxslideshowsettingsstate.h>

#include <glxslideshowstate.h>

#include <glxmodelparm.h>

#include <glxcollectionpluginall.hrh>

#include <glxcollectionplugincamera.hrh>

#include <glxcollectionpluginalbums.hrh>

#include <glxcollectionpluginimageviewer.hrh>

#include <glxexternalutility.h>

#include <glxalbummodel.h>

#include <glxloggerenabler.h>

#include <glxmediaid.h>

#include <glxactionhandler.h>

#include <glxcommandhandlers.hrh>

#include <QApplication>

#include <glxplugincommandid.hrh>

#include <QDebug>

#include <QItemSelectionModel>

#include <hbnotificationdialog.h>

#include <QProcess>

GlxStateManager::GlxStateManager() : mAllMediaModel(NULL), mAlbumGridMediaModel(NULL),

            mAlbumMediaModel(NULL),mImageviewerMediaModel(NULL), mCurrentModel (NULL), mCurrentState (NULL), mActionHandler (NULL)

{

    qDebug("GlxStateManager::GlxStateManager");

    PERFORMANCE_ADV ( d1, "view manager creation time") {

        mViewManager = new GlxViewManager();

    }

    connect ( this, SIGNAL( setupItemsSignal() ), this, SLOT( setupItems() ), Qt::QueuedConnection );

    connect ( mViewManager, SIGNAL(actionTriggered(qint32 )), this, SLOT(actionTriggered(qint32 )), Qt::QueuedConnection );

	//TO:DO TBD through exception when it is null

}

void GlxStateManager::enterMarkingMode()

{

    mViewManager->enterMarkingMode(mCurrentState->id());

}

void GlxStateManager::exitMarkingMode()

{

    mViewManager->exitMarkingMode(mCurrentState->id());

}

bool GlxStateManager::executeCommand(qint32 commandId)

{

    qDebug( "GlxStateManager::executeCommand() : command ID %d", commandId);

    QItemSelectionModel * selectionModel = mViewManager->getSelectionModel(mCurrentState->id());

    if ( selectionModel == NULL )

        return FALSE;

    QModelIndexList indexList = selectionModel->selectedIndexes();

    //if no item is selected then do nothing

    if (indexList.count() == 0) 

        return FALSE;

    for ( int i = 0; i < indexList.count(); i++) {

        qDebug( "GlxGridView::doneAction() : index %d", indexList[i].row());            

        mCurrentModel->setData( indexList[i], indexList[i].row(), GlxSelectedIndexRole );

    }

    mActionHandler->handleAction(commandId, mCollectionId,indexList);

    return TRUE;

}

void GlxStateManager::launchApplication()

{

   qDebug("GlxStateManager::launchApplication");   

   //To:Do use it in future once performance code is removed nextState(GLX_GRIDVIEW_ID, ALL_ITEM_S)

   mCurrentState = createState(GLX_GRIDVIEW_ID);

   mCurrentState->setState(ALL_ITEM_S);

   PERFORMANCE_ADV ( d1, "Media model creation time" ) {

       createModel(GLX_GRIDVIEW_ID);

   }

   PERFORMANCE_ADV ( d2, "Grid View Launch time" ) {

       mViewManager->launchApplication( GLX_GRIDVIEW_ID, mCurrentModel);

   }   

}

void GlxStateManager::launchFromExternal()

{

    qDebug("GlxStateManager::launchApplication");

    mCurrentState = createState(GLX_FULLSCREENVIEW_ID);

    mCurrentState->setState(IMAGEVIEWER_S);

    createModel(GLX_FULLSCREENVIEW_ID);

    mCurrentModel->setData( mCurrentModel->index(0,0), 0, GlxFocusIndexRole );

    mViewManager->launchApplication( GLX_FULLSCREENVIEW_ID, mCurrentModel);

	setupItems();

}

void GlxStateManager::actionTriggered(qint32 id)

{

    qDebug("GlxStateManager::actionTriggered action ID = %d", id);

    mCurrentState->eventHandler(id);

    if (id != EGlxCmdHandled ) {

        eventHandler(id);

    }

}

void GlxStateManager::setupItems()

{    

    qDebug("GlxStateManager::setupItems()");

    mActionHandler = new GlxActionHandler();

    connect ( mViewManager, SIGNAL(externalCommand(int )), this, SIGNAL(externalCommand(int )) );

    mViewManager->setupItems();

    mViewManager->updateToolBarIcon(GLX_ALL_ACTION_ID);

}

void GlxStateManager::nextState(qint32 state, int internalState)

{

    qDebug("GlxStateManager::nextState next state = %u", state);

    GlxEffect effect = NO_EFFECT ;

    GlxViewEffect viewEffect = NO_VIEW ;

    PERFORMANCE ( d1, State Creation Time ) {

        mCurrentState = createState(state); //create a new state

        mCurrentState->setState(internalState); 

    }

    createModel(state); //model should created after the internal state was set.

    PERFORMANCE ( d2, view launch time ) {

        mCurrentState->setTranstionParameter( FORWARD_DIR, effect, viewEffect); // to run the transtion effect

        if ( viewEffect == NO_VIEW ) {

            mViewManager->launchView( state, mCurrentModel );

        }

        else {

            mViewManager->launchView( state, mCurrentModel, effect, viewEffect);

        }

    }

}

void GlxStateManager::previousState()

{

    qDebug("GlxStateManager::previousState");

    GlxEffect effect = NO_EFFECT ;

    GlxViewEffect viewEffect = NO_VIEW ;

    GlxState *state = mCurrentState; // To delete the current state later  

    if ( mCurrentState->previousState() == NULL ) { //In the case only one state in stack then exit from the application

        exitApplication() ;

        mCurrentState = NULL;

    }

    else {

        //effect parameter should be set here other wise there is no way to know from where it come from

        mCurrentState->setTranstionParameter( BACKWARD_DIR, effect, viewEffect);

        mCurrentState = mCurrentState->previousState(); //get the pervious state

        createModel( mCurrentState->id(), BACKWARD_DIR ); 

        if ( viewEffect == NO_VIEW ) {

            mViewManager->launchView( mCurrentState->id(), mCurrentModel );

        }

        else {

            mViewManager->launchView( mCurrentState->id(), mCurrentModel, effect, viewEffect);

        }

    }

    delete state;

}

void GlxStateManager::goBack(qint32 stateId, int internalState)

{

    qDebug("GlxStateManager::goBack()");

    GlxState *state = mCurrentState;

    do {

        mCurrentState = mCurrentState->previousState(); // set pervious state to the current state

        delete state; //delete the current state

        state = mCurrentState;

    }

    while ( mCurrentState && mCurrentState->id() != stateId ); //check, cuurent state is a new state

    //case when new state is not hierarchy then create a new state

    if ( mCurrentState == NULL ) {

        mCurrentState = createState(stateId);

        mCurrentState->setState( internalState );

    }   

    qDebug("GlxStateManager::goBack() state %u", mCurrentState);

    createModel( mCurrentState->id() ); //model should created after the internal state was set.

    mViewManager->launchView( mCurrentState->id(), mCurrentModel );   

}

void GlxStateManager::changeState(qint32 stateId, int internalState)

{

    qDebug("GlxStateManager::changeState %d", stateId);	

    GlxState *state = mCurrentState;

    GlxEffect effect = NO_EFFECT ;

    GlxViewEffect viewEffect = NO_VIEW ;

    mCurrentState = mCurrentState->previousState();//pervious state of current state become the pervious state of new state 

    mCurrentState = createState(stateId);

    mCurrentState->setState( internalState );

    createModel( stateId ); //model should created after the internal state was set.

    mCurrentState->setTranstionParameter( NO_DIR, effect, viewEffect); //set the transition parameter    

    if ( viewEffect == NO_VIEW ) {

        mViewManager->launchView( mCurrentState->id(), mCurrentModel );

    }

    else {

        mViewManager->launchView( mCurrentState->id(), mCurrentModel, effect, viewEffect);

    }

    delete state;

}

void GlxStateManager::removeCurrentModel()

{

    if ( mCurrentModel == mAllMediaModel ) {

        qDebug("GlxStateManager::removeCurrentModel() remove all media model");	

        delete mAllMediaModel ;

        mAllMediaModel = NULL ;

        mCurrentModel = NULL ;

    }

    else if ( mCurrentModel == mAlbumGridMediaModel ) {

        qDebug("GlxStateManager::removeCurrentModel() remove album grid media model");	

        delete mAlbumGridMediaModel ;

        mAlbumGridMediaModel = NULL ;

        mCurrentModel = NULL ;

    }

    else if ( mCurrentModel == mAlbumMediaModel ) {

        qDebug("GlxStateManager::removeCurrentModel() remove  model");	

        delete mAlbumMediaModel ;

        mAlbumMediaModel = NULL ;

        mCurrentModel = NULL ;

    }

    else {

    	qDebug("GlxStateManager::removeCurrentModel() do nothing");

    	//do nothing

    }

}

GlxState * GlxStateManager::createState(qint32 stateId)

{

    qDebug("GlxStateManager::createState state id = %d", stateId);

    switch( stateId ) {    

    case GLX_GRIDVIEW_ID :

        return new GlxGridState( this, mCurrentState );

    case GLX_LISTVIEW_ID :

        return new GlxListState( mCurrentState );    	

    case GLX_FULLSCREENVIEW_ID :

        return new GlxFullScreenState( mCurrentState );

    case GLX_DETAILSVIEW_ID:

        return new GlxDetailState( mCurrentState );

    case GLX_SLIDESHOWVIEW_ID :

        return new GlxSlideShowState( this, mCurrentState );

    case GLX_SLIDESHOWSETTINGSVIEW_ID :

        return new GlxSlideShowSettingsState(this, mCurrentState );

    default :

        return NULL;		

    } 

}

void GlxStateManager::createModel(qint32 stateId, NavigationDir dir)

{

    switch( stateId ) {

    case GLX_GRIDVIEW_ID :

        createGridModel( mCurrentState->state(), dir );

        break;

    case GLX_LISTVIEW_ID :

    	//To:Do change the code when integrate the album list model

        if (mAlbumMediaModel == NULL) {

            GlxModelParm modelParm (KGlxCollectionPluginAlbumsImplementationUid, 0);

            mAlbumMediaModel = new GlxAlbumModel (modelParm);

        }

        mCurrentModel = mAlbumMediaModel;

        mCollectionId = KGlxCollectionPluginAlbumsImplementationUid;

        mCurrentModel->setData(QModelIndex(), (int)GlxContextPtList, GlxContextRole );

        mViewManager->updateToolBarIcon(GLX_ALBUM_ACTION_ID);

        break;

    case GLX_FULLSCREENVIEW_ID :

		if ( mCurrentState->state() == IMAGEVIEWER_S) {

            GlxModelParm modelParm (KGlxCollectionPluginImageViewerImplementationUid, 0);

            mCurrentModel = mImageviewerMediaModel = new GlxMediaModel (modelParm);

            mCollectionId = KGlxCollectionPluginImageViewerImplementationUid;

		}

        else if ( mCurrentState->state() == EXTERNAL_S) {

            if(!mAllMediaModel) {

                GlxModelParm modelParm (KGlxCollectionPluginAllImplementationUid, 0);

                mCurrentModel = mAllMediaModel = new GlxMediaModel (modelParm);

            }

            else {

                mCurrentModel = mAllMediaModel;

            }

            mCollectionId = KGlxCollectionPluginAllImplementationUid;

        }

		setFullScreenContext();

        break;

    case GLX_DETAILSVIEW_ID :

        setFullScreenContext();

        break;

    case GLX_SLIDESHOWVIEW_ID :

        if ( mCurrentState->state() == SLIDESHOW_ALBUM_ITEM_S ) {

            GlxModelParm modelParm ( KGlxAlbumsMediaId , 0);

            mCurrentModel = mAlbumGridMediaModel = new GlxMediaModel( modelParm );

        }

        setFullScreenContext();

        break;

    default :

        break;

    }

    mCurrentModel->setData( QModelIndex(), mCurrentState->state(), GlxSubStateRole );

}

void GlxStateManager::createGridModel(int internalState, NavigationDir dir)

{

    GlxModelParm modelParm;

    GlxContextMode mode;

    if ( mViewManager->orientation() == Qt::Horizontal ) {

        mode = GlxContextLsGrid ;

    }

    else {

        mode = GlxContextPtGrid ;

    }

    switch( internalState) {

    case ALL_ITEM_S :

        if ( mAllMediaModel == NULL ) {

            modelParm.setCollection( KGlxCollectionPluginAllImplementationUid );

            modelParm.setDepth(0);

            modelParm.setContextMode( mode ) ;

            mAllMediaModel = new GlxMediaModel( modelParm );

        }

        mCollectionId = KGlxCollectionPluginAllImplementationUid;

        mCurrentModel = mAllMediaModel;

        mViewManager->updateToolBarIcon(GLX_ALL_ACTION_ID);

        break;

    case ALBUM_ITEM_S :

        if ( dir != BACKWARD_DIR ) { 

            modelParm.setCollection( KGlxAlbumsMediaId );

            modelParm.setDepth(0);

            modelParm.setContextMode( mode ) ;

            mAlbumGridMediaModel = new GlxMediaModel( modelParm );

        }               

        mCollectionId = KGlxAlbumsMediaId;

        mCurrentModel = mAlbumGridMediaModel ;

        mViewManager->updateToolBarIcon(NO_ACTION_ID);

        break;

    default :

        break;

    }

    mCurrentModel->setData(QModelIndex(), (int)mode, GlxContextRole );

}

void GlxStateManager::setFullScreenContext()

{

        mCurrentModel->setData(QModelIndex(), (int)GlxContextLsFs, GlxContextRole );

    }

    else {

        mCurrentModel->setData(QModelIndex(), (int)GlxContextPtFs, GlxContextRole );

    }    

}

void GlxStateManager::eventHandler(qint32 &id)

{

    qDebug("GlxStateManager::eventHandler action id = %d", id);

    switch(id) {

    case EGlxCmdAllGridOpen :

        changeState( GLX_GRIDVIEW_ID, ALL_ITEM_S );

        id = EGlxCmdHandled;

        break;

    case EGlxCmdAlbumListOpen:

        changeState( GLX_LISTVIEW_ID, -1 );

        id = EGlxCmdHandled;

        break;

    case EGlxCmdAlbumGridOpen:

        nextState( GLX_GRIDVIEW_ID, ALBUM_ITEM_S );

        id = EGlxCmdHandled;

        break;

    case EGlxCmdFirstSlideshow :

        //play the slide show with first item

        mCurrentModel->setData( mCurrentModel->index(0, 0), 0, GlxFocusIndexRole );

        nextState( GLX_SLIDESHOWVIEW_ID, SLIDESHOW_GRID_ITEM_S );

        id = EGlxCmdHandled;

        break;

    case EGlxCmdSelectSlideshow:

        //play the slide show with selected item

        nextState( GLX_SLIDESHOWVIEW_ID, SLIDESHOW_GRID_ITEM_S );

        id = EGlxCmdHandled;

        break;

    case EGlxCmdAlbumSlideShow:

        //play the slide show for a album

        nextState( GLX_SLIDESHOWVIEW_ID, SLIDESHOW_ALBUM_ITEM_S );

        id = EGlxCmdHandled;

        break;

    case EGlxCmdSlideshowSettings:

        nextState(GLX_SLIDESHOWSETTINGSVIEW_ID,-1 );

        id = EGlxCmdHandled;

        break;

    case EGlxCmdDetailsOpen:

        qDebug("GlxStateManager::eventHandler EGlxCmdDetailsOpen");

        nextState( GLX_DETAILSVIEW_ID, -1 );

        id = EGlxCmdHandled;

        break;

    case EGlxCmdEmptyData :

        goBack(GLX_GRIDVIEW_ID, NO_GRID_S);

        id = EGlxCmdHandled;

        break;

    case EGlxCmdBack :

    	previousState();

    	id = EGlxCmdHandled;

    	break;

    case EGlxCmdCameraOpen:

		{

		QProcess::startDetached(QString("cxui.exe"));

		id = EGlxCmdHandled;

		}

        break;	

    case EGlxCmdOviOpen:

		{

		HbNotificationDialog::launchDialog("Not Implemented");

        id = EGlxCmdHandled;

		}

        break;	

   case EGlxCmdDelete :

		{

        GlxExternalData* externalItems = GlxExternalUtility::instance()->getExternalData();

        if(externalItems){

            QVariant variant = mCurrentModel->data( mCurrentModel->index(0,0), GlxFocusIndexRole );    

            if ( variant.isValid() &&  variant.canConvert<int> () ) {

                int selIndex = variant.value<int>(); 

                int externalDataCount = externalItems->count();

                if(selIndex < externalDataCount){

                    GlxInterfaceParams tmp = externalItems->value(selIndex);

                    tmp.isSelected = true;

                    externalItems->replace(selIndex,tmp);

                    emit externalCommand(EGlxPluginCmdDelete);

                    return;

                }

            }

        }

        mActionHandler->handleAction(id,mCollectionId);

		}

        break;

   case EGlxCmdMarkAll:

   case EGlxCmdUnMarkAll:

       mViewManager->handleUserAction(mCurrentState->id(), id);

       id = EGlxCmdHandled;

       break;

   case EGlxCmdSetupItem :

       emit setupItemsSignal();

       break;

    default :

        mActionHandler->handleAction(id,mCollectionId);

    	break;

    }	

}

void GlxStateManager::exitApplication()

{

    if ( mCurrentState->id( ) == GLX_FULLSCREENVIEW_ID && mCurrentState->state() == EXTERNAL_S ) {

        emit externalCommand(EGlxPluginCmdBack);

    }

    else {

    //To:Do memory cleanup

        QApplication::quit();

    }    

}

GlxStateManager::~GlxStateManager()

{

    qDebug("GlxStateManager::~GlxStateManager");

    delete mAllMediaModel;

    delete mAlbumMediaModel;