#include "SupportedShaderCatalog.h"

#include <iostream>
#include <string>

namespace
{
int gFailures = 0;

void Expect(bool condition, const std::string& message)
{
	if (condition)
		return;

	++gFailures;
	std::cerr << "FAIL: " << message << "\n";
}

ShaderPackage MakeSinglePassPackage()
{
	ShaderPackage shaderPackage;
	shaderPackage.id = "supported";
	ShaderPassDefinition pass;
	pass.id = "main";
	pass.entryPoint = "mainImage";
	pass.sourcePath = "shader.slang";
	pass.outputName = "layerOutput";
	shaderPackage.passes.push_back(pass);
	return shaderPackage;
}

void SupportsSinglePassStatelessPackage()
{
	const ShaderPackage shaderPackage = MakeSinglePassPackage();
	const RenderCadenceCompositor::ShaderSupportResult result =
		RenderCadenceCompositor::CheckStatelessSinglePassShaderSupport(shaderPackage);

	Expect(result.supported, "single-pass stateless packages should be supported");
	Expect(result.reason.empty(), "supported packages should not report a rejection reason");
}

void SupportsStatelessNamedPassPackage()
{
	ShaderPackage shaderPackage = MakeSinglePassPackage();
	shaderPackage.passes.front().outputName = "generatedMask";
	ShaderPassDefinition secondPass;
	secondPass.id = "second";
	secondPass.entryPoint = "mainImage";
	secondPass.sourcePath = "shader.slang";
	secondPass.inputNames.push_back("generatedMask");
	secondPass.outputName = "layerOutput";
	shaderPackage.passes.push_back(secondPass);

	const RenderCadenceCompositor::ShaderSupportResult result =
		RenderCadenceCompositor::CheckStatelessSinglePassShaderSupport(shaderPackage);

	Expect(result.supported, "stateless named-pass packages should be supported");
	Expect(result.reason.empty(), "supported named-pass packages should not report a rejection reason");
}

void RejectsUnknownPassInput()
{
	ShaderPackage shaderPackage = MakeSinglePassPackage();
	shaderPackage.passes.front().inputNames.push_back("missingIntermediate");

	const RenderCadenceCompositor::ShaderSupportResult result =
		RenderCadenceCompositor::CheckStatelessSinglePassShaderSupport(shaderPackage);

	Expect(!result.supported, "packages with unknown pass inputs should be rejected");
	Expect(result.reason.find("unknown input") != std::string::npos, "unknown input rejection should explain the missing named output");
}

void RejectsTemporalPackage()
{
	ShaderPackage shaderPackage = MakeSinglePassPackage();
	shaderPackage.temporal.enabled = true;

	const RenderCadenceCompositor::ShaderSupportResult result =
		RenderCadenceCompositor::CheckStatelessSinglePassShaderSupport(shaderPackage);

	Expect(!result.supported, "temporal packages should be rejected");
	Expect(result.reason.find("temporal") != std::string::npos, "temporal rejection should mention temporal storage");
}

void RejectsTextureAssets()
{
	ShaderPackage shaderPackage = MakeSinglePassPackage();
	ShaderTextureAsset asset;
	asset.id = "lut";
	shaderPackage.textureAssets.push_back(asset);

	const RenderCadenceCompositor::ShaderSupportResult result =
		RenderCadenceCompositor::CheckStatelessSinglePassShaderSupport(shaderPackage);

	Expect(!result.supported, "texture-backed packages should be rejected for now");
	Expect(result.reason.find("texture") != std::string::npos, "texture rejection should mention texture assets");
}

void RejectsTextParameters()
{
	ShaderPackage shaderPackage = MakeSinglePassPackage();
	ShaderParameterDefinition parameter;
	parameter.id = "caption";
	parameter.type = ShaderParameterType::Text;
	shaderPackage.parameters.push_back(parameter);

	const RenderCadenceCompositor::ShaderSupportResult result =
		RenderCadenceCompositor::CheckStatelessSinglePassShaderSupport(shaderPackage);

	Expect(!result.supported, "text-parameter packages should be rejected for now");
	Expect(result.reason.find("text") != std::string::npos, "text rejection should mention text parameters");
}
}

int main()
{
	SupportsSinglePassStatelessPackage();
	SupportsStatelessNamedPassPackage();
	RejectsUnknownPassInput();
	RejectsTemporalPackage();
	RejectsTextureAssets();
	RejectsTextParameters();

	if (gFailures != 0)
	{
		std::cerr << gFailures << " RenderCadenceCompositorSupportedShaderCatalog test failure(s).\n";
		return 1;
	}

	std::cout << "RenderCadenceCompositorSupportedShaderCatalog tests passed.\n";
	return 0;
}