/*
 *  <Short Description>
 *  Copyright (C) 2023  Brett Terpstra
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

#ifndef BLT_WITH_GRAPHICS_SHADER_H
#define BLT_WITH_GRAPHICS_SHADER_H

#include <blt/gfx/gl_includes.h>
#include <vector>
#include <unordered_map>
#include <string>
#include <blt/math/math.h>

namespace blt::gfx
{
    class shader_base {
        protected:
            struct IntDefaultedToMinusOne {
                GLint i = -1;
            };
            std::unordered_map<std::string, IntDefaultedToMinusOne> uniformVars;
            GLuint programID = 0;
            
            inline GLint getUniformLocation(const std::string &name) {
                if (uniformVars[name].i != -1)
                    return uniformVars[name].i;
                int loc = glGetUniformLocation(programID, name.c_str());
                uniformVars[name].i = loc;
                return loc;
            }
        public:
            inline void bind() const {
                glUseProgram(programID);
            }
            
            inline void setBool(const std::string &name, bool value) {
                glUniform1i(getUniformLocation(name), (int) value);
            }
            
            inline void setInt(const std::string &name, int value) {
                glUniform1i(getUniformLocation(name), value);
            }
            
            inline void setFloat(const std::string &name, float value) {
                glUniform1f(getUniformLocation(name), value);
            }
            
            inline void setMatrix(const std::string &name, blt::mat4x4 &matrix) {
                glUniformMatrix4fv(getUniformLocation(name), 1, GL_FALSE, matrix.ptr());
            }
            
            inline void setVec3(const std::string &name, const blt::vec3 &vec) {
                glUniform3f(getUniformLocation(name), vec.x(), vec.y(), vec.z());
            }
            
            inline void setVec4(const std::string &name, const blt::vec4 &vec) {
                glUniform4f(getUniformLocation(name), vec.x(), vec.y(), vec.z(), vec.w());
            }
            
            inline void setVec2(const std::string &name, float x, float y) {
                glUniform2f(getUniformLocation(name), x, y);
            }
            
            inline void setVec3(const std::string &name, float x, float y, float z) {
                glUniform3f(getUniformLocation(name), x, y, z);
            }
            
            inline void setVec4(const std::string &name, float x, float y, float z, float w) {
                glUniform4f(getUniformLocation(name), x, y, z, w);
            }
    };
    
    /**
     * a basic computer shader class, contains the functions and resources required to use compute shaders!
     */
    class compute_shader : public shader_base {
        private:
            GLuint shaderID = 0;
        public:
            explicit compute_shader(const std::string& shader_source, bool loadAsString = true);
            
            inline void execute(int x, int y, int z) const {
                bind();
                glDispatchCompute(x, y, z);
            }
            
            ~compute_shader();
    };
    
    class shader : public shader_base {
        private:
            GLuint vertexShaderID = 0;
            GLuint fragmentShaderID = 0;
            // while these will remain unused. (Webgl2 apparently doesn't support them despite being based on GL4.3? that's a TODO!)
            GLuint geometryShaderID = 0;
            // this would be very useful however it is highly unlikely webgl will support it
            // im leaving some of this stuff in here because I might expand the native application to use some of it.
            // im trying to keep the web and native versions the same though
            GLuint tessellationShaderID = 0;
            
            static unsigned int createShader(const std::string& source, int type);
        public:
            /**
             * Creates a shader
             * @param vertex vertex shader source or file
             * @param fragment fragment shader source or file
             * @param geometry geometry shader source or file (optional)
             * @param load_as_string load the shader as a string (true) or use the string to load the shader as a file (false)
             */
            shader(const std::string &vertex, const std::string &fragment, const std::string &geometry = "", bool load_as_string = true);
            
            shader(shader&& move) noexcept;
            
            // used to set the location of VAOs to the in variables in opengl shaders.
            void bindAttribute(int attribute, const std::string &name) const;
            
            // used to set location of shared UBOs like the perspective and view matrix
            void setUniformBlockLocation(const std::string &name, int location) const;
            
            ~shader();
            
            static void updateProjectionMatrix(const blt::mat4x4& projectionMatrix);
            static void updateOrthographicMatrix(const blt::mat4x4& orthoMatrix);
            static void updateViewMatrix(const blt::mat4x4& viewMatrix);
            // returns the perspective view matrix which is calculated per frame. (This is for optimization)
            static const blt::mat4x4& getPVM();
    };
}

#endif //BLT_WITH_GRAPHICS_SHADER_H