ComboInput/Source/ComboInputEditor/Private/Ed/EdComboActionGraph.cpp

// ©2023 Batty Bovine Productions, LLC. All Rights Reserved.

#include "Ed/EdComboActionGraph.h"

#include "ComboActionGraph.h"
#include "Ed/EdComboActionGraphEdge.h"
#include "Ed/EdComboActionGraphNode.h"
#include "Nodes/ComboActionGraphEdge.h"
#include "Nodes/ComboActionGraphNode.h"
//#include "Helpers/MounteaDialogueGraphEditorHelpers.h"
//#include "Helpers/MounteaDialogueGraphEditorUtilities.h"
//#include "Helpers/MounteaDialogueSystemEditorBFC.h"

DEFINE_LOG_CATEGORY(LogEdComboActionGraph);


void UEdComboActionGraph::RebuildComboActionGraph()
{
	UE_LOG(LogEdComboActionGraph, Warning, TEXT("UEdComboActionGraph::RebuildComboActionGraph has been called"));

	UComboActionGraph *Graph = GetComboActionGraph();

	Clear();

	for (int i = 0; i < Nodes.Num(); ++i)
	{
		if (UEdComboActionGraphNode *EdNode = Cast<UEdComboActionGraphNode>(Nodes[i]))
		{
			if (EdNode->ComboActionGraphNode == nullptr)
				continue;

			UComboActionGraphNode *ComboActionGraphNode = EdNode->ComboActionGraphNode;

			NodeMap.Add(ComboActionGraphNode, EdNode);

			Graph->AllNodes.Add(ComboActionGraphNode);

			//EdNode->SetDialogueNodeIndex( Graph->AllNodes.Find(EdNode->ComboActionGraphNode) );

			for (int PinIdx = 0; PinIdx < EdNode->Pins.Num(); ++PinIdx)
			{
				UEdGraphPin* Pin = EdNode->Pins[PinIdx];

				if (Pin->Direction != EEdGraphPinDirection::EGPD_Output)
					continue;

				for (int LinkToIdx = 0; LinkToIdx < Pin->LinkedTo.Num(); ++LinkToIdx)
				{
					UComboActionGraphNode *ChildNode = nullptr;
					if (UEdComboActionGraphNode *EdNode_Child = Cast<UEdComboActionGraphNode>(Pin->LinkedTo[LinkToIdx]->GetOwningNode()))
					{
						ChildNode = EdNode_Child->ComboActionGraphNode;
					}
					else if (UEdComboActionGraphEdge *EdNode_Edge = Cast<UEdComboActionGraphEdge>(Pin->LinkedTo[LinkToIdx]->GetOwningNode()))
					{
						UEdComboActionGraphNode *Child = EdNode_Edge->GetEndNode();;
						if (Child != nullptr)
						{
							ChildNode = Child->ComboActionGraphNode;
						}
					}

					if (ChildNode != nullptr)
					{
						ComboActionGraphNode->ChildrenNodes.Add(ChildNode);

						ChildNode->ParentNodes.Add(ComboActionGraphNode);
					}
					else
					{
						UE_LOG(LogEdComboActionGraph, Error, TEXT("[RebuildComboActionGraph] Can't find child node"));
					}
				}
			}
		}
		else if (UEdComboActionGraphEdge *EdgeNode = Cast<UEdComboActionGraphEdge>(Nodes[i]))
		{
			UEdComboActionGraphNode *StartNode = EdgeNode->GetStartNode();
			UEdComboActionGraphNode *EndNode = EdgeNode->GetEndNode();
			UComboActionGraphEdge *Edge = EdgeNode->ComboActionGraphEdge;

			if (StartNode == nullptr || EndNode == nullptr || Edge == nullptr)
			{
				UE_LOG(LogEdComboActionGraph, Error, TEXT("[RebuildMounteaDialogueGraph] Add edge failed."));
				continue;
			}

			EdgeMap.Add(Edge, EdgeNode);

			Edge->Graph = Graph;
			Edge->Rename(nullptr, Graph, REN_DontCreateRedirectors | REN_DoNotDirty);
			Edge->StartNode = StartNode->ComboActionGraphNode;
			Edge->EndNode = EndNode->ComboActionGraphNode;
			Edge->StartNode->Edges.Add(Edge->EndNode, Edge);
		}
	}

	for (int i = 0; i < Graph->AllNodes.Num(); ++i)
	{
		UComboActionGraphNode *Node = Graph->AllNodes[i];
		if (Node->ParentNodes.Num() == 0)
		{
			Graph->RootNodes.Add(Node);

			SortNodes(Node);
		}

		Node->Graph = Graph;
		Node->Rename(nullptr, Graph, REN_DontCreateRedirectors | REN_DoNotDirty);
	}

	Graph->RootNodes.Sort([&](const UComboActionGraphNode &L, const UComboActionGraphNode &R)
	{
		UEdComboActionGraphNode* EdNode_LNode = NodeMap[&L];
		UEdComboActionGraphNode* EdNode_RNode = NodeMap[&R];
		return EdNode_LNode->NodePosX < EdNode_RNode->NodePosX;
	});
}

UComboActionGraph *UEdComboActionGraph::GetComboActionGraph() const
{
	return CastChecked<UComboActionGraph>(GetOuter());
}

bool UEdComboActionGraph::Modify(bool bAlwaysMarkDirty)
{
	bool Rtn = Super::Modify(bAlwaysMarkDirty);

	this->GetComboActionGraph()->Modify();

	for (int32 i = 0; i < Nodes.Num(); ++i)
	{
		Nodes[i]->Modify();
	}

	return Rtn;
}

void UEdComboActionGraph::PostEditUndo()
{
	NotifyGraphChanged();
	
	Super::PostEditUndo();
}

//void UEdComboActionGraph::SetDialogueEditorPtr(TWeakPtr<FAssetEditor_MounteaDialogueGraph> NewPtr)
//{
//	DialogueEditorPtr = NewPtr;
//}

//bool UEdComboActionGraph::JumpToNode(const UMounteaDialogueGraphNode* Node)
//{
//	return FComboActionGraphEditorUtilities::OpenEditorAndJumpToGraphNode(DialogueEditorPtr, *NodeMap.Find(Node));
//}

void UEdComboActionGraph::Clear()
{
	UComboActionGraph *Graph = this->GetComboActionGraph();

	Graph->ClearGraph();
	this->NodeMap.Reset();
	this->EdgeMap.Reset();

	for (int i = 0; i < this->Nodes.Num(); ++i)
	{
		if (UEdComboActionGraphNode *EdNode = Cast<UEdComboActionGraphNode>(Nodes[i]))
		{
			UComboActionGraphNode *MounteaDialogueGraphNode = EdNode->ComboActionGraphNode;
			MounteaDialogueGraphNode->ParentNodes.Reset();
			MounteaDialogueGraphNode->ChildrenNodes.Reset();
			MounteaDialogueGraphNode->Edges.Reset();
		}
	}
}

void UEdComboActionGraph::SortNodes(UComboActionGraphNode *RootNode)
{
	int Level = 0;
	TArray<UComboActionGraphNode*> CurrLevelNodes = { RootNode };
	TArray<UComboActionGraphNode*> NextLevelNodes;

	while (CurrLevelNodes.Num() != 0)
	{
		int32 LevelWidth = 0;
		for (int i = 0; i < CurrLevelNodes.Num(); ++i)
		{
			UComboActionGraphNode *Node = CurrLevelNodes[i];

			auto Comp = [&](const UComboActionGraphNode &L, const UComboActionGraphNode &R)
			{
				UEdComboActionGraphNode *EdNode_LNode = NodeMap[&L];
				UEdComboActionGraphNode *EdNode_RNode = NodeMap[&R];
				return EdNode_LNode->NodePosX < EdNode_RNode->NodePosX;
			};

			Node->ChildrenNodes.Sort(Comp);
			Node->ParentNodes.Sort(Comp);

			for (int j = 0; j < Node->ChildrenNodes.Num(); ++j)
			{
				NextLevelNodes.Add(Node->ChildrenNodes[j]);
			}
		}

		CurrLevelNodes = NextLevelNodes;
		NextLevelNodes.Reset();
		++Level;
	}
}