// Fill out your copyright notice in the Description page of Project Settings.

#include "Game/ShooterGameMode.h"
#include "GenericPlatform/GenericPlatformMisc.h"
#include "Containers/UnrealString.h"
#include "GameLiftClpTypes.h"
#include "GameLift/GameLiftClp.h"
#include "openssl/sha.h"



DEFINE_LOG_CATEGORY(LogShooterGameMode);

//  Function implementations.

AShooterGameMode::AShooterGameMode()
{
}

void AShooterGameMode::BeginPlay()
{
	Super::BeginPlay();
#if WITH_GAMELIFT
	InitGameLift();
#endif
}

void AShooterGameMode::InitGame(const FString& MapName, const FString& Options, FString& ErrorMessage)
{
	Super::InitGame(MapName, Options, ErrorMessage);
	CachedCommandLine = FCommandLine::Get();
	GameLiftConfig.ServerPort = cmdlineparser::details::GetConfiguredOrDefaultPort(CachedCommandLine, TEXT("port"));
	if (FParse::Param(*CachedCommandLine, TEXT("glAnywhereFleet")))
	{
		UE_LOGFMT(LogShooterGameMode, Log, "Fleet type: Anywhere");
		GameLiftConfig.bAllOptionsFound = GetAnywhereFleetParameters(CachedCommandLine);
		LogAnywhereFleetParameters();
	}
	else
	{
		UE_LOGFMT(LogShooterGameMode, Log, "Fleet type: EC2");
		// TODO: EC2 configuration
	}
}

FString AShooterGameMode::GetSHA256Hash(const FString& InString)
{
	
	if (InString.IsEmpty()) 
		return TEXT("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855");

	FSHA256Signature Hash;
	
	// Use OpenSSL to compute the SHA-256 hash
	
	FTCHARToUTF8 Utf8(InString);
	const uint8* Bytes = reinterpret_cast<const uint8*>(Utf8.Get());
	uint32 Length = Utf8.Length() * sizeof(UTF8CHAR);
	
	
	SHA256_CTX Sha256Context;
	SHA256_Init(&Sha256Context);
	SHA256_Update(&Sha256Context, Bytes,Length);
	SHA256_Final(Hash.Signature, &Sha256Context);
	
	return Hash.ToString();
}

void AShooterGameMode::InitGameLift()
{
}

bool AShooterGameMode::GetAnywhereFleetParameters(const FString& CommandLineString)
{
	bool bAllAnywhereFleetParametersValid = true;
	GameLiftConfig.AuthTokenResult = cmdlineparser::GetValueOfToken(CommandLineString, cmdlineparser::details::EAvailableTokens::AuthToken);
	if (!GameLiftConfig.AuthTokenResult.bIsValid) bAllAnywhereFleetParametersValid = false;
	
	GameLiftConfig.FleetIdResult = cmdlineparser::GetValueOfToken(CommandLineString, cmdlineparser::details::EAvailableTokens::FleetId);
	if (!GameLiftConfig.FleetIdResult.bIsValid) bAllAnywhereFleetParametersValid = false;
	
	GameLiftConfig.HostIdResult = cmdlineparser::GetValueOfToken(CommandLineString, cmdlineparser::details::EAvailableTokens::HostId);
	if (!GameLiftConfig.HostIdResult.bIsValid) bAllAnywhereFleetParametersValid = false;

	GameLiftConfig.WebSocketUrlResult = cmdlineparser::GetValueOfToken(CommandLineString, cmdlineparser::details::EAvailableTokens::WebsocketUrl);
	if (!GameLiftConfig.WebSocketUrlResult.bIsValid) bAllAnywhereFleetParametersValid = false;
	
	return bAllAnywhereFleetParametersValid;
}

void AShooterGameMode::LogAnywhereFleetParameters()
{
	// Lambda for getting the token name from token
	auto GetTokenName = [](const cmdlineparser::details::FParseResult& Result) -> FString
	{
		return cmdlineparser::details::CLI_TOKENS[static_cast<int32>(Result.Token)];
	};
	
#if UE_BUILD_DEBUG
	const FString AuthDisplay = GameLiftConfig.AuthTokenResult.Value;
#else
	const FString AuthDisplay = TEXT("HASH:") + GetSHA256Hash(GameLiftConfig.AuthTokenResult.Value);
#endif
	
	UE_LOGFMT(LogShooterGameMode, Log, "Anywhere Fleet Parameters:");
	if (GameLiftConfig.AuthTokenResult.bIsValid)
	{
		UE_LOGFMT(LogShooterGameMode, Log, "AuthToken: {0}", AuthDisplay);
	}
	else
	{
		UE_LOGFMT(
			LogShooterGameMode, 
			Error, 
			"AuthToken: {0}", 
			FString::Format(
				*GameLiftConfig.AuthTokenResult.ErrorMessage, 
				{
					FStringFormatArg(GetTokenName(GameLiftConfig.AuthTokenResult)), 
					FStringFormatArg(AuthDisplay)
				}
			)
		);
	}
	
	if (GameLiftConfig.FleetIdResult.bIsValid)
	{
		UE_LOGFMT(LogShooterGameMode, Log, "FleetId: {0}", GameLiftConfig.FleetIdResult.Value);
	}
	else
	{
		UE_LOGFMT(
			LogShooterGameMode, 
			Error, 
			"FleetId: {0}", 
			FString::Format(
				*GameLiftConfig.FleetIdResult.ErrorMessage, 
				{
					FStringFormatArg(GetTokenName(GameLiftConfig.FleetIdResult)), 
					FStringFormatArg(GameLiftConfig.FleetIdResult.Value)
				}
			)
		);
	}
	
	if (GameLiftConfig.HostIdResult.bIsValid)
	{
		UE_LOGFMT(LogShooterGameMode, Log, "HostId: {0}", GameLiftConfig.HostIdResult.Value);
	}
	else
	{
		UE_LOGFMT(
			LogShooterGameMode, 
			Error, 
			"HostId: {0}", 
			FString::Format(
				*GameLiftConfig.HostIdResult.ErrorMessage, 
				{
					FStringFormatArg(GetTokenName(GameLiftConfig.HostIdResult)), 
					FStringFormatArg(GameLiftConfig.HostIdResult.Value)
				}
			)
		);
	}
	
	if (GameLiftConfig.WebSocketUrlResult.bIsValid)
	{
		UE_LOGFMT(LogShooterGameMode, Log, "WebSocketUrl: {0}", GameLiftConfig.WebSocketUrlResult.Value);
	}
	else
	{
		UE_LOGFMT(
			LogShooterGameMode, 
			Error, 
			"WebSocketUrl: {0}", 
			FString::Format(
				*GameLiftConfig.WebSocketUrlResult.ErrorMessage, 
				{
					FStringFormatArg(GetTokenName(GameLiftConfig.WebSocketUrlResult)), 
					FStringFormatArg(GameLiftConfig.WebSocketUrlResult.Value)
				}
			)
		);
	}
	
	UE_LOGFMT(LogShooterGameMode, Log, "Server Port: {0}", GameLiftConfig.ServerPort);
	
	if (GameLiftConfig.bAllOptionsFound)
	{
		UE_LOGFMT(LogShooterGameMode, Log, "Anywhere Fleet Parameters Loaded Successfully....");
	}
	else
	{
		UE_LOGFMT(LogShooterGameMode, Error, "Anywhere Fleet Parameters Load FAILED....");
	}
}