/*

* Copyright (c) 2009-2010 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:   This module contains the implementation of IAUpdateMainView

*                class member functions.

*

*/

#include <hbaction.h>

#include <QGraphicsWidget>

#include <QGraphicsLayout>

#include <QGraphicsLayoutItem>

#include <QGraphicsLinearLayout>

#include <QSizeF>

#include <hbdockwidget.h>

#include <HbListView>

#include <hblistviewitem.h>

#include <hblistwidgetitem.h>

#include <hbtoolbar.h>

#include <hbmenu.h>

#include <hbdocumentloader.h>

#include <xqconversions.h>

#include <hbmessagebox.h>

#include <hblabel.h>

#include <hbgroupbox.h>

#include <HbDataForm>

#include <HbLabel>

#include <hbtranslator.h>

#include <HbStyleLoader>

#include <HbIconItem>

#include <HbIconAnimationManager>

#include <HbIconAnimator>

#include <hbparameterlengthlimiter.h>

#include "iaupdatemainview.h"

#include "iaupdateengine.h"

#include "iaupdateagreement.h"

#include "iaupdatedeputils.h"

#include "iaupdatedialogutil.h"

#include "iaupdateversion.h"

#include "iaupdateapplistmodel.h"

#include "iaupdateapplistitem.h"

#include "iaupdateuicontroller.h"

#include "iaupdatedebug.h"

const int KKiloByte = 1024;

const int KMegaByte = 1024 * 1024;

const int KMaxShownInKiloBytes = 10 * KMegaByte;

const QString KTranslationsPath = "/resource/qt/translations/";

const QString KTranslationsFile = "swupdate";

const QString ANIMATION_ICON("qtg_anim_loading");

const QString ANIMATION_FILE("qtg_anim_loading.axml");

IAUpdateMainView::IAUpdateMainView(IAUpdateEngine *engine):

mEngine(engine)        

{

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::IAUpdateMainView() begin");

    mFwListView = NULL;

    mApplicationUpdatesGroupBox = NULL;;

    mFwNSUGroupBox = NULL;

    mContentDataForm = NULL;

    mDialogUtil = NULL;

    mDialogState = NoDialog;

    mPrimaryAction = NULL;

    mNode = NULL;

    mSelectionUpdate = false;

    mSelectionConnect = false;

    mTranslator = NULL;

    mAnimationIconItem = NULL;

    mLabel = NULL;

    mMark = false;

    mUpdating = false;

    mTranslator = new HbTranslator(KTranslationsPath, KTranslationsFile);

    HbDocumentLoader loader;

    bool ok = false;

    loader.load(":/xml/iaupdate_mainview.docml", &ok);

    // Exit if the file format is invalid

    Q_ASSERT_X(ok, "Software update", "Invalid docml file");

    // Create the view from DocML

    HbView* loadedWidget = qobject_cast<HbView*>(loader.findWidget("view"));

    Q_ASSERT_X(loadedWidget != 0, "Software update", "View not found");

    QString viewTitle(loadedWidget->title());

    // Set the IAUpdateMainView view to be the widget that was loaded from the xml

    setWidget(loadedWidget);

    setTitle(viewTitle);

    HbToolBar *toolBar = qobject_cast< HbToolBar*>( loader.findWidget("viewToolbar") );

    //setToolBar(toolBar);

    HbMenu *menu = qobject_cast< HbMenu*>( loader.findWidget("viewMenu") );

    setMenu(menu);

    //Get the Action objects from the docml file

    mActionStartUpdate = qobject_cast<HbAction*>(loader.findObject("action"));

    mActionSettings = qobject_cast<HbAction*>(loader.findObject("action_1"));

    mActionDisclaimer = qobject_cast<HbAction*>(loader.findObject("action_2"));

    mActionCancelRefresh = qobject_cast<HbAction*>(loader.findObject("action_3"));

    mActionCancelUpdate = qobject_cast<HbAction*>(loader.findObject("action_4"));

    connect(mActionStartUpdate, SIGNAL(triggered()), this, SLOT(handleStartUpdate()));

    connect(mActionSettings, SIGNAL(triggered()), this, SLOT(handleSettings()));

    connect(mActionDisclaimer, SIGNAL(triggered()), this, SLOT(handleDisclaimer()));

    connect(mActionCancelRefresh, SIGNAL(triggered()), this, SLOT(handleCancelRefresh()));

    connect(mActionCancelUpdate, SIGNAL(triggered()), this, SLOT(handleCancelUpdate()));

    mActionStartUpdate->setDisabled(true);

    mActionCancelRefresh->setVisible(false);

    mActionCancelUpdate->setVisible(false);

    mContent = qobject_cast< HbWidget*>( loader.findWidget("content") );

    //mListView = qobject_cast<HbListView*>( loader.findWidget("listWidget") );

    mListView = new HbListView(mContent);

    mListView->setSelectionMode(HbAbstractItemView::MultiSelection);

    //mListView->setLayoutName("iaupdate_progress");

    HbStyleLoader::registerFilePath(":/layout/");

    connect( mListView, SIGNAL( longPressed( HbAbstractViewItem *, const QPointF & ) ),

            this, SLOT( handleDetails( HbAbstractViewItem *, const QPointF & ) ) ); 

    IAUpdateAppListModel *model = new IAUpdateAppListModel();

    //HbListViewItem *prototype = mListView->listItemPrototype();

    HbListViewItem *prototype = new IAUpdateAppListItem(mListView);

    prototype->setGraphicsSize(HbListViewItem::LargeIcon);

    prototype->setStretchingStyle(HbListViewItem::NoStretching); 

    mListView->setModel(model, prototype);

    HbDockWidget *dock = new HbDockWidget(this);

    HbWidget *dockContainer = new HbWidget(dock);

    QGraphicsLinearLayout *dockLayout = new QGraphicsLinearLayout(dockContainer);

    dockLayout->setOrientation(Qt::Vertical);

    dockContainer->setLayout(dockLayout);

    mSelections = new HbGroupBox(dockContainer);

    QString selectedString = 

        QString(hbTrId("txt_software_subhead_selected_1l_2l_3l_kb")).arg(0).arg(0).arg(0);

    mSelections->setHeading(selectedString); 

    dockLayout->addItem(mSelections);

    dockLayout->addItem(toolBar);

    dock->setWidget(dockContainer);

    setDockWidget(dock);

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::IAUpdateMainView() end");

}

IAUpdateMainView::~IAUpdateMainView()

{

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::~IAUpdateMainView() begin");

    delete mTranslator;

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::~IAUpdateMainView() end");

}

// -----------------------------------------------------------------------------

// IAUpdateMainView::refresh

// Refreshes update list

// -----------------------------------------------------------------------------

//    

void IAUpdateMainView::refresh(const RPointerArray<MIAUpdateNode> &nodes,

                               const RPointerArray<MIAUpdateFwNode> &fwNodes,

                               int error)

{   

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::refresh() begin");

    removeCurrentContentLayout();

    refreshFirmwareUpdates(fwNodes);

    refreshApplicationUpdates(nodes);

    if (nodes.Count() == 0 && fwNodes.Count() == 0 && 

        error != KErrCancel && error != KErrAbort)

    {    

        if (!mContentDataForm)

        {

            mContentDataForm  = new HbDataForm(mContent); 

        }

        else

        {

            mContentDataForm->setVisible(true);

        }

        QGraphicsLinearLayout *linearLayout = (QGraphicsLinearLayout*) mContent->layout();

        linearLayout->addItem(mContentDataForm);

        QString formText;

        if (error == KErrNone)

        {

             formText = 

                hbTrId("txt_software_formlabel_applications_are_up_to_date");

        }

        else

        {

            formText = 

                hbTrId("txt_software_formlabel_refreshing_failed_try_agai");

        }

        mContentDataForm->setDescription(formText);

    }

    updateSelectionInfoInDock(); 

    if (!mUpdating)

    {    

        mActionStartUpdate->setEnabled(countOfSelections() > 0);

    } 

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::refresh() end");

}

void IAUpdateMainView::refreshProgress()

{ 

    IAUpdateAppListModel *model = NULL;

    model = (IAUpdateAppListModel*)  mListView->model();

    if (model)

    {

        model->refreshProgress();    

    }

}

void IAUpdateMainView::startRefreshingAnimation()

{

    removeCurrentContentLayout();

    mActionDisclaimer->setVisible(false);

    mActionSettings->setVisible(false);

    mActionCancelRefresh->setVisible(true);

    if (!mLabel)

    {    

        mLabel = new HbLabel(mContent);

    }

    else

    {    

        mLabel->setVisible(true);

    }

    QString formText;

    formText = hbTrId("txt_software_formlabel_refreshing_updates_list");

    mLabel->setPlainText(formText);

    mLabel->setAlignment(Qt::AlignHCenter);

    QGraphicsLinearLayout *linearLayout = (QGraphicsLinearLayout*) mContent->layout();

    linearLayout->addStretch();

    linearLayout->addItem(mLabel);

    if (!mAnimationIconItem)

    {    

        mAnimationIconItem = new HbIconItem(ANIMATION_ICON,mContent);

    }

    else

    {

        mAnimationIconItem->setVisible(true);

    }

    mAnimationIconItem->setAlignment(Qt::AlignHCenter );

    linearLayout->addItem(mAnimationIconItem);

    linearLayout->addStretch();

    HbIconAnimationManager::global()->addDefinitionFile(ANIMATION_FILE);

    mAnimationIconItem->animator().startAnimation();

}

void IAUpdateMainView::stopRefreshingAnimation()

{

    mActionDisclaimer->setVisible(true);

    mActionSettings->setVisible(true);

    mActionCancelRefresh->setVisible(false);

    mAnimationIconItem->animator().stopAnimation();

}    

void IAUpdateMainView::updateCompleted()

{

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::updateCompleted() begin");  

    mUpdating = false;

    mActionStartUpdate->setEnabled(countOfSelections() > 0);

    mActionDisclaimer->setVisible(true);

    mActionSettings->setVisible(true);

    mActionCancelUpdate->setVisible(false);

    connect( mListView, SIGNAL( longPressed( HbAbstractViewItem *, const QPointF & ) ),

            this, SLOT( handleDetails( HbAbstractViewItem *, const QPointF & ) ) ); 

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::updateCompleted() end"); 

}

void IAUpdateMainView::handleStartUpdate()

{

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::handleStartUpdate() begin");

    mActionStartUpdate->setEnabled(false);

    mActionDisclaimer->setVisible(false);

    mActionSettings->setVisible(false);

    mActionCancelUpdate->setVisible(true);

    disconnect( mListView, SIGNAL( longPressed( HbAbstractViewItem *, const QPointF & ) ),

                this, SLOT( handleDetails( HbAbstractViewItem *, const QPointF & ) ) ); 

    mUpdating = true;

    mEngine->StartUpdate(fotaSelected());

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::handleStartUpdate() end");

}

void IAUpdateMainView::handleSettings()

{

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::handleSettings() begin");

    emit toSettingView();

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::handleSettings() end");

}

void IAUpdateMainView::handleDisclaimer()

{

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::handleDisclaimer() begin");

    int counter = mListView->model()->rowCount();

    if (!mDialogUtil)

    {

        mDialogUtil = new IAUpdateDialogUtil(this);

    }

    if (mDialogUtil)

    {

        HbAction *primaryAction = new HbAction(hbTrId("txt_common_button_ok"));

        mDialogUtil->showAgreement(primaryAction);

    }

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::handleDisclaimer() end");

}

void IAUpdateMainView::handleCancelRefresh()

{

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::handleCancelRefresh() begin");

    mEngine->Controller()->HandleUserCancelL();

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::handleCancelRefresh() end");

}

void IAUpdateMainView::handleCancelUpdate()

{

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::handleCancelUpdate() begin");

    mEngine->Controller()->HandleUserCancelL();

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::handleCancelUpdate() end");

}

void IAUpdateMainView::handleDetails(HbAbstractViewItem * item, const QPointF &)

{

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::handleDetails() begin");

    int ind = item->modelIndex().row();

    if (getApplicationNode(ind) != NULL)

    {    

        showDetails(*getApplicationNode(ind));

    }

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::handleDetails() end");

}

void IAUpdateMainView::handleFotaDetails(HbAbstractViewItem *, const QPointF &)

{

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::handleFotaDetails begin");

    //only one FOTA item in a list, just use it

    for (int i = 0; i < mFwNodes.Count(); i++)

    {

        if (mFwNodes[i]->FwType() == MIAUpdateFwNode::EFotaDp2)

        {

            showDetails(*mFwNodes[i]);

        }

    }

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::handleFotaDetails end");

}

void IAUpdateMainView::handleSelectionChanged(const QItemSelection &selected, const QItemSelection &deselected)

{

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::handleSelectionChanged begin");

    if (!mSelectionUpdate)

    {

        bool changedItemFound = false; 

        QModelIndexList indexList = selected.indexes();

        for (int i = 0; !changedItemFound && i < indexList.count(); ++i)

        {    

            changedItemFound = true;

            markListItem(true, indexList.at(i).row());

        }

        if (!changedItemFound)

        {

            indexList = deselected.indexes();

            for (int i = 0; !changedItemFound && i < indexList.count(); ++i)

            {    

                changedItemFound = true;

                markListItem(false, indexList.at(i).row());

            }

        }

    }

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::handleSelectionChanged end");

}

void IAUpdateMainView::handleFwSelectionChanged(const QItemSelection &selected, const QItemSelection &deselected)

{

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::handleFwSelectionChanged begin");

    if (!mSelectionUpdate)

    {

        bool changedItemFound = false; 

        QModelIndexList indexList = selected.indexes();

        for (int i = 0; !changedItemFound && i < indexList.count(); ++i)

        {    

            changedItemFound = true;

            markFotaItem(true);

        }

        if (!changedItemFound)

        {

            indexList = deselected.indexes();

            for (int i = 0; !changedItemFound && i < indexList.count(); ++i)

            {    

                changedItemFound = true;

                markFotaItem(false);

            }

        }

    }

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::handleFwSelectionChanged end");

}

void IAUpdateMainView::dialogFinished(HbAction *action)

{

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::dialogFinished begin");

    DialogState dialogState = mDialogState;

    mDialogState = NoDialog;

    switch ( dialogState )

    {

        case Dependencies:

            if (action == mPrimaryAction)

            {

                updateSelectionsToNodeArray(*mNode,mMark);

            }

            updateSelectionsToList();

            updateSelectionInfoInDock();

            mActionStartUpdate->setEnabled(countOfSelections() > 0);

            break;

        case CannotOmit:    

            break;

        case Details:

            break; 

        default: 

            break;

    }

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::dialogFinished end");

}

bool IAUpdateMainView::fotaSelected() const

{

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::fotaSelected() begin");

    bool selected = false;

    for (int i = 0; i < mFwNodes.Count() && !selected; ++i)

    {

        if ( mFwNodes[i]->FwType() == MIAUpdateFwNode::EFotaDp2 && mFwNodes[i]->Base().IsSelected() )

        {    

            selected = true;

        }

    }

    if (selected)

        {

        IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::fotaSelected() Fota item is selected");