/*

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

#include "wlanqtutilswlaniap.h"

#include "wlanqtutilsactiveconn.h"

#include "wlanqtutilscmmwrapper.h"

#include "wlanqtutilsconmonwrapper.h"

#include "wlanqtutilsesockwrapper.h"

#include "wlanqtutilsconntestwrapper.h"

#include "wlanqtutils.h"

#include "wlanqtutils_p.h"

#ifdef WLANQTUTILS_NO_OST_TRACES_FLAG

#include <opensystemtrace.h>

#else

#include "OstTraceDefinitions.h"

#endif

#ifdef OST_TRACE_COMPILER_IN_USE

#include "wlanqtutils_pTraces.h"

#endif

WlanQtUtilsPrivate::WlanQtUtilsPrivate(WlanQtUtils *publicPtr) :

    q_ptr(publicPtr),

    wlanScanList_(),

    wlanIapList_(),

    toBeTestedIapId_(WlanQtUtilsInvalidIapId),

    connectingIapId_(WlanQtUtilsInvalidIapId),

    activeConnection_(NULL)

{

    OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_WLANQTUTILSPRIVATE_ENTRY, this );

    // Let's allocate memory for wrapper objects.

    // Engine is set as a parent for wrapper objects.

    cmmWrapper_ = new CmmWrapper(this);

    conMonWrapper_ = new ConMonWrapper(this);

    esockWrapper_ = new EsockWrapper(this);

    connTestWrapper_ = new ConnTestWrapper(this);

    // Make all connections.

    // Todo: having these as signals from the wrappers doesn't bring much benefit

    // -> could be optimized as normal callbacks

    connect(

        conMonWrapper_,

        SIGNAL(availableWlanApsFromWrapper(QList<WlanQtUtilsWlanAp *>&)),

        this,

        SLOT(updateAvailableWlanAps(QList<WlanQtUtilsWlanAp *>&)));

    connect(

        esockWrapper_,

        SIGNAL(connectionStatusFromWrapper(bool)),

        this,

        SLOT(updateConnectionStatus(bool)));

    connect(

        connTestWrapper_,

        SIGNAL(connectivityTestResult(bool)),

        this,

        SLOT(updateConnectivityTestResult(bool)));

    connect(

        conMonWrapper_,

        SIGNAL(connCreatedEventFromWrapper(uint)),

        this,

        SLOT(addActiveConnection(uint)));

    connect(

        conMonWrapper_,

        SIGNAL(connDeletedEventFromWrapper(uint)),

        this,

        SLOT(removeActiveConnection(uint)));

    connect(

        conMonWrapper_,

        SIGNAL(connStatusEventFromWrapper(uint, WlanQtUtilsConnectionStatus)),

        this,

        SLOT(updateActiveConnection(uint, WlanQtUtilsConnectionStatus)));

    // Fetch the initial IAP configuration

    fetchIaps();

    // Retrieve initial status of active connections and update IAPs, if needed.

    activeConnection_ = conMonWrapper_->activeConnection();

    if (activeConnection_ != NULL) {

        updateIapConnectionStatuses(activeConnection_->iapId(), activeConnection_->connectionStatus());

    }

    // TODO: error handling

    OstTraceFunctionExit1( WLANQTUTILSPRIVATE_WLANQTUTILSPRIVATE_EXIT, this );

}

WlanQtUtilsPrivate::~WlanQtUtilsPrivate()

{

    OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_WLANQTUTILSPRIVATEDESTR_ENTRY, this );

    // Delete WLAN scan list

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

        delete wlanScanList_[i];

    }

    wlanScanList_.clear();

    delete activeConnection_;

    delete cmmWrapper_;

    delete conMonWrapper_;

    delete esockWrapper_;

    delete connTestWrapper_;

    OstTraceFunctionExit1( WLANQTUTILSPRIVATE_WLANQTUTILSPRIVATEDESTR_EXIT, this );

}

void WlanQtUtilsPrivate::availableWlanAps(

    QList<WlanQtUtilsWlanIap *> &wlanIapList,

    QList<WlanQtUtilsWlanAp *> &wlanApList)

{

    OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_AVAILABLEWLANAPS_ENTRY, this );

    wlanIapList.clear();

    wlanApList.clear();

    // Add possible connected or connecting IAP as the first item in the list

    int activeIapId = WlanQtUtilsInvalidIapId;

    if (activeConnection_ != NULL) {

        activeIapId = activeConnection_->iapId();

    } else if (connectingIapId_ != WlanQtUtilsInvalidIapId) {

        activeIapId = connectingIapId_;

    }

    if (wlanIapList_.contains(activeIapId)) {

        wlanIapList_[activeIapId]->setSignalStrength(WlanQtUtilsWlanSignalStrengthMax);

        wlanIapList_[activeIapId]->setConnectionStatus(WlanQtUtilsConnectionStatusConnected);

        wlanIapList.append(wlanIapList_[activeIapId]);

    }

    // Todo: IAPs with same SSID and security mode? probably we want to show only one of them?

    // Match IAPs against WLAN scan results

    foreach (WlanQtUtilsWlanIap *iap, wlanIapList_) {

        foreach (WlanQtUtilsWlanAp *scanAp, wlanScanList_) {

            // Todo: security mode check

            if (iap->ssid() == scanAp->ssid()) {

                // IAP found, add it to caller's list of known IAPs (signal strength needs to be

                // updated manually since the IAP in our list does not have that information yet)

                iap->setSignalStrength(scanAp->signalStrength());

                if (iap->id() != activeIapId) {

                    wlanIapList.append(iap);

                } // else: connected IAP, added as the first item in the list already

                break;

            }

        }

    }

    // Go through the scan results to find unknown APs

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

        // Skip networks with empty SSID (hidden networks are handled by UI currently)

        if (wlanScanList_[i]->ssid().isEmpty() == FALSE) {

            // Check whether an IAP with these parameters exists in any SNAP (in which case this

            // network should not be shown as available in this SNAP)

            if (wlanIapExists(wlanScanList_[i]->ssid(), wlanScanList_[i]->securityMode()) == false) {

                // No IAP found in any SNAP, copy the AP to caller's list of unknown APs

                wlanApList.append(wlanScanList_[i]);

            }

        }

    }

    // Sort APs by their SSIDs.

    QMap<QString, WlanQtUtilsWlanAp *> wlanApMap;

    // Loop the AP list copying the keys (lower case SSID) and elements

    // into the map.

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

        wlanApMap.insertMulti(wlanApList[i]->ssid().toLower(), wlanApList[i]);

    }

    wlanApList = wlanApMap.values();

    OstTraceFunctionExit1( WLANQTUTILSPRIVATE_AVAILABLEWLANAPS_EXIT, this );

}

int WlanQtUtilsPrivate::createWlanIap(const WlanQtUtilsWlanAp *wlanAp)

{

    OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_CREATEWLANIAP_ENTRY, this );

    // Create the new IAP. Store its ID, because we need to run ICT for it later

    WlanQtUtilsWlanIap *newIap = cmmWrapper_->createWlanIap(wlanAp);

    toBeTestedIapId_ = newIap->id();

    wlanIapList_.insert(newIap->id(), newIap);

    OstTrace1(

        TRACE_API,

        WLANQTUTILSPRIVATE_CREATEWLANIAP,

        "WlanQtUtilsPrivate::createWlanIap;New IAP ID=%d", toBeTestedIapId_ );

    OstTraceFunctionExit1( WLANQTUTILSPRIVATE_CREATEWLANIAP_EXIT, this );

    return toBeTestedIapId_;

}

void WlanQtUtilsPrivate::connectIap(int iapId)

{

    OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_CONNECTIAP_ENTRY, this );

    OstTrace1( TRACE_API, WLANQTUTILSPRIVATE_CONNECTIAP, "WlanQtUtilsPrivate::connectIap;IAP ID=%d", iapId );

    Q_ASSERT(activeConnection_ == NULL);

    connectingIapId_ = iapId;

    esockWrapper_->connectIap(iapId);

    OstTraceFunctionExit1( WLANQTUTILSPRIVATE_CONNECTIAP_EXIT, this );

}

void WlanQtUtilsPrivate::disconnectIap(int iapId)

{

    OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_DISCONNECTIAP_ENTRY, this );

    OstTrace1( TRACE_API, WLANQTUTILSPRIVATE_DISCONNECTIAP, "WlanQtUtilsPrivate::disconnectIap;IAP ID=%d", iapId );

    Q_ASSERT(activeConnection_ != NULL);

    Q_ASSERT(activeConnection_->iapId() == iapId);

    Q_ASSERT(wlanIapList_.contains(iapId));

    // Todo: IAP may have been opened by someone else... how to know when to disconnect RConnection?    

    esockWrapper_->disconnectIap();

    // In order to close connection even if there are other users for the IAP, close also via ConMon

    conMonWrapper_->disconnectIap(iapId);

    // Change status of the IAP to non-connected

    wlanIapList_[iapId]->setConnectionStatus(WlanQtUtilsConnectionStatusDisconnected);

    OstTraceFunctionExit1( WLANQTUTILSPRIVATE_DISCONNECTIAP_EXIT, this );

}

WlanQtUtilsIap *WlanQtUtilsPrivate::iap(int iapId) const

{

    if (wlanIapList_.contains(iapId)) {

        return wlanIapList_.value(iapId);

    }

    // else: no match

    return NULL;

}

bool WlanQtUtilsPrivate::masterWlan() const

{

    OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_MASTERWLAN_ENTRY, this );

    // TODO: Add actual implementation, this is just temporary dummy for testing wlanentryplugin!

    OstTraceFunctionExit1( WLANQTUTILSPRIVATE_MASTERWLAN_EXIT, this );

    return true;

}

void WlanQtUtilsPrivate::setMasterWlan(bool enabled)

{

    OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_SETMASTERWLAN_ENTRY, this );

    // TODO: Add actual implementation.

    (void)enabled;

    OstTraceFunctionExit1( WLANQTUTILSPRIVATE_SETMASTERWLAN_EXIT, this );

}

int WlanQtUtilsPrivate::connectedWlanId() const

{

    OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_CONNECTEDWLANID_ENTRY, this );

    int retVal = WlanQtUtilsInvalidIapId;

    if (activeConnection_ != NULL) {

        retVal = activeConnection_->iapId();

    }

    OstTraceFunctionExit1( WLANQTUTILSPRIVATE_CONNECTEDWLANID_EXIT, this );

    return retVal;

}

void WlanQtUtilsPrivate::scanWlans()

{

    OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_SCANWLANS_ENTRY, this );

    // Just forward the request to wrapper, which triggers a single WLAN scan

    conMonWrapper_->scanAvailableWlanAPs();

    OstTraceFunctionExit1( WLANQTUTILSPRIVATE_SCANWLANS_EXIT, this );

}

void WlanQtUtilsPrivate::updateAvailableWlanAps(QList<WlanQtUtilsWlanAp *> &availableWlanList)

{

    OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_UPDATEAVAILABLEWLANAPS_ENTRY, this );

    // Old results are removed

    wlanScanList_.clear();

    // Copy available WLAN's to engine's scan result list (duplicates are removed)

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

        bool duplicate = false;

        for (int j = 0; j < wlanScanList_.count(); j++) {

            if (availableWlanList[i]->ssid() == wlanScanList_[j]->ssid()

                && availableWlanList[i]->securityMode() == wlanScanList_[j]->securityMode()) {

                duplicate = true;

                break;

            }

        }

        if (duplicate == false) {

            wlanScanList_.append(availableWlanList[i]);

        }

        // Todo: else deallocate?

    }

    // the information is forwarded to the UI

    emit q_ptr->wlanScanReady();

    OstTraceFunctionExit1( WLANQTUTILSPRIVATE_UPDATEAVAILABLEWLANAPS_EXIT, this );

}

void WlanQtUtilsPrivate::updateConnectionStatus(bool isOpened)

{

    OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_UPDATECONNECTIONSTATUS_ENTRY, this );    

    OstTrace1(

        TRACE_API,

        WLANQTUTILSPRIVATE_UPDATECONNECTIONSTATUS,

        "WlanQtUtilsPrivate::updateConnectionStatus;isOpened=%d", isOpened );

    if (isOpened == false) {

        // Opening failed, update connection statuses, but don't inform UI about

        // connection closing here. It is done always in removeActiveConnection().

        if (activeConnection_ != NULL) {

            activeConnection_->setConnectionStatus(WlanQtUtilsConnectionStatusDisconnected);

        }

        updateIapConnectionStatuses(connectingIapId_, WlanQtUtilsConnectionStatusDisconnected);

    } else {

        // Opening succeeded, update connection statuses and inform UI

        if (activeConnection_ != NULL) {

            activeConnection_->setConnectionStatus(WlanQtUtilsConnectionStatusConnected);

        }

        updateIapConnectionStatuses(connectingIapId_, WlanQtUtilsConnectionStatusConnected);

        emit q_ptr->wlanNetworkOpened(connectingIapId_);

        // Start ICT, if needed

        if (connectingIapId_ == toBeTestedIapId_) {

            WlanQtUtilsIap *iap = WlanQtUtilsPrivate::iap(toBeTestedIapId_);

            connTestWrapper_->startConnectivityTest(toBeTestedIapId_, iap->networkId());

        }

    }

    // IAP is no more in connecting state

    connectingIapId_ = WlanQtUtilsInvalidIapId;

    OstTraceFunctionExit1( WLANQTUTILSPRIVATE_UPDATECONNECTIONSTATUS_EXIT, this );

}

void WlanQtUtilsPrivate::updateConnectivityTestResult(bool result)

{

    OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_UPDATECONNECTIVITYTESTRESULT_ENTRY, this );

    OstTrace1(

        TRACE_API,

        WLANQTUTILSPRIVATE_UPDATECONNECTIVITYTESTRESULT,

        "WlanQtUtilsPrivate::updateConnectivityTestResult;result=%d", result );

    if (result == true) {

        // Move the tested IAP to Internet SNAP since the test passed

        Q_ASSERT(toBeTestedIapId_ != WlanQtUtilsInvalidIapId);

        cmmWrapper_->moveIapToInternetSnap(toBeTestedIapId_);

    } // else: do nothing, IAP remains to be uncategorized

    else

    {

        // TODO: Remove this. This is needed now since the connectivity test fails

        // and thus the IAP is not shown correctly.

        cmmWrapper_->moveIapToInternetSnap(toBeTestedIapId_);

    }

    // This IAP is now tested

    toBeTestedIapId_ = WlanQtUtilsInvalidIapId;

    OstTraceFunctionExit1( WLANQTUTILSPRIVATE_UPDATECONNECTIVITYTESTRESULT_EXIT, this );

}

void WlanQtUtilsPrivate::addActiveConnection(uint connectionId)

{

    OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_ADDACTIVECONNECTION_ENTRY, this );

    OstTrace1(

        TRACE_API,

        WLANQTUTILSPRIVATE_ADDACTIVECONNECTION,

        "WlanQtUtilsPrivate::addActiveConnection;connectionId=%u", connectionId );

    Q_ASSERT(activeConnection_ == NULL);

    activeConnection_ = conMonWrapper_->connectionInfo(connectionId);

    Q_ASSERT(wlanIapList_.contains(activeConnection_->iapId()));

    updateIapConnectionStatuses(activeConnection_->iapId(), activeConnection_->connectionStatus());

    OstTraceFunctionExit1( WLANQTUTILSPRIVATE_ADDACTIVECONNECTION_EXIT, this );

}

void WlanQtUtilsPrivate::removeActiveConnection(uint connectionId)

{

    OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_REMOVEACTIVECONNECTION_ENTRY, this );

    OstTrace1(

        TRACE_API,

        WLANQTUTILSPRIVATE_REMOVEACTIVECONNECTION,

        "WlanQtUtilsPrivate::removeActiveConnection;connectionId=%u", connectionId );

    Q_ASSERT(activeConnection_ != NULL);

    if (activeConnection_->connectionId() == connectionId) {

        // Connection is closed, update connection statuses and inform UI.

        // wlanNetworkClosed is sent from here (and only from here), because, in some cases,

        // connection may be removed without any connection status updates.

        int closedIapId = activeConnection_->iapId();

        updateIapConnectionStatuses(activeConnection_->iapId(), WlanQtUtilsConnectionStatusDisconnected);

        delete activeConnection_;

        activeConnection_ = NULL;

        emit q_ptr->wlanNetworkClosed(closedIapId);

    }

    OstTraceFunctionExit1( WLANQTUTILSPRIVATE_REMOVEACTIVECONNECTION_EXIT, this );

}

void WlanQtUtilsPrivate::updateActiveConnection(uint connectionId, WlanQtUtilsConnectionStatus connectionStatus)

{

    OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_UPDATEACTIVECONNECTION_ENTRY, this );

    OstTraceExt2(

        TRACE_API,

        WLANQTUTILSPRIVATE_UPDATEACTIVECONNECTION,

        "WlanQtUtilsPrivate::updateActiveConnection;connectionId=%u;connectionStatus=%u", connectionId, connectionStatus );

    Q_ASSERT(activeConnection_ != NULL);

    if (activeConnection_->connectionId() == connectionId

        && activeConnection_->connectionStatus() != connectionStatus) {

        // Update connection statuses and inform UI, if necessary

        activeConnection_->setConnectionStatus(connectionStatus);

        updateIapConnectionStatuses(activeConnection_->iapId(), connectionStatus);

        if (connectionStatus == WlanQtUtilsConnectionStatusConnected) {

            emit q_ptr->wlanNetworkOpened(activeConnection_->iapId());

        }

        // Do not inform UI about connection closing here. It is done always in

        // removeActiveConnection(), because that may occur without any connection status updates.

    } // else: connection status did not change

    OstTraceFunctionExit1( WLANQTUTILSPRIVATE_UPDATEACTIVECONNECTION_EXIT, this );

}

int WlanQtUtilsPrivate::fetchIaps()

{

    OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_FETCHIAPS_ENTRY, this );

    QList<WlanQtUtilsIap *> list;

    int error = 0; 

    // Read the IAP list and store WLAN IAPs in our internal map data structure

    error = cmmWrapper_->fetchIaps(list);    

    foreach (WlanQtUtilsIap *iap, list) {

        if (iap->bearerType() == WlanQtUtilsBearerTypeWlan) {

            // Notice that insertMulti not used, because IAP IDs should be unique

            wlanIapList_.insert(iap->id(), qobject_cast<WlanQtUtilsWlanIap *>(iap));            

        }

    }

    OstTraceFunctionExit1( WLANQTUTILSPRIVATE_FETCHIAPS_EXIT, this );

    return error;

}

bool WlanQtUtilsPrivate::wlanIapExists(QString ssid, WlanQtUtilsWlanSecMode secMode)

{    

    foreach (WlanQtUtilsWlanIap *iap, wlanIapList_) {

        // todo: secmode

        (void)secMode;

        if (iap->ssid() == ssid) {

            return true;

        }

    }

    return false;

}

void WlanQtUtilsPrivate::updateIapConnectionStatuses(int iapId, WlanQtUtilsConnectionStatus status)

{

    OstTraceFunctionEntry1( WLANQTUTILSPRIVATE_UPDATEIAPCONNECTIONSTATUSES_ENTRY, this );

    const WlanQtUtilsWlanIap *referenceIap = qobject_cast<WlanQtUtilsWlanIap *>(iap(iapId));

    foreach (WlanQtUtilsWlanIap *iap, wlanIapList_) {

        // todo: security mode checking

        if (iap->id() == referenceIap->id() || iap->ssid() == referenceIap->ssid()) {

            iap->setConnectionStatus(status);

        }

    }

    OstTraceFunctionExit1( WLANQTUTILSPRIVATE_UPDATEIAPCONNECTIONSTATUSES_EXIT, this );

}