#ifdef RENDERER_OPENGL
#ifndef RENDERER_OPENGL_H
#define RENDERER_OPENGL_H

#include "pch.hpp"

#include "utils/Renderer/Renderer.h"

#define GLEW_STATIC
#include <GL/glew.h>


namespace Archimedes {

    class RendererOpenGL : public Renderer {
    
        public:
            typedef void renderCmd();

            RendererOpenGL() {};
            ~RendererOpenGL() {};

            bool init() override { 
                return glewInit() == GLEW_OK;
            };

            void render() override {

                glViewport(0, 0, w, h);
                glClearColor(clearColor.r, clearColor.g, clearColor.b, clearColor.a);
                glClear(GL_COLOR_BUFFER_BIT);

            }

            Shader createShader(const std::string& vs, const std::string& fs, const Shader::LoadType& lt) override {


                Shader shader(vs, fs, lt);
                
                std::string vss = shader.getVSource();
                std::string fss = shader.getFSource();

                const char* vsc = vss.c_str();
                const char* fsc = fss.c_str();

                unsigned int vertexShader = glCreateShader(GL_VERTEX_SHADER);
                glShaderSource(vertexShader, 1, &vsc, 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, &fsc, 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
                unsigned int 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);

                shader.id = shaderProgram;
                
                std::cout << "createShader success!\n";
                return shader;
            }
            
            RenderTarget* createRenderTarget(const void* data, size_t size, unsigned int* indices, size_t count, VertexLayout layout, const std::string& vs, const std::string& fs, const Shader::LoadType& lt) override {
                
                VertexBuffer vb(data, size);

                IndexArray ia(indices, count);

                Shader s = createShader(vs, fs, lt);

                auto rt = new RenderTarget(vb, ia, layout, s);

                glGenVertexArrays(1, &rt->vertexArray.id);

                glGenBuffers(1, &rt->vertexBuffer.id);

                glBindVertexArray(rt->vertexArray.id);

                glBindBuffer(GL_ARRAY_BUFFER, rt->vertexBuffer.id);
                glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 6, data, GL_STATIC_DRAW);
                

                glGenBuffers(1, &rt->indexArray.id);

                glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, rt->indexArray.id);
                glBufferData(GL_ELEMENT_ARRAY_BUFFER, count * sizeof(unsigned int), indices, GL_STATIC_DRAW);
                

                glUseProgram(s.id);

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

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

                std::cout << "createRenderTarget success!\n";
                return rt;
            };

            void draw(const RenderTarget* rt) override {
                
                /*std::cout << "\nNow Rendering:\n"
                    << "\nindex buffer id: " << rt.indexArray.id
                    << "\nshader id: " << rt.shader.id
                    << "\nvertex array id: " << rt.vertexArray.id
                    << "\nvertex buffer id: " << rt.vertexBuffer.id
                    << "\n" << "";*/

                glUseProgram(rt->shader.id);

                glBindVertexArray(rt->vertexArray.id);

                glDrawElements(GL_TRIANGLES, rt->indexArray.getCount(), GL_UNSIGNED_INT, nullptr);
                
                glBindVertexArray(0);
            }
            
            RendererOpenGL* getRendererImpl() override { return this; }
    };
}

#endif
#endif