#include "RuntimeSnapshotProvider.h"

#include <utility>

RuntimeSnapshotProvider::RuntimeSnapshotProvider(RenderSnapshotBuilder& renderSnapshotBuilder) :
	mRenderSnapshotBuilder(renderSnapshotBuilder)
{
}

bool RuntimeSnapshotProvider::BuildLayerPassFragmentShaderSources(const std::string& layerId, std::vector<ShaderPassBuildSource>& passSources, std::string& error) const
{
	try
	{
		return mRenderSnapshotBuilder.BuildLayerPassFragmentShaderSources(layerId, passSources, error);
	}
	catch (const std::exception& exception)
	{
		error = std::string("RuntimeSnapshotProvider::BuildLayerPassFragmentShaderSources exception: ") + exception.what();
		return false;
	}
	catch (...)
	{
		error = "RuntimeSnapshotProvider::BuildLayerPassFragmentShaderSources threw a non-standard exception.";
		return false;
	}
}

unsigned RuntimeSnapshotProvider::GetMaxTemporalHistoryFrames() const
{
	return mRenderSnapshotBuilder.GetMaxTemporalHistoryFrames();
}

RuntimeSnapshotVersions RuntimeSnapshotProvider::GetVersions() const
{
	return mRenderSnapshotBuilder.GetVersions();
}

void RuntimeSnapshotProvider::AdvanceFrame()
{
	mRenderSnapshotBuilder.AdvanceFrame();
}

RuntimeRenderStateSnapshot RuntimeSnapshotProvider::PublishRenderStateSnapshot(unsigned outputWidth, unsigned outputHeight) const
{
	for (;;)
	{
		const RuntimeSnapshotVersions versionsBefore = GetVersions();
		RuntimeRenderStateSnapshot publishedSnapshot;
		if (TryGetPublishedRenderStateSnapshot(outputWidth, outputHeight, versionsBefore, publishedSnapshot))
			return publishedSnapshot;

		RuntimeRenderStateSnapshot snapshot;
		snapshot.outputWidth = outputWidth;
		snapshot.outputHeight = outputHeight;
		mRenderSnapshotBuilder.BuildLayerRenderStates(outputWidth, outputHeight, snapshot.states);

		const RuntimeSnapshotVersions versionsAfter = GetVersions();
		if (versionsBefore.renderStateVersion == versionsAfter.renderStateVersion &&
			versionsBefore.parameterStateVersion == versionsAfter.parameterStateVersion)
		{
			snapshot.versions = versionsAfter;
			StorePublishedRenderStateSnapshot(snapshot);
			return snapshot;
		}
	}
}

bool RuntimeSnapshotProvider::TryPublishRenderStateSnapshot(unsigned outputWidth, unsigned outputHeight, RuntimeRenderStateSnapshot& snapshot) const
{
	const RuntimeSnapshotVersions versionsBefore = GetVersions();
	if (TryGetPublishedRenderStateSnapshot(outputWidth, outputHeight, versionsBefore, snapshot))
		return true;

	std::vector<RuntimeRenderState> states;
	if (!mRenderSnapshotBuilder.TryBuildLayerRenderStates(outputWidth, outputHeight, states))
		return false;

	const RuntimeSnapshotVersions versionsAfter = GetVersions();
	if (versionsBefore.renderStateVersion != versionsAfter.renderStateVersion ||
		versionsBefore.parameterStateVersion != versionsAfter.parameterStateVersion)
	{
		return false;
	}

	snapshot.outputWidth = outputWidth;
	snapshot.outputHeight = outputHeight;
	snapshot.versions = versionsAfter;
	snapshot.states = std::move(states);
	StorePublishedRenderStateSnapshot(snapshot);
	return true;
}

bool RuntimeSnapshotProvider::TryRefreshPublishedSnapshotParameters(RuntimeRenderStateSnapshot& snapshot) const
{
	const uint64_t expectedRenderStateVersion = snapshot.versions.renderStateVersion;
	if (!mRenderSnapshotBuilder.TryRefreshLayerParameters(snapshot.states))
		return false;

	const RuntimeSnapshotVersions versions = GetVersions();
	if (versions.renderStateVersion != expectedRenderStateVersion)
		return false;

	snapshot.versions = versions;
	StorePublishedRenderStateSnapshot(snapshot);
	return true;
}

void RuntimeSnapshotProvider::RefreshDynamicRenderStateFields(std::vector<RuntimeRenderState>& states) const
{
	mRenderSnapshotBuilder.RefreshDynamicRenderStateFields(states);
}

bool RuntimeSnapshotProvider::TryGetPublishedRenderStateSnapshot(unsigned outputWidth, unsigned outputHeight,
	const RuntimeSnapshotVersions& versions, RuntimeRenderStateSnapshot& snapshot) const
{
	std::lock_guard<std::mutex> lock(mPublishedSnapshotMutex);
	if (!mHasPublishedRenderStateSnapshot ||
		!SnapshotMatches(mPublishedRenderStateSnapshot, outputWidth, outputHeight, versions))
	{
		return false;
	}

	snapshot = mPublishedRenderStateSnapshot;
	return true;
}

void RuntimeSnapshotProvider::StorePublishedRenderStateSnapshot(const RuntimeRenderStateSnapshot& snapshot) const
{
	std::lock_guard<std::mutex> lock(mPublishedSnapshotMutex);
	mPublishedRenderStateSnapshot = snapshot;
	mHasPublishedRenderStateSnapshot = true;
}

bool RuntimeSnapshotProvider::SnapshotMatches(const RuntimeRenderStateSnapshot& snapshot, unsigned outputWidth, unsigned outputHeight,
	const RuntimeSnapshotVersions& versions)
{
	return snapshot.outputWidth == outputWidth &&
		snapshot.outputHeight == outputHeight &&
		snapshot.versions.renderStateVersion == versions.renderStateVersion &&
		snapshot.versions.parameterStateVersion == versions.parameterStateVersion;
}