/*

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

#include <hbdataformmodel.h>

#include <hbdataformmodelitem.h>

#include <hbdataformviewitem.h>

#include <hbdialog.h>

#include <hbaction.h>

#include <hblistwidget.h>

#include <hblistwidgetitem.h>

#include <hblabel.h>

#include <cpsettingformitemdata.h>

#include <psetwrapper.h>

#include "cpnetworkpluginform.h"

#include "cpplugincommon.h"

#include "cppluginlogging.h"

#include "cpphonenotes.h"

/*!

  CpNetworkPluginForm::CpNetworkPluginForm

 */

CpNetworkPluginForm::CpNetworkPluginForm(QGraphicsItem *parent) :

    HbDataForm(parent),

    m_activeNoteId(0),

    m_activeProgressNoteId(0),

    m_pSetWrapper(NULL),

    m_cpSettingsWrapper(NULL)

{

    DPRINT << ": IN";

    setHeading(hbTrId("Mobile network"));

    QScopedPointer<PSetWrapper> pSetWrapperGuard(new PSetWrapper);

    m_psetNetworkWrapper = &pSetWrapperGuard->networkWrapper();

    connectToNetworkWrapper(*m_psetNetworkWrapper);

    connectToPhoneNotes(*CpPhoneNotes::instance());

    QScopedPointer<HbDataFormModel> model(new HbDataFormModel);

    QScopedPointer<CpSettingsWrapper> cpSettingsWrapperGuard(new CpSettingsWrapper);

    // #1 Read Network mode value from Cenrep

    model->appendDataFormItem(createNetworkModeItem());

    // #2 Use phone settings for operator selection

    model->appendDataFormItem(createOperatorSelectionItem());

    setModel(model.take());

    m_pSetWrapper = pSetWrapperGuard.take();

    m_cpSettingsWrapper = cpSettingsWrapperGuard.take();

    DPRINT << ": OUT";

}

/*!

  CpNetworkPluginForm::~CpNetworkPluginForm

 */

CpNetworkPluginForm::~CpNetworkPluginForm()

{

    DPRINT << ": IN";

    delete m_pSetWrapper;

    delete m_cpSettingsWrapper;

    DPRINT << ": OUT";

}

/*!

  CpNetworkPluginForm::createNetworkModeItem

  */

HbDataFormModelItem *CpNetworkPluginForm::createNetworkModeItem()

{

    // #1A Read network mode value from Cenrep 

    DPRINT << ": IN";

    m_NetworkModeOptionsItemData = new CpSettingFormItemData(

        HbDataFormModelItem::ComboBoxItem, 

        hbTrId("Network mode"), 

        NULL );

    QScopedPointer<CpSettingFormItemData> settingFormItemGuard(

        m_NetworkModeOptionsItemData);

    mNetworkModeOptions << hbTrId("Dual mode") << hbTrId("UMTS") << hbTrId("GSM");

    m_NetworkModeOptionsItemData->setContentWidgetData(

        "items", QVariant(mNetworkModeOptions));

    QObject::connect(

        m_psetNetworkWrapper, 

        SIGNAL(networkAccessModeGot(int)),

        this, 

        SLOT(networkAccessModeGot(int)));

    QObject::connect(

        m_psetNetworkWrapper, 

        SIGNAL(availableNetworksGot(QList<PSetNetworkWrapper::NetworkInfo*> &)),

        this, 

        SLOT(availableNetworksGot(QList<PSetNetworkWrapper::NetworkInfo*> &)));

    m_psetNetworkWrapper->getNetworkAccessMode();

    addConnection(

        m_NetworkModeOptionsItemData, 

        SIGNAL(currentIndexChanged(int)),

        this, 

        SLOT(networkModeStateChanged(int)));

    settingFormItemGuard.take();

    DPRINT << ": OUT";

    return m_NetworkModeOptionsItemData;

}

/*!

  CpNetworkPluginForm::createOperatorSelectionItem

  */

HbDataFormModelItem *CpNetworkPluginForm::createOperatorSelectionItem()

{

    // #2A Use phone settings for operator selection

    DPRINT << ": IN";

    m_NetworkOperatorSelectionItemData = new CpSettingFormItemData(

        HbDataFormModelItem::ToggleValueItem, 

        hbTrId("Operator selection"), 

        NULL);

    QScopedPointer<CpSettingFormItemData> settingFormItemGuard(

        m_NetworkOperatorSelectionItemData);

    PSetNetworkWrapper::NetworkSelectionMode mode;

    PSetNetworkWrapper::ErrorCode err = 

        m_psetNetworkWrapper->getNetworkSelectionMode(mode);

    if(err == PSetNetworkWrapper::ErrNoError) {

        switch (mode) {

            case PSetNetworkWrapper::SelectionModeAutomatic: 

                m_NetworkOperatorSelectionItemData->setContentWidgetData(

                    "text", QVariant(hbTrId("Automatic")));

                break;

            case PSetNetworkWrapper::SelectionModeManual: 

                m_NetworkOperatorSelectionItemData->setContentWidgetData(

                    "text", QVariant(hbTrId("Manual")));

                break;

            default:

                break;

        }

    }

    addConnection(

        m_NetworkOperatorSelectionItemData, SIGNAL(clicked(bool) ),

        this, SLOT(operatorSelectionStateChanged(bool)));

    settingFormItemGuard.take();

    DPRINT << ": OUT";

    return m_NetworkOperatorSelectionItemData;

}

/*!

  CpNetworkPluginForm::networkModeStateChanged

  */

void CpNetworkPluginForm::networkModeStateChanged(int index)

{

    // #1C network mode changed

    DPRINT << ": IN : index: " << index;

    if(isPhoneOnLine()) {

        if(index == 0){

            dualModeSelection();

        } else if(index == 1) {

            umtsSelection();

        } else if(index == 2) {

            gsmSelection();

        }

    } else {

        // offline mode.

        emit showGlobalNote(

            m_activeNoteId, 

            emit hbTrId("Operation not possible in Off-line mode"), 

            HbMessageBox::MessageTypeInformation);

    }

    DPRINT << ": OUT";

}

/*!

  CpNetworkPluginForm::operatorSelectionStateChanged

  */

void CpNetworkPluginForm::operatorSelectionStateChanged(bool)

{

    // #2C operator selection mode changed

    DPRINT << ": IN ";

    if(isPhoneOnLine()) {

        PSetNetworkWrapper::NetworkSelectionMode mode;

        m_psetNetworkWrapper->getNetworkSelectionMode(mode);

        switch (mode) {

            case PSetNetworkWrapper::SelectionModeAutomatic: 

                manualOperatorSelection();

                m_NetworkOperatorSelectionItemData->setContentWidgetData(

                    "text", QVariant(hbTrId("Manual")));

                break;

            case PSetNetworkWrapper::SelectionModeManual: 

                automaticOperatorSelection();

                m_NetworkOperatorSelectionItemData->setContentWidgetData(

                    "text", QVariant(hbTrId("Automatic")));

                break;

            default:

                break;

            }

    } else {

        // offline mode.

        emit showGlobalNote(

            m_activeNoteId, 

            emit hbTrId("Operation not possible in Off-line mode"), 

            HbMessageBox::MessageTypeInformation);

    }

    DPRINT << ": OUT";

}

/*!

  CpNetworkPluginForm::automaticOperatorSelection

  */

void CpNetworkPluginForm::automaticOperatorSelection()

{

    DPRINT << ": IN";

    PSetNetworkWrapper::NetworkInfo info;

    info.m_mode = PSetNetworkWrapper::SelectionModeAutomatic;

    m_psetNetworkWrapper->selectNetwork(info);

    DPRINT << ": OUT";

}

/*!

  CpNetworkPluginForm::manualOperatorSelection

  */

void CpNetworkPluginForm::manualOperatorSelection()

{

    DPRINT << ": IN";

    m_psetNetworkWrapper->getAvailableNetworks();

    DPRINT << ": OUT";

}

/*!

  CpNetworkPluginForm::dualModeSelection

  */

void CpNetworkPluginForm::dualModeSelection()

{

    DPRINT << ": IN";

    m_psetNetworkWrapper->setNetworkAccessMode(

        PSetNetworkWrapper::AccessModeDual);

    DPRINT << ": OUT";

}

/*!

  CpNetworkPluginForm::umtsSelection

  */

void CpNetworkPluginForm::umtsSelection()

{

    DPRINT << ": IN";

    m_psetNetworkWrapper->setNetworkAccessMode(

        PSetNetworkWrapper::AccessModeUmts);

    DPRINT << ": OUT";

}

/*!

  CpNetworkPluginForm::gsmSelection

  */

void CpNetworkPluginForm::gsmSelection()

{

    DPRINT << ": IN";

    m_psetNetworkWrapper->setNetworkAccessMode(

        PSetNetworkWrapper::AccessModeGsm);

    DPRINT << ": OUT";

}

/*!

  CpNetworkPluginForm::networkAccessModeGot

  */

void CpNetworkPluginForm::networkAccessModeGot(

    int mode)

{

    DPRINT << ": IN";

    switch (mode) {

        case PSetNetworkWrapper::AccessModeDual: 

            m_NetworkModeOptionsItemData->setContentWidgetData(

                "currentIndex", 0);

            break;

        case PSetNetworkWrapper::AccessModeUmts: 

            m_NetworkModeOptionsItemData->setContentWidgetData(

                "currentIndex", 1);

            break;

        case PSetNetworkWrapper::AccessModeGsm: 

            m_NetworkModeOptionsItemData->setContentWidgetData(

                "currentIndex", 2);

            break;

        default:

            break;

    }

    DPRINT << ": OUT";

}

/*!

  CpNetworkPluginForm::availableNetworksGot

  */

void CpNetworkPluginForm::availableNetworksGot(

        QList<PSetNetworkWrapper::NetworkInfo*> &networkInfoList)

{

    DPRINT << ": IN";

    m_networkInfoList = &networkInfoList;

    showManualSeletiondialog();

    DPRINT << ": OUT";

}

/*!

  CpNetworkPluginForm::createDialog

  */

HbDialog* CpNetworkPluginForm::createDialog(const QString& heading) const

{

    DPRINT << ": IN";

    HbDialog *dialog = new HbDialog();

    dialog->setDismissPolicy(HbDialog::NoDismiss);

    dialog->setTimeout(HbDialog::NoTimeout);

    dialog->setHeadingWidget(new HbLabel(heading));

    DPRINT << ": OUT";

    return dialog;

}

/*!

  CpNetworkPluginForm::createDialog

  */

void CpNetworkPluginForm::addItemToListWidget(HbListWidget* w,

        const QString& item, const int& data) const

{

    DPRINT << ": IN";

    Q_ASSERT(w != 0);

    HbListWidgetItem* o = new HbListWidgetItem();

    o->setText(item);

    o->setData(data);

    w->addItem(o);

    DPRINT << ": OUT";

}

/*!

  CpNetworkPluginForm::networkReqestFailed

  */

void CpNetworkPluginForm::networkReqestFailed(

        PSetNetworkWrapper::ErrorCode error,

        PSetNetworkWrapper::RequestType type)

{

    DPRINT << ": IN";

    QString text;

    switch(error) {

        case PSetNetworkWrapper::ErrCauseCallActive:

            text = hbTrId("Call in progress");

            break;

        case PSetNetworkWrapper::ErrNoNetworkService:

            text = hbTrId("No network found");

            break;

        case PSetNetworkWrapper::ErrOfflineOpNotAllowed:

            text = hbTrId("Off-line, not alloowed");

            break;

        case PSetNetworkWrapper::ErrNoNetworkAccess:

            text = hbTrId("No access");

            break;

        default:

            break;

    }

    emit showGlobalNote(

        m_activeNoteId, text, HbMessageBox::MessageTypeInformation);

    // Update UI

    if(type == PSetNetworkWrapper::RequestSetNetworkMode) {

       m_psetNetworkWrapper->getNetworkAccessMode();

       }

    else if(type == PSetNetworkWrapper::RequestSetNetwork && 

            error == PSetNetworkWrapper::ErrNoNetworkAccess) {

        showManualSeletiondialog();

    }

    else if(type == PSetNetworkWrapper::RequestSetNetwork ||

            type == PSetNetworkWrapper::RequestSetNetworkAutomatic ||

            type == PSetNetworkWrapper::RequestGetNetworkInfo) {

        restoreUiSelection();

    }

    DPRINT << ": OUT";

}

/*!

  CpNetworkPluginForm::userCancel

  */

void CpNetworkPluginForm::userCancel()

{

    DPRINT << ": IN";

    m_psetNetworkWrapper->cancelRequest();

    restoreUiSelection();

    DPRINT << ": OUT";

}

/*!

  CpNetworkPluginForm::userCancel

  */

void CpNetworkPluginForm::handleSearchingNetworks(

    PSetNetworkWrapper::RequestType &type)

{

    DPRINT << ": IN";

    if (type != PSetNetworkWrapper::RequestNone) {

        QObject::connect(

            CpPhoneNotes::instance(), SIGNAL(progressNoteCanceled()),

            this, SLOT(userCancel()));

        emit showGlobalProgressNote(m_activeProgressNoteId, hbTrId("Searching..."));

    } else {

        QObject::disconnect(

            CpPhoneNotes::instance(), SIGNAL(progressNoteCanceled()),

            this, SLOT(userCancel()));

        emit cancelNote(m_activeProgressNoteId);

        m_activeProgressNoteId = 0;

    }

    DPRINT << ": OUT";

}

/*!

  CpNetworkPluginForm::userCancel

  */

void CpNetworkPluginForm::handleRequestingSelectedNetwork(bool ongoing)

{

    DPRINT << ": IN";

    if (ongoing) {

        QObject::connect(

            CpPhoneNotes::instance(), SIGNAL(progressNoteCanceled()),

            this, SLOT(userCancel()));

        emit showGlobalProgressNote(m_activeProgressNoteId, hbTrId("Requesting"));

    } else {

        QObject::disconnect(

            CpPhoneNotes::instance(), SIGNAL(progressNoteCanceled()),

            this, SLOT(userCancel()));

        emit cancelNote(m_activeProgressNoteId);

        m_activeProgressNoteId = 0;

    }

    DPRINT << ": OUT";

}

/*!

  CpNetworkPluginForm::userCancel

  */

void CpNetworkPluginForm::handleNetworkChanged(

    PSetNetworkWrapper::NetworkInfo& currentInfo,

    PSetNetworkWrapper::RegistrationStatus& status)

{

    DPRINT << ": IN";

    QString text;

    switch (status){

        case PSetNetworkWrapper::RegisteredOnHomeNetwork:

            text = hbTrId("Home network selected");

            break;

        case PSetNetworkWrapper::RegisteredRoaming: {

            text = hbTrId("Selected network: ");

            text.append(networkName(currentInfo));

        }

            break; 

    }

    emit showGlobalNote(

        m_activeNoteId, text, HbMessageBox::MessageTypeInformation);

    DPRINT << ": OUT";

}

/*!

  CpNetworkPluginForm::showManualSeletiondialog

  */

void CpNetworkPluginForm::showManualSeletiondialog()

{

    DPRINT << ": IN";

    HbDialog *dialog = createDialog(hbTrId("Available networks"));

    HbListWidget *list = new HbListWidget(dialog);