using Gs2.Unity.Core;
using System;
using Cysharp.Threading.Tasks;
using Gs2.Core;
using Gs2.Unity.Gs2Guild.Domain.Model;
using Gs2.Unity.Util;
using UnityEngine;

public sealed class AdventureSocial : MonoBehaviour
{
    private Gs2Domain Client => Gs2ClientHolder.Instance.Gs2;
    private IGameSession Session => Gs2GameSessionHolder.Instance != null && Gs2GameSessionHolder.Instance.Initialized
        ? Gs2GameSessionHolder.Instance.GameSession : null;
    private string displayName = "Adventurer A";
    private string targetUserId = "";
    private string score = "100";
    private string guildName = "";
    private string message = "Save your profile";
    private bool busy;
    private Vector2 scroll;
    private const string FriendNamespace = "Friend";
    private const string RankingNamespace = "Ranking";
    private const string GuildNamespace = "Guild";

    private void OnGUI()
    {
        if (Session == null) return;
        GUILayout.BeginArea(new Rect(700, 20, 650, 650), GUI.skin.box);
        scroll = GUILayout.BeginScrollView(scroll);
        GUILayout.Label("Social / My ID: " + Session.AccessToken.UserId);
        if (GUILayout.Button("Copy my ID")) GUIUtility.systemCopyBuffer = Session.AccessToken.UserId;
        GUILayout.Label(message);
        GUI.enabled = !busy;
        GUILayout.Label("Display name"); displayName = GUILayout.TextField(displayName);
        if (GUILayout.Button("Save my name")) Run(() => SaveProfile()).Forget();
        GUILayout.Label("Other player's ID"); targetUserId = GUILayout.TextField(targetUserId);
        if (GUILayout.Button("Read their name")) Run(() => ReadProfile()).Forget();
        GUILayout.Label("Score"); score = GUILayout.TextField(score);
        if (GUILayout.Button("Submit score")) Run(() => PutScore()).Forget();
        if (GUILayout.Button("Read rankings")) Run(() => ReadRanking()).Forget();
        if (GUILayout.Button("Send friend request")) Run(() => SendFriend()).Forget();
        if (GUILayout.Button("Accept their request")) Run(() => AcceptFriend()).Forget();
        if (GUILayout.Button("Read friends")) Run(() => ReadFriends()).Forget();
        if (GUILayout.Button("Remove friend")) Run(() => DeleteFriend()).Forget();
        GUILayout.Label("Guild ID"); guildName = GUILayout.TextField(guildName);
        if (GUILayout.Button("Create an adventurers' guild")) Run(() => CreateGuild()).Forget();
        if (GUILayout.Button("Join or apply to this guild")) Run(() => JoinGuild()).Forget();
        if (GUILayout.Button("Read members")) Run(() => ReadGuild()).Forget();
        if (GUILayout.Button("Leave this guild")) Run(() => LeaveGuild()).Forget();
        if (GUILayout.Button("Master: Require approval")) Run(() => ManageGuild(false)).Forget();
        if (GUILayout.Button("Master: Approve their request")) Run(() => ManageGuild(true)).Forget();
        GUI.enabled = true;
        GUILayout.EndScrollView(); GUILayout.EndArea();
    }

    private async UniTask Run(System.Func<UniTask> action)
    {
        if (busy) return;
        busy = true;
        try { await action(); }
        catch (System.Exception error) { message = error.Message; }
        finally { busy = false; }
    }

    private async UniTask SaveProfile()
    {
        var request = await Client.Friend.Namespace(FriendNamespace).Me(Session).Profile()
            .UpdateProfileAsync(publicProfile: displayName);
        message = "Name saved";
    }

    private async UniTask ReadProfile()
    {
        var domain = Client.Friend.Namespace(FriendNamespace).User(targetUserId).PublicProfile();
        domain.Invalidate(); var request = await domain.ModelAsync();
        message = (request?.PublicProfile ?? "No name registered yet");
    }

    private async UniTask PutScore()
    {
        if (!long.TryParse(score, out var value)) { message = "Enter a whole number for the score"; return; }
        var request = await Client.Ranking2.Namespace(RankingNamespace).GlobalRankingModel("adventure")
            .GlobalRankingSeason(Session).PutGlobalRankingAsync(value, displayName);
        await ReadRanking();
    }

    private async UniTask ReadRanking()
    {
        var ranking = Client.Ranking2.Namespace(RankingNamespace).GlobalRankingModel("adventure").GlobalRankingSeason(Session);
        ranking.InvalidateGlobalRankings();
        message = "";
        await foreach (var item in ranking.GlobalRankingsAsync())
        {
            if (item != null) message += item.Rank + " / " + item.Metadata + " / " + item.Score + " / " + item.UserId + "\n";
        }
    }

    private async UniTask SendFriend()
    {
        var request = await Client.Friend.Namespace(FriendNamespace).Me(Session).SendRequestAsync(targetUserId); message = "Friend request sent";
    }

    private async UniTask AcceptFriend()
    {
        var request = await Client.Friend.Namespace(FriendNamespace).Me(Session).ReceiveFriendRequest(targetUserId).AcceptAsync();
        await ReadFriends();
    }

    private async UniTask DeleteFriend()
    {
        var request = await Client.Friend.Namespace(FriendNamespace).Me(Session).Friend(true).DeleteFriendAsync(targetUserId);
        await ReadFriends();
    }

    private async UniTask ReadFriends()
    {
        var me = Client.Friend.Namespace(FriendNamespace).Me(Session);
        me.InvalidateFriends(); message = "Friends\n";
        await foreach (var item in me.FriendsAsync(withProfile: true))
        {
            if (item != null) message += item.UserId + " / " + item.PublicProfile + "\n";
        }
    }

    private async UniTask CreateGuild()
    {
        var request = await Client.Guild.Namespace(GuildNamespace).Me(Session).CreateGuildAsync("adventure", "Adventurers' guild", "anybody");
        guildName = request.GuildName;
        await ReadGuild();
    }

    private async UniTask JoinGuild()
    {
        var request = await Client.Guild.Namespace(GuildNamespace).Me(Session).SendRequestAsync("adventure", guildName);
        message = "Join request sent. Check the member list for the result.";
        await ReadGuild();
    }

    private async UniTask ReadGuild()
    {
        var domain = Client.Super.Guild.Namespace(GuildNamespace).Guild("adventure", guildName);
        domain.Invalidate(); var request = await domain.ModelAsync(Session.AccessToken);
        if (request == null) { message = "Guild not found"; return; }
        message = request.DisplayName + " / " + request.JoinPolicy + "\n";
        foreach (var member in request.Members) message += member.UserId + " / " + member.RoleName + "\n";
    }

    private async UniTask LeaveGuild()
    {
        var request = await Client.Guild.Namespace(GuildNamespace).Me(Session).JoinedGuild("adventure", guildName).WithdrawGuildAsync(); message = "Left the guild";
    }

    private async UniTask ManageGuild(bool accept)
    {
        var assume = await Client.Guild.Namespace(GuildNamespace).Me(Session).AssumeAsync(
            new GatewaySetting { gatewayNamespaceName = "default", allowConcurrentAccess = true }, "adventure", guildName);
        var guild = Client.Guild.Namespace(GuildNamespace).GuildGameSession("adventure", assume);
        if (accept)
        {
            var request = await guild.ReceiveMemberRequest(targetUserId).AcceptAsync();
        }
        else
        {
            var request = await guild.UpdateGuildAsync(Session.AccessToken.Token, "Adventurers' guild", "approval");
        }
        await ReadGuild();
    }
}