#include "sparrowrenderer.h"
#include <cstdio>

#include "camera.h"
#include "framebuffer.h"
#include "module.h"
#include <chrono>
#include <string.h>
#include <iostream>
#include "pipeline.h"
#include "scene.h"
#include "Version.h"

GLuint SparrowRenderer::m_quadVAO = 0;
GLuint SparrowRenderer::m_quadVBO = 0;

const GLfloat QUAD_VERTICES[] = {
    -1.0f, -1.0f,
     3.0f, -1.0f,
    -1.0f,  3.0f
};

// main methods

void SparrowRenderer::initGL(int w, int h)
{
    int err = gl3wInit();
    if (err != 0)
        fprintf(stderr, "Warning: glewInit failed!\n");

    bool modernOpenglAvailable = gl3wIsSupported(3, 3);

#ifdef RENDER_DEBUG
    printf("Using SparrowRenderer %d.%d\n\n", SparrowRenderer_VERSION_MAJOR, SparrowRenderer_VERSION_MINOR);
    if(modernOpenglAvailable)
        printf("Modern OpenGL available.\n");
    printf("OpenGL %s\nGLSL %s\nRenderer %s\nVendor %s\n",
           glGetString(GL_VERSION),
           glGetString(GL_SHADING_LANGUAGE_VERSION),
           glGetString(GL_RENDERER),
           glGetString(GL_VENDOR));
#endif

    if(!modernOpenglAvailable)
    {
        fprintf(stderr, "Warning: modern OpenGL not supported! (Opengl 3.3 Core)\nPlease update your drivers or get a real GPU.\n");
        exit(EXIT_FAILURE);
    }
    
    // allocate quad
    if(m_quadVAO == 0)
    {
        glGenVertexArrays(1, &m_quadVAO);
        glBindVertexArray(m_quadVAO);
        glGenBuffers(1, &m_quadVBO);
        glBindBuffer(GL_ARRAY_BUFFER, m_quadVBO);
        glBufferData(GL_ARRAY_BUFFER, 3 * 2 * sizeof(GLfloat), QUAD_VERTICES, GL_STATIC_DRAW);
        glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat)*2, NULL);
        glEnableVertexAttribArray(0);
        glBindVertexArray(0);
    }
    
    // set screen size
    resizeGL(w, h);
}

SparrowRenderer::~SparrowRenderer()
{
    if(m_quadVAO != 0)
    {
        glDeleteVertexArrays(1, &m_quadVAO);
        glDeleteBuffers(1, &m_quadVBO);
    }
}

void SparrowRenderer::resizeGL(int w, int h)
{
    width = w;
    height = h;
    if(m_scene != NULL)
    {
        if(m_scene->getPipeline() != NULL)
            m_scene->getPipeline()->resizeGL(w, h);
    }
}

void SparrowRenderer::renderGL()
{
    if(m_scene != NULL && m_scene->getPipeline() != NULL)
    {
        m_scene->getPipeline()->renderGL(m_scene);
    }
    glFinish();
}

// utils
void SparrowRenderer::drawQuad()
{
    glBindVertexArray(m_quadVAO);
    glDrawArrays(GL_TRIANGLES, 0, 3);
    glBindVertexArray(0);
}

// scene methods

void SparrowRenderer::setScene(Scene* myScene)
{
    m_scene = myScene;
    if(m_scene == NULL || m_scene->getPipeline() == NULL)
        fprintf(stderr, "WARNING : incomplete scene class, rendering may not work properly.\n");
}