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

#pragma once

#include "Compilation/MovieSceneSegmentCompiler.h"
#include "IMovieSceneTrackVirtualAPI.h"
#include "Containers/Array.h"
#include "Containers/ArrayView.h"
#include "CoreMinimal.h"
#include "CoreTypes.h"
#include "Evaluation/Blending/MovieSceneBlendType.h"
#include "Evaluation/MovieSceneEvaluationField.h"
#include "Decorations/MovieSceneDecorationContainer.h"
#include "HAL/Platform.h"
#include "Internationalization/Text.h"
#include "Math/Color.h"
#include "Misc/AssertionMacros.h"
#include "Misc/EnumClassFlags.h"
#include "Misc/Guid.h"
#include "Misc/InlineValue.h"
#include "MovieSceneSignedObject.h"
#include "MovieSceneTrackEvaluationField.h"
#include "Templates/SubclassOf.h"
#include "UObject/NameTypes.h"
#include "UObject/ObjectMacros.h"
#include "UObject/UObjectGlobals.h"
#include "UObject/UnrealNames.h"
#include "UObject/UnrealType.h"
#include "Conditions/MovieSceneCondition.h"

#if WITH_EDITOR
#include "Styling/SlateColor.h"
#endif

#include "MovieSceneTrack.generated.h"

class UMovieSceneSection;
class UObject;
struct FMovieSceneEvaluationTrack;
struct FMovieSceneTrackRowSegmentBlender;
struct FMovieSceneTrackSegmentBlender;
struct IMovieSceneTemplateGenerator;
struct FMovieSceneConditionContainer;
template<typename> struct TMovieSceneEvaluationTree;

/** Flags used to perform cook-time optimization of movie scene data */
enum class ECookOptimizationFlags
{
	/** Perform no cook optimization */
	None 			= 0,
	/** Remove this track since its of no consequence to runtime */
	RemoveTrack		= 1 << 0,
	/** Remove this track's object since its of no consequence to runtime */
	RemoveObject	= 1 << 1,
	/** Remove this section's object since its of no consequence to runtime */
	RemoveSection	= 1 << 2,
};
ENUM_CLASS_FLAGS(ECookOptimizationFlags)

/** Generic evaluation options for any track */
USTRUCT()
struct FMovieSceneTrackEvalOptions
{
	GENERATED_BODY()
	
	FMovieSceneTrackEvalOptions()
		: bCanEvaluateNearestSection(false)
		, bEvalNearestSection(false)
		, bEvaluateInPreroll(false)
		, bEvaluateInPostroll(false)
		, bEvaluateNearestSection_DEPRECATED(false)
	{}

	/** true when the value of bEvalNearestSection is to be considered for the track */
	UPROPERTY()
	uint32 bCanEvaluateNearestSection : 1;

	/** When evaluating empty space on a track, will evaluate the last position of the previous section (if possible), or the first position of the next section, in that order of preference. */
	UPROPERTY(EditAnywhere, Category="Track", DisplayName="Evaluate Nearest Section", meta=(EditCondition=bCanEvaluateNearestSection, HideEditConditionToggle))
	uint32 bEvalNearestSection : 1;

	/** Evaluate this track as part of its parent sub-section's pre-roll, if applicable */
	UPROPERTY(EditAnywhere, Category="Track")
	uint32 bEvaluateInPreroll : 1;

	/** Evaluate this track as part of its parent sub-section's post-roll, if applicable */
	UPROPERTY(EditAnywhere, Category="Track")
	uint32 bEvaluateInPostroll : 1;

	UPROPERTY()
	uint32 bEvaluateNearestSection_DEPRECATED : 1;
};


/** Generic display options for any track */
USTRUCT()
struct FMovieSceneTrackDisplayOptions
{
	GENERATED_BODY()

	FMovieSceneTrackDisplayOptions()
		: bShowVerticalFrames(false)
	{}

	/** Show bounds as vertical frames */
	UPROPERTY(EditAnywhere, Category = "Track")
	uint32 bShowVerticalFrames : 1;
};

/** Returns what kind of section easing we support in the editor */
enum class EMovieSceneTrackEasingSupportFlags
{
	None = 0,
	AutomaticEaseIn = 1 << 0,
	AutomaticEaseOut = 1 << 1,
	ManualEaseIn = 1 << 2,
	ManualEaseOut = 1 << 3,
	AutomaticEasing = AutomaticEaseIn | AutomaticEaseOut,
	ManualEasing = ManualEaseIn | ManualEaseOut,
	All = AutomaticEasing | ManualEasing
};
ENUM_CLASS_FLAGS(EMovieSceneTrackEasingSupportFlags)

/** Parameters for the `SupportsEasing` method */
struct FMovieSceneSupportsEasingParams
{
	// Non-null if we are asking for a specific section.
	const UMovieSceneSection* ForSection;

	FMovieSceneSupportsEasingParams() : ForSection(nullptr) {}
	FMovieSceneSupportsEasingParams(const UMovieSceneSection* InSection) : ForSection(InSection) {}
};

/** Pre-compilation result */
struct FMovieSceneTrackPreCompileResult
{
	/**
	 * The default metadata that will be used for all entity provider sections found on the current track.
	 *
	 * A track can change this metadata by overriding PreCompile.
	 */
	FMovieSceneEvaluationFieldEntityMetaData DefaultMetaData;
};

#if WITH_EDITOR
/** Parameters for sections moving in the editor */
struct FMovieSceneSectionMovedParams
{
	EPropertyChangeType::Type MoveType;

	FMovieSceneSectionMovedParams(EPropertyChangeType::Type InMoveType) : MoveType(InMoveType) {}
};

/** Result of having moved sections in the editor */
enum class EMovieSceneSectionMovedResult
{
	/** Nothing significant has changed */
	None = 0,
	/** Sections have been added or removed, which requires a UI refresh */
	SectionsChanged = 1
};
ENUM_CLASS_FLAGS(EMovieSceneSectionMovedResult);

/** Parameters for helping to determine dynamic label color/tooltip*/
struct FMovieSceneLabelParams
{
	class IMovieScenePlayer* Player = nullptr;
	FGuid BindingID;
	FMovieSceneSequenceID SequenceID;
	bool bIsDimmed = false;
};
#endif

/* Metadata tied to a track row. */
USTRUCT()
struct FMovieSceneTrackRowMetadata
{
	GENERATED_BODY()
	
	/* Optional dynamic conditions tied to specific track rows. */
	UPROPERTY(EditAnywhere, Category="Track Row", meta=(ShowOnlyInnerProperties))
	FMovieSceneConditionContainer ConditionContainer;
};


// Disable some VS warnings that are emitted by Add/RemoveSection functions hiding the
//    private virtual methods in IMovieSceneTrackVirtualAPI
#if PLATFORM_COMPILER_CLANG
	#pragma clang diagnostic push
	#pragma clang diagnostic ignored "-Woverloaded-virtual"
#elif PLATFORM_MICROSOFT
	#pragma warning(push)
	#pragma warning(disable:4263)
	#pragma warning(disable:4264)
#else
	static_assert(false, "Unexpected compiler detected");
#endif

/**
 * Base class for a track in a Movie Scene
 */
UCLASS(abstract, DefaultToInstanced, MinimalAPI, BlueprintType)
class UMovieSceneTrack
	: public UMovieSceneDecorationContainerObject
	, public IMovieSceneTrackVirtualAPI
{
	GENERATED_BODY()

public:

	MOVIESCENE_API UMovieSceneTrack(const FObjectInitializer& InInitializer);
	~UMovieSceneTrack() {};

public:

	/** General evaluation options for a given track */
	UPROPERTY(EditAnywhere, Category = "Track", meta = (ShowOnlyInnerProperties))
	FMovieSceneTrackEvalOptions EvalOptions;

#if WITH_EDITORONLY_DATA
	/** General display options for a given track */
	UPROPERTY(EditAnywhere, Category = "Track", meta = (ShowOnlyInnerProperties))
	FMovieSceneTrackDisplayOptions DisplayOptions;
#endif

	/** Optional dynamic condition for whether this track/any of the sections on this track evaluates at runtime. */
	UPROPERTY(EditAnywhere, Category = "Track")
	FMovieSceneConditionContainer ConditionContainer;

	/**
	 * Gets what kind of blending is supported by this section
	 */
	FMovieSceneBlendTypeField GetSupportedBlendTypes() const
	{
		return SupportedBlendTypes;
	}

	/** 
	 * Get compiler rules to use when compiling sections that overlap on the same row.
	 * These define how to deal with overlapping sections and empty space on a row
	 */
	MOVIESCENE_API virtual FMovieSceneTrackRowSegmentBlenderPtr GetRowSegmentBlender() const;

	/** 
	 * Get compiler rules to use when compiling sections that overlap on different rows.
	 * These define how to deal with overlapping sections and empty space at the track level
	 */
	MOVIESCENE_API virtual FMovieSceneTrackSegmentBlenderPtr GetTrackSegmentBlender() const;

	/**
	 * Update all auto-generated easing curves for all sections in this track
	 */
	MOVIESCENE_API virtual void UpdateEasing();


	void OnAddedToMovieScene(UMovieScene* MovieScene);
	void OnRemovedFromMovieScene();

protected:

	//~ UObject interface
	MOVIESCENE_API virtual void PostInitProperties() override;
	MOVIESCENE_API virtual void PostLoad() override;
	MOVIESCENE_API virtual bool IsPostLoadThreadSafe() const override;

	MOVIESCENE_API virtual void OnDecorationAdded(UObject* NewDecoration) override;
	MOVIESCENE_API virtual void OnDecorationRemoved(UObject* Decoration) override;

	/** Intentionally not a UPROPERTY so this isn't serialized */
	FMovieSceneBlendTypeField SupportedBlendTypes;

	/** Whether evaluation of this track has been disabled via mute/solo */
	UPROPERTY()
	bool bIsEvalDisabled;

	/** Which rows have been disabled via mute/solo */
	UPROPERTY()
	TArray<int32> RowsDisabled;

#if WITH_EDITORONLY_DATA

	/** Whether evaluation of this track has been disabled locally (not serialized with the asset) */
	UPROPERTY(Transient)
	bool bIsLocalEvalDisabled;

	/** Which rows have been disabled locally (not serialized with the asset) */
	UPROPERTY(Transient)
	TArray<int32> LocalRowsDisabled;

#endif

public:

	/**
	 * Run the pre-compilation step for this track.
	 * This method is called by the sequence compiler and is not meant to be called by 3rd party code.
	 */
	void PreCompile(FMovieSceneTrackPreCompileResult& OutPreCompileResult);

	/**
	 * Retrieve a fully up-to-date evaluation field for this track.
	 */
	MOVIESCENE_API const FMovieSceneTrackEvaluationField& GetEvaluationField();

	/**
	 * Retrieve a version number for the logic implemented in PopulateEvaluationTree.
	 *
	 * The evaluation field is cached with the data and is invalidated if the data signature changes, or
	 * if this version number changes. You should bump this version number if you start/stop overriding,
	 * or otherwise change the logic, of PopulateEvaluationTree.
	 */
	virtual int8 GetEvaluationFieldVersion() const { return 0; }

	MOVIESCENE_API FGuid FindObjectBindingGuid() const;

protected:

	enum class ETreePopulationMode : uint8
	{
		None,
		Blended,
		HighPass,
		HighPassPerRow,
	};

	ETreePopulationMode BuiltInTreePopulationMode;

protected:

	/** Forcibly update this evaluation tree without updating the signature. Does not invalidated any compiled data! */
	MOVIESCENE_API void ForceUpdateEvaluationTree();

private:

	/** Sub-classes can override this method to perforum custom evaluation tree population logic. */
	virtual bool PopulateEvaluationTree(TMovieSceneEvaluationTree<FMovieSceneTrackEvaluationData>& OutData) const
	{
		return false;
	}

	/** Sub-classes can override this method to perform custom pre-compilation logic. */
	virtual void PreCompileImpl(FMovieSceneTrackPreCompileResult& OutPreCompileResult)
	{
	}

	virtual void OnAddedToMovieSceneImpl(UMovieScene* InMovieScene)
	{
	}

	virtual void OnRemovedFromMovieSceneImpl()
	{
	}

private:

	void UpdateEvaluationTree();
	void AddSectionRangesToTree(TArrayView<UMovieSceneSection* const> Sections, TMovieSceneEvaluationTree<FMovieSceneTrackEvaluationData>& OutData);
	void AddSectionPrePostRollRangesToTree(TArrayView<UMovieSceneSection* const> Sections, TMovieSceneEvaluationTree<FMovieSceneTrackEvaluationData>& OutData);

	/** The guid of the object signature that the EvaluationField member relates to */
	UPROPERTY()
	FGuid EvaluationFieldGuid;

#if WITH_EDITORONLY_DATA
	/** The version of the logic in PopulateEvaluationTree when the EvaluationField was cached */
	UPROPERTY()
	int8 EvaluationFieldVersion;
#endif

	/** An array of entries that define when specific sections should be evaluated on this track */
	UPROPERTY()
	FMovieSceneTrackEvaluationField EvaluationField;

	/* Optional extra metadata tied to specific track rows. */
	UPROPERTY()
	TMap<int32, FMovieSceneTrackRowMetadata> TrackRowMetadata;

public:

	/**
	 * @return The name that makes this track unique from other track of the same class.
	 */
	virtual FName GetTrackName() const { return NAME_None; }

	/**
	 * @return Whether or not this track has any data in it.
	 */
	virtual bool IsEmpty() const PURE_VIRTUAL(UMovieSceneTrack::IsEmpty, return true;);

	/**
	 * Removes animation data.
	 */
	virtual void RemoveAllAnimationData() { }

	/**
	 * @return Whether or not this track supports multiple row indices.
	 */
	virtual bool SupportsMultipleRows() const
	{
		return SupportedBlendTypes.Num() != 0;
	}

	virtual EMovieSceneTrackEasingSupportFlags SupportsEasing(FMovieSceneSupportsEasingParams& Params) const
	{
		return SupportedBlendTypes.Num() > 0 ? EMovieSceneTrackEasingSupportFlags::All : EMovieSceneTrackEasingSupportFlags::None;
	}

	/** Set This Section as the one to key. If track doesn't support layered blends then don't implement
	 * @param InSection		Section that we want to key
	 */
	 virtual void SetSectionToKey(UMovieSceneSection* InSection) {};

	/** Get the section we want to key. If track doesn't support layered blends it will return nulltpr.
	 * @return The section to key if one exists
	 */
	 virtual UMovieSceneSection* GetSectionToKey() const { return nullptr; }

	/** Gets the greatest row index of all the sections owned by this track. */
	MOVIESCENE_API int32 GetMaxRowIndex() const;

	/**
	 * Updates the row indices of sections owned by this track so that all row indices which are used are consecutive with no gaps. 
	 * @return Whether or not fixes were made. 
	 */
	MOVIESCENE_API virtual bool FixRowIndices();

	/** Called when row indices have been fixed up */
	MOVIESCENE_API virtual void OnRowIndicesChanged(const TMap<int32, int32>& NewToOldRowIndices);

	/**
	 * @return Whether evaluation of this track should be disabled due to deactive setting
	 */
	MOVIESCENE_API bool IsEvalDisabled(const bool bInCheckLocal = true) const;
	MOVIESCENE_API bool IsRowEvalDisabled(const int32 InRowIndex, const bool bInCheckLocal = true) const;

	/**
	 * Called by Sequencer to set whether evaluation of this track should be disabled due to deactive setting
	 */
	void SetEvalDisabled(const bool bInEvalDisabled) { bIsEvalDisabled = bInEvalDisabled; }
	MOVIESCENE_API void SetRowEvalDisabled(const bool bInEvalDisabled, const int32 InRowIndex);

#if WITH_EDITOR

	/**
	 * @return Whether evaluation of this track should be disabled due to local muting/soloing (not serialized with the asset)
	 */
	bool IsLocalEvalDisabled() const { return bIsLocalEvalDisabled; }
	MOVIESCENE_API bool IsLocalRowEvalDisabled(const int32 InRowIndex) const;

	/**
	 * Called by Sequencer to set whether evaluation of this track should be disabled due to local muting/soloing (not serialized with the asset)
	 */
	void SetLocalEvalDisabled(const bool bInEvalDisabled) { bIsLocalEvalDisabled = bInEvalDisabled; }
	MOVIESCENE_API void SetLocalRowEvalDisabled(const bool bInEvalDisabled, int32 InRowIndex);

#endif

	/*
	 * Returns a pointer to optional track row metadata at the given RowIndex, or nullptr if none exists.
	 */
	MOVIESCENE_API const FMovieSceneTrackRowMetadata* FindTrackRowMetadata(int32 RowIndex) const;

	/*
	 * Returns a pointer to optional track row metadata at the given RowIndex, or nullptr if none exists;
	 */
	MOVIESCENE_API FMovieSceneTrackRowMetadata* FindTrackRowMetadata(int32 RowIndex);

	/*
	 * Returns a pointer to optional track row metadata at the given RowIndex, or nullptr if none exists;
	 */
	MOVIESCENE_API FMovieSceneTrackRowMetadata& FindOrAddTrackRowMetadata(int32 RowIndex);

public:

	/*
	 * Does this track support this section class type?

	 * @param ClassType The movie scene section class type
	 * @return Whether this track supports this section class type
	 */
	virtual bool SupportsType(TSubclassOf<UMovieSceneSection> SectionClass) const PURE_VIRTUAL(UMovieSceneTrack::SupportsType, return false;);

	// Parameter structs that only exist to differentiate overloads from IMovieSceneTrackVirtualAPI
	struct FSectionParameter
	{
		FSectionParameter(UMovieSceneSection& InSection) : Section(&InSection) {};
		UMovieSceneSection* Section;
	};
	struct FSectionIndexParameter
	{
		FSectionIndexParameter(int32 InSectionIndex) : SectionIndex(InSectionIndex) {};
		int32 SectionIndex;
	};

	/**
	 * Add a section to this track.
	 *
	 * @param Section The section to add.
	 */
	MOVIESCENE_API void AddSection(FSectionParameter Section);

	/**
	 * Removes a section from this track.
	 *
	 * @param Section The section to remove.
	 */
	MOVIESCENE_API void RemoveSection(FSectionParameter Section);

	/**
	 * Removes a section from this track at a particular index
	 *
	 * @param SectionIndex The section index to remove.
	 */
	MOVIESCENE_API void RemoveSectionAt(FSectionIndexParameter SectionIndex);

public:
	/**
	 * Generates a new section suitable for use with this track.
	 *
	 * @return a new section suitable for use with this track.
	 */
	virtual class UMovieSceneSection* CreateNewSection() PURE_VIRTUAL(UMovieSceneTrack::CreateNewSection, return nullptr;);
	
	/**
	 * Called when all the sections of the track need to be retrieved.
	 * 
	 * @return List of all the sections in the track.
	 */
	virtual const TArray<UMovieSceneSection*>& GetAllSections() const PURE_VIRTUAL(UMovieSceneTrack::GetAllSections, static TArray<UMovieSceneSection*> Empty; return Empty;);

	/**
	 * Checks to see if the section is in this track.
	 *
	 * @param Section The section to query for.
	 * @return True if the section is in this track.
	 */
	virtual bool HasSection(const UMovieSceneSection& Section) const PURE_VIRTUAL(UMovieSceneTrack::HasSection, return false;);

private:

	virtual void OnSectionAddedImpl(UMovieSceneSection* Section)
	{
	}

	virtual void OnSectionRemovedImpl(UMovieSceneSection* Section)
	{
	}

public:

#if WITH_EDITOR

	/**
	 * Called when this track's movie scene is being cooked to determine if/how this track should be cooked.
	 * @return ECookOptimizationFlags detailing how to optimize this track
	 */
	MOVIESCENE_API virtual ECookOptimizationFlags GetCookOptimizationFlags() const;

	/**
	 * Called when this track should be removed for cooking
	 */
	MOVIESCENE_API virtual void RemoveForCook();

	static bool RemoveMutedTracksOnCook();

#endif

#if WITH_EDITORONLY_DATA

	/**
	 * Get the track's display name.
	 *
	 * @return Display name text.
	 */
	virtual FText GetDisplayName() const PURE_VIRTUAL(UMovieSceneTrack::GetDisplayName, return FText::FromString(TEXT("Unnamed Track")););

	/**
	 * Get the track row's display name.
	 *
	 * @return Display name text.
	 */
	virtual FText GetTrackRowDisplayName(int32 RowIndex) const { return FText::FromString(TEXT("Unnamed Track")); }

	/**
	 * Get the track's display tooltip text to be shown on the track's name.
	 *
	 * @return Display tooltip text.
	 */
	virtual FText GetDisplayNameToolTipText(const FMovieSceneLabelParams& LabelParams) const { return FText::GetEmpty(); }

	/**
	 * Gets the track label's color.
	 * 
	 * @return Track label color.
	 */
	virtual FSlateColor GetLabelColor(const FMovieSceneLabelParams& LabelParams) const { return FSlateColor::UseForeground(); }

	/**
	 * Get this track's color tint.
	 *
	 * @return Color Tint.
	 */
	const FColor& GetColorTint() const
	{
		return TrackTint;
	}

	/**
	 * Set this track's color tint.
	 *
	 * @param InTrackTint The color to tint this track.
	 */
	void SetColorTint(const FColor& InTrackTint)
	{
		TrackTint = InTrackTint;
	}

	/**
	 * Get this folder's desired sorting order
	 */
	int32 GetSortingOrder() const
	{
		return SortingOrder;
	}

	/**
	 * Set this folder's desired sorting order.
	 *
	 * @param InSortingOrder The higher the value the further down the list the folder will be.
	 */
	void SetSortingOrder(const int32 InSortingOrder)
	{
		SortingOrder = InSortingOrder;
	}

	/**
	 * @return Whether or not this track supports the creation of default sections when the track is created.
	 */
	virtual bool SupportsDefaultSections() const
	{
		return bSupportsDefaultSections;
	}

	/**
	 * @return Whether or not this track supports conditions.
	 */
	virtual bool SupportsConditions() const
	{
		return bSupportsConditions;
	}

	/*
	* Returns an array of all conditions on track, track row, or section
	*/
	MOVIESCENE_API TArray<UMovieSceneCondition*> GetAllConditions();

protected:

	/** The object binding that this track resides within */
	UPROPERTY()
	FGuid ObjectBindingID;

	/** This track's tint color */
	UPROPERTY(EditAnywhere, Category="Track", DisplayName = Color)
	FColor TrackTint;

	/** This folder's desired sorting order */
	UPROPERTY()
	int32 SortingOrder;

	/** Does this track support the creation of a default section when created? */
	UPROPERTY()
	bool bSupportsDefaultSections;

	/** Does this track support conditions */
	UPROPERTY()
	bool bSupportsConditions;

public:
#endif

#if WITH_EDITOR
	/**
	 * Called if the section is moved in Sequencer.
	 *
	 * @param Section The section that moved.
	 */
	virtual EMovieSceneSectionMovedResult OnSectionMoved(UMovieSceneSection& Section, const FMovieSceneSectionMovedParams& Params)
	{
		return EMovieSceneSectionMovedResult::None;
	}

	#endif
};

#if PLATFORM_COMPILER_CLANG
	#pragma clang diagnostic pop
#elif PLATFORM_MICROSOFT
	#pragma warning(pop)
#endif