#pragma once

#include "core/memory.h"
#include "vertex_array.h"
#include "shader.h"
#include "framebuffer.h"

#include <glm/glm.hpp>

namespace Donut
{
    class RendererAPI 
    {
    public:
        enum class API 
        {
            None   = 0, 
            OpenGL = 1,
            Vulkan = 2,
        };
    public:
        virtual ~RendererAPI() = default;

        virtual void init()                                               = 0;
        virtual void set_viewport(uint32_t x, uint32_t y, 
                                 uint32_t width, uint32_t height)         = 0;
        virtual void set_clear_color(const glm::vec4& color)                = 0;
        virtual void clear()                                              = 0;
        virtual void enable_depth_test()                                    = 0;
        virtual void disable_depth_test()                                   = 0;
        virtual void set_face_culling(bool enabled)                         = 0;
        virtual void enable_blending()                                     = 0;
        virtual void disable_blending()                                    = 0;

        virtual void draw_indexed(const Ref<VertexArray>& vertex_array, 
                                 uint32_t index_count = 0)                 = 0;
        
        virtual void draw_arrays(uint32_t vertex_count, uint32_t first = 0) = 0;
        virtual void draw_lines(const Ref<VertexArray>& vertex_array, 
                               uint32_t index_count = 0)                   = 0;
        virtual void bind_texture(uint32_t texture_id, uint32_t slot = 0)   = 0;
        virtual void bind_image_texture(uint32_t texture_id, 
                                      uint32_t slot = 0, 
                                      bool read_only = false)              = 0;
        virtual void read_pixels(uint32_t x, uint32_t y, uint32_t width, uint32_t height, 
                                uint32_t format, uint32_t type, void* pixels) = 0;

        inline static API get_api()         { return s_api; }
        inline static void set_api(API api) { s_api = api;  }
        static Scope<RendererAPI> create();
    private:
        static API s_api;
    };

    class RenderCommand 
    {
    public:
        inline static void init() 
        {
            s_renderer_api->init();
        }

        inline static void set_viewport(uint32_t x, uint32_t y, uint32_t width, uint32_t height)
        {
            s_renderer_api->set_viewport(x, y, width, height);
        }

        inline static void set_clear_color(const glm::vec4& color)
        {
            s_renderer_api->set_clear_color(color);
        }

        inline static void clear()
        {
            s_renderer_api->clear();
        }

        inline static void enable_depth_test()
        {
            s_renderer_api->enable_depth_test();
        }

        inline static void disable_depth_test()
        {
            s_renderer_api->disable_depth_test();
        }

        inline static void set_face_culling(bool enabled)
        {
            s_renderer_api->set_face_culling(enabled);
        }

        inline static void enable_blending()
        {
            s_renderer_api->enable_blending();
        }

        inline static void disable_blending()
        {
            s_renderer_api->disable_blending();
        }

        inline static void draw_indexed(const Ref<VertexArray>& vertex_array, uint32_t index_count = 0)
        {
            s_renderer_api->draw_indexed(vertex_array, index_count);
        }

        inline static void draw_arrays(uint32_t vertex_count, uint32_t first = 0)
        {
            s_renderer_api->draw_arrays(vertex_count, first);
        }

        inline static void draw_lines(const Ref<VertexArray>& vertex_array, uint32_t index_count = 0)
        {
            s_renderer_api->draw_lines(vertex_array, index_count);
        }

        inline static void bind_texture(uint32_t texture_id, uint32_t slot = 0)
        {
            s_renderer_api->bind_texture(texture_id, slot);
        }

        inline static void bind_image_texture(uint32_t texture_id, uint32_t slot = 0, bool read_only = false)
        {
            s_renderer_api->bind_image_texture(texture_id, slot, read_only);
        }

        inline static void read_pixels(uint32_t x, uint32_t y, uint32_t width, uint32_t height, 
                                      uint32_t format, uint32_t type, void* pixels)
        {
            s_renderer_api->read_pixels(x, y, width, height, format, type, pixels);
        }

    private:
        static Scope<RendererAPI> s_renderer_api;
    };

    class Renderer 
    {
    public:
        static void init();
        static void shutdown();

        static void on_window_resize(uint32_t width, uint32_t height);

        static void submit(const Ref<Shader>& shader, 
                           const Ref<VertexArray>& vertex_array,
                           const glm::mat4& transform,
                           const glm::mat4& view_projection);

        static void set_clear_color(const glm::vec4& color);
        static void clear();

        inline static RendererAPI::API get_api() { return RendererAPI::get_api(); }
    };
};