// This only works with opengl!!!!


#include "TestTriangle.h"



TestTriangle::TestTriangle(Archimedes::App* a, void* h) : Archimedes::Module(a, h) {

    name = "TestTriangle";

    WindowModule* wm = new WindowModule(a, h);
    deps[*wm] = wm;
}

TestTriangle::~TestTriangle() {
 
    if(app) {
        WindowModule* wm; { wm = (WindowModule*) moduleInstances[WindowModule()]; }

        wm->getRenderer()->getCmdList().erase(rcmd_it);
/*
#if WINDOW == 2
        wm->removeEventFn(ecmd_it);
#endif
*/
        wm->releaseWindow(window);
    }   
}

void TestTriangle::onLoad() {
    // get window
    WindowModule* wm; { wm = (WindowModule*) moduleInstances[WindowModule()]; }
    
    if(!wm) {
        std::cout << "No WindowModule for ImguiModule!\n";
        std::abort();
    }

    window = wm->aquireWindow();


    wm->getRenderer()->getCmdList().push_back([this](){
            // draw our first triangle
            glUseProgram(shaderProgram);
            glBindVertexArray(VAO); // seeing as we only have a single VAO there's no need to bind it every time, but we'll do so to keep things a bit more organized
            glDrawArrays(GL_TRIANGLES, 0, 3);
            glBindVertexArray(0); // no need to unbind it every time 
    });

    rcmd_it = --wm->getRenderer()->getCmdList().end()++;


    //////////////////////glew

    /*
    if(glewInit() != GLEW_OK) {
        std::cout << "glew is not ok!" << std::endl;
        std::abort();
    }
    */
   ///////////////////////////////NUCLEAR
   

    // build and compile our shader program
    // ------------------------------------
    // vertex shader
    unsigned int vertexShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
    glCompileShader(vertexShader);
    // check for shader compile errors
    int success;
    char infoLog[512];
    glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
    if (!success)
    {
        glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
        std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" << infoLog << std::endl;
    }
    // fragment shader
    unsigned int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
    glCompileShader(fragmentShader);
    // check for shader compile errors
    glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
    if (!success)
    {
        glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
        std::cout << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" << infoLog << std::endl;
    }
    // link shaders
    shaderProgram = glCreateProgram();
    glAttachShader(shaderProgram, vertexShader);
    glAttachShader(shaderProgram, fragmentShader);
    glLinkProgram(shaderProgram);
    // check for linking errors
    glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
    if (!success) {
        glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog);
        std::cout << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << std::endl;
    }
    glDeleteShader(vertexShader);
    glDeleteShader(fragmentShader);

    // set up vertex data (and buffer(s)) and configure vertex attributes
    // ------------------------------------------------------------------

    glGenVertexArrays(1, &VAO);
    glGenBuffers(1, &VBO);
    // bind the Vertex Array Object first, then bind and set vertex buffer(s), and then configure vertex attributes(s).
    glBindVertexArray(VAO);

    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(0);

    // note that this is allowed, the call to glVertexAttribPointer registered VBO as the vertex attribute's bound vertex buffer object so afterwards we can safely unbind
    glBindBuffer(GL_ARRAY_BUFFER, 0); 

    // You can unbind the VAO afterwards so other VAO calls won't accidentally modify this VAO, but this rarely happens. Modifying other
    // VAOs requires a call to glBindVertexArray anyways so we generally don't unbind VAOs (nor VBOs) when it's not directly necessary.
    glBindVertexArray(0); 


    // uncomment this call to draw in wireframe polygons.
    //glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

}

void TestTriangle::run() {


} 

bool TestTriangle::onEvent(const Archimedes::Event& e) {
    return false;
}