/*
 * Copyright 2022 Frederico de Oliveira Linhares
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "graphics_pipeline_3d_layout.hpp"

#include <array>

#include "../core.hpp"

namespace
{
void
load_descriptor_set_layout_world_view(void *obj)
{
  auto self = static_cast<VK::GraphicsPipeline3DLayout*>(obj);

  std::array<VkDescriptorSetLayoutBinding, 2> set_layouts{};
  set_layouts[0].binding = 0;
  set_layouts[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
  set_layouts[0].descriptorCount = 1;
  set_layouts[0].stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
  set_layouts[0].pImmutableSamplers = nullptr;

  set_layouts[1].binding = 1;
  set_layouts[1].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
  set_layouts[1].descriptorCount = 1;
  set_layouts[1].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
  set_layouts[1].pImmutableSamplers = nullptr;

  VkDescriptorSetLayoutCreateInfo layout_info{};
  layout_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
  layout_info.pNext = nullptr;
  layout_info.flags = 0;
  layout_info.bindingCount = set_layouts.size();
  layout_info.pBindings = set_layouts.data();

  if(vkCreateDescriptorSetLayout(
       cg_core.vk_device_with_swapchain->device, &layout_info, nullptr,
       &self->descriptor_set_world_view) != VK_SUCCESS)
    throw CommandError{
      "Failed to create Vulkan descriptor set layout for world view."};
}

void
unload_descriptor_set_layout_world_view(void *obj)
{
  auto self = static_cast<VK::GraphicsPipeline3DLayout*>(obj);

  vkDestroyDescriptorSetLayout(
    cg_core.vk_device_with_swapchain->device,
    self->descriptor_set_world_view, nullptr);
}

void
load_descriptor_set_layout_model_instance(void *obj)
{
  auto self = static_cast<VK::GraphicsPipeline3DLayout*>(obj);

  std::array<VkDescriptorSetLayoutBinding, 2> layout_bindings{};

  layout_bindings[0].binding = 0;
  layout_bindings[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
  layout_bindings[0].descriptorCount = 1;
  layout_bindings[0].stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
  layout_bindings[0].pImmutableSamplers = nullptr;

  layout_bindings[1].binding = 1;
  layout_bindings[1].descriptorType =
    VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
  layout_bindings[1].descriptorCount = 1;
  layout_bindings[1].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
  layout_bindings[1].pImmutableSamplers = nullptr;

  VkDescriptorSetLayoutCreateInfo layout_info{};
  layout_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
  layout_info.pNext = nullptr;
  layout_info.flags = 0;
  layout_info.bindingCount = static_cast<uint32_t>(layout_bindings.size());
  layout_info.pBindings = layout_bindings.data();

  if(vkCreateDescriptorSetLayout(
       cg_core.vk_device_with_swapchain->device, &layout_info, nullptr,
       &self->descriptor_set_model_instance) != VK_SUCCESS)
    throw CommandError{
      "Failed to create Vulkan descriptor set layout for model instance."};
}

void
unload_descriptor_set_layout_model_instance(void *obj)
{
  auto self = static_cast<VK::GraphicsPipeline3DLayout*>(obj);

  vkDestroyDescriptorSetLayout(
    cg_core.vk_device_with_swapchain->device,
    self->descriptor_set_model_instance, nullptr);
}

void
load_pipeline_layout(void *obj)
{
  auto self = static_cast<VK::GraphicsPipeline3DLayout*>(obj);

  std::array<VkDescriptorSetLayout, 2> set_layouts{
    self->descriptor_set_world_view,
    self->descriptor_set_model_instance};

  VkPipelineLayoutCreateInfo pipeline_layout_info{};
  pipeline_layout_info.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
  pipeline_layout_info.setLayoutCount = set_layouts.size();
  pipeline_layout_info.pSetLayouts = set_layouts.data();
  pipeline_layout_info.pushConstantRangeCount = 0;
  pipeline_layout_info.pPushConstantRanges = nullptr;

  if(vkCreatePipelineLayout(
       cg_core.vk_device_with_swapchain->device,
       &pipeline_layout_info, nullptr, &self->pipeline) != VK_SUCCESS)
    throw CommandError{"Failed to create Vulkan pipeline layout."};
}

void
unload_pipeline_layout(void *obj)
{
  auto self = static_cast<VK::GraphicsPipeline3DLayout*>(obj);

  vkDestroyPipelineLayout(
    cg_core.vk_device_with_swapchain->device, self->pipeline, nullptr);
}

void
load_render_pass(void *obj)
{
  auto self = static_cast<VK::GraphicsPipeline3DLayout*>(obj);

  std::array<VkAttachmentDescription, 2> attachments{};
  // Color attachment.
  attachments[0].flags = 0;
  attachments[0].format = cg_core.vk_swapchain->image_format;
  attachments[0].samples = VK_SAMPLE_COUNT_1_BIT;
  attachments[0].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
  attachments[0].storeOp = VK_ATTACHMENT_STORE_OP_STORE;
  attachments[0].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
  attachments[0].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
  attachments[0].initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
  attachments[0].finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
  // Depth attachment.
  attachments[1].flags = 0;
  attachments[1].format = VK_FORMAT_D32_SFLOAT;
  attachments[1].samples = VK_SAMPLE_COUNT_1_BIT;
  attachments[1].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
  attachments[1].storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
  attachments[1].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
  attachments[1].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
  attachments[1].initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
  attachments[1].finalLayout =
      VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;

  VkAttachmentReference color_attachment_ref{};
  color_attachment_ref.attachment = 0;
  color_attachment_ref.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
  VkAttachmentReference depth_attachment_ref{};
  depth_attachment_ref.attachment = 1;
  depth_attachment_ref.layout =
    VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;

  VkSubpassDescription subpass = {};
  subpass.flags = 0;
  subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
  subpass.inputAttachmentCount = 0;
  subpass.pInputAttachments = nullptr;
  subpass.colorAttachmentCount = 1;
  subpass.pColorAttachments = &color_attachment_ref;
  subpass.pResolveAttachments = nullptr;
  subpass.pDepthStencilAttachment = &depth_attachment_ref;
  subpass.preserveAttachmentCount = 0;
  subpass.pPreserveAttachments = nullptr;

  VkSubpassDependency dependency = {};
  dependency.srcSubpass = VK_SUBPASS_EXTERNAL;
  dependency.dstSubpass = 0;
  dependency.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT |
    VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
  dependency.srcAccessMask = 0;
  dependency.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT |
    VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
  dependency.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT |
    VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT |
    VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;

  VkRenderPassCreateInfo render_pass_info{};
  render_pass_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
  render_pass_info.pNext = nullptr;
  render_pass_info.flags = 0;
  render_pass_info.attachmentCount = attachments.size();
  render_pass_info.pAttachments = attachments.data();
  render_pass_info.subpassCount = 1;
  render_pass_info.pSubpasses = &subpass;
  render_pass_info.dependencyCount = 1;
  render_pass_info.pDependencies = &dependency;

  if(vkCreateRenderPass(
       cg_core.vk_device_with_swapchain->device, &render_pass_info, nullptr,
       &self->render_pass) != VK_SUCCESS)
    throw CommandError{"Failed to create Vulkan Render Pass 3D."};
}

void
unload_render_pass(void *obj)
{
  auto self = static_cast<VK::GraphicsPipeline3DLayout*>(obj);

  vkDestroyRenderPass(
    cg_core.vk_device_with_swapchain->device, self->render_pass, nullptr);
}

const CommandChain loader{
  {&load_descriptor_set_layout_world_view,
   &unload_descriptor_set_layout_world_view},
  {&load_descriptor_set_layout_model_instance,
   &unload_descriptor_set_layout_model_instance},
  {&load_pipeline_layout, &unload_pipeline_layout},
  {&load_render_pass, &unload_render_pass}
};

}

namespace VK
{

GraphicsPipeline3DLayout::GraphicsPipeline3DLayout()
{
  loader.execute(this);
}

GraphicsPipeline3DLayout::~GraphicsPipeline3DLayout()
{
  loader.revert(this);
}

}