#include "glew.h"
#include "wglew.h"

#include "sdl.h"

#include <assert.h>

#define NO_SDL_GLEXT
#include "sdl_opengl.h"

#include "glm.hpp"
#include "gtc/matrix_transform.hpp"

#define ASSERT assert

#include <fstream>
#include <sstream>
#include <string>

using std::string;
typedef unsigned int uint;

#include <malloc.h>

template <typename T, uint uiIncrement=500>
class CBuffer {
public:
    CBuffer()
        : m_uiUsed(0)
        , m_uiSize(uiIncrement)
    {
        m_pBuffer = (T*)malloc(sizeof(T) * uiIncrement);
    }

    ~CBuffer() { }
    void freeBuffer()   { free(m_pBuffer); m_uiUsed = 0; m_uiSize = 0; }
    void clear() { m_uiUsed = 0;    }
    T* alloc()
    {
        if (m_uiUsed == m_uiSize) {
            T* pNewBuffer((T*)realloc(m_pBuffer, sizeof(T) * (m_uiSize + uiIncrement)));
            m_uiSize += uiIncrement;
            m_pBuffer = pNewBuffer;
        }

        T* pAlloc(&m_pBuffer[m_uiUsed]);
        ++m_uiUsed;
        return pAlloc;
    }

    T* GetBuffer()  { return m_pBuffer; }
    uint    GetSize() const         { return m_uiUsed;  }
    uint    GetRealSize() const     { return m_uiSize;  }
private:
    T* m_pBuffer;
    uint m_uiUsed;
    uint m_uiSize;
};


#define OFFSET_OF(st, m) \
    ((size_t) ( (char *)&((st *)0)->m - (char *)0 ))

#define COMPILE_SHADER(shaderName, shaderSource) { \
    GLint iCompiled, iLength; \
    glShaderSource(shaderName, 1, (const GLchar**)&shaderSource, 0); \
    glCompileShader(shaderName); \
    glGetShaderiv(shaderName, GL_COMPILE_STATUS, &iCompiled); \
    if(iCompiled == FALSE)  { \
    glGetShaderiv(shaderName, GL_INFO_LOG_LENGTH, &iLength); \
    char* infoLog((char *)malloc(iLength)); \
    glGetShaderInfoLog(shaderName, iLength, &iLength, infoLog); \
    free(infoLog); \
    } }

#define LINK_SHADER(shaderProgram, vertexShader, fragShader) { \
    GLint iLinked, iLength; \
    glAttachShader(shaderProgram, vertexShader); \
    glAttachShader(shaderProgram, fragShader); \
    glLinkProgram(shaderProgram); \
    glGetProgramiv(shaderProgram, GL_LINK_STATUS, (int *)&iLinked); \
    if(iLinked == FALSE) { \
    glGetProgramiv(shaderProgram, GL_INFO_LOG_LENGTH, &iLength); \
    char* infoLog((char *)malloc(iLength)); \
    glGetProgramInfoLog(shaderProgram, iLength, &iLength, infoLog); \
    free(infoLog); \
    } }


char *FileToBuffer(const string& sFileName)
{
    using std::ifstream;

    ifstream fFile(sFileName, std::ios::binary);

    fFile.seekg(0, std::ios::end);
    std::streamsize zFileSize(fFile.tellg());
    fFile.seekg(0, std::ios::beg);

    char *pBuffer(new char[uint(zFileSize + 1)]);
    fFile.read(pBuffer, zFileSize);
    pBuffer[zFileSize] = 0;

    fFile.close();

    return pBuffer;
}

struct SGLVertex2D {
    GLfloat position[2];
};

int main(int argc, char *argv[])
{
    if (SDL_Init(SDL_INIT_EVERYTHING) < 0)
        return 1;

    SDL_Surface *display = SDL_SetVideoMode(800, 600, 32, 2);
    GLenum err(glewInit());
    assert (err == 0);

    glShadeModel(GL_SMOOTH);
    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
    glReadBuffer(GL_BACK);
    glDrawBuffer(GL_BACK);
    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LEQUAL);
    glDepthMask(TRUE);
    glFrontFace(GL_CCW);
    glCullFace(GL_BACK);
    glEnable(GL_CULL_FACE);
    glClearColor(1.0, 0.0, 0.0, 1.0);
    glClearDepth(1.0);

    CBuffer<SGLVertex2D> m_VertexBuffer;
    CBuffer<GLushort> m_IndexBuffer;
    GLuint m_uiVertexArrayObject, m_uiVertexBufferObject, m_uiIndexBufferObject, m_uiShaderProgram, m_uiFragShader, m_uiVertexShader;

    char *pVertexShader(FileToBuffer("2drender.vert"));
    char *pFragmentShader(FileToBuffer("2drender.frag"));

    ASSERT(GLEW_VERSION_3_3);

    m_uiVertexShader = glCreateShader(GL_VERTEX_SHADER);
    COMPILE_SHADER(m_uiVertexShader, pVertexShader);

    m_uiFragShader = glCreateShader(GL_FRAGMENT_SHADER);
    COMPILE_SHADER(m_uiFragShader, pFragmentShader);

    m_uiShaderProgram = glCreateProgram();
    LINK_SHADER(m_uiShaderProgram, m_uiVertexShader, m_uiFragShader);

    glGenVertexArrays(1, &m_uiVertexArrayObject);
    glBindVertexArray(m_uiVertexArrayObject);

    glGenBuffers(1, &m_uiVertexBufferObject);
    glGenBuffers(1, &m_uiIndexBufferObject);

    glBindBuffer(GL_ARRAY_BUFFER, m_uiVertexBufferObject);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_uiIndexBufferObject);

    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(SGLVertex2D), (void*)OFFSET_OF(SGLVertex2D, position));
    err = glGetError();
    ASSERT(err == 0);

    float fX1(10), fY1(10), fX2(300), fY2(300);

    GLuint uiVertex0(m_VertexBuffer.GetSize());

    SGLVertex2D* pVertex(m_VertexBuffer.alloc());
    pVertex->position[0] = fX1;
    pVertex->position[1] = fY1;

    pVertex = m_VertexBuffer.alloc();
    pVertex->position[0] = fX2;
    pVertex->position[1] = fY1;

    pVertex = m_VertexBuffer.alloc();
    pVertex->position[0] = fX1;
    pVertex->position[1] = fY2;

    pVertex = m_VertexBuffer.alloc();
    pVertex->position[0] = fX2;
    pVertex->position[1] = fY2;

    GLushort* pIndex;
#define ASSIGN_INDEX(index) \
    { pIndex = m_IndexBuffer.alloc(); *pIndex = uiVertex0 + index; }

    ASSIGN_INDEX(0);
    ASSIGN_INDEX(2);
    ASSIGN_INDEX(1);
    ASSIGN_INDEX(1);
    ASSIGN_INDEX(2);
    ASSIGN_INDEX(3);

    glBindVertexArray(m_uiVertexArrayObject);
    glBindBuffer(GL_ARRAY_BUFFER, m_uiVertexBufferObject);
    glBufferData(GL_ARRAY_BUFFER, m_VertexBuffer.GetSize() * sizeof(SGLVertex2D), m_VertexBuffer.GetBuffer(), GL_STATIC_DRAW);  // By passing it NULL for data, we're saying "Trash the old shit, we're giving you new shit"
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_uiIndexBufferObject);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, m_IndexBuffer.GetSize() * sizeof(GLushort), m_IndexBuffer.GetBuffer(), GL_STATIC_DRAW);

    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(SGLVertex2D), (void*)OFFSET_OF(SGLVertex2D, position));

    err = glGetError();
    assert (err == 0);
    while (true) {
        // Bind the vertex buffer object, and fill it with vertex data
        SGLVertex2D* pVertexBuffer(NULL);
        GLuint* pIndexBuffer(NULL);

        glm::mat4 orthoMatrix(glm::ortho<float>(0.0f, float(800), float(600), 0.0f, -1.0f, 1.0f));
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        glBindVertexArray(m_uiVertexArrayObject);
        glBindBuffer(GL_ARRAY_BUFFER, m_uiVertexBufferObject);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_uiIndexBufferObject);

        // bind the shader program
        glUseProgram(m_uiShaderProgram);
        glBindAttribLocation(m_uiShaderProgram, 0, "position");
        uint projLoc(glGetUniformLocation(m_uiShaderProgram, "proj"));
        glUniformMatrix4fv(projLoc, 1, FALSE, (GLfloat*)&orthoMatrix[0][0]);

        // Finally, we draw
        //glDrawRangeElements(GL_TRIANGLE_STRIP, 0, m_VertexBuffer.GetSize(), m_IndexBuffer.GetSize(), GL_UNSIGNED_SHORT, NULL);
        glDrawElements(GL_TRIANGLES, m_IndexBuffer.GetSize(), GL_UNSIGNED_SHORT, NULL);
        err = glGetError();
        ASSERT(err == 0);

        glUseProgram(0);

        glBindBuffer(GL_ARRAY_BUFFER, 0);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
        glBindVertexArray(0);

        glDisableVertexAttribArray(0);

        SDL_GL_SwapBuffers();
    }

    return 0;
}