#include "pch.h"
#include "app.h"

using namespace ui;

App App::I; // singleton

void App::create()
{
    width = 800;
    height = 500;
}

void App::clear()
{
    glClearColor(.1f, .1f, .1f, 1.f);
    glViewport(0, 0, (GLsizei)width, (GLsizei)height);
    glClear(GL_COLOR_BUFFER_BIT);
}

void App::initShaders()
{
    static const char* shader_v =
        SHADER_VERSION
        "uniform mat4 mvp;"
        "in vec4 pos;"
        "in vec2 uvs;"
        "out vec3 uv;"
        "void main(){"
        "   uv = vec3(uvs, pos.w);"
        "   gl_Position = mvp * vec4(pos.xyz, 1.0);"
        "}";
    static const char* shader_f =
        SHADER_VERSION
        "uniform sampler2D tex;"
        "in vec3 uv;"
        "out vec4 frag;"
        "void main(){"
        //"   frag = texture(tex, uv.xy/uv.z);"
        "   frag = texture(tex, uv.xy);"
        "}";
    static const char* shader_uv_f =
        SHADER_VERSION
        "uniform sampler2D tex;"
        "in vec3 uv;"
        "out vec4 frag;"
        "void main(){"
        "   frag = vec4(uv.xy, 0.0, 1.0);"
        "}";
    
    // TEXTURE ATLAS
    static const char* shader_atlas_v =
        SHADER_VERSION
        "uniform mat4 mvp;"
        "uniform vec2 tof;"
        "uniform vec2 tsz;"
        "in vec2 pos;"
        "in vec2 uvs;"
        "out vec2 uv;"
        "void main(){"
        "   uv = tof + uvs * tsz;"
        "   gl_Position = mvp * vec4(pos, 0.0, 1.0);"
        "}";
    static const char* shader_atlas_f =
        SHADER_VERSION
        "uniform sampler2D tex;"
        "in vec2 uv;"
        "out vec4 frag;"
        "void main(){"
        "   frag = texture(tex, uv);"
        "}";
    
    // SOLID COLOR
    static const char* shader_color_v =
        SHADER_VERSION
        "uniform mat4 mvp;"
        "in vec4 pos;"
        "void main(){"
        "   gl_Position = mvp * pos;"
        "}";
    static const char* shader_color_f =
        SHADER_VERSION
        "uniform vec4 col;"
        "out vec4 frag;"
        "void main(){"
        "   frag = col;"
        "}";
    
    // COLOR QUAD
    static const char* shader_color_quad_v =
        SHADER_VERSION
        "uniform mat4 mvp;"
        "in vec4 pos;"
        "in vec2 uvs;"
        "out vec3 uv;"
        "void main(){"
        "   gl_Position = mvp * pos;"
        "   uv = vec3(uvs, pos.w);"
        "}";
    static const char* shader_color_quad_f =
        SHADER_VERSION
        "uniform vec4 col;"
        "in vec3 uv;"
        "out vec4 frag;"
        "void main(){"
        "   vec4 gradient_x = mix(col, vec4(1.0, 1.0, 1.0, 1.0), uv.x);"
        "   frag = mix(gradient_x, vec4(0.0, 0.0, 0.0, 1.0), uv.y);"
        "}";
    
    // HUE
    static const char* shader_color_hue_v =
        SHADER_VERSION
        "uniform mat4 mvp;"
        "in vec4 pos;"
        "in vec2 uvs;"
        "out vec3 uv;"
        "void main(){"
        "   gl_Position = mvp * pos;"
        "   uv = vec3(uvs, pos.w);"
        "}";
    static const char* shader_color_hue_f =
        SHADER_VERSION
        "uniform vec4 col;"
        "in vec3 uv;"
        "out vec4 frag;"
        "vec3 hsv2rgb(vec3 c) {"
        "   vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);"
        "   vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);"
        "   return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);"
        "}"
        "void main(){"
        "   frag = vec4(hsv2rgb(vec3(uv.y, 1.0, 1.0)), 1.0);"
        "}";

    // FONT
    static const char* shader_font_v =
        SHADER_VERSION
        "uniform mat4 mvp;"
        "in vec2 pos;"
        "in vec2 uvs;"
        "out vec2 uv;"
        "void main(){"
        "   uv = uvs;"
        "   gl_Position = mvp * vec4(pos, 0.0, 1.0);"
        "}";
    static const char* shader_font_f =
        SHADER_VERSION
        "uniform sampler2D tex;"
        "uniform vec4 col;"
        "in vec2 uv;"
        "out vec4 frag;"
        "void main(){"
        "   float a = texture(tex, uv).r;"
        "   frag = vec4(col.rgb, a);"
        "}";

    // STROKE
    static const char* shader_stroke_v =
        SHADER_VERSION
        "uniform mat4 mvp;"
        "in vec4 pos;"
        "in vec2 uvs;"
        "out vec3 uv;"
        "void main(){"
        "   uv = vec3(uvs, pos.w);"
        "   gl_Position = mvp * vec4(pos.xyz, 1.0);"
        "}";
    static const char* shader_stroke_f =
        SHADER_VERSION
        "uniform sampler2D tex;"
        "uniform vec4 col;"
        "uniform float alpha;"
        "in vec3 uv;"
        "out vec4 frag;"
        "void main(){"
        "   float a = (1.0 - texture(tex, uv.xy).r) * alpha;"
        "   frag = vec4(col.rgb, a);"
        "}";

    LOG("initializing shaders");
    if (!ShaderManager::create(kShader::Texture, shader_v, shader_f))
        LOG("Failed to create shader Texture");
    if (!ShaderManager::create(kShader::Color, shader_color_v, shader_color_f))
        LOG("Failed to create shader Color");
    if (!ShaderManager::create(kShader::ColorQuad, shader_color_quad_v, shader_color_quad_f))
        LOG("Failed to create shader ColorQuad");
    if (!ShaderManager::create(kShader::ColorHue, shader_color_hue_v, shader_color_hue_f))
        LOG("Failed to create shader ColorHue");
    if (!ShaderManager::create(kShader::UVs, shader_v, shader_uv_f))
        LOG("Failed to create shader UVs");
    if (!ShaderManager::create(kShader::Font, shader_font_v, shader_font_f))
        LOG("Failed to create shader Font");
    if (!ShaderManager::create(kShader::Atlas, shader_atlas_v, shader_atlas_f))
        LOG("Failed to create shader Atlas");
    if (!ShaderManager::create(kShader::Stroke, shader_stroke_v, shader_stroke_f))
        LOG("Failed to create shader Stroke");
    LOG("shaders initialized");
}

void App::initAssets()
{
    LOG("initializing assets");
    FontManager::init();
    LOG("initializing assets loading fonts");
    FontManager::load(kFont::Arial_11, "data/arial.ttf", 15);
    FontManager::load(kFont::Arial_30, "data/arial.ttf", 30);

    LOG("initializing assets create sampler");
    sampler.create(GL_NEAREST);
    LOG("initializing assets load uvs texture");
    if (!tex.load("data/uvs.jpg"))
        LOG("error loading image\n");
    LOG("initializing assets completed");
}

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");

        //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();

        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();
            canvas->m_brush = stroke->m_canvas->m_brush;
            if (on_color_change)
                on_color_change(color);
        };

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

        if (auto* button = layout[main_id]->find<NodeButtonCustom>("btn-stroke"))
        {
            button->on_click = [this](Node*) {
                panels->remove_all_children();
                if (current_panel != stroke.get())
                {
                    panels->add_child(std::static_pointer_cast<Node>(stroke));
                    current_panel = stroke.get();
                }
                else
                {
                    current_panel = nullptr;
                }
            };
        }
        if (auto* button = layout[main_id]->find<NodeButtonCustom>("btn-brush"))
        {
            button->on_click = [this](Node*) {
                panels->remove_all_children();
                if (current_panel != brushes.get())
                {
                    panels->add_child(std::static_pointer_cast<Node>(brushes));
                    current_panel = brushes.get();
                }
                else
                {
                    current_panel = nullptr;
                }
            };
        }
        if (auto* button = layout[main_id]->find<NodeButtonCustom>("btn-color"))
        {
            button->on_click = [this](Node*) {
                panels->remove_all_children();
                if (current_panel != color.get())
                {
                    panels->add_child(std::static_pointer_cast<Node>(color));
                    current_panel = color.get();
                }
                else
                {
                    current_panel = nullptr;
                }
            };
        }
        if (auto* button = layout[main_id]->find<NodeButtonCustom>("btn-layer"))
        {
            button->on_click = [this](Node*) {
                panels->remove_all_children();
                if (current_panel != layers.get())
                {
                    panels->add_child(std::static_pointer_cast<Node>(layers));
                    current_panel = layers.get();
                }
                else
                {
                    current_panel = nullptr;
                }
            };
        }

        if (auto* button = layout[main_id]->find<NodeButton>("btn-close"))
        {
            button->on_click = [this](Node*) { 
                //exit(0); 
                canvas->m_canvas->clear();
            };
        }
        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;
            };
        }
        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;
            };
        }
        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;
            };
        }
        if (auto* toolbar = layout[main_id]->find<Node>("toolbar"))
        {
            toolbar->m_flood_events = true;
        }
    };
    LOG("initializing layout xml");
#ifdef _WIN32
    //layout.load("C:\\Users\\omar\\Desktop\\new_engine\\data\\layout.xml");
    layout.load("data/layout.xml");
#else
    layout.load("data/layout.xml");
#endif
    LOG("initializing layout completed");
}

void App::init()
{
#ifdef _WIN32
    static CONSOLE_SCREEN_BUFFER_INFO info;
    GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &info);
    // colors: http://stackoverflow.com/questions/4053837/colorizing-text-in-the-console-with-c
    glDebugMessageCallback([](GLenum source, GLenum type, GLuint id,
        GLenum severity, GLsizei length, const GLchar* message, const void* userParam) 
    {
        static std::map<GLenum, int> colors = {
            { GL_DEBUG_SEVERITY_NOTIFICATION, 8 },
            { GL_DEBUG_SEVERITY_LOW, 8 },
            { GL_DEBUG_SEVERITY_MEDIUM, FOREGROUND_GREEN | FOREGROUND_INTENSITY },
            { GL_DEBUG_SEVERITY_HIGH, FOREGROUND_RED | FOREGROUND_INTENSITY },
        };
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), colors[severity]);
        LOG("%.*s\n", length, message);
        FlushConsoleInputBuffer(GetStdHandle(STD_OUTPUT_HANDLE));
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), info.wAttributes);
    }, nullptr);
    glEnable(GL_DEBUG_OUTPUT); 
#endif

    glEnable(GL_TEXTURE_2D);
    glDisable(GL_DEPTH_TEST);

    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glBlendEquation(GL_FUNC_ADD);

    initShaders();
    initAssets();
    initLayout();

    //int n;
    //glGetIntegerv(GL_NUM_EXTENSIONS, &n);
    //for (int i = 0; i < n; i++)
    //{
    //    const unsigned char* s = glGetStringi(GL_EXTENSIONS, i);
    //    LOG("GL ext %03d: %s\n", i, s);
    //}
    LOG("GL version: %s\n", glGetString(GL_VERSION));
    LOG("GL vendor: %s\n", glGetString(GL_VENDOR));
    LOG("GL renderer: %s\n", glGetString(GL_RENDERER));
    
    GLfloat width_range[2];
    glGetFloatv(GL_ALIASED_LINE_WIDTH_RANGE, width_range);
    LOG("GL line range: %f - %f\n", width_range[0], width_range[1]);
    LOG("Screen Size: %f %f", width, height);
}

void App::update(float dt)
{
    glClearColor(.1f, .1f, .1f, 1.f);
    glViewport(0, 0, (GLsizei)width, (GLsizei)height);
    glClear(GL_COLOR_BUFFER_BIT);

#ifndef __ANDROID__
    layout.reload();
#endif
    if (auto* main = layout[main_id])
        main->update(width, height, zoom);

    auto observer = [this](Node* n)
    {
        if (n && n->m_display)
        {
            auto box = n->m_clip;
            glm::ivec4 c = glm::vec4((int)box.x - 1, (int)(height / zoom - box.y - box.w) - 1, (int)box.z + 2, (int)box.w + 2) * zoom;
            glScissor(c.x, c.y, c.z, c.w);
            n->draw();
        }
    };
    //glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
    glEnable(GL_SCISSOR_TEST);
    if (auto* main = layout[main_id])
        main->watch(observer);
    //msgbox->watch(observer);
    glDisable(GL_SCISSOR_TEST); 
}

void App::resize(float w, float h)
{
    width = w;
    height = h;
    if (auto* main = layout[main_id])
        main->update(w , h, zoom);
}

bool App::mouse_down(int button, float x, float y)
{
    MouseEvent e;
    e.m_type = button ? kEventType::MouseDownR : kEventType::MouseDownL;
    e.m_pos = { x / zoom, y / zoom };
    auto ret = layout[main_id]->on_event(&e);
    LOG("mouse click button%d pos %f %f\n", button, x, y);

//     if (popup)
//     {
//         layout[main_id]->remove_child(popup);
//         popup = nullptr;
//     }
//     if (button == 1)
//     {
//         popup = (NodePopupMenu*)layout[const_hash("popup-menu")]->m_children[0]->clone();
//         popup->SetPositioning(YGPositionTypeAbsolute);
//         popup->SetPosition(x / zoom, y / zoom);
//         layout[main_id]->add_child(popup);
//     }
    layout[main_id]->update();
    return ret == kEventResult::Consumed;
}
bool App::mouse_move(float x, float y)
{
    MouseEvent e;
    e.m_type = kEventType::MouseMove;
    e.m_pos = { x / zoom, y / zoom };
    kEventResult ret = kEventResult::Available;
    if (auto* main = layout[main_id])
        ret = main->on_event(&e);
    return ret == kEventResult::Consumed;
}
bool App::mouse_up(int button, float x, float y)
{
    MouseEvent e;
    e.m_type = button ? kEventType::MouseUpR : kEventType::MouseUpL;
    e.m_pos = { x / zoom, y / zoom };
    auto ret = layout[main_id]->on_event(&e);
    layout[main_id]->update();
    LOG("mouse up button%d pos %f %f\n", button, x, y);
    return ret == kEventResult::Consumed;
}
bool App::key_down(int key)
{
    KeyEvent e;
    e.m_type = kEventType::KeyDown;
    e.m_key = key;
    auto ret = layout[main_id]->on_event(&e);
    layout[main_id]->update();
    LOG("key down %d '%c'", key, key);
    return ret == kEventResult::Consumed;
}
bool App::key_up(int key)
{
    KeyEvent e;
    e.m_type = kEventType::KeyUp;
    e.m_key = key;
    auto ret = layout[main_id]->on_event(&e);
    layout[main_id]->update();
    LOG("key up %d '%c'", key, key);
    return ret == kEventResult::Consumed;
}
bool App::key_char(int key)
{
    KeyEvent e;
    e.m_type = kEventType::KeyChar;
    e.m_key = key;
    auto ret = layout[main_id]->on_event(&e);
    layout[main_id]->update();
    LOG("key up %d '%c'", key, key);
    return ret == kEventResult::Consumed;
}