Jungfraujoch/viewer/windows/JFJochMergeStatsWindow.cpp

// SPDX-FileCopyrightText: 2026 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
// SPDX-License-Identifier: GPL-3.0-only

#include "JFJochMergeStatsWindow.h"
#include "../ViewerTheme.h"

#include <cmath>
#include <limits>

#include <QButtonGroup>
#include <QComboBox>
#include <QFontDatabase>
#include <QFrame>
#include <QGridLayout>
#include <QHBoxLayout>
#include <QPainter>
#include <QPlainTextEdit>
#include <QHeaderView>
#include <QLabel>
#include <QStackedWidget>
#include <QStringList>
#include <QTableWidget>
#include <QToolButton>
#include <QVBoxLayout>
#include <QtCharts/QChart>
#include <QtCharts/QChartView>
#include <QtCharts/QLineSeries>
#include <QtCharts/QLogValueAxis>
#include <QtCharts/QScatterSeries>
#include <QtCharts/QValueAxis>

#include "../charts/JFJochSimpleChartView.h"
#include "../widgets/ToolbarIcons.h"

namespace {
    // Per-shell metric value (NaN -> dropped by the chart). Keep in sync with the combo entries.
    double ShellMetric(const MergeStatisticsShell &s, int metric) {
        switch (metric) {
            case 0: return s.cc_half * 100.0;                                        // CC1/2 (%)
            case 1: return s.r_meas * 100.0;                                         // R-meas (%)
            case 2: return s.mean_i_over_sigma;                                      // <I/sigma>
            case 3: return s.possible_unique_reflections > 0                          // Completeness (%)
                           ? 100.0 * s.unique_reflections / s.possible_unique_reflections : NAN;
            case 4: return s.unique_reflections > 0                                   // Multiplicity
                           ? static_cast<double>(s.total_observations) / s.unique_reflections : NAN;
            case 5: return s.cc_ref * 100.0;                                         // CCref (%)
            default: return NAN;
        }
    }

    // A big-number "card" for the hero row: large navy value over a small grey caption.
    QWidget *MakeCard(const QString &value, const QString &caption, QWidget *parent) {
        auto *card = new QFrame(parent);
        card->setFrameShape(QFrame::StyledPanel);
        auto *l = new QVBoxLayout(card);
        l->setContentsMargins(12, 8, 12, 8);
        l->setSpacing(0);
        auto *v = new QLabel(value, card);
        v->setTextFormat(Qt::RichText);   // the space group carries <sub>
        QFont f = v->font();
        f.setPointSizeF(f.pointSizeF() * 2.2);
        f.setBold(true);
        v->setFont(f);
        SetThemedStyleSheet(v, [] { return "color: " + AccentTextColor().name() + ";"; });
        v->setAlignment(Qt::AlignCenter);
        auto *c = new QLabel(caption, card);
        c->setStyleSheet("color: gray;");
        c->setAlignment(Qt::AlignCenter);
        l->addWidget(v);
        l->addWidget(c);
        return card;
    }

    // The short Hermann-Mauguin symbol as rich text, screw axes subscripted and rotoinversions
    // overlined: "P 1 21 1" -> P2<sub>1</sub>, "P 41 21 2" -> P4<sub>1</sub>2<sub>1</sub>2. Built from
    // the spaced symbol, where short_name()'s run-together digits are ambiguous (P622 vs P6_2 2).
    QString SpaceGroupHtml(const gemmi::SpaceGroup &sg) {
        std::string hm = sg.hm;
        // the monoclinic shortening of short_name(): "P 1 21 1" -> "P 21"
        if (hm.size() > 6 && hm[2] == '1' && hm[hm.size() - 2] == ' ' && hm.back() == '1')
            hm = hm[0] + hm.substr(3, hm.size() - 3 - 2);
        if (sg.ext == 'H')
            hm[0] = 'H';
        QString out;
        for (const auto &token : QString::fromStdString(hm).split(' ', Qt::SkipEmptyParts)) {
            if (token.size() >= 2 && token[0] == '-')
                out += "<span style=\"text-decoration: overline\">" + token.mid(1, 1) + "</span>" + token.mid(2);
            else if (token.size() >= 2 && token[0].isDigit() && token[1].isDigit())
                out += token.left(1) + "<sub>" + token.mid(1, 1) + "</sub>" + token.mid(2);
            else
                out += token;
        }
        return out;
    }

    // Status light of a pathology check: green tick absent, red cross present, grey dash undetermined.
    QPixmap CheckIcon(ReportCheck::Status status, int size, qreal dpr) {
        QPixmap pm(QSize(size, size) * dpr);
        pm.setDevicePixelRatio(dpr);
        pm.fill(Qt::transparent);
        QPainter p(&pm);
        p.setRenderHint(QPainter::Antialiasing);
        const QColor fill = status == ReportCheck::Status::Present ? QColor(200, 40, 40)
                          : status == ReportCheck::Status::Absent ? QColor(40, 150, 70)
                          : QColor(150, 150, 150);
        p.setPen(Qt::NoPen);
        p.setBrush(fill);
        p.drawEllipse(QRectF(0.5, 0.5, size - 1.0, size - 1.0));
        p.setPen(QPen(Qt::white, size / 8.0, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin));
        const double u = size / 16.0;
        if (status == ReportCheck::Status::Absent)
            p.drawPolyline(QPolygonF({QPointF(4.5 * u, 8.5 * u), QPointF(7 * u, 11 * u), QPointF(11.5 * u, 5.5 * u)}));
        else if (status == ReportCheck::Status::Present) {
            p.drawLine(QPointF(5 * u, 5 * u), QPointF(11 * u, 11 * u));
            p.drawLine(QPointF(11 * u, 5 * u), QPointF(5 * u, 11 * u));
        } else
            p.drawLine(QPointF(4.5 * u, 8 * u), QPointF(11.5 * u, 8 * u));
        return pm;
    }
}

JFJochMergeStatsWindow::JFJochMergeStatsWindow(const QString &title, const MergeStatistics &stats,
                                               double isa, bool has_reference,
                                               const TwinningAnalysisResult &twinning,
                                               const std::optional<gemmi::SpaceGroup> &space_group,
                                               const std::optional<SearchSpaceGroupResult> &space_group_search,
                                               const std::vector<std::pair<float, float>> &merged_i_sigma,
                                               const QString &report,
                                               const std::vector<ReportCheck> &checks,
                                               QWidget *parent)
    : QWidget(parent, Qt::Window), stats_(stats), has_reference_(has_reference) {
    setWindowTitle("Merge statistics — " + title);
    setAttribute(Qt::WA_DeleteOnClose);
    resize(740, 560);

    auto *layout = new QVBoxLayout(this);

    // --- Hero row: overall numbers ---
    const auto &o = stats_.overall;
    const double completeness = o.possible_unique_reflections > 0
        ? 100.0 * o.unique_reflections / o.possible_unique_reflections : NAN;
    const double multiplicity = o.unique_reflections > 0
        ? static_cast<double>(o.total_observations) / o.unique_reflections : NAN;
    auto pct = [](double v) { return std::isfinite(v) ? QString::number(v, 'f', 1) + "%" : QStringLiteral("—"); };
    auto num = [](double v, int d) { return std::isfinite(v) ? QString::number(v, 'f', d) : QStringLiteral("—"); };

    auto *hero = new QHBoxLayout();
    // High-resolution limit of the merge (d_min). When no scaling resolution limit is given it is set
    // by the CC1/2 logistic cutoff, so it varies per run - show it first.
    if (o.d_min < o.d_max)
        hero->addWidget(MakeCard(QString::asprintf("%.2f", o.d_min), "Resolution [Å]", this));
    hero->addWidget(MakeCard(num(isa, 1), "ISa", this));
    hero->addWidget(MakeCard(pct(o.cc_half * 100.0), "CC½", this));
    hero->addWidget(MakeCard(pct(o.r_meas * 100.0), "R-meas", this));
    hero->addWidget(MakeCard(pct(completeness), "Completeness", this));
    hero->addWidget(MakeCard(num(multiplicity, 1), "Multiplicity", this));
    // Wilson B describes how fast the intensities fall off with resolution; the radiation-damage
    // Delta-B is how much MORE they fall off by the end of the run than at the start (rotation only).
    if (std::isfinite(stats_.wilson_b))
        hero->addWidget(MakeCard(num(stats_.wilson_b, 1), "Wilson B [Ų]", this));
    if (std::isfinite(stats_.radiation_damage_delta_b)) {
        const double db = stats_.radiation_damage_delta_b;
        hero->addWidget(MakeCard((db > 0 ? "+" : "") + num(db, 1), "ΔB, damage [Ų]", this));
    }
    if (has_reference_)
        hero->addWidget(MakeCard(pct(o.cc_ref * 100.0), "CCref", this));
    if (space_group.has_value())
        hero->addWidget(MakeCard(SpaceGroupHtml(*space_group), "Space group", this));
    layout->addLayout(hero);

    // --- Pathology checklist, as phenix.xtriage lists its tests: one status light per pathology the
    // report's summary looks for, its words and the warnings it raised in the tooltip.
    if (!checks.empty()) {
        auto *grid = new QGridLayout();
        grid->setHorizontalSpacing(16);
        grid->setVerticalSpacing(2);
        constexpr int columns = 4;
        for (int i = 0; i < static_cast<int>(checks.size()); ++i) {
            const auto &c = checks[i];
            auto *item = new QWidget(this);
            auto *l = new QHBoxLayout(item);
            l->setContentsMargins(0, 0, 0, 0);
            l->setSpacing(6);
            auto *icon = new QLabel(item);
            icon->setPixmap(CheckIcon(c.status, 14, devicePixelRatioF()));
            auto *label = new QLabel(QString::fromStdString(c.label), item);
            if (c.status == ReportCheck::Status::Present) {
                QFont f = label->font();
                f.setBold(true);
                label->setFont(f);
            } else if (c.status == ReportCheck::Status::Undetermined) {
                label->setStyleSheet("color: gray;");
            }
            l->addWidget(icon);
            l->addWidget(label);
            l->addStretch();
            QString tip = "<b>" + QString::fromStdString(c.label).toHtmlEscaped() + "</b>: "
                          + QString::fromStdString(c.text).toHtmlEscaped();
            if (!c.detail.empty() && c.detail != c.text)
                tip += "<br><br>" + QString::fromStdString(c.detail).toHtmlEscaped().replace('\n', "<br><br>");
            item->setToolTip("<qt>" + tip + "</qt>");
            grid->addWidget(item, i / columns, i % columns);
        }
        layout->addLayout(grid);
    }

    // De-novo space-group search: the point group + the ranked candidates it scored (only present when
    // the space group was not fixed by the user). A summary line above a compact table.
    if (space_group_search.has_value() && !space_group_search->candidates.empty()) {
        const auto &sgs = *space_group_search;
        QString summary = "Point group " + QString::fromStdString(sgs.point_group_hm.empty() ? "?" : sgs.point_group_hm);
        if (!sgs.alternatives.empty()) {
            QStringList alts;
            for (const auto &alt : sgs.alternatives)
                alts << SpaceGroupHtml(alt);
            summary += "  ·  indistinguishable from these data: " + alts.join(", ");
        }
        auto *sgLabel = new QLabel(summary, this);
        sgLabel->setTextFormat(Qt::RichText);
        sgLabel->setStyleSheet("color: gray;");
        layout->addWidget(sgLabel);

        auto *sgTable = new QTableWidget(this);
        sgTable->setEditTriggers(QAbstractItemView::NoEditTriggers);
        sgTable->verticalHeader()->setVisible(false);
        const QStringList sgHeaders{"Space group", "Absent", "Viol.", "⟨I/σ⟩ abs", "⟨I/σ⟩ pres", "Consistent"};
        sgTable->setColumnCount(sgHeaders.size());
        sgTable->setHorizontalHeaderLabels(sgHeaders);
        sgTable->setRowCount(static_cast<int>(sgs.candidates.size()));
        for (int i = 0; i < static_cast<int>(sgs.candidates.size()); ++i) {
            const auto &c = sgs.candidates[i];
            int col = 0;
            auto set = [&](const QString &t, bool leftAlign = false) {
                auto *it = new QTableWidgetItem(t);
                it->setTextAlignment((leftAlign ? Qt::AlignLeft : Qt::AlignRight) | Qt::AlignVCenter);
                if (c.selected) { QFont f = it->font(); f.setBold(true); it->setFont(f); }
                sgTable->setItem(i, col++, it);
            };
            set(QString::fromStdString(c.space_group.short_name()) + (c.selected ? " *" : ""), true);
            set(QString::number(c.absent_observed));
            set(QString::number(c.absent_violations));
            set(QString::number(c.absent_mean_i_over_sigma, 'f', 2));
            set(QString::number(c.present_mean_i_over_sigma, 'f', 2));
            set(c.consistent ? QStringLiteral("yes") : QStringLiteral("no"));
        }
        sgTable->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
        sgTable->setMaximumHeight(160);   // a secondary detail — keep the shells plot the focus
        layout->addWidget(sgTable);
    }

    // --- Twinning test (Padilla-Yeates L-test + second moment) ---
    // A red-outlined banner flags suspected twinning; otherwise a quiet grey "all clear".
    if (twinning.l_test_pairs > 0) {
        QString text = QString("Twinning:  ⟨|L|⟩ = %1   ⟨I²⟩/⟨I⟩² = %2")
                           .arg(twinning.mean_abs_l, 0, 'f', 3)
                           .arg(twinning.second_moment, 0, 'f', 2);
        text += "   —  " + QString::fromStdString(TwinningVerdictLine(twinning));

        auto *banner = new QLabel(text, this);
        banner->setContentsMargins(10, 6, 10, 6);
        if (twinning.twinning_suspected)
            SetThemedStyleSheet(banner, [] {
                return QString("color: %1; border: 1px solid red; border-radius: 4px;")
                    .arg(DarkTheme() ? "#FF7B72" : "rgb(160,0,0)");
            });
        else
            banner->setStyleSheet("color: gray;");
        layout->addWidget(banner);
    }

    // --- Controls: plot/table view toggle (icon buttons) + per-resolution metric selector ---
    auto *row = new QHBoxLayout();
    auto *plotBtn = new QToolButton(this);
    plotBtn->setIcon(ToolbarIcons::linePlot());
    plotBtn->setCheckable(true);
    plotBtn->setChecked(true);
    plotBtn->setToolTip("Per-resolution plot");
    SetThemedStyleSheet(plotBtn, ToolbarIcons::buttonStyle);
    auto *tableBtn = new QToolButton(this);
    tableBtn->setIcon(ToolbarIcons::table());
    tableBtn->setCheckable(true);
    tableBtn->setToolTip("Per-shell table");
    SetThemedStyleSheet(tableBtn, ToolbarIcons::buttonStyle);
    auto *isaBtn = new QToolButton(this);
    isaBtn->setIcon(ToolbarIcons::linePlot());
    isaBtn->setCheckable(true);
    isaBtn->setToolTip("ISa diagnostic: merged I/σ against I");
    SetThemedStyleSheet(isaBtn, ToolbarIcons::buttonStyle);
    auto *reportBtn = new QToolButton(this);
    reportBtn->setText("Report");
    reportBtn->setCheckable(true);
    reportBtn->setToolTip("The rugnux result report, as written to <prefix>_report.txt");
    SetThemedStyleSheet(reportBtn, ToolbarIcons::buttonStyle);
    auto *viewGroup = new QButtonGroup(this);
    viewGroup->setExclusive(true);
    viewGroup->addButton(plotBtn, 0);
    viewGroup->addButton(tableBtn, 1);
    viewGroup->addButton(isaBtn, 2);
    viewGroup->addButton(reportBtn, 3);
    row->addWidget(plotBtn);
    row->addWidget(tableBtn);
    row->addWidget(isaBtn);
    row->addWidget(reportBtn);
    row->addSpacing(12);
    metricLabel_ = new QLabel("Metric:", this);
    row->addWidget(metricLabel_);
    metric_ = new QComboBox(this);
    metric_->addItem("CC½ (%)", 0);
    metric_->addItem("R-meas (%)", 1);
    metric_->addItem("⟨I/σ⟩", 2);
    metric_->addItem("Completeness (%)", 3);
    metric_->addItem("Multiplicity", 4);
    if (has_reference_)
        metric_->addItem("CCref (%)", 5);
    row->addWidget(metric_);
    row->addStretch();
    layout->addLayout(row);

    // --- Stacked plot / table ---
    stack_ = new QStackedWidget(this);
    chart_ = new JFJochSimpleChartView(this);
    table_ = new QTableWidget(this);
    table_->setEditTriggers(QAbstractItemView::NoEditTriggers);
    table_->verticalHeader()->setVisible(false);
    stack_->addWidget(chart_);   // page 0
    stack_->addWidget(table_);   // page 1
    isa_page_ = buildIsaDiagnostic(merged_i_sigma, isa);
    if (isa_page_)
        stack_->addWidget(isa_page_);   // page 2
    else
        isaBtn->setEnabled(false);
    // The report is prose and fixed-width tables meant to be read as written - a plain text view
    // in a fixed-width font, never wrapped.
    if (!report.isEmpty()) {
        auto *report_view = new QPlainTextEdit(this);
        report_view->setReadOnly(true);
        report_view->setLineWrapMode(QPlainTextEdit::NoWrap);
        report_view->setFont(QFontDatabase::systemFont(QFontDatabase::FixedFont));
        report_view->setPlainText(report);
        report_page_ = report_view;
        stack_->addWidget(report_page_);
    } else {
        reportBtn->setEnabled(false);
    }
    layout->addWidget(stack_, 1);

    connect(metric_, &QComboBox::currentIndexChanged, this, [this](int) { updatePlot(); });
    // Button ids map to page widgets, not stack indices: an absent page (no ISa scatter, no
    // report) would otherwise shift every page behind it.
    connect(viewGroup, &QButtonGroup::idClicked, this, [this](int idx) {
        QWidget *const pages[] = {chart_, table_, isa_page_, report_page_};
        if (idx >= 0 && idx < 4 && pages[idx])
            stack_->setCurrentWidget(pages[idx]);
        metric_->setVisible(idx == 0);        // the metric selector + its label only apply to the plot
        metricLabel_->setVisible(idx == 0);
    });

    buildTable();
    updatePlot();
}

// Merged I/sigma against I. The error model says sigma -> b*I for strong reflections, so I/sigma
// flattens off at 1/b = ISa: the plot shows whether the reported number is where the data actually
// level out. Log intensity axis, because the reflections span several decades and the asymptote lives
// at the strong end.
QWidget *JFJochMergeStatsWindow::buildIsaDiagnostic(const std::vector<std::pair<float, float>> &i_sigma,
                                                    double isa) {
    auto *points = new QScatterSeries();
    points->setName("merged reflections");
    points->setMarkerSize(4.0);
    points->setBorderColor(Qt::transparent);
    QColor point_color = AccentTextColor();
    point_color.setAlpha(0x60);
    points->setColor(point_color);

    double i_lo = std::numeric_limits<double>::max(), i_hi = 0.0, r_hi = 0.0;
    for (const auto &[I, sigma] : i_sigma) {
        if (!(I > 0.0f) || !(sigma > 0.0f))
            continue;   // the log axis cannot show a non-positive intensity
        const double ratio = I / sigma;
        points->append(I, ratio);
        i_lo = std::min(i_lo, static_cast<double>(I));
        i_hi = std::max(i_hi, static_cast<double>(I));
        r_hi = std::max(r_hi, ratio);
    }
    if (points->count() < 2 || !(i_hi > i_lo)) {
        delete points;
        return nullptr;
    }

    auto *chart = new QChart();
    StyleChart(chart);
    chart->legend()->setVisible(false);
    chart->addSeries(points);

    auto *ax = new QLogValueAxis();
    ax->setBase(10.0);
    ax->setTitleText("merged I");
    ax->setRange(i_lo, i_hi);
    auto *ay = new QValueAxis();
    ay->setTitleText("merged I/σ");
    ay->setRange(0.0, std::max(r_hi, std::isfinite(isa) ? isa * 1.2 : 0.0) * 1.05);
    chart->addAxis(ax, Qt::AlignBottom);
    chart->addAxis(ay, Qt::AlignLeft);
    StyleChartAxes(chart);
    points->attachAxis(ax);
    points->attachAxis(ay);

    if (std::isfinite(isa) && isa > 0.0) {
        auto *line = new QLineSeries();
        line->append(i_lo, isa);
        line->append(i_hi, isa);
        QPen pen(AlertTextColor());
        pen.setStyle(Qt::DashLine);
        pen.setWidth(2);
        line->setPen(pen);
        chart->addSeries(line);
        line->attachAxis(ax);
        line->attachAxis(ay);
    }

    auto *view = new QChartView(chart, this);
    view->setRenderHint(QPainter::Antialiasing);
    view->setToolTip(std::isfinite(isa) && isa > 0.0
                     ? QString("Dashed line: reported ISa = %1. The strong reflections should level "
                               "off there.").arg(isa, 0, 'f', 1)
                     : QString("No ISa was determined for this merge."));
    return view;
}

void JFJochMergeStatsWindow::updatePlot() {
    const int metric = metric_->currentData().toInt();
    std::vector<float> x, y;
    double dmax = 0.0;
    x.reserve(stats_.shells.size());
    y.reserve(stats_.shells.size());
    for (const auto &s: stats_.shells) {
        x.push_back(s.mean_one_over_d2);
        const double v = ShellMetric(s, metric);
        y.push_back(static_cast<float>(v));
        if (std::isfinite(v))
            dmax = std::max(dmax, v);
    }
    // Absolute y-axis so positions are comparable: CC1/2 + CCref are 0..100, completeness 0..(>=100),
    // multiplicity / R-meas / I-sigma start at 0. It has to be given to UpdateData rather than set
    // on the axis afterwards, or the tick labels still describe the range of the data.
    double ymax = 1.0;
    switch (metric) {
        case 0: case 5: ymax = 100.0; break;                              // CC1/2, CCref
        case 3: ymax = std::max(100.0, dmax * 1.05); break;               // Completeness
        default: ymax = dmax > 0.0 ? dmax * 1.05 : 1.0; break;            // R-meas, I/sigma, multiplicity
    }
    chart_->UpdateData(x, y, "Resolution [Å]", metric_->currentText(), true,
                       std::make_pair(0.0, ymax));
}

void JFJochMergeStatsWindow::buildTable() {
    QStringList headers{"Res. [Å]", "N_obs", "Unique", "Compl. %", "Mult.", "⟨I/σ⟩", "R-meas %", "CC½ %"};
    if (has_reference_)
        headers << "CCref %";
    table_->setColumnCount(headers.size());
    table_->setHorizontalHeaderLabels(headers);
    table_->setRowCount(static_cast<int>(stats_.shells.size()) + 1);   // shells + overall

    auto fillRow = [&](int rowIdx, const MergeStatisticsShell &s, const QString &resLabel) {
        int c = 0;
        auto set = [&](const QString &t) {
            auto *it = new QTableWidgetItem(t);
            it->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);   // numbers right-aligned
            table_->setItem(rowIdx, c++, it);
        };
        const double compl_ = s.possible_unique_reflections > 0
            ? 100.0 * s.unique_reflections / s.possible_unique_reflections : NAN;
        const double mult = s.unique_reflections > 0
            ? static_cast<double>(s.total_observations) / s.unique_reflections : NAN;
        set(resLabel);
        set(QString::number(s.total_observations));
        set(QString::number(s.unique_reflections));
        set(std::isfinite(compl_) ? QString::number(compl_, 'f', 1) : QStringLiteral("—"));
        set(std::isfinite(mult) ? QString::number(mult, 'f', 1) : QStringLiteral("—"));
        set(QString::number(s.mean_i_over_sigma, 'f', 1));
        set(QString::number(s.r_meas * 100.0, 'f', 1));
        set(QString::number(s.cc_half * 100.0, 'f', 1));
        if (has_reference_)
            set(QString::number(s.cc_ref * 100.0, 'f', 1));
    };

    int rowIdx = 0;
    for (const auto &s: stats_.shells)
        fillRow(rowIdx++, s, QString::number(s.d_min, 'f', 2));
    fillRow(rowIdx, stats_.overall, QStringLiteral("Overall"));

    // Equal-width columns that fill the table (no super-wide last column).
    table_->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
}