// Copyright (2019-2022) Paul Scherrer Institute
// SPDX-License-Identifier: GPL-3.0-or-later

#ifndef FPGAUNITTEST_H
#define FPGAUNITTEST_H

#include <iostream>
#include <fstream>
#include "../common/DiffractionExperiment.h"
#include "../common/RawToConvertedGeometry.h"
#include "../common/JFJochException.h"
#include "../jungfrau/JFCalibration.h"
#include "../jungfrau/JFModuleGainCalibration.h"
#include "../jungfrau/JFConversionFloatingPoint.h"

template <class T> void LoadBinaryFile(const std::string &filename, T* output, size_t size) {
    std::fstream file(filename.c_str(), std::fstream::in | std::fstream::binary);
    if (file.is_open())
        file.read((char *) output, size * sizeof(T));
    else
        throw JFJochException(JFJochExceptionCategory::GainFileOpenError, "Gain file cannot be opened");
}

template <class T> double Compare(T *source, std::vector<float> &reference, int32_t npixel) {
    double result = 0;

    for (size_t i = 0; i < npixel; i++) {
        double diff = reference[i] - source[i];
        result += diff * diff;
    }

    return sqrt(result / npixel);
}

template <class T> double MaxErrorOnConversion(T *source, std::vector<float> &reference, int32_t npixel) {
    double ret = 0;

    for (size_t i = 0; i < npixel; i++) {
        double val = abs(reference[i] - source[i]);
        if (val >= 32768)
            std::cout << i << " " << reference[i] << " " << source[i] << std::endl;
        if (val > ret) ret = val;
    }
    return ret;
}

template <class T> double CheckConversion(const DiffractionExperiment &experiment,
                                          const JFCalibration &calib,
                                          const uint16_t *raw, T *converted,
                                          size_t storage_cell = 0) {

    std::vector<float> conversion_ref(RAW_MODULE_SIZE);

    JFConversionFloatingPoint conversion;
    conversion.Setup(calib.GainCalibration(0),
                     calib.Pedestal(0, 0, storage_cell),
                     calib.Pedestal(0, 1, storage_cell),
                     calib.Pedestal(0, 2, storage_cell),
                     experiment.GetPhotonEnergy_keV());
    conversion.ConvertFP(conversion_ref.data(), raw);

    return Compare(converted, conversion_ref, RAW_MODULE_SIZE);
}

template <class T> double CheckConversionWithGeomTransform(const DiffractionExperiment &experiment,
                                                           const JFCalibration &calib,
                                                           const uint16_t *raw, T *converted,
                                                           size_t storage_cell = 0) {
    std::vector<float> conversion_ref(experiment.GetModulesNum() * RAW_MODULE_SIZE);
    std::vector<float> conversion_ref_transformed(experiment.GetPixelsNum());

    JFConversionFloatingPoint conversion;

    for (int m = 0; m < experiment.GetModulesNum(); m ++) {
        conversion.Setup(calib.GainCalibration(m),
                         calib.Pedestal(m, 0, storage_cell),
                         calib.Pedestal(m, 1, storage_cell),
                         calib.Pedestal(m, 2, storage_cell),
                         experiment.GetPhotonEnergy_keV());
        conversion.ConvertFP(conversion_ref.data() + m * RAW_MODULE_SIZE, raw);

    }

    RawToConvertedGeometryAdjustMultipixels(experiment, conversion_ref_transformed.data(), conversion_ref.data() );

    return Compare(converted, conversion_ref_transformed, experiment.GetPixelsNum());
}

#endif //FPGAUNITTEST_H