/****************************************************************************
**
** Copyright (C) 2019 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the examples of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:BSD$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** BSD License Usage
** Alternatively, you may use this file under the terms of the BSD license
** as follows:
**
** "Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions are
** met:
**   * Redistributions of source code must retain the above copyright
**     notice, this list of conditions and the following disclaimer.
**   * Redistributions in binary form must reproduce the above copyright
**     notice, this list of conditions and the following disclaimer in
**     the documentation and/or other materials provided with the
**     distribution.
**   * Neither the name of The Qt Company Ltd nor the names of its
**     contributors may be used to endorse or promote products derived
**     from this software without specific prior written permission.
**
**
** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
**
** $QT_END_LICENSE$
**
****************************************************************************/

// Simple QRhiProfiler receiver app. Start it and then in a QRhi-based
// application connect with a QTcpSocket to 127.0.0.1:30667 and set that as the
// QRhiProfiler's device.

#include <QTcpServer>
#include <QTcpSocket>
#include <QApplication>
#include <QWidget>
#include <QVBoxLayout>
#include <QGroupBox>
#include <QTextEdit>
#include <QLabel>
#include <QTime>
#include <QtGui/private/qrhiprofiler_p.h>

const int MIN_KNOWN_OP = 1;
const int MAX_KNOWN_OP = 18;

class Parser : public QObject
{
    Q_OBJECT

public:
    void feed(const QByteArray &line);

    struct Event {
        QRhiProfiler::StreamOp op;
        qint64 timestamp;
        quint64 resource;
        QByteArray resourceName;

        struct Param {
            enum ValueType {
                Int64,
                Float
            };
            QByteArray key;
            ValueType valueType;
            union {
                qint64 intValue;
                float floatValue;
            };
        };

        QVector<Param> params;

        const Param *param(const char *key) const {
            auto it = std::find_if(params.cbegin(), params.cend(), [key](const Param &p) {
                return !strcmp(p.key.constData(), key);
            });
            return it == params.cend() ? nullptr : &*it;
        }
    };

signals:
    void eventReceived(const Event &e);
};

void Parser::feed(const QByteArray &line)
{
    const QList<QByteArray> elems = line.split(',');
    if (elems.count() < 4) {
        qWarning("Malformed line '%s'", line.constData());
        return;
    }
    bool ok = false;
    const int op = elems[0].toInt(&ok);
    if (!ok) {
        qWarning("Invalid op %s", elems[0].constData());
        return;
    }
    if (op < MIN_KNOWN_OP || op > MAX_KNOWN_OP) {
        qWarning("Unknown op %d", op);
        return;
    }

    Event e;
    e.op = QRhiProfiler::StreamOp(op);
    e.timestamp = elems[1].toLongLong();
    e.resource = elems[2].toULongLong();
    e.resourceName = elems[3];

    const int elemCount = elems.count();
    for (int i = 4; i < elemCount; i += 2) {
        if (i + 1 < elemCount && !elems[i].isEmpty() && !elems[i + 1].isEmpty()) {
            QByteArray key = elems[i];
            if (key.startsWith('F')) {
                key = key.mid(1);
                bool ok = false;
                const float value = elems[i + 1].toFloat(&ok);
                if (!ok) {
                    qWarning("Failed to parse float %s in line '%s'", elems[i + 1].constData(), line.constData());
                    continue;
                }
                Event::Param param;
                param.key = key;
                param.valueType = Event::Param::Float;
                param.floatValue = value;
                e.params.append(param);
            } else {
                const qint64 value = elems[i + 1].toLongLong();
                Event::Param param;
                param.key = key;
                param.valueType = Event::Param::Int64;
                param.intValue = value;
                e.params.append(param);
            }
        }
    }

    emit eventReceived(e);
}

class Tracker : public QObject
{
    Q_OBJECT

public slots:
    void handleEvent(const Parser::Event &e);

signals:
    void buffersTouched();
    void texturesTouched();
    void swapchainsTouched();
    void frameTimeTouched();
    void gpuFrameTimeTouched();
    void gpuMemAllocStatsTouched();

public:
    Tracker() {
        reset();
    }

    static const int MAX_STAGING_SLOTS = 3;

    struct Buffer {
        Buffer()
        {
            memset(stagingExtraSize, 0, sizeof(stagingExtraSize));
        }
        quint64 lastTimestamp;
        QByteArray resourceName;
        qint64 effectiveSize = 0;
        int backingGpuBufCount = 1;
        qint64 stagingExtraSize[MAX_STAGING_SLOTS];
    };
    QHash<qint64, Buffer> m_buffers;
    qint64 m_totalBufferApproxByteSize;
    qint64 m_peakBufferApproxByteSize;
    qint64 m_totalStagingBufferApproxByteSize;
    qint64 m_peakStagingBufferApproxByteSize;

    struct Texture {
        Texture()
        {
            memset(stagingExtraSize, 0, sizeof(stagingExtraSize));
        }
        quint64 lastTimestamp;
        QByteArray resourceName;
        qint64 approxByteSize = 0;
        bool ownsNativeResource = true;
        qint64 stagingExtraSize[MAX_STAGING_SLOTS];
    };
    QHash<qint64, Texture> m_textures;
    qint64 m_totalTextureApproxByteSize;
    qint64 m_peakTextureApproxByteSize;
    qint64 m_totalTextureStagingBufferApproxByteSize;
    qint64 m_peakTextureStagingBufferApproxByteSize;

    struct SwapChain {
        quint64 lastTimestamp;
        QByteArray resourceName;
        qint64 approxByteSize = 0;
    };
    QHash<qint64, SwapChain> m_swapchains;
    qint64 m_totalSwapChainApproxByteSize;
    qint64 m_peakSwapChainApproxByteSize;

    struct FrameTime {
        qint64 framesSinceResize = 0;
        int minDelta = 0;
        int maxDelta = 0;
        float avgDelta = 0;
    };
    FrameTime m_lastFrameTime;

    struct GpuFrameTime {
        float minTime = 0;
        float maxTime = 0;
        float avgTime = 0;
    };
    GpuFrameTime m_lastGpuFrameTime;

    struct GpuMemAllocStats {
        qint64 realAllocCount;
        qint64 subAllocCount;
        qint64 totalSize;
        qint64 unusedSize;
    };
    GpuMemAllocStats m_lastGpuMemAllocStats;

    void reset() {
        m_buffers.clear();
        m_textures.clear();
        m_totalBufferApproxByteSize = 0;
        m_peakBufferApproxByteSize = 0;
        m_totalStagingBufferApproxByteSize = 0;
        m_peakStagingBufferApproxByteSize = 0;
        m_totalTextureApproxByteSize = 0;
        m_peakTextureApproxByteSize = 0;
        m_totalTextureStagingBufferApproxByteSize = 0;
        m_peakTextureStagingBufferApproxByteSize = 0;
        m_totalSwapChainApproxByteSize = 0;
        m_peakSwapChainApproxByteSize = 0;
        m_lastFrameTime = FrameTime();
        m_lastGpuFrameTime = GpuFrameTime();
        m_lastGpuMemAllocStats = GpuMemAllocStats();
        emit buffersTouched();
        emit texturesTouched();
        emit swapchainsTouched();
        emit frameTimeTouched();
        emit gpuFrameTimeTouched();
        emit gpuMemAllocStatsTouched();
    }
};

Q_DECLARE_TYPEINFO(Tracker::Buffer, Q_MOVABLE_TYPE);
Q_DECLARE_TYPEINFO(Tracker::Texture, Q_MOVABLE_TYPE);
Q_DECLARE_TYPEINFO(Tracker::FrameTime, Q_MOVABLE_TYPE);
Q_DECLARE_TYPEINFO(Tracker::GpuFrameTime, Q_MOVABLE_TYPE);

void Tracker::handleEvent(const Parser::Event &e)
{
    switch (e.op) {
    case QRhiProfiler::NewBuffer:
    {
        Buffer b;
        b.lastTimestamp = e.timestamp;
        b.resourceName = e.resourceName;
        // type,0,usage,1,logical_size,84,effective_size,84,backing_gpu_buf_count,1,backing_cpu_buf_count,0
        for (const Parser::Event::Param &p : e.params) {
            if (p.key == QByteArrayLiteral("effective_size"))
                b.effectiveSize = p.intValue;
            else if (p.key == QByteArrayLiteral("backing_gpu_buf_count"))
                b.backingGpuBufCount = p.intValue;
        }
        m_totalBufferApproxByteSize += b.effectiveSize * b.backingGpuBufCount;
        m_peakBufferApproxByteSize = qMax(m_peakBufferApproxByteSize, m_totalBufferApproxByteSize);
        m_buffers.insert(e.resource, b);
        emit buffersTouched();
    }
        break;
    case QRhiProfiler::ReleaseBuffer:
    {
        auto it = m_buffers.find(e.resource);
        if (it != m_buffers.end()) {
            m_totalBufferApproxByteSize -= it->effectiveSize * it->backingGpuBufCount;
            m_buffers.erase(it);
            emit buffersTouched();
        }
    }
        break;

    case QRhiProfiler::NewBufferStagingArea:
    {
        qint64 slot = -1;
        qint64 size = 0;
        for (const Parser::Event::Param &p : e.params) {
            if (p.key == QByteArrayLiteral("slot"))
                slot = p.intValue;
            else if (p.key == QByteArrayLiteral("size"))
                size = p.intValue;
        }
        if (slot >= 0 && slot < MAX_STAGING_SLOTS) {
            auto it = m_buffers.find(e.resource);
            if (it != m_buffers.end()) {
                it->stagingExtraSize[slot] = size;
                m_totalStagingBufferApproxByteSize += size;
                m_peakStagingBufferApproxByteSize = qMax(m_peakStagingBufferApproxByteSize, m_totalStagingBufferApproxByteSize);
                emit buffersTouched();
            }
        }
    }
        break;
    case QRhiProfiler::ReleaseBufferStagingArea:
    {
        qint64 slot = -1;
        for (const Parser::Event::Param &p : e.params) {
            if (p.key == QByteArrayLiteral("slot"))
                slot = p.intValue;
        }
        if (slot >= 0 && slot < MAX_STAGING_SLOTS) {
            auto it = m_buffers.find(e.resource);
            if (it != m_buffers.end()) {
                m_totalStagingBufferApproxByteSize -= it->stagingExtraSize[slot];
                it->stagingExtraSize[slot] = 0;
                emit buffersTouched();
            }
        }
    }
        break;

    case QRhiProfiler::NewTexture:
    {
        Texture t;
        t.lastTimestamp = e.timestamp;
        t.resourceName = e.resourceName;
        // width,256,height,256,format,1,owns_native_resource,1,mip_count,9,layer_count,1,effective_sample_count,1,approx_byte_size,349524
        for (const Parser::Event::Param &p : e.params) {
            if (p.key == QByteArrayLiteral("approx_byte_size"))
                t.approxByteSize = p.intValue;
            else if (p.key == QByteArrayLiteral("owns_native_resource"))
                t.ownsNativeResource = p.intValue;
        }
        if (t.ownsNativeResource) {
            m_totalTextureApproxByteSize += t.approxByteSize;
            m_peakTextureApproxByteSize = qMax(m_peakTextureApproxByteSize, m_totalTextureApproxByteSize);
        }
        m_textures.insert(e.resource, t);
        emit texturesTouched();
    }
        break;
    case QRhiProfiler::ReleaseTexture:
    {
        auto it = m_textures.find(e.resource);
        if (it != m_textures.end()) {
            if (it->ownsNativeResource)
                m_totalTextureApproxByteSize -= it->approxByteSize;
            m_textures.erase(it);
            emit texturesTouched();
        }
    }
        break;

    case QRhiProfiler::NewTextureStagingArea:
    {
        qint64 slot = -1;
        qint64 size = 0;
        for (const Parser::Event::Param &p : e.params) {
            if (p.key == QByteArrayLiteral("slot"))
                slot = p.intValue;
            else if (p.key == QByteArrayLiteral("size"))
                size = p.intValue;
        }
        if (slot >= 0 && slot < MAX_STAGING_SLOTS) {
            auto it = m_textures.find(e.resource);
            if (it != m_textures.end()) {
                it->stagingExtraSize[slot] = size;
                m_totalTextureStagingBufferApproxByteSize += size;
                m_peakTextureStagingBufferApproxByteSize = qMax(m_peakTextureStagingBufferApproxByteSize, m_totalTextureStagingBufferApproxByteSize);
                emit texturesTouched();
            }
        }
    }
        break;
    case QRhiProfiler::ReleaseTextureStagingArea:
    {
        qint64 slot = -1;
        for (const Parser::Event::Param &p : e.params) {
            if (p.key == QByteArrayLiteral("slot"))
                slot = p.intValue;
        }
        if (slot >= 0 && slot < MAX_STAGING_SLOTS) {
            auto it = m_textures.find(e.resource);
            if (it != m_textures.end()) {
                m_totalTextureStagingBufferApproxByteSize -= it->stagingExtraSize[slot];
                it->stagingExtraSize[slot] = 0;
                emit texturesTouched();
            }
        }
    }
        break;

    case QRhiProfiler::ResizeSwapChain:
    {
        auto it = m_swapchains.find(e.resource);
        if (it != m_swapchains.end())
            m_totalSwapChainApproxByteSize -= it->approxByteSize;

        SwapChain s;
        s.lastTimestamp = e.timestamp;
        s.resourceName = e.resourceName;
        // width,1280,height,720,buffer_count,2,msaa_buffer_count,0,effective_sample_count,1,approx_total_byte_size,7372800
        for (const Parser::Event::Param &p : e.params) {
            if (p.key == QByteArrayLiteral("approx_total_byte_size"))
                s.approxByteSize = p.intValue;
        }
        m_totalSwapChainApproxByteSize += s.approxByteSize;
        m_peakSwapChainApproxByteSize = qMax(m_peakSwapChainApproxByteSize, m_totalSwapChainApproxByteSize);
        m_swapchains.insert(e.resource, s);
        emit swapchainsTouched();
    }
        break;
    case QRhiProfiler::ReleaseSwapChain:
    {
        auto it = m_swapchains.find(e.resource);
        if (it != m_swapchains.end()) {
            m_totalSwapChainApproxByteSize -= it->approxByteSize;
            m_swapchains.erase(it);
            emit swapchainsTouched();
        }
    }
        break;

    case QRhiProfiler::GpuFrameTime:
    {
        // Fmin_ms_gpu_frame_time,0.15488,Fmax_ms_gpu_frame_time,0.494592,Favg_ms_gpu_frame_time,0.33462
        for (const Parser::Event::Param &p : e.params) {
            if (p.key == QByteArrayLiteral("min_ms_gpu_frame_time"))
                m_lastGpuFrameTime.minTime = p.floatValue;
            else if (p.key == QByteArrayLiteral("max_ms_gpu_frame_time"))
                m_lastGpuFrameTime.maxTime = p.floatValue;
            else if (p.key == QByteArrayLiteral("avg_ms_gpu_frame_time"))
                m_lastGpuFrameTime.avgTime = p.floatValue;
        }
        emit gpuFrameTimeTouched();
    }
        break;
    case QRhiProfiler::FrameToFrameTime:
    {
        // frames_since_resize,121,min_ms_frame_delta,9,max_ms_frame_delta,33,Favg_ms_frame_delta,16.1167
        for (const Parser::Event::Param &p : e.params) {
            if (p.key == QByteArrayLiteral("frames_since_resize"))
                m_lastFrameTime.framesSinceResize = p.intValue;
            else if (p.key == QByteArrayLiteral("min_ms_frame_delta"))
                m_lastFrameTime.minDelta = p.intValue;
            else if (p.key == QByteArrayLiteral("max_ms_frame_delta"))
                m_lastFrameTime.maxDelta = p.intValue;
            else if (p.key == QByteArrayLiteral("avg_ms_frame_delta"))
                m_lastFrameTime.avgDelta = p.floatValue;
        }
        emit frameTimeTouched();
    }
        break;

    case QRhiProfiler::GpuMemAllocStats:
    {
        // real_alloc_count,2,sub_alloc_count,154,total_size,10752,unused_size,50320896
        for (const Parser::Event::Param &p : e.params) {
            if (p.key == QByteArrayLiteral("real_alloc_count"))
                m_lastGpuMemAllocStats.realAllocCount = p.intValue;
            else if (p.key == QByteArrayLiteral("sub_alloc_count"))
                m_lastGpuMemAllocStats.subAllocCount = p.intValue;
            else if (p.key == QByteArrayLiteral("total_size"))
                m_lastGpuMemAllocStats.totalSize = p.intValue;
            else if (p.key == QByteArrayLiteral("unused_size"))
                m_lastGpuMemAllocStats.unusedSize = p.intValue;
        }
        emit gpuMemAllocStatsTouched();
    }
        break;

    default:
        break;
    }
}

class Server : public QTcpServer
{
    Q_OBJECT

protected:
    void incomingConnection(qintptr socketDescriptor) override;

signals:
    void clientConnected();
    void clientDisconnected();
    void receiveStarted();
    void lineReceived(const QByteArray &line);

private:
    bool m_valid = false;
    QTcpSocket m_socket;
    QByteArray m_buf;
};

void Server::incomingConnection(qintptr socketDescriptor)
{
    if (m_valid)
        return;

    m_socket.setSocketDescriptor(socketDescriptor);
    m_valid = true;
    emit clientConnected();
    connect(&m_socket, &QAbstractSocket::readyRead, this, [this] {
        bool receiveStartedSent = false;
        m_buf += m_socket.readAll();
        while (m_buf.contains('\n')) {
            const int lfpos = m_buf.indexOf('\n');
            const QByteArray line = m_buf.left(lfpos).trimmed();
            m_buf = m_buf.mid(lfpos + 1);
            if (!receiveStartedSent) {
                receiveStartedSent = true;
                emit receiveStarted();
            }
            emit lineReceived(line);
        }
    });
    connect(&m_socket, &QAbstractSocket::disconnected, this, [this] {
        if (m_valid) {
            m_valid = false;
            emit clientDisconnected();
        }
    });
}

int main(int argc, char **argv)
{
    QApplication app(argc, argv);

    Tracker tracker;
    Parser parser;
    QObject::connect(&parser, &Parser::eventReceived, &tracker, &Tracker::handleEvent);

    Server server;
    if (!server.listen(QHostAddress::Any, 30667))
        qFatal("Failed to start server: %s", qPrintable(server.errorString()));

    QVBoxLayout *layout = new QVBoxLayout;

    QLabel *infoLabel = new QLabel(QLatin1String("<i>Launch a Qt Quick application with QSG_RHI_PROFILE=1 and QSG_RHI_PROFILE_HOST set to the IP address.<br>"
                                                 "(resource memory usage reporting works best with the Vulkan backend)</i>"));
    layout->addWidget(infoLabel);

    QGroupBox *groupBox = new QGroupBox(QLatin1String("RHI statistics"));
    QVBoxLayout *groupLayout = new QVBoxLayout;

    QLabel *buffersLabel = new QLabel;
    QObject::connect(&tracker, &Tracker::buffersTouched, buffersLabel, [buffersLabel, &tracker] {
        const QString msg = QString::asprintf("%d buffers with ca. %lld bytes of current memory (sub)allocations (peak %lld) + %lld bytes of known staging buffers (peak %lld)",
                                              tracker.m_buffers.count(),
                                              tracker.m_totalBufferApproxByteSize, tracker.m_peakBufferApproxByteSize,
                                              tracker.m_totalStagingBufferApproxByteSize, tracker.m_peakStagingBufferApproxByteSize);
        buffersLabel->setText(msg);
    });
    groupLayout->addWidget(buffersLabel);

    QLabel *texturesLabel = new QLabel;
    QObject::connect(&tracker, &Tracker::texturesTouched, texturesLabel, [texturesLabel, &tracker] {
        const QString msg = QString::asprintf("%d textures with ca. %lld bytes of current memory (sub)allocations (peak %lld) + %lld bytes of known staging buffers (peak %lld)",
                                              tracker.m_textures.count(),
                                              tracker.m_totalTextureApproxByteSize, tracker.m_peakTextureApproxByteSize,
                                              tracker.m_totalTextureStagingBufferApproxByteSize, tracker.m_peakTextureStagingBufferApproxByteSize);
        texturesLabel->setText(msg);
    });
    groupLayout->addWidget(texturesLabel);

    QLabel *swapchainsLabel = new QLabel;
    QObject::connect(&tracker, &Tracker::swapchainsTouched, swapchainsLabel, [swapchainsLabel, &tracker] {
        const QString msg = QString::asprintf("Estimated total swapchain color buffer size is %lld bytes (peak %lld)",
                                              tracker.m_totalSwapChainApproxByteSize, tracker.m_peakSwapChainApproxByteSize);
        swapchainsLabel->setText(msg);
    });
    groupLayout->addWidget(swapchainsLabel);

    QLabel *frameTimeLabel = new QLabel;
    QObject::connect(&tracker, &Tracker::frameTimeTouched, frameTimeLabel, [frameTimeLabel, &tracker] {
        const QString msg = QString::asprintf("Frames since resize %lld Frame delta min %d ms max %d ms avg %f ms",
                                              tracker.m_lastFrameTime.framesSinceResize,
                                              tracker.m_lastFrameTime.minDelta,
                                              tracker.m_lastFrameTime.maxDelta,
                                              tracker.m_lastFrameTime.avgDelta);
        frameTimeLabel->setText(msg);
    });
    groupLayout->addWidget(frameTimeLabel);

    QLabel *gpuFrameTimeLabel = new QLabel;
    QObject::connect(&tracker, &Tracker::gpuFrameTimeTouched, gpuFrameTimeLabel, [gpuFrameTimeLabel, &tracker] {
        const QString msg = QString::asprintf("GPU frame time min %f ms max %f ms avg %f ms",
                                              tracker.m_lastGpuFrameTime.minTime,
                                              tracker.m_lastGpuFrameTime.maxTime,
                                              tracker.m_lastGpuFrameTime.avgTime);
        gpuFrameTimeLabel->setText(msg);
    });
    groupLayout->addWidget(gpuFrameTimeLabel);

    QLabel *gpuMemAllocStatsLabel = new QLabel;
    QObject::connect(&tracker, &Tracker::gpuMemAllocStatsTouched, gpuMemAllocStatsLabel, [gpuMemAllocStatsLabel, &tracker] {
        const QString msg = QString::asprintf("GPU memory allocator status: %lld real allocations %lld sub-allocations %lld total bytes %lld unused bytes",
                                              tracker.m_lastGpuMemAllocStats.realAllocCount,
                                              tracker.m_lastGpuMemAllocStats.subAllocCount,
                                              tracker.m_lastGpuMemAllocStats.totalSize,
                                              tracker.m_lastGpuMemAllocStats.unusedSize);
        gpuMemAllocStatsLabel->setText(msg);
    });
    groupLayout->addWidget(gpuMemAllocStatsLabel);

    groupBox->setLayout(groupLayout);
    layout->addWidget(groupBox);

    QTextEdit *rawLog = new QTextEdit;
    rawLog->setReadOnly(true);
    layout->addWidget(rawLog);

    QObject::connect(&server, &Server::clientConnected, rawLog, [rawLog] {
        rawLog->append(QLatin1String("\nCONNECTED\n"));
    });
    QObject::connect(&server, &Server::clientDisconnected, rawLog, [rawLog, &tracker] {
        rawLog->append(QLatin1String("\nDISCONNECTED\n"));
        tracker.reset();
    });
    QObject::connect(&server, &Server::receiveStarted, rawLog, [rawLog] {
        rawLog->setFontItalic(true);
        rawLog->append(QLatin1String("[") + QTime::currentTime().toString() + QLatin1String("]"));
        rawLog->setFontItalic(false);
    });

    QObject::connect(&server, &Server::lineReceived, rawLog, [rawLog, &parser](const QByteArray &line) {
        rawLog->append(QString::fromUtf8(line));
        parser.feed(line);
    });

    QWidget w;
    w.resize(800, 600);
    w.setLayout(layout);
    w.show();

    return app.exec();
}

#include "qrhiprof.moc"