#ifndef GPU_H
#define GPU_H

#define VK_USE_PLATFORM_MACOS_MVK
#include "vulkan/vulkan_core.h"

#include "vk_mem_alloc.h"

#define GLFW_INCLUDE_VULKAN
#include <GLFW/glfw3.h>

#ifdef __APPLE__
#define GLFW_EXPOSE_NATIVE_COCOA
#endif

#include <GLFW/glfw3native.h>

#define GLM_FORCE_RADIANS
#define GLM_FORCE_DEPTH_ZERO_TO_ONE
#include <cglm/types.h>
#include <cglm/mat4.h>
#include <cglm/vec3.h>
#include <cglm/affine.h>
#include <cglm/quat.h>
#include <cglm/cam.h>

#define MAX_FRAMES_IN_FLIGHT 2
#define WINDOW_MIN_WIDTH 800
#define WINDOW_MIN_HEIGHT 600

extern PFN_vkCmdPipelineBarrier2KHR pVkCmdPipelineBarrier2KHR; 

typedef struct GPUBufferStruct {
  VkBuffer      buffers[MAX_FRAMES_IN_FLIGHT];
  VmaAllocation memory[MAX_FRAMES_IN_FLIGHT];
  VkDeviceSize  size;
} GPUBuffer;

typedef struct GPUQueueStruct {
  VkQueue handle;
  uint32_t family;
  uint32_t index;
} GPUQueue;


VkCommandBuffer command_begin_single(VkDevice device, VkCommandPool transfer_pool);

VkResult command_end_single(VkDevice device, VkCommandBuffer command_buffer, VkCommandPool transfer_pool, GPUQueue transfer_queue);

void command_copy_buffer(VkCommandBuffer command_buffer, VkBuffer src, VkBuffer dst, VkDeviceSize src_offset, VkDeviceSize dst_offset, VkDeviceSize size);

VkResult command_transition_image_layout(VkDevice device, VkCommandPool transfer_pool, GPUQueue transfer_queue, VkImageLayout old_layout, VkImageLayout new_layout, VkImage image, VkAccessFlags src_mask, VkAccessFlags dst_mask, VkPipelineStageFlags source, VkPipelineStageFlags dest, uint32_t source_family, uint32_t dest_family, VkImageAspectFlags aspect_flags);

#define VK_RESULT(x) {\
 result = x;\
 if(result != VK_SUCCESS) {\
    return x;\
 }\
}

typedef struct SwapchainDetailsStruct {
  VkSurfaceCapabilitiesKHR capabilities;

  VkSurfaceFormatKHR* formats;
  uint32_t formats_count;

  VkPresentModeKHR* present_modes;
  uint32_t present_modes_count;
} SwapchainDetails;

typedef struct TransferInfoStruct {
  VkDeviceSize offset;
  VkDeviceSize size;
  VkBuffer     buffer;
} TransferInfo;

typedef struct FrameContextStruct {
  VkFence     ready;
  VkSemaphore image;
  VkSemaphore render;
  VkSemaphore transfer;
  VkSemaphore compute;
  VkSemaphore frame;

  uint64_t frame_index;
  uint64_t compute_index;

  VkCommandBuffer compute_commands;
  VkCommandBuffer transfer_commands;
  VkBuffer        transfer_buffer;
  VmaAllocation   transfer_memory;
  void*           transfer_mapped;
  size_t          transfer_written;

  size_t          transfer_max_size;
  size_t          transfer_max_count;

  TransferInfo*   transfer_infos;
  uint32_t        transfer_count;
} FrameContext;

typedef struct RenderContextStruct {
  VkInstance instance;
  VkDebugUtilsMessengerEXT debug_messenger;
  VkPhysicalDevice physical_device;
  VkSurfaceKHR surface;
  GPUQueue graphics_queue;
  GPUQueue present_queue;
  GPUQueue transfer_queue;
  VkDevice device;
  VmaAllocator allocator;

  SwapchainDetails swapchain_details;
  VkSurfaceFormatKHR swapchain_format;
  VkPresentModeKHR swapchain_present_mode;
  VkExtent2D swapchain_extent;
  VkSwapchainKHR swapchain;

  uint32_t swapchain_image_count;
  VkImage* swapchain_images;
  VkImageView* swapchain_image_views;
  VkFramebuffer* swapchain_framebuffers;

  VkFormat depth_format;
  VkImageView depth_image_view;
  VkImage depth_image;
  VmaAllocation depth_image_memory;

  VkCommandPool extra_graphics_pool;
  VkCommandPool graphics_pool;
  VkCommandPool transfer_pool;

  VkRenderPass render_pass;

  VkCommandBuffer* swapchain_command_buffers;

  FrameContext frame[MAX_FRAMES_IN_FLIGHT];

  uint32_t current_frame;
  vec2 window_scale;
} RenderContext;

GLFWwindow* init_window();

VkResult init_vulkan(
    GLFWwindow* window,
    RenderContext* context);

VkResult create_transfer_buffer(
    VmaAllocator allocator,
    VkDeviceSize size,
    VkBuffer* buffer,
    VmaAllocation* memory,
    void** mapped);

void destroy_transfer_buffer(
    VmaAllocator allocator,
    VkBuffer buffer,
    VmaAllocation memory);

VkResult create_storage_buffer(
    VmaAllocator allocator,
    VkBufferUsageFlags usage,
    VkDeviceSize size,
    VkBuffer* buffer,
    VmaAllocation* memory);

VkDeviceAddress buffer_address(
    VkDevice device,
    VkBuffer buffer);

VkResult add_transfer(
    void* data,
    VkBuffer buffer,
    VkDeviceSize offset,
    VkDeviceSize size,
    uint32_t frame_index,
    RenderContext* gpu);

VkResult add_transfers(
    void* data,
    VkBuffer* buffers,
    VkDeviceSize offset,
    VkDeviceSize size,
    RenderContext* gpu);

#endif