/// Vulkan image module
module gfx.vulkan.image;

package:

import gfx.bindings.vulkan;

import gfx.core.rc;
import gfx.graal.image;
import gfx.graal.memory;
import gfx.vulkan;
import gfx.vulkan.conv;
import gfx.vulkan.device;
import gfx.vulkan.error;
import gfx.vulkan.memory;

class VulkanImage : Image
{
    this(VkImage vk, VulkanDevice dev, ImageType type, ImageDims dims, Format format)
    {
        _vk = vk;
        _dev = dev;
        _type = type;
        _dims = dims;
        _format = format;
        _cmds = dev.cmds;
    }

    final @property VkImage vk()
    {
        return _vk;
    }

    final @property VulkanDevice dev()
    {
        return _dev;
    }

    final @property VkDevice vkDev()
    {
        return _dev.vk;
    }

    final @property VkDeviceCmds cmds() {
        return _cmds;
    }

    final override @property ImageType type() {
        return _type;
    }
    final @property Format format() {
        return _format;
    }
    final override @property ImageDims dims() {
        return _dims;
    }
    final @property uint levels() {
        return _levels;
    }

    override VulkanImageView createView(ImageType viewType, ImageSubresourceRange isr, Swizzle swizzle)
    {
        const it = type;
        VkImageViewCreateInfo ivci;
        ivci.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
        ivci.image = vk;
        ivci.viewType = viewType.toVkView();
        ivci.format = format.toVk();
        ivci.subresourceRange = isr.toVk();
        ivci.components = swizzle.toVk();

        VkImageView vkIv;
        vulkanEnforce(
            cmds.createImageView(vkDev, &ivci, null, &vkIv),
            "Could not create Vulkan View"
        );

        return new VulkanImageView(vkIv, this, isr, swizzle);
    }

    private VkImage _vk;
    private VulkanDevice _dev;
    private VkDeviceCmds _cmds;
    private ImageType _type;
    private ImageDims _dims;
    private Format _format;
    private uint _levels;
}

class VulkanImageRc : VulkanImage, ImageRc
{
    mixin(atomicRcCode);

    this(VkImage vk, VulkanDevice dev, ImageType type, ImageDims dims, Format format)
    {
        super(vk, dev, type, dims, format);
        dev.retain();
    }

    override void dispose() {
        cmds.destroyImage(vkDev, vk, null);
        if (_vdm) _vdm.release();
        dev.release();
    }

    override @property MemoryRequirements memoryRequirements() {
        VkMemoryRequirements vkMr;
        cmds.getImageMemoryRequirements(vkDev, vk, &vkMr);
        return vkMr.toGfx();
    }

    override void bindMemory(DeviceMemory mem, in size_t offset)
    {
        assert(!_vdm, "Bind the same buffer twice");
        _vdm = enforce(cast(VulkanDeviceMemory)mem, "Did not pass a Vulkan memory");
        vulkanEnforce(
            cmds.bindImageMemory(vkDev, vk, _vdm.vk, offset),
            "Could not bind image memory"
        );
        _vdm.retain();
    }

    VulkanDeviceMemory _vdm;
}

class VulkanImageView : VulkanDevObj!(VkImageView, "destroyImageView"), ImageView
{
    mixin(atomicRcCode);

    this(VkImageView vk, VulkanImage img, ImageSubresourceRange isr, Swizzle swizzle)
    {
        super(vk, img.dev);
        _img = img;
        _isr = isr;
        _swizzle = swizzle;
    }

    override void dispose()
    {
        super.dispose();
        _img = null;
    }

    override @property VulkanImage image() {
        return _img;
    }

    override @property ImageSubresourceRange subresourceRange() {
        return _isr;
    }

    override @property Swizzle swizzle() {
        return _swizzle;
    }

    private VulkanImage _img;
    private ImageSubresourceRange _isr;
    private Swizzle _swizzle;
}

class VulkanSampler : VulkanDevObj!(VkSampler, "destroySampler"), Sampler
{
    mixin(atomicRcCode);
    this(VkSampler sampler, VulkanDevice dev) {
        super(sampler, dev);
    }
}