/*

* 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

#include <QApplication>

#include <QDebug>

#include <QItemSelectionModel>

#include <hbnotificationdialog.h>

#include <QProcess>

#include <hbinstance.h>

#include <HbActivityManager.h>

#include <hbapplication.h>

//user includes

#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 "glxtnobserver.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 "glxplugincommandid.hrh"

#include "glxlog.h"

#include "glxtracer.h"

GlxStateManager::GlxStateManager() 

    : mAllMediaModel( NULL ), 

      mAlbumGridMediaModel( NULL ),

      mAlbumMediaModel( NULL ),

      mImageviewerMediaModel( NULL ), 

      mCurrentModel( NULL ), 

      mCurrentState( NULL ), 

      mActionHandler( NULL ),

      mTNObserver ( NULL ),

      isProgressbarRunning ( false )

{

    qDebug("GlxStateManager::GlxStateManager");

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

        mViewManager = new GlxViewManager();

    }

    mTNObserver = new GlxTNObserver();

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

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

    connect ( mTNObserver, SIGNAL( leftTNCount( int ) ), this, SLOT( updateTNProgress( int ) ) );

    connect ( qobject_cast<HbApplication*>(qApp), SIGNAL (aboutToQuit()), this, SLOT(saveData()));

	//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;

}

bool GlxStateManager::eventFilter(QObject *obj, QEvent *event)

{

    TRACER("GlxStateManager::eventFilter() ");

    GLX_LOG_INFO1("GlxStateManager::eventFilter() %d event type", event->type());

    if ( event->type() ==  QEvent::ApplicationActivate ) {

        mTNObserver->startTNMDaemon();

    }

    if ( event->type() ==  QEvent::ApplicationDeactivate ) {

        mTNObserver->stopTNMDaemon();

    }

    return QObject::eventFilter(obj, event);

}

void GlxStateManager::launchApplication()

{

    qDebug("GlxStateManager::launchApplication");   

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

    }

         qDebug("launchapplication::Remove activity failed" );

}

bool GlxStateManager::launchActivity()

{

    HbApplication* app = qobject_cast<HbApplication*>(qApp);

    bool ok = app->activityManager()->waitActivity();

    if ( !ok )

    {

        qDebug("subscribing to activity manager failed" );

    }

    QVariant data = app->activityManager()->activityData( "PhotosMainView" );

    QByteArray serializedModel = data.toByteArray();

    QDataStream stream(&serializedModel, QIODevice::ReadOnly);

    //Fetch the data from the activity Manager

    mCurrentState = createState(stateId);

    createModel( stateId);

	/*Model might not be populated yet to set the visibleWindowIndex right away.

	*So, let us store the visible index as a temporary Variable, so that  visible Window Index 

	*is set once the model is populated.

    */

    mViewManager->launchApplication(stateId, mCurrentModel); 

    return true;

}

void GlxStateManager::launchFromExternal()

{

    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();

}

void GlxStateManager::updateTNProgress( int count)

{    

    TRACER("GlxStateManager::updateTNProgress() ");

    if ( mCurrentModel && ( count > 5  ) ) { 

         goBack( GLX_GRIDVIEW_ID, ALL_ITEM_S ) ;

         cleanAllModel();

         launchProgressDialog();

    }

    if ( isProgressbarRunning ){

        if ( count == 0 ) {

            vanishProgressDialog();

        }

        else {

            mViewManager->updateProgressDialog( count );

        }

    }   

}

void GlxStateManager::saveData()

{

    if( (mCurrentState->id() == GLX_GRIDVIEW_ID && mCurrentState->state() == ALL_ITEM_S) || mCurrentState->id() == GLX_LISTVIEW_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() ;

        return ;

    }

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

    //if current state and it internal state is same then no need to do any thing

    if ( mCurrentState->id() == stateId  && mCurrentState->state() == internalState ) {

        return ;

    }

    GlxState *state = mCurrentState;

    while ( mCurrentState ) {

        if ( mCurrentState->id() == stateId  && mCurrentState->state() == internalState ) {

            break ;           

        }

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

        delete state; //delete the current state

        state = mCurrentState;    

    }

    //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()

{

    TRACER("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

    }

}

void GlxStateManager::cleanAllModel()

{

    TRACER("GlxStateManager::cleanAllModel() ");

    delete mAllMediaModel ;

    mAllMediaModel = NULL ;

    delete mAlbumMediaModel ; 

    mAlbumMediaModel = NULL ;

    delete mAlbumGridMediaModel ;

    mAlbumGridMediaModel = NULL ;

    delete mImageviewerMediaModel ;

    mImageviewerMediaModel = NULL ;

    mCurrentModel = NULL ;

}

void GlxStateManager::launchProgressDialog()

{

    TRACER("GlxStateManager::launchProgressDialog() ");

    QCoreApplication::instance()->installEventFilter( this );

    isProgressbarRunning = true ;

}

void GlxStateManager::vanishProgressDialog()

{

    TRACER("GlxStateManager::vanishProgressDialog() ");

    QCoreApplication::instance()->removeEventFilter( this );

}

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 );