/*
 * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
 * All rights reserved.
 *
 * Contact: Jukka Rissanen <jukka.rissanen@nokia.com>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public License
 * version 2.1 as published by the Free Software Foundation.
 *
 * This library is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA
 */


// !!!!
// !!!! NOTE: THESE TEST DO NOT REALLY WORK YET BECAUSE OF MISSING
// !!!!       FUNCTIONALITY IN ICD2 STUB. YOU HAVE BEEN WARNED.
// !!!!


#include <QtTest/QtTest>
#include <QCoreApplication>
#include <QEventLoop>
#include <QDebug>
#include <icd/dbus_api.h>

#include "maemo_icd.h"

class Ut_MaemoIcd : public QObject
{
    Q_OBJECT

private Q_SLOTS:
    void init();
    void cleanup();
    void initTestCase();
    void cleanupTestCase();

    void scan_req();
    void scan_cancel_req();
    void connect_req_default();
    void state_req_all();
    void state_req();
    void statistics_req_all();
    void statistics_req();
    void addrinfo_req_all();
    void addrinfo_req();

private:
    void disconnect_req_default(); // this is currently not run
    void connect_req_specific();   // this is currently not run
    QProcess *icd_stub;
    bool connect_iap(Maemo::IcdConnectResult &connect_result,
		     QString &result,
		     QString &error,
		     QString iap=QString());
};


QString create_error_str(Maemo::Icd &icd)
{
    return icd.error();
}


void Ut_MaemoIcd::init()
{
    icd_stub = new QProcess(this);
    icd_stub->setStandardOutputFile("/tmp/ut_maemo_icd.log");
    icd_stub->start("/usr/bin/icd2_stub.py");
    QTest::qWait(1000);

    // Set the statistics
    QProcess dbus_send;
    dbus_send.start("dbus-send --type=method_call --system "
		    "--dest=com.nokia.icd2 /com/nokia/icd2 "
		    "com.nokia.icd2.testing.set_statistics "
		    "uint32:1024 uint32:256");
    dbus_send.waitForFinished();

}

void Ut_MaemoIcd::cleanup()
{
    icd_stub->terminate();
    icd_stub->waitForFinished();
}

void Ut_MaemoIcd::initTestCase()
{
} 

void Ut_MaemoIcd::cleanupTestCase()
{
}

void Ut_MaemoIcd::scan_req()
{    
    QList<Maemo::IcdScanResult> scanned;
    QStringList scannedNetworkTypes;
    QStringList networkTypesToScan;
    QString error;
    Maemo::Icd icd(ICD_SHORT_SCAN_TIMEOUT);

    scannedNetworkTypes = icd.scan(ICD_SCAN_REQUEST_ACTIVE,
				   networkTypesToScan,
				   scanned,
				   error);
    QVERIFY(error.isEmpty());
    QCOMPARE(scanned.size(), 3);
    QVERIFY(scannedNetworkTypes[0] == "WLAN_INFRA");
    QVERIFY(scannedNetworkTypes[1] == "DUN_GSM_PS");
}

void Ut_MaemoIcd::scan_cancel_req()
{
    Maemo::Icd icd;
    icd.scanCancel();
    // Not much to verify here
}

bool Ut_MaemoIcd::connect_iap(Maemo::IcdConnectResult &connect_result,
			      QString &result,
			      QString &error,
			      QString iap)
{
    icd_connection_flags flags = ICD_CONNECTION_FLAG_USER_EVENT;
    bool st;
    Maemo::Icd icd(ICD_SHORT_CONNECT_TIMEOUT);

    if (iap.isEmpty()) {
      qDebug() << "connecting to default IAP";
      st = icd.connect(flags, connect_result);
    } else {
      qDebug() << "connecting to" << iap;
      st = icd.connect(flags, iap, result);
    }

    error = create_error_str(icd);
    return st;
}

void Ut_MaemoIcd::connect_req_default()
{
    Maemo::IcdConnectResult connect_result;
    QString result, error;
    bool st;
    st = connect_iap(connect_result, result, error);
    QVERIFY2(st, error.toAscii().data());
    result = connect_result.connect.network_id.data();
    qDebug() << result;
}


void Ut_MaemoIcd::disconnect_req_default()
{
    icd_connection_flags flags = ICD_CONNECTION_FLAG_USER_EVENT;
    bool st;
    Maemo::Icd icd(ICD_SHORT_CONNECT_TIMEOUT);
    icd.disconnect(flags);
}


void Ut_MaemoIcd::connect_req_specific()
{
    Maemo::IcdConnectResult connect_result;
    QString result;
    QString error;
    bool st;
    st = connect_iap(connect_result, result, error, "wpa2gx2.osso.net");
    QVERIFY2(st, error.toAscii().data());
    qDebug() << result;
}


void Ut_MaemoIcd::state_req_all()
{
    QList<Maemo::IcdStateResult> state_results;
    Maemo::Icd icd;
    int sig;
    sig = icd.state(state_results);
    QVERIFY2(sig==1, create_error_str(icd).toAscii().data());
}


void Ut_MaemoIcd::state_req()
{
    Maemo::IcdStateResult state_result;
    Maemo::Icd icd;
    int sig;
    QString service_type, service_id;
    QString network_type("WLAN_INFRA");
    QByteArray network_id("wpa2gx2.osso.net");
    sig = icd.state(service_type, 0, service_id,
		    network_type, (uint)0x17a1, network_id,
		    state_result);
    QVERIFY2(sig==1, create_error_str(icd).toAscii().data());
}


void Ut_MaemoIcd::statistics_req_all()
{
    QList<Maemo::IcdStatisticsResult> stats_results;
    Maemo::Icd icd;
    int sig;
    QString err;
    sig = icd.statistics(stats_results);
    err = create_error_str(icd);
    if (!err.isEmpty())
      QVERIFY2(sig==1, err.toAscii().data());
    else
      QCOMPARE(sig, 1);

    for(int i=0; i<sig; i++) {
        QVERIFY(stats_results[i].bytes_received == 1024);
        QVERIFY(stats_results[i].bytes_sent == 256);
    }
}


// Can be uncommented when needed function is enabled in Icd class
void Ut_MaemoIcd::statistics_req()
{
    Maemo::IcdStatisticsResult stats_result;
    Maemo::Icd icd;
    int sig;
    QString service_type, service_id;
    QString network_type("WLAN_INFRA");
    QByteArray network_id("wpa2gx2.osso.net");
    sig = icd.statistics(service_type, 0, service_id,
			 network_type, (uint)0x17a1, network_id,
			 stats_result);
    QVERIFY2(sig==1, create_error_str(icd).toAscii().data());
    QVERIFY(stats_result.bytes_received == 1024);
    QVERIFY(stats_result.bytes_sent == 256);
}


void Ut_MaemoIcd::addrinfo_req_all()
{
    QList<Maemo::IcdAddressInfoResult> addr_results;
    Maemo::Icd icd;
    int sig;
    sig = icd.addrinfo(addr_results);
    QVERIFY2(sig==1, create_error_str(icd).toAscii().data());
}


void Ut_MaemoIcd::addrinfo_req()
{
    Maemo::IcdAddressInfoResult addr_result;
    Maemo::Icd icd;
    int sig;
    QString service_type, service_id;
    QString network_type("WLAN_INFRA");
    QByteArray network_id("wpa2gx2.osso.net");
    sig = icd.addrinfo(service_type, 0, service_id,
			 network_type, (uint)0x17a1, network_id,
			 addr_result);
    QVERIFY2(sig==1, create_error_str(icd).toAscii().data());
}


QTEST_MAIN(Ut_MaemoIcd)

#include "ut_maemo_icd.moc"