/*

* 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 <hblistview.h>

#include <hblistwidget.h>

#include <hblistviewitem.h>

#include <hblistwidgetitem.h>

#include <hbtoolbar.h>

#include <hbmenu.h>

#include <hbdocumentloader.h>

#include <xqconversions.h>

#include <hbmessagebox.h>

#include "iaupdatemainview.h"

#include "iaupdateengine.h"

#include "iaupdateagreement.h"

#include "iaupdatedeputils.h"

#include "iaupdatedebug.h"

const int KKiloByte = 1024;

const int KMegaByte = 1024 * 1024;

const int KMaxShownInKiloBytes = 10 * KMegaByte;

IAUpdateMainView::IAUpdateMainView(IAUpdateEngine *engine):

mEngine( engine )        

{

    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

    //QGraphicsWidget* widget = loader.findWidget("view");

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

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

    QString viewTitle(widget->title());

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

    setWidget(widget);

    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

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

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

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

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

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

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

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

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

    //mListView = loader.findWidget("listWidget");

    mListView->setSelectionMode( HbAbstractItemView::MultiSelection );

    HbListViewItem *prototype = mListView->listItemPrototype();

    prototype->setGraphicsSize(HbListViewItem::LargeIcon);

    //prototype->setStretchingStyle(HbListViewItem::StretchLandscape);

    //prototype->setSecondaryTextRowCount(1,1);

    /*HbListWidgetItem* item = new HbListWidgetItem();

    QStringList data;

    data << "Test application" << "Critical";

    item->setData(QVariant(data), Qt::DisplayRole);

    mListWidget->addItem(item);*/

}

IAUpdateMainView::~IAUpdateMainView()

{

}

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

// IAUpdateMainView::refresh

// Refreshes update list

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

//    

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

                                const RPointerArray<MIAUpdateFwNode> &fwNodes,

                                int /*error*/ )

    {   

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

    mAllNodes.Reset();

    if ( fwNodes.Count() > 0 )

        {

        IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::refresh hard code importance");

        //hardcode the importance of firmware as Critical

        for ( TInt i = 0; i < fwNodes.Count(); i++ )

             {

             fwNodes[i]->Base().SetImportance( MIAUpdateBaseNode::ECritical );

             }

        //either NSU or FOTA available

        if ( fwNodes.Count() == 1 )

            {

            IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::refresh either NSU or FOTA available");

            MIAUpdateAnyNode* node = fwNodes[0];

            mAllNodes.Append( node );

            }

        //both NSU and FOTA available, show only FOTA node

        if ( fwNodes.Count() == 2 )

            {

            IAUPDATE_TRACE("[IAUPDATE] IAUpdateMainView::refresh both NSU and FOTA available");

            MIAUpdateAnyNode* node1 = fwNodes[0];

            MIAUpdateFwNode* fwnode = static_cast<MIAUpdateFwNode*>( node1 );

            if ( fwnode->FwType() == MIAUpdateFwNode::EFotaDp2  )

                {

                mAllNodes.Append( node1 );

                }

            else

                {

                MIAUpdateAnyNode* node2 = fwNodes[1];

                mAllNodes.Append( node2 );

                }

            }

        }

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

        {

        MIAUpdateAnyNode* node = nodes[i];

        mAllNodes.Append( node );

        }

    mListView->clear();

    QItemSelectionModel *selectionModel = mListView->selectionModel();  

    selectionModel->clear();

    HbIcon icon(QString(":/icons/qgn_menu_swupdate"));

    for( int j = 0; j < mAllNodes.Count(); ++j ) 

        {

        MIAUpdateAnyNode* node = mAllNodes[j];

        int sizeInBytes = node->Base().ContentSizeL();

        int size = 0;

        TBool shownInMegabytes = EFalse;        

        if ( sizeInBytes >= KMaxShownInKiloBytes )

            {

            shownInMegabytes = ETrue;

            size = sizeInBytes / KMegaByte;

            if ( sizeInBytes % KMegaByte != 0 )

                {

                size++;

                }

            }

        else 

            {

            size = sizeInBytes / KKiloByte;

            if ( sizeInBytes % KKiloByte != 0 )

                {

                size++;

                }  

            }

        QString sizeString;

        sizeString.setNum(size);        

        QString importanceDescription;

        switch( node->Base().Importance() )

            {        

            case MIAUpdateBaseNode::EMandatory:

                {

                importanceDescription = "Required ";

                importanceDescription.append(sizeString);

                if ( shownInMegabytes )

                    {

                    importanceDescription.append(" MB" );

                    }

                else 

                    {

                    importanceDescription.append(" kB" );

                    }  

                break;

                }

            case MIAUpdateBaseNode::ECritical:

                {

                bool isNSU = false;

                if( node->NodeType() == MIAUpdateAnyNode::ENodeTypeFw )

                    {

                    MIAUpdateFwNode* fwnode = static_cast<MIAUpdateFwNode*>( node );          

                    if ( fwnode->FwType() == MIAUpdateFwNode::EFotiNsu )

                        {

                        isNSU = true;

                        }

                    }

                importanceDescription = "Important ";

                if ( !size || isNSU )

                    {

                    //for firmware when size info is not provided by server

                    }

                else

                    {

                    importanceDescription.append(sizeString);

                    if ( shownInMegabytes )

                        {

                        importanceDescription.append(" MB" );

                        }

                    else 

                        {

                        importanceDescription.append(" kB" );

                        } 

                    }

                break;

                }

            case MIAUpdateBaseNode::ERecommended:

                {

                importanceDescription = "Recommended ";

                importanceDescription.append(sizeString);

                if ( shownInMegabytes )

                    {

                    importanceDescription.append(" MB" );

                    }

                else 

                    {

                    importanceDescription.append(" kB" );

                    }  

                break;

                }

            case MIAUpdateBaseNode::ENormal:

                {

                importanceDescription = "Optional ";

                importanceDescription.append(sizeString);

                if ( shownInMegabytes )

                    {

                     importanceDescription.append(" MB" );

                    }

                else 

                    {

                    importanceDescription.append(" kB" );

                    }  

                break;

                }

            default:

                {

                break;

                }

            }

            //AknTextUtils::DisplayTextLanguageSpecificNumberConversion( ptr );    

            HbListWidgetItem *item = new HbListWidgetItem();    

            QString name = XQConversions::s60DescToQString(node->Base().Name());

            if ( node->NodeType() == MIAUpdateAnyNode::ENodeTypeFw ) 

                {

                name.append(" DEVICE SOFTWARE");

                }

            item->setText(name);

            item->setSecondaryText(importanceDescription);

            item->setIcon(icon);

             mListView->addItem(item); 

            if ( node->Base().IsSelected() )

                {

                int count = mListView->count();

                QModelIndex modelIndex = mListView->model()->index(count-1,0);

                selectionModel->select(modelIndex, QItemSelectionModel::Select);

                }

        /*if ( nodes.Count() == 0 )

            {

            HBufC* emptyText = NULL;

            if ( aError )

                {

                if ( aError == KErrCancel || aError == KErrAbort )

                    {

                    emptyText = KNullDesC().AllocLC();

                    }

                else

                    {

                    emptyText = StringLoader::LoadLC( R_IAUPDATE_REFRESH_FAILED );  

                    }

                }

            else

                {

                emptyText = StringLoader::LoadLC( R_IAUPDATE_TEXT_NO_UPDATES ); 

                }

            iListBox->View()->SetListEmptyTextL( *emptyText );

            CleanupStack::PopAndDestroy( emptyText );

            iListBox->ScrollBarFrame()->SetScrollBarVisibilityL( 

                    CEikScrollBarFrame::EOff, CEikScrollBarFrame::EOff );  

            }

        else

            {

            if ( iListBox->CurrentItemIndex() == KErrNotFound )

                {

                iListBox->SetCurrentItemIndex( aNodes.Count() - 1 );

                }

            }*/

        //iListBox->HandleItemAdditionL();

        }

     connect(selectionModel, SIGNAL(selectionChanged(QItemSelection,QItemSelection)),

                    this, SLOT(handleSelectionChanged(QItemSelection)));     

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

     }

void IAUpdateMainView::handleStartUpdate()

{

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

    bool firmwareUpdate = false; 

    RPointerArray<MIAUpdateAnyNode> selectedNodes;

    getSelectedNodes(selectedNodes);

    if (selectedNodes.Count() > 0)

        {

        if ( selectedNodes[0]->NodeType() == MIAUpdateAnyNode::ENodeTypeFw )

            {

            //the marking logic will make sure firmware won't be marked with normal sis updates

            //at the same time.

            firmwareUpdate = true;

            }

        }

    selectedNodes.Close();

    //mEngine->StartUpdate(firmwareUpdate);

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

}

void IAUpdateMainView::handleSettings()

{

}

void IAUpdateMainView::handleDisclaimer()

{

    CIAUpdateAgreement* agreement = CIAUpdateAgreement::NewLC();

    agreement->ShowAgreementL();

    CleanupStack::PopAndDestroy( agreement);

}

void IAUpdateMainView::handleSelectionChanged(QItemSelection itemSelection)

{

    QModelIndexList indexList = itemSelection.indexes(); 

    bool changedItemFound = false; 

    for (int i = 0; !changedItemFound && i < mAllNodes.Count(); ++i)

    {

        bool currentlySelected = false; 

        for (int j = 0; !currentlySelected && j < indexList.count(); ++j)

        {

            //QModelIndex modelIndex = indexList.at(j);

            //modelIndex.row();

            if (i == indexList.at(j).row())

            {

                currentlySelected = true;

            }

        }

        if (currentlySelected !=  mAllNodes[i]->Base().IsSelected())

        {

            changedItemFound = true;

            markListItem(currentlySelected,i);

            updateSelectionsToList();

        }

    }

}

void IAUpdateMainView::getSelectedNodes(RPointerArray<MIAUpdateAnyNode> &selectedNodes) const

{

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

    {

        if (mAllNodes[i]->Base().IsSelected())

        {

            selectedNodes.Append(mAllNodes[i]);

        }

    }

}

void IAUpdateMainView::markListItem(bool mark, int index)

{

    if (mark)

    {

        //It's Mark Command

        RPointerArray<MIAUpdateAnyNode> selectedNodes;

        getSelectedNodes(selectedNodes); 

        //There are selected items already and type are different with the current one

        if (selectedNodes.Count() > 0 && (mAllNodes[index]->NodeType() != selectedNodes[0]->NodeType()))

        {       

            // firmware item and normal sis items can't be selected at the same time

            // unmark the selected nodes.

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

            {                

                int index = mAllNodes.Find(selectedNodes[i]);

                mAllNodes[index]->Base().SetSelected(false);

            }

        }

        selectedNodes.Close();

    }

    //there is no selected items or the type is the same with the current one

    if (mAllNodes[index]->NodeType() == MIAUpdateAnyNode::ENodeTypeFw )

    {

        mAllNodes[index]->Base().SetSelected(mark);       

        return;

    }

    if (mAllNodes[index]->NodeType() == MIAUpdateAnyNode::ENodeTypeNormal )

    {

        bool accepted = false;

        if(index > -1)

        {

            accepted = true;

            MIAUpdateNode* node = static_cast<MIAUpdateNode*>(mAllNodes[index]);

            RPointerArray<MIAUpdateAnyNode> mands;

            RPointerArray<MIAUpdateNode> deps;

            if (mark)

            {

                TRAPD(err,IAUpdateDepUtils::GetDependenciesL(*node, mAllNodes, deps));

                if (err != KErrNone)

                {

                    deps.Close();

                    return;

                }

                if (!getMandatoryNodes(mands))

                {

                    // error when creating mandatory node list

                    mands.Close();

                    return;

                }

            }

            else

            {

                //mandatory item is not allowed to be unmarked

                if (mAllNodes[index]->Base().Importance() == MIAUpdateBaseNode::EMandatory)

                {

                    //show dialog  

                    showUpdateCannotOmitDialog();

                    return;

                }

                //CleanupClosePushL( deps );

                TRAPD(err,IAUpdateDepUtils::GetDependantsL(*node, mAllNodes, deps));  

                if (err != KErrNone)

                {

                    deps.Close();

                    return;

                }

                // item is not allowed to be unmarked if its dependant is mandatory

                bool mandatoryDependantFound = false;

                for(int i = 0; i < deps.Count() && !mandatoryDependantFound; i++)

                {

                    if (deps[i]->Base().Importance() == MIAUpdateBaseNode::EMandatory)

                    {

                        mandatoryDependantFound = true;

                    }

                }

                if (mandatoryDependantFound)

                {

                    showUpdateCannotOmitDialog();