#ifndef _SHADER_H
#define _SHADER_H

#include <array>
#include <sstream>
#include <algorithm>

#include "texture.h"

#define MAX_TEXTURES 8

namespace Mauri
{

struct Uniform
{
    Uniform() { this->value = &this->default_value; }

    std::string name;
    std::string uname;
    std::string precision = "";

    UniformType type;

    vec4 default_value = vec4(0.f);
    vec4 *value;
};

struct Combo
{
    Combo(const std::string &name, s32 value) : name(name), value(value)
    {
        std::transform(this->name.begin(), this->name.end(), this->name.begin(), ::toupper);
    }
    std::string name;
    s32 value;
    auto to_string() const -> const std::string;
};

struct Variable
{
    std::string name;
    UniformType type;
    auto to_string() const -> const std::string;
};

class Engine;
class Object;

class Shader
{
  public:
    Shader(const std::string &name);
    Shader(Shader *origin);
    ~Shader();

    std::string name;

    std::vector<Combo> combos;
    std::vector<Uniform *> uniforms;

    std::array<std::string, MAX_TEXTURES> textures = {};
    std::array<std::string, MAX_TEXTURES> texture_combos = {};

    u32 texture_count = 0;

    std::stringstream vs_source;
    std::stringstream fs_source;

    std::vector<Variable> variables;

    auto origin() -> Shader * { return this->origin_ ? this->origin_ : this; }

    auto compile(const std::vector<Combo> &combo_overrides) -> RenderShader *;

    auto bind(RenderShader *shader, Engine *engine, Object *object, mat4x4 *model,
        const std::array<Texture *, MAX_TEXTURES> *textures) -> void;

private:
    Shader *origin_ = nullptr;

    auto build_shader_source(const std::string_view &isource, std::stringstream &out) -> void;
};

extern auto get_shader(const std::string &name) -> Shader *;
extern auto unload_shaders() -> void;

} // namespace Mauri

#endif // _SHADER_H