/*
 * 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 backup and restore handler of file manager
 */

#include "fmbackuprestorehandler.h"
#include "fmbackupsettings.h"
#include "fmrestoresettings.h"
#include "fmoperationservice.h"
#include "fmbackupconfigloader.h"
#include "fmbkupengine.h"
#include "fmoperationbase.h"
#include "fmcommon.h"
#include "fmdlgutils.h"

FmBackupRestoreHandler::FmBackupRestoreHandler( QObject *parent ) : QObject( parent ), mBackupConfigLoader( 0 )
{
    mBkupEngine = new FmBkupEngine( this );

    mCurrentProcess = ProcessNone;

    connect( mBkupEngine, SIGNAL( notifyPreparing( bool ) ), this, SLOT( onNotifyPreparing( bool ) ), Qt::QueuedConnection );
    connect( mBkupEngine, SIGNAL( notifyStart( bool, int) ), this, SLOT( onNotifyStart( bool, int ) ), Qt::QueuedConnection );
    connect( mBkupEngine, SIGNAL( notifyUpdate(int) ), this, SLOT( onNotifyUpdate(int) ), Qt::QueuedConnection );
    connect( mBkupEngine, SIGNAL( notifyFinish(int) ), 
        this, SLOT( onNotifyFinish(int) ), Qt::DirectConnection );
    connect( mBkupEngine, SIGNAL( notifyMemoryLow(int, int& ) ), 
        this, SLOT( onNotifyMemoryLow(int, int&) ) );
    connect( mBkupEngine, SIGNAL( notifyBackupFilesExist( bool& )), this, SLOT( onNotifyBackupFilesExist( bool& )));
    
}
FmBackupRestoreHandler::~FmBackupRestoreHandler()
{
    delete mBkupEngine;
    delete mBackupConfigLoader;
}

FmBkupEngine *FmBackupRestoreHandler::bkupEngine()
{
    return mBkupEngine;
}

FmBackupConfigLoader *FmBackupRestoreHandler::backupConfigLoader()
{
    if( !mBackupConfigLoader ) {
        mBackupConfigLoader = new FmBackupConfigLoader();
    }
    return mBackupConfigLoader;
}

int FmBackupRestoreHandler::error()
{
    return mBkupEngine->error();
}

bool FmBackupRestoreHandler::startBackup( FmOperationBackup *operationBackup )
{
    Q_UNUSED( operationBackup );
    mCurrentProcess = ProcessBackup;
    bool ret = mBkupEngine->startBackup( backupConfigLoader()->driversAndOperationList(),
        backupConfigLoader()->backupCategoryList(), 
        operationBackup->targetDrive(), // targetDrive is stored in FmOperationBackup
        operationBackup->content() );   // content     is stored in FmOperationBackup

    if( !ret ) {
        mCurrentProcess = ProcessNone;
        }
    return ret;
}
void FmBackupRestoreHandler::cancelBackup()
{
    mBkupEngine->cancelBackup();
}
bool FmBackupRestoreHandler::startRestore( FmOperationRestore *operationRestore )
{
    mCurrentProcess = ProcessRestore;
    mBkupEngine->RestoreSettingsL()->SetSelection( operationRestore->selection() );
    bool ret = mBkupEngine->startRestore( backupConfigLoader()->driversAndOperationList() );
    if( !ret ) {
        mCurrentProcess = ProcessNone;
        }
    return ret;
}

int FmBackupRestoreHandler::deleteBackup( quint64 selection )
{
    mBkupEngine->RestoreSettingsL()->SetSelection( selection );
    mBkupEngine->deleteBackup( backupConfigLoader()->driversAndOperationList() );
    return FmErrNone;
}

void FmBackupRestoreHandler::onNotifyMemoryLow( int memoryValue, int &userError )
{
    userError = FmErrNone;
    if( memoryValue < FmEstimateLowerLimit ) {
        userError = FmErrDiskFull;
    } else if( memoryValue < FmEstimateUpperLimit ) {
        if ( !FmDlgUtils::question( "memory low, continue?" ) ){
            userError = FmErrCancel;
        }
    }
}
void FmBackupRestoreHandler::onNotifyBackupFilesExist( bool &isContinue )
    {
    if ( FmDlgUtils::question( "some backup files exist, continue?" ) )
        {
        isContinue = true;
        }
    else
        {
        isContinue = false;
        }
    }


void FmBackupRestoreHandler::onNotifyPreparing( bool cancelable )
{
    emit notifyPreparing(  cancelable );
}
void FmBackupRestoreHandler::onNotifyStart( bool cancelable, int maxSteps )
{
    emit notifyStart( cancelable, maxSteps );
}
void FmBackupRestoreHandler::onNotifyUpdate( int currentStep )
{
    emit notifyProgress( currentStep );
}
void FmBackupRestoreHandler::onNotifyFinish( int err )
{
    if( err == FmErrNone ) {
        emit notifyFinish();
    } else if( err == FmErrCancel ){
        emit notifyCanceled();
    } else {
        emit notifyError( err, QString("") );
    }
}

void FmBackupRestoreHandler::getBackupDriveList( QStringList &driveList )
{
    mBkupEngine->getBackupDriveList( driveList );
}