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

#pragma once

#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "UObject/UObjectGlobals.h"
#include "Templates/SubclassOf.h"
#include "Textures/SlateIcon.h"
#include "Misc/Attribute.h"

#include "IToolMenusModule.h"
#include "ToolMenu.h"
#include "ToolMenuContext.h"
#include "ToolMenuDelegates.h"
#include "ToolMenuEntry.h"
#include "ToolMenuEntryScript.h"
#include "ToolMenuOwner.h"
#include "ToolMenuSection.h"
#include "ToolMenuMisc.h"

#include "Misc/CoreDelegates.h"

#include "ToolMenus.generated.h"

#define UE_API TOOLMENUS_API

class FMenuBuilder;
class FMultiBox;
class SWidget;

namespace UE::ToolMenus
{
class FToolMenuTestInstanceScoped;
}
class UToolMenu;
class UToolMenuEntryScript;
struct FToolMenuEntry;
struct FToolMenuSection;

struct FGeneratedToolMenuWidget
{
	// A copy of the menu so we can refresh menus not in the database
	TObjectPtr<UToolMenu> GeneratedMenu;

	// The actual widget for the menu
	TWeakPtr<SWidget> Widget;

	// Weak ptr to the original menu that owns the widget
	TWeakObjectPtr<UToolMenu> OriginalMenu;
};

struct FGeneratedToolMenuWidgets
{
	TArray<TSharedPtr<FGeneratedToolMenuWidget>> Instances;
};

namespace UE::ToolMenus
{
	/**
	 * A handle to a particular entry. Used when elevating child elements to a parent toolbar.
	 */
	struct FSubBlockReference
	{
		FSubBlockReference();
		FSubBlockReference(const FSubBlockReference& Other);
		FSubBlockReference(UToolMenu* InParent, FToolMenuSection* InSection, FToolMenuEntry* InEntry);

		UToolMenu* ParentMenu;
		FToolMenuSection* Section;
		FToolMenuEntry* Entry;
	};	
}

/*
 * A global context that any menu can add/modify to specify which profiles are currently active
 */
UCLASS(MinimalAPI)
class UToolMenuProfileContext : public UToolMenuContextBase
{
	GENERATED_BODY()
public:

	TArray<FName> ActiveProfiles;
};

/*
 * Struct to store all the profiles for a menu for serialization
 */
USTRUCT()
struct FToolMenuProfileMap
{
	GENERATED_BODY()

	UPROPERTY()
	TMap<FName /*profile name*/, FToolMenuProfile> MenuProfiles;
};

UCLASS(MinimalAPI, config=EditorPerProjectUserSettings)
class UToolMenus : public UObject
{
	GENERATED_BODY()

public:

	UE_API UToolMenus();

	UFUNCTION(BlueprintCallable, Category = "Tool Menus")
	static UE_API UToolMenus* Get();

	/** Try to get UToolMenus without forcing ToolMenus module to load. */
	static inline UToolMenus* TryGet()
	{
		if (IToolMenusModule::IsAvailable())
		{
			return Get();
		}

		return nullptr;
	}

	/** Unregister everything associated with the given owner without forcing ToolMenus module to load. */
	static inline void UnregisterOwner(FToolMenuOwner Owner)
	{
		if (UToolMenus* ToolMenus = UToolMenus::TryGet())
		{
			ToolMenus->UnregisterOwnerInternal(Owner);
		}
	}

	/**
	 * Returns true if slate initialized and editor GUI is being used.
	 * The application should have been initialized before this method is called.
	 *
	 * @return	True if slate initialized and editor GUI is being used.
	 */
	static UE_API bool IsToolMenuUIEnabled();

	/** 
	 * Delays menu registration until safe and ready
	 * Will not trigger if Slate does not end up being enabled after loading
	 * Will not trigger when running commandlet, game, dedicated server or client only
	 *
	 */
	static UE_API FDelegateHandle RegisterStartupCallback(const FSimpleMulticastDelegate::FDelegate& InDelegate);

	/** Unregister a startup callback delegate by pointer */
	static UE_API void UnRegisterStartupCallback(FDelegateUserObjectConst UserPointer);

	/** Unregister a startup callback delegate by handle */
	static UE_API void UnRegisterStartupCallback(FDelegateHandle InHandle);

	/**
	 * Registers a menu by name
	 * @param	Parent	Optional name of a menu to layer on top of.
	 * @param	Type	Type of menu that will be generated such as: ToolBar, VerticalToolBar, etc..
	 * @param	bWarnIfAlreadyRegistered	Display warning if already registered
	 * @return	ToolMenu	Menu object
	 */
	UFUNCTION(BlueprintCallable, Category = "Tool Menus")
	UE_API UToolMenu* RegisterMenu(FName Name, const FName Parent = NAME_None, EMultiBoxType Type = EMultiBoxType::Menu, bool bWarnIfAlreadyRegistered = true);

	/**
	 * Extends a menu without registering the menu or claiming ownership of it. Ok to call even if menu does not exist yet.
	 * @param	Name	Name of the menu to extend
	 * @return	ToolMenu	Menu object
	 */
	UFUNCTION(BlueprintCallable, Category = "Tool Menus")
	UE_API UToolMenu* ExtendMenu(const FName Name);

	/**
	 * Generate widget from a registered menu. Most common function used to generate new menu widgets.
	 * @param	Name	Registered menu's name that widget will be generated from
	 * @param	Context	Additional information specific to the menu being generated
	 * @return	Widget to display
	 */
	UE_API TSharedRef<SWidget> GenerateWidget(const FName Name, const FToolMenuContext& InMenuContext);

	/**
	 * Finds an existing menu that has been registered or extended.
	 * @param	Name	Name of the menu to find.
	 * @return	ToolMenu	Menu object. Returns null if not found.
	 */
	UFUNCTION(BlueprintCallable, Category = "Tool Menus")
	UE_API UToolMenu* FindMenu(const FName Name);

	/**
	 * Determines if a menu has already been registered.
	 * @param	Name	Name of the menu to find.
	 * @return	bool	True if menu has already been registered.
	 */
	UFUNCTION(BlueprintCallable, Category = "Tool Menus")
	UE_API bool IsMenuRegistered(const FName Name) const;

	/** Rebuilds all widgets generated from a specific menu. */
	UFUNCTION(BlueprintCallable, Category = "Tool Menus")
	UE_API bool RefreshMenuWidget(const FName Name);

	/** Rebuilds all currently generated widgets next tick. */
	UFUNCTION(BlueprintCallable, Category = "Tool Menus")
	UE_API void RefreshAllWidgets();

	/** Registers menu entry object from blueprint/script */
	UFUNCTION(BlueprintCallable, Category = "Tool Menus")
	static UE_API bool AddMenuEntryObject(UToolMenuEntryScript* MenuEntryObject);

	/** Unregisters menu entry object from blueprint/script */
	UFUNCTION(BlueprintCallable, Category = "Tool Menus")
	static UE_API bool RemoveMenuEntryObject(UToolMenuEntryScript* MenuEntryObject);

	/** Removes all entries that were registered under a specific owner name */
	UFUNCTION(BlueprintCallable, Category = "Tool Menus")
	UE_API void UnregisterOwnerByName(FName InOwnerName);

	/** Sets a section's displayed label text. */
	UFUNCTION(BlueprintCallable, Category = "Tool Menus")
	UE_API void SetSectionLabel(const FName MenuName, const FName SectionName, const FText Label);

	/** Sets where to insert a section into a menu when generating relative to other section names. */
	UFUNCTION(BlueprintCallable, Category = "Tool Menus")
	UE_API void SetSectionPosition(const FName MenuName, const FName SectionName, const FName OtherSectionName, const EToolMenuInsertType PositionType);

	/** Registers a section for a menu */
	UE_API void AddSection(const FName MenuName, const FName SectionName, const TAttribute< FText >& InLabel, const FToolMenuInsert InPosition = FToolMenuInsert());

	/** Registers an entry for a menu's section */
	UE_API void AddEntry(const FName MenuName, const FName SectionName, const FToolMenuEntry& Entry);

	/** Removes a menu entry from a given menu and section */
	UFUNCTION(BlueprintCallable, Category = "Tool Menus")
	UE_API void RemoveEntry(const FName MenuName, const FName Section, const FName Name);

	/** Removes a section from a given menu */
	UFUNCTION(BlueprintCallable, Category = "Tool Menus")
	UE_API void RemoveSection(const FName MenuName, const FName Section);

	/** Unregisters a menu by name */
	UFUNCTION(BlueprintCallable, Category = "Tool Menus")
	UE_API void RemoveMenu(const FName MenuName);

	/** Finds a context object of a given class if it exists */
	UFUNCTION(BlueprintCallable, Category = "Tool Menus")
	static UE_API UObject* FindContext(const FToolMenuContext& InContext, UClass* InClass);

	/**
	 * Generate widget from a hierarchy of menus. For advanced specialized use cases.
	 * @param	Hierarchy	Array of menus to combine into a final widget
	 * @param	Context	Additional information specific to the menu being generated
	 * @return	Widget to display
	 */
	UE_API TSharedRef<SWidget> GenerateWidget(const TArray<UToolMenu*>& Hierarchy, const FToolMenuContext& InMenuContext);

	/**
	 * Generate widget from a final collapsed menu. For advanced specialized use cases.
	 * @param	GeneratedMenu	Combined final menu to generate final widget from
	 * @return	Widget to display
	 */
	UE_API TSharedRef<SWidget> GenerateWidget(UToolMenu* GeneratedMenu);
	
	/** Create a finalized menu that combines all parents used to generate a widget. Advanced special use cases only. */
	UE_API UToolMenu* GenerateMenu(const FName Name, const FToolMenuContext& InMenuContext);

	/** Create a finalized menu based on a custom crafted menu. Advanced special use cases only. */
	UE_API UToolMenu* GenerateMenuAsBuilder(const UToolMenu* InMenu, const FToolMenuContext& InMenuContext);

	/* Generate either a menu or submenu ready for editing */
	UE_API UToolMenu* GenerateMenuOrSubMenuForEdit(const UToolMenu* InMenu);

	/** Bake final menu including calls to construction delegates, sorting, and customization */
	UE_API void AssembleMenuHierarchy(UToolMenu* GeneratedMenu, const TArray<UToolMenu*>& Hierarchy);

	/* Returns list of menus starting with root parent */
	UE_API TArray<UToolMenu*> CollectHierarchy(const FName Name);

	/** For advanced use cases */
	UE_API FToolMenuOwner CurrentOwner() const;

	/** Registers a new type of string based command handler. */
	UE_API void RegisterStringCommandHandler(const FName InName, const FToolMenuExecuteString& InDelegate);

	/** Removes a string based command handler. */
	UE_API void UnregisterStringCommandHandler(const FName InName);

	DECLARE_MULTICAST_DELEGATE_TwoParams(FOnStringCommandExecuted, FName MenuName, FName TypeName);
	/** Called when we execute a string command. Useful for analytics */
	FOnStringCommandExecuted OnStringCommandExecuted;
	
	/** Sets delegate to setup timer for deferred one off ticks */
	UE_API void AssignSetTimerForNextTickDelegate(const FSimpleDelegate& InDelegate);

	/** Timer function used to consolidate multiple duplicate requests into a single frame. */
	UE_API void HandleNextTick();

	/** Remove customization for a menu */
	UE_API void RemoveCustomization(const FName InName);

	/** Remove all menu customizations for all menus */
	UE_API void RemoveAllCustomizations();

	/** Save menu customizations to ini files */
	UE_API void SaveCustomizations();

	/** Find customization settings for a menu */
	UE_API FCustomizedToolMenu* FindMenuCustomization(const FName InName);

	/** Find or add customization settings for a menu */
	UE_API FCustomizedToolMenu* AddMenuCustomization(const FName InName);

	/** Find index of customization settings for a menu */
	UE_API int32 FindMenuCustomizationIndex(const FName InName);

	/** Find runtime customization settings for a menu */
	UE_API FCustomizedToolMenu* FindRuntimeMenuCustomization(const FName InName);

	/** Find or add runtime customization settings for a menu */
	UE_API FCustomizedToolMenu* AddRuntimeMenuCustomization(const FName InName);

	/** Find a specific profile for a menu */
	UE_API FToolMenuProfile* FindMenuProfile(const FName InMenuName, const FName InProfileName);

	/** Find or add a specific profile for a menu */
	UE_API FToolMenuProfile* AddMenuProfile(const FName InMenuName, const FName InProfileName);

	/** Find a specific runtime only profile for a menu */
	UE_API FToolMenuProfile* FindRuntimeMenuProfile(const FName InMenuName, const FName InProfileName);

	/** Find or add a specific runtime only profile for a menu */
	UE_API FToolMenuProfile* AddRuntimeMenuProfile(const FName InMenuName, const FName InProfileName);

	/** Unregister runtime customization settings for a specific owner name */
	UE_API void UnregisterRuntimeMenuCustomizationOwner(const FName InOwnerName);

	/** Unregister runtime profile settings for a specific owner name */
	UE_API void UnregisterRuntimeMenuProfileOwner(const FName InOwnerName);

	/** Generates sub menu by entry name in the given generated menu parent */
	UE_API UToolMenu* GenerateSubMenu(const UToolMenu* InGeneratedParent, const FName InBlockName);

	/** When true, adds command to open edit menu dialog to each menu */
	UE_API bool GetEditMenusMode() const;

	/** Enables adding command to open edit menu dialog to each menu */
	UE_API void SetEditMenusMode(bool bEnable);

	/* Substitute one menu for another during generate but not during find or extend */
	UE_API void AddMenuSubstitutionDuringGenerate(const FName OriginalMenu, const FName NewMenu);

	/* Remove substitute one menu for another during generate */
	UE_API void RemoveSubstitutionDuringGenerate(const FName InMenu);

	/** Release references to UObjects of widgets that have been deleted. Combines multiple requests in one frame together for improved performance. */
	UE_API void CleanupStaleWidgetsNextTick(bool bGarbageCollect = false);

	/** Displaying extension points is for debugging menus */
	DECLARE_DELEGATE_RetVal(bool, FShouldDisplayExtensionPoints);
	FShouldDisplayExtensionPoints ShouldDisplayExtensionPoints;

	/* Delegate that opens a menu editor */
	DECLARE_DELEGATE_OneParam(FEditMenuDelegate, class UToolMenu*);
	FEditMenuDelegate EditMenuDelegate;

	DECLARE_MULTICAST_DELEGATE_TwoParams(FGenerateWidgetEvent, const FName InName, const FToolMenuContext& InMenuContext);
	/** Called before we generate a menu widget. */
	FGenerateWidgetEvent OnPreGenerateWidget;
	/** Called after we generate a menu widget. */
	FGenerateWidgetEvent OnPostGenerateWidget;

	/** Icon to display in menus for command to open menu editor */
	FSlateIcon EditMenuIcon;

	/** Icon to display in toolbars for command to open menu editor */
	FSlateIcon EditToolbarIcon;

	/** Join two paths together */
	static UE_API FName JoinMenuPaths(const FName Base, const FName Child);

	/** Break apart a menu path into components */
	static UE_API bool SplitMenuPath(const FName MenuPath, FName& OutLeft, FName& OutRight);

	/** Returns true if safe to call into script */
	static UE_API bool CanSafelyRouteCall();

	friend struct FToolMenuOwnerScoped;
	friend struct FToolMenuStringCommand;

	//~ Begin UObject Interface
	static UE_API void AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector);
	UE_API virtual void BeginDestroy() override;
	//~ End UObject Interface

private:
	friend class FPopulateMenuBuilderWithToolMenuEntry;

	/** Create a finalized menu that combines given hierarchy array that will generate a widget. Advanced special use cases only. */
	UE_API UToolMenu* GenerateMenuFromHierarchy(const TArray<UToolMenu*>& Hierarchy, const FToolMenuContext& InMenuContext);

	/** Sets a timer to be called next engine tick so that multiple repeated actions can be combined together. */
	UE_API void SetNextTickTimer();

	/** Release references to UObjects of widgets that have been deleted */
	UE_API void CleanupStaleWidgets();

	/** Re-creates widget that is active */
	UE_API bool RefreshMenuWidget(const FName Name, FGeneratedToolMenuWidget& GeneratedMenuWidget);

	/** Sets the current temporary menu owner to avoid needing to supply owner for each menu entry being registered. Used by FToolMenuEntryScoped */
	UE_API void PushOwner(const FToolMenuOwner InOwner);

	/** Sets the current temporary menu owner. Used by FToolMenuEntryScoped */
	UE_API void PopOwner(const FToolMenuOwner InOwner);

	static UE_API void PrivateStartupCallback();
	static UE_API void UnregisterPrivateStartupCallback();

	UE_API UToolMenu* FindSubMenuToGenerateWith(const FName InParentName, const FName InChildName);

	UE_API void PopulateMenuBuilder(FMenuBuilder& MenuBuilder, UToolMenu* MenuData);
	UE_API void PopulateMenuBarBuilder(FMenuBarBuilder& MenuBarBuilder, UToolMenu* MenuData);

	UE_API void ExtractChildBlocksFromSubMenu(UToolMenu* ParentMenu, FToolMenuEntry& InBlock, TArray<UE::ToolMenus::FSubBlockReference>& SubMenuBlocks);
	UE_API void PopulateToolBarBuilderWithTopLevelChildren(FToolBarBuilder& ToolBarBuilder, UToolMenu* ParentMenu, FToolMenuEntry& InBlock, bool bAddSpaceAfterRaisedChildren);
	UE_API void PopulateToolBarBuilderWithEntry(
		FToolBarBuilder& ToolBarBuilder,
		UToolMenu* MenuData,
		FToolMenuSection& Section,
		FToolMenuEntry& Entry,
		bool bIsRaisingToTopLevel = false,
		bool bIsLastBlockOfLastSection = false
	);
	UE_API void PopulateToolBarBuilder(FToolBarBuilder& ToolBarBuilder, UToolMenu* MenuData);

	UE_API TSharedRef<SWidget> GenerateToolbarComboButtonMenu(TWeakObjectPtr<UToolMenu> InParent, const FName InBlockName);

	UE_API FOnGetContent ConvertWidgetChoice(const FNewToolMenuChoice& Choice, const FToolMenuContext& Context) const;

	/** Converts a string command to a FUIAction */
	static UE_API FUIAction ConvertUIAction(const FToolMenuEntry& Block, const FToolMenuContext& Context);
	static UE_API FUIAction ConvertUIAction(const FToolUIActionChoice& Choice, const FToolMenuContext& Context);
	static UE_API FUIAction ConvertUIAction(const FToolUIAction& Actions, const FToolMenuContext& Context);
	static UE_API FUIAction ConvertUIAction(const FToolDynamicUIAction& Actions, const FToolMenuContext& Context);
	static UE_API FUIAction ConvertScriptObjectToUIAction(UToolMenuEntryScript* ScriptObject, const FToolMenuContext& Context);
	
	static UE_API TAttribute<EVisibility> CalculateToolbarVisibility(
		UToolMenu* Menu,
		FToolMenuSection& Section,
		FToolMenuEntry& Entry,
		bool bIsRaisingToTopLevel,
		bool bEmbedActionOrCommand
	);

	static UE_API void ExecuteStringCommand(const FToolMenuStringCommand StringCommand, FName MenuName, const FToolMenuContext Context);

	UE_API void PopulateSubMenu(FMenuBuilder& Builder, TWeakObjectPtr<UToolMenu> InParent, const FToolMenuEntry InEntry, const FName InBlockName);
	UE_API void PopulateSubMenuWithoutName(FMenuBuilder& MenuBuilder, TWeakObjectPtr<UToolMenu> InParent, const FToolMenuEntry InEntry);
	UE_API TArray<UToolMenu*> CollectHierarchy(const FName Name, const TMap<FName, FName>& UnregisteredParentNames);

	/** Applies the style to the given Builder, as specified by the provided Style. */
	UE_API void ApplyStyleToBuilder(FMenuBuilder& InBuilder, const FToolMenuEntryStyle& InStyle);

	UE_API void ListAllParents(const FName Name, TArray<FName>& AllParents);

	UE_API void AssembleMenu(UToolMenu* GeneratedMenu, const UToolMenu* Other);
	UE_API void AssembleMenuSection(UToolMenu* GeneratedMenu, const UToolMenu* Other, FToolMenuSection* DestSection, const FToolMenuSection& OtherSection);

	UE_API void CopyMenuSettings(UToolMenu* GeneratedMenu, const UToolMenu* Other);

	UE_API void AddReferencedContextObjects(const TSharedRef<FMultiBox>& InMultiBox, const UToolMenu* InMenu);

	UE_API void ApplyCustomizationAndProfiles(UToolMenu* GeneratedMenu);
	UE_API void ApplyProfile(UToolMenu* GeneratedMenu, const FToolMenuProfile& Profile);
	UE_API void ApplyCustomization(UToolMenu* GeneratedMenu, const FCustomizedToolMenu& Profile);

	UE_API void UnregisterOwnerInternal(FToolMenuOwner Owner);

	UE_API bool GetDisplayUIExtensionPoints() const;

	static UE_API void ModifyEntryForEditDialog(FToolMenuEntry& Entry);

	UE_API UToolMenu* NewToolMenuObject(const FName NewBaseName, const FName InMenuName);

private:

	UPROPERTY(EditAnywhere, Category = Misc)
	TArray<FCustomizedToolMenu> CustomizedMenus;
	
	/* Allow substituting one menu for another during generate but not during find or extend */
	UPROPERTY(EditAnywhere, Category = Misc)
	TMap<FName, FName> MenuSubstitutionsDuringGenerate;

	UPROPERTY()
	TMap<FName, TObjectPtr<UToolMenu>> Menus;

	TMap<FName, TSharedPtr<FGeneratedToolMenuWidgets>> GeneratedMenuWidgets;

	TMap<TWeakPtr<FMultiBox>, TArray<TObjectPtr<const UObject>>> WidgetObjectReferences;

	TArray<FToolMenuOwner> OwnerStack;

	TMap<FName, FToolMenuExecuteString> StringCommandHandlers;

	/** Transient customizations made during runtime that will not be saved */
	TArray<FCustomizedToolMenu> RuntimeCustomizedMenus;

	UPROPERTY(EditAnywhere, Category = Misc)
	TMap<FName /*MenuName*/, FToolMenuProfileMap> MenuProfiles;

	/** Transient profiles made during runtime that will not be saved */
	TMap<FName /*MenuName*/, FToolMenuProfileMap> RuntimeMenuProfiles;

	FSimpleDelegate SetTimerForNextTickDelegate;

	bool bNextTickTimerIsSet;
	bool bRefreshWidgetsNextTick;
	bool bCleanupStaleWidgetsNextTick;
	bool bCleanupStaleWidgetsNextTickGC;
	bool bEditMenusMode;
	bool bSuppressRefreshWidgetsRequests = false;

	static UE_API UToolMenus* Singleton;
	static UE_API bool bHasShutDown;
	static UE_API FSimpleMulticastDelegate StartupCallbacks;
	static UE_API TOptional<FDelegateHandle> InternalStartupCallbackHandle;

	friend class UE::ToolMenus::FToolMenuTestInstanceScoped;
};

/**
 * Sets the owner for all menus created until the end of the current scope (with support for nested scopes).
 * Combines well with UToolMenus::UnregisterOwnerByName.
 */
struct FToolMenuOwnerScoped
{
	FToolMenuOwnerScoped(const FToolMenuOwner InOwner) : Owner(InOwner)
	{
		UToolMenus::Get()->PushOwner(InOwner);
	}

	~FToolMenuOwnerScoped()
	{
		UToolMenus::Get()->PopOwner(Owner);
	}

	FToolMenuOwner GetOwner() const { return Owner; }

private:

	FToolMenuOwner Owner;
};

namespace UE::ToolMenus
{

/**
 * Creates a new instance of UToolMenus and sets the UToolMenus singleton to point at this new instance.
 * When the scope instance is destructed, the previous UToolMenus singleton is reinstated.
 */
class FToolMenuTestInstanceScoped
{
public:
	FToolMenuTestInstanceScoped();
	~FToolMenuTestInstanceScoped();

private:
	UToolMenus* PreviousInstance;
	UToolMenus* ScopedInstance;
};

}; // namespace UE::ToolMenus

#undef UE_API