FriendsListMediator

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using Facebook.Unity;
using Firebase.Database;
using Hashbang.Feature.Matchmaking;
using Hashbang.Feature.Squads;
using Hashbang.Window;
using PlayFab;
using PlayFab.ClientModels;
using PrimalCarnage.Data;
using PrimalCarnage.Menu;
using RSG;
using UniRx;
using UnityEngine;
using WindowManagerPack;

public enum FriendIdType { PlayFabId, Username, Email, DisplayName };

[System.Serializable]
public class FetchUserInfoResult
{
 public int ELO;
 public int Tier;
 public int Level;
 public PlayerStats Mods;
 public Dictionary<string, TotalStats> Stats;
 public int HeroCount;
 public PlayFab.ClientModels.GetPlayerCombinedInfoResultPayload InfoResultPayload;
}

public class PlayerTeamData
{
    public string PlayFabId;
    public EntityKey EntityKey;
    public int ELO;
    public int Tier;
    public int Level;
    public bool Ready = false;
    public bool SquadLeader = false;
}

public class FriendsListMediator : WindowMediator, IOnShow, IOnHide
{
    public static System.Action CloseWindowEvent = null;

    [Inject] public FriendsListView View { get; set; }

    [Inject] public WindowManager WindowManager { get; set; }

    [Inject] public GameDataManager GameDataManager { get; set; }

    [Inject] public PlayerAccountData PlayerAccountData { get; set; }

    [Inject] public FirebaseService FirebaseService { get; set; }

    [Inject] public SquadService SquadService { get; set; }

    [Inject] public MatchMakingService MatchMakingService { get; set; }

    [Inject] public PlayFabManager PlayFabManager { get; set; }

    [Inject] public MenuPhotonManager MenuPhotonManager { get; set; }

    [Inject] public PhotonUtils PhotonUtils { get; set; }

    [Inject] public SetElementVisibleSignal SetElementVisibleSignal { get; set; }

    private ListView _friendList;
    private ListView _recentList;
    private ListView _clanList;
    private ListView _facebookList;
    private UserInfoMessageData _selectedPlayer;
    private bool _fetchingUserInfo = false;
    private List<PlayerTeamData> _userList = new List<PlayerTeamData> ();
    private int _tier;
    public int TierToJoin { get { return _tier; } }
    private int _elo;
    public int EloToJoin { get { return _elo; } }
    private int _lowerElo;
    public int LowerElo { get { return _lowerElo; } }
    private int _upperElo;
    public int UpperElo { get { return _upperElo; } }
    private SquadState _squadState;
    public SquadState SquadState { get { return _squadState; } }
    private string[] _expectedUsers;
    public string[] ExpectedUsers { get { return _expectedUsers; } }

    // public static Dictionary<string, UserInfoMessageData> UserInfoDictionary = new Dictionary<string, UserInfoMessageData> ();

    private Dictionary<string, PlayerListItemView> _friendMap = new Dictionary<string, PlayerListItemView> ();

    private List<PlayFab.ClientModels.FriendInfo> _recentPlayerList = new List<PlayFab.ClientModels.FriendInfo> ();
    private List<PlayFab.ClientModels.FriendInfo> _facebookFriendList = new List<PlayFab.ClientModels.FriendInfo> ();

    public override void OnRegister ()
    {
        View.OnTabStateChanged += OnTabStateChanged;
        View.CloseButton.OnClickAsObservable ().Subscribe (_ => CloseSquadWindow ()).AddTo (gameObject);
        View.LeaveSquadButton.OnClickAsObservable ().Subscribe (_ => CloseSquadWindow ()).AddTo (gameObject);

        //Doing this because the foreach loop wasn't working and i'm out of time. (FML)
        if (View.TabButtons[0] != null) View.TabButtons[0].OnClickAsObservable ().Subscribe ((_) => OnTabButtonClicked (0)).AddTo (gameObject);
        if (View.TabButtons[1] != null) View.TabButtons[1].OnClickAsObservable ().Subscribe ((_) => OnTabButtonClicked (1)).AddTo (gameObject);
        if (View.TabButtons[2] != null) View.TabButtons[2].OnClickAsObservable ().Subscribe ((_) => OnTabButtonClicked (2)).AddTo (gameObject);
        if (View.TabButtons[3] != null) View.TabButtons[3].OnClickAsObservable ().Subscribe ((_) => OnTabButtonClicked (3)).AddTo (gameObject);

        View.SquadWindow.OnRegister (this);

        PlayerReference.FriendStateChanged += FriendStateChanged;

        _friendList = View.TabPanels[0].GetComponent<ListView> ();
        _recentList = View.TabPanels[1].GetComponent<ListView> ();
        _clanList = View.TabButtons[2].GetComponent<ListView> ();
        _facebookList = View.TabPanels[3].GetComponent<ListView> ();
        _friendList.ClearContainer ();
        _recentList.ClearContainer ();
        // RemoveFriendListeners ();
        _friendList.OnContainerRebuild += OnBuildFriendList;
        _recentList.OnContainerRebuild += OnBuildRecentList;

        View.ActionBar.SetActive (true);
        View.SquadWindow.gameObject.SetActive (false);

        View.ShowAddFriendPanelButton.onClick.AddListener (ShowAddFriendPanel);

        View.AddFriendButton.onClick.RemoveAllListeners ();
        View.AddFriendButton.onClick.AddListener (OnAddFriendClicked);

        View.CloseAddFriendPanelButton.onClick.AddListener (HideAddFriendPanel);

        View.UserInfoMessagePrefab.CloseUserInfoButton.onClick.AddListener (UserProfileCloseButtonOnClick);
        View.UserInfoMessagePrefab.FriendRemove.onClick.AddListener (OnDeletePlayer);
        View.UserInfoMessagePrefab.FriendInvite.onClick.AddListener (InviteFriendOnClick);
        View.UserInfoMessagePrefab.ClanInvite.onClick.AddListener (AddPlayerToClan);
        View.UserInfoMessagePrefab.ClanRemove.onClick.AddListener (RemovePlayerFromClan);
        View.UserInfoMessagePrefab.SquadInvite.onClick.AddListener (SquadInviteOnClick);
        View.UserInfoMessagePrefab.SquadCancel.onClick.AddListener (SquadCancelOnClick);

        // SquadService.SquadOutboxQueryResult += OnSquadOutboxQuery;
        // SquadService.SquadInboxQueryResult += OnSquadInboxQuery;
        // SquadService.SquadInSameSquadResult += OnSquadInSameSquadQuery;
        SquadService.SquadOutboxAdded += OnSquadOutboxAdded;
        SquadService.SquadOutboxRemoved += OnSquadOutboxRemoved;
        // SquadService.SquadInboxAdded += OnSquadInboxAdded;
        // SquadService.SquadInboxRemoved += OnSquadInboxRemoved;
        SquadService.SquadSelfAcceptInvite += OnSquadSelfAcceptInvite;

        SquadService.SquadChildAddedResult += OnSquadChildAdded;
        SquadService.SquadChildRemovedResult += OnSquadChildRemoved;
        SquadService.SquadStateChangedResult += OnSquadStateChanged;

        CloseWindowEvent += CloseSquadWindow;
        base.OnRegister ();
    }

    public override void OnRemove ()
    {
        View.OnTabStateChanged -= OnTabStateChanged;
        if (_friendList != null)
        {
            _friendList.ClearContainer ();
            _friendList.OnContainerRebuild -= OnBuildFriendList;
        }

        PlayerReference.FriendStateChanged -= FriendStateChanged;

        if (_recentList != null)
        {
            _recentList.ClearContainer ();
            _recentList.OnContainerRebuild -= OnBuildRecentList;
        }

        PlayerReference.ClearAll ();

        View.ShowAddFriendPanelButton.onClick.RemoveListener (ShowAddFriendPanel);
        View.AddFriendButton.onClick.RemoveListener (OnAddFriendClicked);
        View.CloseAddFriendPanelButton.onClick.RemoveListener (HideAddFriendPanel);

        View.UserInfoMessagePrefab.CloseUserInfoButton.onClick.RemoveListener (UserProfileCloseButtonOnClick);
        View.UserInfoMessagePrefab.FriendRemove.onClick.RemoveListener (OnDeletePlayer);
        View.UserInfoMessagePrefab.FriendInvite.onClick.RemoveListener (InviteFriendOnClick);
        View.UserInfoMessagePrefab.ClanInvite.onClick.RemoveListener (AddPlayerToClan);
        View.UserInfoMessagePrefab.ClanRemove.onClick.RemoveListener (RemovePlayerFromClan);
        View.UserInfoMessagePrefab.SquadInvite.onClick.RemoveListener (SquadInviteOnClick);
        View.UserInfoMessagePrefab.SquadCancel.onClick.RemoveListener (SquadCancelOnClick);

        // SquadService.SquadOutboxQueryResult -= OnSquadOutboxQuery;
        // SquadService.SquadInboxQueryResult -= OnSquadInboxQuery;
        // SquadService.SquadInSameSquadResult -= OnSquadInSameSquadQuery;
        SquadService.SquadOutboxAdded -= OnSquadOutboxAdded;
        SquadService.SquadOutboxRemoved -= OnSquadOutboxRemoved;
        // SquadService.SquadInboxAdded -= OnSquadInboxAdded;
        // SquadService.SquadInboxRemoved -= OnSquadInboxRemoved;
        SquadService.SquadSelfAcceptInvite -= OnSquadSelfAcceptInvite;

        SquadService.SquadChildAddedResult -= OnSquadChildAdded;
        SquadService.SquadChildRemovedResult -= OnSquadChildRemoved;
        SquadService.SquadStateChangedResult -= OnSquadStateChanged;

        //SquadService.RoomInfoSetResult -= OnRoomInfoSet;

        // RemoveFriendListeners ();

        CloseWindowEvent -= CloseSquadWindow;
        base.OnRemove ();
    }

    private Queue<System.Action> _actionQueue = new Queue<System.Action> ();
    public void Update ()
    {
        while (_actionQueue.Count > 0)
        {
            _actionQueue.Dequeue ().Invoke ();
        }
        if (View.Content.activeSelf)
        {
            string squadId = (SquadService.GetSquadID ());
            // Debug.Log("squadId " + squadId);
            View.SquadStatus.text = string.IsNullOrEmpty (squadId) ? "Squads" : "In squad " + squadId;
        }

    }

    // private void RemoveFriendListeners (string friendId = "")
    // {
    //     if (string.IsNullOrEmpty (friendId))
    //     {
    //         foreach (var friend in _friendMap)
    //         {
    //             FirebaseService.DatabaseReference.Child (string.Format ("Players/{0}/State", friend.Key)).ValueChanged -= FriendInfoChanged;
    //         }
    //         _friendMap.Clear ();
    //         return;
    //     }
    //     if (_friendMap.ContainsKey (friendId))
    //     {
    //         FirebaseService.DatabaseReference.Child (string.Format ("Players/{0}/State", friendId)).ValueChanged -= FriendInfoChanged;
    //         _friendMap.Remove (friendId);
    //     }
    // }

    public void OnBuildFriendList (List<GameObject> objects)
    {
        // Debug.LogError("On build friends list");
        int i = 0;

        // Debug.Log("GameDataManager.AccountData.Friends " + GameDataManager.AccountData.Friends.Count);
        // Debug.Log("objects " + objects.Count);

        // RemoveFriendListeners ();

        _friendMap.Clear ();

        foreach (var item in objects)
        {

            var playerItem = item.GetComponent<PlayerListItemView> ();

            var player = PlayerReference.AddData (GameDataManager.AccountData.Friends[i].FriendPlayFabId, GameDataManager.AccountData.Friends[i]);

            playerItem.ProfileInfo = GameDataManager.AccountData.Friends[i];

            var profile = playerItem.ProfileInfo.Profile;
            // playerItem.transform.position = Vector3.zero;
            // playerItem.transform.localPosition = Vector3.zero;
            // playerItem.transform.localScale = Vector3.one;

            string value = profile.DisplayName;
            string suffix = (value.Substring (Mathf.Max (0, value.Length - 5)));
            int parsedSuffix = 0;
            if (int.TryParse (suffix, out parsedSuffix))
            {
                if (parsedSuffix > 0)
                {
                    playerItem.PlayerName.text = (value.Substring (0, value.Length - 5));
                }
                else
                {
                    playerItem.PlayerName.text = (value);
                }
            }
            else
            {
                playerItem.PlayerName.text = (value);
            }

            // playerItem.onPlayButtonClick += ;

            playerItem.Clear ();
            playerItem.onPlayerInfoClick += OnProfileClicked;
            if (profile.Statistics != null)
            {
                var eloStat = profile.Statistics.Find (stat => stat.Name == "ELO");
                playerItem.PlayerRank.text = (eloStat != null) ? eloStat.Value.ToString () : "-";

                var tierStat = profile.Statistics.Find (stat => stat.Name == "Tier");
                playerItem.PlayerTier.text = string.Format ("Tier {0}", (tierStat != null) ? tierStat.Value.ToString () : "");
            }

            playerItem.SetState (player.State);

            _friendMap.Add (playerItem.ProfileInfo.FriendPlayFabId, playerItem);

            i++;
        }
    }

    public void OnBuildRecentList (List<GameObject> objects)
    {
        for (int i = 0, ilen = objects.Count; i < ilen; i++)
        {
            var recentPlayer = _recentPlayerList[i];
            var playerItem = objects[i].GetComponent<PlayerListItemView> ();
            playerItem.transform.position = Vector3.zero;
            playerItem.transform.localPosition = Vector3.zero;
            playerItem.transform.localScale = Vector3.one;

            //playerItem.CancelInviteButton.gameObject.SetActive(false);//button never visible
            //playerItem.DeleteFriendButton.gameObject.SetActive(false);//button never visible
            // perhaps change this to invite user?
            //playerItem.InviteButton.gameObject.SetActive(false);//button never visible
            playerItem.OnlineStatus.gameObject.SetActive (false);

            playerItem.ProfileInfo = GameDataManager.AccountData.Friends.Find (oldFriend => oldFriend.Profile.PlayerId == recentPlayer.FriendPlayFabId);
            // if the player is not a friend make the item interactive to be invitable
            if (playerItem.ProfileInfo == null)
            {
                playerItem.PlayerTier.text = "";
                playerItem.PlayerRank.text = "";
                playerItem.PlayButtonText.text = "INVITE";
                playerItem.onPlayButtonClick += OnClickAddFriend;
            }
            else
            {
                playerItem.OnlinePip.interactable = true;
                playerItem.PlayerRank.color = playerItem.Online;
                playerItem.PlayerRank.text = "FRIEND";

                // playerItem.PlayButtonText.text = "INVITE";
                // playerItem.onPlayButtonClick += OnPlayButtonClicked;
            }

            playerItem.Clear ();
            playerItem.onPlayerInfoClick += OnProfileClicked;
            playerItem.PlayerName.text = recentPlayer.Profile.DisplayName;
            playerItem.State = -1;

        }
    }

    private void FriendInfoChanged (object sender, ValueChangedEventArgs args)
    {

        Debug.Log ("FriendInfoChanged");

        if (args.Snapshot != null)
        {
            string key = args.Snapshot.Reference.Parent.Key;
            if (args.Snapshot.Value != null)
            {
                int state = Convert.ToInt32 (args.Snapshot.Value);
                // _actionQueue.Enqueue(() =>
                // {
                FriendStateChanged (key, state);
                // });
                return;
            }
            // _actionQueue.Enqueue(() =>
            // {
            FriendStateChanged (key, 0);
            // });
        }
    }

    private void FriendStateChanged (string senderPlayFabId, int state)
    {

        if (_friendList == null) { return; }
        PlayerListItemView playerListItemView = null;

        // If we're viewing them in detail view, update
        if (_selectedPlayer != null)
        {
            if (_selectedPlayer.UserInfo.InfoResultPayload.AccountInfo.PlayFabId == senderPlayFabId)
            {

                int mask = View.UserInfoMessagePrefab.GetButtonState ();
                if ((state & 1) == 0 || (state & 2) == 0 || (state & 4) == 4)
                {
                    mask &= ~(int) FriendButtonLayout.Available;
                }
                else
                {
                    // online and in menu
                    if ((state & 1) == 1 && (state & 2) == 2)
                    {
                        mask |= (int) FriendButtonLayout.Available;
                    }
                }
                View.UserInfoMessagePrefab.SetButtonState (mask);
            }
        }

        // if we have them in our item list, update
        if (_friendMap.TryGetValue (senderPlayFabId, out playerListItemView))
        {
            if (playerListItemView == null) { return; }

            // playerListItemView.State = state;

            // playerListItemView.ProfileInfo = GameDataManager.AccountData.Friends.Find (friend => friend.FriendPlayFabId == senderPlayFabId);
            // if (playerListItemView.ProfileInfo == null) { return; }
            // playerListItemView.CanvasGroup.interactable = true;

            // default stuff
            // playerListItemView.OnlinePip.interactable = false;
            // playerListItemView.OnlineStatus.color = playerListItemView.Offline;
            // playerListItemView.OnlineStatus.text = "offline";
            // playerListItemView.OnlineStatus.gameObject.SetActive(true);

            // playerListItemView.gameObject.SetActive(false);

            // playerListItemView.PlayButton.gameObject.SetActive(((state & 1) == 1)); // Play button only available if online and not further

            playerListItemView.SetState (state);

            playerListItemView.gameObject.SetActive (true);
            return;
        }

        return;
    }

    private void UserProfileCloseButtonOnClick ()
    {
        _selectedPlayer = null;
        View.UserInfoMessagePrefab.gameObject.SetActive (false);
    }

    private void OnSquadStateChanged (SquadState squadState)
    {
        _squadState = squadState;
        switch (squadState)
        {
            case SquadState.Forming:
                break;
                // find match...
            case SquadState.FindRoom:

                if (View.SquadWindow.SquadLeader)
                {
                    Debug.Log ("FindRoom");
                    SquadService.SetSquadState (SquadState.JoinRoom);
                }
                // if (_userList.Count > 0 && View.SquadWindow.SquadLeader)
                // {
                // FindRoom ();
                // }

                // var mainLobby = GameObject.FindObjectOfType<MainLobbyView>();
                // mainLobby.Battle.isOn = true;
                break;
            case SquadState.JoinRoom:
                Debug.Log ("JoinRoom");
                // if (View.SquadWindow.SquadLeader) break;
                FindRoom ();
                break;
        }
    }

    private void FindRoom ()
    {
        Debug.Log ("FindRoom");

        // var squadLeader = _userList.Find (u => u.SquadLeader);
        PlayerMatchupStateView.Instance.IsSquadMatchUp = true;

        PlayerMatchupStateView.Instance.IsSquadLeader = SquadService.SquadLeader;

        // Whether leader or not... join
        var mainLobby = GameObject.FindObjectOfType<MainLobbyView> ();
        mainLobby.Battle.isOn = true;
    }

    private void ClearSquadInfo ()
    {
        _elo = -1;
        _tier = -1;
        _squadState = SquadState.Forming;
    }

    private void OnProfileClicked (PlayerListItemView playerItem)
    {
        Debug.Log ("ON PROFILE CLICKED");
        if (!playerItem || !playerItem.gameObject.activeInHierarchy) return;
        if (_fetchingUserInfo) return;

        _fetchingUserInfo = true;
        var friend = playerItem.ProfileInfo;

        View.UserInfoMessagePrefab.SetButtonState (-1);

        Debug.Log ("fetch user info....");

        Debug.Log ("friend.FriendPlayFabId " + friend.FriendPlayFabId);

        PlayFabClientAPI.ExecuteCloudScript<FetchUserInfoResult> (new ExecuteCloudScriptRequest
        {
            FunctionName = "FetchUserInfoRequest",
                FunctionParameter = new { UserPlayFabId = friend.FriendPlayFabId },
                GeneratePlayStreamEvent = true
        }, (result) =>
        {
            Debug.Log ("result.FunctionResult " + result.FunctionResult.ToString ());

            foreach (var line in result.Logs)
            {
                Debug.LogError ("cloud: " + line.Message);
            }
            Debug.Log ("result.Error " + result.Error);

            _fetchingUserInfo = false;

            // var json = PlayFab.PluginManager.GetPlugin<ISerializerPlugin>(PluginContract.PlayFab_Serializer);

            // string jsonString = json.SerializeObject(result.FunctionResult);
            // FetchUserInfoResult friendData = json.DeserializeObject<FetchUserInfoResult>(jsonString);

            if (result.Error == null)
            {
                FetchUserInfoResult friendData = result.FunctionResult as FetchUserInfoResult;

                if (friendData != null)
                {
                    int buttonState = View.UserInfoMessagePrefab.GetButtonState ();
                    PlayFab.ClientModels.FriendInfo foundFriend = GameDataManager.AccountData.Friends.Find (oldFriend => oldFriend.FriendPlayFabId == friend.FriendPlayFabId);
                    if (foundFriend == null)
                    {
                        buttonState &= ~(int) FriendButtonLayout.Friended;
                    }
                    else
                    {
                        buttonState |= (int) FriendButtonLayout.Friended;
                    }

                    // not online, not in menu, in game
                    if ((playerItem.State & 1) == 0 || (playerItem.State & 2) == 0 || (playerItem.State & 4) == 4)
                    {
                        buttonState &= ~(int) FriendButtonLayout.Available;
                    }
                    else
                    {
                        // online and in menu
                        if ((playerItem.State & 1) == 1 && (playerItem.State & 2) == 2)
                        {
                            buttonState |= (int) FriendButtonLayout.Available;
                        }
                    }

                    var newInfo = new UserInfoMessageData
                    {
                        UserInfo = friendData,
                        MaxHeroes = friendData.HeroCount,
                        FriendButtonMask = buttonState
                    };

                    PlayerReference.AddData (friend.FriendPlayFabId, newInfo);

                    _selectedPlayer = newInfo;

                    // SquadService.SquadInSameSquadQuery (_selectedPlayer);
                    // SquadService.SquadOutboxQuery (_selectedPlayer);
                    // SquadService.SquadInboxQuery (_selectedPlayer);

                    View.UserInfoMessagePrefab.SetData (_selectedPlayer);
                    View.UserInfoMessagePrefab.gameObject.SetActive (true);
                }
                else
                {
                    Debug.LogError ("friendData is null");
                }

            }
            else
            {
                Debug.LogError ("result error " + result.Error.Message + " | " + result.Error.StackTrace);
            }
        }, (error) =>
        {
            Debug.LogError ("FetchUserInfo Error " + error.ErrorMessage);
        });
    }

    // private void OnSquadInboxAdded (SquadInvite invite)
    // {
    //     Debug.Log ("OnSquadInboxAdded");
    //     if (_selectedPlayer == null) { return; }
    //     if (_selectedPlayer.UserInfo.InfoResultPayload.AccountInfo.PlayFabId == invite.PlayFabId)
    //     {
    //         int mask = View.UserInfoMessagePrefab.GetButtonState ();
    //         mask |= (int) FriendButtonLayout.SquadInviteReceived;
    //         View.UserInfoMessagePrefab.SetButtonState (mask);
    //     }
    // }

    // private void OnSquadInboxRemoved (string playFabId)
    // {
    //     if (_selectedPlayer == null) { return; }
    //     if (_selectedPlayer.UserInfo.InfoResultPayload.AccountInfo.PlayFabId == playFabId)
    //     {
    //         int mask = View.UserInfoMessagePrefab.GetButtonState ();
    //         mask &= ~(int) FriendButtonLayout.SquadInviteReceived;
    //         View.UserInfoMessagePrefab.SetButtonState (mask);
    //     }
    // }

    private List<string> _invitedList = new List<string> ();
    private void OnSquadOutboxAdded (string playFabId)
    {
        Debug.Log ("invited friend " + playFabId);
        if (_friendMap.ContainsKey (playFabId))
        {
            if (!_invitedList.Contains (playFabId))
            {
                _invitedList.Add (playFabId);
            }
            PlayerListItemView playerListItemView = _friendMap[playFabId];
            playerListItemView.CanvasGroup.interactable = false;
            playerListItemView.OnlineStatus.text = "invited";
        }

        if (_selectedPlayer == null)
        {
            return;
        }
        if (_selectedPlayer.UserInfo.InfoResultPayload.AccountInfo.PlayFabId == playFabId)
        {
            int mask = View.UserInfoMessagePrefab.GetButtonState ();
            mask |= (int) FriendButtonLayout.SquadInviteSent;
            View.UserInfoMessagePrefab.SetButtonState (mask);
        }
    }

    private void OnSquadOutboxRemoved (string playFabId)
    {
        if (_friendMap.ContainsKey (playFabId))
        {
            if (_invitedList.Contains (playFabId))
            {
                _invitedList.Remove (playFabId);
            }
            PlayerListItemView playerListItemView = _friendMap[playFabId];
            FriendStateChanged (playFabId, playerListItemView.State);
        }
        if (_selectedPlayer == null)
        {
            if (_friendMap.ContainsKey (playFabId))
            {
                _friendMap[playFabId].CanvasGroup.interactable = true;
            }
            return;
        }
        if (_selectedPlayer.UserInfo.InfoResultPayload.AccountInfo.PlayFabId == playFabId)
        {
            int mask = View.UserInfoMessagePrefab.GetButtonState ();
            mask &= ~(int) FriendButtonLayout.SquadInviteSent;
            View.UserInfoMessagePrefab.SetButtonState (mask);
        }
    }

    // private void OnSquadInSameSquadQuery (string playFabId, bool inSameSquad)
    // {
    //     // user info screen closed, don't care if they are invited or not
    //     if (_selectedPlayer == null) { return; }
    //     if (_selectedPlayer.UserInfo.InfoResultPayload.AccountInfo.PlayFabId == playFabId)
    //     {
    //         int mask = View.UserInfoMessagePrefab.GetButtonState ();
    //         if (inSameSquad)
    //         {
    //             mask |= (int) FriendButtonLayout.InMySquad;
    //         }
    //         else
    //         {
    //             mask &= ~(int) FriendButtonLayout.InMySquad;
    //         }
    //         View.UserInfoMessagePrefab.SetButtonState (mask);
    //     }
    // }

    // private void OnSquadInboxQuery (string playFabId, bool invited)
    // {
    //     // user info screen closed, don't care if they are invited or not
    //     if (_selectedPlayer == null)
    //     {

    //         return;
    //     }
    //     if (_selectedPlayer.UserInfo.InfoResultPayload.AccountInfo.PlayFabId == playFabId)
    //     {
    //         int mask = View.UserInfoMessagePrefab.GetButtonState ();
    //         if (invited)
    //         {
    //             mask |= (int) FriendButtonLayout.SquadInviteReceived;
    //         }
    //         else
    //         {
    //             mask &= ~(int) FriendButtonLayout.SquadInviteReceived;
    //         }
    //         View.UserInfoMessagePrefab.SetButtonState (mask);
    //     }
    // }

    // private void OnSquadOutboxQuery (string playFabId, bool invited)
    // {
    //     // user info screen closed, don't care if they are invited or not
    //     if (_selectedPlayer == null)
    //     {
    //         return;
    //     }
    //     if (_selectedPlayer.UserInfo.InfoResultPayload.AccountInfo.PlayFabId == playFabId)
    //     {
    //         int mask = View.UserInfoMessagePrefab.GetButtonState ();
    //         if (invited)
    //         {
    //             mask |= (int) FriendButtonLayout.SquadInviteSent;
    //         }
    //         else
    //         {
    //             mask &= ~(int) FriendButtonLayout.SquadInviteSent;
    //         }
    //         View.UserInfoMessagePrefab.SetButtonState (mask);
    //     }
    // }

    private void OnSquadSelfAcceptInvite (string playFabId)
    {
        Debug.LogError ("OnSquadSelfAcceptInvite ");
        if (_selectedPlayer != null && _selectedPlayer.UserInfo.InfoResultPayload.AccountInfo.PlayFabId == playFabId)
        {
            int mask = View.UserInfoMessagePrefab.GetButtonState ();
            mask |= (int) FriendButtonLayout.InMySquad;
            View.UserInfoMessagePrefab.SetButtonState (mask);
        }
        View.SquadWindow.ClearSquadUsers ();
        SquadService.SquadLeader = false;
        for (int i = 0, ilen = View.SquadWindow.SquadSlots.Count; i < ilen; i++)
        {
            View.SquadWindow.SquadSlots[i].ClearData ();
            View.SquadWindow.SquadStats[i].ClearData ();
        }
        _friendList = null;
        // RemoveFriendListeners ();
        OnHideWindow ();
        WindowManager.WindowShow ("FriendsScreen");
        View.SquadWindow.gameObject.SetActive (true);

        View.CloseButton.gameObject.SetActive (false);
        View.LeaveSquadButton.gameObject.SetActive (true);
        PlayerAccountData.SetPlayerStateFlag (8);
    }

    private void OnSquadChildAdded (string playFabId, int index)
    {
        int squadSlot = index;
        View.SquadWindow.PopulateSquadData (squadSlot, null);
        PlayerReference.GetUserInfoMessage (playFabId, (userInfo) => // retreieve or fetch user info for squad slot
            {
                View.SquadWindow.PopulateSquadData (squadSlot, userInfo);
            });
        return;

    }

    private void OnSquadChildRemoved (string playFabId, int index)
    {
        Debug.LogError ("OnSquadChildRemoved " + playFabId);
        if (_squadState == SquadState.MatchMake || _squadState == SquadState.FindRoom)
        {
            SquadService.ClearSquadData ();

            View.SquadWindow.ClearSquadUsers ();
            SquadService.SquadLeader = false;
            for (int i = 0, ilen = View.SquadWindow.SquadSlots.Count; i < ilen; i++)
            {
                View.SquadWindow.SquadSlots[i].ClearData ();
                View.SquadWindow.SquadStats[i].ClearData ();
            }
            _friendList = null;
            _recentList = null;
            // RemoveFriendListeners ();

            PlayerAccountData.SetPlayerStateValue (3);
            OnHideWindow ();
            HeaderMediator.OnSetNetLockActive (false);
            HeaderMediator.OnSetNetLockText ("");
            OnShowWindow ();
            if (playFabId == PlayerAccountData.PlayFabId)
            {
                return;
            }

            MessageManager.Instance.ShowMessage (PCMessageType.Error, new MessageData
            {
                Title = "User Left Squad",
                    Body = "A squad member has left the squad."
            });
            return;
        }

        // we're the one who left...
        // clear everything and return to main friends window
        if (playFabId == PlayerAccountData.PlayFabId)
        {
            View.SquadWindow.ClearSquadUsers ();
            SquadService.SquadLeader = false;
            for (int i = 0, ilen = View.SquadWindow.SquadSlots.Count; i < ilen; i++)
            {
                View.SquadWindow.SquadSlots[i].ClearData ();
                View.SquadWindow.SquadStats[i].ClearData ();
            }
            _friendList = null;
            _recentList = null;
            // RemoveFriendListeners ();

            if (View.Content.gameObject.activeInHierarchy)
            {
                OnHideWindow ();
                OnShowWindow ();
            }
            return;
        }

        switch (index)
        {
            case 0:
                // leader left, clear squad and return to main friends window

                View.SquadWindow.ClearSquadUsers ();
                SquadService.SquadLeader = false;
                for (int i = 0, ilen = View.SquadWindow.SquadSlots.Count; i < ilen; i++)
                {
                    View.SquadWindow.SquadSlots[i].ClearData ();
                    View.SquadWindow.SquadStats[i].ClearData ();
                }
                _friendList = null;
                _recentList = null;
                // RemoveFriendListeners ();
                OnHideWindow ();
                OnShowWindow ();
                break;
            case 1:
                if (View.SquadWindow.SquadUsers[2] != null)
                {
                    View.SquadWindow.SquadUsers[1] = View.SquadWindow.SquadUsers[2];
                    View.SquadWindow.SquadUsers[2] = null;
                    View.SquadWindow.ClearSquadData (2);
                    View.SquadWindow.PopulateSquadData (1, View.SquadWindow.SquadUsers[1]);
                }
                else
                {
                    View.SquadWindow.ClearSquadData (index);
                }
                break;
            case 2:
                View.SquadWindow.ClearSquadData (index);
                break;
        }
    }

    private void OnTabButtonClicked (int i)
    {
        View.TabState = (FriendsListView.TabStates) i;
    }

    public void CloseSquadWindow ()
    {
        Debug.Log ("CloseSquadWindow");

        if (View.SquadWindow.SquadLeader) // i am the squad leader... kill the squad?
        {
            MatchMakingService.Cancel ();
        }

        View.SquadWindow.ClearSquadUsers ();
        SquadService.SquadLeader = false;
        for (int i = 0, ilen = View.SquadWindow.SquadSlots.Count; i < ilen; i++)
        {
            View.SquadWindow.SquadSlots[i].ClearData ();
            View.SquadWindow.SquadStats[i].ClearData ();
        }
        _friendList = null;
        _recentList = null;
        // RemoveFriendListeners ();

        HeaderMediator.OnSetNetLockActive (false);
        HeaderMediator.OnSetNetLockText ("");

        SetElementVisibleSignal.Dispatch ("LobbyScreen", true);

        View.Modal.SetActive (false);
        WindowManager.WindowHide ("FriendsScreen");

        // SquadService.ClearSquadOutbox ();

        PlayerAccountData.SetPlayerStateValue (1);
        ClearSquadInfo ();
    }

    private void OnTabStateChanged (FriendsListView.TabStates tabstate)
    {
        ClearTabsStates ();
        if (PlayerAccountData.PlayerStateValue < 3) { return; }
        switch (tabstate)
        {
            case FriendsListView.TabStates.Friends:
                ShowFriendList (null);
                break;
            case FriendsListView.TabStates.Recent:
                ShowRecentList ();
                break;
            case FriendsListView.TabStates.Clan:
                break;
            case FriendsListView.TabStates.Facebook:
                Debug.Log ("Clicked tab 3 (facebook)");
                ShowFacebookList ();
                break;
        }

        if (View.TabPanels[(int) tabstate].gameObject != null)
        {
            View.TabPanels[(int) tabstate].gameObject.SetActive (true);
        }
    }

    private void ClearTabsStates ()
    {
        foreach (var tab in View.TabPanels)
        {
            tab.gameObject.SetActive (false);
        }
    }

    public void OnShowWindow ()
    {
        Debug.Log("FriendsListMediator OnShowWindow");
        View.CloseButton.gameObject.SetActive (true);
        View.LeaveSquadButton.gameObject.SetActive (false);
        _actionQueue.Clear ();
        View.Modal.SetActive (false);
        SetElementVisibleSignal.Dispatch ("LobbyScreen", false);
        _fetchingUserInfo = false;
        SquadService.SquadLeader = false;
        View.ActionBar.SetActive (true);
        View.UserInfoMessagePrefab.gameObject.SetActive (false);
        View.SquadWindow.gameObject.SetActive (false);
        View.MainFriendsPanels.SetActive (true);
        View.TabState = FriendsListView.TabStates.Friends;

        ClearSquadInfo ();

        OnTabButtonClicked (0);
        // PlayerAccountData.SetPlayerStateValue (3);
    }
    // called when user is kicked from a squad
    // or they are the squad leader and they left the squad
    public void OnHideWindow ()
    {
        Debug.Log("OnHideWindow");
        View.CloseButton.gameObject.SetActive (true);
        View.LeaveSquadButton.gameObject.SetActive (false);
        View.Modal.SetActive (false);
        _friendList = null;
        _recentList = null;
    }

    private void ShowAddFriendPanel ()
    {
        View.AddFriendPanel.SetActive (true);
    }

    private void HideAddFriendPanel ()
    {
        View.AddFriendPanel.SetActive (false);
    }

    #region UserInfoButtons

    private void OnDeletePlayer ()
    {
        if (_selectedPlayer == null) { return; }
        View.UserInfoMessagePrefab.FriendRemove.transform.parent.gameObject.SetActive (false);
        // RemoveFriendListeners (_selectedPlayer.FriendData.InfoResultPayload.AccountInfo.PlayFabId);
        PlayFab.PlayFabClientAPI.RemoveFriend (new RemoveFriendRequest ()
        {
            FriendPlayFabId = _selectedPlayer.UserInfo.InfoResultPayload.AccountInfo.PlayFabId
        }, (result) =>
        {
            View.UserInfoMessagePrefab.gameObject.SetActive (false);
            PlayFab.ClientModels.FriendInfo foundFriend = GameDataManager.AccountData.Friends.Find (oldFriend => oldFriend.Profile.PlayerId == _selectedPlayer.UserInfo.InfoResultPayload.AccountInfo.PlayFabId);
            if (foundFriend != null)
            {
                GameDataManager.AccountData.Friends.Remove (foundFriend);
            }
            Promise p = new Promise ();
            p.Then (() => ShowRecentList ());
            ShowFriendList (p);
        }, null);
    }

    [System.Obsolete] //depreciated cause the button this binds to is NEVER enabled
    private void OnDeletePlayer (PlayerListItemView playerItem, PlayFab.ClientModels.FriendInfo friend)
    {
        //TODO: popup to remove friend.
        // RemoveFriendListeners (friend.FriendPlayFabId);
        PlayFab.PlayFabClientAPI.RemoveFriend (new RemoveFriendRequest ()
        {
            FriendPlayFabId = friend.FriendPlayFabId
        }, (result) =>
        {
            PlayFab.ClientModels.FriendInfo foundFriend = GameDataManager.AccountData.Friends.Find (oldFriend => oldFriend.Profile.PlayerId == friend.FriendPlayFabId);
            if (foundFriend != null)
            {
                PlayerReference.RemovePlayer (friend.FriendPlayFabId);
                GameDataManager.AccountData.Friends.Remove (foundFriend);
            }
        }, null);
    }

    private void InviteFriendOnClick ()
    {
        if (null == _selectedPlayer)
        {
            return;
        }
        AddFriend (FriendIdType.PlayFabId, _selectedPlayer.UserInfo.InfoResultPayload.AccountInfo.PlayFabId);
    }

    private void OnAddFriendClicked ()
    {
        if (string.IsNullOrEmpty (View.AddFriendNameText.text))
        {
            return;
        }
        else
        {
            AddFriend (FriendIdType.DisplayName, View.AddFriendNameText.text);
        }
    }

    private void OnClickAddFriend (PlayerListItemView playerItem)
    {
        Debug.Log ("On Click Add Friend");
        AddFriend (FriendIdType.PlayFabId, playerItem.ProfileInfo.FriendPlayFabId);
    }

    private void AddFriend (FriendIdType idType, string friendId)
    {
        //var request = new GetAccountInfoRequest();
        var request = new AddFriendRequest ();
        switch (idType)
        {
            case FriendIdType.PlayFabId:
                request.FriendPlayFabId = friendId;
                break;
            case FriendIdType.Username:
                request.FriendUsername = friendId;
                break;
            case FriendIdType.Email:
                request.FriendEmail = friendId;
                break;
            case FriendIdType.DisplayName:
                request.FriendTitleDisplayName = friendId;
                break;
        }

        //PlayFabClientAPI.GetAccountInfo(request, (accountInfoResult)=> {
        // Execute request and update friends when we are done
        PlayFabClientAPI.AddFriend (request,
            result =>
            {

                PlayFab.ClientModels.FriendInfo foundFriend = GameDataManager.AccountData.Friends.Find (oldFriend => oldFriend.Profile.PlayerId == friendId);
                if (foundFriend == null)
                {

                    PlayFab.ClientModels.FriendInfo friendInfo = new PlayFab.ClientModels.FriendInfo
                    {
                        FriendPlayFabId = friendId,
                        Profile = new PlayerProfileModel
                        {
                            DisplayName = "new friend",
                            PlayerId = friendId
                        }
                    };

                    GameDataManager.AccountData.Friends.Add (friendInfo);
                    // PlayerReference.AddData(friendId, friendInfo);

                    PlayerReference.GetUserInfoMessage (friendId, (userInfo) =>
                    {
                        Debug.Log ("fetched user info..."); // ... maybe want to refetch friends...

                    });
                }
                Promise p = new Promise ();
                p.Then (() => ShowRecentList ());
                ShowFriendList (p);
                HideAddFriendPanel ();
                View.UserInfoMessagePrefab.gameObject.SetActive (false);
                View.AddFriendNameText.text = "";
            }, (error) =>
            {
                switch (error.ErrorMessage)
                {
                    case "User not found":
                        MessageManager.Instance.ShowMessage (PCMessageType.Error, new ErrorMessageData
                        {
                            Title = "Player Not Found",
                                Body = "Player \"" + friendId + "\" not found."
                        });
                        break;
                }

                Debug.Log ("Error Addind Friend");
                Debug.Log (error.ErrorMessage);
                Debug.Log (error.ErrorDetails);
            });
    }

    private void AddPlayerToClan ()
    {
        Debug.Log ("Add Player: " + _selectedPlayer.UserInfo.InfoResultPayload.AccountInfo.PlayFabId + " to Clan");
    }

    private void RemovePlayerFromClan ()
    {
        Debug.Log ("Remove Player: " + _selectedPlayer.UserInfo.InfoResultPayload.AccountInfo.PlayFabId + " from Clan");
    }

    private void SquadInviteOnClick ()
    {
        Debug.LogError ("SquadInviteOnClick");
        if (_selectedPlayer == null) { Debug.LogError ("_selectedPlayer == null"); return; }

        PlayerListItemView playerListItemView = null;
        if (_friendMap.TryGetValue (_selectedPlayer.UserInfo.InfoResultPayload.AccountInfo.PlayFabId, out playerListItemView))
        {

            if (playerListItemView == null) { Debug.Log ("playerListItemView == null(return)"); return; }

            if ((playerListItemView.State & 1) == 0) { Debug.Log ("Friend offline(return)"); return; }
            if ((playerListItemView.State & 2) == 0 || (playerListItemView.State & 4) == 4) { Debug.Log ("Friend not ready or in game(return)"); return; }

            playerListItemView.OnInviteClicked (_selectedPlayer.UserInfo.InfoResultPayload.AccountInfo.PlayFabId);

            Debug.Log ("Add Player: " + _selectedPlayer.UserInfo.InfoResultPayload.AccountInfo.PlayFabId + " to Squad");
            // SquadService.SquadInviteAdd(_selectedPlayer);

        }
        else
        {
            Debug.LogError ("Could not find player in _friendMap(return)");
            return;
        }

    }

    private void SquadCancelOnClick ()
    {
        if (_selectedPlayer == null) { Debug.Log ("_selectedPlayer == null"); return; }
        Debug.LogError ("Remove Player: " + _selectedPlayer.UserInfo.InfoResultPayload.AccountInfo.PlayFabId + " from Squad");
        // SquadService.SquadInviteRemove (_selectedPlayer);
    }

    private void SquadAcceptOnClick ()
    {
        if (_selectedPlayer == null) { Debug.Log ("_selectedPlayer == null"); return; }
        Debug.LogError ("Remove Player: " + _selectedPlayer.UserInfo.InfoResultPayload.AccountInfo.PlayFabId + " from Squad");
        // SquadService.SquadInviteAccept (_selectedPlayer.UserInfo.InfoResultPayload.AccountInfo.PlayFabId);
    }

    #endregion
    private void error (PlayFabError obj)
    {
        throw new NotImplementedException ();
    }

    public void ShowFriendList (Promise p = null)
    {
        ShowFriendList (_friendList == null ? View.TabPanels[0].GetComponent<ListView> () : _friendList, p);
    }

    public void ShowRecentList ()
    {
        ShowRecentList (_recentList == null ? View.TabPanels[1].GetComponent<ListView> () : _recentList);
    }

    public void ShowFacebookList ()
    {
        Debug.Log ("show facebook list first");
        ShowFacebookList (_facebookList == null ? View.TabPanels[3].GetComponent<ListView> () : _facebookList);
    }

    private PlayerProfileViewConstraints _profileConstraints = new PlayFab.ClientModels.PlayerProfileViewConstraints
    {
        ShowAvatarUrl = true,
        ShowDisplayName = true,
        ShowMemberships = true,
        ShowStatistics = true,
        ShowTags = true,
    };

    public void ShowFriendList (ListView listView = null, Promise p = null)
    {
        if (!PlayFab.PlayFabClientAPI.IsClientLoggedIn ())
            return;

        if (GameDataManager.AccountData.Friends == null)
        {
            PlayFabManager.FetchFriendsList ((success) =>
            {
                if (success)
                {
                    RefreshFriendsListObjects (listView);
                    if (p != null)
                    {
                        p.Resolve ();
                    }
                }
                else
                {
                    Debug.LogError ("Failed to fetch friends, resolve promise anyway");
                    p.Resolve ();
                }
            });
        }
        else
        {
            RefreshFriendsListObjects (listView);
        }
    }

    public void RefreshFriendsListObjects (ListView listView = null)
    {
        if (_friendList != null)
        {
            //for(int i = 0, ilen = _friendList.)
            _friendList.ClearContainer ();
            _friendList.OnContainerRebuild -= OnBuildFriendList;
        }
        _friendList = listView == null ? _friendList == null ? View.TabPanels[0].GetComponent<ListView> () : _friendList : listView;
        _friendList.OnContainerRebuild -= OnBuildFriendList;
        _friendList.OnContainerRebuild += OnBuildFriendList;
        //_friendList = View.TabPanels[0].GetComponent<ListView>();
        _friendList.ClearContainer ();
        _friendList.BulkAddToContainer (View.PlayerListItemPrefab, GameDataManager.AccountData.Friends.Count);
    }

    private void ShowFacebookList (ListView listView = null)
    {
        Debug.Log ("Show facebook friends real");

        if (!FB.IsInitialized || !FB.IsLoggedIn) { return; }

        /*string FriendsText;
        string query = "/me/friends";
        FB.API(query, HttpMethod.GET, result =>
        {
            var dictionary = (Dictionary<string, object>)Facebook.MiniJSON.Json.Deserialize(result.RawResult);
            var friendsList = (List<object>)dictionary["data"];
            FriendsText = string.Empty;
            foreach (var dict in friendsList)
            {
                FriendsText += ((Dictionary<string, object>)dict)["name"];
            }
            Debug.Log(FriendsText);
        });*/

        PlayFab.PlayFabClientAPI.GetFriendsList (new PlayFab.ClientModels.GetFriendsListRequest ()
        {
            IncludeFacebookFriends = true,
                IncludeSteamFriends = false,
                ProfileConstraints = _profileConstraints
        }, (response) =>
        {
            if (_facebookList != null)
            {
                //for(int i = 0, ilen = _friendList.)
                _facebookList.ClearContainer ();
                _facebookList.OnContainerRebuild -= OnBuildFacebookFriendList;
            }
            Debug.Log ("fetched friends.Count:" + response.Friends.Count);
            //GameDataManager.AccountData.Friends
            List<PlayFab.ClientModels.FriendInfo> facebookFriends = GameDataManager.AccountData.Friends.Where (friend => !response.Friends.Any (fbFriend => fbFriend.FriendPlayFabId == friend.FriendPlayFabId)).ToList ();
            facebookFriends = facebookFriends.OrderBy (o => o.Profile.DisplayName).ToList ();
            Debug.Log ("facebookFriends.Count:" + facebookFriends.Count);
            _facebookList = listView == null ? _facebookList == null ? View.TabPanels[0].GetComponent<ListView> () : _facebookList : listView;
            _facebookList.OnContainerRebuild -= OnBuildFacebookFriendList;
            _facebookList.OnContainerRebuild += OnBuildFacebookFriendList;

            _facebookFriendList.Clear ();

            for (int i = 0, ilen = facebookFriends.Count; i < ilen; i++)
            {
                _facebookFriendList.Add (facebookFriends[i]);
            }

            _facebookList.ClearContainer ();
            _facebookList.BulkAddToContainer (View.PlayerListItemPrefab, facebookFriends.Count);
        }, (error) => Debug.LogError (error.ErrorMessage));
    }

    private void OnBuildFacebookFriendList (List<GameObject> objects)
    {
        int i = 0;

        foreach (var item in objects)
        {
            var playerItem = item.GetComponent<PlayerListItemView> ();
            var friend = _facebookFriendList[i];
            playerItem.transform.position = Vector3.zero;
            playerItem.transform.localPosition = Vector3.zero;
            playerItem.transform.localScale = Vector3.one;
            var profile = playerItem.ProfileInfo.Profile;
            string value = profile.DisplayName;
            string suffix = (value.Substring (Mathf.Max (0, value.Length - 5)));
            int parsedSuffix = 0;
            if (int.TryParse (suffix, out parsedSuffix))
            {
                if (parsedSuffix > 0)
                {
                    playerItem.PlayerName.text = (value.Substring (0, value.Length - 5));
                }
                else
                {
                    playerItem.PlayerName.text = (value);
                }
            }
            else
            {
                playerItem.PlayerName.text = (value);
            }

            playerItem.Clear ();
            //playerItem.PlayerName.text = friend.Profile.DisplayName;
            playerItem.onPlayerInfoClick += OnProfileClicked;
            if (friend.Profile.Statistics != null)
            {
                var eloStat = friend.Profile.Statistics.Find (stat => stat.Name == "ELO");
                playerItem.PlayerRank.text = "-";
                if (eloStat != null)
                {
                    playerItem.PlayerRank.text = eloStat.Value.ToString ();
                }
            }

            playerItem.OnlinePip.interactable = false;
            playerItem.OnlineStatus.color = playerItem.Offline;
            playerItem.OnlineStatus.text = "offline";
            playerItem.OnlineStatus.gameObject.SetActive (true);

            _friendMap.Add (friend.FriendPlayFabId, playerItem);

            FirebaseService.DatabaseReference.Child (string.Format ("Players/{0}/State", friend.FriendPlayFabId)).ValueChanged += FriendInfoChanged;

            //playerItem.DeleteFriendButton.onClick.AddListener(() => { OnDeletePlayer(playerItem, friend); });//button never visible
            //playerItem.gameObject.SetActive(false);
            i++;
        }
    }

    public void ShowRecentList (ListView listView = null)
    {
        _recentPlayerList.Clear ();
        if (_recentList != null)
        {
            _recentList.ClearContainer ();
            _recentList.OnContainerRebuild -= OnBuildRecentList;
        }

        _recentList = listView == null ? _recentList == null ? View.TabPanels[1].GetComponent<ListView> () : _recentList : listView;
        _recentList.OnContainerRebuild -= OnBuildRecentList;
        _recentList.OnContainerRebuild += OnBuildRecentList;
        _recentList.ClearContainer ();

        Dictionary<string, PlayFab.ClientModels.FriendInfo> recentMap = new Dictionary<string, PlayFab.ClientModels.FriendInfo> ();

        for (int e = 0, i = GameDataManager.AccountData.MatchHistory.Count - 1; i > -1 && e < 10; i--)
        {
            var match = GameDataManager.AccountData.MatchHistory[i];
            for (int j = 0, jlen = match.BlueStats.Count; j < jlen; j++)
            {
                var stat = match.BlueStats[j];

                if (string.IsNullOrEmpty (stat.PlayFabId) || stat.PlayFabId == "-1")
                {
                    continue;
                }

                if (stat.PlayFabId == PlayerAccountData.PlayFabId)
                {
                    continue;
                }

                if (recentMap.ContainsKey (stat.PlayFabId))
                {
                    continue;
                }

                PlayFab.ClientModels.FriendInfo friendInfo = new PlayFab.ClientModels.FriendInfo
                {
                    FriendPlayFabId = stat.PlayFabId,
                    Profile = new PlayerProfileModel
                    {
                    DisplayName = stat.DisplayName,
                    PlayerId = stat.PlayFabId
                    }
                };

                e++;
                _recentPlayerList.Add (friendInfo);
                recentMap.Add (stat.PlayFabId, friendInfo);
            }

            for (int j = 0, jlen = match.RedStats.Count; j < jlen; j++)
            {
                var stat = match.RedStats[j];

                if (string.IsNullOrEmpty (stat.PlayFabId) || stat.PlayFabId == "-1")
                {
                    continue;
                }

                if (stat.PlayFabId == PlayerAccountData.PlayFabId)
                {
                    continue;
                }

                if (recentMap.ContainsKey (stat.PlayFabId))
                {
                    continue;
                }

                PlayFab.ClientModels.FriendInfo friendInfo = new PlayFab.ClientModels.FriendInfo
                {
                    FriendPlayFabId = stat.PlayFabId,
                    Profile = new PlayerProfileModel
                    {
                    DisplayName = stat.DisplayName,
                    PlayerId = stat.PlayFabId
                    }
                };

                e++;
                _recentPlayerList.Add (friendInfo);
                recentMap.Add (stat.PlayFabId, friendInfo);
            }
        }

        _recentList.BulkAddToContainer (View.PlayerListItemPrefab, _recentPlayerList.Count);
    }

}