#include "gui_xml.hpp"

#include "elements/Panel.hpp"
#include "elements/Image.hpp"
#include "elements/Menu.hpp"
#include "elements/Button.hpp"
#include "elements/CheckBox.hpp"
#include "elements/TextBox.hpp"
#include "elements/TrackBar.hpp"
#include "elements/InputBindBox.hpp"
#include "elements/InventoryView.hpp"

#include "frontend/menu.hpp"
#include "frontend/locale.hpp"
#include "items/Inventory.hpp"
#include "logic/scripting/scripting.hpp"
#include "maths/voxmaths.hpp"
#include "util/stringutil.hpp"
#include "window/Events.hpp"

#include <stdexcept>
#include <utility>

using namespace gui;

static Align align_from_string(const std::string& str, Align def) {
    if (str == "left") return Align::left;
    if (str == "center") return Align::center;
    if (str == "right") return Align::right;
    if (str == "top") return Align::top;
    if (str == "bottom") return Align::bottom;
    return def;
}

static Gravity gravity_from_string(const std::string& str) {
    static const std::unordered_map<std::string, Gravity> gravity_names {
        {"top-left", Gravity::top_left},
        {"top-center", Gravity::top_center},
        {"top-right", Gravity::top_right},
        {"center-left", Gravity::center_left},
        {"center-center", Gravity::center_center},
        {"center-right", Gravity::center_right},
        {"bottom-left", Gravity::bottom_left},
        {"bottom-center", Gravity::bottom_center},
        {"bottom-right", Gravity::bottom_right},
    };
    auto found = gravity_names.find(str);
    if (found != gravity_names.end()) {
        return found->second;
    }
    return Gravity::none;
}

static runnable create_runnable(
    const UiXmlReader& reader, 
    const xml::xmlelement& element,
    const std::string& name
) {
    if (element->has(name)) {
        std::string text = element->attr(name).getText();
        if (!text.empty()) {
            return scripting::create_runnable(
                reader.getEnvironment(), text, reader.getFilename()
            );
        }
    }
    return nullptr;
}

static onaction create_action(UiXmlReader& reader, const xml::xmlelement& element, const std::string& name) {
    auto callback = create_runnable(reader, element, name);
    if (callback == nullptr) {
        return nullptr;
    }
    return [callback](GUI*) {callback();};
}

/* Read basic UINode properties */
static void _readUINode(UiXmlReader& reader, const xml::xmlelement& element, UINode& node) {
    if (element->has("id")) {
        node.setId(element->attr("id").getText());
    }
    if (element->has("pos")) {
        node.setPos(element->attr("pos").asVec2());
    }
    if (element->has("size")) {
        node.setSize(element->attr("size").asVec2());
    }
    if (element->has("color")) {
        glm::vec4 color = element->attr("color").asColor();
        glm::vec4 hoverColor = color;
        glm::vec4 pressedColor = color;
        if (element->has("hover-color")) {
            hoverColor = node.getHoverColor();
        }
        if (element->has("pressed-color")) {
            pressedColor = node.getPressedColor();
        }
        node.setColor(color);
        node.setHoverColor(hoverColor);
        node.setPressedColor(pressedColor);
    }
    if (element->has("margin")) {
        node.setMargin(element->attr("margin").asVec4());
    }
    if (element->has("z-index")) {
        node.setZIndex(element->attr("z-index").asInt());
    }
    if (element->has("interactive")) {
        node.setInteractive(element->attr("interactive").asBool());
    }
    if (element->has("visible")) {
        node.setVisible(element->attr("visible").asBool());
    }
    if (element->has("enabled")) {
        node.setEnabled(element->attr("enabled").asBool());
    }
    if (element->has("position-func")) {
        node.setPositionFunc(scripting::create_vec2_supplier(
            reader.getEnvironment(),
            element->attr("position-func").getText(),
            reader.getFilename()
        ));
    }
    if (element->has("size-func")) {
        node.setSizeFunc(scripting::create_vec2_supplier(
            reader.getEnvironment(),
            element->attr("size-func").getText(),
            reader.getFilename()
        ));
    }
    if (element->has("hover-color")) {
        node.setHoverColor(element->attr("hover-color").asColor());
    }
    if (element->has("pressed-color")) {
        node.setPressedColor(element->attr("pressed-color").asColor());
    }
    std::string alignName = element->attr("align", "").getText();
    node.setAlign(align_from_string(alignName, node.getAlign()));

    if (element->has("gravity")) {
        node.setGravity(gravity_from_string(
            element->attr("gravity").getText()
        ));
    }

    if (element->has("tooltip")) {
        node.setTooltip(util::str2wstr_utf8(element->attr("tooltip").getText()));
    }
    if (element->has("tooltip-delay")) {
        node.setTooltipDelay(element->attr("tooltip-delay").asFloat());
    }

    if (auto onclick = create_action(reader, element, "onclick")) {
        node.listenAction(onclick);
    }

    if (auto ondoubleclick = create_action(reader, element, "ondoubleclick")) {
        node.listenDoubleClick(ondoubleclick);
    }
}

static void _readContainer(UiXmlReader& reader, const xml::xmlelement& element, Container& container) {
    _readUINode(reader, element, container);

    if (element->has("scrollable")) {
        container.setScrollable(element->attr("scrollable").asBool());
    }
    for (auto& sub : element->getElements()) {
        if (sub->isText())
            continue;
        auto subnode = reader.readUINode(sub);
        if (subnode) {
            container.add(subnode);
        }
    }
}

void UiXmlReader::readUINode(UiXmlReader& reader, const xml::xmlelement& element, Container& container) {
    _readContainer(reader, element, container);
}

void UiXmlReader::readUINode(UiXmlReader& reader, const xml::xmlelement& element, UINode& node) {
    _readUINode(reader, element, node);
}

static void _readPanel(UiXmlReader& reader, const xml::xmlelement& element, Panel& panel, bool subnodes=true) {
    _readUINode(reader, element, panel);

    if (element->has("padding")) {
        glm::vec4 padding = element->attr("padding").asVec4();
        panel.setPadding(padding);
        glm::vec2 size = panel.getSize();
        panel.setSize(glm::vec2(
            size.x + padding.x + padding.z,
            size.y + padding.y + padding.w
        ));
    }
    if (element->has("size")) {
        panel.setResizing(false);
    }
    if (element->has("max-length")) {
        panel.setMaxLength(element->attr("max-length").asInt());
    }
    if (element->has("orientation")) {
        auto &oname = element->attr("orientation").getText();
        if (oname == "horizontal") {
            panel.setOrientation(Orientation::horizontal);
        }
    }
    if (subnodes) {
        for (auto& sub : element->getElements()) {
            if (sub->isText())
                continue;
            auto subnode = reader.readUINode(sub);
            if (subnode) {
                panel.add(subnode);
            }
        }
    }
}

static std::wstring readAndProcessInnerText(const xml::xmlelement& element, const std::string& context) {
    std::wstring text = L"";
    if (element->size() == 1) {
        std::string source = element->sub(0)->attr("#").getText();
        util::trim(source);
        text = util::str2wstr_utf8(source); 
        if (text[0] == '@') {
            if (context.empty()) {
                text = langs::get(text.substr(1));
            } else {
                text = langs::get(text.substr(1), util::str2wstr_utf8(context));
            }
        }
    }
    return text;
}

static std::shared_ptr<UINode> readLabel(UiXmlReader& reader, const xml::xmlelement& element) {
    std::wstring text = readAndProcessInnerText(element, reader.getContext());
    auto label = std::make_shared<Label>(text);
    _readUINode(reader, element, *label);
    if (element->has("valign")) {
        label->setVerticalAlign(
            align_from_string(element->attr("valign").getText(), label->getVerticalAlign())
        );
    }
    if (element->has("supplier")) {
        label->textSupplier(scripting::create_wstring_supplier(
            reader.getEnvironment(),
            element->attr("supplier").getText(),
            reader.getFilename()
        ));
    }
    if (element->has("autoresize")) {
        label->setAutoResize(element->attr("autoresize").asBool());
    }
    if (element->has("multiline")) {
        label->setMultiline(element->attr("multiline").asBool());
        if (!element->has("valign")) {
            label->setVerticalAlign(Align::top);
        }
    }
    if (element->has("text-wrap")) {
        label->setTextWrapping(element->attr("text-wrap").asBool());
    }
    return label;
}

static std::shared_ptr<UINode> readContainer(UiXmlReader& reader, const xml::xmlelement& element) {
    auto container = std::make_shared<Container>(glm::vec2());
    _readContainer(reader, element, *container);
    return container;
}

static std::shared_ptr<UINode> readPanel(UiXmlReader& reader, const xml::xmlelement& element) {
    float interval = element->attr("interval", "2").asFloat();
    auto panel = std::make_shared<Panel>(glm::vec2(), glm::vec4(), interval);
    _readPanel(reader, element, *panel);
    return panel;
}

static std::shared_ptr<UINode> readButton(UiXmlReader& reader, const xml::xmlelement& element) {
    glm::vec4 padding = element->attr("padding", "10").asVec4();

    std::shared_ptr<Button> button;
    auto& elements = element->getElements();
    if (!elements.empty() && elements[0]->getTag() != "#") {
        auto inner = reader.readUINode(element->getElements().at(0));
        if (inner != nullptr) {
            button = std::make_shared<Button>(inner, padding);
        } else {
            button = std::make_shared<Button>(L"", padding, nullptr);
        }
        _readPanel(reader, element, *button, false);
    } else {
        std::wstring text = readAndProcessInnerText(element, reader.getContext());
        button = std::make_shared<Button>(text, padding, nullptr);
        _readPanel(reader, element, *button, true);
    }
    if (element->has("text-align")) {
        button->setTextAlign(align_from_string(element->attr("text-align").getText(), button->getTextAlign()));
    }
    return button;
}

static std::shared_ptr<UINode> readCheckBox(UiXmlReader& reader, const xml::xmlelement& element) {
    auto text = readAndProcessInnerText(element, reader.getContext());
    bool checked = element->attr("checked", "false").asBool();
    auto checkbox = std::make_shared<FullCheckBox>(text, glm::vec2(32), checked);
    _readPanel(reader, element, *checkbox);

    if (element->has("consumer")) {
        checkbox->setConsumer(scripting::create_bool_consumer(
            reader.getEnvironment(),
            element->attr("consumer").getText(),
            reader.getFilename()
        ));
    }

    if (element->has("supplier")) {
        checkbox->setSupplier(scripting::create_bool_supplier(
            reader.getEnvironment(),
            element->attr("supplier").getText(),
            reader.getFilename()
        ));
    }
    return checkbox;
}

static std::shared_ptr<UINode> readTextBox(UiXmlReader& reader, const xml::xmlelement& element) {
    auto placeholder = util::str2wstr_utf8(element->attr("placeholder", "").getText());
    auto text = readAndProcessInnerText(element, reader.getContext());
    auto textbox = std::make_shared<TextBox>(placeholder, glm::vec4(0.0f));
    _readPanel(reader, element, *textbox);
    textbox->setText(text);

    if (element->has("multiline")) {
        textbox->setMultiline(element->attr("multiline").asBool());
    }
    if (element->has("text-wrap")) {
        textbox->setTextWrapping(element->attr("text-wrap").asBool());
    }
    if (element->has("editable")) {
        textbox->setEditable(element->attr("editable").asBool());
    }
    if (element->has("autoresize")) {
        textbox->setAutoResize(element->attr("autoresize").asBool());
    }
    if (element->has("consumer")) {
        textbox->setTextConsumer(scripting::create_wstring_consumer(
            reader.getEnvironment(),
            element->attr("consumer").getText(),
            reader.getFilename()
        ));
    }
    if (element->has("supplier")) {
        textbox->setTextSupplier(scripting::create_wstring_supplier(
            reader.getEnvironment(),
            element->attr("supplier").getText(),
            reader.getFilename()
        ));
    }
    if (element->has("focused-color")) {
        textbox->setFocusedColor(element->attr("focused-color").asColor());
    }
    if (element->has("error-color")) {
        textbox->setErrorColor(element->attr("error-color").asColor());
    }
    if (element->has("validator")) {
        textbox->setTextValidator(scripting::create_wstring_validator(
            reader.getEnvironment(),
            element->attr("validator").getText(),
            reader.getFilename()
        ));
    }
    if (auto onUpPressed = create_runnable(reader, element, "onup")) {
        textbox->setOnUpPressed(onUpPressed);
    }
    if (auto onDownPressed = create_runnable(reader, element, "ondown")) {
        textbox->setOnDownPressed(onDownPressed);
    }
    return textbox;
}

static std::shared_ptr<UINode> readImage(UiXmlReader& reader, const xml::xmlelement& element) {
    std::string src = element->attr("src", "").getText();
    auto image = std::make_shared<Image>(src);
    _readUINode(reader, element, *image);
    return image;
}

static std::shared_ptr<UINode> readTrackBar(UiXmlReader& reader, const xml::xmlelement& element) {
    const auto& env = reader.getEnvironment();
    const auto& file = reader.getFilename();
    float minv = element->attr("min", "0.0").asFloat();
    float maxv = element->attr("max", "1.0").asFloat();
    float def = element->attr("value", "0.0").asFloat();
    float step = element->attr("step", "1.0").asFloat();
    int trackWidth = element->attr("track-width", "12").asInt();
    auto bar = std::make_shared<TrackBar>(minv, maxv, def, step, trackWidth);
    _readUINode(reader, element, *bar);
    if (element->has("consumer")) {
        bar->setConsumer(scripting::create_number_consumer(
            env, element->attr("consumer").getText(), file));
    }
    if (element->has("sub-consumer")) {
        bar->setSubConsumer(scripting::create_number_consumer(
            env, element->attr("sub-consumer").getText(), file));
    }
    if (element->has("supplier")) {
        bar->setSupplier(scripting::create_number_supplier(
            env, element->attr("supplier").getText(), file));
    }
    if (element->has("track-color")) {
        bar->setTrackColor(element->attr("track-color").asColor());
    }
    if (element->has("change-on-release")) {
        bar->setChangeOnRelease(element->attr("change-on-release").asBool());
    }
    return bar;
}

static std::shared_ptr<UINode> readInputBindBox(UiXmlReader& reader, const xml::xmlelement& element) {
    auto bindname = element->attr("binding").getText();
    auto found = Events::bindings.find(bindname);
    if (found == Events::bindings.end()) {
        throw std::runtime_error("binding does not exists "+util::quote(bindname));
    }
    glm::vec4 padding = element->attr("padding", "6").asVec4();
    auto bindbox = std::make_shared<InputBindBox>(found->second, padding);
    _readPanel(reader, element, *bindbox);

    return bindbox;
}

static slotcallback readSlotFunc(InventoryView* view, UiXmlReader& reader, xml::xmlelement& element, const std::string& attr) {
    auto consumer = scripting::create_int_array_consumer(
        reader.getEnvironment(), 
        element->attr(attr).getText()
    );
    return [=](uint slot, ItemStack&) {
        int args[] {int(view->getInventory()->getId()), int(slot)};
        consumer(args, 2);
    };
}

static void readSlot(InventoryView* view, UiXmlReader& reader, xml::xmlelement element) {
    int index = element->attr("index", "0").asInt();
    bool itemSource = element->attr("item-source", "false").asBool();
    SlotLayout layout(index, glm::vec2(), true, itemSource, nullptr, nullptr, nullptr);
    if (element->has("pos")) {
        layout.position = element->attr("pos").asVec2();
    }
    if (element->has("updatefunc")) {
        layout.updateFunc = readSlotFunc(view, reader, element, "updatefunc");
    }
    if (element->has("sharefunc")) {
        layout.shareFunc = readSlotFunc(view, reader, element, "sharefunc");
    }
    if (element->has("onrightclick")) {
        layout.rightClick = readSlotFunc(view, reader, element, "onrightclick");
    }
    auto slot = view->addSlot(layout);
    reader.readUINode(reader, element, *slot);
    view->add(slot);
}

static void readSlotsGrid(InventoryView* view, UiXmlReader& reader, xml::xmlelement element) {
    int startIndex = element->attr("start-index", "0").asInt();
    int rows = element->attr("rows", "0").asInt();
    int cols = element->attr("cols", "0").asInt();
    int count = element->attr("count", "0").asInt();
    const int slotSize = InventoryView::SLOT_SIZE;
    int interval = element->attr("interval", "-1").asInt();
    if (interval < 0) {
        interval = InventoryView::SLOT_INTERVAL;
    }
    int padding = element->attr("padding", "-1").asInt();
    if (padding < 0) {
        padding = interval;
    }
    if (rows == 0) {
        rows = ceildiv(count, cols);
    } else if (cols == 0) {
        cols = ceildiv(count, rows);
    } else if (count == 0) {
        count = rows * cols;
    }
    bool itemSource = element->attr("item-source", "false").asBool();
    SlotLayout layout(-1, glm::vec2(), true, itemSource, nullptr, nullptr, nullptr);
    if (element->has("pos")) {
        layout.position = element->attr("pos").asVec2();
    }
    if (element->has("updatefunc")) {
        layout.updateFunc = readSlotFunc(view, reader, element, "updatefunc");
    }
    if (element->has("sharefunc")) {
        layout.shareFunc = readSlotFunc(view, reader, element, "sharefunc");
    }
    if (element->has("onrightclick")) {
        layout.rightClick = readSlotFunc(view, reader, element, "onrightclick");
    }
    layout.padding = padding;

    int idx = 0;
    for (int row = 0; row < rows; row++) {
        for (int col = 0; col < cols; col++, idx++) {
            if (idx >= count) {
                return;
            }
            SlotLayout slotLayout = layout;
            slotLayout.index = startIndex + idx;
            slotLayout.position += glm::vec2(
                padding + col * (slotSize + interval),
                padding + (rows-row-1) * (slotSize + interval)
            );
            auto slot = view->addSlot(slotLayout);
            view->add(slot, slotLayout.position);
        }
    }
}

static std::shared_ptr<UINode> readInventory(UiXmlReader& reader, const xml::xmlelement& element) {
    auto view = std::make_shared<InventoryView>();
    view->setColor(glm::vec4(0.122f, 0.122f, 0.122f, 0.878f)); // todo: fixme
    reader.addIgnore("slot");
    reader.addIgnore("slots-grid");
    reader.readUINode(reader, element, *view);

    for (auto& sub : element->getElements()) {
        if (sub->getTag() == "slot") {
            readSlot(view.get(), reader, sub);
        } else if (sub->getTag() == "slots-grid") {
            readSlotsGrid(view.get(), reader, sub);
        }
    }
    return view;
} 

static std::shared_ptr<UINode> readPageBox(UiXmlReader& reader, const xml::xmlelement& element) {
    auto menu = std::make_shared<Menu>();
    // fixme
    menu->setPageLoader(menus::create_page_loader(scripting::engine));
    _readContainer(reader, element, *menu);

    return menu;
}

UiXmlReader::UiXmlReader(const scriptenv& env) : env(env) {
    contextStack.emplace("");
    add("image", readImage);
    add("label", readLabel);
    add("panel", readPanel);
    add("button", readButton);
    add("textbox", readTextBox);
    add("pagebox", readPageBox);
    add("checkbox", readCheckBox);
    add("trackbar", readTrackBar);
    add("container", readContainer);
    add("bindbox", readInputBindBox);
    add("inventory", readInventory);
}

void UiXmlReader::add(const std::string& tag, uinode_reader reader) {
    readers[tag] = std::move(reader);
}

bool UiXmlReader::hasReader(const std::string& tag) const {
    return readers.find(tag) != readers.end();
}

void UiXmlReader::addIgnore(const std::string& tag) {
    ignored.insert(tag);
}

std::shared_ptr<UINode> UiXmlReader::readUINode(const xml::xmlelement& element) {
    if (element->has("if")) {
        const auto& cond = element->attr("if").getText();
        if (cond.empty() || cond == "false" || cond == "nil")
            return nullptr;
    }
    if (element->has("ifnot")) {
        const auto& cond = element->attr("ifnot").getText();
        if (!(cond.empty() || cond == "false" || cond == "nil"))
            return nullptr;
    }

    const std::string& tag = element->getTag();
    auto found = readers.find(tag);
    if (found == readers.end()) {
        if (ignored.find(tag) != ignored.end()) {
            return nullptr;
        }
        throw std::runtime_error("unsupported element '"+tag+"'");
    }

    bool hascontext = element->has("context");
    if (hascontext) {
        contextStack.push(element->attr("context").getText());
    }
    auto node = found->second(*this, element);
    if (hascontext) {
        contextStack.pop();
    }
    return node;
}

std::shared_ptr<UINode> UiXmlReader::readXML(
    const std::string& filename,
    const std::string& source
) {
    this->filename = filename;
    auto document = xml::parse(filename, source);
    auto root = document->getRoot();
    return readUINode(root);
}

std::shared_ptr<UINode> UiXmlReader::readXML(
    const std::string& filename,
    const xml::xmlelement& root
) {
    this->filename = filename;
    return readUINode(root);
}

const std::string& UiXmlReader::getContext() const {
    return contextStack.top();
}

const std::string& UiXmlReader::getFilename() const {
    return filename;
}

const scriptenv& UiXmlReader::getEnvironment() const {
    return env;
}
