#include <QtNetwork/qtcpsocket.h>

#include <QtNetwork/qtcpserver.h>

class TimedSender: public QThread

{

    Q_OBJECT

    qint64 totalBytes;

    QSemaphore ready;

    QByteArray dataToSend;

    QTcpSocket *client;

    int timeout;

    int port;

public:

    int transferRate;

    TimedSender(int ms)

        : totalBytes(0), timeout(ms), port(-1), transferRate(-1)

    {

        dataToSend = QByteArray(16*1024, '@');

        start();

        ready.acquire();

    }

    inline int serverPort() const { return port; }

private slots:

    void writeMore()

    {

        while (client->bytesToWrite() < 128 * 1024) {

            writePacket(dataToSend);

        }

    }

protected:

    void run()

    {

        QTcpServer server;

        server.listen();

        port = server.serverPort();

        ready.release();

        server.waitForNewConnection(-1);

        client = server.nextPendingConnection();

        writeMore();

        connect(client, SIGNAL(bytesWritten(qint64)), SLOT(writeMore()), Qt::DirectConnection);

        QEventLoop eventLoop;

        QTimer::singleShot(timeout, &eventLoop, SLOT(quit()));

        QTime timer;

        timer.start();

        eventLoop.exec();

        disconnect(client, SIGNAL(bytesWritten(qint64)), this, 0);

        // wait for the connection to shut down

        client->disconnectFromHost();

        if (!client->waitForDisconnected(10000))

            return;

        transferRate = totalBytes * 1000 / timer.elapsed();

        qDebug() << "TimedSender::run" << "receive rate:" << (transferRate / 1024) << "kB/s in"

                 << timer.elapsed() << "ms";

    }

    void writePacket(const QByteArray &array)

    {

        client->write(array);

        totalBytes += array.size();

    }

};

class QNetworkReplyPtr: public QSharedPointer<QNetworkReply>

{

public:

    inline QNetworkReplyPtr(QNetworkReply *ptr = 0)

        : QSharedPointer<QNetworkReply>(ptr)

    { }

    inline operator QNetworkReply *() const { return data(); }

};

class DataReader: public QObject

{

    Q_OBJECT

public:

    qint64 totalBytes;

    QByteArray data;

    QIODevice *device;

    bool accumulate;

    DataReader(QIODevice *dev, bool acc = true) : totalBytes(0), device(dev), accumulate(acc)

    {

        connect(device, SIGNAL(readyRead()), SLOT(doRead()));

    }

public slots:

    void doRead()

    {

        QByteArray buffer;

        buffer.resize(device->bytesAvailable());

        qint64 bytesRead = device->read(buffer.data(), device->bytesAvailable());

        if (bytesRead == -1) {

            QTestEventLoop::instance().exitLoop();

            return;

        }

        buffer.truncate(bytesRead);

        totalBytes += bytesRead;

        if (accumulate)

            data += buffer;

    }

};

class ThreadedDataReader: public QThread

{

    Q_OBJECT

    // used to make the constructor only return after the tcp server started listening

    QSemaphore ready;

    QTcpSocket *client;

    int timeout;

    int port;

public:

    qint64 transferRate;

    ThreadedDataReader()

        : port(-1), transferRate(-1)

    {

        start();

        ready.acquire();

    }

    inline int serverPort() const { return port; }

protected:

    void run()

    {

        QTcpServer server;

        server.listen();

        port = server.serverPort();

        ready.release();

        server.waitForNewConnection(-1);

        client = server.nextPendingConnection();

        QEventLoop eventLoop;

        DataReader reader(client, false);

        QObject::connect(client, SIGNAL(disconnected()), &eventLoop, SLOT(quit()));

        QTime timer;

        timer.start();

        eventLoop.exec();

        qint64 elapsed = timer.elapsed();

        transferRate = reader.totalBytes * 1000 / elapsed;

        qDebug() << "ThreadedDataReader::run" << "send rate:" << (transferRate / 1024) << "kB/s in" << elapsed << "msec";

    }

};

class DataGenerator: public QIODevice

{

    Q_OBJECT

    enum { Idle, Started, Stopped } state;

public:

    DataGenerator() : state(Idle)

    { open(ReadOnly); }

    virtual bool isSequential() const { return true; }

    virtual qint64 bytesAvailable() const { return state == Started ? 1024*1024 : 0; }

public slots:

    void start() { state = Started; emit readyRead(); }

    void stop() { state = Stopped; emit readyRead(); }

protected:

    virtual qint64 readData(char *data, qint64 maxlen)

    {

        if (state == Stopped)

            return -1;          // EOF

        // return as many bytes as are wanted

        memset(data, '@', maxlen);

        return maxlen;

    }

    virtual qint64 writeData(const char *, qint64)

    { return -1; }

};

class ThreadedDataReaderHttpServer: public QThread

{

    Q_OBJECT

    // used to make the constructor only return after the tcp server started listening

    QSemaphore ready;

    QTcpSocket *client;

    int timeout;

    int port;

public:

    qint64 transferRate;

    ThreadedDataReaderHttpServer()

        : port(-1), transferRate(-1)

    {

        start();

        ready.acquire();

    }

    inline int serverPort() const { return port; }

protected:

    void run()

    {

        QTcpServer server;

        server.listen();

        port = server.serverPort();

        ready.release();

        server.waitForNewConnection(-1);

        client = server.nextPendingConnection();

        client->write("HTTP/1.0 200 OK\r\n");

        client->write("Content-length: 0\r\n");

        client->write("\r\n");

        client->flush();

        QCoreApplication::processEvents();

        QEventLoop eventLoop;

        DataReader reader(client, false);

        QObject::connect(client, SIGNAL(disconnected()), &eventLoop, SLOT(quit()));

        QTime timer;

        timer.start();

        eventLoop.exec();

        qint64 elapsed = timer.elapsed();

        transferRate = reader.totalBytes * 1000 / elapsed;

        qDebug() << "ThreadedDataReaderHttpServer::run" << "send rate:" << (transferRate / 1024) << "kB/s in" << elapsed << "msec";

    }

};

class FixedSizeDataGenerator : public QIODevice

{

    Q_OBJECT

    enum { Idle, Started, Stopped } state;

public:

    FixedSizeDataGenerator(qint64 size) : state(Idle)

    { open(ReadOnly | Unbuffered);

      toBeGeneratedTotalCount = toBeGeneratedCount = size;

    }

    virtual qint64 bytesAvailable() const

    {

        return state == Started ? toBeGeneratedCount + QIODevice::bytesAvailable() : 0;

    }

    virtual bool isSequential() const{

        return false;

    }

    virtual bool reset() const{

        return false;

    }

    qint64 size() const {

        return toBeGeneratedTotalCount;

    }

public slots:

    void start() { state = Started; emit readyRead(); }

protected:

    virtual qint64 readData(char *data, qint64 maxlen)

    {

        memset(data, '@', maxlen);

        if (toBeGeneratedCount <= 0) {

            return -1;

        }

        qint64 n = qMin(maxlen, toBeGeneratedCount);

        toBeGeneratedCount -= n;

        if (toBeGeneratedCount <= 0) {

            // make sure this is a queued connection!

            emit readChannelFinished();

        }

        return n;

    }

    virtual qint64 writeData(const char *, qint64)

    { return -1; }

    qint64 toBeGeneratedCount;

    qint64 toBeGeneratedTotalCount;

};

class HttpDownloadPerformanceServer : QObject {

    Q_OBJECT;

    qint64 dataSize;

    qint64 dataSent;

    QTcpServer server;

    QTcpSocket *client;

    bool serverSendsContentLength;

    bool chunkedEncoding;

public:

    HttpDownloadPerformanceServer (qint64 ds, bool sscl, bool ce) : dataSize(ds), dataSent(0),

    client(0), serverSendsContentLength(sscl), chunkedEncoding(ce) {

        server.listen();

        connect(&server, SIGNAL(newConnection()), this, SLOT(newConnectionSlot()));

    }

    int serverPort() {

        return server.serverPort();

    }

public slots:

    void newConnectionSlot() {

        client = server.nextPendingConnection();

        client->setParent(this);

        connect(client, SIGNAL(readyRead()), this, SLOT(readyReadSlot()));

        connect(client, SIGNAL(bytesWritten(qint64)), this, SLOT(bytesWrittenSlot(qint64)));

    }

    void readyReadSlot() {

        client->readAll();

        client->write("HTTP/1.0 200 OK\n");

        if (serverSendsContentLength)

            client->write(QString("Content-Length: " + QString::number(dataSize) + "\n").toAscii());

        if (chunkedEncoding)

            client->write(QString("Transfer-Encoding: chunked\n").toAscii());

        client->write("Connection: close\n\n");

    }

    void bytesWrittenSlot(qint64 amount) {

        Q_UNUSED(amount);

        if (dataSent == dataSize && client) {

            // close eventually

            // chunked encoding: we have to send a last "empty" chunk

            if (chunkedEncoding)

                client->write(QString("0\r\n\r\n").toAscii());

            client->disconnectFromHost();

            server.close();

            client = 0;

            return;

        }

        // send data

        if (client && client->bytesToWrite() < 100*1024 && dataSent < dataSize) {

            qint64 amount = qMin(qint64(16*1024), dataSize - dataSent);

            QByteArray data(amount, '@');

            if (chunkedEncoding) {

                client->write(QString(QString("%1").arg(amount,0,16).toUpper() + "\r\n").toAscii());

                client->write(data.constData(), amount);

                client->write(QString("\r\n").toAscii());

            } else {

                client->write(data.constData(), amount);

            }

            dataSent += amount;

        }

    }

};

class HttpDownloadPerformanceClient : QObject {

    Q_OBJECT;

    QIODevice *device;

    public:

    HttpDownloadPerformanceClient (QIODevice *dev) : device(dev){

        connect(dev, SIGNAL(readyRead()), this, SLOT(readyReadSlot()));

    }

    public slots:

    void readyReadSlot() {

        device->readAll();

    }

};

    QNetworkAccessManager manager;

    void downloadPerformance();

    void uploadPerformance();

    void performanceControlRate();

    void httpUploadPerformance();

    void httpDownloadPerformance_data();

    void httpDownloadPerformance();