#include "sar3d_processor.hpp"
#include "../processing/processors/src/sar3d_gpu.hpp"

#include <iostream>
#include <nlohmann/json.hpp>

using Json = nlohmann::json;
using namespace radar;

namespace {
auto complex_samples(const Json& samples) -> std::vector<std::complex<float>> {
    std::vector<std::complex<float>> values;
    for (const auto& sample : samples) {
        values.emplace_back(sample.at(0).get<float>(), sample.at(1).get<float>());
    }
    return values;
}

auto collection(const Json& source) -> ipc::PreprocessedCollection {
    ipc::PreprocessedCollection result;
    result.collection_id = source.at("id");
    result.monotonic_ns = source.at("timestamp");
    for (const auto& entry : source.at("traces")) {
        ipc::SweepTraceBlock trace;
        trace.combo = {entry.at("input"), entry.at("output")};
        trace.capture_start_ns = entry.at("start");
        trace.capture_end_ns = entry.at("end");
        trace.frequency_hz = entry.at("frequency").get<std::vector<float>>();
        for (const auto& sample : complex_samples(entry.at("s21"))) {
            trace.s21.push_back({sample.real(), sample.imag()});
        }
        result.traces.push_back(std::move(trace));
    }
    return result;
}
}

int main() {
    try {
        const Json input = Json::parse(std::cin);
        Json output;
        if (input.at("operation") == "processor") {
            config::RunConfig config;
            for (const auto& row : input.at("tx")) {
                config.gpr.tx_geometry.push_back({row.at(0), row.at(1), row.at(2), row.at(3)});
            }
            for (const auto& row : input.at("rx")) {
                config.gpr.rx_geometry.push_back({row.at(0), row.at(1), row.at(2), row.at(3)});
            }
            processing::ProcessingLiveConfig live;
            live.gpr_start_freq_mhz = input.at("f_start").get<float>() / 1e6F;
            live.gpr_stop_freq_mhz = input.at("f_stop").get<float>() / 1e6F;
            live.gpr_min_depth_m = input.at("min_depth");
            live.gpr_max_depth_m = input.at("max_depth");
            live.gpr_speed_m_s = input.at("speed");
            live.gpr_look_angle_deg = input.at("pitch");
            live.sar3d_voxel_m = input.at("voxel");
            live.sar3d_bp_ground_depth_m = input.at("ground");
            live.sar3d_frame_radius = input.at("radius");
            live.sar3d_comp_range_power = input.at("power");
            live.sar3d_use_compensation = input.at("compensation");
            live.sar3d_normalize_each_frame = input.at("normalize");
            std::vector<ipc::PreprocessedCollection> previous;
            for (const auto& member : input.at("previous")) {
                previous.push_back(collection(member));
            }
            processing::Sar3dProcessor processor;
            const auto result = processor.process_collection(config, collection(input.at("latest")), previous, live);
            output["payloads"] = Json::array();
            for (const auto& payload : result.collection_payloads) {
                output["payloads"].push_back({{"name", payload.processing_name},
                    {"x", payload.image_x_axis}, {"y", payload.image_y_axis},
                    {"image", payload.image_values}, {"table", payload.table_values},
                    {"columns", payload.table_columns}});
            }
        } else {
            processing::sar3d::Engine engine(1.5);
            const auto samples = engine.inverse_dft(complex_samples(input.at("bands")),
                input.at("points"), input.at("first_bin"), input.at("size"));
            output["ascans"] = Json::array();
            for (const auto& sample : samples) {
                output["ascans"].push_back({sample.real(), sample.imag()});
            }
        }
        std::cout << output << '\n';
    } catch (const std::exception& error) {
        std::cout << Json{{"error", error.what()}} << '\n';
        return 1;
    }
}