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

#include "BlueprintEditorLibrary.h"

#include "AssetRegistry/AssetRegistryModule.h"
#include "Blueprint/BlueprintExceptionInfo.h"
#include "BlueprintEditorModule.h"
#include "BlueprintEditor.h"
#include "AnimGraphNode_Base.h"
#include "BlueprintFunctionNodeSpawner.h"
#include "BlueprintNodeBinder.h"
#include "BlueprintTypePromotion.h"
#include "Components/TimelineComponent.h"
#include "Containers/EnumAsByte.h"
#include "Containers/Map.h"
#include "EdGraph/EdGraph.h"
#include "EdGraph/EdGraphNode.h"
#include "EdGraph/EdGraphPin.h"
#include "EdGraphNode_Comment.h"
#include "EdGraphSchema_K2.h"
#include "Editor.h"
#include "Editor/EditorEngine.h"
#include "Engine/Blueprint.h"
#include "Engine/SimpleConstructionScript.h"
#include "HAL/FileManager.h"
#include "HAL/PlatformCrt.h"
#include "HAL/PlatformMath.h"
#include "Internationalization/Text.h"
#include "K2Node_CallFunction.h"
#include "K2Node_CommutativeAssociativeBinaryOperator.h"
#include "K2Node_PromotableOperator.h"
#include "Kismet2/BlueprintEditorUtils.h"
#include "Kismet2/Kismet2NameValidators.h"
#include "Kismet2/KismetEditorUtilities.h"
#include "KismetCompilerModule.h"
#include "Logging/LogCategory.h"
#include "Logging/StructuredLog.h"
#include "Math/Vector2D.h"
#include "Misc/AssertionMacros.h"
#include "Misc/EngineVersion.h"
#include "PackageTools.h"
#include "Subsystems/AssetEditorSubsystem.h"
#include "Templates/Casts.h"
#include "Templates/SubclassOf.h"
#include "Trace/Detail/Channel.h"
#include "UObject/Class.h"
#include "UObject/Field.h"
#include "UObject/Object.h"
#include "UObject/ObjectPtr.h"
#include "UObject/UnrealNames.h"
#include "UObject/UnrealType.h"

#define LOCTEXT_NAMESPACE "BlueprintEditorLibrary"

DEFINE_LOG_CATEGORY(LogBlueprintEditorLib);

///////////////////////////////////////////////////////////
// InternalBlueprintEditorLibrary

namespace InternalBlueprintEditorLibrary
{
	/**
	* Replace the OldNode with the NewNode and reconnect it's pins. If the pins don't
	* exist on the NewNode, then orphan the connections.
	*
	* @param OldNode		The old node to replace
	* @param NewNode		The new node to put in the old node's place
	*/
	static bool ReplaceOldNodeWithNew(UEdGraphNode* OldNode, UEdGraphNode* NewNode)
	{
		const UEdGraphSchema_K2* Schema = GetDefault<UEdGraphSchema_K2>();
		
		bool bSuccess = false;

		if (Schema && OldNode && NewNode)
		{
			TMap<FName, FName> OldToNewPinMap;
			for (UEdGraphPin* Pin : OldNode->Pins)
			{
				if (Pin->ParentPin != nullptr)
				{
					// ReplaceOldNodeWithNew() will take care of mapping split pins (as long as the parents are properly mapped)
					continue;
				}
				else if (Pin->PinName == UEdGraphSchema_K2::PN_Self)
				{
					// there's no analogous pin, signal that we're expecting this
					OldToNewPinMap.Add(Pin->PinName, NAME_None);
				}
				else
				{
					// The input pins follow the same naming scheme
					OldToNewPinMap.Add(Pin->PinName, Pin->PinName);
				}
			}
			
			bSuccess = Schema->ReplaceOldNodeWithNew(OldNode, NewNode, OldToNewPinMap);
			// reconstructing the node will clean up any
			// incorrect default values that may have been copied over
			NewNode->ReconstructNode();			
		}

		return bSuccess;
	}

	/**
	* Returns true if any of these nodes pins have any links. Does not check for 
	* a default value on pins
	*
	* @param Node		The node to check
	*
	* @return bool		True if the node has any links, false otherwise.
	*/
	static bool NodeHasAnyConnections(const UEdGraphNode* Node)
	{
		if (Node)
		{
			for (const UEdGraphPin* Pin : Node->Pins)
			{
				if (Pin && Pin->LinkedTo.Num() > 0)
				{
					return true;
				}
			}
		}

		return false;
	}

	/**
	* Attempt to close any open editors that may be relevant to this blueprint. This will prevent any 
	* problems where the user could see a previously deleted node/graph.
	*
	* @param Blueprint		The blueprint that is being edited
	*/
	static void CloseOpenEditors(UBlueprint* Blueprint)
	{
		UAssetEditorSubsystem* AssetSubsystem = GEditor ? GEditor->GetEditorSubsystem<UAssetEditorSubsystem>() : nullptr;
		if (AssetSubsystem && Blueprint)
		{
			AssetSubsystem->CloseAllEditorsForAsset(Blueprint);
		}
	}

	/**
	 * Converts the given EVersionComparison to the BP friendly EAssetSaveVersionComparisonResults type.
	 */
	static EAssetSaveVersionComparisonResults ConvertSaveVersionComparison(const EVersionComparison RawVersionCompare)
	{
		EAssetSaveVersionComparisonResults Result = EAssetSaveVersionComparisonResults::InvalidComparison;
	
		switch (RawVersionCompare)
		{
		case EVersionComparison::Neither:
			Result = EAssetSaveVersionComparisonResults::Identical;
			break;
		case EVersionComparison::First:
			Result = EAssetSaveVersionComparisonResults::Newer;
			break;
		case EVersionComparison::Second:
			Result = EAssetSaveVersionComparisonResults::Older;
			break;
		}

		return Result;
	}
};

///////////////////////////////////////////////////////////
// UBlueprintEditorLibrary

UBlueprintEditorLibrary::UBlueprintEditorLibrary(const FObjectInitializer& ObjectInitializer)
: Super(ObjectInitializer)
{
}

void UBlueprintEditorLibrary::ReplaceVariableReferences(UBlueprint* Blueprint, const FName OldVarName, const FName NewVarName)
{
	if (!Blueprint || OldVarName.IsNone() || NewVarName.IsNone())
	{
		return;
	}

	FBlueprintEditorUtils::RenameVariableReferences(Blueprint, Blueprint->GeneratedClass, OldVarName, NewVarName);
}

UEdGraph* UBlueprintEditorLibrary::FindEventGraph(UBlueprint* Blueprint)
{
	return Blueprint ? FBlueprintEditorUtils::FindEventGraph(Blueprint) : nullptr;
}

void UBlueprintEditorLibrary::CompareAssetSaveVersionTo(const UObject* Asset, const FString& VersionToCheckString, EAssetSaveVersionComparisonResults& Result)
{
	Result = EAssetSaveVersionComparisonResults::InvalidComparison;
	
	if (!Asset)
	{
		UE_LOG(LogBlueprintEditorLib, Error, TEXT("[%hs] 'Asset' is null! Cannot compare to engine version '%s'"), __func__, *VersionToCheckString);
		return;
	}

	FEngineVersion VersionToCheck = {};
	const bool bSuccessfulParse = FEngineVersion::Parse(VersionToCheckString, OUT VersionToCheck);
	if (!bSuccessfulParse)
	{
		UE_LOG(LogBlueprintEditorLib, Error, TEXT("[%hs] 'VersionToCheckString' value of '%s' is not a valid FEngineVersion!"), __func__, *VersionToCheckString);
		return;
	}
	
	// The linker has the data about what engine version was used to save this asset
	FLinkerLoad* Linker = Asset->GetLinker();
	if (!Linker)
	{
		UE_LOG(LogBlueprintEditorLib, Error, TEXT("[%hs] Failed to find the linker for asset '%s'"), __func__, *GetNameSafe(Asset));
		return;
	}

	const FEngineVersion& AssetVersion = Linker->Summary.SavedByEngineVersion;
	
	EVersionComponent* DifferingComponent =  nullptr;
	const EVersionComparison Comparison = FEngineVersionBase::GetNewest(AssetVersion, VersionToCheck, DifferingComponent);

	Result = InternalBlueprintEditorLibrary::ConvertSaveVersionComparison(Comparison);
}

void UBlueprintEditorLibrary::CompareSoftObjectSaveVersionTo(const TSoftObjectPtr<UObject> ObjectToCheck, const FString& VersionToCheckString, EAssetSaveVersionComparisonResults& Result)
{
	Result = EAssetSaveVersionComparisonResults::InvalidComparison;

	if (!ObjectToCheck.IsValid())
	{
		UE_LOG(LogBlueprintEditorLib, Error, TEXT("[%hs] An invalid ObjectToCheck has been provided, cannot compare save versions."), __func__);
		return;
	}
	
	FString AbsolutePackageFilePath;
	const bool bSuccessfulyFoundFile = FPackageName::DoesPackageExist(ObjectToCheck.GetLongPackageName(), OUT &AbsolutePackageFilePath);
	if (!bSuccessfulyFoundFile)
	{
		UE_LOG(LogBlueprintEditorLib, Error, TEXT("[%hs] Failed to find package on disk for soft object '%s'"), __func__, *ObjectToCheck.ToString());
		return;
	}
	
	// Ensure that this is indeed a package file path. This should always be true if the above DoesPackageExist function works.
	if (!ensure(FPackageName::IsPackageFilename(AbsolutePackageFilePath)))
	{
		UE_LOG(LogBlueprintEditorLib, Error, TEXT("[%hs] '%s' is not a package file path! (FPackageName::IsPackageFilename returned false)"), __func__, *AbsolutePackageFilePath);
		return;
	}

	// Make sure we have a valid version to compare to before attempting to open a file reader
	FEngineVersion VersionToCheck = {};
	const bool bSuccessfulParse = FEngineVersion::Parse(VersionToCheckString, OUT VersionToCheck);
	if (!bSuccessfulParse)
	{
		UE_LOG(LogBlueprintEditorLib, Error, TEXT("[%hs] 'VersionToCheckString' value of '%s' is not a valid FEngineVersion!"), __func__, *VersionToCheckString);
		return;
	}
	
	// Create a file reader to load the file and read its package summary data, which has the save version
	TUniquePtr<FArchive> FileReader(IFileManager::Get().CreateFileReader(*AbsolutePackageFilePath));
	if (!FileReader.IsValid())
	{
		UE_LOG(LogBlueprintEditorLib, Error, TEXT("[%hs] Failed to open file reader for path '%s'"), __func__, *AbsolutePackageFilePath);
		return;
	}
	
	FPackageFileSummary FileSummary;
	(*FileReader) << FileSummary;

	// Make sure this is indeed a package
	if (FileSummary.Tag == PACKAGE_FILE_TAG)
	{
		EVersionComponent* DifferingComponent =  nullptr;
		const EVersionComparison Comparison = FEngineVersionBase::GetNewest(FileSummary.SavedByEngineVersion, VersionToCheck, DifferingComponent);
		Result = InternalBlueprintEditorLibrary::ConvertSaveVersionComparison(Comparison);
	}

	// Clean up our file reader, we are done with it
	FileReader->Close();
	FileReader.Reset();
}

FString UBlueprintEditorLibrary::GetSavedByEngineVersion(const UObject* Asset)
{
	static const FString InvalidVersion = TEXT("INVALID");
	if (!Asset)
	{
		UE_LOG(LogBlueprintEditorLib, Error, TEXT("[%hs] 'Asset' is null! Cannot get the 'saved by' engine version"), __func__);
		return InvalidVersion;
	}

	// The linker has the data about what engine version was used to save this asset
	FLinkerLoad* Linker = Asset->GetLinker();
	if (!Linker)
	{
		UE_LOG(LogBlueprintEditorLib, Error, TEXT("[%hs] Failed to find the linker for asset '%s'"), __func__, *GetNameSafe(Asset));
		return InvalidVersion;
	}
	
	const FEngineVersion& AssetSavedVersion = Linker->Summary.SavedByEngineVersion;
	
	return AssetSavedVersion.ToString();
}

FString UBlueprintEditorLibrary::GetCurrentEngineVersion()
{
	return FEngineVersion::Current().ToString();
}

UEdGraph* UBlueprintEditorLibrary::FindGraph(UBlueprint* Blueprint, FName GraphName)
{
	if (Blueprint && !GraphName.IsNone())
	{
		TArray<UEdGraph*> AllGraphs;
		Blueprint->GetAllGraphs(AllGraphs);

		for (UEdGraph* CurrentGraph : AllGraphs)
		{
			if (CurrentGraph->GetFName() == GraphName)
			{
				return CurrentGraph;
			}
		}
	}

	return nullptr;
}

UK2Node_PromotableOperator* CreateOpNode(const FName OpName, UEdGraph* Graph, const int32 AdditionalPins)
{
	if (!Graph)
	{
		return nullptr;
	}

	// The spawner will be null if type promo isn't enabled
	if (UBlueprintFunctionNodeSpawner* Spawner = FTypePromotion::GetOperatorSpawner(OpName))
	{
		// Spawn a new node!
		IBlueprintNodeBinder::FBindingSet Bindings;
		FVector2D SpawnLoc{};
		UK2Node_PromotableOperator* NewOpNode = Cast<UK2Node_PromotableOperator>(Spawner->Invoke(Graph, Bindings, SpawnLoc));
		check(NewOpNode);

		// Add the necessary number of additional pins
		for (int32 i = 0; i < AdditionalPins; ++i)
		{
			NewOpNode->AddInputPin();
		}

		return NewOpNode;
	}

	return nullptr;
}

void UBlueprintEditorLibrary::UpgradeOperatorNodes(UBlueprint* Blueprint)
{
	if (!Blueprint)
	{
		return;
	}

	if (!TypePromoDebug::IsTypePromoEnabled())
	{
		UE_LOG(LogBlueprintEditorLib, Warning, TEXT("Type Promotion is not enabled! Cannot upgrade operator nodes. Set 'BP.TypePromo.IsEnabled' to true and try again."));
		return;
	}

	TArray<UEdGraph*> AllGraphs;
	Blueprint->GetAllGraphs(AllGraphs);
	Blueprint->Modify();

	/**
	* Used to help us restore the default values of any pins that may have changed their types
	* during replacement. 
	*/
	struct FRestoreDefaultsHelper
	{
		FEdGraphPinType PinType {};

		FString DefaultValue = TEXT("");

		TObjectPtr<UObject> DefaultObject = nullptr;

		FText DefaultTextValue = FText::GetEmpty();
	};

	TMap<FName, FRestoreDefaultsHelper> PinTypeMap;

	for (UEdGraph* Graph : AllGraphs)
	{
		check(Graph);

		Graph->Modify();

		for (int32 i = Graph->Nodes.Num() - 1; i >= 0; --i)
		{
			PinTypeMap.Reset();
			
			// Not every function that we want to upgrade is a CommunicativeBinaryOpNode
			// Some are just regular CallFunction nodes; Vector + Float is an example of this
			if (UK2Node_CallFunction* OldOpNode = Cast<UK2Node_CallFunction>(Graph->Nodes[i]))
			{
				UFunction* Func = OldOpNode->GetTargetFunction();
				UEdGraph* OwningGraph = OldOpNode->GetGraph();
				const bool bHadAnyConnections = InternalBlueprintEditorLibrary::NodeHasAnyConnections(OldOpNode);

				// We should only be modifying nodes within the graph that we want
				ensure(OwningGraph == Graph);
				
				// Don't bother with non-promotable functions or things that are already promotable operators
				if (!FTypePromotion::IsFunctionPromotionReady(Func) || OldOpNode->IsA<UK2Node_PromotableOperator>())
				{
					continue;
				}

				// Keep track of the types of anything with a default value so they can be restored
				for (UEdGraphPin* Pin : OldOpNode->Pins)
				{
					if (Pin->Direction == EGPD_Input && Pin->LinkedTo.IsEmpty())
					{
						FRestoreDefaultsHelper RestoreData;
						RestoreData.PinType = Pin->PinType;
						RestoreData.DefaultValue = Pin->DefaultValue;
						RestoreData.DefaultObject = Pin->DefaultObject;
						RestoreData.DefaultTextValue = Pin->DefaultTextValue;

						PinTypeMap.Add(Pin->GetFName(), RestoreData);
					}
				}

				FName OpName = FTypePromotion::GetOpNameFromFunction(Func);

				UK2Node_CommutativeAssociativeBinaryOperator* BinaryOpNode = Cast<UK2Node_CommutativeAssociativeBinaryOperator>(OldOpNode);

				// Spawn a new node!
				UK2Node_PromotableOperator* NewOpNode = CreateOpNode(
					OpName,
					OwningGraph,
					BinaryOpNode ? BinaryOpNode->GetNumberOfAdditionalInputs() : 0
				);

				// If there is a node that is a communicative op node but is not promotable
				// then the node will be null
				if (!NewOpNode)
				{
					UE_LOG(LogBlueprintEditorLib, Warning, TEXT("Failed to spawn new operator node!"));
					continue;
				}

				NewOpNode->NodePosX = OldOpNode->NodePosX;
				NewOpNode->NodePosY = OldOpNode->NodePosY;

				InternalBlueprintEditorLibrary::ReplaceOldNodeWithNew(OldOpNode, NewOpNode);

				for (const TPair<FName, FRestoreDefaultsHelper>& Pair : PinTypeMap)
				{
					const FRestoreDefaultsHelper& OldPinData = Pair.Value;

					if (UEdGraphPin* Pin = NewOpNode->FindPin(Pair.Key))
					{
						if (NewOpNode->CanConvertPinType(Pin))
						{
							NewOpNode->ConvertPinType(Pin, OldPinData.PinType);
							Pin->DefaultValue = OldPinData.DefaultValue;
							Pin->DefaultObject = OldPinData.DefaultObject;
							Pin->DefaultTextValue = OldPinData.DefaultTextValue;
						}
					}
				}

				// Reset the new node to be wild card if there were no connections to the original node.
				// This is necessary because replacing the old node will attempt to reconcile any 
				// default values on the node, which can result in incorrect pin types and a default
				// value that doesn't match. 
				if(!bHadAnyConnections)
				{
					NewOpNode->ResetNodeToWildcard();
				}
			}
		}
	}
}

void UBlueprintEditorLibrary::CompileBlueprint(UBlueprint* Blueprint)
{
	if (Blueprint)
	{
		// Skip saving this to avoid possible tautologies when saving and allow the user to manually save
		EBlueprintCompileOptions Flags = EBlueprintCompileOptions::SkipSave;
		FKismetEditorUtilities::CompileBlueprint(Blueprint, Flags);
	}
}

UEdGraph* UBlueprintEditorLibrary::AddFunctionGraph(UBlueprint* Blueprint, const FString& FuncName)
{
	if (!Blueprint)
	{
		UE_LOG(LogBlueprintEditorLib, Warning, TEXT("Failed to add function graph, ensure that blueprint is not null!"));
		return nullptr;
	}

	// Validate that the given name is appropriate for a new function graph
	FName GraphName;

	if (FKismetNameValidator(Blueprint).IsValid(FuncName) == EValidatorResult::Ok)
	{
		GraphName = FName(*FuncName);
	}
	else
	{
		static const FString NewFunctionString = TEXT("NewFunction");
		GraphName = FBlueprintEditorUtils::FindUniqueKismetName(Blueprint, !FuncName.IsEmpty() ? FuncName : NewFunctionString);
	}

	Blueprint->Modify();
	UEdGraph* NewGraph = FBlueprintEditorUtils::CreateNewGraph(
		Blueprint, 
		GraphName,
		UEdGraph::StaticClass(), 
		UEdGraphSchema_K2::StaticClass()
	);

	FBlueprintEditorUtils::AddFunctionGraph<UFunction>(Blueprint, NewGraph, /* bIsUserCreated = */ true, /* SignatureFromObject = */ nullptr);

	return NewGraph;
}

void UBlueprintEditorLibrary::RemoveFunctionGraph(UBlueprint* Blueprint, FName FuncName)
{
	if (!Blueprint)
	{
		return;
	}

	// Find the function graph of this name
	UEdGraph* FunctionGraph = nullptr;
	for (UEdGraph* Graph : Blueprint->FunctionGraphs)
	{
		if (Graph->GetFName() == FuncName)
		{
			FunctionGraph = Graph;
			break;
		}
	}

	// Remove the function graph if we can
	if (FunctionGraph && FunctionGraph->bAllowDeletion)
	{
		Blueprint->Modify();
		InternalBlueprintEditorLibrary::CloseOpenEditors(Blueprint);
		FBlueprintEditorUtils::RemoveGraph(Blueprint, FunctionGraph, EGraphRemoveFlags::MarkTransient);
	}
	else
	{
		UE_LOG(LogBlueprintEditorLib, Warning, TEXT("Failed to remove function '%s' on blueprint '%s'!"), *FuncName.ToString(), *Blueprint->GetFriendlyName());
	}
}

void UBlueprintEditorLibrary::RemoveUnusedNodes(UBlueprint* Blueprint)
{
	if (!Blueprint)
	{
		return;
	}

	TArray<UEdGraph*> AllGraphs;
	Blueprint->GetAllGraphs(AllGraphs);
	Blueprint->Modify();

	for (UEdGraph* Graph : AllGraphs)
	{
		// Skip non-editable graphs
		if (!Graph || FBlueprintEditorUtils::IsGraphReadOnly(Graph))
		{
			continue;
		}

		Graph->Modify();
		int32 NumNodesRemoved = 0;

		for (int32 i = Graph->Nodes.Num() - 1; i >= 0; --i)
		{
			UEdGraphNode* Node = Graph->Nodes[i];

			// We only want to delete user facing nodes because this is meant 
			// to be a BP refactoring/cleanup tool. Anim graph nodes can still 
			// be valid with no pin connections made to them
			if (Node->CanUserDeleteNode() && 
				!Node->IsA<UAnimGraphNode_Base>() && 
				!Node->IsA<UEdGraphNode_Comment>() &&
				!InternalBlueprintEditorLibrary::NodeHasAnyConnections(Node))
			{
				Node->BreakAllNodeLinks();
				Graph->RemoveNode(Node);
				++NumNodesRemoved;
			}
		}

		// Notify a change to the graph if nodes have been removed
		if (NumNodesRemoved > 0)
		{
			Graph->NotifyGraphChanged();
		}
	}

	FBlueprintEditorUtils::MarkBlueprintAsStructurallyModified(Blueprint);
}

void UBlueprintEditorLibrary::RemoveGraph(UBlueprint* Blueprint, UEdGraph* Graph)
{
	if (!Blueprint || !Graph)
	{
		return;
	}

	InternalBlueprintEditorLibrary::CloseOpenEditors(Blueprint);
	FBlueprintEditorUtils::RemoveGraph(Blueprint, Graph, EGraphRemoveFlags::MarkTransient);
}

void UBlueprintEditorLibrary::RenameGraph(UEdGraph* Graph, const FString& NewNameStr)
{
	if (!Graph)
	{
		UE_LOG(LogBlueprintEditorLib, Warning, TEXT("Invalid graph given, failed to rename!"));
		return;
	}
	
	// Validate that the given name is appropriate for a new function graph
	UBlueprint* BP = FBlueprintEditorUtils::FindBlueprintForGraph(Graph);
	if (!BP)
	{
		UE_LOG(LogBlueprintEditorLib, Warning, TEXT("Failed to find blueprint for graph!"));
		return;
	}

	FString ValidatedNewName;

	if (FKismetNameValidator(BP).IsValid(NewNameStr) == EValidatorResult::Ok)
	{
		ValidatedNewName = NewNameStr;
	}
	else
	{
		static const FString RenamedGraphString = TEXT("NewGraph");
		ValidatedNewName = FBlueprintEditorUtils::FindUniqueKismetName(BP, !NewNameStr.IsEmpty() ? NewNameStr : RenamedGraphString).ToString();
	}

	FBlueprintEditorUtils::RenameGraph(Graph, ValidatedNewName);
}

UBlueprint* UBlueprintEditorLibrary::GetBlueprintAsset(UObject* Object)
{
	return Cast<UBlueprint>(Object);
}

UBlueprint* UBlueprintEditorLibrary::GetBlueprintForClass(UClass* Class, bool& bDoesClassHaveBlueprint)
{
	bDoesClassHaveBlueprint = false;
	if(!Class)
	{
		return nullptr;
	}

	if(UBlueprint* Result = Cast<UBlueprint>(Class->ClassGeneratedBy))
	{
		bDoesClassHaveBlueprint = true;
		return Result;
	}
	return nullptr;
}

void UBlueprintEditorLibrary::RefreshOpenEditorsForBlueprint(const UBlueprint* BP)
{
	// Get any open blueprint editors for this asset and refresh them if they match the given blueprint
	FBlueprintEditorModule& BlueprintEditorModule = FModuleManager::LoadModuleChecked<FBlueprintEditorModule>("Kismet");
	for (TSharedRef<IBlueprintEditor>& Editor : BlueprintEditorModule.GetBlueprintEditors())
	{
		if (TSharedPtr<FBlueprintEditor> BPEditor = StaticCastSharedPtr<FBlueprintEditor>(Editor.ToSharedPtr()))
		{
			if (BPEditor->GetBlueprintObj() == BP)
			{
				BPEditor->RefreshEditors();
			}
		}
	}
}

void UBlueprintEditorLibrary::RefreshAllOpenBlueprintEditors()
{
	FBlueprintEditorModule& BlueprintEditorModule = FModuleManager::LoadModuleChecked<FBlueprintEditorModule>("Kismet");
	for (TSharedRef<IBlueprintEditor>& Editor : BlueprintEditorModule.GetBlueprintEditors())
	{
		Editor->RefreshEditors();
	}
}

void UBlueprintEditorLibrary::ReparentBlueprint(UBlueprint* Blueprint, UClass* NewParentClass)
{
	if (!Blueprint || !NewParentClass)
	{
		UE_LOG(LogBlueprintEditorLib, Warning, TEXT("Failed to reparent blueprint!"));
		return;
	}

	if (NewParentClass == Blueprint->ParentClass)
	{
		UE_LOG(LogBlueprintEditorLib, Warning, TEXT("'%s' is already parented to class '%s'!"), *Blueprint->GetFriendlyName(), *NewParentClass->GetName());
		return;
	}

	// There could be possible data loss if reparenting outside the current class hierarchy
	if (!Blueprint->ParentClass || !NewParentClass->GetDefaultObject()->IsA(Blueprint->ParentClass))
	{
		UE_LOG(LogBlueprintEditorLib, Warning, TEXT("'%s' class hierarchy is changing, there could be possible data loss!"), *Blueprint->GetFriendlyName());
	}

	Blueprint->ParentClass = NewParentClass;

	if (Blueprint->SimpleConstructionScript != nullptr)
	{
		Blueprint->SimpleConstructionScript->ValidateSceneRootNodes();
	}

	FBlueprintEditorUtils::RefreshAllNodes(Blueprint);
	FBlueprintEditorUtils::MarkBlueprintAsModified(Blueprint);

	EBlueprintCompileOptions CompileOptions
	{
			EBlueprintCompileOptions::SkipSave
		|	EBlueprintCompileOptions::UseDeltaSerializationDuringReinstancing
		|	EBlueprintCompileOptions::SkipNewVariableDefaultsDetection
	};

	// If compilation is enabled during PIE/simulation, references to the CDO might be held by a script variable.
	// Thus, we set the flag to direct the compiler to allow those references to be replaced during reinstancing.
	if (GEditor && GEditor->PlayWorld != nullptr)
	{
		CompileOptions |= EBlueprintCompileOptions::IncludeCDOInReferenceReplacement;
	}

	FKismetEditorUtilities::CompileBlueprint(Blueprint, CompileOptions);
}

bool UBlueprintEditorLibrary::GatherUnusedVariables(const UBlueprint* Blueprint, TArray<FProperty*>& OutProperties)
{
	if (!Blueprint)
	{
		return false;
	}

	bool bHasAtLeastOneVariableToCheck = false;

	for (TFieldIterator<FProperty> PropertyIt(Blueprint->SkeletonGeneratedClass, EFieldIteratorFlags::ExcludeSuper); PropertyIt; ++PropertyIt)
	{
		FProperty* Property = *PropertyIt;
		// Don't show delegate properties, there is special handling for these
		const bool bDelegateProp = Property->IsA(FDelegateProperty::StaticClass()) || Property->IsA(FMulticastDelegateProperty::StaticClass());
		const bool bShouldShowProp = (!Property->HasAnyPropertyFlags(CPF_Parm) && Property->HasAllPropertyFlags(CPF_BlueprintVisible) && !bDelegateProp);

		if (bShouldShowProp)
		{
			bHasAtLeastOneVariableToCheck = true;
			FName VarName = Property->GetFName();

			const int32 VarInfoIndex = FBlueprintEditorUtils::FindNewVariableIndex(Blueprint, VarName);
			const bool bHasVarInfo = (VarInfoIndex != INDEX_NONE);

			const FObjectPropertyBase* ObjectProperty = CastField<const FObjectPropertyBase>(Property);
			bool bIsTimeline = ObjectProperty &&
				ObjectProperty->PropertyClass &&
				ObjectProperty->PropertyClass->IsChildOf(UTimelineComponent::StaticClass());
			if (!bIsTimeline && bHasVarInfo && !FBlueprintEditorUtils::IsVariableUsed(Blueprint, VarName))
			{
				OutProperties.Add(Property);
			}
		}
	}

	return bHasAtLeastOneVariableToCheck;
}

int32 UBlueprintEditorLibrary::RemoveUnusedVariables(UBlueprint* Blueprint)
{
	if (!Blueprint)
	{
		return 0;
	}

	// Gather FProperties from this BP and see if we can remove any
	TArray<FProperty*> VariableProperties;
	UBlueprintEditorLibrary::GatherUnusedVariables(Blueprint, VariableProperties);
	
	// No variables can be removed from this blueprint
	if (VariableProperties.Num() == 0)
	{
		return 0;
	}

	// Get the variables by name so that we can bulk remove them and print them out to the log
	TArray<FName> VariableNames;
	FString PropertyList;
	VariableNames.Reserve(VariableProperties.Num());
	for (int32 Index = 0; Index < VariableProperties.Num(); ++Index)
	{
		VariableNames.Add(VariableProperties[Index]->GetFName());
		if (PropertyList.IsEmpty())
		{
			PropertyList = UEditorEngine::GetFriendlyName(VariableProperties[Index]);
		}
		else
		{
			PropertyList += FString::Printf(TEXT(", %s"), *UEditorEngine::GetFriendlyName(VariableProperties[Index]));
		}
	}

	const int32 NumRemovedVars = VariableNames.Num();
	// Remove the variables by name
	FBlueprintEditorUtils::BulkRemoveMemberVariables(Blueprint, VariableNames);

	UE_LOG(LogBlueprintEditorLib, Log, TEXT("The following variable(s) were deleted successfully: %s."), *PropertyList);
	return NumRemovedVars;
}

UClass* UBlueprintEditorLibrary::GeneratedClass(UBlueprint* BlueprintObj)
{
	if (BlueprintObj)
	{
		if(BlueprintObj->GeneratedClass == nullptr)
		{
			UE_LOG(LogBlueprintEditorLib, Warning, TEXT("Blueprint %s does not have a generated class - consider compiling it"), *BlueprintObj->GetPathName());
			return nullptr;
		}
		return BlueprintObj->GeneratedClass->GetAuthoritativeClass();
	}
	return nullptr;
}

void UBlueprintEditorLibrary::SetBlueprintVariableExposeOnSpawn(UBlueprint* Blueprint, const FName& VariableName, bool bExposeOnSpawn)
{
	if (!Blueprint)
	{
		UE_LOG(LogBlueprintEditorLib, Warning, TEXT("Invalid Blueprint!"));
		return;
	}
	
	if (VariableName == NAME_None)
	{
		UE_LOG(LogBlueprintEditorLib, Warning, TEXT("Invalid variable name!"));
		return;
	}
	
	if(bExposeOnSpawn)
	{
		FBlueprintEditorUtils::SetBlueprintVariableMetaData(Blueprint, VariableName, NULL, FBlueprintMetadata::MD_ExposeOnSpawn, TEXT("true"));
	}
	else
	{
		FBlueprintEditorUtils::RemoveBlueprintVariableMetaData(Blueprint, VariableName, NULL, FBlueprintMetadata::MD_ExposeOnSpawn);
	} 
}

UBlueprint* UBlueprintEditorLibrary::CreateBlueprintAssetWithParent(const FString& AssetPath, UClass* ParentClass)
{
	if(!ParentClass)
	{
		UE_LOGFMT(LogBlueprintEditorLib, Warning, "Cannot create a blueprint asset with null parent class");
		return nullptr;
	}
	
	// do not allow inheritance of function library blueprints or native function libraries that already have functions
	// bIsValidFunctionLibrary provides a carve out for UEditorFunctionLibrary and similar sentinel types:
	const bool bIsFunctionLibrary = ParentClass->IsChildOf(UBlueprintFunctionLibrary::StaticClass());
	const bool bIsValidFunctionLibrary = bIsFunctionLibrary && (ParentClass->Children == nullptr && ParentClass->HasAnyClassFlags(CLASS_Native));
	if(bIsFunctionLibrary && !bIsValidFunctionLibrary)
	{
		UE_LOGFMT(LogBlueprintEditorLib, Warning, "Cannot create a blueprint asset from a function library: {ClassPath}", ParentClass->GetPathName());
		return nullptr;
	}

	// Validate base blueprint logic - this enforces 'blueprintable/notblueprintable'
	if(!bIsValidFunctionLibrary && !FKismetEditorUtilities::CanCreateBlueprintOfClass(ParentClass))
	{
		UE_LOGFMT(LogBlueprintEditorLib, Warning, "Not allowed to create blueprint for class: {ClassPath} - is it Blueprintable or IsBlueprintBase?", ParentClass->GetPathName());
		return nullptr;
	}

	// interface classes require special handling - reject them:
	if(ParentClass->HasAnyClassFlags(CLASS_Interface))
	{
		UE_LOGFMT(LogBlueprintEditorLib, Warning, "Cannot create a blueprint asset from an interface: {ClassPath}", ParentClass->GetPathName());
		return nullptr;
	}

	const FString PackageName = UPackageTools::SanitizePackageName(AssetPath);
	UPackage* Existing = FindObject<UPackage>(nullptr, *PackageName);
	if(Existing)
	{
		UE_LOGFMT(LogBlueprintEditorLib, Warning, "Cannot create a blueprint asset because an asset with this name already exists: {PackageName}", PackageName);
		return nullptr;
	}

	UPackage* Pkg = CreatePackage(*PackageName);
	if(!Pkg)
	{	
		UE_LOGFMT(LogBlueprintEditorLib, Warning, "Create Package Failed: {PackageName}", PackageName);
		return nullptr;
	}

	FName BPName = FPackageName::GetShortFName(PackageName);
	
	UClass* BlueprintClass = nullptr;
	UClass* BlueprintGeneratedClass = nullptr;
	IKismetCompilerInterface& KismetCompilerModule = FModuleManager::LoadModuleChecked<IKismetCompilerInterface>("KismetCompiler");
	KismetCompilerModule.GetBlueprintTypesForClass(ParentClass, BlueprintClass, BlueprintGeneratedClass);
	
	UBlueprint* BP = FKismetEditorUtilities::CreateBlueprint(
		ParentClass, 
		Pkg, 
		BPName, 
		bIsFunctionLibrary ? BPTYPE_FunctionLibrary : BPTYPE_Normal, 
		BlueprintClass, 
		BlueprintGeneratedClass);
	ensure(BP); // FKismetEditorUtilities::CreateBlueprint does not return null, if it does we should clean up the UPackage - somehow

	Pkg->SetAssetAccessSpecifier(EAssetAccessSpecifier::Public);

	// Notify the asset registry
	FAssetRegistryModule::AssetCreated(BP);

	// Mark the package dirty...
	Pkg->MarkPackageDirty();
	return BP;
}

void UBlueprintEditorLibrary::SetBlueprintVariableExposeToCinematics(UBlueprint* Blueprint, const FName& VariableName, bool bExposeToCinematics)
{
	if (!Blueprint)
	{
		UE_LOG(LogBlueprintEditorLib, Warning, TEXT("Invalid Blueprint!"));
		return;
	}
	
	if (VariableName == NAME_None)
	{
		UE_LOG(LogBlueprintEditorLib, Warning, TEXT("Invalid variable name!"));
		return;
	}

	FBlueprintEditorUtils::SetInterpFlag(Blueprint, VariableName, bExposeToCinematics);
}

void UBlueprintEditorLibrary::SetBlueprintVariableInstanceEditable(UBlueprint* Blueprint, const FName& VariableName, bool bInstanceEditable)
{
	if (!Blueprint)
	{
		UE_LOG(LogBlueprintEditorLib, Warning, TEXT("Invalid Blueprint!"));
		return;
	}
	
	if (VariableName == NAME_None)
	{
		UE_LOG(LogBlueprintEditorLib, Warning, TEXT("Invalid variable name!"));
		return;
	}
	
	FBlueprintEditorUtils::SetBlueprintOnlyEditableFlag(Blueprint, VariableName, !bInstanceEditable);
}

bool UBlueprintEditorLibrary::Generic_AddMemberVariableWithValue(UBlueprint* Blueprint, FName MemberName, const uint8* DefaultValuePtr, const FProperty* DefaultValueProp)
{
	if(!Blueprint)
	{
		UE_LOG(LogBlueprintEditorLib, Warning, TEXT("Attempted to add member variable to null blueprint"));
		return false;	
	}

	const UEdGraphSchema_K2* Schema = GetDefault<UEdGraphSchema_K2>();
	FEdGraphPinType PinType;
	if( !Schema->ConvertPropertyToPinType(DefaultValueProp, PinType) )
	{
		return false;
	}

	FString ValueAsString;
	bool bGotDefaultValue = DefaultValueProp->ExportText_Direct(ValueAsString, DefaultValuePtr, DefaultValuePtr, nullptr, PPF_None);
	if(!bGotDefaultValue)
	{
		UE_LOGFMT(LogBlueprintEditorLib, Warning, 
			"Could not export the provided default value, variable {0} added to {1} will have incorrect default", 
			MemberName, Blueprint->GetPathName());
	}

	FName VarName = FBlueprintEditorUtils::FindUniqueKismetName(Blueprint, MemberName.ToString(), Blueprint->SkeletonGeneratedClass);
	return FBlueprintEditorUtils::AddMemberVariable(Blueprint, VarName, PinType, ValueAsString);
}

DEFINE_FUNCTION(UBlueprintEditorLibrary::execAddMemberVariableWithValue)
{
	P_GET_OBJECT(UBlueprint, Blueprint);
	P_GET_PROPERTY(FNameProperty, MemberName);
	
	Stack.StepCompiledIn<FProperty>(nullptr);
	const FProperty* DefaultValueProp = Stack.MostRecentProperty;
	const uint8* DefaultValuePtr = Stack.MostRecentPropertyAddress;
	P_FINISH;

	if (!DefaultValueProp || !DefaultValuePtr)
	{
		FBlueprintExceptionInfo ExceptionInfo(
			EBlueprintExceptionType::AccessViolation,
			LOCTEXT("AddMemberVariable_MissingValue", "Failed to resolve default value and property type from AddMemberVariable.")
		);
		FBlueprintCoreDelegates::ThrowScriptException(P_THIS, Stack, ExceptionInfo);
	}

	*(bool*)RESULT_PARAM = P_THIS->Generic_AddMemberVariableWithValue(Blueprint, MemberName, DefaultValuePtr, DefaultValueProp);
}

bool UBlueprintEditorLibrary::AddMemberVariable(UBlueprint* Blueprint, FName MemberName, const FEdGraphPinType& VariableType)
{
	if(!Blueprint)
	{
		UE_LOG(LogBlueprintEditorLib, Warning, TEXT("Attempted to add member variable to null blueprint"));
		return false;	
	}

	return FBlueprintEditorUtils::AddMemberVariable(
		Blueprint, 
		FBlueprintEditorUtils::FindUniqueKismetName(Blueprint, MemberName.ToString(), Blueprint->SkeletonGeneratedClass),
		VariableType);
}

FEdGraphPinType UBlueprintEditorLibrary::GetBasicTypeByName(FName TypeName)
{
	FEdGraphPinType Result;
	const TSet<FName> PrimitiveTypes = {
		UEdGraphSchema_K2::PC_Boolean, 
		UEdGraphSchema_K2::PC_Byte,
		UEdGraphSchema_K2::PC_Int,
		UEdGraphSchema_K2::PC_Int64,
		UEdGraphSchema_K2::PC_Real,
		UEdGraphSchema_K2::PC_Name,
		UEdGraphSchema_K2::PC_String,
		UEdGraphSchema_K2::PC_Text,
	};
	if(!PrimitiveTypes.Contains(TypeName))
	{
		UE_LOG(LogBlueprintEditorLib, Warning, TEXT("Primitive type: %s not recognized, defaulting to int"), *TypeName.ToString());
		TypeName = UEdGraphSchema_K2::PC_Int;
	}
	Result.PinCategory = TypeName;
	if(TypeName == UEdGraphSchema_K2::PC_Real)
	{
		Result.PinSubCategory = UEdGraphSchema_K2::PC_Double;
	}
	return Result;
}
	
FEdGraphPinType UBlueprintEditorLibrary::GetStructType(const UScriptStruct* StructType)
{
	if(	StructType == nullptr || 
		!UEdGraphSchema_K2::IsAllowableBlueprintVariableType(StructType))
	{
		UE_LOG(LogBlueprintEditorLib, Warning, TEXT("Struct type: %s not allowed, defaulting to int"), StructType ? *StructType->GetPathName() : TEXT("null"));
		return GetBasicTypeByName(UEdGraphSchema_K2::PC_Int);
	}
	
	FEdGraphPinType Result;
	Result.PinCategory = UEdGraphSchema_K2::PC_Struct;
	// the struct here is notionally const, and via PinSubCategoryObject should be extremely rare if they exist:
	Result.PinSubCategoryObject = const_cast<UScriptStruct*>(StructType);
	return Result;
}
	
FEdGraphPinType UBlueprintEditorLibrary::GetClassReferenceType(const UClass* ClassType)
{
	if(	ClassType == nullptr || 
		!UEdGraphSchema_K2::IsAllowableBlueprintVariableType(ClassType))
	{
		UE_LOG(LogBlueprintEditorLib, Warning, TEXT("Class type: %s not allowed, defaulting to int"), ClassType ? *ClassType->GetPathName() : TEXT("null"));
		return GetBasicTypeByName(UEdGraphSchema_K2::PC_Int);
	}
	
	FEdGraphPinType Result;
	Result.PinCategory = UEdGraphSchema_K2::PC_Class;
	// the class here is notionally const, and via PinSubCategoryObject should be extremely rare if they exist:
	Result.PinSubCategoryObject = const_cast<UClass*>(ClassType);
	return Result;
}
	
FEdGraphPinType UBlueprintEditorLibrary::GetObjectReferenceType(const UClass* ObjectType)
{
	if(	ObjectType == nullptr || 
		!UEdGraphSchema_K2::IsAllowableBlueprintVariableType(ObjectType))
	{
		UE_LOG(LogBlueprintEditorLib, Warning, TEXT("Object reference type: %s not allowed, defaulting to int"), ObjectType ? *ObjectType->GetPathName() : TEXT("null"));
		return GetBasicTypeByName(UEdGraphSchema_K2::PC_Int);
	}
	
	FEdGraphPinType Result;
	Result.PinCategory = UEdGraphSchema_K2::PC_Object;
	// the struct here is notionally const, and via PinSubCategoryObject should be extremely rare if they exist:
	Result.PinSubCategoryObject = const_cast<UClass*>(ObjectType);
	return Result;
}
	
FEdGraphPinType UBlueprintEditorLibrary::GetArrayType(const FEdGraphPinType& ContainedType)
{
	if(ContainedType.IsContainer())
	{
		UE_LOG(LogBlueprintEditorLib, Warning, TEXT("Containers cannot be nested directly, an intermediate struct type must be created. Defaulting to int"));
		return GetBasicTypeByName(UEdGraphSchema_K2::PC_Int);
	}

	FEdGraphPinType Result = ContainedType;
	Result.ContainerType = EPinContainerType::Array;
	return Result;
}
	
FEdGraphPinType UBlueprintEditorLibrary::GetSetType(const FEdGraphPinType& ContainedType)
{
	if(ContainedType.IsContainer())
	{
		UE_LOG(LogBlueprintEditorLib, Warning, TEXT("Containers cannot be nested directly, an intermediate struct type must be created. Defaulting to int"));
		return GetBasicTypeByName(UEdGraphSchema_K2::PC_Int);
	}

	if(!FBlueprintEditorUtils::HasGetTypeHash(ContainedType))
	{
		UE_LOG(LogBlueprintEditorLib, Warning, TEXT("Key type must be hashable. Defaulting to int"));
		return GetBasicTypeByName(UEdGraphSchema_K2::PC_Int);
	}

	FEdGraphPinType Result= ContainedType;
	Result.ContainerType = EPinContainerType::Set;
	return Result;
}
	
FEdGraphPinType UBlueprintEditorLibrary::GetMapType(const FEdGraphPinType& KeyType,const FEdGraphPinType& ValueType)
{
	if(KeyType.IsContainer())
	{
		UE_LOG(LogBlueprintEditorLib, Warning, TEXT("Containers cannot be used as a key type, an intermediate struct type must be created. Defaulting to int"));
		return GetBasicTypeByName(UEdGraphSchema_K2::PC_Int);
	}

	if(ValueType.IsContainer())
	{
		UE_LOG(LogBlueprintEditorLib, Warning, TEXT("Containers cannot be as a value type, an intermediate struct type must be created. Defaulting to int"));
		return GetBasicTypeByName(UEdGraphSchema_K2::PC_Int);
	}

	if(!FBlueprintEditorUtils::HasGetTypeHash(KeyType))
	{
		UE_LOG(LogBlueprintEditorLib, Warning, TEXT("Key type must be hashable. Defaulting to int"));
		return GetBasicTypeByName(UEdGraphSchema_K2::PC_Int);
	}

	FEdGraphPinType Result = KeyType;
	Result.ContainerType = EPinContainerType::Map;
	Result.PinValueType = FEdGraphTerminalType::FromPinType(ValueType);
	return Result;
}

#undef LOCTEXT_NAMESPACE	// "BlueprintEditorLibrary"