#include "TheLegendsOfArthurInstance.h"
#include "Engine/Engine.h"
#include "UObject/ConstructorHelpers.h"
#include "Blueprint/UserWidget.h"

#include "OnlineSessionSettings.h"

#include "PlatFormTrigger.h"
#include "Widgets/Login.h"
#include "Widgets/LoginWidget.h"

const static FName SESSION_NAME = TEXT("Game");
const static FName SERVER_NAME_SETTINGS_KEY = TEXT("ServerName");

UTheLegendsOfArthurInstance::UTheLegendsOfArthurInstance(const FObjectInitializer & ObjectInitializer)
{
	ConstructorHelpers::FClassFinder<UUserWidget>LoginBPClass(TEXT("/Game/Assets/widgets/Menu/WDBP_Login"));
	if (!ensure(LoginBPClass.Class != nullptr)) return;

	LoginClass = LoginBPClass.Class;

	ConstructorHelpers::FClassFinder<UUserWidget>IngameMenuBPClass(TEXT("/Game/Assets/widgets/Menu/ExitOptions"));
	if (!ensure(IngameMenuBPClass.Class != nullptr)) return;

	IngameMenuClass = IngameMenuBPClass.Class;
}

void UTheLegendsOfArthurInstance::Init()
{
	Super::Init();
	GSObj = NewObject<UGameSparksObject>(GetWorld(), UGameSparksObject::StaticClass());
	if (!ensure(GSObj != nullptr)) return;
	GSMessageListener = NewObject<UGSMessageListenersObject>(GetWorld(), UGSMessageListenersObject::StaticClass());
	if (!ensure(GSMessageListener != nullptr)) return;
	if (GSObj != nullptr) {



		//Set a listener for OnScriptMessage
		GSMessageListener->OnScriptMessage.AddDynamic(this, &UTheLegendsOfArthurInstance::onScriptMessage);

		//Set the OnAvailable delegate
		GSObj->OnGameSparksAvailableDelegate.AddDynamic(this, &UTheLegendsOfArthurInstance::onAvailable);
		//Disconnected the module just incase it's connected (Refresh)
		GSObj->Disconnect();
		//Connect module
		GSObj->Connect("","", true, false);

	}
	IOnlineSubsystem* SubSystem=IOnlineSubsystem::Get();
	if(SubSystem!=nullptr){
		UE_LOG(LogTemp, Warning, TEXT("Found Substem %s"), *SubSystem->GetSubsystemName().ToString());
 SessionInterface=SubSystem->GetSessionInterface();
 if (SessionInterface.IsValid())
 {

 SessionInterface->OnCreateSessionCompleteDelegates.AddUObject(this, &UTheLegendsOfArthurInstance::OnCreateSessionComplete);
 SessionInterface->OnDestroySessionCompleteDelegates.AddUObject(this, &UTheLegendsOfArthurInstance::OnCreateSessionComplete);
 SessionInterface->OnFindSessionsCompleteDelegates.AddUObject(this, &UTheLegendsOfArthurInstance::OnFindSessionComplete);
 SessionInterface->OnJoinSessionCompleteDelegates.AddUObject(this, &UTheLegendsOfArthurInstance::OnJoinSessionComplete);
 //Host("ola");
 }

 }
	else {
		UE_LOG(LogTemp, Warning, TEXT("Found no  Substem"));
	}
}

void UTheLegendsOfArthurInstance::LoadLoginMenu()
{
if (!ensure(LoginClass != nullptr)) return;
loginMenu = CreateWidget<ULogin>(this, LoginClass);
if (!ensure(loginMenu != nullptr)) return;
loginMenu->Setup();
loginMenu->SetMenuInterface(this);

}

void UTheLegendsOfArthurInstance::LoadIngameMenu()
{
	if (!ensure(IngameMenuClass != nullptr)) return;
	ULoginWidget* InGameMenu = CreateWidget<ULoginWidget>(this, IngameMenuClass);
	if (!ensure(InGameMenu != nullptr)) return;
	InGameMenu->Setup();
	InGameMenu->SetMenuInterface(this);
}

void UTheLegendsOfArthurInstance::LoadMainMenu()
{
	APlayerController* PlayerController = GetFirstLocalPlayerController();
	if (!ensure(PlayerController != nullptr)) return;
	PlayerController->ClientTravel("/Game/Assets/Maps/MainMenu", ETravelType::TRAVEL_Absolute);
}


void UTheLegendsOfArthurInstance::OnCreateSessionComplete(FName SessionName, bool Sucess) {

	if (!Sucess)
	{
		UE_LOG(LogTemp, Warning, TEXT("Could not Create Session"));
		return;
	}
	if (loginMenu != nullptr)
	{
		loginMenu->TearDown();
	}
	UEngine* Engine = GetEngine();
	if (!ensure(Engine != nullptr)) return;
	Engine->AddOnScreenDebugMessage(0, 5, FColor::Red, TEXT("Hosting"));
	UWorld* World = GetWorld();
	if (!ensure(World != nullptr)) return;
	World->ServerTravel("/Game/Assets/Maps/Lobby?listen");
}

void UTheLegendsOfArthurInstance::OndestroySessionComplete(FName SessionName, bool Sucess)
{
	if (Sucess) {
		CreateSession();
	}
}

void UTheLegendsOfArthurInstance::OnFindSessionComplete(bool Sucess)
{


	if (Sucess && SessionSearch.IsValid() && loginMenu!=nullptr)
	{
		UE_LOG(LogTemp, Warning, TEXT("Finished Find Session"));

		TArray<FServerData> ServerName;

		for (const FOnlineSessionSearchResult& SearchResult : SessionSearch->SearchResults) {
			UE_LOG(LogTemp, Warning, TEXT("Found Session Name %s"),*SearchResult.GetSessionIdStr());
			FServerData Data;

			Data.MaxPlayers = SearchResult.Session.SessionSettings.NumPublicConnections;
			Data.CurrentPlayers = Data.MaxPlayers- SearchResult.Session.NumOpenPublicConnections;
			Data.HostUserName = SearchResult.Session.OwningUserName;
			FString ServerNames;
			if (SearchResult.Session.SessionSettings.Get(SERVER_NAME_SETTINGS_KEY, ServerNames))
			{
				Data.Name = ServerNames;
			UE_LOG(LogTemp, Warning, TEXT("Data Found Setting "));
			}
			else
			{
				Data.Name = "Could Not Find the Server";
			//	UE_LOG(LogTemp, Warning, TEXT("Data Not Found Setting"));
			}
			ServerName.Add(Data);
		}
		loginMenu->SetServerList(ServerName);
	}

}

void UTheLegendsOfArthurInstance::Host(FString Servername)
{
	DiresedServername = Servername;
	if (SessionInterface.IsValid()) {

	auto ExistingSession=SessionInterface->GetNamedSession(SESSION_NAME);
	if (ExistingSession != nullptr)
	{
		SessionInterface->DestroySession(SESSION_NAME);
	}
	else
	{
		CreateSession();
	}

	}

}
void UTheLegendsOfArthurInstance::CreateSession()
{
	if (SessionInterface.IsValid()) {
		FOnlineSessionSettings SessionSettings;

		if (IOnlineSubsystem::Get()->GetSubsystemName() == "NULL") {
			SessionSettings.bIsLANMatch = true;
		}else{
			SessionSettings.bIsLANMatch = false;
		}

		SessionSettings.NumPublicConnections = 2;
		SessionSettings.bShouldAdvertise = true;
		SessionSettings.bUsesPresence = true;
		SessionSettings.Set(SERVER_NAME_SETTINGS_KEY, DiresedServername,EOnlineDataAdvertisementType::ViaOnlineServiceAndPing);

		SessionInterface->CreateSession(0, SESSION_NAME, SessionSettings);

	}
}
void  UTheLegendsOfArthurInstance::RefreshServerList()
{
	SessionSearch = MakeShareable(new FOnlineSessionSearch());

	if (SessionSearch.IsValid())
	{
		//SessionSearch->bIsLanQuery = true;
		SessionSearch->MaxSearchResults = 100;
		SessionSearch->QuerySettings.Set(SEARCH_PRESENCE,true, EOnlineComparisonOp::Equals);
		// SessionSearch->QuerySettings;
		UE_LOG(LogTemp, Warning, TEXT("Starting Find Session"));
		SessionInterface->FindSessions(0, SessionSearch.ToSharedRef());
	}

}

void UTheLegendsOfArthurInstance::Join(uint32 Index)
{

	if (!SessionInterface.IsValid()) return;
	if (!SessionSearch.IsValid()) return;
	if (loginMenu != nullptr)
	{


		loginMenu->TearDown();

	}

	SessionInterface->JoinSession(0,GameSessionName,SessionSearch->SearchResults[Index]);

}

void UTheLegendsOfArthurInstance::StartSession()
{
	if (SessionInterface.IsValid())
	{
		SessionInterface->StartSession(GameSessionName);
	}
}

void UTheLegendsOfArthurInstance::OnJoinSessionComplete(FName SessionName, EOnJoinSessionCompleteResult::Type Result)
{
	if (!SessionInterface.IsValid()) return;
	FString Address;
	if (!SessionInterface->GetResolvedConnectString(SessionName, Address))
	{
		UE_LOG(LogTemp, Warning, TEXT("Could not Get Connection"));
		return;
	}
	UEngine* Engine = GetEngine();
	if (!ensure(Engine != nullptr)) return;
	Engine->AddOnScreenDebugMessage(0, 5, FColor::Red, FString::Printf( TEXT("Joining %s"),*Address));
	APlayerController* PlayerController = GetFirstLocalPlayerController();
	if (!ensure(PlayerController != nullptr)) return;
	PlayerController->ClientTravel(Address,ETravelType::TRAVEL_Absolute);


}

void UTheLegendsOfArthurInstance::onScriptMessage(FGSScriptMessage message) {
	//Handle script message

	GEngine->AddOnScreenDebugMessage(-1, 10.f, FColor::Red, TEXT("Message!"));
	const FString test = message.Data->GetString("title");
	GEngine->AddOnScreenDebugMessage(-1, 10.f, FColor::Red, test);
}

void UTheLegendsOfArthurInstance::onAvailable(bool available)
{
	if (available)
	{
		//GEngine->AddOnScreenDebugMessage(-1, 10.f, FColor::Red, TEXT("Connected"));

		GameSparks::Core::GS& gs = UGameSparksModule::GetModulePtr()->GetGSInstance();
		//UE_LOG(LogTemp, Warning, TEXT("Connected"));

	}

}