#include "pch.h"
#include "app.h"
#include "node_icon.h"
#include "node_dialog_open.h"

using namespace ui;

void App::initLayout()
{
    LOG("initializing layout statics");
    NodeBorder::static_init();
    NodeImage::static_init();
    NodeIcon::static_init();
    NodeStrokePreview::static_init();

    layout.on_loaded = [&] {
        LOG("initializing layout updating after load");
        layout[main_id]->update(width, height, zoom);

        LOG("initializing layout components");
        sidebar = layout[main_id]->find<NodeBorder>("sidebar");
        panels = layout[main_id]->find<Node>("panels");
        canvas = layout[main_id]->find<NodeCanvas>("paint-canvas");
        canvas->data_path = data_path;

        //brushes = layout[main_id]->find<NodePanelBrush>("panel-brush");
        //layers = layout[main_id]->find<NodePanelLayer>("panel-layer");
        //color = layout[main_id]->find<NodePanelColor>("panel-color");
        //stroke = layout[main_id]->find<NodePanelStroke>("panel-stroke");

        brushes = std::make_shared<NodePanelBrush>();
        brushes->m_manager = &layout;
        brushes->init();
        brushes->create();
        brushes->loaded();

        layers = std::make_shared<NodePanelLayer>();
        layers->m_manager = &layout;
        layers->init();
        layers->create();
        layers->loaded();

        color = std::make_shared<NodePanelColor>();
        color->m_manager = &layout;
        color->init();
        color->create();
        color->loaded();

        stroke = std::make_shared<NodePanelStroke>();
        stroke->m_manager = &layout;
        stroke->init();
        stroke->create();
        stroke->loaded();

        if (canvas)
        {
            stroke->m_canvas->m_brush.m_tip_color = color->m_color;
            stroke->m_canvas->draw_stroke();
            canvas->m_brush = stroke->m_canvas->m_brush;
        }

        brushes->on_brush_changed = [this](Node* target, int index) {
            auto tid = brushes->get_texture_id(index);
            stroke->m_canvas->m_brush.m_tex_id = tid;
            stroke->m_canvas->draw_stroke();
            canvas->m_brush = stroke->m_canvas->m_brush;
            if (on_brush_select)
                on_brush_select(index);
        };

        color->on_color_changed = [this](Node* target, glm::vec4 color) {
            stroke->m_canvas->m_brush.m_tip_color = color;
//             stroke->m_canvas->draw_stroke();
            if (canvas)
                canvas->m_brush = stroke->m_canvas->m_brush;
            if (on_color_change)
                on_color_change(color);
        };

        stroke->on_stroke_change = [this](Node*target) {
            if (canvas)
                canvas->m_brush = stroke->m_canvas->m_brush;
            if (on_stroke_change)
                on_stroke_change();
        };

        layers->on_layer_add = [this](Node*) {
            canvas->m_canvas->layer_add(layers->m_layers.back()->m_label_text.c_str());
        };

        layers->on_layer_change = [this](Node*, int old_idx, int new_idx) {
            canvas->m_canvas->m_current_layer_idx = canvas->m_canvas->m_order[new_idx];
        };
        
        layers->on_layer_order = [this](Node*, int old_idx, int new_idx) {
            canvas->m_canvas->layer_order(old_idx, new_idx);
        };

        layers->on_layer_opacity_changed = [this](Node*, int idx, float value) {
            canvas->m_canvas->m_layers[canvas->m_canvas->m_order[idx]].m_opacity = value;
        };

        layers->on_layer_visibility_changed = [this](Node*, int idx, bool visible) {
            canvas->m_canvas->m_layers[canvas->m_canvas->m_order[idx]].m_alpha_locked = visible;
        };

        canvas->m_canvas->layer_add("Default");
        layers->add_layer("Default");

        static glm::vec4 color_button_normal{.1, .1, .1, 1};
        static glm::vec4 color_button_hlight{ 1, .0, .0, 1};
        if (auto* button = layout[main_id]->find<NodeButton>("btn-pen"))
        {
            button->on_click = [this](Node*) {
                layout[main_id]->find<NodeButton>("btn-pen")->set_color(color_button_hlight);
                layout[main_id]->find<NodeButton>("btn-erase")->set_color(color_button_normal);
                layout[main_id]->find<NodeButton>("btn-line")->set_color(color_button_normal);
                layout[main_id]->find<NodeButton>("btn-cam")->set_color(color_button_normal);
                layout[main_id]->find<NodeButton>("btn-grid")->set_color(color_button_normal);
                layout[main_id]->find<NodeButton>("btn-fill")->set_color(color_button_normal);
                Canvas::set_mode(Canvas::kCanvasMode::Draw);
            };
            layout[main_id]->find<NodeButton>("btn-pen")->set_color(color_button_hlight);
            Canvas::set_mode(Canvas::kCanvasMode::Draw);
        }
        if (auto* button = layout[main_id]->find<NodeButton>("btn-erase"))
        {
            button->on_click = [this](Node*) {
                layout[main_id]->find<NodeButton>("btn-pen")->set_color(color_button_normal);
                layout[main_id]->find<NodeButton>("btn-erase")->set_color(color_button_hlight);
                layout[main_id]->find<NodeButton>("btn-line")->set_color(color_button_normal);
                layout[main_id]->find<NodeButton>("btn-cam")->set_color(color_button_normal);
                layout[main_id]->find<NodeButton>("btn-grid")->set_color(color_button_normal);
                layout[main_id]->find<NodeButton>("btn-fill")->set_color(color_button_normal);
                Canvas::set_mode(Canvas::kCanvasMode::Erase);
            };
        }
        if (auto* button = layout[main_id]->find<NodeButton>("btn-line"))
        {
            button->on_click = [this](Node*) {
                layout[main_id]->find<NodeButton>("btn-pen")->set_color(color_button_normal);
                layout[main_id]->find<NodeButton>("btn-erase")->set_color(color_button_normal);
                layout[main_id]->find<NodeButton>("btn-line")->set_color(color_button_hlight);
                layout[main_id]->find<NodeButton>("btn-cam")->set_color(color_button_normal);
                layout[main_id]->find<NodeButton>("btn-grid")->set_color(color_button_normal);
                layout[main_id]->find<NodeButton>("btn-fill")->set_color(color_button_normal);
                Canvas::set_mode(Canvas::kCanvasMode::Line);
            };
        }
        if (auto* button = layout[main_id]->find<NodeButton>("btn-cam"))
        {
            button->on_click = [this](Node*) {
                layout[main_id]->find<NodeButton>("btn-pen")->set_color(color_button_normal);
                layout[main_id]->find<NodeButton>("btn-erase")->set_color(color_button_normal);
                layout[main_id]->find<NodeButton>("btn-line")->set_color(color_button_normal);
                layout[main_id]->find<NodeButton>("btn-cam")->set_color(color_button_hlight);
                layout[main_id]->find<NodeButton>("btn-grid")->set_color(color_button_normal);
                layout[main_id]->find<NodeButton>("btn-fill")->set_color(color_button_normal);
                Canvas::set_mode(Canvas::kCanvasMode::Camera);
            };
        }
        if (auto* button = layout[main_id]->find<NodeButton>("btn-grid"))
        {
            button->on_click = [this](Node*) {
                layout[main_id]->find<NodeButton>("btn-pen")->set_color(color_button_normal);
                layout[main_id]->find<NodeButton>("btn-erase")->set_color(color_button_normal);
                layout[main_id]->find<NodeButton>("btn-line")->set_color(color_button_normal);
                layout[main_id]->find<NodeButton>("btn-cam")->set_color(color_button_normal);
                layout[main_id]->find<NodeButton>("btn-grid")->set_color(color_button_hlight);
                layout[main_id]->find<NodeButton>("btn-fill")->set_color(color_button_normal);
                Canvas::set_mode(Canvas::kCanvasMode::Grid);
            };
        }
        if (auto* button = layout[main_id]->find<NodeButton>("btn-fill"))
        {
            button->on_click = [this](Node*) {
                layout[main_id]->find<NodeButton>("btn-pen")->set_color(color_button_normal);
                layout[main_id]->find<NodeButton>("btn-erase")->set_color(color_button_normal);
                layout[main_id]->find<NodeButton>("btn-line")->set_color(color_button_normal);
                layout[main_id]->find<NodeButton>("btn-cam")->set_color(color_button_normal);
                layout[main_id]->find<NodeButton>("btn-grid")->set_color(color_button_normal);
                layout[main_id]->find<NodeButton>("btn-fill")->set_color(color_button_hlight);
                Canvas::set_mode(Canvas::kCanvasMode::Fill);
            };
        }
        if (auto* button = layout[main_id]->find<NodeButtonCustom>("btn-bucket"))
        {
            button->on_click = [this](Node*) {
                canvas->m_canvas->clear(canvas->m_brush.m_tip_color);
            };
        }
        if (auto* button = layout[main_id]->find<NodeButtonCustom>("btn-stroke"))
        {
            button->on_click = [this, button](Node*) {
                panels->get_child_index(stroke.get()) == -1 ? panels->add_child(stroke) : panels->remove_child(stroke.get());
                button->set_color(panels->get_child_index(stroke.get()) == -1 ? color_button_normal : color_button_hlight);
            };
        }
        if (auto* button = layout[main_id]->find<NodeButtonCustom>("btn-brush"))
        {
            button->on_click = [this, button](Node*) {
                panels->get_child_index(brushes.get()) == -1 ? panels->add_child(brushes) : panels->remove_child(brushes.get());
                button->set_color(panels->get_child_index(brushes.get()) == -1 ? color_button_normal : color_button_hlight);
            };
        }
        if (auto* button = layout[main_id]->find<NodeButtonCustom>("btn-color"))
        {
            button->on_click = [this, button](Node*) {
                panels->get_child_index(color.get()) == -1 ? panels->add_child(color) : panels->remove_child(color.get());
                button->set_color(panels->get_child_index(color.get()) == -1 ? color_button_normal : color_button_hlight);
            };
        }
        if (auto* button = layout[main_id]->find<NodeButtonCustom>("btn-layer"))
        {
            button->on_click = [this, button](Node*) {
                panels->get_child_index(layers.get()) == -1 ? panels->add_child(layers) : panels->remove_child(layers.get());
                button->set_color(panels->get_child_index(layers.get()) == -1 ? color_button_normal : color_button_hlight);
            };
        }

        if (auto* button = layout[main_id]->find<NodeButton>("btn-export"))
        {
            button->on_click = [this,button](Node*) {
                if (canvas)
                {
                    canvas->m_canvas->export_equirectangular(data_path);
                }
            };
        }
        if (auto* button = layout[main_id]->find<NodeButton>("btn-anim"))
        {
            button->on_click = [this,button](Node*) {
                if (canvas)
                {
                    canvas->m_canvas->export_anim(data_path);
                }
            };
        }
        if (auto* button = layout[main_id]->find<NodeButton>("btn-open"))
        {
            button->on_click = [this,button](Node*) {
                if (canvas)
                {
                    // load thumbnail test
                    auto open_dialog = std::make_shared<NodeDialogOpen>();
                    open_dialog->m_manager = &layout;
                    open_dialog->data_path = data_path;
                    open_dialog->init();
                    open_dialog->create();
                    open_dialog->loaded();

                    layout[main_id]->add_child(open_dialog);
                    layout[main_id]->update();
                    
                    open_dialog->btn_ok->on_click = [this,open_dialog](Node*)
                    {
                        layers->clear();
                        canvas->m_canvas->project_open(data_path);
                        for (auto& i : canvas->m_canvas->m_order)
                            layers->add_layer(canvas->m_canvas->m_layers[i].m_name.c_str());
                        open_dialog->destroy();
                    };
                }
            };
        }
        if (auto* button = layout[main_id]->find<NodeButton>("btn-save"))
        {
            button->on_click = [this,button](Node*) {
                if (canvas)
                {
                    canvas->m_canvas->project_save(data_path);
                }
            };
        }
        if (auto* button = layout[main_id]->find<NodeButton>("btn-undo"))
        {
            button->on_click = [this,button](Node*) {
                if (!ActionManager::empty())
                    ActionManager::undo();
            };
        }
        if (auto* button = layout[main_id]->find<NodeButtonCustom>("btn-clean-memory"))
        {
            button->on_click = [this](Node*) {
                ActionManager::clear();
            };
        }
        if (auto* button = layout[main_id]->find<NodeButton>("btn-clear"))
        {
            button->on_click = [this](Node*) { 
                //exit(0); 
                if (canvas)
                    canvas->m_canvas->clear({ 0, 0, 0, 0 });
            };
        }
        if (auto* button = layout[main_id]->find<NodeButton>("btn-popup"))
        {
            button->on_click = [this](Node*) {
                msgbox = new NodeMessageBox();
                msgbox->m_manager = &layout;
                msgbox->init();
                layout[main_id]->add_child(msgbox);
                layout[main_id]->update();
            };
        }
        if (auto* button = layout[main_id]->find<NodeButtonCustom>("btn-settings"))
        {
            button->on_click = [this](Node*) {
                settings = new NodeSettings();
                settings->m_manager = &layout;
                settings->init();
                layout[main_id]->add_child(settings);
                layout[main_id]->update();
            };
        }
        if (auto* menu_file = layout[main_id]->find<NodeButtonCustom>("menu-file"))
        {
            menu_file->on_click = [=](Node*) {
                glm::vec2 pos = menu_file->m_pos + glm::vec2(0, menu_file->m_size.y);
                popup = (NodePopupMenu*)layout[const_hash("file-menu")]->m_children[0]->clone();
                popup->SetPositioning(YGPositionTypeAbsolute);
                popup->SetPosition(pos.x, pos.y);
                layout[main_id]->add_child(popup);
                layout[main_id]->update();
                popup->mouse_capture();
                popup->m_mouse_ignore = false;
                popup->m_flood_events = true;
                popup->m_capture_children = false;
            };
        }
        if (auto* menu_file = layout[main_id]->find<NodeButtonCustom>("menu-edit"))
        {
            menu_file->on_click = [=](Node*) {
                glm::vec2 pos = menu_file->m_pos + glm::vec2(0, menu_file->m_size.y);
                popup = (NodePopupMenu*)layout[const_hash("edit-menu")]->m_children[0]->clone();
                popup->SetPositioning(YGPositionTypeAbsolute);
                popup->SetPosition(pos.x, pos.y);
                layout[main_id]->add_child(popup);
                layout[main_id]->update();
                popup->mouse_capture();
                popup->m_mouse_ignore = false;
                popup->m_flood_events = true;
                popup->m_capture_children = false;
            };
        }
        if (auto* menu_file = layout[main_id]->find<NodeButtonCustom>("menu-layers"))
        {
            menu_file->on_click = [=](Node*) {
                glm::vec2 pos = menu_file->m_pos + glm::vec2(0, menu_file->m_size.y);
                popup = (NodePopupMenu*)layout[const_hash("layers-menu")]->m_children[0]->clone();
                popup->SetPositioning(YGPositionTypeAbsolute);
                popup->SetPosition(pos.x, pos.y);
                layout[main_id]->add_child(popup);
                layout[main_id]->update();
                popup->mouse_capture();
                popup->m_mouse_ignore = false;
                popup->m_flood_events = true;
                popup->m_capture_children = false;
                popup->find<NodeButtonCustom>("clear-grids")->on_click = [this](Node*) {
                    CanvasModeGrid* mode = (CanvasModeGrid*)ui::Canvas::modes[(int)ui::Canvas::kCanvasMode::Grid][0];
                    mode->clear();
                    popup->mouse_release();
                    popup->destroy();
                };
            };
        }
        if (auto* toolbar = layout[main_id]->find<Node>("toolbar"))
        {
            toolbar->m_flood_events = true;
        }
        if (auto* slider = layout[main_id]->find<NodeSliderH>("frames-slider"))
        {
            slider->on_value_changed = [this](Node*, float value)
            {
                auto& c = *ui::Canvas::I;

                for (int i = 0; i < c.m_layers.size(); i++)
                {
                    auto l = layers->get_layer_at(i);
                    layers->handle_layer_opacity(l, .0f);
                }

                int current_layer = (int)floor(value * c.m_layers.size());
                auto l = layers->get_layer_at(current_layer);
                layers->handle_layer_selected(l);
                layers->handle_layer_opacity(l, 1.f);
                if (current_layer > 0)
                {
                    auto l = layers->get_layer_at(current_layer - 1);
                    layers->handle_layer_opacity(l, .25f);
                }
            };
        }
    };
    LOG("initializing layout xml");
    if (layout.m_loaded)
    {
        LOG("restore layout");
        layout.restore_context();
        if (panels->get_child_index(brushes.get()) == -1) brushes->restore_context();
        if (panels->get_child_index(layers.get()) == -1) layers->restore_context();
        if (panels->get_child_index(color.get()) == -1) color->restore_context();
        if (panels->get_child_index(stroke.get()) == -1) stroke->restore_context();
    }
    else
        layout.load("data/layout.xml");
    LOG("initializing layout completed");
}