/****************************************************************************

**

** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the Qt Mobility Components.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "nmview.h"

#include <QLabel>

#include <QLayout>

#include <QListWidget>

#include <QDebug>

#include <QPushButton>

#include <QtDBus>

#include <QtNetwork>

#include <NetworkManager/NetworkManager.h>

#include <arpa/inet.h>

#include <QDBusConnection>

#include <QDBusError>

#include <QDBusInterface>

#include <QDBusMessage>

#include <QDBusReply>

#include <QHostAddress>

#include <QNetworkInterface>

#include <QTreeWidgetItem>

#include <QMessageBox>

//#include "ui_dialog.h"

#include <qnetworkconfiguration.h>

#include <qnetworkconfigmanager.h>

#include <qnetworksession.h>

#include <qnetworkmanagerservice_p.h>

//static QDBusConnection dbc = QDBusConnection::systemBus();

//typedef QMap< QString, QMap<QString,QVariant> > SettingsMap;

//Q_DECLARE_METATYPE(SettingsMap)

NMView::NMView(QDialog* parent)

    : QDialog(parent, 0), dbc(QDBusConnection::systemBus())

{

    init();

    if (!dbc.isConnected()) {

        qWarning() << "Unable to connect to D-Bus:" << dbc.lastError();

        return;

    }

    updateConnections();

    getDevices();

}

NMView::~NMView()

{

}

void NMView::init()

{

    setupUi(this);

    sess = 0;

//    readSettings();

    connect(startButton, SIGNAL(clicked()), this, SLOT(activate()));

    connect(stopButton, SIGNAL(clicked()), this, SLOT(deactivate()));

    connect(scanButton, SIGNAL(clicked()), this, SLOT(findAccessPoints()));

    connect(updateButton, SIGNAL(clicked()), this, SLOT(update()));

    connect(cons, SIGNAL(itemActivated(QTreeWidgetItem*, int)),

            this,SLOT(connectionItemActivated(QTreeWidgetItem*, int)));

    connect(devicesTreeWidget, SIGNAL(itemActivated(QTreeWidgetItem*, int)),

            this, SLOT(deviceItemActivated(QTreeWidgetItem*, int)));

    cons->header()->setResizeMode(QHeaderView::ResizeToContents);

    devicesTreeWidget->header()->setResizeMode(QHeaderView::ResizeToContents);

    accessPointsTreeWidget->header()->setResizeMode(QHeaderView::ResizeToContents);

//    accessPointsTreeWidget->header()->setResizeMode(QHeaderView::ResizeToContents);

   manager = new QNetworkConfigurationManager(this);

   connect(manager, SIGNAL(updateCompleted()), this, SLOT(updateCompleted()));

   connect(manager, SIGNAL(configurationAdded(const QNetworkConfiguration &)),

           this, SLOT(configurationAdded(const QNetworkConfiguration&)));

   devicesTreeWidget->header()->hideSection(0);

   devicesTreeWidget->header()->hideSection(1);

   devicesTreeWidget->header()->hideSection(3);

   devicesTreeWidget->header()->hideSection(5);

   devicesTreeWidget->header()->hideSection(6);

   devicesTreeWidget->header()->hideSection(7);

   devicesTreeWidget->header()->hideSection(8);

   devicesTreeWidget->header()->hideSection(9);

}

void NMView::updateConnections()

{

    cons->clear();

    manager->updateConfigurations();

    QList<QNetworkConfiguration> configs = manager->allConfigurations();

    foreach(QNetworkConfiguration p, configs) {

        QStringList strlist;

        strlist << p.name();

        strlist << stateToString(p.state());

        strlist << p.identifier();

        strlist << typeToString(p.type());

        QTreeWidgetItem *item;

        item = new QTreeWidgetItem(strlist);

        cons->insertTopLevelItem(0, item);

    }

    cons->sortItems ( 1, Qt::AscendingOrder);

}

void NMView::getActiveConnections()

{

    QList<QNetworkConfiguration> configs = manager->allConfigurations(QNetworkConfiguration::Active);

    foreach(QNetworkConfiguration p, configs) {

        qWarning() << __FUNCTION__ << p.name() << p.identifier();

    }

//     QDBusInterface iface(NM_DBUS_SERVICE, NM_DBUS_PATH, NM_DBUS_INTERFACE, dbc);

//     if (!iface.isValid()) {

//         qWarning() << "Could not find NetworkManager";

//         return;

//     }

//     QVariant prop = iface.property("ActiveConnections");

//     QList<QDBusObjectPath> connections = prop.value<QList<QDBusObjectPath> >();

//     foreach(QDBusObjectPath path, connections) {

//         QDBusInterface conDetails(NM_DBUS_SERVICE, path.path(), NM_DBUS_INTERFACE_ACTIVE_CONNECTION, dbc);

//         if (conDetails.isValid()) {

//             QString desc = path.path();

//            conDetails.property("Connection Path").value<QDBusObjectPath>().path();

//            QList<QDBusObjectPath> devices = conDetails.property("Devices").value<QList<QDBusObjectPath> >();

//

//            foreach(QDBusObjectPath devpath, devices) {

//                QDBusInterface devIface(NM_DBUS_SERVICE, devpath.path(), NM_DBUS_INTERFACE_DEVICE, dbc);

//                desc += " "+devIface.property("Interface").toString();

//                desc +=  " "+QHostAddress(htonl(devIface.property("Ip4Address").toUInt())).toString();

//            }

//            qWarning() << conDetails.property("Connection").value<QDBusObjectPath>().path() << path.path();

//            QListWidgetItem* item = new QListWidgetItem(desc,  activeCons);

//            item->setData(Qt::UserRole, path.path());

//      }

//    }

}

void NMView::update()

{

//    QNetworkManagerInterface *dbIface;

//    dbIface = new QNetworkManagerInterface;

//    QList <QDBusObjectPath> connections = dbIface->activeConnections();

//

//    foreach(QDBusObjectPath conpath, connections) {

//        QNetworkManagerConnectionActive *aConn;

//        aConn = new QNetworkManagerConnectionActive(conpath.path());

//        // in case of accesspoint, specificObject will hold the accessPOintObjectPath

//        qWarning() << aConn->connection().path() << aConn->specificObject().path() << aConn->devices().count();

//        QList <QDBusObjectPath>  devs = aConn->devices();

//        foreach(QDBusObjectPath device, devs) {

//            qWarning() << "    " << device.path();

//        }

//    }

    QStringList connectionServices;

    connectionServices << NM_DBUS_SERVICE_SYSTEM_SETTINGS;

    connectionServices << NM_DBUS_SERVICE_USER_SETTINGS;

    foreach (QString service, connectionServices) {

        QDBusInterface allCons(service,

                               NM_DBUS_PATH_SETTINGS,

                               NM_DBUS_IFACE_SETTINGS,

                               dbc);

        if (allCons.isValid()) {

            QDBusReply<QList<QDBusObjectPath> > reply = allCons.call("ListConnections");

            if ( reply.isValid() ) {

                QList<QDBusObjectPath> list = reply.value();

                foreach(QDBusObjectPath path, list) {

                    QDBusInterface sysIface(service,

                                            path.path(),

                                            NM_DBUS_IFACE_SETTINGS_CONNECTION,

                                            dbc);

                    if (sysIface.isValid()) {

                        qWarning() << "";

                        qWarning() << path.path();

                        //                        QDBusMessage r = sysIface.call("GetSettings");

                        QDBusReply< QNmSettingsMap > rep = sysIface.call("GetSettings");

                        QMap< QString, QMap<QString,QVariant> > map = rep.value();

                        QList<QString> list = map.keys();

                        foreach (QString key, list) {

                            QMap<QString,QVariant> innerMap = map[key];

                            qWarning() << "       Key: " << key;

                            QMap<QString,QVariant>::const_iterator i = innerMap.constBegin();

                            while (i != innerMap.constEnd()) {

                                QString k = i.key();

                                qWarning() << "          Key: " << k << " Entry: " << i.value();

                                i++;

                            }//end innerMap

                        }//end foreach key

                    }//end settings connection

                } // foreach path

            } //end ListConnections

        } //end settingsInterface

    }// end services

    QDBusInterface iface(NM_DBUS_SERVICE,

                         NM_DBUS_PATH,

                         NM_DBUS_INTERFACE,

                         dbc);

    if (iface.isValid()) {

        QVariant prop = iface.property("ActiveConnections");

        QList<QDBusObjectPath> connections = prop.value<QList<QDBusObjectPath> >();

        foreach(QDBusObjectPath conpath, connections) {

            qWarning() << "Active connection" << conpath.path();

            QDBusInterface conDetails(NM_DBUS_SERVICE,

                                      conpath.path(),

                                      NM_DBUS_INTERFACE_ACTIVE_CONNECTION,

                                      dbc);

            if (conDetails.isValid()) {

                QVariant prop = conDetails.property("Connection");

                QDBusObjectPath connection = prop.value<QDBusObjectPath>();

                qWarning() << conDetails.property("Default").toBool() << connection.path();

//                QVariant Sprop = conDetails.property("Devices");

//                QList<QDBusObjectPath> so = Sprop.value<QList<QDBusObjectPath> >();

//                foreach(QDBusObjectPath device, so) {

//                    if(device.path() == devicePath) {

//                        path = connection.path();

//                    }

//                    break;

//                }

            }

        }

    }

qWarning() << "";

}

void NMView::deactivate()

{

    QList<QNetworkConfiguration> configs = manager->allConfigurations(QNetworkConfiguration::Active);

    foreach(QNetworkConfiguration p, configs) {

        qWarning() << "Active cons" << p.name();

        if(p.name() == cons->currentItem()->text(0)

            && p.identifier() == cons->currentItem()->text(2)) {

            qWarning() <<__FUNCTION__<< p.name();

            if(!sess) {

                sess = new QNetworkSession(p);

                connect(sess,  SIGNAL(stateChanged(QNetworkSession::State)),

                        this, SLOT(stateChanged(QNetworkSession::State)));

                connect(sess,  SIGNAL(error(QNetworkSession::SessionError)),

                        this,  SLOT(networkSessionError(QNetworkSession::SessionError)));

            }

            sess->close();

            delete sess;

            sess = 0;

        }

    }

}

void NMView::activate()

{

    qWarning() << __FUNCTION__ << cons->currentItem()->text(0);

    QList<QNetworkConfiguration> configs = manager->allConfigurations();

    foreach(QNetworkConfiguration p, configs) {

        if(p.name() == cons->currentItem()->text(0)) {

            sess = new QNetworkSession(p);

            connect(sess, SIGNAL(newConfigurationActivated()),

                    this, SLOT(getActiveConnections()));

            connect(sess,  SIGNAL(stateChanged(QNetworkSession::State)),

                    this, SLOT(stateChanged(QNetworkSession::State)));

            connect(sess,  SIGNAL(error(QNetworkSession::SessionError)),

                    this,  SLOT(networkSessionError(QNetworkSession::SessionError)));

            sess->open();

        }

    }

}

void NMView::getDevices()

{

    qWarning() << "";

    qWarning() << __FUNCTION__;

    devicesTreeWidget->clear();

    //qDBusRegisterMetaType<SettingsMap>();

    if (!dbc.isConnected()) {

        qWarning() << "Unable to connect to D-Bus:" << dbc.lastError();

        return;

    }

        QDBusInterface iface(NM_DBUS_SERVICE,

                             NM_DBUS_PATH,

                             NM_DBUS_INTERFACE,

                             dbc);

//NetworkManager interface

        if (!iface.isValid()) {

            qWarning() << "Could not find NetworkManager";

            return;

        }

//         uint state = iface.property("State").toUInt();

//         switch(state) {

//         case NM_STATE_UNKNOWN:

//             qWarning() << "State: Unknown"; break;

//         case NM_STATE_ASLEEP:

//             qWarning() << "State: Asleep"; break;

//         case NM_STATE_CONNECTING:

//             qWarning() << "State: Connecting"; break;

//         case NM_STATE_CONNECTED:

//             qWarning() << "State: Connected"; break;

//         case NM_STATE_DISCONNECTED:

//             qWarning() << "State: Disconnected"; break;

//         }

        //get list of network devices

        QTreeWidgetItem *item;

        QDBusReply<QList<QDBusObjectPath> > reply = iface.call("GetDevices");

        if ( reply.isValid() ) {

//            qWarning() << "Current devices:";

            QList<QDBusObjectPath> list = reply.value();

            foreach(QDBusObjectPath path, list) {

                QStringList devicesList;

                qWarning() << "  " << path.path();

                devicesList << path.path();

                QDBusInterface devIface(NM_DBUS_SERVICE,

                                        path.path(),

                                        NM_DBUS_INTERFACE_DEVICE,

                                        dbc);

                if (devIface.isValid()) {

                    ////// connect the dbus signal

//                     /*if(*/dbc.connect(NM_DBUS_SERVICE,

//                                    path.path(),

//                                    NM_DBUS_INTERFACE_DEVICE,

//                                    "StateChanged",

//                                    this,SLOT(deviceStateChanged(quint32)));

//                    {

//                        qWarning() << "XXXXXXXXXX dbus connect successful" <<  path.path();

//                    }

          //          qWarning() << "     Managed: " << devIface.property("Managed").toBool();

                    devicesList << devIface.property("Managed").toString();

 //                   qWarning() << "     Interface: " << devIface.property("Interface").toString();

                    devicesList <<  devIface.property("Interface").toString();

  //                  qWarning() << "     HAL UDI: " << devIface.property("Udi").toString();

   //                 qWarning() << "     Driver: " << devIface.property("Driver").toString();

                    devicesList  << devIface.property("Driver").toString();

                    QString x =  deviceTypeToString(devIface.property("DeviceType").toUInt());

 //                   qWarning() << "     Type:" << x;

                    devicesList << x;

                                 if( devIface.property("DeviceType").toUInt() == DEVICE_TYPE_802_11_WIRELESS) {

                                     qWarning() << "Device is WIFI";

                    //                //    findAccessPoints(path.path());

                                    }

                    QVariant v = devIface.property("State");

                    x = deviceStateToString(v.toUInt());

//                    qWarning() << "     State:" << x;

                    devicesList << x;

                    quint32 ip = devIface.property("Ip4Address").toUInt();

//                    qWarning() << "     IP4Address: " << QHostAddress(htonl(ip)).toString();

                    devicesList << QHostAddress(htonl(ip)).toString();

                    if (v.toUInt() == NM_DEVICE_STATE_ACTIVATED) {

                        QString path = devIface.property("Ip4Config").value<QDBusObjectPath>().path();

//                        qWarning() << "     IP4Config: " << path;

                        devicesList << path;

                        QDBusInterface ipIface(NM_DBUS_SERVICE,

                                               path,

                                               NM_DBUS_INTERFACE_IP4_CONFIG,

                                               dbc);

                        if (ipIface.isValid()) {

      //                      qWarning() << "        Hostname: " << ipIface.property("Hostname").toString();

                            devicesList << ipIface.property("Hostname").toString();

//                            qWarning() << "        Domains: " << ipIface.property("Domains").toStringList();

                            devicesList <<  ipIface.property("Domains").toStringList().join(", ");

//                            qWarning() << "        NisDomain: " << ipIface.property("NisDomain").toString();

                            QDBusArgument arg=  ipIface.property("Addresses").value<QDBusArgument>();

//                            qWarning() << "        Addresses: " << ipIface.property("Addresses");

//                            qWarning() << "        Nameservers: " << ipIface.property("Nameservers");

//                            qWarning() << "        NisServers: " << ipIface.property("NisServers");

                        }

                    }

                }

                item = new QTreeWidgetItem(devicesList);

                devicesTreeWidget->insertTopLevelItem(0, item);

            }

        }

//        netconfig();

}

void NMView::readSettings()

{

        QDBusInterface settingsiface(NM_DBUS_SERVICE_SYSTEM_SETTINGS,

                                     NM_DBUS_PATH_SETTINGS,

                                     NM_DBUS_IFACE_SETTINGS,

                                     dbc);

        //NetworkManagerSettings interface

        if (settingsiface.isValid()) {

            QDBusReply<QList<QDBusObjectPath> > reply = settingsiface.call("ListConnections");

            if ( reply.isValid() ) {

                QList<QDBusObjectPath> list = reply.value();

                foreach(QDBusObjectPath path, list) {

                    qWarning() <<__FUNCTION__ << path.path();

                }

            }

        }

        QDBusInterface iface(NM_DBUS_SERVICE, NM_DBUS_PATH, NM_DBUS_INTERFACE, dbc);

        if (!iface.isValid()) {

            qWarning() << "Could not find NetworkManager";

            return;

        }

        //   QStringList list = item->text().split(" -> ");

        QVariant prop = iface.property("ActiveConnections");

        QList<QDBusObjectPath> connections = prop.value<QList<QDBusObjectPath> >();

        foreach(QDBusObjectPath path, connections) {

            QDBusInterface conDetails(NM_DBUS_SERVICE,

                                      path.path(),

                                      NM_DBUS_INTERFACE_ACTIVE_CONNECTION,

                                      dbc);

            if (conDetails.isValid()) {

                QString desc = path.path();

                qWarning() << desc;

                //if ( item->text(0) == conDetails.property("Connection").value<QDBusObjectPath>().path() ) {

                    //                QListWidgetItem* item = new QTreeWidgetItem( desc,

                    //                                                             cons);

                    //                item->setData(Qt::UserRole, desc);

                    //                activeItemActivated( item );

                //}

            }

        }

}

void NMView::printConnectionDetails(const QString& service)

{

    Q_UNUSED(service);

//

//    qWarning() << __FUNCTION__ << service;

//

//    QDBusConnection dbc = QDBusConnection::systemBus();

//    if (!dbc.isConnected()) {

//        qWarning() << "Unable to connect to D-Bus:" << dbc.lastError();

//        return;

//    }

//    QDBusInterface allCons(service,

//                           NM_DBUS_PATH_SETTINGS,

//                           NM_DBUS_IFACE_SETTINGS,

//                           dbc);

//

//    if (allCons.isValid()) {

//        QDBusReply<QList<QDBusObjectPath> > reply = allCons.call("ListConnections");

//

//        if ( reply.isValid() ) {

//            qWarning() << "Known connections:";

//            QList<QDBusObjectPath> list = reply.value();

//

//            foreach(QDBusObjectPath path, list) {

//                qWarning() << "  " << path.path();

//

//                QDBusInterface sysIface(NM_DBUS_SERVICE_SYSTEM_SETTINGS,

//                                        path.path(),