mainwindow.cpp

/**
 * @file mainwindow.cpp
 * @brief Action handlers, collapsible panels, and motion feedback.
 */

#include "mainwindow.h"
#include "offline_worker.h"
#include "shimmer.h"
#include "stretchtitlelabel.h"
#include "ui_mainwindow.h"
#include "qcustomplot.h"
#include "ColorMapEditorDialog.h"
#include "channel_detector.h"
#include "channel_band_item.h"
#include "channel_palette.h"
#include "iq_bandpass_filter.h"
#include "measurement_panel.h"
#include "spectrum_traces.h"
#include <QAbstractItemView>
#include <QApplication>
#include <QHeaderView>
#include <QScrollArea>
#include <QAction>
#include <QCheckBox>
#include <QColor>
#include <QComboBox>
#include <QDialogButtonBox>
#include <QFormLayout>
#include <QInputDialog>
#include <QLineEdit>
#include <QDoubleValidator>
#include <QDoubleSpinBox>
#include <QEasingCurve>
#include <QEvent>
#include <QFileDialog>
#include <QFileInfo>
#include <QFrame>
#include <QGraphicsDropShadowEffect>
#include <QGraphicsOpacityEffect>
#include <QGroupBox>
#include <QIcon>
#include <QKeyEvent>
#include <QGridLayout>
#include <QLayout>
#include <QMutexLocker>
#include <QLabel>
#include <QMenu>
#include <QMessageBox>
#include <QDateTime>
#include <QDialog>
#include <QHBoxLayout>
#include <QVBoxLayout>
#include <QMouseEvent>
#include <QPainter>
#include <QPainterPath>
#include <QPixmap>
#include <QPushButton>
#include <QPropertyAnimation>
#include <QProgressDialog>
#include <QStatusBar>
#include <QSlider>
#include <QSignalBlocker>
#include <QSizePolicy>
#include <QStyle>
#include <QTableWidget>
#include <QTableWidgetItem>
#include <QThread>
#include <QToolButton>
#include <QTimer>

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

namespace {

/**
 * @brief Hanning window for the GUI-thread FFT (x310 / oscilloscope pattern).
 */
float hanningWindow(int i, int n)
{
    if (n <= 1) {
        return 1.0f;
    }
    return static_cast<float>(
        0.5 * (1.0 - std::cos(2.0 * M_PI * static_cast<double>(i) / (n - 1))));
}

constexpr size_t kCircBufSize = 100000;
constexpr size_t kDefaultFftSize = 4096;
const QColor kBrandGreen(0x8F, 0xCB, 0x57);

/** @brief Fixed card shadow; never animated so it stays the same at runtime. */
constexpr qreal kCardShadowBlur = 20.0;
constexpr qreal kCardShadowY = 5.0;
const QColor kCardShadowColor(0, 0, 0, 90);



/** @brief Same locked shadow, tighter so title glyphs stay readable. */
/** @brief Fixed spectrum Y span (dB); do not auto-rescale per frame. */
constexpr double kFreqYMinDb = -120.0;
constexpr double kFreqYMaxDb = 40.0;

constexpr qreal kTitleShadowY = 2.0;

class TitleTextShadowFilter : public QObject
{
public:
    explicit TitleTextShadowFilter(QObject *parent = nullptr)
        : QObject(parent)
    {
    }

protected:
    bool eventFilter(QObject *watched, QEvent *event) override
    {
        if (event->type() != QEvent::Paint) {
            return false;
        }
        auto *label = qobject_cast<QLabel *>(watched);
        if (!label || label->text().isEmpty()) {
            return false;
        }
        // StretchTitleLabel paints its own offset shadow in paintEvent.
        if (label->inherits("StretchTitleLabel")) {
            return false;
        }
        QPainter p(label);
        p.setRenderHint(QPainter::TextAntialiasing, true);
        p.setFont(label->font());
        p.setPen(kCardShadowColor);
        p.drawText(label->rect().translated(0, static_cast<int>(kTitleShadowY)),
                   int(label->alignment()),
                   label->text());
        return false;
    }
};

/**
 * @brief Draws a flat brand-green glyph so command actions are not theme icons.
 * @param name One of reset, play, pause.
 * @return Transparent pixmap icon in `#8FCB57`.
 */
QIcon brandedCommandIcon(const QString &name)
{
    const int s = 128;
    QPixmap pm(s, s);
    pm.fill(Qt::transparent);

    QPainter p(&pm);
    p.setRenderHint(QPainter::Antialiasing, true);
    const QColor fill(kBrandGreen);
    const QColor stroke = fill.darker(118);

    if (name == QLatin1String("play")) {
        QPainterPath tri;
        tri.moveTo(36, 22);
        tri.lineTo(36, 106);
        tri.lineTo(108, 64);
        tri.closeSubpath();
        p.setPen(QPen(stroke, 4.0, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin));
        p.setBrush(fill);
        p.drawPath(tri);
    } else if (name == QLatin1String("pause")) {
        p.setPen(Qt::NoPen);
        p.setBrush(fill);
        p.drawRoundedRect(QRectF(32, 24, 22, 80), 6, 6);
        p.drawRoundedRect(QRectF(74, 24, 22, 80), 6, 6);
    } else {
        // Clockwise circular arrow (reset / refresh).
        p.setBrush(Qt::NoBrush);
        p.setPen(QPen(fill, 12.0, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin));
        p.drawArc(QRectF(24, 24, 80, 80), 50 * 16, 270 * 16);

        QPainterPath head;
        head.moveTo(88, 24);
        head.lineTo(112, 40);
        head.lineTo(78, 48);
        head.closeSubpath();
        p.setPen(Qt::NoPen);
        p.setBrush(fill);
        p.drawPath(head);
    }

    return QIcon(pm);
}

/**
 * @brief Moves the first child layout of a group box into a hideable widget.
 *
 * The .ui file places each QFormLayout directly in the group; collapsible
 * sections need a QWidget so the title stays visible while the fields hide.
 *
 * @param box Checkable section group.
 * @return Body widget owning the original form layout, or nullptr.
 */
QWidget *extractFormBody(QGroupBox *box)
{
    if (!box || !box->layout() || box->layout()->count() == 0) {
        return nullptr;
    }

    QLayoutItem *item = box->layout()->takeAt(0);
    auto *body = new QWidget(box);
    QLayout *inner = item ? item->layout() : nullptr;
    if (inner) {
        body->setLayout(inner);
        // takeAt() returns the QFormLayout itself (QLayout is a QLayoutItem).
        if (item != inner) {
            delete item;
        }
    } else {
        delete item;
    }
    box->layout()->addWidget(body);
    return body;
}

/**
 * @brief Theme icon with a Qt standard-pixmap fallback.
 * @param style Widget style used for the fallback.
 * @param theme Freedesktop icon name.
 * @param fallback Qt standard pixmap.
 * @return Non-null icon when the style provides the pixmap.
 */
QIcon commandIcon(const QStyle *style, const QString &theme, QStyle::StandardPixmap fallback)
{
    const QIcon themed = QIcon::fromTheme(theme);
    if (!themed.isNull()) {
        return themed;
    }
    return style ? style->standardIcon(fallback) : QIcon();
}

} // namespace

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
{
    ui->setupUi(this);

    setupBrandIcon();
    setupCollapsibles();
    setupPlaybackTimers();
    wireActions();
    setupChrome();
    setupPlots();
    setupBodyPanels();
    setupPlotScrollAndChannelTable();
    setupSideDockScroll();
    setupOfflinePipeline();

    ui->editSampleRate->setEnabled(true);
    ui->cmbSampleRateUnit->setCurrentIndex(2); // MHz
    {
        auto *validator = new QDoubleValidator(0.0, 1.0e12, 6, ui->editSampleRate);
        validator->setNotation(QDoubleValidator::StandardNotation);
        ui->editSampleRate->setValidator(validator);
    }

    ui->cmbSourceType->setCurrentIndex(0);
    ui->cmbSourceType->setEnabled(false);

    m_liveApplyEnabled = true;
    wireLiveParams();
    applyLiveParameters();

    statusBar()->showMessage(tr("Ready — parameter changes apply immediately."), 5000);
}

void MainWindow::setupBrandIcon()
{
    // Wayland/GNOME often hide title-bar icons; keep brand mark in the command bar.
    const QPixmap iconPix(QStringLiteral(":/resources/icons/app_icon.png"));
    if (!iconPix.isNull()) {
        ui->lblAppIcon->setPixmap(
            iconPix.scaled(44, 44, Qt::KeepAspectRatio, Qt::SmoothTransformation));
    }
}

void MainWindow::setupCollapsibles()
{
    wireCollapsible(ui->groupSource, extractFormBody(ui->groupSource));
    wireCollapsible(ui->groupCapture, extractFormBody(ui->groupCapture));
    wireCollapsible(ui->groupInterval, extractFormBody(ui->groupInterval));
    wireCollapsible(ui->groupFft, extractFormBody(ui->groupFft));

    ui->groupSource->setChecked(true);
    ui->groupCapture->setChecked(true);
    ui->groupInterval->setChecked(true);
    ui->groupFft->setChecked(true);
}

void MainWindow::setupSideDockScroll()
{
    // Keep docks full-height; let scroll areas shrink contents to the viewport width.
    ui->rootLayout->setStretch(1, 1);
    ui->bodyLayout->setStretch(0, 0); // measurement
    ui->bodyLayout->setStretch(1, 1); // plots
    ui->bodyLayout->setStretch(2, 0); // control

    ui->sideDock->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Expanding);
    ui->sideScroll->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    ui->sideScrollContents->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Minimum);
    ui->sideDockLayout->setStretchFactor(ui->sideScroll, 1);
    ui->sideScroll->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
    ui->sideScroll->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
    ui->sideScroll->setWidgetResizable(true);
}

void MainWindow::setupBodyPanels()
{
    // Designer order is Control | Plots. Reorder to Measurement | Plots | Control
    // and attach the SweepPlots-inspired trace/peak manager to freq_widget.
    m_measurementPanel = new MeasurementPanel(this);
    m_spectrumTraces = new SpectrumTraces(this);
    m_spectrumTraces->attach(ui->freq_widget, m_measurementPanel);

    connect(m_spectrumTraces, &SpectrumTraces::markerReadoutChanged,
            this, &MainWindow::setMarkerReadout);
    connect(m_spectrumTraces, &SpectrumTraces::traceModeLabelChanged,
            this, [this](const QString &modeName) {
                ui->lblBottomVal2->setText(modeName);
                flashLabel(ui->lblBottomVal2);
            });
    connect(m_measurementPanel->buttonChannelizer(), &QPushButton::clicked,
            this, &MainWindow::onChannelizerClicked);
    connect(m_measurementPanel->buttonClearChannels(), &QPushButton::clicked,
            this, &MainWindow::onClearChannelsClicked);
    connect(m_measurementPanel->buttonSelectFilterRange(), &QPushButton::clicked,
            this, &MainWindow::onSelectFilterRangeClicked);
    connect(m_measurementPanel->buttonFilterSave(), &QPushButton::clicked,
            this, &MainWindow::onFilterAndSaveClicked);
    connect(m_measurementPanel->buttonClearFilter(), &QPushButton::clicked,
            this, &MainWindow::onClearFilterClicked);
    ui->freq_widget->installEventFilter(this);

    ui->bodyLayout->removeWidget(ui->sideDock);
    ui->bodyLayout->removeWidget(ui->plotsHost);
    ui->bodyLayout->addWidget(m_measurementPanel, /*stretch=*/0);
    ui->bodyLayout->addWidget(ui->plotsHost, /*stretch=*/1);
    ui->bodyLayout->addWidget(ui->sideDock, /*stretch=*/0);

    applySoftCardShadow(m_measurementPanel);
    QLabel *measTitle = m_measurementPanel->titleLabel();
    if (measTitle) {
        applyTitleShadow(measTitle);
        ShimmerController::markAsTitle(measTitle);
    }
    // Overlay must be installed after the panel exists; markAsTitle alone
    // only sets a property and does not create the shimmer band.
    if (m_shimmer && measTitle) {
        m_shimmer->installOn(measTitle);
        m_shimmer->rescan();
    }
}

void MainWindow::setupPlotScrollAndChannelTable()
{
    auto *results = new QFrame(ui->splitterPlots);
    results->setObjectName(QStringLiteral("plotChannelResults"));
    results->setMinimumHeight(200);
    results->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
    auto *resultsLayout = new QVBoxLayout(results);
    resultsLayout->setContentsMargins(12, 8, 12, 10);
    resultsLayout->setSpacing(6);

    auto *title = new QLabel(tr("Channelizer Results"), results);
    title->setObjectName(QStringLiteral("lblChannelResultsTitle"));
    title->setStyleSheet(
        QStringLiteral("font-size:13px;font-weight:700;color:#111111;font-family:Georgia,serif;"));
    resultsLayout->addWidget(title);

    m_channelResultsTable = new QTableWidget(0, 5, results);
    m_channelResultsTable->setObjectName(QStringLiteral("tblChannels"));
    m_channelResultsTable->setHorizontalHeaderLabels(
        {tr("#"), tr("Start"), tr("Stop"), tr("BW"), tr("Peak")});
    m_channelResultsTable->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
    m_channelResultsTable->horizontalHeader()->setDefaultAlignment(Qt::AlignCenter);
    m_channelResultsTable->horizontalHeader()->setFixedHeight(26);
    m_channelResultsTable->verticalHeader()->setVisible(false);
    m_channelResultsTable->setEditTriggers(QAbstractItemView::NoEditTriggers);
    m_channelResultsTable->setSelectionBehavior(QAbstractItemView::SelectRows);
    m_channelResultsTable->setSelectionMode(QAbstractItemView::SingleSelection);
    m_channelResultsTable->setMinimumHeight(140);
    m_channelResultsTable->setAlternatingRowColors(true);
    m_channelResultsTable->setShowGrid(true);
    m_channelResultsTable->setGridStyle(Qt::SolidLine);
    m_channelResultsTable->verticalHeader()->setDefaultSectionSize(24);
    m_channelResultsTable->setStyleSheet(QStringLiteral(
        "QTableWidget {"
        "  border: 1px solid #C8D5C8;"
        "  border-radius: 4px;"
        "  background: #FAFCFA;"
        "  alternate-background-color: #EDF4ED;"
        "  gridline-color: #D5E0D5;"
        "  font-size: 12px;"
        "}"
        "QTableWidget::item {"
        "  padding: 2px 6px;"
        "  border: none;"
        "}"
        "QTableWidget::item:selected {"
        "  background: #4A8A5A;"
        "  color: #FFFFFF;"
        "}"
        "QHeaderView::section {"
        "  background: #2E6040;"
        "  color: #FFFFFF;"
        "  font-weight: 700;"
        "  font-size: 12px;"
        "  padding: 4px;"
        "  border: none;"
        "  border-right: 1px solid #3D7A50;"
        "  border-bottom: 1px solid #1E4030;"
        "}"
        "QHeaderView::section:last {"
        "  border-right: none;"
        "}"));
    resultsLayout->addWidget(m_channelResultsTable, 1);
    ui->splitterPlots->addWidget(results);

    ui->plotTime->setMinimumHeight(280);
    ui->plotSpectrum->setMinimumHeight(280);
    ui->plotWaterfall->setMinimumHeight(280);
    ui->iq_widget->setMinimumHeight(200);
    ui->freq_widget->setMinimumHeight(200);
    ui->waterfall_widget->setMinimumHeight(200);
    ui->splitterPlots->setMinimumHeight(280 * 3 + 220);

    auto *scroll = new QScrollArea(ui->plotsHost);
    scroll->setObjectName(QStringLiteral("plotsScroll"));
    scroll->setFrameShape(QFrame::NoFrame);
    scroll->setWidgetResizable(true);
    scroll->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
    scroll->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
    scroll->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);

    ui->plotsHostLayout->removeWidget(ui->splitterPlots);
    scroll->setWidget(ui->splitterPlots);
    ui->plotsHostLayout->addWidget(scroll);
}

void MainWindow::setupPlaybackTimers()
{
    m_blinkTimer = new QTimer(this);
    m_blinkTimer->setInterval(450);
    connect(m_blinkTimer, &QTimer::timeout, this, &MainWindow::onBlinkTick);

    m_plotTimer = new QTimer(this);
    m_plotTimer->setTimerType(Qt::PreciseTimer);
    m_plotTimer->setSingleShot(false);
    connect(m_plotTimer, &QTimer::timeout, this, &MainWindow::onPlotSweepTick);

    m_channelAnimTimer = new QTimer(this);
    m_channelAnimTimer->setInterval(33);
    connect(m_channelAnimTimer, &QTimer::timeout, this, &MainWindow::onChannelAnimTick);

    ui->lblActivityDot->setStyleSheet(QStringLiteral("color:#C5D0C2;"));
}

void MainWindow::setupChrome()
{
    for (QWidget *card : {static_cast<QWidget *>(ui->commandBar),
                          static_cast<QWidget *>(ui->sideDock),
                          static_cast<QWidget *>(ui->bottomReadout)}) {
        applySoftCardShadow(card);
    }

    const QSize iconSz(28, 28);
    ui->btnPlay->setIcon(brandedCommandIcon(QStringLiteral("play")));
    ui->btnPlay->setToolTip(tr("Play"));
    ui->btnResetParams->setIcon(brandedCommandIcon(QStringLiteral("reset")));
    ui->btnBrowseSource->setIcon(commandIcon(style(), QStringLiteral("document-open"),
                                             QStyle::SP_DirOpenIcon));
    for (QPushButton *btn : {ui->btnPlay, ui->btnResetParams}) {
        btn->setIconSize(iconSz);
        btn->setFlat(true);
        btn->setText(QString());
        btn->setFocusPolicy(Qt::NoFocus);
        btn->setGraphicsEffect(nullptr);
    }
    ui->btnBrowseSource->setIconSize(QSize(18, 18));

    for (QWidget *title : {static_cast<QWidget *>(ui->lblAppTitle),
                           static_cast<QWidget *>(ui->lblDockTitle),
                           static_cast<QWidget *>(ui->lblPlotTimeTitle),
                           static_cast<QWidget *>(ui->lblPlotSpectrumTitle),
                           static_cast<QWidget *>(ui->lblPlotWaterfallTitle)}) {
        applyTitleShadow(title);
        ShimmerController::markAsTitle(title);
    }
    ShimmerController::markAsTitle(ui->lblAppIcon);
    m_shimmer = new ShimmerController(this, this);
}

void MainWindow::stylePlot(QCustomPlot *plot)
{
    plot->setAttribute(Qt::WA_OpaquePaintEvent, true);
    plot->setNotAntialiasedElements(QCP::aeAll);
    plot->setBackground(QColor(QStringLiteral("#FFFFFF")));
    plot->axisRect()->setBackground(QColor(QStringLiteral("#FAFCFA")));
    plot->xAxis->setBasePen(QPen(QColor(QStringLiteral("#9AA39A"))));
    plot->yAxis->setBasePen(QPen(QColor(QStringLiteral("#9AA39A"))));
    plot->xAxis->setTickPen(QPen(QColor(QStringLiteral("#9AA39A"))));
    plot->yAxis->setTickPen(QPen(QColor(QStringLiteral("#9AA39A"))));
    plot->xAxis->setSubTickPen(QPen(QColor(QStringLiteral("#D9E2D7"))));
    plot->yAxis->setSubTickPen(QPen(QColor(QStringLiteral("#D9E2D7"))));
    plot->xAxis->setTickLabelColor(QColor(QStringLiteral("#333333")));
    plot->yAxis->setTickLabelColor(QColor(QStringLiteral("#333333")));
    plot->xAxis->setLabelColor(QColor(QStringLiteral("#555555")));
    plot->yAxis->setLabelColor(QColor(QStringLiteral("#555555")));
    plot->xAxis->grid()->setPen(QPen(QColor(QStringLiteral("#E4EBE2")), 1, Qt::DotLine));
    plot->yAxis->grid()->setPen(QPen(QColor(QStringLiteral("#E4EBE2")), 1, Qt::DotLine));
    plot->setInteractions(QCP::iNone);
}

void MainWindow::setupPlots()
{
    stylePlot(ui->iq_widget);
    stylePlot(ui->freq_widget);
    stylePlot(ui->waterfall_widget);

    ui->iq_widget->addGraph();
    ui->iq_widget->graph(0)->setPen(QPen(QColor(QStringLiteral("#111111")), 1));
    ui->iq_widget->graph(0)->setAdaptiveSampling(true);
    ui->iq_widget->addGraph();
    ui->iq_widget->graph(1)->setPen(QPen(QColor(QStringLiteral("#3D7A9A")), 1));
    ui->iq_widget->graph(1)->setAdaptiveSampling(true);
    ui->iq_widget->xAxis->setLabel(QStringLiteral("Time (ms)"));
    ui->iq_widget->yAxis->setLabel(QStringLiteral("Amplitude"));
    ui->iq_widget->xAxis->setRange(0, 1);
    ui->iq_widget->yAxis->setRange(-1, 1);

    // Frequency graphs are owned by SpectrumTraces (6 traces × primary/secondary/peaks).
    ui->freq_widget->xAxis->setLabel(QStringLiteral("Frequency (Hz)"));
    ui->freq_widget->yAxis->setLabel(QStringLiteral("Power (dB)"));
    ui->freq_widget->xAxis->setRange(0, 1e6);
    ui->freq_widget->yAxis->setRange(kFreqYMinDb, kFreqYMaxDb);

    m_waterfallMap = new QCPColorMap(ui->waterfall_widget->xAxis, ui->waterfall_widget->yAxis);
    m_waterfallMap->setGradient(QCPColorGradient::gpSpectrum);
    m_waterfallMap->setInterpolate(false);
    m_waterfallMap->data()->setSize(256, static_cast<int>(m_waterfallHistory));
    m_waterfallMap->data()->setRange(QCPRange(0, 1e6),
                                     QCPRange(0, static_cast<double>(m_waterfallHistory - 1)));
    m_waterfallMap->data()->fill(m_wfColorMin);
    m_waterfallMap->setDataRange(QCPRange(m_wfColorMin, m_wfColorMax));
    ui->waterfall_widget->xAxis->setLabel(QStringLiteral("Frequency (Hz)"));
    ui->waterfall_widget->yAxis->setLabel(QStringLiteral("History"));
    ui->waterfall_widget->yAxis->setRangeReversed(true);

    setupPlotInteractions();

    ui->iq_widget->replot();
    ui->freq_widget->replot();
    ui->waterfall_widget->replot();
}

MainWindow::~MainWindow()
{
    stopOfflineWorker();
    destroyGuiFftPlan();

    delete m_timeBuffer;
    m_timeBuffer = nullptr;
    delete m_offlineParams;
    m_offlineParams = nullptr;

    delete ui;
}

void MainWindow::applySoftCardShadow(QWidget *widget)
{
    if (!widget) {
        return;
    }

    auto *shadow = qobject_cast<QGraphicsDropShadowEffect *>(widget->graphicsEffect());
    if (!shadow) {
        shadow = new QGraphicsDropShadowEffect(widget);
        widget->setGraphicsEffect(shadow);
    }
    shadow->setBlurRadius(kCardShadowBlur);
    shadow->setOffset(0.0, kCardShadowY);
    shadow->setColor(kCardShadowColor);
    shadow->setEnabled(true);
}

void MainWindow::applyCtaButtonShadow(QWidget *widget)
{
    applySoftCardShadow(widget);
}

void MainWindow::applyTitleShadow(QWidget *widget)
{
    if (!widget) {
        return;
    }

    // Blur-based QGraphicsDropShadowEffect is recomputed on every plot
    // replot and makes realtime feel sluggish. Paint a cheap offset copy
    // instead so the look stays the same while playing.
    widget->setGraphicsEffect(nullptr);
    if (qobject_cast<StretchTitleLabel *>(widget)) {
        return;
    }
    widget->installEventFilter(new TitleTextShadowFilter(widget));
}

void MainWindow::wireCollapsible(QGroupBox *box, QWidget *body)
{
    if (!box || !body) {
        return;
    }

    box->setCheckable(true);
    connect(box, &QGroupBox::toggled, body, &QWidget::setVisible);
    connect(box, &QGroupBox::toggled, this, [body, box](bool on) {
        if (!on) {
            // Opacity effects left on layout bodies cause Wayland ghosting/hover glitches.
            body->setGraphicsEffect(nullptr);
            return;
        }
        auto *fx = new QGraphicsOpacityEffect(body);
        body->setGraphicsEffect(fx);
        auto *fade = new QPropertyAnimation(fx, "opacity", body);
        fade->setDuration(220);
        fade->setStartValue(0.15);
        fade->setEndValue(1.0);
        fade->setEasingCurve(QEasingCurve::OutCubic);
        // Remove the effect when done: a permanent QGraphicsEffect on a layout body
        // breaks hover painting and leaves ghost strips (especially on Wayland).
        QObject::connect(fade, &QAbstractAnimation::finished, body, [body]() {
            body->setGraphicsEffect(nullptr);
        });
        fade->start(QAbstractAnimation::DeleteWhenStopped);
    });
    body->setVisible(box->isChecked());
}

void MainWindow::wireActions()
{
    connect(ui->actionOpenSignal, &QAction::triggered, this, &MainWindow::openSignal);
    connect(ui->actionResetParams, &QAction::triggered, this, &MainWindow::resetParameters);
    connect(ui->actionPlay, &QAction::triggered, this, &MainWindow::playAnalysis);
    connect(ui->actionPause, &QAction::triggered, this, &MainWindow::pauseAnalysis);
    connect(ui->actionExit, &QAction::triggered, this, &QWidget::close);
    connect(ui->actionExpandAll, &QAction::triggered, this, &MainWindow::expandAllSections);
    connect(ui->actionCollapseAll, &QAction::triggered, this, &MainWindow::collapseAllSections);

    connect(ui->actionMaxPeak, &QAction::triggered, this, &MainWindow::peakMax);
    connect(ui->actionMinPeak, &QAction::triggered, this, &MainWindow::peakMin);
    connect(ui->actionSearchPeak, &QAction::triggered, this, &MainWindow::peakSearch);
    connect(ui->actionNextPeak, &QAction::triggered, this, &MainWindow::peakNext);
    connect(ui->actionLeftPeak, &QAction::triggered, this, &MainWindow::peakLeft);
    connect(ui->actionRightPeak, &QAction::triggered, this, &MainWindow::peakRight);

    connect(ui->btnBrowseSource, &QToolButton::clicked, this, &MainWindow::openSignal);
    connect(ui->btnResetParams, &QPushButton::clicked, this, &MainWindow::resetParameters);
    connect(ui->btnPlay, &QPushButton::clicked, this, &MainWindow::togglePlayback);
    connect(ui->sliderTimeProgress, &QSlider::sliderPressed, this, [this]() {
        m_timeSliderHeld = true;
    });
    connect(ui->sliderTimeProgress, &QSlider::sliderReleased, this, [this]() {
        m_timeSliderHeld = false;
        onTimeSliderReleased();
    });
    connect(ui->sliderTimeProgress, &QAbstractSlider::actionTriggered, this,
            [this](int action) {
                if (action == QAbstractSlider::SliderNoAction) {
                    return;
                }
                QTimer::singleShot(0, this, [this]() {
                    if (!m_timeSliderHeld) {
                        onTimeSliderReleased();
                    }
                });
            });

    ui->lbl_chkAutoRepeat->setBuddy(ui->chkAutoRepeat);
    connect(ui->chkAutoRepeat, &QCheckBox::toggled, this, [this](bool checked) {
        if (m_offlineParams) {
            QMutexLocker lock(&m_offlineParams->mutex);
            m_offlineParams->autoRepeat = checked;
        }
        if (m_offlineWorker) {
            m_offlineWorker->setAutoRepeat(checked);
        }
    });
}

void MainWindow::wireLiveParams()
{
    // Debounce rapid spin/combo changes (especially RBW) so the GUI thread
    // does not run configurePlotsForOffline on every intermediate value.
    m_liveParamsDebounce = new QTimer(this);
    m_liveParamsDebounce->setSingleShot(true);
    m_liveParamsDebounce->setInterval(150);
    connect(m_liveParamsDebounce, &QTimer::timeout, this, &MainWindow::applyLiveParameters);

    const auto scheduleApply = [this]() {
        if (m_liveParamsDebounce) {
            m_liveParamsDebounce->start();
        }
    };

    for (QDoubleSpinBox *spin : findChildren<QDoubleSpinBox *>()) {
        connect(spin, &QDoubleSpinBox::valueChanged, this, scheduleApply);
    }
    for (QComboBox *combo : findChildren<QComboBox *>()) {
        connect(combo, QOverload<int>::of(&QComboBox::currentIndexChanged), this, scheduleApply);
    }
    for (QCheckBox *box : findChildren<QCheckBox *>()) {
        connect(box, &QCheckBox::toggled, this, scheduleApply);
    }
    for (QLineEdit *edit : findChildren<QLineEdit *>()) {
        connect(edit, &QLineEdit::editingFinished, this, scheduleApply);
    }
}

void MainWindow::animateButtonPress(QWidget *button)
{
    if (!button) {
        return;
    }

    const QRect start = button->geometry();
    const QRect pressed(start.x() + 2, start.y() + 2, start.width() - 4, start.height() - 4);

    auto *anim = new QPropertyAnimation(button, "geometry", button);
    anim->setDuration(160);
    anim->setKeyValueAt(0.0, start);
    anim->setKeyValueAt(0.45, pressed);
    anim->setKeyValueAt(1.0, start);
    anim->setEasingCurve(QEasingCurve::OutBack);
    anim->start(QAbstractAnimation::DeleteWhenStopped);
}

void MainWindow::flashLabel(QWidget *label)
{
    if (!label) {
        return;
    }
    // Replace any previous opacity effect so a cancelled flash cannot leave
    // SIGNAL/TRACE looking blank.
    label->setGraphicsEffect(nullptr);
    auto *fx = new QGraphicsOpacityEffect(label);
    label->setGraphicsEffect(fx);
    auto *fade = new QPropertyAnimation(fx, "opacity", label);
    fade->setDuration(350);
    fade->setKeyValueAt(0.0, 0.2);
    fade->setKeyValueAt(0.5, 1.0);
    fade->setKeyValueAt(1.0, 1.0);
    fade->setEasingCurve(QEasingCurve::OutCubic);
    fade->start(QAbstractAnimation::DeleteWhenStopped);
}

void MainWindow::refreshBottomSignalName()
{
    QString path = m_signalPath.trimmed();
    if (path.isEmpty() && ui->editSourceFile) {
        path = ui->editSourceFile->text().trimmed();
        if (!path.isEmpty()) {
            m_signalPath = path;
        }
    }

    const QString name = path.isEmpty() ? tr("—") : QFileInfo(path).fileName();
    if (ui->lblBottomVal1) {
        ui->lblBottomVal1->setGraphicsEffect(nullptr);
        ui->lblBottomVal1->setText(name);
        ui->lblBottomVal1->setToolTip(path);
    }
    // Keep TRACE filled whenever we refresh the bottom strip.
    if (ui->lblBottomVal2 && m_spectrumTraces) {
        const QString mode = m_spectrumTraces->currentTraceModeName();
        if (!mode.isEmpty()) {
            ui->lblBottomVal2->setGraphicsEffect(nullptr);
            ui->lblBottomVal2->setText(mode);
        }
    }
}

void MainWindow::openSignal()
{
    animateButtonPress(ui->btnBrowseSource);
    raise();
    activateWindow();
    QFileDialog dlg(this, tr("Open Signal"));
    dlg.setOption(QFileDialog::DontUseNativeDialog, true);
    dlg.setFileMode(QFileDialog::ExistingFile);
    dlg.setNameFilter(tr("Signal files (*.wav *.bin *.iq *.csv *.dat *.sig);;All files (*)"));
    dlg.setWindowModality(Qt::WindowModal);
    dlg.setMinimumSize(780, 520);
    const int dlgCode = dlg.exec();
    const QString path = (dlgCode == QDialog::Accepted) ? dlg.selectedFiles().value(0) : QString();
    if (path.isEmpty()) {
        return;
    }

    const QString prevPath = m_signalPath;
    m_signalPath = path;
    ui->editSourceFile->setText(path);
    refreshBottomSignalName();
    flashLabel(ui->lblBottomVal1);
    statusBar()->showMessage(tr("Signal opened: %1").arg(path), 5000);
    if (path != prevPath) {
        discardOfflineSession();
    }
    applyLiveParameters();
    {
        const QSignalBlocker blocker(ui->sliderTimeProgress);
        ui->sliderTimeProgress->setValue(0);
    }
    ui->sliderTimeProgress->setToolTip(tr("How much of the signal has been displayed"));
    playAnalysis();
}

void MainWindow::applyParameters()
{
    const QString summary =
        tr("%1 | fc=%2 %3 | RBW=%4 %5 | gain=%6 | %7")
            .arg(ui->cmbSourceType->currentText())
            .arg(ui->spinCenter->value(), 0, 'f', 3)
            .arg(ui->cmbCenterUnit->currentText())
            .arg(ui->spinRbw->value(), 0, 'f', 3)
            .arg(ui->cmbRbwUnit->currentText())
            .arg(ui->spinSourceGain->value(), 0, 'f', 2)
            .arg(ui->cmbFileSampleType->currentText());

    ui->lblBottomVal4->setText(summary);
    ui->lblPlotSpectrumMeta->setText(
        tr("Center %1 %2")
            .arg(ui->spinCenter->value(), 0, 'f', 3)
            .arg(ui->cmbCenterUnit->currentText()));
    flashLabel(ui->lblBottomVal4);
    flashLabel(ui->lblPlotSpectrumMeta);
    applyLiveParameters();
    statusBar()->showMessage(tr("Parameters applied."), 3000);
}

void MainWindow::resetParameters()
{
    animateButtonPress(ui->btnResetParams);
    m_liveApplyEnabled = false;

    ui->cmbSourceType->setCurrentIndex(0);
    ui->cmbSourceType->setEnabled(false);
    ui->spinSourceGain->setValue(0.70);
    ui->spinSignalFreq->setValue(100.0);
    ui->cmbSignalFreqUnit->setCurrentIndex(0);
    ui->cmbFileSampleType->setCurrentIndex(0);
    ui->chkAutoRepeat->setChecked(true);

    ui->spinRefLevel->setValue(-20.0);
    ui->cmbRefLevelUnit->setCurrentIndex(0);
    ui->spinCenter->setValue(100.0);
    ui->cmbCenterUnit->setCurrentIndex(2);
    ui->spinStep->setValue(1.0);
    ui->cmbStepUnit->setCurrentIndex(0);
    ui->editSampleRate->setText(QStringLiteral("40"));
    ui->cmbSampleRateUnit->setCurrentIndex(2);
    ui->editSampleRate->setEnabled(true);
    ui->spinIfBw->setValue(-1.0);
    ui->cmbIfBwUnit->setCurrentIndex(0);
    ui->chkAutoIfBw->setChecked(true);
    ui->spinSwpTime->setValue(200.0);
    ui->cmbSwpTimeUnit->setCurrentIndex(1);

    ui->chkAutoInterval->setChecked(true);
    ui->spinIntervalOffset->setValue(0.0);
    ui->cmbIntervalOffsetUnit->setCurrentIndex(0);
    ui->spinIntervalLength->setValue(0.0);
    ui->cmbIntervalLengthUnit->setCurrentIndex(0);

    ui->chkAutoOverlap->setChecked(true);
    ui->spinOverlap->setValue(98.999);
    ui->spinMaxFft->setValue(1000.0);
    ui->spinStepLength->setValue(3.775);
    ui->cmbStepLengthUnit->setCurrentIndex(0);

    m_liveApplyEnabled = true;
    syncRbwSpinFromFftSize(kDefaultFftSize);
    applyLiveParameters();

    flashLabel(ui->lblBottomVal2);
    statusBar()->showMessage(tr("Parameters reset to defaults."), 3000);
}

void MainWindow::playAnalysis()
{
    animateButtonPress(ui->btnPlay);
    applyParameters();
    refreshBottomSignalName();

    if (m_signalPath.isEmpty()) {
        QMessageBox::warning(this, tr("No signal"),
                             tr("Please select a signal file before playing."));
        return;
    }

    const bool sameWorkerFile = m_offlineWorker && (m_workerFilePath == m_signalPath);
    if (m_offlineWorker && m_offlinePaused && sameWorkerFile) {
        m_offlineWorker->setPaused(false);
        m_offlinePaused = false;
        setPlayingUi(true);
        schedulePlotTick(sweepTimeToMs());
        statusBar()->showMessage(tr("Resumed offline playback."), 3000);
        return;
    }

    if (m_playing && m_offlineWorker && m_offlineWorker->isRunning()) {
        return;
    }

    try {
        fillOfflineParamsFromUi();
        {
            QMutexLocker lock(&m_offlineParams->mutex);
            m_fftSize = m_offlineParams->fftSize;
        }

        const size_t cap = std::max(kCircBufSize, m_fftSize * 16);
        m_timeBuffer->set_capacity(cap);
        configurePlotsForOffline();
        rebuildGuiFftPlan();

        stopOfflineWorker();

        m_offlineWorker = new OfflineWorker();
        m_offlineThread = new QThread();
        m_offlineWorker->moveToThread(m_offlineThread);

        connect(m_offlineWorker, &OfflineWorker::errorOccurred,
                this, &MainWindow::onOfflineError);
        connect(m_offlineWorker, &OfflineWorker::finished,
                this, &MainWindow::onOfflineFinished);

        connect(this, &MainWindow::startOfflineThread, m_offlineWorker,
                [this]() {
                    m_offlineWorker->runOffline(m_offlineParams, m_timeBuffer);
                });

        const int sweepMs = sweepTimeToMs();
        size_t hop = 0;
        {
            QMutexLocker lock(&m_offlineParams->mutex);
            hop = m_offlineParams->hopSamples;
        }

        m_offlineThread->start();
        if (m_pendingSeekBytes >= 0) {
            m_offlineWorker->requestSeek(m_pendingSeekBytes);
            m_pendingSeekBytes = -1;
        }
        emit startOfflineThread();

        m_offlinePaused = false;
        setPlayingUi(true);
        m_waitingForPaint = false;
        schedulePlotTick(sweepMs);
        m_lastAppliedSweepMs = sweepMs;
        m_lastAppliedFftSize = m_fftSize;
        m_lastAppliedHop = hop;
        m_workerFilePath = m_signalPath;
        statusBar()->showMessage(tr("Offline playback started."), 3000);
    } catch (const std::exception &ex) {
        QMessageBox::warning(this, tr("Exception"),
                             tr("Cannot start offline playback:\n%1").arg(ex.what()));
    } catch (...) {
        QMessageBox::warning(this, tr("Exception"),
                             tr("Invalid input parameters. Check the file, sample rate, and type."));
    }
}

void MainWindow::pauseAnalysis()
{
    animateButtonPress(ui->btnPlay);

    if (m_offlineWorker) {
        m_offlineWorker->setPaused(true);
    }
    m_offlinePaused = true;
    m_waitingForPaint = false;
    if (m_plotTimer) {
        m_plotTimer->stop();
    }

    setPlayingUi(false);
    ui->lblPlotTimeMeta->setText(tr("PAUSED"));
    ui->lblPlotWaterfallMeta->setText(tr("PAUSED"));
    flashLabel(ui->lblPlotTimeMeta);
    statusBar()->showMessage(tr("Paused."), 3000);
}

void MainWindow::togglePlayback()
{
    if (m_playing) {
        pauseAnalysis();
    } else {
        playAnalysis();
    }
}

void MainWindow::onBlinkTick()
{
    m_blinkOn = !m_blinkOn;
    ui->lblActivityDot->setVisible(m_blinkOn);
}

void MainWindow::expandAllSections()
{
    ui->groupSource->setChecked(true);
    ui->groupCapture->setChecked(true);
    ui->groupInterval->setChecked(true);
    ui->groupFft->setChecked(true);
}

void MainWindow::collapseAllSections()
{
    ui->groupSource->setChecked(false);
    ui->groupCapture->setChecked(false);
    ui->groupInterval->setChecked(false);
    ui->groupFft->setChecked(false);
}

void MainWindow::setMarkerReadout(const QString &mode, double freqHz, double ampDb)
{
    ui->lblBottomVal3->setText(mode);
    ui->lblBottomVal4->setText(tr("%1 Hz   %2 dB").arg(freqHz, 0, 'f', 1).arg(ampDb, 0, 'f', 1));
    flashLabel(ui->lblBottomVal3);
    flashLabel(ui->lblBottomVal4);
    statusBar()->showMessage(tr("%1 → %2 Hz, %3 dB").arg(mode).arg(freqHz, 0, 'f', 1).arg(ampDb, 0, 'f', 1),
                             2500);
}

void MainWindow::peakMax()
{
    if (m_spectrumTraces) {
        m_spectrumTraces->peakSearchMax();
    }
}

void MainWindow::peakMin()
{
    if (m_spectrumTraces) {
        m_spectrumTraces->peakSearchMin();
    }
}

void MainWindow::peakSearch()
{
    if (m_spectrumTraces) {
        m_spectrumTraces->peakSearchMax();
    }
}

void MainWindow::peakNext()
{
    if (m_spectrumTraces) {
        m_spectrumTraces->nextPeak();
    }
}

void MainWindow::peakLeft()
{
    if (m_spectrumTraces) {
        m_spectrumTraces->peakLeft();
    }
}

void MainWindow::peakRight()
{
    if (m_spectrumTraces) {
        m_spectrumTraces->peakRight();
    }
}

void MainWindow::setupOfflinePipeline()
{
    m_offlineParams = new OfflineParams();
    m_timeBuffer = new ThreadSafeBuffer<std::complex<float>>(kCircBufSize);
}

void MainWindow::fillOfflineParamsFromUi()
{
    if (!ui->editSourceFile->text().trimmed().isEmpty()) {
        m_signalPath = ui->editSourceFile->text().trimmed();
    }

    QMutexLocker lock(&m_offlineParams->mutex);
    m_offlineParams->fileName = m_signalPath;
    m_offlineParams->sampleRate = sampleRateFromCombo();
    m_offlineParams->fileType = ui->cmbFileSampleType->currentText().trimmed();
    m_offlineParams->centerFreq =
        valueToHz(ui->spinCenter->value(), ui->cmbCenterUnit->currentText());
    m_offlineParams->fftSize = fftSizeFromUi();
    m_offlineParams->hopSamples = hopSamplesFromUi(m_offlineParams->fftSize);
    m_offlineParams->autoRepeat = ui->chkAutoRepeat->isChecked();
    if (m_offlineWorker) {
        m_offlineWorker->setAutoRepeat(m_offlineParams->autoRepeat);
    }
    // Keep SIGNAL strip in sync whenever params are pulled from the UI.
    refreshBottomSignalName();
}

void MainWindow::applyLiveParameters()
{
    if (!m_liveApplyEnabled || !m_offlineParams) {
        return;
    }

    // Write params under mutex only. Never pause the worker from the GUI
    // thread; the worker rereads fftSize/hop each loop and rebuilds FFTW.
    fillOfflineParamsFromUi();

    size_t fftSize = 0;
    size_t hop = 0;
    {
        QMutexLocker lock(&m_offlineParams->mutex);
        fftSize = m_offlineParams->fftSize;
        hop = m_offlineParams->hopSamples;
    }

    const bool fftChanged = (fftSize != m_lastAppliedFftSize);
    const bool workerRunning = m_offlineWorker && m_offlineWorker->isRunning();

    m_fftSize = fftSize;
    const int sweepMs = sweepTimeToMs();

    // x310-style: pause the plot timer while FFT-dependent axes resize.
    bool restartPlotTimer = false;
    if (fftChanged && m_plotTimer && m_plotTimer->isActive()) {
        m_plotTimer->stop();
        restartPlotTimer = true;
    }

    if (m_plotTimer) {
        m_plotTimer->setInterval(sweepMs);
    }

    m_lastAppliedSweepMs = sweepMs;
    m_lastAppliedFftSize = fftSize;
    m_lastAppliedHop = hop;


    if (fftChanged && workerRunning && m_timeBuffer) {
        m_timeBuffer->clear();
        m_waterfallFrameCounter = 0;
        rebuildGuiFftPlan();
    }

    if (fftChanged && !workerRunning) {
        const size_t cap = std::max(kCircBufSize, fftSize * 16);
        m_timeBuffer->set_capacity(cap);
        configurePlotsForOffline();
        rebuildGuiFftPlan();
    } else if (fftChanged) {
        configurePlotsForOffline();
        rebuildGuiFftPlan();
    } else {
        const double fs = sampleRateFromCombo();
        const double fc =
            valueToHz(ui->spinCenter->value(), ui->cmbCenterUnit->currentText());
        const double tMaxMs = (fs > 0.0) ? (static_cast<double>(fftSize) / fs * 1000.0) : 1.0;
        const double fMin = fc - fs * 0.5;
        const double fMax = fc + fs * 0.5;
        if (!m_timeAxesUserZoomed) {
            ui->iq_widget->xAxis->setRange(0.0, tMaxMs);
        }
        ui->freq_widget->xAxis->setRange(fMin, fMax);
        if (m_waterfallMap) {
            m_waterfallMap->data()->setRange(
                QCPRange(fMin, fMax),
                QCPRange(0.0, static_cast<double>(m_waterfallHistory - 1)));
            m_waterfallMap->setDataRange(QCPRange(m_wfColorMin, m_wfColorMax));
            ui->waterfall_widget->xAxis->setRange(fMin, fMax);
        }
        rebuildAxisCache();
    }

    if (restartPlotTimer && m_playing && !m_offlinePaused) {
        schedulePlotTick(sweepMs);
    }

    // Always sync RBW display: covers fftSize change AND fs change with same fftSize.
    syncRbwSpinFromFftSize(fftSize);

    ui->lblBottomVal4->setText(
        tr("%1 | fc=%2 %3 | RBW=%4 %5 | gain=%6 | %7")
            .arg(ui->cmbSourceType->currentText())
            .arg(ui->spinCenter->value(), 0, 'f', 3)
            .arg(ui->cmbCenterUnit->currentText())
            .arg(ui->spinRbw->value(), 0, 'f', 3)
            .arg(ui->cmbRbwUnit->currentText())
            .arg(ui->spinSourceGain->value(), 0, 'f', 2)
            .arg(ui->cmbFileSampleType->currentText()));
    ui->lblPlotSpectrumMeta->setText(
        tr("Center %1 %2")
            .arg(ui->spinCenter->value(), 0, 'f', 3)
            .arg(ui->cmbCenterUnit->currentText()));
}

void MainWindow::stopOfflineWorker()
{
    if (m_plotTimer) {
        m_plotTimer->stop();
    }

    m_waitingForPaint = false;
    disconnect(this, &MainWindow::startOfflineThread, nullptr, nullptr);

    if (m_offlineWorker) {
        disconnect(m_offlineWorker, nullptr, this, nullptr);
        m_offlineWorker->requestStop();
    }

    if (m_offlineThread) {
        m_offlineThread->quit();
        if (!m_offlineThread->wait(3000)) {
            m_offlineThread->terminate();
            m_offlineThread->wait(1000);
        }
    }

    if (m_offlineWorker) {
        delete m_offlineWorker;
        m_offlineWorker = nullptr;
    }

    delete m_offlineThread;
    m_offlineThread = nullptr;
    m_offlinePaused = false;
    m_workerFilePath.clear();
}

void MainWindow::discardOfflineSession()
{
    stopOfflineWorker();
    if (m_timeBuffer) {
        m_timeBuffer->clear();
    }
    resetPlotsForSeek();
    if (m_spectrumTraces) {
        m_spectrumTraces->clearCurrentTrace();
    }
    clearChannelizerOverlays();
    m_pendingSeekBytes = -1;
}

void MainWindow::rebuildAxisCache()
{
    if (!m_offlineParams || m_fftSize == 0) {
        return;
    }

    const double fs = m_offlineParams->sampleRate;
    const double fc = m_offlineParams->centerFreq;
    const double dt = (fs > 0.0) ? (1.0 / fs) : 1.0;
    const double fMin = fc - fs * 0.5;
    const double df = (fs > 0.0) ? (fs / static_cast<double>(m_fftSize)) : 1.0;

    m_cachedTAxis.resize(static_cast<int>(m_fftSize));
    m_cachedFAxis.resize(static_cast<int>(m_fftSize));
    for (size_t n = 0; n < m_fftSize; ++n) {
        const int idx = static_cast<int>(n);
        m_cachedTAxis[idx] = static_cast<double>(n) * dt;
        m_cachedFAxis[idx] = fMin + static_cast<double>(n) * df;
    }
    m_cachedAxisFftSize = m_fftSize;
}

void MainWindow::syncRbwSpinFromFftSize(size_t fftSize)
{
    if (!ui->spinRbw || !ui->cmbRbwUnit || fftSize == 0) {
        return;
    }

    const double fs = sampleRateFromCombo();
    if (fs <= 0.0) {
        return;
    }

    const double rbwHz = fs / static_cast<double>(fftSize);
    const QSignalBlocker blockSpin(ui->spinRbw);
    const QSignalBlocker blockUnit(ui->cmbRbwUnit);

    if (rbwHz >= 1.0e6) {
        const int idx = ui->cmbRbwUnit->findText(QStringLiteral("MHz"), Qt::MatchFixedString);
        if (idx >= 0) {
            ui->cmbRbwUnit->setCurrentIndex(idx);
        }
        ui->spinRbw->setValue(rbwHz / 1.0e6);
    } else if (rbwHz >= 1.0e3) {
        const int idx = ui->cmbRbwUnit->findText(QStringLiteral("kHz"), Qt::MatchFixedString);
        if (idx >= 0) {
            ui->cmbRbwUnit->setCurrentIndex(idx);
        }
        ui->spinRbw->setValue(rbwHz / 1.0e3);
    } else {
        const int idx = ui->cmbRbwUnit->findText(QStringLiteral("Hz"), Qt::MatchFixedString);
        if (idx >= 0) {
            ui->cmbRbwUnit->setCurrentIndex(idx);
        }
        ui->spinRbw->setValue(rbwHz);
    }

}

void MainWindow::configurePlotsForOffline()
{
    const double fs = m_offlineParams->sampleRate;
    const double fc = m_offlineParams->centerFreq;
    const double tMaxMs = (fs > 0.0) ? (static_cast<double>(m_fftSize) / fs * 1000.0) : 1.0;
    const double fMin = fc - fs * 0.5;
    const double fMax = fc + fs * 0.5;
    m_timeAxesUserZoomed = false;

    ui->iq_widget->xAxis->setRange(0.0, tMaxMs);
    ui->iq_widget->yAxis->setRange(-1.0, 1.0);

    ui->freq_widget->xAxis->setRange(fMin, fMax);
    ui->freq_widget->yAxis->setRange(kFreqYMinDb, kFreqYMaxDb);

    if (m_waterfallMap) {
        const int nx = static_cast<int>(m_fftSize);
        const int ny = static_cast<int>(m_waterfallHistory);
        const bool sizeChanged =
            (m_waterfallMap->data()->keySize() != nx
             || m_waterfallMap->data()->valueSize() != ny);
        if (sizeChanged) {
            m_waterfallMap->data()->setSize(nx, ny);
            m_waterfallMap->data()->fill(m_wfColorMin);
        }
        m_waterfallMap->data()->setRange(
            QCPRange(fMin, fMax),
            QCPRange(0.0, static_cast<double>(m_waterfallHistory - 1)));
        m_waterfallMap->setDataRange(QCPRange(m_wfColorMin, m_wfColorMax));
        m_waterfallMap->setInterpolate(false);
        ui->waterfall_widget->xAxis->setRange(fMin, fMax);
        ui->waterfall_widget->yAxis->setRange(0.0, static_cast<double>(m_waterfallHistory - 1));
    }

    rebuildAxisCache();
    m_waterfallFrameCounter = 0;
    clearWaterfallHistory();

    ui->iq_widget->replot(QCustomPlot::rpQueuedReplot);
    ui->freq_widget->replot(QCustomPlot::rpQueuedReplot);
    ui->waterfall_widget->replot(QCustomPlot::rpQueuedReplot);
}

void MainWindow::resetPlotsForSeek()
{
    if (ui->iq_widget->graphCount() >= 2) {
        ui->iq_widget->graph(0)->data()->clear();
        ui->iq_widget->graph(1)->data()->clear();
        ui->iq_widget->replot(QCustomPlot::rpQueuedReplot);
    }
    if (ui->freq_widget->graphCount() >= 1) {
        ui->freq_widget->graph(0)->data()->clear();
        ui->freq_widget->replot(QCustomPlot::rpQueuedReplot);
    }
    if (m_waterfallMap) {
        m_waterfallMap->data()->fill(m_wfColorMin);
    }
    clearWaterfallHistory();
    ui->waterfall_widget->replot(QCustomPlot::rpQueuedReplot);
}

qint64 MainWindow::signalPayloadBytes() const
{
    if (m_offlineWorker) {
        const qint64 n = m_offlineWorker->payloadBytes();
        if (n > 0) {
            return n;
        }
    }
    if (m_signalPath.isEmpty()) {
        return 0;
    }
    return QFileInfo(m_signalPath).size();
}

double MainWindow::valueToHz(double value, const QString &unit) const
{
    if (unit.compare(QStringLiteral("kHz"), Qt::CaseInsensitive) == 0) {
        return value * 1.0e3;
    }
    if (unit.compare(QStringLiteral("MHz"), Qt::CaseInsensitive) == 0) {
        return value * 1.0e6;
    }
    if (unit.compare(QStringLiteral("GHz"), Qt::CaseInsensitive) == 0) {
        return value * 1.0e9;
    }
    return value;
}

double MainWindow::sampleRateFromCombo() const
{
    const QString text = ui->editSampleRate->text().trimmed();
    if (text.isEmpty()) {
        return 40.0e6;
    }
    bool ok = false;
    const double value = text.toDouble(&ok);
    if (!ok || value < 0.0) {
        return 40.0e6;
    }
    return valueToHz(value, ui->cmbSampleRateUnit->currentText());
}

int MainWindow::sweepTimeToMs() const
{
    const double seconds =
        valueToSeconds(ui->spinSwpTime->value(), ui->cmbSwpTimeUnit->currentText());
    const int ms = static_cast<int>(std::lround(seconds * 1000.0));
    return std::max(16, ms);
}

double MainWindow::valueToSeconds(double value, const QString &unit) const
{
    if (unit.compare(QStringLiteral("ms"), Qt::CaseInsensitive) == 0) {
        return value * 1.0e-3;
    }
    if (unit.compare(QStringLiteral("us"), Qt::CaseInsensitive) == 0) {
        return value * 1.0e-6;
    }
    return value;
}

size_t MainWindow::hopSamplesFromUi(size_t fftSize) const
{
    const double fs = sampleRateFromCombo();
    size_t hop = fftSize;
    if (ui->chkAutoOverlap->isChecked()) {
        const double stepSec =
            valueToSeconds(ui->spinStepLength->value(), ui->cmbStepLengthUnit->currentText());
        if (fs > 0.0 && stepSec > 0.0) {
            hop = static_cast<size_t>(std::llround(stepSec * fs));
        }
    } else {
        const double overlap = std::clamp(ui->spinOverlap->value(), 0.0, 99.999);
        hop = static_cast<size_t>(
            std::llround(static_cast<double>(fftSize) * (1.0 - overlap / 100.0)));
    }
    hop = std::max<size_t>(1, hop);
    hop = std::min(hop, fftSize);
    return hop;
}

size_t MainWindow::fftSizeFromUi() const
{
    const double fs = sampleRateFromCombo();
    const double rbw = valueToHz(ui->spinRbw->value(), ui->cmbRbwUnit->currentText());
    // Max FFT is only used as an NFFT cap when it is a real FFT length (>= 2048).
    const size_t uiMax = static_cast<size_t>(std::max(1.0, ui->spinMaxFft->value()));
    const size_t maxSize = (uiMax >= 2048) ? std::min<size_t>(uiMax, 32768) : 32768;

    if (rbw <= 0.0 || fs <= 0.0) {
        return kDefaultFftSize;
    }

    const double bins = fs / rbw;
    if (bins < 2.0) {
        return 2048;
    }

    const auto shift = static_cast<unsigned>(std::log2(bins) + 0.999);
    size_t fftSize = (shift >= 15) ? 32768u : (1u << shift);
    fftSize = std::min(fftSize, maxSize);
    fftSize = std::max<size_t>(fftSize, 2048);
    return fftSize;
}

void MainWindow::setPlayingUi(bool playing)
{
    m_playing = playing;
    ui->btnPlay->setIcon(brandedCommandIcon(playing ? QStringLiteral("pause")
                                                    : QStringLiteral("play")));
    ui->btnPlay->setToolTip(playing ? tr("Pause") : tr("Play"));
    if (playing) {
        m_blinkTimer->start();
        ui->lblPlotTimeMeta->setText(tr("PLAYING"));
        ui->lblPlotWaterfallMeta->setText(tr("LIVE"));
        ui->lblActivityDot->setStyleSheet(QStringLiteral("color:#8FCB57;"));
        if (m_shimmer) {
            m_shimmer->setActive(false);
        }
        ui->lblAppTitle->setPulseEnabled(false);
    } else {
        m_blinkTimer->stop();
        ui->lblActivityDot->setStyleSheet(QStringLiteral("color:#C5D0C2;"));
        ui->lblActivityDot->setVisible(true);
        if (m_shimmer) {
            m_shimmer->setActive(true);
        }
        ui->lblAppTitle->setPulseEnabled(true);
    }
}

void MainWindow::destroyGuiFftPlan()
{
    if (m_guiFftPlan) {
        fftw_destroy_plan(m_guiFftPlan);
        m_guiFftPlan = nullptr;
    }
    if (m_guiFftIn) {
        fftw_free(m_guiFftIn);
        m_guiFftIn = nullptr;
    }
    if (m_guiFftOut) {
        fftw_free(m_guiFftOut);
        m_guiFftOut = nullptr;
    }
    m_guiFftPlanSize = 0;
}

void MainWindow::rebuildGuiFftPlan()
{
    destroyGuiFftPlan();
    if (m_fftSize == 0) {
        return;
    }


    m_guiFftIn = fftw_alloc_complex(m_fftSize);
    m_guiFftOut = fftw_alloc_complex(m_fftSize);
    if (!m_guiFftIn || !m_guiFftOut) {
        destroyGuiFftPlan();
        return;
    }
    m_guiFftPlan = fftw_plan_dft_1d(static_cast<int>(m_fftSize), m_guiFftIn, m_guiFftOut,
                                    FFTW_FORWARD, FFTW_ESTIMATE);
    m_guiFftPlanSize = m_fftSize;

}

size_t MainWindow::sweepBlockSamples() const
{
    return m_fftSize;
}

void MainWindow::clearWaterfallHistory()
{
    m_waterfallBuffer.clear();
    m_waterfallCurrentFftSize = 0;
    m_waterfallWriteIdx = 0;
    if (m_waterfallMap) {
        m_waterfallMap->setVisible(true);
        m_waterfallMap->data()->fill(m_wfColorMin);
        ui->waterfall_widget->replot(QCustomPlot::rpQueuedReplot);
    }
}

void MainWindow::updateSpectrumPlot(const QVector<double> &x,
                                    const QVector<double> &y,
                                    double startFreq,
                                    double endFreq)
{
    if (m_spectrumTraces) {
        m_spectrumTraces->updateSpectrum(x, y);
    }
    ui->freq_widget->xAxis->setRange(startFreq, endFreq);
    ui->freq_widget->yAxis->setRange(kFreqYMinDb, kFreqYMaxDb);
}

void MainWindow::updateWaterfallPlot(const QVector<double> &y, double startFreq, double endFreq)
{
    if (!ui->waterfall_widget || !m_waterfallMap || y.isEmpty()) {
        return;
    }

    m_waterfallMap->setVisible(true);
    QCPColorMap *colorMap = m_waterfallMap;
    const int fftSize = y.size();
    const int rowCount = static_cast<int>(m_waterfallHistory);

    if (fftSize != m_waterfallCurrentFftSize) {
        m_waterfallCurrentFftSize = fftSize;
        m_waterfallBuffer.clear();
        m_waterfallBuffer.resize(static_cast<size_t>(rowCount),
                                 std::vector<double>(static_cast<size_t>(fftSize), -120.0));
        colorMap->data()->setSize(fftSize, rowCount);
        colorMap->data()->setKeyRange(QCPRange(startFreq, endFreq));
        colorMap->data()->setValueRange(QCPRange(0, rowCount - 1));
        colorMap->data()->fill(m_wfColorMin);
        m_waterfallWriteIdx = 0;
    }

    if (m_waterfallBuffer.empty()) {
        m_waterfallBuffer.resize(static_cast<size_t>(rowCount),
                                 std::vector<double>(static_cast<size_t>(fftSize), -120.0));
        m_waterfallWriteIdx = 0;
    }


    // Overwrite oldest row in circular buffer.
    auto &destRow = m_waterfallBuffer[static_cast<size_t>(m_waterfallWriteIdx % rowCount)];
    destRow.assign(y.begin(), y.end());
    m_waterfallWriteIdx++;

    // Render: newest row at y=0, oldest at y=rowCount-1.
    for (int r = 0; r < rowCount; ++r) {
        const int bufIdx =
            ((m_waterfallWriteIdx - 1 - r) % rowCount + rowCount) % rowCount;
        const auto &row = m_waterfallBuffer[static_cast<size_t>(bufIdx)];
        for (int x = 0; x < fftSize && x < static_cast<int>(row.size()); ++x) {
            colorMap->data()->setCell(x, r, row[static_cast<size_t>(x)]);
        }
    }

    colorMap->data()->setKeyRange(QCPRange(startFreq, endFreq));
    colorMap->setDataRange(QCPRange(m_wfColorMin, m_wfColorMax));
    ui->waterfall_widget->xAxis->setRange(startFreq, endFreq);
    ui->waterfall_widget->yAxis->setRange(0.0, static_cast<double>(rowCount - 1));
    ui->waterfall_widget->yAxis->setRangeReversed(true);
}

bool MainWindow::computeSweepFrameFromRing(QVector<double> &tAxisMs,
                                           QVector<double> &iVals,
                                           QVector<double> &qVals,
                                           QVector<double> &dbVals,
                                           double &peakI)
{
    if (!m_timeBuffer || m_fftSize == 0 || !m_guiFftPlan || !m_offlineParams) {
        return false;
    }

    if (m_timeBuffer->size() < m_fftSize) {
        return false;
    }

    std::vector<std::complex<float>> samples;
    try {
        samples = m_timeBuffer->read(static_cast<long>(m_fftSize));
    } catch (...) {
        return false;
    }

    if (samples.size() != m_fftSize) {
        return false;
    }


    const double fs = m_offlineParams->sampleRate;
    const double timeStepMs = (fs > 0.0) ? (1000.0 / fs) : 1.0;

    tAxisMs.resize(static_cast<int>(m_fftSize));
    iVals.resize(static_cast<int>(m_fftSize));
    qVals.resize(static_cast<int>(m_fftSize));
    peakI = 0.05;

    for (size_t i = 0; i < m_fftSize; ++i) {
        const int idx = static_cast<int>(i);
        tAxisMs[idx] = static_cast<double>(i) * timeStepMs;
        iVals[idx] = static_cast<double>(samples[i].real());
        qVals[idx] = static_cast<double>(samples[i].imag());
        peakI = std::max(peakI, std::abs(iVals[idx]));
        peakI = std::max(peakI, std::abs(qVals[idx]));
    }

    double windowPower = 0.0;
    for (size_t i = 0; i < m_fftSize; ++i) {
        const float w = hanningWindow(static_cast<int>(i), static_cast<int>(m_fftSize));
        windowPower += static_cast<double>(w * w);
    }
    if (windowPower <= 0.0) {
        windowPower = 1.0;
    }
    const double correction = 1.0 / windowPower;

    for (size_t i = 0; i < m_fftSize; ++i) {
        const float w = hanningWindow(static_cast<int>(i), static_cast<int>(m_fftSize));
        m_guiFftIn[i][0] = static_cast<double>(samples[i].real() * w);
        m_guiFftIn[i][1] = static_cast<double>(samples[i].imag() * w);
    }

    fftw_execute(m_guiFftPlan);

    dbVals.resize(static_cast<int>(m_fftSize));
    const int half = static_cast<int>(m_fftSize >> 1);
    for (size_t i = 0; i < m_fftSize; ++i) {
        const int shiftedIdx = (static_cast<int>(i) + half) % static_cast<int>(m_fftSize);
        const double re = m_guiFftOut[i][0];
        const double im = m_guiFftOut[i][1];
        const double norm = re * re + im * im;
        dbVals[shiftedIdx] = 10.0 * std::log10(std::max(norm * correction, 1.0e-12));
    }


    return true;
}

void MainWindow::schedulePlotTick(int delayMs)
{
    if (!m_plotTimer || !m_playing || m_offlinePaused) {
        return;
    }
    const int interval = std::max(16, delayMs);
    if (m_plotTimer->interval() != interval) {
        m_plotTimer->setInterval(interval);
    }
    if (!m_plotTimer->isActive()) {
        m_plotTimer->start();
    }
}

void MainWindow::onPlotSweepTick()
{

    const size_t blockSize = sweepBlockSamples();
    if (!m_timeBuffer || m_fftSize == 0 || blockSize == 0) {
        return;
    }

    if (m_timeBuffer->size() < m_fftSize) {
        return;
    }


    QVector<double> tAxisMs;
    QVector<double> iVals;
    QVector<double> qVals;
    QVector<double> dbVals;
    double peakI = 0.05;
    if (!computeSweepFrameFromRing(tAxisMs, iVals, qVals, dbVals, peakI)) {
        return;
    }

    if (m_cachedAxisFftSize != m_fftSize) {
        rebuildAxisCache();
    }
    const QVector<double> &fAxis = m_cachedFAxis;

    const double fs = m_offlineParams->sampleRate;
    const double fc = m_offlineParams->centerFreq;
    const double startFreq = fc - fs * 0.5;
    const double endFreq = fc + fs * 0.5;

    // WMS onSpectrumData / onTimeData: same sweep block updates all three plots.
    ui->iq_widget->graph(0)->setData(tAxisMs, iVals);
    ui->iq_widget->graph(1)->setData(tAxisMs, qVals);
    if (!m_timeAxesUserZoomed) {
        ui->iq_widget->yAxis->setRange(-peakI, peakI);
    }

    updateSpectrumPlot(fAxis, dbVals, startFreq, endFreq);

    ++m_waterfallFrameCounter;
    const bool doWaterfall = (m_waterfallFrameCounter % 4) == 0;
    if (doWaterfall) {
        updateWaterfallPlot(dbVals, startFreq, endFreq);
    }

    updateTimeProgressSlider();

    ui->iq_widget->replot(QCustomPlot::rpQueuedReplot);
    ui->freq_widget->replot(QCustomPlot::rpQueuedReplot);
    if (doWaterfall) {
        ui->waterfall_widget->replot(QCustomPlot::rpQueuedReplot);
    }


    m_lastAppliedSweepMs = sweepTimeToMs();
}

void MainWindow::onPlotPaintFinished()
{
    // Reserved for future use; scheduling is now handled by the repeating m_plotTimer.
}

void MainWindow::onOfflineError(const QString &message)
{
    setPlayingUi(false);
    if (m_plotTimer) {
        m_plotTimer->stop();
    }
    QMessageBox::warning(this, tr("Offline playback"), message);
}

void MainWindow::onOfflineFinished()
{
    if (m_offlinePaused) {
        return;
    }
    if (m_plotTimer) {
        m_plotTimer->stop();
    }
    setPlayingUi(false);
    ui->lblPlotTimeMeta->setText(tr("STOPPED"));
    ui->lblPlotWaterfallMeta->setText(tr("STOPPED"));
    {
        const QSignalBlocker blocker(ui->sliderTimeProgress);
        ui->sliderTimeProgress->setValue(ui->sliderTimeProgress->maximum());
    }
    ui->sliderTimeProgress->setToolTip(tr("100% of the signal displayed"));
    statusBar()->showMessage(tr("Offline playback finished."), 3000);
}

void MainWindow::setupPlotInteractions()
{
    enableDashedBoxZoom(ui->iq_widget, true);
    enableDashedBoxZoom(ui->waterfall_widget, true);
    // Frequency Y stays locked at -120..+20; box-zoom only the frequency axis.
    enableDashedBoxZoom(ui->freq_widget, false);

    connect(ui->freq_widget->xAxis,
            qOverload<const QCPRange &>(&QCPAxis::rangeChanged),
            this, &MainWindow::syncWaterfallXFromFrequency);
    connect(ui->waterfall_widget->xAxis,
            qOverload<const QCPRange &>(&QCPAxis::rangeChanged),
            this, [this](const QCPRange &range) {
                if (m_syncingFreqWaterfallX || !ui->freq_widget) {
                    return;
                }
                m_syncingFreqWaterfallX = true;
                ui->freq_widget->xAxis->setRange(range);
                ui->freq_widget->replot(QCustomPlot::rpQueuedReplot);
                m_syncingFreqWaterfallX = false;
            });

    connect(ui->iq_widget->selectionRect(), &QCPSelectionRect::accepted,
            this, [this](const QRect &, QMouseEvent *) {
                m_timeAxesUserZoomed = true;
            });
    connect(ui->waterfall_widget->selectionRect(), &QCPSelectionRect::accepted,
            this, [this](const QRect &, QMouseEvent *) {
            });
    connect(ui->freq_widget->selectionRect(), &QCPSelectionRect::accepted,
            this, [this](const QRect &, QMouseEvent *) {
                ui->freq_widget->yAxis->setRange(kFreqYMinDb, kFreqYMaxDb);
            });

    setupTimeContextMenu();
    setupFreqContextMenu();
    setupWaterfallContextMenu();

}

void MainWindow::enableDashedBoxZoom(QCustomPlot *plot, bool zoomVertical)
{
    if (!plot || !plot->axisRect()) {
        return;
    }

    plot->setInteractions(QCP::iNone);
    plot->setSelectionRectMode(QCP::srmZoom);
    plot->selectionRect()->setPen(QPen(Qt::black, 1.5, Qt::DashLine));
    plot->selectionRect()->setBrush(Qt::NoBrush);

    if (zoomVertical) {
        plot->axisRect()->setRangeZoomAxes(plot->xAxis, plot->yAxis);
    } else {
        plot->axisRect()->setRangeZoomAxes(QList<QCPAxis *>{plot->xAxis}, QList<QCPAxis *>{});
    }

    // Right-click must not start a zoom rect, so the context menu can open.
    connect(plot, &QCustomPlot::mousePress, this, [this, plot](QMouseEvent *event) {
        if (m_filterPickStage != FilterPickStage::Idle && plot == ui->freq_widget) {
            plot->setSelectionRectMode(QCP::srmNone);
            return;
        }
        if (m_pickingNoiseFloor && plot == ui->freq_widget) {
            plot->setSelectionRectMode(QCP::srmNone);
            return;
        }
        if (event->button() == Qt::LeftButton) {
            plot->setSelectionRectMode(QCP::srmZoom);
        } else {
            plot->setSelectionRectMode(QCP::srmNone);
        }
    });

    // Scroll-wheel near the Y axis zooms only the Y axis; elsewhere zooms X.
    connect(plot, &QCustomPlot::mouseWheel, this, [plot](QWheelEvent *event) {
        if (!plot->axisRect()) {
            return;
        }
        const int yAxisWidth = plot->yAxis->axisRect()->left()
                               - plot->axisRect()->left() + 60;
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
        const int pointerX = static_cast<int>(event->position().x());
#else
        const int pointerX = event->x();
#endif
        const double factor = (event->angleDelta().y() > 0) ? 0.75 : 1.333;
        if (pointerX < yAxisWidth) {
            // Mouse pointer is over Y-axis strip: zoom Y only.
            plot->yAxis->scaleRange(factor, plot->yAxis->pixelToCoord(
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
                event->position().y()
#else
                event->y()
#endif
                ));
            plot->replot(QCustomPlot::rpQueuedReplot);
        }
        // If not on Y axis, QCustomPlot's default box-zoom handles X.
    });
}

void MainWindow::setupTimeContextMenu()
{
    m_timeMenu = new QMenu(this);
    m_timeRescaleAction = m_timeMenu->addAction(tr("Rescale"));
    connect(m_timeRescaleAction, &QAction::triggered, this, &MainWindow::rescaleTimePlot);

    ui->iq_widget->setContextMenuPolicy(Qt::CustomContextMenu);
    connect(ui->iq_widget, &QCustomPlot::customContextMenuRequested,
            this, &MainWindow::showTimeContextMenu);
}

void MainWindow::setupFreqContextMenu()
{
    m_freqMenu = new QMenu(this);
    m_freqRescaleAction = m_freqMenu->addAction(tr("Rescale"));
    connect(m_freqRescaleAction, &QAction::triggered, this, &MainWindow::rescaleFrequencyPlot);

    ui->freq_widget->setContextMenuPolicy(Qt::CustomContextMenu);
    connect(ui->freq_widget, &QCustomPlot::customContextMenuRequested,
            this, &MainWindow::showFreqContextMenu);
}

void MainWindow::setupWaterfallContextMenu()
{
    m_waterfallMenu = new QMenu(this);

    // Preferences
    QAction *prefsAction = m_waterfallMenu->addAction(tr("Preferences"));
    connect(prefsAction, &QAction::triggered, this, &MainWindow::showWaterfallPreferences);

    // Clear Spectrogram
    QAction *clearAction = m_waterfallMenu->addAction(tr("Clear Spectrogram"));
    connect(clearAction, &QAction::triggered, this, &MainWindow::clearWaterfallHistory);

    // Delta Marker
    m_wfDeltaMarkerAction = m_waterfallMenu->addAction(tr("Delta Marker"));
    m_wfDeltaMarkerAction->setCheckable(true);
    m_wfDeltaMarkerAction->setChecked(false);
    connect(m_wfDeltaMarkerAction, &QAction::toggled, this, [this](bool on) {
        m_wfDeltaMarkerEnabled = on;
        if (!on && m_wfDeltaLine) {
            m_wfDeltaLine->setVisible(false);
            ui->waterfall_widget->replot(QCustomPlot::rpQueuedReplot);
        }
    });

    // Auto Scale
    QAction *autoScaleAction = m_waterfallMenu->addAction(tr("Auto Scale"));
    connect(autoScaleAction, &QAction::triggered, this, &MainWindow::autoScaleWaterfall);

    m_waterfallMenu->addSeparator();

    m_waterfallRescaleAction = m_waterfallMenu->addAction(tr("Rescale"));
    connect(m_waterfallRescaleAction, &QAction::triggered,
            this, &MainWindow::rescaleWaterfallPlot);
    m_colorMapEditorAction = m_waterfallMenu->addAction(tr("ColorMap_Editor"));
    connect(m_colorMapEditorAction, &QAction::triggered,
            this, &MainWindow::openColorMapEditor);

    ui->waterfall_widget->setContextMenuPolicy(Qt::CustomContextMenu);
    connect(ui->waterfall_widget, &QCustomPlot::customContextMenuRequested,
            this, &MainWindow::showWaterfallContextMenu);
}

void MainWindow::showTimeContextMenu(const QPoint &pos)
{
    if (!m_timeMenu) {
        return;
    }
    m_timeMenu->exec(ui->iq_widget->mapToGlobal(pos));
}

void MainWindow::showFreqContextMenu(const QPoint &pos)
{
    if (!m_freqMenu) {
        return;
    }
    m_freqMenu->exec(ui->freq_widget->mapToGlobal(pos));
}

void MainWindow::showWaterfallContextMenu(const QPoint &pos)
{
    if (!m_waterfallMenu) {
        return;
    }
    m_waterfallMenu->exec(ui->waterfall_widget->mapToGlobal(pos));
}

void MainWindow::rescaleTimePlot()
{
    const double fs = m_offlineParams ? m_offlineParams->sampleRate : sampleRateFromCombo();
    const double tMaxMs = (fs > 0.0) ? (static_cast<double>(m_fftSize) / fs * 1000.0) : 1.0;
    m_timeAxesUserZoomed = false;
    ui->iq_widget->xAxis->setRange(0.0, tMaxMs);
    if (ui->iq_widget->graphCount() >= 1) {
        ui->iq_widget->yAxis->rescale(true);
        const double half = std::max(0.05, std::abs(ui->iq_widget->yAxis->range().upper));
        ui->iq_widget->yAxis->setRange(-half, half);
    } else {
        ui->iq_widget->yAxis->setRange(-1.0, 1.0);
    }
    ui->iq_widget->replot(QCustomPlot::rpQueuedReplot);
}

void MainWindow::rescaleFrequencyPlot()
{
    const double fs = m_offlineParams ? m_offlineParams->sampleRate : sampleRateFromCombo();
    const double fc = m_offlineParams ? m_offlineParams->centerFreq
                                      : valueToHz(ui->spinCenter->value(),
                                                  ui->cmbCenterUnit->currentText());
    const double fMin = fc - fs * 0.5;
    const double fMax = fc + fs * 0.5;
    ui->freq_widget->xAxis->setRange(fMin, fMax);
    ui->freq_widget->yAxis->setRange(kFreqYMinDb, kFreqYMaxDb);
    ui->freq_widget->replot(QCustomPlot::rpQueuedReplot);
}

void MainWindow::rescaleWaterfallPlot()
{
    const double fs = m_offlineParams ? m_offlineParams->sampleRate : sampleRateFromCombo();
    const double fc = m_offlineParams ? m_offlineParams->centerFreq
                                      : valueToHz(ui->spinCenter->value(),
                                                  ui->cmbCenterUnit->currentText());
    const double fMin = fc - fs * 0.5;
    const double fMax = fc + fs * 0.5;
    ui->waterfall_widget->xAxis->setRange(fMin, fMax);
    ui->waterfall_widget->yAxis->setRange(0.0, static_cast<double>(m_waterfallHistory - 1));
    ui->freq_widget->xAxis->setRange(fMin, fMax);
    ui->freq_widget->yAxis->setRange(kFreqYMinDb, kFreqYMaxDb);
    ui->waterfall_widget->replot(QCustomPlot::rpQueuedReplot);
    ui->freq_widget->replot(QCustomPlot::rpQueuedReplot);
}

void MainWindow::syncWaterfallXFromFrequency(const QCPRange &range)
{
    if (m_syncingFreqWaterfallX || !ui->waterfall_widget) {
        return;
    }
    m_syncingFreqWaterfallX = true;
    ui->waterfall_widget->xAxis->setRange(range);
    ui->waterfall_widget->replot(QCustomPlot::rpQueuedReplot);
    m_syncingFreqWaterfallX = false;
}

void MainWindow::showWaterfallPreferences()
{
    if (!m_wfPrefsDialog) {
        m_wfPrefsDialog = new QDialog(this);
        m_wfPrefsDialog->setWindowTitle(tr("Spectrogram Preferences"));
        m_wfPrefsDialog->setWindowModality(Qt::NonModal);

        auto *grid = new QGridLayout(m_wfPrefsDialog);
        int row = 0;

        grid->addWidget(new QLabel(tr("Sweep Depth"), m_wfPrefsDialog), row, 0);
        m_wfPrefDepth = new QLineEdit(QString::number(m_waterfallHistory), m_wfPrefsDialog);
        grid->addWidget(m_wfPrefDepth, row++, 1);

        grid->addWidget(new QLabel(tr("Color Scale"), m_wfPrefsDialog), row, 0);
        m_wfPrefColorScale = new QComboBox(m_wfPrefsDialog);
        m_wfPrefColorScale->addItems({
            QStringLiteral("gpSpectrum"), QStringLiteral("gpHot"),
            QStringLiteral("Grayscale"), QStringLiteral("gpNight"),
            QStringLiteral("gpCandy"), QStringLiteral("gpIon"),
            QStringLiteral("gpThermal"), QStringLiteral("gpPolar"),
            QStringLiteral("gpJet"), QStringLiteral("gpHues")});
        m_wfPrefColorScale->setCurrentIndex(0);
        grid->addWidget(m_wfPrefColorScale, row++, 1);

        grid->addWidget(new QLabel(tr("Scale to Ref"), m_wfPrefsDialog), row, 0);
        m_wfPrefScaleToRef = new QCheckBox(m_wfPrefsDialog);
        m_wfPrefScaleToRef->setChecked(true);
        grid->addWidget(m_wfPrefScaleToRef, row++, 1);

        grid->addWidget(new QLabel(tr("Min Color (dBm)"), m_wfPrefsDialog), row, 0);
        m_wfPrefMinColor = new QLineEdit(QStringLiteral("-100.000"), m_wfPrefsDialog);
        grid->addWidget(m_wfPrefMinColor, row++, 1);

        grid->addWidget(new QLabel(tr("Max Color (dBm)"), m_wfPrefsDialog), row, 0);
        m_wfPrefMaxColor = new QLineEdit(QStringLiteral("0.000"), m_wfPrefsDialog);
        grid->addWidget(m_wfPrefMaxColor, row++, 1);

        // Connect signals
        connect(m_wfPrefDepth, &QLineEdit::editingFinished, this, [this]() {
            bool ok = false;
            int depth = m_wfPrefDepth->text().toInt(&ok);
            if (ok && depth > 0 && depth <= 2000) {
                m_waterfallHistory = static_cast<size_t>(depth);
                clearWaterfallHistory();
            }
        });

        connect(m_wfPrefColorScale, QOverload<int>::of(&QComboBox::currentIndexChanged),
                this, [this](int idx) {
            static const QCPColorGradient::GradientPreset presets[] = {
                QCPColorGradient::gpSpectrum, QCPColorGradient::gpHot,
                QCPColorGradient::gpGrayscale, QCPColorGradient::gpNight,
                QCPColorGradient::gpCandy, QCPColorGradient::gpIon,
                QCPColorGradient::gpThermal, QCPColorGradient::gpPolar,
                QCPColorGradient::gpJet, QCPColorGradient::gpHues};
            if (idx >= 0 && idx < 10 && m_waterfallMap) {
                m_waterfallMap->setGradient(presets[idx]);
                ui->waterfall_widget->replot(QCustomPlot::rpQueuedReplot);
            }
        });

        connect(m_wfPrefMinColor, &QLineEdit::editingFinished, this, [this]() {
            applyWaterfallColorRange();
        });
        connect(m_wfPrefMaxColor, &QLineEdit::editingFinished, this, [this]() {
            applyWaterfallColorRange();
        });
        connect(m_wfPrefScaleToRef, &QCheckBox::toggled, this, [this](bool on) {
            m_wfScaleToRef = on;
        });
    }

    m_wfPrefsDialog->show();
    m_wfPrefsDialog->raise();
    m_wfPrefsDialog->activateWindow();
}

void MainWindow::applyWaterfallColorRange()
{
    if (!m_waterfallMap || !m_wfPrefMinColor || !m_wfPrefMaxColor) {
        return;
    }
    bool okMin = false, okMax = false;
    const double minC = m_wfPrefMinColor->text().toDouble(&okMin);
    const double maxC = m_wfPrefMaxColor->text().toDouble(&okMax);
    if (okMin && okMax && minC < maxC) {
        m_wfColorMin = minC;
        m_wfColorMax = maxC;
        m_waterfallMap->setDataRange(QCPRange(m_wfColorMin, m_wfColorMax));
        ui->waterfall_widget->replot(QCustomPlot::rpQueuedReplot);
    }
}

void MainWindow::autoScaleWaterfall()
{
    if (m_waterfallBuffer.empty() || !m_waterfallMap) {
        return;
    }
    double minVal = 1e30, maxVal = -1e30;
    for (const auto &row : m_waterfallBuffer) {
        for (double v : row) {
            if (v < minVal) minVal = v;
            if (v > maxVal) maxVal = v;
        }
    }
    if (minVal >= maxVal) {
        return;
    }
    const double margin = (maxVal - minVal) * 0.05;
    m_wfColorMin = minVal - margin;
    m_wfColorMax = maxVal + margin;
    m_waterfallMap->setDataRange(QCPRange(m_wfColorMin, m_wfColorMax));
    ui->waterfall_widget->replot(QCustomPlot::rpQueuedReplot);

    if (m_wfPrefMinColor) {
        m_wfPrefMinColor->setText(QString::number(m_wfColorMin, 'f', 3));
    }
    if (m_wfPrefMaxColor) {
        m_wfPrefMaxColor->setText(QString::number(m_wfColorMax, 'f', 3));
    }
}

void MainWindow::openColorMapEditor()
{
    if (!m_colorMapEditor) {
        m_colorMapEditor = new ColorMapEditorDialog(this);
        m_colorMapEditor->setWindowModality(Qt::WindowModal);
        connect(m_colorMapEditor, &ColorMapEditorDialog::baseColorMapChanged,
                this, &MainWindow::onWaterfallColorMapChanged,
                Qt::UniqueConnection);
    }

    QVector<QColor> colors;
    colors.reserve(256);
    if (m_waterfallMap) {
        QCPColorGradient gradient = m_waterfallMap->gradient();
        const QCPRange range(0.0, 1.0);
        for (int i = 0; i < 256; ++i) {
            colors.append(QColor::fromRgba(
                gradient.color(static_cast<double>(i) / 255.0, range)));
        }
        m_colorMapEditor->setBaseColorMap(colors);
    }

    m_colorMapEditor->show();
    m_colorMapEditor->raise();
    m_colorMapEditor->activateWindow();
}

void MainWindow::onWaterfallColorMapChanged(const QCPColorGradient &gradient)
{
    if (!m_waterfallMap) {
        return;
    }
    m_waterfallMap->setGradient(gradient);
    ui->waterfall_widget->replot(QCustomPlot::rpQueuedReplot);
}

void MainWindow::updateTimeProgressSlider()
{
    if (!ui->sliderTimeProgress || m_timeSliderHeld || ui->sliderTimeProgress->isSliderDown()) {
        return;
    }

    const qint64 payload = signalPayloadBytes();
    qint64 pos = 0;
    if (m_offlineWorker) {
        pos = m_offlineWorker->positionBytes();
    }

    int value = 0;
    if (payload > 0) {
        value = static_cast<int>(std::min<qint64>(1000, (pos * 1000) / payload));
    }


    const QSignalBlocker blocker(ui->sliderTimeProgress);
    ui->sliderTimeProgress->setValue(value);
    ui->sliderTimeProgress->setToolTip(
        tr("%1% of the signal displayed").arg(value / 10.0, 0, 'f', 1));
}

void MainWindow::onTimeSliderReleased()
{
    const qint64 payload = signalPayloadBytes();
    if (payload <= 0) {
        return;
    }

    const qint64 offset =
        (static_cast<qint64>(ui->sliderTimeProgress->value()) * payload) / 1000;


    if (m_timeBuffer) {
        m_timeBuffer->clear();
    }
    resetPlotsForSeek();

    if (m_offlineWorker && m_offlineWorker->isRunning()) {
        m_offlineWorker->requestSeek(offset);
        if (m_offlinePaused) {
            m_offlineWorker->setPaused(false);
            m_offlinePaused = false;
            setPlayingUi(true);
        }
        m_waitingForPaint = false;
        if (m_playing && !m_offlinePaused) {
            schedulePlotTick(sweepTimeToMs());
        }
        return;
    }

    m_pendingSeekBytes = offset;
    if (!m_signalPath.isEmpty() && !m_playing) {
        playAnalysis();
    }
}

QString MainWindow::formatHertz(double hz)
{
    const double mag = std::abs(hz);
    if (mag >= 1.0e9) {
        return QStringLiteral("%1 GHz").arg(hz / 1.0e9, 0, 'f', 4);
    }
    if (mag >= 1.0e6) {
        return QStringLiteral("%1 MHz").arg(hz / 1.0e6, 0, 'f', 3);
    }
    if (mag >= 1.0e3) {
        return QStringLiteral("%1 kHz").arg(hz / 1.0e3, 0, 'f', 3);
    }
    return QStringLiteral("%1 Hz").arg(hz, 0, 'f', 1);
}

void MainWindow::onChannelizerClicked()
{
    QVector<double> freqHz;
    QVector<double> psdDb;
    const bool haveSpec = m_spectrumTraces
                          && m_spectrumTraces->copyDisplayedSpectrum(&freqHz, &psdDb);
    if (!haveSpec) {
        QMessageBox::information(this, tr("Channelizer"),
                                 tr("Play a signal first so a spectrum is available, "
                                    "then drag a frequency range and click Channelizer."));
        return;
    }

    QMessageBox box(this);
    box.setWindowModality(Qt::WindowModal);
    box.setWindowTitle(tr("Channelizer"));
    box.setText(tr("A frequency range is selected on the spectrum.\n"
                   "How should the noise floor be set?"));
    auto *autoBtn = box.addButton(tr("Automatic"), QMessageBox::AcceptRole);
    auto *manualBtn = box.addButton(tr("Select on plot"), QMessageBox::ActionRole);
    box.addButton(QMessageBox::Cancel);
    box.exec();
    if (box.clickedButton() == autoBtn) {
        runChannelizer(true, 0.0);
    } else if (box.clickedButton() == manualBtn) {
        setNoiseFloorPicking(true);
    }
}

void MainWindow::onClearChannelsClicked()
{
    setNoiseFloorPicking(false);
    clearChannelizerOverlays();
    if (m_channelResultsTable) {
        m_channelResultsTable->setRowCount(0);
    }
    if (m_measurementPanel && m_measurementPanel->channelizerHintLabel()) {
        m_measurementPanel->channelizerHintLabel()->setText(
            tr("1. Drag a frequency range on the spectrum.\n"
               "2. Click Channelizer.\n"
               "3. Choose Automatic or Manual noise floor.\n"
               "Results appear in the table below the waterfall."));
    }
    ui->freq_widget->replot(QCustomPlot::rpQueuedReplot);
    statusBar()->showMessage(tr("Channelizer results cleared."), 2500);
}

void MainWindow::clearFilterOverlays()
{
    if (!ui->freq_widget) {
        return;
    }
    clearFilterPreview();
    if (m_filterLineStart) {
        ui->freq_widget->removeItem(m_filterLineStart);
        m_filterLineStart = nullptr;
    }
    if (m_filterLineEnd) {
        ui->freq_widget->removeItem(m_filterLineEnd);
        m_filterLineEnd = nullptr;
    }
    if (m_filterBandRect) {
        ui->freq_widget->removeItem(m_filterBandRect);
        m_filterBandRect = nullptr;
    }
    m_haveFilterRange = false;
    m_filterFStartHz = 0.0;
    m_filterFEndHz = 0.0;
}

void MainWindow::clearFilterPreview()
{
    if (!ui->freq_widget) {
        return;
    }
    if (m_filterPreviewLine) {
        ui->freq_widget->removeItem(m_filterPreviewLine);
        m_filterPreviewLine = nullptr;
    }
    if (m_filterPreviewLabel) {
        ui->freq_widget->removeItem(m_filterPreviewLabel);
        m_filterPreviewLabel = nullptr;
    }
}

void MainWindow::updateFilterPreview(double fHz)
{
    if (!ui->freq_widget) {
        return;
    }

    QCustomPlot *plot = ui->freq_widget;
    const QCPRange xRange = plot->xAxis->range();
    const double clampedHz = qBound(xRange.lower, fHz, xRange.upper);
    const double yTop = plot->yAxis->range().upper;
    const double yBot = plot->yAxis->range().lower;

    if (!m_filterPreviewLine) {
        m_filterPreviewLine = new QCPItemLine(plot);
        m_filterPreviewLine->setLayer(QStringLiteral("overlay"));
        m_filterPreviewLabel = new QCPItemText(plot);
        m_filterPreviewLabel->setLayer(QStringLiteral("overlay"));
        m_filterPreviewLabel->setFont(QFont(QStringLiteral("Segoe UI"), 9, QFont::Bold));
        m_filterPreviewLabel->setPadding(QMargins(6, 2, 6, 2));
        m_filterPreviewLabel->setPositionAlignment(Qt::AlignHCenter | Qt::AlignTop);
    }

    m_filterPreviewLine->start->setCoords(clampedHz, yBot);
    m_filterPreviewLine->end->setCoords(clampedHz, yTop);
    QPen previewPen(QColor(71, 85, 105, 220), 2.0, Qt::DashLine);
    previewPen.setCapStyle(Qt::RoundCap);
    m_filterPreviewLine->setPen(previewPen);

    m_filterPreviewLabel->position->setCoords(clampedHz, yTop);
    m_filterPreviewLabel->setText(formatHertz(clampedHz));
    m_filterPreviewLabel->setColor(QColor(QStringLiteral("#334155")));
    m_filterPreviewLabel->setBrush(QColor(248, 250, 252, 235));
    m_filterPreviewLabel->setPen(QPen(QColor(71, 85, 105, 180), 1.0));

    if (m_filterPickStage == FilterPickStage::SecondLine) {
        const double fLo = qMin(m_filterFStartHz, clampedHz);
        const double fHi = qMax(m_filterFStartHz, clampedHz);
        if (!m_filterBandRect) {
            m_filterBandRect = new QCPItemRect(plot);
            m_filterBandRect->setLayer(QStringLiteral("overlay"));
        }
        m_filterBandRect->topLeft->setCoords(fLo, yTop);
        m_filterBandRect->bottomRight->setCoords(fHi, yBot);
        m_filterBandRect->setPen(QPen(QColor(71, 85, 105, 120), 1.0, Qt::DashLine));
        m_filterBandRect->setBrush(QColor(71, 85, 105, 10));
    }

}

QString MainWindow::promptFilterSavePath(QString *outFileType) const
{
    QDialog dlg(const_cast<MainWindow *>(this));
    dlg.setWindowTitle(tr("Save Filtered IQ"));

    auto *layout = new QVBoxLayout(&dlg);
    auto *form = new QFormLayout();

    auto *pathEdit = new QLineEdit(&dlg);
    const QString defaultName =
        QFileInfo(m_signalPath).completeBaseName() + QStringLiteral("_filtered.iq");
    pathEdit->setText(defaultName);

    auto *browseBtn = new QPushButton(tr("Browse…"), &dlg);
    auto *pathRow = new QWidget(&dlg);
    auto *pathLayout = new QHBoxLayout(pathRow);
    pathLayout->setContentsMargins(0, 0, 0, 0);
    pathLayout->addWidget(pathEdit, 1);
    pathLayout->addWidget(browseBtn);
    form->addRow(tr("Output file:"), pathRow);

    auto *typeCombo = new QComboBox(&dlg);
    typeCombo->addItem(QStringLiteral("float32"));
    typeCombo->addItem(QStringLiteral("double64"));
    typeCombo->addItem(QStringLiteral("uint16"));

    QString inType = QStringLiteral("float32");
    if (m_offlineParams) {
        QMutexLocker lock(&m_offlineParams->mutex);
        inType = m_offlineParams->fileType;
    }
    const int typeIdx = typeCombo->findText(inType, Qt::MatchFixedString);
    typeCombo->setCurrentIndex(typeIdx >= 0 ? typeIdx : 0);
    form->addRow(tr("Sample type:"), typeCombo);

    layout->addLayout(form);

    auto *buttons = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, &dlg);
    layout->addWidget(buttons);
    QObject::connect(buttons, &QDialogButtonBox::accepted, &dlg, &QDialog::accept);
    QObject::connect(buttons, &QDialogButtonBox::rejected, &dlg, &QDialog::reject);
    QObject::connect(browseBtn, &QPushButton::clicked, &dlg, [&dlg, pathEdit]() {
        const QString picked = QFileDialog::getSaveFileName(
            &dlg,
            MainWindow::tr("Save Filtered IQ"),
            pathEdit->text(),
            MainWindow::tr("IQ files (*.iq *.bin);;All files (*)"));
        if (!picked.isEmpty()) {
            pathEdit->setText(picked);
        }
    });

    if (dlg.exec() != QDialog::Accepted) {
        return QString();
    }

    if (outFileType) {
        *outFileType = typeCombo->currentText().trimmed();
    }
    return pathEdit->text().trimmed();
}

void MainWindow::updateFilterBandOverlay()
{
    if (!ui->freq_widget || !m_haveFilterRange) {
        return;
    }

    QCustomPlot *plot = ui->freq_widget;
    const double fLo = qMin(m_filterFStartHz, m_filterFEndHz);
    const double fHi = qMax(m_filterFStartHz, m_filterFEndHz);
    const double yTop = plot->yAxis->range().upper;
    const double yBot = plot->yAxis->range().lower;

    if (!m_filterBandRect) {
        m_filterBandRect = new QCPItemRect(plot);
        m_filterBandRect->setLayer(QStringLiteral("overlay"));
    }
    m_filterBandRect->topLeft->setCoords(fLo, yTop);
    m_filterBandRect->bottomRight->setCoords(fHi, yBot);
    m_filterBandRect->setPen(QPen(QColor(71, 85, 105, 160), 1.0, Qt::DashDotLine));
    m_filterBandRect->setBrush(QColor(71, 85, 105, 16));
}

void MainWindow::setFilterRangePicking(bool enabled)
{
    if (!ui->freq_widget) {
        return;
    }

    QCustomPlot *plot = ui->freq_widget;
    if (enabled) {
        setNoiseFloorPicking(false);
        m_filterPickStage = FilterPickStage::FirstLine;
        plot->setSelectionRectMode(QCP::srmNone);
        plot->setMouseTracking(true);
        plot->setCursor(Qt::CrossCursor);
        plot->setFocus(Qt::OtherFocusReason);
        statusBar()->showMessage(
            tr("Move the mouse to the start frequency, then click to confirm."), 0);
        if (m_measurementPanel && m_measurementPanel->filterHintLabel()) {
            m_measurementPanel->filterHintLabel()->setText(
                tr("The dashed vertical line follows the mouse.\n"
                   "Click to set the start frequency, then the end frequency.\n"
                   "Right-click or Esc cancels."));
        }
        const double midHz = (plot->xAxis->range().lower + plot->xAxis->range().upper) * 0.5;
        updateFilterPreview(midHz);
        plot->replot(QCustomPlot::rpQueuedReplot);
    } else {
        m_filterPickStage = FilterPickStage::Idle;
        plot->unsetCursor();
        plot->setMouseTracking(false);
        plot->setSelectionRectMode(QCP::srmZoom);
        clearFilterPreview();
        if (m_measurementPanel && m_measurementPanel->filterHintLabel()) {
            m_measurementPanel->filterHintLabel()->setText(
                tr("1. Click Select Range, then move the mouse and click start and end frequencies.\n"
                   "2. Click Filter & Save and choose output path and sample type."));
        }
    }
}

void MainWindow::onSelectFilterRangeClicked()
{
    if (!ui->freq_widget) {
        return;
    }
    clearFilterOverlays();
    setFilterRangePicking(true);
    ui->freq_widget->replot(QCustomPlot::rpQueuedReplot);
}

void MainWindow::onClearFilterClicked()
{
    setFilterRangePicking(false);
    clearFilterOverlays();
    ui->freq_widget->replot(QCustomPlot::rpQueuedReplot);
    statusBar()->showMessage(tr("Filter range cleared."), 2500);
}

void MainWindow::onFilterAndSaveClicked()
{
    if (m_signalPath.isEmpty()) {
        QMessageBox::information(this, tr("Band Filter"),
                                 tr("Open and play a signal file first."));
        return;
    }
    if (!m_haveFilterRange) {
        QMessageBox::information(this, tr("Band Filter"),
                                 tr("Select a frequency range with two vertical markers first."));
        return;
    }

    const double fLo = qMin(m_filterFStartHz, m_filterFEndHz);
    const double fHi = qMax(m_filterFStartHz, m_filterFEndHz);
    if (fHi - fLo < 1.0) {
        QMessageBox::warning(this, tr("Band Filter"),
                              tr("Selected bandwidth is too narrow."));
        return;
    }

    QString outFileType;
    const QString outPath = promptFilterSavePath(&outFileType);
    if (outPath.isEmpty()) {
        return;
    }

    QString fileType;
    double sampleRate = 0.0;
    double centerFreq = 0.0;
    {
        QMutexLocker lock(&m_offlineParams->mutex);
        fileType = m_offlineParams->fileType;
        sampleRate = m_offlineParams->sampleRate;
        centerFreq = m_offlineParams->centerFreq;
    }

    QProgressDialog progress(tr("Filtering IQ data…"), tr("Cancel"), 0, 100, this);
    progress.setWindowModality(Qt::WindowModal);
    progress.setMinimumDuration(0);
    progress.setValue(0);

    const bool ok = filterIqFile(
        m_signalPath,
        outPath,
        fileType,
        outFileType,
        sampleRate,
        centerFreq,
        fLo,
        fHi,
        [&progress](int pct) {
            progress.setValue(pct);
        });

    if (!ok) {
        QMessageBox::critical(this, tr("Band Filter"),
                              tr("Filtering failed. Check the selected range and file format."));
        return;
    }

    const BandpassParams bp = bandpassParamsFromRange(centerFreq, fLo, fHi);
    statusBar()->showMessage(
        tr("Filtered IQ saved to %1  (%2 Hz BW, FC=%3 Hz)")
            .arg(outPath)
            .arg(bp.bwHz, 0, 'f', 0)
            .arg(bp.fcHz, 0, 'f', 0),
        8000);
    QMessageBox::information(
        this,
        tr("Band Filter"),
        tr("Filtered signal saved as %1 IQ:\n%2\n\nSample rate: %3 Hz\nCenter freq: %4 Hz")
            .arg(outFileType)
            .arg(outPath)
            .arg(sampleRate, 0, 'f', 0)
            .arg(centerFreq, 0, 'f', 0));
}

void MainWindow::clearNoiseFloorPreview()
{
    if (!ui->freq_widget) {
        return;
    }
    if (m_noiseFloorPreviewLine) {
        ui->freq_widget->removeItem(m_noiseFloorPreviewLine);
        m_noiseFloorPreviewLine = nullptr;
    }
    if (m_noiseFloorPreviewLabel) {
        ui->freq_widget->removeItem(m_noiseFloorPreviewLabel);
        m_noiseFloorPreviewLabel = nullptr;
    }
}

void MainWindow::updateNoiseFloorPreview(double thresholdDb)
{
    if (!ui->freq_widget) {
        return;
    }

    QCustomPlot *plot = ui->freq_widget;
    const QCPRange xRange = plot->xAxis->range();
    const double clampedDb = qBound(plot->yAxis->range().lower,
                                    thresholdDb,
                                    plot->yAxis->range().upper);

    if (!m_noiseFloorPreviewLine) {
        m_noiseFloorPreviewLine = new QCPItemLine(plot);
        m_noiseFloorPreviewLine->setLayer(QStringLiteral("overlay"));
        m_noiseFloorPreviewLabel = new QCPItemText(plot);
        m_noiseFloorPreviewLabel->setLayer(QStringLiteral("overlay"));
        m_noiseFloorPreviewLabel->setFont(QFont(QStringLiteral("Segoe UI"), 9, QFont::Bold));
        m_noiseFloorPreviewLabel->setPadding(QMargins(6, 2, 6, 2));
        m_noiseFloorPreviewLabel->setPositionAlignment(Qt::AlignLeft | Qt::AlignVCenter);
    }

    m_noiseFloorPreviewLine->start->setCoords(xRange.lower, clampedDb);
    m_noiseFloorPreviewLine->end->setCoords(xRange.upper, clampedDb);
    QPen previewPen(QColor(245, 158, 11, 225), 2.0, Qt::DashLine);
    previewPen.setCapStyle(Qt::RoundCap);
    m_noiseFloorPreviewLine->setPen(previewPen);

    m_noiseFloorPreviewLabel->position->setCoords(xRange.upper, clampedDb);
    m_noiseFloorPreviewLabel->setText(QStringLiteral("%1 dB").arg(clampedDb, 0, 'f', 1));
    m_noiseFloorPreviewLabel->setColor(QColor(QStringLiteral("#92400E")));
    m_noiseFloorPreviewLabel->setBrush(QColor(255, 251, 235, 235));
    m_noiseFloorPreviewLabel->setPen(QPen(QColor(245, 158, 11, 210), 1.0));
}

void MainWindow::setNoiseFloorPicking(bool enabled)
{
    m_pickingNoiseFloor = enabled;
    if (!ui->freq_widget) {
        return;
    }

    QCustomPlot *plot = ui->freq_widget;
    plot->setSelectionRectMode(enabled ? QCP::srmNone : QCP::srmZoom);
    plot->setMouseTracking(enabled);

    if (enabled) {
        plot->setCursor(Qt::CrossCursor);
        plot->setFocus(Qt::OtherFocusReason);
        statusBar()->showMessage(
            tr("Move the mouse to position the noise floor, then click to confirm."), 0);
        if (m_measurementPanel && m_measurementPanel->channelizerHintLabel()) {
            m_measurementPanel->channelizerHintLabel()->setText(
                tr("Move the mouse — the amber line follows the mouse.\n"
                   "Click to set the noise floor. Right-click or Esc to cancel."));
        }
        const double midDb = (plot->yAxis->range().upper + plot->yAxis->range().lower) * 0.5;
        updateNoiseFloorPreview(midDb);
        plot->replot(QCustomPlot::rpQueuedReplot);
    } else {
        plot->unsetCursor();
        clearNoiseFloorPreview();
        plot->setSelectionRectMode(QCP::srmZoom);
    }
}

bool MainWindow::eventFilter(QObject *watched, QEvent *event)
{
    if (m_filterPickStage != FilterPickStage::Idle && watched == ui->freq_widget) {
        if (event->type() == QEvent::MouseMove) {
            auto *mouse = static_cast<QMouseEvent *>(event);
            const double fHz = ui->freq_widget->xAxis->pixelToCoord(mouse->position().x());
            updateFilterPreview(fHz);
            ui->freq_widget->replot(QCustomPlot::rpQueuedReplot);
            return false;
        }
        if (event->type() == QEvent::MouseButtonPress) {
            auto *mouse = static_cast<QMouseEvent *>(event);
            if (mouse->button() == Qt::LeftButton) {
                ui->freq_widget->setSelectionRectMode(QCP::srmNone);
                return true;
            }
            if (mouse->button() == Qt::RightButton) {
                setFilterRangePicking(false);
                clearFilterOverlays();
                ui->freq_widget->replot(QCustomPlot::rpQueuedReplot);
                statusBar()->showMessage(tr("Filter range selection cancelled."), 2500);
                return true;
            }
        }
        if (event->type() == QEvent::MouseButtonRelease) {
            auto *mouse = static_cast<QMouseEvent *>(event);
            if (mouse->button() == Qt::LeftButton) {
                const double fHz = ui->freq_widget->xAxis->pixelToCoord(mouse->position().x());
                QCustomPlot *plot = ui->freq_widget;
                const double yTop = plot->yAxis->range().upper;
                const double yBot = plot->yAxis->range().lower;
                const QPen linePen(QColor(71, 85, 105, 220), 2.0, Qt::SolidLine);

                if (m_filterPickStage == FilterPickStage::FirstLine) {
                    m_filterFStartHz = fHz;
                    if (!m_filterLineStart) {
                        m_filterLineStart = new QCPItemLine(plot);
                        m_filterLineStart->setLayer(QStringLiteral("overlay"));
                    }
                    m_filterLineStart->start->setCoords(fHz, yBot);
                    m_filterLineStart->end->setCoords(fHz, yTop);
                    m_filterLineStart->setPen(linePen);
                    m_filterPickStage = FilterPickStage::SecondLine;
                    clearFilterPreview();
                    updateFilterPreview(fHz);
                    statusBar()->showMessage(
                        tr("Move the mouse to the end frequency, then click to confirm."), 0);
                    if (m_measurementPanel && m_measurementPanel->filterHintLabel()) {
                        m_measurementPanel->filterHintLabel()->setText(
                            tr("The dashed line follows the mouse.\n"
                               "Click to set the end frequency. Right-click or Esc cancels."));
                    }
                } else {
                    m_filterFEndHz = fHz;
                    if (!m_filterLineEnd) {
                        m_filterLineEnd = new QCPItemLine(plot);
                        m_filterLineEnd->setLayer(QStringLiteral("overlay"));
                    }
                    m_filterLineEnd->start->setCoords(fHz, yBot);
                    m_filterLineEnd->end->setCoords(fHz, yTop);
                    m_filterLineEnd->setPen(linePen);
                    m_haveFilterRange = true;
                    clearFilterPreview();
                    setFilterRangePicking(false);
                    updateFilterBandOverlay();
                    statusBar()->showMessage(
                        tr("Filter range: %1 – %2")
                            .arg(formatHertz(qMin(m_filterFStartHz, m_filterFEndHz)))
                            .arg(formatHertz(qMax(m_filterFStartHz, m_filterFEndHz))),
                        5000);
                    if (m_measurementPanel && m_measurementPanel->filterHintLabel()) {
                        m_measurementPanel->filterHintLabel()->setText(
                            tr("Range set. Click Filter & Save to export filtered IQ."));
                    }
                }
                plot->replot(QCustomPlot::rpQueuedReplot);
                return true;
            }
        }
        if (event->type() == QEvent::KeyPress) {
            auto *key = static_cast<QKeyEvent *>(event);
            if (key->key() == Qt::Key_Escape) {
                setFilterRangePicking(false);
                clearFilterOverlays();
                ui->freq_widget->replot(QCustomPlot::rpQueuedReplot);
                statusBar()->showMessage(tr("Filter range selection cancelled."), 2500);
                return true;
            }
        }
    }

    if (m_pickingNoiseFloor && watched == ui->freq_widget) {
        if (event->type() == QEvent::MouseMove) {
            auto *mouse = static_cast<QMouseEvent *>(event);
            const double thresholdDb =
                ui->freq_widget->yAxis->pixelToCoord(mouse->position().y());
            updateNoiseFloorPreview(thresholdDb);
            ui->freq_widget->replot(QCustomPlot::rpQueuedReplot);
            return false;
        }
        if (event->type() == QEvent::MouseButtonPress) {
            auto *mouse = static_cast<QMouseEvent *>(event);
            if (mouse->button() == Qt::LeftButton) {
                ui->freq_widget->setSelectionRectMode(QCP::srmNone);
                return true;
            }
            if (mouse->button() == Qt::RightButton) {
                setNoiseFloorPicking(false);
                ui->freq_widget->replot(QCustomPlot::rpQueuedReplot);
                statusBar()->showMessage(tr("Noise floor selection cancelled."), 2500);
                return true;
            }
        }
        if (event->type() == QEvent::MouseButtonRelease) {
            auto *mouse = static_cast<QMouseEvent *>(event);
            if (mouse->button() == Qt::LeftButton) {
                const double thresholdDb =
                    ui->freq_widget->yAxis->pixelToCoord(mouse->position().y());
                if (m_noiseFloorPreviewLine) {
                    m_noiseFloorPreviewLine->setPen(
                        QPen(QColor(239, 68, 68, 240), 2.2, Qt::SolidLine));
                    ui->freq_widget->replot(QCustomPlot::rpQueuedReplot);
                }
                setNoiseFloorPicking(false);
                runChannelizer(false, thresholdDb);
                return true;
            }
        }
        if (event->type() == QEvent::KeyPress) {
            auto *key = static_cast<QKeyEvent *>(event);
            if (key->key() == Qt::Key_Escape) {
                setNoiseFloorPicking(false);
                ui->freq_widget->replot(QCustomPlot::rpQueuedReplot);
                statusBar()->showMessage(tr("Noise floor selection cancelled."), 2500);
                return true;
            }
        }
    }
    return QMainWindow::eventFilter(watched, event);
}

bool MainWindow::computeChannelizerSpectrum(int numPackets,
                                            QVector<double> &xHz,
                                            QVector<double> &yDb)
{
    if (!m_timeBuffer || m_fftSize == 0 || !m_guiFftPlan || !m_offlineParams) {
        return false;
    }

    const int n = static_cast<int>(m_fftSize);
    const double fs = m_offlineParams->sampleRate;
    const double fc = m_offlineParams->centerFreq;
    const double df = (fs > 0.0) ? (fs / static_cast<double>(n)) : 1.0;

    // Pre-compute Hanning window and its power for normalisation.
    std::vector<float> win(static_cast<size_t>(n));
    double windowPower = 0.0;
    for (int i = 0; i < n; ++i) {
        win[static_cast<size_t>(i)] = hanningWindow(i, n);
        windowPower += static_cast<double>(win[static_cast<size_t>(i)]
                                           * win[static_cast<size_t>(i)]);
    }
    if (windowPower <= 0.0) {
        windowPower = 1.0;
    }
    const double correction = 1.0 / windowPower;

    // Accumulate linear power over numPackets frames.
    std::vector<double> linearAcc(static_cast<size_t>(n), 0.0);
    int packetsDone = 0;
    const int maxWaitMs = 500; // Total wait budget
    const int sliceMs   = 5;
    int waitedMs = 0;

    while (packetsDone < numPackets) {
        if (m_timeBuffer->size() < m_fftSize) {
            if (waitedMs >= maxWaitMs) {
                break;
            }
            QThread::msleep(sliceMs);
            waitedMs += sliceMs;
            continue;
        }

        std::vector<std::complex<float>> samples;
        try {
            samples = m_timeBuffer->read(static_cast<long>(m_fftSize));
        } catch (...) {
            break;
        }
        if (static_cast<int>(samples.size()) != n) {
            break;
        }

        for (int i = 0; i < n; ++i) {
            m_guiFftIn[static_cast<size_t>(i)][0] =
                static_cast<double>(samples[static_cast<size_t>(i)].real()
                                    * win[static_cast<size_t>(i)]);
            m_guiFftIn[static_cast<size_t>(i)][1] =
                static_cast<double>(samples[static_cast<size_t>(i)].imag()
                                    * win[static_cast<size_t>(i)]);
        }
        fftw_execute(m_guiFftPlan);

        const int half = n >> 1;
        for (int i = 0; i < n; ++i) {
            const int si = (i + half) % n;
            const double re = m_guiFftOut[static_cast<size_t>(i)][0];
            const double im = m_guiFftOut[static_cast<size_t>(i)][1];
            linearAcc[static_cast<size_t>(si)] += (re * re + im * im) * correction;
        }
        ++packetsDone;
        waitedMs = 0;
    }

    if (packetsDone == 0) {
        return false;
    }

    xHz.resize(n);
    yDb.resize(n);
    const double startFreq = fc - fs * 0.5;
    const double scale = 1.0 / static_cast<double>(packetsDone);
    for (int i = 0; i < n; ++i) {
        xHz[i] = startFreq + static_cast<double>(i) * df;
        yDb[i] = 10.0 * std::log10(std::max(linearAcc[static_cast<size_t>(i)] * scale,
                                             1.0e-12));
    }
    return true;
}

void MainWindow::runChannelizer(bool automatic, double manualThresholdDb)
{
    // Collect and average multiple FFT packets so the detector always receives
    // a smooth spectrum, independent of the current trace display mode.
    constexpr int kChanPackets = 20;
    QVector<double> freqHz;
    QVector<double> psdDb;
    const bool haveAvg = computeChannelizerSpectrum(kChanPackets, freqHz, psdDb);
    if (!haveAvg) {
        // Fall back to whatever the trace currently displays.
        if (!m_spectrumTraces || !m_spectrumTraces->copyDisplayedSpectrum(&freqHz, &psdDb)) {
            QMessageBox::information(this, tr("Channelizer"),
                                     tr("No spectrum data is available yet."));
            return;
        }
    }


    const QCPRange vis = ui->freq_widget->xAxis->range();
    ChannelDetectConfig cfg;
    cfg.fMinHz = vis.lower;
    cfg.fMaxHz = vis.upper;
    cfg.automaticNoiseFloor = automatic;
    cfg.manualThresholdDb = manualThresholdDb;
    cfg.smoothBins = 3;
    cfg.minBins = 3;
    cfg.mergeGapBins = 24;
    cfg.minSnrDb = 3.0;
    cfg.mergeImbalanceDb = 8.0;
    cfg.mergeShallowDipDb = 2.5;
    cfg.edgeDropDb = 12.0;
    cfg.saddleFillDb = 3.0;
    // Occupancy follows the drawn noise-floor line. A 1 dB enter margin
    // rejects noise spikes; exit stays on the floor so edges do not shrink.
    cfg.enterMarginDb = 1.0;
    cfg.exitMarginDb = 0.0;
    cfg.noisePercentile = 0.20;

    double noiseFloorDb = manualThresholdDb;
    const QVector<DetectedChannel> channels =
        ChannelDetector::detect(freqHz, psdDb, cfg, &noiseFloorDb);

    showChannelizerResults(channels, cfg.fMinHz, cfg.fMaxHz, noiseFloorDb);
}

void MainWindow::clearChannelizerOverlays()
{
    if (m_channelAnimTimer) {
        m_channelAnimTimer->stop();
    }
    if (!ui->freq_widget) {
        return;
    }
    for (ChannelBandItem *item : m_channelBands) {
        ui->freq_widget->removeItem(item);
    }
    m_channelBands.clear();
    if (m_noiseFloorLine) {
        ui->freq_widget->removeItem(m_noiseFloorLine);
        m_noiseFloorLine = nullptr;
    }
    if (m_roiRect) {
        ui->freq_widget->removeItem(m_roiRect);
        m_roiRect = nullptr;
    }
}

void MainWindow::onChannelAnimTick()
{
    if (!ui->freq_widget || m_channelBands.isEmpty()) {
        if (m_channelAnimTimer) {
            m_channelAnimTimer->stop();
        }
        return;
    }

    const qint64 elapsed = QDateTime::currentMSecsSinceEpoch() - m_channelAnimStartMs;
    const qreal fadeT = qMin(1.0, elapsed / 650.0);
    m_channelFadeAlpha = 1.0 - std::pow(1.0 - fadeT, 3.0);
    const qreal shimmerPhase = std::fmod(elapsed / 2800.0, 1.0);

    for (int i = 0; i < m_channelBands.size(); ++i) {
        ChannelBandItem *band = m_channelBands[i];
        band->setFadeAlpha(m_channelFadeAlpha);
        band->setAnimationPhase(shimmerPhase + static_cast<qreal>(i) * 0.11);
    }

    ui->freq_widget->replot(QCustomPlot::rpQueuedReplot);
}

void MainWindow::showChannelizerResults(const QVector<DetectedChannel> &channels,
                                        double fMinHz,
                                        double fMaxHz,
                                        double noiseFloorDb)
{
    clearChannelizerOverlays();

    QCustomPlot *plot = ui->freq_widget;
    const double yTop = plot->yAxis->range().upper;
    const double yBot = plot->yAxis->range().lower;

    m_roiRect = new QCPItemRect(plot);
    m_roiRect->topLeft->setCoords(fMinHz, yTop);
    m_roiRect->bottomRight->setCoords(fMaxHz, yBot);
    m_roiRect->setPen(QPen(QColor(71, 85, 105, 150), 1.2, Qt::DashDotLine));
    m_roiRect->setBrush(QColor(71, 85, 105, 14));
    m_roiRect->setLayer(QStringLiteral("overlay"));

    const QColor channelAccent = channelAccentColor();

    for (int i = 0; i < channels.size(); ++i) {
        const DetectedChannel &ch = channels[i];

        auto *band = new ChannelBandItem(plot);
        band->topLeft->setCoords(ch.fStartHz, yTop);
        band->bottomRight->setCoords(ch.fStopHz, yBot);
        band->setChannelColor(channelAccent);
        band->setChannelIndex(i + 1);
        band->setPeakDb(ch.peakDb);
        band->setBandwidthLabel(formatHertz(ch.bandwidthHz));
        band->setAnimationPhase(static_cast<qreal>(i) * 0.11);
        band->setFadeAlpha(0.0);
        band->setLayer(QStringLiteral("overlay"));
        m_channelBands.append(band);
    }

    m_noiseFloorLine = new QCPItemLine(plot);
    m_noiseFloorLine->start->setCoords(fMinHz, noiseFloorDb);
    m_noiseFloorLine->end->setCoords(fMaxHz, noiseFloorDb);
    m_noiseFloorLine->setPen(QPen(QColor(255, 82, 82, 210), 1.8, Qt::DashLine));
    m_noiseFloorLine->setLayer(QStringLiteral("overlay"));

    m_channelAnimStartMs = QDateTime::currentMSecsSinceEpoch();
    m_channelFadeAlpha = 0.0;
    if (m_channelAnimTimer && !channels.isEmpty()) {
        m_channelAnimTimer->start();
    }

    if (m_channelResultsTable) {
        QTableWidget *table = m_channelResultsTable;
        table->setRowCount(channels.size());
        for (int i = 0; i < channels.size(); ++i) {
            const DetectedChannel &ch = channels[i];
            const auto makeCell = [](const QString &text, bool isNumber = false) {
                auto *item = new QTableWidgetItem(text);
                item->setTextAlignment(Qt::AlignCenter);
                if (isNumber) {
                    item->setFont(QFont(QStringLiteral("Monospace"), 9));
                }
                return item;
            };
            table->setItem(i, 0, makeCell(QString::number(i + 1)));
            table->setItem(i, 1, makeCell(formatHertz(ch.fStartHz), true));
            table->setItem(i, 2, makeCell(formatHertz(ch.fStopHz), true));
            table->setItem(i, 3, makeCell(formatHertz(ch.bandwidthHz), true));
            table->setItem(i, 4, makeCell(
                QStringLiteral("%1 dB").arg(ch.peakDb, 0, 'f', 1), true));
        }
    }

    if (m_measurementPanel && m_measurementPanel->channelizerHintLabel()) {
        m_measurementPanel->channelizerHintLabel()->setText(
            tr("Found %1 channel(s). Noise floor %2 dB. See table below waterfall.")
                .arg(channels.size())
                .arg(noiseFloorDb, 0, 'f', 1));
    }

    plot->replot(QCustomPlot::rpQueuedReplot);
    if (channels.isEmpty()) {
        statusBar()->showMessage(tr("No occupied channels found in the selected range."), 4000);
    } else {
        statusBar()->showMessage(tr("Channelizer found %1 channel(s).").arg(channels.size()), 4000);
    }
}