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

**

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

** All rights reserved.

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

**

** This file is part of the plugins of the Qt Toolkit.

**

** $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 "qconnmanengine.h"

#include "qconnmanservice_linux_p.h"

#include "../qnetworksession_impl.h"

#include <QtNetwork/private/qnetworkconfiguration_p.h>

#include <QtNetwork/qnetworksession.h>

#include <QtCore/qdebug.h>

#include <QtDBus/QtDBus>

#include <QtDBus/QDBusConnection>

#include <QtDBus/QDBusInterface>

#include <QtDBus/QDBusMessage>

#include <QtDBus/QDBusReply>

#ifndef QT_NO_BEARERMANAGEMENT

#ifndef QT_NO_DBUS

QT_BEGIN_NAMESPACE

QConnmanEngine::QConnmanEngine(QObject *parent)

:   QBearerEngineImpl(parent),

    connmanManager(new QConnmanManagerInterface(this))

{

}

QConnmanEngine::~QConnmanEngine()

{

}

bool QConnmanEngine::connmanAvailable() const

{

    QMutexLocker locker(&mutex);

    return connmanManager->isValid();

}

void QConnmanEngine::initialize()

{

    connect(connmanManager,SIGNAL(propertyChangedContext(QString,QString,QDBusVariant)),

            this,SLOT(propertyChangedContext(QString,QString,QDBusVariant)));

    foreach(const QString techPath, connmanManager->getTechnologies()) {

        QConnmanTechnologyInterface *tech;

        tech = new QConnmanTechnologyInterface(techPath, this);

        connect(tech,SIGNAL(propertyChangedContext(QString,QString,QDBusVariant)),

                this,SLOT(technologyPropertyChangedContext(QString,QString,QDBusVariant)));

        foreach(const QString devicePath,tech->getDevices()) {

            QConnmanDeviceInterface *dev;

            dev = new QConnmanDeviceInterface(devicePath);

            if(!deviceMap.value(techPath).contains(devicePath)) {

                connect(dev,SIGNAL(propertyChangedContext(QString,QString,QDBusVariant)),

                        this,SLOT(devicePropertyChangedContext(QString,QString,QDBusVariant)));

                deviceMap.insert(techPath,QStringList() << devicePath);

                foreach(const QString network,dev->getNetworks()) {

                    serviceNetworks.insert(getServiceForNetwork(network),network);

                }

            }

        }

    }

    // Get current list of access points.

    getConfigurations();

}

QList<QNetworkConfigurationPrivate *> QConnmanEngine::getConfigurations()

{

    QMutexLocker locker(&mutex);

  //  foundConfigurations.clear();

    getNetworkListing();

    QList<QNetworkConfigurationPrivate *> fetchedConfigurations;

    QNetworkConfigurationPrivate* cpPriv = 0;

    for (int i = 0; i < foundConfigurations.count(); ++i) {

        QNetworkConfigurationPrivate *config = new QNetworkConfigurationPrivate;

        cpPriv = foundConfigurations.at(i);

        config->name = cpPriv->name;

        config->isValid = cpPriv->isValid;

        config->id = cpPriv->id;

        config->state = cpPriv->state;

        config->type = cpPriv->type;

        config->roamingSupported = cpPriv->roamingSupported;

        config->purpose = cpPriv->purpose;

        config->bearer = cpPriv->bearer;

        fetchedConfigurations.append(config);

    }

    return fetchedConfigurations;

//    return foundConfigurations;

}

void QConnmanEngine::getNetworkListing()

{

    QMutexLocker locker(&mutex);

    QMapIterator<QString,QStringList> i(deviceMap);

    while(i.hasNext()) {

        i.next();

        QConnmanDeviceInterface dev(i.value().at(0));

        if(dev.isValid()) {

            foreach(const QString network,dev.getNetworks()) {

                addNetworkConfiguration(network);

            }

        }

    }

}

void QConnmanEngine::doRequestUpdate()

{

    connmanManager->requestScan("");

    getConfigurations();

    emit updateCompleted();

}

QString QConnmanEngine::getInterfaceFromId(const QString &id)

{

    QMutexLocker locker(&mutex);

    return configInterfaces.value(id);

}

bool QConnmanEngine::hasIdentifier(const QString &id)

{

    QMutexLocker locker(&mutex);

    return accessPointConfigurations.contains(id);

}

QString QConnmanEngine::bearerName(const QString &id)

{

    QMutexLocker locker(&mutex);

    QConnmanServiceInterface serv(serviceFromId(id));

    QString connectionType = serv.getType();

    if (connectionType == "ethernet")

        return QLatin1String("Ethernet");

    else if (connectionType == "wifi")

        return QLatin1String("WLAN");

    else if (connectionType == "cellular") {

        QString mode = serv.getMode();

        if(mode == "gprs" || mode == "edge") {

            return QLatin1String("2G");

        } else if(mode == "umts") {

            return QLatin1String("WCDMA");

        }

    }

    else if (connectionType == "wimax")

        return QLatin1String("WIMAX");

    return QString();

}

void QConnmanEngine::connectToId(const QString &id)

{

    QMutexLocker locker(&mutex);

    QConnmanConnectThread *thread;

    thread = new QConnmanConnectThread(this);

    thread->setServicePath(serviceFromId(id));

    thread->setIdentifier(id);

    connect(thread,SIGNAL(connectionError(QString,QBearerEngineImpl::ConnectionError)),

            this,SIGNAL(connectionError(QString,QBearerEngineImpl::ConnectionError)));

    thread->start();

}

void QConnmanEngine::disconnectFromId(const QString &id)

{

    QMutexLocker locker(&mutex);

    QConnmanServiceInterface serv(serviceFromId(id));

    if(!serv.isValid()) {

        emit connectionError(id, DisconnectionError);

    } else {

        serv.disconnect();

    }

}

void QConnmanEngine::requestUpdate()

{

    QMutexLocker locker(&mutex);

    QTimer::singleShot(0, this, SLOT(doRequestUpdate()));

}

QString QConnmanEngine::serviceFromId(const QString &id)

{

    QMutexLocker locker(&mutex);

    foreach(const QString service, serviceNetworks.keys()) {

        if (id == QString::number(qHash(service)))

            return service;

    }

    return QString();

}

QNetworkSession::State QConnmanEngine::sessionStateForId(const QString &id)

{

    QMutexLocker locker(&mutex);

    QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(id);

    if (!ptr)

        return QNetworkSession::Invalid;

    if (!ptr->isValid) {

        return QNetworkSession::Invalid;

    }

    QString service = serviceFromId(id);

    QConnmanServiceInterface serv(service);

    QString servState = serv.getState();

    if(serv.isFavorite() && (servState == "idle" || servState == "failure")) {

        return QNetworkSession::Disconnected;

    }

    if(servState == "association" || servState == "configuration" || servState == "login") {

        return QNetworkSession::Connecting;

    }

    if(servState == "ready" || servState == "online") {

        return QNetworkSession::Connected;

    }

    if ((ptr->state & QNetworkConfiguration::Discovered) ==

                QNetworkConfiguration::Discovered) {

        return QNetworkSession::Disconnected;

    } else if ((ptr->state & QNetworkConfiguration::Defined) == QNetworkConfiguration::Defined) {

        return QNetworkSession::NotAvailable;

    } else if ((ptr->state & QNetworkConfiguration::Undefined) ==

                QNetworkConfiguration::Undefined) {

        return QNetworkSession::NotAvailable;

    }

    return QNetworkSession::Invalid;

}

quint64 QConnmanEngine::bytesWritten(const QString &id)

{//TODO use connman counter API

    QMutexLocker locker(&mutex);

    quint64 result = 0;

    QString devFile = getInterfaceFromId(id);

    QFile tx("/sys/class/net/"+devFile+"/statistics/tx_bytes");

    if(tx.exists() && tx.open(QIODevice::ReadOnly | QIODevice::Text)) {

        QTextStream in(&tx);

        in >> result;

        tx.close();

    }

    return result;

}

quint64 QConnmanEngine::bytesReceived(const QString &id)

{//TODO use connman counter API

    QMutexLocker locker(&mutex);

    quint64 result = 0;

    QString devFile = getInterfaceFromId(id);

    QFile rx("/sys/class/net/"+devFile+"/statistics/rx_bytes");

    if(rx.exists() && rx.open(QIODevice::ReadOnly | QIODevice::Text)) {

        QTextStream in(&rx);

        in >> result;

        rx.close();

    }

    return result;

}

quint64 QConnmanEngine::startTime(const QString &/*id*/)

{

    // TODO

    QMutexLocker locker(&mutex);

    if (activeTime.isNull()) {

        return 0;

    }

    return activeTime.secsTo(QDateTime::currentDateTime());

}

QNetworkConfigurationManager::Capabilities QConnmanEngine::capabilities() const

{

    return QNetworkConfigurationManager::ForcedRoaming |

            QNetworkConfigurationManager::DataStatistics |

           QNetworkConfigurationManager::CanStartAndStopInterfaces;

}

QNetworkSessionPrivate *QConnmanEngine::createSessionBackend()

{

     return new QNetworkSessionPrivateImpl;

}

QNetworkConfigurationPrivatePointer QConnmanEngine::defaultConfiguration()

{

    return QNetworkConfigurationPrivatePointer();

}

QString QConnmanEngine::getServiceForNetwork(const QString &netPath)

{

    QMutexLocker locker(&mutex);

    QConnmanNetworkInterface network(netPath, this);

    foreach(QString service,connmanManager->getServices()) {

        QConnmanServiceInterface serv(service,this);

        if(serv.getName() == network.getName()

            && network.getSignalStrength() == serv.getSignalStrength()) {

            return service;

        }

    }

    return QString();

}

void QConnmanEngine::propertyChangedContext(const QString &path,const QString &item, const QDBusVariant &value)

{

    Q_UNUSED(path);

//    qDebug() << __FUNCTION__ << path << item << value.variant();

    QMutexLocker locker(&mutex);

    if(item == "Services") {

        QDBusArgument arg = qvariant_cast<QDBusArgument>(value.variant());

        QStringList list = qdbus_cast<QStringList>(arg);

        if(list.count() > accessPointConfigurations.count()) {

            foreach(const QString service, list) {

                addServiceConfiguration(service);

            }

        }

    }

    if(item == "Technologies") {

        QDBusArgument arg = qvariant_cast<QDBusArgument>(value.variant());

        QStringList newlist = qdbus_cast<QStringList>(arg);

        if(newlist.count() > 0) {

            QMap<QString,QConnmanTechnologyInterface *> oldtech = technologies;

            foreach(const QString listPath, newlist) {

                if(!oldtech.contains(listPath)) {

                    QConnmanTechnologyInterface *tech;

                    tech = new QConnmanTechnologyInterface(listPath,this);

                    connect(tech,SIGNAL(propertyChangedContext(QString,QString,QDBusVariant)),

                            this,SLOT(technologyPropertyChangedContext(QString,QString,QDBusVariant)));

                    technologies.insert(listPath, tech);

                }

            }

            foreach(const QString old, oldtech.keys()) {

                if(!newlist.contains(old)) {

                    QConnmanTechnologyInterface *tech = oldtech.value(old);

                    disconnect(tech,SIGNAL(propertyChangedContext(QString,QString,QDBusVariant)),

                               this,SLOT(technologyPropertyChangedContext(QString,QString,QDBusVariant)));

                    technologies.remove(old);

                    getNetworkListing();

                }

            }

        }

    }

    if(item == "State") {

// qDebug() << value.variant();

    }

}

void QConnmanEngine::servicePropertyChangedContext(const QString &path,const QString &item, const QDBusVariant &value)

{

    QMutexLocker locker(&mutex);

    if(item == "State") {

        configurationChange(QString::number(qHash(path)));

        if(value.variant().toString() == "failure") {

            QConnmanServiceInterface serv(path);

            emit connectionError(QString::number(qHash(path)), ConnectError);

        }

    }

}

void QConnmanEngine::networkPropertyChangedContext(const QString &/*path*/,const QString &/*item*/, const QDBusVariant &/*value*/)

{

    QMutexLocker locker(&mutex);

}

void QConnmanEngine::devicePropertyChangedContext(const QString &devpath,const QString &item,const QDBusVariant &value)