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

**

** 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 examples 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 <QtNetwork>

#include "client.h"

#include "connection.h"

#include "peermanager.h"

static const qint32 BroadcastInterval = 2000;

static const unsigned broadcastPort = 45000;

PeerManager::PeerManager(Client *client)

    : QObject(client)

{

    this->client = client;

    QStringList envVariables;

    envVariables << "USERNAME.*" << "USER.*" << "USERDOMAIN.*"

                 << "HOSTNAME.*" << "DOMAINNAME.*";

    QStringList environment = QProcess::systemEnvironment();

    foreach (QString string, envVariables) {

        int index = environment.indexOf(QRegExp(string));

        if (index != -1) {

            QStringList stringList = environment.at(index).split('=');

            if (stringList.size() == 2) {

                username = stringList.at(1).toUtf8();

                break;

            }

        }

    }

    if (username.isEmpty())

#ifndef Q_OS_SYMBIAN

        username = "unknown";

#else

        username = "QtS60";

#endif

    updateAddresses();

    serverPort = 0;

    broadcastSocket.bind(QHostAddress::Any, broadcastPort, QUdpSocket::ShareAddress

                         | QUdpSocket::ReuseAddressHint);

    connect(&broadcastSocket, SIGNAL(readyRead()),

            this, SLOT(readBroadcastDatagram()));

    broadcastTimer.setInterval(BroadcastInterval);

    connect(&broadcastTimer, SIGNAL(timeout()),

            this, SLOT(sendBroadcastDatagram()));

}

void PeerManager::setServerPort(int port)

{

    serverPort = port;

}

QByteArray PeerManager::userName() const

{

    return username;

}

void PeerManager::startBroadcasting()

{

    broadcastTimer.start();

}

bool PeerManager::isLocalHostAddress(const QHostAddress &address)

{

    foreach (QHostAddress localAddress, ipAddresses) {

        if (address == localAddress)

            return true;

    }

    return false;

}

void PeerManager::sendBroadcastDatagram()

{

    QByteArray datagram(username);

    datagram.append('@');

    datagram.append(QByteArray::number(serverPort));

    bool validBroadcastAddresses = true;

    foreach (QHostAddress address, broadcastAddresses) {

        if (broadcastSocket.writeDatagram(datagram, address,

                                          broadcastPort) == -1)

            validBroadcastAddresses = false;

    }

    if (!validBroadcastAddresses)

        updateAddresses();

}

void PeerManager::readBroadcastDatagram()

{

    while (broadcastSocket.hasPendingDatagrams()) {

        QHostAddress senderIp;

        quint16 senderPort;

        QByteArray datagram;

        datagram.resize(broadcastSocket.pendingDatagramSize());

        if (broadcastSocket.readDatagram(datagram.data(), datagram.size(),

                                         &senderIp, &senderPort) == -1)

            continue;

        QList<QByteArray> list = datagram.split('@');

        if (list.size() != 2)

            continue;

        int senderServerPort = list.at(1).toInt();

        if (isLocalHostAddress(senderIp) && senderServerPort == serverPort)

            continue;

        if (!client->hasConnection(senderIp)) {

            Connection *connection = new Connection(this);

            emit newConnection(connection);

            connection->connectToHost(senderIp, senderServerPort);

        }

    }

}

void PeerManager::updateAddresses()

{

    broadcastAddresses.clear();

    ipAddresses.clear();

    foreach (QNetworkInterface interface, QNetworkInterface::allInterfaces()) {

        foreach (QNetworkAddressEntry entry, interface.addressEntries()) {

            QHostAddress broadcastAddress = entry.broadcast();

            if (broadcastAddress != QHostAddress::Null && entry.ip() != QHostAddress::LocalHost) {

                broadcastAddresses << broadcastAddress;

                ipAddresses << entry.ip();

            }

        }

    }

}