/*

* 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 "fmoperationresultprocesser.h"

#include "fmoperationbase.h"

#include "fmoperationservice.h"

#include "fmoperationformat.h"

#include "fmbkupengine.h"

#include "fmbackupsettings.h"

#include "fmbackuprestorehandler.h"

#include "fmoperationviewdetails.h"

#include "fmviewdetailsdialog.h"

#include "fmdlgutils.h"

#include "fmutils.h"

#include <hbaction.h>

#include <hbprogressdialog.h>

#include <hbaction.h>

#include <hbglobal.h>

#include <QFileInfo>

/*

 * Constructs one operation result processer with \a operation Service.

 */

FmOperationResultProcesser::FmOperationResultProcesser( FmOperationService *operationService )

    : mOperationService( operationService ), mNote( 0 )

{

}

/*

 * Destructs the operation result processer

 */

FmOperationResultProcesser::~FmOperationResultProcesser(void)

{

}

/*

 * Called by operation service on_operation_askForRename

 * \sa FmOperationService::on_operation_askForRename

 */

void FmOperationResultProcesser::onAskForRename(

    FmOperationBase* operationBase, const QString &srcFile, QString *destFile )

{

    Q_UNUSED( operationBase );

    int maxFileNameLength = FmUtils::getMaxFileNameLength();

    QString questionText = QString( "file " ) +

        srcFile + QString( " already exist, please rename:" );

    QString value;   

    QFileInfo srcFileInfo(srcFile);

    QStringList regExpList = (QStringList() << Regex_ValidFileFolderName << Regex_ValidNotEndWithDot );

    bool ret = FmDlgUtils::showTextQuery( questionText, value, regExpList,

        maxFileNameLength, QString(), false );

    while ( ret ) {

        // remove whitespace from the start and the end.

        value = value.trimmed();

        QString newTargetPath = FmUtils::fillPathWithSplash(

                                srcFileInfo.absolutePath() ) + value;

        QString errString;

        // check if name/path is available for use.

        if( !FmUtils::checkNewFolderOrFile( value, newTargetPath, errString ) ) {

            FmDlgUtils::warning( errString, HbMessageBox::Ok, true );

            ret = FmDlgUtils::showTextQuery( questionText, value, regExpList, maxFileNameLength, QString(), false );

            continue;

        } else {

            break;

        }

    }   

	if( ret ) {

        // Got file/folder name for rename, save it to destFile

		*destFile = value;

        QFileInfo destFileInfo( *destFile );

        if ( ( srcFileInfo.suffix().compare( destFileInfo.suffix(), Qt::CaseInsensitive ) != 0 )

            && srcFileInfo.isFile() ) {

            // popup warning when the suffix of file is changed.

        }   

	}

}

/*

 * Called by operation service on_operation_askForReplace

 * \sa FmOperationService::on_operation_askForReplace

 */

void FmOperationResultProcesser::onAskForReplace(

    FmOperationBase* operationBase, const QString &srcFile, const QString &destFile, bool *isAccepted )

{

    Q_UNUSED( operationBase );

    Q_UNUSED( destFile );

    QString questionText = QString( "file " ) +

        srcFile + QString( " already exist, replace it?" );

    if( FmDlgUtils::question( questionText ) ) {

        *isAccepted = true;

    } else {

        *isAccepted = false;

    }

}

/*

 * Called by operation service on_operation_showNote

 * \sa FmOperationService::on_operation_showNote

 */

void FmOperationResultProcesser::onShowNote( FmOperationBase* operationBase, const char *noteString )

{

    Q_UNUSED( operationBase );

    FmDlgUtils::information(hbTrId(noteString), HbMessageBox::Ok, true );

}

/*

 * Called by operation service on_operation_notifyWaiting

 * \sa FmOperationService::on_operation_notifyWaiting

 */

void FmOperationResultProcesser::onNotifyWaiting( FmOperationBase* operationBase, bool cancelable )

{

    QString title = hbTrId("Operation");

    switch( operationBase->operationType() )

    {

    case FmOperationService::EOperationTypeBackup:

        title = hbTrId("backuping");

        break;

    case FmOperationService::EOperationTypeRestore:

        title = hbTrId("restoring");

        break;

      case FmOperationService::EOperationTypeDriveDetails:

          title = hbTrId( "Scaning memory..." );

        break;

    case FmOperationService::EOperationTypeFolderDetails:

        title = hbTrId( "Scaning folder..." );

        break;

    default:

        break;

    }

    showWaiting( title, cancelable );

}

/*

 * Called by operation service on_operation_notifyPreparing

 * \sa FmOperationService::on_operation_notifyPreparing

 */

void FmOperationResultProcesser::onNotifyPreparing( FmOperationBase* operationBase, bool cancelable )

{

    QString title = hbTrId("Operation");

    switch( operationBase->operationType() )

    {

    case FmOperationService::EOperationTypeBackup:

        title = hbTrId("backup preparing");

        break;

    case FmOperationService::EOperationTypeRestore:

        title = hbTrId("restore preparing");

        break;

    case FmOperationService::EOperationTypeCopy:

        title = hbTrId("copy preparing");

        break;

    case FmOperationService::EOperationTypeMove:

        title = hbTrId("move preparing");

        break;

    case FmOperationService::EOperationTypeRemove:

        title = hbTrId("delete preparing");

        break;

    case FmOperationService::EOperationTypeFormat:

        title = hbTrId("format preparing");

        break;

    default:

        break;

    }

    showPreparing( title, cancelable );

}

/*

 * Called by operation service on_operation_notifyStart

 * \sa FmOperationService::on_operation_notifyStart

 */

void FmOperationResultProcesser::onNotifyStart( FmOperationBase* operationBase, bool cancelable, int maxSteps )

{

    QString title = hbTrId("Operation");

    switch( operationBase->operationType() )

    {

    case FmOperationService::EOperationTypeBackup:

        title = hbTrId("backup...");

        break;

    case FmOperationService::EOperationTypeRestore:

        title = hbTrId("restore...");

        break;

    case FmOperationService::EOperationTypeCopy:

        title = hbTrId("copy...");

        break;

    case FmOperationService::EOperationTypeMove:

        title = hbTrId("move...");

        break;

    case FmOperationService::EOperationTypeRemove:

        title = hbTrId("delete...");

        break;

    case FmOperationService::EOperationTypeFormat:

        title = hbTrId("formating...");

        break;

    default:

        break;

    }

    showProgress( title, cancelable, maxSteps );   

}

/*

 * Called by operation service on_operation_notifyProgress

 * \sa FmOperationService::on_operation_notifyProgress

 */

void FmOperationResultProcesser::onNotifyProgress( FmOperationBase* operationBase, int currentStep )

{

    Q_UNUSED( operationBase );

    setProgress( currentStep );

}

/*

 * Called by operation service on_operation_notifyFinish

 * \sa FmOperationService::on_operation_notifyFinish

 */

void FmOperationResultProcesser::onNotifyFinish( FmOperationBase* operationBase )

{

    finishProgress();

    switch( operationBase->operationType() )

    {

    case FmOperationService::EOperationTypeDriveDetails:

        {

            FmOperationDriveDetails *paramDriveDetails = static_cast<FmOperationDriveDetails*>( operationBase );

            QString diskName = paramDriveDetails->driverName();

            FmViewDetailsDialog::showDriveViewDetailsDialog( diskName, paramDriveDetails->detailsSizeList(),

				FmUtils::getDriveLetterFromPath( diskName ) );

            break;

        }

    case FmOperationService::EOperationTypeFolderDetails:

        {

            FmOperationFolderDetails *paramFolderDetails = static_cast<FmOperationFolderDetails*>( operationBase );

            FmViewDetailsDialog::showFolderViewDetailsDialog( paramFolderDetails->folderPath(),

                paramFolderDetails->numofSubFolders(),

                paramFolderDetails->numofFiles(),

                paramFolderDetails->sizeofFolder(), 

				FmUtils::getDriveLetterFromPath( paramFolderDetails->folderPath() ) );

            break;

        }

    case FmOperationService::EOperationTypeFormat:

        {

            FmUtils::setSystem( false );

            FmDlgUtils::information( QString( hbTrId("Format succeed!")), HbMessageBox::Ok, true );

            FmOperationFormat *paramFormat = static_cast<FmOperationFormat*>( operationBase );

            QString title( hbTrId( "Drive name ") );  

            QString driveName( paramFormat->driverName() );

            FmDriverInfo driverInfo = FmUtils::queryDriverInfo( driveName );

            FmDriverInfo::DriveState state = driverInfo.driveState();

            FmDriverInfo::DriveType driveType = driverInfo.driveType();

            // If drive is available and it is mmc or usb memory

            if( ( state & FmDriverInfo::EDriveAvailable ) &&

                ( driveType == FmDriverInfo::EDriveTypeMemoryCard ||

                  driveType == FmDriverInfo::EDriveTypeUsbMemory ) ) { 

                bool needToSetVolume = false;

                QString volumeName = FmUtils::getVolumeNameWithDefaultNameIfNull( driveName, needToSetVolume );                            

                //use isReturnFalseWhenNoTextChanged = false in order that FmUtils::renameDrive( driveName, volumeName ) will

                //be excuted at lease once to set the volume name.

                while( FmDlgUtils::showTextQuery( title, volumeName, QStringList(), FmMaxLengthofDriveName, QString(), false ) ){                    

                    int err = FmUtils::renameDrive( driveName, volumeName );

                    if ( err == FmErrNone ) {

                        FmDlgUtils::information( hbTrId( "The name has been changed!" ) );

                        mOperationService->on_operation_driveSpaceChanged();

                        break;

                    } else if( err == FmErrBadName ) {

                        FmDlgUtils::warning( hbTrId( "Illegal characters! Use only letters and numbers." ), HbMessageBox::Ok, true );

                    } else{

                        FmDlgUtils::warning( hbTrId( "Error occurred, operation cancelled!" ) );

                        break;

                    }                

                }

            }

            break;

        }

    case FmOperationService::EOperationTypeBackup:

        {

            FmDlgUtils::information( QString( hbTrId("Backup succeed!")) );

            break;

        }

    case FmOperationService::EOperationTypeRestore:

        {

            FmDlgUtils::information( QString( hbTrId("Restore succeed!")) );

            break;

        }

    default:

        FmDlgUtils::information( QString( hbTrId("Operation finished")) );

    }

}

/*

 * Called by operation service on_operation_notifyError

 * \sa FmOperationService::on_operation_notifyError

 */

void FmOperationResultProcesser::onNotifyError( FmOperationBase* operationBase, int error, const QString &errString )

{

    Q_UNUSED( errString );

    failAndCloseProgress();

    if( operationBase->operationType() == FmOperationService::EOperationTypeFormat ) {

        FmUtils::setSystem( false );

    }

    switch( error )

    {

        case FmErrCancel:

            cancelProgress();

            // Do not pop up general cancel note as it is not needed( according to TB9.2 ).

            // If it should be added later, please do not use blocking note. 

            // Blocking note will cause second backup operaion freeze after cancel previous backup operation

            // as QEventLoop::exec will cause some problem when used for blocking dialog.

			// HbDialog has already removed exec function which is implemented with QEventLoop::exec.

			// If need use QEventLoop::exec to block code execute sequence, It should be invoked in a Qt::QueuedConnection slot.

            return;

        case FmErrAlreadyStarted:

            FmDlgUtils::warning( QString( hbTrId("Operation already started!")) );

            return;

        case FmErrLocked:

            {

                FmOperationBackup *operationBackup = qobject_cast<FmOperationBackup*>(operationBase);

                if( operationBackup ) {

                    // special error note for backup

                    QString targetDrive( operationBackup->targetDrive() );

                    QString defaultDriveVolume( FmUtils::getDefaultVolumeName( targetDrive ) );

                    QString driveString( defaultDriveVolume.isEmpty()? targetDrive:defaultDriveVolume );

                    FmDlgUtils::warning( QString( hbTrId("txt_fmgr_info_backup_locked") ).arg( driveString ) );

                } else {

                    FmDlgUtils::warning( QString( hbTrId("Operation failed because drive is locked!")) );

                }

                return;

            }

        case FmErrPathNotFound:

            FmDlgUtils::warning( QString( hbTrId("Operation failed because can not find target path or drive is not available!") ) );

            return;

        case FmErrCorrupt:

            {

                FmOperationBackup *operationBackup = qobject_cast<FmOperationBackup*>(operationBase);

                if( operationBackup ) {

                    // special error note for backup

                    QString targetDrive( operationBackup->targetDrive() );

                    QString defaultDriveVolume( FmUtils::getDefaultVolumeName( targetDrive ) );

                    QString driveString( defaultDriveVolume.isEmpty()? targetDrive:defaultDriveVolume );

                    FmDlgUtils::warning( QString( hbTrId("txt_fmgr_info_backup_corrupted") ).arg( driveString ) );

                } else {

                    FmDlgUtils::warning( QString( hbTrId("Operation failed because target media is corrupted!") ) );

                }

                return;

            }

        case FmErrNotReady: // Caused when MMC & OTG is not inserted when start backup

            {

                FmOperationBackup *operationBackup = qobject_cast<FmOperationBackup*>(operationBase);

                if( operationBackup ) {

                    // special error note for backup

                    QString targetDrive( operationBackup->targetDrive() );

                    QString defaultDriveVolume( FmUtils::getDefaultVolumeName( targetDrive ) );

                    QString driveString( defaultDriveVolume.isEmpty()? targetDrive:defaultDriveVolume );

                    FmDlgUtils::warning( QString( hbTrId("txt_fmgr_info_backup_unavailable") ).arg( driveString ) );

                } else {

                    FmDlgUtils::warning( QString( hbTrId("Operation failed because device is not ready!") ) );

                }

                return;

            }

        case FmErrDisMounted: // Caused by eject MMC when preparing backup, will be localized later

            FmDlgUtils::warning( QString( hbTrId("Operation failed because backup target drive has been removed!") ) );

            return;

        case FmErrDiskFull:

            FmDlgUtils::warning( QString( hbTrId("Not enough space. Operation cancelled!")) );

            return;

        case FmErrCopyDestToSubFolderInSrc:

            FmDlgUtils::warning( QString( hbTrId("Can not copy to sub folder!")) );

            return;

        case FmErrMoveDestToSubFolderInSrc:

            FmDlgUtils::warning( QString( hbTrId("Can not move to sub folder!")) );

            return;

        case FmErrCannotRemove:{

            if( operationBase->operationType() == FmOperationService::EOperationTypeCopy ) {

                // when copy a file/dir to same name destination, and delete dest fail, this error will occur

                FmDlgUtils::warning( QString( hbTrId( "Can not copy because %1 can not be deleted!" ).arg( errString ) ) );

                return;

            }

            else if( operationBase->operationType() == FmOperationService::EOperationTypeMove ) {

                // when move a file/dir to same name destination, and delete dest fail, this error will occur

                FmDlgUtils::warning( QString( hbTrId( "Can not move because %1 can not be deleted!" ).arg( errString ) ) );

                return;

            }

            // when delete file/dir fail, this error will occur

            FmDlgUtils::warning( QString( hbTrId( "Can not delete %1!" ).arg( errString ) ) );

            return; 

        }      

        case FmErrRemoveDefaultFolder:{

            if( operationBase->operationType() == FmOperationService::EOperationTypeMove ) {

                // when move a default folder

                FmDlgUtils::warning( QString( hbTrId( "Could not move because the default folder %1 can not be deleted!" ).arg( errString ) ) );

                return;

            }

            else {

               // when delete the default folder

               FmDlgUtils::warning( QString( hbTrId( "Could not remove the default folder %1 " ).arg( errString ) ) );

               return;

            }

        }

    }

    switch( operationBase->operationType() )

    {

    case FmOperationService::EOperationTypeFormat:

        FmDlgUtils::warning( QString( hbTrId("Format failed!")) );

        break;

    default:

        FmDlgUtils::warning( QString( hbTrId("Operation failed")) );

    }

}

/*

 * Responds to waiting note's cancel signal.

 */

void FmOperationResultProcesser::onProgressCancelled()

{

    mOperationService->cancelOperation();

}

/*

 * Shows the waiting dialog with 

 * \a title the title of the dialog.

 * \a cancelable whether it could be cancelled.

 */

void FmOperationResultProcesser::showWaiting( QString title, bool cancelable )

{

    qDebug("show warning");

    if( mNote ){

        mNote->close();

        delete mNote;        

    }

    mNote = new HbProgressDialog( HbProgressDialog::WaitDialog );

    connect( mNote, SIGNAL( cancelled() ), this, SLOT(onProgressCancelled() ) );

//    if( !mNote ) {

//        mNote = new HbProgressDialog( HbProgressDialog::WaitNote );

//        connect( mNote, SIGNAL( cancelled() ), this, SLOT(onProgressCancelled() ) );

//    } else {

//        mNote->setProgressDialogType( HbProgressDialog::WaitNote );

//    }

    mNote->setText( title );

    //KRAZY: ignore krazy warning because QAction must be used.

    QList<QAction *> actionList = mNote->actions();

    if (actionList.size() > 0) {        

        QAction *cancelAction = actionList.at(0);

        if (!cancelable) {

            cancelAction->setDisabled( true );

        } else {

            cancelAction->setDisabled( false );

        }        

    } 

    mNote->open();

}

/*

 * Shows the preparing dialog with 

 * \a title the title of the dialog.

 * \a cancelable whether it could be cancelled.

 */

void FmOperationResultProcesser::showPreparing( QString title, bool cancelable )

{

    qDebug("show preparing");