Skip to content

FinceptTerminal is a modern finance application offering advanced market analytics, investment research, and economic data tools, designed for interactive exploration and data-driven decision-making in a user-friendly environment.

40.6 KB
Raw Blame
// src/screens/quantlib/QuantLibResultView.cpp
//
// Results pane of the QuantLib screen — see the header. Styling comes from the
// QuantLib screen's root stylesheet (#ql* selectors); the chart is themed
// through the QtCharts API. Nothing here calls setStyleSheet.

#include "screens/quantlib/QuantLibResultView.h"

#include "core/logging/Logger.h"
#include "ui/tables/NumericTableWidgetItem.h"
#include "ui/theme/Theme.h"

#include <QApplication>
#include <QButtonGroup>
#include <QChart>
#include <QChartView>
#include <QClipboard>
#include <QComboBox>
#include <QDateTime>
#include <QFile>
#include <QFileDialog>
#include <QHBoxLayout>
#include <QHash>
#include <QHeaderView>
#include <QJsonArray>
#include <QJsonDocument>
#include <QKeySequence>
#include <QLabel>
#include <QLegend>
#include <QLineSeries>
#include <QPlainTextEdit>
#include <QPushButton>
#include <QShortcut>
#include <QSignalBlocker>
#include <QStackedWidget>
#include <QStyle>
#include <QTableWidget>
#include <QTextStream>
#include <QValueAxis>
#include <QVBoxLayout>

#include <algorithm>
#include <cmath>
#include <limits>

namespace fincept::screens {

using namespace fincept::ui;

namespace {

constexpr int kQlTableRowCap = 5000;      // rows rendered in the widget (CSV/COPY export all)
constexpr int kQlChartPointCap = 4000;    // points per plotted series (stride-downsampled above)
constexpr int kQlChartSeriesCap = 25;     // series per chart
constexpr int kQlJsonCharCap = 2'000'000; // raw JSON view

QString ql_rv_number(double v) {
    if (!std::isfinite(v))
        return QString::number(v);
    if (std::floor(v) == v && std::fabs(v) < 1e15)
        return QString::number(static_cast<qlonglong>(v));
    return QString::number(v, 'g', 10);
}

QString ql_rv_number_full(double v) {
    if (std::floor(v) == v && std::fabs(v) < 1e15)
        return QString::number(static_cast<qlonglong>(v));
    return QString::number(v, 'g', 15);
}

QString ql_rv_compact(const QJsonValue& v) {
    if (v.isArray())
        return QString::fromUtf8(QJsonDocument(v.toArray()).toJson(QJsonDocument::Compact));
    if (v.isObject())
        return QString::fromUtf8(QJsonDocument(v.toObject()).toJson(QJsonDocument::Compact));
    return {};
}

// Cell text for display (`full` = export precision).
QString ql_rv_cell(const QJsonValue& v, bool full) {
    if (v.isDouble())
        return full ? ql_rv_number_full(v.toDouble()) : ql_rv_number(v.toDouble());
    if (v.isBool())
        return v.toBool() ? QStringLiteral("true") : QStringLiteral("false");
    if (v.isNull() || v.isUndefined())
        return full ? QString() : QStringLiteral("--");
    if (v.isString())
        return v.toString();
    return ql_rv_compact(v);
}

QString ql_rv_csv_escape(QString s) {
    if (s.contains(QLatin1Char(',')) || s.contains(QLatin1Char('"')) || s.contains(QLatin1Char('\n'))) {
        s.replace(QLatin1Char('"'), QStringLiteral("\"\""));
        s = QLatin1Char('"') + s + QLatin1Char('"');
    }
    return s;
}

bool ql_rv_numeric_array(const QJsonValue& v, QList<double>* out) {
    if (!v.isArray())
        return false;
    const QJsonArray a = v.toArray();
    if (a.size() < 2)
        return false;
    out->clear();
    out->reserve(a.size());
    for (const auto& e : a) {
        if (!e.isDouble())
            return false;
        out->append(e.toDouble());
    }
    return true;
}

bool ql_rv_numeric_matrix(const QJsonValue& v, QList<QList<double>>* rows) {
    if (!v.isArray())
        return false;
    const QJsonArray a = v.toArray();
    if (a.isEmpty())
        return false;
    rows->clear();
    for (const auto& r : a) {
        if (!r.isArray())
            return false;
        QList<double> row;
        for (const auto& e : r.toArray()) {
            if (!e.isDouble())
                return false;
            row.append(e.toDouble());
        }
        rows->append(row);
    }
    return true;
}

// Column keys of an array of objects, in first-appearance order.
QStringList ql_rv_object_columns(const QJsonArray& arr) {
    QStringList cols;
    const int scan = std::min<int>(arr.size(), 500);
    for (int i = 0; i < scan; ++i) {
        const QJsonObject o = arr.at(i).toObject();
        for (auto it = o.begin(); it != o.end(); ++it) {
            if (!cols.contains(it.key()))
                cols << it.key();
        }
    }
    return cols;
}

QList<QPointF> ql_rv_downsample(const QList<QPointF>& pts, bool* downsampled) {
    if (pts.size() <= kQlChartPointCap)
        return pts;
    *downsampled = true;
    QList<QPointF> out;
    const double stride = double(pts.size()) / kQlChartPointCap;
    out.reserve(kQlChartPointCap + 1);
    for (int i = 0; i < kQlChartPointCap; ++i)
        out.append(pts.at(int(i * stride)));
    out.append(pts.last());
    return out;
}

} // namespace

// ── Construction ─────────────────────────────────────────────────────────────

QuantLibResultView::QuantLibResultView(QWidget* parent) : QWidget(parent) {
    setObjectName("qlResultPanel");
    auto* vl = new QVBoxLayout(this);
    vl->setContentsMargins(0, 0, 0, 0);
    vl->setSpacing(0);

    // Toolbar: RESULTS · endpoint ····· status · TABLE CHART JSON · COPY CSV
    auto* bar = new QWidget(this);
    bar->setObjectName("qlResultBar");
    bar->setFixedHeight(34);
    auto* bl = new QHBoxLayout(bar);
    bl->setContentsMargins(12, 0, 8, 0);
    bl->setSpacing(6);
    title_ = new QLabel(tr("RESULTS"), bar);
    title_->setObjectName("qlPanelTitle");
    bl->addWidget(title_);
    endpoint_label_ = new QLabel(bar);
    endpoint_label_->setObjectName("qlResultEndpoint");
    bl->addWidget(endpoint_label_);
    bl->addStretch(1);
    status_ = new QLabel(bar);
    status_->setObjectName("qlResultStatus");
    bl->addWidget(status_);

    auto make_btn = [bar](const QString& text, const char* object_name) {
        auto* b = new QPushButton(text, bar);
        b->setObjectName(object_name);
        b->setCursor(Qt::PointingHandCursor);
        b->setFocusPolicy(Qt::TabFocus);
        return b;
    };
    table_btn_ = make_btn(tr("TABLE"), "qlViewBtn");
    chart_btn_ = make_btn(tr("CHART"), "qlViewBtn");
    json_btn_ = make_btn(tr("JSON"), "qlViewBtn");
    auto* group = new QButtonGroup(this);
    group->setExclusive(true);
    for (auto* b : {table_btn_, chart_btn_, json_btn_}) {
        b->setCheckable(true);
        group->addButton(b);
        bl->addWidget(b);
    }
    table_btn_->setChecked(true);
    connect(table_btn_, &QPushButton::clicked, this, [this]() { set_view(View::Table); });
    connect(chart_btn_, &QPushButton::clicked, this, [this]() { set_view(View::Chart); });
    connect(json_btn_, &QPushButton::clicked, this, [this]() { set_view(View::Json); });

    copy_btn_ = make_btn(tr("COPY"), "qlFormBtn");
    copy_btn_->setToolTip(tr("Copy the current view (table as tab-separated text, chart as an image)"));
    connect(copy_btn_, &QPushButton::clicked, this, &QuantLibResultView::copy_current);
    bl->addWidget(copy_btn_);
    csv_btn_ = make_btn(tr("CSV"), "qlFormBtn");
    csv_btn_->setToolTip(tr("Export the selected section — every row — to a CSV file"));
    connect(csv_btn_, &QPushButton::clicked, this, &QuantLibResultView::export_csv);
    bl->addWidget(csv_btn_);
    vl->addWidget(bar);

    // Section selector (only when an object response carries arrays).
    auto* section_bar = new QWidget(this);
    section_bar->setObjectName("qlSectionBar");
    auto* sl = new QHBoxLayout(section_bar);
    sl->setContentsMargins(12, 4, 12, 4);
    sl->setSpacing(6);
    section_label_ = new QLabel(tr("VIEW"), section_bar);
    section_label_->setObjectName("qlLabel");
    section_combo_ = new QComboBox(section_bar);
    section_combo_->setAccessibleName(tr("Result section"));
    connect(section_combo_, QOverload<int>::of(&QComboBox::currentIndexChanged), this,
            [this](int) { render_current(); });
    sl->addWidget(section_label_);
    sl->addWidget(section_combo_, 1);
    vl->addWidget(section_bar);
    section_bar->hide();

    stack_ = new QStackedWidget(this);

    message_ = new QLabel(this);
    message_->setObjectName("qlResultMessage");
    message_->setAlignment(Qt::AlignCenter);
    message_->setWordWrap(true);
    stack_->addWidget(message_); // kMessagePage

    table_ = new QTableWidget(this);
    table_->verticalHeader()->setVisible(false);
    table_->horizontalHeader()->setStretchLastSection(true);
    table_->setEditTriggers(QAbstractItemView::NoEditTriggers);
    table_->setSelectionBehavior(QAbstractItemView::SelectItems);
    table_->setSelectionMode(QAbstractItemView::ExtendedSelection);
    table_->setAccessibleName(tr("QuantLib result table"));
    stack_->addWidget(table_); // kTablePage

    chart_view_ = new QChartView(this);
    chart_view_->setRenderHint(QPainter::Antialiasing, true);
    chart_view_->setChart(new QChart());
    stack_->addWidget(chart_view_); // kChartPage

    json_ = new QPlainTextEdit(this);
    json_->setObjectName("qlJsonView");
    json_->setReadOnly(true);
    json_->setLineWrapMode(QPlainTextEdit::NoWrap);
    stack_->addWidget(json_); // kJsonPage

    auto* error_page = new QWidget(this);
    error_page->setObjectName("qlErrorPage");
    auto* el = new QVBoxLayout(error_page);
    el->setContentsMargins(20, 20, 20, 20);
    el->setSpacing(10);
    error_title_ = new QLabel(error_page);
    error_title_->setObjectName("qlErrorTitle");
    error_text_ = new QLabel(error_page);
    error_text_->setObjectName("qlErrorText");
    error_text_->setWordWrap(true);
    error_text_->setTextInteractionFlags(Qt::TextSelectableByMouse);
    error_hint_ = new QLabel(error_page);
    error_hint_->setObjectName("qlErrorHint");
    error_hint_->setWordWrap(true);
    auto* actions = new QHBoxLayout;
    actions->setSpacing(8);
    error_primary_ = new QPushButton(error_page);
    error_primary_->setObjectName("qlExecBtn");
    error_primary_->setCursor(Qt::PointingHandCursor);
    connect(error_primary_, &QPushButton::clicked, this, &QuantLibResultView::upgrade_requested);
    error_retry_ = new QPushButton(tr("RETRY"), error_page);
    error_retry_->setObjectName("qlFormBtn");
    error_retry_->setCursor(Qt::PointingHandCursor);
    connect(error_retry_, &QPushButton::clicked, this, &QuantLibResultView::retry_requested);
    actions->addWidget(error_primary_);
    actions->addWidget(error_retry_);
    actions->addStretch(1);
    el->addWidget(error_title_);
    el->addWidget(error_text_);
    el->addWidget(error_hint_);
    el->addLayout(actions);
    el->addStretch(1);
    stack_->addWidget(error_page); // kErrorPage

    vl->addWidget(stack_, 1);

    // Ctrl+C on the table copies the selection (or the whole section).
    auto* copy_sc = new QShortcut(QKeySequence::Copy, table_);
    copy_sc->setContext(Qt::WidgetShortcut);
    connect(copy_sc, &QShortcut::activated, this, &QuantLibResultView::copy_current);

    show_idle();
}

void QuantLibResultView::retranslate() {
    title_->setText(tr("RESULTS"));
    table_btn_->setText(tr("TABLE"));
    chart_btn_->setText(tr("CHART"));
    json_btn_->setText(tr("JSON"));
    copy_btn_->setText(tr("COPY"));
    copy_btn_->setToolTip(tr("Copy the current view (table as tab-separated text, chart as an image)"));
    csv_btn_->setText(tr("CSV"));
    csv_btn_->setToolTip(tr("Export the selected section — every row — to a CSV file"));
    section_label_->setText(tr("VIEW"));
    error_retry_->setText(tr("RETRY"));
    if (has_failure_)
        show_failure(endpoint_, failure_);
    else if (!has_result_)
        show_idle();
}

// ── States ───────────────────────────────────────────────────────────────────

void QuantLibResultView::set_result_controls_enabled(bool enabled) {
    for (auto* b : {table_btn_, chart_btn_, json_btn_, copy_btn_, csv_btn_})
        b->setEnabled(enabled);
    if (!enabled)
        section_combo_->parentWidget()->hide();
}

void QuantLibResultView::show_idle() {
    has_result_ = false;
    has_failure_ = false;
    endpoint_label_->clear();
    status_->clear();
    set_result_controls_enabled(false);
    message_->setText(tr("Pick a module and an endpoint, set the parameters, then press Enter or EXECUTE."));
    stack_->setCurrentIndex(kMessagePage);
}

void QuantLibResultView::show_loading(const QString& endpoint, const QString& cost_note) {
    has_failure_ = false;
    endpoint_label_->setText(endpoint);
    status_->setText(cost_note.isEmpty() ? tr("Computing…") : tr("Computing… (%1)").arg(cost_note));
    set_result_controls_enabled(false);
    message_->setText(tr("Computing %1 …").arg(endpoint));
    stack_->setCurrentIndex(kMessagePage);
}

void QuantLibResultView::show_input_error(const QString& message) {
    has_failure_ = false;
    status_->setText(tr("Not sent"));
    show_error_page(tr("INVALID INPUT"), QStringLiteral("error"), message,
                    tr("Nothing was sent — fix the highlighted field and run again."), QString(), false);
}

void QuantLibResultView::show_error_page(const QString& title, const QString& tone, const QString& message,
                                         const QString& hint, const QString& primary_text, bool show_retry) {
    set_result_controls_enabled(false);
    error_title_->setText(title);
    error_title_->setProperty("tone", tone);
    error_title_->style()->unpolish(error_title_);
    error_title_->style()->polish(error_title_);
    error_text_->setText(message);
    error_hint_->setText(hint);
    error_hint_->setVisible(!hint.isEmpty());
    error_primary_->setText(primary_text);
    error_primary_->setVisible(!primary_text.isEmpty());
    error_retry_->setVisible(show_retry);
    stack_->setCurrentIndex(kErrorPage);
}

void QuantLibResultView::show_failure(const QString& endpoint, const services::QuantLibFailure& failure) {
    using Kind = services::QuantLibFailureKind;
    endpoint_ = endpoint;
    failure_ = failure;
    has_failure_ = true;
    has_result_ = false;
    endpoint_label_->setText(endpoint);
    status_->setText(failure.http_status > 0 ? tr("HTTP %1").arg(failure.http_status) : tr("Failed"));

    switch (failure.kind) {
        case Kind::NeedsPro:
            show_error_page(tr("THIS MODULE NEEDS PRO"), QStringLiteral("pro"), failure.message,
                            tr("Pro ($10/month) includes every QuantLib module — all endpoints at 0 credits per "
                               "call."),
                            tr("UPGRADE TO PRO"), false);
            break;
        case Kind::OutOfCredits:
            show_error_page(tr("OUT OF CREDITS"), QStringLiteral("warn"), failure.message,
                            tr("On the Free plan this endpoint costs 1 credit per call. Pro includes every QuantLib "
                               "endpoint at 0 credits."),
                            tr("VIEW PLANS"), true);
            break;
        case Kind::AuthRequired:
            show_error_page(tr("SIGN-IN REQUIRED"), QStringLiteral("warn"), failure.message,
                            tr("Your session is missing or has expired. Sign in again, then retry."), QString(),
                            true);
            break;
        case Kind::RateLimited:
            show_error_page(tr("RATE LIMITED"), QStringLiteral("warn"), failure.message,
                            tr("Too many requests right now — wait a moment, then retry."), QString(), true);
            break;
        case Kind::InvalidInput:
            show_error_page(tr("INVALID INPUT"), QStringLiteral("error"), failure.message,
                            tr("The server rejected the request body. Check the field names and units (decimals: "
                               "0.05 = 5%)."),
                            QString(), false);
            break;
        case Kind::Network:
            show_error_page(tr("NETWORK ERROR"), QStringLiteral("error"), failure.message,
                            tr("The request did not reach the QuantLib service. Check your connection and retry."),
                            QString(), true);
            break;
        case Kind::Server:
            show_error_page(tr("SERVICE ERROR"), QStringLiteral("error"), failure.message,
                            tr("The QuantLib service did not return a usable answer. Retry in a moment."), QString(),
                            true);
            break;
        case Kind::Computation:
            show_error_page(tr("COMPUTATION FAILED"), QStringLiteral("error"), failure.message,
                            tr("The model could not be evaluated with these inputs. Adjust the parameters and run "
                               "again."),
                            QString(), false);
            break;
    }
}

void QuantLibResultView::show_result(const QString& endpoint, const QJsonObject& request, const QJsonValue& payload,
                                     qint64 elapsed_ms) {
    endpoint_ = endpoint;
    request_ = request;
    payload_ = payload;
    elapsed_ms_ = elapsed_ms;
    has_result_ = true;
    has_failure_ = false;
    endpoint_label_->setText(endpoint);
    set_result_controls_enabled(true);
    build_sections();
    render_current();
}

// ── Sections ─────────────────────────────────────────────────────────────────

void QuantLibResultView::build_sections() {
    sections_.clear();
    if (payload_.isObject()) {
        const QJsonObject obj = payload_.toObject();
        sections_.append({tr("Summary"), payload_});
        for (auto it = obj.begin(); it != obj.end(); ++it) {
            if (it.value().isArray() && !it.value().toArray().isEmpty())
                sections_.append({it.key(), it.value()});
        }
    } else {
        sections_.append({tr("Result"), payload_});
    }
    {
        const QSignalBlocker block(section_combo_);
        section_combo_->clear();
        for (const auto& s : sections_) {
            const int n = s.second.isArray() ? int(s.second.toArray().size()) : -1;
            section_combo_->addItem(n >= 0 ? tr("%1  (%2 rows)").arg(s.first).arg(n) : s.first);
        }
        section_combo_->setCurrentIndex(0);
    }
    section_combo_->parentWidget()->setVisible(sections_.size() > 1);
}

void QuantLibResultView::render_current() {
    if (!has_result_ || sections_.isEmpty())
        return;
    const int idx = std::clamp(section_combo_->currentIndex(), 0, int(sections_.size()) - 1);
    const QJsonValue section = sections_.at(idx).second;

    // Status: size of what is shown + round-trip time.
    QString size_text;
    if (section.isArray()) {
        const int n = int(section.toArray().size());
        size_text = n > kQlTableRowCap ? tr("showing %1 of %2 rows").arg(kQlTableRowCap).arg(n) : tr("%1 rows").arg(n);
    } else if (section.isObject()) {
        size_text = tr("%1 fields").arg(section.toObject().size());
    } else {
        size_text = tr("1 value");
    }
    status_->setText(tr("%1 · %2 ms").arg(size_text).arg(elapsed_ms_));

    render_table(section);
    QString x_title;
    const QList<Series> series = chart_series(section, &x_title);
    chart_btn_->setEnabled(!series.isEmpty());
    chart_btn_->setToolTip(series.isEmpty() ? tr("No numeric series in this section to chart") : QString());
    if (!series.isEmpty())
        render_chart(series, x_title);
    render_json();

    View v = view_;
    if (v == View::Chart && series.isEmpty())
        v = View::Table;
    set_view(v);
}

void QuantLibResultView::set_view(View view) {
    view_ = view;
    const QSignalBlocker b1(table_btn_), b2(chart_btn_), b3(json_btn_);
    table_btn_->setChecked(view == View::Table);
    chart_btn_->setChecked(view == View::Chart);
    json_btn_->setChecked(view == View::Json);
    if (!has_result_)
        return;
    stack_->setCurrentIndex(view == View::Table ? kTablePage : view == View::Chart ? kChartPage : kJsonPage);
}

// ── Table ────────────────────────────────────────────────────────────────────

void QuantLibResultView::render_table(const QJsonValue& section) {
    table_->setSortingEnabled(false);
    table_->clear();

    auto numeric_item = [](const QJsonValue& v) -> QTableWidgetItem* {
        const QString text = ql_rv_cell(v, false);
        QTableWidgetItem* item = v.isDouble() ? new ui::NumericTableWidgetItem(text, v.toDouble())
                                              : new QTableWidgetItem(text);
        if (v.isDouble()) {
            item->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
            item->setForeground(QColor(v.toDouble() < 0 ? colors::NEGATIVE() : colors::CYAN()));
        } else if (v.isArray() || v.isObject()) {
            item->setToolTip(text.left(4000));
            if (text.size() > 200)
                item->setText(text.left(200) + QStringLiteral("…"));
        }
        return item;
    };

    if (section.isObject()) {
        const QJsonObject obj = section.toObject();
        table_->setColumnCount(2);
        table_->setHorizontalHeaderLabels({tr("Field"), tr("Value")});
        table_->setRowCount(int(obj.size()));
        int r = 0;
        for (auto it = obj.begin(); it != obj.end(); ++it, ++r) {
            auto* key_item = new QTableWidgetItem(it.key());
            key_item->setForeground(QColor(colors::TEXT_SECONDARY()));
            table_->setItem(r, 0, key_item);
            table_->setItem(r, 1, numeric_item(it.value()));
        }
    } else if (section.isArray()) {
        const QJsonArray arr = section.toArray();
        const int rows = std::min<int>(arr.size(), kQlTableRowCap);
        const bool objects = !arr.isEmpty() && std::all_of(arr.begin(), arr.end(), [](const QJsonValue& v) {
            return v.isObject();
        });
        const bool matrix = !arr.isEmpty() && !objects && std::all_of(arr.begin(), arr.end(), [](const QJsonValue& v) {
            return v.isArray();
        });
        if (objects) {
            const QStringList cols = ql_rv_object_columns(arr);
            table_->setColumnCount(int(cols.size()));
            table_->setHorizontalHeaderLabels(cols);
            table_->setRowCount(rows);
            for (int r = 0; r < rows; ++r) {
                const QJsonObject o = arr.at(r).toObject();
                for (int c = 0; c < cols.size(); ++c)
                    table_->setItem(r, c, numeric_item(o.value(cols.at(c))));
            }
        } else if (matrix) {
            int width = 0;
            for (int r = 0; r < rows; ++r)
                width = std::max(width, int(arr.at(r).toArray().size()));
            width = std::min(width, 200);
            QStringList headers{QStringLiteral("#")};
            for (int c = 0; c < width; ++c)
                headers << QString::number(c);
            table_->setColumnCount(width + 1);
            table_->setHorizontalHeaderLabels(headers);
            table_->setRowCount(rows);
            for (int r = 0; r < rows; ++r) {
                table_->setItem(r, 0, new ui::NumericTableWidgetItem(QString::number(r), r));
                const QJsonArray row = arr.at(r).toArray();
                for (int c = 0; c < width && c < row.size(); ++c)
                    table_->setItem(r, c + 1, numeric_item(row.at(c)));
            }
        } else {
            table_->setColumnCount(2);
            table_->setHorizontalHeaderLabels({QStringLiteral("#"), tr("Value")});
            table_->setRowCount(rows);
            for (int r = 0; r < rows; ++r) {
                table_->setItem(r, 0, new ui::NumericTableWidgetItem(QString::number(r), r));
                table_->setItem(r, 1, numeric_item(arr.at(r)));
            }
        }
    } else {
        table_->setColumnCount(1);
        table_->setHorizontalHeaderLabels({tr("Value")});
        table_->setRowCount(1);
        table_->setItem(0, 0, numeric_item(section));
    }
    table_->resizeColumnsToContents();
    table_->setSortingEnabled(true);
}

QList<QStringList> QuantLibResultView::section_rows(const QJsonValue& section, QStringList* headers) const {
    QList<QStringList> rows;
    headers->clear();
    if (section.isObject()) {
        *headers = {QStringLiteral("field"), QStringLiteral("value")};
        const QJsonObject obj = section.toObject();
        for (auto it = obj.begin(); it != obj.end(); ++it)
            rows.append({it.key(), ql_rv_cell(it.value(), true)});
        return rows;
    }
    if (!section.isArray()) {
        *headers = {QStringLiteral("value")};
        rows.append({ql_rv_cell(section, true)});
        return rows;
    }
    const QJsonArray arr = section.toArray();
    const bool objects =
        !arr.isEmpty() && std::all_of(arr.begin(), arr.end(), [](const QJsonValue& v) { return v.isObject(); });
    const bool matrix =
        !arr.isEmpty() && !objects && std::all_of(arr.begin(), arr.end(), [](const QJsonValue& v) { return v.isArray(); });
    if (objects) {
        *headers = ql_rv_object_columns(arr);
        for (const auto& v : arr) {
            const QJsonObject o = v.toObject();
            QStringList row;
            for (const QString& c : *headers)
                row << ql_rv_cell(o.value(c), true);
            rows.append(row);
        }
    } else if (matrix) {
        int width = 0;
        for (const auto& v : arr)
            width = std::max(width, int(v.toArray().size()));
        *headers = {QStringLiteral("row")};
        for (int c = 0; c < width; ++c)
            *headers << QString::number(c);
        int r = 0;
        for (const auto& v : arr) {
            QStringList row{QString::number(r++)};
            for (const auto& e : v.toArray())
                row << ql_rv_cell(e, true);
            rows.append(row);
        }
    } else {
        *headers = {QStringLiteral("index"), QStringLiteral("value")};
        int r = 0;
        for (const auto& v : arr)
            rows.append({QString::number(r++), ql_rv_cell(v, true)});
    }
    return rows;
}

// ── Chart ────────────────────────────────────────────────────────────────────

QList<QuantLibResultView::Series> QuantLibResultView::chart_series(const QJsonValue& section, QString* x_title) const {
    QList<Series> out;
    *x_title = tr("index");
    auto by_index = [](const QList<double>& ys) {
        QList<QPointF> pts;
        pts.reserve(ys.size());
        for (int i = 0; i < ys.size(); ++i)
            pts.append(QPointF(i, ys.at(i)));
        return pts;
    };
    auto against = [](const QList<double>& xs, const QList<double>& ys) {
        QList<QPointF> pts;
        pts.reserve(ys.size());
        for (int i = 0; i < ys.size() && i < xs.size(); ++i)
            pts.append(QPointF(xs.at(i), ys.at(i)));
        return pts;
    };
    static const QStringList kXKeys = {"times",  "time",   "t",       "tenors",     "tenor",      "x",
                                       "x_data", "query_x", "query_tenors", "strikes", "strike",  "maturities",
                                       "maturity", "grid", "t_grid",  "year",       "step",       "period",
                                       "volatility", "risk"};

    QList<double> ys;
    QList<QList<double>> mat;

    if (ql_rv_numeric_array(section, &ys)) {
        out.append({tr("value"), by_index(ys)});
        return out;
    }
    if (ql_rv_numeric_matrix(section, &mat)) {
        const bool pairs = mat.size() >= 2 && std::all_of(mat.begin(), mat.end(), [](const QList<double>& r) {
            return r.size() == 2;
        });
        if (pairs) {
            QList<QPointF> pts;
            for (const auto& r : mat)
                pts.append(QPointF(r.at(0), r.at(1)));
            *x_title = QStringLiteral("x");
            out.append({tr("y"), pts});
            return out;
        }
        for (int i = 0; i < mat.size() && out.size() < kQlChartSeriesCap; ++i) {
            if (mat.at(i).size() >= 2)
                out.append({tr("row %1").arg(i + 1), by_index(mat.at(i))});
        }
        return out;
    }
    if (section.isArray()) {
        // Array of objects: numeric columns.
        const QJsonArray arr = section.toArray();
        if (arr.size() < 2 || !arr.at(0).isObject())
            return out;
        QStringList numeric;
        for (const QString& c : ql_rv_object_columns(arr)) {
            const bool all_num = std::all_of(arr.begin(), arr.end(), [&c](const QJsonValue& v) {
                return v.toObject().value(c).isDouble();
            });
            if (all_num)
                numeric << c;
        }
        if (numeric.isEmpty())
            return out;
        QString x_key;
        for (const QString& k : kXKeys) {
            if (numeric.contains(k)) {
                x_key = k;
                break;
            }
        }
        if (x_key.isEmpty() && numeric.size() >= 2)
            x_key = numeric.first();
        QList<double> xs;
        if (!x_key.isEmpty()) {
            for (const auto& v : arr)
                xs.append(v.toObject().value(x_key).toDouble());
            *x_title = x_key;
        }
        for (const QString& k : numeric) {
            if (k == x_key || out.size() >= 6)
                continue;
            QList<double> col;
            for (const auto& v : arr)
                col.append(v.toObject().value(k).toDouble());
            out.append({k, x_key.isEmpty() ? by_index(col) : against(xs, col)});
        }
        return out;
    }
    if (!section.isObject())
        return out;

    // Object: numeric arrays plotted against an x-like array of the same length.
    const QJsonObject obj = section.toObject();
    QHash<QString, QList<double>> arrays;
    QHash<QString, QList<QList<double>>> matrices;
    for (auto it = obj.begin(); it != obj.end(); ++it) {
        if (ql_rv_numeric_array(it.value(), &ys))
            arrays.insert(it.key(), ys);
        else if (ql_rv_numeric_matrix(it.value(), &mat))
            matrices.insert(it.key(), mat);
    }
    if (arrays.isEmpty() && matrices.isEmpty())
        return out;

    QString x_key;
    for (const QString& k : kXKeys) {
        if (arrays.contains(k)) {
            x_key = k;
            break;
        }
    }
    const QList<double> xs = x_key.isEmpty() ? QList<double>{} : arrays.value(x_key);

    // Without an x array, plot the length group with the most arrays so series
    // of unrelated lengths (e.g. one path + per-path final values) never share axes.
    int target_len = int(xs.size());
    if (x_key.isEmpty()) {
        QHash<int, int> counts;
        for (auto it = arrays.begin(); it != arrays.end(); ++it)
            counts[int(it.value().size())] += 1;
        int best = -1;
        for (auto it = counts.begin(); it != counts.end(); ++it) {
            if (best < 0 || it.value() > counts.value(best) || (it.value() == counts.value(best) && it.key() > best))
                best = it.key();
        }
        target_len = best;
    } else {
        *x_title = x_key;
    }

    QStringList keys = arrays.keys();
    keys.sort();
    for (const QString& k : keys) {
        if (k == x_key || out.size() >= kQlChartSeriesCap)
            continue;
        const QList<double>& col = arrays.value(k);
        if (int(col.size()) != target_len)
            continue;
        out.append({k, x_key.isEmpty() ? by_index(col) : against(xs, col)});
    }
    QStringList mkeys = matrices.keys();
    mkeys.sort();
    for (const QString& k : mkeys) {
        const auto& rows = matrices.value(k);
        if (!xs.isEmpty() && !rows.isEmpty() && int(rows.first().size()) == int(xs.size())) {
            // One row per path, sampled on the x grid.
            for (int i = 0; i < rows.size() && out.size() < kQlChartSeriesCap; ++i)
                out.append({rows.size() == 1 ? k : tr("%1 %2").arg(k).arg(i + 1), against(xs, rows.at(i))});
        } else if (!xs.isEmpty() && int(rows.size()) == int(xs.size()) && !rows.first().isEmpty() &&
                   rows.first().size() <= 10) {
            // One row per time step (multi-dimensional path): one series per dimension.
            const int dims = int(rows.first().size());
            for (int d = 0; d < dims && out.size() < kQlChartSeriesCap; ++d) {
                QList<double> col;
                for (const auto& r : rows)
                    col.append(d < r.size() ? r.at(d) : std::numeric_limits<double>::quiet_NaN());
                out.append({tr("%1[%2]").arg(k).arg(d), against(xs, col)});
            }
        }
    }
    return out;
}

void QuantLibResultView::render_chart(const QList<Series>& series, const QString& x_title) {
    auto* chart = new QChart();
    chart->setBackgroundBrush(QBrush(QColor(colors::BG_BASE())));
    chart->setPlotAreaBackgroundBrush(QBrush(QColor(colors::BG_BASE())));
    chart->setPlotAreaBackgroundVisible(true);
    chart->setMargins(QMargins(6, 6, 6, 6));
    chart->setTitleBrush(QBrush(QColor(colors::AMBER())));
    QFont title_font(fonts::DATA_FAMILY, 9, QFont::Bold);
    chart->setTitleFont(title_font);

    const QList<QColor> palette = {QColor(colors::AMBER()),   QColor(colors::CYAN()),     QColor(colors::POSITIVE()),
                                   QColor(colors::INFO()),    QColor(colors::WARNING()),  QColor(colors::NEGATIVE()),
                                   QColor(colors::TEXT_SECONDARY())};

    double min_x = std::numeric_limits<double>::max(), max_x = std::numeric_limits<double>::lowest();
    double min_y = min_x, max_y = max_x;
    bool downsampled = false;
    QList<QLineSeries*> lines;
    for (int i = 0; i < series.size(); ++i) {
        const QList<QPointF> pts = ql_rv_downsample(series.at(i).points, &downsampled);
        for (const QPointF& p : pts) {
            if (!std::isfinite(p.x()) || !std::isfinite(p.y()))
                continue;
            min_x = std::min(min_x, p.x());
            max_x = std::max(max_x, p.x());
            min_y = std::min(min_y, p.y());
            max_y = std::max(max_y, p.y());
        }
        auto* line = new QLineSeries(chart);
        line->setName(series.at(i).name);
        QPen pen(palette.at(i % palette.size()));
        pen.setWidthF(series.size() > 8 ? 1.0 : 1.6);
        line->setPen(pen);
        line->replace(pts); // one call per series — never point-by-point appends
        chart->addSeries(line);
        lines.append(line);
    }
    if (min_x > max_x) { // nothing finite to plot
        min_x = 0;
        max_x = 1;
        min_y = 0;
        max_y = 1;
    }
    if (min_x == max_x) {
        min_x -= 0.5;
        max_x += 0.5;
    }
    if (min_y == max_y) {
        const double pad = std::fabs(min_y) > 0 ? std::fabs(min_y) * 0.05 : 1.0;
        min_y -= pad;
        max_y += pad;
    } else {
        const double pad = (max_y - min_y) * 0.05;
        min_y -= pad;
        max_y += pad;
    }

    auto style_axis = [](QValueAxis* ax) {
        ax->setLabelsColor(QColor(colors::TEXT_TERTIARY()));
        ax->setGridLineColor(QColor(colors::BORDER_DIM()));
        ax->setLinePen(QPen(QColor(colors::BORDER_MED())));
        ax->setTitleBrush(QBrush(QColor(colors::TEXT_SECONDARY())));
        ax->setLabelFormat("%.4g");
        ax->setMinorTickCount(0);
    };
    auto* ax_x = new QValueAxis(chart);
    ax_x->setRange(min_x, max_x);
    ax_x->setTitleText(x_title);
    style_axis(ax_x);
    auto* ax_y = new QValueAxis(chart);
    ax_y->setRange(min_y, max_y);
    style_axis(ax_y);
    chart->addAxis(ax_x, Qt::AlignBottom);
    chart->addAxis(ax_y, Qt::AlignLeft);
    for (auto* line : lines) {
        line->attachAxis(ax_x);
        line->attachAxis(ax_y);
    }

    const bool legend = series.size() <= 8;
    chart->legend()->setVisible(legend);
    if (legend) {
        chart->legend()->setAlignment(Qt::AlignBottom);
        chart->legend()->setLabelColor(QColor(colors::TEXT_SECONDARY()));
    }
    QString title = series.size() == 1 ? series.first().name : tr("%1 series").arg(series.size());
    if (downsampled)
        title += tr(" · downsampled to %1 points").arg(kQlChartPointCap);
    chart->setTitle(title);

    QChart* old = chart_view_->chart();
    chart_view_->setChart(chart);
    delete old; // QChartView releases (does not delete) the previous chart
}

// ── JSON ─────────────────────────────────────────────────────────────────────

void QuantLibResultView::render_json() {
    QByteArray text;
    if (payload_.isObject())
        text = QJsonDocument(payload_.toObject()).toJson(QJsonDocument::Indented);
    else if (payload_.isArray())
        text = QJsonDocument(payload_.toArray()).toJson(QJsonDocument::Indented);
    else
        text = ql_rv_cell(payload_, true).toUtf8();
    if (text.size() > kQlJsonCharCap) {
        const qsizetype total = text.size();
        text.truncate(kQlJsonCharCap);
        text += "\n… " + tr("truncated: %1 of %2 bytes shown — use CSV to export everything")
                             .arg(kQlJsonCharCap)
                             .arg(total)
                             .toUtf8();
    }
    json_->setPlainText(QString::fromUtf8(text));
}

// ── Copy / export ────────────────────────────────────────────────────────────

void QuantLibResultView::copy_current() {
    if (!has_result_ || sections_.isEmpty())
        return;
    QClipboard* cb = QApplication::clipboard();
    if (view_ == View::Chart) {
        cb->setPixmap(chart_view_->grab());
        status_->setText(tr("Chart copied as an image"));
        return;
    }
    if (view_ == View::Json) {
        cb->setText(json_->toPlainText());
        status_->setText(tr("JSON copied"));
        return;
    }
    // Table: the selected cells when there is a selection, else the whole section
    // (from the data, so rows beyond the table's display cap are included).
    const auto ranges = table_->selectedRanges();
    QStringList lines;
    if (!ranges.isEmpty()) {
        const auto& r = ranges.first();
        for (int row = r.topRow(); row <= r.bottomRow(); ++row) {
            QStringList cells;
            for (int col = r.leftColumn(); col <= r.rightColumn(); ++col) {
                const QTableWidgetItem* it = table_->item(row, col);
                cells << (it ? (it->toolTip().isEmpty() ? it->text() : it->toolTip()) : QString());
            }
            lines << cells.join(QLatin1Char('\t'));
        }
    } else {
        const int idx = std::clamp(section_combo_->currentIndex(), 0, int(sections_.size()) - 1);
        QStringList headers;
        const QList<QStringList> rows = section_rows(sections_.at(idx).second, &headers);
        lines << headers.join(QLatin1Char('\t'));
        for (const auto& row : rows)
            lines << row.join(QLatin1Char('\t'));
    }
    cb->setText(lines.join(QLatin1Char('\n')));
    status_->setText(tr("%1 lines copied").arg(lines.size()));
}

void QuantLibResultView::export_csv() {
    if (!has_result_ || sections_.isEmpty())
        return;
    const int idx = std::clamp(section_combo_->currentIndex(), 0, int(sections_.size()) - 1);
    QString base = endpoint_;
    base.replace(QLatin1Char('/'), QLatin1Char('_'));
    const QString suggested = QStringLiteral("quantlib_%1_%2.csv")
                                  .arg(base, QDateTime::currentDateTime().toString(QStringLiteral("yyyyMMdd_HHmmss")));
    const QString path = QFileDialog::getSaveFileName(this, tr("Export CSV"), suggested, tr("CSV Files (*.csv)"));
    if (path.isEmpty())
        return;
    QFile file(path);
    if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
        status_->setText(tr("Could not write %1").arg(path));
        LOG_ERROR("QuantLib", QString("CSV export failed: cannot open %1").arg(path));
        return;
    }
    QTextStream out(&file);
    out.setEncoding(QStringConverter::Utf8);
    // Provenance: an export without its inputs is not reproducible.
    out << "# endpoint=" << endpoint_ << "  section=" << sections_.at(idx).first
        << "  exported=" << QDateTime::currentDateTimeUtc().toString(Qt::ISODate) << "\n";
    out << "# request=" << QString::fromUtf8(QJsonDocument(request_).toJson(QJsonDocument::Compact)) << "\n";
    QStringList headers;
    const QList<QStringList> rows = section_rows(sections_.at(idx).second, &headers);
    QStringList escaped;
    for (const QString& h : headers)
        escaped << ql_rv_csv_escape(h);
    out << escaped.join(QLatin1Char(',')) << "\n";
    for (const auto& row : rows) {
        escaped.clear();
        for (const QString& c : row)
            escaped << ql_rv_csv_escape(c);
        out << escaped.join(QLatin1Char(',')) << "\n";
    }
    file.close();
    status_->setText(tr("Exported %1 rows").arg(rows.size()));
    LOG_INFO("QuantLib", QString("Exported %1 rows of %2 to CSV").arg(rows.size()).arg(endpoint_));
}

} // namespace fincept::screens