#include <vk_initializers.h>

// #if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
//
#define VULKAN_HPP_NO_STRUCT_CONSTRUCTORS 1
#define VULKAN_HPP_NO_CONSTRUCTORS 1
#include <vulkan/vulkan.hpp>

VkCommandPoolCreateInfo vkinit::command_pool_create_info(uint32_t queueFamilyIndex,
    VkCommandPoolCreateFlags flags /*= 0*/)
{
  return vk::CommandPoolCreateInfo{
    .flags=vk::CommandPoolCreateFlags(flags),
    .queueFamilyIndex=queueFamilyIndex
  };
}


VkCommandBufferAllocateInfo vkinit::command_buffer_allocate_info(
    VkCommandPool pool, uint32_t count /*= 1*/)
{
  return vk::CommandBufferAllocateInfo{
    .commandPool=pool,
    .level=vk::CommandBufferLevel::ePrimary,
    .commandBufferCount=count
  };
}

VkFenceCreateInfo vkinit::fence_create_info(VkFenceCreateFlags flags /*=0*/)
{
  return vk::FenceCreateInfo{
    .flags=vk::FenceCreateFlags(flags)
  };
}

VkSemaphoreCreateInfo vkinit::semaphore_create_info(VkSemaphoreCreateFlags flags/*=0*/)
{
  return vk::SemaphoreCreateInfo{
    .flags=vk::SemaphoreCreateFlags(flags)
  };
}

VkCommandBufferBeginInfo vkinit::command_buffer_begin_info(VkCommandBufferUsageFlags flags /*= 0*/)
{
    return vk::CommandBufferBeginInfo{
      .flags=vk::CommandBufferUsageFlags(flags)
    };
}

VkImageSubresourceRange vkinit::image_subresource_range(VkImageAspectFlags aspectMask)
{
    return vk::ImageSubresourceRange{
      vk::ImageAspectFlags(aspectMask),
        0, VK_REMAINING_MIP_LEVELS, 0, VK_REMAINING_ARRAY_LAYERS
    };
}

VkSemaphoreSubmitInfo vkinit::semaphore_submit_info(VkPipelineStageFlags2 stageMask, VkSemaphore semaphore)
{
	return vk::SemaphoreSubmitInfo{
      .semaphore=vk::Semaphore{semaphore},
      .value=1,
      .stageMask=vk::PipelineStageFlags2{stageMask},
      .deviceIndex=0,
    };
}

VkCommandBufferSubmitInfo vkinit::command_buffer_submit_info(VkCommandBuffer cmd)
{
	return vk::CommandBufferSubmitInfo{
        .commandBuffer=cmd, // commandBuffer
        .deviceMask=0, // deviceMask
    };
}

VkSubmitInfo2 vkinit::submit_info(VkCommandBufferSubmitInfo* cmd, VkSemaphoreSubmitInfo* signalSemaphoreInfo,
    VkSemaphoreSubmitInfo* waitSemaphoreInfo)
{
    VkSubmitInfo2 info = {};
    info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO_2;
    info.pNext = nullptr;

    info.waitSemaphoreInfoCount = waitSemaphoreInfo == nullptr ? 0 : 1;
    info.pWaitSemaphoreInfos = waitSemaphoreInfo;

    info.signalSemaphoreInfoCount = signalSemaphoreInfo == nullptr ? 0 : 1;
    info.pSignalSemaphoreInfos = signalSemaphoreInfo;

    info.commandBufferInfoCount = 1;
    info.pCommandBufferInfos = cmd;

    return info;
}

VkImageCreateInfo vkinit::image_create_info(VkFormat format, VkImageUsageFlags usageFlags, VkExtent3D extent)
{
  return vk::ImageCreateInfo{
    .flags=vk::ImageCreateFlags(0),
    .imageType=vk::ImageType::e2D,
    .format=vk::Format{format},
    .extent=vk::Extent3D{extent.width, extent.height, extent.depth},
    .mipLevels=1,
    .arrayLayers=1,
    .samples=vk::SampleCountFlagBits::e1,
    .tiling=vk::ImageTiling::eOptimal,
    .usage=vk::ImageUsageFlags{usageFlags},
  };
}

VkImageViewCreateInfo vkinit::imageview_create_info(VkFormat format, VkImage image, VkImageAspectFlags aspectFlags)
{
  return vk::ImageViewCreateInfo{
    .image=image,
    .viewType=vk::ImageViewType::e2D,
    .format=vk::Format{format},
    .subresourceRange{
      .aspectMask=vk::ImageAspectFlags{aspectFlags},
      .baseMipLevel=0,
      .levelCount=1,
      .baseArrayLayer=0,
      .layerCount=1,
    }
  };
}

VkRenderingAttachmentInfo vkinit::attachment_info(
    VkImageView view, VkClearValue* clear ,VkImageLayout layout /*= VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL*/)
{
    vk::RenderingAttachmentInfo colorAttachment{
        .imageView=view,
        .imageLayout=vk::ImageLayout(layout),
        .loadOp=vk::AttachmentLoadOp(clear ? VK_ATTACHMENT_LOAD_OP_CLEAR : VK_ATTACHMENT_LOAD_OP_LOAD),
        .storeOp=vk::AttachmentStoreOp(VK_ATTACHMENT_STORE_OP_STORE),
    };

    if (clear) {
      vk::ArrayWrapper1D<float, 4> thefuckingcolor{{
        clear->color.float32[0],
        clear->color.float32[1],
        clear->color.float32[2],
        clear->color.float32[3],
      }};

      colorAttachment.clearValue = vk::ClearValue{
        .color = thefuckingcolor
      };
    }

    return colorAttachment;
}


VkRenderingInfo vkinit::rendering_info(VkExtent2D renderExtent, VkRenderingAttachmentInfo* colorAttachment,
    VkRenderingAttachmentInfo* depthAttachment)
{
    VkRenderingInfo renderInfo {};
    renderInfo.sType = VK_STRUCTURE_TYPE_RENDERING_INFO;
    renderInfo.pNext = nullptr;

    renderInfo.renderArea = VkRect2D { VkOffset2D { 0, 0 }, renderExtent };
    renderInfo.layerCount = 1;
    renderInfo.colorAttachmentCount = 1;
    renderInfo.pColorAttachments = colorAttachment;
    renderInfo.pDepthAttachment = depthAttachment;
    renderInfo.pStencilAttachment = nullptr;

    return renderInfo;
}