// Copyright (2019-2023) Paul Scherrer Institute
// Using OpenAPI licensed with Apache License 2.0

#include <nlohmann/json.hpp>
#include "JFJochBrokerHttp.h"
#include "gen/model/Error_message.h"

// From https://en.cppreference.com/w/cpp/string/byte/tolower
inline std::string str_tolower(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), [](unsigned char c){ return std::tolower(c); });
    return s;
}

inline SpotFindingSettings Convert(const org::openapitools::server::model::Spot_finding_settings &input) {
    SpotFindingSettings ret{};
    ret.signal_to_noise_threshold = input.getSignalToNoiseThreshold();
    ret.photon_count_threshold = input.getPhotonCountThreshold();
    ret.min_pix_per_spot = input.getMinPixPerSpot();
    ret.max_pix_per_spot = input.getMaxPixPerSpot();
    ret.high_resolution_limit = input.getHighResolutionLimit();
    ret.low_resolution_limit = input.getLowResolutionLimit();
    ret.preview_indexed_only = input.previewIndexedOnlyIsSet() ? input.isPreviewIndexedOnly() : false;
    return ret;
}

inline org::openapitools::server::model::Spot_finding_settings Convert(const SpotFindingSettings &input) {
    org::openapitools::server::model::Spot_finding_settings ret;
    ret.setSignalToNoiseThreshold(input.signal_to_noise_threshold);
    ret.setPhotonCountThreshold(input.photon_count_threshold);
    ret.setMinPixPerSpot(input.min_pix_per_spot);
    ret.setMaxPixPerSpot(input.max_pix_per_spot);
    ret.setHighResolutionLimit(input.high_resolution_limit);
    ret.setLowResolutionLimit(input.low_resolution_limit);
    ret.setPreviewIndexedOnly(input.preview_indexed_only);
    return ret;
}

inline org::openapitools::server::model::Measurement_statistics Convert(const MeasurementStatistics &input) {
    org::openapitools::server::model::Measurement_statistics ret{};

    if (!input.file_prefix.empty())
        ret.setFilePrefix(input.file_prefix);

    ret.setImagesExpected(input.images_expected);
    ret.setImagesCollected(input.images_collected);
    ret.setImagesSent(input.images_sent);
    ret.setMaxImageNumberSent(input.max_image_number_sent);
    if (input.collection_efficiency >= 0.0)
        ret.setCollectionEfficiency(input.collection_efficiency);
    ret.setCompressionRatio(input.compression_ratio);

    ret.setCancelled(input.cancelled);
    ret.setMaxReceiverDelay(input.max_receive_delay);

    ret.setDetectorWidth(input.detector_width);
    ret.setDetectorHeight(input.detector_height);
    ret.setDetectorPixelDepth(input.detector_pixel_depth);

    if (input.indexing_rate >= 0.0)
        ret.setIndexingRate(input.indexing_rate);

    if (input.bkg_estimate >= 0.0)
        ret.setBkgEstimate(input.bkg_estimate);

    return ret;
}

inline DetectorSettings Convert(const org::openapitools::server::model::Detector_settings &input) {
    DetectorSettings ret{};

    ret.frame_time_us = input.getFrameTimeUs();
    if (input.countTimeUsIsSet())
        ret.count_time_us = input.getCountTimeUs();

    ret.storage_cell_count = input.getStorageCellCount();

    ret.use_internal_packet_generator = input.isInternalFrameGenerator();
    ret.collect_raw_data = input.isCollectRawData();
    ret.fixed_gain_g1 = input.isFixedGainG1();
    ret.use_gain_hg0 = input.isUseGainHg0();

    if (input.pedestalG0FramesIsSet())
        ret.pedestal_g0_frames = input.getPedestalG0Frames();
    if (input.pedestalG1FramesIsSet())
        ret.pedestal_g1_frames = input.getPedestalG1Frames();
    if (input.pedestalG2FramesIsSet())
        ret.pedestal_g2_frames = input.getPedestalG2Frames();
    if (input.storageCellDelayNsIsSet())
        ret.storage_cell_delay_ns = input.getStorageCellDelayNs();
    if (input.detectorTriggerDelayNsIsSet())
        ret.detector_delay_ns = input.getDetectorTriggerDelayNs();

    return ret;
}

inline org::openapitools::server::model::Detector_settings Convert(const DetectorSettings &input) {
    org::openapitools::server::model::Detector_settings ret{};

    ret.setFrameTimeUs(input.frame_time_us);
    ret.setCountTimeUs(input.count_time_us.value());

    ret.setStorageCellCount(input.storage_cell_count);
    ret.setInternalFrameGenerator(input.use_internal_packet_generator);
    ret.setCollectRawData(input.collect_raw_data);
    ret.setFixedGainG1(input.fixed_gain_g1);
    ret.setUseGainHg0(input.use_gain_hg0);
    ret.setPedestalG0Frames(input.pedestal_g0_frames.value());
    ret.setPedestalG1Frames(input.pedestal_g1_frames.value());
    ret.setPedestalG2Frames(input.pedestal_g2_frames.value());

    ret.setStorageCellDelayNs(input.storage_cell_delay_ns.value());
    ret.setDetectorTriggerDelayNs(input.detector_delay_ns.value());

    return ret;
}

inline org::openapitools::server::model::Broker_status Convert(const BrokerStatus& input) {
    org::openapitools::server::model::Broker_status ret;

    switch (input.broker_state) {
        case JFJochState::Inactive:
            ret.setState("Inactive");
            break;
        case JFJochState::Idle:
            ret.setState("Idle");
            break;
        case JFJochState::Measuring:
            ret.setState("Measuring");
            break;
        case JFJochState::Error:
            ret.setState("Error");
            break;
        case JFJochState::Busy:
            ret.setState("Busy");
            break;
        case JFJochState::Pedestal:
            ret.setState("Pedestal");
            break;
    }
    if (input.progress.has_value())
        ret.setProgress(input.progress.value());
    if (input.indexing_rate.has_value() && (input.indexing_rate >= 0.0))
        ret.setIndexingRate(input.indexing_rate.value());
    return ret;
}

inline org::openapitools::server::model::Calibration_statistics_inner Convert(const JFCalibrationModuleStatistics& input) {
    org::openapitools::server::model::Calibration_statistics_inner output;

    output.setModuleNumber(input.module_number);
    output.setMaskedPixels(input.masked_pixels);
    output.setStorageCellNumber(input.storage_cell_number);
    output.setGainG0Mean(input.gain_g0_mean);
    output.setGainG1Mean(input.gain_g1_mean);
    output.setGainG2Mean(input.gain_g2_mean);
    output.setPedestalG0Mean(input.pedestal_g0_mean);
    output.setPedestalG1Mean(input.pedestal_g1_mean);
    output.setPedestalG2Mean(input.pedestal_g2_mean);

    return output;
}

inline org::openapitools::server::model::Detector_status Convert(const DetectorStatus &input) {
    org::openapitools::server::model::Detector_status output;
    output.setServerVersion(input.detector_server_version);
    output.setNumberOfTriggersLeft(input.remaining_triggers);
    output.setFpgaTempDegC(input.temperature_fpga_degC);
    output.setHighVoltageV(input.high_voltage_V);
    switch (input.power_state) {
        case DetectorPowerState::ON:
            output.setPowerchip("On");
            break;
        case DetectorPowerState::OFF:
            output.setPowerchip("Off");
            break;
        case DetectorPowerState::PARTIAL:
            output.setPowerchip("Partial");
            break;
    }
    switch (input.detector_state) {

        case DetectorState::IDLE:
            output.setState("Idle");
            break;
        case DetectorState::ERROR:
            output.setState("Error");
            break;
        case DetectorState::BUSY:
            output.setState("Busy");
            break;
        case DetectorState::WAITING:
            output.setState("Waiting");
            break;
    }
    return output;
}

inline org::openapitools::server::model::Detector_list Convert(const DetectorList &input) {
    org::openapitools::server::model::Detector_list ret;
    std::vector<org::openapitools::server::model::Detector_list_detectors_inner> dets;
    for (int i = 0; i < input.detector.size(); i++) {
        org::openapitools::server::model::Detector_list_detectors_inner d;
        d.setId(i);
        d.setDescription(input.detector[i].description);
        d.setNmodules(input.detector[i].nmodules);
        d.setHeight(input.detector[i].height);
        d.setWidth(input.detector[i].width);
        dets.emplace_back(std::move(d));
    }
    ret.setDetectors(dets);
    ret.setCurrentId(input.current_id);
    return ret;
}

inline org::openapitools::server::model::Plot Convert(const Plot& input) {
    org::openapitools::server::model::Plot output;
    output.setX(input.x);
    output.setY(input.y);
    return output;
}

inline org::openapitools::server::model::Radial_integration_plots_inner Convert(const RadialIntegrationProfileStruct& input) {
    org::openapitools::server::model::Radial_integration_plots_inner output;
    output.setTitle(input.title);
    output.setPlot(Convert(input.plot));
    return output;
}

inline PlotRequest Convert(const org::openapitools::server::model::Plot_request& request) {
    PlotRequest ret{};
    if (request.binningIsSet())
        ret.binning = request.getBinning();
    else
        ret.binning = 0;
    return ret;
}

inline RadialIntegrationSettings Convert(const org::openapitools::server::model::Rad_int_settings& input) {
    RadialIntegrationSettings ret{};
    ret.solid_angle_correction = input.isSolidAngleCorr();
    if (input.polarizationFactorIsSet())
        ret.polarization_factor = input.getPolarizationFactor();
    ret.q_spacing = input.getQSpacing();
    ret.low_q_recipA = input.getLowQRecipA();
    ret.high_q_recipA = input.getHighQRecipA();
    return ret;
}

inline org::openapitools::server::model::Rad_int_settings Convert(const RadialIntegrationSettings& settings) {
    org::openapitools::server::model::Rad_int_settings ret{};
    ret.setSolidAngleCorr(settings.solid_angle_correction);
    if (settings.polarization_factor)
        ret.setPolarizationFactor(settings.polarization_factor.value());
    ret.setHighQRecipA(settings.high_q_recipA);
    ret.setLowQRecipA(settings.low_q_recipA);
    ret.setQSpacing(settings.q_spacing);
    return ret;
}

inline PreviewJPEGSettings Convert(const org::openapitools::server::model::Preview_settings& input) {
    PreviewJPEGSettings ret{};
    ret.show_spots = input.isShowSpots();
    ret.jpeg_quality = input.getJpegQuality();
    ret.saturation_value = input.getSaturation();
    return ret;
}

inline org::openapitools::server::model::Preview_settings Convert(const PreviewJPEGSettings& settings) {
    org::openapitools::server::model::Preview_settings ret{};
    ret.setJpegQuality(settings.jpeg_quality);
    ret.setSaturation(settings.saturation_value);
    ret.setShowSpots(settings.show_spots);
    return ret;
}

inline DatasetSettings Convert(const org::openapitools::server::model::Dataset_settings& input) {
    DatasetSettings ret;

    ret.images_per_trigger = input.getImagesPerTrigger();
    ret.ntrigger = input.ntriggerIsSet() ? input.getNtrigger() : 1;

    if (!input.fpgaOutputIsSet())
        ret.fpga_pixel_output = FPGAPixelOutput::Auto;
    else {
        std::string out = str_tolower(input.getFpgaOutput());
        if (out == "auto")
            ret.fpga_pixel_output = FPGAPixelOutput::Auto;
        else if (out == "int16")
            ret.fpga_pixel_output = FPGAPixelOutput::Int16;
        else if (out == "uint16")
            ret.fpga_pixel_output = FPGAPixelOutput::Uint16;
        else if (out == "int32")
            ret.fpga_pixel_output = FPGAPixelOutput::Int32;
        else if (out == "uint32")
            ret.fpga_pixel_output = FPGAPixelOutput::Uint32;
        else
            throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Unknown output format");
    }

    ret.summation = input.summationIsSet() ? input.getSummation() : 1;
    ret.beam_x_pxl = input.getBeamXPxl();
    ret.beam_y_pxl = input.getBeamYPxl();
    ret.detector_distance_mm = input.getDetectorDistanceMm();
    ret.photon_energy_keV = input.getPhotonEnergyKeV();

    ret.photon_energy_multiplier = input.getPhotonEnergyMultiplier();

    ret.file_prefix = input.filePrefixIsSet() ? input.getFilePrefix() : "";
    ret.data_file_count = input.dataFileCountIsSet() ? input.getDataFileCount() : 1;

    if (!input.compressionIsSet())
        ret.compression = CompressionAlgorithm::BSHUF_LZ4;
    else {
        std::string compr = str_tolower(input.getCompression());
        if (compr == "bslz4")
            ret.compression = CompressionAlgorithm::BSHUF_LZ4;
        else if (compr == "bszstd")
            ret.compression = CompressionAlgorithm::BSHUF_ZSTD;
        else if (compr == "bszstd_rle")
            ret.compression = CompressionAlgorithm::BSHUF_ZSTD_RLE;
        else if (compr == "none")
            ret.compression = CompressionAlgorithm::NO_COMPRESSION;
        else
            throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Unknown compression");
    }

    if (input.unitCellIsSet())
        ret.unit_cell = UnitCell{
                .a = input.getUnitCell().getA(),
                .b = input.getUnitCell().getB(),
                .c = input.getUnitCell().getC(),
                .alpha = input.getUnitCell().getAlpha(),
                .beta = input.getUnitCell().getBeta(),
                .gamma = input.getUnitCell().getGamma()
        };

    if (input.totalFluxIsSet())
        ret.total_flux = input.getTotalFlux();
    if (input.transmissionIsSet())
        ret.attenuator_transmission = input.getTransmission();

    if (input.omegaIsSet()) {
        ret.omega_step = input.getOmega().getStep();
        ret.omega_start = input.getOmega().getStart();
        if (input.getOmega().getVector().size() == 3) {
            auto v = input.getOmega().getVector();
            ret.omega_axis = Coord(v[0], v[1], v[2]);
        } else
            ret.omega_axis = Coord(0, 0, 0);
    }

    if (input.roiSumAreaIsSet()) {
        ret.roi_sum_area = ROIRectangle{
                .x_min = static_cast<size_t>(input.getRoiSumArea().getXMin()),
                .x_max = static_cast<size_t>(input.getRoiSumArea().getXMax()),
                .y_min = static_cast<size_t>(input.getRoiSumArea().getYMin()),
                .y_max = static_cast<size_t>(input.getRoiSumArea().getYMax())
        };
    }
    ret.space_group_number = input.spaceGroupNumberIsSet() ? input.getSpaceGroupNumber() : 0;
    ret.sample_name = input.getSampleName();
    ret.header_appendix = input.getHeaderAppendix();
    ret.image_appendix = input.getImageAppendix();
    ret.save_calibration = input.saveCalibrationIsSet() && input.isSaveCalibration();
    return ret;
}


JFJochBrokerHttp::JFJochBrokerHttp(const DiffractionExperiment &experiment, std::shared_ptr<Pistache::Rest::Router> &rtr)
: DefaultApi(rtr) {
    Pistache::Rest::Routes::Get(*rtr, "/", Pistache::Rest::Routes::bind(&JFJochBrokerHttp::GetStaticFile, this));
    Pistache::Rest::Routes::Get(*rtr, "/frontend", Pistache::Rest::Routes::bind(&JFJochBrokerHttp::GetStaticFile, this));
    Pistache::Rest::Routes::Get(*rtr, "/frontend/*", Pistache::Rest::Routes::bind(&JFJochBrokerHttp::GetStaticFile, this));
    Pistache::Rest::Routes::Get(*rtr, "/frontend/static/js/*", Pistache::Rest::Routes::bind(&JFJochBrokerHttp::GetStaticFile, this));
    Pistache::Rest::Routes::Get(*rtr, "/frontend/static/css/*", Pistache::Rest::Routes::bind(&JFJochBrokerHttp::GetStaticFile, this));

    state_machine.NotThreadSafe_Experiment() = experiment;
    init();
}

void JFJochBrokerHttp::AddDetectorSetup(const DetectorSetup &setup) {
    state_machine.AddDetectorSetup(setup);
    logger.Info("Added detector {}", setup.GetDescription());
}

JFJochServices &JFJochBrokerHttp::Services() {
    return services;
}

void JFJochBrokerHttp::cancel_post(Pistache::Http::ResponseWriter &response) {
    state_machine.Cancel();
    response.send(Pistache::Http::Code::Ok);
}

void JFJochBrokerHttp::deactivate_post(Pistache::Http::ResponseWriter &response) {
    state_machine.Deactivate();
    response.send(Pistache::Http::Code::Ok);
}

void JFJochBrokerHttp::initialize_post(Pistache::Http::ResponseWriter &response) {
    state_machine.Initialize();
    response.send(Pistache::Http::Code::Ok);
}

void JFJochBrokerHttp::start_post(const org::openapitools::server::model::Dataset_settings &datasetSettings,
                                  Pistache::Http::ResponseWriter &response) {
    state_machine.Start(Convert(datasetSettings));
    response.send(Pistache::Http::Code::Ok);
}

void JFJochBrokerHttp::status_get(Pistache::Http::ResponseWriter &response) {
    ProcessOutput(Convert(state_machine.GetStatus()), response);
}

void JFJochBrokerHttp::wait_till_done_post(Pistache::Http::ResponseWriter &response) {
    auto state = state_machine.WaitTillMeasurementDone(std::chrono::seconds(5));
    switch (state) {
        case JFJochState::Idle:
            response.send(Pistache::Http::Code::Ok);
            break;
        case JFJochState::Inactive:
            response.send(Pistache::Http::Code::Bad_Gateway);
            break;
        case JFJochState::Error:
            response.send(Pistache::Http::Code::Internal_Server_Error);
            break;
        case JFJochState::Measuring:
        case JFJochState::Busy:
        case JFJochState::Pedestal:
            response.send(Pistache::Http::Code::Gateway_Timeout);
            break;
    }
}

void JFJochBrokerHttp::trigger_post(Pistache::Http::ResponseWriter &response) {
    state_machine.Trigger();
    response.send(Pistache::Http::Code::Ok);
}

void JFJochBrokerHttp::pedestal_post(Pistache::Http::ResponseWriter &response) {
    state_machine.Pedestal();
    response.send(Pistache::Http::Code::Ok);
}

void JFJochBrokerHttp::config_detector_get(Pistache::Http::ResponseWriter &response) {
    ProcessOutput(Convert(state_machine.GetDetectorSettings()), response);
}

void JFJochBrokerHttp::config_detector_put(const org::openapitools::server::model::Detector_settings &detectorSettings,
                                           Pistache::Http::ResponseWriter &response) {
    state_machine.LoadDetectorSettings(Convert(detectorSettings));
    response.send(Pistache::Http::Code::Ok);
}

void JFJochBrokerHttp::config_rad_int_get(Pistache::Http::ResponseWriter &response) {
    ProcessOutput(Convert(state_machine.GetRadialIntegrationSettings()), response);
}

void JFJochBrokerHttp::config_rad_int_put(const org::openapitools::server::model::Rad_int_settings &radIntSettings,
                                          Pistache::Http::ResponseWriter &response) {
    state_machine.SetRadialIntegrationSettings(Convert(radIntSettings));
    response.send(Pistache::Http::Code::Ok);
}

void JFJochBrokerHttp::config_select_detector_get(Pistache::Http::ResponseWriter &response) {
    ProcessOutput(Convert(state_machine.GetDetectorsList()), response);
}

void JFJochBrokerHttp::config_select_detector_put(
        const org::openapitools::server::model::Detector_selection &detectorSelection,
        Pistache::Http::ResponseWriter &response) {
    state_machine.SelectDetector(detectorSelection.getId());
    response.send(Pistache::Http::Code::Ok);
}

void JFJochBrokerHttp::config_spot_finding_get(Pistache::Http::ResponseWriter &response) {
    ProcessOutput(Convert(state_machine.GetSpotFindingSettings()), response);
}

void JFJochBrokerHttp::config_spot_finding_put(
        const org::openapitools::server::model::Spot_finding_settings &spotFindingSettings,
        Pistache::Http::ResponseWriter &response) {
    state_machine.SetSpotFindingSettings(Convert(spotFindingSettings));
    response.send(Pistache::Http::Code::Ok);
}

void JFJochBrokerHttp::plot_saturated_pixel_post(const org::openapitools::server::model::Plot_request &plotRequest,
                                                Pistache::Http::ResponseWriter &response) {
    PlotRequest req{.type = PlotType::SaturatedPixels, .binning = 0};
    if (plotRequest.binningIsSet())
        req.binning = plotRequest.getBinning();
    auto plot = state_machine.GetPlots(req);
    ProcessOutput(Convert(plot), response);
}

void JFJochBrokerHttp::plot_bkg_estimate_post(const org::openapitools::server::model::Plot_request &plotRequest,
                                              Pistache::Http::ResponseWriter &response) {
    PlotRequest req{.type = PlotType::BkgEstimate, .binning = 0};
    if (plotRequest.binningIsSet())
        req.binning = plotRequest.getBinning();
    auto plot = state_machine.GetPlots(req);
    ProcessOutput(Convert(plot), response);
}

void JFJochBrokerHttp::plot_indexing_rate_per_file_get(Pistache::Http::ResponseWriter &response) {
    PlotRequest req{.type = PlotType::IndexingRatePerFile};
    auto plot = state_machine.GetPlots(req);
    ProcessOutput(Convert(plot), response);
}

void JFJochBrokerHttp::plot_indexing_rate_post(const org::openapitools::server::model::Plot_request &plotRequest,
                                               Pistache::Http::ResponseWriter &response) {
    PlotRequest req{.type = PlotType::IndexingRate, .binning = 0};
    if (plotRequest.binningIsSet())
        req.binning = plotRequest.getBinning();
    auto plot = state_machine.GetPlots(req);
    ProcessOutput(Convert(plot), response);

}

void JFJochBrokerHttp::plot_rad_int_get(Pistache::Http::ResponseWriter &response) {
    PlotRequest req{.type = PlotType::RadInt};
    auto plot = state_machine.GetPlots(req);
    ProcessOutput(Convert(plot), response);
}

void JFJochBrokerHttp::plot_rad_int_per_file_get(Pistache::Http::ResponseWriter &response) {
    auto rad_int = state_machine.GetRadialIntegrationProfiles();
    nlohmann::json j;

    for (const auto &i: rad_int.profiles) {
        auto output = Convert(i);
        std::stringstream s;
        assert(output.validate(s));

        nlohmann::json j_elem;
        to_json(j_elem, output);
        j.push_back(j_elem);
    }
    response.send(Pistache::Http::Code::Ok, j.dump(), MIME(Application, Json));
}

void JFJochBrokerHttp::plot_spot_count_post(const org::openapitools::server::model::Plot_request &plotRequest,
                                            Pistache::Http::ResponseWriter &response) {
    PlotRequest req{.type = PlotType::SpotCount, .binning = 0};
    if (plotRequest.binningIsSet())
        req.binning = plotRequest.getBinning();
    auto plot = state_machine.GetPlots(req);
    ProcessOutput(Convert(plot), response);
}

void JFJochBrokerHttp::statistics_calibration_get(Pistache::Http::ResponseWriter &response) {
    auto calib = state_machine.GetCalibrationStatistics();
    nlohmann::json j;

    for (const auto &i: calib) {
        auto output = Convert(i);
        std::stringstream s;
        assert(output.validate(s));

        nlohmann::json j_elem;
        to_json(j_elem, output);
        j.push_back(j_elem);
    }
    response.send(Pistache::Http::Code::Ok, j.dump(), MIME(Application, Json));
}

void JFJochBrokerHttp::statistics_data_collection_get(Pistache::Http::ResponseWriter &response) {
    auto stats = state_machine.GetMeasurementStatistics();
    if (stats) {
        ProcessOutput(Convert(stats.value()), response);
    } else {
        response.send(Pistache::Http::Code::Not_Found);
    }
}

std::pair<Pistache::Http::Code, std::string>
JFJochBrokerHttp::handleOperationException(const std::exception &ex) const noexcept {
    try {
        throw;
    } catch (const WrongDAQStateException &e) {
        org::openapitools::server::model::Error_message msg;
        msg.setMsg(ex.what());
        msg.setReason("WrongDAQState");
        nlohmann::json j;
        to_json(j, msg);
        return std::make_pair(Pistache::Http::Code::Internal_Server_Error, j.dump());
    } catch (const std::exception &e) {
        org::openapitools::server::model::Error_message msg;
        msg.setMsg(ex.what());
        msg.setReason("Other");
        nlohmann::json j;
        to_json(j, msg);
        return std::make_pair(Pistache::Http::Code::Internal_Server_Error, j.dump());
    }
}

void JFJochBrokerHttp::GetStaticFile(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
    if (!frontend_directory.empty()) {
        logger.Info("Requesting static resource {} from {}", request.resource(), frontend_directory);
        if (request.resource().find("../") != std::string::npos)
            response.send(Pistache::Http::Code::Forbidden);
        try {
            if ((request.resource() == "/")
                || (request.resource() == "/frontend")
                || (request.resource() == "/frontend/"))
                Pistache::Http::serveFile(response, frontend_directory + "/index.html");
            else if (request.resource().substr(0, 10) == "/frontend/")
                Pistache::Http::serveFile(response, frontend_directory + "/" + request.resource().substr(10));
            else response.send(Pistache::Http::Code::Not_Found);
        } catch (const std::exception &e) {
            logger.Error(e.what());
            response.send(Pistache::Http::Code::Not_Found);
        }
    } else response.send(Pistache::Http::Code::Not_Found);
}

JFJochBrokerHttp &JFJochBrokerHttp::FrontendDirectory(const std::string &directory) {
    frontend_directory = directory;
    return *this;
}

void JFJochBrokerHttp::plot_error_pixel_post(const org::openapitools::server::model::Plot_request &plotRequest,
                                             Pistache::Http::ResponseWriter &response) {
    PlotRequest req{.type = PlotType::ErrorPixels, .binning = 0};
    if (plotRequest.binningIsSet())
        req.binning = plotRequest.getBinning();
    auto plot = state_machine.GetPlots(req);
    ProcessOutput(Convert(plot), response);
}

void JFJochBrokerHttp::plot_strong_pixel_post(const org::openapitools::server::model::Plot_request &plotRequest,
                                              Pistache::Http::ResponseWriter &response) {
    PlotRequest req{.type = PlotType::StrongPixels, .binning = 0};
    if (plotRequest.binningIsSet())
        req.binning = plotRequest.getBinning();
    auto plot = state_machine.GetPlots(req);
    ProcessOutput(Convert(plot), response);
}

void JFJochBrokerHttp::plot_image_collection_efficiency_post(
        const org::openapitools::server::model::Plot_request &plotRequest, Pistache::Http::ResponseWriter &response) {
    PlotRequest req{.type = PlotType::ImageCollectionEfficiency, .binning = 0};
    if (plotRequest.binningIsSet())
        req.binning = plotRequest.getBinning();
    auto plot = state_machine.GetPlots(req);
    ProcessOutput(Convert(plot), response);
}

void JFJochBrokerHttp::plot_receiver_delay_post(const org::openapitools::server::model::Plot_request &plotRequest,
                                                Pistache::Http::ResponseWriter &response) {
    PlotRequest req{.type = PlotType::ReceiverDelay, .binning = 0};
    if (plotRequest.binningIsSet())
        req.binning = plotRequest.getBinning();
    auto plot = state_machine.GetPlots(req);
    ProcessOutput(Convert(plot), response);
}

void JFJochBrokerHttp::plot_roi_sum_post(const org::openapitools::server::model::Plot_request &plotRequest,
                                         Pistache::Http::ResponseWriter &response) {
    PlotRequest req{.type = PlotType::ROISum, .binning = 0};
    if (plotRequest.binningIsSet())
        req.binning = plotRequest.getBinning();
    auto plot = state_machine.GetPlots(req);
    ProcessOutput(Convert(plot), response);
}

void JFJochBrokerHttp::detector_status_get(Pistache::Http::ResponseWriter &response) {
    auto out = state_machine.GetDetectorStatus();
    if (out)
        ProcessOutput(Convert(out.value()), response);
    else
        response.send(Pistache::Http::Code::Not_Found);
}

void JFJochBrokerHttp::preview_calibration_tiff_get(Pistache::Http::ResponseWriter &response) {
    std::string s = state_machine.GetPreviewTIFF(true);
    if (!s.empty())
        response.send(Pistache::Http::Code::Ok, s, Pistache::Http::Mime::MediaType::fromString("image/tiff"));
    else
        response.send(Pistache::Http::Code::Not_Found);
}

void JFJochBrokerHttp::preview_image_jpeg_get(Pistache::Http::ResponseWriter &response) {
    std::string s = state_machine.GetPreviewJPEG();
    if (!s.empty())
        response.send(Pistache::Http::Code::Ok, s, Pistache::Http::Mime::MediaType::fromString("image/jpeg"));
    else
        response.send(Pistache::Http::Code::Not_Found);
}

void JFJochBrokerHttp::preview_image_tiff_get(Pistache::Http::ResponseWriter &response) {
    std::string s = state_machine.GetPreviewTIFF(false);
    if (!s.empty())
        response.send(Pistache::Http::Code::Ok, s, Pistache::Http::Mime::MediaType::fromString("image/tiff"));
    else
        response.send(Pistache::Http::Code::Not_Found);
}

void JFJochBrokerHttp::preview_jpeg_settings_get(Pistache::Http::ResponseWriter &response) {
    ProcessOutput(Convert(state_machine.GetPreviewJPEGSettings()), response);
}

void JFJochBrokerHttp::preview_jpeg_settings_put(const org::openapitools::server::model::Preview_settings &previewSettings,
                                                 Pistache::Http::ResponseWriter &response) {
    state_machine.SetPreviewJPEGSettings(Convert(previewSettings));
    response.send(Pistache::Http::Code::Ok);
}

void JFJochBrokerHttp::plot_resolution_estimate_histogram_get(Pistache::Http::ResponseWriter &response) {
    PlotRequest req{.type = PlotType::ResEstimation, .binning = 0};
    auto plot = state_machine.GetPlots(req);
    ProcessOutput(Convert(plot), response);
}