/*

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

 *     The source file of the operation service of file manager

 */

#include "fmoperationservice.h"

#include "fmoperationthread.h"

#include "fmbackupconfigloader.h"

#include "fmbackuprestorehandler.h"

#include "fmbkupengine.h"

#include "fmviewdetailsdialog.h"

#include "fmoperationresultprocesser.h"

#include "fmoperationcopy.h"

#include "fmoperationmove.h"

#include "fmoperationremove.h"

#include "fmoperationformat.h"

#include <hbaction.h>

FmOperationService::FmOperationService( QObject *parent ) : QObject( parent ),

        mCurrentOperation( 0 )

{

    mThread = new FmOperationThread( this );

    mThread->setObjectName( "operationThread" );

    mBackupRestoreHandler = new FmBackupRestoreHandler( this );

    mBackupRestoreHandler->setObjectName( "backupRestore" ) ;

    mOperationResultProcesser = new FmOperationResultProcesser( this );

    QMetaObject::connectSlotsByName( this );

}

FmOperationService::~FmOperationService()

{

    delete mThread;

    delete mBackupRestoreHandler;

}

bool FmOperationService::isRunning()

{

    if( mCurrentOperation ) {

        return true;

    } else {

        return false;

    }

}

int FmOperationService::asyncCopy( QStringList sourceList, QString targetPath )

{

    if ( isRunning() )

        return FmErrAlreadyStarted;

    Q_ASSERT( !mCurrentOperation );

    if( sourceList.empty() ) {

        return FmErrWrongParam;

    }

    mCurrentOperation = new FmOperationCopy( mThread, sourceList, targetPath );

    int ret = mThread->asyncCopy( mCurrentOperation );

    if( ret != FmErrNone ) {

        resetOperation();

    }

    return ret;

}

int FmOperationService::asyncMove( QStringList sourceList, QString targetPath )

{

    if ( isRunning() )

        return FmErrAlreadyStarted;

    Q_ASSERT( !mCurrentOperation );

    if( sourceList.empty() ) {

        return FmErrWrongParam;

    }

    mCurrentOperation = new FmOperationMove( mThread, sourceList, targetPath );

    int ret = mThread->asyncMove( mCurrentOperation );

    if( ret != FmErrNone ) {

        resetOperation();

    }

    return ret;

}

int FmOperationService::asyncRemove( QStringList pathList )

{

    if ( isRunning() )

        return FmErrAlreadyStarted;

    Q_ASSERT( !mCurrentOperation ); 

    mCurrentOperation = new FmOperationRemove( mThread, pathList );

    int ret = mThread->asyncRemove( mCurrentOperation );

    if( ret != FmErrNone ) {

        resetOperation();

    }

    return ret;

}

int FmOperationService::asyncFormat( QString driverName )

{

    if ( isRunning() )

        return FmErrAlreadyStarted;

    Q_ASSERT( !mCurrentOperation );

    mCurrentOperation = new FmOperationFormat( mThread, driverName );

    int ret = mThread->asyncFormat( mCurrentOperation );

    if( ret != FmErrNone ) {

        resetOperation();

    }

    return ret;

}

int FmOperationService::asyncViewDriveDetails( const QString driverName )

{

    if ( isRunning() )

        return FmErrAlreadyStarted;

    Q_ASSERT( !mCurrentOperation );

    mCurrentOperation = new FmOperationDriveDetails( mThread, driverName );

    int ret = mThread->asyncViewDriveDetails( mCurrentOperation );

    if( ret != FmErrNone ) {

        resetOperation();

    }

    return ret;

}

int FmOperationService::asyncViewFolderDetails( const QString folderPath )

{

    if ( isRunning() )

        return FmErrAlreadyStarted;

    Q_ASSERT( !mCurrentOperation );

    mCurrentOperation = new FmOperationFolderDetails( mThread, folderPath );

    int ret = mThread->asyncViewFolderDetails( mCurrentOperation );

    if( ret != FmErrNone ) {

        resetOperation();

    }

    return ret;

}

int FmOperationService::asyncBackup()

{   

    if ( isRunning() )

        return FmErrAlreadyStarted;

    Q_ASSERT( !mCurrentOperation );

    FmOperationBackup *operationBackup = new FmOperationBackup( mBackupRestoreHandler );

    mCurrentOperation = operationBackup;

    int ret = backupRestoreHandler()->startBackup( operationBackup );

    if( ret ){

        return FmErrNone;

    } else {

        resetOperation();

        return backupRestoreHandler()->error();

    }

}

int FmOperationService::asyncRestore( quint64 selection )

{

    if ( isRunning() )

        return FmErrAlreadyStarted;

    Q_ASSERT( !mCurrentOperation );

    FmOperationRestore* operationRestore = new FmOperationRestore( mBackupRestoreHandler, selection );

    mCurrentOperation = operationRestore;

    int ret = backupRestoreHandler()->startRestore( operationRestore );

    if( ret ){

        return FmErrNone;

    } else {

        resetOperation();

        return backupRestoreHandler()->error();

    }

}

int FmOperationService::syncDeleteBackup( quint64 selection )

{

    return mBackupRestoreHandler->deleteBackup( selection );

}

void FmOperationService::cancelOperation()

{

    switch( mCurrentOperation->operationType() )

    {

    case  EOperationTypeBackup:

        backupRestoreHandler()->cancelBackup();

        break;

    case EOperationTypeDriveDetails:

        mThread->stop();

        break;

    case EOperationTypeFolderDetails:

        mThread->stop();

        break;

    case EOperationTypeFormat:

        //can not cancel format

        break;

    case EOperationTypeCopy:

         mThread->stop();

        break;

    case EOperationTypeMove:

         mThread->stop();

        break;

    case EOperationTypeRemove:

         mThread->stop();

        break;

    default:

        Q_ASSERT( false );

    }    

}

int FmOperationService::syncSetVolume( const QString &driverName, const QString &volume )

{

    Q_UNUSED( driverName );

    Q_UNUSED( volume );

    return FmErrNone;

}

int FmOperationService::syncSetdDriverPassword( const QString &driverName,

                                               const QString &oldPassword, 

                                               const QString &newPassword )

{

    Q_UNUSED( driverName );

    Q_UNUSED( oldPassword );

    Q_UNUSED( newPassword );

    return FmErrNone;

}

int FmOperationService::syncRename( const QString &oldPath, const QString &newName )

{

    Q_UNUSED( oldPath );

    Q_UNUSED( newName );

    return FmErrNone;

}

int FmOperationService::syncLaunchFileOpen( const QString &filePath )

{

    return FmUtils::launchFile( filePath );

}

FmBackupRestoreHandler *FmOperationService::backupRestoreHandler()

{

    if( !mBackupRestoreHandler ) {

        mBackupRestoreHandler = new FmBackupRestoreHandler( this );

        QMetaObject::connectSlotsByName( this );

    }

    return mBackupRestoreHandler;

}

void FmOperationService::resetOperation()

{

   if( mCurrentOperation ) {

        delete mCurrentOperation;

        mCurrentOperation = 0;

    }

}

/////////////////////////////////////////////////////

///Thread

void FmOperationService::on_operationThread_askForRename( const QString &srcFile, QString *destFile )

{

    mOperationResultProcesser->onAskForRename(

        mCurrentOperation, srcFile, destFile );

}

void FmOperationService::on_operationThread_askForReplace( const QString &srcFile, const QString &destFile, bool *isAccepted )

{

    mOperationResultProcesser->onAskForReplace(

        mCurrentOperation, srcFile, destFile, isAccepted );

}

void FmOperationService::on_operationThread_refreshModel( const QString &path )

{

    emit refreshModel( mCurrentOperation, path );

}

void FmOperationService::on_operationThread_showNote( const char *noteString )

{

    mOperationResultProcesser->onShowNote( mCurrentOperation, noteString );

}

void FmOperationService::on_operationThread_notifyWaiting( bool cancelable )

{

    mOperationResultProcesser->onNotifyWaiting(

        mCurrentOperation, cancelable );

    emit notifyWaiting( mCurrentOperation, cancelable );

}

void FmOperationService::on_operationThread_notifyPreparing( bool cancelable )

{

    mOperationResultProcesser->onNotifyPreparing(

        mCurrentOperation, cancelable );

    emit notifyPreparing( mCurrentOperation, cancelable );

}

void FmOperationService::on_operationThread_notifyStart( bool cancelable, int maxSteps )

{

    mOperationResultProcesser->onNotifyStart(

        mCurrentOperation, cancelable, maxSteps );

    emit notifyStart( mCurrentOperation, cancelable, maxSteps );

}

void FmOperationService::on_operationThread_notifyProgress( int currentStep )

{

    mOperationResultProcesser->onNotifyProgress(

        mCurrentOperation, currentStep );

    emit notifyProgress( mCurrentOperation, currentStep );

}

void FmOperationService::on_operationThread_notifyFinish()

{

    mOperationResultProcesser->onNotifyFinish( mCurrentOperation );

    emit notifyFinish( mCurrentOperation );

    resetOperation();

}

void FmOperationService::on_operationThread_notifyError(int error, QString errString )

{

    mOperationResultProcesser->onNotifyError(

        mCurrentOperation, error, errString );

    emit notifyError( mCurrentOperation, error, errString );

    resetOperation();

}

void FmOperationService::on_operationThread_notifyCanceled()

{

    mOperationResultProcesser->onNotifyCanceled(

        mCurrentOperation );

    emit notifyCanceled( mCurrentOperation );

    resetOperation();

}

///

/////////////////////////////////////////////////////

/////////////////////////////////////////////////////

///BackupRestore

void FmOperationService::on_backupRestore_notifyPreparing( bool cancelable )

{

    mOperationResultProcesser->onNotifyPreparing(

        mCurrentOperation, cancelable );

     emit notifyPreparing( mCurrentOperation, cancelable );

}

void FmOperationService::on_backupRestore_notifyStart( bool cancelable, int maxSteps )

{

    mOperationResultProcesser->onNotifyStart(

        mCurrentOperation, cancelable, maxSteps );

    emit notifyStart( mCurrentOperation, cancelable, maxSteps );

}

void FmOperationService::on_backupRestore_notifyProgress( int currentStep )

{

    mOperationResultProcesser->onNotifyProgress(

        mCurrentOperation, currentStep );

    emit notifyProgress( mCurrentOperation, currentStep );

}

void FmOperationService::on_backupRestore_notifyFinish()

{

    mOperationResultProcesser->onNotifyFinish( mCurrentOperation );

    emit notifyFinish( mCurrentOperation );

    resetOperation();

}

void FmOperationService::on_backupRestore_notifyError(int error, QString errString )

{

    mOperationResultProcesser->onNotifyError(

        mCurrentOperation, error, errString );

    emit notifyError( mCurrentOperation, error, errString );

    resetOperation();

}

void FmOperationService::on_backupRestore_notifyCanceled()

{

    mOperationResultProcesser->onNotifyCanceled(

        mCurrentOperation );

    emit notifyCanceled( mCurrentOperation );

    resetOperation();

}

///

/////////////////////////////////////////////////////