/* Screenmap maps strip indexes to x,y coordinates. This is used for FastLED Web
 * to map the 1D strip to a 2D grid. Note that the strip can have arbitrary
 * size. this was first motivated during the (attempted? Oct. 19th 2024) port of
 * the Chromancer project to FastLED Web.
 */

#include "fl/screenmap.h"

#include "fl/json.h"
#include "fl/map.h"
#include "fl/math.h"
#include "fl/math_macros.h"
#include "fl/namespace.h"
#include "fl/screenmap.h"
#include "fl/str.h"
#include "fl/vector.h"
#include "fl/warn.h"


namespace fl {

// Helper function to extract a vector of floats from a JSON array
fl::vector<float> jsonArrayToFloatVector(const fl::Json& jsonArray) {
    fl::vector<float> result;
    
    if (!jsonArray.has_value() || !jsonArray.is_array()) {
        return result;
    }
    auto begin_float =  jsonArray.begin_array<float>();
    auto end_float = jsonArray.end_array<float>();

    using T = decltype(*begin_float);
    static_assert(fl::is_same<T, fl::ParseResult<float>>::value, "Value type must be ParseResult<float>");
    
    // Use explicit array iterator style as demonstrated in FEATURE.md
    // DO NOT CHANGE THIS CODE. FIX THE IMPLIMENTATION IF NECESSARY.
    for (auto it = begin_float; it != end_float; ++it) {
        // assert that the value type is ParseResult<float>

        // get the name of the type
        auto parseResult = *it;
        if (!parseResult.has_error()) {
            result.push_back(parseResult.get_value());
        } else {
            FL_WARN("jsonArrayToFloatVector: ParseResult<float> has error: " << parseResult.get_error().message);
        }
    }
    
    return result;
}

ScreenMap ScreenMap::Circle(int numLeds, float cm_between_leds,
                            float cm_led_diameter, float completion) {
    ScreenMap screenMap(numLeds);

    // radius from LED spacing
    float circumference = numLeds * cm_between_leds;
    float radius = circumference / (2 * PI);

    // how big an arc we light vs leave dark
    float totalAngle = completion * 2 * PI;
    float gapAngle = 2 * PI - totalAngle;

    // shift so the dark gap is centered at the bottom (–π/2)
    float startAngle = -PI / 2 + gapAngle / 2.0f;

    // if partial, land last LED exactly at startAngle+totalAngle
    float divisor =
        (completion < 1.0f && numLeds > 1) ? (numLeds - 1) : numLeds;

    for (int i = 0; i < numLeds; ++i) {
        float angle = startAngle + (i * totalAngle) / divisor;
        float x = radius * cos(angle) * 2;
        float y = radius * sin(angle) * 2;
        screenMap[i] = {x, y};
    }

    screenMap.setDiameter(cm_led_diameter);
    return screenMap;
}

bool ScreenMap::ParseJson(const char *jsonStrScreenMap,
                          fl::fl_map<string, ScreenMap> *segmentMaps, string *err) {

#if FASTLED_NO_JSON
    FL_UNUSED(jsonStrScreenMap);
    FL_UNUSED(segmentMaps);
    FL_UNUSED(err);
    FL_WARN("ScreenMap::ParseJson called with FASTLED_NO_JSON");
    if (err) {
        *err = "JSON is not supported in this build";
    }
    return false;
#else
    //FL_WARN_SCREENMAP("ParseJson called with JSON: " << jsonStrScreenMap);
    
    string _err;
    if (!err) {
        err = &_err;
    }

    auto jsonDoc = fl::Json::parse(jsonStrScreenMap);
    if (!jsonDoc.has_value()) {
        *err = "Failed to parse JSON";
        FL_WARN("Failed to parse JSON");
        return false;
    }
    
    if (!jsonDoc.is_object()) {
        *err = "JSON root is not an object";
        FL_WARN("JSON root is not an object");
        return false;
    }
    
    // Check if "map" key exists and is an object
    if (!jsonDoc.contains("map")) {
        *err = "Missing 'map' key in JSON";
        FL_WARN("Missing 'map' key in JSON");
        return false;
    }
    
    // Get the map object
    auto mapObj = jsonDoc["map"];
    if (!mapObj.has_value() || !mapObj.is_object()) {
        *err = "Invalid 'map' object in JSON";
        FL_WARN("Invalid 'map' object in JSON");
        return false;
    }
    
    auto jsonMapOpt = mapObj.as_object();
    if (!jsonMapOpt || jsonMapOpt->empty()) {
        *err = "Failed to parse map from JSON or map is empty";
        FL_WARN("Failed to parse map from JSON or map is empty");
        return false;
    }
    
    auto& jsonMap = *jsonMapOpt;

    
    for (const auto& kv : jsonMap) {
        auto name = kv.first;

        
        // Check that the value is not null before creating Json object
        if (!kv.second) {
            *err = "Null value for segment " + name;
            return false;
        }
        
        // Create Json object directly from shared_ptr
        fl::Json val(kv.second);
        if (!val.has_value()) {
            *err = "Invalid value for segment " + name;
            return false;
        }
        
        if (!val.is_object()) {
            *err = "Segment value for " + name + " is not an object";
            return false;
        }
        
        // Check if x array exists and is actually an array
        if (!val.contains("x")) {
            *err = "Missing x array for " + name;
            return false;
        }
        
        if (!val["x"].has_value() || !val["x"].is_array()) {
            *err = "Invalid x array for " + name;
            return false;
        }
        
        // Extract x array using our helper function
        fl::vector<float> x_array = jsonArrayToFloatVector(val["x"]);
        
        // Check if y array exists and is actually an array
        if (!val.contains("y")) {
            *err = "Missing y array for " + name;
            return false;
        }
        
        if (!val["y"].has_value() || !val["y"].is_array()) {
            *err = "Invalid y array for " + name;
            return false;
        }
        
        // Extract y array using our helper function
        fl::vector<float> y_array = jsonArrayToFloatVector(val["y"]);
        
        // Get diameter (optional) with default value
        float diameter = -1.0f; // default value
        if (val.contains("diameter") && val["diameter"].has_value()) {
                            auto diameterOpt = val["diameter"].as_float();
            if (diameterOpt) {
                diameter = static_cast<float>(*diameterOpt);
            }
        }

        auto n = MIN(x_array.size(), y_array.size());
        if (n != x_array.size() || n != y_array.size()) {
            if (n != x_array.size()) {
            }
            if (n != y_array.size()) {
            }
        }

        ScreenMap segment_map(n, diameter);
        for (size_t i = 0; i < n; i++) {
            segment_map.set(i, vec2f{x_array[i], y_array[i]});
        }
        (*segmentMaps)[name] = fl::move(segment_map);
    }
    return true;
#endif
}

bool ScreenMap::ParseJson(const char *jsonStrScreenMap,
                          const char *screenMapName, ScreenMap *screenmap,
                          string *err) {

    fl::fl_map<string, ScreenMap> segmentMaps;
    bool ok = ParseJson(jsonStrScreenMap, &segmentMaps, err);
    if (!ok) {
        return false;
    }
    if (segmentMaps.size() == 0) {
        return false;
    }
    if (segmentMaps.contains(screenMapName)) {
        *screenmap = segmentMaps[screenMapName];
        return true;
    }
    string _err = "ScreenMap not found: ";
    _err.append(screenMapName);
    if (err) {
        *err = _err;
    }
    
    return false;
}

void ScreenMap::toJson(const fl::fl_map<string, ScreenMap> &segmentMaps,
                       fl::Json *doc) {

#if FASTLED_NO_JSON
    FL_WARN("ScreenMap::toJson called with FASTLED_NO_JSON");
    return;
#else
    if (!doc) {
        FL_WARN("ScreenMap::toJson called with nullptr doc");
        return;
    }

    // Create the root object
    *doc = fl::Json::object();
    
    // Create the map object
    fl::Json mapObj = fl::Json::object();
    
    // Populate the map object with segments
    for (const auto& kv : segmentMaps) {
        if (kv.second.getLength() == 0) {
            FL_WARN("ScreenMap::toJson called with empty segment: " << fl::string(kv.first));   
            continue;
        }
        
        auto& name = kv.first;
        auto& segment = kv.second;
        float diameter = segment.getDiameter();
        
        // Create x array
        fl::Json xArray = fl::Json::array();
        for (u16 i = 0; i < segment.getLength(); i++) {
            xArray.push_back(fl::Json(static_cast<double>(segment[i].x)));
        }
        
        // Create y array
        fl::Json yArray = fl::Json::array();
        for (u16 i = 0; i < segment.getLength(); i++) {
            yArray.push_back(fl::Json(static_cast<double>(segment[i].y)));
        }
        
        // Create segment object
        fl::Json segmentObj = fl::Json::object();
        // Add arrays and diameter to segment object
        segmentObj.set("x", xArray);
        segmentObj.set("y", yArray);
        segmentObj.set("diameter", fl::Json(static_cast<double>(diameter)));
        
        // Add segment to map object
        mapObj.set(name, segmentObj);
    }
    
    // Add map object to root
    doc->set("map", mapObj);
    
    // Debug output
    fl::string debugStr = doc->to_string();
    FL_WARN("ScreenMap::toJson generated JSON: " << debugStr);
#endif
}

void ScreenMap::toJsonStr(const fl::fl_map<string, ScreenMap> &segmentMaps,
                          string *jsonBuffer) {
    fl::Json doc;
    toJson(segmentMaps, &doc);
    *jsonBuffer = doc.to_string();
}

ScreenMap::ScreenMap(u32 length, float mDiameter)
    : length(length), mDiameter(mDiameter) {
    if (length > 0) {
        mLookUpTable = fl::make_shared<LUTXYFLOAT>(length);
        LUTXYFLOAT &lut = *mLookUpTable.get();
        vec2f *data = lut.getDataMutable();
        for (u32 x = 0; x < length; x++) {
            data[x] = {0, 0};
        }
    }
}

ScreenMap::ScreenMap(const vec2f *lut, u32 length, float diameter)
    : length(length), mDiameter(diameter) {
    mLookUpTable = fl::make_shared<LUTXYFLOAT>(length);
    LUTXYFLOAT &lut16xy = *mLookUpTable.get();
    vec2f *data = lut16xy.getDataMutable();
    for (u32 x = 0; x < length; x++) {
        data[x] = lut[x];
    }
}

ScreenMap::ScreenMap(const ScreenMap &other) {
    mDiameter = other.mDiameter;
    length = other.length;
    mLookUpTable = other.mLookUpTable;
}

ScreenMap::ScreenMap(ScreenMap&& other) {
    mDiameter = other.mDiameter;
    length = other.length;
    fl::swap(mLookUpTable, other.mLookUpTable);
    other.mLookUpTable.reset();
}

void ScreenMap::set(u16 index, const vec2f &p) {
    if (mLookUpTable) {
        LUTXYFLOAT &lut = *mLookUpTable.get();
        auto *data = lut.getDataMutable();
        data[index] = p;
    }
}

void ScreenMap::setDiameter(float diameter) { mDiameter = diameter; }

vec2f ScreenMap::mapToIndex(u32 x) const {
    if (x >= length || !mLookUpTable) {
        return {0, 0};
    }
    LUTXYFLOAT &lut = *mLookUpTable.get();
    vec2f screen_coords = lut[x];
    return screen_coords;
}

u32 ScreenMap::getLength() const { return length; }

float ScreenMap::getDiameter() const { return mDiameter; }

vec2f ScreenMap::getBounds() const {

    if (length == 0 || !mLookUpTable) {
        return {0, 0};
    }

    LUTXYFLOAT &lut = *mLookUpTable.get();

    fl::vec2f *data = lut.getDataMutable();
    // float minX = lut[0].x;
    // float maxX = lut[0].x;
    // float minY = lut[0].y;
    // float maxY = lut[0].y;
    float minX = data[0].x;
    float maxX = data[0].x;
    float minY = data[0].y;
    float maxY = data[0].y;

    for (u32 i = 1; i < length; i++) {
        const vec2f &p = lut[i];
        minX = MIN(minX, p.x);
        maxX = MAX(maxX, p.x);
        minY = MIN(minY, p.y);
        maxY = MAX(maxY, p.y);
    }

    return {maxX - minX, maxY - minY};
}

const vec2f &ScreenMap::empty() {
    static const vec2f s_empty = vec2f(0, 0);
    return s_empty;
}

const vec2f &ScreenMap::operator[](u32 x) const {
    if (x >= length || !mLookUpTable) {
        return empty(); // better than crashing.
    }
    LUTXYFLOAT &lut = *mLookUpTable.get();
    return lut[x];
}

vec2f &ScreenMap::operator[](u32 x) {
    if (x >= length || !mLookUpTable) {
        return const_cast<vec2f &>(empty()); // better than crashing.
    }
    LUTXYFLOAT &lut = *mLookUpTable.get();
    auto *data = lut.getDataMutable();
    return data[x];
}

ScreenMap &ScreenMap::operator=(const ScreenMap &other) {
    if (this != &other) {
        mDiameter = other.mDiameter;
        length = other.length;
        mLookUpTable = other.mLookUpTable;
    }
    return *this;
}

ScreenMap &ScreenMap::operator=(ScreenMap &&other) {
    if (this != &other) {
        mDiameter = other.mDiameter;
        length = other.length;
        mLookUpTable = fl::move(other.mLookUpTable);
        other.length = 0;
        other.mDiameter = -1.0f;
    }
    return *this;
}

void ScreenMap::addOffset(const vec2f &p) {
    vec2f *data = mLookUpTable->getDataMutable();
    for (u32 i = 0; i < length; i++) {
        vec2f &curr = data[i];
        curr.x += p.x;
        curr.y += p.y;
    }
}

void ScreenMap::addOffsetX(float x) { addOffset({x, 0}); }
void ScreenMap::addOffsetY(float y) { addOffset({0, y}); }

} // namespace fl