#include "MyView.hpp"
#include <sponza/sponza.hpp>
#include <tygra/FileHelper.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <iostream>
#include <cassert>

MyView::MyView()
{
}

MyView::~MyView() {
}

void MyView::setScene(const sponza::Context * scene)
{
    scene_ = scene;
}

void MyView::windowViewWillStart(tygra::Window * window)
{
    assert(scene_ != nullptr);

    // STEP 1
    // Compile sponza_vs.glsl
    GLint compile_status = GL_FALSE;

    GLuint vertex_shader = glCreateShader(GL_VERTEX_SHADER);
    std::string vertex_shader_string = tygra::createStringFromFile("resource:///sponza_vs.glsl");
    const char * vertex_shader_code = vertex_shader_string.c_str();
    glShaderSource(vertex_shader, 1, (const GLchar **)&vertex_shader_code, NULL);
    glCompileShader(vertex_shader);
    glGetShaderiv(vertex_shader, GL_COMPILE_STATUS, &compile_status);
    if (compile_status != GL_TRUE) {
        const int string_length = 1024;
        GLchar log[string_length] = "";
        glGetShaderInfoLog(vertex_shader, string_length, NULL, log);
        std::cerr << log << std::endl;
    }
    else
        std::cout << "COMPILED VS" << std::endl;

    // Compile sponza_fs.glsl
    GLuint fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
    std::string fragment_shader_string = tygra::createStringFromFile("resource:///sponza_fs.glsl");
    const char * fragment_shader_code = fragment_shader_string.c_str();
    glShaderSource(fragment_shader, 1,
        (const GLchar **)&fragment_shader_code, NULL);
    glCompileShader(fragment_shader);
    glGetShaderiv(fragment_shader, GL_COMPILE_STATUS, &compile_status);
    if (compile_status != GL_TRUE) {
        const int string_length = 1024;
        GLchar log[string_length] = "";
        glGetShaderInfoLog(fragment_shader, string_length, NULL, log);
        std::cerr << log << std::endl;
    }
    else
        std::cout << "COMPILED FS" << std::endl;

    // Linking
    sponza_program_ = glCreateProgram();
    glAttachShader(sponza_program_, vertex_shader);
    glBindAttribLocation(sponza_program_, kVertexPosition, "vertex_position");
    glBindAttribLocation(sponza_program_, kVertexNormal, "vertex_normal");
    glBindAttribLocation(sponza_program_, kVertexTexCoord, "tex_coord");
    glDeleteShader(vertex_shader);
    glAttachShader(sponza_program_, fragment_shader);
    glBindFragDataLocation(sponza_program_, kFragmentColour, "fragment_colour");
    glDeleteShader(fragment_shader);
    glLinkProgram(sponza_program_);

    // Check link
    GLint link_status = GL_FALSE;
    glGetProgramiv(sponza_program_, GL_LINK_STATUS, &link_status);
    if (link_status != GL_TRUE) {
        const int string_length = 1024;
        GLchar log[string_length] = "";
        glGetProgramInfoLog(sponza_program_, string_length, NULL, log);
        std::cerr << log << std::endl;
    }

    // STEP 2
    // Create GL mesh
    sponza::GeometryBuilder builder;

    for (int i = 0; i < builder.getAllMeshes().size(); i++) {
        MeshGL mesh_;

        auto meshes = builder.getAllMeshes();

        const auto& source_mesh = builder.getMeshById(meshes[i].getId());
        const auto& positions = source_mesh.getPositionArray();
        const auto& normals = source_mesh.getNormalArray();
        const auto& elements = source_mesh.getElementArray();
        const auto& tex_coords = source_mesh.getTextureCoordinateArray();

        glGenBuffers(1, &mesh_.position_vbo);
        glBindBuffer(GL_ARRAY_BUFFER, mesh_.position_vbo);
        glBufferData(GL_ARRAY_BUFFER,
            positions.size() * sizeof(glm::vec3), // size of data in bytes
            positions.data(), // pointer to the data
            GL_STATIC_DRAW);
        glBindBuffer(GL_ARRAY_BUFFER, kNullId);

        glGenBuffers(1, &mesh_.normal_vbo);
        glBindBuffer(GL_ARRAY_BUFFER, mesh_.normal_vbo);
        glBufferData(GL_ARRAY_BUFFER,
            normals.size() * sizeof(glm::vec3), // size of data in bytes
            normals.data(), // pointer to the data
            GL_STATIC_DRAW);
        glBindBuffer(GL_ARRAY_BUFFER, kNullId);

        glGenBuffers(1, &mesh_.element_vbo);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mesh_.element_vbo);
        glBufferData(GL_ELEMENT_ARRAY_BUFFER,
            elements.size() * sizeof(unsigned int),
            elements.data(),
            GL_STATIC_DRAW);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, kNullId);
        mesh_.element_count = elements.size();

        glGenBuffers(1, &mesh_.textcoords_vbo);
        glBindBuffer(GL_ARRAY_BUFFER, mesh_.textcoords_vbo);
        glBufferData(GL_ARRAY_BUFFER,
            tex_coords.size() * sizeof(glm::vec2), // size of data in bytes
            tex_coords.data(), // pointer to the data
            GL_STATIC_DRAW);
        glBindBuffer(GL_ARRAY_BUFFER, kNullId);

        glGenVertexArrays(1, &mesh_.vao);
        glBindVertexArray(mesh_.vao);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mesh_.element_vbo);
        glBindBuffer(GL_ARRAY_BUFFER, mesh_.position_vbo);
        glEnableVertexAttribArray(kVertexPosition);
        glVertexAttribPointer(kVertexPosition, 3, GL_FLOAT, GL_FALSE,
            sizeof(glm::vec3), TGL_BUFFER_OFFSET(0));
        glBindBuffer(GL_ARRAY_BUFFER, mesh_.normal_vbo);
        glEnableVertexAttribArray(kVertexNormal);
        glVertexAttribPointer(kVertexNormal, 3, GL_FLOAT, GL_FALSE,
            sizeof(glm::vec3), TGL_BUFFER_OFFSET(0));
        glBindBuffer(GL_ARRAY_BUFFER, mesh_.textcoords_vbo);
        glEnableVertexAttribArray(kVertexTexCoord);
        glVertexAttribPointer(kVertexTexCoord, 3, GL_FLOAT, GL_FALSE, sizeof(glm::vec2), TGL_BUFFER_OFFSET(0));
        glBindBuffer(GL_ARRAY_BUFFER, kNullId);
        glBindVertexArray(kNullId);

        meshMap[meshes[i].getId()] = mesh_;

        glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

        tygra::Image texture_image = tygra::createImageFromPngFile("resource:///diff0.png");
        if (texture_image.doesContainData())
        {
            glGenTextures(1, &textureTest);
            glBindTexture(GL_TEXTURE_2D, textureTest);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
            GLenum pixel_formats[] = { 0, GL_RED, GL_RG, GL_RGB, GL_RGBA };
            glTexImage2D(GL_TEXTURE_2D,
                0,
                GL_RGBA,
                texture_image.width(),
                texture_image.height(),
                0,
                pixel_formats[texture_image.componentsPerPixel()],
                texture_image.bytesPerComponent() == 1
                ? GL_UNSIGNED_BYTE : GL_UNSIGNED_SHORT,
                texture_image.pixelData());
            glGenerateMipmap(GL_TEXTURE_2D);
            glBindTexture(GL_TEXTURE_2D, kNullId);
        }
    }
}

void MyView::windowViewDidReset(tygra::Window * window,
    int width,
    int height)
{
    glViewport(0, 0, width, height);
}

void MyView::windowViewDidStop(tygra::Window * window)
{
    glDeleteProgram(sponza_program_);
}

void MyView::windowViewRender(tygra::Window * window)
{
    assert(scene_ != nullptr);

    glEnable(GL_DEPTH_TEST);
    glEnable(GL_CULL_FACE);

    glClearColor(0.f, 0.f, 0.25f, 0.f);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    GLint viewport_size[4];
    glGetIntegerv(GL_VIEWPORT, viewport_size);
    const float aspect_ratio = viewport_size[2] / (float)viewport_size[3];

    auto cam = scene_->getCamera();
    glm::vec3 up = glm::vec3(scene_->getUpDirection().x, scene_->getUpDirection().y, scene_->getUpDirection().z);
    glm::vec3 CamDirection = glm::vec3(cam.getDirection().x, cam.getDirection().y, cam.getDirection().z);
    glm::vec3 camPos = glm::vec3(cam.getPosition().x, cam.getPosition().y, cam.getPosition().z);

    glm::vec3 camAtPos = camPos + CamDirection;

    glm::mat4 projection_xform = glm::perspective(glm::radians(cam.getVerticalFieldOfViewInDegrees()), aspect_ratio, cam.getNearPlaneDistance(), cam.getFarPlaneDistance());
    glm::mat4 view_xform = glm::lookAt(camPos, camAtPos, up);
    glm::mat4 model_xform = glm::translate(glm::mat4(1.0), camPos);

    glm::mat4 combined_xform = projection_xform * view_xform;

    glUseProgram(sponza_program_);

    GLuint pv_xform_id = glGetUniformLocation(sponza_program_, "projection_view_xform");
    glUniformMatrix4fv(pv_xform_id, 1, GL_FALSE, glm::value_ptr(combined_xform));

    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, textureTest);
    glUniform1i(glGetUniformLocation(sponza_program_, "mystery_sampler"), 0);

    GLuint mystery_sampler_id = glGetUniformLocation(sponza_program_, "mystery_sampler");
    glUniform1i(mystery_sampler_id, kTextureTest);


    for (const auto& instance : scene_->getAllInstances())
    {
        glm::mat4 model_xform = (const glm::mat4x3&)instance.getTransformationMatrix();
        const MeshGL& mesh = meshMap[instance.getMeshId()];

        GLuint m_xform_id = glGetUniformLocation(sponza_program_, "model_xform");
        glUniformMatrix4fv(m_xform_id, 1, GL_FALSE, glm::value_ptr(model_xform));

        glBindVertexArray(meshMap.at(instance.getMeshId()).vao);
        glDrawElements(GL_TRIANGLES, meshMap.at(instance.getMeshId()).element_count, GL_UNSIGNED_INT, 0);
    }
}