// SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
// SPDX-License-Identifier: GPL-3.0-only

#include "JFJochMath.h"
#include "ROIMap.h"
#include "JFJochException.h"
#include "PanelRows.h"

std::vector<uint16_t> ROIMap::GetROIMap(const DiffractionGeometry &geom, const DetectorModules &modules,
                                        size_t xpixel, size_t ypixel) const {
    std::vector<uint16_t> map(xpixel * ypixel, 0);
    std::vector<float> resolution_map(xpixel * ypixel, 0);
    std::vector<float> phi_map;
    if (!rois.azimuthal.empty()) {
        phi_map.resize(xpixel * ypixel, 0);
        // A pixel on no panel keeps resolution and angle 0.
        ForEachPixelInRows(modules, static_cast<int64_t>(xpixel), 0, static_cast<int64_t>(ypixel),
                           [&](int64_t, size_t i, double px, double py) {
                               const auto x = static_cast<float>(px), y = static_cast<float>(py);
                               resolution_map[i] = geom.PxlToRes(x, y);
                               phi_map[i] = geom.Phi_rad(x, y) * 180.0f / static_cast<float>(PI);
                           });
    }

    uint16_t roi_id = 0;

    for (const auto & box : rois.boxes) {
        box.MarkROI(map, roi_id, xpixel, ypixel, resolution_map, phi_map);
        roi_id++;
    }

    for (const auto & circle : rois.circles) {
        circle.MarkROI(map, roi_id, xpixel, ypixel, resolution_map, phi_map);
        roi_id++;
    }

    for (const auto &az : rois.azimuthal) {
        az.MarkROI(map, roi_id, xpixel, ypixel, resolution_map, phi_map);
        roi_id++;
    }

    return map;
}

std::map<std::string, uint16_t> ROIMap::GetROINameMap() const {
    std::map<std::string, uint16_t> roi_name_map;

    uint16_t roi_id = 0;

    for (auto & box : rois.boxes) {
        roi_name_map[box.GetName()] = roi_id;
        roi_id++;
    }

    for (auto & circle : rois.circles) {
        roi_name_map[circle.GetName()] = roi_id;
        roi_id++;
    }

    for (auto & az : rois.azimuthal) {
        roi_name_map[az.GetName()] = roi_id;
        roi_id++;
    }
    return roi_name_map;
}

void ROIMap::SetROI(const ROIDefinition &input) {
    if (input.boxes.size() + input.circles.size() + input.azimuthal.size() > roi_limit)
        throw JFJochException(JFJochExceptionCategory::ArrayOutOfBounds, "Limit of box ROIs exceeded");

    rois = input;
}

const ROIDefinition &ROIMap::GetROIDefinition() const {
    return rois;
}

bool ROIMap::empty() const {
    return rois.boxes.empty() && rois.circles.empty() && rois.azimuthal.empty();
}

size_t ROIMap::size() const {
    return rois.boxes.size() + rois.circles.size() + rois.azimuthal.size();
}

std::vector<ROIConfig> ROIMap::ExportMetadata() const {
    std::vector<ROIConfig> ret;
    for (auto &r : rois.boxes)
        ret.emplace_back(r.ExportMetadata());

    for (auto &r : rois.circles)
        ret.emplace_back(r.ExportMetadata());

    for (auto &r : rois.azimuthal)
        ret.emplace_back(r.ExportMetadata());

    return ret;
}