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

#include <future>

#include "../image_analysis/RadialIntegration.h"
#include "../common/Logger.h"
#include "../writer/HDF5Objects.h"

Logger logger{"RadialIntegrationCPUTest"};

void RunRadialIntegrationThread(RadialIntegration *integration,
                                int16_t* image, size_t nimages,
                                size_t image0, size_t stride,
                                size_t npixel) {
    for (size_t i = image0; i < nimages; i += stride)
        integration->ProcessOneImage(image + i * npixel, npixel);
}

auto TestRadialIntegration(const DiffractionExperiment &experiment,
                           int16_t* image, size_t nimages,
                           uint32_t nthreads,
                           uint32_t pixel_split) {
    uint32_t nredo = 5;
    RadialIntegrationMapping mapping(experiment);

    std::vector<float> result;
    std::vector<RadialIntegration> integration;
    for (int i = 0; i < nthreads; i++) {
        if (pixel_split == 1)
            integration.emplace_back(mapping);
        else
            integration.emplace_back(mapping.GetPixelToBinMappingSplitTo4(), mapping.GetBinNumber(), 4);
    }

    auto start_time = std::chrono::system_clock::now();
    for (int redo = 0; redo < nredo; redo++) {
        std::vector<std::future<void>> futures;
        for (int i = 0; i < nthreads; i++) {
            futures.emplace_back(std::async(std::launch::async, &RunRadialIntegrationThread,
                                            &integration[i], image, nimages, i, nthreads,
                                            experiment.GetPixelsNum()));
        }
        for (auto &f: futures)
            f.get();
    }
    auto end_time = std::chrono::system_clock::now();
    auto elapsed = std::chrono::duration_cast<std::chrono::microseconds>(end_time - start_time);

    return elapsed.count() / (1000.0 * (double) nimages * nredo);
}

int main(int argc, char **argv) {
    if (argc > 3) {
        logger.Info("Usage: ./DataAnalysisPerfTest {<number of threads=1>} {<number of images=100>}");
        exit(EXIT_FAILURE);
    }

    uint32_t nthreads = 1;
    if (argc >= 2)
        nthreads = atol(argv[1]);

    uint64_t nimages = 100;
    if (argc == 3)
        nimages = atol(argv[2]);

    if ((nthreads <= 0) || (nimages <= 0)) {
        std::cerr << "Error in input parameters" << std::endl;
        exit(EXIT_FAILURE);
    }

    DiffractionExperiment x(DetectorGeometry(8, 2, 8, 36));

    logger.Info("Number of threads: {}", nthreads);
    logger.Info("Number of images in the dataset: {}", nimages);

    x.Mode(DetectorMode::Conversion);

    std::vector<int16_t> image_conv ( nimages * x.GetPixelsNum(), 30);

    x.BeamX_pxl(1090).BeamY_pxl(1136).DetectorDistance_mm(75).PhotonEnergy_keV(WVL_1A_IN_KEV);
    std::vector<uint8_t> one_byte_mask(x.GetPixelsNum(), 1);

    logger.Info("{:30s} {:8.2f} ms/image", "Radial int. pxlspl 1 (CPU)",
                TestRadialIntegration(x, image_conv.data(), nimages, nthreads, 1));
    logger.Info("{:30s} {:8.2f} ms/image", "Radial int. pxlspl 2 (CPU)",
                TestRadialIntegration(x, image_conv.data(), nimages, nthreads, 4));
}