#pragma once

#include "RenderEngineBase.hpp"
#include "ModelManager.hpp"

#include <vector>
#include <string>
#include <memory>

#define GLM_FORCE_RADIANS
#include <mutex>
#include <glm/glm.hpp>

#include "VkObjects/Device.hpp"
#include "VkObjects/Instance.hpp"
#include "VkObjects/PhysicalDevice.hpp"
#include "VkObjects/Surface.hpp"
#include "VkObjects/Swapchain.hpp"

class Camera;
class GPU_GarbageCollector;

#define GET_RENDER_ENGINE static_cast<UwURenderEngine*>(GetWorld()->GetGameInstance().GetCore().GetRenderEngine())

class UwURenderEngine : public RenderEngineBase
{
    struct UniformBufferObject {
        glm::mat4 model;
        glm::mat4 view;
        glm::mat4 proj;
    };
    
    const std::vector<ModelManager::Vertex> vertices_ = {
        {{-0.5f, -0.5f, 0.5f}, {1.0f, 0.0f, 0.0f}},
        {{0.5f, -0.5f, 0.5f}, {0.0f, 1.0f, 0.0f}},
        {{0.5f, 0.5f, 0.5f}, {0.0f, 0.0f, 1.0f}},
        {{-0.5f, 0.5f, 0.5f}, {1.0f, 1.0f, 1.0f}},
        {{-0.5f, -0.5f, -0.5f}, {1.0f, 0.0f, 0.0f}},
        {{0.5f, -0.5f, -0.5f}, {0.0f, 1.0f, 0.0f}},
        {{0.5f, 0.5f, -0.5f}, {0.0f, 0.0f, 1.0f}},
        {{-0.5f, 0.5f, -0.5f}, {1.0f, 1.0f, 1.0f}}
    };
    const std::vector<uint16_t> indices_ = {
        0, 1, 2, 2, 3, 0,
        2, 1, 5, 5, 6, 2,
        0, 3, 7, 7, 4, 0,
        3, 2, 6, 6, 7, 3,
        7, 6, 5, 5, 4, 7,
        4, 5, 1, 1, 0, 4
    };
    
    const std::vector<const char*> UwURenderEngine::deviceExtensions = {
        VK_KHR_SWAPCHAIN_EXTENSION_NAME
    };
    
    // Counting frame from the beginning
    unsigned int current_frame_ = 0;

    CoreInstance& core_;
    std::shared_ptr<ModelManager> model_manager_;
    std::shared_ptr<GPU_GarbageCollector> garbage_collector_;
    std::weak_ptr<Camera> active_camera_;
    std::mutex m_active_camera_;
    
    VkObjects::Instance instance_;
    VkObjects::Surface surface_;
    VkObjects::PhysicalDevice physical_device_;
    VkObjects::Device device_;
    VkObjects::Swapchain swapchain_;
    VkRenderPass render_pass_ = VK_NULL_HANDLE;
    VkDescriptorSetLayout ubo_layout_binding_ = VK_NULL_HANDLE;
    VkDescriptorPool descriptor_pool_ = VK_NULL_HANDLE;
    std::vector<VkDescriptorSet> descriptor_sets_;
    VkPipelineLayout pipeline_layout_ = VK_NULL_HANDLE;
    VkPipeline graphics_pipeline_ = VK_NULL_HANDLE;
    std::vector<VkFramebuffer> framebuffers_;
    VkCommandPool command_pool_ = VK_NULL_HANDLE;
    std::vector<VkCommandBuffer> command_buffers_;
    VkBuffer vertex_buffer_ = VK_NULL_HANDLE;
    VkDeviceMemory vertex_buffer_memory_ = VK_NULL_HANDLE;
    VkBuffer index_buffer_ = VK_NULL_HANDLE;
    VkDeviceMemory index_buffer_memory_ = VK_NULL_HANDLE;
    std::vector<VkBuffer> uniform_buffers_;
    std::vector<VkDeviceMemory> uniform_buffers_memory_;
    std::vector<void*> uniform_buffers_mapped_;

    // Sync objects
    std::vector<VkSemaphore> image_available_semaphores_, render_finished_semaphores_;
    std::vector<VkFence> in_flight_fences_;
    
    
    VkShaderModule create_shader_module(const std::string& code) const;
    
    void create_render_pass();
    void create_description_set_layout();
    void create_uniform_buffers();
    void create_descriptor_pool();
    void create_descriptor_sets();
    void create_graphics_pipeline();
    void create_framebuffers();
    void create_command_pool();
    void allocate_command_buffers();
    void create_sync_objects();
    void allocate_vertex_buffer();
    void allocate_index_buffer();
    
    void record_command_buffer(VkCommandBuffer command_buffer, uint32_t image_index) const;
    void update_uniform_buffer(uint32_t current_frame) const;
    void draw_frame();
public:
    // Can throw the exception
    explicit UwURenderEngine(CoreInstance& core);
    ~UwURenderEngine() override;

    void start() override;
    void stop_render() const override;

    std::shared_ptr<ModelManager> GetModelManager() const { return model_manager_; }

    void SetActiveCamera(const std::weak_ptr<Camera>& camera);
};