/*
* 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.
*/

#pragma once

//#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"

#include "HoudiniAsset.h"
#include "HoudiniAssetComponent.h"
#include "HoudiniTranslatorTypes.h"

#include "HoudiniPDGAssetLink.generated.h"

struct FHoudiniPackageParams;

UENUM()
enum class EPDGLinkState : uint8
{
	Inactive,
	Linking,
	Linked,
	Error_Not_Linked
};


UENUM()
enum class EPDGNodeState : uint8
{
	None,
	Dirtied,
	Dirtying,
	Cooking,
	Cook_Complete,
	Cook_Failed
};

UENUM()
enum class EPDGWorkResultState : uint8
{
	None,
	ToLoad,
	Loading,
	Loaded,
	ToDelete,
	Deleting,
	Deleted,
	NotLoaded
};


USTRUCT()
struct HOUDINIENGINERUNTIME_API FOutputActorOwner
{
	GENERATED_BODY();
public:
	FOutputActorOwner()
		: OutputActor(nullptr) {};
	
	virtual ~FOutputActorOwner() {};
	
	// Create OutputActor, an actor to hold work result output
	virtual bool CreateOutputActor(UWorld* InWorld, UHoudiniPDGAssetLink* InAssetLink, AActor *InParentActor, const FName& InName);

	// Return OutputActor
	virtual AActor* GetOutputActor() const { return OutputActor; }

	// Setter for OutputActor
	virtual void SetOutputActor(AActor* InActor) { OutputActor = InActor; }
	
	// Destroy OutputActor if it is valid.
	virtual bool DestroyOutputActor();

private:
	UPROPERTY(NonTransactional)
	AActor* OutputActor;
	
};

USTRUCT()
struct HOUDINIENGINERUNTIME_API FTOPWorkResultObject
{
	GENERATED_USTRUCT_BODY()

public:

	// Constructor
	FTOPWorkResultObject();

	// Call DestroyResultObjects in the destructor
	virtual ~FTOPWorkResultObject();

	// Set ResultObjects to a copy of InUpdatedOutputs
	void SetResultOutputs(const TArray<UHoudiniOutput*>& InUpdatedOutputs) { ResultOutputs = InUpdatedOutputs; }

	// Getter for ResultOutputs
	TArray<UHoudiniOutput*>& GetResultOutputs() { return ResultOutputs; }
	
	// Getter for ResultOutputs
	const TArray<UHoudiniOutput*>& GetResultOutputs() const { return ResultOutputs; }

	// Destroy ResultOutputs
	void DestroyResultOutputs();

	// Get the OutputActor owner struct
	FOutputActorOwner& GetOutputActorOwner() { return OutputActorOwner; }

	// Get the OutputActor owner struct
	const FOutputActorOwner& GetOutputActorOwner() const { return OutputActorOwner; }

	// Destroy the ResultOutputs and remove the output actor.
	void DestroyResultOutputsAndRemoveOutputActor();

	// Getter for bAutoBakedSinceLastLoad: indicates if this work result object has been auto-baked since it's last load.
	bool AutoBakedSinceLastLoad() const { return bAutoBakedSinceLastLoad; }
	// Setter for bAutoBakedSinceLastLoad
	void SetAutoBakedSinceLastLoad(bool bInAutoBakedSinceLastLoad) { bAutoBakedSinceLastLoad = bInAutoBakedSinceLastLoad; }

public:

	UPROPERTY(NonTransactional)
	FString					Name;
	UPROPERTY(NonTransactional)
	FString					FilePath;
	UPROPERTY(NonTransactional)
	EPDGWorkResultState		State;
	// The index in the WorkItemResultInfo array of this item as it was received from HAPI.
	UPROPERTY(NonTransactional)
	int32					WorkItemResultInfoIndex;

protected:
	// UPROPERTY()
	// TArray<UObject*>		ResultObjects;

	UPROPERTY(NonTransactional)
	TArray<UHoudiniOutput*> ResultOutputs;

	// If true, indicates that the work result object has been auto-baked since it was last loaded.
	UPROPERTY(NonTransactional)
	bool bAutoBakedSinceLastLoad = false;

private:
	// List of objects to delete, internal use only (DestroyResultOutputs)
	UPROPERTY(NonTransactional)
	TArray<UObject*> OutputObjectsToDelete;

	UPROPERTY(NonTransactional)
	FOutputActorOwner OutputActorOwner;
};

USTRUCT()
struct HOUDINIENGINERUNTIME_API FTOPWorkResult
{
	GENERATED_USTRUCT_BODY()

public:

	// Constructor
	FTOPWorkResult();

	// Comparison operator, used by hashing containers and arrays.
	bool operator==(const FTOPWorkResult& OtherWorkResult) const;

	// Calls FTOPWorkResultObject::DestroyResultOutputsAndRemoveOutputActor on each entry in ResultObjects and clears the array.
	void ClearAndDestroyResultObjects();

	// Search for the first FTOPWorkResultObject entry by WorkItemResultInfoIndex and return it, or nullptr if it could not be found.
	int32 IndexOfWorkResultObjectByHAPIResultInfoIndex(const int32& InWorkItemResultInfoIndex);
	// Search for the first FTOPWorkResultObject entry by WorkItemResultInfoIndex and return it, or nullptr if it could not be found.
	FTOPWorkResultObject* GetWorkResultObjectByHAPIResultInfoIndex(const int32& InWorkItemResultInfoIndex);
	// Return the FTOPWorkResultObject at InArrayIndex in the ResultObjects array, or nullptr if InArrayIndex is not a valid index.
	FTOPWorkResultObject* GetWorkResultObjectByArrayIndex(const int32& InArrayIndex);

public:

	UPROPERTY(NonTransactional)
	int32							WorkItemIndex;
	UPROPERTY(Transient)
	int32							WorkItemID;
	
	UPROPERTY(NonTransactional)
	TArray<FTOPWorkResultObject>	ResultObjects;

	/*
	UPROPERTY()
	TArray<UObject*>				ResultObjects;

	UPROPERTY()
	TArray<FString>					ResultNames;
	UPROPERTY()
	TArray<FString>					ResultFilePaths;
	UPROPERTY()
	TArray<EPDGWorkResultState>		ResultStates;
	*/
};

USTRUCT()
struct HOUDINIENGINERUNTIME_API FWorkItemTallyBase
{
	GENERATED_USTRUCT_BODY()
	
public:
	virtual ~FWorkItemTallyBase();
	
	//
	// Mutators
	//

	// Zero all counts, including total.
	virtual void ZeroAll() {};
	
	//
	// Accessors
	//
	
	bool AreAllWorkItemsComplete() const;
	bool AnyWorkItemsFailed() const;
	bool AnyWorkItemsPending() const;

	virtual int32 NumWorkItems() const { return 0; };
	virtual int32 NumWaitingWorkItems() const { return 0; };
	virtual int32 NumScheduledWorkItems() const { return 0; };
	virtual int32 NumCookingWorkItems() const { return 0; };
	virtual int32 NumCookedWorkItems() const { return 0; };
	virtual int32 NumErroredWorkItems() const { return 0; };
	virtual int32 NumCookCancelledWorkItems() const { return 0; };

	FString ProgressRatio() const;
};

USTRUCT()
struct HOUDINIENGINERUNTIME_API FWorkItemTally : public FWorkItemTallyBase
{
	GENERATED_USTRUCT_BODY()

public:

	// Constructor
	FWorkItemTally();

	//
	// Mutators
	//

	// Empty all state sets, as well as AllWorkItems.
	virtual void ZeroAll() override;
	
	// Remove a work item from all state sets and AllWorkItems.
	void RemoveWorkItem(int32 InWorkItemID);

	void RecordWorkItemAsWaiting(int32 InWorkItemID);
	void RecordWorkItemAsScheduled(int32 InWorkItemID);
	void RecordWorkItemAsCooking(int32 InWorkItemID);
	void RecordWorkItemAsCooked(int32 InWorkItemID);
	void RecordWorkItemAsErrored(int32 InWorkItemID);
	void RecordWorkItemAsCookCancelled(int32 InWorkItemID);

	//
	// Accessors
	//

	virtual int32 NumWorkItems() const override { return AllWorkItems.Num(); }
	virtual int32 NumWaitingWorkItems() const override { return WaitingWorkItems.Num(); }
	virtual int32 NumScheduledWorkItems() const override { return ScheduledWorkItems.Num(); }
	virtual int32 NumCookingWorkItems() const override { return CookingWorkItems.Num(); }
	virtual int32 NumCookedWorkItems() const override { return CookedWorkItems.Num(); }
	virtual int32 NumErroredWorkItems() const override { return ErroredWorkItems.Num(); }
	virtual int32 NumCookCancelledWorkItems() const override { return CookCancelledWorkItems.Num(); }
	
protected:

	// Removes the work item id from all state sets (but not from AllWorkItems -- use RemoveWorkItem for that).
	void RemoveWorkItemFromAllStateSets(int32 InWorkItemID);

	// We use sets to keep track of in what state a work item is. The set stores the WorkItemID.
	
	UPROPERTY()
	TSet<int32> AllWorkItems;
	UPROPERTY()
	TSet<int32> WaitingWorkItems;
	UPROPERTY()
	TSet<int32> ScheduledWorkItems;
	UPROPERTY()
	TSet<int32> CookingWorkItems;
	UPROPERTY()
	TSet<int32> CookedWorkItems;
	UPROPERTY()
	TSet<int32> ErroredWorkItems;
	UPROPERTY()
	TSet<int32> CookCancelledWorkItems;
};

USTRUCT()
struct HOUDINIENGINERUNTIME_API FAggregatedWorkItemTally : public FWorkItemTallyBase
{
	GENERATED_USTRUCT_BODY()

public:

	// Constructor
	FAggregatedWorkItemTally();

	virtual void ZeroAll() override;

	void Add(const FWorkItemTallyBase& InWorkItemTally);

	void Subtract(const FWorkItemTallyBase& InWorkItemTally);

	virtual int32 NumWorkItems() const override { return TotalWorkItems; }
	virtual int32 NumWaitingWorkItems() const override { return WaitingWorkItems; }
	virtual int32 NumScheduledWorkItems() const override { return ScheduledWorkItems; }
	virtual int32 NumCookingWorkItems() const override { return CookingWorkItems; }
	virtual int32 NumCookedWorkItems() const override { return CookedWorkItems; }
	virtual int32 NumErroredWorkItems() const override { return ErroredWorkItems; }

protected:
	UPROPERTY()
	int32 TotalWorkItems;
	UPROPERTY()
	int32 WaitingWorkItems;
	UPROPERTY()
	int32 ScheduledWorkItems;
	UPROPERTY()
	int32 CookingWorkItems;
	UPROPERTY()
	int32 CookedWorkItems;
	UPROPERTY()
	int32 ErroredWorkItems;
	UPROPERTY()
	int32 CookCancelledWorkItems;
	
};

// Container for baked outputs of a PDG work result object. 
USTRUCT()
struct HOUDINIENGINERUNTIME_API FHoudiniPDGWorkResultObjectBakedOutput
{
	GENERATED_BODY()

	public:
		// Array of baked output per output index of the work result object's outputs.
		UPROPERTY()
		TArray<FHoudiniBakedOutput> BakedOutputs;
};

// Forward declare the UTOPNetwork here for some references in the UTOPNode
class UTOPNetwork;

UCLASS()
class HOUDINIENGINERUNTIME_API UTOPNode : public UObject
{
	GENERATED_BODY()

public:
	// Constructor
	UTOPNode();

	// Comparison operator, used by hashing containers and arrays.
	bool operator==(const UTOPNode& Other) const;

	void Reset();

	const FWorkItemTallyBase& GetWorkItemTally() const
	{
		if (bHasChildNodes)
			return AggregatedWorkItemTally;
		return WorkItemTally;
	}

	void AggregateTallyFromChildNode(const UTOPNode* InChildNode)
	{
		if (IsValid(InChildNode))
			AggregatedWorkItemTally.Add(InChildNode->GetWorkItemTally());
	}

	bool AreAllWorkItemsComplete() const { return GetWorkItemTally().AreAllWorkItemsComplete(); };
	bool AnyWorkItemsFailed() const { return GetWorkItemTally().AnyWorkItemsFailed(); };
	bool AnyWorkItemsPending() const { return GetWorkItemTally().AnyWorkItemsPending(); };
	void ZeroWorkItemTally()
	{
		WorkItemTally.ZeroAll();
		AggregatedWorkItemTally.ZeroAll();
	}

	// Called by PDG manager when work item events are received
	
	// Notification that a work item has been created
	void OnWorkItemCreated(int32 InWorkItemID) { };

	// Notification that a work item has been removed.
	void OnWorkItemRemoved(int32 InWorkItemID) { WorkItemTally.RemoveWorkItem(InWorkItemID); };

	// Notification that a work item has moved to the waiting state.
	void OnWorkItemWaiting(int32 InWorkItemID);

	// Notification that a work item has been scheduled.
	void OnWorkItemScheduled(int32 InWorkItemID) { WorkItemTally.RecordWorkItemAsScheduled(InWorkItemID); };

	// Notification that a work item has started cooking.
	void OnWorkItemCooking(int32 InWorkItemID) { WorkItemTally.RecordWorkItemAsCooking(InWorkItemID); };

	// Notification that a work item has been cooked.
	void OnWorkItemCooked(int32 InWorkItemID);
	
	// Notification that a work item has errored.
	void OnWorkItemErrored(int32 InWorkItemID) { WorkItemTally.RecordWorkItemAsErrored(InWorkItemID); };

	// Notification that a work item cook has been cancelled.
	void OnWorkItemCookCancelled(int32 InWorkItemID) { WorkItemTally.RecordWorkItemAsCookCancelled(InWorkItemID); };

	bool IsVisibleInLevel() const { return bShow; }
	void SetVisibleInLevel(bool bInVisible);
	void UpdateOutputVisibilityInLevel();

	// Sets all WorkResultObjects that are in the NotLoaded state to ToLoad.
	void SetNotLoadedWorkResultsToLoad(bool bInAlsoSetDeletedToLoad=false);

	// Sets all WorkResultObjects that are in the Loaded state to ToDelete (will delete output objects and output
	// actors).
	void SetLoadedWorkResultsToDelete();

	// Immediately delete Loaded work result output objects (keeps the work items and result arrays but deletes the output
	// objects and actors and sets the state to Deleted.
	void DeleteWorkResultOutputObjects();

	// Get the OutputActor owner struct
	FOutputActorOwner& GetOutputActorOwner() { return OutputActorOwner; }

	// Get the OutputActor owner struct
	const FOutputActorOwner& GetOutputActorOwner() const { return OutputActorOwner; }

	// Get the baked outputs from the last bake. The map keys are [work_result.work_item_index]_[work_result_object_index]
	TMap<FString, FHoudiniPDGWorkResultObjectBakedOutput>& GetBakedWorkResultObjectsOutputs() { return BakedWorkResultObjectOutputs; }
	const TMap<FString, FHoudiniPDGWorkResultObjectBakedOutput>& GetBakedWorkResultObjectsOutputs() const { return BakedWorkResultObjectOutputs; }
	// Helper to construct the key used to look up baked work results.
	static FString GetBakedWorkResultObjectOutputsKey(int32 InWorkItemIndex, int32 InWorkResultObjectArrayIndex);
	// Helper to construct the key used to look up baked work results.
	static FString GetBakedWorkResultObjectOutputsKey(const FTOPWorkResult& InWorkResult, int32 InWorkResultObjectArrayIndex);
	// Helper to construct the key used to look up baked work results.
	bool GetBakedWorkResultObjectOutputsKey(int32 InWorkResultArrayIndex, int32 InWorkResultObjectArrayIndex, FString& OutKey) const;
	// Get the FHoudiniPDGWorkResultObjectBakedOutput for a work item (FTOPWorkResult) and specific result object.
	bool GetBakedWorkResultObjectOutputs(int32 InWorkResultArrayIndex, int32 InWorkResultObjectArrayIndex, FHoudiniPDGWorkResultObjectBakedOutput*& OutBakedOutput);
	// Get the FHoudiniPDGWorkResultObjectBakedOutput for a work item (FTOPWorkResult) and specific result object (const version).
	bool GetBakedWorkResultObjectOutputs(int32 InWorkResultArrayIndex, int32 InWorkResultObjectArrayIndex, FHoudiniPDGWorkResultObjectBakedOutput const*& OutBakedOutput) const;

	// Search for the first FTOPWorkResult entry by WorkItemID and return it, or nullptr if it could not be found.
	int32 IndexOfWorkResultByID(const int32& InWorkItemID);
	// Search for the first FTOPWorkResult entry by WorkItemID and return it, or nullptr if it could not be found.
	FTOPWorkResult* GetWorkResultByID(const int32& InWorkItemID);
	// Search for the first FTOPWorkResult entry by WorkItemIndex and return it, or nullptr if it could not be found.
	// If bWithInvalidWorkItemID is true, then only return an entry if its WorkItemID is INDEX_NONE.
	int32 IndexOfWorkResultByHAPIIndex(const int32& InWorkItemIndex, bool bInWithInvalidWorkItemID=false);
	// Search for the first FTOPWorkResult entry by WorkItemIndex and return it, or nullptr if it could not be found.
	// If bWithInvalidWorkItemID is true, then only return an entry if its WorkItemID is INDEX_NONE.
	FTOPWorkResult* GetWorkResultByHAPIIndex(const int32& InWorkItemIndex, bool bInWithInvalidWorkItemID=false);
	// Return the FTOPWorkResult at InArrayIndex in the WorkResult array, or nullptr if InArrayIndex is not a valid index.
	FTOPWorkResult* GetWorkResultByArrayIndex(const int32& InArrayIndex);

	// Returns true if InNetwork is the parent TOP Net of this node.
	bool IsParentTOPNetwork(UTOPNetwork const * const InNetwork) const;

	// Returns true if this node can still be auto-baked
	bool CanStillBeAutoBaked() const;

#if WITH_EDITOR
	void PostEditChangeChainProperty(FPropertyChangedChainEvent& PropertyChangedEvent) override;
#endif

#if WITH_EDITOR
	void PostTransacted(const FTransactionObjectEvent& TransactionEvent) override;
#endif

public:

	UPROPERTY(Transient, NonTransactional)
	int32					NodeId;
	UPROPERTY(NonTransactional)
	FString					NodeName;
	UPROPERTY(NonTransactional)
	FString					NodePath;
	UPROPERTY(NonTransactional)
	FString					ParentName;
	
	UPROPERTY()
	UObject*				WorkResultParent;
	UPROPERTY(NonTransactional)
	TArray<FTOPWorkResult>	WorkResult;

	// Hidden in the nodes combobox
	UPROPERTY()
	bool					bHidden;
	UPROPERTY()
	bool					bAutoLoad;

	UPROPERTY(Transient, NonTransactional)
	EPDGNodeState 			NodeState;

	// This is set when the TOP node's work items are processed by
	// FHoudiniPDGManager based on if any NotLoaded work result objects are found
	UPROPERTY(NonTransactional)
	bool bCachedHaveNotLoadedWorkResults;

	// This is set when the TOP node's work items are processed by
	// FHoudiniPDGManager based on if any Loaded work result objects are found
	UPROPERTY(NonTransactional)
	bool bCachedHaveLoadedWorkResults;

	// True if this node has child nodes
	UPROPERTY(NonTransactional)
	bool bHasChildNodes;

	// These notification events have been introduced so that we can start encapsulating code.
	// in this class as opposed to modifying this object in various places throughout the codebase.

	// Notification that this TOP node has been dirtied.
	void OnDirtyNode();

	// Accessors for the landscape data caches
	FHoudiniLandscapeExtent& GetLandscapeExtent() { return LandscapeExtent; }
	FHoudiniLandscapeReferenceLocation& GetLandscapeReferenceLocation() { return LandscapeReferenceLocation; }
	FHoudiniLandscapeTileSizeInfo& GetLandscapeSizeInfo() { return LandscapeSizeInfo; }
	// More cached landscape data
	UPROPERTY()
	TSet<FString> ClearedLandscapeLayers;

	// Returns true if the node has received the HAPI_PDG_EVENT_COOK_COMPLETE event since the last the cook started 
	bool HasReceivedCookCompleteEvent() const { return bHasReceivedCookCompleteEvent; }
	// Handler for when the node receives the HAPI_PDG_EVENT_COOK_START (called for each node when a TOPNet starts cooking)
	void HandleOnPDGEventCookStart() { bHasReceivedCookCompleteEvent = false; }
	// Handler for when the node receives the HAPI_PDG_EVENT_COOK_COMPLETE event (called for each node when a TOPNet completes cooking)
	void HandleOnPDGEventCookComplete() { bHasReceivedCookCompleteEvent = true; }

protected:
	void InvalidateLandscapeCache();
	
	// Value caches used during landscape tile creation.
	FHoudiniLandscapeReferenceLocation LandscapeReferenceLocation;
	FHoudiniLandscapeTileSizeInfo LandscapeSizeInfo;
	FHoudiniLandscapeExtent LandscapeExtent;

	// Visible in the level
	UPROPERTY()
	bool					bShow;

	// Map of [work_result_index]_[work_result_object_index] to the work result object's baked outputs. 
	UPROPERTY()
	TMap<FString, FHoudiniPDGWorkResultObjectBakedOutput> BakedWorkResultObjectOutputs;

	// This node's own work items, used when bHasChildNodes is false.
	UPROPERTY(Transient, NonTransactional)
	FWorkItemTally			WorkItemTally;
	// This node's aggregated work item tallys (sum of child work item tally, use when bHasChildNodes is true)
	UPROPERTY(Transient, NonTransactional)
	FAggregatedWorkItemTally	AggregatedWorkItemTally;

	// Set to true when the node recieves HAPI_PDG_EVENT_COOK_COMPLETE event
	UPROPERTY(Transient, NonTransactional)
	bool bHasReceivedCookCompleteEvent;

private:
	UPROPERTY()
	FOutputActorOwner OutputActorOwner;
};


UCLASS()
class HOUDINIENGINERUNTIME_API UTOPNetwork : public UObject
{
	GENERATED_BODY()

public:

	// Delegate that is broadcast when cook of the network is complete. Parameters are the UTOPNetwork and bAnyFailedWorkItems.
	DECLARE_MULTICAST_DELEGATE_TwoParams(FOnPostCookDelegate, UTOPNetwork*, const bool);

	// Constructor
	UTOPNetwork();

	// Comparison operator, used by hashing containers and arrays.
	bool operator==(const UTOPNetwork& Other) const;

	// Sets all WorkResultObjects that are in the Loaded state to ToDelete (will delete output objects and output
	// actors).
	void SetLoadedWorkResultsToDelete();

	// Immediately delete Loaded work result output objects (keeps the work items and result arrays but deletes the output
	// objects and actors and sets the state to Deleted.
	void DeleteWorkResultOutputObjects();

	// Returns true if any node in this TOP net has pending (waiting, scheduled, cooking) work items.
	bool AnyWorkItemsPending() const;

	// Returns true if any node in this TOP net has failed/errored work items.
	bool AnyWorkItemsFailed() const;

	// Returns true if this network has nodes that can still be auto-baked
	bool CanStillBeAutoBaked() const;

	// Handler for when a node in the newtork receives the HAPI_PDG_EVENT_COOK_COMPLETE event (called for each node when a TOPNet completes cooking)
	void HandleOnPDGEventCookCompleteReceivedByChildNode(UHoudiniPDGAssetLink* const InAssetLink, UTOPNode* const InTOPNode);

	FOnPostCookDelegate& GetOnPostCookDelegate() { return OnPostCookDelegate; }
	
public:

	UPROPERTY(Transient, NonTransactional)
	int32				NodeId;
	UPROPERTY(NonTransactional)
	FString				NodeName;
	// HAPI path to this node (relative to the HDA)
	UPROPERTY(NonTransactional)
	FString				NodePath;

	UPROPERTY()
	TArray<UTOPNode*>	AllTOPNodes;

	// TODO: Should be using SelectedNodeName instead?
	// Index is not consistent after updating filter
	UPROPERTY()
	int32				SelectedTOPIndex;
	
	UPROPERTY(NonTransactional)
	FString 			ParentName;

	UPROPERTY()
	bool				bShowResults;
	UPROPERTY()
	bool				bAutoLoadResults;

	FOnPostCookDelegate OnPostCookDelegate;
};


class UHoudiniPDGAssetLink;
DECLARE_MULTICAST_DELEGATE_FourParams(FHoudiniPDGAssetLinkWorkResultObjectLoaded, UHoudiniPDGAssetLink*, UTOPNode*, int32 /*WorkItemHAPIIndex*/, int32 /*WorkItemResultInfoIndex*/);

UCLASS()
class HOUDINIENGINERUNTIME_API UHoudiniPDGAssetLink : public UObject
{
	GENERATED_UCLASS_BODY()

public:

	friend class UHoudiniAssetComponent;

	// Delegate for when the entire bake operation is complete (all selected nodes/networks have been baked).
	DECLARE_MULTICAST_DELEGATE_TwoParams(FOnPostBakeDelegate, UHoudiniPDGAssetLink*, const bool);
	// Delegate for when a network completes a cook. Passes the asset link, the network, a bAnyWorkItemsFailed.
	DECLARE_MULTICAST_DELEGATE_ThreeParams(FOnPostTOPNetworkCookDelegate, UHoudiniPDGAssetLink*, UTOPNetwork*, const bool);
	
	static FString GetAssetLinkStatus(const EPDGLinkState& InLinkState);
	static FString GetTOPNodeStatus(const UTOPNode* InTOPNode);
	static FLinearColor GetTOPNodeStatusColor(const UTOPNode* InTOPNode);

	void UpdateTOPNodeWithChildrenWorkItemTallyAndState(UTOPNode* InNode, UTOPNetwork* InNetwork);
	void UpdateWorkItemTally();
	static void ResetTOPNetworkWorkItemTally(UTOPNetwork* TOPNetwork);

	// Set the TOP network at the given index as currently selected TOP network
	void SelectTOPNetwork(const int32& AtIndex);
	// Set the TOP node at the given index in the given TOP network as currently selected TOP node
	void SelectTOPNode(UTOPNetwork* InTOPNetwork, const int32& AtIndex);

	UTOPNode* GetSelectedTOPNode();
	const UTOPNode* GetSelectedTOPNode() const;
	UTOPNetwork* GetSelectedTOPNetwork();
	const UTOPNetwork* GetSelectedTOPNetwork() const;
	
	FString GetSelectedTOPNodeName();
	FString GetSelectedTOPNetworkName();

	UTOPNode* GetTOPNode(const int32& InNodeID);
	bool GetTOPNodeAndNetworkByNodeId(const int32& InNodeID, UTOPNetwork*& OutNetwork, UTOPNode*& OutNode);
	UTOPNetwork* GetTOPNetwork(const int32& AtIndex);
	const UTOPNetwork* GetTOPNetwork(const int32& AtIndex) const;

	// Find the node with relative path 'InNodePath' from its topnet.
	static UTOPNode* GetTOPNodeByNodePath(const FString& InNodePath, const TArray<UTOPNode*>& InTOPNodes, int32& OutIndex);
	// Find the network with relative path 'InNetPath' from the HDA
	static UTOPNetwork* GetTOPNetworkByNodePath(const FString& InNodePath, const TArray<UTOPNetwork*>& InTOPNetworks, int32& OutIndex);

	// Get the parent TOP node of the specified node. This is resolved 
	UTOPNode* GetParentTOPNode(const UTOPNode* InNode);

	static void ClearTOPNodeWorkItemResults(UTOPNode* TOPNode);
	static void ClearTOPNetworkWorkItemResults(UTOPNetwork* TOPNetwork);
	// Clear the result objects of a work item (FTOPWorkResult.ResultObjects), but don't delete the work item from
	// TOPNode.WorkResults (for example, the work item was dirtied but not removed from PDG)
	static void ClearWorkItemResultByID(const int32& InWorkItemID, UTOPNode* InTOPNode);
	// Calls ClearWorkItemResultByID and then deletes the FTOPWorkResult from InTOPNode.Result as well. For example:
	// the work item was removed in PDG.
	static void DestroyWorkItemByID(const int32& InWorkItemID, UTOPNode* InTOPNode);
	static FTOPWorkResult* GetWorkResultByID(const int32& InWorkItemID, UTOPNode* InTOPNode);

	// This should be called after the owner and this PDG asset link is duplicated. Set all output parent actors to
	// null in all TOP networks/nodes. Since the TOP Networks/TOP nodes are all structs, we cannot set
	// DuplicateTransient property on their OutputActor properties.
	void UpdatePostDuplicate();

	// Load the geometry generated as results of the given work item, of the given TOP node.
	// The load will be done asynchronously.
	// Results must be tagged with 'file', and must have a file path, otherwise will not be loaded.
	//void LoadResults(FTOPNode TOPNode, HAPI_PDG_WorkitemInfo workItemInfo, HAPI_PDG_WorkitemResultInfo[] resultInfos, HAPI_PDG_WorkitemId workItemID)

	// Return the first UHoudiniAssetComponent in the parent chain. If this asset link is not
	// owned by a HoudiniAssetComponent, a nullptr will be returned.
	UHoudiniAssetComponent* GetOuterHoudiniAssetComponent() const;

	// Gets the temporary cook folder. If the parent of this asset link is a HoudiniAssetComponent use that, otherwise
	// use the default static mesh temporary cook folder.
	FDirectoryPath GetTemporaryCookFolder() const;

	// Get the actor that owns this PDG asset link. If the asset link is owned by a component,
	// then the component's owning actor is returned. Can return null if this is now owned by
	// an actor or component.
	AActor* GetOwnerActor() const;

	// Checks if the asset link has any temporary outputs and returns true if it has
	bool HasTemporaryOutputs() const;

	// Filter TOP nodes and outputs (hidden/visible) by TOPNodeFilter and TOPOutputFilter.
	void FilterTOPNodesAndOutputs();

	// On all FTOPNodes: Load not loaded items if bAutoload is true, and update the level visibility of work items
	// result. Used when FTOPNode.bShow and/or FTOPNode.bAutoload changed.
	void UpdateTOPNodeAutoloadAndVisibility();

#if WITH_EDITORONLY_DATA
	// Returns true if there are any nodes left that can/must still be auto-baked.
	bool AnyRemainingAutoBakeNodes() const;
#endif

	// Delegate handlers

	// Get the post bake delegate
	FOnPostBakeDelegate& GetOnPostBakeDelegate() { return OnPostBakeDelegate; }
	
	// Called by baking code after baking all of the outputs
	void HandleOnPostBake(const bool bInSuccess);

	FOnPostTOPNetworkCookDelegate& GetOnPostTOPNetworkCookDelegate() { return OnPostTOPNetworkCookDelegate; }

	// Handler for when a TOP network completes a cook. Called by the TOP Net once all of its nodes have received
	// HAPI_PDG_EVENT_COOK_COMPLETE.
	void HandleOnTOPNetworkCookComplete(UTOPNetwork* const InTOPNet);

#if WITH_EDITORONLY_DATA
	void PostEditChangeChainProperty(FPropertyChangedChainEvent& PropertyChangedEvent) override;
#endif

#if WITH_EDITORONLY_DATA
	void PostTransacted(const FTransactionObjectEvent& TransactionEvent) override;
#endif

private:

	void ClearAllTOPData();
	
	static void DestroyWorkItemResultData(FTOPWorkResult& Result);

	static void DestoryWorkResultObjectData(FTOPWorkResultObject& ResultObject);

public:

	//UPROPERTY()
	//UHoudiniAsset*				HoudiniAsset;

	//UPROPERTY()
	//UHoudiniAssetComponent*		ParentHAC;

	UPROPERTY(DuplicateTransient, NonTransactional)
	FString						AssetName;

	// The full path to the HDA in HAPI
	UPROPERTY(DuplicateTransient, NonTransactional)
	FString						AssetNodePath;

	UPROPERTY(DuplicateTransient, NonTransactional)
	int32						AssetID;

	UPROPERTY()
	TArray<UTOPNetwork*>		AllTOPNetworks;

	UPROPERTY()
	int32						SelectedTOPNetworkIndex;

	UPROPERTY(Transient, NonTransactional)
	EPDGLinkState				LinkState;

	UPROPERTY()
	bool						bAutoCook;
	UPROPERTY()
	bool						bUseTOPNodeFilter;
	UPROPERTY()
	bool						bUseTOPOutputFilter;
	UPROPERTY()
	FString						TOPNodeFilter;
	UPROPERTY()
	FString						TOPOutputFilter;

	UPROPERTY(NonTransactional)
	int32						NumWorkitems;
	UPROPERTY(Transient, NonTransactional)
	FAggregatedWorkItemTally		WorkItemTally;

	UPROPERTY()
	FString						OutputCachePath;

	UPROPERTY(Transient)
	bool						bNeedsUIRefresh;

	// A parent actor to serve as the parent of any output actors
	// that are created.
	// If null, then output actors are created under a folder
	UPROPERTY(EditAnywhere, Category="Output")
	AActor*					 	OutputParentActor;

	// Folder used for baking PDG outputs
	UPROPERTY()
	FDirectoryPath BakeFolder;

	//
	// Notifications
	//

	// Delegate that is broadcast when a work result object has been loaded
	FHoudiniPDGAssetLinkWorkResultObjectLoaded OnWorkResultObjectLoaded;

	// Delegate that is broadcast after a bake.
	FOnPostBakeDelegate OnPostBakeDelegate;

	// Delegate that is broadcast after a TOP Network completes a cook.
	FOnPostTOPNetworkCookDelegate OnPostTOPNetworkCookDelegate;

	//
	// End: Notifications
	//

#if WITH_EDITORONLY_DATA
	UPROPERTY()
	bool bBakeMenuExpanded;

	// What kind of output to bake, for example, bake actors, bake to blueprint
	UPROPERTY()
	EHoudiniEngineBakeOption HoudiniEngineBakeOption;

	// Which outputs to bake, for example, all, selected network, selected node
	UPROPERTY()
	EPDGBakeSelectionOption PDGBakeSelectionOption;

	// This determines if the baked assets should replace existing assets with the same name,
	// or always generate new assets (with numerical suffixes if needed to create unique names)
	UPROPERTY()
	EPDGBakePackageReplaceModeOption PDGBakePackageReplaceMode;

	// If true, recenter baked actors to their bounding box center after bake
	UPROPERTY()
	bool bRecenterBakedActors;

	// Auto-bake: if this is true, it indicates that once all work result objects for the node is loaded they should
	// all be baked 
	UPROPERTY()
	bool bBakeAfterAllWorkResultObjectsLoaded;

	// The delegate handle of the auto bake helper function bound to OnWorkResultObjectLoaded.
	FDelegateHandle AutoBakeDelegateHandle;
#endif
};