#ifndef GLSHADER_SHADER_HPP_
#define GLSHADER_SHADER_HPP_


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

#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();

protected:

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

    GLuint             program_;
    std::string        program_name_;
    std::string static root_;
    Defines     static defines_;
    Locations   static verts_;
    Locations   static frags_;
};


// Debug macros.

#ifndef NDEBUG
    #define GLSHADER_DEBUG_(...) __VA_ARGS__
#else
    #define GLSHADER_DEBUG_(...)
#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;
}


#endif // GLSHADER_SHADER_HPP_