#include <fstream>
#include <shaderc/shaderc.hpp>
#include <iostream>

#include "vulkan.hpp"

namespace vk {

template<typename T>
class defer {
public:
    defer(const T& t) : ft(t) {}
    ~defer() { ft(); }
    T ft;
};

class PhysicalDeviceImpl : public PhysicalDevice {
public:
    PhysicalDeviceImpl(VkPhysicalDevice handle) : physical_device(handle) {
        vkGetPhysicalDeviceProperties(handle, &props);
        vkGetPhysicalDeviceMemoryProperties(handle, &mem_props);
        uint32_t extension_count = 0;
        vkEnumerateDeviceExtensionProperties(handle, nullptr, &extension_count, nullptr);
        rs::vector<VkExtensionProperties> extension_props(extension_count);
        vkEnumerateDeviceExtensionProperties(handle, nullptr, &extension_count, extension_props.data());
        uint32_t queue_family_count = 0;
        vkGetPhysicalDeviceQueueFamilyProperties(handle, &queue_family_count, nullptr);
        queue_family_props.resize(queue_family_count);
        vkGetPhysicalDeviceQueueFamilyProperties(handle, &queue_family_count, queue_family_props.data());
        vkGetPhysicalDeviceFeatures(handle, &features);
    }
    PhysicalDeviceImpl(const PhysicalDeviceImpl&) = delete;
    PhysicalDeviceImpl(PhysicalDeviceImpl&& pdev) {
        physical_device = pdev.physical_device;
        props = pdev.props;
        mem_props = pdev.mem_props;
        extension_props = std::move(pdev.extension_props);
        queue_family_props = std::move(pdev.queue_family_props);
        features = pdev.features;
    };
    ~PhysicalDeviceImpl() {}

    VkPhysicalDevice handle() const override { return physical_device;}
    const VkPhysicalDeviceProperties* properties() const override { return &props; }
    const VkPhysicalDeviceMemoryProperties* mem_properties() const override { return &mem_props; }
    const VkPhysicalDeviceFeatures* supported_features() const override { return &features; }
    rs::iterator<const VkExtensionProperties*> enumerate_extensions() const override{ return extension_props.into_iter_ptr(); }
    rs::iterator<const VkQueueFamilyProperties*> enumerate_queue_families() const override { return queue_family_props.into_iter_ptr(); }

private:
    VkPhysicalDevice physical_device;
    VkPhysicalDeviceProperties props;
    VkPhysicalDeviceMemoryProperties mem_props;
    rs::vector<VkExtensionProperties> extension_props;
    rs::vector<VkQueueFamilyProperties> queue_family_props;
    VkPhysicalDeviceFeatures features;
};

class InstanceImpl : public Instance {
public:
    InstanceImpl(VkInstance handle) : instance(handle) {
        uint32_t device_count = 0;
        vkEnumeratePhysicalDevices(instance, &device_count, nullptr);
        rs::vector<VkPhysicalDevice> devices(device_count);
        vkEnumeratePhysicalDevices(instance, &device_count, devices.data());
        physical_devices.reserve(device_count);
        for(auto p : devices)
            physical_devices.emplace_back(p);
    }
    InstanceImpl(const InstanceImpl&) = delete;
    ~InstanceImpl() {
        vkDestroyInstance(instance, nullptr);
    }

    rs::iterator<const PhysicalDevice*> enumerate_physical_device() const override {
        return physical_devices.into_iter_ptr().map([](const PhysicalDeviceImpl* p) {
            return static_cast<const PhysicalDevice*>(p);
        });
    }

    VkInstance handle() const override { return instance; }

private:
    VkInstance instance;
    rs::vector<PhysicalDeviceImpl> physical_devices;
};

class SurfaceImpl : public Surface {
public:
    SurfaceImpl(VkSurfaceKHR s, const Instance& inst, const PhysicalDevice& dev) : surface(s) {
        instance = inst.handle();
        physical_device = dev.handle();
        refresh();
    }
    SurfaceImpl(const SurfaceImpl&) = delete;
    ~SurfaceImpl() {
        vkDestroySurfaceKHR(instance, surface, nullptr);
    }

    VkSurfaceKHR handle() const override { return surface; }
    void refresh() override {
        vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physical_device, surface, &surface_capabilities);
        uint32_t surface_format_count = 0;
        vkGetPhysicalDeviceSurfaceFormatsKHR(physical_device, surface, &surface_format_count, nullptr);
        supported_formats.resize(surface_format_count);
        vkGetPhysicalDeviceSurfaceFormatsKHR(physical_device, surface, &surface_format_count, supported_formats.data());
    }
    const VkSurfaceCapabilitiesKHR* capabilities() const override { return &surface_capabilities; }
    rs::iterator<const VkSurfaceFormatKHR*> enumerate_formats() const override {
        return supported_formats.into_iter_ptr().map([](const VkSurfaceFormatKHR* p) {
            return static_cast<const VkSurfaceFormatKHR*>(p);
        });
    }
    const VkSurfaceFormatKHR* default_format() const override {
        return supported_formats.into_iter_ptr().find([](const VkSurfaceFormatKHR* format) {
            return format->format == VK_FORMAT_B8G8R8A8_UNORM;
        }).value_or(&supported_formats[0]);
    }

private:
    VkInstance instance;
    VkSurfaceKHR surface;
    VkPhysicalDevice physical_device;
    VkSurfaceCapabilitiesKHR surface_capabilities;
    rs::vector<VkSurfaceFormatKHR> supported_formats;
};

class DeviceImpl : public Device {
public:
    DeviceImpl(VkDevice handle, rs::vector<Queue> q) : device(handle), queues(std::move(q)) {}
    DeviceImpl(const DeviceImpl&) = delete;
    ~DeviceImpl() {
        vkDeviceWaitIdle(device);
        vkDestroyDevice(device, nullptr);
    }

    VkDevice handle() const override { return device; }
    void wait_idle() const override {
        vkDeviceWaitIdle(device);
    }

    rs::iterator<const Queue*> enumerate_queues() const override { return queues.into_iter_ptr(); }
    rs::vector<uint32_t> queue_family_in_use() const override {
        return queues.into_iter_ptr().map([](const Queue* q) -> uint32_t {
            return q->queue_family_index;
        }).collect<rs::set<uint32_t>>().into_iter().collect<rs::vector<uint32_t>>();
    }

private:
    VkDevice device;
    rs::vector<Queue> queues;
};

class BufferImpl : public Buffer {
public:
    BufferImpl(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, size_t size, bool host_visible)
        : inner_device(device), buffer(buffer), device_memory(mem), mem_size(size), host_visible(host_visible) {}
    BufferImpl(const BufferImpl&) = delete;
    ~BufferImpl() {
        vkDestroyBuffer(inner_device, buffer, nullptr);
        vkFreeMemory(inner_device, device_memory, nullptr);
    }

    VkBuffer handle() const override { return buffer; }
    bool can_map() const override { return host_visible; }
    void* map(uint32_t offset, uint32_t size) override {
        void* data = nullptr;
        if(mapped || vkMapMemory(inner_device, device_memory, offset, size, 0, &data) != VK_SUCCESS)
            return nullptr;
        mapped = true;
        return data;
    }
    void unmap() override {
        mapped = false;
        vkUnmapMemory(inner_device, device_memory);
    }

    void update_buffer(const void* src, uint32_t size) {
        void* dst = nullptr;
        if(vkMapMemory(inner_device, device_memory, 0, size, 0, &dst) != VK_SUCCESS) {
            std::cout << "map error!" << std::endl;
            return;
        }
        memcpy(dst, src, size);
        vkUnmapMemory(inner_device, device_memory);
    }

private:
    VkDevice inner_device;
    VkBuffer buffer;
    VkDeviceMemory device_memory;
    size_t mem_size;
    bool mapped = false;
    bool host_visible;
};

class ImageViewImpl : public ImageView {
public:
    ImageViewImpl(VkDevice device, VkImageView handle, std::shared_ptr<Image> image)
        : device(device), imageview(handle), image(image) {}
    ImageViewImpl(const ImageViewImpl&) = delete;
    ImageViewImpl(ImageViewImpl&& iv) {
        device = iv.device;
        imageview = iv.imageview;
        iv.imageview = nullptr;
    };
    ~ImageViewImpl() {
        if(imageview != nullptr)
            vkDestroyImageView(device, imageview, nullptr);
    }

    VkImageView handle() const override {
        return imageview;
    }

private:
    VkDevice device;
    VkImageView imageview;
    std::shared_ptr<Image> image;
};

class ImageImpl : public Image, public std::enable_shared_from_this<ImageImpl> {
public:
    ImageImpl(VkDevice device, VkImage handle, VkDeviceMemory memory, VkFormat format, bool host_visible)
        : inner_device(device), image(handle), device_memory(memory), format(format), host_visible(host_visible) {}
    ImageImpl(const ImageImpl&) = delete;
    ~ImageImpl() {
        vkDestroyImage(inner_device, image, nullptr);
        vkFreeMemory(inner_device, device_memory, nullptr);
    }

    VkImage handle() const override { return image; }

    std::shared_ptr<ImageView> create_view(VkFormat view_format, VkImageAspectFlags aspect) override {
        VkImageViewCreateInfo view_info;
        view_info.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
        view_info.pNext = nullptr;
        view_info.flags = 0;
        view_info.image = image;
        view_info.viewType = VK_IMAGE_VIEW_TYPE_2D;
        view_info.format = view_format;
        view_info.subresourceRange = {aspect, 0u, 1u, 0u, 1u};
        view_info.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
        view_info.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
        view_info.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
        view_info.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
        VkImageView image_view;
        if (vkCreateImageView(inner_device, &view_info, nullptr, &image_view) != VK_SUCCESS)
            return nullptr;
        return std::make_shared<ImageViewImpl>(inner_device, image_view, shared_from_this());
    }

private:
    VkDevice inner_device;
    VkImage image;
    VkDeviceMemory device_memory;
    bool mapped = false;
    bool host_visible;
    VkFormat format;
};

class SamplerImpl : public Sampler {
public:
    SamplerImpl(VkDevice device, VkSampler handle) : inner_device(device), sampler(handle) {}
    SamplerImpl(const SamplerImpl&) = delete;
    ~SamplerImpl() {
        vkDestroySampler(inner_device, sampler, nullptr);
    }

    VkSampler handle() const override { return sampler; }

private:
    VkDevice inner_device;
    VkSampler sampler;
};

class ShaderModuleImpl : public ShaderModule {
public:
    ShaderModuleImpl(VkDevice device, VkShaderModule handle) : inner_device(device), shader_module(handle) {}
    ShaderModuleImpl(const ShaderModuleImpl&) = delete;
    ~ShaderModuleImpl() {
        vkDestroyShaderModule(inner_device, shader_module, nullptr);
    };

    VkShaderModule handle() const override { return shader_module; }
    
private:
    VkDevice inner_device;
    VkShaderModule shader_module;
};

class SwapchainImpl : public Swapchain {
public:
    SwapchainImpl(VkDevice device, VkSwapchainKHR handle, VkFormat fmt) : inner_device(device), swapchain(handle), format(fmt) {
        uint32_t swapchain_image_count = 0;
        vkGetSwapchainImagesKHR(device, swapchain, &swapchain_image_count, nullptr);
        rs::vector<VkImage> swapchain_images(swapchain_image_count);
        vkGetSwapchainImagesKHR(device, swapchain, &swapchain_image_count, swapchain_images.data());
        for(VkImage img : swapchain_images) {
            VkImageViewCreateInfo imageview_create_info;
            imageview_create_info.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
            imageview_create_info.pNext = nullptr;
            imageview_create_info.flags = 0;
            imageview_create_info.image = img;
            imageview_create_info.format = format;
            imageview_create_info.viewType = VK_IMAGE_VIEW_TYPE_2D;
            imageview_create_info.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1};
            imageview_create_info.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
            imageview_create_info.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
            imageview_create_info.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
            imageview_create_info.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
            VkImageView view;
            vkCreateImageView(device, &imageview_create_info, nullptr, &view);
            swapchain_imageviews.emplace_back(device, view, nullptr);
        }
    }
    SwapchainImpl(const SwapchainImpl&) = delete;
    ~SwapchainImpl() {
        vkDestroySwapchainKHR(inner_device, swapchain, nullptr);
    }

    VkSwapchainKHR handle() const override { return swapchain;}
    uint32_t image_count() const override { return swapchain_imageviews.size(); }

    rs::vector<ImageView*> get_swapchain_images() override {
        return swapchain_imageviews.into_iter_mptr().map([](ImageViewImpl* iv) {
            return static_cast<ImageView*>(iv);
        }).collect<rs::vector<ImageView*>>();
    }

private:
    VkDevice inner_device;
    VkSwapchainKHR swapchain;
    VkFormat format;
    rs::vector<ImageViewImpl> swapchain_imageviews;
};

class RenderPassImpl : public RenderPass {
public:
    RenderPassImpl(VkDevice device, VkRenderPass handle) : inner_device(device), render_pass(handle) {}
    RenderPassImpl(const RenderPassImpl&) = delete;
    ~RenderPassImpl() {
        vkDestroyRenderPass(inner_device, render_pass, nullptr);
    }

    VkRenderPass handle() const override {return render_pass; }

private:
    VkDevice inner_device;
    VkRenderPass render_pass;
};

class DescriptorSetImpl : public DescriptorSet {
public:
    DescriptorSetImpl(VkDevice device, VkDescriptorSet handle, std::weak_ptr<DescriptorPool> pool)
        : inner_device(device), descriptor_set(handle), pool(pool) {}
    DescriptorSetImpl(const DescriptorSetImpl&) = delete;
    ~DescriptorSetImpl() {
        if(auto pool_ptr = pool.lock(); pool_ptr != nullptr)
            vkFreeDescriptorSets(inner_device, pool_ptr->handle(), 1, &descriptor_set);
    }
    VkDescriptorSet handle() const override { return descriptor_set; }

    DescriptorSet& update_write(VkDescriptorType type, uint32_t binding, uint32_t start_index) {
        VkWriteDescriptorSet descriptor_write;
        descriptor_write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
        descriptor_write.pNext = nullptr;
        descriptor_write.dstSet = descriptor_set;
        descriptor_write.dstBinding = binding;
        descriptor_write.descriptorType = type;
        descriptor_write.dstArrayElement = start_index;
        descriptor_write.descriptorCount = 0;
        descriptor_write.pBufferInfo = nullptr;
        descriptor_write.pImageInfo = nullptr;
        descriptor_write.pTexelBufferView = nullptr;
        write_info.push_back(descriptor_write);
        return *this;
    }
    DescriptorSet& update_write_buffer_info(const Buffer& buffer, uint32_t offset, uint32_t range, uint32_t rep_count) override {
        VkDescriptorBufferInfo buffer_info;
        buffer_info.buffer = buffer.handle();
        buffer_info.offset = offset;
        buffer_info.range = range;
        for(uint32_t i = 0; i < rep_count; ++i)
            write_buffer_info.push_back(buffer_info);
        write_info.back().pBufferInfo = write_buffer_info.data();
        write_info.back().descriptorCount = write_buffer_info.size();
        return *this;
    }

    DescriptorSet& update_write_image_info(const ImageView& view, const Sampler& sampler) override {
        VkDescriptorImageInfo image_info;
        image_info.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
        image_info.imageView = view.handle();
        image_info.sampler = sampler.handle();
        write_image_info.push_back(image_info);
        write_info.back().pImageInfo = write_image_info.data();
        write_info.back().descriptorCount = write_image_info.size();
        return *this;
    }

    virtual DescriptorSet& update_end() override {
        if(!write_info.empty()) {
            vkUpdateDescriptorSets(inner_device, write_info.size(), write_info.data(), 0, nullptr);
            write_buffer_info.clear();
            write_image_info.clear();
            write_info.clear();
        }
        return *this;
    }
private:
    VkDevice inner_device;
    VkDescriptorSet descriptor_set;
    std::weak_ptr<DescriptorPool> pool;
    rs::vector<VkDescriptorBufferInfo> write_buffer_info;
    rs::vector<VkDescriptorImageInfo> write_image_info;
    rs::vector<VkWriteDescriptorSet> write_info;
};

class DescriptorSetLayoutImpl : public DescriptorSetLayout {
public:
    DescriptorSetLayoutImpl(VkDevice device, VkDescriptorSetLayout handle) : inner_device(device), layout(handle) {}
    DescriptorSetLayoutImpl(const DescriptorSetLayoutImpl&) = delete;
    ~DescriptorSetLayoutImpl() {
        vkDestroyDescriptorSetLayout(inner_device, layout, nullptr);
    }

    VkDescriptorSetLayout handle() const override { return layout; }

private:
    VkDevice inner_device;
    VkDescriptorSetLayout layout;
};

class DescriptorPoolImpl : public DescriptorPool, public std::enable_shared_from_this<DescriptorPoolImpl> {
public:
    DescriptorPoolImpl(VkDevice device, VkDescriptorPool handle, VkDescriptorPoolCreateFlags flags)
        : inner_device(device), pool(handle), flags(flags) {}
    DescriptorPoolImpl(const DescriptorPoolImpl&) = delete;
    ~DescriptorPoolImpl() {
        vkDestroyDescriptorPool(inner_device, pool, nullptr);
    }

    VkDescriptorPool handle() const override { return pool; }

    rs::vector<std::shared_ptr<DescriptorSet>> alloc_descriptor_set(const DescriptorSetLayout& layout, uint32_t count) override {
        std::vector<VkDescriptorSetLayout> layouts(count, layout.handle());
        VkDescriptorSetAllocateInfo alloc_info;
        alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
        alloc_info.pNext = nullptr;
        alloc_info.descriptorPool = pool;
        alloc_info.descriptorSetCount = count;
        alloc_info.pSetLayouts = layouts.data();
        std::vector<VkDescriptorSet> sets(count);
        if(vkAllocateDescriptorSets(inner_device, &alloc_info, sets.data()) != VK_SUCCESS)
            return {};
        rs::vector<std::shared_ptr<DescriptorSet>> descriptor_sets;
        std::weak_ptr<DescriptorPool> ptr = (flags & VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT) ? shared_from_this() : nullptr;
        for(auto& ds : sets)
            descriptor_sets.emplace_back(new DescriptorSetImpl(inner_device, ds, ptr));
        return descriptor_sets;
    }

    void reset() override {
        vkResetDescriptorPool(inner_device, pool, 0);
    }

private:
    VkDevice inner_device;
    VkDescriptorPool pool;
    VkDescriptorPoolCreateFlags flags = 0;
};

class PipelineImpl : public Pipeline {
public:
    PipelineImpl(VkDevice device, VkPipeline handle, VkPipelineLayout layout) 
        : inner_device(device), pipeline(handle), pipeline_layout(layout) {}
    PipelineImpl(const RenderPassImpl&) = delete;
    ~PipelineImpl() {
        vkDestroyPipeline(inner_device, pipeline, nullptr);
        vkDestroyPipelineLayout(inner_device, pipeline_layout, nullptr);
    }

    VkPipeline handle() const override { return pipeline; }
    VkPipelineLayout layout() const override { return pipeline_layout; }

private:
    VkDevice inner_device;
    VkPipeline pipeline;
    VkPipelineLayout pipeline_layout;
};

class FramebufferImpl : public Framebuffer {
public:
    FramebufferImpl(VkDevice device, VkFramebuffer handle, VkExtent2D sz) : inner_device(device), framebuffer(handle), fsize(sz) {}
    FramebufferImpl(const FramebufferImpl&) = delete;
    ~FramebufferImpl() {
        vkDestroyFramebuffer(inner_device, framebuffer, nullptr);
    }

    VkFramebuffer handle() const override { return framebuffer; }
    VkExtent2D size() const override { return fsize; }

private:
    VkExtent2D fsize;
    VkDevice inner_device;
    VkFramebuffer framebuffer;
};

class CommandPipelineBarrierBuilderImpl : public CommandPipelineBarrierBuilder {
public:
    CommandPipelineBarrierBuilderImpl(CommandBuffer* pcmd, VkPipelineStageFlags src, VkPipelineStageFlags dst)
        : cmd_buffer(pcmd), src(src), dst(dst) {}

    CommandPipelineBarrierBuilder& add_image_memory_barrior(const Image& img) override {
        VkImageMemoryBarrier barrier;
        barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
        barrier.pNext = nullptr;
        barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        barrier.image = img.handle();
        barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
        barrier.subresourceRange.baseMipLevel = 0;
        barrier.subresourceRange.levelCount = 1;
        barrier.subresourceRange.baseArrayLayer = 0;
        barrier.subresourceRange.layerCount = 1;
        image_barriors.push_back(barrier);
        return *this;
    }
    CommandPipelineBarrierBuilder& image_set_layout(VkImageLayout old_layout, VkImageLayout new_layout) {
        image_barriors.back().oldLayout = old_layout;
        image_barriors.back().newLayout = new_layout;
        return *this;
    }
    CommandPipelineBarrierBuilder& image_set_aspect_mask(VkImageAspectFlags aspect_mask) {
        image_barriors.back().subresourceRange.aspectMask = aspect_mask;
        return *this;
    }
    CommandPipelineBarrierBuilder& image_set_access_mask(VkAccessFlags src, VkAccessFlags dst) {
        image_barriors.back().srcAccessMask = src;
        image_barriors.back().dstAccessMask = dst;
        return *this;
    }
    CommandBuffer& end_pipeline_barrior() {
        auto d = defer([this](){delete this;});
        vkCmdPipelineBarrier(
            cmd_buffer->handle(), src, dst, 0,
            mem_barriors.size(), (mem_barriors.empty() ? nullptr : mem_barriors.data()),
            buffer_barriors.size(), (buffer_barriors.empty() ? nullptr : buffer_barriors.data()),
            image_barriors.size(), (image_barriors.empty() ? nullptr : image_barriors.data())
        );
        return *cmd_buffer;
    }
private:
    rs::vector<VkMemoryBarrier> mem_barriors;
    rs::vector<VkBufferMemoryBarrier> buffer_barriors;
    rs::vector<VkImageMemoryBarrier> image_barriors;
    CommandBuffer* cmd_buffer;
    VkPipelineStageFlags src;
    VkPipelineStageFlags dst;
};

class CommandBufferCopyBuilderImpl : public CommandBufferCopyBuilder {
public:
    CommandBufferCopyBuilderImpl(CommandBuffer* pcmd, const Buffer& src, const Buffer& dst)
        : cmd_buffer(pcmd), src(src.handle()), dst(dst.handle()) {}
    CommandBufferCopyBuilder& add_region(uint32_t src_offset, uint32_t dst_offset, uint32_t size) override {
        VkBufferCopy region;
        region.srcOffset = src_offset;
        region.dstOffset = dst_offset;
        region.size = size;
        regions.push_back(region);
        return *this;
    }
    CommandBuffer& end_buffer_copy() override {
        auto d = defer([this](){delete this;});
        if(!regions.empty())
            vkCmdCopyBuffer(cmd_buffer->handle(), src, dst, regions.size(), regions.data());
        return *cmd_buffer;
    }

private:
    CommandBuffer* cmd_buffer;
    VkBuffer src;
    VkBuffer dst;
    rs::vector<VkBufferCopy> regions;
};

class CommandBufferImageCopyBuilderImpl : public CommandBufferImageCopyBuilder {
public:
    CommandBufferImageCopyBuilderImpl(CommandBuffer* pcmd, const Buffer& buffer, const Image& img)
        : cmd_buffer(pcmd), buffer(buffer.handle()), image(img.handle()) {}
    CommandBufferImageCopyBuilder& add_region(uint32_t offset, VkOffset3D img_offset, VkExtent3D img_extent) override {
        VkBufferImageCopy region;
        region.bufferOffset = offset;
        region.bufferRowLength = 0;
        region.bufferImageHeight = 0;
        region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
        region.imageSubresource.mipLevel = 0;
        region.imageSubresource.baseArrayLayer = 0;
        region.imageSubresource.layerCount = 1;
        region.imageOffset = img_offset;
        region.imageExtent = img_extent;
        regions.push_back(region);
        return *this;
    }
    CommandBuffer& end_buffer_image_copy() override {
        auto d = defer([this](){delete this;});
        if(!regions.empty())
            vkCmdCopyBufferToImage(cmd_buffer->handle(), buffer, image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, regions.size(), regions.data());
        return *cmd_buffer;
    }

private:
    CommandBuffer* cmd_buffer;
    VkBuffer buffer;
    VkImage image;
    rs::vector<VkBufferImageCopy> regions;
};

class CommandBufferImpl : public CommandBuffer {
public:
    CommandBufferImpl(VkDevice device, VkCommandBuffer buffer, std::weak_ptr<CommandPool> pool)
        : inner_device(device), command_buffer(buffer), weak_pool(pool) {}
    CommandBufferImpl(const CommandBufferImpl&) = delete;
    ~CommandBufferImpl() {
        if(auto pool = weak_pool.lock(); pool != nullptr)
        vkFreeCommandBuffers(inner_device, pool->handle(), 1, &command_buffer);
    }

    VkCommandBuffer handle() const override { return command_buffer; }
    CommandBuffer& begin_command(VkCommandBufferUsageFlags flag) override {
        VkCommandBufferBeginInfo begin_info;
        begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
        begin_info.pNext = nullptr;
        begin_info.flags = flag;
        begin_info.pInheritanceInfo = nullptr;
        vkBeginCommandBuffer(command_buffer, &begin_info);
        return *this;
    }
    void end_command() override {
        vkEndCommandBuffer(command_buffer);
    }
    CommandBuffer& begin_render_pass(const RenderPass& pass, const Framebuffer& buffer, VkClearValue c) override {
        VkClearValue cvalues[2] = {c, {1.0f, 0}};
        VkRenderPassBeginInfo render_pass_info;
        render_pass_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
        render_pass_info.pNext = nullptr;
        render_pass_info.renderPass = pass.handle();
        render_pass_info.renderArea = {{0, 0}, buffer.size()};
        render_pass_info.framebuffer = buffer.handle();
        render_pass_info.clearValueCount = 2;
        render_pass_info.pClearValues = cvalues;
        vkCmdBeginRenderPass(command_buffer, &render_pass_info, VK_SUBPASS_CONTENTS_INLINE);
        return *this;
    }
    CommandBuffer& end_render_pass() override {
        vkCmdEndRenderPass(command_buffer);
        return *this;
    }
    CommandBuffer& bind_pipeline(const Pipeline& pipeline) override {
        vkCmdBindPipeline(command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline.handle());
        return *this;
    }
    CommandBuffer& bind_pipeline_and_descriptor_sets(const Pipeline& pipeline, const DescriptorSet& sets) override {
        vkCmdBindPipeline(command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline.handle());
        auto descriptor_set = sets.handle();
        vkCmdBindDescriptorSets(command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline.layout(), 0, 1, &descriptor_set, 0, nullptr);
        return *this;
    }
    CommandBuffer& draw(uint32_t count) override {
        vkCmdDraw(command_buffer, count, 1, 0, 0);
        return *this;
    }
    CommandBuffer& draw_vertices(const Buffer& vertex_buffer, uint32_t count) override {
        VkBuffer buffers[] = {vertex_buffer.handle()};
        VkDeviceSize offsets[] = {0};
        vkCmdBindVertexBuffers(command_buffer, 0, 1, buffers, offsets);
        vkCmdDraw(command_buffer, count, 1, 0, 0);
        return *this;
    }
    CommandBuffer& draw_indexed(const Buffer& vertex_buffer, const Buffer& index_buffer, uint32_t count) override {
        VkBuffer buffers[] = {vertex_buffer.handle()};
        VkDeviceSize offsets[] = {0};
        vkCmdBindVertexBuffers(command_buffer, 0, 1, buffers, offsets);
        vkCmdBindIndexBuffer(command_buffer, index_buffer.handle(), 0, VK_INDEX_TYPE_UINT32);
        vkCmdDrawIndexed(command_buffer, count, 1, 0, 0, 0);
        return *this;
    }
    CommandPipelineBarrierBuilder& begin_pipeline_barrior(VkPipelineStageFlags src, VkPipelineStageFlags dst) override {
        return *(new CommandPipelineBarrierBuilderImpl(this, src, dst));
    }
    CommandBufferCopyBuilder& begin_copy_buffer(const Buffer& src, const Buffer& dst) override {
        return *(new CommandBufferCopyBuilderImpl(this, src, dst));
    }
    CommandBufferImageCopyBuilder& begin_copy_buffer_to_image(const Buffer& src, const Image& dst) override {
        return *(new CommandBufferImageCopyBuilderImpl(this, src, dst));
    }

private:
    VkDevice inner_device;
    VkCommandBuffer command_buffer;
    std::weak_ptr<CommandPool> weak_pool;
};

class CommandPoolImpl : public CommandPool, public std::enable_shared_from_this<CommandPoolImpl> {
public:
    CommandPoolImpl(VkDevice device, VkCommandPool pool) : inner_device(device), command_pool(pool) {}
    ~CommandPoolImpl() {
        vkDestroyCommandPool(inner_device, command_pool, nullptr);
    }
    VkCommandPool handle() const override { return command_pool; }
    rs::vector<std::shared_ptr<CommandBuffer>> alloc_command_buffer(VkCommandBufferLevel level, uint32_t count) override {
        rs::vector<std::shared_ptr<CommandBuffer>> results;
        alloc_command_buffer(results, level, count);
        return results;
    }

    CommandPool& alloc_command_buffer(rs::vector<std::shared_ptr<CommandBuffer>>& vec, VkCommandBufferLevel level, uint32_t count) override {
        rs::vector<VkCommandBuffer> command_buffers(count);
        VkCommandBufferAllocateInfo alloc_info;
        alloc_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
        alloc_info.pNext = nullptr;
        alloc_info.commandPool = command_pool;
        alloc_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
        alloc_info.commandBufferCount = (uint32_t) command_buffers.size();
        if(vkAllocateCommandBuffers(inner_device, &alloc_info, command_buffers.data()) != VK_SUCCESS)
            return *this;
        std::weak_ptr<CommandPool> pool = shared_from_this();
        for(auto& buf : command_buffers)
            vec.emplace_back(new CommandBufferImpl(inner_device, buf, pool));
        return *this;
    }

private:
    VkDevice inner_device;
    VkCommandPool command_pool;
};

class RendererImpl : public Renderer {
public:
    RendererImpl(VkDevice device, uint32_t count) : inner_device(device) {
        img_count = count;
        current_frame = 0;
        image_semaphore.resize(img_count);
        signal_semaphore.resize(img_count);
        submit_fence.resize(img_count);
        VkSemaphoreCreateInfo semaphore_info;
        semaphore_info.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
        semaphore_info.pNext = nullptr;
        semaphore_info.flags = 0;
        VkFenceCreateInfo fence_info;
        fence_info.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
        fence_info.pNext = nullptr;
        fence_info.flags = VK_FENCE_CREATE_SIGNALED_BIT;
        
        for(uint32_t i = 0; i < img_count; ++i) {
            vkCreateSemaphore(device, &semaphore_info, nullptr, &image_semaphore[i]);
            vkCreateSemaphore(device, &semaphore_info, nullptr, &signal_semaphore[i]);
            vkCreateFence(device, &fence_info, nullptr, &submit_fence[i]);
        }
    }
    RendererImpl(const RendererImpl&) = delete;
    ~RendererImpl() {
        for(uint32_t i = 0; i < img_count; ++i) {
            vkDestroySemaphore(inner_device, image_semaphore[i], nullptr);
            vkDestroySemaphore(inner_device, signal_semaphore[i], nullptr);
            vkDestroyFence(inner_device, submit_fence[i], nullptr);
        }
    }
    uint32_t prepare_for_next_frame() override {
        current_index = current_frame % img_count;
        current_frame++;
        vkWaitForFences(inner_device, 1, &submit_fence[current_index], VK_TRUE, std::numeric_limits<uint64_t>::max());
        vkResetFences(inner_device, 1, &submit_fence[current_index]);
        outofdate = false;
        return current_index;
    }
    uint32_t accquire_next_image(const Swapchain& swapchain) override {
        uint32_t image_index = 0;
        auto result = vkAcquireNextImageKHR(inner_device, swapchain.handle(), std::numeric_limits<uint64_t>::max(),
                              image_semaphore[current_index], nullptr, &image_index);
        if(result == VK_ERROR_OUT_OF_DATE_KHR)
            outofdate = true;
        return image_index;
    }
    Renderer& submit_draw_command(const Queue& queue, const CommandBuffer& command_buffer) override {
        VkPipelineStageFlags wait_stages[] = {VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT};
        VkSubmitInfo submit_info;
        submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
        submit_info.pNext = nullptr;
        submit_info.waitSemaphoreCount = 1;
        submit_info.pWaitSemaphores = &image_semaphore[current_index];
        submit_info.pWaitDstStageMask = wait_stages;
        submit_info.commandBufferCount = 1;
        auto cmd = command_buffer.handle();
        submit_info.pCommandBuffers = &cmd;
        submit_info.signalSemaphoreCount = 1;
        submit_info.pSignalSemaphores = &signal_semaphore[current_index];
        vkQueueSubmit(queue.handle, 1, &submit_info, submit_fence[current_index]);
        return *this;
    }
    Renderer& present(const Queue& queue, const Swapchain& swapchain, uint32_t index) override {
        VkSwapchainKHR swapchains[] = {swapchain.handle()};
        VkPresentInfoKHR present_info;
        present_info.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
        present_info.pNext = nullptr;
        present_info.waitSemaphoreCount = 1;
        present_info.pWaitSemaphores = &signal_semaphore[current_index];
        present_info.swapchainCount = 1;
        present_info.pSwapchains = swapchains;
        present_info.pImageIndices = &index;
        present_info.pResults = nullptr;
        if(vkQueuePresentKHR(queue.handle, &present_info) == VK_ERROR_OUT_OF_DATE_KHR)
            outofdate = true;
        return *this;
    }
    Renderer& wait_idle(const Queue& queue) override {
        vkQueueWaitIdle(queue.handle);
        return *this;
    }
    Renderer& submit_onetime_command(const Queue& queue, rs::vector<std::shared_ptr<CommandBuffer>>& command_buffers) override {
        rs::vector<VkCommandBuffer> cmds;
        for(auto& ptr : command_buffers)
            cmds.push_back(ptr->handle());
        VkSubmitInfo submitInfo = {};
        submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
        submitInfo.commandBufferCount = cmds.size();
        submitInfo.pCommandBuffers = cmds.data();
        vkQueueSubmit(queue.handle, 1, &submitInfo, VK_NULL_HANDLE);
        return *this;
    }
    bool out_of_date() const override {
        return outofdate;
    }
private:
    VkDevice inner_device;
    std::vector<VkSemaphore> image_semaphore;
    std::vector<VkSemaphore> signal_semaphore;
    std::vector<VkFence> submit_fence;
    uint32_t img_count = 1;
    uint32_t current_frame = 0;
    uint32_t current_index = 0;
    bool outofdate = false;
};

rs::vector<VkLayerProperties> list_layer_properties() {
    uint32_t layer_count = 0;
    vkEnumerateInstanceLayerProperties(&layer_count, nullptr);
    rs::vector<VkLayerProperties> instance_layer_props(layer_count);
    vkEnumerateInstanceLayerProperties(&layer_count, instance_layer_props.data());
    return instance_layer_props;
}

class InstanceBuilderImpl : public InstanceBuilder {
public:
    InstanceBuilder& set_application_name(const char* name) { app_name = name; return *this; }
    InstanceBuilder& set_enging_name(const char* name) { engine_name = name; return *this; }
    InstanceBuilder& set_application_version(uint32_t ver) { app_version = ver; return *this; }
    InstanceBuilder& set_engine_version(uint32_t ver) { engine_version = ver; return *this; }
    InstanceBuilder& set_api_version(uint32_t ver) { api_version = ver; return *this; }
    InstanceBuilder& set_layers(const rs::vector<const char*>& layers) { layer_names = layers; return *this; }
    InstanceBuilder& set_extensions(const rs::vector<const char*>& extensions) { extension_names = extensions; return *this; }
    std::shared_ptr<Instance> end() {
        auto d = defer([this](){delete this;});
        VkApplicationInfo app_info;
        app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
        app_info.pNext = nullptr;
        app_info.pApplicationName = app_name.c_str();
        app_info.applicationVersion = app_version;
        app_info.pEngineName = engine_name.c_str();
        app_info.engineVersion = engine_version;
        app_info.apiVersion = api_version;
        VkInstanceCreateInfo instance_create_info;
        instance_create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
        instance_create_info.pNext = nullptr;
        instance_create_info.flags = 0;
        instance_create_info.pApplicationInfo = &app_info;
        instance_create_info.enabledLayerCount = layer_names.size();
        instance_create_info.ppEnabledLayerNames = layer_names.empty() ? nullptr : layer_names.data();
        instance_create_info.enabledExtensionCount = extension_names.size();
        instance_create_info.ppEnabledExtensionNames = extension_names.empty() ? nullptr : extension_names.data();
        VkInstance handle;
        if(vkCreateInstance(&instance_create_info, nullptr, &handle) != VK_SUCCESS)
            return nullptr;
        return std::shared_ptr<Instance>(new InstanceImpl(handle));
    }
private:
    std::string app_name;
    std::string engine_name;
    uint32_t app_version = 0;
    uint32_t engine_version = 0;
    uint32_t api_version = 0;
    rs::vector<const char*> layer_names;
    rs::vector<const char*> extension_names;
};

class DeviceBuilderImpl : public DeviceBuilder {
public:
    DeviceBuilderImpl(const PhysicalDevice& handle) : physical_device(&handle) {}
    DeviceBuilder& set_extensions(const rs::vector<const char*>& extensions) { extension_names = extensions; return *this; }
    DeviceBuilder& add_queue_family(uint32_t index, float priority) { queue_infos.emplace_back(index, priority); return *this; }
    DeviceBuilder& enable_features(const VkPhysicalDeviceFeatures& features) { enabled_features = features; return *this; }
    std::shared_ptr<Device> end() {
        auto d = defer([this](){delete this;});
        auto queue_counts = physical_device->enumerate_queue_families().map([](const VkQueueFamilyProperties* q) {
            return q->queueCount;
        }).collect<rs::vector<uint32_t>>();
        rs::vector<rs::vector<float>> priorities(queue_counts.size());
        queue_infos.into_iter().for_each([&priorities, &queue_counts](uint32_t idx, float priority) {
            if(idx >= priorities.size())
                return;
            if(priorities[idx].size() < queue_counts[idx])
                priorities[idx].push_back(priority);
        });
        auto queue_create_infos = priorities.into_iter_ptr().enumerate().filter([](size_t idx, const rs::vector<float>* p) {
            return p->size() > 0;
        }).map([](size_t idx, const rs::vector<float>* p) {
            VkDeviceQueueCreateInfo queue_create_info;
            queue_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
            queue_create_info.pNext = nullptr;
            queue_create_info.flags = 0;
            queue_create_info.queueFamilyIndex = (uint32_t)idx;
            queue_create_info.queueCount = p->size();
            queue_create_info.pQueuePriorities = p->data();
            return queue_create_info;
        }).collect<rs::vector<VkDeviceQueueCreateInfo>>();
        VkDeviceCreateInfo device_create_info;
        device_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
        device_create_info.pNext = nullptr;
        device_create_info.flags = 0;
        device_create_info.queueCreateInfoCount = (uint32_t)queue_create_infos.size();
        device_create_info.pQueueCreateInfos = queue_create_infos.data();
        device_create_info.enabledLayerCount = 0;
        device_create_info.ppEnabledLayerNames = nullptr;
        device_create_info.enabledExtensionCount = extension_names.size();
        device_create_info.ppEnabledExtensionNames = extension_names.data();
        device_create_info.pEnabledFeatures = &enabled_features;
        VkDevice device;
        if(vkCreateDevice(physical_device->handle(), &device_create_info, nullptr, &device) == VK_SUCCESS) {
            auto queues = queue_create_infos.into_iter_ptr().flat_map([device](const VkDeviceQueueCreateInfo* pinfo) {
                return rs::range(0u, pinfo->queueCount).map([device, pinfo](uint32_t idx) {
                    VkQueue queue;
                    vkGetDeviceQueue(device, pinfo->queueFamilyIndex, idx, &queue);
                    return Queue{queue, pinfo->queueFamilyIndex, idx};
                });
            }).collect<rs::vector<Queue>>();
            return std::shared_ptr<Device>(new DeviceImpl(device, std::move(queues)));
        }
        return nullptr;
    }
private:
    const PhysicalDevice* physical_device;
    rs::vector<const char*> extension_names;
    rs::vector<std::pair<uint32_t, float>> queue_infos;
    VkPhysicalDeviceFeatures enabled_features;
};

class BufferBuilderImpl : public BufferBuilder {
public:
    BufferBuilderImpl(const Device& device, const PhysicalDevice& physical_device) : device(device.handle()) {
        mem_props = physical_device.mem_properties();
    }
    BufferBuilder& alloc_size(size_t size) { this->size = size; return *this; }
    BufferBuilder& set_usage(VkBufferUsageFlags usage) { this->usage = usage; return *this; }
    BufferBuilder& set_sharing_mode(VkSharingMode mode) { this->mode = mode; return *this; }
    BufferBuilder& set_cpu_accessible() {
        expected_prop = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
        return *this;
    }
    BufferBuilder& set_device_local() {
        expected_prop = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
        return *this;
    }
    std::shared_ptr<Buffer> end() {
        auto d = defer([this](){delete this;});
        VkBufferCreateInfo buffer_info;
        buffer_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
        buffer_info.pNext = nullptr;
        buffer_info.flags = 0;
        buffer_info.size = size;
        buffer_info.usage = usage;
        buffer_info.sharingMode = mode;
        VkBuffer buffer;
        if(vkCreateBuffer(device, &buffer_info, nullptr, &buffer) != VK_SUCCESS)
            return nullptr;
        VkMemoryRequirements mem_requirements;
        vkGetBufferMemoryRequirements(device, buffer, &mem_requirements);
        auto mem_index = rs::range(0u, mem_props->memoryTypeCount).find([&, this](uint32_t idx) {
            return ((mem_requirements.memoryTypeBits & (1 << idx))
                && (mem_props->memoryTypes[idx].propertyFlags & expected_prop) == expected_prop);
        }).value();
        VkMemoryAllocateInfo alloc_info;
        alloc_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
        alloc_info.pNext = nullptr;
        alloc_info.allocationSize = mem_requirements.size;
        alloc_info.memoryTypeIndex = mem_index;
        VkDeviceMemory device_memory;
        if(vkAllocateMemory(device, &alloc_info, nullptr, &device_memory) != VK_SUCCESS) {
            vkDestroyBuffer(device, buffer, nullptr);
            return nullptr;
        }
        vkBindBufferMemory(device, buffer, device_memory, 0);
        bool host_visible = (expected_prop & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
        return std::shared_ptr<Buffer>(new BufferImpl(device, buffer, device_memory, mem_requirements.size, host_visible));
    }

private:
    VkDevice device;
    const VkPhysicalDeviceMemoryProperties* mem_props;
    uint32_t size = 0;
    VkBufferUsageFlags usage;
    VkSharingMode mode = VK_SHARING_MODE_EXCLUSIVE;
    VkMemoryPropertyFlags expected_prop;
};

class ImageBuilderImpl : public ImageBuilder {
public:
    ImageBuilderImpl(const Device& device, const PhysicalDevice& physical_device) : device(device.handle()) {
        mem_props = physical_device.mem_properties();
        info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
        info.pNext = nullptr;
        info.flags = 0;
        info.imageType = VK_IMAGE_TYPE_2D;
        info.format = VK_FORMAT_B8G8R8A8_UNORM;
        info.extent = {0u, 0u, 1u};
        info.mipLevels = 1;
        info.arrayLayers = 1;
        info.samples = VK_SAMPLE_COUNT_1_BIT;
        info.tiling = VK_IMAGE_TILING_OPTIMAL;
        info.usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
        info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
        info.queueFamilyIndexCount = 0;
        info.pQueueFamilyIndices = nullptr;
        info.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
    }
    ImageBuilder& set_type(VkImageType type) { info.imageType = type; return *this; }
    ImageBuilder& set_format(VkFormat format) { info.format = format; return *this; }
    ImageBuilder& set_extent(VkExtent3D ext) { info.extent = ext; return *this; }
    ImageBuilder& set_mip_level(uint32_t level) { info.mipLevels = level; return *this; }
    ImageBuilder& set_array_layers(uint32_t layer) { info.arrayLayers = layer; return *this; }
    ImageBuilder& set_samples(VkSampleCountFlagBits samples) { info.samples = samples; return *this; }
    ImageBuilder& set_tilling(VkImageTiling tiling) { info.tiling = tiling; return *this; }
    ImageBuilder& set_usage(VkImageUsageFlags usage) { info.usage = usage; return *this; }
    ImageBuilder& set_sharing_mode(VkSharingMode mode) { info.sharingMode = mode; return *this; }
    ImageBuilder& set_init_layout(VkImageLayout layout) { info.initialLayout = layout; return *this; }
    ImageBuilder& set_cpu_accessible() {
        expected_prop = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
        return *this;
    }
    ImageBuilder& set_device_local() {
        expected_prop = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
        return *this;
    }
    std::shared_ptr<Image> end() {
        auto d = defer([this](){delete this;});
        VkImage image;
        if(vkCreateImage(device, &info, nullptr, &image) != VK_SUCCESS)
            return nullptr;
        VkMemoryRequirements mem_requirements;
        vkGetImageMemoryRequirements(device, image, &mem_requirements);
        auto mem_index = rs::range(0u, mem_props->memoryTypeCount).find([&, this](uint32_t idx) {
            return ((mem_requirements.memoryTypeBits & (1 << idx))
                && (mem_props->memoryTypes[idx].propertyFlags & expected_prop) == expected_prop);
        }).value();
        VkMemoryAllocateInfo alloc_info;
        alloc_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
        alloc_info.pNext = nullptr;
        alloc_info.allocationSize = mem_requirements.size;
        alloc_info.memoryTypeIndex = mem_index;
        VkDeviceMemory device_memory;
        if(vkAllocateMemory(device, &alloc_info, nullptr, &device_memory) != VK_SUCCESS) {
            vkDestroyImage(device, image, nullptr);
            return nullptr;
        }
        vkBindImageMemory(device, image, device_memory, 0);
        bool host_visible = (expected_prop & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
        return std::make_shared<ImageImpl>(device, image, device_memory, info.format, host_visible);
    }

private:
    VkDevice device;
    const VkPhysicalDeviceMemoryProperties* mem_props;
    VkImageCreateInfo info;
    VkMemoryPropertyFlags expected_prop;
};

class SamplerBuilderImpl : public SamplerBuilder {
public:
    SamplerBuilderImpl(const Device& device) : device(device.handle()) {
        sampler_info.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
        sampler_info.pNext = nullptr;
        sampler_info.flags = 0;
        sampler_info.magFilter = VK_FILTER_LINEAR;
        sampler_info.minFilter = VK_FILTER_LINEAR;
        sampler_info.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT;
        sampler_info.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT;
        sampler_info.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT;
        sampler_info.anisotropyEnable = VK_FALSE;
        sampler_info.maxAnisotropy = 0;
        sampler_info.borderColor = VK_BORDER_COLOR_INT_OPAQUE_BLACK;
        sampler_info.unnormalizedCoordinates = VK_FALSE;
        sampler_info.compareEnable = VK_FALSE;
        sampler_info.compareOp = VK_COMPARE_OP_ALWAYS;
        sampler_info.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
        sampler_info.mipLodBias = 0.0f;
        sampler_info.minLod = 0.0f;
        sampler_info.maxLod = 0.0f;
    }
    SamplerBuilder& set_filter(VkFilter filter) {
        sampler_info.magFilter = filter;
        sampler_info.minFilter = filter;
        return *this;
    }
    SamplerBuilder& set_address_mode(VkSamplerAddressMode mode) {
        sampler_info.addressModeU = mode;
        sampler_info.addressModeV = mode;
        sampler_info.addressModeW = mode;
        return *this;
    }
    SamplerBuilder& set_anisotrophy(float value) {
        sampler_info.anisotropyEnable = VK_TRUE;
        sampler_info.maxAnisotropy = value;
        return *this;
    }
    std::shared_ptr<Sampler> end() {
        auto d = defer([this](){delete this;});
        VkSampler sampler;
        if(vkCreateSampler(device, &sampler_info, nullptr, &sampler) != VK_SUCCESS)
            return nullptr;
        return std::make_shared<SamplerImpl>(device, sampler);
    }

private:
    VkDevice device;
    VkSamplerCreateInfo sampler_info;
};

class SwapchainBuilderImpl : public SwapchainBuilder {
public:
    SwapchainBuilderImpl(const Device& device) : device(device.handle()) {
        swapchain_create_info.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
        swapchain_create_info.pNext = nullptr;
        swapchain_create_info.flags = 0;
        swapchain_create_info.surface = nullptr;
        swapchain_create_info.minImageCount = 2;
        swapchain_create_info.imageFormat = VK_FORMAT_B8G8R8A8_UNORM;
        swapchain_create_info.imageColorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR;
        swapchain_create_info.imageExtent = {128, 128};
        swapchain_create_info.imageArrayLayers = 1;
        swapchain_create_info.imageUsage = VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM;
        swapchain_create_info.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
        swapchain_create_info.queueFamilyIndexCount = 0;
        swapchain_create_info.pQueueFamilyIndices = nullptr;
        swapchain_create_info.preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
        swapchain_create_info.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
        swapchain_create_info.presentMode = VK_PRESENT_MODE_FIFO_KHR;
        swapchain_create_info.clipped = VK_TRUE;
        swapchain_create_info.oldSwapchain = nullptr;
    }
    SwapchainBuilder& set_surface(const Surface& surface) { swapchain_create_info.surface = surface.handle(); return *this; }
    SwapchainBuilder& set_min_image_count(uint32_t count) { swapchain_create_info.minImageCount = count; return *this; }
    SwapchainBuilder& set_format(VkFormat format) { swapchain_create_info.imageFormat = format; return *this; }
    SwapchainBuilder& set_colorspace(VkColorSpaceKHR colorspace) { swapchain_create_info.imageColorSpace = colorspace; return *this; }
    SwapchainBuilder& set_extent(VkExtent2D ext) { swapchain_create_info.imageExtent = ext; return *this; }
    SwapchainBuilder& set_array_layer(uint32_t array_layer) { swapchain_create_info.imageArrayLayers = array_layer; return *this; }
    SwapchainBuilder& set_image_usage(VkImageUsageFlags usage) { swapchain_create_info.imageUsage = usage; return *this; }
    SwapchainBuilder& set_queue_family_indices(const rs::vector<uint32_t>& queue_family_indices) {
        if(queue_family_indices.size() <= 1) {
            swapchain_create_info.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
            swapchain_create_info.queueFamilyIndexCount = 0;
            swapchain_create_info.pQueueFamilyIndices = nullptr;
        } else {
            swapchain_create_info.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
            swapchain_create_info.queueFamilyIndexCount = queue_family_indices.size();
            swapchain_create_info.pQueueFamilyIndices = queue_family_indices.data();
        }
        return *this;
    }
    SwapchainBuilder& set_transform(VkSurfaceTransformFlagBitsKHR transform) { swapchain_create_info.preTransform = transform; return *this; }
    SwapchainBuilder& set_composite_alpha(VkCompositeAlphaFlagBitsKHR alpha) { swapchain_create_info.compositeAlpha = alpha; return *this; }
    SwapchainBuilder& set_present_mode(VkPresentModeKHR mode) { swapchain_create_info.presentMode = mode; return *this; }
    SwapchainBuilder& set_clipped(VkBool32 clipped) { swapchain_create_info.clipped = clipped; return *this; }
    SwapchainBuilder& set_old_swapchain(Swapchain& old) { swapchain_create_info.oldSwapchain = old.handle(); return *this; }
    std::shared_ptr<Swapchain> end() {
        auto d = defer([this](){delete this;});
        VkSwapchainKHR swapchain;
        if(vkCreateSwapchainKHR(device, &swapchain_create_info, nullptr, &swapchain) != VK_SUCCESS)
            return nullptr;
        return std::shared_ptr<Swapchain>(new SwapchainImpl(device, swapchain, swapchain_create_info.imageFormat));
    }
private:
    VkDevice device;
    VkSwapchainCreateInfoKHR swapchain_create_info;
};

class RenderPassBuilderImpl : public RenderPassBuilder {
public:
    RenderPassBuilderImpl(const Device& device) : device(device.handle()) {}

    RenderPassBuilder& set_format(VkFormat format) { color_format = format; return *this; }
    RenderPassBuilder& set_samples(VkSampleCountFlagBits samples) { this->samples = samples; return *this; }

    std::shared_ptr<RenderPass> end() {
        auto d = defer([this](){delete this;});
        VkAttachmentDescription attachments[3];
        // 0 - color attackment
        attachments[0].flags = 0;
        attachments[0].format = color_format;
        attachments[0].samples = samples;
        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;
        if(samples == VK_SAMPLE_COUNT_1_BIT)
            attachments[0].finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
        else
            attachments[0].finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
        // 1- depth attackment
        attachments[1].flags = 0;
        attachments[1].format = VK_FORMAT_D24_UNORM_S8_UINT;
        attachments[1].samples = samples;
        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;
        // 2 - color attachment resolve, for msaa
        attachments[2].flags = 0;
        attachments[2].format = color_format;
        attachments[2].samples = VK_SAMPLE_COUNT_1_BIT;
        attachments[2].loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
        attachments[2].storeOp = VK_ATTACHMENT_STORE_OP_STORE;
        attachments[2].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
        attachments[2].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
        attachments[2].initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
        attachments[2].finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;

        VkAttachmentReference attachment_ref[3];
        attachment_ref[0].attachment = 0;
        attachment_ref[0].layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
        attachment_ref[1].attachment = 1;
        attachment_ref[1].layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
        attachment_ref[2].attachment = 2;
        attachment_ref[2].layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;

        VkSubpassDescription subpass = {};
        subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
        subpass.colorAttachmentCount = 1;
        subpass.pColorAttachments = &attachment_ref[0];
        subpass.pDepthStencilAttachment = &attachment_ref[1];
        if(samples != VK_SAMPLE_COUNT_1_BIT)
            subpass.pResolveAttachments = &attachment_ref[2];

        VkSubpassDependency dependency;
        dependency.dependencyFlags = 0;
        dependency.srcSubpass = VK_SUBPASS_EXTERNAL;
        dependency.dstSubpass = 0;
        dependency.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
        dependency.srcAccessMask = 0;
        dependency.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
        dependency.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_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 = (samples == VK_SAMPLE_COUNT_1_BIT) ? 2 : 3;
        render_pass_info.pAttachments = attachments;
        render_pass_info.subpassCount = 1;
        render_pass_info.pSubpasses = &subpass;
        render_pass_info.dependencyCount = 1;
        render_pass_info.pDependencies = &dependency;
        VkRenderPass render_pass;
        vkCreateRenderPass(device, &render_pass_info, nullptr, &render_pass);
        return std::shared_ptr<RenderPass>(new RenderPassImpl(device, render_pass));
    }

private:
    VkDevice device;
    VkFormat color_format = VK_FORMAT_B8G8R8A8_UNORM;
    VkSampleCountFlagBits samples = VK_SAMPLE_COUNT_1_BIT;
};

class DescriptorSetLayoutBuilderImpl : public DescriptorSetLayoutBuilder {
public:
    DescriptorSetLayoutBuilderImpl(const Device& device) : device(device.handle()) {}
    DescriptorSetLayoutBuilder& add_binding(VkDescriptorType type) {
        VkDescriptorSetLayoutBinding layout_binding;
        layout_binding.binding = bindings.size();
        layout_binding.descriptorType = type;
        layout_binding.descriptorCount = 1;
        layout_binding.stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
        layout_binding.pImmutableSamplers = nullptr;
        bindings.push_back(layout_binding);
        return *this;
    }
    DescriptorSetLayoutBuilder& set_count(uint32_t count) { bindings.back().descriptorCount = count; return *this; }
    DescriptorSetLayoutBuilder& set_stage(VkShaderStageFlags stage) { bindings.back().stageFlags = stage; return *this; }
    DescriptorSetLayoutBuilder& set_samplers() { return *this; }
    std::shared_ptr<DescriptorSetLayout> end() {
        auto d = defer([this](){delete this;});
        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 = bindings.size();
        layout_info.pBindings = bindings.data();
        VkDescriptorSetLayout descriptor_set_layout;
        if(vkCreateDescriptorSetLayout(device, &layout_info, nullptr, &descriptor_set_layout) != VK_SUCCESS)
            return nullptr;
        return std::shared_ptr<DescriptorSetLayout>(new DescriptorSetLayoutImpl(device, descriptor_set_layout));
    }

private:
    VkDevice device;
    rs::vector<VkDescriptorSetLayoutBinding> bindings;
};

class DescriptorPoolBuilderImpl : public DescriptorPoolBuilder {
public:
    DescriptorPoolBuilderImpl(const Device& device) : device(device.handle()) {}
    DescriptorPoolBuilder& add_pool_size(VkDescriptorType type, uint32_t count) { pool_size.push_back({type, count}); return *this; }
    DescriptorPoolBuilder& set_max_sets(uint32_t count) { max_sets = count; return *this; }
    DescriptorPoolBuilder& set_flags(VkDescriptorPoolCreateFlags flag) { flags = flag; return *this; }
    std::shared_ptr<DescriptorPool> end() {
        auto d = defer([this](){delete this;});
        VkDescriptorPoolCreateInfo pool_info;
        pool_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
        pool_info.pNext = nullptr;
        pool_info.flags = flags;
        pool_info.poolSizeCount = pool_size.size();
        pool_info.pPoolSizes = pool_size.data();
        pool_info.maxSets = max_sets;;
        VkDescriptorPool descriptor_pool;
        if(vkCreateDescriptorPool(device, &pool_info, nullptr, &descriptor_pool) != VK_SUCCESS)
            return nullptr;
        return std::shared_ptr<DescriptorPool>(new DescriptorPoolImpl(device, descriptor_pool, flags));
    }
private:
    VkDevice device;
    rs::vector<VkDescriptorPoolSize> pool_size;
    uint32_t max_sets = 0;
    VkDescriptorPoolCreateFlags flags = 0;
};

class PipelineBuilderImpl : public PipelineBuilder {
public:
    PipelineBuilderImpl(const Device& device) : device(device.handle()) {}
    PipelineBuilder& set_render_pass(const RenderPass& pass) { render_pass = pass.handle(); return *this; }
    PipelineBuilder& set_vertex_shader(const ShaderModule& vert) { vert_shader = vert.handle(); return *this; }
    PipelineBuilder& set_fragment_shader(const ShaderModule& frag) { frag_shader = frag.handle(); return *this; }
    PipelineBuilder& normal_viewport(float w, float h) { viewport = {0.0f, 0.0f, w, h, 0.0f, 1.0f}; return *this; }
    PipelineBuilder& normal_scissor(uint32_t w, uint32_t h) { scissor = {{0, 0}, {w, h}}; return *this; }
    PipelineBuilder& draw_topology(VkPrimitiveTopology topology) { this->topology = topology; return *this; }
    PipelineBuilder& set_polygon_mode(VkPolygonMode mode) { polygon_mode = mode; return *this; }
    PipelineBuilder& set_cull_mode(VkCullModeFlags mode) { cull_mode = mode; return *this; }
    PipelineBuilder& set_front_face(VkFrontFace front) { front_face = front; return *this; }
    PipelineBuilder& set_line_width(float width) { line_width = width; return *this; }
    PipelineBuilder& set_samples(VkSampleCountFlagBits samples) { this->samples = samples; return *this; }
    PipelineBuilder& bind_vertex_size(uint32_t sz) { vertex_size = sz; return *this; }
    PipelineBuilder& add_binding_attribute(VkFormat format, uint32_t offset) {
        input_attributes.push_back({(uint32_t)input_attributes.size(), 0, format, offset});
        return *this;
    }
    PipelineBuilder& add_descriptor_set_layout(const DescriptorSetLayout& layout) { descriptor_set_layouts.push_back(layout.handle()); return *this; }

    std::shared_ptr<Pipeline> end() {
        auto d = defer([this](){delete this;});
        VkPipelineShaderStageCreateInfo shader_stages[2];
        VkPipelineShaderStageCreateInfo& vert_shader_info = shader_stages[0];
        vert_shader_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
        vert_shader_info.pNext = nullptr;
        vert_shader_info.flags = 0;
        vert_shader_info.stage = VK_SHADER_STAGE_VERTEX_BIT;
        vert_shader_info.module = vert_shader;
        vert_shader_info.pName = "main";
        vert_shader_info.pSpecializationInfo = nullptr;
        VkPipelineShaderStageCreateInfo& frag_shader_info = shader_stages[1];
        frag_shader_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
        frag_shader_info.pNext = nullptr;
        frag_shader_info.flags = 0;
        frag_shader_info.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
        frag_shader_info.module = frag_shader;
        frag_shader_info.pName = "main";
        frag_shader_info.pSpecializationInfo = nullptr;
        VkPipelineVertexInputStateCreateInfo vertex_input_info;
        vertex_input_info.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
        vertex_input_info.pNext = nullptr;
        vertex_input_info.flags = 0;
        if(input_attributes.empty()) {
            vertex_input_info.vertexBindingDescriptionCount = 0;
            vertex_input_info.pVertexBindingDescriptions = nullptr;
            vertex_input_info.vertexAttributeDescriptionCount = 0;
            vertex_input_info.pVertexAttributeDescriptions = nullptr;
        } else {
            VkVertexInputBindingDescription binding_description;
            binding_description.binding = 0;
            binding_description.stride = vertex_size;
            binding_description.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
            vertex_input_info.vertexBindingDescriptionCount = 1;
            vertex_input_info.pVertexBindingDescriptions = &binding_description;
            vertex_input_info.vertexAttributeDescriptionCount = input_attributes.size();
            vertex_input_info.pVertexAttributeDescriptions = input_attributes.data();
        }
        VkPipelineInputAssemblyStateCreateInfo input_assemply_info;
        input_assemply_info.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
        input_assemply_info.pNext = nullptr;
        input_assemply_info.flags = 0;
        input_assemply_info.topology = topology;
        input_assemply_info.primitiveRestartEnable = VK_FALSE;
        VkPipelineViewportStateCreateInfo viewport_state;
        viewport_state.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
        viewport_state.pNext = nullptr;
        viewport_state.flags = 0;
        viewport_state.viewportCount = 1;
        viewport_state.pViewports = &viewport;
        viewport_state.scissorCount = 1;
        viewport_state.pScissors = &scissor;
        VkPipelineRasterizationStateCreateInfo rasterizer;
        rasterizer.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
        rasterizer.pNext = nullptr;
        rasterizer.flags = 0;        
        rasterizer.depthClampEnable = VK_FALSE;
        rasterizer.rasterizerDiscardEnable = VK_FALSE;
        rasterizer.polygonMode = polygon_mode;
        rasterizer.cullMode = cull_mode;
        rasterizer.frontFace = front_face;
        rasterizer.depthBiasEnable = VK_FALSE;
        rasterizer.depthBiasConstantFactor = 0.0f;
        rasterizer.depthBiasClamp = 0.0f;
        rasterizer.depthBiasSlopeFactor = 0.0f;
        rasterizer.lineWidth = line_width;
        VkPipelineMultisampleStateCreateInfo multisampling;
        multisampling.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
        multisampling.pNext = nullptr;
        multisampling.flags = 0;        
        multisampling.rasterizationSamples = samples;
        multisampling.sampleShadingEnable = VK_FALSE;
        multisampling.minSampleShading = 1.0f;
        multisampling.pSampleMask = nullptr;
        multisampling.alphaToCoverageEnable = VK_FALSE;
        multisampling.alphaToOneEnable = VK_FALSE;
        VkPipelineColorBlendAttachmentState colorBlendAttachment;
        colorBlendAttachment.blendEnable = VK_TRUE;
        colorBlendAttachment.srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
        colorBlendAttachment.dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
        colorBlendAttachment.colorBlendOp = VK_BLEND_OP_ADD;
        colorBlendAttachment.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
        colorBlendAttachment.dstAlphaBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
        colorBlendAttachment.alphaBlendOp = VK_BLEND_OP_ADD;
        colorBlendAttachment.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT
                                            | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
        VkPipelineColorBlendStateCreateInfo colorBlending;
        colorBlending.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
        colorBlending.pNext = nullptr;
        colorBlending.flags = 0;
        colorBlending.logicOpEnable = VK_FALSE;
        colorBlending.logicOp = VK_LOGIC_OP_COPY;
        colorBlending.attachmentCount = 1;
        colorBlending.pAttachments = &colorBlendAttachment;
        colorBlending.blendConstants[0] = 0.0f;
        colorBlending.blendConstants[1] = 0.0f;
        colorBlending.blendConstants[2] = 0.0f;
        colorBlending.blendConstants[3] = 0.0f;
        VkPipelineLayoutCreateInfo pipeline_layout_info;
        pipeline_layout_info.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
        pipeline_layout_info.pNext = nullptr;
        pipeline_layout_info.flags = 0;
        if(descriptor_set_layouts.empty()) {
            pipeline_layout_info.setLayoutCount = 0;
            pipeline_layout_info.pSetLayouts = nullptr;
        } else {
            pipeline_layout_info.setLayoutCount = descriptor_set_layouts.size();
            pipeline_layout_info.pSetLayouts = descriptor_set_layouts.data();
        }
        pipeline_layout_info.pushConstantRangeCount = 0;
        VkPipelineLayout pipeline_layout;
        if(vkCreatePipelineLayout(device, &pipeline_layout_info, nullptr, &pipeline_layout) != VK_SUCCESS)
            return nullptr;

        VkPipelineDepthStencilStateCreateInfo depthStencil = {};
        depthStencil.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
        depthStencil.depthTestEnable = VK_TRUE;
        depthStencil.depthWriteEnable = VK_TRUE;
        depthStencil.depthCompareOp = VK_COMPARE_OP_LESS;
        depthStencil.depthBoundsTestEnable = VK_FALSE;
        depthStencil.minDepthBounds = 0.0f;
        depthStencil.maxDepthBounds = 1.0f;
        depthStencil.stencilTestEnable = VK_FALSE;
        depthStencil.front = {};
        depthStencil.back = {};

        VkGraphicsPipelineCreateInfo pipelineInfo;
        pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
        pipelineInfo.pNext = nullptr;
        pipelineInfo.flags = 0;
        pipelineInfo.stageCount = 2;
        pipelineInfo.pStages = shader_stages;
        pipelineInfo.pVertexInputState = &vertex_input_info;
        pipelineInfo.pInputAssemblyState = &input_assemply_info;
        pipelineInfo.pViewportState = &viewport_state;
        pipelineInfo.pRasterizationState = &rasterizer;
        pipelineInfo.pMultisampleState = &multisampling;
        pipelineInfo.pDepthStencilState = &depthStencil;
        pipelineInfo.pColorBlendState = &colorBlending;
        pipelineInfo.pDynamicState = nullptr;
        pipelineInfo.layout = pipeline_layout;
        pipelineInfo.renderPass = render_pass;
        pipelineInfo.subpass = 0;
        pipelineInfo.basePipelineHandle = VK_NULL_HANDLE;
        pipelineInfo.basePipelineIndex = -1;
        VkPipeline graphicsPipeline;
        if(vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &graphicsPipeline) != VK_SUCCESS)
            return nullptr;
        return std::shared_ptr<Pipeline>(new PipelineImpl(device, graphicsPipeline, pipeline_layout));
    }

private:
    VkDevice device;
    VkRenderPass render_pass;
    VkShaderModule vert_shader;
    VkShaderModule frag_shader;
    VkViewport viewport;
    VkRect2D scissor;
    VkPrimitiveTopology topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
    VkPolygonMode polygon_mode = VK_POLYGON_MODE_FILL;
    VkCullModeFlags cull_mode = VK_CULL_MODE_NONE;
    VkFrontFace front_face = VK_FRONT_FACE_COUNTER_CLOCKWISE;
    float line_width = 1.0;
    VkSampleCountFlagBits samples = VK_SAMPLE_COUNT_1_BIT;
    uint32_t vertex_size = 0;
    rs::vector<VkVertexInputAttributeDescription> input_attributes;
    rs::vector<VkDescriptorSetLayout> descriptor_set_layouts;
};

class FramebufferBuilderImpl : public FramebufferBuilder {
public:
    FramebufferBuilderImpl(const Device& dev) : device(dev.handle()) {}
    FramebufferBuilder& set_render_pass(const RenderPass& render_pass) { this->render_pass = render_pass.handle(); return *this; }
    FramebufferBuilder& set_framebuffer_size(uint32_t w, uint32_t h) { width = w; height = h; return *this; }
    FramebufferBuilder& add_image_view(const ImageView& view) { image_views.push_back(view.handle()); return *this; }
    FramebufferBuilder& set_flags(VkFramebufferCreateFlags flag) { this->flags = flags; return *this; }
    FramebufferBuilder& set_layer(uint32_t layer) { this->layer = layer; return *this; }
    std::shared_ptr<Framebuffer> end() {
        auto d = defer([this](){delete this;});
        VkFramebufferCreateInfo create_info;
        create_info.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
        create_info.pNext = nullptr;
        create_info.flags = flags;
        create_info.renderPass = render_pass;
        create_info.attachmentCount = image_views.size();
        create_info.pAttachments = image_views.data();
        create_info.width = width;
        create_info.height = height;
        create_info.layers = layer;
        VkFramebuffer framebuffer;
        if(vkCreateFramebuffer(device, &create_info, nullptr, &framebuffer) != VK_SUCCESS)
            return nullptr;
        return std::shared_ptr<Framebuffer>(new FramebufferImpl(device, framebuffer, {width, height}));
    }
private:
    VkDevice device;
    VkRenderPass render_pass;
    std::vector<VkImageView> image_views;
    VkFramebufferCreateFlags flags = 0;
    uint32_t layer = 1;
    uint32_t width = 0;
    uint32_t height = 0;
};

class CommandPoolBuilderImpl : public CommandPoolBuilder {
public:
    CommandPoolBuilderImpl(const Device& dev) : device(dev.handle()) {}
    CommandPoolBuilder& set_queue_family_index(uint32_t idx) { queue_family_index = idx; return *this; }
    CommandPoolBuilder& set_pool_flag(VkCommandPoolCreateFlags flags) { pool_flag = flags; return *this; }
    std::shared_ptr<CommandPool> end() {
        auto d = defer([this](){delete this;});
        VkCommandPoolCreateInfo pool_create_info;
        pool_create_info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
        pool_create_info.pNext = nullptr;
        pool_create_info.flags = pool_flag;
        pool_create_info.queueFamilyIndex = queue_family_index;
        VkCommandPool command_pool;
        if(vkCreateCommandPool(device, &pool_create_info, nullptr, &command_pool) != VK_SUCCESS)
            return nullptr;
        return std::make_shared<CommandPoolImpl>(device, command_pool);
    }

private:
    VkDevice device;
    uint32_t queue_family_index = 0;
    VkCommandPoolCreateFlags pool_flag = 0;
};

// static builders
InstanceBuilder& Instance::begin_build() {
    return *(new InstanceBuilderImpl);
}

std::shared_ptr<Surface> Surface::from_raw_surface(VkSurfaceKHR surface, const Instance& inst, const PhysicalDevice& physical_device) {
    return std::shared_ptr<Surface>(new SurfaceImpl(surface, inst, physical_device));
}

DeviceBuilder& Device::begin_build(const PhysicalDevice& physical_device) {
    return *(new DeviceBuilderImpl(physical_device));
}

BufferBuilder& Buffer::begin_build(const Device& device, const PhysicalDevice& physical_device) {
    return *(new BufferBuilderImpl(device, physical_device));
}

ImageBuilder& Image::begin_build(const Device& device, const PhysicalDevice& physical_device) {
    return *(new ImageBuilderImpl(device, physical_device));
}

SamplerBuilder& Sampler::begin_build(const Device& device) {
    return *(new SamplerBuilderImpl(device));
}

std::shared_ptr<ShaderModule> ShaderModule::load_from_spv(const Device& device, const std::string& filename) {
    std::ifstream file(filename, std::ios::ate | std::ios::binary);
    if(!file.is_open())
        return nullptr;
    size_t file_size = (size_t) file.tellg();
    std::vector<char> buffer(file_size);
    file.seekg(0);
    file.read(buffer.data(), file_size);
    VkShaderModuleCreateInfo shader_module_create_info;
    shader_module_create_info.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
    shader_module_create_info.pNext = nullptr;
    shader_module_create_info.flags = 0;
    shader_module_create_info.codeSize = file_size;
    shader_module_create_info.pCode = reinterpret_cast<uint32_t*>(buffer.data());
    VkShaderModule shaderModule;
    if(vkCreateShaderModule(device.handle(), &shader_module_create_info, nullptr, &shaderModule) != VK_SUCCESS)
        return nullptr;
    return std::shared_ptr<ShaderModule>(new ShaderModuleImpl(device.handle(), shaderModule));
}

std::shared_ptr<ShaderModule> ShaderModule::load_from_src(const Device& device, const std::string& filename, uint32_t kind) {
    std::ifstream file(filename, std::ios::ate);
    if(!file.is_open())
        return nullptr;
    size_t file_size = (size_t) file.tellg();
    std::string text(file_size, ' ');
    file.seekg(0);
    file.read(text.data(), file_size);
    shaderc::Compiler compiler;
    shaderc::SpvCompilationResult result = compiler.CompileGlslToSpv(text.c_str(), text.length(), (shaderc_shader_kind)kind, filename.c_str());
    if(result.GetNumErrors() != 0) {
        std::cout << result.GetErrorMessage() << std::endl;
        return nullptr;
    }
    if(auto status = result.GetCompilationStatus(); status != shaderc_compilation_status_success) {
        std::cout << filename << " compile status error ==> " << status << std::endl;
        return nullptr;
    }
    auto bin_begin = result.begin();
    size_t code_size = (result.end() - result.begin()) * sizeof(uint32_t);
    VkShaderModuleCreateInfo shader_module_create_info;
    shader_module_create_info.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
    shader_module_create_info.pNext = nullptr;
    shader_module_create_info.flags = 0;
    shader_module_create_info.codeSize = code_size;
    shader_module_create_info.pCode = bin_begin;
    VkShaderModule shaderModule;
    if(vkCreateShaderModule(device.handle(), &shader_module_create_info, nullptr, &shaderModule) != VK_SUCCESS)
        return nullptr;
    return std::shared_ptr<ShaderModule>(new ShaderModuleImpl(device.handle(), shaderModule));
}

SwapchainBuilder& Swapchain::begin_build(const Device& device) {
    return *(new SwapchainBuilderImpl(device));
}

RenderPassBuilder& RenderPass::begin_build(const Device& device) {
    return *(new RenderPassBuilderImpl(device));
}

DescriptorSetLayoutBuilder& DescriptorSetLayout::begin_build(const Device& device) {
    return *(new DescriptorSetLayoutBuilderImpl(device));
}

DescriptorPoolBuilder& DescriptorPool::begin_build(const Device& device) {
    return *(new DescriptorPoolBuilderImpl(device));
}

PipelineBuilder& Pipeline::begin_build(const Device& device) {
    return *(new PipelineBuilderImpl(device));
}

FramebufferBuilder& Framebuffer::begin_build(const Device& device) {
    return *(new FramebufferBuilderImpl(device));
}

CommandPoolBuilder& CommandPool::begin_build(const Device& device) {
    return *(new CommandPoolBuilderImpl(device));
}

std::shared_ptr<Renderer> Renderer::create_renderer(const vk::Device& device, uint32_t img_count) {
    return std::shared_ptr<Renderer>(new RendererImpl(device.handle(), img_count));
}

}