/*
* 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 is the source file for Connection Utilities test context.
*/

#include <QObject>
#include <QSharedPointer>
#include <QTest>
#include <rconnmon.h>
#include <nifvar.h>
#include <cmmanager_shim.h>

#include "wlanqtutils.h"
#include "wlanqtutilstestcontext.h"
#include "wlanqtutilsap.h"
#include "wlanqtutilsiap.h"
#include "wlanqtutilsconnection.h"

// ---------------------------------------------------------
// class WlanQtUtilsCtxEsock
// ---------------------------------------------------------

WlanQtUtilsCtxEsock::WlanQtUtilsCtxEsock() :
    startRetValue_(KErrNone)
{
}

WlanQtUtilsCtxEsock::~WlanQtUtilsCtxEsock()
{
}

void WlanQtUtilsCtxEsock::initialize()
{
    startRetValue_ = KErrNone;
}

// ---------------------------------------------------------
// class WlanQtUtilsCtxActiveConn
// ---------------------------------------------------------

WlanQtUtilsCtxActiveConn::WlanQtUtilsCtxActiveConn() :
    WlanQtUtilsConnection(), connMonBearerType_(EBearerUnknown), connMonConnectionStatus_(
        KConnectionUninitialised), connMonWlanConnectionMode_(-1), connMonWlanSecurityMode_(-1),
        applicationUids_()
{
}

WlanQtUtilsCtxActiveConn::~WlanQtUtilsCtxActiveConn()
{
}

// ---------------------------------------------------------
// class WlanQtUtilsCtxActiveConnections
// ---------------------------------------------------------

WlanQtUtilsCtxActiveConnections::WlanQtUtilsCtxActiveConnections() :
    activeConnList_()
{
}

WlanQtUtilsCtxActiveConnections::~WlanQtUtilsCtxActiveConnections()
{
    clearActiveConnList();
}

void WlanQtUtilsCtxActiveConnections::initialize()
{
    clearActiveConnList();
}

void WlanQtUtilsCtxActiveConnections::createDefaultActiveConnList(int numberOfActiveConns,
    int firstIapId)
{
    clearActiveConnList();
    for (int i = 0; i < numberOfActiveConns; i++) {
        WlanQtUtilsCtxActiveConn *activeConn = new WlanQtUtilsCtxActiveConn();

        activeConn->setConnectionId((i + 1) * 100);
        activeConn->setIapId(firstIapId + i);
        activeConn->connMonConnectionStatus_ = KLinkLayerOpen;
        activeConn->setConnectionStatus(WlanQtUtils::ConnStatusConnected);

        // WLAN connection.
        activeConn->connMonBearerType_ = EBearerWLAN;
        activeConn->connMonWlanSecurityMode_ = EConnMonSecurityOpen;
        activeConn->connMonWlanConnectionMode_ = EConnMonInfraStructure;
        activeConnList_.append(activeConn);
    }
}

void WlanQtUtilsCtxActiveConnections::clearActiveConnList()
{
    Q_FOREACH(WlanQtUtilsCtxActiveConn* activeConn, activeConnList_)
        {
            delete activeConn;
        }
    activeConnList_.clear();
}

void WlanQtUtilsCtxActiveConnections::verifyActiveConnList(
    QList<WlanQtUtilsConnection*> activeConnList)
{
    QCOMPARE(activeConnList.count(), activeConnList_.count());

    for (int i = 0; i < activeConnList_.count(); i++) {
        QCOMPARE(activeConnList[i]->connectionId(), activeConnList_[i]->connectionId());
        QCOMPARE(activeConnList[i]->iapId(), activeConnList_[i]->iapId());
        QCOMPARE(activeConnList[i]->connectionStatus(), activeConnList_[i]->connectionStatus());
    }
}

WlanQtUtilsCtxActiveConn *WlanQtUtilsCtxActiveConnections::findActiveConn(uint connectionId) const
{
    WlanQtUtilsCtxActiveConn *activeConn = NULL;
    for (int i = 0; i < activeConnList_.count(); i++) {
        if (activeConnList_[i]->connectionId() == connectionId) {
            activeConn = activeConnList_[i];
        }
    }
    Q_ASSERT(activeConn != NULL);
    return activeConn;
}

// ---------------------------------------------------------
// class WlanQtUtilsWlanScanResult
// ---------------------------------------------------------

WlanQtUtilsWlanScan::WlanQtUtilsWlanScan() :
    mScanResultIterator(0),
    mWlanScanIapResultList(),
    mWlanScanApResultList(),
    mCompleteWlanIapScan(true),
    mCompleteWlanApScan(true),
    mIapScanRetValue(KErrNone),
    mApScanRetValue(KErrNone)
{
}

WlanQtUtilsWlanScan::~WlanQtUtilsWlanScan()
{
    clearWlanScanIapResultList();
    clearWlanScanApResultList();
}

void WlanQtUtilsWlanScan::initialize()
{
    clearWlanScanIapResultList();
    clearWlanScanApResultList();
    mCompleteWlanIapScan = true;
    mCompleteWlanApScan = true;
    mIapScanRetValue = KErrNone;
    mApScanRetValue = KErrNone;
}

void WlanQtUtilsWlanScan::createDefaultWlanScanIapResultList(int numberOfWlanIaps)
{
    clearWlanScanIapResultList();
    
    for (int i = 0; i < numberOfWlanIaps; i++) {
        QSharedPointer<WlanQtUtilsIap> iap(new WlanQtUtilsIap());
        iap->setValue(WlanQtUtilsIap::ConfIdIapId, i);
        iap->setValue(WlanQtUtilsIap::ConfIdName, "TestWlanAp" + QString::number(i + 1));
        // ConfIdNetworkId?
        iap->setValue(WlanQtUtilsAp::ConfIdSsid, "TestWlanAp" + QString::number(i + 1));
        iap->setValue(WlanQtUtilsAp::ConfIdSignalStrength, 20);
        iap->setValue(WlanQtUtilsAp::ConfIdConnectionMode, CMManagerShim::Infra);
        iap->setValue(WlanQtUtilsAp::ConfIdSecurityMode, CMManagerShim::WlanSecModeOpen);
        iap->setValue(WlanQtUtilsAp::ConfIdWpaPskUse, false);
        mWlanScanIapResultList.append(iap);
    }
}

void WlanQtUtilsWlanScan::clearWlanScanIapResultList()
{
    mWlanScanIapResultList.clear();
}

void WlanQtUtilsWlanScan::verifyWlanScanIapResultList(
    QList< QSharedPointer<WlanQtUtilsIap> > wlanIapList)
{
    QCOMPARE(wlanIapList.count(), mWlanScanIapResultList.count());
    
    for (int i = 0; i < mWlanScanIapResultList.count(); i++) {
        QCOMPARE(
            wlanIapList[i]->value(WlanQtUtilsIap::ConfIdIapId),
            mWlanScanIapResultList[i]->value(WlanQtUtilsIap::ConfIdIapId));
        QCOMPARE(
            wlanIapList[i]->value(WlanQtUtilsAp::ConfIdSignalStrength),
            mWlanScanIapResultList[i]->value(WlanQtUtilsAp::ConfIdSignalStrength));
        //QCOMPARE(
        //    wlanIapList[i]->value(WlanQtUtilsAp::ConfIdSsid),
        //    mWlanScanApResultList[i]->value(WlanQtUtilsAp::ConfIdSsid));
    }
}


void WlanQtUtilsWlanScan::createDefaultWlanScanApResultList(int numberOfWlanAps)
{
    clearWlanScanApResultList();
    
    for (int i = 0; i < numberOfWlanAps; i++) {
        QSharedPointer<WlanQtUtilsAp> ap(new WlanQtUtilsAp());
        ap->setValue(WlanQtUtilsAp::ConfIdSsid, "TestWlanAp" + QString::number(i + 1));
        ap->setValue(WlanQtUtilsAp::ConfIdBssid, QByteArray("123456"));
        ap->setValue(WlanQtUtilsAp::ConfIdSignalStrength, 20);
        ap->setValue(WlanQtUtilsAp::ConfIdConnectionMode, CMManagerShim::Infra);
        ap->setValue(WlanQtUtilsAp::ConfIdSecurityMode, CMManagerShim::WlanSecModeOpen);
        ap->setValue(WlanQtUtilsAp::ConfIdWpaPskUse, false);
        ap->setValue(WlanQtUtilsAp::ConfIdWpsSupported, false);
        mWlanScanApResultList.append(ap);
    }
}

void WlanQtUtilsWlanScan::clearWlanScanApResultList()
{
    mWlanScanApResultList.clear();
}

void WlanQtUtilsWlanScan::verifyWlanScanApResultList(
    QList< QSharedPointer<WlanQtUtilsAp> > wlanApList)
{
    QCOMPARE(wlanApList.count(), mWlanScanApResultList.count());

    for (int i = 0; i < mWlanScanApResultList.count(); i++) {
        QCOMPARE(
            wlanApList[i]->value(WlanQtUtilsAp::ConfIdSsid),
            mWlanScanApResultList[i]->value(WlanQtUtilsAp::ConfIdSsid));
        QCOMPARE(
            wlanApList[i]->value(WlanQtUtilsAp::ConfIdBssid),
            mWlanScanApResultList[i]->value(WlanQtUtilsAp::ConfIdBssid));
        QCOMPARE(
            wlanApList[i]->value(WlanQtUtilsAp::ConfIdSignalStrength),
            mWlanScanApResultList[i]->value(WlanQtUtilsAp::ConfIdSignalStrength));
        QCOMPARE(
            wlanApList[i]->value(WlanQtUtilsAp::ConfIdConnectionMode),
            mWlanScanApResultList[i]->value(WlanQtUtilsAp::ConfIdConnectionMode));
        QCOMPARE(
            wlanApList[i]->value(WlanQtUtilsAp::ConfIdSecurityMode),
            mWlanScanApResultList[i]->value(WlanQtUtilsAp::ConfIdSecurityMode));
        QCOMPARE(
            wlanApList[i]->value(WlanQtUtilsAp::ConfIdWpaPskUse),
            mWlanScanApResultList[i]->value(WlanQtUtilsAp::ConfIdWpaPskUse));
        QCOMPARE(
            wlanApList[i]->value(WlanQtUtilsAp::ConfIdWpsSupported),
            mWlanScanApResultList[i]->value(WlanQtUtilsAp::ConfIdWpsSupported));
    }
}

// ---------------------------------------------------------
// class WlanQtUtilsCtxConnMon
// ---------------------------------------------------------

WlanQtUtilsCtxConnMon::WlanQtUtilsCtxConnMon() :
    activeConnections_()
{
}

WlanQtUtilsCtxConnMon::~WlanQtUtilsCtxConnMon()
{
}

void WlanQtUtilsCtxConnMon::initialize()
{
    activeConnections_.initialize();
}

// ---------------------------------------------------------
// class WlanQtUtilsCtxIct
// ---------------------------------------------------------

WlanQtUtilsCtxIct::WlanQtUtilsCtxIct()
{
}

WlanQtUtilsCtxIct::~WlanQtUtilsCtxIct()
{
}

void WlanQtUtilsCtxIct::initialize()
{
}

// ---------------------------------------------------------
// class WlanQtUtilsTestContext
// ---------------------------------------------------------

WlanQtUtilsTestContext::WlanQtUtilsTestContext() :
    esock_(), connMon_(), ict_()
{
}

WlanQtUtilsTestContext::~WlanQtUtilsTestContext()
{
}

void WlanQtUtilsTestContext::initialize()
{
    esock_.initialize();
    connMon_.initialize();
    ict_.initialize();
    mScan.initialize();
}