#include "UIFrame.h"
#include "UICollection.h"
#include "GameEngine.h"
#include "PyVector.h"
#include "UICaption.h"
#include "UISprite.h"
#include "UIGrid.h"
#include "McRFPy_API.h"
#include "PyPositionHelper.h"
// UIDrawable methods now in UIBase.h

UIDrawable* UIFrame::click_at(sf::Vector2f point)
{
    // Check bounds first (optimization)
    float x = box.getPosition().x, y = box.getPosition().y, w = box.getSize().x, h = box.getSize().y;
    if (point.x < x || point.y < y || point.x >= x+w || point.y >= y+h) {
        return nullptr;
    }
    
    // Transform to local coordinates for children
    sf::Vector2f localPoint = point - box.getPosition();
    
    // Check children in reverse order (top to bottom, highest z-index first)
    for (auto it = children->rbegin(); it != children->rend(); ++it) {
        auto& child = *it;
        if (!child->visible) continue;
        
        if (auto target = child->click_at(localPoint)) {
            return target;
        }
    }
    
    // No child handled it, check if we have a handler
    if (click_callable) {
        return this;
    }
    
    return nullptr;
}

UIFrame::UIFrame()
: outline(0)
{
    children = std::make_shared<std::vector<std::shared_ptr<UIDrawable>>>();
    box.setPosition(0, 0);
    box.setSize(sf::Vector2f(0, 0));
}

UIFrame::UIFrame(float _x, float _y, float _w, float _h)
: outline(0)
{
    box.setPosition(_x, _y);
    box.setSize(sf::Vector2f(_w, _h));
    children = std::make_shared<std::vector<std::shared_ptr<UIDrawable>>>();
}

UIFrame::~UIFrame()
{
    children.reset();
}

PyObjectsEnum UIFrame::derived_type()
{
    return PyObjectsEnum::UIFRAME;
}

// Phase 1 implementations
sf::FloatRect UIFrame::get_bounds() const
{
    auto pos = box.getPosition();
    auto size = box.getSize();
    return sf::FloatRect(pos.x, pos.y, size.x, size.y);
}

void UIFrame::move(float dx, float dy)
{
    box.move(dx, dy);
}

void UIFrame::resize(float w, float h)
{
    box.setSize(sf::Vector2f(w, h));
}

void UIFrame::render(sf::Vector2f offset, sf::RenderTarget& target)
{
    // Check visibility
    if (!visible) return;
    
    // TODO: Apply opacity when SFML supports it on shapes
    
    box.move(offset);
    //Resources::game->getWindow().draw(box);
    target.draw(box);
    box.move(-offset);

    // Sort children by z_index if needed
    if (children_need_sort && !children->empty()) {
        std::sort(children->begin(), children->end(),
            [](const std::shared_ptr<UIDrawable>& a, const std::shared_ptr<UIDrawable>& b) {
                return a->z_index < b->z_index;
            });
        children_need_sort = false;
    }

    for (auto drawable : *children) {
        drawable->render(offset + box.getPosition(), target);
    }
}

PyObject* UIFrame::get_children(PyUIFrameObject* self, void* closure)
{
    // create PyUICollection instance pointing to self->data->children
    //PyUICollectionObject* o = (PyUICollectionObject*)mcrfpydef::PyUICollectionType.tp_alloc(&mcrfpydef::PyUICollectionType, 0);
    auto type = (PyTypeObject*)PyObject_GetAttrString(McRFPy_API::mcrf_module, "UICollection");
    auto o = (PyUICollectionObject*)type->tp_alloc(type, 0);
    if (o)
        o->data = self->data->children;
    return (PyObject*)o;
}


PyObject* UIFrame::get_float_member(PyUIFrameObject* self, void* closure)
{
    auto member_ptr = reinterpret_cast<long>(closure);
    if (member_ptr == 0)
        return PyFloat_FromDouble(self->data->box.getPosition().x);
    else if (member_ptr == 1)
        return PyFloat_FromDouble(self->data->box.getPosition().y);
    else if (member_ptr == 2)
        return PyFloat_FromDouble(self->data->box.getSize().x);
    else if (member_ptr == 3)
        return PyFloat_FromDouble(self->data->box.getSize().y);
    else if (member_ptr == 4)
        return PyFloat_FromDouble(self->data->box.getOutlineThickness());
    else
    {
        PyErr_SetString(PyExc_AttributeError, "Invalid attribute");
        return nullptr;
    }
}

int UIFrame::set_float_member(PyUIFrameObject* self, PyObject* value, void* closure)
{
    float val;
    auto member_ptr = reinterpret_cast<long>(closure);
    if (PyFloat_Check(value))
    {
        val = PyFloat_AsDouble(value);
    }
    else if (PyLong_Check(value))
    {
        val = PyLong_AsLong(value);
    }
    else
    {
        PyErr_SetString(PyExc_TypeError, "Value must be an integer.");
        return -1;
    }
    if (member_ptr == 0) //x
        self->data->box.setPosition(val, self->data->box.getPosition().y);
    else if (member_ptr == 1) //y
        self->data->box.setPosition(self->data->box.getPosition().x, val);
    else if (member_ptr == 2) //w
        self->data->box.setSize(sf::Vector2f(val, self->data->box.getSize().y));
    else if (member_ptr == 3) //h
        self->data->box.setSize(sf::Vector2f(self->data->box.getSize().x, val));
    else if (member_ptr == 4) //outline
        self->data->box.setOutlineThickness(val);
    return 0;
}

PyObject* UIFrame::get_color_member(PyUIFrameObject* self, void* closure)
{
    // validate closure (should be impossible to be wrong, but it's thorough)
    auto member_ptr = reinterpret_cast<long>(closure);
    if (member_ptr != 0 && member_ptr != 1)
    {
        PyErr_SetString(PyExc_AttributeError, "Invalid attribute");
        return nullptr;
    }
    //PyTypeObject* colorType = &PyColorType;
    auto colorType = (PyTypeObject*)PyObject_GetAttrString(McRFPy_API::mcrf_module, "Color");
    PyObject* pyColor = colorType->tp_alloc(colorType, 0);
    if (pyColor == NULL)
    {
        std::cout << "failure to allocate mcrfpy.Color / PyColorType" << std::endl;
        return NULL;
    }
    PyColorObject* pyColorObj = reinterpret_cast<PyColorObject*>(pyColor);

    // fetch correct member data
    sf::Color color;
    if (member_ptr == 0)
    {
        color = self->data->box.getFillColor();
        //return Py_BuildValue("(iii)", color.r, color.g, color.b);
    }
    else if (member_ptr == 1)
    {
        color = self->data->box.getOutlineColor();
        //return Py_BuildValue("(iii)", color.r, color.g, color.b);
    }
    
    return PyColor(color).pyObject();
}

int UIFrame::set_color_member(PyUIFrameObject* self, PyObject* value, void* closure)
{
    //TODO: this logic of (PyColor instance OR tuple -> sf::color) should be encapsulated for reuse
    auto member_ptr = reinterpret_cast<long>(closure);
    int r, g, b, a;
    if (PyObject_IsInstance(value, PyObject_GetAttrString(McRFPy_API::mcrf_module, "Color")))
    {
        sf::Color c = ((PyColorObject*)value)->data;
        r = c.r; g = c.g; b = c.b; a = c.a;
    }
    else if (!PyTuple_Check(value) || PyTuple_Size(value) < 3 || PyTuple_Size(value) > 4)
    {
        // reject non-Color, non-tuple value
        PyErr_SetString(PyExc_TypeError, "Value must be a tuple of 3 or 4 integers or an mcrfpy.Color object.");
        return -1;
    }
    else // get value from tuples
    {
        r = PyLong_AsLong(PyTuple_GetItem(value, 0));
        g = PyLong_AsLong(PyTuple_GetItem(value, 1));
        b = PyLong_AsLong(PyTuple_GetItem(value, 2));
        a = 255;

        if (PyTuple_Size(value) == 4)
        {
            a = PyLong_AsLong(PyTuple_GetItem(value, 3));
        }
    }

    if (r < 0 || r > 255 || g < 0 || g > 255 || b < 0 || b > 255 || a < 0 || a > 255)
    {
        PyErr_SetString(PyExc_ValueError, "Color values must be between 0 and 255.");
        return -1;
    }

    if (member_ptr == 0)
    {
        self->data->box.setFillColor(sf::Color(r, g, b, a));
    }
    else if (member_ptr == 1)
    {
        self->data->box.setOutlineColor(sf::Color(r, g, b, a));
    }
    else
    {
        PyErr_SetString(PyExc_AttributeError, "Invalid attribute");
        return -1;
    }

    return 0;
}

PyObject* UIFrame::get_pos(PyUIFrameObject* self, void* closure)
{
    auto type = (PyTypeObject*)PyObject_GetAttrString(McRFPy_API::mcrf_module, "Vector");
    auto obj = (PyVectorObject*)type->tp_alloc(type, 0);
    if (obj) {
        auto pos = self->data->box.getPosition();
        obj->data = sf::Vector2f(pos.x, pos.y);
    }
    return (PyObject*)obj;
}

int UIFrame::set_pos(PyUIFrameObject* self, PyObject* value, void* closure)
{
    PyVectorObject* vec = PyVector::from_arg(value);
    if (!vec) {
        PyErr_SetString(PyExc_TypeError, "pos must be a Vector or convertible to Vector");
        return -1;
    }
    self->data->box.setPosition(vec->data);
    return 0;
}

// Define the PyObjectType alias for the macros
typedef PyUIFrameObject PyObjectType;

// Method definitions
PyMethodDef UIFrame_methods[] = {
    UIDRAWABLE_METHODS,
    {NULL}  // Sentinel
};

PyGetSetDef UIFrame::getsetters[] = {
    {"x", (getter)UIFrame::get_float_member, (setter)UIFrame::set_float_member, "X coordinate of top-left corner",   (void*)0},
    {"y", (getter)UIFrame::get_float_member, (setter)UIFrame::set_float_member, "Y coordinate of top-left corner",   (void*)1},
    {"w", (getter)UIFrame::get_float_member, (setter)UIFrame::set_float_member, "width of the rectangle",   (void*)2},
    {"h", (getter)UIFrame::get_float_member, (setter)UIFrame::set_float_member, "height of the rectangle",   (void*)3},
    {"outline", (getter)UIFrame::get_float_member, (setter)UIFrame::set_float_member, "Thickness of the border",   (void*)4},
    {"fill_color", (getter)UIFrame::get_color_member, (setter)UIFrame::set_color_member, "Fill color of the rectangle", (void*)0},
    {"outline_color", (getter)UIFrame::get_color_member, (setter)UIFrame::set_color_member, "Outline color of the rectangle", (void*)1},
    {"children", (getter)UIFrame::get_children, NULL, "UICollection of objects on top of this one", NULL},
    {"click", (getter)UIDrawable::get_click, (setter)UIDrawable::set_click, "Object called with (x, y, button) when clicked", (void*)PyObjectsEnum::UIFRAME},
    {"z_index", (getter)UIDrawable::get_int, (setter)UIDrawable::set_int, "Z-order for rendering (lower values rendered first)", (void*)PyObjectsEnum::UIFRAME},
    {"name", (getter)UIDrawable::get_name, (setter)UIDrawable::set_name, "Name for finding elements", (void*)PyObjectsEnum::UIFRAME},
    {"pos", (getter)UIFrame::get_pos, (setter)UIFrame::set_pos, "Position as a Vector", NULL},
    UIDRAWABLE_GETSETTERS,
    {NULL}
};

PyObject* UIFrame::repr(PyUIFrameObject* self)
{
    std::ostringstream ss;
    if (!self->data) ss << "<Frame (invalid internal object)>";
    else {
        auto box = self->data->box;
        auto fc = box.getFillColor();
        auto oc = box.getOutlineColor();
        ss << "<Frame (x=" << box.getPosition().x << ", y=" << box.getPosition().y << ", w=" << 
            box.getSize().x << ", w=" << box.getSize().y << ", " <<
            "outline=" << box.getOutlineThickness() << ", " << 
            "fill_color=(" << (int)fc.r << ", " << (int)fc.g << ", " << (int)fc.b << ", " << (int)fc.a <<"), " <<
            "outline_color=(" << (int)oc.r << ", " << (int)oc.g << ", " << (int)oc.b << ", " << (int)oc.a <<"), " <<
            self->data->children->size() << " child objects" <<
            ")>";
    }
    std::string repr_str = ss.str();
    return PyUnicode_DecodeUTF8(repr_str.c_str(), repr_str.size(), "replace");
}

int UIFrame::init(PyUIFrameObject* self, PyObject* args, PyObject* kwds)
{
    // Parse position using the standardized helper
    auto pos_result = PyPositionHelper::parse_position(args, kwds);
    
    const char* keywords[] = { "x", "y", "w", "h", "fill_color", "outline_color", "outline", "children", "click", "pos", nullptr }; 
    float x = 0.0f, y = 0.0f, w = 0.0f, h=0.0f, outline=0.0f;
    PyObject* fill_color = 0;
    PyObject* outline_color = 0;
    PyObject* children_arg = 0;
    PyObject* click_handler = 0;
    PyObject* pos_obj = 0;

    // Try to parse all arguments including x, y
    if (PyArg_ParseTupleAndKeywords(args, kwds, "|ffffOOfOOO", const_cast<char**>(keywords), 
                                     &x, &y, &w, &h, &fill_color, &outline_color, &outline, &children_arg, &click_handler, &pos_obj))
    {
        // If pos was provided, it overrides x,y
        if (pos_obj && pos_obj != Py_None) {
            PyVectorObject* vec = PyVector::from_arg(pos_obj);
            if (!vec) {
                PyErr_SetString(PyExc_TypeError, "pos must be a Vector or tuple (x, y)");
                return -1;
            }
            x = vec->data.x;
            y = vec->data.y;
        }
    }
    else 
    {
        PyErr_Clear();  // Clear the error
        
        // Try to parse as ((x,y), w, h, ...) or (Vector, w, h, ...)
        const char* alt_keywords[] = { "pos", "w", "h", "fill_color", "outline_color", "outline", "children", "click", nullptr };
        PyObject* pos_arg = nullptr;
        
        if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OffOOfOO", const_cast<char**>(alt_keywords), 
                                          &pos_arg, &w, &h, &fill_color, &outline_color, &outline, &children_arg, &click_handler))
        {
            return -1;
        }
        
        // Convert position argument to x, y if provided
        if (pos_arg && pos_arg != Py_None) {
            PyVectorObject* vec = PyVector::from_arg(pos_arg);
            if (!vec) {
                PyErr_SetString(PyExc_TypeError, "pos must be a Vector or tuple (x, y)");
                return -1;
            }
            x = vec->data.x;
            y = vec->data.y;
        }
    }

    self->data->box.setPosition(sf::Vector2f(x, y));
    self->data->box.setSize(sf::Vector2f(w, h));
    self->data->box.setOutlineThickness(outline);
    // getsetter abuse because I haven't standardized Color object parsing (TODO)
    int err_val = 0;
    if (fill_color && fill_color != Py_None) err_val = UIFrame::set_color_member(self, fill_color, (void*)0);
    else self->data->box.setFillColor(sf::Color(0,0,0,255));
    if (err_val) return err_val;
    if (outline_color && outline_color != Py_None) err_val = UIFrame::set_color_member(self, outline_color, (void*)1);
    else self->data->box.setOutlineColor(sf::Color(128,128,128,255));
    if (err_val) return err_val;
    
    // Process children argument if provided
    if (children_arg && children_arg != Py_None) {
        if (!PySequence_Check(children_arg)) {
            PyErr_SetString(PyExc_TypeError, "children must be a sequence");
            return -1;
        }
        
        Py_ssize_t len = PySequence_Length(children_arg);
        for (Py_ssize_t i = 0; i < len; i++) {
            PyObject* child = PySequence_GetItem(children_arg, i);
            if (!child) return -1;
            
            // Check if it's a UIDrawable (Frame, Caption, Sprite, or Grid)
            PyObject* frame_type = PyObject_GetAttrString(McRFPy_API::mcrf_module, "Frame");
            PyObject* caption_type = PyObject_GetAttrString(McRFPy_API::mcrf_module, "Caption");
            PyObject* sprite_type = PyObject_GetAttrString(McRFPy_API::mcrf_module, "Sprite");
            PyObject* grid_type = PyObject_GetAttrString(McRFPy_API::mcrf_module, "Grid");
            
            if (!PyObject_IsInstance(child, frame_type) &&
                !PyObject_IsInstance(child, caption_type) &&
                !PyObject_IsInstance(child, sprite_type) &&
                !PyObject_IsInstance(child, grid_type)) {
                Py_DECREF(child);
                PyErr_SetString(PyExc_TypeError, "children must contain only Frame, Caption, Sprite, or Grid objects");
                return -1;
            }
            
            // Get the shared_ptr and add to children
            std::shared_ptr<UIDrawable> drawable = nullptr;
            if (PyObject_IsInstance(child, frame_type)) {
                drawable = ((PyUIFrameObject*)child)->data;
            } else if (PyObject_IsInstance(child, caption_type)) {
                drawable = ((PyUICaptionObject*)child)->data;
            } else if (PyObject_IsInstance(child, sprite_type)) {
                drawable = ((PyUISpriteObject*)child)->data;
            } else if (PyObject_IsInstance(child, grid_type)) {
                drawable = ((PyUIGridObject*)child)->data;
            }
            
            // Clean up type references
            Py_DECREF(frame_type);
            Py_DECREF(caption_type);
            Py_DECREF(sprite_type);
            Py_DECREF(grid_type);
            
            if (drawable) {
                self->data->children->push_back(drawable);
                self->data->children_need_sort = true;
            }
            
            Py_DECREF(child);
        }
    }
    
    // Process click handler if provided
    if (click_handler && click_handler != Py_None) {
        if (!PyCallable_Check(click_handler)) {
            PyErr_SetString(PyExc_TypeError, "click must be callable");
            return -1;
        }
        self->data->click_register(click_handler);
    }
    
    return 0;
}

// Animation property system implementation
bool UIFrame::setProperty(const std::string& name, float value) {
    if (name == "x") {
        box.setPosition(sf::Vector2f(value, box.getPosition().y));
        return true;
    } else if (name == "y") {
        box.setPosition(sf::Vector2f(box.getPosition().x, value));
        return true;
    } else if (name == "w") {
        box.setSize(sf::Vector2f(value, box.getSize().y));
        return true;
    } else if (name == "h") {
        box.setSize(sf::Vector2f(box.getSize().x, value));
        return true;
    } else if (name == "outline") {
        box.setOutlineThickness(value);
        return true;
    } else if (name == "fill_color.r") {
        auto color = box.getFillColor();
        color.r = std::clamp(static_cast<int>(value), 0, 255);
        box.setFillColor(color);
        return true;
    } else if (name == "fill_color.g") {
        auto color = box.getFillColor();
        color.g = std::clamp(static_cast<int>(value), 0, 255);
        box.setFillColor(color);
        return true;
    } else if (name == "fill_color.b") {
        auto color = box.getFillColor();
        color.b = std::clamp(static_cast<int>(value), 0, 255);
        box.setFillColor(color);
        return true;
    } else if (name == "fill_color.a") {
        auto color = box.getFillColor();
        color.a = std::clamp(static_cast<int>(value), 0, 255);
        box.setFillColor(color);
        return true;
    } else if (name == "outline_color.r") {
        auto color = box.getOutlineColor();
        color.r = std::clamp(static_cast<int>(value), 0, 255);
        box.setOutlineColor(color);
        return true;
    } else if (name == "outline_color.g") {
        auto color = box.getOutlineColor();
        color.g = std::clamp(static_cast<int>(value), 0, 255);
        box.setOutlineColor(color);
        return true;
    } else if (name == "outline_color.b") {
        auto color = box.getOutlineColor();
        color.b = std::clamp(static_cast<int>(value), 0, 255);
        box.setOutlineColor(color);
        return true;
    } else if (name == "outline_color.a") {
        auto color = box.getOutlineColor();
        color.a = std::clamp(static_cast<int>(value), 0, 255);
        box.setOutlineColor(color);
        return true;
    }
    return false;
}

bool UIFrame::setProperty(const std::string& name, const sf::Color& value) {
    if (name == "fill_color") {
        box.setFillColor(value);
        return true;
    } else if (name == "outline_color") {
        box.setOutlineColor(value);
        return true;
    }
    return false;
}

bool UIFrame::setProperty(const std::string& name, const sf::Vector2f& value) {
    if (name == "position") {
        box.setPosition(value);
        return true;
    } else if (name == "size") {
        box.setSize(value);
        return true;
    }
    return false;
}

bool UIFrame::getProperty(const std::string& name, float& value) const {
    if (name == "x") {
        value = box.getPosition().x;
        return true;
    } else if (name == "y") {
        value = box.getPosition().y;
        return true;
    } else if (name == "w") {
        value = box.getSize().x;
        return true;
    } else if (name == "h") {
        value = box.getSize().y;
        return true;
    } else if (name == "outline") {
        value = box.getOutlineThickness();
        return true;
    } else if (name == "fill_color.r") {
        value = box.getFillColor().r;
        return true;
    } else if (name == "fill_color.g") {
        value = box.getFillColor().g;
        return true;
    } else if (name == "fill_color.b") {
        value = box.getFillColor().b;
        return true;
    } else if (name == "fill_color.a") {
        value = box.getFillColor().a;
        return true;
    } else if (name == "outline_color.r") {
        value = box.getOutlineColor().r;
        return true;
    } else if (name == "outline_color.g") {
        value = box.getOutlineColor().g;
        return true;
    } else if (name == "outline_color.b") {
        value = box.getOutlineColor().b;
        return true;
    } else if (name == "outline_color.a") {
        value = box.getOutlineColor().a;
        return true;
    }
    return false;
}

bool UIFrame::getProperty(const std::string& name, sf::Color& value) const {
    if (name == "fill_color") {
        value = box.getFillColor();
        return true;
    } else if (name == "outline_color") {
        value = box.getOutlineColor();
        return true;
    }
    return false;
}

bool UIFrame::getProperty(const std::string& name, sf::Vector2f& value) const {
    if (name == "position") {
        value = box.getPosition();
        return true;
    } else if (name == "size") {
        value = box.getSize();
        return true;
    }
    return false;
}