[Server/Client/Protocol] Reporting users + moderation queue functionality (#7091)

* [Server/Client/Protocol] Reporting users + moderation queue functionality

Took 6 minutes

Took 3 minutes

Took 8 seconds

Took 11 minutes

Took 12 minutes

Took 7 minutes

Took 15 seconds

Took 2 minutes

Took 1 minute


Took 30 seconds

Took 16 seconds

* CI Fix

Took 6 minutes

* CI Fix

Took 6 minutes

* [Protocol] Add moderation investigation commands

Adds the protocol layer for the moderation investigation suite:
- Command_GetUserSessions/GetUserAlts/GetModeratorLastLogins/ResetUserPassword/RemoveUserAvatar (1013-1017)
- Response extensions 1215-1219 with ServerInfo messages for sessions, alts, and staff logins
- last_login on Response_ReportUserInfo and warning_il on Response_WarnList

Took 2 minutes

* [Utility] Add warning categories parser with infraction levels

Parses the server's 'officialwarnings' setting (comma-separated, optional
'|IL' suffix) into WarningCategory structs so the client can display the
infraction level of each warning category. Includes GTest coverage.

* [Server] Add moderation investigation tools

Implements the server side of the moderation suite:
- getUserSessions/getUserAlts/getModeratorLastLogins/removeUserAvatar DB methods
- Handlers for all five new commands with audit records (PASSWORD_RESET,
  REMOVE_USER_AVATAR); password resets return a generated temporary password
- cmdGetWarnList now reports per-category infraction levels from the
  officialwarnings setting; cmdReportUserInfo reports last_login
- Update servatrice.ini.example with the warning taxonomy
- Password/avatar mutations report RespNameNotFound when the user does not exist

* [Client] Add moderation tab with investigate, password reset, and avatar removal

- New Moderation tab: search a user to show account info, alternate
  accounts, login sessions, and staff last logins; actions to reset the
  user's password (shows the generated temporary password) and remove the
  user's avatar
- 'Investigate user' entry in the user context menu opens the tab pre-loaded
  for that user
- Warning dialog shows the infraction level of each warning category
- Tab wired into TabSupervisor with a moderator-gated menu action, shortcut,
  and tabs.ini persistence (default closed)

* [Server/Client/Protocol] Address PR #7091 review: security, bug, and perf fixes

Security:
- Promote RESET_USER_PASSWORD to admin-only dispatch (was moderator-accessible)
- Reject password reset on users with equal/higher privilege than caller
- Notify affected user via Event_NotifyUser::CUSTOM when password is reset
- Add server-side category whitelist for reports
- Drop reporter name fallback in comment/details authorization (ID-only)
- Force password change: new DB column + login enforcement + client disconnect

Bugs:
- XSS via QTextEdit::append() → insertPlainText() in report tab and utils
- allNotified initialized to true even with empty recipients list
- Warning combo box: use currentData() instead of baked-in display text
- Report resolution now records who resolved (resolved_by column + audit)

Performance:
- IP-correlation subquery: add 6-month window + LIMIT 200
- getUserSessions: clamp limit to 500

Non-blocking:
- Palette-aware colors in report_utils.cpp (dark/light mode)
- Report list pagination: offset/limit fields + total_count in response
- SessionCommand enum gap comment for reserved values 1201-1203

Schema: 36→37 (force_password_change), 37→38 (resolved_by)

Took 12 minutes


Took 16 seconds

* Fix macOs pedantry

Took 5 minutes

---------

Co-authored-by: Lukas Brübach <Bruebach.Lukas@bdosecurity.de>

cockatrice/src/interface/widgets/dialogs/dlg_my_reports.cpp

@@ -0,0 +1,297 @@
+#include "dlg_my_reports.h"
+
+#include "../utility/report_utils.h"
+#include "abstract_client.h"
+
+#include <QFontDatabase>
+#include <QGroupBox>
+#include <QHBoxLayout>
+#include <QHeaderView>
+#include <QLabel>
+#include <QLineEdit>
+#include <QPushButton>
+#include <QSplitter>
+#include <QTableWidget>
+#include <QTextEdit>
+#include <QVBoxLayout>
+#include <libcockatrice/protocol/pb/command_report_add_comment.pb.h>
+#include <libcockatrice/protocol/pb/command_report_details.pb.h>
+#include <libcockatrice/protocol/pb/command_report_my_list.pb.h>
+#include <libcockatrice/protocol/pb/response_report_details.pb.h>
+#include <libcockatrice/protocol/pb/response_report_my_list.pb.h>
+#include <libcockatrice/protocol/pending_command.h>
+
+namespace
+{
+constexpr int COL_ID = 0;
+constexpr int COL_TIME = 1;
+constexpr int COL_REPORTED = 2;
+constexpr int COL_CATEGORY = 3;
+constexpr int COL_GAMEID = 4;
+constexpr int COL_STATUS = 5;
+constexpr int COL_ASSIGNED = 6;
+constexpr int COL_COUNT = 7;
+} // namespace
+
+DlgMyReports::DlgMyReports(AbstractClient *_client, QWidget *parent)
+    : QDialog(parent), client(_client), selectedReportId(-1)
+{
+    setWindowTitle(tr("My Reports"));
+    setMinimumSize(800, 500);
+
+    table = new QTableWidget(0, COL_COUNT);
+    table->setHorizontalHeaderLabels(
+        {tr("#"), tr("Time"), tr("Reported User"), tr("Category"), tr("Game ID"), tr("Status"), tr("Assigned To")});
+    table->setSelectionBehavior(QAbstractItemView::SelectRows);
+    table->setSelectionMode(QAbstractItemView::SingleSelection);
+    table->setEditTriggers(QAbstractItemView::NoEditTriggers);
+    table->setSortingEnabled(true);
+    table->verticalHeader()->setVisible(false);
+    table->setAlternatingRowColors(true);
+    table->horizontalHeader()->setSectionResizeMode(COL_TIME, QHeaderView::ResizeToContents);
+    table->horizontalHeader()->setSectionResizeMode(COL_REPORTED, QHeaderView::Stretch);
+    connect(table, &QTableWidget::itemSelectionChanged, this, &DlgMyReports::onSelectionChanged);
+
+    auto *detailsGroup = new QGroupBox(tr("Report Details"));
+    descriptionEdit = new QTextEdit;
+    descriptionEdit->setReadOnly(true);
+    descriptionEdit->setFixedHeight(80);
+
+    auto *chatGroup = new QGroupBox(tr("Chat Log Context"));
+    chatLogEdit = new QTextEdit;
+    chatLogEdit->setReadOnly(true);
+    QFont monoFont("monospace");
+    monoFont.setStyleHint(QFont::Monospace);
+    const int systemPointSize = QFontDatabase::systemFont(QFontDatabase::GeneralFont).pointSize();
+    if (systemPointSize > 0) {
+        monoFont.setPointSize(systemPointSize);
+    }
+    chatLogEdit->setFont(monoFont);
+    auto *chatLayout = new QVBoxLayout(chatGroup);
+    chatLayout->setContentsMargins(4, 4, 4, 4);
+    chatLayout->addWidget(chatLogEdit);
+
+    auto *commentsLabel = new QLabel(tr("Comments:"));
+    commentsEdit = new QTextEdit;
+    commentsEdit->setReadOnly(true);
+    commentsEdit->setFixedHeight(120);
+
+    auto *addCommentLabel = new QLabel(tr("Add a comment:"));
+    commentInput = new QLineEdit;
+    commentInput->setPlaceholderText(tr("Type your comment here..."));
+    commentButton = new QPushButton(tr("Send"));
+    commentButton->setEnabled(false);
+    connect(commentButton, &QPushButton::clicked, this, &DlgMyReports::addComment);
+    connect(commentInput, &QLineEdit::returnPressed, this, &DlgMyReports::addComment);
+
+    auto *detailsLayout = new QVBoxLayout(detailsGroup);
+    detailsLayout->setContentsMargins(4, 4, 4, 4);
+    detailsLayout->addWidget(descriptionEdit);
+    detailsLayout->addWidget(chatGroup);
+    detailsLayout->addWidget(commentsLabel);
+    detailsLayout->addWidget(commentsEdit);
+    detailsLayout->addWidget(addCommentLabel);
+    auto *commentRow = new QHBoxLayout;
+    commentRow->addWidget(commentInput);
+    commentRow->addWidget(commentButton);
+    detailsLayout->addLayout(commentRow);
+
+    closeButton = new QPushButton(tr("Close"));
+    connect(closeButton, &QPushButton::clicked, this, &QDialog::accept);
+
+    refreshButton = new QPushButton(tr("Refresh"));
+    connect(refreshButton, &QPushButton::clicked, this, &DlgMyReports::refreshList);
+
+    statusLabel = new QLabel;
+
+    auto *bottomBar = new QHBoxLayout;
+    bottomBar->addWidget(statusLabel);
+    bottomBar->addStretch();
+    bottomBar->addWidget(refreshButton);
+    bottomBar->addWidget(closeButton);
+
+    auto *layout = new QVBoxLayout(this);
+    layout->addWidget(table, 1);
+    layout->addWidget(detailsGroup);
+    layout->addLayout(bottomBar);
+
+    setActionsEnabled(false);
+    refreshList();
+}
+
+void DlgMyReports::refreshList()
+{
+    selectedReportIdBeforeRefresh = selectedReportId;
+    commentDraftBeforeRefresh = commentInput->text();
+    statusLabel->setText(tr("Loading..."));
+    refreshButton->setEnabled(false);
+    table->setRowCount(0);
+    currentReports.clear();
+    descriptionEdit->clear();
+    chatLogEdit->clear();
+    commentsEdit->clear();
+    commentInput->clear();
+    setActionsEnabled(false);
+    selectedReportId = -1;
+
+    Command_ReportMyList cmd;
+
+    PendingCommand *pend = client->prepareSessionCommand(cmd);
+    connect(pend, &PendingCommand::finished, this, &DlgMyReports::reportListResponse);
+    client->sendCommand(pend);
+}
+
+void DlgMyReports::reportListResponse(const Response &response)
+{
+    refreshButton->setEnabled(true);
+
+    if (response.response_code() != Response::RespOk) {
+        statusLabel->setText(tr("Failed to load reports."));
+        return;
+    }
+
+    const Response_ReportMyList &resp = response.GetExtension(Response_ReportMyList::ext);
+    currentReports.clear();
+    for (int i = 0; i < resp.reports_size(); ++i) {
+        currentReports.append(resp.reports(i));
+    }
+
+    table->setSortingEnabled(false);
+    table->setRowCount(currentReports.size());
+
+    for (int row = 0; row < currentReports.size(); ++row) {
+        const ServerInfo_Report &r = currentReports[row];
+
+        report_utils::fillReportTableRow(table, row, r, COL_ID, COL_TIME, COL_REPORTED, COL_CATEGORY, COL_GAMEID,
+                                         COL_STATUS, COL_ASSIGNED);
+    }
+
+    table->setSortingEnabled(true);
+    table->resizeColumnsToContents();
+    table->horizontalHeader()->setSectionResizeMode(COL_REPORTED, QHeaderView::Stretch);
+
+    if (selectedReportIdBeforeRefresh >= 0) {
+        for (int row = 0; row < table->rowCount(); ++row) {
+            if (table->item(row, COL_ID) &&
+                table->item(row, COL_ID)->data(Qt::UserRole).toInt() == selectedReportIdBeforeRefresh) {
+                table->setCurrentCell(row, 0);
+                break;
+            }
+        }
+    }
+
+    if (commentInput->text().isEmpty()) {
+        commentInput->setText(commentDraftBeforeRefresh);
+    }
+
+    statusLabel->setText(tr("%1 report(s)").arg(currentReports.size()));
+}
+
+void DlgMyReports::onSelectionChanged()
+{
+    const int row = table->currentRow();
+    if (row < 0 || !table->item(row, COL_ID)) {
+        descriptionEdit->clear();
+        chatLogEdit->clear();
+        commentsEdit->clear();
+        commentInput->clear();
+        commentButton->setEnabled(false);
+        selectedReportId = -1;
+        return;
+    }
+
+    const int reportId = table->item(row, COL_ID)->data(Qt::UserRole).toInt();
+    selectedReportId = reportId;
+
+    for (const ServerInfo_Report &r : currentReports) {
+        if (r.report_id() == reportId) {
+            descriptionEdit->setPlainText(QString::fromStdString(r.description()));
+            break;
+        }
+    }
+
+    chatLogEdit->setPlainText(tr("Loading..."));
+    commentsEdit->setPlainText(tr("Loading..."));
+
+    Command_ReportDetails cmd;
+    cmd.set_report_id(reportId);
+
+    PendingCommand *pend = client->prepareSessionCommand(cmd);
+    connect(pend, &PendingCommand::finished, this, &DlgMyReports::reportDetailsResponse);
+    client->sendCommand(pend);
+
+    QString status = table->item(row, COL_STATUS)->text();
+    bool canComment = (status == "open" || status == "assigned");
+    commentButton->setEnabled(canComment);
+    commentInput->setEnabled(canComment);
+    if (!canComment) {
+        commentInput->setPlaceholderText(tr("This report is closed."));
+    } else {
+        commentInput->setPlaceholderText(tr("Type your comment here..."));
+    }
+}
+
+void DlgMyReports::reportDetailsResponse(const Response &response)
+{
+    if (response.response_code() != Response::RespOk) {
+        if (selectedReportId == -1) {
+            return;
+        }
+        chatLogEdit->clear();
+        commentsEdit->setPlainText(tr("Failed to load report details."));
+        return;
+    }
+
+    const Response_ReportDetails &resp = response.GetExtension(Response_ReportDetails::ext);
+    const ServerInfo_Report &r = resp.report();
+
+    if (selectedReportId != r.report_id()) {
+        return;
+    }
+
+    loadReportDetails(r);
+}
+
+void DlgMyReports::loadReportDetails(const ServerInfo_Report &report)
+{
+    report_utils::renderReportDetails(chatLogEdit, commentsEdit, report, tr("No comments yet."), tr("[Moderator]"),
+                                      tr("[You]"));
+}
+
+void DlgMyReports::addComment()
+{
+    if (selectedReportId < 0) {
+        return;
+    }
+
+    QString text = commentInput->text().trimmed();
+    if (text.isEmpty()) {
+        return;
+    }
+
+    commentButton->setEnabled(false);
+
+    Command_ReportAddComment cmd;
+    cmd.set_report_id(selectedReportId);
+    cmd.set_comment(text.toStdString());
+
+    PendingCommand *pend = client->prepareSessionCommand(cmd);
+    connect(pend, &PendingCommand::finished, this, &DlgMyReports::addCommentResponse);
+    client->sendCommand(pend);
+}
+
+void DlgMyReports::addCommentResponse(const Response &response)
+{
+    if (response.response_code() == Response::RespOk) {
+        commentInput->clear();
+        refreshList();
+    } else {
+        commentButton->setEnabled(true);
+    }
+}
+
+void DlgMyReports::setActionsEnabled(bool enabled)
+{
+    commentButton->setEnabled(enabled);
+    commentInput->setEnabled(enabled);
+}

cockatrice/src/interface/widgets/dialogs/dlg_my_reports.h

@@ -0,0 +1,52 @@
+#ifndef COCKATRICE_DLG_MY_REPORTS_H
+#define COCKATRICE_DLG_MY_REPORTS_H
+
+#include <QDialog>
+#include <QList>
+#include <libcockatrice/protocol/pb/response.pb.h>
+#include <libcockatrice/protocol/pb/serverinfo_report.pb.h>
+
+class AbstractClient;
+class QTableWidget;
+class QTextEdit;
+class QLineEdit;
+class QPushButton;
+class QLabel;
+
+class DlgMyReports : public QDialog
+{
+    Q_OBJECT
+public:
+    explicit DlgMyReports(AbstractClient *_client, QWidget *parent = nullptr);
+
+private slots:
+    void refreshList();
+    void reportListResponse(const Response &response);
+    void onSelectionChanged();
+    void reportDetailsResponse(const Response &response);
+    void addComment();
+    void addCommentResponse(const Response &response);
+
+private:
+    void loadReportDetails(const ServerInfo_Report &report);
+    void setActionsEnabled(bool enabled);
+
+    AbstractClient *client;
+
+    QTableWidget *table;
+    QTextEdit *descriptionEdit;
+    QTextEdit *chatLogEdit;
+    QTextEdit *commentsEdit;
+    QLineEdit *commentInput;
+    QPushButton *commentButton;
+    QPushButton *refreshButton;
+    QPushButton *closeButton;
+    QLabel *statusLabel;
+
+    QList<ServerInfo_Report> currentReports;
+    int selectedReportId;
+    int selectedReportIdBeforeRefresh = -1;
+    QString commentDraftBeforeRefresh;
+};
+
+#endif // COCKATRICE_DLG_MY_REPORTS_H

cockatrice/src/interface/widgets/dialogs/dlg_report_user.cpp

@@ -0,0 +1,191 @@
+#include "dlg_report_user.h"
+
+#include "abstract_client.h"
+
+#include <QComboBox>
+#include <QDialogButtonBox>
+#include <QFontDatabase>
+#include <QGridLayout>
+#include <QGroupBox>
+#include <QLabel>
+#include <QLineEdit>
+#include <QMessageBox>
+#include <QPushButton>
+#include <QTextEdit>
+#include <QVBoxLayout>
+#include <libcockatrice/protocol/pb/command_report.pb.h>
+#include <libcockatrice/protocol/pending_command.h>
+
+DlgReportUser::DlgReportUser(AbstractClient *_client,
+                             const QString &_reportedUser,
+                             int _gameId,
+                             const QString &_autoChatLog,
+                             QWidget *parent)
+    : QDialog(parent), client(_client), reportedUser(_reportedUser), gameId(_gameId)
+{
+    setWindowTitle(tr("Report User"));
+    setMinimumWidth(500);
+
+    auto *infoLabel =
+        new QLabel(tr("Reports are reviewed by moderators. False reports may result in account penalties."));
+    infoLabel->setWordWrap(true);
+    infoLabel->setStyleSheet("color: palette(placeholderText); padding: 5px;");
+
+    auto *reportGroup = new QGroupBox(tr("Report Details"));
+    auto *reportGrid = new QGridLayout(reportGroup);
+
+    reportGrid->addWidget(new QLabel(tr("Reported User:")), 0, 0);
+    reportedUserLabel = new QLabel(reportedUser);
+    reportedUserLabel->setStyleSheet("font-weight: bold;");
+    reportGrid->addWidget(reportedUserLabel, 0, 1);
+
+    reportGrid->addWidget(new QLabel(tr("Game ID:")), 1, 0);
+    if (gameId >= 0) {
+        gameIdLabel = new QLabel(QString::number(gameId));
+        gameIdLabel->setStyleSheet("font-weight: bold;");
+        reportGrid->addWidget(gameIdLabel, 1, 1);
+    } else {
+        gameIdEdit = new QLineEdit;
+        gameIdEdit->setPlaceholderText(tr("(Optional) Enter game ID if available"));
+        gameIdEdit->setToolTip(tr("If the report is related to a specific game, enter its ID."));
+        reportGrid->addWidget(gameIdEdit, 1, 1);
+        gameIdLabel = nullptr;
+    }
+
+    auto *categoryGroup = new QGroupBox(tr("Category"));
+    auto *categoryGrid = new QGridLayout(categoryGroup);
+
+    categoryBox = new QComboBox;
+    categoryBox->addItem(tr("Cheating / Unsporting behavior"), "cheating");
+    categoryBox->setItemData(categoryBox->count() - 1,
+                             tr("Using external tools, card marked manipulation, or exploiting game bugs"),
+                             Qt::ToolTipRole);
+    categoryBox->addItem(tr("Harassment / Abuse"), "harassment");
+    categoryBox->setItemData(categoryBox->count() - 1, tr("Threatening, bullying, or persistent unwanted contact"),
+                             Qt::ToolTipRole);
+    categoryBox->addItem(tr("Hate speech"), "hate_speech");
+    categoryBox->setItemData(categoryBox->count() - 1,
+                             tr("Discriminatory language targeting race, gender, religion, etc."), Qt::ToolTipRole);
+    categoryBox->addItem(tr("Spam"), "spam");
+    categoryBox->setItemData(categoryBox->count() - 1, tr("Repeated unwanted messages or advertisements"),
+                             Qt::ToolTipRole);
+    categoryBox->addItem(tr("Other"), "other");
+    categoryBox->setItemData(categoryBox->count() - 1, tr("Any behavior not covered by the above categories"),
+                             Qt::ToolTipRole);
+
+    categoryGrid->addWidget(new QLabel(tr("Category:")), 0, 0);
+    categoryGrid->addWidget(categoryBox, 0, 1);
+
+    auto *descGroup = new QGroupBox(tr("Description"));
+    auto *descLayout = new QVBoxLayout(descGroup);
+
+    descriptionEdit = new QTextEdit;
+    descriptionEdit->setPlaceholderText(
+        tr("Please describe what happened. Include dates, game details, or any evidence if available."));
+    descriptionEdit->setFixedHeight(120);
+    descLayout->addWidget(descriptionEdit);
+
+    auto *chatGroup = new QGroupBox(tr("Chat Log Context"));
+    auto *chatLayout = new QVBoxLayout(chatGroup);
+    chatLogEdit = new QTextEdit;
+    chatLogEdit->setReadOnly(true);
+    QFont monoFont("monospace");
+    monoFont.setStyleHint(QFont::Monospace);
+    const int systemPointSize = QFontDatabase::systemFont(QFontDatabase::GeneralFont).pointSize();
+    if (systemPointSize > 0) {
+        monoFont.setPointSize(systemPointSize);
+    }
+    chatLogEdit->setFont(monoFont);
+    if (!_autoChatLog.isEmpty()) {
+        chatLogEdit->setPlainText(_autoChatLog);
+    } else {
+        chatLogEdit->setPlaceholderText(tr("No chat context available (not triggered from chat)."));
+    }
+    chatLogEdit->setFixedHeight(100);
+    chatLayout->addWidget(chatLogEdit);
+
+    auto *chatNote = new QLabel(
+        tr("This chat log is captured from your local chat window and may not reflect the full conversation."));
+    chatNote->setWordWrap(true);
+    chatNote->setStyleSheet("color: palette(placeholderText);");
+    chatLayout->addWidget(chatNote);
+
+    buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
+    buttonBox->button(QDialogButtonBox::Ok)->setText(tr("Submit Report"));
+    connect(buttonBox, &QDialogButtonBox::accepted, this, &DlgReportUser::actSubmit);
+    connect(buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject);
+
+    auto *layout = new QVBoxLayout(this);
+    layout->addWidget(infoLabel);
+    layout->addWidget(reportGroup);
+    layout->addWidget(categoryGroup);
+    layout->addWidget(descGroup);
+    layout->addWidget(chatGroup);
+    layout->addWidget(buttonBox);
+}
+
+void DlgReportUser::actSubmit()
+{
+    const QString description = descriptionEdit->toPlainText().trimmed();
+    if (description.isEmpty()) {
+        QMessageBox::warning(this, tr("Missing description"), tr("Please describe what happened before submitting."));
+        return;
+    }
+
+    QMessageBox::StandardButton reply =
+        QMessageBox::question(this, tr("Confirm Report"),
+                              tr("Submit report against %1 for %2?").arg(reportedUser, categoryBox->currentText()),
+                              QMessageBox::Yes | QMessageBox::No);
+
+    if (reply != QMessageBox::Yes) {
+        return;
+    }
+
+    buttonBox->setEnabled(false);
+    buttonBox->button(QDialogButtonBox::Ok)->setText(tr("Submitting..."));
+
+    Command_Report cmd;
+    cmd.set_reported_user(reportedUser.toStdString());
+    cmd.set_category(categoryBox->currentData().toString().toStdString());
+    cmd.set_description(description.toStdString());
+
+    if (gameId >= 0) {
+        cmd.set_game_id(gameId);
+    } else if (gameIdEdit && !gameIdEdit->text().trimmed().isEmpty()) {
+        bool ok;
+        int manualGameId = gameIdEdit->text().trimmed().toInt(&ok);
+        if (ok && manualGameId > 0) {
+            cmd.set_game_id(manualGameId);
+        }
+    }
+
+    const QString chatLog = chatLogEdit->toPlainText().trimmed();
+    if (!chatLog.isEmpty()) {
+        cmd.set_chat_log(chatLog.toStdString());
+    }
+
+    PendingCommand *pend = client->prepareSessionCommand(cmd);
+    connect(pend, &PendingCommand::finished, this, &DlgReportUser::reportResponse);
+    client->sendCommand(pend);
+}
+
+void DlgReportUser::reportResponse(const Response &response)
+{
+    buttonBox->setEnabled(true);
+    buttonBox->button(QDialogButtonBox::Ok)->setText(tr("Submit Report"));
+
+    if (response.response_code() == Response::RespOk) {
+        QMessageBox::information(this, tr("Report Submitted"),
+                                 tr("Your report has been submitted and will be reviewed by a moderator. Thank you."));
+        accept();
+    } else if (response.response_code() == Response::RespTooManyRequests) {
+        QMessageBox::warning(this, tr("Submission Failed"),
+                             tr("You have reached the daily report limit. Please try again later."));
+    } else if (response.response_code() == Response::RespNameNotFound) {
+        QMessageBox::warning(
+            this, tr("Submission Failed"),
+            tr("The reported user could not be found. Guests (unregistered users) cannot be reported."));
+    } else {
+        QMessageBox::warning(this, tr("Submission Failed"), tr("Failed to submit report. Please try again."));
+    }
+}

cockatrice/src/interface/widgets/dialogs/dlg_report_user.h

@@ -0,0 +1,42 @@
+#ifndef COCKATRICE_DLG_REPORT_USER_H
+#define COCKATRICE_DLG_REPORT_USER_H
+
+#include <QDialog>
+#include <libcockatrice/protocol/pb/response.pb.h>
+
+class AbstractClient;
+class QComboBox;
+class QDialogButtonBox;
+class QLineEdit;
+class QTextEdit;
+class QLabel;
+
+class DlgReportUser : public QDialog
+{
+    Q_OBJECT
+public:
+    DlgReportUser(AbstractClient *_client,
+                  const QString &_reportedUser,
+                  int _gameId = -1,
+                  const QString &_autoChatLog = QString(),
+                  QWidget *parent = nullptr);
+
+private slots:
+    void actSubmit();
+    void reportResponse(const Response &response);
+
+private:
+    AbstractClient *client;
+    QString reportedUser;
+    int gameId;
+
+    QLabel *reportedUserLabel;
+    QLabel *gameIdLabel = nullptr;
+    QLineEdit *gameIdEdit = nullptr;
+    QComboBox *categoryBox;
+    QTextEdit *descriptionEdit;
+    QTextEdit *chatLogEdit;
+    QDialogButtonBox *buttonBox;
+};
+
+#endif // COCKATRICE_DLG_REPORT_USER_H

cockatrice/src/interface/widgets/server/chat_view/chat_view.cpp

@@ -273,6 +273,14 @@ void ChatView::appendMessage(QString message,
     // messageType should be Event_RoomSay::UserMessage though we don't actually check
     bool isUserMessage = !(userName.toLower() == "servatrice" || userName.isEmpty());
     bool sameSender = isUserMessage && userName == lastSender;
+
+    if (isUserMessage) {
+        chatHistory.append({userName, message, QDateTime::currentDateTime()});
+        while (chatHistory.size() > MAX_CHAT_HISTORY) {
+            chatHistory.removeFirst();
+        }
+    }
+
     QTextCursor cursor = prepareBlock(sameSender);
     lastSender = userName;
 
@@ -650,6 +658,19 @@ void ChatView::clearChat()
     document()->clear();
     lastSender = "";
     evenNumber = true;
+    chatHistory.clear();
+}
+
+QString ChatView::getRecentChatLog(int maxMessages) const
+{
+    QStringList lines;
+    int start = qMax(0, chatHistory.size() - maxMessages);
+    for (int i = start; i < chatHistory.size(); ++i) {
+        const ChatLogEntry &entry = chatHistory.at(i);
+        lines.append(
+            QString("[%1] %2: %3").arg(entry.timestamp.toString("hh:mm:ss")).arg(entry.userName).arg(entry.message));
+    }
+    return lines.join("\n");
 }
 
 void ChatView::redactMessages(const QString &userName, int amount)

cockatrice/src/interface/widgets/server/chat_view/chat_view.h

@@ -33,6 +33,13 @@ public:
     QTextBlock block;
 };
 
+struct ChatLogEntry
+{
+    QString userName;
+    QString message;
+    QDateTime timestamp;
+};
+
 class ChatView : public QTextBrowser
 {
     Q_OBJECT
@@ -65,6 +72,8 @@ private:
     QString hoveredContent;
     QAction *messageClicked;
     QMap<QString, QVector<UserMessagePosition>> userMessagePositions;
+    QList<ChatLogEntry> chatHistory;
+    static constexpr int MAX_CHAT_HISTORY = 200;
 
     [[nodiscard]] QTextFragment getFragmentUnderMouse(const QPoint &pos) const;
     QTextCursor prepareBlock(bool same = false);
@@ -107,6 +116,7 @@ public:
                        bool playerBold = false);
     void clearChat();
     void redactMessages(const QString &userName, int amount);
+    QString getRecentChatLog(int maxMessages = 50) const;
 
 protected:
     void enterEvent(QEnterEvent *event) override;

cockatrice/src/interface/widgets/server/game_selector.cpp

@@ -359,7 +359,11 @@ void GameSelector::joinGame(const bool asSpectator, const bool asJudge)
         return;
     }
 
-    const ServerInfo_Game &game = gameListModel->getGame(ind.data(Qt::UserRole).toInt());
+    joinGame(gameListModel->getGame(ind.data(Qt::UserRole).toInt()), asSpectator, asJudge);
+}
+
+void GameSelector::joinGame(const ServerInfo_Game &game, const bool asSpectator, const bool asJudge)
+{
     if (tabSupervisor->switchToGameTabIfAlreadyExists(game.game_id())) {
         return;
     }
@@ -414,18 +418,16 @@ void GameSelector::joinGame(const bool asSpectator, const bool asJudge)
     disableButtons();
 }
 
-bool GameSelector::joinGameById(int gameId)
+bool GameSelector::joinGameById(const int gameId, const bool asSpectator)
 {
-    auto *model = gameListView->model();
-
-    for (int row = 0; row < model->rowCount(); ++row) {
-        QModelIndex idx = model->index(row, 0);
-        const ServerInfo_Game &game = gameListModel->getGame(idx.data(Qt::UserRole).toInt());
-        if (game.game_id() == gameId) {
-            gameListView->setCurrentIndex(idx);
-            joinGame();
-            return true;
+    for (int row = 0; row < gameListModel->rowCount(); ++row) {
+        const ServerInfo_Game &game = gameListModel->getGame(row);
+        if (game.game_id() != gameId) {
+            continue;
         }
+
+        joinGame(game, asSpectator);
+        return true;
     }
 
     qWarning() << "Game" << gameId << "not found";

cockatrice/src/interface/widgets/server/game_selector.h

@@ -171,6 +171,17 @@ private:
      */
     void joinGame(bool asSpectator = false, bool asJudge = false);
 
+    /**
+     * @brief Performs the join or spectate action for a specific game.
+     * @param game The game to join.
+     * @param asSpectator True to join as a spectator, false to join as a player.
+     * @param asJudge True to join as a judge, false to join as a player.
+     *
+     * Unlike the selection-based overload, this does not depend on the game being
+     * visible in the filtered game list.
+     */
+    void joinGame(const ServerInfo_Game &game, bool asSpectator = false, bool asJudge = false);
+
 public:
     /**
      * @brief Constructs a GameSelector widget.
@@ -202,7 +213,16 @@ public:
      * @param info The ServerInfo_Game object containing information about the game to update.
      */
     void processGameInfo(const ServerInfo_Game &info);
-    bool joinGameById(int gameId);
+    /**
+     * @brief Finds a game by ID and joins or spectates it.
+     * @param gameId The ID of the game to join.
+     * @param asSpectator True to join as a spectator, false to join as a player.
+     * @return True if the game was found and joined, false otherwise.
+     *
+     * Unlike the selection-based overload, this does not depend on the game
+     * being visible in the filtered game list.
+     */
+    bool joinGameById(int gameId, bool asSpectator = false);
 };
 
 #endif

cockatrice/src/interface/widgets/server/user/user_context_menu.cpp

@@ -1,5 +1,6 @@
 #include "user_context_menu.h"
 
+#include "../../dialogs/dlg_report_user.h"
 #include "../../interface/widgets/tabs/tab_account.h"
 #include "../../interface/widgets/tabs/tab_game.h"
 #include "../../interface/widgets/tabs/tab_supervisor.h"
@@ -41,6 +42,7 @@ UserContextMenu::UserContextMenu(TabSupervisor *_tabSupervisor, QWidget *parent,
     aAddToIgnoreList = new QAction(QString(), this);
     aRemoveFromIgnoreList = new QAction(QString(), this);
     aKick = new QAction(QString(), this);
+    aReport = new QAction(QString(), this);
     aWarnUser = new QAction(QString(), this);
     aWarnHistory = new QAction(QString(), this);
     aBan = new QAction(QString(), this);
@@ -50,6 +52,7 @@ UserContextMenu::UserContextMenu(TabSupervisor *_tabSupervisor, QWidget *parent,
     aPromoteToJudge = new QAction(QString(), this);
     aDemoteFromJudge = new QAction(QString(), this);
     aGetAdminNotes = new QAction(QString(), this);
+    aInvestigateUser = new QAction(QString(), this);
 
     retranslateUi();
 }
@@ -64,6 +67,7 @@ void UserContextMenu::retranslateUi()
     aAddToIgnoreList->setText(tr("Add to &ignore list"));
     aRemoveFromIgnoreList->setText(tr("Remove from &ignore list"));
     aKick->setText(tr("Kick from &game"));
+    aReport->setText(tr("Report user"));
     aWarnUser->setText(tr("Warn user"));
     aWarnHistory->setText(tr("View user's war&n history"));
     aBan->setText(tr("Ban from &server"));
@@ -73,6 +77,7 @@ void UserContextMenu::retranslateUi()
     aPromoteToJudge->setText(tr("Promote user to &judge"));
     aDemoteFromJudge->setText(tr("Demote user from judge"));
     aGetAdminNotes->setText(tr("View admin notes"));
+    aInvestigateUser->setText(tr("Investigate user"));
 }
 
 void UserContextMenu::gamesOfUserReceived(const Response &resp, const CommandContainer &commandContainer)
@@ -144,7 +149,8 @@ void UserContextMenu::warnUser_processGetWarningsListResponse(const Response &r)
 
     if (response.warning_size() > 0) {
         for (int i = 0; i < response.warning_size(); ++i) {
-            dlg->addWarningOption(QString::fromStdString(response.warning(i)).simplified());
+            int startingIl = i < response.warning_il_size() ? response.warning_il(i) : 1;
+            dlg->addWarningOption(QString::fromStdString(response.warning(i)).simplified(), startingIl);
         }
     }
     dlg->show();
@@ -395,6 +401,9 @@ void UserContextMenu::showContextMenu(const QPoint &pos,
         aRemoveMessages = new QAction(tr("Remove this user's messages"), this);
         menu->addAction(aRemoveMessages);
     }
+    if (userListProxy->isOwnUserRegistered()) {
+        menu->addAction(aReport);
+    }
     if (game && (game->isHost() || !tabSupervisor->getAdminLocked())) {
         menu->addSeparator();
         menu->addAction(aKick);
@@ -408,6 +417,7 @@ void UserContextMenu::showContextMenu(const QPoint &pos,
         menu->addAction(aBanHistory);
         menu->addSeparator();
         menu->addAction(aGetAdminNotes);
+        menu->addAction(aInvestigateUser);
 
         menu->addSeparator();
         if (userLevel.testFlag(ServerInfo_User::IsModerator) &&
@@ -431,6 +441,7 @@ void UserContextMenu::showContextMenu(const QPoint &pos,
     aDetails->setEnabled(true);
     aChat->setEnabled(anotherUser && online);
     aShowGames->setEnabled(online);
+    aReport->setEnabled(anotherUser);
     aAddToBuddyList->setEnabled(anotherUser);
     aRemoveFromBuddyList->setEnabled(anotherUser);
     aAddToIgnoreList->setEnabled(anotherUser);
@@ -441,6 +452,7 @@ void UserContextMenu::showContextMenu(const QPoint &pos,
     aBan->setEnabled(anotherUser);
     aBanHistory->setEnabled(anotherUser);
     aGetAdminNotes->setEnabled(anotherUser);
+    aInvestigateUser->setEnabled(anotherUser);
     aPromoteToMod->setEnabled(anotherUser);
     aDemoteFromMod->setEnabled(anotherUser);
 
@@ -462,6 +474,15 @@ void UserContextMenu::showContextMenu(const QPoint &pos,
         execRemoveFromIgnore(userName);
     } else if (actionClicked == aKick) {
         execKick(playerId);
+    } else if (actionClicked == aReport) {
+        int gameId = game ? game->getGameMetaInfo()->gameId() : -1;
+        QString autoChatLog;
+        if (chatView) {
+            autoChatLog = chatView->getRecentChatLog(50);
+        }
+        auto dlgReport = new DlgReportUser(client, userName, gameId, autoChatLog, static_cast<QWidget *>(parent()));
+        dlgReport->setAttribute(Qt::WA_DeleteOnClose);
+        dlgReport->exec();
     } else if (actionClicked == aBan) {
         execBan(userName);
     } else if (actionClicked == aPromoteToMod || actionClicked == aDemoteFromMod) {
@@ -476,6 +497,8 @@ void UserContextMenu::showContextMenu(const QPoint &pos,
         execWarnHistory(userName);
     } else if (actionClicked == aGetAdminNotes) {
         execAdminNotes(userName);
+    } else if (actionClicked == aInvestigateUser) {
+        execInvestigateUser(userName);
     } else if (actionClicked == aCopyToClipBoard) {
         QClipboard *clipboard = QGuiApplication::clipboard();
         clipboard->setText(deckHash);
@@ -652,6 +675,11 @@ void UserContextMenu::execAdminNotes(const QString &userName)
     client->sendCommand(pend);
 }
 
+void UserContextMenu::execInvestigateUser(const QString &userName)
+{
+    tabSupervisor->openTabModeration(userName);
+}
+
 void UserContextMenu::execAdjustMod(const QString &userName, bool shouldBeMod)
 {
     Command_AdjustMod cmd;

cockatrice/src/interface/widgets/server/user/user_context_menu.h

@@ -41,12 +41,14 @@ private:
     QAction *aAddToBuddyList, *aRemoveFromBuddyList;
     QAction *aAddToIgnoreList, *aRemoveFromIgnoreList;
     QAction *aKick;
+    QAction *aReport;
     QAction *aBan, *aBanHistory;
     QAction *aPromoteToMod, *aDemoteFromMod;
     QAction *aPromoteToJudge, *aDemoteFromJudge;
     QAction *aWarnUser, *aWarnHistory;
     QAction *aGetAdminNotes;
     std::function<QList<GameInviteOption>()> gameInviteLinkProvider;
+    QAction *aInvestigateUser;
 signals:
     void openMessageDialog(const QString &userName, bool focus);
 private slots:
@@ -118,6 +120,7 @@ public:
     void execBanHistory(const QString &userName);
     void execWarnHistory(const QString &userName);
     void execAdminNotes(const QString &userName);
+    void execInvestigateUser(const QString &userName);
     void execAdjustMod(const QString &userName, bool shouldBeMod);
     void execAdjustJudge(const QString &userName, bool shouldBeJudge);
 

cockatrice/src/interface/widgets/server/user/user_list_widget.cpp

@@ -151,7 +151,7 @@ WarningDialog::WarningDialog(const QString userName, const QString clientID, QWi
     warnClientID = new QLineEdit(clientID);
     warnClientID->setMaxLength(MAX_NAME_LENGTH);
     warningOption = new QComboBox();
-    warningOption->addItem("");
+    warningOption->addItem("", "");
 
     deleteMessages = new QCheckBox(tr("Redact all messages from this user in all rooms"));
 
@@ -184,7 +184,7 @@ void WarningDialog::okClicked()
         return;
     }
 
-    if (warningOption->currentText().simplified().isEmpty()) {
+    if (warningOption->currentData().toString().simplified().isEmpty()) {
         QMessageBox::critical(this, tr("Error"),
                               tr("Warning to use can not be blank, please select a valid warning to send."));
         return;
@@ -205,7 +205,7 @@ QString WarningDialog::getWarnID() const
 
 QString WarningDialog::getReason() const
 {
-    return warningOption->currentText().simplified();
+    return warningOption->currentData().toString().simplified();
 }
 
 int WarningDialog::getDeleteMessages() const
@@ -213,9 +213,13 @@ int WarningDialog::getDeleteMessages() const
     return deleteMessages->isChecked() ? -1 : 0;
 }
 
-void WarningDialog::addWarningOption(const QString warning)
+void WarningDialog::addWarningOption(const QString warning, int startingIl)
 {
-    warningOption->addItem(warning);
+    if (startingIl > 1) {
+        warningOption->addItem(tr("%1 (IL %2)").arg(warning).arg(startingIl), warning);
+    } else {
+        warningOption->addItem(warning, warning);
+    }
 }
 
 void BanDialog::okClicked()

cockatrice/src/interface/widgets/server/user/user_list_widget.h

@@ -85,7 +85,7 @@ public:
     [[nodiscard]] QString getWarnID() const;
     [[nodiscard]] QString getReason() const;
     [[nodiscard]] int getDeleteMessages() const;
-    void addWarningOption(const QString warning);
+    void addWarningOption(const QString warning, int startingIl = 1);
 };
 
 class AdminNotesDialog : public QDialog

cockatrice/src/interface/widgets/tabs/tab_account.cpp

@@ -1,6 +1,7 @@
 #include "tab_account.h"
 
 #include "../client/sound_engine.h"
+#include "../interface/widgets/dialogs/dlg_my_reports.h"
 #include "../interface/widgets/server/user/user_info_box.h"
 #include "../interface/widgets/server/user/user_list_manager.h"
 #include "../interface/widgets/server/user/user_list_widget.h"
@@ -49,6 +50,11 @@ TabAccount::TabAccount(TabSupervisor *_tabSupervisor, AbstractClient *_client, c
 
     auto *vbox = new QVBoxLayout;
     vbox->addWidget(userInfoBox);
+
+    myReportsButton = new QPushButton(tr("My Reports"));
+    connect(myReportsButton, &QPushButton::clicked, this, &TabAccount::openMyReports);
+    vbox->addWidget(myReportsButton);
+
     vbox->addWidget(allUsersList);
 
     auto *addToBuddyList = new QHBoxLayout;
@@ -126,6 +132,7 @@ void TabAccount::addToList(const std::string &listName, const QString &userName)
 
 void TabAccount::retranslateUi()
 {
+    myReportsButton->setText(tr("My Reports"));
     allUsersList->retranslateUi();
     buddyList->retranslateUi();
     ignoreList->retranslateUi();
@@ -240,3 +247,10 @@ void TabAccount::processRemoveFromListEvent(const Event_RemoveFromList &event)
 
     userList->deleteUser(user);
 }
+
+void TabAccount::openMyReports()
+{
+    auto *dlg = new DlgMyReports(client, this);
+    dlg->setAttribute(Qt::WA_DeleteOnClose);
+    dlg->exec();
+}

cockatrice/src/interface/widgets/tabs/tab_account.h

@@ -18,6 +18,7 @@ class Event_RemoveFromList;
 class Event_UserJoined;
 class Event_UserLeft;
 class LineEditUnfocusable;
+class QPushButton;
 class Response;
 class ServerInfo_User;
 class UserInfoBox;
@@ -41,6 +42,7 @@ private slots:
     void processRemoveFromListEvent(const Event_RemoveFromList &event);
     void addToIgnoreList();
     void addToBuddyList();
+    void openMyReports();
 
 private:
     AbstractClient *client;
@@ -50,6 +52,7 @@ private:
     UserInfoBox *userInfoBox;
     LineEditUnfocusable *addBuddyEdit;
     LineEditUnfocusable *addIgnoreEdit;
+    QPushButton *myReportsButton;
     void addToList(const std::string &listName, const QString &userName);
 
 public:

cockatrice/src/interface/widgets/tabs/tab_moderation.cpp

@@ -0,0 +1,462 @@
+#include "tab_moderation.h"
+
+#include "abstract_client.h"
+#include "tab_supervisor.h"
+
+#include <QDateTime>
+#include <QGridLayout>
+#include <QGroupBox>
+#include <QHBoxLayout>
+#include <QHeaderView>
+#include <QLabel>
+#include <QLineEdit>
+#include <QMessageBox>
+#include <QPushButton>
+#include <QSplitter>
+#include <QTableWidget>
+#include <QTextEdit>
+#include <QVBoxLayout>
+#include <libcockatrice/protocol/pb/command_report_user_info.pb.h>
+#include <libcockatrice/protocol/pb/moderator_commands.pb.h>
+#include <libcockatrice/protocol/pb/response_moderator_last_logins.pb.h>
+#include <libcockatrice/protocol/pb/response_remove_user_avatar.pb.h>
+#include <libcockatrice/protocol/pb/response_report_user_info.pb.h>
+#include <libcockatrice/protocol/pb/response_reset_user_password.pb.h>
+#include <libcockatrice/protocol/pb/response_user_alts.pb.h>
+#include <libcockatrice/protocol/pb/response_user_sessions.pb.h>
+#include <libcockatrice/protocol/pb/serverinfo_user.pb.h>
+#include <libcockatrice/protocol/pending_command.h>
+
+namespace
+{
+constexpr int COL_ALTS_USER = 0;
+constexpr int COL_ALTS_EMAIL = 1;
+constexpr int COL_ALTS_CLIENTID = 2;
+constexpr int COL_ALTS_REGISTERED = 3;
+constexpr int COL_ALTS_LAST_LOGIN = 4;
+constexpr int COL_ALTS_WARNS = 5;
+constexpr int COL_ALTS_BANS = 6;
+constexpr int COL_ALTS_ACTIVE = 7;
+constexpr int COL_ALTS_COUNT = 8;
+
+constexpr int COL_SESSIONS_IP = 0;
+constexpr int COL_SESSIONS_CLIENTID = 1;
+constexpr int COL_SESSIONS_START = 2;
+constexpr int COL_SESSIONS_END = 3;
+constexpr int COL_SESSIONS_TYPE = 4;
+constexpr int COL_SESSIONS_COUNT = 5;
+
+constexpr int COL_STAFF_USER = 0;
+constexpr int COL_STAFF_LEVEL = 1;
+constexpr int COL_STAFF_LAST_LOGIN = 2;
+constexpr int COL_STAFF_COUNT = 3;
+} // namespace
+
+TabModeration::TabModeration(TabSupervisor *_tabSupervisor, AbstractClient *_client, const QString &initialUser)
+    : Tab(_tabSupervisor), client(_client)
+{
+    auto *centralWidget = new QWidget(this);
+    setCentralWidget(centralWidget);
+
+    searchEdit = new QLineEdit;
+    searchEdit->setClearButtonEnabled(true);
+    connect(searchEdit, &QLineEdit::returnPressed, this, &TabModeration::investigateUser);
+
+    investigateButton = new QPushButton;
+    connect(investigateButton, &QPushButton::clicked, this, &TabModeration::investigateUser);
+
+    resetPasswordButton = new QPushButton;
+    connect(resetPasswordButton, &QPushButton::clicked, this, &TabModeration::resetPassword);
+
+    removeAvatarButton = new QPushButton;
+    connect(removeAvatarButton, &QPushButton::clicked, this, &TabModeration::removeAvatar);
+
+    auto *topBar = new QHBoxLayout;
+    topBar->addWidget(searchEdit);
+    topBar->addWidget(investigateButton);
+    topBar->addStretch();
+    topBar->addWidget(resetPasswordButton);
+    topBar->addWidget(removeAvatarButton);
+
+    userInfoGroup = new QGroupBox;
+    userInfoNameLabel = new QLabel;
+    userInfoNameValue = new QLabel;
+    userInfoRegisteredLabel = new QLabel;
+    userInfoRegisteredValue = new QLabel;
+    userInfoLastLoginLabel = new QLabel;
+    userInfoLastLoginValue = new QLabel;
+    userInfoStatusLabel = new QLabel;
+    userInfoStatusValue = new QLabel;
+    userInfoCountsLabel = new QLabel;
+    userInfoCountsValue = new QLabel;
+    userInfoNotesLabel = new QLabel;
+    userInfoNotesEdit = new QTextEdit;
+    userInfoNotesEdit->setReadOnly(true);
+
+    auto *infoGrid = new QGridLayout;
+    infoGrid->addWidget(userInfoNameLabel, 0, 0);
+    infoGrid->addWidget(userInfoNameValue, 0, 1);
+    infoGrid->addWidget(userInfoRegisteredLabel, 0, 2);
+    infoGrid->addWidget(userInfoRegisteredValue, 0, 3);
+    infoGrid->addWidget(userInfoLastLoginLabel, 1, 0);
+    infoGrid->addWidget(userInfoLastLoginValue, 1, 1);
+    infoGrid->addWidget(userInfoStatusLabel, 1, 2);
+    infoGrid->addWidget(userInfoStatusValue, 1, 3);
+    infoGrid->addWidget(userInfoCountsLabel, 2, 0);
+    infoGrid->addWidget(userInfoCountsValue, 2, 1, 1, 3);
+    infoGrid->addWidget(userInfoNotesLabel, 3, 0, Qt::AlignTop);
+    infoGrid->addWidget(userInfoNotesEdit, 3, 1, 1, 3);
+    infoGrid->setColumnStretch(1, 1);
+    infoGrid->setColumnStretch(3, 1);
+
+    auto *infoLayout = new QVBoxLayout(userInfoGroup);
+    infoLayout->addLayout(infoGrid);
+
+    auto configureTable = [](QTableWidget *table) {
+        table->setSelectionBehavior(QAbstractItemView::SelectRows);
+        table->setSelectionMode(QAbstractItemView::SingleSelection);
+        table->setEditTriggers(QAbstractItemView::NoEditTriggers);
+        table->verticalHeader()->setVisible(false);
+        table->setAlternatingRowColors(true);
+        table->horizontalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);
+        table->horizontalHeader()->setStretchLastSection(true);
+    };
+
+    altsGroup = new QGroupBox;
+    altsTable = new QTableWidget(0, COL_ALTS_COUNT);
+    configureTable(altsTable);
+    auto *altsLayout = new QVBoxLayout(altsGroup);
+    altsLayout->addWidget(altsTable);
+
+    sessionsGroup = new QGroupBox;
+    sessionsTable = new QTableWidget(0, COL_SESSIONS_COUNT);
+    configureTable(sessionsTable);
+    auto *sessionsLayout = new QVBoxLayout(sessionsGroup);
+    sessionsLayout->addWidget(sessionsTable);
+
+    staffGroup = new QGroupBox;
+    staffTable = new QTableWidget(0, COL_STAFF_COUNT);
+    configureTable(staffTable);
+    refreshStaffButton = new QPushButton;
+    connect(refreshStaffButton, &QPushButton::clicked, this, &TabModeration::requestModeratorLogins);
+    auto *staffHeader = new QHBoxLayout;
+    staffHeader->addStretch();
+    staffHeader->addWidget(refreshStaffButton);
+    auto *staffLayout = new QVBoxLayout(staffGroup);
+    staffLayout->addWidget(staffTable);
+    staffLayout->addLayout(staffHeader);
+
+    auto *splitter = new QSplitter(Qt::Vertical);
+    splitter->addWidget(userInfoGroup);
+    splitter->addWidget(altsGroup);
+    splitter->addWidget(sessionsGroup);
+    splitter->addWidget(staffGroup);
+    splitter->setStretchFactor(0, 1);
+    splitter->setStretchFactor(1, 2);
+    splitter->setStretchFactor(2, 2);
+    splitter->setStretchFactor(3, 1);
+
+    auto *mainLayout = new QVBoxLayout(centralWidget);
+    mainLayout->addLayout(topBar);
+    mainLayout->addWidget(splitter);
+
+    retranslateUi();
+    clearUserData();
+    requestModeratorLogins();
+    investigate(initialUser);
+}
+
+void TabModeration::retranslateUi()
+{
+    searchEdit->setPlaceholderText(tr("User name"));
+    investigateButton->setText(tr("Investigate"));
+    resetPasswordButton->setText(tr("Reset Password"));
+    removeAvatarButton->setText(tr("Remove Avatar"));
+    refreshStaffButton->setText(tr("Refresh"));
+
+    userInfoGroup->setTitle(tr("User Info"));
+    userInfoNameLabel->setText(tr("Name:"));
+    userInfoRegisteredLabel->setText(tr("Registered:"));
+    userInfoLastLoginLabel->setText(tr("Last login:"));
+    userInfoStatusLabel->setText(tr("Status:"));
+    userInfoCountsLabel->setText(tr("Counts:"));
+    userInfoNotesLabel->setText(tr("Admin notes:"));
+
+    altsGroup->setTitle(tr("Alts"));
+    sessionsGroup->setTitle(tr("Sessions"));
+    staffGroup->setTitle(tr("Staff Last Logins"));
+
+    altsTable->setHorizontalHeaderLabels({tr("User"), tr("eMail"), tr("Client ID"), tr("Registered"), tr("Last login"),
+                                          tr("Warns"), tr("Bans"), tr("Active")});
+    sessionsTable->setHorizontalHeaderLabels({tr("IP"), tr("Client ID"), tr("Start"), tr("End"), tr("Type")});
+    staffTable->setHorizontalHeaderLabels({tr("User"), tr("Level"), tr("Last login")});
+}
+
+QString TabModeration::formatEpoch(quint64 ts) const
+{
+    if (ts == 0) {
+        return tr("Unknown");
+    }
+    return QDateTime::fromSecsSinceEpoch(ts).toLocalTime().toString("yyyy-MM-dd HH:mm");
+}
+
+void TabModeration::clearUserData()
+{
+    currentUser.clear();
+    userInfoNameValue->clear();
+    userInfoRegisteredValue->clear();
+    userInfoLastLoginValue->clear();
+    userInfoStatusValue->clear();
+    userInfoCountsValue->clear();
+    userInfoNotesEdit->clear();
+    altsTable->setRowCount(0);
+    sessionsTable->setRowCount(0);
+    resetPasswordButton->setEnabled(false);
+    removeAvatarButton->setEnabled(false);
+}
+
+void TabModeration::investigate(const QString &userName)
+{
+    if (userName.isEmpty()) {
+        return;
+    }
+    searchEdit->setText(userName);
+    investigateUser();
+}
+
+void TabModeration::investigateUser()
+{
+    const QString userName = searchEdit->text().simplified();
+    if (userName.isEmpty()) {
+        return;
+    }
+    currentUser = userName;
+    resetPasswordButton->setEnabled(true);
+    removeAvatarButton->setEnabled(true);
+    altsTable->setRowCount(0);
+    sessionsTable->setRowCount(0);
+    requestUserInfo(userName);
+    requestSessions(userName);
+    requestAlts(userName);
+}
+
+void TabModeration::requestUserInfo(const QString &userName)
+{
+    userInfoNameValue->setText(userName);
+    userInfoRegisteredValue->setText(tr("Loading..."));
+    userInfoLastLoginValue->setText(tr("Loading..."));
+    userInfoStatusValue->clear();
+    userInfoCountsValue->clear();
+    userInfoNotesEdit->clear();
+
+    Command_ReportUserInfo cmd;
+    cmd.set_user_name(userName.toStdString());
+    PendingCommand *pend = client->prepareModeratorCommand(cmd);
+    connect(pend, &PendingCommand::finished, this, &TabModeration::userInfoResponse);
+    client->sendCommand(pend);
+}
+
+void TabModeration::userInfoResponse(const Response &response)
+{
+    if (response.response_code() != Response::RespOk) {
+        userInfoRegisteredValue->clear();
+        userInfoLastLoginValue->clear();
+        userInfoStatusValue->setText(tr("Error loading user info."));
+        return;
+    }
+
+    const Response_ReportUserInfo &resp = response.GetExtension(Response_ReportUserInfo::ext);
+    if (resp.has_user_name() && QString::fromStdString(resp.user_name()) != currentUser) {
+        return;
+    }
+
+    userInfoRegisteredValue->setText(formatEpoch(resp.registration_time()));
+    userInfoLastLoginValue->setText(formatEpoch(resp.last_login()));
+
+    QStringList statusParts;
+    statusParts << (resp.is_active() ? tr("active") : tr("inactive"));
+    if (resp.has_is_admin() && resp.is_admin()) {
+        statusParts << tr("admin");
+    }
+    userInfoStatusValue->setText(statusParts.join(", "));
+
+    userInfoCountsValue->setText(tr("Reports: %1   Bans: %2   Warnings: %3")
+                                     .arg(resp.total_reports())
+                                     .arg(resp.total_bans())
+                                     .arg(resp.total_warns()));
+
+    if (resp.has_admin_notes() && !resp.admin_notes().empty()) {
+        userInfoNotesEdit->setPlainText(QString::fromStdString(resp.admin_notes()));
+    } else {
+        userInfoNotesEdit->setPlainText(tr("(none)"));
+    }
+}
+
+void TabModeration::requestSessions(const QString &userName)
+{
+    Command_GetUserSessions cmd;
+    cmd.set_user_name(userName.toStdString());
+    PendingCommand *pend = client->prepareModeratorCommand(cmd);
+    connect(pend, &PendingCommand::finished, this, &TabModeration::sessionsResponse);
+    client->sendCommand(pend);
+}
+
+void TabModeration::sessionsResponse(const Response &response)
+{
+    sessionsTable->setRowCount(0);
+    if (response.response_code() != Response::RespOk) {
+        return;
+    }
+
+    const Response_UserSessions &resp = response.GetExtension(Response_UserSessions::ext);
+    sessionsTable->setRowCount(resp.sessions_size());
+    for (int i = 0; i < resp.sessions_size(); ++i) {
+        const ServerInfo_UserSession &session = resp.sessions(i);
+        sessionsTable->setItem(i, COL_SESSIONS_IP, new QTableWidgetItem(QString::fromStdString(session.ip_address())));
+        sessionsTable->setItem(i, COL_SESSIONS_CLIENTID,
+                               new QTableWidgetItem(QString::fromStdString(session.clientid())));
+        sessionsTable->setItem(i, COL_SESSIONS_START, new QTableWidgetItem(formatEpoch(session.start_time())));
+        sessionsTable->setItem(
+            i, COL_SESSIONS_END,
+            new QTableWidgetItem(session.end_time() == 0 ? tr("Active") : formatEpoch(session.end_time())));
+        sessionsTable->setItem(i, COL_SESSIONS_TYPE,
+                               new QTableWidgetItem(QString::fromStdString(session.connection_type())));
+    }
+}
+
+void TabModeration::requestAlts(const QString &userName)
+{
+    Command_GetUserAlts cmd;
+    cmd.set_user_name(userName.toStdString());
+    PendingCommand *pend = client->prepareModeratorCommand(cmd);
+    connect(pend, &PendingCommand::finished, this, &TabModeration::altsResponse);
+    client->sendCommand(pend);
+}
+
+void TabModeration::altsResponse(const Response &response)
+{
+    altsTable->setRowCount(0);
+    if (response.response_code() != Response::RespOk) {
+        return;
+    }
+
+    const Response_UserAlts &resp = response.GetExtension(Response_UserAlts::ext);
+    altsTable->setRowCount(resp.alts_size());
+    for (int i = 0; i < resp.alts_size(); ++i) {
+        const ServerInfo_UserAlt &alt = resp.alts(i);
+        altsTable->setItem(i, COL_ALTS_USER, new QTableWidgetItem(QString::fromStdString(alt.user_name())));
+        altsTable->setItem(i, COL_ALTS_EMAIL, new QTableWidgetItem(QString::fromStdString(alt.email())));
+        altsTable->setItem(i, COL_ALTS_CLIENTID, new QTableWidgetItem(QString::fromStdString(alt.clientid())));
+        altsTable->setItem(i, COL_ALTS_REGISTERED, new QTableWidgetItem(formatEpoch(alt.registration_time())));
+        altsTable->setItem(i, COL_ALTS_LAST_LOGIN, new QTableWidgetItem(formatEpoch(alt.last_login())));
+        altsTable->setItem(i, COL_ALTS_WARNS, new QTableWidgetItem(QString::number(alt.warn_count())));
+        altsTable->setItem(i, COL_ALTS_BANS, new QTableWidgetItem(QString::number(alt.ban_count())));
+        altsTable->setItem(i, COL_ALTS_ACTIVE, new QTableWidgetItem(alt.is_active() ? tr("yes") : tr("no")));
+    }
+}
+
+void TabModeration::requestModeratorLogins()
+{
+    Command_GetModeratorLastLogins cmd;
+    PendingCommand *pend = client->prepareModeratorCommand(cmd);
+    connect(pend, &PendingCommand::finished, this, &TabModeration::moderatorLoginsResponse);
+    client->sendCommand(pend);
+}
+
+void TabModeration::moderatorLoginsResponse(const Response &response)
+{
+    staffTable->setRowCount(0);
+    if (response.response_code() != Response::RespOk) {
+        return;
+    }
+
+    const Response_ModeratorLastLogins &resp = response.GetExtension(Response_ModeratorLastLogins::ext);
+    staffTable->setRowCount(resp.logins_size());
+    for (int i = 0; i < resp.logins_size(); ++i) {
+        const ServerInfo_ModeratorLogin &login = resp.logins(i);
+        staffTable->setItem(i, COL_STAFF_USER, new QTableWidgetItem(QString::fromStdString(login.user_name())));
+        staffTable->setItem(i, COL_STAFF_LAST_LOGIN, new QTableWidgetItem(formatEpoch(login.last_login())));
+
+        QStringList levels;
+        if (login.user_level() & ServerInfo_User::IsAdmin) {
+            levels << tr("Admin");
+        }
+        if (login.user_level() & ServerInfo_User::IsModerator) {
+            levels << tr("Moderator");
+        }
+        if (login.user_level() & ServerInfo_User::IsJudge) {
+            levels << tr("Judge");
+        }
+        staffTable->setItem(i, COL_STAFF_LEVEL, new QTableWidgetItem(levels.join(" / ")));
+    }
+}
+
+void TabModeration::resetPassword()
+{
+    if (currentUser.isEmpty()) {
+        return;
+    }
+
+    QMessageBox::StandardButton choice =
+        QMessageBox::warning(this, tr("Reset Password"),
+                             tr("Reset the password of %1? A temporary password will be generated and shown to you. "
+                                "The user must change it on their first login.")
+                                 .arg(currentUser),
+                             QMessageBox::Ok | QMessageBox::Cancel, QMessageBox::Cancel);
+    if (choice != QMessageBox::Ok) {
+        return;
+    }
+
+    Command_ResetUserPassword cmd;
+    cmd.set_user_name(currentUser.toStdString());
+    PendingCommand *pend = client->prepareModeratorCommand(cmd);
+    connect(pend, &PendingCommand::finished, this, &TabModeration::resetPasswordResponse);
+    client->sendCommand(pend);
+}
+
+void TabModeration::resetPasswordResponse(const Response &response)
+{
+    if (response.response_code() != Response::RespOk) {
+        QMessageBox::critical(this, tr("Error"), tr("Password reset failed."));
+        return;
+    }
+
+    const Response_ResetUserPassword &resp = response.GetExtension(Response_ResetUserPassword::ext);
+    QMessageBox::information(this, tr("Password reset"),
+                             tr("Temporary password for %1:\n\n%2\n\nPass it to the user through a secure channel.")
+                                 .arg(QString::fromStdString(resp.user_name()))
+                                 .arg(QString::fromStdString(resp.temporary_password())));
+}
+
+void TabModeration::removeAvatar()
+{
+    if (currentUser.isEmpty()) {
+        return;
+    }
+
+    QMessageBox::StandardButton choice =
+        QMessageBox::warning(this, tr("Remove Avatar"),
+                             tr("Remove the avatar of %1? The user will have to upload a new one.").arg(currentUser),
+                             QMessageBox::Ok | QMessageBox::Cancel, QMessageBox::Cancel);
+    if (choice != QMessageBox::Ok) {
+        return;
+    }
+
+    Command_RemoveUserAvatar cmd;
+    cmd.set_user_name(currentUser.toStdString());
+    PendingCommand *pend = client->prepareModeratorCommand(cmd);
+    connect(pend, &PendingCommand::finished, this, &TabModeration::removeAvatarResponse);
+    client->sendCommand(pend);
+}
+
+void TabModeration::removeAvatarResponse(const Response &response)
+{
+    if (response.response_code() != Response::RespOk) {
+        QMessageBox::critical(this, tr("Error"), tr("Could not remove the avatar."));
+        return;
+    }
+
+    const Response_RemoveUserAvatar &resp = response.GetExtension(Response_RemoveUserAvatar::ext);
+    QMessageBox::information(this, tr("Avatar removed"),
+                             tr("The avatar of %1 has been removed.").arg(QString::fromStdString(resp.user_name())));
+}

cockatrice/src/interface/widgets/tabs/tab_moderation.h

@@ -0,0 +1,83 @@
+#ifndef TAB_MODERATION_H
+#define TAB_MODERATION_H
+
+#include "tab.h"
+
+#include <libcockatrice/protocol/pb/response.pb.h>
+
+class AbstractClient;
+class QGroupBox;
+class QLabel;
+class QLineEdit;
+class QPushButton;
+class QTableWidget;
+class QTextEdit;
+
+/**
+ * Staff investigation tool. Lets moderators look up a user's account data,
+ * alternate accounts, login sessions, and staff login activity, and offers
+ * the password-reset and remove-avatar actions.
+ */
+class TabModeration : public Tab
+{
+    Q_OBJECT
+public:
+    explicit TabModeration(TabSupervisor *_tabSupervisor, AbstractClient *_client, const QString &initialUser = {});
+    void retranslateUi() override;
+    [[nodiscard]] QString getTabText() const override
+    {
+        return tr("Moderation");
+    }
+    void investigate(const QString &userName);
+
+private slots:
+    void investigateUser();
+    void userInfoResponse(const Response &response);
+    void sessionsResponse(const Response &response);
+    void altsResponse(const Response &response);
+    void moderatorLoginsResponse(const Response &response);
+    void resetPassword();
+    void resetPasswordResponse(const Response &response);
+    void removeAvatar();
+    void removeAvatarResponse(const Response &response);
+
+private:
+    void requestUserInfo(const QString &userName);
+    void requestSessions(const QString &userName);
+    void requestAlts(const QString &userName);
+    void requestModeratorLogins();
+    void clearUserData();
+    [[nodiscard]] QString formatEpoch(quint64 ts) const;
+
+    AbstractClient *client;
+    QString currentUser;
+
+    QLineEdit *searchEdit;
+    QPushButton *investigateButton;
+    QPushButton *resetPasswordButton;
+    QPushButton *removeAvatarButton;
+
+    QGroupBox *userInfoGroup;
+    QLabel *userInfoNameLabel;
+    QLabel *userInfoNameValue;
+    QLabel *userInfoRegisteredLabel;
+    QLabel *userInfoRegisteredValue;
+    QLabel *userInfoLastLoginLabel;
+    QLabel *userInfoLastLoginValue;
+    QLabel *userInfoStatusLabel;
+    QLabel *userInfoStatusValue;
+    QLabel *userInfoCountsLabel;
+    QLabel *userInfoCountsValue;
+    QLabel *userInfoNotesLabel;
+    QTextEdit *userInfoNotesEdit;
+
+    QGroupBox *altsGroup;
+    QTableWidget *altsTable;
+    QGroupBox *sessionsGroup;
+    QTableWidget *sessionsTable;
+    QGroupBox *staffGroup;
+    QTableWidget *staffTable;
+    QPushButton *refreshStaffButton;
+};
+
+#endif // TAB_MODERATION_H

cockatrice/src/interface/widgets/tabs/tab_report.cpp

@@ -0,0 +1,927 @@
+#include "tab_report.h"
+
+#include "../utility/report_utils.h"
+#include "abstract_client.h"
+#include "tab_supervisor.h"
+
+#include <QCheckBox>
+#include <QComboBox>
+#include <QDateTime>
+#include <QFontDatabase>
+#include <QGridLayout>
+#include <QGroupBox>
+#include <QHBoxLayout>
+#include <QHeaderView>
+#include <QInputDialog>
+#include <QLabel>
+#include <QLineEdit>
+#include <QMessageBox>
+#include <QPushButton>
+#include <QSignalBlocker>
+#include <QSplitter>
+#include <QTableWidget>
+#include <QTextCursor>
+#include <QTextEdit>
+#include <QTimer>
+#include <QVBoxLayout>
+#include <QWidget>
+#include <libcockatrice/protocol/pb/command_replay_download_by_game_id.pb.h>
+#include <libcockatrice/protocol/pb/command_report_add_comment.pb.h>
+#include <libcockatrice/protocol/pb/command_report_assign.pb.h>
+#include <libcockatrice/protocol/pb/command_report_details.pb.h>
+#include <libcockatrice/protocol/pb/command_report_list.pb.h>
+#include <libcockatrice/protocol/pb/command_report_resolve.pb.h>
+#include <libcockatrice/protocol/pb/command_report_stats.pb.h>
+#include <libcockatrice/protocol/pb/command_report_user_info.pb.h>
+#include <libcockatrice/protocol/pb/game_replay.pb.h>
+#include <libcockatrice/protocol/pb/response_replay_download_by_game_id.pb.h>
+#include <libcockatrice/protocol/pb/response_report_details.pb.h>
+#include <libcockatrice/protocol/pb/response_report_list.pb.h>
+#include <libcockatrice/protocol/pb/response_report_stats.pb.h>
+#include <libcockatrice/protocol/pb/response_report_user_info.pb.h>
+#include <libcockatrice/protocol/pb/serverinfo_report.pb.h>
+#include <libcockatrice/protocol/pending_command.h>
+
+namespace
+{
+constexpr int COL_ID = 0;
+constexpr int COL_TIME = 1;
+constexpr int COL_REPORTER = 2;
+constexpr int COL_REPORTED = 3;
+constexpr int COL_CATEGORY = 4;
+constexpr int COL_GAMEID = 5;
+constexpr int COL_STATUS = 6;
+constexpr int COL_ASSIGNED = 7;
+constexpr int COL_REPLAY = 8;
+constexpr int COL_ROOM = 9;
+constexpr int COL_COUNT = 10;
+constexpr int REFRESH_INTERVAL_MS = 300000;
+} // namespace
+
+TabReport::TabReport(TabSupervisor *_tabSupervisor, AbstractClient *_client) : Tab(_tabSupervisor), client(_client)
+{
+    auto *centralWidget = new QWidget(this);
+    setCentralWidget(centralWidget);
+
+    searchEdit = new QLineEdit;
+    searchEdit->setClearButtonEnabled(true);
+    connect(searchEdit, &QLineEdit::textChanged, this, &TabReport::applyFilters);
+
+    statusFilter = new QComboBox;
+    connect(statusFilter, &QComboBox::currentIndexChanged, this, &TabReport::applyFilters);
+
+    unresolvedOnlyBox = new QCheckBox;
+    unresolvedOnlyBox->setChecked(true);
+#if QT_VERSION >= QT_VERSION_CHECK(6, 7, 0)
+    connect(unresolvedOnlyBox, &QCheckBox::checkStateChanged, this, &TabReport::refreshList);
+#else
+    connect(unresolvedOnlyBox, &QCheckBox::stateChanged, this, &TabReport::refreshList);
+#endif
+
+    refreshButton = new QPushButton;
+    connect(refreshButton, &QPushButton::clicked, this, &TabReport::refreshList);
+
+    refreshTimer = new QTimer(this);
+    refreshTimer->setInterval(REFRESH_INTERVAL_MS);
+    connect(refreshTimer, &QTimer::timeout, this, [this]() {
+        if (tabSupervisor->currentWidget() == this) {
+            refreshList();
+        }
+    });
+    refreshTimer->start();
+
+    auto *topBar = new QHBoxLayout;
+    topBar->addWidget(searchEdit);
+    topBar->addWidget(statusFilter);
+    topBar->addWidget(unresolvedOnlyBox);
+    topBar->addStretch();
+    topBar->addWidget(refreshButton);
+
+    statsLabel = new QLabel;
+
+    table = new QTableWidget(0, COL_COUNT);
+    table->setSelectionBehavior(QAbstractItemView::SelectRows);
+    table->setSelectionMode(QAbstractItemView::SingleSelection);
+    table->setEditTriggers(QAbstractItemView::NoEditTriggers);
+    table->setSortingEnabled(true);
+    table->verticalHeader()->setVisible(false);
+    table->setAlternatingRowColors(true);
+    table->horizontalHeader()->setSectionResizeMode(COL_TIME, QHeaderView::ResizeToContents);
+    table->horizontalHeader()->setSectionResizeMode(COL_REPORTED, QHeaderView::Stretch);
+    table->horizontalHeader()->setSectionResizeMode(COL_REPORTER, QHeaderView::ResizeToContents);
+    connect(table, &QTableWidget::itemSelectionChanged, this, &TabReport::onSelectionChanged);
+
+    descGroup = new QGroupBox;
+    descriptionEdit = new QTextEdit;
+    descriptionEdit->setReadOnly(true);
+    auto *descLayout = new QVBoxLayout(descGroup);
+    descLayout->setContentsMargins(4, 4, 4, 4);
+    descLayout->addWidget(descriptionEdit);
+
+    chatGroup = new QGroupBox;
+    chatLogEdit = new QTextEdit;
+    chatLogEdit->setReadOnly(true);
+    QFont monoFont("monospace");
+    monoFont.setStyleHint(QFont::Monospace);
+    const int systemPointSize = QFontDatabase::systemFont(QFontDatabase::GeneralFont).pointSize();
+    if (systemPointSize > 0) {
+        monoFont.setPointSize(systemPointSize);
+    }
+    chatLogEdit->setFont(monoFont);
+    auto *chatLayout = new QVBoxLayout(chatGroup);
+    chatLayout->setContentsMargins(4, 4, 4, 4);
+    chatLayout->addWidget(chatLogEdit);
+
+    commentsGroup = new QGroupBox;
+    commentsEdit = new QTextEdit;
+    commentsEdit->setReadOnly(true);
+    auto *commentInputRow = new QHBoxLayout;
+    commentInput = new QLineEdit;
+    commentButton = new QPushButton;
+    commentButton->setEnabled(false);
+    connect(commentButton, &QPushButton::clicked, this, &TabReport::addComment);
+    connect(commentInput, &QLineEdit::returnPressed, this, &TabReport::addComment);
+    commentInputRow->addWidget(commentInput);
+    commentInputRow->addWidget(commentButton);
+    auto *commentsLayout = new QVBoxLayout(commentsGroup);
+    commentsLayout->setContentsMargins(4, 4, 4, 4);
+    commentsLayout->addWidget(commentsEdit);
+    commentsLayout->addLayout(commentInputRow);
+
+    userContextGroup = new QGroupBox;
+    userContextName = new QLabel;
+    userContextAccountAge = new QLabel;
+    userContextReports = new QLabel;
+    userContextBans = new QLabel;
+    userContextWarns = new QLabel;
+    userContextNotes = new QTextEdit;
+    userContextNotes->setReadOnly(true);
+    userContextNotes->setMaximumHeight(80);
+    userContextRecentReports = new QTextEdit;
+    userContextRecentReports->setReadOnly(true);
+    userContextRecentReports->setMaximumHeight(120);
+    userContextUserLabel = new QLabel;
+    userContextAgeLabel = new QLabel;
+    userContextReportsLabel = new QLabel;
+    userContextBansLabel = new QLabel;
+    userContextWarnsLabel = new QLabel;
+    userContextNotesLabel = new QLabel;
+    userContextRecentReportsLabel = new QLabel;
+    auto *ucLayout = new QGridLayout(userContextGroup);
+    ucLayout->setContentsMargins(8, 8, 8, 8);
+    ucLayout->addWidget(userContextUserLabel, 0, 0);
+    ucLayout->addWidget(userContextName, 0, 1, 1, 3);
+    ucLayout->addWidget(userContextAgeLabel, 1, 0);
+    ucLayout->addWidget(userContextAccountAge, 1, 1);
+    ucLayout->addWidget(userContextReportsLabel, 1, 2);
+    ucLayout->addWidget(userContextReports, 1, 3);
+    ucLayout->addWidget(userContextBansLabel, 2, 0);
+    ucLayout->addWidget(userContextBans, 2, 1);
+    ucLayout->addWidget(userContextWarnsLabel, 2, 2);
+    ucLayout->addWidget(userContextWarns, 2, 3);
+    ucLayout->addWidget(userContextNotesLabel, 3, 0, Qt::AlignTop);
+    ucLayout->addWidget(userContextNotes, 3, 1, 1, 3);
+    ucLayout->addWidget(userContextRecentReportsLabel, 4, 0, 1, 4);
+    ucLayout->addWidget(userContextRecentReports, 5, 0, 1, 4);
+    userContextGroup->setVisible(false);
+
+    statsGroup = new QGroupBox;
+    statsGroup->setCheckable(true);
+    statsTotalLabel = new QLabel;
+    statsTrendLabel = new QLabel;
+    statsCategoriesLabel = new QLabel;
+    statsDetailText = new QTextEdit;
+    statsDetailText->setReadOnly(true);
+    statsDetailText->setMaximumHeight(150);
+    auto *statsContent = new QWidget;
+    auto *sgLayout = new QVBoxLayout(statsContent);
+    sgLayout->setContentsMargins(8, 8, 8, 8);
+    sgLayout->addWidget(statsTotalLabel);
+    sgLayout->addWidget(statsTrendLabel);
+    sgLayout->addWidget(statsCategoriesLabel);
+    sgLayout->addWidget(statsDetailText);
+    auto *statsGroupLayout = new QVBoxLayout(statsGroup);
+    statsGroupLayout->setContentsMargins(0, 0, 0, 0);
+    statsGroupLayout->addWidget(statsContent);
+    statsGroup->setChecked(true);
+    connect(statsGroup, &QGroupBox::toggled, this, [this, statsContent](bool checked) {
+        statsContent->setVisible(checked);
+        if (checked) {
+            requestStats();
+        }
+    });
+
+    detailSplitter = new QSplitter(Qt::Vertical);
+    detailSplitter->addWidget(descGroup);
+    detailSplitter->addWidget(chatGroup);
+    detailSplitter->addWidget(commentsGroup);
+    detailSplitter->setStretchFactor(0, 1);
+    detailSplitter->setStretchFactor(1, 1);
+    detailSplitter->setStretchFactor(2, 2);
+
+    assignButton = new QPushButton;
+    resolveButton = new QPushButton;
+    resolveWithNoteButton = new QPushButton;
+    dismissButton = new QPushButton;
+    viewReplayButton = new QPushButton;
+    joinGameButton = new QPushButton;
+    connect(assignButton, &QPushButton::clicked, this, &TabReport::assignReport);
+    connect(resolveButton, &QPushButton::clicked, this, [this]() { resolveReport(false, false); });
+    connect(resolveWithNoteButton, &QPushButton::clicked, this, [this]() { resolveReport(false, true); });
+    connect(dismissButton, &QPushButton::clicked, this, [this]() { resolveReport(true, true); });
+    connect(viewReplayButton, &QPushButton::clicked, this, &TabReport::viewReplay);
+    connect(joinGameButton, &QPushButton::clicked, this, &TabReport::joinGame);
+
+    statusLabel = new QLabel;
+
+    auto *actionBar = new QHBoxLayout;
+    actionBar->addWidget(assignButton);
+    actionBar->addWidget(resolveButton);
+    actionBar->addWidget(resolveWithNoteButton);
+    actionBar->addWidget(dismissButton);
+    actionBar->addSpacing(20);
+    actionBar->addWidget(viewReplayButton);
+    actionBar->addWidget(joinGameButton);
+    actionBar->addStretch();
+    actionBar->addWidget(statusLabel);
+
+    auto *layout = new QVBoxLayout(centralWidget);
+    layout->addLayout(topBar);
+    layout->addWidget(statsLabel);
+    layout->addWidget(table, 2);
+    layout->addWidget(detailSplitter, 1);
+    layout->addWidget(userContextGroup);
+    layout->addWidget(statsGroup);
+    layout->addLayout(actionBar);
+
+    retranslateUi();
+
+    setActionsEnabled(false);
+    refreshList();
+}
+
+void TabReport::retranslateUi()
+{
+    searchEdit->setPlaceholderText(tr("Search by username, category..."));
+    statusFilter->clear();
+    statusFilter->addItem(tr("All Statuses"), "");
+    statusFilter->addItem(tr("Open"), "open");
+    statusFilter->addItem(tr("Assigned"), "assigned");
+    statusFilter->addItem(tr("Resolved"), "resolved");
+    statusFilter->addItem(tr("Dismissed"), "dismissed");
+    unresolvedOnlyBox->setText(tr("Unresolved only"));
+    refreshButton->setText(tr("Refresh"));
+
+    table->setHorizontalHeaderLabels({tr("#"), tr("Time"), tr("Reporter"), tr("Reported User"), tr("Category"),
+                                      tr("Game ID"), tr("Status"), tr("Assigned To"), tr("Replay"), tr("Room")});
+
+    descGroup->setTitle(tr("Description"));
+    chatGroup->setTitle(tr("Chat Log Context"));
+    chatGroup->setToolTip(
+        tr("Chat log attached by the reporter. It is captured from their client and may be incomplete or edited."));
+    commentsGroup->setTitle(tr("Comments / Thread"));
+    descriptionEdit->setPlaceholderText(tr("No description."));
+    chatLogEdit->setPlaceholderText(tr("No chat log attached."));
+    commentsEdit->setPlaceholderText(tr("No comments yet."));
+    commentInput->setPlaceholderText(tr("Type a reply..."));
+    commentButton->setText(tr("Send"));
+
+    userContextGroup->setTitle(tr("Reported User Context"));
+    userContextUserLabel->setText(tr("User:"));
+    userContextAgeLabel->setText(tr("Account Age:"));
+    userContextReportsLabel->setText(tr("Reports:"));
+    userContextBansLabel->setText(tr("Bans:"));
+    userContextWarnsLabel->setText(tr("Warns:"));
+    userContextNotesLabel->setText(tr("Admin Notes:"));
+    userContextRecentReportsLabel->setText(tr("Recent Reports Against User:"));
+    userContextAccountAge->setText(QString());
+    userContextReports->setText(QString());
+    userContextBans->setText(QString());
+    userContextWarns->setText(QString());
+
+    statsGroup->setTitle(tr("Report Statistics"));
+
+    assignButton->setText(tr("Assign to Me"));
+    resolveButton->setText(tr("Resolve"));
+    resolveWithNoteButton->setText(tr("Resolve with note..."));
+    dismissButton->setText(tr("Dismiss..."));
+    viewReplayButton->setText(tr("View Replay"));
+    joinGameButton->setText(tr("Join Game"));
+}
+
+void TabReport::refreshList()
+{
+    selectedReportIdBeforeRefresh = selectedReportId();
+    commentDraftBeforeRefresh = commentInput->text();
+    previousSelectedReportValid = selectedReportInfo(previousSelectedReport);
+
+    refreshButton->setEnabled(false);
+    statusLabel->setText(tr("Loading..."));
+    table->setRowCount(0);
+    allReports.clear();
+    filteredReports.clear();
+    commentButton->setEnabled(false);
+    setActionsEnabled(false);
+
+    Command_ReportList cmd;
+    cmd.set_unresolved_only(unresolvedOnlyBox->isChecked());
+
+    PendingCommand *pend = client->prepareModeratorCommand(cmd);
+    connect(pend, &PendingCommand::finished, this, &TabReport::reportListResponse);
+    client->sendCommand(pend);
+}
+
+void TabReport::reportListResponse(const Response &response)
+{
+    refreshButton->setEnabled(true);
+
+    if (response.response_code() != Response::RespOk) {
+        statusLabel->setText(tr("Failed to load reports."));
+        return;
+    }
+
+    const Response_ReportList &resp = response.GetExtension(Response_ReportList::ext);
+    allReports.clear();
+    for (int i = 0; i < resp.reports_size(); ++i) {
+        allReports.append(resp.reports(i));
+    }
+
+    applyFilters();
+    updateStats();
+
+    if (selectedReportIdBeforeRefresh >= 0) {
+        bool found = false;
+        for (int row = 0; row < table->rowCount(); ++row) {
+            if (table->item(row, COL_ID) &&
+                table->item(row, COL_ID)->data(Qt::UserRole).toInt() == selectedReportIdBeforeRefresh) {
+                found = true;
+                {
+                    QSignalBlocker blocker(table);
+                    table->setCurrentCell(row, 0);
+                }
+                break;
+            }
+        }
+
+        if (found) {
+            bool dataChanged = false;
+            ServerInfo_Report newReport;
+            if (!selectedReportInfo(newReport) || !previousSelectedReportValid ||
+                previousSelectedReport.description() != newReport.description() ||
+                previousSelectedReport.status() != newReport.status() ||
+                previousSelectedReport.resolution_note() != newReport.resolution_note() ||
+                previousSelectedReport.assigned_mod_name() != newReport.assigned_mod_name()) {
+                dataChanged = true;
+            }
+
+            if (dataChanged || detailsRequestedReportId != selectedReportIdBeforeRefresh) {
+                loadReportDetails(selectedReportIdBeforeRefresh);
+            }
+            updateActionStates();
+        } else {
+            descriptionEdit->clear();
+            chatLogEdit->clear();
+            commentsEdit->clear();
+            setActionsEnabled(false);
+            userContextGroup->setVisible(false);
+        }
+    }
+
+    if (commentInput->text().isEmpty()) {
+        commentInput->setText(commentDraftBeforeRefresh);
+    }
+
+    if (statsGroup->isChecked()) {
+        requestStats();
+    }
+}
+
+void TabReport::applyFilters()
+{
+    filteredReports.clear();
+
+    const QString searchText = searchEdit->text().toLower();
+    const QString statusFilterValue = statusFilter->currentData().toString();
+
+    for (const ServerInfo_Report &r : allReports) {
+        bool matchesSearch = searchText.isEmpty() ||
+                             QString::fromStdString(r.reporter_name()).toLower().contains(searchText) ||
+                             QString::fromStdString(r.reported_user_name()).toLower().contains(searchText) ||
+                             QString::fromStdString(r.category()).toLower().contains(searchText) ||
+                             QString::fromStdString(r.description()).toLower().contains(searchText);
+
+        bool matchesStatus = statusFilterValue.isEmpty() || QString::fromStdString(r.status()) == statusFilterValue;
+
+        if (matchesSearch && matchesStatus) {
+            filteredReports.append(r);
+        }
+    }
+
+    table->setSortingEnabled(false);
+    table->setRowCount(filteredReports.size());
+
+    for (int row = 0; row < filteredReports.size(); ++row) {
+        const ServerInfo_Report &r = filteredReports[row];
+
+        report_utils::fillReportTableRow(table, row, r, COL_ID, COL_TIME, COL_REPORTED, COL_CATEGORY, COL_GAMEID,
+                                         COL_STATUS, COL_ASSIGNED);
+
+        table->setItem(row, COL_REPORTER, new QTableWidgetItem(QString::fromStdString(r.reporter_name())));
+
+        table->setItem(row, COL_REPLAY,
+                       new QTableWidgetItem(r.has_replay_id() && r.replay_id() > 0 ? tr("Yes") : tr("No")));
+
+        table->setItem(row, COL_ROOM,
+                       new QTableWidgetItem(r.has_room_id() && r.room_id() > 0 ? QString::number(r.room_id()) : ""));
+    }
+
+    table->setSortingEnabled(true);
+    table->resizeColumnsToContents();
+    table->horizontalHeader()->setSectionResizeMode(COL_REPORTED, QHeaderView::Stretch);
+
+    statusLabel->setText(tr("%1 report(s)").arg(filteredReports.size()));
+}
+
+void TabReport::updateStats()
+{
+    int open = 0, assigned = 0, resolved = 0, dismissed = 0;
+    for (const ServerInfo_Report &r : allReports) {
+        QString status = QString::fromStdString(r.status());
+        if (status == "open") {
+            open++;
+        } else if (status == "assigned") {
+            assigned++;
+        } else if (status == "resolved") {
+            resolved++;
+        } else if (status == "dismissed") {
+            dismissed++;
+        }
+    }
+
+    statsLabel->setText(tr("%1 open  |  %2 assigned  |  %3 resolved  |  %4 dismissed")
+                            .arg(open)
+                            .arg(assigned)
+                            .arg(resolved)
+                            .arg(dismissed));
+}
+
+void TabReport::onSelectionChanged()
+{
+    const int row = table->currentRow();
+    if (row < 0 || !table->item(row, COL_ID)) {
+        descriptionEdit->clear();
+        chatLogEdit->clear();
+        commentsEdit->clear();
+        commentInput->clear();
+        commentButton->setEnabled(false);
+        setActionsEnabled(false);
+        userContextGroup->setVisible(false);
+        return;
+    }
+
+    const int reportId = table->item(row, COL_ID)->data(Qt::UserRole).toInt();
+    loadReportDetails(reportId);
+    updateActionStates();
+}
+
+void TabReport::loadReportDetails(int reportId)
+{
+    detailsRequestedReportId = reportId;
+
+    for (const ServerInfo_Report &r : filteredReports) {
+        if (r.report_id() == reportId) {
+            descriptionEdit->setPlainText(QString::fromStdString(r.description()));
+
+            QString reportedUser = QString::fromStdString(r.reported_user_name());
+            if (!reportedUser.isEmpty()) {
+                requestUserInfo(reportedUser);
+            } else {
+                userContextGroup->setVisible(false);
+            }
+
+            QString status = QString::fromStdString(r.status());
+            bool canComment = (status == "open" || status == "assigned");
+            commentButton->setEnabled(canComment);
+            commentInput->setEnabled(canComment);
+            if (!canComment) {
+                commentInput->setPlaceholderText(tr("This report is closed."));
+            } else {
+                commentInput->setPlaceholderText(tr("Type a reply..."));
+            }
+            break;
+        }
+    }
+
+    chatLogEdit->setPlainText(tr("Loading..."));
+    commentsEdit->setPlainText(tr("Loading..."));
+
+    Command_ReportDetails cmd;
+    cmd.set_report_id(reportId);
+
+    const int seq = ++detailsRequestSeq;
+    PendingCommand *pend = client->prepareSessionCommand(cmd);
+    connect(pend, &PendingCommand::finished, this, [this, seq](const Response &response) {
+        if (seq != detailsRequestSeq) {
+            return;
+        }
+        reportDetailsResponse(response);
+    });
+    client->sendCommand(pend);
+}
+
+void TabReport::reportDetailsResponse(const Response &response)
+{
+    if (response.response_code() != Response::RespOk) {
+        if (selectedReportId() == detailsRequestedReportId) {
+            chatLogEdit->clear();
+            commentsEdit->setPlainText(tr("Failed to load report details."));
+        }
+        return;
+    }
+
+    const Response_ReportDetails &resp = response.GetExtension(Response_ReportDetails::ext);
+    const ServerInfo_Report &r = resp.report();
+
+    if (selectedReportId() != r.report_id()) {
+        return;
+    }
+
+    report_utils::renderReportDetails(chatLogEdit, commentsEdit, r, tr("No comments yet."), tr("[Moderator]"),
+                                      tr("[Reporter]"));
+}
+
+void TabReport::updateActionStates()
+{
+    const int row = table->currentRow();
+    if (row < 0 || !table->item(row, COL_STATUS)) {
+        setActionsEnabled(false);
+        return;
+    }
+
+    ServerInfo_Report report;
+    if (!selectedReportInfo(report)) {
+        setActionsEnabled(false);
+        return;
+    }
+
+    const QString status = QString::fromStdString(report.status());
+    assignButton->setEnabled(status == "open");
+    resolveButton->setEnabled(status == "open" || status == "assigned");
+    resolveWithNoteButton->setEnabled(status == "open" || status == "assigned");
+    dismissButton->setEnabled(status == "open" || status == "assigned");
+
+    const bool hasGameId = report.game_id() > 0;
+    const bool hasReplay = hasGameId && report.has_replay_id() && report.replay_id() > 0;
+    viewReplayButton->setEnabled(hasReplay);
+    joinGameButton->setEnabled(hasGameId && report.has_room_id() && report.room_id() > 0);
+}
+
+void TabReport::setActionsEnabled(bool enabled)
+{
+    assignButton->setEnabled(enabled);
+    resolveButton->setEnabled(enabled);
+    resolveWithNoteButton->setEnabled(enabled);
+    dismissButton->setEnabled(enabled);
+    viewReplayButton->setEnabled(false);
+    joinGameButton->setEnabled(false);
+    commentButton->setEnabled(enabled);
+    commentInput->setEnabled(enabled);
+}
+
+int TabReport::selectedReportId() const
+{
+    const int row = table->currentRow();
+    if (row < 0 || !table->item(row, COL_ID)) {
+        return -1;
+    }
+    return table->item(row, COL_ID)->data(Qt::UserRole).toInt();
+}
+
+bool TabReport::selectedReportInfo(ServerInfo_Report &info) const
+{
+    const int reportId = selectedReportId();
+    if (reportId < 0) {
+        return false;
+    }
+
+    for (const ServerInfo_Report &r : filteredReports) {
+        if (r.report_id() == reportId) {
+            info = r;
+            return true;
+        }
+    }
+
+    return false;
+}
+
+void TabReport::assignReport()
+{
+    const int reportId = selectedReportId();
+    if (reportId < 0) {
+        return;
+    }
+
+    setActionsEnabled(false);
+    statusLabel->setText(tr("Assigning..."));
+
+    Command_ReportAssign cmd;
+    cmd.set_report_id(reportId);
+
+    PendingCommand *pend = client->prepareModeratorCommand(cmd);
+    connect(pend, &PendingCommand::finished, this, &TabReport::assignResponse);
+    client->sendCommand(pend);
+}
+
+void TabReport::assignResponse(const Response &response)
+{
+    if (response.response_code() == Response::RespOk) {
+        statusLabel->setText(tr("Assigned."));
+        refreshList();
+    } else {
+        statusLabel->setText(tr("Assignment failed."));
+        updateActionStates();
+    }
+}
+
+void TabReport::resolveReport(bool dismissed, bool promptNote)
+{
+    const int reportId = selectedReportId();
+    if (reportId < 0) {
+        return;
+    }
+
+    QString note;
+    if (promptNote) {
+        bool ok;
+        note = QInputDialog::getText(this, dismissed ? tr("Dismiss Report") : tr("Resolve Report"),
+                                     dismissed ? tr("Optional note:") : tr("Resolution note (optional):"),
+                                     QLineEdit::Normal, QString(), &ok);
+        if (!ok) {
+            return;
+        }
+    }
+
+    setActionsEnabled(false);
+    statusLabel->setText(dismissed ? tr("Dismissing...") : tr("Resolving..."));
+
+    Command_ReportResolve cmd;
+    cmd.set_report_id(reportId);
+    cmd.set_dismissed(dismissed);
+    if (!note.isEmpty()) {
+        cmd.set_resolution_note(note.toStdString());
+    }
+
+    PendingCommand *pend = client->prepareModeratorCommand(cmd);
+    connect(pend, &PendingCommand::finished, this, &TabReport::resolveResponse);
+    client->sendCommand(pend);
+}
+
+void TabReport::resolveResponse(const Response &response)
+{
+    if (response.response_code() == Response::RespOk) {
+        statusLabel->setText(tr("Done."));
+        refreshList();
+    } else {
+        statusLabel->setText(tr("Action failed."));
+        updateActionStates();
+    }
+}
+
+void TabReport::viewReplay()
+{
+    ServerInfo_Report report;
+    if (!selectedReportInfo(report) || report.game_id() <= 0) {
+        return;
+    }
+
+    setActionsEnabled(false);
+    statusLabel->setText(tr("Loading replay..."));
+
+    Command_ReplayDownloadByGameId cmd;
+    cmd.set_game_id(report.game_id());
+
+    PendingCommand *pend = client->prepareModeratorCommand(cmd);
+    connect(pend, &PendingCommand::finished, this, &TabReport::viewReplayResponse);
+    client->sendCommand(pend);
+}
+
+void TabReport::viewReplayResponse(const Response &response)
+{
+    if (response.response_code() != Response::RespOk) {
+        statusLabel->setText(tr("No replay available for this game."));
+        updateActionStates();
+        return;
+    }
+
+    const Response_ReplayDownloadByGameId &resp = response.GetExtension(Response_ReplayDownloadByGameId::ext);
+    GameReplay *replay = new GameReplay;
+    if (replay->ParseFromString(resp.replay_data())) {
+        emit openReplay(replay);
+        statusLabel->setText(tr("Replay opened."));
+    } else {
+        delete replay;
+        statusLabel->setText(tr("Failed to parse replay."));
+    }
+
+    updateActionStates();
+}
+
+void TabReport::joinGame()
+{
+    ServerInfo_Report report;
+    if (!selectedReportInfo(report) || report.game_id() <= 0) {
+        return;
+    }
+
+    const int roomId = report.has_room_id() ? report.room_id() : -1;
+    if (roomId <= 0) {
+        statusLabel->setText(tr("No room recorded for this report, use the replay instead."));
+        return;
+    }
+
+    emit requestJoinGame(report.game_id(), roomId);
+    statusLabel->setText(tr("Attempting to join game..."));
+}
+
+void TabReport::addComment()
+{
+    const int reportId = selectedReportId();
+    if (reportId < 0) {
+        return;
+    }
+
+    QString text = commentInput->text().trimmed();
+    if (text.isEmpty()) {
+        return;
+    }
+
+    commentButton->setEnabled(false);
+
+    Command_ReportAddComment cmd;
+    cmd.set_report_id(reportId);
+    cmd.set_comment(text.toStdString());
+
+    PendingCommand *pend = client->prepareSessionCommand(cmd);
+    connect(pend, &PendingCommand::finished, this, &TabReport::addCommentResponse);
+    client->sendCommand(pend);
+}
+
+void TabReport::addCommentResponse(const Response &response)
+{
+    if (response.response_code() == Response::RespOk) {
+        commentInput->clear();
+        refreshList();
+    } else {
+        commentButton->setEnabled(true);
+        statusLabel->setText(tr("Failed to send comment."));
+    }
+}
+
+void TabReport::requestUserInfo(const QString &userName)
+{
+    if (userName.isEmpty()) {
+        userContextGroup->setVisible(false);
+        return;
+    }
+
+    lastRequestedUser = userName;
+    userContextGroup->setVisible(true);
+    userContextName->setText(userName);
+    userContextAccountAge->setText(tr("Loading..."));
+    userContextReports->clear();
+    userContextBans->clear();
+    userContextWarns->clear();
+    userContextNotes->clear();
+    userContextRecentReports->clear();
+
+    Command_ReportUserInfo cmd;
+    cmd.set_user_name(userName.toStdString());
+
+    PendingCommand *pend = client->prepareModeratorCommand(cmd);
+    connect(pend, &PendingCommand::finished, this, &TabReport::userInfoResponse);
+    client->sendCommand(pend);
+}
+
+void TabReport::userInfoResponse(const Response &response)
+{
+    if (response.response_code() != Response::RespOk) {
+        userContextAccountAge->setText(tr("Error loading user info."));
+        return;
+    }
+
+    const Response_ReportUserInfo &resp = response.GetExtension(Response_ReportUserInfo::ext);
+
+    if (resp.has_user_name() && QString::fromStdString(resp.user_name()) != lastRequestedUser) {
+        return;
+    }
+
+    QDateTime regTime = QDateTime::fromSecsSinceEpoch(resp.registration_time());
+    qint64 daysSinceReg = regTime.daysTo(QDateTime::currentDateTime());
+    userContextAccountAge->setText(tr("%1 days (since %2)").arg(daysSinceReg).arg(regTime.toString("yyyy-MM-dd")));
+
+    userContextReports->setText(QString::number(resp.total_reports()));
+    userContextBans->setText(QString::number(resp.total_bans()));
+    userContextWarns->setText(QString::number(resp.total_warns()));
+
+    if (resp.has_admin_notes() && !resp.admin_notes().empty()) {
+        userContextNotes->setPlainText(QString::fromStdString(resp.admin_notes()));
+    } else {
+        userContextNotes->setPlainText(tr("(none)"));
+    }
+
+    userContextRecentReports->clear();
+    if (resp.recent_reports_size() == 0) {
+        userContextRecentReports->setPlainText(tr("No previous reports against this user."));
+    } else {
+        for (int i = 0; i < resp.recent_reports_size(); ++i) {
+            const ServerInfo_Report &r = resp.recent_reports(i);
+            QDateTime dt = QDateTime::fromSecsSinceEpoch(r.report_time());
+            userContextRecentReports->moveCursor(QTextCursor::End);
+            userContextRecentReports->insertPlainText(QString("[%1] #%2 by %3 [%4]: %5\n")
+                                                          .arg(dt.toString("yyyy-MM-dd"))
+                                                          .arg(r.report_id())
+                                                          .arg(QString::fromStdString(r.reporter_name()))
+                                                          .arg(QString::fromStdString(r.status()))
+                                                          .arg(QString::fromStdString(r.category())));
+        }
+    }
+}
+
+void TabReport::requestStats()
+{
+    statsTotalLabel->setText(tr("Loading statistics..."));
+    statsTrendLabel->clear();
+    statsCategoriesLabel->clear();
+    statsDetailText->clear();
+
+    Command_ReportStats cmd;
+
+    PendingCommand *pend = client->prepareModeratorCommand(cmd);
+    connect(pend, &PendingCommand::finished, this, &TabReport::statsResponse);
+    client->sendCommand(pend);
+}
+
+void TabReport::statsResponse(const Response &response)
+{
+    if (response.response_code() != Response::RespOk) {
+        statsTotalLabel->setText(tr("Error loading statistics."));
+        return;
+    }
+
+    const Response_ReportStats &resp = response.GetExtension(Response_ReportStats::ext);
+
+    statsTotalLabel->setText(tr("Total: %1 reports (%2 open, %3 assigned, %4 resolved/dismissed)")
+                                 .arg(resp.total_reports())
+                                 .arg(resp.total_pending())
+                                 .arg(resp.total_assigned())
+                                 .arg(resp.total_resolved()));
+
+    statsTrendLabel->setText(tr("Last 24h: %1  |  Last 7d: %2  |  Last 30d: %3  |  Avg resolution: %4h")
+                                 .arg(resp.reports_last_24h())
+                                 .arg(resp.reports_last_7d())
+                                 .arg(resp.reports_last_30d())
+                                 .arg(resp.avg_resolution_hours(), 0, 'f', 1));
+
+    QString weekCompare =
+        tr("This week: %1 vs last week: %2 (%3%)")
+            .arg(resp.reports_this_week())
+            .arg(resp.reports_last_week())
+            .arg(resp.reports_last_week() > 0 ? QString::number(((resp.reports_this_week() - resp.reports_last_week()) *
+                                                                 100.0 / resp.reports_last_week()),
+                                                                'f', 0)
+                 : resp.reports_this_week() > 0 ? "new"
+                                                : "0");
+    statsTrendLabel->setText(statsTrendLabel->text() + "  |  " + weekCompare);
+
+    statsCategoriesLabel->setText(tr("By category:"));
+    statsDetailText->clear();
+
+    statsDetailText->moveCursor(QTextCursor::End);
+    statsDetailText->insertPlainText(tr("=== Top Categories ===") + "\n");
+    for (int i = 0; i < resp.category_counts_size(); ++i) {
+        const ReportCategoryCount &cc = resp.category_counts(i);
+        QString cat = QString::fromStdString(cc.category());
+        cat.replace('_', ' ');
+        cat = cat.left(1).toUpper() + cat.mid(1);
+        statsDetailText->moveCursor(QTextCursor::End);
+        statsDetailText->insertPlainText(QString("  %1: %2\n").arg(cat).arg(cc.count()));
+    }
+
+    statsDetailText->moveCursor(QTextCursor::End);
+    statsDetailText->insertPlainText("\n" + tr("=== Most Reported Users ===") + "\n");
+    for (int i = 0; i < resp.top_reported_users_size(); ++i) {
+        const ReportTopUser &tu = resp.top_reported_users(i);
+        statsDetailText->moveCursor(QTextCursor::End);
+        statsDetailText->insertPlainText(
+            QString("  %1: %2 reports\n").arg(QString::fromStdString(tu.user_name())).arg(tu.count()));
+    }
+
+    statsDetailText->moveCursor(QTextCursor::End);
+    statsDetailText->insertPlainText("\n" + tr("=== Top Reporters ===") + "\n");
+    for (int i = 0; i < resp.top_reporters_size(); ++i) {
+        const ReportTopUser &tu = resp.top_reporters(i);
+        statsDetailText->moveCursor(QTextCursor::End);
+        statsDetailText->insertPlainText(
+            QString("  %1: %2 reports filed\n").arg(QString::fromStdString(tu.user_name())).arg(tu.count()));
+    }
+}

cockatrice/src/interface/widgets/tabs/tab_report.h

@@ -0,0 +1,124 @@
+#ifndef TAB_REPORT_H
+#define TAB_REPORT_H
+
+#include "tab.h"
+
+#include <QList>
+#include <libcockatrice/protocol/pb/response.pb.h>
+#include <libcockatrice/protocol/pb/serverinfo_report.pb.h>
+
+class AbstractClient;
+class QCheckBox;
+class QComboBox;
+class QGroupBox;
+class QLabel;
+class QLineEdit;
+class QPushButton;
+class QSplitter;
+class QTableWidget;
+class QTextEdit;
+class QTimer;
+class GameReplay;
+
+class TabReport : public Tab
+{
+    Q_OBJECT
+public:
+    TabReport(TabSupervisor *_tabSupervisor, AbstractClient *_client);
+    void retranslateUi() override;
+    [[nodiscard]] QString getTabText() const override
+    {
+        return tr("Report Queue");
+    }
+
+signals:
+    void openReplay(GameReplay *replay);
+    void requestJoinGame(int gameId, int roomId);
+
+private slots:
+    void refreshList();
+    void reportListResponse(const Response &response);
+    void assignReport();
+    void assignResponse(const Response &response);
+    void resolveReport(bool dismissed, bool promptNote);
+    void resolveResponse(const Response &response);
+    void onSelectionChanged();
+    void viewReplay();
+    void viewReplayResponse(const Response &response);
+    void joinGame();
+    void addComment();
+    void addCommentResponse(const Response &response);
+    void requestUserInfo(const QString &userName);
+    void userInfoResponse(const Response &response);
+    void reportDetailsResponse(const Response &response);
+    void requestStats();
+    void statsResponse(const Response &response);
+
+private:
+    int selectedReportId() const;
+    bool selectedReportInfo(ServerInfo_Report &info) const;
+    void setActionsEnabled(bool enabled);
+    void updateActionStates();
+    void applyFilters();
+    void updateStats();
+    void loadReportDetails(int reportId);
+
+    AbstractClient *client;
+
+    QLineEdit *searchEdit;
+    QComboBox *statusFilter;
+    QCheckBox *unresolvedOnlyBox;
+    QPushButton *refreshButton;
+    QLabel *statsLabel;
+    QTableWidget *table;
+    QSplitter *detailSplitter;
+    QGroupBox *descGroup;
+    QGroupBox *chatGroup;
+    QGroupBox *commentsGroup;
+    QTextEdit *descriptionEdit;
+    QTextEdit *chatLogEdit;
+    QTextEdit *commentsEdit;
+    QLineEdit *commentInput;
+    QPushButton *commentButton;
+    QPushButton *assignButton;
+    QPushButton *resolveButton;
+    QPushButton *resolveWithNoteButton;
+    QPushButton *dismissButton;
+    QPushButton *viewReplayButton;
+    QPushButton *joinGameButton;
+    QLabel *statusLabel;
+    QTimer *refreshTimer;
+
+    QGroupBox *userContextGroup;
+    QLabel *userContextName;
+    QLabel *userContextAccountAge;
+    QLabel *userContextReports;
+    QLabel *userContextBans;
+    QLabel *userContextWarns;
+    QTextEdit *userContextNotes;
+    QTextEdit *userContextRecentReports;
+    QLabel *userContextUserLabel;
+    QLabel *userContextAgeLabel;
+    QLabel *userContextReportsLabel;
+    QLabel *userContextBansLabel;
+    QLabel *userContextWarnsLabel;
+    QLabel *userContextNotesLabel;
+    QLabel *userContextRecentReportsLabel;
+    QString lastRequestedUser;
+    QGroupBox *statsGroup;
+    QLabel *statsTotalLabel;
+    QLabel *statsTrendLabel;
+    QLabel *statsCategoriesLabel;
+    QTextEdit *statsDetailText;
+
+    QList<ServerInfo_Report> allReports;
+    QList<ServerInfo_Report> filteredReports;
+    int detailsRequestedReportId = -1;
+    int detailsRequestSeq = 0;
+    int selectedReportIdBeforeRefresh = -1;
+    QString commentDraftBeforeRefresh;
+    ServerInfo_Report previousSelectedReport;
+    bool previousSelectedReportValid = false;
+};
+
+#endif // TAB_REPORT_H

cockatrice/src/interface/widgets/tabs/tab_supervisor.cpp

@@ -2,6 +2,7 @@
 
 #include "../../../client/settings/cache_settings.h"
 #include "../../../client/settings/shortcuts_settings.h"
+#include "../../intents/intent_join_server_game.h"
 #include "../interface/pixel_map_generator.h"
 #include "../interface/widgets/server/game_link.h"
 #include "../interface/widgets/server/user/user_list_manager.h"
@@ -18,7 +19,9 @@
 #include "tab_home.h"
 #include "tab_logs.h"
 #include "tab_message.h"
+#include "tab_moderation.h"
 #include "tab_replays.h"
+#include "tab_report.h"
 #include "tab_room.h"
 #include "tab_server.h"
 #include "tab_visual_database_display.h"
@@ -31,6 +34,7 @@
 #include <QPainter>
 #include <QSystemTrayIcon>
 #include <libcockatrice/network/client/abstract/abstract_client.h>
+#include <libcockatrice/network/client/remote/remote_client.h>
 #include <libcockatrice/protocol/pb/event_game_joined.pb.h>
 #include <libcockatrice/protocol/pb/event_notify_user.pb.h>
 #include <libcockatrice/protocol/pb/event_user_message.pb.h>
@@ -39,6 +43,7 @@
 #include <libcockatrice/protocol/pb/room_event.pb.h>
 #include <libcockatrice/protocol/pb/serverinfo_room.pb.h>
 #include <libcockatrice/protocol/pb/serverinfo_user.pb.h>
+#include <libcockatrice/protocol/pending_command.h>
 #include <libcockatrice/settings/chat_settings.h>
 #include <libcockatrice/settings/deck_editor_settings.h>
 #include <libcockatrice/settings/interface_settings.h>
@@ -113,7 +118,7 @@ void CloseButton::paintEvent(QPaintEvent * /*event*/)
 TabSupervisor::TabSupervisor(AbstractClient *_client, QMenu *tabsMenu, QWidget *parent)
     : QTabWidget(parent), userInfo(nullptr), client(_client), tabsMenu(tabsMenu), tabVisualDeckStorage(nullptr),
       tabServer(nullptr), tabAccount(nullptr), tabDeckStorage(nullptr), tabReplays(nullptr), tabAdmin(nullptr),
-      tabLog(nullptr), isLocalGame(false)
+      tabLog(nullptr), tabReport(nullptr), tabModeration(nullptr), isLocalGame(false)
 {
     setElideMode(Qt::ElideRight);
     setMovable(true);
@@ -190,6 +195,14 @@ TabSupervisor::TabSupervisor(AbstractClient *_client, QMenu *tabsMenu, QWidget *
     aTabLog->setCheckable(true);
     connect(aTabLog, &QAction::triggered, this, &TabSupervisor::actTabLog);
 
+    aTabReport = new QAction(this);
+    aTabReport->setCheckable(true);
+    connect(aTabReport, &QAction::triggered, this, &TabSupervisor::actTabReport);
+
+    aTabModeration = new QAction(this);
+    aTabModeration->setCheckable(true);
+    connect(aTabModeration, &QAction::triggered, this, &TabSupervisor::actTabModeration);
+
     connect(&SettingsCache::instance().shortcuts(), &ShortcutsSettings::shortCutChanged, this,
             &TabSupervisor::refreshShortcuts);
     refreshShortcuts();
@@ -229,6 +242,8 @@ void TabSupervisor::retranslateUi()
     aTabReplays->setText(tr("Game Replays"));
     aTabAdmin->setText(tr("Administration"));
     aTabLog->setText(tr("Logs"));
+    aTabReport->setText(tr("Report Queue"));
+    aTabModeration->setText(tr("Moderation"));
 
     // tabs
     QList<Tab *> tabs;
@@ -238,6 +253,8 @@ void TabSupervisor::retranslateUi()
     tabs.append(tabAdmin);
     tabs.append(tabAccount);
     tabs.append(tabLog);
+    tabs.append(tabReport);
+    tabs.append(tabModeration);
     QMapIterator<int, TabRoom *> roomIterator(roomTabs);
     while (roomIterator.hasNext()) {
         tabs.append(roomIterator.next().value());
@@ -284,6 +301,8 @@ void TabSupervisor::refreshShortcuts()
     aTabReplays->setShortcuts(shortcuts.getShortcut("Tabs/aTabReplays"));
     aTabAdmin->setShortcuts(shortcuts.getShortcut("Tabs/aTabAdmin"));
     aTabLog->setShortcuts(shortcuts.getShortcut("Tabs/aTabLog"));
+    aTabReport->setShortcuts(shortcuts.getShortcut("Tabs/aTabReport"));
+    aTabModeration->setShortcuts(shortcuts.getShortcut("Tabs/aTabModeration"));
 }
 
 void TabSupervisor::closeEvent(QCloseEvent *event)
@@ -485,6 +504,8 @@ void TabSupervisor::start(const ServerInfo_User &_userInfo)
         tabsMenu->addAction(aTabAdmin);
         tabsMenu->addAction(aTabLog);
         tabsMenu->addAction(aTabCardArtRules);
+        tabsMenu->addAction(aTabReport);
+        tabsMenu->addAction(aTabModeration);
 
         if (SettingsCache::instance().tabs().getTabAdminOpen()) {
             openTabAdmin();
@@ -492,6 +513,12 @@ void TabSupervisor::start(const ServerInfo_User &_userInfo)
         if (SettingsCache::instance().tabs().getTabLogOpen()) {
             openTabLog();
         }
+        if (SettingsCache::instance().tabs().getTabReportOpen()) {
+            openTabReport();
+        }
+        if (SettingsCache::instance().tabs().getTabModerationOpen()) {
+            openTabModeration();
+        }
         openTabCardArtRules();
     }
 
@@ -505,6 +532,8 @@ void TabSupervisor::startLocal(const QList<AbstractClient *> &_clients)
     tabAccount = nullptr;
     tabAdmin = nullptr;
     tabLog = nullptr;
+    tabReport = nullptr;
+    tabModeration = nullptr;
     isLocalGame = true;
     userInfo = new ServerInfo_User;
     localClients = _clients;
@@ -546,6 +575,12 @@ void TabSupervisor::stop()
         if (tabLog) {
             tabLog->close();
         }
+        if (tabReport) {
+            tabReport->close();
+        }
+        if (tabModeration) {
+            tabModeration->close();
+        }
     }
 
     QList<Tab *> tabsToDelete;
@@ -783,6 +818,59 @@ void TabSupervisor::openTabLog()
     aTabLog->setChecked(true);
 }
 
+void TabSupervisor::actTabReport(bool checked)
+{
+    SettingsCache::instance().tabs().setTabReportOpen(checked);
+    if (checked && !tabReport) {
+        openTabReport();
+        setCurrentWidget(tabReport);
+    } else if (!checked && tabReport) {
+        tabReport->closeRequest();
+    }
+}
+
+void TabSupervisor::openTabReport()
+{
+    tabReport = new TabReport(this, client);
+    myAddTab(tabReport, aTabReport);
+    connect(tabReport, &TabReport::openReplay, this, &TabSupervisor::openReplay);
+    connect(tabReport, &TabReport::requestJoinGame, this, &TabSupervisor::joinReportGame);
+    connect(tabReport, &QObject::destroyed, this, [this] {
+        tabReport = nullptr;
+        aTabReport->setChecked(false);
+    });
+    aTabReport->setChecked(true);
+}
+
+void TabSupervisor::actTabModeration(bool checked)
+{
+    SettingsCache::instance().tabs().setTabModerationOpen(checked);
+    if (checked && !tabModeration) {
+        openTabModeration();
+        setCurrentWidget(tabModeration);
+    } else if (!checked && tabModeration) {
+        tabModeration->closeRequest();
+    }
+}
+
+void TabSupervisor::openTabModeration(const QString &userName)
+{
+    if (tabModeration) {
+        setCurrentWidget(tabModeration);
+        if (!userName.isEmpty()) {
+            tabModeration->investigate(userName);
+        }
+        return;
+    }
+    tabModeration = new TabModeration(this, client, userName);
+    myAddTab(tabModeration, aTabModeration);
+    connect(tabModeration, &QObject::destroyed, this, [this] {
+        tabModeration = nullptr;
+        aTabModeration->setChecked(false);
+    });
+    aTabModeration->setChecked(true);
+}
+
 void TabSupervisor::updatePingTime(int value, int max)
 {
     if (!tabServer) {
@@ -900,6 +988,30 @@ void TabSupervisor::replayLeft(TabGame *tab)
     replayTabs.removeOne(tab);
 }
 
+void TabSupervisor::joinReportGame(const int gameId, const int roomId)
+{
+    auto *remoteClient = qobject_cast<RemoteClient *>(client);
+    if (!remoteClient) {
+        actShowPopup(tr("Report joins are only available on a remote server."));
+        return;
+    }
+
+    auto ctx = std::make_unique<ContextJoinGame>();
+    ctx->roomContext.serverContext.hostname = remoteClient->peerName();
+    ctx->roomContext.serverContext.port = QString::number(remoteClient->peerPort());
+    ctx->roomContext.roomId = roomId;
+    ctx->gameId = gameId;
+    ctx->asSpectator = true;
+
+    auto *joinGameIntent = new IntentJoinServerGame(this, remoteClient, std::move(ctx));
+    joinGameIntent->setParent(this);
+    connect(joinGameIntent, &Intent::failed, this, [gameId](const QString &reason) {
+        actShowPopup(tr("Could not join game %1.\n%2").arg(gameId).arg(reason));
+    });
+
+    joinGameIntent->execute();
+}
+
 TabMessage *TabSupervisor::addMessageTab(const QString &receiverName, bool focus)
 {
     if (receiverName == QString::fromStdString(userInfo->name())) {
@@ -1284,6 +1396,24 @@ void TabSupervisor::processNotifyUserEvent(const Event_NotifyUser &event)
             }
             break;
         }
+        case Event_NotifyUser::REPORT_RESOLVED: {
+            QString title = QString::fromStdString(event.custom_title()).simplified();
+            QString content = QString::fromStdString(event.custom_content()).trimmed();
+            if (!title.isEmpty() && !content.isEmpty()) {
+                actShowPopup(title + "\n" + content);
+                QApplication::alert(this);
+            }
+            break;
+        }
+        case Event_NotifyUser::REPORT_COMMENT: {
+            QString title = QString::fromStdString(event.custom_title()).simplified();
+            QString content = QString::fromStdString(event.custom_content()).trimmed();
+            if (!title.isEmpty() && !content.isEmpty()) {
+                actShowPopup(title + "\n" + content);
+                QApplication::alert(this);
+            }
+            break;
+        }
         default:;
     }
 }

cockatrice/src/interface/widgets/tabs/tab_supervisor.h

@@ -40,6 +40,8 @@ class TabDeckStorage;
 class TabReplays;
 class TabAdmin;
 class TabMessage;
+class TabReport;
+class TabModeration;
 class TabAccount;
 class TabDeckEditor;
 class TabLog;
@@ -103,6 +105,8 @@ private:
     TabAdmin *tabAdmin;
     TabCardArtRules *tabCardArtRules;
     TabLog *tabLog;
+    TabReport *tabReport;
+    TabModeration *tabModeration;
     QMap<int, TabRoom *> roomTabs;
     QMap<int, TabGame *> gameTabs;
     QList<TabGame *> replayTabs;
@@ -112,7 +116,7 @@ private:
 
     QAction *aTabHome, *aTabDeckEditor, *aTabVisualDeckEditor, *aTabEdhRec, *aTabArchidekt, *aTabVisualDeckStorage,
         *aTabVisualDatabaseDisplay, *aTabServer, *aTabAccount, *aTabDeckStorage, *aTabReplays, *aTabAdmin,
-        *aTabCardArtRules, *aTabLog;
+        *aTabCardArtRules, *aTabLog, *aTabReport, *aTabModeration;
 
     int myAddTab(Tab *tab, QAction *manager = nullptr);
     void addCloseButtonToTab(Tab *tab, int tabIndex, QAction *manager);
@@ -183,6 +187,8 @@ public slots:
     TabArchidekt *addArchidektTab();
     TabEdhRec *addEdhrecTab(const CardInfoPtr &cardToQuery, bool isCommander = false);
     void openReplay(GameReplay *replay);
+    void joinReportGame(int gameId, int roomId);
+    void openTabModeration(const QString &userName = {});
     void switchToFirstAvailableNetworkTab();
     void maximizeMainWindow();
     void actTabVisualDeckStorage(bool checked);
@@ -198,6 +204,8 @@ private slots:
     void actTabDeckStorage(bool checked);
     void actTabAdmin(bool checked);
     void actTabLog(bool checked);
+    void actTabReport(bool checked);
+    void actTabModeration(bool checked);
 
     void openTabVisualDeckStorage();
     void openTabHome();
@@ -208,6 +216,7 @@ private slots:
     void actTabCardArtRules(bool checked);
     void openTabCardArtRules();
     void openTabLog();
+    void openTabReport();
 
     void updateCurrent(int index);
     void updatePingTime(int value, int max);

cockatrice/src/interface/widgets/utility/report_utils.cpp

@@ -0,0 +1,119 @@
+#include "report_utils.h"
+
+#include <QApplication>
+#include <QBrush>
+#include <QDateTime>
+#include <QPalette>
+#include <QTableWidget>
+#include <QTextCursor>
+#include <QTextEdit>
+
+namespace report_utils
+{
+
+namespace
+{
+QColor reportStatusColor(const QString &status)
+{
+    const QColor text = qApp->palette().color(QPalette::Text);
+    const int luminance = (299 * text.red() + 587 * text.green() + 114 * text.blue()) / 1000;
+    const bool dark = luminance < 128;
+
+    if (status == "open") {
+        return dark ? QColor("#e06060") : QColor("#c0392b");
+    }
+    if (status == "assigned") {
+        return dark ? QColor("#e0a030") : QColor("#d68910");
+    }
+    if (status == "resolved") {
+        return dark ? QColor("#50c878") : QColor("#1e8449");
+    }
+    if (status == "dismissed") {
+        return qApp->palette().color(QPalette::PlaceholderText);
+    }
+    return QColor();
+}
+
+void setReportStatusItemColor(QTableWidgetItem *item, const QString &status)
+{
+    const QColor color = reportStatusColor(status);
+    if (color.isValid()) {
+        item->setForeground(QBrush(color));
+    }
+}
+} // namespace
+
+QString formatReportCategory(const QString &category)
+{
+    QString result = category;
+    result.replace('_', ' ');
+    return result.left(1).toUpper() + result.mid(1);
+}
+
+QString formatReportTime(qint64 secondsSinceEpoch)
+{
+    const QDateTime dt = QDateTime::fromSecsSinceEpoch(secondsSinceEpoch);
+    return dt.toString("yyyy-MM-dd hh:mm");
+}
+
+void fillReportTableRow(QTableWidget *table,
+                        int row,
+                        const ServerInfo_Report &report,
+                        int idColumn,
+                        int timeColumn,
+                        int reportedColumn,
+                        int categoryColumn,
+                        int gameIdColumn,
+                        int statusColumn,
+                        int assignedColumn)
+{
+    auto *idItem = new QTableWidgetItem(QString::number(report.report_id()));
+    idItem->setData(Qt::UserRole, report.report_id());
+    table->setItem(row, idColumn, idItem);
+
+    table->setItem(row, timeColumn, new QTableWidgetItem(formatReportTime(report.report_time())));
+    table->setItem(row, reportedColumn, new QTableWidgetItem(QString::fromStdString(report.reported_user_name())));
+    table->setItem(row, categoryColumn,
+                   new QTableWidgetItem(formatReportCategory(QString::fromStdString(report.category()))));
+    table->setItem(row, gameIdColumn,
+                   new QTableWidgetItem(report.game_id() > 0 ? QString::number(report.game_id()) : QString()));
+
+    auto *statusItem = new QTableWidgetItem(QString::fromStdString(report.status()));
+    setReportStatusItemColor(statusItem, QString::fromStdString(report.status()));
+    table->setItem(row, statusColumn, statusItem);
+
+    table->setItem(row, assignedColumn, new QTableWidgetItem(QString::fromStdString(report.assigned_mod_name())));
+}
+
+void renderReportDetails(QTextEdit *chatLogEdit,
+                         QTextEdit *commentsEdit,
+                         const ServerInfo_Report &report,
+                         const QString &commentsEmptyText,
+                         const QString &moderatorPrefix,
+                         const QString &nonModeratorPrefix)
+{
+    if (report.has_chat_log() && !report.chat_log().empty()) {
+        chatLogEdit->setPlainText(QString::fromStdString(report.chat_log()));
+    } else {
+        chatLogEdit->clear();
+    }
+
+    commentsEdit->clear();
+
+    if (report.comments_size() == 0) {
+        commentsEdit->setPlainText(commentsEmptyText);
+        return;
+    }
+
+    for (int i = 0; i < report.comments_size(); ++i) {
+        const ServerInfo_ReportComment &c = report.comments(i);
+        const QString author = QString::fromStdString(c.author_name());
+        const QString text = QString::fromStdString(c.comment_text());
+        const QString prefix = c.is_moderator() ? moderatorPrefix : nonModeratorPrefix;
+        commentsEdit->moveCursor(QTextCursor::End);
+        commentsEdit->insertPlainText(
+            QString("[%1] %2 %3:\n%4\n\n").arg(formatReportTime(c.comment_time()), prefix, author, text));
+    }
+}
+
+} // namespace report_utils

cockatrice/src/interface/widgets/utility/report_utils.h

@@ -0,0 +1,36 @@
+#ifndef REPORT_UTILS_H
+#define REPORT_UTILS_H
+
+#include <QString>
+#include <libcockatrice/protocol/pb/serverinfo_report.pb.h>
+
+class QTableWidget;
+class QTextEdit;
+
+namespace report_utils
+{
+
+QString formatReportCategory(const QString &category);
+QString formatReportTime(qint64 secondsSinceEpoch);
+
+void fillReportTableRow(QTableWidget *table,
+                        int row,
+                        const ServerInfo_Report &report,
+                        int idColumn,
+                        int timeColumn,
+                        int reportedColumn,
+                        int categoryColumn,
+                        int gameIdColumn,
+                        int statusColumn,
+                        int assignedColumn);
+
+void renderReportDetails(QTextEdit *chatLogEdit,
+                         QTextEdit *commentsEdit,
+                         const ServerInfo_Report &report,
+                         const QString &commentsEmptyText,
+                         const QString &moderatorPrefix,
+                         const QString &nonModeratorPrefix);
+
+} // namespace report_utils
+
+#endif // REPORT_UTILS_H