// Copyright 1998-2018 Epic Games, Inc. All Rights Reserved.

#include "SGGameMode.h"
#include "SGCharacter.h"
#include "Blueprint/UserWidget.h"
#include "UObject/ConstructorHelpers.h"
#include "SIOJConvert.h"
#include "UnrealNetwork.h"
#include "Runtime/UMG/Public/Components/EditableTextBox.h"
#include "Runtime/UMG/Public/Blueprint/WidgetTree.h"

ASGGameMode::ASGGameMode()
{
    // set default pawn class to our Blueprinted character
    static ConstructorHelpers::FClassFinder<APawn> PlayerPawnBPClass(TEXT("/Game/ThirdPersonCPP/Blueprints/ThirdPersonCharacter"));
    if (PlayerPawnBPClass.Class != NULL)
    {
        DefaultPawnClass = PlayerPawnBPClass.Class;
        PlayerControllerClass = ASPlayerController::StaticClass();
    }

    if (Role == ROLE_Authority)
        SocketIo = CreateDefaultSubobject<USocketIOClientComponent>(TEXT("SocketIOClientComponent"));

    if (!IsRunningDedicatedServer())
    {
        static ConstructorHelpers::FClassFinder<UUserWidget> BackgroundVideoWidget(TEXT("/Game/UI/User/W_BackgroundVideo"));
        static ConstructorHelpers::FClassFinder<UUserWidget> TitleVideoWidget(TEXT("/Game/UI/User/W_TitleVideo"));
        static ConstructorHelpers::FClassFinder<UUserWidget> NewsInterfaceWidget(TEXT("/Game/UI/News/W_NewsInterface"));
        static ConstructorHelpers::FClassFinder<UUserWidget> MainMenuWidget(TEXT("/Game/UI/MainMenu/W_MainMenu"));
        static ConstructorHelpers::FClassFinder<UUserWidget> LoginInterfaceWidget(TEXT("/Game/UI/User/W_LoginInterface"));
        static ConstructorHelpers::FClassFinder<UUserWidget> RegisterInterfaceWidget(TEXT("/Game/UI/User/W_RegisterInterface"));
        static ConstructorHelpers::FClassFinder<UUserWidget> ResetPasswordInterfaceWidget(TEXT("/Game/UI/User/W_ResetPasswordInterface"));

        if (BackgroundVideoWidget.Class != NULL)
            WBackgroundVideo = BackgroundVideoWidget.Class;
        if (TitleVideoWidget.Class != NULL)
            WTitleVideo = TitleVideoWidget.Class;
        if (NewsInterfaceWidget.Class != NULL)
            WNewsInterface = NewsInterfaceWidget.Class;
        if (MainMenuWidget.Class != NULL)
            WMainMenu = MainMenuWidget.Class;
        if (LoginInterfaceWidget.Class != NULL)
            WLoginInterface = LoginInterfaceWidget.Class;
        if (RegisterInterfaceWidget.Class != NULL)
            WRegisterInterface = RegisterInterfaceWidget.Class;
        if (ResetPasswordInterfaceWidget.Class != NULL)
            WResetPasswordInterface = ResetPasswordInterfaceWidget.Class;
    }
}

// Save to GameDir\Saved\Config\Windows\Game.ini
void ASGGameMode::SaveAccountName(const FString& name)
{
    if (!GConfig) return;

    FString VictorySection = "SG.Auth";
    GConfig->SetString(*VictorySection, TEXT("account_name"), *name, GGameIni);

    //ConfigCacheIni.h
    //void Flush( bool Read, const FString& Filename=TEXT("") );
    GConfig->Flush(false, GGameIni);
}

void ASGGameMode::BeginPlay()
{
    Super::BeginPlay();

    if (!IsRunningDedicatedServer())
    {
        APlayerController* playerController = GEngine->GetFirstLocalPlayerController(GWorld);

        if (playerController != nullptr)
        {
            playerController->SetInputMode(FInputModeUIOnly());
            playerController->bShowMouseCursor = true;

            if (WBackgroundVideo && !this->isLogged) {
                BackgroundVideo = CreateWidget<UUserWidget>(playerController, WBackgroundVideo);
                BackgroundVideo->AddToViewport();
            }

            if (WTitleVideo && !this->isLogged) {
                TitleVideo = CreateWidget<UUserWidget>(playerController, WTitleVideo);
                TitleVideo->AddToViewport();
            }

            if (WNewsInterface && !this->isLogged) {
                NewsInterface = CreateWidget<UUserWidget>(playerController, WNewsInterface);
                NewsInterface->AddToViewport();

                SocketIo->EmitNative(FString("posts_index"), true);

                SocketIo->OnNativeEvent(FString("posts_index_result"), [&](const FString& Event, const TSharedPtr<FJsonValue>& Payload)
                {
                    FString json = USIOJConvert::ToJsonString(Payload);
                    TArray<TSharedPtr<FJsonValue>> posts = USIOJConvert::JsonStringToJsonArray(json);

                    for (auto& post : posts) {
                        FString str = USIOJConvert::ToJsonString(post);
                        TSharedPtr<FJsonObject> data = USIOJConvert::ToJsonObject(str);

                        FString id      = data->GetStringField("id");
                        FString title   = data->GetStringField("title");
                        FString content = data->GetStringField("content");
                        FString image   = data->GetStringField("image");
                        OnPostResult.Broadcast(id, title, content, image);
                    }
                });
            }

            if (WMainMenu)
                MainMenu = CreateWidget<UUserWidget>(playerController, WMainMenu);

            if (WLoginInterface && !this->isLogged)
            {
                LoginInterface = CreateWidget<UUserWidget>(playerController, WLoginInterface);

                if (WLoginInterface)
                    LoginInterface->AddToViewport();
            }

            if (WRegisterInterface && !this->isLogged)
                RegisterInterface = CreateWidget<UUserWidget>(playerController, WRegisterInterface);

            if (WResetPasswordInterface && !this->isLogged)
                ResetPasswordInterface = CreateWidget<UUserWidget>(playerController, WResetPasswordInterface);

            this->GetLastAccountName();
        }
    }

    if (SocketIo != nullptr && Role == ROLE_Authority)
    {
        //SocketIo->AddressAndPort = FString("http://virax.net");
        SocketIo->AddressAndPort = FString("http://127.0.0.1:3000");
        //SocketIo->bShouldAutoConnect = false;
        //SocketIo->Connect(SocketIo->AddressAndPort);
    }
    else
    {
        SocketIo = nullptr;
    }
}
void ASGGameMode::GetLastAccountName()
{
    FString Section = "SG.Auth";
    FString name;

    GConfig->GetString(*Section, TEXT("account_name"), name, GGameIni);

    UEditableTextBox* input = nullptr;

    const FName TextControlName = FName(TEXT("InputEmail"));

    if (input == nullptr)
    {
        input = (UEditableTextBox*)(LoginInterface->WidgetTree->FindWidget(TextControlName));
        input->SetText(FText::FromString(name));
    }
}

void ASGGameMode::UserLogin(const FString& email, const FString& password, bool saveAccountName)
{
    if (!SocketIo->bIsConnected) {
        OnLoginResult.Broadcast(FString("Connection issues, retry later"), false);
        return;
    }

    TSharedPtr<FJsonObject> obj = MakeShareable(new FJsonObject);
    obj->SetStringField(FString("email"), email);
    obj->SetStringField(FString("password"), password);

    SocketIo->EmitNative(FString("login"), obj);

    this->SaveAccountName(saveAccountName ? email : "");

    SocketIo->OnNativeEvent(FString("logged"), [&](const FString& Event, const TSharedPtr<FJsonValue>& Payload)
    {
        FString json = USIOJConvert::ToJsonString(Payload);
        TSharedPtr<FJsonObject> data = USIOJConvert::ToJsonObject(json);

        bool state;
        if (data->TryGetBoolField("state", state)) {
            if (state) {
                FString token;
                if (data->TryGetStringField("token", token)) {
                    this->SessionToken = token;

                    FString msg;
                    if (data->TryGetStringField("msg", msg))
                        OnLoginResult.Broadcast(msg, true);

                    APlayerController* playerController = GEngine->GetFirstLocalPlayerController(GWorld);

                    if (playerController != nullptr)
                        playerController->SetInputMode(FInputModeGameAndUI());
                }
                else {
                    OnLoginResult.Broadcast("Unable to get authentication token", false);
                }
            }
            else {
                FString error;
                if (data->TryGetStringField("error", error)) {
                    OnLoginResult.Broadcast(error, false);
                }
            }
        }
    });
}

void ASGGameMode::UserResetPassword(const FString& email)
{
    if (!SocketIo->bIsConnected) {
        OnRegisterResult.Broadcast(FString("Connection issues, retry later"), false);
        return;
    }

    TSharedPtr<FJsonObject> obj = MakeShareable(new FJsonObject);
    obj->SetStringField(FString("email"), email);

    SocketIo->EmitNative(FString("reset_password"), obj);

    SocketIo->OnNativeEvent(FString("password_reseted"), [&](const FString& Event, const TSharedPtr<FJsonValue>& Payload)
    {
        FString json = USIOJConvert::ToJsonString(Payload);
        TSharedPtr<FJsonObject> data = USIOJConvert::ToJsonObject(json);

        bool state;
        if (data->TryGetBoolField("state", state)) {
            if (state) {
                FString msg;
                if (data->TryGetStringField("msg", msg)) {
                    OnResetPasswordResult.Broadcast(msg, true);
                }
            }
            else {
                FString error;
                if (data->TryGetStringField("error", error)) {
                    OnResetPasswordResult.Broadcast(error, false);
                }
            }
        }
    });
}

void ASGGameMode::UserRegister(const FString& email, const FString& nickname, const FString& password)
{
    if (!SocketIo->bIsConnected) {
        OnRegisterResult.Broadcast(FString("Connection issues, retry later"), false);
        return;
    }

    TSharedPtr<FJsonObject> obj = MakeShareable(new FJsonObject);
    obj->SetStringField(FString("nickname"), nickname);
    obj->SetStringField(FString("email"), email);
    obj->SetStringField(FString("password"), password);

    SocketIo->EmitNative(FString("register"), obj);

    SocketIo->OnNativeEvent(FString("registered"), [&](const FString& Event, const TSharedPtr<FJsonValue>& Payload)
    {
        FString json = USIOJConvert::ToJsonString(Payload);
        TSharedPtr<FJsonObject> data = USIOJConvert::ToJsonObject(json);

        bool state;
        if (data->TryGetBoolField("state", state)) {
            if (state) {
                FString msg;
                if (data->TryGetStringField("msg", msg)) {
                    OnRegisterResult.Broadcast(msg, true);
                }
            }
            else {
                FString error;
                if (data->TryGetStringField("error", error)) {
                    OnRegisterResult.Broadcast(error, false);
                }
            }
        }
    });
}