/*

 * 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 header file of the back up widget of file manager

 */

#include "fmbackupwidget.h"

#include "fmbackupsettings.h"

#include "fmdlgutils.h"

#include "fmviewmanager.h"

#include "fmoperationservice.h"

#include "fmbkupengine.h"

#include "fmbackuprestorehandler.h"

#include "fmutils.h"

#include <QGraphicsLinearLayout>

#include <QDir>

#include <hbdataform.h>

#include <hbdataformmodel.h>

#include <hbdataformmodelitem.h>

#include <hbdataformviewitem.h>

FmBackupWidget::FmBackupWidget( QGraphicsItem *parent )

: HbWidget( parent ), mLastPressedItem( 0 ), mScrolled( 0 )

{

    init();

}

FmBackupWidget::~FmBackupWidget()

{

    mDataForm->setModel( 0 );

    delete mModel;

}

void FmBackupWidget::on_list_released( const QModelIndex &index )

{

    HbDataFormModelItem *item = mModel->itemFromIndex(index);

    if( item != mLastPressedItem || mDataForm->isScrolling() || mScrolled ) {

        mScrolled = false;

        return;

    }

    mScrolled = false;

    if( item == mContentsItem ){

        ChangeContents();

    } else if( item == mTargetItem ){

        ChangeTargetDrive();

    } else if( item == mSchedulingItem ){

        ChangeScheduling();

    } else if( item == mWeekdayItem ){

        ChangeWeekday();

    } else if( item == mTimeItem ){

        ChangeTime();

    }

}

void FmBackupWidget::on_list_pressed( const QModelIndex &index )

{

    mLastPressedItem = mModel->itemFromIndex(index);

}

void FmBackupWidget::on_list_scrollingStarted()

{

    mScrolled = true;

}

void FmBackupWidget::init()

{

    QGraphicsLinearLayout *vLayout = new QGraphicsLinearLayout( this );

    vLayout->setOrientation( Qt::Vertical );

    mModel = new HbDataFormModel();

    initModel();

    mDataForm = new HbDataForm( this );

    mDataForm->setModel( mModel );

    vLayout->addItem( mDataForm );

    connect( mDataForm, SIGNAL( released( const QModelIndex & ) ),

             this, SLOT( on_list_released( const QModelIndex & ) ) );

    connect( mDataForm, SIGNAL( pressed( const QModelIndex & ) ),

             this, SLOT( on_list_pressed( const QModelIndex & ) ) );

    connect( mDataForm, SIGNAL( scrollingStarted() ),

             this, SLOT( on_list_scrollingStarted() ) );

    connect( this, SIGNAL( doModelRefresh() ),

             this, SLOT( refreshModel() ), Qt::QueuedConnection );

    //mBackupSettings = new FmBackupSettings();

    mBackupSettings = FmViewManager::viewManager()->operationService()->backupRestoreHandler()->bkupEngine()->BackupSettingsL();

    mBackupSettings->load();

    emit doModelRefresh();

}

void FmBackupWidget::expandAllGroup()

{

    mDataForm->setModel( 0 );

    mDataForm->setModel( mModel );

    HbDataFormViewItem *itemScheduling = 

        (HbDataFormViewItem *)(mDataForm->itemByIndex(mModel->indexFromItem(mSchedulingGroup)));

    if( itemScheduling ){

        itemScheduling->setExpanded( true );

    }

    HbDataFormViewItem *itemGroup = 

        (HbDataFormViewItem *)(mDataForm->itemByIndex(mModel->indexFromItem(mContentsGroup)));

    if( itemGroup ){

        itemGroup->setExpanded( true );

    }

}

void FmBackupWidget::initModel()

{

    mContentsGroup = mModel->appendDataFormGroup(

        QString( tr( "Contents" ) ), mModel->invisibleRootItem());

    mContentsItem = mModel->appendDataFormItem(

        HbDataFormModelItem::TextItem, QString( "" ), mContentsGroup );

    mContentsItem->setContentWidgetData( QString("readOnly"), QString("true") );

    mTargetItem = mModel->appendDataFormItem(

        HbDataFormModelItem::TextItem, QString( "" ), mContentsGroup );

    mTargetItem->setContentWidgetData( QString("readOnly"), QString("true") );

    mSchedulingGroup = mModel->appendDataFormGroup(

        QString( tr( "Scheduling" ) ), mModel->invisibleRootItem());

    mSchedulingItem = mModel->appendDataFormItem(

        HbDataFormModelItem::TextItem, QString( "" ), mSchedulingGroup );

    mSchedulingItem->setContentWidgetData( QString("readOnly"), QString("true") );

    mWeekdayItem = mModel->appendDataFormItem(

        HbDataFormModelItem::TextItem, QString( "" ), mSchedulingGroup );

    mWeekdayItem->setContentWidgetData( QString("readOnly"), QString("true") );

    mTimeItem = mModel->appendDataFormItem(

        HbDataFormModelItem::TextItem, QString( "" ), mSchedulingGroup );

    mTimeItem->setContentWidgetData( QString("readOnly"), QString("true") );

}

void FmBackupWidget::refreshModel()

{

    mDataForm->setModel( 0 );

    mBackupSettings->load();

    bool isWeekdayExist = false;

    bool isTimeExist = false;

    QList< FmBackupEntry* > backupEntryList = mBackupSettings->backupEntryList();

    QList< FmBackupEntry* >::iterator it;

    for (  it = backupEntryList.begin(); it != backupEntryList.end(); ++it ){

        int type = ( *it )->type();

        QString title = ( *it )->title();

        QString tips  = ( *it )->tips();

        switch ( type )

        {

        case FmBackupEntry::EContents:

            {

            mContentsItem->setLabel(title);

            mContentsItem->setContentWidgetData( QString("text"), tips );

            break;

            }

        case FmBackupEntry::ETarget:

            {

            mTargetItem->setLabel(title);

            mTargetItem->setContentWidgetData( QString("text"), tips );

            break;

            }

        case FmBackupEntry::EScheduling:

            {

            mSchedulingItem->setLabel(title);

            mSchedulingItem->setContentWidgetData( QString("text"), tips );

            break;

            }

        case FmBackupEntry::EWeekday:

            {

            mWeekdayItem->setLabel(title);

            mWeekdayItem->setContentWidgetData( QString("text"), tips );

            isWeekdayExist = true;

            break;

            }

        case FmBackupEntry::ETime:

            {

            mTimeItem->setLabel(title);

            mTimeItem->setContentWidgetData( QString("text"), tips );

            isTimeExist = true;

            break;

            }

        }

    }

    int index = 0;

    index = mSchedulingGroup->indexOf(  mWeekdayItem );

    if( index >=0 ){

        mSchedulingGroup->removeChild( index );

    }

    index = mSchedulingGroup->indexOf(  mTimeItem );

    if( index >=0 ){

        mSchedulingGroup->removeChild( index );

    }

    if( isWeekdayExist ) {

            mSchedulingGroup->appendChild( mWeekdayItem );

        }

    if( isTimeExist ){

            mSchedulingGroup->appendChild( mTimeItem );

        }

    mDataForm->setModel( mModel );

    expandAllGroup();

}

void FmBackupWidget::ChangeContents()

{

    QString title = constFileManagerBackupSettingsTitleContents;  

    QStringList queryStringList;

    quint32 contentMask = FmBackupSettings::EFileManagerBackupContentAll;

    while ( contentMask <= FmBackupSettings::EFileManagerBackupContentLast)

    {

        queryStringList.push_back( mBackupSettings->contentToString( contentMask ) );

        contentMask = contentMask << 1;

    }

    quint32 select = mBackupSettings->content();

    if( FmDlgUtils::showMultiSettingQuery( title, queryStringList, select, 0 ) )

    {

        mBackupSettings->setContent( select );

        emit doModelRefresh();

    }

} 

void FmBackupWidget::ChangeScheduling()

{

    QString title = constFileManagerBackupSettingsTitleScheduling;  

    QStringList queryStringList;

    FmBackupSettings::TFileManagerBackupSchedule schedule = FmBackupSettings::EFileManagerBackupScheduleNever;

    while ( schedule <= FmBackupSettings::EFileManagerBackupScheduleWeekly )

    {

        queryStringList.push_back( mBackupSettings->schedulingToString( schedule ) );

        schedule = FmBackupSettings::TFileManagerBackupSchedule(((int)schedule)+1);

    }

    // adjust index offset against monday.

    int selectIndex = mBackupSettings->scheduling() - FmBackupSettings::EFileManagerBackupScheduleNever;

    if( FmDlgUtils::showSingleSettingQuery( title, queryStringList, selectIndex ) )

    {

        selectIndex += FmBackupSettings::EFileManagerBackupScheduleNever;

        mBackupSettings->setScheduling( ( FmBackupSettings::TFileManagerBackupSchedule )selectIndex );

        emit doModelRefresh();

    }

}

void FmBackupWidget::ChangeWeekday()

{

    QString title = constFileManagerBackupSettingsTitleWeekday;  

    QStringList queryStringList;

    FmBackupSettings::TFileManagerBackupWeekday weekday = FmBackupSettings::EFileManagerBackupWeekdayMonday;

    while ( weekday <= FmBackupSettings::EFileManagerBackupWeekdaySunday )

    {

        queryStringList.push_back( mBackupSettings->weekdayToString( weekday ) );

        weekday = FmBackupSettings::TFileManagerBackupWeekday(((int)weekday)+1);

    }

    // adjust index offset against monday.

    int selectIndex = mBackupSettings->weekday() - FmBackupSettings::EFileManagerBackupWeekdayMonday;

    if( FmDlgUtils::showSingleSettingQuery( title, queryStringList, selectIndex ) )

    {

        selectIndex += FmBackupSettings::EFileManagerBackupWeekdayMonday;

        mBackupSettings->setWeekday( (FmBackupSettings::TFileManagerBackupWeekday)selectIndex );

        emit doModelRefresh();

    }

}

void FmBackupWidget::ChangeTime()

{

    QString title = constFileManagerBackupSettingsTitleTime;  

    QTime queryTime = mBackupSettings->time();

    if( FmDlgUtils::showTimeSettingQuery( title, queryTime ) )

    {

        mBackupSettings->setTime( queryTime );

        emit doModelRefresh();

    }

}

void FmBackupWidget::ChangeTargetDrive()

{

    QString title = constFileManagerBackupSettingsTitleTargetDrive;  

    QStringList queryStringList;

    QStringList driveStringList;

    QStringList driveList;

    FmUtils::getDriveList( driveList, true );

    QString targetDrive =  mBackupSettings->targetDrive();

    int selectIndex = -1;

    int currentIndex = 0;

    for( QStringList::const_iterator it = driveList.begin(); it != driveList.end(); ++it )

    {

        QString drive = (*it);

        drive = FmUtils::removePathSplash( drive );

        QString driveWithVolume = FmUtils::fillDriveVolume( drive, true );

        driveStringList.push_back( drive );

        queryStringList.push_back( driveWithVolume );

        if( drive == targetDrive )

        {

            // adjust index offset against drive.

            selectIndex = currentIndex;

        }

        ++currentIndex;

    }

    if( FmDlgUtils::showSingleSettingQuery( title, queryStringList, selectIndex ) )

    {

        mBackupSettings->setTargetDrive( driveStringList.at( selectIndex ) );

        emit doModelRefresh();

    }

}