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

#include "ModulePlacementConvert.h"

namespace model = org::openapitools::server::model;

namespace {

DetectorModuleGeometry::Direction Convert(const model::Detector_module_direction &input) {
    switch (input.getValue()) {
        case model::Detector_module_direction::eDetector_module_direction::XN:
            return DetectorModuleGeometry::Direction::Xneg;
        case model::Detector_module_direction::eDetector_module_direction::YP:
            return DetectorModuleGeometry::Direction::Ypos;
        case model::Detector_module_direction::eDetector_module_direction::YN:
            return DetectorModuleGeometry::Direction::Yneg;
        default:
            return DetectorModuleGeometry::Direction::Xpos;
    }
}

model::Detector_module_direction Convert(DetectorModuleGeometry::Direction input) {
    model::Detector_module_direction d;
    switch (input) {
        case DetectorModuleGeometry::Direction::Xneg:
            d.setValue(model::Detector_module_direction::eDetector_module_direction::XN);
            break;
        case DetectorModuleGeometry::Direction::Ypos:
            d.setValue(model::Detector_module_direction::eDetector_module_direction::YP);
            break;
        case DetectorModuleGeometry::Direction::Yneg:
            d.setValue(model::Detector_module_direction::eDetector_module_direction::YN);
            break;
        default:
            d.setValue(model::Detector_module_direction::eDetector_module_direction::XP);
            break;
    }
    return d;
}

}  // namespace

ModulePlacement Convert(const model::Detector_module_placement &input) {
    ModulePlacement p;
    p.x0 = input.getX0();
    p.y0 = input.getY0();
    p.fast = Convert(input.getFastAxis());
    p.slow = Convert(input.getSlowAxis());
    p.x0_plane = input.getX0Plane();
    p.y0_plane = input.getY0Plane();
    const auto f = input.getFastStep(), s = input.getSlowStep();
    p.fast_step = {f.at(0), f.at(1)};
    p.slow_step = {s.at(0), s.at(1)};
    return p;
}

model::Detector_module_placement ConvertPlacement(const ModulePlacement &input) {
    model::Detector_module_placement m;
    m.setX0(input.x0);
    m.setY0(input.y0);
    m.setFastAxis(Convert(input.fast));
    m.setSlowAxis(Convert(input.slow));
    m.setX0Plane(input.x0_plane);
    m.setY0Plane(input.y0_plane);
    m.setFastStep({input.fast_step[0], input.fast_step[1]});
    m.setSlowStep({input.slow_step[0], input.slow_step[1]});
    return m;
}

std::vector<ModulePlacement> ParseModulePlacement(const std::string &json_text) {
    const auto list = nlohmann::json::parse(json_text).at("module_placement")
            .get<std::vector<model::Detector_module_placement>>();
    std::vector<ModulePlacement> out;
    for (const auto &e: list) {
        e.validate();
        out.push_back(Convert(e));
    }
    return out;
}

std::string ModulePlacementJson(const DetectorModules &modules) {
    std::vector<model::Detector_module_placement> list;
    for (const auto &m: modules.Get())
        list.push_back(ConvertPlacement(PlacementOf(m)));
    return nlohmann::json{{"module_placement", list}}.dump(2) + "\n";
}