Jungfraujoch/viewer/widgets/JFJochViewerSettingsDock.h

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

#pragma once

#include <QWidget>
#include <memory>

#include "../../common/DiffractionExperiment.h"
#include "../../common/IndexingSettings.h"
#include "../../common/AzimuthalIntegrationSettings.h"
#include "../../common/BraggIntegrationSettings.h"
#include "../../common/ScalingSettings.h"
#include "../../image_analysis/spot_finding/SpotFindingSettings.h"
#include "../../reader/JFJochReaderDataset.h"
#include "../../reader/JFJochReaderImage.h"
#include "../../rugnux/Rugnux.h"   // ProcessMode
#include "../ReferenceMtzInfo.h"
#include "PowderCalibrationWidget.h"   // CalibrationSelection

class QStackedWidget;
class QCheckBox;
class QComboBox;
class QLabel;
class QPushButton;
class SliderPlusBox;
class NumberLineEdit;

// The single, always-visible settings panel: an MX / AzInt / Calib toggle picks the page, and the panel
// is the one place all processing settings live (there is no separate window, so no synchronisation).
// "Analyze image" / "Analyze dataset" sit on top; the page choice decides what a dataset run does.
// Edits feed straight back into the running analysis via the worker.
class JFJochViewerSettingsDock : public QWidget {
    Q_OBJECT
public:
    JFJochViewerSettingsDock(const SpotFindingSettings &spot, const IndexingSettings &indexing,
                             const AzimuthalIntegrationSettings &azint, const BraggIntegrationSettings &bragg,
                             const ScalingSettings &scaling, QWidget *parent = nullptr);

public slots:
    void datasetLoaded(std::shared_ptr<const JFJochReaderDataset> dataset);
    void loadImage(std::shared_ptr<const JFJochReaderImage> image);
    void referenceLoaded(ReferenceMtzInfo info);   // worker reports a (un)loaded reference MTZ
    // Dataset re-processing reads a stored HDF5 file, so it is unavailable on a live HTTP stream:
    // grey out "Analyze dataset" while connected rather than failing with a dialog afterwards.
    void setHttpConnection(bool connected, QString addr);

signals:
    void spotFindingChanged(const SpotFindingSettings &spot, const IndexingSettings &indexing, int64_t max_spots);
    void azintChanged(const AzimuthalIntegrationSettings &settings);
    void braggChanged(BraggIntegrationSettings settings);
    void scalingChanged(ScalingSettings settings);
    void experimentChanged(const DiffractionExperiment &experiment);
    void findBeamCenter(QVector<float> ring_q, bool guess);
    void ringsFromCalibration(QVector<float> rings);
    void referenceSelected(QString path, QString column);   // user picked a reference MTZ / column
    void reanalyzeImage(bool armed);                        // "Analyze image" toggle
    // "Analyze dataset". The mode is the selected page; the calibrant selection is only read for
    // ProcessMode::Calibration and is carried along so the job needs no second copy of the controls.
    void analyzeDataset(ProcessMode mode, CalibrationSelection calibration);

private:
    SpotFindingSettings spot_;
    IndexingSettings indexing_;
    AzimuthalIntegrationSettings azint_;
    BraggIntegrationSettings bragg_;
    ScalingSettings scaling_;
    DiffractionExperiment experiment_;
    bool have_experiment_ = false;     // geometry edits only take effect once a dataset is loaded
    int64_t max_spots_ = 1000;
    // Min-pix is kept as the pair the UI shows - the fixed value AND whether to choose it per image -
    // because spot_.min_pix_per_spot can only hold one of the two (unset = per image). SyncMinPix()
    // turns the pair into that field, and per-image only ever applies to stills.
    bool adaptive_min_pix_ = false;
    int64_t min_pix_value_ = 2;
    ProcessMode mode_ = ProcessMode::FullAnalysis;   // the selected page, and what "Analyze dataset" runs

    // "Analyze dataset" hero button, disabled while a live HTTP source is connected.
    QPushButton *analyzeDatasetBtn_ = nullptr;

    // Indexing-algorithm combo + the description line under it (kept so the Auto resolution refreshes).
    QComboBox *algo_ = nullptr;
    QLabel *algoDesc_ = nullptr;
    // "Process as stills" — kept so datasetLoaded can enable it only when the dataset has a goniometer
    // (a rotation dataset); it drives indexing/scaling mode via ApplyProcessingMode().
    QCheckBox *stills_ = nullptr;

    // Geometry fields (shared by both MX and AzInt, since both need the same geometry)
    NumberLineEdit *energy_ = nullptr;
    NumberLineEdit *distance_ = nullptr;
    NumberLineEdit *beamX_ = nullptr;
    NumberLineEdit *beamY_ = nullptr;
    NumberLineEdit *rot1_ = nullptr;     // detector tilt (PONI rot1), deg
    NumberLineEdit *rot2_ = nullptr;     // detector tilt (PONI rot2), deg
    // Crystal fields
    QCheckBox *cellKnown_ = nullptr;
    NumberLineEdit *cellA_ = nullptr, *cellB_ = nullptr, *cellC_ = nullptr;
    NumberLineEdit *cellAlpha_ = nullptr, *cellBeta_ = nullptr, *cellGamma_ = nullptr;
    NumberLineEdit *spaceGroup_ = nullptr;
    QLabel *spaceGroupName_ = nullptr;   // resolved Hermann–Mauguin symbol

    // Reference dataset (MTZ) for scaling / CCref. The chosen file is remembered so a
    // column change re-loads the same file; the worker owns the reflections, this just drives it.
    QPushButton *refButton_ = nullptr;
    QComboBox *refColumn_ = nullptr;
    QLabel *refSummary_ = nullptr;
    QLabel *refWarning_ = nullptr;
    QString refPath_;

    PowderCalibrationWidget *powder_ = nullptr;

    QWidget *BuildGeometrySection();
    QWidget *BuildMXPage();
    QWidget *BuildBraggSection();
    QWidget *BuildScalingSection();
    QWidget *BuildReferenceSection();
    QWidget *BuildAzIntPage();
    QWidget *BuildCalibrationPage();
    void SyncMinPix();
    void EmitSpotFinding();
    void EmitExperiment();
    void ApplyProcessingMode();   // "Process as stills" -> indexing + scaling rotation/stills mode
    void UpdateAlgorithmDescription();
    void RefreshGeometryFields();
    void UpdateSpaceGroupName();
};