#ifndef ENGINE_H
#define ENGINE_H
// Normal header

#include "Common/types.h"



struct FrameData {
  VkCommandPool   _commandPool;
  VkCommandBuffer _mainCommandBuffer;
  VkSemaphore     _swapchainSemaphore;
  VkSemaphore     _renderSemaphore;
  VkFence         _renderFence;
  DeletionQueue   _deletionQueue;
};

constexpr uint32_t FRAME_OVERLAP = 2;

class Engine {
  public:
    //========== Class Members ==========
    bool        _isInitialized  { false };
    int         _frameNumber    { 0 };
    VkExtent2D  _windowExtent   { 1700, 900 };

    GLFWwindow  *window         { nullptr };

    //  Vulkan specific class members
    VkInstance                _instance;
    VkDebugUtilsMessengerEXT  _debugMessenger;
    VkPhysicalDevice          _choosenGPU;
    VkDevice                  _device;
    VkSurfaceKHR              _surface;

    VkSwapchainKHR            _swapchain;
    VkFormat                  _swapchainImageFormat;

    std::vector<VkImage>      _swapchainImages;
    std::vector<VkImageView>  _swapchainImageViews;
    VkExtent2D                _swapchainExtent;

    FrameData                 _frames[FRAME_OVERLAP];

    FrameData&                getCurrentFrame() { return _frames[_frameNumber % FRAME_OVERLAP]; };

    VkQueue                   _graphicsQueue;
    uint32_t                  _graphicsQueueFamily;

    // Deletion queue
    DeletionQueue             _mainDeletionQueue;
    VmaAllocator              _allocator;

    // Draw resources
    AllocatedImage            _drawImage;
    VkExtent2D                _drawExtent;


    void init();

    void cleanup();

    void draw();

    void run();

  private:
    void initRender();
    void initVulkan();
    void initSwapchain();
    void initCommands();
    void initSyncStructures();

    void createSwapchain(
      uint32_t width,
      uint32_t height
    );
    void destroySwapchain();
    void drawBackground(
      VkCommandBuffer cmd
    );
};

#endif


#ifdef ENGINE_IMPL
#ifndef ENGINE_IMPL_H
#define ENGINE_IMPL_H
//========== Implementation ==========
// Implementation defines
#define IMAGES_IMPL
#define INITIALIZERS_IMPL
#define CALLBACK_IMPL
#define TIMER_IMPL
#define VMA_IMPLEMENTATION

// Custom includes
#include "images.h"
#include "initializers.h"
#include "callbacks.h"
#include "Common/timer.h"
#include "Common/types.h"

#include "VkBootstrap.h"
#include "vk_mem_alloc.h"


#ifndef DEBUG
constexpr bool bUseValidationLayers = false;
#else
constexpr bool bUseValidationLayers = true;
#endif

// Abort when there is an error
// Todo : Give an error message or crash dump

using namespace std;
#define VK_CHECK(x)                                        \
  do {                                                      \
    VkResult err = x;                                        \
    if (err) {                                                \
      fmt::println("Vulkan error : {}", string_VkResult(err)); \
      abort();                                                  \
    }                                                            \
  } while (0)                                                     \

void Engine::init() {
  #ifdef DEBUG
  fmt::println("Initializing the engine...");
  fmt::println("Current engine version {}", BUILD_ID);
  #endif

  glfwInit();

  glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
  glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE);

  window = glfwCreateWindow(
    static_cast<uint32_t>(_windowExtent.width),
    static_cast<uint32_t>(_windowExtent.height),
    "Engine",
    nullptr,
    nullptr
  );

  glfwSetKeyCallback(window, Callback::keyboardCallback);

  _isInitialized = true;

  initRender();

  #ifdef DEBUG
  fmt::println("Engine Initialized !");
  #endif
}

void Engine::cleanup() {
  #ifdef DEBUG
  fmt::println("Cleaning up...");
  #endif
  if (_isInitialized) {
    // Wait for the GPU to stop working
    vkDeviceWaitIdle(_device);

    for (int i = 0; i < FRAME_OVERLAP; i++) {
      vkDestroyCommandPool(_device, _frames[i]._commandPool, nullptr);
      // Destroy sync objects
      vkDestroyFence(_device, _frames[i]._renderFence, nullptr);
      vkDestroySemaphore(_device, _frames[i]._renderSemaphore, nullptr);
      vkDestroySemaphore(_device, _frames[i]._swapchainSemaphore, nullptr);

      // Uses the deletion queue to clear ressources
      _frames[i]._deletionQueue.flush();
    }

    // Flush the global deletion queue
    _mainDeletionQueue.flush();

    destroySwapchain();

    vkDestroySurfaceKHR(_instance, _surface, nullptr);
    vkDestroyDevice(_device, nullptr);

    vkb::destroy_debug_utils_messenger(_instance, _debugMessenger);
    vkDestroyInstance(_instance, nullptr);

    /*

    vkDestroyCommandPool(_device, _commandPool, nullptr);



    vkDestroySwapchainKHR(_device, _swapchain, nullptr);
    // Change to use dynamic rendering
    vkDestroyRenderPass(_device, _renderPass, nullptr);

    // Destroy swapchain ressources
    for (uint32_t i = 0; i < _framebuffers.size(); i++) {
      vkDestroyFramebuffer(_device, _framebuffers[i], nullptr);

      vkDestroyImageView(_device, _swapchainImageViews[i], nullptr);
    }
     */

    // Destroy the window (at the end)
    glfwDestroyWindow(window);
    glfwTerminate();
  }

  #ifdef DEBUG
  fmt::println("Engine cleaned up !");
  #endif
}

void Engine::draw() {
 	// wait until the gpu has finished rendering the last frame. Timeout of 1s
 	VK_CHECK(vkWaitForFences(_device, 1, &getCurrentFrame()._renderFence, true, UINT64_MAX));

 // Flush frame data
  getCurrentFrame()._deletionQueue.flush();

	// Request image from the swapchain
	uint32_t swapchainImageIndex;
	VK_CHECK(vkAcquireNextImageKHR(_device, _swapchain, UINT64_MAX, getCurrentFrame()._swapchainSemaphore, nullptr, &swapchainImageIndex));

  // Reset fences to redo sync
  VK_CHECK(vkResetFences(_device, 1, &getCurrentFrame()._renderFence));

	VkCommandBuffer cmd = getCurrentFrame()._mainCommandBuffer;

	_drawExtent.width   = _drawImage.imageExtent.width;
	_drawExtent.height  = _drawImage.imageExtent.height;

	VK_CHECK(vkResetCommandBuffer(cmd, 0));

	VkCommandBufferBeginInfo cmdBeginInfo = {
	  vkinit::commandBufferBeginInfo(
			VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT
		)
	};

	VK_CHECK(vkBeginCommandBuffer(cmd, &cmdBeginInfo));

	vkutil::transitionImage(
	  cmd,
		_drawImage.image,
	  VK_IMAGE_LAYOUT_UNDEFINED,
		VK_IMAGE_LAYOUT_GENERAL
	);

	drawBackground(cmd);

	// Transfer the draw image and swapchain image to the correct layouts
	vkutil::transitionImage(
  	cmd,
  	_drawImage.image,
    VK_IMAGE_LAYOUT_GENERAL,
    VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL
	);

	vkutil::transitionImage(
  	cmd,
  	_swapchainImages[swapchainImageIndex],
    VK_IMAGE_LAYOUT_UNDEFINED,
    VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
	);

	// Copy image -> swapchain
	vkutil::copyImageToImage(
	  cmd,
		_drawImage.image,
		_swapchainImages[swapchainImageIndex],
		_drawExtent,
		_swapchainExtent
	);

	// Uses the present layout to display into the screen
	vkutil::transitionImage(
	  cmd,
		_swapchainImages[swapchainImageIndex],
		VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
		VK_IMAGE_LAYOUT_PRESENT_SRC_KHR
	);

	// Locks the buffer, allowing it to be executed
	VK_CHECK(vkEndCommandBuffer(cmd));

	VkCommandBufferSubmitInfo cmdinfo = vkinit::commandBufferSubmitInfo(cmd);

	VkSemaphoreSubmitInfo waitInfo = vkinit::semaphoreSubmitInfo(VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR, getCurrentFrame()._swapchainSemaphore);
	VkSemaphoreSubmitInfo signalInfo = vkinit::semaphoreSubmitInfo(VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT, getCurrentFrame()._renderSemaphore);

	VkSubmitInfo2 submit = vkinit::submitInfo(&cmdinfo, &signalInfo, &waitInfo);

	VK_CHECK(vkQueueSubmit2(_graphicsQueue, 1, &submit, getCurrentFrame()._renderFence));

	VkPresentInfoKHR presentInfo = {};
	presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
	presentInfo.pNext = nullptr;
	presentInfo.pSwapchains = &_swapchain;
	presentInfo.swapchainCount = 1;

	presentInfo.pWaitSemaphores = &getCurrentFrame()._renderSemaphore;
	presentInfo.waitSemaphoreCount = 1;

	presentInfo.pImageIndices = &swapchainImageIndex;

	VK_CHECK(vkQueuePresentKHR(_graphicsQueue, &presentInfo));

	_frameNumber++;
}

void Engine::run() {
  #ifdef DEBUG
  fmt::println("Running...");
  RunTimer timer;
  timer.startTimer();
  #endif
  bool stopRendering = false;

  while (!glfwWindowShouldClose(window)) {
    glfwPollEvents();

    if (glfwGetWindowAttrib(window, GLFW_ICONIFIED)) {
      stopRendering = true;
    } else {
      stopRendering = false;
    }

    if (stopRendering) {
      // Minimized, pause
      std::this_thread::sleep_for(std::chrono::milliseconds(100));
      continue;
    }

    draw();
  }
  #ifdef DEBUG
  fmt::println("Engine has finished running after {} seconds!", timer.endTimer());
  #endif
}

void Engine::initRender() {
  initVulkan();
  initSwapchain();
  //initDefaultRenderpass();
  //initFramebuffers();
  initCommands();
  initSyncStructures();
}

void Engine::initVulkan() {
  #ifdef DEBUG
  fmt::println("Initializing Vulkan...");
  #endif
  vkb::InstanceBuilder builder;

  // Create a basic VK instance, with debuging features
  auto instRet = builder.set_app_name("Engine")
    .request_validation_layers(bUseValidationLayers)
    .use_default_debug_messenger()
    .require_api_version(1, 3, 0)
    .build();

  vkb::Instance vkbInst = instRet.value();

  // Grab the instance
  _instance       = vkbInst.instance;
  _debugMessenger = vkbInst.debug_messenger;

  // Create the surface
  if (glfwCreateWindowSurface(_instance, window, nullptr, & _surface) != VK_SUCCESS) {
    throw std::runtime_error("Failed to create window surface !\nAborting...");
  }

  // Features
  // Vulkan 1.3
  VkPhysicalDeviceVulkan13Features features13 {
    .sType            = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES,
    .synchronization2 = true,
    .dynamicRendering = true
  };

  VkPhysicalDeviceVulkan12Features features12 {
    .sType            = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES,
    .descriptorIndexing   = true,
    .bufferDeviceAddress  = true
  };

  // Use vkBootstrap to select the GPU
  vkb::PhysicalDeviceSelector selector { vkbInst };
  vkb::PhysicalDevice physicalDevice = selector
    .set_minimum_version(1, 3)
    .set_required_features_13(features13)
    .set_required_features_12(features12)
    .set_surface(_surface)
    .select()
    .value();

  vkb::DeviceBuilder  deviceBuilder { physicalDevice };
  #ifdef DEBUG
  fmt::println("Device {}", physicalDevice.name);
  #endif
  vkb::Device           vkbDevice     { deviceBuilder.build().value() };

  _device               = { vkbDevice.device };
  _choosenGPU           = { physicalDevice.physical_device };

  _graphicsQueue        = { vkbDevice.get_queue(vkb::QueueType::graphics).value() };
  _graphicsQueueFamily  = { vkbDevice.get_queue_index(vkb::QueueType::graphics).value() };

  VmaAllocatorCreateInfo  allocatorInfo = {};
  allocatorInfo.physicalDevice          = _choosenGPU;
  allocatorInfo.device                  = _device;
  allocatorInfo.instance                = _instance;
  allocatorInfo.flags                   = VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT;

  vmaCreateAllocator(&allocatorInfo, &_allocator);

  _mainDeletionQueue.pushFunction([&]() {
    vmaDestroyAllocator(_allocator);
  });

  #ifdef DEBUG
  fmt::println("Vulkan initialized !");
  #endif
}

void Engine::initSwapchain() {
  #ifdef DEBUG
  fmt::println("Initializing the swapchain...");
  #endif

  createSwapchain(_windowExtent.width, _windowExtent.height);

  VkExtent3D drawImageExtent = {
    _windowExtent.width,
    _windowExtent.height,
    1
  };

  // Hardcoding draw format to a 32 bit float

  _drawImage.imageFormat  = VK_FORMAT_R16G16B16A16_SFLOAT;
  _drawImage.imageExtent  = drawImageExtent;

  VkImageUsageFlags drawImageUsages {
    VK_IMAGE_USAGE_TRANSFER_SRC_BIT     |
    VK_IMAGE_USAGE_TRANSFER_DST_BIT     |
    VK_IMAGE_USAGE_STORAGE_BIT          |
    VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT
  };

  VkImageCreateInfo rImgInfo = {
    vkinit::imageCreateInfo(
      _drawImage.imageFormat,
      drawImageUsages,
      drawImageExtent
    )
  };

  // Use the GPU local memory for the draw image
  VmaAllocationCreateInfo rImgAllocInfo = {
    .usage          = VMA_MEMORY_USAGE_GPU_ONLY,
    .requiredFlags  = VkMemoryPropertyFlags(VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT)
  };

  vmaCreateImage(
    _allocator,
    &rImgInfo,
    &rImgAllocInfo,
    &_drawImage.image,
    &_drawImage.allocation,
    nullptr
  );

  VkImageViewCreateInfo rViewInfo = {
    vkinit::imageViewCreateInfo(
      _drawImage.imageFormat,
      _drawImage.image,
      VK_IMAGE_ASPECT_COLOR_BIT
    )
  };

  VK_CHECK(
    vkCreateImageView(
      _device,
      &rViewInfo,
      nullptr,
      &_drawImage.imageView
    )
  );

  // Add to deletion queues
  _mainDeletionQueue.pushFunction([this]() {
    vkDestroyImageView(
      _device,
      _drawImage.imageView,
      nullptr
    );
    vmaDestroyImage(
      _allocator,
      _drawImage.image,
      _drawImage.allocation
    );
  });

  #ifdef DEBUG
  fmt::println("Swapchain initialized !");
  #endif
}

void Engine::initCommands() {
  #ifdef DEBUG
  fmt::println("Initializing vulkan commands..");
  #endif

  VkCommandPoolCreateInfo commandPoolInfo = {
    vkinit::commandPoolCreateInfo(
      _graphicsQueueFamily,
      VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT
    )
  };

  for ( uint32_t i = 0; i < FRAME_OVERLAP; i++ ) {
    VK_CHECK(
      vkCreateCommandPool(
        _device,
        &commandPoolInfo,
        nullptr,
        &_frames[i]._commandPool
      )
    );

    VkCommandBufferAllocateInfo cmdAllocInfo = vkinit::commandBufferAllocateInfo(_frames[i]._commandPool, 1);

    VK_CHECK(
      vkAllocateCommandBuffers(
        _device,
        &cmdAllocInfo,
        &_frames[i]._mainCommandBuffer
      )
    );
  }
  #ifdef DEBUG
  fmt::println("Vulan commands initialized !");
  #endif
}

void Engine::initSyncStructures() {
  #ifdef DEBUG
  fmt::println("Creating sync structures...");
  #endif

  VkFenceCreateInfo fenceCreateInfo = vkinit::fenceCreateInfo(VK_FENCE_CREATE_SIGNALED_BIT);
  VkSemaphoreCreateInfo semaphoreCreateInfo = vkinit::semaphoreCreateInfo();

  for (int i = 0; i < FRAME_OVERLAP; i++) {
    VK_CHECK(vkCreateFence(_device, &fenceCreateInfo, nullptr, &_frames[i]._renderFence));

		VK_CHECK(vkCreateSemaphore(_device, &semaphoreCreateInfo, nullptr, &_frames[i]._swapchainSemaphore));
		VK_CHECK(vkCreateSemaphore(_device, &semaphoreCreateInfo, nullptr, &_frames[i]._renderSemaphore));
	}

  #ifdef DEBUG
  fmt::println("Sync structures created !");
  #endif
}

void Engine::createSwapchain(
  uint32_t width,
  uint32_t height
) {
  #ifdef DEBUG
  fmt::println("Creating the Swapchain...");
  #endif
  vkb::SwapchainBuilder swapchainBuilder {
    _choosenGPU,
    _device,
    _surface
  };

  _swapchainImageFormat = VK_FORMAT_B8G8R8A8_UNORM;

  vkb::Swapchain vkbSwapchain = swapchainBuilder
    .set_desired_format(
      VkSurfaceFormatKHR {
        .format     = _swapchainImageFormat,
        .colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR
      }
    )
    .set_desired_present_mode(VK_PRESENT_MODE_FIFO_KHR) // VSync
    .set_desired_extent(width, height)
    .add_image_usage_flags(VK_IMAGE_USAGE_TRANSFER_DST_BIT)
    .build()
    .value();

  _swapchainExtent     = { vkbSwapchain.extent };
  // Store swapchain and it's related images
  _swapchain           = { vkbSwapchain.swapchain };
  _swapchainImages     = { vkbSwapchain.get_images().value() };
  _swapchainImageViews = { vkbSwapchain.get_image_views().value() };

  #ifdef DEBUG
  fmt::println("Swapchain created with dimentions {} by {}", vkbSwapchain.extent.width, vkbSwapchain.extent.height);
  #endif
}

void Engine::destroySwapchain() {
  #ifdef DEBUG
  fmt::println("Destroying the swapchain...");
  #endif
  vkDestroySwapchainKHR(_device, _swapchain, nullptr);

  for (uint32_t i = 0; i < _swapchainImageViews.size(); i++) {
    vkDestroyImageView(_device, _swapchainImageViews[i], nullptr);
  }

  #ifdef DEBUG
  fmt::println("Swapchain destroyed !");
  #endif
}

void Engine::drawBackground(
  VkCommandBuffer cmd
) {
  VkClearColorValue clearValue;

  float flash = { std::abs(std::sin(_frameNumber / 120.0f)) };

  clearValue  = { { 0.0f, 0.0f, flash, 1.0f } };

  VkImageSubresourceRange clearRange = vkinit::imageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT);

  // Clear Image
  vkCmdClearColorImage(
    cmd,
    _drawImage.image,
    VK_IMAGE_LAYOUT_GENERAL,
    &clearValue,
    1,
    &clearRange
  );
}


#endif
#endif