#include "sparrowrenderer.h"
#include "deferredpipeline.h"
#include "texture.h"
#include "scene.h"
#include "mesh.h"
#include "shader.h"
#include <glm/ext.hpp>
#include "shadersource.h"
#include "phongmaterial.h"
#include "camera.h"
#include <resource.h>

RESOURCE_PACK(shaders)

GBuffer::GBuffer(int width, int height) : FrameBuffer()
{
    Texture* tex;
    // - Normal buffer
    tex = new Texture(GL_RGB, GL_RGB16F, width, height, GL_FLOAT, GL_TEXTURE_RECTANGLE);
    tex->setFiltering(GL_NEAREST);
    tex->setUnit(NORMAL);
    addTexture(tex, GL_COLOR_ATTACHMENT0);

    // - Color + objectId buffer
    tex = new Texture(GL_RGBA, GL_RGBA, width, height, GL_UNSIGNED_BYTE, GL_TEXTURE_RECTANGLE);
    tex->setFiltering(GL_NEAREST);
    tex->setUnit(DIFFUSE);
    addTexture(tex, GL_COLOR_ATTACHMENT1);

    // - Specular color + Specular exponent buffer
    tex = new Texture(GL_RGBA, GL_RGBA, width, height, GL_UNSIGNED_BYTE, GL_TEXTURE_RECTANGLE);
    tex->setFiltering(GL_NEAREST);
    tex->setUnit(SPECULAR);
    addTexture(tex, GL_COLOR_ATTACHMENT2);

    // - Position buffer
    tex = new Texture(GL_RGBA, GL_RGBA16F, width, height, GL_FLOAT, GL_TEXTURE_RECTANGLE);
    tex->setFiltering(GL_NEAREST);
    tex->setUnit(POSITION);
    addTexture(tex, GL_COLOR_ATTACHMENT3);

    // - depth buffer
    tex = new Texture(GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT, width, height, GL_FLOAT, GL_TEXTURE_RECTANGLE);
    tex->setFiltering(GL_NEAREST);
    tex->setUnit(DEPTH);
    addTexture(tex, GL_DEPTH_ATTACHMENT);

    initColorAttachments();
}

void GBuffer::bindTextures()
{
    for(int i=0; i<NB_BUFFERS; ++i)
        getTexture(i)->bind();
}

void GBuffer::unbindTextures()
{
    for(int i=0; i<NB_BUFFERS; ++i)
        getTexture(i)->unbind();
}

LightingBuffer::LightingBuffer(int width, int height) : FrameBuffer()
{
    // colors are encoded in float to allow tonemapping
    Texture* tex = new Texture(GL_RGBA, GL_RGBA16F, width, height, GL_FLOAT, GL_TEXTURE_RECTANGLE);
    tex->setFiltering(GL_NEAREST);
    addTexture(tex, GL_COLOR_ATTACHMENT0);

    initColorAttachments();
}

DeferredPipeline::DeferredPipeline() :
    m_camera(NULL),
    m_width(512),
    m_height(512),
    m_gBuffer(NULL),
    m_lightingBuffer(NULL),
    m_renderTarget(NULL)
{
    Resource::ResourceMap shaderMap;
    Resource::getResourcePack_shaders(shaderMap);
    m_gBufferSource = new ShaderSource();
    m_gBufferSource->setSource(shaderMap["shaders/gbuffer.vert.glsl"], ShaderSource::VERTEX);
    m_gBufferSource->setSource(shaderMap["shaders/gbuffer.frag.glsl"], ShaderSource::FRAGMENT);
    m_lightingSource = new ShaderSource();
    m_lightingSource->setSource(shaderMap["shaders/lighting.vert.glsl"], ShaderSource::VERTEX);
    m_lightingSource->setSource(shaderMap["shaders/lighting.frag.glsl"], ShaderSource::FRAGMENT);
    m_mesh2DSource = new ShaderSource();
    m_mesh2DSource->setSource(shaderMap["shaders/gui.vert.glsl"], ShaderSource::VERTEX);
    m_mesh2DSource->setSource(shaderMap["shaders/gui.frag.glsl"], ShaderSource::FRAGMENT);
    std::string vertSource = shaderMap["shaders/posteffects.vert.glsl"];
    std::string fragSource = shaderMap["shaders/posteffects.frag.glsl"];
    m_postEffectsShader = new Shader(vertSource, fragSource);
}

void DeferredPipeline::renderGL(Scene *scene)
{
    if(m_renderTarget == NULL)
        return;

    // GEOMETRY PASS
    std::vector<GeometryNode*> mesh2D;
    m_gBuffer->bindFBO();
    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LESS);
    glDisable(GL_BLEND);
    glClearColor(0.0f, 0.0f, 0.0f, 1.f);
    glClearDepth(1.0f);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    // loop on geometry
    unsigned int id = 2;
    for(SceneIterator<GeometryNode*>* geometryIt = scene->getGeometry();
        geometryIt->isValid(); geometryIt->next())
    {
        GeometryNode* node = geometryIt->getItem();
        unsigned int type = node->mesh->getFlags();
        if(type & (1 << Mesh::MESH_2D))
        {
            mesh2D.push_back(node);
            continue;
        }
        Shader *shader = m_mesh3DShaders[node->mesh->getFlags()];
        if(shader == NULL)
        {
            fprintf(stderr, "no shader to render this 3D geometry, please call refreshScene to generate the shader\n");
            continue;
        }
        shader->bind();
        
        shader->bindUnsignedInteger(shader->getLocation("object_identifier"), id);
        if(node->mesh->instances_offsets.empty())
            ++id;
        else
            id += node->mesh->instances_offsets.size();
        
        glm::mat4 modelViewMatrix = m_camera->getViewMatrix() * node->modelMatrix;
        glm::mat4 normalMatrix = glm::transpose(glm::inverse(modelViewMatrix));
        shader->bindMat4(shader->getLocation("projectionMatrix"), m_camera->getProjectionMatrix());
        shader->bindMat4(shader->getLocation("modelViewMatrix"), modelViewMatrix);
        shader->bindMat3(shader->getLocation("normalMatrix"), glm::mat3(normalMatrix));
        // draw geometry
        node->mesh->draw(shader);
    }
    
    // LIGHTING PASS
    m_lightingBuffer->bindFBO();
    glDepthFunc(GL_LEQUAL);
    glEnable(GL_BLEND);
    glBlendFunc(GL_ONE, GL_ONE);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    m_gBuffer->bindTextures();
    for(SceneIterator<Light*>* lightIt = scene->getLights();
        lightIt->isValid(); lightIt->next())
    {
        Light* light = lightIt->getItem();
        Shader *shader = m_lightShaders[light->getFlags()];
        if(shader == NULL)
        {
            fprintf(stderr, "no shader to render this light, please call refreshScene to generate the shader\n");
            continue;
        }
        shader->bind();

        // bind GBuffer
        shader->bindInteger(shader->getLocation("normalBuffer"), GBuffer::NORMAL);
        shader->bindInteger(shader->getLocation("colorBuffer"), GBuffer::DIFFUSE);
        shader->bindInteger(shader->getLocation("specularBuffer"), GBuffer::SPECULAR);
        shader->bindInteger(shader->getLocation("positionBuffer"), GBuffer::POSITION);
        shader->bindInteger(shader->getLocation("depthBuffer"), GBuffer::DEPTH);

        // bind light
        light->bindAttributes(shader, m_camera);

        // compute fragments
        SparrowRenderer::drawQuad();
    }
    m_gBuffer->unbindTextures();
    
    // POST EFFECTS PASS
    m_renderTarget->bindFBO();
    glDisable(GL_BLEND);
    m_lightingBuffer->getTexture(0)->bind(0);
    m_postEffectsShader->bind();
    m_postEffectsShader->bindInteger(m_postEffectsShader->getLocation("lightBuffer"), 0);
    SparrowRenderer::drawQuad();
    m_lightingBuffer->getTexture(0)->unbind();

    // 2D GUI PASS
    glClear(GL_DEPTH_BUFFER_BIT);
    for(GeometryNode* node : mesh2D)
    {
        Shader *shader = m_mesh2DShaders[node->mesh->getFlags()];
        if(shader == NULL)
        {
            fprintf(stderr, "no shader to render this 2D geometry, please call refreshScene to generate the shader\n");
            continue;
        }
        shader->bind();

        shader->bindMat4(shader->getLocation("orthoMatrix"), m_orthoMatrix);
        shader->bindMat4(shader->getLocation("transformMatrix"), node->modelMatrix);
        // draw geometry
        node->mesh->draw(shader);
    }
}

void DeferredPipeline::resizeGL(int w, int h)
{
    // updating dimensions
    m_width = w;
    m_height = h;
    
    // rebuilding FrameBuffers
    if(m_gBuffer != NULL)
    {
        delete m_gBuffer;
        delete m_lightingBuffer;
    }
    m_gBuffer = new GBuffer(w, h);
    m_lightingBuffer = new LightingBuffer(w, h);
    m_orthoMatrix = glm::ortho(0.f, float(m_width), float(m_height), 0.f);
}

void DeferredPipeline::setSources(ShaderSource *gBufferSource, ShaderSource *lightingSource, ShaderSource *guiSource, Shader *postEffectsShader)
{
    if(m_gBufferSource != NULL)
        delete m_gBufferSource;
    m_gBufferSource = gBufferSource;
    if(m_lightingSource != NULL)
        delete m_lightingSource;
    m_lightingSource = lightingSource;
    if(m_mesh2DSource != NULL)
        delete m_mesh2DSource;
    m_mesh2DSource = guiSource;
    if(m_postEffectsShader != NULL)
        delete m_postEffectsShader;
    m_postEffectsShader = postEffectsShader;
}

void DeferredPipeline::refreshScene(Scene *scene)
{
    for(auto it : m_mesh3DShaders)
        delete it.second;
    m_mesh3DShaders.clear();
    m_meshTypes.clear();
    scene->getMeshTypes(m_meshTypes);
    for(unsigned int type : m_meshTypes)
    {
        if(type & (1 << Mesh::MESH_2D))
            m_mesh2DShaders[type] = m_mesh2DSource->compile(type, 0);
        else
            m_mesh3DShaders[type] = m_gBufferSource->compile(type, 0);
    }
    
    for(auto it : m_lightShaders)
        delete it.second;
    m_lightShaders.clear();
    m_lightTypes.clear();
    scene->getLightTypes(m_lightTypes);
    for(unsigned int type : m_lightTypes)
        m_lightShaders[type] = m_lightingSource->compile(0, type);
}