#ifndef GLSHADER_SHADER_HPP_
#define GLSHADER_SHADER_HPP_


#include <map>
#include <set>
#include <string>
#include <unordered_map>

#include <GL/glew.h>


class Shader
{
public:

    using Paths = std::set<std::string>;

    explicit Shader(Paths const & paths);
    virtual ~Shader();
    Shader(Shader &&) noexcept;
    Shader(Shader const &) = delete;
    Shader & operator=(Shader &&) = delete;
    Shader & operator=(Shader const &) = delete;

    using Defines = std::map<std::string, std::string>;
    using Locations = std::map<std::string, GLuint>;

    static void root(std::string const & root);
    static void defines(Defines const & defines);
    static void verts(Locations const & verts);
    static void frags(Locations const & frags);

    GLuint program() const;

    Shader & validate();
    Shader & use();

    template<typename Value>
    Shader & uniform(
        std::string const & name,
        Value       const & value,
        bool                required = true
    );
    template<typename Value>
    Shader & uniform(
        std::string const & name,
        Value             * value,
        bool                required = true
    ) = delete;

    template<typename Value>
    static void uniform_buffer(
        std::string const & name,
        Value       const & value,
        bool                required = true
    );
    template<typename Value>
    static void uniform_buffer(
        std::string const & name,
        Value             * value,
        bool                required = true
    ) = delete;

    Shader & texture(
        std::string const & name,
        GLuint              texture,
        GLenum              target,
        bool                required = true
    );

protected:

    struct Uniform
    {
        GLint location;
        bool set;
    };

    struct UniformBuffer
    {
        GLuint buffer;
        GLsizeiptr size;
        GLuint binding;
        bool set;
    };

    struct UniformBlock
    {
        UniformBuffer & buffer;
    };

    void validate_() const;
    void current_(
        std::string const & error
    ) const;

    static void error_(
        std::string const & error,
        std::string const & error_hint = {}
    );

    Uniform * uniform_(
        std::string const & error,
        std::string const & name,
        bool                required
    );
    UniformBlock * uniform_block_(
        std::string const & error,
        std::string const & name,
        bool                required,
        GLsizeiptr          size
    );
    static UniformBuffer * uniform_buffer_(
        std::string const & error,
        std::string const & name,
        bool                required,
        GLsizeiptr          size
    );

    template<typename Value>
    using ByName = std::unordered_map<std::string, Value>;

    GLuint                       program_;
    std::string                  program_name_;
    std::string           static root_;
    Defines               static defines_;
    Locations             static verts_;
    Locations             static frags_;
    ByName<Uniform>              uniforms_;
    ByName<UniformBlock>         uniform_blocks_;
    ByName<UniformBuffer> static uniform_buffers_;
};


// Debug macros.

#ifndef NDEBUG
    #define GLSHADER_DEBUG_(...) __VA_ARGS__
    #define GLSHADER_DEBUG_ERROR_(...) \
        auto error = std::string{} + __VA_ARGS__;
#else
    #define GLSHADER_DEBUG_(...)
    #define GLSHADER_DEBUG_ERROR_(...) \
        auto error = std::string{};
#endif // NDEBUG


// Inline definitions.

#define GLSHADER_SET_(TYPE, NAME) \
    inline void Shader::NAME(TYPE const & NAME) \
    { \
        NAME##_ = NAME; \
    }
GLSHADER_SET_(std::string, root)
GLSHADER_SET_(Defines, defines)
GLSHADER_SET_(Locations, verts)
GLSHADER_SET_(Locations, frags)

inline GLuint Shader::program() const
{
    return program_;
}

inline Shader & Shader::validate()
{
    GLSHADER_DEBUG_(validate_();)
    return *this;
}

inline Shader & Shader::use()
{
    glUseProgram(program_);
    return *this;
}


// Uniform template definitions.

#define GLSHADER_UNIFORM_BUFFER_(BLOCK_OR_BUFFER, BUFFER, SET) \
    if (auto block_or_buffer = BLOCK_OR_BUFFER( \
        error, name, required, sizeof(value) \
    )) \
    { \
        glBindBuffer(GL_UNIFORM_BUFFER, block_or_buffer->BUFFER); \
        GLSHADER_DEBUG_(error_(error, "unprocessed previous error");) \
        glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(value), &value); \
        GLSHADER_DEBUG_(error_(error);) \
        GLSHADER_DEBUG_(block_or_buffer->SET = true;) \
    }

template<typename Value>
inline void Shader::uniform_buffer(
    std::string const & name,
    Value       const & value,
    bool                required
)
{
    GLSHADER_DEBUG_ERROR_(
        "Failed to set uniform buffer '" + name + "'"
    )
    GLSHADER_UNIFORM_BUFFER_(uniform_buffer_, buffer, set)
}

template<typename Value>
inline Shader & Shader::uniform(
    std::string const & name,
    Value       const & value,
    bool                required
)
{
    GLSHADER_DEBUG_ERROR_(
        "Failed to set uniform block '" + name + "' of " + program_name_
    )
    GLSHADER_DEBUG_(current_(error);)
    GLSHADER_UNIFORM_BUFFER_(uniform_block_, buffer.buffer, buffer.set)
    return *this;
}


// Uniform template specializations.

#define GLSHADER_UNIFORM_SIGNATURE_(TYPE) \
    template<> \
    inline Shader & Shader::uniform( \
        std::string const & name, \
        TYPE        const & value, \
        bool                required \
    )

#define GLSHADER_UNIFORM_DELETE(TYPE) \
    GLSHADER_UNIFORM_SIGNATURE_(TYPE) = delete;

#define GLSHADER_UNIFORM(TYPE, CODE) \
    GLSHADER_UNIFORM_SIGNATURE_(TYPE) \
    { \
        GLSHADER_DEBUG_ERROR_( \
            "Failed to set uniform '" + name + "' of " + program_name_ \
        ) \
        GLSHADER_DEBUG_(current_(error);) \
        if (auto * uniform = uniform_(error, name, required)) \
        { \
            GLint const & location = uniform->location; \
            GLSHADER_DEBUG_(error_(error, "unprocessed previous error");) \
            CODE \
            GLSHADER_DEBUG_(error_(error, "wrong type?");) \
            GLSHADER_DEBUG_(uniform->set = true;) \
        } \
        return *this; \
    }


// Uniform scalar template specializations.

#define GLSHADER_UNIFORM_SCALAR_(TYPE, SUFFIX) \
    GLSHADER_UNIFORM( \
        TYPE, \
        glUniform1##SUFFIX( \
            location, value \
        ); \
    )

GLSHADER_UNIFORM_SCALAR_(bool,      i)
GLSHADER_UNIFORM_SCALAR_(GLboolean, i)
GLSHADER_UNIFORM_SCALAR_(GLint,     i)
GLSHADER_UNIFORM_SCALAR_(GLuint,    ui)
GLSHADER_UNIFORM_SCALAR_(GLfloat,   f)

GLSHADER_UNIFORM_DELETE(GLdouble)


#endif // GLSHADER_SHADER_HPP_