#ifndef PARADISO_SHADER_HPP
#define PARADISO_SHADER_HPP

#include "globals.hpp"

#include <unordered_map>
#include <variant>
#include <string>
#include <vector>
#include <memory>
#include <tuple>

namespace paradiso
{

    struct Shader final
    {
        Shader();
        ~Shader();
        Shader(const Shader &) = delete;
        Shader(Shader &&) = default;

        enum class Type
        {
            Vertex,
            Fragment,
            Geometry,
            Compute
        };

        void set_source(Type t, const std::string &c) { source_[t] = c; }
        std::string source(Type t) const { return source_.at(t); }

        bool ready() const;

        bool build();

        void use();

        Shader &set_uniform_at_location(int location, float v);    //!< sets a float in a shader
        Shader &set_uniform_at_location(int location, uint32_t v); //!< sets a 32bit unsigned in a shader
        Shader &set_uniform_at_location(int location, int32_t v);  //!< sets a 32bit signed in a shader

        /**
         * @brief retrieves the position of a uniform
         * @param name of the uniform
         * @return position of the uniform or negative if it doesn't exist
         */
        int uniform_location(std::string const &name) const;

        /**
         * @brief check if a uniform with the given name exists
         * @param name of the uniform
         * @return true if found
         */
        bool has_uniform(std::string const &name) const { return uniform_location(name) >= 0; }

        /**
         * sets data of the
         */
        template <typename T>
        Shader &set_uniform(std::string const &name, T &&value)
        {
            return set_uniform_at_location(uniform_location(name), std::forward<T>(value));
        }


        using uniform_t = std::variant<bool, int, float, double /*,vector2f,vector3f,vector4f,matrix4x4f*/>;
        using uniform_entry_t = std::tuple<std::string, uniform_t, int>;

        using uniform_cache_t = std::vector<uniform_entry_t>;

        void set_uniforms(uniform_cache_t c);

        uint32_t native_handle() const;

    private:
        std::unordered_map<Type, std::string> source_;

        struct impl;
        std::unique_ptr<impl> impl_;
    };

}

#endif