// Copyright (2019-2023) Paul Scherrer Institute

#ifndef JFJOCH_USE_CUDA

#include "GPUImageAnalysis.h"

struct CudaStreamWrapper {
    int32_t just_anything_as_this_wont_be_used;
};

GPUImageAnalysis::GPUImageAnalysis(int32_t in_xpixels, int32_t in_ypixels, const std::vector<uint8_t> &mask) :
        xpixels(in_xpixels), ypixels(in_ypixels), gpu_out(nullptr), rad_integration_nbins(0) {
}

GPUImageAnalysis::GPUImageAnalysis(int32_t xpixels, int32_t ypixels, const std::vector<uint8_t> &mask,
                                   const std::vector<uint16_t> &rad_int_mapping, uint16_t rad_int_nbins)
                                   : GPUImageAnalysis(xpixels, ypixels, mask) {}

GPUImageAnalysis::GPUImageAnalysis(int32_t xpixels, int32_t ypixels, const std::vector<uint8_t> &mask,
                                   const RadialIntegrationMapping& mapping)
        : GPUImageAnalysis(xpixels, ypixels, mask, mapping.GetPixelToBinMapping(),
                           mapping.GetBinNumber()) {}

GPUImageAnalysis::~GPUImageAnalysis() {}

void GPUImageAnalysis::SetInputBuffer(void *ptr) {}

bool GPUImageAnalysis::GPUPresent() {
    return false;
}

void GPUImageAnalysis::RunSpotFinder(const JFJochProtoBuf::DataProcessingSettings &settings) {}

void GPUImageAnalysis::GetSpotFinderResults(StrongPixelSet &pixel_set) {}

void GPUImageAnalysis::GetSpotFinderResults(const DiffractionExperiment &experiment,
                                  const JFJochProtoBuf::DataProcessingSettings &settings,
                                  std::vector<DiffractionSpot> &vec) {}

void GPUImageAnalysis::RegisterBuffer() {}

void GPUImageAnalysis::UnregisterBuffer() {}

void GPUImageAnalysis::LoadDataToGPU(bool apply_pixel_mask_on_gpu) {}

void GPUImageAnalysis::RunRadialIntegration() {}

void GPUImageAnalysis::GetRadialIntegrationProfile(std::vector<float> &result) {}

std::vector<float> GPUImageAnalysis::GetRadialIntegrationSum() const {
    return {};
}

std::vector<float> GPUImageAnalysis::GetRadialIntegrationCount() const {
    return {};
}

float GPUImageAnalysis::GetRadialIntegrationRangeValue(uint16_t min_bin, uint16_t max_bin) {
    return 0;
}

void GPUImageAnalysis::LoadRadialIntegrationCorr(const std::vector<float>& v) {}

#endif