/*
* Copyright (c) <2021> Side Effects Software Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
*    this list of conditions and the following disclaimer.
*
* 2. The name of Side Effects Software may not be used to endorse or
*    promote products derived from this software without specific prior
*    written permission.
*
* THIS SOFTWARE IS PROVIDED BY SIDE EFFECTS SOFTWARE "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
* NO EVENT SHALL SIDE EFFECTS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#include "HoudiniInput.h"

#include "HoudiniEngineRuntime.h"
#include "HoudiniAssetComponent.h"
#include "HoudiniOutput.h"
#include "HoudiniSplineComponent.h"
#include "HoudiniAsset.h"
#include "HoudiniGeoPartObject.h"
#include "HoudiniAssetComponent.h"
#include "HoudiniAssetBlueprintComponent.h"

#include "EngineUtils.h"
#include "Engine/Brush.h"
#include "Engine/Engine.h"
#include "Engine/DataTable.h"
#include "Model.h"
#include "Engine/StaticMesh.h"
#include "Engine/SkeletalMesh.h"
#include "UObject/UObjectGlobals.h"
#include "FoliageType_InstancedStaticMesh.h"

#include "Components/SplineComponent.h"
#include "Components/StaticMeshComponent.h"
#include "Components/InstancedStaticMeshComponent.h"
#include "Landscape.h"

#if WITH_EDITOR

#include "Kismet2/BlueprintEditorUtils.h"
#include "Kismet2/KismetEditorUtilities.h"

#endif

//
UHoudiniInput::UHoudiniInput()
	: Type(EHoudiniInputType::Invalid)
	, PreviousType(EHoudiniInputType::Invalid)
	, AssetNodeId(-1)
	, InputNodeId(-1)
	, InputIndex(0)
	, ParmId(-1)
	, bIsObjectPathParameter(false)
	, bHasChanged(false)
	, bPackBeforeMerge(false)
	, bExportLODs(false)
	, bExportSockets(false)
	, bExportColliders(false)
	, bCookOnCurveChanged(true)
	, bStaticMeshChanged(false)
	, bInputAssetConnectedInHoudini(false)
	, DefaultCurveOffset(0.f)
	, bAddRotAndScaleAttributesOnCurves(false)
	, bIsWorldInputBoundSelector(false)
	, bWorldInputBoundSelectorAutoUpdate(false)
	, UnrealSplineResolution(50.0f)
	, bUpdateInputLandscape(false)
	, LandscapeExportType(EHoudiniLandscapeExportType::Heightfield)
	, bLandscapeExportSelectionOnly(false)
	, bLandscapeAutoSelectComponent(false)
	, bLandscapeExportMaterials(false)
	, bLandscapeExportLighting(false)
	, bLandscapeExportNormalizedUVs(false)
	, bLandscapeExportTileUVs(false)
{
	Name = TEXT("");
	Label = TEXT("");
	SetFlags(RF_Transactional);

	// Geometry inputs always have one null default object
	GeometryInputObjects.Add(nullptr);
	
	KeepWorldTransform = GetDefaultXTransformType();

	const UHoudiniRuntimeSettings * HoudiniRuntimeSettings = GetDefault<UHoudiniRuntimeSettings>();
	UnrealSplineResolution = HoudiniRuntimeSettings ? HoudiniRuntimeSettings->MarshallingSplineResolution : 50.0f;

	bAddRotAndScaleAttributesOnCurves = HoudiniRuntimeSettings ? HoudiniRuntimeSettings->bAddRotAndScaleAttributesOnCurves : false;
}

void
UHoudiniInput::BeginDestroy()
{
	InvalidateData();

	// DO NOT MANUALLY DESTROY OUR INPUT OBJECTS!
	// This messes up unreal's Garbage collection and would cause crashes on duplication

	// Mark all our input objects for destruction
	ForAllHoudiniInputObjectArrays([](TArray<UHoudiniInputObject*>& ObjectArray) {
		ObjectArray.Empty();
	});

	Super::BeginDestroy();
}

#if WITH_EDITOR
void UHoudiniInput::PostEditUndo() 
{
	 Super::PostEditUndo();
	 TArray<UHoudiniInputObject*>* InputObjectsPtr = GetHoudiniInputObjectArray(Type);
	 if (!InputObjectsPtr)
		 return;

	 MarkChanged(true);
	 bool bBlueprintStructureChanged = false;

	 if (HasInputTypeChanged()) 
	 {
		 // If the input type has changed on undo, previousType becomes new type
		 /*   This does not work properly, see the corresponding part in FHoudiniInputDetails::AddInputTypeComboBox(...), after Transaction(...
		 )
		 {
			 EHoudiniInputType NewType = PreviousType;
			 SetInputType(NewType);
		 }
		 */
		 EHoudiniInputType Temp = Type;
		 Type = PreviousType;
		 PreviousType = EHoudiniInputType::Invalid;

		 // If the undo action caused input type changing, treat it as a regular type changing
		 // after set up the new and prev types properly 
		 SetInputType(Temp, bBlueprintStructureChanged);
	 }
	 else
	 {
		 if (Type == EHoudiniInputType::Asset)
		 {
			 // Mark the input asset object as changed, since only undo changing asset will get into here.
			 // The input array will be empty when undo adding asset (only support single asset input object in an input now)
			 for (auto & NextAssetInputObj : *InputObjectsPtr)
			 {
				 if (!NextAssetInputObj || NextAssetInputObj->IsPendingKill())
					 continue;

				 NextAssetInputObj->MarkChanged(true);
			 }
		 }


		 if (Type == EHoudiniInputType::World)
		 {
			 if (WorldInputObjects.Num() == 0 && InputNodeId >= 0)
			 {
				 for (auto & NextNodeId : CreatedDataNodeIds)
				 {
					 if (bCanDeleteHoudiniNodes)
						FHoudiniEngineRuntime::Get().MarkNodeIdAsPendingDelete(NextNodeId, true);
				 }

				 CreatedDataNodeIds.Empty();

				 if (bCanDeleteHoudiniNodes)
					FHoudiniEngineRuntime::Get().MarkNodeIdAsPendingDelete(InputNodeId, true);
				 InputNodeId = -1;
			 }
		 }

		 if (Type == EHoudiniInputType::Curve)
		 {
			 if (PreviousType != EHoudiniInputType::Curve)
			 {
				 for (auto& NextInput : *GetHoudiniInputObjectArray(Type))
				 {
					 UHoudiniInputHoudiniSplineComponent* SplineInput = Cast< UHoudiniInputHoudiniSplineComponent>(NextInput);
					 if (!SplineInput || SplineInput->IsPendingKill())
						 continue;

					 UHoudiniSplineComponent * HoudiniSplineComponent = SplineInput->GetCurveComponent();
					 if (!HoudiniSplineComponent || HoudiniSplineComponent->IsPendingKill())
						 continue;

					 USceneComponent* OuterComponent = Cast<USceneComponent>(GetOuter());

					 // Attach the new Houdini spline component to it's owner
					 HoudiniSplineComponent->RegisterComponent();
					 HoudiniSplineComponent->AttachToComponent(OuterComponent, FAttachmentTransformRules::KeepRelativeTransform);
					 HoudiniSplineComponent->SetVisibility(true, true);
					 HoudiniSplineComponent->SetHoudiniSplineVisible(true);
					 HoudiniSplineComponent->SetHiddenInGame(false, true);
					 HoudiniSplineComponent->MarkChanged(true);
				 }
				 return;
			 }
			 bool bUndoDelete = false;
			 bool bUndoInsert = false;
			 bool bUndoDeletedObjArrayEmptied = false;

			 TArray< USceneComponent* > childActor;
			 UHoudiniAssetComponent* OuterHAC = Cast<UHoudiniAssetComponent>(GetOuter());
			 if (OuterHAC && !OuterHAC->IsPendingKill())
				 childActor = OuterHAC->GetAttachChildren();

			 // Undo delete input objects action
			 for (int Index = 0; Index < GetNumberOfInputObjects(); ++Index)
			 {
				 UHoudiniInputObject* InputObject = (*InputObjectsPtr)[Index];
				 if (!InputObject || InputObject->IsPendingKill())
					 continue;

				 UHoudiniInputHoudiniSplineComponent * HoudiniSplineInputObject = Cast<UHoudiniInputHoudiniSplineComponent>(InputObject);

				 if (!HoudiniSplineInputObject || HoudiniSplineInputObject->IsPendingKill())
					 continue;

				 UHoudiniSplineComponent* SplineComponent = HoudiniSplineInputObject->GetCurveComponent();

				 if (!SplineComponent || SplineComponent->IsPendingKill())
					 continue;

				 // If the last change deleted this curve input, recreate this Houdini Spline input.
				 if (!SplineComponent->GetAttachParent())
				 {
					 bUndoDelete = true;

					 if (!bUndoDeletedObjArrayEmptied)  
						 LastUndoDeletedInputs.Empty();

					 bUndoDeletedObjArrayEmptied = true;

					 UHoudiniSplineComponent * ReconstructedSpline = NewObject<UHoudiniSplineComponent>(
						 GetOuter(), UHoudiniSplineComponent::StaticClass());

					 if (!ReconstructedSpline || ReconstructedSpline->IsPendingKill())
						 continue;

					 ReconstructedSpline->SetFlags(RF_Transactional);
					 ReconstructedSpline->CopyHoudiniData(SplineComponent);

					 UHoudiniInputObject * ReconstructedInputObject = UHoudiniInputHoudiniSplineComponent::Create(
						 ReconstructedSpline, GetOuter(), ReconstructedSpline->GetHoudiniSplineName());
					 UHoudiniInputHoudiniSplineComponent *ReconstructedHoudiniSplineInput = (UHoudiniInputHoudiniSplineComponent*)ReconstructedInputObject;
					 (*InputObjectsPtr)[Index] = ReconstructedHoudiniSplineInput;

					 ReconstructedSpline->RegisterComponent();
					 ReconstructedSpline->SetFlags(RF_Transactional);

					 CreateHoudiniSplineInput(ReconstructedHoudiniSplineInput, true, true, bBlueprintStructureChanged);

					 // Cast the reconstructed Houdini Spline Input to a generic HoudiniInput object.
					 UHoudiniInputObject * ReconstructedHoudiniInput = Cast<UHoudiniInputObject>(ReconstructedHoudiniSplineInput);

					 LastUndoDeletedInputs.Add(ReconstructedHoudiniInput);
					 // Reset the LastInsertedInputsArray for redoing this undo action.
				 }
			 }

			 if (bUndoDelete)
				 return;

			 // Undo insert input objects action
			 for (int Index = 0; Index < LastInsertedInputs.Num(); ++Index)
			 {
				 bUndoInsert = true;
				 UHoudiniInputHoudiniSplineComponent* SplineInputComponent = LastInsertedInputs[Index];
				 if (!SplineInputComponent || SplineInputComponent->IsPendingKill()) 
					 continue;

				 UHoudiniSplineComponent* HoudiniSplineComponent = SplineInputComponent->GetCurveComponent();
				 if (!HoudiniSplineComponent || HoudiniSplineComponent->IsPendingKill()) 
					 continue;

				 HoudiniSplineComponent->DestroyComponent();
			 }

			 if (bUndoInsert)
				 return;

			 for (int Index = 0; Index < LastUndoDeletedInputs.Num(); ++Index)
			 {
				 UHoudiniInputObject* NextInputObject = LastUndoDeletedInputs[Index];

				 UHoudiniInputHoudiniSplineComponent* SplineInputComponent = Cast<UHoudiniInputHoudiniSplineComponent>(NextInputObject);
				 if (!SplineInputComponent || SplineInputComponent->IsPendingKill())
					 continue;

				 UHoudiniSplineComponent* HoudiniSplineComponent = SplineInputComponent->GetCurveComponent();
				 if (!HoudiniSplineComponent || SplineInputComponent->IsPendingKill())
					 continue;

				 FDetachmentTransformRules DetachTransRules(EDetachmentRule::KeepRelative, EDetachmentRule::KeepRelative, EDetachmentRule::KeepRelative, false);
				 HoudiniSplineComponent->DetachFromComponent(DetachTransRules);

				 HoudiniSplineComponent->DestroyComponent();
			 }
		 }
	 }

	 if (bBlueprintStructureChanged)
	 {
		 UHoudiniAssetComponent* OuterHAC = Cast<UHoudiniAssetComponent>(GetOuter());
		 FHoudiniEngineRuntimeUtils::MarkBlueprintAsStructurallyModified(OuterHAC);
	 }

}
#endif


FBox 
UHoudiniInput::GetBounds() const 
{
	FBox BoxBounds(ForceInitToZero);

	switch (Type)
	{
	case EHoudiniInputType::Curve:
	{
		for (int32 Idx = 0; Idx < CurveInputObjects.Num(); ++Idx)
		{
			const UHoudiniInputHoudiniSplineComponent* CurInCurve = Cast<UHoudiniInputHoudiniSplineComponent>(CurveInputObjects[Idx]);
			if (!CurInCurve || CurInCurve->IsPendingKill())
				continue;

			UHoudiniSplineComponent* CurCurve = CurInCurve->GetCurveComponent();
			if (!CurCurve || CurCurve->IsPendingKill())
				continue;

			FBox CurCurveBound(ForceInitToZero);
			for (auto & Trans : CurCurve->CurvePoints)
			{
				CurCurveBound += Trans.GetLocation();
			}

			UHoudiniAssetComponent* OuterHAC = Cast<UHoudiniAssetComponent>(GetOuter());

			if (OuterHAC && !OuterHAC->IsPendingKill())
				BoxBounds += CurCurveBound.MoveTo(OuterHAC->GetComponentLocation());
		}
	}
	break;

	case EHoudiniInputType::Asset:
	{
		for (int32 Idx = 0; Idx < AssetInputObjects.Num(); ++Idx)
		{
			UHoudiniInputHoudiniAsset* CurInAsset = Cast<UHoudiniInputHoudiniAsset>(AssetInputObjects[Idx]);
			if (!CurInAsset || CurInAsset->IsPendingKill())
				continue;

			UHoudiniAssetComponent* CurInHAC = CurInAsset->GetHoudiniAssetComponent();
			if (!CurInHAC || CurInHAC->IsPendingKill())
				continue;

			BoxBounds += CurInHAC->GetAssetBounds(nullptr, false);
		}
	}
	break;

	case EHoudiniInputType::World:
	{
		for (int32 Idx = 0; Idx < WorldInputObjects.Num(); ++Idx)
		{
			UHoudiniInputActor* CurInActor = Cast<UHoudiniInputActor>(WorldInputObjects[Idx]);
			if (CurInActor && !CurInActor->IsPendingKill())
			{
				AActor* Actor = CurInActor->GetActor();
				if (!Actor || Actor->IsPendingKill())
					continue;

				FVector Origin, Extent;
				Actor->GetActorBounds(false, Origin, Extent);

				BoxBounds += FBox::BuildAABB(Origin, Extent);
			}
			else
			{
				// World Input now also support HoudiniAssets
				UHoudiniInputHoudiniAsset* CurInAsset = Cast<UHoudiniInputHoudiniAsset>(WorldInputObjects[Idx]);
				if (CurInAsset && !CurInAsset->IsPendingKill())
				{
					UHoudiniAssetComponent* CurInHAC = CurInAsset->GetHoudiniAssetComponent();
					if (!CurInHAC || CurInHAC->IsPendingKill())
						continue;

					BoxBounds += CurInHAC->GetAssetBounds(nullptr, false);
					continue;
				}
			}
		}
	}
	break;

	case EHoudiniInputType::Landscape:
	{
		for (int32 Idx = 0; Idx < LandscapeInputObjects.Num(); ++Idx)
		{
			UHoudiniInputLandscape* CurInLandscape = Cast<UHoudiniInputLandscape>(LandscapeInputObjects[Idx]);
			if (!CurInLandscape || CurInLandscape->IsPendingKill())
				continue;

			ALandscapeProxy* CurLandscape = CurInLandscape->GetLandscapeProxy();
			if (!CurLandscape || CurLandscape->IsPendingKill())
				continue;

			FVector Origin, Extent;
			CurLandscape->GetActorBounds(false, Origin, Extent);

			BoxBounds += FBox::BuildAABB(Origin, Extent);
		}
	}
	break;

	case EHoudiniInputType::Skeletal:
	case EHoudiniInputType::Invalid:
	default:
		break;
	}

	return BoxBounds;
}

FString
UHoudiniInput::InputTypeToString(const EHoudiniInputType& InInputType)
{
	FString InputTypeStr;
	switch (InInputType)
	{
		case EHoudiniInputType::Geometry:
		{
			InputTypeStr = TEXT("Geometry Input");
		}
		break;

		case EHoudiniInputType::Asset:
		{
			InputTypeStr = TEXT("Asset Input");
		}
		break;

		case EHoudiniInputType::Curve:
		{
			InputTypeStr = TEXT("Curve Input");
		}
		break;

		case EHoudiniInputType::Landscape:
		{
			InputTypeStr = TEXT("Landscape Input");
		}
		break;

		case EHoudiniInputType::World:
		{
			InputTypeStr = TEXT("World Outliner Input");
		}
		break;

		case EHoudiniInputType::Skeletal:
		{
			InputTypeStr = TEXT("Skeletal Mesh Input");
		}
		break;
	}

	return InputTypeStr;
}


EHoudiniInputType
UHoudiniInput::StringToInputType(const FString& InInputTypeString)
{
	if (InInputTypeString.StartsWith(TEXT("Geometry"), ESearchCase::IgnoreCase))
	{
		return EHoudiniInputType::Geometry;
	}
	else if (InInputTypeString.StartsWith(TEXT("Asset"), ESearchCase::IgnoreCase))
	{
		return EHoudiniInputType::Asset;
	}
	else if (InInputTypeString.StartsWith(TEXT("Curve"), ESearchCase::IgnoreCase))
	{
		return EHoudiniInputType::Curve;
	}
	else if (InInputTypeString.StartsWith(TEXT("Landscape"), ESearchCase::IgnoreCase))
	{
		return EHoudiniInputType::Landscape;
	}
	else if (InInputTypeString.StartsWith(TEXT("World"), ESearchCase::IgnoreCase))
	{
		return EHoudiniInputType::World;
	}
	else if (InInputTypeString.StartsWith(TEXT("Skeletal"), ESearchCase::IgnoreCase))
	{
		return EHoudiniInputType::Skeletal;
	}

	return EHoudiniInputType::Invalid;
}


EHoudiniCurveType UHoudiniInput::StringToHoudiniCurveType(const FString& HoudiniCurveTypeString) 
{
	if (HoudiniCurveTypeString.StartsWith(TEXT("Polygon"), ESearchCase::IgnoreCase))
	{
		return EHoudiniCurveType::Polygon;
	}
	else if (HoudiniCurveTypeString.StartsWith(TEXT("Nurbs"), ESearchCase::IgnoreCase))
	{
		return EHoudiniCurveType::Nurbs;
	}
	else if (HoudiniCurveTypeString.StartsWith(TEXT("Bezier"), ESearchCase::IgnoreCase))
	{
		return EHoudiniCurveType::Bezier;
	}
	else if (HoudiniCurveTypeString.StartsWith(TEXT("Points"), ESearchCase::IgnoreCase))
	{
		return EHoudiniCurveType::Points;
	}
	
	return EHoudiniCurveType::Invalid;
}

EHoudiniCurveMethod UHoudiniInput::StringToHoudiniCurveMethod(const FString& HoudiniCurveMethodString) 
{
	if (HoudiniCurveMethodString.StartsWith(TEXT("CVs"), ESearchCase::IgnoreCase)) 
	{
		return EHoudiniCurveMethod::CVs;
	}
	else if (HoudiniCurveMethodString.StartsWith(TEXT("Breakpoints"), ESearchCase::IgnoreCase)) 
	{
		return EHoudiniCurveMethod::Breakpoints;
	}

	else if (HoudiniCurveMethodString.StartsWith(TEXT("Freehand"), ESearchCase::IgnoreCase))
	{
		return EHoudiniCurveMethod::Freehand;
	}

	return EHoudiniCurveMethod::Invalid;

}

// 
void 
UHoudiniInput::SetSOPInput(const int32& InInputIndex)
{
	// Set the input index
	InputIndex = InInputIndex;

	// Invalidate objpath parameter
	ParmId = -1;
	bIsObjectPathParameter = false;
}

void
UHoudiniInput::SetObjectPathParameter(const int32& InParmId)
{
	// Set as objpath parameter
	ParmId = InParmId;
	bIsObjectPathParameter = true;

	// Invalidate the geo input
	InputIndex = -1;
}

EHoudiniXformType 
UHoudiniInput::GetDefaultXTransformType() 
{
	switch (Type)
	{
		case EHoudiniInputType::Curve:
		case EHoudiniInputType::Geometry:
		case EHoudiniInputType::Skeletal:
			return EHoudiniXformType::None;
		case EHoudiniInputType::Asset:
		case EHoudiniInputType::Landscape:
		case EHoudiniInputType::World:
			return EHoudiniXformType::IntoThisObject;
	}

	return EHoudiniXformType::Auto;
}

bool
UHoudiniInput::GetKeepWorldTransform() const
{
	bool bReturn = false;
	switch (KeepWorldTransform)
	{
		case EHoudiniXformType::Auto:
		{
			// Return default values corresponding to the input type:
			if (Type == EHoudiniInputType::Curve
				|| Type == EHoudiniInputType::Geometry
				|| Type == EHoudiniInputType::Skeletal )
			{
				// NONE  for Geo, Curve and skeletal mesh IN
				bReturn = false;
			}
			else
			{
				// INTO THIS OBJECT for Asset, Landscape and World IN
				bReturn = true;
			}
			break;
		}
		
		case EHoudiniXformType::None:
		{
			bReturn = false;
			break;
		}

		case EHoudiniXformType::IntoThisObject:
		{
			bReturn = true;
			break;
		}
	}

	return bReturn;
}

void
UHoudiniInput::SetKeepWorldTransform(const bool& bInKeepWorldTransform)
{
	if (bInKeepWorldTransform)
	{
		KeepWorldTransform = EHoudiniXformType::IntoThisObject;
	}
	else
	{
		KeepWorldTransform = EHoudiniXformType::None;
	}
}

void 
UHoudiniInput::SetInputType(const EHoudiniInputType& InInputType, bool& bOutBlueprintStructureModified)
{ 
	if (InInputType == Type)
		return;

	SetPreviousInputType(Type);

	// Mark this input as changed
	MarkChanged(true);
	bOutBlueprintStructureModified = true;

	// Check previous input type
	switch (PreviousType) 
	{
		case EHoudiniInputType::Asset:
		{
			break;
		}

		case EHoudiniInputType::Curve:
		{
			// detach the input curves from the asset component
			if (GetNumberOfInputObjects() > 0)
			{
				for (UHoudiniInputObject * CurrentInput : *GetHoudiniInputObjectArray(Type))
				{
					UHoudiniInputHoudiniSplineComponent * CurrentInputHoudiniSpline = Cast<UHoudiniInputHoudiniSplineComponent>(CurrentInput);

					if (!CurrentInputHoudiniSpline || CurrentInputHoudiniSpline->IsPendingKill())
						continue;

					UHoudiniSplineComponent * HoudiniSplineComponent = CurrentInputHoudiniSpline->GetCurveComponent();


					if (!HoudiniSplineComponent || HoudiniSplineComponent->IsPendingKill())
						continue;

					HoudiniSplineComponent->Modify();

					const bool bIsArchetype = HoudiniSplineComponent->HasAnyFlags(RF_ArchetypeObject|RF_ClassDefaultObject);

					if (bIsArchetype)
					{
#if WITH_EDITOR
						check(HoudiniSplineComponent->IsTemplate());
						FHoudiniEngineRuntimeUtils::SetTemplatePropertyValue(HoudiniSplineComponent, "bVisible", false);
						FHoudiniEngineRuntimeUtils::SetTemplatePropertyValue(HoudiniSplineComponent, "bHiddenInGame", true);
						FHoudiniEngineRuntimeUtils::SetTemplatePropertyValue(HoudiniSplineComponent, "bIsHoudiniSplineVisible", false);
						FHoudiniEngineRuntimeUtils::SetTemplatePropertyValue(HoudiniSplineComponent, "bHasChanged", true);
						FHoudiniEngineRuntimeUtils::SetTemplatePropertyValue(HoudiniSplineComponent, "bNeedsToTriggerUpdate", true);
#endif
					}
					else
					{
						AActor* OwningActor = HoudiniSplineComponent->GetOwner();
						check(OwningActor);

						FDetachmentTransformRules DetachTransRules(EDetachmentRule::KeepRelative, EDetachmentRule::KeepRelative, EDetachmentRule::KeepRelative, false);
						HoudiniSplineComponent->DetachFromComponent(DetachTransRules);						
				 		HoudiniSplineComponent->SetVisibility(false, true);
						HoudiniSplineComponent->SetHoudiniSplineVisible(false);
						HoudiniSplineComponent->SetHiddenInGame(true, true);
						
						// This NodeId shouldn't be invalidated like this. If a spline component
						// or curve input is no longer valid, the input object should be removed from the HoudinInput
						// to get cleaned up properly.
						// HoudiniSplineComponent->SetNodeId(-1);
						HoudiniSplineComponent->MarkChanged(true);
					}

					bOutBlueprintStructureModified = true;
				}
			}
			break;
		}

		case EHoudiniInputType::Geometry:
		{
			break;
		}

		case EHoudiniInputType::Landscape:
		{
			TArray<UHoudiniInputObject*>* InputObjectsArray = GetHoudiniInputObjectArray(PreviousType);

			if (!InputObjectsArray)
				break;
		
			for (int32 Idx = 0; Idx < InputObjectsArray->Num(); ++Idx)
			{
				UHoudiniInputObject* InputObj = (*InputObjectsArray)[Idx];

				if (!InputObj || InputObj->IsPendingKill())
					continue;

				UHoudiniInputLandscape* InputLandscape = Cast<UHoudiniInputLandscape>(InputObj);

				if (!InputLandscape || InputLandscape->IsPendingKill())
					continue;

				// do something?
			}
		
			break;
		}

		case EHoudiniInputType::Skeletal:
		{
			break;
		}

		case EHoudiniInputType::World:
		{
			break;
		}

		default:
			break;
	}


	Type = InInputType;

	// TODO: NOPE, not needed
	// Set keep world transform to default w.r.t to new input type.
	//KeepWorldTransform = GetDefaultXTransformType();
	
	// Check current input type
	switch (InInputType) 
	{
		case EHoudiniInputType::World:
		case EHoudiniInputType::Asset:
		{
			UHoudiniAssetComponent* OuterHAC = Cast<UHoudiniAssetComponent>(GetOuter());
			if (OuterHAC && !bImportAsReference) 
			{
				for (auto& CurrentInput : *GetHoudiniInputObjectArray(Type)) 
				{
					UHoudiniInputHoudiniAsset* HoudiniAssetInput = Cast<UHoudiniInputHoudiniAsset>(CurrentInput);
					if (!HoudiniAssetInput || HoudiniAssetInput->IsPendingKill())
						continue;

					UHoudiniAssetComponent* CurrentHAC = HoudiniAssetInput->GetHoudiniAssetComponent();
					if (!CurrentHAC || CurrentHAC->IsPendingKill())
						continue;

					CurrentHAC->AddDownstreamHoudiniAsset(OuterHAC);
				}
			}
		}
		break;

		case EHoudiniInputType::Curve:
		{
			if (GetNumberOfInputObjects() == 0)
			{
				CreateNewCurveInputObject(bOutBlueprintStructureModified);
				MarkChanged(true);
			}
			else
			{
				for (auto& CurrentInput : *GetHoudiniInputObjectArray(Type))
				{
					UHoudiniInputHoudiniSplineComponent* SplineInput = Cast< UHoudiniInputHoudiniSplineComponent>(CurrentInput);
					if (!IsValid(SplineInput))
						continue;

					UHoudiniSplineComponent * HoudiniSplineComponent = SplineInput->GetCurveComponent();
					if (!IsValid(HoudiniSplineComponent))
						continue;
				
					HoudiniSplineComponent->Modify();

					const bool bIsArchetype = HoudiniSplineComponent->HasAnyFlags(RF_ArchetypeObject|RF_ClassDefaultObject);

					if (bIsArchetype)
					{
#if WITH_EDITOR
						check(HoudiniSplineComponent->IsTemplate());
						FHoudiniEngineRuntimeUtils::SetTemplatePropertyValue(HoudiniSplineComponent, "bVisible", true);
						FHoudiniEngineRuntimeUtils::SetTemplatePropertyValue(HoudiniSplineComponent, "bHiddenInGame", false);
						FHoudiniEngineRuntimeUtils::SetTemplatePropertyValue(HoudiniSplineComponent, "bIsHoudiniSplineVisible", true);
						FHoudiniEngineRuntimeUtils::SetTemplatePropertyValue(HoudiniSplineComponent, "bHasChanged", true);
						FHoudiniEngineRuntimeUtils::SetTemplatePropertyValue(HoudiniSplineComponent, "bNeedsToTriggerUpdate", true);
#endif
					}
					else
					{
						// Attach the new Houdini spline component to it's owner
						AActor* OwningActor = HoudiniSplineComponent->GetOwner();
						check(OwningActor);
						USceneComponent* OuterComponent = Cast<USceneComponent>(GetOuter());
						HoudiniSplineComponent->RegisterComponent();
						HoudiniSplineComponent->AttachToComponent(OuterComponent, FAttachmentTransformRules::KeepRelativeTransform);
						HoudiniSplineComponent->SetHoudiniSplineVisible(true);
						HoudiniSplineComponent->SetHiddenInGame(false, true);
						HoudiniSplineComponent->SetVisibility(true, true);
						HoudiniSplineComponent->MarkChanged(true);
					
					}

					bOutBlueprintStructureModified = true;
				}
			}
		}
		break;

		case EHoudiniInputType::Geometry:
		{

		}
		break;

		case EHoudiniInputType::Landscape:
		{
			// Need to do anything on select?	
		}
		break;

		case EHoudiniInputType::Skeletal:
		{
		}
		break;

		default:
		{
		}
		break;
	}
}

UHoudiniInputObject*
UHoudiniInput::CreateNewCurveInputObject(bool& bOutBlueprintStructureModified)
{
	if (CurveInputObjects.Num() > 0)
		return nullptr;

	UHoudiniInputHoudiniSplineComponent* NewCurveInputObject = CreateHoudiniSplineInput(nullptr, true, false, bOutBlueprintStructureModified);
	if (!NewCurveInputObject || NewCurveInputObject->IsPendingKill())
		return nullptr;

	UHoudiniSplineComponent * HoudiniSplineComponent = NewCurveInputObject->GetCurveComponent();
	if (!HoudiniSplineComponent || HoudiniSplineComponent->IsPendingKill())
		return nullptr;

    // Default Houdini spline component input should not be visible at initialization
	HoudiniSplineComponent->SetVisibility(true, true);
	HoudiniSplineComponent->SetHoudiniSplineVisible(true);
	HoudiniSplineComponent->SetHiddenInGame(false, true);

	CurveInputObjects.Add(NewCurveInputObject);
	SetInputObjectsNumber(EHoudiniInputType::Curve, 1);
	CurveInputObjects.SetNum(1);

	return NewCurveInputObject;
}

void
UHoudiniInput::MarkAllInputObjectsChanged(const bool& bInChanged)
{
	MarkDataUploadNeeded(bInChanged);

	// Mark all the objects from this input has changed so they upload themselves

	TSet<EHoudiniInputType> InputTypes;
	InputTypes.Add(Type);
	InputTypes.Add(EHoudiniInputType::Curve);
	
	TArray<UHoudiniInputObject*>* NewInputObjects = GetHoudiniInputObjectArray(Type);
	if (NewInputObjects)
	{
		for (auto CurInputObject : *NewInputObjects)
		{
			if (CurInputObject && !CurInputObject->IsPendingKill())
				CurInputObject->MarkChanged(bInChanged);
		}
	}
}

UHoudiniInput * UHoudiniInput::DuplicateAndCopyState(UObject * DestOuter, bool bInCanDeleteHoudiniNodes)
{
	UHoudiniInput* NewInput = Cast<UHoudiniInput>(StaticDuplicateObject(this, DestOuter));

	NewInput->CopyStateFrom(this, false, bInCanDeleteHoudiniNodes);

	return NewInput;
}

void UHoudiniInput::CopyStateFrom(UHoudiniInput* InInput, bool bCopyAllProperties, bool bInCanDeleteHoudiniNodes)
{

	// Preserve the current input objects before the copy to ensure we don't lose 
	// access to input objects and have them end up in the garbage.
	
	TMap<EHoudiniInputType, TArray<UHoudiniInputObject*>*> PrevInputObjectsMap;

	for(EHoudiniInputType InputType : HoudiniInputTypeList)
	{
		PrevInputObjectsMap.Add(InputType, GetHoudiniInputObjectArray(InputType));
	}
	
	// TArray<UHoudiniInputObject*> PrevInputObjects;
	// TArray<UHoudiniInputObject*>* OldToInputObjects = GetHoudiniInputObjectArray(Type);
	// if (OldToInputObjects)
	// PrevInputObjects = *OldToInputObjects;

	// Copy the state of this UHoudiniInput object.
	if (bCopyAllProperties)
	{
		UEngine::FCopyPropertiesForUnrelatedObjectsParams Params;
		Params.bDoDelta = false; // Perform a deep copy
		Params.bClearReferences = false; // References will be replaced afterwards.
		UEngine::CopyPropertiesForUnrelatedObjects(InInput, this, Params);
	}

	AssetNodeId = InInput->AssetNodeId;
	InputNodeId = InInput->InputNodeId;
	ParmId = InInput->ParmId;
	bCanDeleteHoudiniNodes = bInCanDeleteHoudiniNodes;

	//if (bInCanDeleteHoudiniNodes)
	//{
	//	// Delete stale data nodes before they get overwritten.
	//	TSet<int32> NewNodeIds(InInput->CreatedDataNodeIds);
	//	for (int32 NodeId : CreatedDataNodeIds)
	//	{
	//		if (!NewNodeIds.Contains(NodeId))
	//		{
	//			FHoudiniEngineRuntime::Get().MarkNodeIdAsPendingDelete(NodeId);
	//		}
	//	}
	//}

	CreatedDataNodeIds = InInput->CreatedDataNodeIds;

	// Important note: At this point the new object may still share objects with InInput.
	// The CopyInputs() will properly duplicate inputs where necessary.

	// Copy states of Input Objects that correspond to the current type.

	for(auto& Entry : PrevInputObjectsMap)
	{
		EHoudiniInputType InputType = Entry.Key;
		TArray<UHoudiniInputObject*>* PrevInputObjects = Entry.Value;
		TArray<UHoudiniInputObject*>* ToInputObjects = GetHoudiniInputObjectArray(InputType);
		TArray<UHoudiniInputObject*>* FromInputObjects = InInput->GetHoudiniInputObjectArray(InputType);

		if (ToInputObjects && FromInputObjects)
		{
			*ToInputObjects = *PrevInputObjects;
			CopyInputs(*ToInputObjects, *FromInputObjects, bInCanDeleteHoudiniNodes);
		}
	}

}

void UHoudiniInput::SetCanDeleteHoudiniNodes(bool bInCanDeleteNodes)
{
	bCanDeleteHoudiniNodes = bInCanDeleteNodes;
	for(UHoudiniInputObject* InputObject : GeometryInputObjects)
	{
		if (!InputObject)
			continue;
		InputObject->SetCanDeleteHoudiniNodes(bInCanDeleteNodes);
	}

	for(UHoudiniInputObject* InputObject : AssetInputObjects)
	{
		if (!InputObject)
			continue;
		InputObject->SetCanDeleteHoudiniNodes(bInCanDeleteNodes);
	}

	for(UHoudiniInputObject* InputObject : CurveInputObjects)
	{
		if (!InputObject)
			continue;
		InputObject->SetCanDeleteHoudiniNodes(bInCanDeleteNodes);
	}

	for(UHoudiniInputObject* InputObject : LandscapeInputObjects)
	{
		if (!InputObject)
			continue;
		InputObject->SetCanDeleteHoudiniNodes(bInCanDeleteNodes);
	}

	for(UHoudiniInputObject* InputObject : WorldInputObjects)
	{
		if (!InputObject)
			continue;
		InputObject->SetCanDeleteHoudiniNodes(bInCanDeleteNodes);
	}
}

void UHoudiniInput::InvalidateData()
{
	// If valid, mark our input node for deletion
	if (InputNodeId >= 0)
	{
		// .. but if we're an asset input, don't delete the node as InputNodeId
		// is set to the input HDA's node ID!
		if (Type != EHoudiniInputType::Asset)
		{
			if (bCanDeleteHoudiniNodes)
				FHoudiniEngineRuntime::Get().MarkNodeIdAsPendingDelete(InputNodeId, true);
		}
		
		InputNodeId = -1;
	}

	for(UHoudiniInputObject* InputObject : GeometryInputObjects)
	{
		if (!InputObject)
			continue;
		InputObject->InvalidateData();
	}

	for(UHoudiniInputObject* InputObject : AssetInputObjects)
	{
		if (!InputObject)
			continue;
		InputObject->InvalidateData();
	}

	for(UHoudiniInputObject* InputObject : CurveInputObjects)
	{
		if (!InputObject)
			continue;
		InputObject->InvalidateData();
	}

	for(UHoudiniInputObject* InputObject : LandscapeInputObjects)
	{
		if (!InputObject)
			continue;
		InputObject->InvalidateData();
	}

	for(UHoudiniInputObject* InputObject : WorldInputObjects)
	{
		if (!InputObject)
			continue;

		if (InputObject->IsA<UHoudiniInputHoudiniAsset>())
		{
			// When the input object is a HoudiniAssetComponent, 
			// we need to be sure that this HDA node id is not in CreatedDataNodeIds
			// We dont want to delete the input HDA node!
			CreatedDataNodeIds.Remove(InputObject->InputNodeId);
		}

		InputObject->InvalidateData();
	}

	if (bCanDeleteHoudiniNodes)
	{
		auto& HoudiniEngineRuntime = FHoudiniEngineRuntime::Get();
		for(int32 NodeId : CreatedDataNodeIds)
		{
			HoudiniEngineRuntime.MarkNodeIdAsPendingDelete(NodeId, true);
		}
	}
	
	CreatedDataNodeIds.Empty();
}

void UHoudiniInput::CopyInputs(TArray<UHoudiniInputObject*>& ToInputObjects, TArray<UHoudiniInputObject*>& FromInputObjects, bool bInCanDeleteHoudiniNodes)
{
	TSet<UHoudiniInputObject*> StaleObjects(ToInputObjects);

	const int32 NumInputs = FromInputObjects.Num();
	UObject* TargetOuter = GetOuter();
	
	ToInputObjects.SetNum(NumInputs);


	for (int i = 0; i < NumInputs; i++)
	{
		UHoudiniInputObject* FromObject = FromInputObjects[i];
		UHoudiniInputObject* ToObject = ToInputObjects[i];

		if (!FromObject)
		{
			ToInputObjects[i] = nullptr;
			continue;
		}

		if (ToObject)
		{
			bool IsValid = true;
			// Is ToInput and FromInput the same or do we have to create a input object?
			IsValid = IsValid && ToObject->Matches(*FromObject);
			IsValid = IsValid && ToObject->GetOuter() == TargetOuter;

			if (!IsValid)
			{
				ToObject = nullptr;
			}
		}

		if (ToObject)
		{
			// We have an existing (matching) object. Copy the
			// state from the incoming input.
			StaleObjects.Remove(ToObject);
			ToObject->CopyStateFrom(FromObject, true);
		}
		else
		{
			// We need to create a new input here.
			ToObject = FromObject->DuplicateAndCopyState(TargetOuter);
			ToInputObjects[i] = ToObject;
		}

		ToObject->SetCanDeleteHoudiniNodes(bInCanDeleteHoudiniNodes);
	}


	for (UHoudiniInputObject* StaleInputObject : StaleObjects)
	{
		if (!StaleInputObject)
			continue;
		if (StaleInputObject->GetOuter() == this)
		{
			StaleInputObject->SetCanDeleteHoudiniNodes(bInCanDeleteHoudiniNodes);
		}
	}
}


UHoudiniInputHoudiniSplineComponent*
UHoudiniInput::CreateHoudiniSplineInput(UHoudiniInputHoudiniSplineComponent * FromHoudiniSplineInputComponent, const bool & bAttachToparent, const bool & bAppendToInputArray, bool& bOutBlueprintStructureModified)
{
	UHoudiniInputHoudiniSplineComponent* HoudiniSplineInput = nullptr;
	UHoudiniSplineComponent* HoudiniSplineComponent = nullptr;

	UObject* OuterObj = GetOuter();
	USceneComponent* OuterComp = Cast<USceneComponent>(GetOuter());
	bool bOuterIsTemplate = (OuterObj && OuterObj->IsTemplate());

	if (!FromHoudiniSplineInputComponent)
	{
		// NOTE: If we're inside the Blueprint editor, the outer here is going to the be HAC component template.
		check(OuterObj)
		
		// Create a default Houdini spline input if a null pointer is passed in.
		FName HoudiniSplineName = MakeUniqueObjectName(OuterComp, UHoudiniSplineComponent::StaticClass(), TEXT("Houdini Spline"));

		// Create a Houdini Input Object.
		UHoudiniInputObject * NewInputObject = UHoudiniInputHoudiniSplineComponent::Create(
			nullptr, OuterObj, HoudiniSplineName.ToString());

		if (!NewInputObject || NewInputObject->IsPendingKill())
			return nullptr;

		HoudiniSplineInput = Cast<UHoudiniInputHoudiniSplineComponent>(NewInputObject);
		if (!HoudiniSplineInput)
			return nullptr;

		HoudiniSplineComponent = NewObject<UHoudiniSplineComponent>(
			HoudiniSplineInput,	UHoudiniSplineComponent::StaticClass());

		if (!HoudiniSplineComponent || HoudiniSplineComponent->IsPendingKill())
			return nullptr;

		HoudiniSplineInput->Update(HoudiniSplineComponent);

		HoudiniSplineComponent->SetHoudiniSplineName(HoudiniSplineName.ToString());
		HoudiniSplineComponent->SetFlags(RF_Transactional);

		// Set the default position of curve to avoid overlapping.
		HoudiniSplineComponent->SetOffset(DefaultCurveOffset);
		DefaultCurveOffset += 100.f;

		if (!bOuterIsTemplate)
		{ 
			HoudiniSplineComponent->RegisterComponent();

			// Attach the new Houdini spline component to it's owner.
			if (bAttachToparent)
				HoudiniSplineComponent->AttachToComponent(OuterComp, FAttachmentTransformRules::KeepRelativeTransform);
		}

		//push the new input object to the array for new type.
		if (bAppendToInputArray &&  Type == EHoudiniInputType::Curve)
			GetHoudiniInputObjectArray(Type)->Add(NewInputObject);

#if WITH_EDITOR
		if (bOuterIsTemplate)
		{
			UHoudiniAssetBlueprintComponent* HAB = Cast<UHoudiniAssetBlueprintComponent>(OuterObj);
			if (HAB)
			{
				UBlueprintGeneratedClass* BPGC = Cast<UBlueprintGeneratedClass>(HAB->GetOuter());
				UBlueprint* Blueprint = Cast<UBlueprint>(BPGC->ClassGeneratedBy);
				if (Blueprint)
				{
					TArray<UActorComponent*> Components;
					Components.Add(HoudiniSplineComponent);

					USCS_Node* HABNode = HAB->FindSCSNodeForTemplateComponentInClassHierarchy(HAB);

					// NOTE: FAddComponentsToBlueprintParams was introduced in 4.26 so for the sake of 
					// backwards compatibility, manually determine which SCSNode was added instead of
					// relying on Params.OutNodes.
					//FKismetEditorUtilities::FAddComponentsToBlueprintParams Params;
					//Params.OptionalNewRootNode = HABNode;
					const TSet<USCS_Node*> PreviousSCSNodes(Blueprint->SimpleConstructionScript->GetAllNodes());
					FKismetEditorUtilities::AddComponentsToBlueprint(Blueprint, Components, FKismetEditorUtilities::EAddComponentToBPHarvestMode::None, HABNode, false);
					USCS_Node* NewNode = nullptr;
					const TSet<USCS_Node*> CurrentSCSNodes(Blueprint->SimpleConstructionScript->GetAllNodes());
					const TSet<USCS_Node*> AddedNodes = CurrentSCSNodes.Difference(PreviousSCSNodes);
					
					if (AddedNodes.Num() > 0)
					{
						// Record Input / SCS node mapping 
						USCS_Node* SCSNode = AddedNodes.Array()[0];
						HAB->AddInputObjectMapping(NewInputObject->GetInputGuid(), SCSNode->VariableGuid);
						SCSNode->ComponentTemplate->SetFlags(RF_Public | RF_ArchetypeObject | RF_DefaultSubObject);
					}

					Blueprint->Modify();
					bOutBlueprintStructureModified = true;
				}
			}
		}
#endif
	}
	else 
	{
		// Otherwise, get the Houdini spline, and Houdini spline input from the argument.
		HoudiniSplineInput = FromHoudiniSplineInputComponent;
		HoudiniSplineComponent = FromHoudiniSplineInputComponent->GetCurveComponent();

		if (!HoudiniSplineComponent || HoudiniSplineComponent->IsPendingKill())
			return nullptr;

		// Attach the new Houdini spline component to it's owner.
		HoudiniSplineComponent->AttachToComponent(OuterComp, FAttachmentTransformRules::KeepRelativeTransform);
	}

	// Mark the created UHoudiniSplineComponent as an input, and set its InputObject.
	HoudiniSplineComponent->SetIsInputCurve(true);

	// HoudiniSplineComponent->SetInputObject(HoudiniSplineInput);

	// Set Houdini Spline Component bHasChanged and bNeedsToTrigerUpdate to true.
	HoudiniSplineComponent->MarkChanged(true);

	

	return HoudiniSplineInput;
}

void
UHoudiniInput::RemoveSplineFromInputObject(
	UHoudiniInputHoudiniSplineComponent* InHoudiniSplineInputObject,
	bool& bOutBlueprintStructureModified) const
{
	if (!InHoudiniSplineInputObject)
		return;

	UObject* OuterObj = GetOuter();
	const bool bOuterIsTemplate = OuterObj && OuterObj->IsTemplate();

	if (bOuterIsTemplate)
	{
#if WITH_EDITOR
		// Find the SCS node that corresponds to this input and remove it.
		UHoudiniAssetBlueprintComponent* HAB = Cast<UHoudiniAssetBlueprintComponent>(OuterObj);
		if (HAB)
		{
			const UBlueprintGeneratedClass* BPGC = Cast<UBlueprintGeneratedClass>(HAB->GetOuter());
			UBlueprint* Blueprint = Cast<UBlueprint>(BPGC->ClassGeneratedBy);
			if (Blueprint)
			{
				USimpleConstructionScript* SCS = Blueprint->SimpleConstructionScript;
				check(SCS);
				FGuid SCSGuid;
				if (HAB->GetInputObjectSCSVariableGuid(InHoudiniSplineInputObject->Guid, SCSGuid))
				{
					// TODO: Move this SCS variable removal code to a reusable utility function. We're
					// going to need to reuse this in a few other places too.
					USCS_Node* SCSNode = SCS->FindSCSNodeByGuid(SCSGuid);
					if (SCSNode)
					{
						SCS->RemoveNodeAndPromoteChildren(SCSNode);
						SCSNode->SetOnNameChanged(FSCSNodeNameChanged());
						bOutBlueprintStructureModified = true;
						HAB->RemoveInputObjectSCSVariableGuid(InHoudiniSplineInputObject->Guid);

						if (SCSNode->ComponentTemplate != nullptr)
						{
							const FName TemplateName = SCSNode->ComponentTemplate->GetFName();
							const FString RemovedName = SCSNode->GetVariableName().ToString() + TEXT("_REMOVED_") + FGuid::NewGuid().ToString();

							SCSNode->ComponentTemplate->Modify();
							SCSNode->ComponentTemplate->Rename(*RemovedName, /*NewOuter =*/nullptr, REN_DontCreateRedirectors);

							TArray<UObject*> ArchetypeInstances;
							auto DestroyArchetypeInstances = [&ArchetypeInstances, &RemovedName](UActorComponent* ComponentTemplate)
							{
								ComponentTemplate->GetArchetypeInstances(ArchetypeInstances);
								for (UObject* ArchetypeInstance : ArchetypeInstances)
								{
									if (!ArchetypeInstance->HasAllFlags(RF_ArchetypeObject | RF_InheritableComponentTemplate))
									{
										CastChecked<UActorComponent>(ArchetypeInstance)->DestroyComponent();
										ArchetypeInstance->Rename(*RemovedName, nullptr, REN_DontCreateRedirectors);
									}
								}
							};

							DestroyArchetypeInstances(SCSNode->ComponentTemplate);
							
							if (Blueprint)
							{
								// Children need to have their inherited component template instance of the component renamed out of the way as well
								TArray<UClass*> ChildrenOfClass;
								GetDerivedClasses(Blueprint->GeneratedClass, ChildrenOfClass);

								for (UClass* ChildClass : ChildrenOfClass)
								{
									UBlueprintGeneratedClass* BPChildClass = CastChecked<UBlueprintGeneratedClass>(ChildClass);

									if (UActorComponent* Component = (UActorComponent*)FindObjectWithOuter(BPChildClass, UActorComponent::StaticClass(), TemplateName))
									{
										Component->Modify();
										Component->Rename(*RemovedName, /*NewOuter =*/nullptr, REN_DontCreateRedirectors);

										DestroyArchetypeInstances(Component);
									}
								}
							}
						}
					}
				} // if (HAB->GetInputObjectSCSVariableGuid(InHoudiniSplineInputObject->Guid, SCSGuid))
			} // if (Blueprint)
		}
#endif
	} // if (bIsOuterTemplate)
	else
	{
		UHoudiniSplineComponent* HoudiniSplineComponent = InHoudiniSplineInputObject->GetCurveComponent();
		if (HoudiniSplineComponent)
		{
			// detach the input curves from the asset component
			//FDetachmentTransformRules DetachTransRules(EDetachmentRule::KeepRelative, EDetachmentRule::KeepRelative, EDetachmentRule::KeepRelative, false);
			//HoudiniSplineComponent->DetachFromComponent(DetachTransRules);
			// Destroy the Houdini Spline Component
			//InputObjectsPtr->RemoveAt(AtIndex);
			HoudiniSplineComponent->DestroyComponent();
		}
	}
	InHoudiniSplineInputObject->Update(nullptr);
}


TArray<UHoudiniInputObject*>*
UHoudiniInput::GetHoudiniInputObjectArray(const EHoudiniInputType& InType)
{
	switch (InType)
	{
	case EHoudiniInputType::Geometry:
		return &GeometryInputObjects;

	case EHoudiniInputType::Curve:
		return &CurveInputObjects;

	case EHoudiniInputType::Asset:
		return &AssetInputObjects;

	case EHoudiniInputType::Landscape:
		return &LandscapeInputObjects;

	case EHoudiniInputType::World:
		return &WorldInputObjects;

	case EHoudiniInputType::Skeletal:
		return &SkeletalInputObjects;

	default:
	case EHoudiniInputType::Invalid:
		return nullptr;
	}

	return nullptr;
}

TArray<AActor*>*
UHoudiniInput::GetBoundSelectorObjectArray()
{
	return &WorldInputBoundSelectorObjects;
}

const TArray<AActor*>*
UHoudiniInput::GetBoundSelectorObjectArray() const
{
	return &WorldInputBoundSelectorObjects;
}

const TArray<UHoudiniInputObject*>*
UHoudiniInput::GetHoudiniInputObjectArray(const EHoudiniInputType& InType) const
{
	switch (InType)
	{
		case EHoudiniInputType::Geometry:
			return &GeometryInputObjects;

		case EHoudiniInputType::Curve:
			return &CurveInputObjects;

		case EHoudiniInputType::Asset:
			return &AssetInputObjects;

		case EHoudiniInputType::Landscape:
			return &LandscapeInputObjects;

		case EHoudiniInputType::World:
			return &WorldInputObjects;

		case EHoudiniInputType::Skeletal:
			return &SkeletalInputObjects;

		default:
		case EHoudiniInputType::Invalid:
			return nullptr;
	}

	return nullptr;
}

UHoudiniInputObject*
UHoudiniInput::GetHoudiniInputObjectAt(const int32& AtIndex)
{
	return GetHoudiniInputObjectAt(Type, AtIndex);
}

const UHoudiniInputObject*
UHoudiniInput::GetHoudiniInputObjectAt(const int32& AtIndex) const
{
	const TArray<UHoudiniInputObject*>* InputObjectsArray = GetHoudiniInputObjectArray(Type);
	if (!InputObjectsArray || !InputObjectsArray->IsValidIndex(AtIndex))
		return nullptr;

	return (*InputObjectsArray)[AtIndex];
}

UHoudiniInputObject*
UHoudiniInput::GetHoudiniInputObjectAt(const EHoudiniInputType& InType, const int32& AtIndex)
{
	TArray<UHoudiniInputObject*>* InputObjectsArray = GetHoudiniInputObjectArray(InType);
	if (!InputObjectsArray || !InputObjectsArray->IsValidIndex(AtIndex))
		return nullptr;

	return (*InputObjectsArray)[AtIndex];
}

UObject*
UHoudiniInput::GetInputObjectAt(const int32& AtIndex)
{
	return GetInputObjectAt(Type, AtIndex);
}

AActor*
UHoudiniInput::GetBoundSelectorObjectAt(const int32& AtIndex)
{
	if (!WorldInputBoundSelectorObjects.IsValidIndex(AtIndex))
		return nullptr;

	return WorldInputBoundSelectorObjects[AtIndex];
}

UObject*
UHoudiniInput::GetInputObjectAt(const EHoudiniInputType& InType, const int32& AtIndex)
{
	UHoudiniInputObject* HoudiniInputObject = GetHoudiniInputObjectAt(InType, AtIndex);
	if (!HoudiniInputObject || HoudiniInputObject->IsPendingKill())
		return nullptr;

	return HoudiniInputObject->GetObject();
}

void
UHoudiniInput::InsertInputObjectAt(const int32& AtIndex)
{
	InsertInputObjectAt(Type, AtIndex);
}

void
UHoudiniInput::InsertInputObjectAt(const EHoudiniInputType& InType, const int32& AtIndex)
{
	TArray<UHoudiniInputObject*>* InputObjectsPtr = GetHoudiniInputObjectArray(InType);
	if (!InputObjectsPtr)
		return;

	InputObjectsPtr->InsertDefaulted(AtIndex, 1);
	MarkChanged(true);
}

void
UHoudiniInput::DeleteInputObjectAt(const int32& AtIndex)
{
	DeleteInputObjectAt(Type, AtIndex);
}

void
UHoudiniInput::DeleteInputObjectAt(const EHoudiniInputType& InType, const int32& AtIndex)
{
	TArray<UHoudiniInputObject*>* InputObjectsPtr = GetHoudiniInputObjectArray(InType);
	if (!InputObjectsPtr)
		return;

	if (!InputObjectsPtr->IsValidIndex(AtIndex))
		return;

	bool bBlueprintStructureModified = false;

	if (Type == EHoudiniInputType::Asset)
	{
		// ... TODO operations for removing asset input type
	}
	else if (Type == EHoudiniInputType::Curve)
	{
		UHoudiniInputHoudiniSplineComponent* HoudiniSplineInputObject = Cast<UHoudiniInputHoudiniSplineComponent>((*InputObjectsPtr)[AtIndex]);
		if (HoudiniSplineInputObject)
		{
			RemoveSplineFromInputObject(HoudiniSplineInputObject, bBlueprintStructureModified);
		}
	}
	else if (Type == EHoudiniInputType::Geometry) 
	{
		// ... TODO operations for removing geometry input type
	}
	else if (Type == EHoudiniInputType::Landscape) 
	{
		// ... TODO operations for removing landscape input type
	}
	else if (Type == EHoudiniInputType::Skeletal) 
	{
		// ... TODO operations for removing skeletal input type
	}
	else if (Type == EHoudiniInputType::World) 
	{
		// ... TODO operations for removing world input type
	}
	else 
	{
		// ... invalid input type
	}

	MarkChanged(true);

	UHoudiniInputObject* InputObjectToDelete = (*InputObjectsPtr)[AtIndex];
	if (InputObjectToDelete && !InputObjectToDelete->IsPendingKill())
	{		
		// Mark the input object's nodes for deletion
		InputObjectToDelete->InvalidateData();

		// If the deleted object wasnt null, trigger a re upload of the input data
		MarkDataUploadNeeded(true);
	}

	InputObjectsPtr->RemoveAt(AtIndex);

	// Delete the merge node when all the input objects are deleted.
	if (InputObjectsPtr->Num() == 0 && InputNodeId >= 0)
	{
		if (bCanDeleteHoudiniNodes)
			FHoudiniEngineRuntime::Get().MarkNodeIdAsPendingDelete(InputNodeId);
		InputNodeId = -1;
	}

#if WITH_EDITOR
	if (bBlueprintStructureModified)
	{
		UActorComponent* Component = Cast<UActorComponent>(GetOuter());
		FHoudiniEngineRuntimeUtils::MarkBlueprintAsStructurallyModified(Component);
	}
#endif
}

void
UHoudiniInput::DuplicateInputObjectAt(const int32& AtIndex)
{
	DuplicateInputObjectAt(Type, AtIndex);
}

void
UHoudiniInput::DuplicateInputObjectAt(const EHoudiniInputType& InType, const int32& AtIndex)
{
	TArray<UHoudiniInputObject*>* InputObjectsPtr = GetHoudiniInputObjectArray(InType);
	if (!InputObjectsPtr)
		return;

	if (!InputObjectsPtr->IsValidIndex(AtIndex))
		return;

	// If the duplicated object is not null, trigger a re upload of the input data
	bool bTriggerUpload = (*InputObjectsPtr)[AtIndex] != nullptr;

	// TODO: Duplicate the UHoudiniInputObject!!
	UHoudiniInputObject* DuplicateInput = (*InputObjectsPtr)[AtIndex];
	InputObjectsPtr->Insert(DuplicateInput, AtIndex);

	MarkChanged(true);

	if (bTriggerUpload)
		MarkDataUploadNeeded(true);
}

int32
UHoudiniInput::GetNumberOfInputObjects()
{
	return GetNumberOfInputObjects(Type);
}

int32
UHoudiniInput::GetNumberOfInputObjects(const EHoudiniInputType& InType)
{
	TArray<UHoudiniInputObject*>* InputObjectsPtr = GetHoudiniInputObjectArray(InType);
	if (!InputObjectsPtr)
		return 0;

	return InputObjectsPtr->Num();
}

int32
UHoudiniInput::GetNumberOfInputMeshes()
{
	return GetNumberOfInputMeshes(Type);
}

int32
UHoudiniInput::GetNumberOfInputMeshes(const EHoudiniInputType& InType)
{
	TArray<UHoudiniInputObject*>* InputObjectsPtr = GetHoudiniInputObjectArray(InType);
	if (!InputObjectsPtr)
		return 0;

	// TODO?
	// If geometry input, and we only have one null object, return 0
	int32 Num = InputObjectsPtr->Num();

	// TODO: Fix BP properly!
	// Special case for SM in BP:
	// we need to add extra input objects store in BlueprintStaticMeshes
	// Same thing for Actor InputObjects!
	for (auto InputObj : *InputObjectsPtr)
	{
		if (!InputObj || InputObj->IsPendingKill())
			continue;

		UHoudiniInputStaticMesh* InputSM = Cast<UHoudiniInputStaticMesh>(InputObj);
		if (InputSM && !InputSM->IsPendingKill())
		{
			if (InputSM->BlueprintStaticMeshes.Num() > 0)
			{
				Num += (InputSM->BlueprintStaticMeshes.Num() - 1);
			}
		}

		UHoudiniInputActor* InputActor = Cast<UHoudiniInputActor>(InputObj);
		if (InputActor && !InputActor->IsPendingKill())
		{
			if (InputActor->GetActorComponents().Num() > 0)
			{
				Num += (InputActor->GetActorComponents().Num() - 1);
			}
		}
	}

	return Num;
}


int32
UHoudiniInput::GetNumberOfBoundSelectorObjects() const
{
	return WorldInputBoundSelectorObjects.Num();
}

void
UHoudiniInput::SetInputObjectAt(const int32& AtIndex, UObject* InObject)
{
	return SetInputObjectAt(Type, AtIndex, InObject);
}

void
UHoudiniInput::SetInputObjectAt(const EHoudiniInputType& InType, const int32& AtIndex, UObject* InObject)
{
	// Start by making sure we have the proper number of input objects
	int32 NumIntObject = GetNumberOfInputObjects(InType);
	if (NumIntObject <= AtIndex)
	{
		// We need to resize the array
		SetInputObjectsNumber(InType, AtIndex + 1);
	}

	UObject* CurrentInputObject = GetInputObjectAt(InType, AtIndex);
	if (CurrentInputObject == InObject)
	{
		// Nothing to do
		return;
	}

	UHoudiniInputObject* CurrentInputObjectWrapper = GetHoudiniInputObjectAt(InType, AtIndex);
	if (!InObject)
	{
		// We want to set the input object to null
		TArray<UHoudiniInputObject*>* InputObjectsPtr = GetHoudiniInputObjectArray(InType);		
		if (!ensure(InputObjectsPtr != nullptr && InputObjectsPtr->IsValidIndex(AtIndex)))
			return;

		if (CurrentInputObjectWrapper)
		{
			// TODO: Check this case
			// Do not destroy the input object manually! this messes up GC
			//CurrentInputObjectWrapper->ConditionalBeginDestroy();
			MarkDataUploadNeeded(true);
		}

		(*InputObjectsPtr)[AtIndex] = nullptr;
		return;
	}

	// Get the type of the previous and new input objects
	EHoudiniInputObjectType NewObjectType = InObject ? UHoudiniInputObject::GetInputObjectTypeFromObject(InObject) : EHoudiniInputObjectType::Invalid;
	EHoudiniInputObjectType CurrentObjectType = CurrentInputObjectWrapper ? CurrentInputObjectWrapper->Type : EHoudiniInputObjectType::Invalid;

	// See if we can reuse the existing InputObject		
	if (CurrentObjectType == NewObjectType && NewObjectType != EHoudiniInputObjectType::Invalid)
	{
		// The InputObjectTypes match, we can just update the existing object
		CurrentInputObjectWrapper->Update(InObject);
		CurrentInputObjectWrapper->MarkChanged(true);
		return;
	}

	// Destroy the existing input object
	TArray<UHoudiniInputObject*>* InputObjectsPtr = GetHoudiniInputObjectArray(InType);
	if (!ensure(InputObjectsPtr))
		return;

	UHoudiniInputObject* NewInputObject = UHoudiniInputObject::CreateTypedInputObject(InObject, this, FString::FromInt(AtIndex + 1));
	if (!ensure(NewInputObject))
		return;

	// Mark that input object as changed so we know we need to update it
	NewInputObject->MarkChanged(true);
	if (CurrentInputObjectWrapper && !CurrentInputObjectWrapper->IsPendingKill())
	{
		// TODO:
		// For some input type, we may have to copy some of the previous object's property before deleting it

		// Delete the previous object
		CurrentInputObjectWrapper->MarkPendingKill();
		(*InputObjectsPtr)[AtIndex] = nullptr;
	}

	// Update the input object array with the newly created input object
	(*InputObjectsPtr)[AtIndex] = NewInputObject;
}

void
UHoudiniInput::SetInputObjectsNumber(const EHoudiniInputType& InType, const int32& InNewCount)
{
	TArray<UHoudiniInputObject*>* InputObjectsPtr = GetHoudiniInputObjectArray(InType);
	if (!InputObjectsPtr)
		return;

	if (InputObjectsPtr->Num() == InNewCount)
	{
		// Nothing to do
		return;
	}

	if (InNewCount > InputObjectsPtr->Num())
	{
		// Simply add new default InputObjects
		InputObjectsPtr->SetNum(InNewCount);
	}
	else
	{
		// TODO: Check this case!
		// Do not destroy the input object themselves manually,
		// destroy the input object's nodes and reduce the array's size  
		for (int32 InObjIdx = InputObjectsPtr->Num() - 1; InObjIdx >= InNewCount; InObjIdx--)
		{
			UHoudiniInputObject* CurrentInputObject = (*InputObjectsPtr)[InObjIdx];
			if (!CurrentInputObject || CurrentInputObject->IsPendingKill())
				continue;

			if (bCanDeleteHoudiniNodes)
				CurrentInputObject->InvalidateData();

			/*/
			//FHoudiniInputTranslator::DestroyInput(Inputs[InputIdx]);
			CurrentObject->ConditionalBeginDestroy();
			(*InputObjectsPtr)[InObjIdx] = nullptr;
			*/
		}
		
		// Decrease the input object array size
		InputObjectsPtr->SetNum(InNewCount);
	}

	// Also delete the input's merge node when all the input objects are deleted.
	if (InNewCount == 0 && InputNodeId >= 0)
	{
		if (bCanDeleteHoudiniNodes)
			FHoudiniEngineRuntime::Get().MarkNodeIdAsPendingDelete(InputNodeId, true);
		InputNodeId = -1;
	}
}

void
UHoudiniInput::SetBoundSelectorObjectsNumber(const int32& InNewCount)
{
	if (WorldInputBoundSelectorObjects.Num() == InNewCount)
	{
		// Nothing to do
		return;
	}

	if (InNewCount > WorldInputBoundSelectorObjects.Num())
	{
		// Simply add new default InputObjects
		WorldInputBoundSelectorObjects.SetNum(InNewCount);
	}
	else
	{
		/*
		// TODO: Not Needed?
		// Do not destroy the input object themselves manually,
		// destroy the input object's nodes and reduce the array's size  
		for (int32 InObjIdx = WorldInputBoundSelectorObjects.Num() - 1; InObjIdx >= InNewCount; InObjIdx--)
		{
			UHoudiniInputObject* CurrentInputObject = WorldInputBoundSelectorObjects[InObjIdx];
			if (!CurrentInputObject)
				continue;

			CurrentInputObject->MarkInputNodesForDeletion();
		}
		*/

		// Decrease the input object array size
		WorldInputBoundSelectorObjects.SetNum(InNewCount);
	}
}

void
UHoudiniInput::SetBoundSelectorObjectAt(const int32& AtIndex, AActor* InActor)
{
	// Start by making sure we have the proper number of objects
	int32 NumIntObject = GetNumberOfBoundSelectorObjects();
	if (NumIntObject <= AtIndex)
	{
		// We need to resize the array
		SetBoundSelectorObjectsNumber(AtIndex + 1);
	}

	AActor* CurrentActor = GetBoundSelectorObjectAt(AtIndex);
	if (CurrentActor == InActor)
	{
		// Nothing to do
		return;
	}

	// Update the array with the new object
	WorldInputBoundSelectorObjects[AtIndex] = InActor;
}

// Helper function indicating what classes are supported by an input type
TArray<const UClass*>
UHoudiniInput::GetAllowedClasses(const EHoudiniInputType& InInputType)
{
	TArray<const UClass*> AllowedClasses;
	switch (InInputType)
	{
		case EHoudiniInputType::Geometry:
			AllowedClasses.Add(UStaticMesh::StaticClass());
			AllowedClasses.Add(USkeletalMesh::StaticClass());
			AllowedClasses.Add(UBlueprint::StaticClass());
			AllowedClasses.Add(UDataTable::StaticClass());
			AllowedClasses.Add(UFoliageType_InstancedStaticMesh::StaticClass());
			break;

		case EHoudiniInputType::Curve:
			AllowedClasses.Add(USplineComponent::StaticClass());
			AllowedClasses.Add(UHoudiniSplineComponent::StaticClass());
			break;

		case EHoudiniInputType::Asset:
			AllowedClasses.Add(UHoudiniAssetComponent::StaticClass());
			break;

		case EHoudiniInputType::Landscape:
			AllowedClasses.Add(ALandscapeProxy::StaticClass());
			break;

		case EHoudiniInputType::World:
			AllowedClasses.Add(AActor::StaticClass());
			break;

		case EHoudiniInputType::Skeletal:
			AllowedClasses.Add(USkeletalMesh::StaticClass());
			break;

		default:
			break;
	}

	return AllowedClasses;
}

// Helper function indicating if an object is supported by an input type
bool 
UHoudiniInput::IsObjectAcceptable(const EHoudiniInputType& InInputType, const UObject* InObject)
{
	TArray<const UClass*> AllowedClasses = GetAllowedClasses(InInputType);
	for (auto CurClass : AllowedClasses)
	{
		if (InObject->IsA(CurClass))
			return true;
	}

	return false;
}

bool
UHoudiniInput::IsDataUploadNeeded()
{
	if (bDataUploadNeeded)
		return true;

	return HasChanged();
}

// Indicates if this input has changed and should be updated
bool 
UHoudiniInput::HasChanged()
{
	if (bHasChanged)
		return true;

	TArray<UHoudiniInputObject*>* InputObjectsPtr = GetHoudiniInputObjectArray(Type);
	if (!ensure(InputObjectsPtr))
		return false;

	for (auto CurrentInputObject : (*InputObjectsPtr))
	{
		if (CurrentInputObject && CurrentInputObject->HasChanged())
			return true;
	}

	return false;
}

bool
UHoudiniInput::IsTransformUploadNeeded()
{
	TArray<UHoudiniInputObject*>* InputObjectsPtr = GetHoudiniInputObjectArray(Type);
	if (!ensure(InputObjectsPtr))
		return false;

	for (auto CurrentInputObject : (*InputObjectsPtr))
	{
		if (CurrentInputObject && CurrentInputObject->HasTransformChanged())
			return true;
	}

	return false;
}

// Indicates if this input needs to trigger an update
bool
UHoudiniInput::NeedsToTriggerUpdate()
{
	if (bNeedsToTriggerUpdate)
		return true;

	const TArray<UHoudiniInputObject*>* InputObjectsPtr = GetHoudiniInputObjectArray(Type);
	if (!ensure(InputObjectsPtr))
		return false;

	for (auto CurrentInputObject : (*InputObjectsPtr))
	{
		if (CurrentInputObject && CurrentInputObject->NeedsToTriggerUpdate())
			return true;
	}

	return false;
}

FString 
UHoudiniInput::GetNodeBaseName() const
{
	UHoudiniAssetComponent* HAC = Cast<UHoudiniAssetComponent>(GetOuter());
	FString NodeBaseName = HAC ? HAC->GetDisplayName() : TEXT("HoudiniAsset");

	// Unfortunately CreateInputNode always prefix with input_...
	if (IsObjectPathParameter())
		NodeBaseName += TEXT("_") + GetName();
	else
		NodeBaseName += TEXT("_input") + FString::FromInt(GetInputIndex());

	return NodeBaseName;
}

void
UHoudiniInput::OnTransformUIExpand(const int32& AtIndex)
{
#if WITH_EDITORONLY_DATA
	if (TransformUIExpanded.IsValidIndex(AtIndex))
	{
		TransformUIExpanded[AtIndex] = !TransformUIExpanded[AtIndex];
	}
	else
	{
		// We need to append values to the expanded array
		for (int32 Index = TransformUIExpanded.Num(); Index <= AtIndex; Index++)
		{
			TransformUIExpanded.Add(Index == AtIndex ? true : false);
		}
	}
#endif
}

bool
UHoudiniInput::IsTransformUIExpanded(const int32& AtIndex)
{
#if WITH_EDITORONLY_DATA
	return TransformUIExpanded.IsValidIndex(AtIndex) ? TransformUIExpanded[AtIndex] : false;
#else
	return false;
#endif
};

FTransform*
UHoudiniInput::GetTransformOffset(const int32& AtIndex) 
{
	UHoudiniInputObject* InObject = GetHoudiniInputObjectAt(AtIndex);
	if (InObject)
		return &(InObject->Transform);

	return nullptr;
}

const FTransform
UHoudiniInput::GetTransformOffset(const int32& AtIndex) const
{
	const UHoudiniInputObject* InObject = GetHoudiniInputObjectAt(AtIndex);
	if (InObject)
		return InObject->Transform;

	return FTransform::Identity;
}

TOptional<float>
UHoudiniInput::GetPositionOffsetX(int32 AtIndex) const
{
	return GetTransformOffset(AtIndex).GetLocation().X;
}

TOptional<float>
UHoudiniInput::GetPositionOffsetY(int32 AtIndex) const
{
	return GetTransformOffset(AtIndex).GetLocation().Y;
}

TOptional<float>
UHoudiniInput::GetPositionOffsetZ(int32 AtIndex) const
{
	return GetTransformOffset(AtIndex).GetLocation().Z;
}

TOptional<float>
UHoudiniInput::GetRotationOffsetRoll(int32 AtIndex) const
{
	return GetTransformOffset(AtIndex).Rotator().Roll;
}

TOptional<float>
UHoudiniInput::GetRotationOffsetPitch(int32 AtIndex) const
{
	return GetTransformOffset(AtIndex).Rotator().Pitch;
}

TOptional<float>
UHoudiniInput::GetRotationOffsetYaw(int32 AtIndex) const
{
	return GetTransformOffset(AtIndex).Rotator().Yaw;
}

TOptional<float>
UHoudiniInput::GetScaleOffsetX(int32 AtIndex) const
{
	return GetTransformOffset(AtIndex).GetScale3D().X;
}

TOptional<float>
UHoudiniInput::GetScaleOffsetY(int32 AtIndex) const
{
	return GetTransformOffset(AtIndex).GetScale3D().Y;
}

TOptional<float>
UHoudiniInput::GetScaleOffsetZ(int32 AtIndex) const
{
	return GetTransformOffset(AtIndex).GetScale3D().Z;
}

bool
UHoudiniInput::SetTransformOffsetAt(const float& Value, const int32& AtIndex, const int32& PosRotScaleIndex, const int32& XYZIndex)
{
	FTransform* Transform = GetTransformOffset(AtIndex);
	if (!Transform)
		return false;

	if (PosRotScaleIndex == 0)
	{
		FVector Position = Transform->GetLocation();
		if (Position[XYZIndex] == Value)
			return false;
		Position[XYZIndex] = Value;
		Transform->SetLocation(Position);
	}
	else if (PosRotScaleIndex == 1)
	{
		FRotator Rotator = Transform->Rotator();
		switch (XYZIndex)
		{
			case 0:
			{
				if (Rotator.Roll == Value)
					return false;
				Rotator.Roll = Value;
				break;
			}

			case 1:
			{
				if (Rotator.Pitch == Value)
					return false;
				Rotator.Pitch = Value;
				break;
			}

			case 2:
			{
				if (Rotator.Yaw == Value)
					return false;
				Rotator.Yaw = Value;
				break;
			}
		}
		Transform->SetRotation(Rotator.Quaternion());
	}
	else if (PosRotScaleIndex == 2)
	{
		FVector Scale = Transform->GetScale3D();
		if (Scale[XYZIndex] == Value)
			return false;

		Scale[XYZIndex] = Value;
		Transform->SetScale3D(Scale);
	}

	MarkChanged(true);
	bStaticMeshChanged = true;

	return true;
}

void
UHoudiniInput::SetAddRotAndScaleAttributes(const bool& InValue)
{
	if (bAddRotAndScaleAttributesOnCurves == InValue)
		return;

	bAddRotAndScaleAttributesOnCurves = InValue;

	// Mark all input obj as changed
	MarkAllInputObjectsChanged(true);
}

#if WITH_EDITOR
FText 
UHoudiniInput::GetCurrentSelectionText() const 
{
	FText CurrentSelectionText;
	switch (Type) 
	{
		case EHoudiniInputType::Landscape :
		{
			if (LandscapeInputObjects.Num() > 0) 
			{
				UHoudiniInputObject* InputObject = LandscapeInputObjects[0];

				UHoudiniInputLandscape* InputLandscape = Cast<UHoudiniInputLandscape>(InputObject);
				if (!InputLandscape || InputLandscape->IsPendingKill())
					return CurrentSelectionText;

				ALandscapeProxy* LandscapeProxy = InputLandscape->GetLandscapeProxy();
				if (!LandscapeProxy || LandscapeProxy->IsPendingKill())
					return CurrentSelectionText;

				CurrentSelectionText = FText::FromString(LandscapeProxy->GetActorLabel());
			}	
		}
		break;

		case EHoudiniInputType::Asset :
		{
			if (AssetInputObjects.Num() > 0) 
			{
				UHoudiniInputObject* InputObject = AssetInputObjects[0];

				UHoudiniInputHoudiniAsset* HoudiniAssetInput = Cast<UHoudiniInputHoudiniAsset>(InputObject);
				if (!HoudiniAssetInput || HoudiniAssetInput->IsPendingKill())
					return CurrentSelectionText;

				UHoudiniAssetComponent* HAC = HoudiniAssetInput->GetHoudiniAssetComponent();
				if (!HAC || HAC->IsPendingKill())
					return CurrentSelectionText;

				UHoudiniAsset* HoudiniAsset = HAC->GetHoudiniAsset();
				if (!HoudiniAsset || HoudiniAsset->IsPendingKill())
					return CurrentSelectionText;

				CurrentSelectionText = FText::FromString(HoudiniAsset->GetName());
			}
		}
		break;

		default:
		break;
	}
	
	return CurrentSelectionText;
}
#endif

bool 
UHoudiniInput::HasLandscapeExportTypeChanged () const 
{
	if (Type != EHoudiniInputType::Landscape)
		return false;

	return bLandscapeHasExportTypeChanged;
}

void 
UHoudiniInput::SetHasLandscapeExportTypeChanged(const bool InChanged) 
{
	if (Type != EHoudiniInputType::Landscape)
		return;

	bLandscapeHasExportTypeChanged = InChanged;
}

bool 
UHoudiniInput::GetUpdateInputLandscape() const 
{
	if (Type != EHoudiniInputType::Landscape)
		return false;

	return bUpdateInputLandscape;
}

void 
UHoudiniInput::SetUpdateInputLandscape(const bool bInUpdateInputLandcape)
{
	if (Type != EHoudiniInputType::Landscape)
		return;

	bUpdateInputLandscape = bInUpdateInputLandcape;
}


bool
UHoudiniInput::UpdateWorldSelectionFromBoundSelectors()
{
	// Dont do anything if we're not a World Input
	if (Type != EHoudiniInputType::World)
		return false;

	// Build an array of the current selection's bounds
	TArray<FBox> AllBBox;
	for (auto CurrentActor : WorldInputBoundSelectorObjects)
	{
		if (!CurrentActor || CurrentActor->IsPendingKill())
			continue;

		AllBBox.Add(CurrentActor->GetComponentsBoundingBox(true, true));
	}

	//
	// Select all actors in our bound selectors bounding boxes
	//

	// Get our parent component/actor
	USceneComponent* ParentComponent = Cast<USceneComponent>(GetOuter());
	AActor* ParentActor = ParentComponent ? ParentComponent->GetOwner() : nullptr;

	//UWorld* editorWorld = GEditor->GetEditorWorldContext().World();
	UWorld* MyWorld = GetWorld();
	TArray<AActor*> NewSelectedActors;
	for (TActorIterator<AActor> ActorItr(MyWorld); ActorItr; ++ActorItr)
	{
		AActor *CurrentActor = *ActorItr;
		if (!CurrentActor || CurrentActor->IsPendingKill())
			continue;

		// Check that actor is currently not selected
		if (WorldInputBoundSelectorObjects.Contains(CurrentActor))
			continue;

		// Ignore the SkySpheres?
		FString ClassName = CurrentActor->GetClass() ? CurrentActor->GetClass()->GetName() : FString();
		if (ClassName.Contains("BP_Sky_Sphere"))
			continue;

		// Don't allow selection of ourselves. Bad things happen if we do.
		if (ParentActor && (CurrentActor == ParentActor))
			continue;

		// For BrushActors, both the actor and its brush must be valid
		ABrush* BrushActor = Cast<ABrush>(CurrentActor);
		if (BrushActor)
		{
			if (!BrushActor->Brush || BrushActor->Brush->IsPendingKill())
				continue;
		}

		FBox ActorBounds = CurrentActor->GetComponentsBoundingBox(true);
		for (auto InBounds : AllBBox)
		{
			// Check if both actor's bounds intersects
			if (!ActorBounds.Intersect(InBounds))
				continue;

			NewSelectedActors.Add(CurrentActor);
			break;
		}
	}
	
	return UpdateWorldSelection(NewSelectedActors);
}

bool
UHoudiniInput::UpdateWorldSelection(const TArray<AActor*>& InNewSelection)
{
	TArray<AActor*> NewSelectedActors = InNewSelection;

	// Update our current selection with the new one
	// Keep actors that are still selected, remove the one that are not selected anymore
	bool bHasSelectionChanged = false;
	for (int32 Idx = WorldInputObjects.Num() - 1; Idx >= 0; Idx--)
	{
		UHoudiniInputActor* InputActor = Cast<UHoudiniInputActor>(WorldInputObjects[Idx]);
		AActor* CurActor = InputActor ? InputActor->GetActor() : nullptr;

		if (CurActor && NewSelectedActors.Contains(CurActor))
		{
			// The actor is still selected, remove it from the new selection
			NewSelectedActors.Remove(CurActor);
		}
		else
		{
			// That actor is no longer selected, remove itr from our current selection
			DeleteInputObjectAt(EHoudiniInputType::World, Idx);
			bHasSelectionChanged = true;
		}
	}

	if (NewSelectedActors.Num() > 0)
		bHasSelectionChanged = true;

	// Then add the newly selected Actors
	int32 InputObjectIdx = GetNumberOfInputObjects(EHoudiniInputType::World);
	int32 NewInputObjectNumber = InputObjectIdx + NewSelectedActors.Num();
	SetInputObjectsNumber(EHoudiniInputType::World, NewInputObjectNumber);
	for (const auto& CurActor : NewSelectedActors)
	{
		// Update the input objects from the valid selected actors array
		SetInputObjectAt(InputObjectIdx++, CurActor);
	}

	MarkChanged(bHasSelectionChanged);

	return bHasSelectionChanged;
}


bool
UHoudiniInput::ContainsInputObject(const UObject* InObject, const EHoudiniInputType& InType) const
{
	if (!InObject || InObject->IsPendingKill())
		return false;

	// Returns true if the object is one of our input object for the given type
	const TArray<UHoudiniInputObject*>* ObjectArray = GetHoudiniInputObjectArray(InType);
	if (!ObjectArray)
		return false;

	for (auto& CurrentInputObject : (*ObjectArray))
	{
		if (!CurrentInputObject || CurrentInputObject->IsPendingKill())
			continue;

		if (CurrentInputObject->GetObject() == InObject)
			return true;
	}

	return false;
}

void UHoudiniInput::ForAllHoudiniInputObjects(TFunctionRef<void(UHoudiniInputObject*)> Fn) const
{
	for(UHoudiniInputObject* InputObject : GeometryInputObjects)
	{
		Fn(InputObject);
	}

	for(UHoudiniInputObject* InputObject : AssetInputObjects)
	{
		Fn(InputObject);
	}

	for(UHoudiniInputObject* InputObject : CurveInputObjects)
	{
		Fn(InputObject);
	}

	for(UHoudiniInputObject* InputObject : LandscapeInputObjects)
	{
		Fn(InputObject);
	}
	
	for(UHoudiniInputObject* InputObject : WorldInputObjects)
	{
		Fn(InputObject);
	}

	for(UHoudiniInputObject* InputObject : SkeletalInputObjects)
	{
		Fn(InputObject);
	}
}

TArray<const TArray<UHoudiniInputObject*>*> UHoudiniInput::GetAllObjectArrays() const
{
	return { &GeometryInputObjects, &CurveInputObjects, &WorldInputObjects, &SkeletalInputObjects, &LandscapeInputObjects, &AssetInputObjects };
}

TArray<TArray<UHoudiniInputObject*>*> UHoudiniInput::GetAllObjectArrays()
{
	return { &GeometryInputObjects, &CurveInputObjects, &WorldInputObjects, &SkeletalInputObjects, &LandscapeInputObjects, &AssetInputObjects };
}

void UHoudiniInput::ForAllHoudiniInputObjectArrays(TFunctionRef<void(const TArray<UHoudiniInputObject*>&)> Fn) const
{
	TArray<const TArray<UHoudiniInputObject*>*> ObjectArrays = GetAllObjectArrays();
	for (const TArray<UHoudiniInputObject*>* ObjectArrayPtr : ObjectArrays)
	{
		if (!ObjectArrayPtr)
			continue;
		Fn(*ObjectArrayPtr);
	}
}

void UHoudiniInput::ForAllHoudiniInputObjectArrays(TFunctionRef<void(TArray<UHoudiniInputObject*>&)> Fn)
{
	TArray<TArray<UHoudiniInputObject*>*> ObjectArrays = GetAllObjectArrays();
	for (TArray<UHoudiniInputObject*>* ObjectArrayPtr : ObjectArrays)
	{
		if (!ObjectArrayPtr)
			continue;
		Fn(*ObjectArrayPtr);
	}
}

void UHoudiniInput::GetAllHoudiniInputObjects(TArray<UHoudiniInputObject*>& OutObjects) const
{
	OutObjects.Empty();
	auto AddInputObject = [&OutObjects](UHoudiniInputObject* InputObject)
	{
		if (InputObject)
			OutObjects.Add(InputObject);
	};
	ForAllHoudiniInputObjects(AddInputObject);
}

void UHoudiniInput::ForAllHoudiniInputSceneComponents(TFunctionRef<void(UHoudiniInputSceneComponent*)> Fn) const
{
	auto ProcessSceneComponent = [Fn](UHoudiniInputObject* InputObject)
	{
		if (!InputObject)
			return;
		UHoudiniInputSceneComponent* SceneComponentInput = Cast<UHoudiniInputSceneComponent>(InputObject);
		if (!SceneComponentInput)
			return;
		Fn(SceneComponentInput);
	};
	ForAllHoudiniInputObjects(ProcessSceneComponent);
}

void UHoudiniInput::GetAllHoudiniInputSceneComponents(TArray<UHoudiniInputSceneComponent*>& OutObjects) const
{
	OutObjects.Empty();
	auto AddSceneComponent = [&OutObjects](UHoudiniInputObject* InputObject)
	{
		if (!InputObject)
			return;
		UHoudiniInputSceneComponent* SceneComponentInput = Cast<UHoudiniInputSceneComponent>(InputObject);
		if (!SceneComponentInput)
			return;
		OutObjects.Add(SceneComponentInput);
	};
	ForAllHoudiniInputObjects(AddSceneComponent);
}

void UHoudiniInput::GetAllHoudiniInputSplineComponents(TArray<UHoudiniInputHoudiniSplineComponent*>& OutObjects) const
{
	OutObjects.Empty();
	auto AddSceneComponent = [&OutObjects](UHoudiniInputObject* InputObject)
	{
		if (!InputObject)
			return;
		UHoudiniInputHoudiniSplineComponent* SceneComponentInput = Cast<UHoudiniInputHoudiniSplineComponent>(InputObject);
		if (!SceneComponentInput)
			return;
		OutObjects.Add(SceneComponentInput);
	};
	ForAllHoudiniInputObjects(AddSceneComponent);
}


void UHoudiniInput::RemoveHoudiniInputObject(UHoudiniInputObject* InInputObject)
{
	if (!InInputObject)
		return;

	ForAllHoudiniInputObjectArrays([InInputObject](TArray<UHoudiniInputObject*>& ObjectArray) {
		ObjectArray.Remove(InInputObject);
	});

	return;
}