// Copyright 2018 The Amber Authors.
//
// 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 "src/vulkan/graphics_pipeline.h"

#include <cassert>
#include <cmath>

#include "src/command.h"
#include "src/make_unique.h"
#include "src/vulkan/command_pool.h"
#include "src/vulkan/device.h"

namespace amber {
namespace vulkan {
namespace {

const VkAttachmentDescription kDefaultAttachmentDesc = {
    0,                                    /* flags */
    VK_FORMAT_UNDEFINED,                  /* format */
    VK_SAMPLE_COUNT_1_BIT,                /* samples */
    VK_ATTACHMENT_LOAD_OP_LOAD,           /* loadOp */
    VK_ATTACHMENT_STORE_OP_STORE,         /* storeOp */
    VK_ATTACHMENT_LOAD_OP_LOAD,           /* stencilLoadOp */
    VK_ATTACHMENT_STORE_OP_STORE,         /* stencilStoreOp */
    VK_IMAGE_LAYOUT_UNDEFINED,            /* initialLayout */
    VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, /* finalLayout */
};

const VkSampleMask kSampleMask = ~0U;

VkPrimitiveTopology ToVkTopology(Topology topology) {
  switch (topology) {
    case Topology::kPointList:
      return VK_PRIMITIVE_TOPOLOGY_POINT_LIST;
    case Topology::kLineList:
      return VK_PRIMITIVE_TOPOLOGY_LINE_LIST;
    case Topology::kLineStrip:
      return VK_PRIMITIVE_TOPOLOGY_LINE_STRIP;
    case Topology::kTriangleList:
      return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
    case Topology::kTriangleStrip:
      return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
    case Topology::kTriangleFan:
      return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN;
    case Topology::kLineListWithAdjacency:
      return VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY;
    case Topology::kLineStripWithAdjacency:
      return VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY;
    case Topology::kTriangleListWithAdjacency:
      return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY;
    case Topology::kTriangleStripWithAdjacency:
      return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY;
    case Topology::kPatchList:
      return VK_PRIMITIVE_TOPOLOGY_PATCH_LIST;
    default:
      break;
  }

  assert(false && "Vulkan::Unknown topology");
  return VK_PRIMITIVE_TOPOLOGY_POINT_LIST;
}

VkStencilOp ToVkStencilOp(StencilOp op) {
  switch (op) {
    case StencilOp::kKeep:
      return VK_STENCIL_OP_KEEP;
    case StencilOp::kZero:
      return VK_STENCIL_OP_ZERO;
    case StencilOp::kReplace:
      return VK_STENCIL_OP_REPLACE;
    case StencilOp::kIncrementAndClamp:
      return VK_STENCIL_OP_INCREMENT_AND_CLAMP;
    case StencilOp::kDecrementAndClamp:
      return VK_STENCIL_OP_DECREMENT_AND_CLAMP;
    case StencilOp::kInvert:
      return VK_STENCIL_OP_INVERT;
    case StencilOp::kIncrementAndWrap:
      return VK_STENCIL_OP_INCREMENT_AND_WRAP;
    case StencilOp::kDecrementAndWrap:
      return VK_STENCIL_OP_DECREMENT_AND_WRAP;
    case StencilOp::kUnknown:
      break;
  }
  assert(false && "Vulkan::Unknown StencilOp");
  return VK_STENCIL_OP_KEEP;
}

VkCompareOp ToVkCompareOp(CompareOp op) {
  switch (op) {
    case CompareOp::kNever:
      return VK_COMPARE_OP_NEVER;
    case CompareOp::kLess:
      return VK_COMPARE_OP_LESS;
    case CompareOp::kEqual:
      return VK_COMPARE_OP_EQUAL;
    case CompareOp::kLessOrEqual:
      return VK_COMPARE_OP_LESS_OR_EQUAL;
    case CompareOp::kGreater:
      return VK_COMPARE_OP_GREATER;
    case CompareOp::kNotEqual:
      return VK_COMPARE_OP_NOT_EQUAL;
    case CompareOp::kGreaterOrEqual:
      return VK_COMPARE_OP_GREATER_OR_EQUAL;
    case CompareOp::kAlways:
      return VK_COMPARE_OP_ALWAYS;
    case CompareOp::kUnknown:
      break;
  }
  assert(false && "Vulkan::Unknown CompareOp");
  return VK_COMPARE_OP_NEVER;
}

VkPolygonMode ToVkPolygonMode(PolygonMode mode) {
  switch (mode) {
    case PolygonMode::kFill:
      return VK_POLYGON_MODE_FILL;
    case PolygonMode::kLine:
      return VK_POLYGON_MODE_LINE;
    case PolygonMode::kPoint:
      return VK_POLYGON_MODE_POINT;
  }
  assert(false && "Vulkan::Unknown PolygonMode");
  return VK_POLYGON_MODE_FILL;
}

VkCullModeFlags ToVkCullMode(CullMode mode) {
  switch (mode) {
    case CullMode::kNone:
      return VK_CULL_MODE_NONE;
    case CullMode::kFront:
      return VK_CULL_MODE_FRONT_BIT;
    case CullMode::kBack:
      return VK_CULL_MODE_BACK_BIT;
    case CullMode::kFrontAndBack:
      return VK_CULL_MODE_FRONT_AND_BACK;
  }
  assert(false && "Vulkan::Unknown CullMode");
  return VK_CULL_MODE_NONE;
}

VkFrontFace ToVkFrontFace(FrontFace front_face) {
  return front_face == FrontFace::kClockwise ? VK_FRONT_FACE_CLOCKWISE
                                             : VK_FRONT_FACE_COUNTER_CLOCKWISE;
}

VkLogicOp ToVkLogicOp(LogicOp op) {
  switch (op) {
    case LogicOp::kClear:
      return VK_LOGIC_OP_CLEAR;
    case LogicOp::kAnd:
      return VK_LOGIC_OP_AND;
    case LogicOp::kAndReverse:
      return VK_LOGIC_OP_AND_REVERSE;
    case LogicOp::kCopy:
      return VK_LOGIC_OP_COPY;
    case LogicOp::kAndInverted:
      return VK_LOGIC_OP_AND_INVERTED;
    case LogicOp::kNoOp:
      return VK_LOGIC_OP_NO_OP;
    case LogicOp::kXor:
      return VK_LOGIC_OP_XOR;
    case LogicOp::kOr:
      return VK_LOGIC_OP_OR;
    case LogicOp::kNor:
      return VK_LOGIC_OP_NOR;
    case LogicOp::kEquivalent:
      return VK_LOGIC_OP_EQUIVALENT;
    case LogicOp::kInvert:
      return VK_LOGIC_OP_INVERT;
    case LogicOp::kOrReverse:
      return VK_LOGIC_OP_OR_REVERSE;
    case LogicOp::kCopyInverted:
      return VK_LOGIC_OP_COPY_INVERTED;
    case LogicOp::kOrInverted:
      return VK_LOGIC_OP_OR_INVERTED;
    case LogicOp::kNand:
      return VK_LOGIC_OP_NAND;
    case LogicOp::kSet:
      return VK_LOGIC_OP_SET;
  }
  assert(false && "Vulkan::Unknown LogicOp");
  return VK_LOGIC_OP_CLEAR;
}

VkBlendFactor ToVkBlendFactor(BlendFactor factor) {
  switch (factor) {
    case BlendFactor::kZero:
      return VK_BLEND_FACTOR_ZERO;
    case BlendFactor::kOne:
      return VK_BLEND_FACTOR_ONE;
    case BlendFactor::kSrcColor:
      return VK_BLEND_FACTOR_SRC_COLOR;
    case BlendFactor::kOneMinusSrcColor:
      return VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR;
    case BlendFactor::kDstColor:
      return VK_BLEND_FACTOR_DST_COLOR;
    case BlendFactor::kOneMinusDstColor:
      return VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR;
    case BlendFactor::kSrcAlpha:
      return VK_BLEND_FACTOR_SRC_ALPHA;
    case BlendFactor::kOneMinusSrcAlpha:
      return VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
    case BlendFactor::kDstAlpha:
      return VK_BLEND_FACTOR_DST_ALPHA;
    case BlendFactor::kOneMinusDstAlpha:
      return VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA;
    case BlendFactor::kConstantColor:
      return VK_BLEND_FACTOR_CONSTANT_COLOR;
    case BlendFactor::kOneMinusConstantColor:
      return VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR;
    case BlendFactor::kConstantAlpha:
      return VK_BLEND_FACTOR_CONSTANT_ALPHA;
    case BlendFactor::kOneMinusConstantAlpha:
      return VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA;
    case BlendFactor::kSrcAlphaSaturate:
      return VK_BLEND_FACTOR_SRC_ALPHA_SATURATE;
    case BlendFactor::kSrc1Color:
      return VK_BLEND_FACTOR_SRC1_COLOR;
    case BlendFactor::kOneMinusSrc1Color:
      return VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR;
    case BlendFactor::kSrc1Alpha:
      return VK_BLEND_FACTOR_SRC1_ALPHA;
    case BlendFactor::kOneMinusSrc1Alpha:
      return VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA;
    case BlendFactor::kUnknown:
      break;
  }
  assert(false && "Vulkan::Unknown BlendFactor");
  return VK_BLEND_FACTOR_ZERO;
}

VkBlendOp ToVkBlendOp(BlendOp op) {
  switch (op) {
    case BlendOp::kAdd:
      return VK_BLEND_OP_ADD;
    case BlendOp::kSubtract:
      return VK_BLEND_OP_SUBTRACT;
    case BlendOp::kReverseSubtract:
      return VK_BLEND_OP_REVERSE_SUBTRACT;
    case BlendOp::kMin:
      return VK_BLEND_OP_MIN;
    case BlendOp::kMax:
      return VK_BLEND_OP_MAX;
    case BlendOp::kZero:
      return VK_BLEND_OP_ZERO_EXT;
    case BlendOp::kSrc:
      return VK_BLEND_OP_SRC_EXT;
    case BlendOp::kDst:
      return VK_BLEND_OP_DST_EXT;
    case BlendOp::kSrcOver:
      return VK_BLEND_OP_SRC_OVER_EXT;
    case BlendOp::kDstOver:
      return VK_BLEND_OP_DST_OVER_EXT;
    case BlendOp::kSrcIn:
      return VK_BLEND_OP_SRC_IN_EXT;
    case BlendOp::kDstIn:
      return VK_BLEND_OP_DST_IN_EXT;
    case BlendOp::kSrcOut:
      return VK_BLEND_OP_SRC_OUT_EXT;
    case BlendOp::kDstOut:
      return VK_BLEND_OP_DST_OUT_EXT;
    case BlendOp::kSrcAtop:
      return VK_BLEND_OP_SRC_ATOP_EXT;
    case BlendOp::kDstAtop:
      return VK_BLEND_OP_DST_ATOP_EXT;
    case BlendOp::kXor:
      return VK_BLEND_OP_XOR_EXT;
    case BlendOp::kMultiply:
      return VK_BLEND_OP_MULTIPLY_EXT;
    case BlendOp::kScreen:
      return VK_BLEND_OP_SCREEN_EXT;
    case BlendOp::kOverlay:
      return VK_BLEND_OP_OVERLAY_EXT;
    case BlendOp::kDarken:
      return VK_BLEND_OP_DARKEN_EXT;
    case BlendOp::kLighten:
      return VK_BLEND_OP_LIGHTEN_EXT;
    case BlendOp::kColorDodge:
      return VK_BLEND_OP_COLORDODGE_EXT;
    case BlendOp::kColorBurn:
      return VK_BLEND_OP_COLORBURN_EXT;
    case BlendOp::kHardLight:
      return VK_BLEND_OP_HARDLIGHT_EXT;
    case BlendOp::kSoftLight:
      return VK_BLEND_OP_SOFTLIGHT_EXT;
    case BlendOp::kDifference:
      return VK_BLEND_OP_DIFFERENCE_EXT;
    case BlendOp::kExclusion:
      return VK_BLEND_OP_EXCLUSION_EXT;
    case BlendOp::kInvert:
      return VK_BLEND_OP_INVERT_EXT;
    case BlendOp::kInvertRGB:
      return VK_BLEND_OP_INVERT_RGB_EXT;
    case BlendOp::kLinearDodge:
      return VK_BLEND_OP_LINEARDODGE_EXT;
    case BlendOp::kLinearBurn:
      return VK_BLEND_OP_LINEARBURN_EXT;
    case BlendOp::kVividLight:
      return VK_BLEND_OP_VIVIDLIGHT_EXT;
    case BlendOp::kLinearLight:
      return VK_BLEND_OP_LINEARLIGHT_EXT;
    case BlendOp::kPinLight:
      return VK_BLEND_OP_PINLIGHT_EXT;
    case BlendOp::kHardMix:
      return VK_BLEND_OP_HARDMIX_EXT;
    case BlendOp::kHslHue:
      return VK_BLEND_OP_HSL_HUE_EXT;
    case BlendOp::kHslSaturation:
      return VK_BLEND_OP_HSL_SATURATION_EXT;
    case BlendOp::kHslColor:
      return VK_BLEND_OP_HSL_COLOR_EXT;
    case BlendOp::kHslLuminosity:
      return VK_BLEND_OP_HSL_LUMINOSITY_EXT;
    case BlendOp::kPlus:
      return VK_BLEND_OP_PLUS_EXT;
    case BlendOp::kPlusClamped:
      return VK_BLEND_OP_PLUS_CLAMPED_EXT;
    case BlendOp::kPlusClampedAlpha:
      return VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT;
    case BlendOp::kPlusDarker:
      return VK_BLEND_OP_PLUS_DARKER_EXT;
    case BlendOp::kMinus:
      return VK_BLEND_OP_MINUS_EXT;
    case BlendOp::kMinusClamped:
      return VK_BLEND_OP_MINUS_CLAMPED_EXT;
    case BlendOp::kContrast:
      return VK_BLEND_OP_CONTRAST_EXT;
    case BlendOp::kInvertOvg:
      return VK_BLEND_OP_INVERT_OVG_EXT;
    case BlendOp::kRed:
      return VK_BLEND_OP_RED_EXT;
    case BlendOp::kGreen:
      return VK_BLEND_OP_GREEN_EXT;
    case BlendOp::kBlue:
      return VK_BLEND_OP_BLUE_EXT;
    case BlendOp::kUnknown:
      break;
  }
  assert(false && "Vulkan::Unknown BlendOp");
  return VK_BLEND_OP_ADD;
}

class RenderPassGuard {
 public:
  explicit RenderPassGuard(GraphicsPipeline* pipeline) : pipeline_(pipeline) {
    auto* frame = pipeline_->GetFrameBuffer();
    auto* cmd = pipeline_->GetCommandBuffer();
    frame->ChangeFrameToDrawLayout(cmd);

    VkRenderPassBeginInfo render_begin_info = VkRenderPassBeginInfo();
    render_begin_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
    render_begin_info.renderPass = pipeline_->GetVkRenderPass();
    render_begin_info.framebuffer = frame->GetVkFrameBuffer();
    render_begin_info.renderArea = {{0, 0},
                                    {frame->GetWidth(), frame->GetHeight()}};
    pipeline_->GetDevice()->GetPtrs()->vkCmdBeginRenderPass(
        cmd->GetVkCommandBuffer(), &render_begin_info,
        VK_SUBPASS_CONTENTS_INLINE);
  }

  ~RenderPassGuard() {
    auto* cmd = pipeline_->GetCommandBuffer();

    pipeline_->GetDevice()->GetPtrs()->vkCmdEndRenderPass(
        cmd->GetVkCommandBuffer());

    auto* frame = pipeline_->GetFrameBuffer();
    frame->ChangeFrameToProbeLayout(cmd);
  }

 private:
  GraphicsPipeline* pipeline_;
};

}  // namespace

GraphicsPipeline::GraphicsPipeline(
    Device* device,
    const std::vector<amber::Pipeline::BufferInfo>& color_buffers,
    amber::Pipeline::BufferInfo depth_stencil_buffer,
    const std::vector<amber::Pipeline::BufferInfo>& resolve_targets,
    uint32_t fence_timeout_ms,
    bool pipeline_runtime_layer_enabled,
    const std::vector<VkPipelineShaderStageCreateInfo>& shader_stage_info)
    : Pipeline(PipelineType::kGraphics,
               device,
               fence_timeout_ms,
               pipeline_runtime_layer_enabled,
               shader_stage_info),
      depth_stencil_buffer_(depth_stencil_buffer) {
  for (const auto& info : color_buffers)
    color_buffers_.push_back(&info);
  for (const auto& info : resolve_targets)
    resolve_targets_.push_back(&info);
}

GraphicsPipeline::~GraphicsPipeline() {
  if (render_pass_) {
    device_->GetPtrs()->vkDestroyRenderPass(device_->GetVkDevice(),
                                            render_pass_, nullptr);
  }
}

Result GraphicsPipeline::CreateRenderPass() {
  VkSubpassDescription subpass_desc = VkSubpassDescription();
  subpass_desc.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;

  std::vector<VkAttachmentDescription> attachment_desc;

  std::vector<VkAttachmentReference> color_refer;
  VkAttachmentReference depth_refer = VkAttachmentReference();
  std::vector<VkAttachmentReference> resolve_refer;

  for (const auto* info : color_buffers_) {
    attachment_desc.push_back(kDefaultAttachmentDesc);
    attachment_desc.back().format =
        device_->GetVkFormat(*info->buffer->GetFormat());
    attachment_desc.back().initialLayout =
        VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
    attachment_desc.back().finalLayout =
        VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
    attachment_desc.back().samples =
        static_cast<VkSampleCountFlagBits>(info->buffer->GetSamples());

    VkAttachmentReference ref = VkAttachmentReference();
    ref.attachment = static_cast<uint32_t>(attachment_desc.size() - 1);
    ref.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
    color_refer.push_back(ref);
  }
  subpass_desc.colorAttachmentCount = static_cast<uint32_t>(color_refer.size());
  subpass_desc.pColorAttachments = color_refer.data();

  if (depth_stencil_buffer_.buffer &&
      depth_stencil_buffer_.buffer->GetFormat()->IsFormatKnown()) {
    attachment_desc.push_back(kDefaultAttachmentDesc);
    attachment_desc.back().format =
        device_->GetVkFormat(*depth_stencil_buffer_.buffer->GetFormat());
    attachment_desc.back().initialLayout =
        VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
    attachment_desc.back().finalLayout =
        VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;

    depth_refer.attachment = static_cast<uint32_t>(attachment_desc.size() - 1);
    depth_refer.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;

    subpass_desc.pDepthStencilAttachment = &depth_refer;
  }

  for (const auto* info : resolve_targets_) {
    attachment_desc.push_back(kDefaultAttachmentDesc);
    attachment_desc.back().format =
        device_->GetVkFormat(*info->buffer->GetFormat());
    attachment_desc.back().initialLayout =
        VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
    attachment_desc.back().finalLayout =
        VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;

    VkAttachmentReference ref = VkAttachmentReference();
    ref.attachment = static_cast<uint32_t>(attachment_desc.size() - 1);
    ref.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
    resolve_refer.push_back(ref);
  }

  subpass_desc.pResolveAttachments = resolve_refer.data();

  VkRenderPassCreateInfo render_pass_info = VkRenderPassCreateInfo();
  render_pass_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
  render_pass_info.attachmentCount =
      static_cast<uint32_t>(attachment_desc.size());
  render_pass_info.pAttachments = attachment_desc.data();
  render_pass_info.subpassCount = 1;
  render_pass_info.pSubpasses = &subpass_desc;

  if (device_->GetPtrs()->vkCreateRenderPass(device_->GetVkDevice(),
                                             &render_pass_info, nullptr,
                                             &render_pass_) != VK_SUCCESS) {
    return Result("Vulkan::Calling vkCreateRenderPass Fail");
  }

  return {};
}

VkPipelineDepthStencilStateCreateInfo
GraphicsPipeline::GetVkPipelineDepthStencilInfo(
    const PipelineData* pipeline_data) {
  VkPipelineDepthStencilStateCreateInfo depthstencil_info =
      VkPipelineDepthStencilStateCreateInfo();
  depthstencil_info.sType =
      VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;

  depthstencil_info.depthTestEnable = pipeline_data->GetEnableDepthTest();
  depthstencil_info.depthWriteEnable = pipeline_data->GetEnableDepthWrite();
  depthstencil_info.depthCompareOp =
      ToVkCompareOp(pipeline_data->GetDepthCompareOp());
  depthstencil_info.depthBoundsTestEnable =
      pipeline_data->GetEnableDepthBoundsTest();
  depthstencil_info.stencilTestEnable = pipeline_data->GetEnableStencilTest();

  depthstencil_info.front.failOp =
      ToVkStencilOp(pipeline_data->GetFrontFailOp());
  depthstencil_info.front.passOp =
      ToVkStencilOp(pipeline_data->GetFrontPassOp());
  depthstencil_info.front.depthFailOp =
      ToVkStencilOp(pipeline_data->GetFrontDepthFailOp());
  depthstencil_info.front.compareOp =
      ToVkCompareOp(pipeline_data->GetFrontCompareOp());
  depthstencil_info.front.compareMask = pipeline_data->GetFrontCompareMask();
  depthstencil_info.front.writeMask = pipeline_data->GetFrontWriteMask();
  depthstencil_info.front.reference = pipeline_data->GetFrontReference();

  depthstencil_info.back.failOp = ToVkStencilOp(pipeline_data->GetBackFailOp());
  depthstencil_info.back.passOp = ToVkStencilOp(pipeline_data->GetBackPassOp());
  depthstencil_info.back.depthFailOp =
      ToVkStencilOp(pipeline_data->GetBackDepthFailOp());
  depthstencil_info.back.compareOp =
      ToVkCompareOp(pipeline_data->GetBackCompareOp());
  depthstencil_info.back.compareMask = pipeline_data->GetBackCompareMask();
  depthstencil_info.back.writeMask = pipeline_data->GetBackWriteMask();
  depthstencil_info.back.reference = pipeline_data->GetBackReference();

  depthstencil_info.minDepthBounds = pipeline_data->GetMinDepthBounds();
  depthstencil_info.maxDepthBounds = pipeline_data->GetMaxDepthBounds();

  return depthstencil_info;
}

std::vector<VkPipelineColorBlendAttachmentState>
GraphicsPipeline::GetVkPipelineColorBlendAttachmentState(
    const PipelineData* pipeline_data) {
  std::vector<VkPipelineColorBlendAttachmentState> states;

  for (size_t i = 0; i < color_buffers_.size(); ++i) {
    VkPipelineColorBlendAttachmentState colorblend_attachment =
        VkPipelineColorBlendAttachmentState();
    colorblend_attachment.blendEnable = pipeline_data->GetEnableBlend();
    colorblend_attachment.srcColorBlendFactor =
        ToVkBlendFactor(pipeline_data->GetSrcColorBlendFactor());
    colorblend_attachment.dstColorBlendFactor =
        ToVkBlendFactor(pipeline_data->GetDstColorBlendFactor());
    colorblend_attachment.colorBlendOp =
        ToVkBlendOp(pipeline_data->GetColorBlendOp());
    colorblend_attachment.srcAlphaBlendFactor =
        ToVkBlendFactor(pipeline_data->GetSrcAlphaBlendFactor());
    colorblend_attachment.dstAlphaBlendFactor =
        ToVkBlendFactor(pipeline_data->GetDstAlphaBlendFactor());
    colorblend_attachment.alphaBlendOp =
        ToVkBlendOp(pipeline_data->GetAlphaBlendOp());
    colorblend_attachment.colorWriteMask = pipeline_data->GetColorWriteMask();
    states.push_back(colorblend_attachment);
  }
  return states;
}

Result GraphicsPipeline::CreateVkGraphicsPipeline(
    const PipelineData* pipeline_data,
    VkPrimitiveTopology topology,
    const VertexBuffer* vertex_buffer,
    const VkPipelineLayout& pipeline_layout,
    VkPipeline* pipeline) {
  if (!pipeline_data) {
    return Result(
        "Vulkan: GraphicsPipeline::CreateVkGraphicsPipeline PipelineData is "
        "null");
  }

  std::vector<VkVertexInputBindingDescription> vertex_bindings;
  std::vector<VkVertexInputAttributeDescription> vertex_attribs;
  if (vertex_buffer != nullptr) {
    vertex_bindings = vertex_buffer->GetVkVertexInputBinding();
    vertex_attribs = vertex_buffer->GetVkVertexInputAttr();
  }

  VkPipelineVertexInputStateCreateInfo vertex_input_info =
      VkPipelineVertexInputStateCreateInfo();
  vertex_input_info.sType =
      VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
  vertex_input_info.vertexBindingDescriptionCount =
      static_cast<uint32_t>(vertex_bindings.size());
  vertex_input_info.pVertexBindingDescriptions =
      vertex_bindings.empty() ? nullptr : vertex_bindings.data();
  vertex_input_info.vertexAttributeDescriptionCount =
      static_cast<uint32_t>(vertex_attribs.size());
  vertex_input_info.pVertexAttributeDescriptions =
      vertex_attribs.empty() ? nullptr : vertex_attribs.data();

  VkPipelineInputAssemblyStateCreateInfo input_assembly_info =
      VkPipelineInputAssemblyStateCreateInfo();
  input_assembly_info.sType =
      VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
  // TODO(jaebaek): Handle the given index if exists.
  input_assembly_info.topology = topology;
  input_assembly_info.primitiveRestartEnable =
      pipeline_data->GetEnablePrimitiveRestart();

  VkViewport viewport = {
      0, 0, static_cast<float>(frame_width_), static_cast<float>(frame_height_),
      0, 1};

  if (pipeline_data->HasViewportData()) {
    Viewport vp = pipeline_data->GetViewport();
    viewport.x = vp.x;
    viewport.y = vp.y;
    viewport.width = vp.w;
    viewport.height = vp.h;
    viewport.minDepth = vp.mind;
    viewport.maxDepth = vp.maxd;
  }

  VkRect2D scissor = {{0, 0}, {frame_width_, frame_height_}};

  VkPipelineViewportStateCreateInfo viewport_info =
      VkPipelineViewportStateCreateInfo();
  viewport_info.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
  viewport_info.viewportCount = 1;
  viewport_info.pViewports = &viewport;
  viewport_info.scissorCount = 1;
  viewport_info.pScissors = &scissor;

  auto shader_stage_info = GetVkShaderStageInfo();
  bool is_tessellation_needed = false;
  for (auto& info : shader_stage_info) {
    info.pName = GetEntryPointName(info.stage);
    if (info.stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT ||
        info.stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT) {
      is_tessellation_needed = true;
    }
  }

  VkPipelineMultisampleStateCreateInfo multisampleInfo = {
      VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, /* sType */
      nullptr,                                                  /* pNext */
      0,                                                        /* flags */
      kDefaultAttachmentDesc.samples, /* rasterizationSamples */
      VK_FALSE,                       /* sampleShadingEnable */
      0,                              /* minSampleShading */
      &kSampleMask,                   /* pSampleMask */
      VK_FALSE,                       /* alphaToCoverageEnable */
      VK_FALSE,                       /* alphaToOneEnable */
  };

  // Search for multisampled color buffers and adjust the rasterization samples
  // to match.
  for (const auto& cb : color_buffers_) {
    uint32_t samples = cb->buffer->GetSamples();
    assert(static_cast<VkSampleCountFlagBits>(samples) >=
           multisampleInfo.rasterizationSamples);
    multisampleInfo.rasterizationSamples =
        static_cast<VkSampleCountFlagBits>(samples);
  }

  VkGraphicsPipelineCreateInfo pipeline_info = VkGraphicsPipelineCreateInfo();
  pipeline_info.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
  pipeline_info.stageCount = static_cast<uint32_t>(shader_stage_info.size());
  pipeline_info.pStages = shader_stage_info.data();
  pipeline_info.pVertexInputState = &vertex_input_info;
  pipeline_info.pInputAssemblyState = &input_assembly_info;
  pipeline_info.pViewportState = &viewport_info;
  pipeline_info.pMultisampleState = &multisampleInfo;

  VkPipelineRasterizationStateCreateInfo rasterization_info =
      VkPipelineRasterizationStateCreateInfo();
  rasterization_info.sType =
      VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
  rasterization_info.depthClampEnable = pipeline_data->GetEnableDepthClamp();
  rasterization_info.rasterizerDiscardEnable =
      pipeline_data->GetEnableRasterizerDiscard();
  rasterization_info.polygonMode =
      ToVkPolygonMode(pipeline_data->GetPolygonMode());
  rasterization_info.cullMode = ToVkCullMode(pipeline_data->GetCullMode());
  rasterization_info.frontFace = ToVkFrontFace(pipeline_data->GetFrontFace());
  rasterization_info.depthBiasEnable = pipeline_data->GetEnableDepthBias();
  rasterization_info.depthBiasConstantFactor =
      pipeline_data->GetDepthBiasConstantFactor();
  rasterization_info.depthBiasClamp = pipeline_data->GetDepthBiasClamp();
  rasterization_info.depthBiasSlopeFactor =
      pipeline_data->GetDepthBiasSlopeFactor();
  rasterization_info.lineWidth = pipeline_data->GetLineWidth();
  pipeline_info.pRasterizationState = &rasterization_info;

  VkPipelineTessellationStateCreateInfo tess_info =
      VkPipelineTessellationStateCreateInfo();
  if (is_tessellation_needed) {
    tess_info.sType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO;
    tess_info.patchControlPoints = patch_control_points_;
    pipeline_info.pTessellationState = &tess_info;
  }

  VkPipelineDepthStencilStateCreateInfo depthstencil_info;
  if (depth_stencil_buffer_.buffer &&
      depth_stencil_buffer_.buffer->GetFormat()->IsFormatKnown()) {
    depthstencil_info = GetVkPipelineDepthStencilInfo(pipeline_data);
    pipeline_info.pDepthStencilState = &depthstencil_info;
  }

  VkPipelineColorBlendStateCreateInfo colorblend_info =
      VkPipelineColorBlendStateCreateInfo();

  auto colorblend_attachment =
      GetVkPipelineColorBlendAttachmentState(pipeline_data);

  colorblend_info.sType =
      VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
  colorblend_info.logicOpEnable = pipeline_data->GetEnableLogicOp();
  colorblend_info.logicOp = ToVkLogicOp(pipeline_data->GetLogicOp());
  colorblend_info.attachmentCount =
      static_cast<uint32_t>(colorblend_attachment.size());
  colorblend_info.pAttachments = colorblend_attachment.data();
  pipeline_info.pColorBlendState = &colorblend_info;

  pipeline_info.layout = pipeline_layout;
  pipeline_info.renderPass = render_pass_;
  pipeline_info.subpass = 0;

  if (device_->GetPtrs()->vkCreateGraphicsPipelines(
          device_->GetVkDevice(), VK_NULL_HANDLE, 1, &pipeline_info, nullptr,
          pipeline) != VK_SUCCESS) {
    return Result("Vulkan::Calling vkCreateGraphicsPipelines Fail");
  }

  return {};
}

Result GraphicsPipeline::Initialize(uint32_t width,
                                    uint32_t height,
                                    CommandPool* pool) {
  Result r = Pipeline::Initialize(pool);
  if (!r.IsSuccess())
    return r;

  r = CreateRenderPass();
  if (!r.IsSuccess())
    return r;

  frame_ =
      MakeUnique<FrameBuffer>(device_, color_buffers_, depth_stencil_buffer_,
                              resolve_targets_, width, height);
  r = frame_->Initialize(render_pass_);
  if (!r.IsSuccess())
    return r;

  frame_width_ = width;
  frame_height_ = height;

  return {};
}

Result GraphicsPipeline::SendVertexBufferDataIfNeeded(
    VertexBuffer* vertex_buffer) {
  if (!vertex_buffer || vertex_buffer->VertexDataSent())
    return {};
  return vertex_buffer->SendVertexData(command_.get());
}

Result GraphicsPipeline::SetIndexBuffer(Buffer* buffer) {
  if (index_buffer_) {
    return Result(
        "GraphicsPipeline::SetIndexBuffer must be called once when "
        "index_buffer_ is created");
  }

  index_buffer_ = MakeUnique<IndexBuffer>(device_);

  CommandBufferGuard guard(GetCommandBuffer());
  if (!guard.IsRecording())
    return guard.GetResult();

  Result r = index_buffer_->SendIndexData(command_.get(), buffer);
  if (!r.IsSuccess())
    return r;

  return guard.Submit(GetFenceTimeout(), GetPipelineRuntimeLayerEnabled());
}

Result GraphicsPipeline::SetClearColor(float r, float g, float b, float a) {
  clear_color_r_ = r;
  clear_color_g_ = g;
  clear_color_b_ = b;
  clear_color_a_ = a;
  return {};
}

Result GraphicsPipeline::SetClearStencil(uint32_t stencil) {
  if (!depth_stencil_buffer_.buffer ||
      !depth_stencil_buffer_.buffer->GetFormat()->IsFormatKnown()) {
    return Result(
        "Vulkan::ClearStencilCommand No DepthStencil Buffer for FrameBuffer "
        "Exists");
  }

  clear_stencil_ = stencil;
  return {};
}

Result GraphicsPipeline::SetClearDepth(float depth) {
  if (!depth_stencil_buffer_.buffer ||
      !depth_stencil_buffer_.buffer->GetFormat()->IsFormatKnown()) {
    return Result(
        "Vulkan::ClearStencilCommand No DepthStencil Buffer for FrameBuffer "
        "Exists");
  }

  clear_depth_ = depth;
  return {};
}

Result GraphicsPipeline::Clear() {
  VkClearValue colour_clear;
  colour_clear.color = {
      {clear_color_r_, clear_color_g_, clear_color_b_, clear_color_a_}};

  CommandBufferGuard cmd_buf_guard(GetCommandBuffer());
  if (!cmd_buf_guard.IsRecording())
    return cmd_buf_guard.GetResult();

  frame_->ChangeFrameToWriteLayout(GetCommandBuffer());
  frame_->CopyBuffersToImages();
  frame_->TransferImagesToDevice(GetCommandBuffer());

  {
    RenderPassGuard render_pass_guard(this);

    std::vector<VkClearAttachment> clears;
    for (size_t i = 0; i < color_buffers_.size(); ++i) {
      VkClearAttachment clear_attachment = VkClearAttachment();
      clear_attachment.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
      clear_attachment.colorAttachment = static_cast<uint32_t>(i);
      clear_attachment.clearValue = colour_clear;

      clears.push_back(clear_attachment);
    }

    if (depth_stencil_buffer_.buffer &&
        depth_stencil_buffer_.buffer->GetFormat()->IsFormatKnown()) {
      VkClearValue depth_stencil_clear;
      depth_stencil_clear.depthStencil = {clear_depth_, clear_stencil_};

      VkImageAspectFlags aspect = VK_IMAGE_ASPECT_DEPTH_BIT;
      if (depth_stencil_buffer_.buffer->GetFormat()->HasStencilComponent())
        aspect |= VK_IMAGE_ASPECT_STENCIL_BIT;

      VkClearAttachment clear_attachment = VkClearAttachment();
      clear_attachment.aspectMask = aspect;
      clear_attachment.colorAttachment =
          static_cast<uint32_t>(color_buffers_.size());
      clear_attachment.clearValue = depth_stencil_clear;

      clears.push_back(clear_attachment);
    }

    VkClearRect clear_rect;
    clear_rect.rect = {{0, 0}, {frame_width_, frame_height_}};
    clear_rect.baseArrayLayer = 0;
    clear_rect.layerCount = 1;

    device_->GetPtrs()->vkCmdClearAttachments(
        command_->GetVkCommandBuffer(), static_cast<uint32_t>(clears.size()),
        clears.data(), 1, &clear_rect);
  }

  frame_->TransferImagesToHost(command_.get());

  Result r = cmd_buf_guard.Submit(GetFenceTimeout(),
                                  GetPipelineRuntimeLayerEnabled());
  if (!r.IsSuccess())
    return r;

  frame_->CopyImagesToBuffers();
  return {};
}

Result GraphicsPipeline::Draw(const DrawArraysCommand* command,
                              VertexBuffer* vertex_buffer) {
  Result r = SendDescriptorDataToDeviceIfNeeded();
  if (!r.IsSuccess())
    return r;

  VkPipelineLayout pipeline_layout = VK_NULL_HANDLE;
  r = CreateVkPipelineLayout(&pipeline_layout);
  if (!r.IsSuccess())
    return r;

  VkPipeline pipeline = VK_NULL_HANDLE;
  r = CreateVkGraphicsPipeline(command->GetPipelineData(),
                               ToVkTopology(command->GetTopology()),
                               vertex_buffer, pipeline_layout, &pipeline);
  if (!r.IsSuccess())
    return r;

  // Note that a command updating a descriptor set and a command using
  // it must be submitted separately, because using a descriptor set
  // while updating it is not safe.
  UpdateDescriptorSetsIfNeeded();

  {
    CommandBufferGuard cmd_buf_guard(GetCommandBuffer());
    if (!cmd_buf_guard.IsRecording())
      return cmd_buf_guard.GetResult();

    r = SendVertexBufferDataIfNeeded(vertex_buffer);
    if (!r.IsSuccess())
      return r;

    frame_->ChangeFrameToWriteLayout(GetCommandBuffer());
    frame_->CopyBuffersToImages();
    frame_->TransferImagesToDevice(GetCommandBuffer());

    {
      RenderPassGuard render_pass_guard(this);

      BindVkDescriptorSets(pipeline_layout);

      r = RecordPushConstant(pipeline_layout);
      if (!r.IsSuccess())
        return r;

      device_->GetPtrs()->vkCmdBindPipeline(command_->GetVkCommandBuffer(),
                                            VK_PIPELINE_BIND_POINT_GRAPHICS,
                                            pipeline);

      if (vertex_buffer != nullptr)
        vertex_buffer->BindToCommandBuffer(command_.get());

      if (command->IsIndexed()) {
        if (!index_buffer_)
          return Result("Vulkan: Draw indexed is used without given indices");

        r = index_buffer_->BindToCommandBuffer(command_.get());
        if (!r.IsSuccess())
          return r;

        // VkRunner spec says
        //   "vertexCount will be used as the index count, firstVertex
        //    becomes the vertex offset and firstIndex will always be zero."
        device_->GetPtrs()->vkCmdDrawIndexed(
            command_->GetVkCommandBuffer(),
            command->GetVertexCount(),   /* indexCount */
            command->GetInstanceCount(), /* instanceCount */
            0,                           /* firstIndex */
            static_cast<int32_t>(
                command->GetFirstVertexIndex()), /* vertexOffset */
            command->GetFirstInstance());        /* firstInstance */
      } else {
        device_->GetPtrs()->vkCmdDraw(
            command_->GetVkCommandBuffer(), command->GetVertexCount(),
            command->GetInstanceCount(), command->GetFirstVertexIndex(),
            command->GetFirstInstance());
      }
    }

    frame_->TransferImagesToHost(command_.get());

    r = cmd_buf_guard.Submit(GetFenceTimeout(),
                             GetPipelineRuntimeLayerEnabled());
    if (!r.IsSuccess())
      return r;
  }

  r = ReadbackDescriptorsToHostDataQueue();
  if (!r.IsSuccess())
    return r;

  frame_->CopyImagesToBuffers();

  device_->GetPtrs()->vkDestroyPipeline(device_->GetVkDevice(), pipeline,
                                        nullptr);
  device_->GetPtrs()->vkDestroyPipelineLayout(device_->GetVkDevice(),
                                              pipeline_layout, nullptr);
  return {};
}

}  // namespace vulkan
}  // namespace amber