// Copyright 2019 The SwiftShader Authors. All Rights Reserved.
//
// 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 "Device.hpp"
#include "Driver.hpp"

Device::Device()
		: driver(nullptr),
		  device(nullptr),
		  physicalDevice(nullptr),
		  queueFamilyIndex(0) {}

Device::Device(
		Driver const *driver, VkDevice device, VkPhysicalDevice physicalDevice,
		uint32_t queueFamilyIndex)
	: driver(driver),
	  device(device),
	  physicalDevice(physicalDevice),
	  queueFamilyIndex(queueFamilyIndex) {}

Device::~Device()
{
	if (device != nullptr)
	{
		driver->vkDeviceWaitIdle(device);
		driver->vkDestroyDevice(device, nullptr);
	}
}

bool Device::IsValid() const { return device != nullptr; }

VkResult Device::CreateComputeDevice(
		Driver const *driver, VkInstance instance, std::unique_ptr<Device> &out)
{
    VkResult result;

    // Gather all physical devices
    std::vector<VkPhysicalDevice> physicalDevices;
    result = GetPhysicalDevices(driver, instance, physicalDevices);
    if (result != VK_SUCCESS)
    {
		return result;
    }

    // Inspect each physical device's queue families for compute support.
    for (auto physicalDevice : physicalDevices)
    {
        int queueFamilyIndex = GetComputeQueueFamilyIndex(driver, physicalDevice);
        if (queueFamilyIndex < 0)
        {
            continue;
        }

        const float queuePrioritory = 1.0f;
        const VkDeviceQueueCreateInfo deviceQueueCreateInfo = {
            VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,  // sType
            nullptr,                                     // pNext
            0,                                           // flags
            (uint32_t)queueFamilyIndex,                  // queueFamilyIndex
            1,                                           // queueCount
            &queuePrioritory,                            // pQueuePriorities
        };

        const VkDeviceCreateInfo deviceCreateInfo = {
            VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,  // sType
            nullptr,                               // pNext
            0,                                     // flags
            1,                                     // queueCreateInfoCount
            &deviceQueueCreateInfo,                // pQueueCreateInfos
            0,                                     // enabledLayerCount
            nullptr,                               // ppEnabledLayerNames
            0,                                     // enabledExtensionCount
            nullptr,                               // ppEnabledExtensionNames
            nullptr,                               // pEnabledFeatures
        };

        VkDevice device;
        result = driver->vkCreateDevice(physicalDevice, &deviceCreateInfo, nullptr, &device);
        if (result != VK_SUCCESS)
        {
            return result;
        }

		out.reset(new Device(driver, device, physicalDevice, static_cast<uint32_t>(queueFamilyIndex)));
        return VK_SUCCESS;
    }

    return VK_SUCCESS;
}

int Device::GetComputeQueueFamilyIndex(
		Driver const *driver, VkPhysicalDevice device)
{
    auto properties = GetPhysicalDeviceQueueFamilyProperties(driver, device);
    for (uint32_t i = 0; i < properties.size(); i++)
    {
        if ((properties[i].queueFlags & VK_QUEUE_COMPUTE_BIT) != 0)
        {
            return static_cast<int>(i);
        }
    }
    return -1;
}

std::vector<VkQueueFamilyProperties>
		Device::GetPhysicalDeviceQueueFamilyProperties(
				Driver const *driver, VkPhysicalDevice device)
{
    std::vector<VkQueueFamilyProperties> out;
    uint32_t count = 0;
    driver->vkGetPhysicalDeviceQueueFamilyProperties(device, &count, nullptr);
    out.resize(count);
    driver->vkGetPhysicalDeviceQueueFamilyProperties(device, &count, out.data());
    return out;
}

VkResult Device::GetPhysicalDevices(
		const Driver* driver, VkInstance instance,
		std::vector<VkPhysicalDevice>& out)
{
    uint32_t count = 0;
    VkResult result = driver->vkEnumeratePhysicalDevices(instance, &count, 0);
    if (result != VK_SUCCESS)
    {
        return result;
    }
    out.resize(count);
    return driver->vkEnumeratePhysicalDevices(instance, &count, out.data());
}

VkResult Device::CreateStorageBuffer(
		VkDeviceMemory memory, VkDeviceSize size,
		VkDeviceSize offset, VkBuffer* out) const
{
	const VkBufferCreateInfo info = {
		VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // sType
		nullptr,                              // pNext
		0,                                    // flags
		size,                                 // size
		VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,   // usage
		VK_SHARING_MODE_EXCLUSIVE,            // sharingMode
		0,                                    // queueFamilyIndexCount
		nullptr,                              // pQueueFamilyIndices
	};

	VkBuffer buffer;
	VkResult result = driver->vkCreateBuffer(device, &info, 0, &buffer);
	if (result != VK_SUCCESS)
	{
		return result;
	}

	result = driver->vkBindBufferMemory(device, buffer, memory, offset);
	if (result != VK_SUCCESS)
	{
		return result;
	}

	*out = buffer;
	return VK_SUCCESS;
}

void Device::DestroyBuffer(VkBuffer buffer) const
{
	driver->vkDestroyBuffer(device, buffer, nullptr);
}

VkResult Device::CreateShaderModule(
		const std::vector<uint32_t>& spirv, VkShaderModule* out) const
{
	VkShaderModuleCreateInfo info = {
		VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, // sType
		nullptr,                                     // pNext
		0,                                           // flags
		spirv.size() * 4,                            // codeSize
		spirv.data(),                                // pCode
	};
	return driver->vkCreateShaderModule(device, &info, 0, out);
}

void Device::DestroyShaderModule(VkShaderModule shaderModule) const
{
	driver->vkDestroyShaderModule(device, shaderModule, nullptr);
}

VkResult Device::CreateDescriptorSetLayout(
		const std::vector<VkDescriptorSetLayoutBinding>& bindings,
		VkDescriptorSetLayout* out) const
{
	VkDescriptorSetLayoutCreateInfo info = {
		VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, // sType
		nullptr,                                             // pNext
		0,                                                   // flags
		(uint32_t)bindings.size(),                           // bindingCount
		bindings.data(),                                     // pBindings
	};

	return driver->vkCreateDescriptorSetLayout(device, &info, 0, out);
}

void Device::DestroyDescriptorSetLayout(VkDescriptorSetLayout descriptorSetLayout) const
{
	driver->vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr);
}

VkResult Device::CreatePipelineLayout(
		VkDescriptorSetLayout layout, VkPipelineLayout* out) const
{
	VkPipelineLayoutCreateInfo info = {
		VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // sType
		nullptr,                                       // pNext
		0,                                             // flags
		1,                                             // setLayoutCount
		&layout,                                       // pSetLayouts
		0,                                             // pushConstantRangeCount
		nullptr,                                       // pPushConstantRanges
	};

	return driver->vkCreatePipelineLayout(device, &info, 0, out);
}

void Device::DestroyPipelineLayout(VkPipelineLayout pipelineLayout) const
{
	driver->vkDestroyPipelineLayout(device, pipelineLayout, nullptr);
}

VkResult Device::CreateComputePipeline(
		VkShaderModule module, VkPipelineLayout pipelineLayout,
		VkPipeline* out) const
{
	VkComputePipelineCreateInfo info = {
		VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO, // sType
		nullptr,                                        // pNext
		0,                                              // flags
		{
			// stage
			VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // sType
			nullptr,                                             // pNext
			0,                                                   // flags
			VK_SHADER_STAGE_COMPUTE_BIT,                         // stage
			module,                                              // module
			"main",                                              // pName
			nullptr,                                             // pSpecializationInfo
		},
		pipelineLayout, // layout
		0,              // basePipelineHandle
		0,              // basePipelineIndex
	};

	return driver->vkCreateComputePipelines(device, 0, 1, &info, 0, out);
}

void Device::DestroyPipeline(VkPipeline pipeline) const
{
	driver->vkDestroyPipeline(device, pipeline, nullptr);
}

VkResult Device::CreateStorageBufferDescriptorPool(uint32_t descriptorCount,
		VkDescriptorPool* out) const
{
	VkDescriptorPoolSize size = {
		VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, // type
		descriptorCount,                   // descriptorCount
	};

	VkDescriptorPoolCreateInfo info = {
		VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, // sType
		nullptr,                                       // pNext
		0,                                             // flags
		1,                                             // maxSets
		1,                                             // poolSizeCount
		&size,                                         // pPoolSizes
	};

	return driver->vkCreateDescriptorPool(device, &info, 0, out);
}

void Device::DestroyDescriptorPool(VkDescriptorPool descriptorPool) const
{
	driver->vkDestroyDescriptorPool(device, descriptorPool, nullptr);
}

VkResult Device::AllocateDescriptorSet(
		VkDescriptorPool pool, VkDescriptorSetLayout layout,
		VkDescriptorSet* out) const
{
	VkDescriptorSetAllocateInfo info = {
		VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, // sType
		nullptr,                                        // pNext
		pool,                                           // descriptorPool
		1,                                              // descriptorSetCount
		&layout,                                        // pSetLayouts
	};

	return driver->vkAllocateDescriptorSets(device, &info, out);
}

void Device::UpdateStorageBufferDescriptorSets(
		VkDescriptorSet descriptorSet,
		const std::vector<VkDescriptorBufferInfo>& bufferInfos) const
{
	std::vector<VkWriteDescriptorSet> writes;
	writes.reserve(bufferInfos.size());
	for (uint32_t i = 0; i < bufferInfos.size(); i++)
	{
		writes.push_back(VkWriteDescriptorSet{
			VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, // sType
			nullptr,                                // pNext
			descriptorSet,                          // dstSet
			i,                                      // dstBinding
			0,                                      // dstArrayElement
			1,                                      // descriptorCount
			VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,      // descriptorType
			nullptr,                                // pImageInfo
			&bufferInfos[i],                        // pBufferInfo
			nullptr,                                // pTexelBufferView
		});
	}

	driver->vkUpdateDescriptorSets(device, writes.size(), writes.data(), 0, nullptr);
}

VkResult Device::AllocateMemory(size_t size, VkMemoryPropertyFlags flags, VkDeviceMemory* out) const
{
	VkPhysicalDeviceMemoryProperties properties;
	driver->vkGetPhysicalDeviceMemoryProperties(physicalDevice, &properties);

	for(uint32_t type = 0; type < properties.memoryTypeCount; type++)
	{
		if ((flags & properties.memoryTypes[type].propertyFlags) == 0)
		{
			continue;  // Type mismatch
		}

		if (size > properties.memoryHeaps[properties.memoryTypes[type].heapIndex].size)
		{
			continue;  // Too small.
		}

		const VkMemoryAllocateInfo info = {
			VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,  // sType
			nullptr,                                 // pNext
			size,                                    // allocationSize
			type,                                    // memoryTypeIndex
		};

		return driver->vkAllocateMemory(device, &info, 0, out);
	}

    return VK_ERROR_OUT_OF_DEVICE_MEMORY; // TODO: Change to something not made up?
}

void Device::FreeMemory(VkDeviceMemory memory) const
{
	driver->vkFreeMemory(device, memory, nullptr);
}

VkResult Device::MapMemory(VkDeviceMemory memory, VkDeviceSize offset,
		VkDeviceSize size, VkMemoryMapFlags flags, void **ppData) const
{
	return driver->vkMapMemory(device, memory, offset, size, flags, ppData);
}

void Device::UnmapMemory(VkDeviceMemory memory) const
{
	driver->vkUnmapMemory(device, memory);
}

VkResult Device::CreateCommandPool(VkCommandPool* out) const
{
    VkCommandPoolCreateInfo info = {
        VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,  // sType
        nullptr,                                     // pNext
        0,                                           // flags
        queueFamilyIndex,                            // queueFamilyIndex
    };
    return driver->vkCreateCommandPool(device, &info, 0, out);
}

void Device::DestroyCommandPool(VkCommandPool commandPool) const
{
    return driver->vkDestroyCommandPool(device, commandPool, nullptr);
}

VkResult Device::AllocateCommandBuffer(
		VkCommandPool pool, VkCommandBuffer* out) const
{
    VkCommandBufferAllocateInfo info = {
        VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,  // sType
        nullptr,                                         // pNext
        pool,                                            // commandPool
        VK_COMMAND_BUFFER_LEVEL_PRIMARY,                 // level
        1,                                               // commandBufferCount
    };
    return driver->vkAllocateCommandBuffers(device, &info, out);
}

void Device::FreeCommandBuffer(VkCommandPool pool, VkCommandBuffer buffer)
{
	driver->vkFreeCommandBuffers(device, pool, 1, &buffer);
}

VkResult Device::BeginCommandBuffer(
		VkCommandBufferUsageFlags usage, VkCommandBuffer commandBuffer) const
{
    VkCommandBufferBeginInfo info = {
        VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,  // sType
        nullptr,                                      // pNext
        usage,                                        // flags
        nullptr,                                      // pInheritanceInfo
    };

    return driver->vkBeginCommandBuffer(commandBuffer, &info);
}

VkResult Device::QueueSubmitAndWait(VkCommandBuffer commandBuffer) const
{
    VkQueue queue;
    driver->vkGetDeviceQueue(device, queueFamilyIndex, 0, &queue);

    VkSubmitInfo info = {
        VK_STRUCTURE_TYPE_SUBMIT_INFO,  // sType
        nullptr,                        // pNext
        0,                              // waitSemaphoreCount
        nullptr,                        // pWaitSemaphores
        nullptr,                        // pWaitDstStageMask
        1,                              // commandBufferCount
        &commandBuffer,                 // pCommandBuffers
        0,                              // signalSemaphoreCount
        nullptr,                        // pSignalSemaphores
    };

    VkResult result = driver->vkQueueSubmit(queue, 1, &info, 0);
    if (result != VK_SUCCESS)
    {
        return result;
    }

    return driver->vkQueueWaitIdle(queue);
}