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.

28.7 KB
Raw Blame
// src/screens/surface_analytics/SurfaceAnalyticsScreen_Providers.cpp
//
// Databento provider result handlers — vol surface, OHLCV, futures, generic
// surface, plus fetch-status / connection-test / raw-response logging.
//
// Part of the partial-class split of SurfaceAnalyticsScreen.cpp.

#include "Surface3DWidget.h"
#include "SurfaceAnalyticsScreen.h"
#include "SurfaceCapabilities.h"
#include "SurfaceControlPanel.h"
#include "SurfaceCsvImporter.h"
#include "SurfaceDataInspector.h"
#include "SurfaceDefaults.h"
#include "SurfaceLineWidget.h"
#include "SurfaceTableWidget.h"
#include "core/logging/Logger.h"
#include "core/session/ScreenStateManager.h"
#include "datahub/DataHub.h"
#include "datahub/DataHubMetaTypes.h"
#include "services/markets/MarketDataService.h"
#include "ui/theme/Theme.h"

#include <QFileDialog>
#include <QFrame>
#include <QHBoxLayout>
#include <QLabel>
#include <QPushButton>
#include <QScrollArea>
#include <QSplitter>
#include <QStackedWidget>
#include <QStringList>
#include <QVBoxLayout>
#include <QVariant>

#include <QCoreApplication>
#include <QDate>
#include <QDateTime>
#include <QMap>
#include <QTimeZone>

#include <algorithm>
#include <cmath>
#include <string>
#include <vector>

namespace fincept::surface {

using namespace fincept::ui;

namespace {

// ── Risk-surface maths (pure, no Qt) ────────────────────────────────────────
// Everything below works on aligned daily series: closes[asset][t] ascending by date and
// returns[asset][t-1] = close[t] / close[t-1] - 1.

// Pearson correlation of two return series (common length).
double risk_corr(const std::vector<double>& x, const std::vector<double>& y) {
    const size_t n = std::min(x.size(), y.size());
    if (n < 2)
        return 0.0;
    double mx = 0.0, my = 0.0;
    for (size_t i = 0; i < n; ++i) {
        mx += x[i];
        my += y[i];
    }
    mx /= double(n);
    my /= double(n);
    double sxx = 0.0, syy = 0.0, sxy = 0.0;
    for (size_t i = 0; i < n; ++i) {
        const double dx = x[i] - mx, dy = y[i] - my;
        sxx += dx * dx;
        syy += dy * dy;
        sxy += dx * dy;
    }
    const double d = std::sqrt(sxx * syy);
    return d > 0.0 ? sxy / d : 0.0;
}

// OLS beta of `y` on `x` over the LAST `k` observations (cov(y,x) / var(x)). 0 when the
// window is too short or x is constant.
double risk_beta_last(const std::vector<double>& y, const std::vector<double>& x, size_t k) {
    const size_t n = std::min(x.size(), y.size());
    k = std::min(k, n);
    if (k < 3)
        return 0.0;
    const size_t off = n - k;
    double mx = 0.0, my = 0.0;
    for (size_t i = off; i < n; ++i) {
        mx += x[i];
        my += y[i];
    }
    mx /= double(k);
    my /= double(k);
    double vx = 0.0, cxy = 0.0;
    for (size_t i = off; i < n; ++i) {
        const double dx = x[i] - mx;
        vx += dx * dx;
        cxy += dx * (y[i] - my);
    }
    return vx > 0.0 ? cxy / vx : 0.0;
}

// Maximum peak-to-trough decline (percent, <= 0) of `close` within its last `w` trading
// days (w + 1 closes). A window longer than the data uses all of it.
double risk_max_drawdown_pct_last(const std::vector<double>& close, size_t w) {
    const size_t n = close.size();
    const size_t k = std::min(n, w + 1);
    if (k < 2)
        return 0.0;
    double peak = close[n - k];
    double mdd = 0.0;
    for (size_t i = n - k; i < n; ++i) {
        peak = std::max(peak, close[i]);
        if (peak > 0.0)
            mdd = std::min(mdd, close[i] / peak - 1.0);
    }
    return mdd * 100.0;
}

// q-quantile (0..1) of `v` by linear interpolation between order statistics.
double risk_quantile(std::vector<double> v, double q) {
    if (v.empty())
        return 0.0;
    std::sort(v.begin(), v.end());
    const double pos = std::min(1.0, std::max(0.0, q)) * double(v.size() - 1);
    const size_t lo = size_t(std::floor(pos));
    const size_t hi = std::min(v.size() - 1, lo + 1);
    return v[lo] + (v[hi] - v[lo]) * (pos - double(lo));
}

// Eigen-decomposition of a symmetric matrix by cyclic Jacobi rotations (n is a basket,
// a handful of assets). Eigenvalues come back in DESCENDING order; evecs[row][k] is the
// row-th component of the k-th eigenvector.
void risk_jacobi_eigen(std::vector<std::vector<double>> a, std::vector<double>& evals,
                       std::vector<std::vector<double>>& evecs) {
    const size_t n = a.size();
    std::vector<std::vector<double>> v(n, std::vector<double>(n, 0.0));
    for (size_t i = 0; i < n; ++i)
        v[i][i] = 1.0;
    for (int sweep = 0; sweep < 100; ++sweep) {
        double off = 0.0;
        for (size_t p = 0; p + 1 < n; ++p)
            for (size_t q = p + 1; q < n; ++q)
                off += a[p][q] * a[p][q];
        if (off < 1e-22)
            break;
        for (size_t p = 0; p + 1 < n; ++p) {
            for (size_t q = p + 1; q < n; ++q) {
                if (std::fabs(a[p][q]) < 1e-300)
                    continue;
                const double theta = (a[q][q] - a[p][p]) / (2.0 * a[p][q]);
                const double t = (theta >= 0.0 ? 1.0 : -1.0) / (std::fabs(theta) + std::sqrt(theta * theta + 1.0));
                const double c = 1.0 / std::sqrt(t * t + 1.0);
                const double s = t * c;
                for (size_t k = 0; k < n; ++k) {
                    const double akp = a[k][p], akq = a[k][q];
                    a[k][p] = c * akp - s * akq;
                    a[k][q] = s * akp + c * akq;
                }
                for (size_t k = 0; k < n; ++k) {
                    const double apk = a[p][k], aqk = a[q][k];
                    a[p][k] = c * apk - s * aqk;
                    a[q][k] = s * apk + c * aqk;
                }
                for (size_t k = 0; k < n; ++k) {
                    const double vkp = v[k][p], vkq = v[k][q];
                    v[k][p] = c * vkp - s * vkq;
                    v[k][q] = s * vkp + c * vkq;
                }
            }
        }
    }
    std::vector<size_t> order(n);
    for (size_t i = 0; i < n; ++i)
        order[i] = i;
    std::sort(order.begin(), order.end(), [&](size_t l, size_t r) { return a[l][l] > a[r][r]; });
    evals.assign(n, 0.0);
    evecs.assign(n, std::vector<double>(n, 0.0));
    for (size_t k = 0; k < n; ++k) {
        evals[k] = a[order[k]][order[k]];
        for (size_t i = 0; i < n; ++i)
            evecs[i][k] = v[i][order[k]];
    }
}

// Aligned daily closes for the symbols of an OHLCV response: the dates COMMON to every
// symbol, ascending, with a positive close. rets[a][t-1] = close[t] / close[t-1] - 1.
struct SurfaceRiskInputs {
    std::vector<std::string> assets;
    std::vector<std::vector<double>> closes;
    std::vector<std::vector<double>> rets;
};

// "YYYY-MM-DD" of a bar: the provider stringifies the pandas index ("2026-09-29 00:00:00+00:00"),
// or - without pandas - a nanosecond `ts_event`.
QString surface_bar_date(const QJsonObject& bar) {
    const QString d = bar.value(QStringLiteral("date")).toString().left(10);
    if (QDate::fromString(d, Qt::ISODate).isValid())
        return d;
    const qint64 ns = bar.value(QStringLiteral("ts_event")).toVariant().toLongLong();
    if (ns > 0)
        return QDateTime::fromMSecsSinceEpoch(ns / 1000000, QTimeZone::UTC).date().toString(Qt::ISODate);
    return {};
}

bool surface_build_risk_inputs(const QHash<QString, QVector<QJsonObject>>& data, const QStringList& preferred,
                               SurfaceRiskInputs& out, QString& err) {
    QStringList order;
    for (const QString& s : preferred)
        if (data.contains(s) && !data.value(s).isEmpty() && !order.contains(s))
            order << s;
    QStringList rest = data.keys();
    rest.sort();
    for (const QString& s : rest)
        if (!order.contains(s) && !data.value(s).isEmpty())
            order << s;
    if (order.isEmpty()) {
        err = QCoreApplication::translate("SurfaceAnalyticsScreen", "The response carried no price bars.");
        return false;
    }

    QVector<QMap<QString, double>> by_date;
    for (const QString& sym : order) {
        QMap<QString, double> m;
        for (const QJsonObject& bar : data.value(sym)) {
            const double close = bar.value(QStringLiteral("close")).toDouble();
            const QString d = surface_bar_date(bar);
            if (close > 0.0 && std::isfinite(close) && !d.isEmpty())
                m.insert(d, close);
        }
        by_date.append(m);
    }
    QStringList common = by_date.first().keys(); // QMap keys are sorted ascending
    for (int i = 1; i < by_date.size(); ++i) {
        QStringList kept;
        for (const QString& d : common)
            if (by_date[i].contains(d))
                kept << d;
        common = kept;
    }
    constexpr int kMinCommonDays = 6;
    if (common.size() < kMinCommonDays) {
        err = QCoreApplication::translate("SurfaceAnalyticsScreen",
                                          "Only %1 trading day(s) are common to %2 - at least %3 are needed. A "
                                          "symbol with a short history (a recent listing) limits the whole basket.")
                  .arg(common.size())
                  .arg(order.join(QStringLiteral(", ")))
                  .arg(kMinCommonDays);
        return false;
    }
    for (int a = 0; a < order.size(); ++a) {
        out.assets.push_back(order[a].toStdString());
        std::vector<double> closes;
        closes.reserve(size_t(common.size()));
        for (const QString& d : common)
            closes.push_back(by_date[a].value(d));
        std::vector<double> rets;
        rets.reserve(closes.size() - 1);
        for (size_t t = 1; t < closes.size(); ++t)
            rets.push_back(closes[t] / closes[t - 1] - 1.0);
        out.closes.push_back(std::move(closes));
        out.rets.push_back(std::move(rets));
    }
    return true;
}

} // namespace

// The six EQUITIES-tier surfaces (Correlation, PCA, VaR, Drawdown, Beta, Factor Exposure)
// are declared as Databento OHLCV-driven in the capability matrix, and the fetch ran —
// but the response only ever filled the inspector's raw table, so the surfaces stayed
// sample data. Compute the five that daily closes can support. Factor Exposure needs
// factor-return series (size / value / momentum ...) that OHLCV does not carry, so it stays
// sample data and says so.
void SurfaceAnalyticsScreen::apply_risk_surfaces(const fincept::DatabentoOhlcvResult& r) {
    SurfaceRiskInputs in;
    QString err;
    const QStringList basket = control_panel_ ? control_panel_->state().basket : QStringList{};
    if (!surface_build_risk_inputs(r.data, basket, in, err)) {
        if (data_inspector_)
            data_inspector_->set_error(err);
        return;
    }
    const size_t n = in.assets.size();
    const size_t nret = in.rets[0].size();
    const std::vector<int> windows = {5, 10, 21, 63, 126, 252};
    QStringList computed;

    // ── Drawdown: max peak-to-trough % inside each trailing window ───────────
    drawdown_data_ = {};
    drawdown_data_.assets = in.assets;
    drawdown_data_.windows = windows;
    for (size_t a = 0; a < n; ++a) {
        std::vector<float> row;
        for (int w : windows)
            row.push_back(float(risk_max_drawdown_pct_last(in.closes[a], size_t(w))));
        drawdown_data_.z.push_back(std::move(row));
    }
    real_data_charts_.insert(static_cast<int>(ChartType::Drawdown));
    computed << QStringLiteral("Drawdown");

    // ── Beta vs SPY over each trailing horizon ───────────────────────────────
    size_t spy = n;
    for (size_t a = 0; a < n; ++a)
        if (in.assets[a] == "SPY")
            spy = a;
    if (spy < n) {
        beta_data_ = {};
        beta_data_.assets = in.assets;
        beta_data_.horizons = windows;
        for (size_t a = 0; a < n; ++a) {
            std::vector<float> row;
            for (int h : windows)
                row.push_back(float(risk_beta_last(in.rets[a], in.rets[spy], size_t(h))));
            beta_data_.z.push_back(std::move(row));
        }
        real_data_charts_.insert(static_cast<int>(ChartType::BetaSurface));
        computed << QStringLiteral("Beta");
    }

    // ── VaR of the equal-weight basket (historical simulation, % loss) ───────
    {
        std::vector<double> port(nret, 0.0);
        for (size_t t = 0; t < nret; ++t) {
            for (size_t a = 0; a < n; ++a)
                port[t] += in.rets[a][t];
            port[t] /= double(n);
        }
        var_data_ = {};
        var_data_.confidence_levels = {90.0f, 95.0f, 99.0f, 99.5f, 99.9f};
        var_data_.horizons = {1, 5, 10, 20, 60};
        std::vector<std::vector<double>> by_horizon; // overlapping compounded h-day returns
        for (int h : var_data_.horizons) {
            std::vector<double> rh;
            const size_t hh = size_t(h);
            if (nret >= hh + 19) { // >= 20 windows, else scale the 1-day figure below
                for (size_t s = 0; s + hh <= nret; ++s) {
                    double g = 1.0;
                    for (size_t k = s; k < s + hh; ++k)
                        g *= 1.0 + port[k];
                    rh.push_back(g - 1.0);
                }
            }
            by_horizon.push_back(std::move(rh));
        }
        for (float conf : var_data_.confidence_levels) {
            const double alpha = 1.0 - double(conf) / 100.0;
            const double q1 = risk_quantile(port, alpha);
            std::vector<float> row;
            for (size_t hi = 0; hi < var_data_.horizons.size(); ++hi) {
                const double qh = by_horizon[hi].empty()
                                      ? q1 * std::sqrt(double(var_data_.horizons[hi]))
                                      : risk_quantile(by_horizon[hi], alpha);
                row.push_back(float(-qh * 100.0));
            }
            var_data_.z.push_back(std::move(row));
        }
        real_data_charts_.insert(static_cast<int>(ChartType::VaR));
        computed << QStringLiteral("VaR");
    }

    // ── Correlation + PCA (need at least two assets) ─────────────────────────
    if (n >= 2) {
        std::vector<std::vector<double>> corr(n, std::vector<double>(n, 1.0));
        for (size_t i = 0; i < n; ++i)
            for (size_t j = 0; j < n; ++j)
                if (i != j)
                    corr[i][j] = risk_corr(in.rets[i], in.rets[j]);

        corr_data_ = {};
        corr_data_.assets = in.assets;
        corr_data_.window = int(nret);
        std::vector<float> flat;
        flat.reserve(n * n);
        for (size_t i = 0; i < n; ++i)
            for (size_t j = 0; j < n; ++j)
                flat.push_back(float(corr[i][j]));
        corr_data_.z.push_back(std::move(flat)); // one slice: the whole fetched window
        real_data_charts_.insert(static_cast<int>(ChartType::Correlation));
        computed << QStringLiteral("Correlation");

        std::vector<double> evals;
        std::vector<std::vector<double>> evecs;
        risk_jacobi_eigen(corr, evals, evecs);
        const size_t kpc = std::min<size_t>(n, 5);
        pca_data_ = {};
        pca_data_.assets = in.assets;
        for (size_t k = 0; k < kpc; ++k) {
            pca_data_.factors.push_back("PC" + std::to_string(k + 1));
            pca_data_.variance_explained.push_back(float(std::max(0.0, evals[k]) / double(n)));
        }
        // Loadings = eigenvector x sqrt(eigenvalue): the correlation of each asset with the
        // component. An eigenvector's sign is arbitrary, so orient every component so its
        // loadings sum positive (PC1 then reads as "the market").
        std::vector<double> sign(kpc, 1.0);
        for (size_t k = 0; k < kpc; ++k) {
            double s = 0.0;
            for (size_t a = 0; a < n; ++a)
                s += evecs[a][k];
            sign[k] = s < 0.0 ? -1.0 : 1.0;
        }
        for (size_t a = 0; a < n; ++a) {
            std::vector<float> row;
            for (size_t k = 0; k < kpc; ++k)
                row.push_back(float(sign[k] * evecs[a][k] * std::sqrt(std::max(0.0, evals[k]))));
            pca_data_.z.push_back(std::move(row));
        }
        real_data_charts_.insert(static_cast<int>(ChartType::PCA));
        computed << QStringLiteral("PCA");
    }

    sync_synthetic_badge();
    if (data_inspector_) {
        QString msg = tr("Computed %1 from %2 symbol(s) x %3 trading days of daily closes.")
                          .arg(computed.join(QStringLiteral(", ")))
                          .arg(n)
                          .arg(nret + 1);
        if (nret < 252)
            msg += tr(" Windows / horizons longer than the sample use all of it.");
        if (nret < 30)
            msg += tr(" The sample is short - widen the date range for stable estimates.");
        data_inspector_->set_status(msg, true);
        if (active_chart_ == ChartType::FactorExposure)
            data_inspector_->set_error(
                tr("Factor exposure needs factor-return series (size, value, momentum ...) that daily closes "
                   "do not carry - this surface is still sample data."));
        else if (active_chart_ == ChartType::BetaSurface && spy >= n)
            data_inspector_->set_error(
                tr("Beta is measured against SPY - add SPY to the basket and fetch again. "
                   "This surface is still sample data."));
        else if (active_chart_ == ChartType::Correlation && n < 2)
            data_inspector_->set_error(tr("Correlation needs at least two symbols in the basket."));
        else if (active_chart_ == ChartType::PCA && n < 2)
            data_inspector_->set_error(tr("PCA needs at least two symbols in the basket."));
    }
}

void SurfaceAnalyticsScreen::on_vol_surface_received(const fincept::DatabentoVolSurfaceResult& r) {
    if (data_inspector_)
        data_inspector_->set_status(r.success ? tr("Vol surface loaded") : tr("Vol fetch failed"), r.success);
    if (!r.success) {
        if (data_inspector_)
            data_inspector_->set_error(r.error);
        update_chart();
        return;
    }

    QString sym = current_symbol_or_default();
    std::string sym_std = sym.toStdString();
    float spot = spot_for(sym);

    // SAFETY: the DEMO badge may only be cleared for grids that were genuinely
    // replaced. A "successful" response can still carry an empty grid for some
    // (or every) surface — clearing the badge unconditionally would relabel
    // untouched rand() sample data as live market data.
    bool replaced_active = false;
    auto note_replaced = [&](ChartType t) {
        real_data_charts_.insert(static_cast<int>(t));
        if (active_chart_ == t)
            replaced_active = true;
    };

    if (!r.vol.z.empty()) {
        vol_data_ = r.vol;
        vol_data_.underlying = sym_std;
        vol_data_.spot_price = spot;
        note_replaced(ChartType::Volatility);
    }
    if (!r.delta.z.empty()) {
        delta_data_ = r.delta;
        delta_data_.underlying = sym_std;
        delta_data_.spot_price = spot;
        note_replaced(ChartType::DeltaSurface);
    }
    if (!r.gamma.z.empty()) {
        gamma_data_ = r.gamma;
        gamma_data_.underlying = sym_std;
        gamma_data_.spot_price = spot;
        note_replaced(ChartType::GammaSurface);
    }
    if (!r.vega.z.empty()) {
        vega_data_ = r.vega;
        vega_data_.underlying = sym_std;
        vega_data_.spot_price = spot;
        note_replaced(ChartType::VegaSurface);
    }
    if (!r.theta.z.empty()) {
        theta_data_ = r.theta;
        theta_data_.underlying = sym_std;
        theta_data_.spot_price = spot;
        note_replaced(ChartType::ThetaSurface);
    }
    if (!r.skew.z.empty()) {
        skew_data_ = r.skew;
        skew_data_.underlying = sym_std;
        note_replaced(ChartType::SkewSurface);
    }
    sync_synthetic_badge();
    if (!replaced_active && data_inspector_)
        data_inspector_->set_error(
            tr("The response carried no grid for the surface on screen — it is still showing sample data."));

    if (data_inspector_) {
        QStringList headers = {"strike", "expiration", "iv"};
        QVector<QStringList> rows;
        for (size_t i = 0; i < vol_data_.strikes.size(); ++i) {
            for (size_t j = 0; j < vol_data_.expirations.size(); ++j) {
                if (i < vol_data_.z.size() && j < vol_data_.z[i].size()) {
                    rows.push_back({QString::number(vol_data_.strikes[i], 'f', 2),
                                    QString::number(vol_data_.expirations[j]),
                                    QString::number(vol_data_.z[i][j], 'f', 4)});
                }
            }
        }
        data_inspector_->show_table("vol_surface", headers, rows);
    }

    update_chart();
    update_metrics();
    update_inspector_lineage();
}

void SurfaceAnalyticsScreen::on_ohlcv_received(const fincept::DatabentoOhlcvResult& r) {
    // The raw bars go to the inspector's table. The DEMO badge is only ever lowered by
    // apply_risk_surfaces() below, and only for the surfaces it actually computed from
    // those bars — everything it does not touch is still rand() sample data.
    if (data_inspector_) {
        data_inspector_->set_status(r.success ? tr("OHLCV loaded") : tr("OHLCV fetch failed"), r.success);
        if (!r.success)
            data_inspector_->set_error(r.error);
        else {
            QStringList headers = {"symbol", "date", "open", "high", "low", "close", "volume"};
            QVector<QStringList> rows;
            for (auto it = r.data.constBegin(); it != r.data.constEnd(); ++it) {
                for (const QJsonObject& bar : it.value()) {
                    rows.push_back({it.key(), bar.value("date").toString(),
                                    QString::number(bar.value("open").toDouble(), 'f', 2),
                                    QString::number(bar.value("high").toDouble(), 'f', 2),
                                    QString::number(bar.value("low").toDouble(), 'f', 2),
                                    QString::number(bar.value("close").toDouble(), 'f', 2),
                                    QString::number(bar.value("volume").toDouble(), 'f', 0)});
                }
            }
            data_inspector_->show_table("ohlcv-1d", headers, rows);
        }
    }
    if (r.success)
        apply_risk_surfaces(r);
    update_chart();
    update_metrics();
    update_inspector_lineage();
}

void SurfaceAnalyticsScreen::on_futures_received(const fincept::DatabentoFuturesResult& r) {
    if (data_inspector_) {
        data_inspector_->set_status(r.success ? tr("Futures curve loaded") : tr("Futures fetch failed"), r.success);
        if (!r.success)
            data_inspector_->set_error(r.error);
    }
    if (r.success) {
        // Only the two grids below come from this response — anything else on
        // screen is still sample data and keeps its DEMO badge.
        if (!r.forward.z.empty())
            real_data_charts_.insert(static_cast<int>(ChartType::CommodityForward));
        if (!r.contango.z.empty())
            real_data_charts_.insert(static_cast<int>(ChartType::ContangoBackwardation));
        if (!r.forward.z.empty())
            cmdty_fwd_data_ = r.forward;
        if (!r.contango.z.empty())
            contango_data_ = r.contango;
        sync_synthetic_badge();
    }
    update_chart();
    update_metrics();
    update_inspector_lineage();
}

void SurfaceAnalyticsScreen::on_surface_received(const fincept::DatabentoSurfaceResult& r) {
    if (data_inspector_) {
        data_inspector_->set_status(r.success ? tr("Surface loaded") : tr("Surface fetch failed"), r.success);
        if (!r.success)
            data_inspector_->set_error(r.error);
    }
    if (!r.success) {
        update_chart();
        return;
    }
    const auto& type = r.type;
    QString sym = current_symbol_or_default();
    std::string sym_std = sym.toStdString();
    float spot = spot_for(sym);

    // Track which surface (if any) this payload actually replaced. `type` can be
    // a value we don't handle, or arrive with an empty grid — in either case
    // nothing on screen changed and the DEMO badge must stay on.
    ChartType replaced = active_chart_;
    bool did_replace = false;
    if (type == "local_vol" && !r.z.empty()) {
        local_vol_data_.strikes.assign(r.x_axis.begin(), r.x_axis.end());
        local_vol_data_.expirations.assign(r.y_axis.begin(), r.y_axis.end());
        local_vol_data_.z = r.z;
        local_vol_data_.underlying = sym_std;
        local_vol_data_.spot_price = spot;
        replaced = ChartType::LocalVolSurface;
        did_replace = true;
    } else if (type == "implied_dividend" && !r.z.empty()) {
        impl_div_data_.strikes.assign(r.x_axis.begin(), r.x_axis.end());
        impl_div_data_.expirations.assign(r.y_axis.begin(), r.y_axis.end());
        impl_div_data_.z = r.z;
        impl_div_data_.underlying = sym_std;
        replaced = ChartType::ImpliedDividend;
        did_replace = true;
    } else if (type == "liquidity" && !r.z.empty()) {
        liquidity_data_.strikes.assign(r.x_axis.begin(), r.x_axis.end());
        liquidity_data_.expirations.assign(r.y_axis.begin(), r.y_axis.end());
        liquidity_data_.z = r.z;
        liquidity_data_.underlying = sym_std;
        replaced = ChartType::LiquidityHeatmap;
        did_replace = true;
    } else if (type == "commodity_vol" && !r.z.empty()) {
        cmdty_vol_data_.strikes.assign(r.x_axis.begin(), r.x_axis.end());
        cmdty_vol_data_.expirations.assign(r.y_axis.begin(), r.y_axis.end());
        cmdty_vol_data_.z = r.z;
        cmdty_vol_data_.commodity = sym_std;
        replaced = ChartType::CommodityVol;
        did_replace = true;
    } else if (type == "crack_spread" && !r.z.empty()) {
        crack_data_.spread_types = r.x_labels;
        crack_data_.contract_months.assign(r.y_axis.begin(), r.y_axis.end());
        crack_data_.z = r.z;
        replaced = ChartType::CrackSpread;
        did_replace = true;
    } else if (type == "stress_test" && !r.z.empty()) {
        stress_data_.scenarios = r.x_labels;
        stress_data_.portfolios = r.y_labels;
        stress_data_.z = r.z;
        replaced = ChartType::StressTestPnL;
        did_replace = true;
    } else if (type == "yield_curve" && !r.z.empty()) {
        // Rows = settlement dates (newest first), columns = maturities in months.
        yield_data_ = {};
        for (float m : r.x_axis)
            yield_data_.maturities.push_back(static_cast<int>(std::lround(m)));
        yield_data_.time_points.assign(r.y_axis.begin(), r.y_axis.end());
        yield_data_.time_labels = r.y_labels;
        yield_data_.z = r.z;
        replaced = ChartType::YieldCurve;
        did_replace = true;
    } else if (type == "forward_rate" && !r.z.empty()) {
        fwd_rate_data_ = {};
        for (float st : r.x_axis)
            fwd_rate_data_.start_tenors.push_back(static_cast<int>(std::lround(st)));
        fwd_rate_data_.forward_periods.assign(r.y_axis.begin(), r.y_axis.end());
        fwd_rate_data_.z = r.z;
        replaced = ChartType::ForwardRate;
        did_replace = true;
    } else if (type == "rate_path" && !r.z.empty()) {
        monetary_data_ = {};
        monetary_data_.central_banks = r.x_labels;
        monetary_data_.meetings_ahead.assign(r.y_axis.begin(), r.y_axis.end());
        monetary_data_.step_labels = r.y_labels;
        monetary_data_.z = r.z;
        replaced = ChartType::MonetaryPolicyPath;
        did_replace = true;
    } else if (type == "fx_forward_points" && !r.z.empty()) {
        fx_fwd_data_ = {};
        fx_fwd_data_.pairs = r.x_labels;
        fx_fwd_data_.tenors.assign(r.y_axis.begin(), r.y_axis.end());
        fx_fwd_data_.tenor_labels = r.y_labels;
        fx_fwd_data_.z = r.z;
        replaced = ChartType::FXForwardPoints;
        did_replace = true;
    }

    if (did_replace)
        real_data_charts_.insert(static_cast<int>(replaced));
    const bool active_is_real = did_replace && replaced == active_chart_;
    sync_synthetic_badge();
    if (!active_is_real && data_inspector_)
        data_inspector_->set_error(
            tr("The response replaced no grid for the surface on screen — it is still showing sample data."));

    update_chart();
    update_metrics();
    update_inspector_lineage();
}

void SurfaceAnalyticsScreen::on_db_fetch_started(const QString& desc) {
    if (data_inspector_)
        data_inspector_->set_status(desc, true);
}

void SurfaceAnalyticsScreen::on_db_fetch_failed(const QString& err) {
    if (data_inspector_) {
        data_inspector_->set_status(tr("Fetch failed"), false);
        data_inspector_->set_error(err);
    }
}

void SurfaceAnalyticsScreen::on_db_connection_tested(bool ok, const QString& msg) {
    if (!control_panel_)
        return;
    control_panel_->set_provider_status("databento", ok ? "connected" : "error", ok ? QString() : msg);
}

void SurfaceAnalyticsScreen::on_db_raw_response(const QString& cmd, const QString& raw_stdout) {
    if (!data_inspector_)
        return;
    QString header = QString("=== %1 ===\n").arg(cmd);
    data_inspector_->set_raw_output(header + raw_stdout);
}

} // namespace fincept::surface