/*-------------------------------------------------------------------------
 * Vulkan Conformance Tests
 * ------------------------
 *
 * Copyright (c) 2015 Google Inc.
 * Copyright (c) 2019-2020 NVIDIA Corporation
 *
 * 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.
 *
 *//*!
 * \file
 * \brief Fragment Shading Rate tests
 *//*--------------------------------------------------------------------*/

#include "vktFragmentShadingRateTests.hpp"
#include "vktFragmentShadingRateBasic.hpp"
#include "vktFragmentShadingRatePixelConsistency.hpp"
#include "vktAttachmentRateTests.hpp"
#include "vktTestGroupUtil.hpp"
#include "vktTestCaseUtil.hpp"
#include "tcuTestLog.hpp"
#include <limits>

namespace vkt
{
namespace FragmentShadingRate
{

namespace
{

tcu::TestStatus testLimits(Context& context)
{
	bool			allChecksPassed					= true;
	tcu::TestLog&	log								= context.getTestContext().getLog();
	const auto&		features						= context.getDeviceFeatures();
	const auto&		properties						= context.getDeviceProperties();
	const auto&		vulkan12Features				= context.getDeviceVulkan12Features();
	const auto&		fragmentShadingRateFeatures		= context.getFragmentShadingRateFeatures();
	const auto&		fragmentShadingRateProperties	= context.getFragmentShadingRateProperties();

	if (!fragmentShadingRateFeatures.pipelineFragmentShadingRate)
	{
		log << tcu::TestLog::Message << "pipelineFragmentShadingRate is not supported" << tcu::TestLog::EndMessage;
		allChecksPassed = false;
	}

	if (context.getFragmentShadingRateProperties().primitiveFragmentShadingRateWithMultipleViewports && !context.getFragmentShadingRateFeatures().primitiveFragmentShadingRate)
	{
		log << tcu::TestLog::Message << "primitiveFragmentShadingRateWithMultipleViewports "
										"limit should only be supported if primitiveFragmentShadingRate is supported" << tcu::TestLog::EndMessage;
		allChecksPassed = false;
	}

	bool requiredFeatures = features.geometryShader || vulkan12Features.shaderOutputViewportIndex || context.isDeviceFunctionalitySupported("VK_EXT_shader_viewport_index_layer");
	if (context.getFragmentShadingRateProperties().primitiveFragmentShadingRateWithMultipleViewports && !requiredFeatures)
	{
		log << tcu::TestLog::Message << "primitiveFragmentShadingRateWithMultipleViewports limit should only "
										"be supported if at least one of the geometryShader feature, shaderOutputViewportIndex feature, "
										"or VK_EXT_shader_viewport_index_layer extension is supported" << tcu::TestLog::EndMessage;
		allChecksPassed = false;
	}

	if (fragmentShadingRateProperties.layeredShadingRateAttachments && !fragmentShadingRateFeatures.attachmentFragmentShadingRate)
	{
		log << tcu::TestLog::Message << "layeredShadingRateAttachments should only be supported if attachmentFragmentShadingRate is supported" << tcu::TestLog::EndMessage;
		allChecksPassed = false;
	}

	requiredFeatures = features.geometryShader || context.getMultiviewFeatures().multiview || vulkan12Features.shaderOutputViewportIndex ||
						context.isDeviceFunctionalitySupported("VK_EXT_shader_viewport_index_layer");
	if (fragmentShadingRateProperties.layeredShadingRateAttachments && !requiredFeatures)
	{
		log << tcu::TestLog::Message << "layeredShadingRateAttachments should only be supported if at least one of the geometryShader feature, multiview feature, "
										"shaderOutputViewportIndex feature, or VK_EXT_shader_viewport_index_layer extension is supported" << tcu::TestLog::EndMessage;
		allChecksPassed = false;
	}

	requiredFeatures = fragmentShadingRateFeatures.primitiveFragmentShadingRate || fragmentShadingRateFeatures.attachmentFragmentShadingRate;
	if (fragmentShadingRateProperties.fragmentShadingRateNonTrivialCombinerOps && !requiredFeatures)
	{
		log << tcu::TestLog::Message << "fragmentShadingRateNonTrivialCombinerOps should only be supported if at least one of primitiveFragmentShadingRate "
										"or attachmentFragmentShadingRate is supported" << tcu::TestLog::EndMessage;
		allChecksPassed = false;
	}

	if (fragmentShadingRateProperties.maxFragmentSizeAspectRatio > std::max(fragmentShadingRateProperties.maxFragmentSize.width, fragmentShadingRateProperties.maxFragmentSize.height))
	{
		log << tcu::TestLog::Message << "maxFragmentSizeAspectRatio should be less than or equal to the maximum width / height of maxFragmentSize" << tcu::TestLog::EndMessage;
		allChecksPassed = false;
	}

	if (fragmentShadingRateProperties.maxFragmentSizeAspectRatio < 2)
	{
		log << tcu::TestLog::Message << "maxFragmentSizeAspectRatio should be at least 2" << tcu::TestLog::EndMessage;
		allChecksPassed = false;
	}

	if (!deIntIsPow2(static_cast<int>(fragmentShadingRateProperties.maxFragmentSizeAspectRatio)))
	{
		log << tcu::TestLog::Message << "maxFragmentSizeAspectRatio should be power of 2" << tcu::TestLog::EndMessage;
		allChecksPassed = false;
	}

	if (fragmentShadingRateProperties.fragmentShadingRateWithShaderSampleMask && (fragmentShadingRateProperties.maxFragmentShadingRateCoverageSamples > (properties.limits.maxSampleMaskWords * 32)))
	{
		log << tcu::TestLog::Message << "maxFragmentShadingRateCoverageSamples should be less than or equal maxSampleMaskWords * 32 "
										"if fragmentShadingRateWithShaderSampleMask is supported" << tcu::TestLog::EndMessage;
		allChecksPassed = false;
	}

	deUint32 requiredValue = fragmentShadingRateProperties.maxFragmentSize.width * fragmentShadingRateProperties.maxFragmentSize.height *
								fragmentShadingRateProperties.maxFragmentShadingRateRasterizationSamples;
	if (fragmentShadingRateProperties.maxFragmentShadingRateCoverageSamples > requiredValue)
	{
		log << tcu::TestLog::Message << "maxFragmentShadingRateCoverageSamples should be less than or equal to the product of the width and height of "
										"maxFragmentSize and the samples reported by maxFragmentShadingRateRasterizationSamples" << tcu::TestLog::EndMessage;
		allChecksPassed = false;
	}

	if (fragmentShadingRateProperties.maxFragmentShadingRateCoverageSamples < 16)
	{
		log << tcu::TestLog::Message << "maxFragmentShadingRateCoverageSamples should at least be 16" << tcu::TestLog::EndMessage;
		allChecksPassed = false;
	}

	if (fragmentShadingRateProperties.maxFragmentShadingRateRasterizationSamples < vk::VK_SAMPLE_COUNT_4_BIT)
	{
		log << tcu::TestLog::Message << "maxFragmentShadingRateRasterizationSamples should supports at least VK_SAMPLE_COUNT_4_BIT" << tcu::TestLog::EndMessage;
		allChecksPassed = false;
	}

	if (fragmentShadingRateProperties.fragmentShadingRateWithConservativeRasterization && !context.isDeviceFunctionalitySupported("VK_EXT_conservative_rasterization"))
	{
		log << tcu::TestLog::Message << "fragmentShadingRateWithConservativeRasterization should only be supported if VK_EXT_conservative_rasterization is supported" << tcu::TestLog::EndMessage;
		allChecksPassed = false;
	}

	if (fragmentShadingRateProperties.fragmentShadingRateWithFragmentShaderInterlock && !context.isDeviceFunctionalitySupported("VK_EXT_fragment_shader_interlock"))
	{
		log << tcu::TestLog::Message << "fragmentShadingRateWithFragmentShaderInterlock should only be supported if VK_EXT_fragment_shader_interlock is supported" << tcu::TestLog::EndMessage;
		allChecksPassed = false;
	}

	if (fragmentShadingRateProperties.fragmentShadingRateWithCustomSampleLocations && !context.isDeviceFunctionalitySupported("VK_EXT_sample_locations"))
	{
		log << tcu::TestLog::Message << "fragmentShadingRateWithCustomSampleLocations should only be supported if VK_EXT_sample_locations is supported" << tcu::TestLog::EndMessage;
		allChecksPassed = false;
	}

	if (fragmentShadingRateFeatures.attachmentFragmentShadingRate)
	{
		if ((fragmentShadingRateProperties.maxFragmentShadingRateAttachmentTexelSize.width < 8) ||
			(fragmentShadingRateProperties.maxFragmentShadingRateAttachmentTexelSize.height < 8))
		{
			log << tcu::TestLog::Message << "maxFragmentShadingRateAttachmentTexelSize should at least be { 8,8 }" << tcu::TestLog::EndMessage;
			allChecksPassed = false;
		}

		if ((fragmentShadingRateProperties.minFragmentShadingRateAttachmentTexelSize.width > 32) ||
			(fragmentShadingRateProperties.minFragmentShadingRateAttachmentTexelSize.height > 32))
		{
			log << tcu::TestLog::Message << "minFragmentShadingRateAttachmentTexelSize should't be greater than { 32,32 }" << tcu::TestLog::EndMessage;
			allChecksPassed = false;
		}

		if ((fragmentShadingRateProperties.maxFragmentShadingRateAttachmentTexelSize.width < fragmentShadingRateProperties.minFragmentShadingRateAttachmentTexelSize.width) ||
			(fragmentShadingRateProperties.maxFragmentShadingRateAttachmentTexelSize.height < fragmentShadingRateProperties.minFragmentShadingRateAttachmentTexelSize.height))
		{
			log << tcu::TestLog::Message << "maxFragmentShadingRateAttachmentTexelSize should be greater than or equal to "
				"minFragmentShadingRateAttachmentTexelSize in each dimension" << tcu::TestLog::EndMessage;
			allChecksPassed = false;
		}

		if (!deIntIsPow2(static_cast<int>(fragmentShadingRateProperties.maxFragmentShadingRateAttachmentTexelSize.width)) ||
			!deIntIsPow2(static_cast<int>(fragmentShadingRateProperties.maxFragmentShadingRateAttachmentTexelSize.height)))
		{
			log << tcu::TestLog::Message << "maxFragmentShadingRateAttachmentTexelSize should be power of 2" << tcu::TestLog::EndMessage;
			allChecksPassed = false;
		}

		if (!deIntIsPow2(static_cast<int>(fragmentShadingRateProperties.minFragmentShadingRateAttachmentTexelSize.width)) ||
			!deIntIsPow2(static_cast<int>(fragmentShadingRateProperties.minFragmentShadingRateAttachmentTexelSize.height)))
		{
			log << tcu::TestLog::Message << "minFragmentShadingRateAttachmentTexelSize should be power of 2" << tcu::TestLog::EndMessage;
			allChecksPassed = false;
		}
	}
	else
	{
		if ((fragmentShadingRateProperties.maxFragmentShadingRateAttachmentTexelSize.width != 0) ||
			(fragmentShadingRateProperties.maxFragmentShadingRateAttachmentTexelSize.height != 0))
		{
			log << tcu::TestLog::Message << "maxFragmentShadingRateAttachmentTexelSize should be { 0,0 } when "
											"attachmentFragmentShadingRate is not supported" << tcu::TestLog::EndMessage;
			allChecksPassed = false;
		}

		if ((fragmentShadingRateProperties.minFragmentShadingRateAttachmentTexelSize.width != 0) ||
			(fragmentShadingRateProperties.minFragmentShadingRateAttachmentTexelSize.height != 0))
		{
			log << tcu::TestLog::Message << "minFragmentShadingRateAttachmentTexelSize should be { 0,0 } when "
											"attachmentFragmentShadingRate is not supported" << tcu::TestLog::EndMessage;
			allChecksPassed = false;
		}
	}

	if ((fragmentShadingRateProperties.maxFragmentSize.width < 2) ||
		(fragmentShadingRateProperties.maxFragmentSize.height < 2))
	{
		log << tcu::TestLog::Message << "maxFragmentSize should at least be { 2,2 }" << tcu::TestLog::EndMessage;
		allChecksPassed = false;
	}

	if ((fragmentShadingRateProperties.maxFragmentSize.width > 4) ||
		(fragmentShadingRateProperties.maxFragmentSize.height > 4))
	{
		log << tcu::TestLog::Message << "maxFragmentSize should't be greater than{ 4,4 }" << tcu::TestLog::EndMessage;
		allChecksPassed = false;
	}

	if (allChecksPassed)
		return tcu::TestStatus::pass("pass");
	return tcu::TestStatus::fail("fail");
}

tcu::TestStatus testShadingRates(Context& context)
{
	bool							someChecksFailed					= false;
	tcu::TestLog&					log									= context.getTestContext().getLog();
	const vk::InstanceInterface&	vki									= context.getInstanceInterface();
	vk::VkPhysicalDevice			physicalDevice						= context.getPhysicalDevice();
	const auto&						fragmentShadingRateProperties		= context.getFragmentShadingRateProperties();
	deUint32						supportedFragmentShadingRateCount	= 0;

	vk::VkResult result = vki.getPhysicalDeviceFragmentShadingRatesKHR(physicalDevice, &supportedFragmentShadingRateCount, DE_NULL);
	if ((result != vk::VK_SUCCESS) && (result != vk::VK_ERROR_OUT_OF_HOST_MEMORY))
	{
		someChecksFailed = true;
		log << tcu::TestLog::Message << "vkGetPhysicalDeviceFragmentShadingRatesKHR returned invalid result" << tcu::TestLog::EndMessage;
	}

	std::vector<vk::VkPhysicalDeviceFragmentShadingRateKHR> fragmentShadingRateVect(supportedFragmentShadingRateCount);
	for (auto& fragmentShadingRate : fragmentShadingRateVect)
	{
		fragmentShadingRate.sType = vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR;
		fragmentShadingRate.pNext = DE_NULL;
	}

	// Pass a value of 1 into pFragmentShadingRateCount, and an array of at least length one into pFragmentShadingRates.
	// Check that the returned value is either VK_INCOMPLETE or VK_ERROR_OUT_OF_HOST_MEMORY(and issue a quality warning in the latter case).
	supportedFragmentShadingRateCount = 1u;
	result = vki.getPhysicalDeviceFragmentShadingRatesKHR(physicalDevice, &supportedFragmentShadingRateCount, fragmentShadingRateVect.data());
	if ((result != vk::VK_INCOMPLETE) && (result != vk::VK_ERROR_OUT_OF_HOST_MEMORY))
	{
		someChecksFailed = true;
		log << tcu::TestLog::Message << "vkGetPhysicalDeviceFragmentShadingRatesKHR returned invalid result" << tcu::TestLog::EndMessage;
	}

	// Get all available fragment shading rates
	supportedFragmentShadingRateCount = static_cast<deUint32>(fragmentShadingRateVect.size());
	result = vki.getPhysicalDeviceFragmentShadingRatesKHR(physicalDevice, &supportedFragmentShadingRateCount, fragmentShadingRateVect.data());
	if ((result != vk::VK_SUCCESS) && (result != vk::VK_ERROR_OUT_OF_HOST_MEMORY))
	{
		someChecksFailed = true;
		log << tcu::TestLog::Message << "vkGetPhysicalDeviceFragmentShadingRatesKHR returned invalid result" << tcu::TestLog::EndMessage;
	}

	bool		widthCheckPassed	= true;
	bool		heightCheckPassed	= true;
	deUint32	previousWidth		= std::numeric_limits<deUint32>::max();
	deUint32	previousHeight		= std::numeric_limits<deUint32>::max();

	for (const auto& fsr : fragmentShadingRateVect)
	{
		const auto& fragmentSize = fsr.fragmentSize;

		// Check that rate width and height are power-of-two
		if (!deIntIsPow2(static_cast<int>(fragmentSize.width)) ||
			!deIntIsPow2(static_cast<int>(fragmentSize.height)))
		{
			log << tcu::TestLog::Message << "fragmentSize should be power of 2" << tcu::TestLog::EndMessage;
			someChecksFailed = true;
		}

		// Check that the width and height are less than the values in the maxFragmentSize limit
		if ((fragmentSize.width > fragmentShadingRateProperties.maxFragmentSize.width) ||
			(fragmentSize.height > fragmentShadingRateProperties.maxFragmentSize.height))
		{
			log << tcu::TestLog::Message << "fragmentSize width and height are not less than the values in the maxFragmentSize" << tcu::TestLog::EndMessage;
			someChecksFailed = true;
		}

		if ((fragmentSize.width * fragmentSize.height) == 1)
		{
			// special case for fragmentSize {1, 1}
			if (fsr.sampleCounts != ~0u)
			{
				log << tcu::TestLog::Message << "implementations must support sampleCounts equal to ~0 for fragmentSize {1, 1}" << tcu::TestLog::EndMessage;
				someChecksFailed = true;
			}
		}
		else
		{
			// get highest sample count value
			deUint32 highestSampleCount = 0x80000000;
			while (highestSampleCount)
			{
				if (fsr.sampleCounts & highestSampleCount)
					break;
				highestSampleCount >>= 1;
			}

			// Check that the highest sample count in sampleCounts is less than or equal to maxFragmentShadingRateRasterizationSamples limit
			if (highestSampleCount > static_cast<deUint32>(fragmentShadingRateProperties.maxFragmentShadingRateRasterizationSamples))
			{
				log << tcu::TestLog::Message << "highest sample count value is not less than or equal to the maxFragmentShadingRateRasterizationSamples limit" << tcu::TestLog::EndMessage;
				someChecksFailed = true;
			}

			// Check that the product of the width, height, and highest sample count value is less than the maxFragmentShadingRateCoverageSamples limit
			if ((fragmentSize.width * fragmentSize.height * highestSampleCount) > fragmentShadingRateProperties.maxFragmentShadingRateCoverageSamples)
			{
				log << tcu::TestLog::Message << "product of the width, height, and highest sample count value is not less than the maxFragmentShadingRateCoverageSamples limit" << tcu::TestLog::EndMessage;
				someChecksFailed = true;
			}
		}

		// Check that the entries in the array are ordered first by largest to smallest width, then largest to smallest height
		{
			const deUint32 currentWidth = fragmentSize.width;
			if (widthCheckPassed && (currentWidth > previousWidth))
			{
				log << tcu::TestLog::Message << "vkGetPhysicalDeviceFragmentShadingRatesKHR returned entries that are not ordered by largest to smallest width" << tcu::TestLog::EndMessage;
				widthCheckPassed = false;
			}

			deUint32 currentHeight = fragmentSize.height;
			if (heightCheckPassed)
			{
				// we can check order of height only for entries that have same width
				if (currentWidth == previousWidth)
				{
					if (currentHeight > previousHeight)
					{
						log << tcu::TestLog::Message << "vkGetPhysicalDeviceFragmentShadingRatesKHR returned entries with same width but height is not ordered by largest to smallest" << tcu::TestLog::EndMessage;
						heightCheckPassed = false;
					}
				}
				else
					currentHeight = std::numeric_limits<deUint32>::max();
			}

			previousWidth = currentWidth;
			previousHeight = currentHeight;
		}

		// Check that no two entries in the array have the same fragmentSize.width and fragmentSize.height value
		{
			deUint32 count = 0;
			for (const auto& fsrB : fragmentShadingRateVect)
			{
				if ((fragmentSize.width  == fsrB.fragmentSize.width) &&
					(fragmentSize.height == fsrB.fragmentSize.height))
				{
					if (++count > 1)
					{
						log << tcu::TestLog::Message << "vkGetPhysicalDeviceFragmentShadingRatesKHR returned entries with same fragmentSize" << tcu::TestLog::EndMessage;
						someChecksFailed = true;
						break;
					}
				}
			}
		}

		// Check that 1x1, 1x2, 2x1, and 2x2 rates are supported with sample counts of 1 and 4
		if ((fragmentSize.width < 3) && (fragmentSize.height < 3) &&
			(!(fsr.sampleCounts & vk::VK_SAMPLE_COUNT_1_BIT) || !(fsr.sampleCounts & vk::VK_SAMPLE_COUNT_4_BIT)))
		{
			log << tcu::TestLog::Message << "vkGetPhysicalDeviceFragmentShadingRatesKHR returned 1x1, 1x2, 2x1, and 2x2 rates with sample counts not supporting 1 and 4" << tcu::TestLog::EndMessage;
			someChecksFailed = true;
		}

		// If the framebufferColorSampleCounts limit includes a sample count of 2, ensure that a sample count of 2 is also reported for the 1x1, 1x2, 2x1, and 2x2 rates.
		if (context.getDeviceProperties().limits.framebufferColorSampleCounts & vk::VK_SAMPLE_COUNT_2_BIT)
		{
			if ((fragmentSize.width < 3) && (fragmentSize.height < 3) &&
				!(fsr.sampleCounts & vk::VK_SAMPLE_COUNT_2_BIT))
			{
				log << tcu::TestLog::Message << "vkGetPhysicalDeviceFragmentShadingRatesKHR returned 1x1, 1x2, 2x1, and 2x2 rates with sample counts not supporting 2 while framebufferColorSampleCounts does" << tcu::TestLog::EndMessage;
				someChecksFailed = true;
			}
		}
	}

	if (someChecksFailed || !widthCheckPassed || !heightCheckPassed)
		return tcu::TestStatus::fail("fail");

	return tcu::TestStatus::pass("pass");
}

void checkSupport(Context& context)
{
	context.requireDeviceFunctionality("VK_KHR_fragment_shading_rate");
}

void createMiscTests(tcu::TestContext& testCtx, tcu::TestCaseGroup* parentGroup)
{
	de::MovePtr<tcu::TestCaseGroup> group(new tcu::TestCaseGroup(testCtx, "misc", ""));

	addFunctionCase(group.get(), "limits",			"", checkSupport, testLimits);
	addFunctionCase(group.get(), "shading_rates",	"", checkSupport, testShadingRates);

	parentGroup->addChild(group.release());
}

void createChildren (tcu::TestCaseGroup* group)
{
	tcu::TestContext&	testCtx		= group->getTestContext();

	createMiscTests				(testCtx, group);
	createBasicTests			(testCtx, group);
	createPixelConsistencyTests	(testCtx, group);
	createAttachmentRateTests	(testCtx, group);
}

} // anonymous

tcu::TestCaseGroup* createTests (tcu::TestContext& testCtx)
{
	return createTestGroup(testCtx, "fragment_shading_rate", "Fragment shading rate tests", createChildren);
}

} // FragmentShadingRate
} // vkt