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

App App::I; // singleton

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

void App::init()
{
    static const char* shader_v =
        "#version 150\n"
        "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.f);"
        "}";
    static const char* shader_f =
        "#version 150\n"
        "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 =
        "#version 150\n"
        "uniform sampler2D tex;"
        "in vec3 uv;"
        "out vec4 frag;"
        "void main(){"
        "   frag = vec4(uv.xy,0,1);"
        "}";
    static const char* shader_color_v =
        "#version 150\n"
        "uniform mat4 mvp;"
        "in vec4 pos;"
        "void main(){"
        "   gl_Position = mvp * pos;"
        "}";
    static const char* shader_color_f =
        "#version 150\n"
        "uniform vec4 col;"
        "out vec4 frag;"
        "void main(){"
        "   frag = col;"
        "}";

    auto y_root = YGNodeNew();
    tinyxml2::XMLDocument xml;
    auto ret = xml.LoadFile("data\\layout.xml");
    auto root = xml.RootElement();
    auto child = root->FirstChildElement();
    while (child)
    {
        printf("Element %s: ", child->Name());
        auto attr = child->FirstAttribute();
        auto y_node = YGNodeNew();
        YGNodeInsertChild(y_root, y_node, 0);
        while (attr)
        {
            printf("%s=%s ", attr->Name(), attr->Value());
            if (strcmp("width", attr->Name()) == 0)
            {
                if (strchr(attr->Value(), '%'))
                    YGNodeStyleSetWidthPercent(y_node, attr->FloatValue());
                else
                    YGNodeStyleSetWidth(y_node, attr->FloatValue());
            }
            attr = attr->Next();
        }
        printf("\n");
        child = child->NextSiblingElement();
    }

    shader.create(shader_v, shader_f);
    shader_color.create(shader_color_v, shader_color_f);
    shader_uv.create(shader_v, shader_uv_f);
    plane.create<5>(50, 50);
    circle.create<10>(25);
    circle2.create<10>(25, Circle::kUVMapping::Tube);
    circle3.create<10>(25, 12, Circle::kUVMapping::Tube);
    circle4.create<10>(25, 12, Circle::kUVMapping::Planar);
    rounded.create<3>(50, 50, 10);
    slice.create(50, 50, 10, .3f);
    if (!tex.load("data/uvs.jpg"))
        printf("error loading image\n");
    
    glViewport(0, 0, width, height);
    glEnable(GL_TEXTURE);
    glDisable(GL_DEPTH_TEST);
    glPointSize(5);
    glLineWidth(1);
    
    //int n;
    //glGetIntegerv(GL_NUM_EXTENSIONS, &n);
    //for (int i = 0; i < n; i++)
    //{
    //    const unsigned char* s = glGetStringi(GL_EXTENSIONS, i);
    //    printf("GL ext %03d: %s\n", i, s);
    //}
    printf("GL version: %s\n", glGetString(GL_VERSION));
    printf("GL vendor: %s\n", glGetString(GL_VENDOR));
    printf("GL renderer: %s\n", glGetString(GL_RENDERER));
    
    GLfloat width_range[2];
    glGetFloatv(GL_LINE_WIDTH_RANGE, width_range);
    printf("GL line range: %f - %f\n", width_range[0], width_range[1]);
}

void App::update(float dt)
{
//    static float theta = 0;
//    theta += M_PI * 0.5f * dt;
//    float red = fabsf(sinf(theta));
    
//    glm::mat4 proj = glm::perspective(glm::radians(85.f), 1.f, .1f, 100.f);
//    glm::mat4 model = glm::translate(glm::vec3(0, 0, 0));
//    glm::mat4 view = glm::lookAt(glm::vec3(sinf(theta), 0, 1), glm::vec3(0, 0, 0), glm::vec3(0, 1, 0));

    glm::mat4 proj = glm::ortho(0.f, (float)width, (float)height, 0.f, -1.f, 1.f);
    
    Shape* shapes[] = { &circle, &circle2, &circle3, &circle4, &plane, &rounded, &slice };

    //glClearColor(red, 0, 0, 1);
    glClear(GL_COLOR_BUFFER_BIT);
    
    auto s = glm::scale(glm::vec3(1.5));
    int h = 100;
    for (int i = 0; i < sizeof(shapes)/sizeof(Shape*); i++)
    {
        shader.use();
        
        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
        glActiveTexture(GL_TEXTURE0);
        tex.bind();
        shader.u_int("tex", 0);
        shader.u_mat4("mvp", proj * glm::translate(glm::vec3{75 + h * 1, 75 + h * i, 0.f}) * s);
        shapes[i]->draw_fill();
        tex.unbind();
        
        shader_color.use();
        shader_color.u_mat4("mvp", proj * glm::translate(glm::vec3{75 + h * 2, 75 + h * i, 0.f}) * s);
        shader_color.u_vec4("col", {1, 1, 1, 1});
        shapes[i]->draw_stroke();

        shader_color.u_mat4("mvp", proj * glm::translate(glm::vec3{75 + h * 0, 75 + h * i, 0.f}) * s);
        glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
        shapes[i]->draw_fill();

        shader_uv.use();
        shader_uv.u_mat4("mvp", proj * glm::translate(glm::vec3{75 + h * 3, 75 + h * i, 0.f}) * s);
        shader_uv.u_int("tex", 0);
        glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
        shapes[i]->draw_fill();
        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
        shader_uv.u_mat4("mvp", proj * glm::translate(glm::vec3{75 + h * 4, 75 + h * i, 0.f}) * s);
        shapes[i]->draw_fill();
        tex.unbind();
    }
    //glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
    //shader_color.use();
    //shader_color.u_mat4("mvp", proj * glm::translate(glm::vec3{width/2, height/2, 0.f}) * glm::scale(glm::vec3(8)));
    //shader_color.u_vec4("col", {1, 1, 1, 1});
    
    //glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
    //tex.bind();
    //shader.use(); 
    //shader.u_mat4("mvp", proj * glm::translate(glm::vec3{ width / 2, height / 2, 0.f }) * glm::scale(glm::vec3(8)));
    //shader.u_int("tex", 0);
    //circle3.draw_fill();

    //glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
    //shader_color.use();
    //shader_color.u_mat4("mvp", proj * glm::translate(glm::vec3{width/2, height/2, 0.f}) * glm::scale(glm::vec3(8)));
    //shader_color.u_vec4("col", {1, 1, 1, 1});
    //glLineWidth(2);
    //circle3.draw_fill();
}