#include "DumpSource.h"

#include <cmath>
#include <string>
#include <utility>
#include <vector>

#include <nlohmann/json.hpp>
#include <raylib.h>

#include "Grid.h"
#include "Killmail.h"
#include "LongVector3.h"


using json = nlohmann::json;


static constexpr long double SCALE {.0001};
static constexpr long double EXTENT {1000 * 50000};


static Grid& find_grid_for(std::vector<Grid>& grids, const LongVector3& original);


DumpSource::DumpSource(const char* filename) :
    m_grids {}
{
    if (!FileExists(filename))
        throw "File does not exist";
    char* text = LoadFileText(filename);
    auto dump = json::parse(text);
    for (const auto& info : dump["killmails"]) {
        Killmail km;
        km.original = {
            info["victim"]["position"]["x"].get<long double>(),
            info["victim"]["position"]["y"].get<long double>(),
            info["victim"]["position"]["z"].get<long double>(),
        };
        auto id = info["solar_system_id"].get<long int>();
        auto location = dump["locations"][std::to_string(id)];
        km.location.system = location["name"].get<std::string>().data();
        km.location.constellation = location["constellation"].get<std::string>().data();
        km.location.region = location["region"].get<std::string>().data();
        auto& grid = find_grid_for(m_grids, km.original);
        grid.killmails.push_back(std::move(km));
    }
    UnloadFileText(text);
    for (auto& grid : m_grids) {
        LongVector3 average {0, 0, 0};
        for (const auto& km : grid.killmails) {
            average.x += km.original.x;
            average.y += km.original.y;
            average.z += km.original.z;
        }
        const auto killmails = grid.killmails.size();
        average.x /= killmails;
        average.y /= killmails;
        average.z /= killmails;
        for (auto& km : grid.killmails) {
            km.position = {
                static_cast<float>((km.original.x - average.x) * SCALE),
                static_cast<float>((km.original.y - average.y) * SCALE),
                static_cast<float>((km.original.z - average.z) * SCALE),
            };
        }
        grid.origin = average;
    }
}


std::vector<Grid>
DumpSource::grids() const
{
    return m_grids;
}


Grid&
find_grid_for(std::vector<Grid>& grids, const LongVector3& original)
{
    for (auto& grid : grids) {
        for (auto& km : grid.killmails) {
            const long double dist =
                std::sqrt(
                    std::pow(original.x - km.original.x, 2) +
                    std::pow(original.y - km.original.y, 2) +
                    std::pow(original.z - km.original.z, 2));
            if (dist < EXTENT)
                return grid;
        }
    }
    grids.push_back(Grid{});
    return grids.back();
}