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

#pragma once

#include "Containers/Map.h"
#include "Containers/StringFwd.h"
#include "Containers/StringView.h"
#include "Containers/UnrealString.h"
#include "CoreMinimal.h"
#include "Delegates/Delegate.h"
#include "HAL/Platform.h"
#include "Internationalization/Text.h"
#include "Misc/EnumClassFlags.h"
#include "Misc/StringBuilder.h"
#include "Templates/SharedPointer.h"
#include "Templates/TypeHash.h"
#include "UObject/NameTypes.h"
#include "UObject/Object.h"
#include "UObject/WeakObjectPtr.h"
#include "UObject/WeakObjectPtrTemplates.h"

class FContentBrowserMinimalItemData;
class IContentBrowserItemDataSink;
class UContentBrowserDataSource;

/** Flags denoting basic state information for an item instance */
enum class EContentBrowserItemFlags : uint16
{
	/** No flags */
	None = 0,

	/** Flags denoting the item type (mutually exclusive) */
	Type_Folder = 1<<0,
	Type_File = 1<<1,
	Type_MASK = Type_Folder | Type_File,

	/** Flags denoting the item category */
	Category_Asset = 1<<2,
	Category_Class = 1<<3,
	Category_Collection = 1<<4,
	Category_Plugin = 1 << 5, // Plugin content or classes - note that folders containing plugins do not have this flag set 
	Category_Misc = 1<<6,
	Category_MASK = Category_Asset | Category_Class | Category_Collection | Category_Plugin | Category_Misc,

	/** Flags denoting additional information for temporary items (mutually exclusive) */
	Temporary_Creation = 1<<7,
	Temporary_Duplication = 1<<8,
	Temporary_MASK = Temporary_Creation | Temporary_Duplication,

	/** Flag to mark the item as showing something that is unsupported */
	Misc_Unsupported = 1 << 9,
};
ENUM_CLASS_FLAGS(EContentBrowserItemFlags);

/** Flags denoting the save behavior of items */
enum class EContentBrowserItemSaveFlags : uint8
{
	/** No flags */
	None = 0,
	/** Save the item only if it is considered dirty */
	SaveOnlyIfDirty = 1<<0,
	/** Save the item only if it is currently loaded (will load the item if required when this flag isn't set) */
	SaveOnlyIfLoaded = 1<<1,
};
ENUM_CLASS_FLAGS(EContentBrowserItemSaveFlags);

/** Enum denoting the types of values that an item attribute can store */
enum class EContentBrowserItemDataAttributeValueType : uint8
{
	/** No value is set */
	None,
	/** An FString value is set */
	String,
	/** An FName value is set */
	Name,
	/** An FText value is set */
	Text,
};

/** Enum denoting the types of updates that can be emitted for an item */
enum class EContentBrowserItemUpdateType : uint8
{
	/** This item was newly added */
	Added,
	/** This item already existed, and has been modified */
	Modified,
	/** This item already existed, and has been moved to a new location or renamed */
	Moved,
	/** This item existed and has been deleted */
	Removed,
};

/**
 * Interface used to store any data source defined payload data that is required to operate on the underlying thing that a Content Browser item represents.
 * @note This is deliberately opaque as only the owner data source should know what it is.
 */
class IContentBrowserItemDataPayload
{
public:
	virtual ~IContentBrowserItemDataPayload() = default;
};

/**
 * The primitive data that represents an internal Content Browser item, as defined and managed by a Content Browser data source.
 *
 * FContentBrowserItemData itself is a concrete type, so extensibility is handled via the IContentBrowserItemDataPayload interface, which can be
 * used to store any data source defined payload data that is required to operate on the underlying thing that this item represents.
 *
 * FContentBrowserItemData has no real functionality, and relies on passing itself back into the correct data source instance when asked to perform 
 * actions or validation.
 *
 * @note This is the lower-level version of FContentBrowserItem, and is used internally by data sources. External code is more likely to use 
 * FContentBrowserItem directly, as that type can composite multiple internal items together (eg, combining equivalent folder items from different data sources).
 *
 * @see UContentBrowserDataSource.
 */
class CONTENTBROWSERDATA_API FContentBrowserItemData final
{
public:
	/**
	 * Default constructor.
	 * Produces an item that is empty (IsValid() will return false).
	 */
	FContentBrowserItemData() = default;

	/**
	 * Create an internal Content Browser item.
	 *
	 * @param InOwnerDataSource A pointer to the data source that manages the thing represented by this item. This is
	 * usually set, but may be null in rare circumstances (ie, creating a dummy placeholder item with no owner).
	 * @param InItemFlags Flags denoting basic state information for this item instance.
	 * @param InVirtualPath The complete virtual path that uniquely identifies this item within its owner data source
	 * (eg, "/MyRoot/MyFolder/MyFile").
	 * @param InItemName The leaf-name of this item (eg, "MyFile").
	 * @param InDisplayNameOverride The user-facing name of this item (eg, "MyFile"). This will be lazily set to
	 * InItemName if no override is provided.
	 * @param InPayload Any data source defined payload data for this item.
	 * @param InInternalPath Internal path if any (some items such as "virtual folders" may not have an internal path)
	 */
	FContentBrowserItemData(
		UContentBrowserDataSource* InOwnerDataSource,
		EContentBrowserItemFlags InItemFlags,
		FName InVirtualPath,
		FName InItemName,
		FText InDisplayNameOverride,
		TSharedPtr<const IContentBrowserItemDataPayload> InPayload,
		FName InInternalPath);

	/**
	 * Copy support.
	 */
	FContentBrowserItemData(const FContentBrowserItemData&) = default;
	FContentBrowserItemData& operator=(const FContentBrowserItemData&) = default;

	/**
	 * Move support.
	 */
	FContentBrowserItemData(FContentBrowserItemData&&) = default;
	FContentBrowserItemData& operator=(FContentBrowserItemData&&) = default;

	/**
	 * Comparison support.
	 */
	bool operator==(const FContentBrowserItemData& InOther) const;
	bool operator!=(const FContentBrowserItemData& InOther) const;

	/**
	 * Check to see whether this item is valid (is either a folder or a file).
	 */
	bool IsValid() const;

	/**
	 * Check to see whether this item is a folder.
	 * @note Equivalent to testing whether EContentBrowserItemFlags::Type_Folder is set on GetItemFlags().
	 */
	bool IsFolder() const;

	/**
	 * Check to see whether this item is a file.
	 * @note Equivalent to testing whether EContentBrowserItemFlags::Type_File is set on GetItemFlags().
	 */
	bool IsFile() const;

	/**
	 * Check to see whether this item is in a plugin. Folders and files inside plugins return true, folders which
	 * contain and organize plugins do not.
	 */
	bool IsPlugin() const;

	/**
	 * Check if the item is representing a supported item
	 * The content browser can also display some unsupported asset
	 * @note Equivalent to testing whether EContentBrowserItemFlags::Misc_Unsupported is not set on GetItemFlags()
	 */
	bool IsSupported() const;

	/**
	 * Check to see whether this item is temporary.
	 * @note Equivalent to testing whether any of EContentBrowserItemFlags::Temporary_MASK is set on GetItemFlags().
	 */
	bool IsTemporary() const;

	/**
	 * Check to see whether this item is a display only folder.
	 * @note Equivalent to testing whether all of EContentBrowserItemFlags::Category_MASK are unset on GetItemFlags().
	 */
	bool IsDisplayOnlyFolder() const;

	/**
	 * Get the pointer to the data source that manages the thing represented by this item.
	 * @note This is usually set for valid items, but may be null in rare circumstances (ie, creating a dummy placeholder item with no owner).
	 */
	UContentBrowserDataSource* GetOwnerDataSource() const;

	/**
	 * Get the flags denoting basic state information for this item instance.
	 */
	EContentBrowserItemFlags GetItemFlags() const;

	/**
	 * Get the flags denoting the item type information for this item instance.
	 * @note Equivalent to applying EContentBrowserItemFlags::Type_MASK to GetItemFlags().
	 */
	EContentBrowserItemFlags GetItemType() const;

	/**
	 * Get the flags denoting the item category information for this item instance.
	 * @note Equivalent to applying EContentBrowserItemFlags::Category_MASK to GetItemFlags().
	 */
	EContentBrowserItemFlags GetItemCategory() const;

	/**
	 * Get the flags denoting the item temporary reason information for this item instance.
	 * @note Equivalent to applying EContentBrowserItemFlags::Temporary_MASK to GetItemFlags().
	 */
	EContentBrowserItemFlags GetItemTemporaryReason() const;

	/**
	 * Get the complete virtual path that uniquely identifies this item within its owner data source (eg, "/All/MyRoot/MyFolder/MyFile").
	 */
	FName GetVirtualPath() const;

	/**
	 * Get the complete invariant path that uniquely identifies this item within its owner data source (eg, "/MyRoot/MyFolder/MyFile").
	 * This path will be the same regardless of the options being toggled 'Show All Folder' or 'Organize Folders'
	 */
	FName GetInvariantPath() const;

	/**
	 * Get the complete internal path that uniquely identifies this item within its owner data source if it has one (eg, "/MyRoot/MyFolder/MyFile").
	 */
	FName GetInternalPath() const;

	/**
	 * Get the leaf-name of this item (eg, "MyFile").
	 */
	FName GetItemName() const;

	/**
	 * Get the user-facing name of this item (eg, "MyFile").
	 */
	FText GetDisplayName() const;

	/**
	 * Get any data source defined payload data for this item.
	 */
	TSharedPtr<const IContentBrowserItemDataPayload> GetPayload() const;

private:
	/** A pointer to the data source that manages the thing represented by this item. This is usually set for valid items, but may be null in rare circumstances (ie, creating a dummy placeholder item with no owner) */
	TWeakObjectPtr<UContentBrowserDataSource> OwnerDataSource;

	/** Flags denoting basic state information for this item instance */
	EContentBrowserItemFlags ItemFlags = EContentBrowserItemFlags::None;

	/** The complete virtual path that uniquely identifies this item within its owner data source (eg, "/MyRoot/MyFolder/MyFile") */
	FName VirtualPath;

	/** The leaf-name of this item (eg, "MyFile") */
	FName ItemName;

	/** Internal path used to identify item within the owner data source */
	FName InternalPath;

	/** The user-facing name of this item (eg, "MyFile") */
	FText CachedDisplayName;

	/** Any data source defined payload data for this item */
	TSharedPtr<const IContentBrowserItemDataPayload> Payload;
};

/**
 * Type describing the meta-data associated with an item attribute value.
 * This provides additional context and information that can be used to interpret and display the value.
 */
class CONTENTBROWSERDATA_API FContentBrowserItemDataAttributeMetaData
{
public:
	/**
	 * Constructor.
	 */
	FContentBrowserItemDataAttributeMetaData() = default;

	/**
	 * Copy support.
	 */
	FContentBrowserItemDataAttributeMetaData(const FContentBrowserItemDataAttributeMetaData&) = default;
	FContentBrowserItemDataAttributeMetaData& operator=(const FContentBrowserItemDataAttributeMetaData&) = default;

	/**
	 * Move support.
	 */
	FContentBrowserItemDataAttributeMetaData(FContentBrowserItemDataAttributeMetaData&&) = default;
	FContentBrowserItemDataAttributeMetaData& operator=(FContentBrowserItemDataAttributeMetaData&&) = default;

	/** The kind of data represented by this attribute value */
	UObject::FAssetRegistryTag::ETagType AttributeType = UObject::FAssetRegistryTag::TT_Hidden;

	/** Flags giving hints at how to display this attribute value in the UI (see ETagDisplay) */
	uint32 DisplayFlags = UObject::FAssetRegistryTag::TD_None;

	/** Resolved display name of the associated attribute */
	FText DisplayName;
	
	/** Optional tooltip of the associated attribute */
	FText TooltipText;
	
	/** Optional suffix to apply to values of the associated attribute in the UI */
	FText Suffix;

	/** True if this attribute value is considered "important" in the UI */
	bool bIsImportant = false;
};

/**
 * Type describing the value of an item attribute.
 * Internally this is optimized to store the value as either an FString, FName, or FText.
 */
class CONTENTBROWSERDATA_API FContentBrowserItemDataAttributeValue
{
public:
	/**
	 * Default constructor.
	 * Produces an attribute value that is empty (IsValid() will return false).
	 */
	FContentBrowserItemDataAttributeValue() = default;

	/**
	 * Construct this attribute value from the given string.
	 */
	explicit FContentBrowserItemDataAttributeValue(const TCHAR* InStr);
	explicit FContentBrowserItemDataAttributeValue(const FString& InStr);
	explicit FContentBrowserItemDataAttributeValue(FString&& InStr);

	/**
	 * Construct this attribute value from the given name.
	 */
	explicit FContentBrowserItemDataAttributeValue(const FName InName);

	/**
	 * Construct this attribute value from the given text.
	 */
	explicit FContentBrowserItemDataAttributeValue(FText InText);

	/**
	 * Copy support.
	 */
	FContentBrowserItemDataAttributeValue(const FContentBrowserItemDataAttributeValue&) = default;
	FContentBrowserItemDataAttributeValue& operator=(const FContentBrowserItemDataAttributeValue&) = default;

	/**
	 * Move support.
	 */
	FContentBrowserItemDataAttributeValue(FContentBrowserItemDataAttributeValue&&) = default;
	FContentBrowserItemDataAttributeValue& operator=(FContentBrowserItemDataAttributeValue&&) = default;

	/**
	 * Check to see whether this attribute value is valid (has been set to an internal value).
	 */
	bool IsValid() const;

	/**
	 * Reset this attribute value to its empty default state.
	 */
	void Reset();

	/**
	 * Get the value denoting what type of internal value is stored within this attribute value.
	 */
	EContentBrowserItemDataAttributeValueType GetValueType() const;
	
	/**
	 * Get this attribute value as the requested type, converting its internal value to the given type if required.
	 * @note This function is specialized for FString, FName, and FText, with the generic implementation requiring a LexFromString implementation for the requested type.
	 */
	template <typename ValueAttrType>
	ValueAttrType GetValue() const;

	/**
	 * Set this attribute value from the given type, converting it to a type we can store internally if required.
	 * @note This function is overloaded for FString, FName, and FText, with the generic implementation requiring a LexToString implementation for the given type.
	 * @note This function will reset the type during the set, so will also clear any currently associated meta-data.
	 */
	template <typename ValueAttrType>
	void SetValue(ValueAttrType InValue);
	void SetValue(const TCHAR* InStr);
	void SetValue(const FString& InStr);
	void SetValue(FString&& InStr);
	void SetValue(const FName InName);
	void SetValue(FText InText);

	/**
	 * Get this attribute value as a string view, converting its internal value using the scratch buffer if required (if ValueType == Name).
	 */
	FStringView GetValueStringView(FStringBuilderBase& ScratchBuffer) const;

	/**
	 * Get the internal string value.
	 * @note Only valid when ValueType == String.
	 */
	const FString& GetValueString() const;

	/**
	 * Get the internal name value.
	 * @note Only valid when ValueType == Name.
	 */
	FName GetValueName() const;

	/**
	 * Get the internal text value.
	 * @note Only valid when ValueType == Name.
	 */
	FText GetValueText() const;

	/**
	 * Get the meta-data associated with this attribute value.
	 */
	const FContentBrowserItemDataAttributeMetaData& GetMetaData() const;

	/**
	 * Set the meta-data associated with this attribute value.
	 */
	void SetMetaData(const FContentBrowserItemDataAttributeMetaData& InMetaData);
	void SetMetaData(FContentBrowserItemDataAttributeMetaData&& InMetaData);

private:
	/** Value denoting what type of internal value is stored within this attribute value */
	EContentBrowserItemDataAttributeValueType ValueType = EContentBrowserItemDataAttributeValueType::None;

	/** Internal string value */
	FString StrValue;

	/** Internal name value */
	FName NameValue;

	/** Internal text value */
	FText TextValue;

	/** Meta-data associated with this attribute value */
	TSharedPtr<const FContentBrowserItemDataAttributeMetaData> MetaData;
};

template <typename ValueAttrType>
inline ValueAttrType FContentBrowserItemDataAttributeValue::GetValue() const
{
	TStringBuilder<FName::StringBufferSize> NameStr;

	const TCHAR* StrPtr = nullptr;
	switch (ValueType)
	{
	case EContentBrowserItemDataAttributeValueType::String:
		StrPtr = *StrValue;
		break;

	case EContentBrowserItemDataAttributeValueType::Name:
		NameValue.ToString(NameStr);
		StrPtr = *NameStr;
		break;

	case EContentBrowserItemDataAttributeValueType::Text:
		StrPtr = *TextValue.ToString();
		break;
	}

	ValueAttrType Result = ValueAttrType();
	if (StrPtr)
	{
		LexFromString(Result, StrPtr);
	}
	return Result;
}

template <>
inline FString FContentBrowserItemDataAttributeValue::GetValue<FString>() const
{
	switch (ValueType)
	{
	case EContentBrowserItemDataAttributeValueType::String:
		return StrValue;

	case EContentBrowserItemDataAttributeValueType::Name:
		return NameValue.ToString();

	case EContentBrowserItemDataAttributeValueType::Text:
		return TextValue.ToString();
	}

	return FString();
}

template <>
inline FText FContentBrowserItemDataAttributeValue::GetValue<FText>() const
{
	switch (ValueType)
	{
	case EContentBrowserItemDataAttributeValueType::String:
		return FText::FromString(StrValue);

	case EContentBrowserItemDataAttributeValueType::Name:
		return FText::FromName(NameValue);

	case EContentBrowserItemDataAttributeValueType::Text:
		return TextValue;
	}

	return FText();
}

template <>
inline FName FContentBrowserItemDataAttributeValue::GetValue<FName>() const
{
	switch (ValueType)
	{
	case EContentBrowserItemDataAttributeValueType::String:
		return FName(*StrValue);

	case EContentBrowserItemDataAttributeValueType::Name:
		return NameValue;

	case EContentBrowserItemDataAttributeValueType::Text:
		return FName(*TextValue.ToString());
	}

	return FName();
}

template <typename ValueAttrType>
void FContentBrowserItemDataAttributeValue::SetValue(ValueAttrType InValue)
{
	SetValue(LexToString(InValue));
}

typedef TMap<FName, FContentBrowserItemDataAttributeValue> FContentBrowserItemDataAttributeValues;

/**
 * Context for asynchronous item creation (for new items or duplicating existing ones).
 * Data sources will return one of these (hosting a temporary item with any required context) when they want to begin the creation or duplication of an item item.
 * UI involved in this creation flow should call ValidateItem for any name changes, as well as before calling FinalizeItem. Once finalized the temporary item should be replaced with the real one.
 */
class CONTENTBROWSERDATA_API FContentBrowserItemDataTemporaryContext
{
public:
	/** Delegate used to validate that the proposed item name is valid */
	DECLARE_DELEGATE_RetVal_ThreeParams(bool, FOnValidateItem, const FContentBrowserItemData& /*InItemData*/, const FString& /*InProposedName*/, FText* /*OutErrorMsg*/);
	
	/** Delegate used to finalize the creation of the temporary item, and return the real item */
	DECLARE_DELEGATE_RetVal_ThreeParams(FContentBrowserItemData, FOnFinalizeItem, const FContentBrowserItemData& /*InItemData*/, const FString& /*InProposedName*/, FText* /*OutErrorMsg*/);

	/**
	 * Default constructor.
	 * Produces a context that is empty (IsValid() will return false).
	 */
	FContentBrowserItemDataTemporaryContext() = default;

	/**
	 * Create a context instance.
	 *
	 * @param InItemData Data representing the temporary item instance.
	 * @param InOnValidateItem Delegate used to validate that the proposed item name is valid (optional).
	 * @param InOnFinalizeItem Delegate used to finalize the creation of the temporary item, and return the real item.
	 */
	FContentBrowserItemDataTemporaryContext(FContentBrowserItemData&& InItemData, FOnValidateItem InOnValidateItem, FOnFinalizeItem InOnFinalizeItem);

	/**
	 * Copy support.
	 */
	FContentBrowserItemDataTemporaryContext(const FContentBrowserItemDataTemporaryContext&) = default;
	FContentBrowserItemDataTemporaryContext& operator=(const FContentBrowserItemDataTemporaryContext&) = default;

	/**
	 * Move support.
	 */
	FContentBrowserItemDataTemporaryContext(FContentBrowserItemDataTemporaryContext&&) = default;
	FContentBrowserItemDataTemporaryContext& operator=(FContentBrowserItemDataTemporaryContext&&) = default;

	/**
	 * Check to see whether this context is valid (has been set to a temporary item).
	 */
	bool IsValid() const;

	/**
	 * Get the data representing the temporary item instance.
	 */
	const FContentBrowserItemData& GetItemData() const;

	/**
	 * Invoke the delegate used to validate that the proposed item name is valid.
	 * @note Returns True if no validation delegate is bound.
	 */
	bool ValidateItem(const FString& InProposedName, FText* OutErrorMsg = nullptr) const;

	/**
	 * Invoke the delegate used to finalize the creation of the temporary item, and return the real item.
	 */
	FContentBrowserItemData FinalizeItem(const FString& InProposedName, FText* OutErrorMsg = nullptr) const;

private:
	/** Data representing the temporary item instance */
	FContentBrowserItemData ItemData;

	/** Delegate used to validate that the proposed item name is valid (optional) */
	FOnValidateItem OnValidateItem;

	/** Delegate used to finalize the creation of the temporary item, and return the real item */
	FOnFinalizeItem OnFinalizeItem;
};

/**
 * Minimal representation of a FContentBrowserItemData instance for comparison purposes.
 * @note Unlike FContentBrowserItemDataKey this does consider the data source, and unlike FContentBrowserItemKey it considers the data source for folder items.
 *  It can be used to identify a FContentBrowserItemData for removal from an FContentBrowserItem
 */
class CONTENTBROWSERDATA_API FContentBrowserMinimalItemData
{
public:
	explicit FContentBrowserMinimalItemData(const FContentBrowserItemData& InItemData);
	FContentBrowserMinimalItemData(EContentBrowserItemFlags InItemType, FName InVirtualPath, const UContentBrowserDataSource* InSource);

	bool operator==(const FContentBrowserMinimalItemData& Other) const
	{
		return !(*this != Other);
	}
	bool operator!=(const FContentBrowserMinimalItemData& Other) const
	{
		return ItemType != Other.ItemType || VirtualPath != Other.VirtualPath || DataSource != Other.DataSource;
	}

	/** Return a string representation for debugging. */
	FString ToString() const;
	
	EContentBrowserItemFlags GetItemType() const
	{
		return ItemType;
	} 

	FName GetVirtualPath() const
	{
		return VirtualPath;
	}

	const UContentBrowserDataSource* GetDataSource() const 
	{
		return DataSource;
	}

private:
	/**
	 * Flags denoting the item type information for an item instance.
	 * @note This is always masked against EContentBrowserItemFlags::Type_MASK to remove any non-type information.
	 */
	EContentBrowserItemFlags ItemType = EContentBrowserItemFlags::None;

	/**
	 * The complete virtual path that uniquely identifies an item within its owner data source.
	 */
	FName VirtualPath;

	/** A pointer to the data source that manages the thing represented by this key */
	const UContentBrowserDataSource* DataSource = nullptr;
};

/**
 * Minimal representation of a FContentBrowserItemData instance that can be used as a map key.
 * @note This key doesn't consider the data source, so should only be used for maps within a given data source.
 *		 Use FContentBrowserItemKey for more general use where items may have come from different data sources.
 */
class CONTENTBROWSERDATA_API FContentBrowserItemDataKey
{
public:
	/**
	 * Default constructor.
	 * Produces a key that is empty.
	 */
	FContentBrowserItemDataKey() = default;

	/**
	 * Construct this key from the given item.
	 */
	explicit FContentBrowserItemDataKey(const FContentBrowserItemData& InItemData);
	
	/**
	 * Construct this key from the given item type and virtual path.
	 */
	FContentBrowserItemDataKey(EContentBrowserItemFlags InItemType, FName InVirtualPath);

	/**
	 * Equality support.
	 */
	bool operator==(const FContentBrowserItemDataKey& InOther) const
	{
		return ItemType == InOther.ItemType
			&& VirtualPath.IsEqual(InOther.VirtualPath, ENameCase::CaseSensitive);
	}

	/**
	 * Inequality support.
	 */
	bool operator!=(const FContentBrowserItemDataKey& InOther) const
	{
		return !(*this == InOther);
	}

	/**
	 * Get the hash of the given instance.
	 */
	friend inline uint32 GetTypeHash(const FContentBrowserItemDataKey& InKey)
	{
		return HashCombine(GetTypeHash(InKey.ItemType), GetTypeHash(InKey.VirtualPath));
	}

protected:
	/**
	 * Flags denoting the item type information for an item instance.
	 * @note This is always masked against EContentBrowserItemFlags::Type_MASK to remove any non-type information.
	 */
	EContentBrowserItemFlags ItemType = EContentBrowserItemFlags::None;

	/**
	 * The complete virtual path that uniquely identifies an item within its owner data source.
	 */
	FName VirtualPath;
};

/**
 * Type describing an update to an item.
 */
class CONTENTBROWSERDATA_API FContentBrowserItemDataUpdate
{
public:
	/**
	 * Create an item update for when a new item is added.
	 */
	static FContentBrowserItemDataUpdate MakeItemAddedUpdate(FContentBrowserItemData InItemData);

	/**
	 * Create an item update for when an existing item is updated.
	 */
	static FContentBrowserItemDataUpdate MakeItemModifiedUpdate(FContentBrowserItemData InItemData);

	/**
	 * Create an item update for when an existing item is moved (or renamed), including its previous virtual path.
	 */
	static FContentBrowserItemDataUpdate MakeItemMovedUpdate(FContentBrowserItemData InItemData, FName InPreviousVirtualPath);

	/**
	 * Create an item update for when an item is deleted.
	 */
	static FContentBrowserItemDataUpdate MakeItemRemovedUpdate(FContentBrowserItemData InItemData);

	/**
	 * Get the value denoting the types of updates that can be emitted for an item.
	 */
	EContentBrowserItemUpdateType GetUpdateType() const;

	/**
	 * Get the item data for the update.
	 */
	const FContentBrowserItemData& GetItemData() const;

	/**
	 * Get the previous virtual path (UpdateType == Moved).
	 */
	FName GetPreviousVirtualPath() const;

private:
	/** Value denoting the types of updates that can be emitted for an item */
	EContentBrowserItemUpdateType UpdateType;

	/** Item data for the update */
	FContentBrowserItemData ItemData;

	/** Previous virtual path (UpdateType == Moved) */
	FName PreviousVirtualPath;
};

/**
 * The data sink interface that can be used to communicate with the Content Browser Data Subsystem.
 */
class IContentBrowserItemDataSink
{
public:
	/**
	 * Destructor.
	 */
	virtual ~IContentBrowserItemDataSink() = default;

	/**
	 * Queue an incremental item data update, for data sources that can provide delta-updates.
	 */
	virtual void QueueItemDataUpdate(FContentBrowserItemDataUpdate&& InUpdate) = 0;

	/**
	 * Notify a wholesale item data update, for data sources that can't provide delta-updates.
	 */
	 UE_DEPRECATED(5.5, "NotifyItemDataRefreshed is deprecated, for editor performance reasons no external systems should be able to request a full refresh.")
	virtual void NotifyItemDataRefreshed() = 0;

	/**
	 * Converts an internal path to a virtual path.
	 */
	virtual void ConvertInternalPathToVirtual(const FStringView InPath, FStringBuilderBase& OutPath) = 0;
};