/*
* 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 "HoudiniAssetBlueprintComponent.h"

#include "HoudiniEngineCopyPropertiesInterface.h"
#include "HoudiniOutput.h"
#include "HoudiniEngineRuntime.h"
#include "HoudiniEngineRuntimeUtils.h"
#include "Engine/SCS_Node.h"
#include "Engine/SimpleConstructionScript.h"
#include "UObject/Object.h"
#include "Logging/LogMacros.h"

#include "HoudiniParameterFloat.h"
#include "HoudiniParameterToggle.h"
#include "HoudiniInput.h"
#include "HoudiniEngineRuntimePrivatePCH.h"

#if WITH_EDITOR
	#include "Editor.h"
	#include "Kismet2/BlueprintEditorUtils.h"
	#include "Kismet2/KismetEditorUtilities.h"
	#include "Toolkits/AssetEditorManager.h"
	#include "Kismet2/ComponentEditorUtils.h"
	#include "ComponentAssetBroker.h"
#endif

HOUDINI_BP_DEFINE_LOG_CATEGORY();

UHoudiniAssetBlueprintComponent::UHoudiniAssetBlueprintComponent(const FObjectInitializer & ObjectInitializer)
	: Super(ObjectInitializer)
{

#if WITH_EDITOR
	if (IsTemplate())
	{
		// CachedAssetEditorSubsystem = GEditor->GetEditorSubsystem<UAssetEditorSubsystem>();
		//GEditor->GetEditorSubsystem<UAssetEditorSubsystem>()->OnAssetEditorRequestClose().AddUObject( this, &UHoudiniAssetBlueprintComponent::ReceivedAssetEditorRequestCloseEvent );
	}
#endif

	bForceNeedUpdate = false;
	bHoudiniAssetChanged = false;
	bIsInBlueprintEditor = false;
	bCanDeleteHoudiniNodes = false;

	// AssetState will be updated by changes to the HoudiniAsset
	// or parameter changes on the Component template.
	AssetState = EHoudiniAssetState::None;
	bHasRegisteredComponentTemplate = false;
	bHasBeenLoaded = false;
	bUpdatedFromTemplate = false;

	// Disable proxy mesh by default (unsupported for now)
	bOverrideGlobalProxyStaticMeshSettings = true;
	bEnableProxyStaticMeshOverride = false;
	bEnableProxyStaticMeshRefinementByTimerOverride = false;
	bEnableProxyStaticMeshRefinementOnPreSaveWorldOverride = false;
	bEnableProxyStaticMeshRefinementOnPreBeginPIEOverride = false;
	StaticMeshMethod = EHoudiniStaticMeshMethod::RawMesh;

	// Set default mobility to Movable
	Mobility = EComponentMobility::Movable;
}

#if WITH_EDITOR
void
UHoudiniAssetBlueprintComponent::CopyStateToTemplateComponent()
{
	// We need to propagate changes made here back to the corresponding component in 
	// the Blueprint Generated Class ("<COMPONENT_NAME>_GEN_VARIABLE"). The reason being that
	// the Blueprint editor works directly with the GEN_VARIABLE component (all 
	// PostEditChange() calls, Details Customizations, etc will receive the GEN_VARIABLE instance) BUT
	// when the Editor runs the construction script it uses a different component instance, so all changes
	// made to that instance won't write back to the Blueprint definition.
	// To Summarize:
	// Be sure to sync the Parameters array (and any other relevant properties) back
	// to the corresponding component on the Blueprint Generated class otherwise these wont be 
	// accessible in the Details Customization callbacks.

	HOUDINI_BP_MESSAGE(TEXT("[UHoudiniAssetBlueprintComponent::CopyStateFromTemplateComponent] Component: %s"), *(GetPathName()));
	HOUDINI_BP_MESSAGE(TEXT("[UHoudiniAssetBlueprintComponent::CopyStateFromTemplateComponent] To Component: %s"), *(CachedTemplateComponent->GetPathName()));

	// This should never be called by component templates. 
	check(!IsTemplate());

	if (!CachedTemplateComponent.IsValid())
		return;

	USimpleConstructionScript* SCS = CachedBlueprint->SimpleConstructionScript;
	check(SCS);

	/*
	USCS_Node* SCSNodeForInstance = FindSCSNodeForInstanceComponent(SCS, this);
	if (SCSNodeForInstance)
	{
	
	}
	else 
	{
	
	}
	*/

	//// If we don't have an SCS node for this preview instance, we need to create one, regardless
	//// of whether output updates are required.
	//if (!CachedTemplateComponent->bOutputsRequireUpdate && SCSNodeForInstance != nullptr)
	//	return;

	// TODO: If the blueprint editor is NOT open, then we shouldn't attempting 
	// to copy state back to the BPGC at all!
	FBlueprintEditor* BlueprintEditor = FHoudiniEngineRuntimeUtils::GetBlueprintEditor(this);
	check(BlueprintEditor);
	
	USCS_Node* SCSHACNode = FindSCSNodeForTemplateComponentInClassHierarchy(CachedTemplateComponent.Get());
	// check(SCSHACNode);
	
	// This is the actor instance that is being used for component editing.
	AActor* PreviewActor = GetPreviewActor();
	check(PreviewActor);
	
	// NOTE: Inputs are only from component templates to instances, not the other way around ... I think.

	// -----------------------------------------------------
	// Copy outputs to component template
	// -----------------------------------------------------

	// Populate / update the outputs for the template from the preview / instance.
	// TODO: Wrap the Blueprint manipulation in a transaction
	TArray<UHoudiniOutput*>& TemplateOutputs = CachedTemplateComponent->Outputs;
	TSet<UHoudiniOutput*> StaleTemplateOutputs(TemplateOutputs);

	TemplateOutputs.SetNum(Outputs.Num());
	CachedOutputNodes.Empty();

	for (int i = 0; i < Outputs.Num(); i++)
	{
		// Find a output on the template that corresponds to this output from the instance.
		UHoudiniOutput* TemplateOutput = nullptr;
		UHoudiniOutput* InstanceOutput = nullptr;
		InstanceOutput = Outputs[i];
		
		//check(InstanceOutput)
		if (!InstanceOutput || InstanceOutput->IsPendingKill())
			continue;

		// Ensure that instance outputs won't delete houdini content. 
		// Houdini content should only be allowed to be deleted from 
		// the component template.
		InstanceOutput->SetCanDeleteHoudiniNodes(false);
		
		TemplateOutput = TemplateOutputs[i];

		if (TemplateOutput)
		{
			check(TemplateOutput->GetOuter() == CachedTemplateComponent.Get());
			StaleTemplateOutputs.Remove(TemplateOutput);
		}

		
		if (TemplateOutput)
		{
			// Copy properties from the current instance component while preserving output objects
			// and instanced outputs.
			TemplateOutput->CopyPropertiesFrom(InstanceOutput, true);
		}
		else
		{
			// NOTE: If the template output is NULL it means that the HDA spawned a new component / output in the transient world
			// and the new output object needs to be copied back to the BPGC.

			// Corresponding template output could not be found. Create one by duplicating the instance output.
			TemplateOutput = InstanceOutput->DuplicateAndCopyProperties(CachedTemplateComponent.Get(), FName(InstanceOutput->GetName()));
			// Treat these the same one would components created by CreateDefaultSubObject.
			// NOTE: CreateDefaultSubobject performs lots of checks, and unfortunately we can't use it directly (it is 
			// only allowed to be used in a constructor). Not sure whether we need to either. For now, we just set the
			// object flags to be similar to components created by CreateDefaultSubobject.
			TemplateOutput->SetFlags(RF_Public|RF_ArchetypeObject|RF_DefaultSubObject);
			TemplateOutputs[i] = TemplateOutput;
		}
		
		check(TemplateOutput);
		TemplateOutput->SetCanDeleteHoudiniNodes(false);

		// Keep track of potential stale output objects on the template component, for this output.
		TMap<FHoudiniOutputObjectIdentifier, FHoudiniOutputObject>& TemplateOutputObjects = TemplateOutput->GetOutputObjects();
		TArray<FHoudiniOutputObjectIdentifier> StaleTemplateObjects;
		TemplateOutputObjects.GetKeys(StaleTemplateObjects);

		for (auto& Entry : InstanceOutput->GetOutputObjects())
		{
		
			// Prepare the FHoudiniOutputObject for the template component
			const FHoudiniOutputObject& InstanceObj = Entry.Value;
			FHoudiniOutputObject TemplateObj;

			// Any output present in the Instance Outputs should be
			// transferred to the template.
			// Remove this output object from stale outputs list.
			StaleTemplateObjects.Remove(Entry.Key);

			if (TemplateOutputObjects.Contains(Entry.Key))
			{
				// Reuse the existing template object
				TemplateObj = TemplateOutputObjects.FindChecked(Entry.Key);
			}
			else 
			{
				// Create a new template output object object by duplicating the instance object.
				// Keep the output object, but clear the output component since we have to 
				// create a new component template.
				TemplateObj = InstanceObj;
				TemplateObj.ProxyComponent = nullptr;
				TemplateObj.OutputComponent = nullptr;
				TemplateObj.ProxyObject = nullptr;
			}

			USceneComponent* ComponentInstance = Cast<USceneComponent>(InstanceObj.OutputComponent);
			USceneComponent* ComponentTemplate = Cast<USceneComponent>(TemplateObj.OutputComponent);
			UObject* OutputObject = InstanceObj.OutputObject;

			if (ComponentInstance)
			{
				// The translation process has either constructed new components, or it is 
				// reusing existing components, or changed an output (or all or none of the aforementioned). 
				// Carefully inspect the SCS graph to determine whether there is a corresponding 
				// (and compatible) node for this output. If not, create a new node and remove unusable node, if any.

				USCS_Node* ComponentNode = nullptr;
				{
					// Check whether the current OutputComponent being referenced by the template is still valid.
					// Even if it was removed in the editor, it doesn't have any associated destroyed / pendingkill state. 
					// Instead we're going to check for validity by finding an SCS node with a matching template component. 
					bool bValidComponentTemplate = (ComponentTemplate != nullptr);
					if (ComponentTemplate)
					{
					
						ComponentNode = FindSCSNodeForTemplateComponentInClassHierarchy(ComponentTemplate);
						bValidComponentTemplate = bValidComponentTemplate && (ComponentNode != nullptr);
					}

					if (!bValidComponentTemplate)
					{
						// Either this component was removed from the editor or it doesn't exist yet.
						// Ensure the references are cleared
						TemplateObj.OutputComponent = nullptr;
						ComponentTemplate = nullptr;
					}
				}

				// NOTE: we can't use the component instance name directly due to the Blueprint compiler performing an internal checking
				// using FComponentEditorUtils::IsValidVariableNameString(), which will return false if the name looks like an autogenerated name...
				//FString ComponentName = ComponentInstance->GetName();
				FString ComponentName = FBlueprintEditorUtils::GetClassNameWithoutSuffix(ComponentInstance->GetClass());
				FName ComponentFName  = FName(ComponentName);
			

				const auto ComponentCopyOptions = ( EditorUtilities::ECopyOptions::Type )(
						EditorUtilities::ECopyOptions::PropagateChangesToArchetypeInstances |
						EditorUtilities::ECopyOptions::CallPostEditChangeProperty |
						EditorUtilities::ECopyOptions::CallPostEditMove);
				
				if (IsValid(ComponentNode))
				{
					// Check if we have an existing and compatible SCS node containing a USceneComponent as a template component.
					bool bComponentNodeIsValid = true;
					
					ComponentTemplate = Cast<USceneComponent>(ComponentNode->ComponentTemplate);

					bComponentNodeIsValid = bComponentNodeIsValid && ComponentInstance->GetClass() == ComponentNode->ComponentClass;
					bComponentNodeIsValid = bComponentNodeIsValid && ComponentTemplate != nullptr;
					// TODO: Do we need to perform any other compatibility checks?

					if (!bComponentNodeIsValid)
					{
						// Component template is not compatible. We can't reuse it.
					
						SCSHACNode->RemoveChildNode(ComponentNode);
						SCS->RemoveNode(ComponentNode);
						ComponentNode = nullptr;
						ComponentTemplate = nullptr;
						CachedTemplateComponent->MarkAsBlueprintStructureModified();
					}
				}

				if (ComponentNode)
				{
					// We found a reusable SCS node. Just copy the component instance
					// properties over to the existing template.
					check(ComponentNode->ComponentTemplate);

					// UEngine::FCopyPropertiesForUnrelatedObjectsParams Params;
					// //Params.bReplaceObjectClassReferences = false;
					// Params.bDoDelta = false; // Perform a deep copy
					// Params.bClearReferences = false;
					// UEngine::CopyPropertiesForUnrelatedObjects(ComponentInstance, ComponentNode->ComponentTemplate, Params);
					
					FHoudiniEngineRuntimeUtils::CopyComponentProperties(ComponentInstance, ComponentNode->ComponentTemplate, ComponentCopyOptions);
					CachedTemplateComponent->MarkAsBlueprintStructureModified();

					ComponentNode->ComponentTemplate->CreationMethod = EComponentCreationMethod::Native;
				}
				else
				{
					// We couldn't find a reusable SCS node. 
					// Duplicate the instance component and create a new corresponding SCS node
					ComponentNode = SCS->CreateNode(ComponentInstance->GetClass(), ComponentFName);
					
					UEditorEngine::FCopyPropertiesForUnrelatedObjectsParams Params;
					Params.bDoDelta = false; // We need a deep copy of parameters here so the CDO values get copied as well
					UEditorEngine::CopyPropertiesForUnrelatedObjects(ComponentInstance, ComponentNode->ComponentTemplate, Params);
					// FHoudiniEngineRuntimeUtils::CopyComponentProperties(ComponentInstance, ComponentNode->ComponentTemplate, ComponentCopyOptions);

					// {
					// 	UInstancedStaticMeshComponent* Component = Cast<UInstancedStaticMeshComponent>(ComponentNode->ComponentTemplate);
					// 	if (Component)
					// 	{
					// 	}
					// }
					
					// NOTE: The EComponentCreationMethod here is currently set to be the same as a component that was 
					// created manually in the editor.
					ComponentNode->ComponentTemplate->CreationMethod = EComponentCreationMethod::Native; 
					
					// Add this node to the SCS root set.

					// Attach the new node the HAC SCS node
					// NOTE: This will add the node to the SCS->AllNodes list too but it won't update
					// the nodename map. We can't forcibly update the Node/Name map either since the 
					// relevant functions have not been exported.
					SCSHACNode->AddChildNode(ComponentNode);

					// Set the output component.
					TemplateObj.OutputComponent = ComponentNode->ComponentTemplate;

					CachedTemplateComponent->MarkAsBlueprintStructureModified();
				}

				// Cache the mapping between the output and the SCS node.
				check(ComponentNode);
				CachedOutputNodes.Add(Entry.Key, ComponentNode->VariableGuid);
			} // if (ComponentInstance)
			/*
			else if (InstanceObj.OutputObject)
			{
			
			}
			*/

			// Add the updated output object to the template output
			TemplateOutputObjects.Add(Entry.Key, TemplateObj);
		}

		// Cleanup stale objects for this template output.
		for (const auto& StaleId : StaleTemplateObjects)
		{
			FHoudiniOutputObject& OutputObj = TemplateOutputObjects.FindChecked(StaleId);

			// Ensure the component template is no longer referencing this output.
			TemplateOutputObjects.Remove(StaleId);

			USceneComponent* TemplateComponent = Cast<USceneComponent>(OutputObj.OutputComponent);

			if (TemplateComponent)
			{
				USCS_Node* StaleNode = FindSCSNodeForTemplateComponentInClassHierarchy(TemplateComponent);
				if (StaleNode)
				{
				
					SCS->RemoveNode(StaleNode, false);
					CachedTemplateComponent->MarkAsBlueprintStructureModified();
				}
				/*
				else
				{
				
				}
				*/
			}
			/*
			else
			{
			
			}
			*/
		}
	} //for (int i = 0; i < Outputs.Num(); i++)

	// Clean up stale outputs on the component template.
	for (UHoudiniOutput* StaleOutput : StaleTemplateOutputs)
	{
		if (!StaleOutput)
			continue;

		// Remove any components contained in this output from the SCS graph
		for (auto& Entry : StaleOutput->GetOutputObjects())
		{
			FHoudiniOutputObject& StaleObject = Entry.Value;
			USceneComponent* OutputComponent = Cast<USceneComponent>(StaleObject.OutputComponent);

			if (OutputComponent)
			{
			
				USCS_Node* StaleNode = FindSCSNodeForTemplateComponentInClassHierarchy(OutputComponent);
				if (StaleNode)
				{
				
					SCS->RemoveNode(StaleNode, false);
					CachedTemplateComponent->MarkAsBlueprintStructureModified();
				}
			}
		}

		TemplateOutputs.Remove(StaleOutput);
		//StaleOutput->ConditionalBeginDestroy();
	}

	SCS->ValidateSceneRootNodes();

	// Copy parameters from this component to the template component.
	// NOTE: We need to do this since the preview component will be cooking the HDA and get populated with
	// all the parameters. This data needs to be sent back to the component template.
	UClass* ComponentClass = CachedTemplateComponent->GetClass();
	UHoudiniAssetBlueprintComponent* DefaultObj = Cast<UHoudiniAssetBlueprintComponent>(ComponentClass->GetDefaultObject());
	bool bBPStructureModified = false;
	CachedTemplateComponent->CopyDetailsFromComponent(
		this, 
		true,
		true, 
		true,
		false,
		true,
		bBPStructureModified,
		/* SetFlags */ CachedTemplateComponent->GetMaskedFlags(RF_PropagateToSubObjects));

	if (bBPStructureModified)
		CachedTemplateComponent->MarkAsBlueprintStructureModified();

	// Copy the cached output nodes back to the template so that 
	// reconstructed actors can correctly update output objects
	// with newly constructed components during ApplyComponentInstanceData() calls. 
	CachedTemplateComponent->CachedOutputNodes = CachedOutputNodes;

	CachedTemplateComponent->MarkPackageDirty();
	PostEditChange();

	CachedTemplateComponent->AssetId = AssetId;
	CachedTemplateComponent->HapiGUID = HapiGUID;
	CachedTemplateComponent->AssetCookCount = AssetCookCount;
	CachedTemplateComponent->AssetStateResult = AssetStateResult;
	CachedTemplateComponent->bLastCookSuccess = bLastCookSuccess;

#if WITH_EDITOR
	// TODO: Do we need to handle this right now or can we wait for the next Houdini Engine manager tick to process it?
	if (CachedTemplateComponent->NeedBlueprintStructureUpdate())
	{
		// We are about to recompile the blueprint. This will reconstruct the preview actor so we need to ensure
		// that the old actor won't release the houdini nodes.
		FHoudiniEngineRuntimeUtils::MarkBlueprintAsStructurallyModified(CachedTemplateComponent.Get());
		SetCanDeleteHoudiniNodes(false);
	}
	/*else if (CachedTemplateComponent->NeedBlueprintUpdate())
	{
		FHoudiniEngineRuntimeUtils::MarkBlueprintAsModified(CachedTemplateComponent.Get());
	}*/
#endif
}
#endif

#if WITH_EDITOR
void
UHoudiniAssetBlueprintComponent::CopyStateFromTemplateComponent(UHoudiniAssetBlueprintComponent* FromComponent, const bool bClearFromInputs, const bool bClearToInputs, const bool bCopyInputObjectComponentProperties)
{
	HOUDINI_BP_MESSAGE(TEXT("[UHoudiniAssetBlueprintComponent::CopyStateFromTemplateComponent] Component: %s"), *(GetPathName()));
	HOUDINI_BP_MESSAGE(TEXT("[UHoudiniAssetBlueprintComponent::CopyStateFromTemplateComponent] From Component: %s"), *(FromComponent->GetPathName()));

	// This should never be called by component templates. 
	check(!IsTemplate());

	// Make sure all TransientDuplicate properties from the Template Component needed by this transient component
	// gets copied.

	ComponentGUID = FromComponent->ComponentGUID;

	/*
	{
		const TArray<USceneComponent*> Children = GetAttachChildren();
		for (USceneComponent* Child : Children) 
		{
			if (!Child)
				continue;
		}
	}
	*/

	// AssetState = FromComponent->PreviewAssetState;
	
	// This state should not be shared between template / instance components.
	//bFullyLoaded = FromComponent->bFullyLoaded;

	bNoProxyMeshNextCookRequested = FromComponent->bNoProxyMeshNextCookRequested;
	
	// Reconstruct outputs and update them to point to component instances as opposed to templates.
	UObject* TemplateOuter = CachedTemplateComponent->GetOuter();
	
	USimpleConstructionScript* SCS = CachedBlueprint->SimpleConstructionScript;
	check(SCS);
	
	// NOTE: We can find the SCS node for the HoudiniAssetComponent from either the template component or the instance (editor preview) component.
	USCS_Node* SCSHACNode = FindSCSNodeForTemplateComponentInClassHierarchy(CachedTemplateComponent.Get());
	check(SCSHACNode);

	// -----------------------------------------------------
	// Copy outputs to component template
	// -----------------------------------------------------

	TArray<UHoudiniOutput*>& TemplateOutputs = CachedTemplateComponent->Outputs;
	
	TSet<UHoudiniOutput*> StaleInstanceOutputs(Outputs);
	
	Outputs.SetNum(TemplateOutputs.Num());

	for (int i = 0; i < TemplateOutputs.Num(); i++)
	{
		UHoudiniOutput* TemplateOutput = TemplateOutputs[i];
		if (!IsValid(TemplateOutput))
			continue;

		UHoudiniOutput* InstanceOutput = Outputs[i];
		if (!(InstanceOutput->GetOuter() == this))
			InstanceOutput = nullptr;

		if (InstanceOutput)
		{
			StaleInstanceOutputs.Remove(InstanceOutput);
		}

		if (InstanceOutput)
		{
			// Copy properties from the current instance component while preserving output objects
			// and instanced outputs.
			InstanceOutput->CopyPropertiesFrom(TemplateOutput, true);
		}
		else
		{
			InstanceOutput = TemplateOutput->DuplicateAndCopyProperties(this, FName(TemplateOutput->GetName()));
			if (IsValid(InstanceOutput))
				InstanceOutput->ClearFlags(RF_ArchetypeObject|RF_DefaultSubObject);
		}

		Outputs[i] = InstanceOutput;

		if (!IsValid(InstanceOutput))
			continue;

		InstanceOutput->SetCanDeleteHoudiniNodes(false);

		TMap<FHoudiniOutputObjectIdentifier, FHoudiniOutputObject>& TemplateOutputObjects = TemplateOutput->GetOutputObjects();
		TMap<FHoudiniOutputObjectIdentifier, FHoudiniOutputObject>& InstanceOutputObjects = InstanceOutput->GetOutputObjects();
		TArray<FHoudiniOutputObjectIdentifier> StaleOutputObjects;
		InstanceOutputObjects.GetKeys(StaleOutputObjects);

		for (auto& Entry : TemplateOutputObjects)
		{
			const FHoudiniOutputObject& TemplateObj = Entry.Value;
			FHoudiniOutputObject InstanceObj = TemplateObj;

			if (!InstanceOutputObjects.Contains(Entry.Key))
				continue;

			StaleOutputObjects.Remove(Entry.Key);
			InstanceObj = InstanceOutputObjects.FindChecked(Entry.Key);

		} // for (auto& Entry : TemplateOutputObjects)
		
		// Cleanup stale output objects for this output.
		for (const auto& StaleId : StaleOutputObjects)
		{
			//TemplateOutput
			//check(TemplateOutputs);

			FHoudiniOutputObject& OutputObj = InstanceOutputObjects.FindChecked(StaleId);

			InstanceOutputObjects.Remove(StaleId);
			if (OutputObj.OutputComponent)
			{
				//OutputObj.OutputComponent->ConditionalBeginDestroy();
				OutputObj.OutputComponent = nullptr;
			}
		}
	} // for (int i = 0; i < TemplateOutputs.Num(); i++)

	// Cleanup any stale outputs found on the component instance.
	for (UHoudiniOutput* StaleOutput : StaleInstanceOutputs)
	{
		if (!StaleOutput)
			continue;

		if (!(StaleOutput->GetOuter() == this))
			continue;
	
		// We don't want to clear stale outputs on components instances. Only on template components.
		StaleOutput->SetCanDeleteHoudiniNodes(false);
	}

	// Copy parameters from the component template to the instance.
	bool bBlueprintStructureChanged = false;
	CopyDetailsFromComponent(FromComponent, 
		false, 
		bClearFromInputs, 
		bClearToInputs,
		false,
		true,
		bBlueprintStructureChanged,
		/*SetFlags*/ RF_Public, 
		/*ClearFlags*/ RF_DefaultSubObject|RF_ArchetypeObject);
}
#endif

#if WITH_EDITOR
void 
UHoudiniAssetBlueprintComponent::CopyDetailsFromComponent(
	UHoudiniAssetBlueprintComponent* FromComponent,
	const bool bCreateSCSNodes,
	const bool bClearChangedToInputs,
	const bool bClearChangedFromInputs,
	const bool bInCanDeleteHoudiniNodes,
	const bool bCopyInputObjectComponentProperties,
	bool &bOutBlueprintStructureChanged,
	EObjectFlags SetFlags,
	EObjectFlags ClearFlags)
{
	check(FromComponent);

	HOUDINI_BP_MESSAGE(TEXT("[UHoudiniAssetBlueprintComponent::CopyDetailsFromComponent] Component: %s"), *(GetPathName()));
	HOUDINI_BP_MESSAGE(TEXT("[UHoudiniAssetBlueprintComponent::CopyDetailsFromComponent] FromComponent: %s"), *(FromComponent->GetPathName()));

	/*
	if (!FromComponent->HoudiniAsset)
	{	
		return;
	}
	*/

	// TODO: Try to reuse objects here when we're able.
	//// Copy UHoudiniOutput state from instance to template
	//UEngine::FCopyPropertiesForUnrelatedObjectsParams Params;
	////Params.bReplaceObjectClassReferences = false;
	////Params.bClearReferences = false;
	//Params.bDoDelta = true;
	//UEngine::CopyPropertiesForUnrelatedObjects(ComponentInstance, ComponentNode->ComponentTemplate, Params);

	// Record input remapping that will need to take place when duplicating parameters.
	TMap<UHoudiniInput*, UHoudiniInput*> InputMapping;

	// -----------------------------------------------------
	// Copy inputs
	// -----------------------------------------------------

	// TODO: Add support for input components
	{
		TArray<UHoudiniInput*>& FromInputs = FromComponent->Inputs;
		TSet<UHoudiniInput*> StaleInputs(Inputs);
		USimpleConstructionScript* SCS = GetSCS();
		USCS_Node* SCSHACNode = nullptr;

		if (bCreateSCSNodes)
		{
			SCSHACNode = FindSCSNodeForTemplateComponentInClassHierarchy(CachedTemplateComponent.Get());
		}
		
		Inputs.SetNum(FromInputs.Num());
		for (int i = 0; i < FromInputs.Num(); i++)
		{
			UHoudiniInput* FromInput = nullptr;
			UHoudiniInput* ToInput = nullptr;
			FromInput = FromInputs[i];

			check(FromInput);

			ToInput = Inputs[i];

			if (ToInput)
			{
				// Check whether the instance and template input objects are compatible.
				bool bIsValid = true;
				bIsValid = bIsValid && ToInput->Matches(*FromInput);
				bIsValid = bIsValid && ToInput->GetOuter() == this; 

				if (!bIsValid)
				{
					ToInput = nullptr;
				}
			}

			// TODO: Process stale input objects

			// NOTE: The CopyStateFrom() / DuplicateAndCopyState() will copy/duplicate/cleanup internal inputs to 
			// ensure that there aren't any shared instances between the ToInput/FromInput.
			if (ToInput)
			{
				// We have a compatible input that we can reuse.
				StaleInputs.Remove(ToInput);
				ToInput->CopyStateFrom(FromInput, true, bInCanDeleteHoudiniNodes);
			}
			else
			{
			
				// We don't have an existing / compatible input. Create a new one.
				ToInput = FromInput->DuplicateAndCopyState(this, bInCanDeleteHoudiniNodes);
				if (SetFlags != RF_NoFlags)
					ToInput->SetFlags(SetFlags);
				if (ClearFlags != RF_NoFlags)
					ToInput->ClearFlags( ClearFlags );
			}

			check(ToInput);


			UpdateInputObjectComponentReferences(SCS, FromInput, ToInput, bCopyInputObjectComponentProperties, bCreateSCSNodes, SCSHACNode, &bOutBlueprintStructureChanged);

			Inputs[i] = ToInput;
			InputMapping.Add(FromInput, ToInput);

			if (bClearChangedToInputs)
			{
				// Clear the changed flags on the FromInput so that it doesn't trigger 
				// another update. The ToInput will now be carrying to changed/update flags.
				ToInput->MarkChanged(false);
				ToInput->MarkAllInputObjectsChanged(false);
			}

			if (bClearChangedFromInputs)
			{
				// Clear the changed flags on the FromInput so that it doesn't trigger 
				// another update. The ToInput will now be carrying to changed/update flags.
				FromInput->MarkChanged(false);
				FromInput->MarkAllInputObjectsChanged(false);
			}
		}

		// Cleanup any stale inputs from this component.
		// NOTE: We would typically only have stale inputs when copying state from
		// the component instance to the component template. Garbage collection
		// eventually picks up the input objects and removes the content
		// but until such time we are stuck with those nodes as inputs in the Houdini session
		// so we get rid of those nodes immediately here to avoid some user confusion.
		for (UHoudiniInput* StaleInput : StaleInputs)
		{
			if (!IsValid(StaleInput))
				continue;
		
			check(StaleInput->GetOuter() == this);			
		
			if (StaleInput->HasAnyFlags(RF_NeedLoad | RF_NeedPostLoad))
				continue;
		
			StaleInput->ConditionalBeginDestroy();
		}
	}


	// -----------------------------------------------------
	// Copy parameters (and optionally remap inputs).
	// -----------------------------------------------------
	TMap<UHoudiniParameter*, UHoudiniParameter*> ParameterMapping;
	
	TArray<UHoudiniParameter*>& FromParameters = FromComponent->Parameters;
	Parameters.SetNum(FromParameters.Num());

	for (int i = 0; i < FromParameters.Num(); i++)
	{
		UHoudiniParameter* FromParameter = nullptr;
		UHoudiniParameter* ToParameter = nullptr;

		FromParameter = FromParameters[i];

		check(FromParameter);

		if (Parameters.IsValidIndex(i))
		{
			ToParameter = Parameters[i];
		}

		if (ToParameter)
		{
			bool bIsValid = true;
			// Check whether To/From parameters are compatible
			bIsValid = bIsValid && ToParameter->Matches(*FromParameter);
			bIsValid = bIsValid && ToParameter->GetOuter() == this;
			
			if (!bIsValid)
				ToParameter = nullptr;
		}

		if (ToParameter)
		{
			// Parameter already exists. Simply sync the state.
			ToParameter->CopyStateFrom(FromParameter, true, ClearFlags, SetFlags);
		}
		else
		{
			// TODO: Check whether parameters are the same to avoid recreating them.
			ToParameter = FromParameter->DuplicateAndCopyState(this, ClearFlags, SetFlags);
			Parameters[i] = ToParameter;
		}
		
		check(ToParameter);
		ParameterMapping.Add(FromParameter, ToParameter);
		
		if (bClearChangedFromInputs)
		{
			// We clear the Changed flag on the FromParameter (most likely on the component template)
			// since the template parameter state has now been transfered to the preview component and
			// will resume processing from there.
			FromParameter->MarkChanged(false);
		}
	}

	// Apply remappings on the new parameters
	for (UHoudiniParameter* ToParameter : Parameters)
	{
		ToParameter->RemapParameters(ParameterMapping);
		ToParameter->RemapInputs(InputMapping);
	}

	FProperty* ParametersProperty = GetClass()->FindPropertyByName(TEXT("Parameters"));
	FPropertyChangedEvent Evt(ParametersProperty);
	PostEditChangeProperty(Evt);

	bEnableCooking = FromComponent->bEnableCooking;
	bRecookRequested = FromComponent->bRecookRequested;
	bRebuildRequested = FromComponent->bRebuildRequested;
}

void
UHoudiniAssetBlueprintComponent::UpdateInputObjectComponentReferences(
	USimpleConstructionScript* SCS,
	UHoudiniInput* FromInput,
	UHoudiniInput* ToInput,
	const bool bCopyInputObjectProperties,
	const bool bCreateMissingSCSNodes,
	USCS_Node* SCSHACParent,
	bool* bOutSCSNodeCreated)
{
	TArray<UHoudiniInputHoudiniSplineComponent*> ToInputObjects;
	TArray<UHoudiniInputHoudiniSplineComponent*> FromInputObjects;
	TArray<UHoudiniInputHoudiniSplineComponent*> StaleInputObjects;

	ToInput->GetAllHoudiniInputSplineComponents(ToInputObjects);
	FromInput->GetAllHoudiniInputSplineComponents(FromInputObjects);

	StaleInputObjects = ToInputObjects;
	
	const int32 NumInputObjects = FromInputObjects.Num();
	ToInputObjects.SetNum(NumInputObjects);

	const auto ComponentCopyOptions = ( EditorUtilities::ECopyOptions::Type )(EditorUtilities::ECopyOptions::Default);
	UEngine::FCopyPropertiesForUnrelatedObjectsParams Params;
	//Params.bDoDelta = false; // Perform a deep copy
	Params.bClearReferences = false; 
	
	for(int32 InputObjectIndex = 0; InputObjectIndex < NumInputObjects; ++InputObjectIndex)
	{
		UHoudiniInputHoudiniSplineComponent* FromInputObject = FromInputObjects[InputObjectIndex];
		UHoudiniInputHoudiniSplineComponent* ToInputObject = ToInputObjects[InputObjectIndex];
		if (!FromInputObject)
			continue;
		if (!ToInputObject)
			continue;
		
		USCS_Node* SCSNode = nullptr;
		if (CachedInputNodes.Contains(ToInputObject->Guid))
		{
			// Reuse / update the existing SCS node.
			SCSNode = SCS->FindSCSNodeByGuid( CachedInputNodes.FindChecked(ToInputObject->Guid) );
		}

		if (!SCSNode)
		{
			if (!bCreateMissingSCSNodes)
				continue; // This input object should be removed.
		}

		USceneComponent* ToComponent = nullptr;
		USceneComponent* FromComponent = Cast<USceneComponent>(FromInputObject->GetObject());

		StaleInputObjects.Remove(ToInputObject);
		
		if (FromComponent)
		{
			if (!SCSNode)
			{
				if (bCreateMissingSCSNodes)
				{
					// Create a new SCS node
					SCSNode = SCS->CreateNode(FromComponent->GetClass());
					SCSHACParent->AddChildNode(SCSNode);
					if (bOutSCSNodeCreated)
					{
						*bOutSCSNodeCreated = true;
					}
					AddInputObjectMapping(ToInputObject->Guid, SCSNode->VariableGuid);
				}
			}

			if (SCSNode)
			{
				if (bCreateMissingSCSNodes)
				{
					// If we have been instructed to create missing SCS nodes, assume we are copying
					// the the component template.
					ToComponent = Cast<USceneComponent>(SCSNode->ComponentTemplate);
				}
				else
				{
					// We are not copying to the component template, so we're assuming this is a 
					// component instance. Find the component on the owning actor that matches the SCS node.
					AActor* ToOwningActor = ToInput->GetTypedOuter<AActor>();
					check(ToOwningActor);

					ToComponent = Cast<USceneComponent>(FindComponentInstanceInActor(ToOwningActor, SCSNode));
				}

				if (bCopyInputObjectProperties && ToComponent)
				{		
					USceneComponent* ToAttachParent = ToComponent->GetAttachParent();
					// Copy specific properties from the component template to the instance, if supported by the component.
					// We typically resort to this in order to transfer Transient and TransientDuplicate properties from the 
					// component template over to the instance (typically HasChanged / NeedsToTriggerUpdate flags) in order for
					// the instance to cook properly.
					IHoudiniEngineCopyPropertiesInterface* ToCopyableComponent = Cast<IHoudiniEngineCopyPropertiesInterface>(ToComponent);
					if (ToCopyableComponent)
					{
						// Let the component manage its own data copying.
						ToCopyableComponent->CopyPropertiesFrom(FromComponent);
					}
					else 
					{
						// The component doesn't implement the property copy interface. Simply do a general property copy.
						//UEngine::CopyPropertiesForUnrelatedObjects(FromComponent, ToComponent, Params);
						FHoudiniEngineRuntimeUtils::CopyComponentProperties(FromComponent, ToComponent, ComponentCopyOptions);
					}
					ToComponent->PostEditChange();
				}
			}
		}

		ToInputObject->Update(ToComponent);
		ToInputObjects[InputObjectIndex] = ToInputObject;
	}

	for (UHoudiniInputObject* StaleInputObject : StaleInputObjects)
	{
		if (!StaleInputObject)
			continue;
		StaleInputObject->InvalidateData();
		ToInput->RemoveHoudiniInputObject(StaleInputObject);
		ToInput->MarkChanged(true);
		// TODO: Find the corresponding SCS node and remove it
	}
}

#endif

#if WITH_EDITOR
bool
UHoudiniAssetBlueprintComponent::HasOpenEditor() const
{
	if (IsTemplate())
	{ 
		IAssetEditorInstance* EditorInstance = FindEditorInstance();

		return EditorInstance != nullptr;
	}

	return false;
}
#endif

#if WITH_EDITOR
IAssetEditorInstance*
UHoudiniAssetBlueprintComponent::FindEditorInstance() const
{
	UClass* BPGC = Cast<UClass>(GetOuter());
	if (!IsValid(BPGC))
		return nullptr;
	UBlueprint* Blueprint = Cast<UBlueprint>(BPGC->ClassGeneratedBy);
	if (!IsValid(Blueprint))
		return nullptr;
	if (!CachedAssetEditorSubsystem.IsValid())
		return nullptr;

	IAssetEditorInstance* EditorInstance = CachedAssetEditorSubsystem->FindEditorForAsset(Blueprint, false);

	return EditorInstance;
}
#endif

#if WITH_EDITOR
AActor* 
UHoudiniAssetBlueprintComponent::GetPreviewActor() const
{
	FBlueprintEditor* BlueprintEditor = FHoudiniEngineRuntimeUtils::GetBlueprintEditor(this);
	if (BlueprintEditor)
	{
		return BlueprintEditor->GetPreviewActor();
	}
	return nullptr;
}
#endif

UHoudiniAssetComponent*
UHoudiniAssetBlueprintComponent::GetCachedTemplate() const
{
	return CachedTemplateComponent.Get();
}

//bool 
//UHoudiniAssetBlueprintComponent::CanUpdateParameters() const
//{
//	return IsTemplate();
//}
//
//bool 
//UHoudiniAssetBlueprintComponent::CanUpdateInputs() const
//{
//	return !IsTemplate();
//}
//
//bool
//UHoudiniAssetBlueprintComponent::CanUpdateOutputs() const
//{
//	return !IsTemplate();
//}
//
//bool 
//UHoudiniAssetBlueprintComponent::CanProcessOutputs() const
//{
//	return !IsTemplate();
//}

//bool 
//UHoudiniAssetBlueprintComponent::CanInstantiateAsset() const
//{
//	// If this is a preview component, it should not trigger an asset instantiation. It should wait 
//	// for the BPGC template component to finish the cook, get the synced data and then translate.
//
//	if (IsPreview())
//		return false;
//
//	return true;
//}
//
//// Check whether the HAC can translate Houdini outputs at all
//bool
//UHoudiniAssetBlueprintComponent::CanTranslateFromHoudini() const
//{
//	// Template components can't translate Houdini output since they typically do not exist in a world.
//	if (IsTemplate())
//		return false;
//	// Preview components and normally instanced actors can translate Houdini outputs.
//	return true;
//}
//
//// Check whether the HAC can translate a specific output type.
//bool
//UHoudiniAssetBlueprintComponent::CanTranslateFromHoudini(EHoudiniOutputType OutputType) const
//{
//	// Blueprint components have limited translation support, for now.
//	if (OutputType == EHoudiniOutputType::Mesh)
//		return true;
//
//	return false;
//}
//
bool 
UHoudiniAssetBlueprintComponent::CanDeleteHoudiniNodes() const
{
	return bCanDeleteHoudiniNodes;
}

void
UHoudiniAssetBlueprintComponent::SetCanDeleteHoudiniNodes(bool bInCanDeleteNodes)
{
	bCanDeleteHoudiniNodes = bInCanDeleteNodes;
	
	for (UHoudiniInput* Input : Inputs)
	{
		Input->SetCanDeleteHoudiniNodes(bInCanDeleteNodes);
	}

	for (UHoudiniOutput* Output : Outputs)
	{
		Output->SetCanDeleteHoudiniNodes(bInCanDeleteNodes);
	}
}

bool 
UHoudiniAssetBlueprintComponent::IsValidComponent() const
{
	if (!Super::IsValidComponent())
		return false;
	
	if (IsTemplate())
	{
		UObject* Outer = this->GetOuter();
		if (!IsValid(Outer))
			return false;
		UBlueprintGeneratedClass* BPGC = Cast<UBlueprintGeneratedClass>(Outer);
		if (!BPGC)
			return false;
		// Ensure this component is still in the SCS
		USimpleConstructionScript* SCS = BPGC->SimpleConstructionScript;
		if (!SCS)
			return false;
		USCS_Node* SCSNode = FindSCSNodeForTemplateComponentInClassHierarchy(this);
		if (!SCSNode)
			return false;
		/*UClass* OwnerClass = Outer->GetClass();
		if (!IsValid(OwnerClass))
			return false;*/
		/*UBlueprint* Blueprint = Cast<UBlueprint>(Outhe);
		if (Blueprint)
		{
			
		}*/
	}
	
#if WITH_EDITOR
	if (!IsTemplate())
	{ 
		if (!GetOwner())
		{
			// If it's not a template, it needs an owner!
			return false;
		}

		USimpleConstructionScript* SCS = GetSCS();
		if (SCS)
		{
			// We're dealing with a Blueprint related component.
			AActor* PreviewActor = GetPreviewActor();
			AActor* OwningActor  = GetOwner();
			if (!OwningActor)
				return false;
			if (OwningActor != PreviewActor)
			{
				return false;
			}
		}

	}

	if (IsPreview() && false)
	{
		USimpleConstructionScript* SCS = GetSCS();
		if (!SCS)
			return false; // Preview components should have an SCS.

		// We want to specifically detect whether an editor component is still being previewed. We do this 
		// by checking whether the owning actor is still the active editor actor in the SCS.
		AActor* PreviewActor = GetPreviewActor();
		if (!PreviewActor)
		{
			return false;
		}

		// Ensure this component still belongs the to the current preview actor.
		if (PreviewActor != GetOwner())
		{
			return false;
		}

		/*
		AActor* EditorActor = SCS->GetComponentEditorActorInstance();
		if (GetOwner() != EditorActor)
		{
			return false;
		}
		*/
	}
#endif

	return true;
}

bool 
UHoudiniAssetBlueprintComponent::IsInputTypeSupported(EHoudiniInputType InType) const
{
	switch (InType)
	{
		case EHoudiniInputType::Geometry:
		case EHoudiniInputType::Curve:
			return true;
			break;
		default:
			break;
	}
	return false;
}

bool 
UHoudiniAssetBlueprintComponent::IsOutputTypeSupported(EHoudiniOutputType InType) const
{
	switch (InType)
	{
		case EHoudiniOutputType::Mesh:
		case EHoudiniOutputType::Instancer:
			return true;
			break;
		default:
			break;
	}
	return false;
}

bool 
UHoudiniAssetBlueprintComponent::IsProxyStaticMeshEnabled() const
{
	// TODO: Investigate adding support for proxy meshes in BP
	// Disabled for now
	return false;
}

//void 
//UHoudiniAssetBlueprintComponent::BroadcastPreAssetCook()
//{
//	// ------------------------------------------------
//	// NOTE: This code will run on TEMPLATE components
//	// ------------------------------------------------
//
//	// The HoudiniAsset is about to be recooked. This flag will indicate to
//	// the transient components that output processing needs to be baked 
//	// back to the BP definition.
//	bOutputsRequireUpdate = true;
//
//	Super::BroadcastPreAssetCook();
//}

void 
UHoudiniAssetBlueprintComponent::OnPrePreCook()
{
	check(IsPreview());
	
	Super::OnPrePreCook();

	// We need to allow deleting houdini nodes 
	SetCanDeleteHoudiniNodes(true);
}

void 
UHoudiniAssetBlueprintComponent::OnPostPreCook()
{
	check(IsPreview());
	
	Super::OnPostPreCook();

	// Ensure the houdini nodes can be deleted during the translation process.
	SetCanDeleteHoudiniNodes(false);
}

void 
UHoudiniAssetBlueprintComponent::OnPreOutputProcessing()
{
	check(IsPreview());
	
	Super::OnPreOutputProcessing();

	// Ensure the houdini nodes can be deleted during the translation process.
	SetCanDeleteHoudiniNodes(true);
}

void 
UHoudiniAssetBlueprintComponent::OnPostOutputProcessing()
{
	Super::OnPostOutputProcessing();

	// ------------------------------------------------
	// NOTE: 
	// In Blueprint editor mode, this code will run on PREVIEW components
	// In Map editor mode, this code will run on component instances.
	// ------------------------------------------------
	if (IsPreview())
	{
		// Ensure all the inputs / outputs belonging to the 
		// preview actor won't be deleted by PreviewActor destruction.
		SetCanDeleteHoudiniNodes(false);
		
#if WITH_EDITOR
		CopyStateToTemplateComponent();
#endif
		
	}
	bUpdatedFromTemplate = false;
}

void UHoudiniAssetBlueprintComponent::OnPrePreInstantiation()
{
	HOUDINI_BP_MESSAGE(TEXT("[UHoudiniAssetBlueprintComponent::OnPrePreInstantiation] Component: %s"), *(GetPathName()));

	check(IsPreview());
	
	if (bUpdatedFromTemplate)
		return;
	
	check(CachedTemplateComponent.IsValid());
	
	// This HDA is about to be cooked but not through template parameter changes. It is likely that an input changed directly in the preview world.
	// We need to flag our inputs and parameters appropriately in order to preserve their values.

	// We need to mark all our parameters as changed/not triggering update
	for (auto CurrentParam : Parameters)
	{
		if (CurrentParam)
		{
			CurrentParam->MarkChanged(true);
			CurrentParam->SetNeedsToTriggerUpdate(false);
		}
	}

	// We need to mark all our inputs as changed/not triggering update
	for (auto CurrentInput : Inputs)
	{
		if (CurrentInput)
		{
			CurrentInput->MarkChanged(true);
			CurrentInput->SetNeedsToTriggerUpdate(false);
			CurrentInput->MarkDataUploadNeeded(true);
		}
	}
}

void 
UHoudiniAssetBlueprintComponent::NotifyHoudiniRegisterCompleted()
{
	if (IsTemplate())
	{
		// TODO: Do we need to set any status flags or clear stuff to ensure 
		// the BP HAC will cook properly when the BP is opened again...

		// If the template is being registered, we need to invalidate the AssetId here since it likely 
		// contains a stale asset id from its last cook.
		AssetId = -1;
		// Template component's have very limited update requirements / capabilities.
		// Mostly just cache parameters and cook state.
		SetAssetState(EHoudiniAssetState::ProcessTemplate); 
	}

	Super::NotifyHoudiniRegisterCompleted();
}

void 
UHoudiniAssetBlueprintComponent::NotifyHoudiniPreUnregister()
{
	if (IsTemplate())
	{
		// Templates can delete Houdini nodes when they get deregistered.
		SetCanDeleteHoudiniNodes(true);
	}
	Super::NotifyHoudiniPreUnregister();
}

void 
UHoudiniAssetBlueprintComponent::NotifyHoudiniPostUnregister()
{
	InvalidateData();
	
	Super::NotifyHoudiniPostUnregister();

	if (IsTemplate())
	{		
		SetCanDeleteHoudiniNodes(false);
	}
}

#if WITH_EDITOR
void 
UHoudiniAssetBlueprintComponent::OnComponentCreated()
{
	HOUDINI_BP_MESSAGE(TEXT("[UHoudiniAssetBlueprintComponent::OnComponentCreated] Component: %s"), *(GetPathName()));

	Super::OnComponentCreated();
	bUpdatedFromTemplate = false;

	CachePreviewState();

	if (IsPreview())
	{
		// Don't set an initial AssetState here. Preview components should only cook when template's 
		// Houdini Asset or HDA parameters have changed.

		// Clear these to ensure that we're not sharing references with the component template (otherwise
		// the shared objects will get deleted when the component instance gets destroyed).
		// These objects will be properly duplicated when copying state from the component template.
		Inputs.Empty();
		Parameters.Empty();
	}

	// Wait until InitializeComponent() for blueprint construction to complete before we start caching blueprint data.

}
#endif


void 
UHoudiniAssetBlueprintComponent::OnRegister()
{
	HOUDINI_BP_MESSAGE(TEXT("[UHoudiniAssetBlueprintComponent::OnRegister] Component: %s"), *(GetPathName()));

	Super::OnRegister();

	// We run our Blueprint caching functions here since this the last hook that we have before 
	// entering HoudiniEngineTick();

	CacheBlueprintData();
	CachePreviewState();

	if (IsPreview())
	{
		check(CachedTemplateComponent.Get());
		// Ensure that the component template has been registered since it needs to be processed for parameter updates by the HE manager.
		if (!FHoudiniEngineRuntime::Get().IsComponentRegistered(CachedTemplateComponent.Get()))
		{
			// The template component has not been registered yet, which means that we're probably busy opening a Blueprint editor and this
			// preview component will need to be updated.
		
			FHoudiniEngineRuntime::Get().RegisterHoudiniComponent(CachedTemplateComponent.Get(), true);
			CachedTemplateComponent->SetCanDeleteHoudiniNodes(false);
			// Since we're likely opening a fresh blueprint editor, we'll need to instantiate the HDA.
			bHasRegisteredComponentTemplate = true;
		}
	}

	if (IsTemplate())
	{
		// We're initializing the asset id for HAC template here since it doesn't get unloaded
		// from memory, for example, between Blueprint Editor open/close so we need to make sure
		// that the AssetId has indeed been reset between registrations.
		AssetId = -1;
	}

	//TickInitialization();
}

void 
UHoudiniAssetBlueprintComponent::BeginDestroy()
{
	Super::BeginDestroy();
}

void 
UHoudiniAssetBlueprintComponent::DestroyComponent(bool bPromoteChildren)
{
	//FDebug::DumpStackTraceToLog();
	if (CachedTemplateComponent.IsValid() && TemplatePropertiesChangedHandle.IsValid())
	{
		CachedTemplateComponent->Modify();
		CachedTemplateComponent->OnParametersChangedEvent.Remove(TemplatePropertiesChangedHandle);
	}
	Super::DestroyComponent(bPromoteChildren);
}

void 
UHoudiniAssetBlueprintComponent::OnComponentDestroyed(bool bDestroyingHierarchy)
{
	Super::OnComponentDestroyed(bDestroyingHierarchy);
}

TStructOnScope<FActorComponentInstanceData> 
UHoudiniAssetBlueprintComponent::GetComponentInstanceData() const
{
	HOUDINI_BP_MESSAGE(TEXT("[UHoudiniAssetBlueprintComponent::GetComponentInstanceData] Component: %s"), *(GetPathName()));

	TStructOnScope<FActorComponentInstanceData> ComponentInstanceData = MakeStructOnScope<FActorComponentInstanceData, FHoudiniAssetBlueprintInstanceData>(this);
	FHoudiniAssetBlueprintInstanceData* InstanceData = ComponentInstanceData.Cast<FHoudiniAssetBlueprintInstanceData>();

	InstanceData->AssetId = AssetId;
	InstanceData->AssetState = AssetState;
	InstanceData->SubAssetIndex = SubAssetIndex;
	InstanceData->ComponentGUID = ComponentGUID;
	InstanceData->HapiGUID = HapiGUID;
	InstanceData->HoudiniAsset = HoudiniAsset;
	InstanceData->SourceName = GetPathName();
	InstanceData->AssetCookCount = AssetCookCount;
	InstanceData->bHasBeenLoaded = bHasBeenLoaded;
	InstanceData->bHasBeenDuplicated = bHasBeenDuplicated;
	InstanceData->bPendingDelete = bPendingDelete;
	InstanceData->bRecookRequested = bRecookRequested;
	InstanceData->bEnableCooking = bEnableCooking;
	InstanceData->bForceNeedUpdate = bForceNeedUpdate;
	InstanceData->bLastCookSuccess = bLastCookSuccess;
	InstanceData->bRegisteredComponentTemplate = bHasRegisteredComponentTemplate;

	InstanceData->Inputs.Empty();

	for (UHoudiniInput* Input : Inputs)
	{
		if (!Input)
			continue;
		UHoudiniInput* TransientInput = Input->DuplicateAndCopyState(GetTransientPackage(), false);
		InstanceData->Inputs.Add(TransientInput);
	}

	// Cache the current outputs
	InstanceData->Outputs.Empty();
	int OutputIndex = 0;
	for(UHoudiniOutput* Output : Outputs)
	{
		if (!Output)
			continue;

		TMap<FHoudiniOutputObjectIdentifier, FHoudiniOutputObject> OutputObjects = Output->GetOutputObjects();
		for (auto& Entry : OutputObjects)
		{
			FHoudiniAssetBlueprintOutput OutputObjectData;
			OutputObjectData.OutputIndex = OutputIndex;
			OutputObjectData.OutputObject = Entry.Value;
			InstanceData->Outputs.Add(Entry.Key, OutputObjectData);
		}

		++OutputIndex;
	}

	return ComponentInstanceData;

}

void 
UHoudiniAssetBlueprintComponent::ApplyComponentInstanceData(FHoudiniAssetBlueprintInstanceData* InstanceData, const bool bPostUCS)
{
	HOUDINI_BP_MESSAGE(TEXT("[UHoudiniAssetBlueprintComponent::ApplyComponentInstanceData] Component: %s"), *(GetPathName()));
	check(InstanceData);

	if (!bPostUCS)
	{
		// Initialize the component before the User Construction Script runs
		USimpleConstructionScript* SCS = GetSCS();
		check(SCS);

		TArray<UHoudiniInput*> StaleInputs(Inputs);

		// We need to update references contain in inputs / outputs to point to new reconstructed components.
		const int32 NumInputs = InstanceData->Inputs.Num();
		Inputs.SetNum(NumInputs);
		for (int i = 0; i < NumInputs; ++i)
		{
			UHoudiniInput* FromInput = InstanceData->Inputs[i];
			UHoudiniInput* ToInput = Inputs[i];

			if (ToInput)
			{
				bool bIsValid = true;
				bIsValid = bIsValid && ToInput->Matches(*FromInput);
				bIsValid = bIsValid && ToInput->GetOuter() == this;
				if (!bIsValid)
				{
					ToInput = nullptr;
				}
			}

			if (ToInput)
			{
				// Reuse input
				StaleInputs.Remove(ToInput);
				ToInput->CopyStateFrom(FromInput, true, false);
			}
			else
			{
				// Create new input
				ToInput = FromInput->DuplicateAndCopyState(this, false);
			}

#if WITH_EDITOR
			// We can't create missing SCS nodes here since we're likely already in the middle of a 
			// Blueprint reconstruction. We'll have to recreate missing SCS nodes next time the 
			// component state if copied to the template.
			UpdateInputObjectComponentReferences(SCS, FromInput, ToInput, true, false);
#endif

			Inputs[i] = ToInput;
		}

		// We need to update FHoudiniOutputObject SceneComponent references to
		// the newly created components. Since we cached a map of Output Object IDs to
		// SCSNodes (during CopyStateToTemplateComponent), we can the SCSNode that corresponds to this output objects and find
		// the SceneComponent that matches the SCSNode's variable name.
		// It is important to note that it is safe to do it this way since we're in the pre-UCS
		// phase so that current components should match the SCS graph exactly (no user construction script
		// interference here yet).

		for (auto& Entry : InstanceData->Outputs)
		{
			FHoudiniOutputObjectIdentifier& ObjectId = Entry.Key;
			FHoudiniAssetBlueprintOutput& OutputData = Entry.Value;

			// NOTE: Output objects are going to be empty here since they dissapear during actor reconstruction.
			// We'll need to repopulate from the instance data.

			check(Outputs.IsValidIndex(OutputData.OutputIndex));
			UHoudiniOutput* Output = Outputs[OutputData.OutputIndex];
			check(Output);
			TMap<FHoudiniOutputObjectIdentifier, FHoudiniOutputObject>& OutputObjects = Output->GetOutputObjects();
			FHoudiniOutputObject NewObject = OutputData.OutputObject;

			if (OutputData.OutputObject.OutputComponent)
			{
				// Update the output component reference.
				check(CachedOutputNodes.Contains(ObjectId))
				const FGuid VariableGuid = CachedOutputNodes.FindChecked(ObjectId);
				USCS_Node* SCSNode = SCS->FindSCSNodeByGuid(VariableGuid);

				if (SCSNode)
				{
					// Find the component that corresponds to the SCS node.
					USceneComponent* SceneComponent = FindActorComponentByName(GetOwner(), SCSNode->GetVariableName());
					NewObject.OutputComponent = SceneComponent;
				}
				else
				{
					NewObject.OutputComponent = nullptr;
				}
			}

			OutputObjects.Add(ObjectId, NewObject);
		}

		if (CachedTemplateComponent.IsValid())
		{
#if WITH_EDITOR
		CopyStateFromTemplateComponent( CachedTemplateComponent.Get(), false, false, true);
#endif
		}
	
		AssetId = InstanceData->AssetId;
		SubAssetIndex = InstanceData->SubAssetIndex;
		ComponentGUID = InstanceData->ComponentGUID;
		HapiGUID = InstanceData->HapiGUID;
	
		// Apply the previous HoudiniAsset to the component
		// so that we can compare it against the template during CopyStateFromTemplate() calls to see whether it changed.
		HoudiniAsset = InstanceData->HoudiniAsset;

		AssetCookCount = InstanceData->AssetCookCount;
		bHasBeenLoaded = InstanceData->bHasBeenLoaded;
		bHasBeenDuplicated = InstanceData->bHasBeenDuplicated;
		bPendingDelete = InstanceData->bPendingDelete;
		bRecookRequested = InstanceData->bRecookRequested;
		bEnableCooking = InstanceData->bEnableCooking;
		bForceNeedUpdate = InstanceData->bForceNeedUpdate;
		bLastCookSuccess = InstanceData->bLastCookSuccess;
		bHasRegisteredComponentTemplate = InstanceData->bRegisteredComponentTemplate;

		AssetState = InstanceData->AssetState;
		
		SetCanDeleteHoudiniNodes(false);

	}   // if (!bPostUCS)
	/*
	else
	{
		// PostUCS

	}
	*/
}


void 
UHoudiniAssetBlueprintComponent::HoudiniEngineTick()
{
	if (!IsFullyLoaded())
	{
		USimpleConstructionScript* SCS = GetSCS();
		if (SCS == nullptr)
		{		
			OnFullyLoaded();
		}
		else if (IsPreview())
		{
			AActor* OwningActor = GetOwner();
			check(OwningActor);

			// If this is a *preview component*, it is important to wait for the template component to be fully loaded
			// since it needs to be initialized so that the component instance can copy initial values from the template.
			check(CachedTemplateComponent.Get());

			if (CachedTemplateComponent->IsFullyLoaded())
			{
#if WITH_EDITOR
				if(SCS->IsConstructingEditorComponents())
				{
					// We're stuck in an editor blueprint construction / preview actor update. Wait some more.				
				}
				else 
				{
					OnFullyLoaded();
				}
#else
				OnFullyLoaded();
#endif
			}
		}
		else
		{
			// Anything else can go onto being fully loaded at this point.
			OnFullyLoaded();
		}
	}
}

void 
UHoudiniAssetBlueprintComponent::OnFullyLoaded()
{
	Super::OnFullyLoaded();

	// Check whether this component is inside a Blueprint editor. If this object lives outside the blueprint editor (in , then we need to ensure that this 
	// component won't be influencing the Blueprint asset.
	
	if (!IsTemplate())
	{
#if WITH_EDITOR
		AActor* PreviewActor = GetPreviewActor();
#else
		AActor* PreviewActor = nullptr;
#endif
		AActor* OwningActor = GetOwner();
	
		if (!PreviewActor)
		{
			bIsInBlueprintEditor = false;
			AssetState = EHoudiniAssetState::None;
			return;
		}

		if (OwningActor && PreviewActor != OwningActor)  
		{
			bIsInBlueprintEditor = false;
			AssetState = EHoudiniAssetState::None;
			return;
		}
	}

	bIsInBlueprintEditor = true;

	CachePreviewState();
	CacheBlueprintData();

	/*
	for (UHoudiniOutput* Output : Outputs)
	{
		if (!Output)
			continue;
	}
	*/

	if (IsTemplate())
	{	
		AssetId = -1;
		AssetState = EHoudiniAssetState::ProcessTemplate;
	}

	if (IsPreview()) 
	{
		check(CachedTemplateComponent.Get());
	
		// If this is a preview actor, sync initial settings from the component template
#if WITH_EDITOR
		CopyStateFromTemplateComponent(CachedTemplateComponent.Get(), false, false, true);
#endif

		TemplatePropertiesChangedHandle = CachedTemplateComponent->OnParametersChangedEvent.AddUObject(this, &UHoudiniAssetBlueprintComponent::OnTemplateParametersChangedHandler);
		if (bHoudiniAssetChanged)
		{
		
			// The HoudiniAsset has changed, so we need to force the PreviewInstance to re-instantiate
			AssetState = EHoudiniAssetState::NeedInstantiation;
			bForceNeedUpdate = true;
			bHoudiniAssetChanged = false;
			// TODO: Make this better?
			CachedTemplateComponent->bHoudiniAssetChanged = false;
		}

		if (bHasRegisteredComponentTemplate)
		{
			// We have a newly registered component template. One of two things happened to cause this:
			// 1. A new HoudiniAssetBlueprintComponent was created and registered.
			// 2. The Blueprint Editor was closed / opened.
			// The problem that arises in the #2 is that the template component was never fully unloaded
			// from memory (it was deregistered but not destroyed). After deregistration we had the
			// opportunity to invalidate asset/node ids but now that it has reregistered (without going
			// through the normal initialization process) we will have to force a call to MarkAsNeedInstantiation
			// during the next OnTemplateParametersChangedHandler() invocation.
			bHasBeenLoaded = true;
		}
	}
}

void 
UHoudiniAssetBlueprintComponent::OnTemplateParametersChanged()
{
	OnParametersChangedEvent.Broadcast(this);
}

void UHoudiniAssetBlueprintComponent::OnBlueprintStructureModified()
{
	check(IsTemplate());
	bBlueprintStructureModified = false;

#if WITH_EDITOR
	if (IsTemplate())
	{
		FHoudiniEngineRuntimeUtils::MarkBlueprintAsStructurallyModified(this);
	}
	else
	{
		check(CachedTemplateComponent.IsValid());
		FHoudiniEngineRuntimeUtils::MarkBlueprintAsStructurallyModified(CachedTemplateComponent.Get());
	}
#endif
}

void UHoudiniAssetBlueprintComponent::OnBlueprintModified()
{
	check(IsTemplate());
	bBlueprintModified = false;
#if WITH_EDITOR
	FHoudiniEngineRuntimeUtils::MarkBlueprintAsModified(this);
#endif
}

void 
UHoudiniAssetBlueprintComponent::OnHoudiniAssetChanged()
{
	if (IsTemplate())
	{
		// Invalidate data associated with this component since we're about to change and reinstantiate the Houdini Asset.
		SetCanDeleteHoudiniNodes(true);
		InvalidateData();
		SetCanDeleteHoudiniNodes(false);
		Parameters.Empty();
		Inputs.Empty();
	}

	Super::OnHoudiniAssetChanged();

	// Set on template components, then copied to preview components, and 
	// then used (and reset) during OnFullyLoaded.
	bHoudiniAssetChanged = true;
}

void 
UHoudiniAssetBlueprintComponent::RegisterHoudiniComponent(UHoudiniAssetComponent *InComponent)
{
	// We only want to register this component if it is the preview actor for the Blueprint editor. 
#if WITH_EDITOR
	AActor* PreviewActor = GetPreviewActor();
#else
	AActor* PreviewActor = nullptr;
#endif
	AActor* OwningActor = GetOwner();
	if (!OwningActor)
		return;

	if (PreviewActor != OwningActor)
		return;

	Super::RegisterHoudiniComponent(InComponent);
}




//bool UHoudiniAssetBlueprintComponent::TickInitialization()
//{
//	return true;
//
//	if (IsFullyLoaded())
//		return true;
//
//	bool bHasFinishedLoading = Super::TickInitialization();
//
//	if (!bHasFinishedLoading)
//		return false;
//
//	if (!IsTemplate())
//	{
//
//		if (CachedTemplateComponent.Get())
//		{
//			// Now that that SCS has finished constructing editor components, we can continue.
//			// Copy the current state from the template component, in case there is something that can be processed.
//			CopyStateFromTemplateComponent(CachedTemplateComponent.Get());
//		}
//
//		AssetStateResult = EHoudiniAssetStateResult::None;
//		AssetState = EHoudiniAssetState::None;
//	
//		bForceNeedUpdate = true;
//		AssetState = EHoudiniAssetState::PostCook;
//	}
//
//	return true;
//}

template<typename ParamT, typename ValueT>
inline void 
UHoudiniAssetBlueprintComponent::SetTypedValueAt(const FString& Name, ValueT& Value, int Index)
{
	ParamT* Parameter = Cast<ParamT>(FindParameterByName(Name));
	if (!Parameter)
		return;

	Parameter->SetValueAt(Value, Index);
}

bool
UHoudiniAssetBlueprintComponent::HasParameter(FString Name)
{
	return FindParameterByName(Name) != nullptr;
}

void 
UHoudiniAssetBlueprintComponent::SetFloatParameter(FString Name, float Value, int Index)
{
	SetTypedValueAt<UHoudiniParameterFloat>(Name, Value, Index);
}

void 
UHoudiniAssetBlueprintComponent::SetToggleValueAt(FString Name, bool Value, int Index)
{
	UHoudiniParameterToggle* Parameter = Cast<UHoudiniParameterToggle>(FindParameterByName(Name));
	if (!Parameter)
		return;

	Parameter->SetValueAt(Value, Index);
}

//void UHoudiniAssetBlueprintComponent::OnPostCookHandler(UHoudiniAssetComponent* InComponent)
//{
//
//	// Before this component handles any translation, we need to make sure that it still belongs to the editor actor.
//	// When a blueprint gets recompiled, the editor actor gets replaced with a new one but the old actor has not yet 
//	// been ftroyed / garbage collected so its components still receive cook events from the template.
//
//	UHoudiniAssetBlueprintComponent* ComponentTemplate = Cast<UHoudiniAssetBlueprintComponent>(InComponent);
//	if (!IsValid(ComponentTemplate))
//		return;
//
//	CopyStateFromTemplateComponent(ComponentTemplate);
//	bForceNeedUpdate = true;
//}

void 
UHoudiniAssetBlueprintComponent::OnTemplateParametersChangedHandler(UHoudiniAssetComponent* InComponentTemplate)
{	
	if (!(AssetState == EHoudiniAssetState::None || AssetState == EHoudiniAssetState::NeedInstantiation || AssetState == EHoudiniAssetState::NeedRebuild))
		// Don't process parameter changes since we're already cooking -- it is going to break things badly if we do.
		return;

	if (!IsValidComponent())
		return;

	UHoudiniAssetBlueprintComponent* ComponentTemplate = Cast<UHoudiniAssetBlueprintComponent>(InComponentTemplate);
	if (!ComponentTemplate)
		return;

	// The component instance needs to copy values from the template.
	bool bBlueprintStructureChanged = false;
#if WITH_EDITOR
	CopyDetailsFromComponent(ComponentTemplate,
		false,
		false,
		true,
		false,
		true,
		bBlueprintStructureChanged,
		RF_Public,
		RF_ClassDefaultObject|RF_ArchetypeObject);
#endif

	SetCanDeleteHoudiniNodes(false);

	if (bHasRegisteredComponentTemplate)
	{
		// NOTE: It is very important to call this *after* CopyDetailsFromComponent(), since CopyDetailsFromComponent
		// will clobber the inputs and parameter states on this component.

		// If we already have a valid asset id, keep it.
		if (AssetId >= 0)
		{
			MarkAsNeedCook();
		}
		else
		{
			MarkAsNeedInstantiation();
		}
		
		bHasRegisteredComponentTemplate = false;
		bFullyLoaded = true; // MarkAsNeedInstantiation sets this to false. Force to true.
		// While MarkAsNeedInstantiation() sets ParametersChanged to true, it does not
		// set the 'NeedToTriggerUpdate' flag (both of which needs to be true in order
		// to trigger an HDA update) so we are going to force NeedUpdate() to return true
		// in order to get an initial cook.
		bForceNeedUpdate = true;
	}

	bUpdatedFromTemplate = true;
}

void 
UHoudiniAssetBlueprintComponent::InvalidateData()
{
	if (IsTemplate())
	{
		// Ensure transient properties are invalidated/released for parameters, inputs and outputs as if the
		// the object was undergoing destruction since the template component will likely be reregistered
		// without being destroyed.
		for(UHoudiniParameter* Param : Parameters)
		{
			Param->InvalidateData();
		}
		
		for(UHoudiniInput* Input : Inputs)
		{
			Input->InvalidateData();
		}

		FHoudiniEngineRuntime::Get().MarkNodeIdAsPendingDelete(AssetId, true);
		AssetId = -1;
	}
}

//void UHoudiniAssetBlueprintComponent::OnTemplateHoudiniAssetChangedHandler(UHoudiniAssetComponent* InComponentTemplate)
//{
//
//	UHoudiniAssetBlueprintComponent* ComponentTemplate = Cast<UHoudiniAssetBlueprintComponent>(InComponentTemplate);
//	if (!ComponentTemplate)
//		return;
//	check(IsPreview());
//
//	// The Houdini Asset was changed on the template. We need to recook.
//	AssetState = EHoudiniAssetState::NeedInstantiation;
//
//}

USceneComponent* 
UHoudiniAssetBlueprintComponent::FindOwnerComponentByName(FName ComponentName) const
{
	AActor* Owner = GetOwner();
	if (!Owner)
		return nullptr;

	return FindActorComponentByName(Owner, ComponentName);
}

USceneComponent*
UHoudiniAssetBlueprintComponent::FindActorComponentByName(AActor* InActor, FName ComponentName) const
{
	const TSet<UActorComponent*>& Components = InActor->GetComponents();

	for (UActorComponent* Component : Components)
	{
		USceneComponent* SceneComponent = Cast<USceneComponent>(Component);
		if (!IsValid(SceneComponent))
			continue;
		if (FName(SceneComponent->GetName()) == ComponentName)
			return SceneComponent;
	}

	return nullptr;
}

bool UHoudiniAssetBlueprintComponent::GetInputObjectSCSVariableGuid(const FGuid& InputGuid, FGuid& OutSCSGuid)
{
	FGuid* SCSGuid = CachedInputNodes.Find(InputGuid);
	if (!SCSGuid)
		return false;
	OutSCSGuid = *SCSGuid;
	return true;
}

USCS_Node* 
UHoudiniAssetBlueprintComponent::FindSCSNodeForTemplateComponent(USimpleConstructionScript* SCS, const UActorComponent* InComponent) const
{
	const TArray<USCS_Node*>& AllNodes = SCS->GetAllNodes();

	for (USCS_Node* Node : AllNodes)
	{
		if (!Node)
			continue;

		if (Node->ComponentTemplate == InComponent)
			return Node;
	}

	return nullptr;
}

USCS_Node* 
UHoudiniAssetBlueprintComponent::FindSCSNodeForTemplateComponentInClassHierarchy(
	const UActorComponent* InComponent) const
{
	UObject* Outer = this->GetOuter();
	if (!IsValid(Outer))
		return nullptr;
	UBlueprintGeneratedClass* MainBPGC;
	if (IsTemplate())
	{
		MainBPGC = Cast<UBlueprintGeneratedClass>(Outer);
	}
	else
	{
		AActor* OwningActor = GetOwner();
		MainBPGC = Cast<UBlueprintGeneratedClass>(OwningActor->GetClass());
	}

	check(MainBPGC);
	TArray<const UBlueprintGeneratedClass*> BPGCStack;
	UBlueprintGeneratedClass::GetGeneratedClassesHierarchy(MainBPGC, BPGCStack);
	for(const UBlueprintGeneratedClass* BPGC : BPGCStack)
	{
		USimpleConstructionScript* SCS = BPGC->SimpleConstructionScript;
		if (!SCS)
			return nullptr;
		USCS_Node* SCSNode = FindSCSNodeForTemplateComponent(SCS, InComponent);
		SCSNode = SCS->FindSCSNode(InComponent->GetFName());
		if (SCSNode)
			return SCSNode;		
	}

	return nullptr;
}

#if WITH_EDITOR
USCS_Node*
UHoudiniAssetBlueprintComponent::FindSCSNodeForInstanceComponent(USimpleConstructionScript* SCS, const UActorComponent* InComponent) const
{
	const TArray<USCS_Node*>& AllNodes = SCS->GetAllNodes();

	if (!InComponent)
		return nullptr;

	for (USCS_Node* Node : AllNodes)
	{
		if (!Node)
			continue;
		if (Node->EditorComponentInstance.Get() == InComponent)
			return Node;
	}

	return nullptr;
}
#endif

UActorComponent*
UHoudiniAssetBlueprintComponent::FindComponentInstanceInActor(const AActor* InActor,
	USCS_Node* SCSNode) const
{
	UActorComponent* ComponentTemplate = SCSNode->ComponentTemplate;

	UActorComponent* ComponentInstance = NULL;
	if (InActor != NULL)
	{
		if (SCSNode != NULL)
		{
			FName VariableName = SCSNode->GetVariableName();
			if (VariableName != NAME_None)
			{
				UWorld* World = InActor->GetWorld();
				FObjectPropertyBase* Property = FindFProperty<FObjectPropertyBase>(InActor->GetClass(), VariableName);
				if (Property != NULL)
				{
					// Return the component instance that's stored in the property with the given variable name
					ComponentInstance = Cast<UActorComponent>(Property->GetObjectPropertyValue_InContainer(InActor));
				}
				else if (World != nullptr && World->WorldType == EWorldType::EditorPreview)
				{
					// If this is the preview actor, return the cached component instance that's being used for the pmnaview actor prior to recompiling the Blueprint
#if WITH_EDITOR
					ComponentInstance = SCSNode->EditorComponentInstance.Get();
#endif
				}
			}
		}
		else if (ComponentTemplate != NULL)
		{
#if WITH_EDITOR
			TInlineComponentArray<UActorComponent*> Components;
			InActor->GetComponents(Components);
			ComponentInstance = FComponentEditorUtils::FindMatchingComponent(ComponentTemplate, Components);
#endif
		}
	}

	return ComponentInstance;
}


//void UHoudiniAssetBlueprintComponent::OnOutputProcessingCompletedHandler(UHoudiniAssetComponent* InComponent)
//{
//
//	UHoudiniAssetBlueprintComponent* TemplateComponent = Cast<UHoudiniAssetBlueprintComponent>(InComponent);
//	if (!IsValid(TemplateComponent))
//		return;
//
//	CopyStateFromComponent(TemplateComponent);
//	bForceNeedUpdate = true;
//}

//#if WITH_EDITOR
//void UHoudiniAssetBlueprintComponent::ReceivedAssetEditorRequestCloseEvent(UObject* Asset, EAssetEditorCloseReason CloseReason)
//{
//	
//	if (CachedBlueprint.Get())
//	{
//	}
//
//	if (Asset)
//	{
//
//	}
//	
//}
//#endif

void
UHoudiniAssetBlueprintComponent::CachePreviewState()
{
	bCachedIsPreview = false;

#if WITH_EDITOR
	AActor* ComponentOwner = GetOwner();
	if (!IsValid(ComponentOwner))
		return;

	USimpleConstructionScript* SCS = GetSCS();
	if (SCS == nullptr)
		return;

	// Get the preview actor directly from the BlueprintEditor.
	FBlueprintEditor* BlueprintEditor = FHoudiniEngineRuntimeUtils::GetBlueprintEditor(this);
	if (BlueprintEditor)
	{
		AActor* PreviewActor = BlueprintEditor->GetPreviewActor();
		if (PreviewActor == ComponentOwner)
		{
			bCachedIsPreview = true;
			return;
		}
	}
#endif
}

void
UHoudiniAssetBlueprintComponent::CacheBlueprintData()
{
	CachedBlueprint = nullptr;
	CachedActorCDO = nullptr;
	CachedTemplateComponent = IsTemplate() ? this : nullptr;

#if WITH_EDITOR
	CachedAssetEditorSubsystem = GEditor->GetEditorSubsystem<UAssetEditorSubsystem>();
#endif
	
	UBlueprintGeneratedClass* BPGC = Cast<UBlueprintGeneratedClass>(GetOuter());
	if (BPGC)
	{
		// Dealing with a component template
		CachedBlueprint = Cast<UBlueprint>(BPGC->ClassGeneratedBy);
	}
	else
	{
		// Dealing with a component instance.
		CachedBlueprint = Cast<UBlueprint>(GetOuter()->GetClass()->ClassGeneratedBy);
	}

	if (CreationMethod != EComponentCreationMethod::SimpleConstructionScript)
		return;

	AActor* ComponentOwner = this->GetOwner();
	if (!IsValid(ComponentOwner))
		return;
	UClass* OwnerClass = ComponentOwner->GetClass();
	if (!IsValid(OwnerClass))
		return;

	if (!IsTemplate())
	{
		// NOTE: The following code allows us to find the component template from an instance.
		CachedActorCDO = Cast< AActor >(CachedBlueprint->GeneratedClass->GetDefaultObject());
		if (!CachedActorCDO.IsValid() || (CachedActorCDO.Get() == ComponentOwner))
			return;
#if WITH_EDITOR
		UActorComponent* TargetComponent = EditorUtilities::FindMatchingComponentInstance(this, CachedActorCDO.Get());
		CachedTemplateComponent = Cast<UHoudiniAssetBlueprintComponent>(TargetComponent);
#endif
	}

}

USimpleConstructionScript*
UHoudiniAssetBlueprintComponent::GetSCS() const
{
	if (!CachedBlueprint.Get())
		return nullptr;

	return CachedBlueprint->SimpleConstructionScript;
}

//------------------------------------------------------------------------------------------------
// FHoudiniAssetBlueprintInstanceData
//------------------------------------------------------------------------------------------------

FHoudiniAssetBlueprintInstanceData::FHoudiniAssetBlueprintInstanceData()
	: HoudiniAsset(nullptr)
	, AssetId(-1)
	, AssetState(EHoudiniAssetState::None)
	, SubAssetIndex(-1)
	, AssetCookCount(0)
	, bHasBeenLoaded(false)
	, bHasBeenDuplicated(false)
	, bPendingDelete(false)
	, bRecookRequested(false)
	, bRebuildRequested(false)
	, bEnableCooking(true)
	, bForceNeedUpdate(false)
	, bLastCookSuccess(false)
	, ComponentGUID(FGuid())
	, HapiGUID(FGuid())
	, bRegisteredComponentTemplate(false)
	, SourceName()
{

}

FHoudiniAssetBlueprintInstanceData::FHoudiniAssetBlueprintInstanceData(const UHoudiniAssetBlueprintComponent* SourceComponent)
	: FActorComponentInstanceData(SourceComponent)
{

}

void 
FHoudiniAssetBlueprintInstanceData::AddReferencedObjects(FReferenceCollector & Collector)
{
	Super::AddReferencedObjects(Collector);
	// TODO: Do we need to add references to output objects here?
	// Any other references?
	// What are the implications?
}