// 2014 (C) SAGE Engine
// Stephan Vedder
#include "Terrain.hpp"
#include "../Util/Logger.hpp"
#include <vector>
#include <SFML/Graphics.hpp>
#include <glm/gtc/type_ptr.hpp>
using namespace Graphics;

Terrain::Terrain() : m_vbo(0), m_ibo(0)
{
    //glGenVertexArrays(1, &m_vao);
    //glBindVertexArray(m_vao);

    glGenBuffers(1, &m_vbo);
    glGenBuffers(1, &m_ibo);

    m_shader.LoadFromFile(Shader::VERTEX_SHADER, "./shader/terrain.vert");
    m_shader.LoadFromFile(Shader::FRAGMENT_SHADER, "./shader/terrain.frag");
    m_shader.Link();

    m_shader.AddUniform("MVP");
    m_shader.AddAttribute("pos");
    m_shader.AddAttribute("color");
}

Terrain::~Terrain()
{
    glDeleteVertexArrays(1, &m_vao);
    glDeleteBuffers(1, &m_vbo);
    glDeleteBuffers(1, &m_ibo);
}

void Terrain::Render(const glm::mat4& mvp)
{
    m_shader.Use();

    //glBindVertexArray(m_vao);
    glBindBuffer(GL_ARRAY_BUFFER, m_vbo);
    glEnableVertexAttribArray(m_shader.Attribute("pos"));
    glEnableVertexAttribArray(m_shader.Attribute("color"));

    glVertexAttribPointer(m_shader.Attribute("pos"), 3, GL_FLOAT,
        GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, pos));

    glVertexAttribPointer(m_shader.Attribute("color"), 3, GL_FLOAT,
        GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, color));

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ibo);

    glUniformMatrix4fv(m_shader.Uniform("MVP"), 1, false, glm::value_ptr(mvp));
    glDrawElements(GL_LINES,  m_indicecount,
                GL_UNSIGNED_SHORT,nullptr);

    m_shader.UnUse();
    //glBindVertexArray(0);
}

void Terrain::Create(const glm::ivec2& size)
{
    if (size.x != m_heightmap->getSize().x ||
        size.y != m_heightmap->getSize().y)
    {
        SAGELogCrash("Heightmap size doesn't fit terrain size");
    }

    //glBindVertexArray(m_vao);
    //Create vertices first
    std::vector<Vertex> vertices;

    for (auto y = 0; y < size.y; ++y)
    {
        for (auto x = 0; x < size.x; ++x)
        {
            auto offset = y*size.x + x;
            Vertex vert;
            auto height = m_heightmap->getPixel(x, y).r/ 20.0f;
            vert.pos = glm::vec3(x, height, y);
            vert.color = glm::vec3(1.0f, 1.0f, 1.0f);
            vertices.push_back(vert);
        }
    }

    m_vertexcount = vertices.size();
    glBindBuffer(GL_ARRAY_BUFFER, m_vbo);
    glBufferData(GL_ARRAY_BUFFER, m_vertexcount * sizeof(Vertex), &vertices[0], GL_STATIC_DRAW);

    std::vector<uint16_t> indices;
    for (auto y = 0; y < size.y-1; ++y)
    {
        for (auto x = 0; x < size.x-1; ++x)
        {
            //lower left triangle
            indices.push_back((y + 1)*size.x + x);
            indices.push_back(y*size.x + x);
            indices.push_back(y*size.x + x+1);
            //upper right triangle
            indices.push_back((y + 1)*size.x + x);
            indices.push_back((y + 1)*size.x + x+1);
            indices.push_back(y*size.x + x + 1);
        }
    }
    m_indicecount = indices.size();
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ibo);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, m_indicecount * sizeof(uint16_t), &indices[0], GL_STATIC_DRAW);

    //glBindVertexArray(0);
}