// Copyright (2019-2023) Paul Scherrer Institute

#ifndef DIFFRACTIONEXPERIMENT_H
#define DIFFRACTIONEXPERIMENT_H

#include <chrono>
#include <exception>
#include <optional>

#include "../compression/CompressionAlgorithmEnum.h"

#include "UnitCell.h"
#include "Coord.h"
#include "Definitions.h"
#include "../frame_serialize/JFJochMessages.h"
#include "DetectorSetup.h"
#include "../image_analysis/SpotFindingSettings.h"

enum class DetectorMode {
    Conversion, Raw, PedestalG0, PedestalG1, PedestalG2
};

enum class FPGAPixelOutput {
    Auto, Int16, Uint16, Int32, Uint32
};

struct AcquisitionDeviceNetConfig {
    std::string mac_addr;
    std::string ipv4_addr;
    uint64_t udp_port;
};

struct DetectorModuleConfig {
    uint64_t udp_dest_port_1;
    uint64_t udp_dest_port_2;
    std::string ipv4_src_addr_1;
    std::string ipv4_src_addr_2;
    std::string ipv4_dest_addr_1;
    std::string ipv4_dest_addr_2;
    std::string mac_addr_dest_1;
    std::string mac_addr_dest_2;
    uint64_t module_id_in_data_stream;
};

class DiffractionExperiment {
    // Internal detector settings
    std::chrono::microseconds frame_time_pedestalG1G2;
    //   uint64 frame_time_pedestalG2_us = 2; reserved
    std::chrono::microseconds frame_time;
    std::chrono::microseconds count_time;

    DetectorSetup detector;

    int64_t ndatastreams;

    bool internal_fpga_packet_generator;
    int64_t storage_cells;
    int64_t storage_cell_start;
    std::chrono::nanoseconds storage_cell_delay;
    std::chrono::nanoseconds detector_delay;
    int64_t pedestal_g0_frames;
    int64_t pedestal_g1_frames;
    int64_t pedestal_g2_frames;
    bool use_gain_hg0;
    bool fix_gain_g1;

    std::chrono::microseconds preview_period;

    DetectorMode mode;
    bool mask_module_edges;
    bool mask_chip_edges;

    int64_t ipv4_base_addr;

    float low_q;
    float high_q;
    float q_spacing;

    std::string git_sha1;
    std::string git_date;

    std::string source_name;
    std::string source_name_short;
    std::string instrument_name;
    std::string instrument_name_short;
    bool pulsed_source;

    bool debug_pixel_mask;
    Coord default_omega_axis;

    bool conversion_on_fpga;

    uint64_t series_id;

    std::string neural_net_model_path;

    // Dataset settings
    struct {
        int64_t images_per_trigger;
        int64_t ntrigger;

        FPGAPixelOutput fpga_pixel_output;
        int64_t summation;

        float beam_x_pxl;
        float beam_y_pxl;
        float detector_distance_mm;
        float photon_energy_keV;
        float photon_energy_multiplier;

        std::string file_prefix;
        int64_t data_file_count;

        CompressionAlgorithm compression;

        std::string sample_name;
        std::optional<UnitCell> unit_cell;
        int64_t space_group_number;

        bool rad_int_solid_angle_corr;
        bool rad_int_polarization_corr;
        float rad_int_polarization_factor;

        bool save_calibration;
        std::optional<float> total_flux;
        std::optional<float> attenuator_transmission;
        std::optional<float> omega_step;
        float omega_start;
        std::string image_appendix;
        std::string header_appendix;

        Coord omega_rotation_axis;
        std::optional<ROIRectangle> roi_sum;
    } dataset;

    constexpr static const int64_t max_spot_count = 100;
public:
    // Public methods are atomic
    DiffractionExperiment();
    DiffractionExperiment(const DetectorSetup& geom);

    // Methods below can be chained together
    DiffractionExperiment& Detector(const DetectorSetup& input);
    DiffractionExperiment& Mode(DetectorMode input);
    DiffractionExperiment& DataStreams(int64_t input);

    DiffractionExperiment& ImagesPerTrigger(int64_t input);
    DiffractionExperiment& NumTriggers(int64_t triggers);

    DiffractionExperiment& PedestalG0Frames(int64_t input);
    DiffractionExperiment& PedestalG1Frames(int64_t input);
    DiffractionExperiment& PedestalG2Frames(int64_t input);
    DiffractionExperiment& FrameTime(std::chrono::microseconds frame_time,
                                     std::chrono::microseconds in_count_time = std::chrono::microseconds(0));
    DiffractionExperiment& PedestalG1G2FrameTime(std::chrono::microseconds input);
    DiffractionExperiment& PhotonEnergy_keV(float input);
    DiffractionExperiment& BeamX_pxl(float input);
    DiffractionExperiment& BeamY_pxl(float input);
    DiffractionExperiment& DetectorDistance_mm(float input);

    DiffractionExperiment& FilePrefix(std::string input);
    DiffractionExperiment& DataFileCount(int64_t input);

    DiffractionExperiment& Compression(CompressionAlgorithm input);
    DiffractionExperiment& PreviewPeriod(std::chrono::microseconds input);

    DiffractionExperiment& UseInternalPacketGenerator(bool input);
    DiffractionExperiment& IPv4BaseAddr(std::string input);
    DiffractionExperiment& MaskModuleEdges(bool input);
    DiffractionExperiment& MaskChipEdges(bool input);
    DiffractionExperiment& SetUnitCell(const std::optional<UnitCell> &cell);

    DiffractionExperiment& LowResForAzimInt_A(float input);
    DiffractionExperiment& HighResForAzimInt_A(float input);
    DiffractionExperiment& LowQForAzimInt_recipA(float input);
    DiffractionExperiment& HighQForAzimInt_recipA(float input);
    DiffractionExperiment& QSpacingForAzimInt_recipA(float input);

    DiffractionExperiment& SpaceGroupNumber(int64_t input);
    DiffractionExperiment& StorageCells(int64_t input);
    DiffractionExperiment& StorageCellStart(int64_t input = 15);
    DiffractionExperiment& SampleName(std::string input);

    DiffractionExperiment& SourceName(std::string input);
    DiffractionExperiment& SourceNameShort(std::string input);
    DiffractionExperiment& InstrumentName(std::string input);
    DiffractionExperiment& InstrumentNameShort(std::string input);
    DiffractionExperiment& ApplyPixelMaskInFPGA(bool input);
    DiffractionExperiment& AttenuatorTransmission(const std::optional<float> &input);
    DiffractionExperiment& TotalFlux(const std::optional<float> &input);
    DiffractionExperiment& OmegaStep(const std::optional<float> &input);
    DiffractionExperiment& OmegaStart(float input);
    DiffractionExperiment& OmegaAxis(const Coord &c);
    DiffractionExperiment& OmegaAxis();
    DiffractionExperiment& DefaultOmegaAxis(const Coord &c);

    DiffractionExperiment& UsingGainHG0(bool input);
    DiffractionExperiment& FixedGainG1(bool input);
    DiffractionExperiment& HeaderAppendix(const std::string& input);
    DiffractionExperiment& ImageAppendix(const std::string& input);
    DiffractionExperiment& IncrementSeriesID();
    DiffractionExperiment& ROISummation(const std::optional<ROIRectangle>& input);
    DiffractionExperiment& ConversionOnFPGA(bool input);
    DiffractionExperiment& NeuralNetModelPath(const std::string& input);
    DiffractionExperiment& PulsedSource(bool input);
    DiffractionExperiment& PhotonEnergyMultiplayer(float input);

    void FillMessage(StartMessage &message) const;

    static void CheckDataProcessingSettings(const SpotFindingSettings& settings);
    static SpotFindingSettings DefaultDataProcessingSettings();
    DetectorMode GetDetectorMode() const;

    int64_t GetPixelDepth() const;
    bool IsPixelSigned() const;
    int64_t GetOverflow() const;
    int64_t GetUnderflow() const;

    int64_t GetNumTriggers() const;
    int64_t GetImageNum() const;
    int64_t GetImageNumPerTrigger() const;

    int64_t GetPedestalG0Frames() const;
    int64_t GetPedestalG1Frames() const;
    int64_t GetPedestalG2Frames() const;

    int64_t GetFrameNum() const;
    int64_t GetFrameNumPerTrigger() const;

    std::chrono::microseconds GetFrameTime() const;
    std::chrono::microseconds GetImageTime() const;

    std::chrono::microseconds GetImageCountTime() const;
    std::chrono::microseconds GetFrameCountTime() const;

    DiffractionExperiment& StorageCellDelay(std::chrono::nanoseconds input);
    std::chrono::nanoseconds GetStorageCellDelay() const;

    DiffractionExperiment& DetectorDelay(std::chrono::nanoseconds input);
    std::chrono::nanoseconds GetDetectorDelay() const;

    float GetPhotonEnergy_keV() const;
    float GetWavelength_A() const;
    float GetBeamX_pxl() const;
    float GetBeamY_pxl() const;
    float GetDetectorDistance_mm() const;

    Coord GetScatteringVector() const;

    std::string GetFilePrefix() const;
    int64_t GetDataFileCount() const;

    CompressionAlgorithm GetCompressionAlgorithm() const;

    int64_t GetMaxCompressedSize() const;

    int64_t GetDataStreamsNum() const;
    int64_t GetModulesNum(uint16_t data_stream) const;
    int64_t GetModulesNum() const;
    int64_t GetFirstModuleOfDataStream(uint16_t data_stream) const;

    int64_t GetPixelsNum() const;
    int64_t GetYPixelsNum() const;
    int64_t GetXPixelsNum() const;
    int64_t GetPixel0OfModule(uint16_t module_number) const;
    int64_t GetModuleFastDirectionStep(uint16_t module_number) const;
    int64_t GetModuleSlowDirectionStep(uint16_t module_number) const;

    Coord GetModuleFastDirection(uint16_t module_number) const;
    Coord GetModuleSlowDirection(uint16_t module_number) const;

    std::chrono::microseconds GetPreviewPeriod() const;

    int64_t GetSpotFindingBin() const;

    bool IsUsingInternalPacketGen() const;

    uint32_t GetSrcIPv4Address(uint32_t data_stream, uint32_t half_module) const;

    bool CheckGitSha1Consistent() const;
    std::string CheckGitSha1Msg() const;

    bool GetMaskModuleEdges() const;
    bool GetMaskChipEdges() const;
    std::optional<UnitCell> GetUnitCell() const;

    Coord LabCoord(float detector_x, float detector_y) const;

    float GetLowQForAzimInt_recipA() const;
    float GetHighQForAzimInt_recipA() const;
    float GetQSpacingForAzimInt_recipA() const;

    float GetLowQForBkgEstimate_recipA() const;
    float GetHighQForBkgEstimate_recipA() const;

    int64_t GetSpaceGroupNumber() const;

    int64_t GetStorageCellNumber() const;
    int64_t GetStorageCellStart() const;

    int64_t GetMaxSpotCount() const;
    std::string GetSampleName() const;

    bool GetApplyPixelMaskInFPGA() const;
    float GetPixelSize_mm() const;
    std::string GetSourceName() const;
    std::string GetSourceNameShort() const;
    std::string GetInstrumentName() const;
    std::string GetInstrumentNameShort() const;
    std::string GetDetectorDescription() const;

    std::vector<std::string> GetDetectorModuleHostname() const;

    DiffractionExperiment& ApplySolidAngleCorr(bool input);
    DiffractionExperiment& ApplyPolarizationCorr(bool input);
    DiffractionExperiment& PolarizationFactor(float input);
    bool GetApplySolidAngleCorr() const;
    bool GetApplyPolarizationCorr() const;
    float GetPolarizationFactor() const;

    DiffractionExperiment& SaveCalibration(bool input);
    bool GetSaveCalibration() const;

    DiffractionExperiment& Summation(int64_t input);
    int64_t GetSummation() const;

    DiffractionExperiment& FPGAOutputMode(FPGAPixelOutput input);
    FPGAPixelOutput GetFPGAOutputMode() const;

    int64_t GetUDPInterfaceCount() const;
    std::vector<DetectorModuleConfig> GetDetectorModuleConfig(const std::vector<AcquisitionDeviceNetConfig>& net_config) const;
    std::optional<float> GetAttenuatorTransmission() const;
    std::optional<float> GetTotalFlux() const;
    std::optional<float> GetOmegaStep() const;
    float GetOmegaStart() const;
    Coord GetOmegaAxis() const;
    Coord GetDefaultOmegaAxis() const;

    bool IsFixedGainG1() const;
    bool IsUsingGainHG0() const;
    std::string GetHeaderAppendix() const;
    std::string GetImageAppendix() const;

    uint64_t GetSeriesID() const;
    std::string GetSeriesIDString() const;
    std::optional<ROIRectangle> GetROISummation() const;
    bool IsConversionOnFPGA() const;

    const DetectorSetup& GetDetectorSetup() const;
    std::string GetNeuralNetModelPath() const;

    bool IsPulsedSource() const;

    bool IsSpotFindingEnabled() const;

    float GetPhotonEnergyForConversion_keV() const;
    float GetPhotonEnergyMultiplier() const;

};

inline int64_t CalculateStride(const std::chrono::microseconds &frame_time, const std::chrono::microseconds &preview_time) {
    if ((preview_time.count() <= 0) || (frame_time.count() <= 0))
        return 0;
    else if (preview_time < frame_time)
        return 1;
    else
        return preview_time / frame_time;
}

#endif //DIFFRACTIONEXPERIMENT_H