// Copyright Epic Games, Inc. All Rights Reserved.

#include "EntitySystem/MovieSceneEntitySystemGraphs.h"
#include "EntitySystem/MovieSceneEntitySystem.h"
#include "EntitySystem/MovieSceneEntitySystemLinker.h"
#include "EntitySystem/MovieSceneSystemTaskDependencies.h"
#include "EntitySystem/MovieSceneTaskScheduler.h"

#include "Templates/SubclassOf.h"
#include "Algo/IndexOf.h"
#include "Algo/Reverse.h"
#include "Algo/RemoveIf.h"
#include "Algo/BinarySearch.h"

#include UE_INLINE_GENERATED_CPP_BY_NAME(MovieSceneEntitySystemGraphs)

void FMovieSceneEntitySystemGraphNodes::AddStructReferencedObjects(FReferenceCollector& Collector) const
{
	for (FMovieSceneEntitySystemGraphNode& Node : const_cast<TSparseArray<FMovieSceneEntitySystemGraphNode>&>(Array))
	{
		Collector.AddReferencedObject(Node.System);
	}
}

FMovieSceneEntitySystemGraph::FMovieSceneEntitySystemGraph() = default;
FMovieSceneEntitySystemGraph::~FMovieSceneEntitySystemGraph() = default;

FMovieSceneEntitySystemGraph::FMovieSceneEntitySystemGraph(FMovieSceneEntitySystemGraph&&) = default;
FMovieSceneEntitySystemGraph& FMovieSceneEntitySystemGraph::operator=(FMovieSceneEntitySystemGraph&&) = default;

void FMovieSceneEntitySystemGraph::AddSystem(UMovieSceneEntitySystem* InSystem)
{
	checkf(ReentrancyGuard == 0, TEXT("Attempting to add a system to the graph recursively."));

	checkSlow(InSystem->GetGraphID() == TNumericLimits<uint16>::Max() && Nodes.Array.GetMaxIndex() < TNumericLimits<uint16>::Max() - 1);

	const int32 NewIndex = Nodes.Array.Add(FMovieSceneEntitySystemGraphNode(InSystem));
	check(NewIndex >= 0 && NewIndex < TNumericLimits<uint16>::Max());

	const uint16 NewNodeID = static_cast<uint16>(NewIndex);

	ReferenceGraph.AllocateNode(NewNodeID);

	InSystem->SetGraphID(NewNodeID);

	checkf(!GlobalToLocalNodeIDs.Contains(InSystem->GetGlobalDependencyGraphID()), TEXT("Got more than one instance of a given system class"));
	GlobalToLocalNodeIDs.Add(InSystem->GetGlobalDependencyGraphID(), NewNodeID);

	++SerialNumber;
}

void FMovieSceneEntitySystemGraph::AddReference(UMovieSceneEntitySystem* FromReference, UMovieSceneEntitySystem* ToReference)
{
	const uint16 FromID = FromReference->GetGraphID();
	const uint16 ToID   = ToReference->GetGraphID();

	check(FromID != TNumericLimits<uint16>::Max() && ToID != TNumericLimits<uint16>::Max());

	ReferenceGraph.MakeEdge(FromID, ToID);
}

void FMovieSceneEntitySystemGraph::RemoveReference(UMovieSceneEntitySystem* FromReference, UMovieSceneEntitySystem* ToReference)
{
	const uint16 FromID = FromReference->GetGraphID();
	const uint16 ToID   = ToReference->GetGraphID();

	check(FromID != TNumericLimits<uint16>::Max() && ToID != TNumericLimits<uint16>::Max());

	ReferenceGraph.DestroyEdge(FromID, ToID);
}

void FMovieSceneEntitySystemGraph::RemoveSystem(UMovieSceneEntitySystem* InSystem)
{
	checkf(ReentrancyGuard == 0, TEXT("Attempting to remove a system from the graph recursively."));

	++ReentrancyGuard;

	const uint16 NodeID = InSystem->GetGraphID();
	check(NodeID != TNumericLimits<uint16>::Max());

	ReferenceGraph.RemoveNode(NodeID);

	Nodes.Array.RemoveAt(NodeID);

	InSystem->SetGraphID(TNumericLimits<uint16>::Max());

	GlobalToLocalNodeIDs.Remove(InSystem->GetGlobalDependencyGraphID());

	++SerialNumber;
	--ReentrancyGuard;

	ReferenceGraph.CleanUpDanglingEdges();
}

int32 FMovieSceneEntitySystemGraph::RemoveIrrelevantSystems(UMovieSceneEntitySystemLinker* Linker)
{
	checkf(ReentrancyGuard == 0, TEXT("Attempting to remove a system from the graph recursively."));
	++ReentrancyGuard;

	check(PreviousSerialNumber == SerialNumber);

	int32 NumRemoved = 0;

	UE::MovieScene::FDirectedGraph::FBreadthFirstSearch Search(&ReferenceGraph);

	// Search from all non-intermediate systems and mark systems that are still referenced
	for (const FMovieSceneEntitySystemGraphNode& Node : Nodes.Array)
	{
		const uint16 GraphID = Node.System->GetGraphID();
		if (Search.GetVisited()[GraphID] == false && Node.System->IsRelevant(Linker))
		{
			Search.Search(GraphID);
		}
	}

	const bool bAnyNotVisited = Search.GetVisited().Num() < Nodes.Array.GetMaxIndex() || Search.GetVisited().Find(false) != INDEX_NONE;
	if (bAnyNotVisited)
	{
		for (int32 Index = 0; Index < Nodes.Array.GetMaxIndex(); ++Index)
		{
			if (Nodes.Array.IsAllocated(Index) && Search.GetVisited()[Index] == false)
			{
				const uint16 NodeID = Index;

				ReferenceGraph.RemoveNode(NodeID);

				UMovieSceneEntitySystem* System = Nodes.Array[NodeID].System;
				Nodes.Array.RemoveAt(NodeID);

				// Remove this system from the graph to ensure we are not re-entrant when calling Unlink() on it
				System->SetGraphID(TNumericLimits<uint16>::Max());

				GlobalToLocalNodeIDs.Remove(System->GetGlobalDependencyGraphID());

				System->Unlink();
				++NumRemoved;
			}
		}
	}

	if (NumRemoved > 0)
	{
		++SerialNumber;

		ReferenceGraph.CleanUpDanglingEdges();
	}

	--ReentrancyGuard;
	return NumRemoved;
}

void FMovieSceneEntitySystemGraph::UpdateCache()
{
	using namespace UE::MovieScene;

	if (PreviousSerialNumber == SerialNumber)
	{
		return;
	}

	ReferenceGraph.CleanUpDanglingEdges();

	checkf(!ReferenceGraph.IsCyclic(), TEXT("Cycle detected in system reference graph.\n")
		TEXT("----------------------------------------------------------------------------------\n")
		TEXT("%s\n")
		TEXT("----------------------------------------------------------------------------------\n"),
		*ToString());

	SpawnPhase.Empty();
	InstantiationPhase.Empty();
	SchedulingPhase.Empty();
	EvaluationPhase.Empty();
	FinalizationPhase.Empty();

	TArray<uint16> SortedGlobalNodeIDs;
	for (const FMovieSceneEntitySystemGraphNode& Node : Nodes.Array)
	{
		SortedGlobalNodeIDs.Add(Node.System->GetGlobalDependencyGraphID());
	}
	UMovieSceneEntitySystem::SortByFlowOrder(SortedGlobalNodeIDs);

	TArray<uint16> SortedNodeIDs;
	for (uint16 GlobalNodeID : SortedGlobalNodeIDs)
	{
		SortedNodeIDs.Add(GlobalToLocalNodeIDs[GlobalNodeID]);
	}

	const bool bCombineSchedulingAndEvaluation = !FEntitySystemScheduler::IsCustomSchedulingEnabled();

	for (uint16 NodeID : SortedNodeIDs)
	{
		ESystemPhase SystemPhase = Nodes.Array[NodeID].System->GetPhase();

		if (EnumHasAnyFlags(SystemPhase, ESystemPhase::Spawn))
		{
			SpawnPhase.Emplace(NodeID);
		}
		if (EnumHasAnyFlags(SystemPhase, ESystemPhase::Instantiation))
		{
			InstantiationPhase.Emplace(NodeID);
		}
		if (EnumHasAnyFlags(SystemPhase, ESystemPhase::Scheduling))
		{
			if (bCombineSchedulingAndEvaluation)
			{
				EvaluationPhase.Emplace(NodeID);
			}
			else
			{
				SchedulingPhase.Emplace(NodeID);
			}
		}
		if (EnumHasAnyFlags(SystemPhase, ESystemPhase::Evaluation))
		{
			EvaluationPhase.Emplace(NodeID);
		}
		if (EnumHasAnyFlags(SystemPhase, ESystemPhase::Finalization))
		{
			FinalizationPhase.Emplace(NodeID);
		}
	}

	PreviousSerialNumber = SerialNumber;
}

void FMovieSceneEntitySystemGraph::DebugPrint() const
{
	static constexpr TCHAR FormatString[] =
		TEXT("----------------------------------------------------------------------------------\n")
		TEXT("%s\n")
		TEXT("----------------------------------------------------------------------------------\n");

	GLog->Log(TEXT("Printing debug graph for Entity System Graph (in standard graphviz syntax):"));
	GLog->Log(FString::Printf(FormatString, *ToString()));
}

FString FMovieSceneEntitySystemGraph::ToString() const
{
	using namespace UE::MovieScene;

	TStringBuilder<1024> String;

	String += TEXT("\ndigraph FMovieSceneEntitySystemGraph {\n");
	String += TEXT("\tnode [shape=record,height=.1];\n");

	FString FlowStrings[] = 
	{
		TEXT("\tsubgraph cluster_flow_0 { label=\"Spawn\"; color=\"#0e868c\";\n"),
		TEXT("\tsubgraph cluster_flow_1 { label=\"Instantiation\"; color=\"#96c74c\";\n"),
		TEXT("\tsubgraph cluster_flow_2 { label=\"Evaluation\"; color=\"#6dc74c\";\n"),
		TEXT("\tsubgraph cluster_flow_3 { label=\"Finalization\"; color=\"#aa42f5\";\n"),
	};

	FString ReferenceGraphString = TEXT("\tsubgraph cluster_references { label=\"Explicit Reference Graph (connections imply ownership)\"; color=\"#bfc74c\";\n");

	TBitArray<> FlowFilter[4];
	TBitArray<> ReferencedSystems;

	for (int32 SystemIndex = 0; SystemIndex < this->Nodes.Array.GetMaxIndex(); ++SystemIndex)
	{
		if (Nodes.Array.IsAllocated(SystemIndex))
		{
			UMovieSceneEntitySystem* System = Nodes.Array[SystemIndex].System;

			ESystemPhase SystemPhase = System->GetPhase();
			const uint16 GlobalIndex = System->GetGlobalDependencyGraphID();

			if (EnumHasAnyFlags(SystemPhase, ESystemPhase::Spawn))
			{
				FlowStrings[0] += FString::Printf(TEXT("\t\tflow_node%d_0[label=\"%s\"];\n"), GlobalIndex, *System->GetName());
				FlowFilter[0].PadToNum(GlobalIndex+1, false);
				FlowFilter[0][GlobalIndex] = true;
			}
			if (EnumHasAnyFlags(SystemPhase, ESystemPhase::Instantiation))
			{
				FlowStrings[1] += FString::Printf(TEXT("\t\tflow_node%d_1[label=\"%s\"];\n"), GlobalIndex, *System->GetName());
				FlowFilter[1].PadToNum(GlobalIndex+1, false);
				FlowFilter[1][GlobalIndex] = true;
			}
			if (EnumHasAnyFlags(SystemPhase, ESystemPhase::Evaluation | ESystemPhase::Scheduling))
			{
				FlowStrings[2] += FString::Printf(TEXT("\t\tflow_node%d_2[label=\"%s\"];\n"), GlobalIndex, *System->GetName());
				FlowFilter[2].PadToNum(GlobalIndex+1, false);
				FlowFilter[2][GlobalIndex] = true;
			}
			if (EnumHasAnyFlags(SystemPhase, ESystemPhase::Finalization))
			{
				FlowStrings[3] += FString::Printf(TEXT("\t\tflow_node%d_3[label=\"%s\"];\n"), GlobalIndex, *System->GetName());
				FlowFilter[3].PadToNum(GlobalIndex+1, false);
				FlowFilter[3][GlobalIndex] = true;
			}

			TArrayView<const FDirectionalEdge> ReferenceEdges = ReferenceGraph.GetEdgesFrom(SystemIndex);
			if (ReferenceEdges.Num() > 0)
			{
				ReferencedSystems.PadToNum(SystemIndex+1, false);
				ReferencedSystems[SystemIndex] = true;

				for (FDirectionalEdge Edge : ReferenceEdges)
				{
					ReferencedSystems.PadToNum(Edge.ToNode+1, false);
					ReferencedSystems[Edge.ToNode] = true;
				}
			}
		}
	}

	for (TConstSetBitIterator<> ReferencedSystemIt(ReferencedSystems); ReferencedSystemIt; ++ReferencedSystemIt)
	{
		UMovieSceneEntitySystem* System = Nodes.Array[ReferencedSystemIt.GetIndex()].System;
		const uint16 GlobalIndex = System->GetGlobalDependencyGraphID();

		ReferenceGraphString += FString::Printf(TEXT("\t\treference_node%d[label=\"%s\"];\n"), GlobalIndex, *System->GetName());
	}

	for (FString& FlowString : FlowStrings)
	{
		String += FlowString;
		String += TEXT("\t}\n");
	}
	String += ReferenceGraphString;
	String += TEXT("\t}\n");

	UMovieSceneEntitySystem::PrintFilteredFlowGraph(FlowFilter, String);

	{
		FDirectedGraph::FDiscoverCyclicEdges CyclicEdges(&ReferenceGraph);
		CyclicEdges.Search();

		TArrayView<const FDirectionalEdge> ReferenceEdges = ReferenceGraph.GetEdges();
		for (int32 EdgeIndex = 0; EdgeIndex < ReferenceEdges.Num(); ++EdgeIndex)
		{
			FDirectionalEdge Edge = ReferenceEdges[EdgeIndex];
			const bool bIsCyclic = CyclicEdges.IsCyclic(EdgeIndex);

			const uint16 FromGlobalIndex = Nodes.Array[Edge.FromNode].System->GetGlobalDependencyGraphID();
			const uint16 ToGlobalIndex   = Nodes.Array[Edge.ToNode].System->GetGlobalDependencyGraphID();
			String += FString::Printf(TEXT("\treference_node%d -> reference_node%d [color=\"%s\"];\n"), (int32)FromGlobalIndex, (int32)ToGlobalIndex, bIsCyclic ? TEXT("#FF0000") : TEXT("#3992ad"));
		}
	}

	String += TEXT("}");
	return String.ToString();
}

TArray<UMovieSceneEntitySystem*> FMovieSceneEntitySystemGraph::GetSystems() const
{
	TArray<UMovieSceneEntitySystem*> Systems;
	for (const FMovieSceneEntitySystemGraphNode& Node : Nodes.Array)
	{
		Systems.Add(Node.System);
	}
	return Systems;
}

UMovieSceneEntitySystem* FMovieSceneEntitySystemGraph::FindSystemOfType(TSubclassOf<UMovieSceneEntitySystem> InClassType) const
{
	UClass* ClassType = InClassType.Get();
	for (const FMovieSceneEntitySystemGraphNode& Node : Nodes.Array)
	{
		if (Node.System->GetClass() == ClassType)
		{
			return Node.System;
		}
	}
	return nullptr;
}

int32 FMovieSceneEntitySystemGraph::NumInPhase(UE::MovieScene::ESystemPhase Phase) const
{
	switch (Phase)
	{
	case UE::MovieScene::ESystemPhase::Spawn:         return SpawnPhase.Num();
	case UE::MovieScene::ESystemPhase::Instantiation: return InstantiationPhase.Num();
	case UE::MovieScene::ESystemPhase::Evaluation:    return EvaluationPhase.Num();
	case UE::MovieScene::ESystemPhase::Finalization:  return FinalizationPhase.Num();
	default: ensureMsgf(false, TEXT("Invalid phase specified for execution.")); return 0;
	}
}

void FMovieSceneEntitySystemGraph::ExecutePhase(UE::MovieScene::ESystemPhase Phase, UMovieSceneEntitySystemLinker* Linker, FGraphEventArray& OutTasks)
{
	UpdateCache();

	switch (Phase)
	{
	case UE::MovieScene::ESystemPhase::Spawn:         ExecutePhase(Phase, SpawnPhase,         Linker, OutTasks); break;
	case UE::MovieScene::ESystemPhase::Instantiation: ExecutePhase(Phase, InstantiationPhase, Linker, OutTasks); break;
	case UE::MovieScene::ESystemPhase::Evaluation:    ExecutePhase(Phase, EvaluationPhase,    Linker, OutTasks); break;
	case UE::MovieScene::ESystemPhase::Finalization:  ExecutePhase(Phase, FinalizationPhase,  Linker, OutTasks); break;
	default: ensureMsgf(false, TEXT("Invalid phase specified for execution.")); break;
	}
}

void FMovieSceneEntitySystemGraph::IteratePhase(UE::MovieScene::ESystemPhase Phase, TFunctionRef<void(UMovieSceneEntitySystem*)> InIter)
{
	UpdateCache();

	TArrayView<const uint16> Array;
	switch (Phase)
	{
	case UE::MovieScene::ESystemPhase::Spawn:         Array = SpawnPhase;         break;
	case UE::MovieScene::ESystemPhase::Instantiation: Array = InstantiationPhase; break;
	case UE::MovieScene::ESystemPhase::Scheduling:    Array = SchedulingPhase;    break;
	case UE::MovieScene::ESystemPhase::Evaluation:    Array = EvaluationPhase;    break;
	case UE::MovieScene::ESystemPhase::Finalization:  Array = FinalizationPhase;  break;
	default: ensureMsgf(false, TEXT("Invalid phase specified for iteration."));   return;
	}

	for (uint16 NodeID : Array)
	{
		InIter(Nodes.Array[NodeID].System);
	}
}

template<typename ArrayType>
void FMovieSceneEntitySystemGraph::ExecutePhase(UE::MovieScene::ESystemPhase Phase, const ArrayType& SortedEntries, UMovieSceneEntitySystemLinker* Linker, FGraphEventArray& OutTasks)
{
	using namespace UE::MovieScene;

	const bool bCustomSchedulingEnabled = FEntitySystemScheduler::IsCustomSchedulingEnabled();

	Linker->EntityManager.UpdateThreadingModel();

	const EEntityThreadingModel ThreadingModel = Linker->EntityManager.GetThreadingModel();

	// In a transaction we can only support the no-threading mode.
	check(!AutoRTFM::IsTransactional() || (EEntityThreadingModel::NoThreading == ThreadingModel));

	FSystemSubsequentTasks DownstreamTasks(this, &OutTasks, ThreadingModel);

	FSystemTaskPrerequisites NoPrerequisites;

	const bool bStructureCanChange = !Linker->EntityManager.IsLockedDown();

	for (int32 CurrentIndex = 0; CurrentIndex < SortedEntries.Num(); ++CurrentIndex)
	{
		const uint16 NodeID = SortedEntries[CurrentIndex];

		UMovieSceneEntitySystem* System = Nodes.Array[NodeID].System;
		checkSlow(System);

		// Initialize downstream task structure for this system
		DownstreamTasks.ResetNode(NodeID);

		TSharedPtr<FSystemTaskPrerequisites> Prerequisites = Nodes.Array[NodeID].Prerequisites;
		System->Run(Prerequisites ? *Prerequisites : NoPrerequisites, DownstreamTasks);

		if (bStructureCanChange)
		{
			Linker->AutoLinkRelevantSystems();
		}

		// If we linked any new systems, we may have to move our current offset
		if (SerialNumber != PreviousSerialNumber)
		{
#if DO_CHECK
			// Cache the systems we've already run
			TArray<uint16> HeadList(SortedEntries.GetData(), CurrentIndex+1);
#endif

			// This may actually change the SortedEntries array
			UpdateCache();

			CurrentIndex = Algo::IndexOf(SortedEntries, NodeID);
			checkf(CurrentIndex != INDEX_NONE, TEXT("System has removed itself while being Run. This is not supported."));

#if DO_CHECK
			for (int32 NewIndex = 0; NewIndex < CurrentIndex; ++NewIndex)
			{
				if (!HeadList.Contains(SortedEntries[NewIndex]))
				{
					const uint16 NewNodeIndex     = SortedEntries[NewIndex];
					const uint16 CurrentNodeIndex = SortedEntries[CurrentIndex];
					ensureAlwaysMsgf(false, 
						TEXT("System %s has been inserted upstream of %s in the same execution phase that is currently in-flight, and will not be run this frame. "
							 "This can be either because this system has been newly linked, or because it has been re-ordered due to other newly linked systems."),
						*this->Nodes.Array[NewNodeIndex].System->GetName(),
						*this->Nodes.Array[CurrentNodeIndex].System->GetName()
					);
				}
			}
#endif
		}

		// Don't need prerequisites now
		if (Prerequisites)
		{
			Prerequisites->Empty();
		}

		// Propagate subsequent tasks
		if (DownstreamTasks.Subsequents && DownstreamTasks.Subsequents->Num() != 0)
		{
			SCOPE_CYCLE_COUNTER(MovieSceneEval_SystemDependencyCost)

			TArray<uint16> ToGlobalNodeIDs;
			UMovieSceneEntitySystem::GetSubsequentSystems(System->GetGlobalDependencyGraphID(), ToGlobalNodeIDs);
			for (uint16 ToGlobalNodeID : ToGlobalNodeIDs)
			{
				uint16* ToNodeID = GlobalToLocalNodeIDs.Find(ToGlobalNodeID);
				if (ToNodeID)
				{
					FMovieSceneEntitySystemGraphNode& ToNode = Nodes.Array[*ToNodeID];
					if (EnumHasAnyFlags(ToNode.System->GetPhase(), Phase)
						// If custom scheduling is disabled, allow propagation between evaluation/scheduling phase as well
						|| (!bCustomSchedulingEnabled && Phase == ESystemPhase::Evaluation && EnumHasAnyFlags(ToNode.System->GetPhase(), ESystemPhase::Scheduling))
						)
					{
						if (!ToNode.Prerequisites)
						{
							ToNode.Prerequisites = MakeShared<FSystemTaskPrerequisites>();
						}
						ToNode.Prerequisites->Consume(*DownstreamTasks.Subsequents);
					}
				}
			}

			// Done with subsequents now
			DownstreamTasks.Subsequents->Empty();
		}
	}
}

void FMovieSceneEntitySystemGraph::ReconstructTaskSchedule(UE::MovieScene::FEntityManager* EntityManager)
{
	using namespace UE::MovieScene;

	if (!FEntitySystemScheduler::IsCustomSchedulingEnabled())
	{
		// When disabled, we combine the scheduling phase with the evaluation phase and
		// execute them using the legacy procedural task prerequisites API through OnRun

		return;
	}

	UpdateCache();

	if (!TaskScheduler)
	{
		TaskScheduler = MakeUnique<FEntitySystemScheduler>(EntityManager);
	}

	TaskScheduler->BeginConstruction();

	for (int32 CurrentIndex = 0; CurrentIndex < SchedulingPhase.Num(); ++CurrentIndex)
	{
		const uint16 NodeID = SchedulingPhase[CurrentIndex];

		UMovieSceneEntitySystem* System = Nodes.Array[NodeID].System;
		checkSlow(System);

		// Initilaize downstream task structure for this system
		TaskScheduler->BeginSystem(NodeID);

		System->SchedulePersistentTasks(TaskScheduler.Get());

		// Propagate subsequent tasks
		if (TaskScheduler->HasAnyTasksToPropagateDownstream())
		{
			TArray<uint16> ToGlobalNodeIDs;
			UMovieSceneEntitySystem::GetSubsequentSystems(System->GetGlobalDependencyGraphID(), ToGlobalNodeIDs);
			for (uint16 ToGlobalNodeID : ToGlobalNodeIDs)
			{
				uint16* ToNodeID = GlobalToLocalNodeIDs.Find(ToGlobalNodeID);
				if (ToNodeID)
				{
					TaskScheduler->PropagatePrerequisite(*ToNodeID);
				}
			}
		}

		TaskScheduler->EndSystem(NodeID);
	}

	TaskScheduler->EndConstruction();

	SchedulerSerialNumber = EntityManager->GetSystemSerial();
}

void FMovieSceneEntitySystemGraph::ScheduleTasks(UE::MovieScene::FEntityManager* EntityManager)
{
	// @todo: First off go through and increase the WriteContexts?
	if (TaskScheduler)
	{
		EntityManager->IncrementSystemSerial();

		if (EntityManager->HasStructureChangedSince(SchedulerSerialNumber))
		{
			ReconstructTaskSchedule(EntityManager);
		}

		TaskScheduler->ExecuteTasks();
	}
}

void FMovieSceneEntitySystemGraph::Shutdown()
{
	checkf(ReentrancyGuard == 0, TEXT("Attempting to shutdown the system graph while it is in use."));

	++ReentrancyGuard;

	for (int32 Index = 0; Index < Nodes.Array.GetMaxIndex(); ++Index)
	{
		if (Nodes.Array.IsAllocated(Index))
		{
			Nodes.Array[Index].System->Abandon();
		}
	}

	--ReentrancyGuard;

	*this = FMovieSceneEntitySystemGraph();
}

uint16 FMovieSceneEntitySystemGraph::GetGraphID(const UMovieSceneEntitySystem* InSystem)
{
	return InSystem->GetGraphID();
}