// Copyright (2019-2023) Paul Scherrer Institute

#include <cstring>

#include "bitshuffle/bitshuffle.h"

#include "FrameTransformation.h"
#include "../common/RawToConvertedGeometry.h"
#include "../common/JFJochException.h"

template <class T> void FillVector(std::vector<char> &v, T fill_value) {
    auto ptr = (T *) v.data();
    for (int i = 0; i < v.size() / sizeof(T); i++)
        ptr[i] = fill_value;
}

FrameTransformation::FrameTransformation(const DiffractionExperiment &in_experiment) :
        experiment(in_experiment),
        pixel_depth(experiment.GetPixelDepth()), pixel_signed(experiment.IsPixelSigned()),
        compressor(in_experiment.GetCompressionAlgorithm()),
        err_value(experiment.GetPixelDepth() * RAW_MODULE_SIZE) {

    precompression_buffer.resize(experiment.GetPixelsNum() * pixel_depth);

    if (pixel_depth == 2) {
        if (pixel_signed) {
            FillVector<int16_t>(precompression_buffer, INT16_MIN);
            FillVector<int16_t>(err_value, INT16_MIN);
        } else {
            FillVector<uint16_t>(precompression_buffer, UINT16_MAX);
            FillVector<uint16_t>(err_value, UINT16_MAX);
        }
    } else if (pixel_depth == 4) {
        if (pixel_signed) {
            FillVector<int32_t>(precompression_buffer, INT32_MIN);
            FillVector<int32_t>(err_value, INT32_MIN);
        } else {
            FillVector<uint32_t>(precompression_buffer, UINT32_MAX);
            FillVector<uint32_t>(err_value, UINT32_MAX);
        }
    }
}

size_t FrameTransformation::CompressImage(void *output) {
    return compressor.Compress(output, precompression_buffer.data(), experiment.GetPixelsNum(), experiment.GetPixelDepth());
}

CompressedImage FrameTransformation::GetCompressedImage() {
    CompressedImage image{};
    if (experiment.GetCompressionAlgorithm() == CompressionAlgorithm::NO_COMPRESSION) {
        image.data = (uint8_t *) precompression_buffer.data();
        image.size = experiment.GetPixelsNum() * experiment.GetPixelDepth();
    } else {
        compressed_buffer.resize(MaxCompressedSize(experiment.GetCompressionAlgorithm(),
                                                   experiment.GetPixelsNum(),
                                                   experiment.GetPixelDepth()));
        image.data = (uint8_t *) compressed_buffer.data();
        image.size = CompressImage(compressed_buffer.data());
    }
    image.xpixel = experiment.GetXPixelsNum();
    image.ypixel = experiment.GetYPixelsNum();
    image.algorithm = experiment.GetCompressionAlgorithm();
    image.pixel_depth_bytes = experiment.GetPixelDepth();
    image.pixel_is_signed = pixel_signed;
    image.pixel_is_float = false;
    image.channel = "default";
    return image;
}

void FrameTransformation::ProcessModule(const void *input, uint16_t module_number, int data_stream) {
    size_t module_number_abs = experiment.GetFirstModuleOfDataStream(data_stream) + module_number;

    if (experiment.GetDetectorMode() != DetectorMode::Conversion) {
        size_t mod_size = RAW_MODULE_SIZE * pixel_depth;
        memcpy(precompression_buffer.data() + module_number_abs * mod_size, input, mod_size);
    } else {
        if (pixel_depth == 2) {
            if (pixel_signed)
                TransferModuleAdjustMultipixels((int16_t *) precompression_buffer.data(), (int16_t *) input,
                                                experiment.GetModuleSlowDirectionStep(module_number_abs),
                                                static_cast<int16_t>(INT16_MIN),
                                                static_cast<int16_t>(INT16_MAX),
                                                experiment.GetModuleFastDirectionStep(module_number_abs),
                                                experiment.GetPixel0OfModule(module_number_abs));
            else
                TransferModuleAdjustMultipixels((uint16_t *) precompression_buffer.data(), (uint16_t *) input,
                                                experiment.GetModuleSlowDirectionStep(module_number_abs),
                                                static_cast<uint16_t>(0),
                                                static_cast<uint16_t>(UINT16_MAX - 1),
                                                experiment.GetModuleFastDirectionStep(module_number_abs),
                                                experiment.GetPixel0OfModule(module_number_abs));
        } else if (pixel_depth == 4) {
            if (pixel_signed)
                TransferModuleAdjustMultipixels((int32_t *) precompression_buffer.data(), (int32_t *) input,
                                                experiment.GetModuleSlowDirectionStep(module_number_abs),
                                                static_cast<int32_t>(INT32_MIN),
                                                static_cast<int32_t>(INT32_MAX),
                                                experiment.GetModuleFastDirectionStep(module_number_abs),
                                                experiment.GetPixel0OfModule(module_number_abs));
            else
                TransferModuleAdjustMultipixels((uint32_t *) precompression_buffer.data(), (uint32_t *) input,
                                                experiment.GetModuleSlowDirectionStep(module_number_abs),
                                                static_cast<uint32_t>(0),
                                                static_cast<uint32_t>(UINT32_MAX - 1),
                                                experiment.GetModuleFastDirectionStep(module_number_abs),
                                                experiment.GetPixel0OfModule(module_number_abs));
        }
    }
}

void FrameTransformation::ProcessModule(const DeviceOutput *output, int data_stream) {
    ProcessModule(output->pixels, output->module_statistics.module_number, data_stream);
}

const void *FrameTransformation::GetImage() const {
    return precompression_buffer.data();
}

void FrameTransformation::FillNotCollectedModule(uint16_t module_number, int data_stream) {
    ProcessModule(err_value.data(), module_number, data_stream);
}