#include "TextBoxEditTool.hpp"
#include "../../DrawingProgram.hpp"
#include "../../../MainProgram.hpp"
#include "../../../DrawData.hpp"
#include "Helpers/ConvertVec.hpp"
#include "Helpers/SCollision.hpp"
#include <cereal/types/vector.hpp>
#include <include/core/SkFontStyle.h>
#include <modules/skparagraph/include/DartTypes.h>
#include <modules/skparagraph/include/ParagraphStyle.h>
#include <modules/skparagraph/include/TextStyle.h>
#include <modules/skparagraph/src/ParagraphBuilderImpl.h>
#include <modules/skunicode/include/SkUnicode_icu.h>
#include <memory>
#include "../EditTool.hpp"

#include "../../../GUIStuff/ElementHelpers/TextLabelHelpers.hpp"
#include "../../../GUIStuff/ElementHelpers/LayoutHelpers.hpp"
#include "../../../GUIStuff/ElementHelpers/ButtonHelpers.hpp"
#include "../../../GUIStuff/ElementHelpers/NumberSliderHelpers.hpp"
#include "../../../GUIStuff/Elements/PositionAdjustingPopupMenu.hpp"

using namespace RichText;

TextBoxEditTool::TextBoxEditTool(DrawingProgram& initDrawP, CanvasComponentContainer::ObjInfo* initComp):
    DrawingProgramEditToolBase(initDrawP, initComp)
{}

void TextBoxEditTool::commit_update_func() {
    comp->obj->commit_update(drawP);
}

void TextBoxEditTool::commit_update_and_layout_func() {
    comp->obj->commit_update(drawP);
    drawP.world.main.g.gui.set_to_layout();
}

void TextBoxEditTool::edit_gui() {
    using namespace GUIStuff;
    using namespace ElementHelpers;

    auto& a = static_cast<TextBoxCanvasComponent&>(comp->obj->get_comp());
    Toolbar& t = drawP.world.main.toolbar;
    auto& gui = drawP.world.main.g.gui;
    auto& currentMods = *currentModsPtr;

    gui.new_id("edit tool text", [&] {
        text_label_centered(gui, "Edit Text");

        //left_to_right_line_layout(gui, [&] {
        //    text_label(gui, "Font");
        //    if(gui.font_picker("font picker", &newFontName)) {
        //        currentMods[TextStyleModifier::ModifierType::FONT_FAMILIES] = std::make_shared<FontFamiliesTextStyleModifier>(std::vector<SkString>{SkString{newFontName.c_str(), newFontName.size()}});
        //        add_undo_if_selecting_area(a, [&]() {a.textBox->set_text_style_modifier_between(a.cursor->selectionBeginPos, a.cursor->selectionEndPos, currentMods[TextStyleModifier::ModifierType::FONT_FAMILIES]);});
        //    }
        //});
        
        left_to_right_line_centered_layout(gui, [&] {
            svg_icon_button(gui, "Bold button", "data/icons/RemixIcon/bold.svg", {
                .isSelected = newIsBold,
                .onClick = [&] {
                    newIsBold = !newIsBold;
                    currentMods[TextStyleModifier::ModifierType::WEIGHT] = std::make_shared<WeightTextStyleModifier>(newIsBold ? SkFontStyle::Weight::kBold_Weight : SkFontStyle::Weight::kNormal_Weight);
                    add_undo_if_selecting_area(a, [&]() {a.textBox->set_text_style_modifier_between(a.cursor->selectionBeginPos, a.cursor->selectionEndPos, currentMods[TextStyleModifier::ModifierType::WEIGHT]);});
                    commit_update_func();
                }
            });

            svg_icon_button(gui, "Italic button", "data/icons/RemixIcon/italic.svg", {
                .isSelected = newIsItalic,
                .onClick = [&] {
                    newIsItalic = !newIsItalic;
                    currentMods[TextStyleModifier::ModifierType::SLANT] = std::make_shared<SlantTextStyleModifier>(newIsItalic ? SkFontStyle::Slant::kItalic_Slant : SkFontStyle::Slant::kUpright_Slant);
                    add_undo_if_selecting_area(a, [&]() {a.textBox->set_text_style_modifier_between(a.cursor->selectionBeginPos, a.cursor->selectionEndPos, currentMods[TextStyleModifier::ModifierType::SLANT]);});
                    commit_update_func();
                }
            });

            auto decorationChange = [&] {
                currentMods[TextStyleModifier::ModifierType::DECORATION] = std::make_shared<DecorationTextStyleModifier>(get_new_decoration_value());
                add_undo_if_selecting_area(a, [&]() {a.textBox->set_text_style_modifier_between(a.cursor->selectionBeginPos, a.cursor->selectionEndPos, currentMods[TextStyleModifier::ModifierType::DECORATION]);});
                commit_update_func();
            };

            svg_icon_button(gui, "Underline button", "data/icons/RemixIcon/underline.svg", {
                .isSelected = newIsUnderlined,
                .onClick = [&, decorationChange] {
                    newIsUnderlined = !newIsUnderlined;
                    decorationChange();
                }
            });

            svg_icon_button(gui, "Strikethrough button", "data/icons/RemixIcon/strikethrough.svg", {
                .isSelected = newIsLinethrough,
                .onClick = [&, decorationChange] {
                    newIsLinethrough = !newIsLinethrough;
                    decorationChange();
                }
            });

            svg_icon_button(gui, "Overline button", "data/icons/RemixIcon/overline.svg", {
                .isSelected = newIsOverline,
                .onClick = [&, decorationChange] {
                    newIsOverline = !newIsOverline;
                    decorationChange();
                }
            });
        });

        left_to_right_line_centered_layout(gui, [&]() {
            auto paragraph_operation_button = [&](const char* id, const char* svgPath, bool isSelected, const std::function<void()>& func) {
                svg_icon_button(gui, id, svgPath, {
                    .isSelected = isSelected,
                    .onClick = [&, func] {
                        add_undo(func);
                        commit_update_func();
                    }
                });
            };

            paragraph_operation_button("Align left button", "data/icons/RemixIcon/align-left.svg", currentPStyle.textAlignment == skia::textlayout::TextAlign::kLeft, [&] {
                a.textBox->set_text_alignment_between(a.cursor->selectionBeginPos.fParagraphIndex, a.cursor->selectionEndPos.fParagraphIndex, skia::textlayout::TextAlign::kLeft);
            });
            paragraph_operation_button("Align center button", "data/icons/RemixIcon/align-center.svg", currentPStyle.textAlignment == skia::textlayout::TextAlign::kCenter, [&] {
                a.textBox->set_text_alignment_between(a.cursor->selectionBeginPos.fParagraphIndex, a.cursor->selectionEndPos.fParagraphIndex, skia::textlayout::TextAlign::kCenter);
            });
            paragraph_operation_button("Align right button", "data/icons/RemixIcon/align-right.svg", currentPStyle.textAlignment == skia::textlayout::TextAlign::kRight, [&] {
                a.textBox->set_text_alignment_between(a.cursor->selectionBeginPos.fParagraphIndex, a.cursor->selectionEndPos.fParagraphIndex, skia::textlayout::TextAlign::kRight);
            });
            paragraph_operation_button("Align justify button", "data/icons/RemixIcon/align-justify.svg", currentPStyle.textAlignment == skia::textlayout::TextAlign::kJustify, [&] {
                a.textBox->set_text_alignment_between(a.cursor->selectionBeginPos.fParagraphIndex, a.cursor->selectionEndPos.fParagraphIndex, skia::textlayout::TextAlign::kJustify);
            });
            paragraph_operation_button("Text direction left button", "data/icons/RemixIcon/text-direction-l.svg", currentPStyle.textDirection == skia::textlayout::TextDirection::kLtr, [&] {
                a.textBox->set_text_direction_between(a.cursor->selectionBeginPos.fParagraphIndex, a.cursor->selectionEndPos.fParagraphIndex, skia::textlayout::TextDirection::kLtr);
            });
            paragraph_operation_button("Text direction right button", "data/icons/RemixIcon/text-direction-r.svg", currentPStyle.textDirection == skia::textlayout::TextDirection::kRtl, [&] {
                a.textBox->set_text_direction_between(a.cursor->selectionBeginPos.fParagraphIndex, a.cursor->selectionEndPos.fParagraphIndex, skia::textlayout::TextDirection::kRtl);
            });
        });

        slider_scalar_field<uint32_t>(gui, "Font Size Slider", "Font Size", &newFontSize, 3, 100, TextBoxScalarOptions{
            .onEdit = [&] {
                currentMods[TextStyleModifier::ModifierType::SIZE] = std::make_shared<SizeTextStyleModifier>(newFontSize);
                a.textBox->set_text_style_modifier_between(a.cursor->selectionBeginPos, a.cursor->selectionEndPos, currentMods[TextStyleModifier::ModifierType::SIZE]);
                commit_update_func();
            },
            .onSelect = [&] { hold_undo_data("Font Size", a); },
            .onDeselect = [&] { release_undo_data("Font Size"); }
        });

        //// Text color
        //gui.left_to_right_line_layout([&]() {
        //    if(gui.color_button_big("Text Color", &newTextColor, &newTextColor == t.colorRight)) 
        //        t.color_selector_right(&newTextColor == t.colorRight ? nullptr : &newTextColor);
        //    gui.text_label("Text Color");
        //});

        //if(&newTextColor == t.colorRight)
        //    hold_undo_data("Text Color", a);
        //else
        //    release_undo_data("Text Color");

        //if((&newTextColor == t.colorRight) && t.isUpdatingColorRight) {
        //    currentMods[TextStyleModifier::ModifierType::COLOR] = std::make_shared<ColorTextStyleModifier>(newTextColor);
        //    a.textBox->set_text_style_modifier_between(a.cursor->selectionBeginPos, a.cursor->selectionEndPos, currentMods[TextStyleModifier::ModifierType::COLOR]);
        //}

        //// Highlight color
        //gui.left_to_right_line_layout([&]() {
        //    if(gui.color_button_big("Highlight Color", &newHighlightColor, &newHighlightColor == t.colorRight)) {
        //        if(newHighlightColor.w() == 0.0f) { // Make highlight appear when the button is pressed
        //            newHighlightColor.w() = 1.0f;
        //            currentMods[TextStyleModifier::ModifierType::HIGHLIGHT_COLOR] = std::make_shared<HighlightColorTextStyleModifier>(newHighlightColor);
        //            add_undo_if_selecting_area(a, [&]() {a.textBox->set_text_style_modifier_between(a.cursor->selectionBeginPos, a.cursor->selectionEndPos, currentMods[TextStyleModifier::ModifierType::HIGHLIGHT_COLOR]);});
        //        }
        //        t.color_selector_right(&newHighlightColor == t.colorRight ? nullptr : &newHighlightColor);
        //    }
        //    if(newHighlightColor.w() != 0.0f) {
        //        if(gui.svg_icon_button("Remove Highlight Color", "data/icons/close.svg")) {
        //            newHighlightColor = {0.0f, 0.0f, 0.0f, 0.0f};
        //            currentMods[TextStyleModifier::ModifierType::HIGHLIGHT_COLOR] = std::make_shared<HighlightColorTextStyleModifier>(newHighlightColor);
        //            add_undo_if_selecting_area(a, [&]() {a.textBox->set_text_style_modifier_between(a.cursor->selectionBeginPos, a.cursor->selectionEndPos, currentMods[TextStyleModifier::ModifierType::HIGHLIGHT_COLOR]);});
        //        }
        //    }
        //    gui.text_label("Highlight Color");
        //});

        //if(&newHighlightColor == t.colorRight)
        //    hold_undo_data("Highlight Color", a);
        //else
        //    release_undo_data("Highlight Color");

        //if((&newHighlightColor == t.colorRight) && t.isUpdatingColorRight) {
        //    currentMods[TextStyleModifier::ModifierType::HIGHLIGHT_COLOR] = std::make_shared<HighlightColorTextStyleModifier>(newHighlightColor);
        //    a.textBox->set_text_style_modifier_between(a.cursor->selectionBeginPos, a.cursor->selectionEndPos, currentMods[TextStyleModifier::ModifierType::HIGHLIGHT_COLOR]);
        //}

    });

    //if(a.textBox->inputChangedTextBox)
    //    set_styles_at_selection(a);

    //// NOTE: There should be a system that periodically sends updates even if no changes are made, since unreliable channels can drop update data
    //bool oldInputChangedTextBox = a.textBox->inputChangedTextBox;
    //a.textBox->inputChangedTextBox = false;
    //return oldInputChangedTextBox;
}

void TextBoxEditTool::input_paste_callback(const CustomEvents::PasteEventData& paste) {
    if(textboxID.has_value() && textboxID.value() == drawP.world.main.input.text.current_textbox_editing_id()) {
        auto& a = static_cast<TextBoxCanvasComponent&>(comp->obj->get_comp());
        if(userInput->input_paste_callback(paste)) {
            commit_update_and_layout_func();
            set_styles_at_selection(a);
        }
    }
}

void TextBoxEditTool::input_text_key_callback(const InputManager::KeyCallbackArgs& key) {
    if(textboxID.has_value() && textboxID.value() == drawP.world.main.input.text.current_textbox_editing_id()) {
        auto& a = static_cast<TextBoxCanvasComponent&>(comp->obj->get_comp());
        auto changes = userInput->input_key_callback(drawP.world.main.input, key);
        if(changes.textEdited || changes.cursorChanged) {
            commit_update_and_layout_func();
            set_styles_at_selection(a);
        }
    }
}

void TextBoxEditTool::input_text_callback(const InputManager::TextCallbackArgs& text) {
    if(textboxID.has_value() && textboxID.value() == drawP.world.main.input.text.current_textbox_editing_id()) {
        auto& a = static_cast<TextBoxCanvasComponent&>(comp->obj->get_comp());
        userInput->add_text_to_textbox(text.str);
        commit_update_and_layout_func();
        set_styles_at_selection(a);
    }
}

void TextBoxEditTool::input_mouse_button_on_canvas_callback(const InputManager::MouseButtonCallbackArgs& button, bool isDraggingPoint) {
    if(button.button == InputManager::MouseButton::LEFT && !isDraggingPoint) {
        auto& a = static_cast<TextBoxCanvasComponent&>(comp->obj->get_comp());

        SCollision::ColliderCollection<float> mousePointCollection;
        mousePointCollection.circle.emplace_back(button.pos, 1.0f);
        mousePointCollection.recalculate_bounds();

        InputManager& input = drawP.world.main.input;

        bool collidesWithBox = comp->obj->collides_with_cam_coords(drawP.world.drawData.cam.c, mousePointCollection);

        auto oldCursor = *a.cursor;
        a.textBox->process_mouse_left_button(*a.cursor, a.get_mouse_pos(drawP), (button.down && button.clicks && collidesWithBox) ? button.clicks : 0, button.down, input.key(InputManager::KEY_GENERIC_LSHIFT).held);
        if(oldCursor != *a.cursor) {
            set_styles_at_selection(a);
            commit_update_and_layout_func();
        }
    }
}

void TextBoxEditTool::input_mouse_motion_callback(const InputManager::MouseMotionCallbackArgs& motion, bool isDraggingPoint) {
    auto& a = static_cast<TextBoxCanvasComponent&>(comp->obj->get_comp());
    a.init_text_box(drawP);

    if(!isDraggingPoint) {
        auto& a = static_cast<TextBoxCanvasComponent&>(comp->obj->get_comp());

        SCollision::ColliderCollection<float> mousePointCollection;
        mousePointCollection.circle.emplace_back(motion.pos, 1.0f);
        mousePointCollection.recalculate_bounds();

        InputManager& input = drawP.world.main.input;

        auto oldCursor = *a.cursor;
        a.textBox->process_mouse_left_button(*a.cursor, a.get_mouse_pos(drawP), 0, drawP.controls.leftClickHeld, input.key(InputManager::KEY_GENERIC_LSHIFT).held);
        if(oldCursor != *a.cursor) {
            set_styles_at_selection(a);
            commit_update_and_layout_func();
        }
    }
}

void TextBoxEditTool::right_click_popup_gui(Vector2f popupPos) {
    using namespace GUIStuff;
    using namespace ElementHelpers;

    Toolbar& t = drawP.world.main.toolbar;
    auto& gui = drawP.world.main.g.gui;
    auto& a = static_cast<TextBoxCanvasComponent&>(comp->obj->get_comp());

    gui.element<PositionAdjustingPopupMenu>("Text popup menu", popupPos, [&, popupPos] {
        text_label_light(gui, "Text menu");
        InputManager& input = drawP.world.main.input;
        //drawP.popup_menu_action_button("Paste", "Paste", [&] {
        //    input.call_text_paste(true);
        //});
        //drawP.popup_menu_action_button("Paste without formatting", "Paste without formatting", [&] {
        //    input.call_text_paste(false);
        //});
        //if(a.cursor->selectionBeginPos != a.cursor->selectionEndPos) {
        //    drawP.popup_menu_action_button("Copy", "Copy", [&] {
        //        input.set_clipboard_plain_and_richtext_pair(a.textBox->process_copy(*a.cursor));
        //    });
        //    drawP.popup_menu_action_button("Cut", "Cut", [&] {
        //        input.text.do_textbox_operation_with_undo([&]() {
        //            input.set_clipboard_plain_and_richtext_pair(a.textBox->process_cut(*a.cursor));
        //        });
        //    });
        //}
    });
}

void TextBoxEditTool::hold_undo_data(const std::string& undoName, TextBoxCanvasComponent& a) {
    auto it = undoHeldData.find(undoName);
    if(it != undoHeldData.end()) {
        std::pair<RichText::TextBox::Cursor, RichText::TextData>& undoData = it->second;
        if(undoData.first != *a.cursor)
            undoHeldData.erase(it);
    }
    else if(a.cursor->selectionBeginPos != a.cursor->selectionEndPos)
        undoHeldData.emplace(undoName, std::pair<RichText::TextBox::Cursor, RichText::TextData>{*a.cursor, a.textBox->get_rich_text_data()});
}

void TextBoxEditTool::release_undo_data(const std::string& undoName) {
    auto it = undoHeldData.find(undoName);
    if(it != undoHeldData.end()) {
        std::pair<RichText::TextBox::Cursor, RichText::TextData>& undoData = it->second;
        userInput->add_textbox_undo(undoData.first, undoData.second);
        undoHeldData.erase(it);
    }
}

void TextBoxEditTool::add_undo_if_selecting_area(TextBoxCanvasComponent& a, const std::function<void()>& func) {
    if(a.cursor->selectionBeginPos == a.cursor->selectionEndPos)
        func();
    else
        userInput->do_textbox_operation_with_undo(func);
}

void TextBoxEditTool::add_undo(const std::function<void()>& func) {
    userInput->do_textbox_operation_with_undo(func);
}

uint8_t TextBoxEditTool::get_new_decoration_value() {
    uint8_t toRet = skia::textlayout::TextDecoration::kNoDecoration;
    if(newIsUnderlined)
        toRet |= skia::textlayout::TextDecoration::kUnderline;
    if(newIsLinethrough)
        toRet |= skia::textlayout::TextDecoration::kLineThrough;
    if(newIsOverline)
        toRet |= skia::textlayout::TextDecoration::kOverline;
    return toRet;
}

void TextBoxEditTool::set_styles_at_selection(TextBoxCanvasComponent& a) {
    auto& currentMods = *currentModsPtr;

    TextPosition start = std::min(a.cursor->selectionBeginPos, a.cursor->selectionEndPos);
    TextPosition end = std::max(a.cursor->selectionBeginPos, a.cursor->selectionEndPos);
    if(start == end)
        currentMods = a.textBox->get_mods_used_at_pos(a.textBox->move(TextBox::Movement::LEFT, start));
    else
        currentMods = a.textBox->get_mods_used_at_pos(start);

    newFontName = std::static_pointer_cast<FontFamiliesTextStyleModifier>(currentMods[TextStyleModifier::ModifierType::FONT_FAMILIES])->get_families().back().c_str();
    newFontSize = std::static_pointer_cast<SizeTextStyleModifier>(currentMods[TextStyleModifier::ModifierType::SIZE])->get_size();
    newTextColor = std::static_pointer_cast<ColorTextStyleModifier>(currentMods[TextStyleModifier::ModifierType::COLOR])->get_color();
    newHighlightColor = std::static_pointer_cast<HighlightColorTextStyleModifier>(currentMods[TextStyleModifier::ModifierType::HIGHLIGHT_COLOR])->get_color();
    newIsBold = std::static_pointer_cast<WeightTextStyleModifier>(currentMods[TextStyleModifier::ModifierType::WEIGHT])->get_weight() == SkFontStyle::Weight::kBold_Weight;
    newIsItalic = std::static_pointer_cast<SlantTextStyleModifier>(currentMods[TextStyleModifier::ModifierType::SLANT])->get_slant() == SkFontStyle::Slant::kItalic_Slant;
    newIsUnderlined = std::static_pointer_cast<DecorationTextStyleModifier>(currentMods[TextStyleModifier::ModifierType::DECORATION])->get_decoration_value() & skia::textlayout::TextDecoration::kUnderline;
    newIsLinethrough = std::static_pointer_cast<DecorationTextStyleModifier>(currentMods[TextStyleModifier::ModifierType::DECORATION])->get_decoration_value() & skia::textlayout::TextDecoration::kLineThrough;
    newIsOverline = std::static_pointer_cast<DecorationTextStyleModifier>(currentMods[TextStyleModifier::ModifierType::DECORATION])->get_decoration_value() & skia::textlayout::TextDecoration::kOverline;

    currentPStyle = a.textBox->get_paragraph_style_data_at(start.fParagraphIndex);
}

void TextBoxEditTool::commit_edit_updates(std::any& prevData) {
    auto& a = static_cast<TextBoxCanvasComponent&>(comp->obj->get_comp());
    a.d.editing = false;
    comp->obj->commit_update(drawP);
    if(textboxID.has_value())
        drawP.world.main.input.remove_text_box(textboxID.value());
}

TextBoxEditTool::TextBoxEditToolAllData TextBoxEditTool::get_all_data(const TextBoxCanvasComponent& a) {
    return {
        .textboxData = a.d,
        .richText = a.textBox->get_rich_text_data()
    };
}

void TextBoxEditTool::edit_start(EditTool& editTool, std::any& prevData) {
    auto& a = static_cast<TextBoxCanvasComponent&>(comp->obj->get_comp());
    auto& cur = a.cursor;
    auto& textbox = a.textBox;

    a.init_text_box(drawP);

    cur = std::make_shared<TextBox::Cursor>();
    Vector2f textSelectPos = a.get_mouse_pos(drawP);
    textbox->process_mouse_left_button(*cur, textSelectPos, 1, false, false);
    prevData = get_all_data(a);
    a.d.editing = true;

    set_styles_at_selection(a);

    editTool.add_point_handle({&a.d.p1, nullptr, &a.d.p2});
    editTool.add_point_handle({&a.d.p2, &a.d.p1, nullptr});

    comp->obj->commit_update(drawP);

    userInput = std::make_unique<RichTextUserInput>(textbox, cur, currentModsPtr);
    textboxID = drawP.world.main.input.set_text_box_back(std::nullopt, {
        .inputType = SDL_TextInputType::SDL_TEXTINPUT_TYPE_TEXT,
        .capitalization = SDL_Capitalization::SDL_CAPITALIZE_NONE,
        .autocorrect = true,
        .multiline = true,
        .androidInputType = InputManager::AndroidInputType::ANDROIDTEXT_TYPE_CLASS_TEXT
    });
}

bool TextBoxEditTool::edit_update() {
    return true;
}