#include "RuntimeCoordinator.h"

#include "RuntimeStore.h"

RuntimeCoordinator::RuntimeCoordinator(RuntimeStore& runtimeStore) :
	mRuntimeStore(runtimeStore)
{
}

RuntimeCoordinatorResult RuntimeCoordinator::AddLayer(const std::string& shaderId)
{
	std::string error;
	return ApplyStoreMutation(mRuntimeStore.CreateStoredLayer(shaderId, error), error, true, true);
}

RuntimeCoordinatorResult RuntimeCoordinator::RemoveLayer(const std::string& layerId)
{
	std::string error;
	return ApplyStoreMutation(mRuntimeStore.DeleteStoredLayer(layerId, error), error, true, true);
}

RuntimeCoordinatorResult RuntimeCoordinator::MoveLayer(const std::string& layerId, int direction)
{
	std::string error;
	return ApplyStoreMutation(mRuntimeStore.MoveStoredLayer(layerId, direction, error), error, true, true);
}

RuntimeCoordinatorResult RuntimeCoordinator::MoveLayerToIndex(const std::string& layerId, std::size_t targetIndex)
{
	std::string error;
	return ApplyStoreMutation(mRuntimeStore.MoveStoredLayerToIndex(layerId, targetIndex, error), error, true, true);
}

RuntimeCoordinatorResult RuntimeCoordinator::SetLayerBypass(const std::string& layerId, bool bypassed)
{
	std::string error;
	return ApplyStoreMutation(mRuntimeStore.SetStoredLayerBypassState(layerId, bypassed, error), error, true, false);
}

RuntimeCoordinatorResult RuntimeCoordinator::SetLayerShader(const std::string& layerId, const std::string& shaderId)
{
	std::string error;
	return ApplyStoreMutation(mRuntimeStore.SetStoredLayerShaderSelection(layerId, shaderId, error), error, true, false);
}

RuntimeCoordinatorResult RuntimeCoordinator::UpdateLayerParameter(const std::string& layerId, const std::string& parameterId, const JsonValue& newValue)
{
	std::string error;
	return ApplyStoreMutation(mRuntimeStore.SetStoredParameterValue(layerId, parameterId, newValue, error), error, false, false);
}

RuntimeCoordinatorResult RuntimeCoordinator::UpdateLayerParameterByControlKey(const std::string& layerKey, const std::string& parameterKey, const JsonValue& newValue)
{
	std::string error;
	return ApplyStoreMutation(mRuntimeStore.SetStoredParameterValueByControlKey(layerKey, parameterKey, newValue, error), error, false, false);
}

RuntimeCoordinatorResult RuntimeCoordinator::ResetLayerParameters(const std::string& layerId)
{
	std::string error;
	RuntimeCoordinatorResult result = ApplyStoreMutation(mRuntimeStore.ResetStoredLayerParameterValues(layerId, error), error, false, false);
	if (!result.accepted)
		return result;

	result.clearTransientOscState = true;
	result.renderResetScope = RuntimeCoordinatorRenderResetScope::TemporalHistoryAndFeedback;
	return result;
}

RuntimeCoordinatorResult RuntimeCoordinator::SaveStackPreset(const std::string& presetName)
{
	std::string error;
	return ApplyStoreMutation(mRuntimeStore.SaveStackPresetSnapshot(presetName, error), error, false, false);
}

RuntimeCoordinatorResult RuntimeCoordinator::LoadStackPreset(const std::string& presetName)
{
	std::string error;
	return ApplyStoreMutation(mRuntimeStore.LoadStackPresetSnapshot(presetName, error), error, true, false);
}

RuntimeCoordinatorResult RuntimeCoordinator::RequestShaderReload(bool preserveFeedbackState)
{
	return BuildQueuedReloadResult(preserveFeedbackState);
}

RuntimeCoordinatorResult RuntimeCoordinator::HandleRuntimePollFailure(const std::string& error)
{
	RuntimeCoordinatorResult result;
	result.accepted = true;
	result.runtimeStateBroadcastRequired = true;
	result.compileStatusChanged = true;
	result.compileStatusSucceeded = false;
	result.compileStatusMessage = error;
	return result;
}

RuntimeCoordinatorResult RuntimeCoordinator::HandlePreparedShaderBuildFailure(const std::string& error)
{
	mPreserveFeedbackOnNextShaderBuild = false;
	mUseCommittedLayerStates = true;

	RuntimeCoordinatorResult result;
	result.accepted = true;
	result.runtimeStateBroadcastRequired = true;
	result.compileStatusChanged = true;
	result.compileStatusSucceeded = false;
	result.compileStatusMessage = error;
	result.committedStateMode = RuntimeCoordinatorCommittedStateMode::UseCommittedStates;
	return result;
}

RuntimeCoordinatorResult RuntimeCoordinator::HandlePreparedShaderBuildSuccess()
{
	mUseCommittedLayerStates = false;

	RuntimeCoordinatorResult result;
	result.accepted = true;
	result.runtimeStateBroadcastRequired = true;
	result.compileStatusChanged = true;
	result.compileStatusSucceeded = true;
	result.compileStatusMessage = "Shader layers compiled successfully.";
	result.committedStateMode = RuntimeCoordinatorCommittedStateMode::UseLiveSnapshots;
	mPreserveFeedbackOnNextShaderBuild = false;
	return result;
}

RuntimeCoordinatorResult RuntimeCoordinator::HandleRuntimeReloadRequest()
{
	return BuildQueuedReloadResult(false);
}

void RuntimeCoordinator::ApplyCommittedStateMode(RuntimeCoordinatorCommittedStateMode mode)
{
	switch (mode)
	{
	case RuntimeCoordinatorCommittedStateMode::UseCommittedStates:
		mUseCommittedLayerStates = true;
		break;
	case RuntimeCoordinatorCommittedStateMode::UseLiveSnapshots:
		mUseCommittedLayerStates = false;
		break;
	case RuntimeCoordinatorCommittedStateMode::Unchanged:
	default:
		break;
	}
}

bool RuntimeCoordinator::UseCommittedLayerStates() const
{
	return mUseCommittedLayerStates.load();
}

bool RuntimeCoordinator::PreserveFeedbackOnNextShaderBuild() const
{
	return mPreserveFeedbackOnNextShaderBuild;
}

RuntimeCoordinatorResult RuntimeCoordinator::ApplyStoreMutation(bool succeeded, const std::string& errorMessage, bool reloadRequired, bool preserveFeedbackState)
{
	if (!succeeded)
	{
		RuntimeCoordinatorResult result;
		result.accepted = false;
		result.errorMessage = errorMessage;
		return result;
	}

	if (reloadRequired)
		return BuildQueuedReloadResult(preserveFeedbackState);

	return BuildAcceptedNoReloadResult();
}

RuntimeCoordinatorResult RuntimeCoordinator::BuildQueuedReloadResult(bool preserveFeedbackState)
{
	mPreserveFeedbackOnNextShaderBuild = preserveFeedbackState;
	mUseCommittedLayerStates = true;

	RuntimeCoordinatorResult result;
	result.accepted = true;
	result.runtimeStateBroadcastRequired = true;
	result.shaderBuildRequested = true;
	result.compileStatusChanged = true;
	result.compileStatusSucceeded = true;
	result.compileStatusMessage = "Shader rebuild queued.";
	result.clearReloadRequest = true;
	result.committedStateMode = RuntimeCoordinatorCommittedStateMode::UseCommittedStates;
	return result;
}

RuntimeCoordinatorResult RuntimeCoordinator::BuildAcceptedNoReloadResult() const
{
	RuntimeCoordinatorResult result;
	result.accepted = true;
	result.runtimeStateBroadcastRequired = true;
	return result;
}