usagereportingmanager.cpp

#include "usagereportingmanager.h"

#include <QDebug>
#include <QEventLoop>
#include <QJsonDocument>
#include <QJsonObject>
#include <QJsonParseError>
#include <QNetworkAccessManager>
#include <QNetworkReply>
#include <QNetworkRequest>
#include <QTimer>
#include <QUuid>

// ─────────────────────────────────────────────────────────────
//  Construction
// ─────────────────────────────────────────────────────────────
QString UsageReportingManager::generateSessionId()
{
    return QUuid::createUuid().toString(QUuid::WithoutBraces);
}

UsageReportingManager::UsageReportingManager(QObject* parent)
    : QObject(parent)
    , m_nam(new QNetworkAccessManager(this))
    , m_sessionId(generateSessionId())
    , m_serverUrl(QString::fromLatin1(kDefaultServerUrl))
{
    qDebug() << "TrackClick usage: session id" << m_sessionId;
}

UsageReportingManager::~UsageReportingManager()
{
    // Normally a no-op: MainWindow calls shutdown() from aboutToQuit, while the
    // event loop is still healthy.  This is the safety net for teardown paths
    // that never reach that signal.
    shutdown();
}

// ─────────────────────────────────────────────────────────────
//  Public API
// ─────────────────────────────────────────────────────────────
void UsageReportingManager::sendStartupReport()
{
    if (!m_reportingEnabled) return;   // user opted out — send nothing

    post(QLatin1String(kStartupPath), serializeStartupPayload(), [this](bool success) {
        m_startupReportSent = success;
        emit startupReportFinished(success, m_lastStartupResponse);
    });
}

void UsageReportingManager::sendClickModeReport(const ClickModeReportPayload& payload)
{
    // Still track the mode locally so that a user who opts back in later reports
    // the mode the session is actually in, but send nothing while opted out.
    m_lastClickMode = payload.clickingMode;
    if (!m_reportingEnabled) return;

    post(QLatin1String(kClickModePath), serializeClickModePayload(payload), [this](bool success) {
        m_clickModeReportSent = success;
        emit clickModeReportFinished(success, m_lastClickModeResponse);
    });
}

void UsageReportingManager::shutdown()
{
    if (m_shuttingDown)
        return;
    m_shuttingDown = true;

    // Opted out: skip the catch-up posts entirely.  Without this the opt-out
    // would leak both reports on every quit, since the block below deliberately
    // sends whatever has not been reported yet.
    if (!m_reportingEnabled)
        return;

    waitForPending();

    if (!m_startupReportSent)
        m_startupReportSent = postBlocking(QLatin1String(kStartupPath), serializeStartupPayload());

    // Sent even when the user never switched modes: /startup records the mode the
    // session opened with, this one records the mode it ended on.
    if (!m_clickModeReportSent) {
        ClickModeReportPayload payload;
        payload.softwareType = m_startupPayload.softwareType;
        payload.clickingMode = m_lastClickMode;
        m_clickModeReportSent = postBlocking(QLatin1String(kClickModePath),
                                             serializeClickModePayload(payload));
    }
}

// ─────────────────────────────────────────────────────────────
//  Request plumbing
// ─────────────────────────────────────────────────────────────
QUrl UsageReportingManager::urlFor(const QString& path) const
{
    QString spec = m_serverUrl.trimmed();
    if (spec.isEmpty())
        return QUrl();
    if (!spec.contains(QLatin1String("://")))
        spec.prepend(QLatin1String("http://"));

    QUrl url(spec, QUrl::StrictMode);
    if (!url.isValid() || url.host().isEmpty())
        return QUrl();

    // Keep any base path the endpoint carries, then append the report path.
    QString base = url.path();
    while (base.endsWith(QLatin1Char('/')))
        base.chop(1);
    url.setPath(base + path);
    url.setQuery(QString());
    url.setFragment(QString());
    return url;
}

QNetworkReply* UsageReportingManager::startPost(const QString& path, const QByteArray& body,
                                                int timeoutMs)
{
    const QUrl url = urlFor(path);
    if (!url.isValid()) {
        qWarning() << "TrackClick usage: invalid server URL:" << m_serverUrl;
        return nullptr;
    }

    QNetworkRequest request(url);
    request.setHeader(QNetworkRequest::ContentTypeHeader, QStringLiteral("application/json"));

    qDebug() << "TrackClick usage: POST" << url.toString() << body;

    QNetworkReply* reply = m_nam->post(request, body);
    if (!reply)
        return nullptr;

    // Qt's own transfer timeout only exists from 5.15, and TrackClick still
    // builds against 5.12 — abort on our own timer instead so a hung server
    // can never wedge the caller (or app exit).
    QTimer* abortTimer = new QTimer(reply);
    abortTimer->setSingleShot(true);
    connect(abortTimer, &QTimer::timeout, reply, &QNetworkReply::abort);
    abortTimer->start(timeoutMs);

    return reply;
}

void UsageReportingManager::post(const QString& path, const QByteArray& body,
                                 std::function<void(bool)> done)
{
    QNetworkReply* reply = startPost(path, body, kRequestTimeoutMs);
    if (!reply) {
        done(false);
        return;
    }

    m_pending.insert(reply);
    connect(reply, &QNetworkReply::finished, this,
            [this, path, reply, done = std::move(done)]() mutable {
        m_pending.remove(reply);
        const bool success = handleReply(path, reply);
        reply->deleteLater();
        done(success);
    });
}

bool UsageReportingManager::postBlocking(const QString& path, const QByteArray& body)
{
    QNetworkReply* reply = startPost(path, body, kShutdownTimeoutMs);
    if (!reply)
        return false;

    QEventLoop loop;
    connect(reply, &QNetworkReply::finished, &loop, &QEventLoop::quit);
    if (!reply->isFinished())
        loop.exec(QEventLoop::ExcludeUserInputEvents);

    const bool success = handleReply(path, reply);
    reply->deleteLater();   // owned by m_nam either way, so never leaked
    return success;
}

void UsageReportingManager::waitForPending()
{
    if (m_pending.isEmpty())
        return;

    QEventLoop loop;
    QTimer budget;
    budget.setSingleShot(true);
    connect(&budget, &QTimer::timeout, &loop, &QEventLoop::quit);
    budget.start(kShutdownTimeoutMs);

    // The replies' finished handlers run inside this loop; poll for the set
    // draining rather than tracking each one individually.
    QTimer drained;
    connect(&drained, &QTimer::timeout, &loop, [this, &loop] {
        if (m_pending.isEmpty())
            loop.quit();
    });
    drained.start(25);

    loop.exec(QEventLoop::ExcludeUserInputEvents);

    // Give up on anything still in flight (iterating a copy: aborting completes
    // the reply, whose handler mutates m_pending).
    const QSet<QNetworkReply*> stragglers = m_pending;
    for (QNetworkReply* reply : stragglers)
        reply->abort();
}

bool UsageReportingManager::handleReply(const QString& path, QNetworkReply* reply)
{
    const QVariant statusAttr = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute);
    const QByteArray responseBody = reply->readAll();

    // No status at all means the request never reached the server (DNS, refused
    // connection, our abort timer, …).
    if (!statusAttr.isValid()) {
        qWarning() << "TrackClick usage: POST" << path << "failed:" << reply->errorString();
        return false;
    }

    const int status = statusAttr.toInt();
    if (status != 200 && status != 201) {
        qWarning() << "TrackClick usage: POST" << path << "returned status" << status;
        return false;
    }

    qDebug() << "TrackClick usage: POST" << path << "ok:" << responseBody;

    // A malformed or empty body is not a delivery failure — the report landed.
    if (path == QLatin1String(kStartupPath))
        parseStartupResponse(responseBody, m_lastStartupResponse);
    else if (path == QLatin1String(kClickModePath))
        parseClickModeResponse(responseBody, m_lastClickModeResponse);

    return true;
}

// ─────────────────────────────────────────────────────────────
//  JSON
// ─────────────────────────────────────────────────────────────
bool UsageReportingManager::parseStartupResponse(const QByteArray& json,
                                                 StartupReportResponse& out)
{
    QJsonParseError error{};
    const QJsonDocument doc = QJsonDocument::fromJson(json, &error);
    if (error.error != QJsonParseError::NoError || !doc.isObject()) {
        qWarning() << "TrackClick usage: failed to parse startup response:" << error.errorString();
        return false;
    }

    const QJsonObject object = doc.object();
    out.latestSoftwareVersion      = object.value(QLatin1String("latestSoftwareVersion")).toString();
    out.softwareDownloadUrl        = object.value(QLatin1String("softwareDownloadUrl")).toString();
    out.newerVersionAvailable      = object.value(QLatin1String("newerVersionAvailable")).toBool();
    out.minimumSoftwareVersion     = object.value(QLatin1String("minimumSoftwareVersion")).toString();
    out.latestGameslistDownloadUrl = object.value(QLatin1String("latestGameslistDownloadUrl")).toString();
    out.latestGameslistVersion     = object.value(QLatin1String("latestGameslistVersion")).toInt();
    out.newsUrl                    = object.value(QLatin1String("newsUrl")).toString();
    out.newsVersion                = object.value(QLatin1String("newsVersion")).toInt();
    return true;
}

bool UsageReportingManager::parseClickModeResponse(const QByteArray& json,
                                                   ClickModeReportResponse& out)
{
    QJsonParseError error{};
    const QJsonDocument doc = QJsonDocument::fromJson(json, &error);
    if (error.error != QJsonParseError::NoError || !doc.isObject()) {
        qWarning() << "TrackClick usage: failed to parse click-mode response:" << error.errorString();
        return false;
    }

    out.success = doc.object().value(QLatin1String("success")).toBool();
    return true;
}

QByteArray UsageReportingManager::serializeStartupPayload() const
{
    QJsonObject json;
    json[QLatin1String("sessionId")]       = m_sessionId;
    // Omitted rather than sent empty when the caller never set one, so the
    // backend can tell "this build does not report it" from a real value.
    if (!m_userId.isEmpty())
        json[QLatin1String("userId")]      = m_userId;
    json[QLatin1String("operatingSystem")] = m_startupPayload.operatingSystem;
    json[QLatin1String("softwareType")]    = m_startupPayload.softwareType;
    json[QLatin1String("softwareVersion")] = m_startupPayload.softwareVersion;
    json[QLatin1String("statusId")]        = m_startupPayload.statusId;
    json[QLatin1String("trackingMode")]    = m_startupPayload.trackingMode;
    json[QLatin1String("trackingClip")]    = m_startupPayload.trackingClip;
    json[QLatin1String("clickingMode")]    = static_cast<int>(m_startupPayload.clickingMode);
    return QJsonDocument(json).toJson(QJsonDocument::Compact);
}

QByteArray UsageReportingManager::serializeClickModePayload(const ClickModeReportPayload& payload) const
{
    QJsonObject json;
    json[QLatin1String("sessionId")]    = m_sessionId;
    json[QLatin1String("softwareType")] = payload.softwareType;
    json[QLatin1String("clickingMode")] = static_cast<int>(payload.clickingMode);
    return QJsonDocument(json).toJson(QJsonDocument::Compact);
}