#pragma once

class render_target;
class texture;

struct shader_draw_data {
    int width;
    int height;
};

class shader : public std::enable_shared_from_this<shader> {
public:
    virtual ~shader() = default;

    virtual bool init() { return false; }

    [[nodiscard]] virtual bool is_initialized() const = 0;

    virtual void bind() = 0;

    virtual void unbind() = 0;

    virtual void compute(int x, int y, int z) {
    }

    // param setters
    virtual void set_cbuffer(const char* name, void* buffer, int size) = 0;

    virtual void set_uav_buffer(const char* name, void* buffer, int count, int element_size) {
    }

    virtual void set_texture(const char* name, std::shared_ptr<texture> in_texture) = 0;

    virtual void set_render_target(const char* name, std::shared_ptr<render_target> in_render_target) = 0;

    template<typename T>
    void set_cbuffer(const char* name, const T& buffer) {
        set_cbuffer(name, (void*) &buffer, sizeof(T));
    }

    template<typename T>
    void set_cbuffer(const char* name, const std::vector<T>& buffer) {
        set_cbuffer(name, (void*) buffer.data(), sizeof(T) * buffer.size());
    }

    template<typename T>
    void set_uav_buffer(const char* name, const T& buffer) {
        set_uav_buffer(name, (void*) &buffer, sizeof(buffer), sizeof(T));
    }

    template<typename T>
    void set_uav_buffer(const char* name, const std::vector<T>& buffer) {
        set_uav_buffer(name, (void*) buffer.data(), buffer.size(), sizeof(T));
    }

    void begin_draw(const shader_draw_data& in_data) { if (on_begin_draw) on_begin_draw(in_data, *this); }
    std::function<void(const shader_draw_data&, shader&)> on_begin_draw;
};