import std.random;
import std.stdio;
import std.math;

import derelict.sdl.sdl;
import derelict.sdl.sdlfuncs;
import derelict.sdl.sdltypes;
import derelict.opengl.gl;
import derelict.opengl.extfuncs;
import derelict.opengl.exttypes;

import gl3n.linalg;
import timer;
import shaderstuff;

immutable GLuint VertexCount = 4;
immutable GLuint PositionSize = VertexCount * vec2.sizeof;
vec2 PositionData[VertexCount] =
    [
        vec2(-0.5f,-0.5f),
        vec2( 0.5f,-0.5f),
        vec2( 0.5f, 0.5f),
        vec2(-0.5f, 0.5f)
    ];

immutable GLuint ElementCount = 6;
immutable size_t ElementSize = ElementCount * GLushort.sizeof;

immutable GLushort ElementData[ElementCount] = [ 0, 1, 2,
                                                 2, 3, 0 ];

immutable width = 640;
immutable height = 480;


GLuint ProgramName = 0;
GLuint ElementBufferName = 0;
GLuint ArrayBufferName = 0;
GLuint VertexArrayName = 0;
GLint UniformMVP = 0;
GLint UniformDiffuse = 0;

bool initProgram()
{
    bool validated = true;

    if( validated )
    {
        /*
        GLuint vertexShader = createShader(GL_VERTEX_SHADER, "shaders/tess.vert");
        checkError("vertexShader");
        GLuint controlShader = createShader(GL_TESS_CONTROL_SHADER, "shaders/tess.cont");
        checkError("controlShader");
        GLuint evaluationShader = createShader(GL_TESS_EVALUATION_SHADER, "shaders/tess.eval");
        checkError("evaluationShader");
        GLuint fragmentShader = createShader(GL_FRAGMENT_SHADER, "shaders/tess.frag");
        checkError("fragmentShader");
        */

        GLuint vertexShader = createShader(GL_VERTEX_SHADER, "shaders/primitive-instancing.vert");
        checkError("vertexShader");
        GLuint geometryshader = createShader(GL_GEOMETRY_SHADER, "shaders/primitive-instancing.geom");
        checkError("geometryshader");
        GLuint fragmentShader = createShader(GL_FRAGMENT_SHADER, "shaders/primitive-instancing.frag");
        checkError("fragmentShader");


        /*
        writefln("""Shader values
                    vertex  %1$s
                    control %2$s
                    eval    %3$s
                    frag    %4$s
                 """,
                    vertexShader, controlShader, evaluationShader, fragmentShader);
        */

        writefln("""Shader values
                    vertex  %1$s
                    geom    %2$s
                    frag    %3$s
                 """,
                    vertexShader, geometryshader, fragmentShader);


        ProgramName = glCreateProgram();
        writeln("Program idx is ", ProgramName);

        glAttachShader(ProgramName, vertexShader);
        //glAttachShader(ProgramName, controlShader);
        //glAttachShader(ProgramName, evaluationShader);
        glAttachShader(ProgramName, geometryshader);
        glAttachShader(ProgramName, fragmentShader);

        glDeleteShader(vertexShader);
        //glDeleteShader(controlShader);
        glDeleteShader(geometryshader);
        //glDeleteShader(evaluationShader);
        glDeleteShader(fragmentShader);

        glLinkProgram(ProgramName);
        checkError("link program");

        validated = checkProgram(ProgramName);
    }

    if( validated )
    {
        writeln("Program validated, getting variable locations");
        UniformMVP = glGetUniformLocation(ProgramName, "MVP");
        validated = checkError("get uniform mvp");
        UniformDiffuse = glGetUniformLocation(ProgramName, "Diffuse");
        validated = checkError("get uniform diffuse");
        writefln("""uniforms
                    mvp %1$s
                    dif %2$s
                """,
                UniformMVP,
                UniformDiffuse);

        glUseProgram(ProgramName);

        vec4 diffuse = vec4(1.0f, 0.5f, 0.0f, 1.0f);

        glUniform4fv(UniformDiffuse, 1, &diffuse.vector[0]);
        checkError("applying defuse");
        glUseProgram(0);
    }

    return validated && checkError("initProgram");
}

bool initVertexArray()
{
    glGenVertexArrays(1, &VertexArrayName);
    glBindVertexArray(VertexArrayName);
        glBindBuffer(GL_ARRAY_BUFFER, ArrayBufferName);
        glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, null);
        glEnableVertexAttribArray(0);
        glBindBuffer(GL_ARRAY_BUFFER, 0);

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

    writeln("VertexArrayName ", VertexArrayName);

    return checkError("initVertexArray");
}

bool initArrayBuffer()
{

    glGenBuffers(1, &ElementBufferName);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ElementBufferName);
        glBufferData(GL_ELEMENT_ARRAY_BUFFER, ElementSize, &ElementData, GL_STATIC_DRAW);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);


    writeln("ElementBufferName ", ElementBufferName);

    glGenBuffers(1, &ArrayBufferName);
    glBindBuffer(GL_ARRAY_BUFFER, ArrayBufferName);
        glBufferData(GL_ARRAY_BUFFER, PositionSize, &PositionData, GL_STATIC_DRAW);
    glBindBuffer(GL_ARRAY_BUFFER, 0);

    writeln("ArrayBufferName ", ArrayBufferName);

    return checkError("initArrayBuffer");
}

bool begin()
{
    GLint MajorVersion = 0;
    GLint MinorVersion = 0;

    glGetIntegerv(GL_MAJOR_VERSION, &MajorVersion);
    glGetIntegerv(GL_MINOR_VERSION, &MinorVersion);

    immutable SAMPLE_MAJOR_VERSION = 4;
    immutable SAMPLE_MINOR_VERSION = 2;

    bool validated = (MajorVersion * 10 + MinorVersion) >= (SAMPLE_MAJOR_VERSION * 10 + SAMPLE_MINOR_VERSION);

    glEnable(GL_DEPTH_TEST);

    writeln("validated ", validated);

    if( validated && !initProgram() )
    {
        writeln("Initprogram failed");
        validated = false;
    }

    if( validated && !initArrayBuffer() )
    {
        writeln("initArrayBuffer failed");
        validated = false;
    }

    if( validated && !initVertexArray() )
    {
        writeln("initVertexArray failed");
        validated = false;
    }

    return validated && checkError("begin");
}

bool end()
{
    glDeleteVertexArrays(1, &VertexArrayName);
    glDeleteBuffers(1, &ArrayBufferName);
    glDeleteBuffers(1, &ElementBufferName);
    glDeleteProgram(ProgramName);

    return checkError("end");
}

void display(Timer timer)
{
    //glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
    mat4 projection = mat4.perspective(4.0f, 3.0f, 45.0f, 0.1f, 10.0f);
    mat4 translate = mat4.translate(0.0f, 0.0f, 1.0f);
    mat4 view;
    view.clear(1.0f);
    //view = mat4.rotatey(45.0f/180.0*PI) * translate * view;
    view = translate;

    mat4 model;
    model.clear(1.0f);
    mat4 MVP = projection * view * model;

    glViewport(0, 0, width, height);
    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
    //glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glUseProgram(ProgramName);
    glUniformMatrix4fv(UniformMVP, 1, GL_FALSE, &MVP.matrix[0][0]);

    glBindVertexArray(VertexArrayName);
        glDrawElements(GL_TRIANGLES, ElementCount, GL_UNSIGNED_SHORT, null);
        //glPatchParameteri(GL_PATCH_VERTICES, VertexCount);
        //glDrawArrays(GL_TRIANGLES, 0, VertexCount);
        checkError("draw arrays");
    glBindVertexArray(0);

    glUseProgram(0);
    checkError("display");
}

void main()
{
    DerelictSDL.load();
    DerelictGL.load();

    SDL_Surface* screen = null;

    SDL_Init( SDL_INIT_EVERYTHING );


    screen = SDL_SetVideoMode(width, height, 32, SDL_OPENGL);

    if( screen is null )
    {
        return;
    }

    GLint majorVersion;
    GLint minorVersion;


    writeln("Loading GL 2.1");
    GLVersion loadedVersion = DerelictGL.loadClassicVersions(GLVersion.GL21);
    writeln("Loading max version %1$s", DerelictGL.versionToString(DerelictGL.maxVersion()));
    loadedVersion = DerelictGL.loadModernVersions(GLVersion.GL40);

    writefln("max version    %1$s", DerelictGL.maxVersion());
    writefln("loaded version %1$s", loadedVersion);

    writefln("we got version %1$s.%2$s", DerelictGL.versionToString(loadedVersion));
    DerelictGL.loadExtensions();
    writeln("loaded extensions");

    glGetIntegerv(GL_MAJOR_VERSION, &majorVersion);
    glGetIntegerv(GL_MINOR_VERSION, &minorVersion);

    writefln("major %1$s, minor %2$s", majorVersion, minorVersion);

    foreach(string s; DerelictGL.loadedExtensionNames())
    {
        writeln(s);
    }

    writeln("\nnot loaded extesnions");
    foreach(string s; DerelictGL.notLoadedExtensionNames())
    {
        writeln(s);
    }

    writeln();
    writeln("Starting up");

    scope(success)
    {
        bool quit = false;
        writeln("writing data");
        writeln("done");

        SDL_Event event;
        Timer timer = new Timer;

        while(!quit)
        {
            timer.start();
            while( SDL_PollEvent(&event) )
            {
               if( event.type == SDL_QUIT )
               {
                   quit = true;
               }
            }

            display(timer);
            SDL_GL_SwapBuffers();

            if( timer.getTicks() < 1000/60 )
            {
                SDL_Delay( 1000/60 - timer.getTicks() );
            }
        }

        end();
        SDL_Quit();
    }
    scope(failure)
    {
    }

    if( !begin() )
    {
        throw new Exception("init failed");
    }
}