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

#include "SZenStatusBar.h"

#include "Async/Future.h"
#include "Containers/Array.h"
#include "Delegates/Delegate.h"
#include "DerivedDataCacheInterface.h"
#include "IDerivedDataCacheNotifications.h"
#include "ZenEditor.h"
#include "DerivedDataInformation.h"
#include "Framework/Commands/InputChord.h"
#include "Framework/Commands/UIAction.h"
#include "Framework/Commands/UICommandInfo.h"
#include "Framework/Commands/UICommandList.h"
#include "Framework/MultiBox/MultiBoxDefs.h"
#include "Framework/Notifications/NotificationManager.h"
#include "Framework/SlateDelegates.h"
#include "HAL/PlatformCrt.h"
#include "ISettingsModule.h"
#include "Internationalization/Internationalization.h"
#include "Layout/Children.h"
#include "Layout/Margin.h"
#include "Math/Color.h"
#include "Math/UnitConversion.h"
#include "Math/UnrealMathSSE.h"
#include "Misc/Attribute.h"
#include "Misc/CoreMisc.h"
#include "Modules/ModuleManager.h"
#include "SlotBase.h"
#include "Styling/AppStyle.h"
#include "Styling/ISlateStyle.h"
#include "Styling/SlateColor.h"
#include "Styling/SlateTypes.h"
#include "Textures/SlateIcon.h"
#include "ToolMenu.h"
#include "ToolMenuContext.h"
#include "ToolMenuSection.h"
#include "ToolMenus.h"
#include "Types/WidgetActiveTimerDelegate.h"
#include "UObject/NameTypes.h"
#include "UObject/UnrealNames.h"
#include "Widgets/Images/SImage.h"
#include "Widgets/Input/SComboButton.h"
#include "Widgets/Notifications/SNotificationList.h"
#include "Widgets/SBoxPanel.h"
#include "Widgets/SOverlay.h"
#include "Widgets/Text/STextBlock.h"
#include "ZenDashboardLauncher.h"
#include "ZenServiceInstanceManager.h"
#include "Experimental/ZenServerInterface.h"

class SWidget;
struct FSlateBrush;

#define LOCTEXT_NAMESPACE "ZenStatusBar"


TSharedRef<FUICommandList> FZenStausBarCommands::ActionList(new FUICommandList());
TSharedPtr<UE::Zen::FServiceInstanceManager> FZenStausBarCommands::ServiceInstanceManager;

static const FName ZenMenuName(TEXT("ZenStatusBarMenu"));
static const FName ZenMenuServerSectionName(TEXT("ZenStatusBarMenu.ServerSection"));
static const FName ZenMenuStoreSectionName(TEXT("ZenStatusBarMenu.StoreSection"));
static const FName ZenMenuToolsSectionName(TEXT("ZenStatusBarMenu.ToolsSection"));
static const FName ZenMenuCacheSectionName(TEXT("ZenStatusBarMenu.CacheSection"));
static const FName ZenMenuServerActionsSubMenuName(TEXT("ZenStatusBarMenu.ServerActions"));


FZenStausBarCommands::FZenStausBarCommands()
	: TCommands<FZenStausBarCommands>
	(
		"ZenSettings",
		NSLOCTEXT("Contexts", "Zen", "Zen"),
		"LevelEditor",
		FAppStyle::GetAppStyleSetName()
	)
{}

void FZenStausBarCommands::RegisterCommands()
{
	ServiceInstanceManager = MakeShared<UE::Zen::FServiceInstanceManager>();

	UI_COMMAND(ChangeCacheSettings, "Cache Settings", "Opens a dialog to change Cache settings.", EUserInterfaceActionType::Button, FInputChord());
	UI_COMMAND(ViewCacheStatistics, "Cache Statistics", "Opens the Cache Statistics panel.", EUserInterfaceActionType::Button, FInputChord());
	UI_COMMAND(ViewResourceUsage, "Cache Resource Usage", "Opens the Cache Resource Usage panel.", EUserInterfaceActionType::Button, FInputChord());
	UI_COMMAND(ViewServerStatus, "Server Status", "Opens the Zen Server Status panel.", EUserInterfaceActionType::Button, FInputChord());
	UI_COMMAND(ViewZenStore, "View Store", "Opens the Zen Store page in your browser.", EUserInterfaceActionType::Button, FInputChord());
	UI_COMMAND(LaunchZenDashboard, "Launch Dashboard", "Launches the Zen Dashboard utility.", EUserInterfaceActionType::Button, FInputChord());
	UI_COMMAND(StartZenServer, "Start Server", "Starts the Zen Server.", EUserInterfaceActionType::Button, FInputChord());
	UI_COMMAND(StopZenServer, "Stop Server", "Stops the Zen Server.", EUserInterfaceActionType::Button, FInputChord());
	UI_COMMAND(RestartZenServer, "Restart Server", "Restarts the Zen Server.", EUserInterfaceActionType::Button, FInputChord());

	ActionList->MapAction(
		ChangeCacheSettings,
		FExecuteAction::CreateStatic(&FZenStausBarCommands::ChangeCacheSettings_Clicked)
	);

	ActionList->MapAction(
		ViewCacheStatistics,
		FExecuteAction::CreateStatic(&FZenStausBarCommands::ViewCacheStatistics_Clicked)
	);

	ActionList->MapAction(
		ViewResourceUsage,
		FExecuteAction::CreateStatic(&FZenStausBarCommands::ViewResourceUsage_Clicked)
	);

	ActionList->MapAction(
		ViewServerStatus,
		FExecuteAction::CreateStatic(&FZenStausBarCommands::ViewServerStatus_Clicked)
	);

	ActionList->MapAction(
		ViewZenStore,
		FExecuteAction::CreateStatic(&FZenStausBarCommands::ViewZenStore_Clicked)
	);

	ActionList->MapAction(
		LaunchZenDashboard,
		FExecuteAction::CreateStatic(&FZenStausBarCommands::LaunchZenDashboard_Clicked)
	);

	ActionList->MapAction(
		StartZenServer,
		FExecuteAction::CreateStatic(&FZenStausBarCommands::StartZenServer_Clicked)
	);

	ActionList->MapAction(
		StopZenServer,
		FExecuteAction::CreateStatic(&FZenStausBarCommands::StopZenServer_Clicked)
	);

	ActionList->MapAction(
		RestartZenServer,
		FExecuteAction::CreateStatic(&FZenStausBarCommands::RestartZenServer_Clicked)
	);
}

void FZenStausBarCommands::ChangeCacheSettings_Clicked()
{
	FModuleManager::LoadModuleChecked<ISettingsModule>("Settings").ShowViewer("Editor", "General", "Global");
}

void FZenStausBarCommands::ViewCacheStatistics_Clicked()
{
	FZenEditor& ZenEditor = FModuleManager::LoadModuleChecked<FZenEditor>("ZenEditor");
	ZenEditor.ShowCacheStatisticsTab();
}

void FZenStausBarCommands::ViewResourceUsage_Clicked()
{
	FZenEditor& ZenEditor = FModuleManager::LoadModuleChecked<FZenEditor>("ZenEditor");
	ZenEditor.ShowResourceUsageTab();
}

void FZenStausBarCommands::ViewServerStatus_Clicked()
{
	FZenEditor& ZenEditor = FModuleManager::LoadModuleChecked<FZenEditor>("ZenEditor");
	ZenEditor.ShowZenServerStatusTab();
}

void FZenStausBarCommands::StartZenServer_Clicked()
{
	FZenEditor& ZenEditor = FModuleManager::LoadModuleChecked<FZenEditor>("ZenEditor");
	ZenEditor.StartZenServer();
}

void FZenStausBarCommands::StopZenServer_Clicked()
{
	FZenEditor& ZenEditor = FModuleManager::LoadModuleChecked<FZenEditor>("ZenEditor");
	ZenEditor.StopZenServer();
}

void FZenStausBarCommands::RestartZenServer_Clicked()
{
	FZenEditor& ZenEditor = FModuleManager::LoadModuleChecked<FZenEditor>("ZenEditor");
	ZenEditor.RestartZenServer();
}

void FZenStausBarCommands::ViewZenStore_Clicked()
{
	using namespace UE::Zen;
	TSharedPtr<FZenServiceInstance> ServerInstance = ServiceInstanceManager.Get()->GetZenServiceInstance();

	if (ServerInstance.IsValid())
	{
		FString URL = ServerInstance->GetEndpoint().GetURL();
		FPlatformProcess::LaunchURL(*FString::Printf(TEXT("%s/dashboard/?"), *URL), nullptr, nullptr);
	}
}

void FZenStausBarCommands::LaunchZenDashboard_Clicked()
{
	using namespace UE::Zen;
	FZenDashboardLauncher::Get()->StartZenDashboard(FZenDashboardLauncher::Get()->GetZenDashboardApplicationPath());
}


TSharedRef<SWidget> SZenStatusBarWidget::CreateStatusBarMenu()
{
	UToolMenu* Menu = UToolMenus::Get()->RegisterMenu(ZenMenuName, NAME_None, EMultiBoxType::Menu, false);

	{
		FToolMenuSection& Section = Menu->AddSection(ZenMenuToolsSectionName, LOCTEXT("ZenMenuToolsSection", "Tools"));

		Section.AddMenuEntry(
			FZenStausBarCommands::Get().LaunchZenDashboard,
			TAttribute<FText>(),
			TAttribute<FText>(),
			FSlateIcon(FAppStyle::GetAppStyleSetName(), "Zen.Dashboard.Icon")
		);
	}

	{
		FToolMenuSection& Section = Menu->AddSection(ZenMenuServerSectionName, LOCTEXT("ZenMenuServerSection", "Server"));

		Section.AddMenuEntry(
			FZenStausBarCommands::Get().ViewServerStatus,
			TAttribute<FText>(),
			TAttribute<FText>(),
			FSlateIcon(FAppStyle::GetAppStyleSetName(), "Zen.Server")
		);

		{
			Section.AddSubMenu(TEXT("ZenServerActionSubMenu"), LOCTEXT("ZenServerActions", "Server Actions"), LOCTEXT("ZenServerActionsSubMenu", "Server Actions"),
				FNewToolMenuDelegate::CreateLambda([this](UToolMenu* InSubMenu)
					{
						using namespace UE::Zen;
						TSharedPtr<FZenServiceInstance> ServerInstance = ServiceInstanceManager.Get()->GetZenServiceInstance();
						FToolMenuSection& Section = InSubMenu->AddSection(NAME_None);
						
						if (ServerInstance.IsValid() && ServerInstance->IsServiceRunning())
						{
							Section.AddMenuEntry(
								FZenStausBarCommands::Get().StopZenServer,
								TAttribute<FText>(),
								TAttribute<FText>(),
								FSlateIcon(FAppStyle::GetAppStyleSetName(), "Zen.Server.Stop")
							);

							Section.AddMenuEntry(
								FZenStausBarCommands::Get().RestartZenServer,
								TAttribute<FText>(),
								TAttribute<FText>(),
								FSlateIcon(FAppStyle::GetAppStyleSetName(), "Zen.Server.Restart")
							);
						}
						else
						{
							Section.AddMenuEntry(
								FZenStausBarCommands::Get().StartZenServer,
								TAttribute<FText>(),
								TAttribute<FText>(),
								FSlateIcon(FAppStyle::GetAppStyleSetName(), "Zen.Server.Start")
							);
						}
					}));
		}
	}

	{
		FToolMenuSection& Section = Menu->AddSection(ZenMenuStoreSectionName, LOCTEXT("ZenMenuStoreSection", "Store"));

		Section.AddMenuEntry(
			FZenStausBarCommands::Get().ViewZenStore,
			TAttribute<FText>(),
			TAttribute<FText>(),
			FSlateIcon(FAppStyle::GetAppStyleSetName(), "Zen.Store")
		);
	}

	{
		FToolMenuSection& Section = Menu->AddSection(ZenMenuCacheSectionName, LOCTEXT("ZenMenuDerivedDataSection", "Cache"));

		Section.AddMenuEntry(
			FZenStausBarCommands::Get().ViewCacheStatistics,
			TAttribute<FText>(),
			TAttribute<FText>(),
			FSlateIcon(FAppStyle::GetAppStyleSetName(), "DerivedData.Cache.Statistics")
		);
	
		Section.AddMenuEntry(
			FZenStausBarCommands::Get().ViewResourceUsage,
			TAttribute<FText>(),
			TAttribute<FText>(),
			FSlateIcon(FAppStyle::GetAppStyleSetName(), "DerivedData.ResourceUsage")
		);

		Section.AddMenuEntry(
			FZenStausBarCommands::Get().ChangeCacheSettings,
			TAttribute<FText>(),
			TAttribute<FText>(),
			FSlateIcon(FAppStyle::GetAppStyleSetName(), "DerivedData.Cache.Settings")
		);
	}

	return UToolMenus::Get()->GenerateWidget(ZenMenuName, FToolMenuContext(FZenStausBarCommands::ActionList));
}

void SZenStatusBarWidget::Construct(const FArguments& InArgs)
{	
	ServiceInstanceManager = MakeShared<UE::Zen::FServiceInstanceManager>();

	this->ChildSlot
	[
		SNew(SComboButton)
		.ContentPadding(FMargin(6.0f, 0.0f))
		.MenuPlacement(MenuPlacement_AboveAnchor)
		.ComboButtonStyle(&FAppStyle::Get().GetWidgetStyle<FComboButtonStyle>("SimpleComboButton"))
		.ButtonContent()
		[

			SNew(SHorizontalBox)
	
			+ SHorizontalBox::Slot()
			.AutoWidth()
			.VAlign(VAlign_Center)
			.Padding(0, 0, 3, 0)
			[
				SNew(SOverlay)
				+ SOverlay::Slot()
				.HAlign(HAlign_Center)
				.VAlign(VAlign_Top)
				[
					SNew(SImage)
					.ColorAndOpacity(FSlateColor::UseForeground())
					.Image_Lambda([this] { return GetServerStateBackgroundIcon();  })
					.ToolTipText_Lambda([this] { return GetServerStateToolTipText(); })
				]

				+ SOverlay::Slot()
				.HAlign(HAlign_Center)
				.VAlign(VAlign_Top)
				[
					SNew(SImage)
					.ColorAndOpacity(FSlateColor::UseForeground())
					.Image_Lambda([this] { return GetServerStateBadgeIcon();  })
					.ToolTipText_Lambda([this] { return GetServerStateToolTipText(); })
				]

				+ SOverlay::Slot()
				.HAlign(HAlign_Center)
				.VAlign(VAlign_Top)
				[
					SNew(SImage)
					.Image(FAppStyle::Get().GetBrush("Zen.Status.Uploading"))
					.ColorAndOpacity_Lambda([this] { return IsUploading? FLinearColor::White.CopyWithNewOpacity(FMath::MakePulsatingValue(ElapsedUploadTime, 2)) : FLinearColor(0,0,0,0); })
					.ToolTipText_Lambda([this] { return GetServerStateToolTipText(); })
				]

				+ SOverlay::Slot()
				.HAlign(HAlign_Center)
				.VAlign(VAlign_Top)
				[
					SNew(SImage)
					.Image(FAppStyle::Get().GetBrush("Zen.Status.Downloading"))
					.ColorAndOpacity_Lambda([this] { return IsDownloading ? FLinearColor::White.CopyWithNewOpacity(FMath::MakePulsatingValue(ElapsedDownloadTime, 2)) : FLinearColor(0, 0, 0, 0); })
					.ToolTipText_Lambda([this] { return GetServerStateToolTipText(); })
				]				
			]

			+ SHorizontalBox::Slot()
			.AutoWidth()
			.VAlign(VAlign_Center)
			.Padding(0, 0, 10, 0)
			[
				SNew(STextBlock)
				.Text_Lambda([this] { return GetTitleText(); })
				.ToolTipText_Lambda([this] { return GetTitleToolTipText(); })
			]
		]
		.OnGetMenuContent(FOnGetContent::CreateRaw(this, &SZenStatusBarWidget::CreateStatusBarMenu))
	];

	RegisterActiveTimer(0.2f, FWidgetActiveTimerDelegate::CreateSP(this, &SZenStatusBarWidget::UpdateBusyIndicator));
	RegisterActiveTimer(5.0f, FWidgetActiveTimerDelegate::CreateSP(this, &SZenStatusBarWidget::UpdateWarnings));
}

EActiveTimerReturnType SZenStatusBarWidget::UpdateBusyIndicator(double InCurrentTime, float InDeltaTime)
{	
	using namespace UE::Zen;
	TSharedPtr<FZenServiceInstance> ServerInstance = ServiceInstanceManager.Get()->GetZenServiceInstance();

	static int64 LastTotalHits=0;
	static int64 LastTotalReads=0;
	static int64 LastTotalWrites=0;

	if (ServerInstance.IsValid() && ServerInstance->IsServiceRunning())
	{
		FZenCacheStats CacheStats;
		ServerInstance->GetCacheStats(CacheStats);

		FZenProjectStats ProjectStats;
		ServerInstance->GetProjectStats(ProjectStats);

		const int64 TotalCacheHits = CacheStats.General.Hits + CacheStats.General.CidHits;
		const int64 TotalCacheWrites = CacheStats.General.Writes + CacheStats.General.CidWrites;
		const int64 TotalProjectReads = ProjectStats.General.Project.ReadCount + ProjectStats.General.Oplog.ReadCount;
		const int64 TotalProjectWrites = ProjectStats.General.Project.ReadCount + ProjectStats.General.Oplog.ReadCount;

		const int64 TotalHits = TotalCacheHits;
		const int64 TotalReads = TotalProjectReads;
		const int64 TotalWrites = TotalCacheWrites + TotalProjectWrites;
			
		IsRunning = true;
		IsDownloading = CacheStats.Upstream.Reading;
		IsUploading = CacheStats.Upstream.Writing;
		IsReading = TotalReads > LastTotalReads;
		IsWriting = TotalWrites > LastTotalWrites;

		LastTotalHits = TotalHits;
		LastTotalReads = TotalReads;
		LastTotalWrites = TotalWrites;
	}
	else
	{
		IsRunning = false;
		IsDownloading = false;
		IsUploading = false;
		IsReading = false;
		IsWriting = false;

		LastTotalHits = 0;
		LastTotalReads = 0;
		LastTotalWrites = 0;
	}

	IsBusy = IsUploading || IsDownloading || IsReading || IsWriting;

	FDerivedDataInformation::UpdateRemoteCacheState();

	IsBusy			= GetDerivedDataCache()->AnyAsyncRequestsRemaining();
	IsUploading		= FDerivedDataInformation::IsUploading() && FDerivedDataInformation::GetRemoteCacheState() == ERemoteCacheState::Busy;
	IsDownloading	= FDerivedDataInformation::IsDownloading() && FDerivedDataInformation::GetRemoteCacheState() == ERemoteCacheState::Busy;

	if (IsUploading)
	{
		ElapsedUploadTime += fmod(InDeltaTime,3600.0);
	}
	else
	{
		ElapsedUploadTime = 0.0;
	}

	if (IsDownloading)
	{
		ElapsedDownloadTime += fmod(InDeltaTime, 3600.0);
	}
	else
	{
		ElapsedDownloadTime = 0.0;
	}

	if (IsBusy)
	{
		ElapsedBusyTime += fmod(InDeltaTime, 3600.0);
	}
	else
	{
		ElapsedBusyTime = 0;
	}

	return EActiveTimerReturnType::Continue;
}

EActiveTimerReturnType SZenStatusBarWidget::UpdateWarnings(double InCurrentTime, float InDeltaTime)
{
	if ( FDerivedDataInformation::GetRemoteCacheState()== ERemoteCacheState::Warning )
	{
		if ( NotificationItem.IsValid() == false || NotificationItem->GetCompletionState()== SNotificationItem::CS_None)
		{
			// No existing notification or the existing one has finished
			TPromise<TWeakPtr<SNotificationItem>> NotificationPromise;

			FNotificationInfo Info(FDerivedDataInformation::GetRemoteCacheWarningMessage());
			Info.bUseSuccessFailIcons = true;
			Info.bFireAndForget = false;
			Info.bUseThrobber = false;
			Info.FadeOutDuration = 0.0f;
			Info.ExpireDuration = 0.0f;

			Info.ButtonDetails.Add(FNotificationButtonInfo(LOCTEXT("OpenSettings", "Open Settings"), FText(), FSimpleDelegate::CreateLambda([NotificationFuture = NotificationPromise.GetFuture().Share()]() {
				FModuleManager::LoadModuleChecked<ISettingsModule>("Settings").ShowViewer("Editor", "General", "Global");

				TWeakPtr<SNotificationItem> NotificationPtr = NotificationFuture.Get();
				if (TSharedPtr<SNotificationItem> Notification = NotificationPtr.Pin())
				{
					Notification->SetCompletionState(SNotificationItem::CS_None);
					Notification->ExpireAndFadeout();
				}
			}),
				SNotificationItem::ECompletionState::CS_Fail));

			NotificationItem = FSlateNotificationManager::Get().AddNotification(Info);

			if (NotificationItem.IsValid())
			{
				NotificationPromise.SetValue(NotificationItem);
				NotificationItem->SetCompletionState(SNotificationItem::CS_Fail);
			}
		}
	}
	else
	{
		// No longer any warnings
		if (NotificationItem.IsValid())
		{
			NotificationItem->SetCompletionState(SNotificationItem::CS_None);
			NotificationItem->ExpireAndFadeout();
		}
	}

	return EActiveTimerReturnType::Continue;
}

FText SZenStatusBarWidget::GetTitleToolTipText() const
{
	return GetServerStateToolTipText();
}

FText SZenStatusBarWidget::GetTitleText() const
{
	return LOCTEXT("ZenStatusBarName", "Zen Server");
}

FText SZenStatusBarWidget::GetServerStateToolTipText() const
{
	FTextBuilder DescBuilder;
	
	if (IsRunning)
	{
		DescBuilder.AppendLineFormat(LOCTEXT("ZenServerStaus", "{0}"), FText::FromString(IsBusy ? TEXT("Busy") : TEXT("Idle")));
	}
	else
	{
		DescBuilder.AppendLineFormat(LOCTEXT("ZenServerStaus", "{0}"), FText::FromString(TEXT("Stopped")));
	}

	return DescBuilder.ToText();
}

const FSlateBrush* SZenStatusBarWidget::GetServerStateBackgroundIcon() const
{
	if (IsRunning)
	{
		return IsBusy ? FAppStyle::Get().GetBrush("Zen.Status.BusyBG") : FAppStyle::Get().GetBrush("Zen.Status.IdleBG");
	}

	return FAppStyle::Get().GetBrush("Zen.Status.UnavailableBG");
}

const FSlateBrush* SZenStatusBarWidget::GetServerStateBadgeIcon() const
{
	if (IsRunning)
	{
		return IsBusy ? FAppStyle::Get().GetBrush("Zen.Status.Busy") : FAppStyle::Get().GetBrush("Zen.Status.Idle");
	}

	return FAppStyle::Get().GetBrush("Zen.Status.Unavailable");
}


#undef LOCTEXT_NAMESPACE