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

#include "Widgets/SInvalidationPanel.h"
#include "Rendering/DrawElements.h"
#include "Misc/App.h"
#include "Application/SlateApplicationBase.h"
#include "Styling/CoreStyle.h"
#include "Layout/WidgetPath.h"
#include "HAL/IConsoleManager.h"
#include "Framework/Application/SlateApplication.h"
#include "Types/ReflectionMetadata.h"
#include "Rendering/SlateObjectReferenceCollector.h"
#include "Widgets/SNullWidget.h"

DECLARE_CYCLE_STAT(TEXT("SInvalidationPanel::Paint"), STAT_SlateInvalidationPaint, STATGROUP_Slate);


void ConsoleVariableEnableInvalidationPanelsChanged(IConsoleVariable*);

/** True if we should allow widgets to be cached in the UI at all. */
static bool bInvalidationPanelsEnabled = true;
FAutoConsoleVariableRef CVarEnableInvalidationPanels(
	TEXT("Slate.EnableInvalidationPanels"),
	bInvalidationPanelsEnabled,
	TEXT("Whether to attempt to cache any widgets through invalidation panels."),
	FConsoleVariableDelegate::CreateStatic(ConsoleVariableEnableInvalidationPanelsChanged));

#if WITH_SLATE_DEBUGGING

static bool bAlwaysInvalidate = false;
FAutoConsoleVariableRef CVarAlwaysInvalidate(
	TEXT("Slate.AlwaysInvalidate"),
	bAlwaysInvalidate,
	TEXT("Forces invalidation panels to cache, but to always invalidate."));

#endif // WITH_SLATE_DEBUGGING

#if UE_SLATE_WITH_DYNAMIC_INVALIDATION
namespace DynamicInvalidationCVars
{
	void ConsoleVariableEnableDynamicInvalidationChanged(IConsoleVariable*);

	static int32 DynamicInvalidationOptions = 0;
	static FAutoConsoleVariableRef CVarDynamicInvalidationOptions(
		TEXT("Slate.DynamicInvalidation.Options"),
		DynamicInvalidationOptions,
		TEXT("Toggle Dynamic Invalidation options for Invalidation Panels.\n")
		TEXT(" A Dynamic Invalidation Panel refers to an Invalidation Panel with bUseDynamicInvalidation set to true.\n")
		TEXT(" 0. Disable Dynamic Invalidation and disable caching for all Dynamic Invalidation Panels\n")
		TEXT(" 1. Disable Dynamic Invalidation and makes the Dynamic Invalidation Panels act like regular Invalidation Panels\n")
		TEXT(" 2. Enable Dynamic Invalidation for Dynamic Invalidation Panels\n")
		TEXT(" 3. Forces Dynamic Invalidation on all Invalidation Panels"),
	FConsoleVariableDelegate::CreateStatic(ConsoleVariableEnableDynamicInvalidationChanged)
	);

	void ConsoleVariableEnableDynamicInvalidationChanged(IConsoleVariable*)
	{
		DynamicInvalidationOptions = FMath::Clamp(DynamicInvalidationOptions, 0, 4);
#if UE_SLATE_TRACE_ENABLED
		const FString Description = DynamicInvalidationOptions == 0 ? TEXT("Disabled") :
			DynamicInvalidationOptions == 1 ? TEXT("Disabled: forced Static") :
			DynamicInvalidationOptions == 2 ? TEXT("Enabled") :
			DynamicInvalidationOptions == 3 ? TEXT("Forced") : TEXT("Unknown");

		UE_TRACE_SLATE_BOOKMARK(TEXT("Dynamic Invalidation changed [%d]: %s"), DynamicInvalidationOptions, *Description)
#endif // UE_SLATE_TRACE_ENABLED
	}
}
#endif


SLATE_IMPLEMENT_WIDGET(SInvalidationPanel)
void SInvalidationPanel::PrivateRegisterAttributes(FSlateAttributeInitializer& AttributeInitializer) {}

SInvalidationPanel::SInvalidationPanel()
	: HittestGrid(MakeShared<FHittestGrid>())
	, bCanCache(true)
#if UE_SLATE_WITH_DYNAMIC_INVALIDATION
	, bUseDynamicInvalidation(false)
#endif
	, bPaintedSinceLastPrepass(true)
	, bWasCachable(false)
{
	bHasCustomPrepass = true;
	SetInvalidationRootWidget(*this);
	SetInvalidationRootHittestGrid(HittestGrid.Get());
	SetCanTick(false);
	SetVolatilePrepass(GetCanCache());

	LastIncomingColorAndOpacity = FLinearColor::White;

	FSlateApplicationBase::Get().OnGlobalInvalidationToggled().AddRaw(this, &SInvalidationPanel::OnGlobalInvalidationToggled);
}

void SInvalidationPanel::Construct( const FArguments& InArgs )
{
	ChildSlot
	[
		InArgs._Content.Widget
	];

#if UE_SLATE_WITH_DYNAMIC_INVALIDATION
	bUseDynamicInvalidation = InArgs._UseDynamicInvalidation;
#endif

#if SLATE_VERBOSE_NAMED_EVENTS
	DebugName = InArgs._DebugName;
	DebugTickName = InArgs._DebugName + TEXT("_Tick");
	DebugPaintName = InArgs._DebugName + TEXT("_Paint");
#endif
}

FChildren* SInvalidationPanel::GetAllChildren()
{
	// The default implementation would call SInvalidationPanel::GetChildren which is always empty if we can cache
	return SCompoundWidget::GetChildren();
}

SInvalidationPanel::~SInvalidationPanel()
{
	InvalidateRootChildOrder();

	if (FSlateApplicationBase::IsInitialized())
	{
		FSlateApplicationBase::Get().OnGlobalInvalidationToggled().RemoveAll(this);
	}
}

void ConsoleVariableEnableInvalidationPanelsChanged(IConsoleVariable*)
{
	// If the cache changed, the parent's InvalidationRoot need to rebuild its list
	//since InvalidationPanel cannot be nested in regular mode.
	if (!GSlateEnableGlobalInvalidation)
	{
		FSlateApplicationBase::Get().OnGlobalInvalidationToggled().Broadcast(GSlateEnableGlobalInvalidation);
	}
}

#if WITH_SLATE_DEBUGGING
bool SInvalidationPanel::AreInvalidationPanelsEnabled()
{
	return bInvalidationPanelsEnabled;
}

void SInvalidationPanel::EnableInvalidationPanels(bool bEnable)
{
	if (bInvalidationPanelsEnabled != bEnable)
	{
		bInvalidationPanelsEnabled = bEnable;

		// If the cache changed, the parent's InvalidationRoot need to rebuild its list
		//since InvalidationPanel cannot be nested in regular mode.
		if (!GSlateEnableGlobalInvalidation)
		{
			FSlateApplicationBase::Get().OnGlobalInvalidationToggled().Broadcast(GSlateEnableGlobalInvalidation);
		}
	}
}
#endif

bool SInvalidationPanel::GetCanCache() const
{
#if UE_SLATE_WITH_DYNAMIC_INVALIDATION
	const bool bForcedDynamicInvalidation = DynamicInvalidationCVars::DynamicInvalidationOptions == 3;
	const bool bDynamicInvalidationEnabled = bForcedDynamicInvalidation || (bUseDynamicInvalidation && DynamicInvalidationCVars::DynamicInvalidationOptions == 2);
	if (!bDynamicInvalidationEnabled)
	{
		const bool bRevertToRegularInvalidation = !bUseDynamicInvalidation || DynamicInvalidationCVars::DynamicInvalidationOptions == 1;
		if (!bRevertToRegularInvalidation)
		{
			return false;
		}
	}
#endif
	return bCanCache && !GSlateEnableGlobalInvalidation && bInvalidationPanelsEnabled;
}

void SInvalidationPanel::OnGlobalInvalidationToggled(bool bGlobalInvalidationEnabled)
{
	InvalidateRootChildOrder();
	ClearAllFastPathData(true);
	SetVolatilePrepass(GetCanCache());
	Invalidate(EInvalidateWidgetReason::LayoutAndVolatility);
}

bool SInvalidationPanel::UpdateCachePrequisites(FSlateWindowElementList& OutDrawElements, const FGeometry& AllottedGeometry, const FSlateRect& MyCullingRect, int32 LayerId, const FWidgetStyle& InWidgetStyle) const
{
	bool bNeedsRecache = false;

#if WITH_SLATE_DEBUGGING
	bNeedsRecache = bAlwaysInvalidate;
#endif

	// We only need to re-cache if the incoming layer is higher than the maximum layer Id we cached at,
	// we do this so that widgets that appear and live behind your invalidated UI don't constantly invalidate
	// everything above it.
	if (LayerId > LastIncomingLayerId)
	{
		LastIncomingLayerId = LayerId;
		bNeedsRecache = true;
	}

	if ( AllottedGeometry.GetLocalSize() != LastAllottedGeometry.GetLocalSize() || AllottedGeometry.GetAccumulatedRenderTransform() != LastAllottedGeometry.GetAccumulatedRenderTransform() )
	{
		LastAllottedGeometry = AllottedGeometry;
		bNeedsRecache = true;
	}

	// If our clip rect changes size, we've definitely got to invalidate.
	const FVector2D ClipRectSize = MyCullingRect.GetSize().RoundToVector();
	if ( ClipRectSize != LastClipRectSize )
	{
		LastClipRectSize = ClipRectSize;
		bNeedsRecache = true;
	}

	TOptional<FSlateClippingState> ClippingState = OutDrawElements.GetClippingState();
	if (LastClippingState != ClippingState)
	{
		LastClippingState = ClippingState;
		bNeedsRecache = true;
	}

	if (LastIncomingColorAndOpacity != InWidgetStyle.GetColorAndOpacityTint())
	{
		LastIncomingColorAndOpacity = InWidgetStyle.GetColorAndOpacityTint();
		bNeedsRecache = true;
	}
	
	return bNeedsRecache;
}

void SInvalidationPanel::SetCanCache(bool InCanCache)
{
	if (bCanCache != InCanCache)
	{
		bCanCache = InCanCache;
		SetVolatilePrepass(GetCanCache());
		InvalidateRootChildOrder();
	}
}

#if UE_SLATE_WITH_DYNAMIC_INVALIDATION
bool SInvalidationPanel::GetUseDynamicInvalidation() const
{
	return bUseDynamicInvalidation;
}

void SInvalidationPanel::SetUseDynamicInvalidation(bool InUseDynamicInvalidation)
{
	bUseDynamicInvalidation = InUseDynamicInvalidation;
	
	// Make sure we update the cached value
	const bool bUseCachedValue = false;
	SupportsInvalidationRecursive(bUseCachedValue);
}
#endif

FChildren* SInvalidationPanel::GetChildren()
{
	if (GetCanCache())
	{
		return &FNoChildren::NoChildrenInstance;
	}
	else
	{
		return SCompoundWidget::GetChildren();
	}
}

#if WITH_SLATE_DEBUGGING
FChildren* SInvalidationPanel::Debug_GetChildrenForReflector()
{
	return SCompoundWidget::GetChildren();
}
#endif

#if UE_SLATE_WITH_DYNAMIC_INVALIDATION
bool SInvalidationPanel::SupportsInvalidationRecursive(bool bUseCachedValue) const
{
	const bool bForcedDynamicInvalidation = DynamicInvalidationCVars::DynamicInvalidationOptions == 3;
	const bool bDynamicInvalidationEnabled = bForcedDynamicInvalidation || (bUseDynamicInvalidation && DynamicInvalidationCVars::DynamicInvalidationOptions == 2);
	// For an invalidation panel without bUseDynamicInvalidation, we force the caching of all children, so we always support invalidation
	return !bDynamicInvalidationEnabled || SWidget::SupportsInvalidationRecursive(bUseCachedValue);
}
#endif

int32 SInvalidationPanel::OnPaint( const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyCullingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
#if SLATE_VERBOSE_NAMED_EVENTS
	SCOPED_NAMED_EVENT_FSTRING(DebugPaintName, FColor::Purple);
#endif
	SCOPE_CYCLE_COUNTER(STAT_SlateInvalidationPaint);

	bPaintedSinceLastPrepass = true;
	SInvalidationPanel* MutableThis = const_cast<SInvalidationPanel*>(this);

#if UE_SLATE_WITH_DYNAMIC_INVALIDATION
	const bool bCanCacheThisFrame = GetCanCache() && SupportsInvalidationRecursive();
#else
	const bool bCanCacheThisFrame = GetCanCache();
#endif
	if (bCanCacheThisFrame != bWasCachable)
	{
		MutableThis->InvalidateRootChildOrder();

		bWasCachable = bCanCacheThisFrame;
	}

	if(bCanCacheThisFrame)
	{
		// Copy hit test grid settings from the root
		const bool bHittestCleared = HittestGrid->SetHittestArea(Args.RootGrid.GetGridOrigin(), Args.RootGrid.GetGridSize(), Args.RootGrid.GetGridWindowOrigin());
		HittestGrid->SetOwner(this);
		HittestGrid->SetCullingRect(MyCullingRect);
		FPaintArgs NewArgs = Args.WithNewHitTestGrid(HittestGrid.Get());

		// Copy the current user index into the new grid since nested hit test grids should inherit their parents user id
		NewArgs.GetHittestGrid().SetUserIndex(Args.RootGrid.GetUserIndex());
		check(!GSlateEnableGlobalInvalidation);

		const bool bRequiresRecache = UpdateCachePrequisites(OutDrawElements, AllottedGeometry, MyCullingRect, LayerId, InWidgetStyle);
		if (bHittestCleared || bRequiresRecache)
		{
			// @todo: Overly aggressive?
			MutableThis->InvalidateRootLayout(this);
		}

		// The root widget is our child.  We are not the root because we could be in a parent invalidation panel.  If we are nested in another invalidation panel, our OnPaint was called by that panel
		FSlateInvalidationContext Context(OutDrawElements, InWidgetStyle);
		Context.bParentEnabled = bParentEnabled;
		Context.bAllowFastPathUpdate = true;
		Context.LayoutScaleMultiplier = GetPrepassLayoutScaleMultiplier();
		Context.PaintArgs = &NewArgs;
		Context.IncomingLayerId = LayerId;
		Context.CullingRect = MyCullingRect;

		const FSlateInvalidationResult Result = MutableThis->PaintInvalidationRoot(Context);

		const bool bInheritedHittestability = Args.GetInheritedHittestability();
		const bool bOutgoingHittestability = bInheritedHittestability && GetVisibility().AreChildrenHitTestVisible();

		// add our widgets to the root hit test grid
		if (bOutgoingHittestability)
		{
			Args.GetHittestGrid().AddGrid(HittestGrid);
		}
		return Result.MaxLayerIdPainted;
	}
	else
	{
#if SLATE_VERBOSE_NAMED_EVENTS
		SCOPED_NAMED_EVENT_TEXT("SInvalidationPanel Uncached", FColor::Emerald);
#endif
		return SCompoundWidget::OnPaint(Args, AllottedGeometry, MyCullingRect, OutDrawElements, LayerId, InWidgetStyle, bParentEnabled);
	}
}

void SInvalidationPanel::SetContent(const TSharedRef< SWidget >& InContent)
{
	ChildSlot
	[
		InContent
	];

	InvalidateRootChildOrder();
}

bool SInvalidationPanel::CustomPrepass(float LayoutScaleMultiplier)
{
	bPaintedSinceLastPrepass = false;

	if (GetCanCache())
	{
		if (NeedsPrepass())
		{
			SetNeedsSlowPath(true);
		}
		ProcessInvalidation();
		if (NeedsSlowPath())
		{
			FChildren* Children = SCompoundWidget::GetChildren();
			Prepass_ChildLoop(LayoutScaleMultiplier, Children);
		}
		return false;
	}
	else
	{
		return true;
	}
}

bool SInvalidationPanel::Advanced_IsInvalidationRoot() const
{
	return GetCanCache();
}

const FSlateInvalidationRoot* SInvalidationPanel::Advanced_AsInvalidationRoot() const
{
	return GetCanCache() ? this : nullptr;
}

TSharedRef<SWidget> SInvalidationPanel::GetRootWidget()
{
	return GetCanCache() ? SCompoundWidget::GetChildren()->GetChildAt(0) : SNullWidget::NullWidget;
}

int32 SInvalidationPanel::PaintSlowPath(const FSlateInvalidationContext& Context)
{
	return SCompoundWidget::OnPaint(*Context.PaintArgs, GetPaintSpaceGeometry(), Context.CullingRect, *Context.WindowElementList, Context.IncomingLayerId, Context.WidgetStyle, Context.bParentEnabled);
}