#include <glew/glew.h>
#include <cstdio>
#include "sparrowrenderer.h"
#include "glassert.h"
#include "camera.h"
#include "module.h"
#include <chrono>

// main methods

bool SparrowRenderer::modernOpenglAvailable = false;

void SparrowRenderer::initGL(int width, int height, bool forceCrappy)
{
    glewExperimental = GL_TRUE;
    GLenum err = glewInit();
    if (GLEW_OK != err)
        fprintf(stderr, "Warning: glewInit failed!\n");
    if (!forceCrappy &&
        GLEW_ARB_vertex_program   &&
        GLEW_ARB_fragment_program &&
        GLEW_ARB_texture_float    &&
        GLEW_ARB_draw_buffers     &&
        GLEW_ARB_framebuffer_object &&
        glewIsSupported("GL_VERSION_3_3") &&
        GLEW_VERSION_3_3)
    {
        modernOpenglAvailable = true;
        printf("Modern OpenGL available.\n");
    }
    else
    {
        modernOpenglAvailable = false;
        fprintf(stderr, "Warning: modern OpenGL not supported!\nEnabling fallback crappy rendering mode\n");
    }

    std::cout << "OpenGL version " << glGetString(GL_VERSION) << std::endl;
    std::cout << "GLSL version " << glGetString(GL_SHADING_LANGUAGE_VERSION) << std::endl;
    std::cout << "gl renderer " << glGetString(GL_RENDERER) << std::endl;
    std::cout << "gl vendor " << glGetString(GL_VENDOR) << std::endl;

    glAssert(glEnable(GL_DEPTH_TEST));
    glAssert(glEnable(GL_CULL_FACE));
    glAssert(glEnable(GL_TEXTURE_2D));
    resizeGL(width, height);
}

void SparrowRenderer::destroyGL()
{
    for(ModuleNode &m : modules)
        delete m.module;
    modules.clear();
}

void SparrowRenderer::resizeGL(int width, int height)
{
    glAssert(glViewport(0, 0, width, height));
    camera->resize(width, height);
}

void SparrowRenderer::renderGL()
{
    glAssert(glClearColor(clearColor.r, clearColor.g, clearColor.b, 1));
    glAssert(glClearDepth(1.0));
    glAssert(glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT));
    for(ModuleNode &m : modules)
    {
        if(m.isEnabled)
        {
            std::chrono::high_resolution_clock::time_point t = std::chrono::high_resolution_clock::now();
            m.module->renderGL(getCamera(), scene);
            m.seconds = std::chrono::duration_cast<std::chrono::duration<double>>(std::chrono::high_resolution_clock::now() - t).count();
        }
    }
}

bool SparrowRenderer::isModernOpenGLAvailable()
{
    return modernOpenglAvailable;
}

// clock methods

double SparrowRenderer::getFPS()
{
    double totalTime = 0;
    for(ModuleNode &m : modules)
    {
        if(m.isEnabled)
            totalTime += m.seconds;
    }
    return 1./totalTime;
}

double SparrowRenderer::getModuleTime(int moduleId)
{
    return modules[moduleId].seconds;
}

// module methods

void SparrowRenderer::addModule(Module* myModule, std::string name)
{
    if(modernOpenglAvailable || !myModule->requiresModernOpenGL())
        modules.push_back(ModuleNode(myModule, name));
}

int SparrowRenderer::getNbModules()
{
    return modules.size();
}

// camera methods

void SparrowRenderer::setCamera(Camera* myCamera)
{
    camera = myCamera;
}

Camera* SparrowRenderer::getCamera()
{
    return camera;
}

// scene methods

void SparrowRenderer::setScene(Scene* myScene)
{
    scene = myScene;
}

Scene* SparrowRenderer::getScene()
{
    return scene;
}