#include "pch.h"
#include "layout.h"
#include "util.hpp"

Plane WidgetBorder::m_plane;

void Node::update(float width, float height)
{
    YGNodeStyleSetWidth(y_node, width);
    YGNodeStyleSetHeight(y_node, height);
    YGNodeCalculateLayout(y_node, YGUndefined, YGUndefined, YGDirectionLTR);
    glm::mat4 proj = glm::ortho(0.f, m_size.x, m_size.y, 0.f, -1.f, 1.f);
    update_internal({ 0, 0 }, proj);
}

void Node::update_internal(const glm::vec2& origin, const glm::mat4& proj)
{
    float x = YGNodeLayoutGetLeft(y_node);
    float y = YGNodeLayoutGetTop(y_node);
    float w = YGNodeLayoutGetWidth(y_node);
    float h = YGNodeLayoutGetHeight(y_node);
    m_pos = origin + glm::vec2(x, y);
    m_size = glm::vec2(w, h);
    m_clip = !parent ? glm::vec4(m_pos, m_size) : rect_intersection(glm::vec4(m_pos, m_size), parent->m_clip);
    if (m_widget)
    {
        glm::mat4 pivot = glm::translate(glm::vec3(.5f, .5f, 0.f));
        glm::mat4 scale = glm::scale(glm::vec3(m_size, 1.f));
        glm::mat4 pos = glm::translate(glm::vec3(m_pos, 0));
        m_widget->mvp = proj * pos * scale * pivot;
        m_widget->clip = m_clip;
    }
    for (auto& c : m_children)
        c.update_internal(m_pos, proj);
}

void Node::parse_attributes(kAttribute ka, const tinyxml2::XMLAttribute* attr)
{
    switch (ka)
    {
    case kAttribute::Width:
        if (strcmp(attr->Value(), "auto") == 0)
        {
            YGNodeStyleSetWidth(y_node, YGUndefined);
            YGNodeStyleSetWidthPercent(y_node, YGUndefined);
        }
        else
        {
            if (strchr(attr->Value(), '%'))
                YGNodeStyleSetWidthPercent(y_node, attr->FloatValue());
            else
                YGNodeStyleSetWidth(y_node, attr->FloatValue());
        }
        break;
    case kAttribute::MinWidth:
        if (strchr(attr->Value(), '%'))
            YGNodeStyleSetMinWidthPercent(y_node, attr->FloatValue());
        else
            YGNodeStyleSetMinWidth(y_node, attr->FloatValue());
        break;
    case kAttribute::MaxWidth:
        YGNodeStyleSetMaxWidth(y_node, attr->FloatValue());
        break;
    case kAttribute::Height:
        if (strcmp(attr->Value(), "auto") == 0)
        {
            YGNodeStyleSetHeight(y_node, YGUndefined);
            YGNodeStyleSetHeightPercent(y_node, YGUndefined);
        }
        else
        {
            if (strchr(attr->Value(), '%'))
                YGNodeStyleSetHeightPercent(y_node, attr->FloatValue());
            else
                YGNodeStyleSetHeight(y_node, attr->FloatValue());
        }
        break;
    case kAttribute::MinHeight:
        YGNodeStyleSetMinHeight(y_node, attr->FloatValue());
        break;
    case kAttribute::MaxHeight:
        YGNodeStyleSetMaxHeight(y_node, attr->FloatValue());
        break;
    case kAttribute::Grow:
        YGNodeStyleSetFlexGrow(y_node, attr->FloatValue());
        break;
    case kAttribute::Shrink:
        YGNodeStyleSetFlexShrink(y_node, attr->FloatValue());
        break;
    case kAttribute::FlexDir:
    {
        YGFlexDirection dir = YGFlexDirectionRow;
        if (strcmp("col", attr->Value()) == 0)
            dir = YGFlexDirectionColumn;
        else if (strcmp("col-reverse", attr->Value()) == 0)
            dir = YGFlexDirectionColumnReverse;
        else if (strcmp("row", attr->Value()) == 0)
            dir = YGFlexDirectionRow;
        else if (strcmp("row-reverse", attr->Value()) == 0)
            dir = YGFlexDirectionRowReverse;
        YGNodeStyleSetFlexDirection(y_node, dir);
        break;
    }
    case kAttribute::FlexWrap:
        YGNodeStyleSetFlexWrap(y_node, attr->IntValue() ? YGWrapWrap : YGWrapNoWrap);
        break;
    case kAttribute::Padding:
    {
        glm::vec4 pad;
        int n = sscanf(attr->Value(), "%f %f %f %f", &pad.x, &pad.y, &pad.z, &pad.w);
        if (n == 1)
        {
            YGNodeStyleSetPadding(y_node, YGEdgeTop, pad.x);
            YGNodeStyleSetPadding(y_node, YGEdgeRight, pad.x);
            YGNodeStyleSetPadding(y_node, YGEdgeBottom, pad.x);
            YGNodeStyleSetPadding(y_node, YGEdgeLeft, pad.x);
        }
        else
        {
            YGNodeStyleSetPadding(y_node, YGEdgeTop, pad.x);
            YGNodeStyleSetPadding(y_node, YGEdgeRight, pad.y);
            YGNodeStyleSetPadding(y_node, YGEdgeBottom, pad.z);
            YGNodeStyleSetPadding(y_node, YGEdgeLeft, pad.w);
        }
        break;
    }
    case kAttribute::Margin:
    {
        glm::vec4 pad;
        int n = sscanf(attr->Value(), "%f %f %f %f", &pad.x, &pad.y, &pad.z, &pad.w);
        if (n == 1)
        {
            YGNodeStyleSetMargin(y_node, YGEdgeTop, pad.x);
            YGNodeStyleSetMargin(y_node, YGEdgeRight, pad.x);
            YGNodeStyleSetMargin(y_node, YGEdgeBottom, pad.x);
            YGNodeStyleSetMargin(y_node, YGEdgeLeft, pad.x);
        }
        else
        {
            YGNodeStyleSetMargin(y_node, YGEdgeTop, pad.x);
            YGNodeStyleSetMargin(y_node, YGEdgeRight, pad.y);
            YGNodeStyleSetMargin(y_node, YGEdgeBottom, pad.z);
            YGNodeStyleSetMargin(y_node, YGEdgeLeft, pad.w);
        }
        break;
    }
    default:
        if (m_widget)
            m_widget->parse_attributes(ka, attr);
        break;
    }
}

void Node::load(const char* path)
{
    struct stat tmp_info;
    if (stat(path, &tmp_info) != 0)
        return;
    if (tmp_info.st_mtime <= m_file_info.st_mtime)
        return;
    m_file_info = tmp_info;
    m_path = path;

    m_children.clear();
    YGNodeReset(y_node);

    tinyxml2::XMLDocument xml;
    auto ret = xml.LoadFile(path);
    if (ret != tinyxml2::XMLError::XML_SUCCESS)
        return;
    load_internal(xml.RootElement());
}

void Node::load_internal(const tinyxml2::XMLElement* x_node)
{
    m_name = x_node->Name();
    auto attr = x_node->FirstAttribute();
    
    kWidget widget_id = (kWidget)const_hash(x_node->Name());
    switch (widget_id)
    {
    case kWidget::Border:
        m_widget = std::make_unique<WidgetBorder>();
        break;
    }
    
    while (attr)
    {
        parse_attributes((kAttribute)const_hash(attr->Name()), attr);
        attr = attr->Next();
    }

    auto x_child = x_node->FirstChildElement();
    while (x_child)
    {
        //Node n;
        m_children.emplace_back();
        auto& n = m_children.back();
        n.parent = this;
        YGNodeInsertChild(y_node, n.y_node, YGNodeGetChildCount(y_node));
        n.load_internal(x_child);
        x_child = x_child->NextSiblingElement();
    }
}

void Node::reload()
{
    float w = YGNodeLayoutGetWidth(y_node);
    float h = YGNodeLayoutGetHeight(y_node);
    // avoid conflict when assigning the same string from c_str
    std::string path_copy = m_path; 
    load(path_copy.c_str());
    update(w, h);
}