FREE Friends : 1.1.1 1.1.1

using Oxide.Game.Rust.Cui;
using UnityEngine;
using System.Linq;
using System.Collections.Generic;
using Oxide.Core;
using Newtonsoft.Json;
using System.Text;
using Oxide.Core.Plugins;

namespace Oxide.Plugins 
{
    [Info("Friends", "walkinrey", "1.1.1f")]
    public class Friends : RustPlugin
    {
        [PluginReference] private Plugin ImageLibrary;

        private Dictionary<ulong, string> _lastInput = new Dictionary<ulong, string>();
        private Dictionary<ulong, int> _viewingNow = new Dictionary<ulong, int>();
        private Dictionary<ulong, ulong> _pendingRequests = new Dictionary<ulong, ulong>();

        private Dictionary<ulong, float> _requestCooldown = new Dictionary<ulong, float>();

        private const string _middleAnchor = "0.5 0.5";

        #region Конфиг

        private Configuration _config;

        private class Configuration
        {
            [JsonProperty("Кнопки быстрого доступа, слева от кнопки удалить (макс.3)")]
            public List<FriendButton> friendButtons = new List<FriendButton>();

            [JsonProperty("Настройка задержек")]
            public CooldownSetup cooldowns = new CooldownSetup();

            [JsonProperty("Настройка интерфейса")]
            public GUISetup gui = new GUISetup();

            [JsonProperty("Настройки логирования")]
            public LogOptions logs = new LogOptions();

            [JsonProperty("Время на принятие заявки в друзья")]
            public float addTime = 30f;

            [JsonProperty("Максимальное кол-во друзей")]
            public int maxFriends = 35;

            public class LogOptions 
            {
                [JsonProperty("Включить логирование в файл?")]
                public bool enableLogs = false;

                [JsonProperty("Логировать о добавлении в друзья?")]
                public bool logAddFriends = true;

                [JsonProperty("Логировать о удалении из друзей?")]
                public bool logRemoveFriends = true;

                [JsonProperty("Логировать о игнорировании запроса в друзья?")]
                public bool logIgnoreRequest = true;

                [JsonProperty("Логировать о добавлении шкафа в дата-файл игрока?")]
                public bool logCupboardAdd = true;

                [JsonProperty("Логировать о добавлении турели в дата-файл игрока?")]
                public bool logTurretsAdd = true;
            }

            public class FriendButton 
            {
                [JsonProperty("Отображаемое название")]
                public string name = "Телепорт";

                [JsonProperty("Исполняемая чатовая команда")]
                public string command = "tpr %FRIEND_ID% %FRIEND_NAME%";
            }

            public class CooldownSetup
            {
                [JsonProperty("Стандартная задержка на добавление в друзья")]
                public float cooldown = 60f;

                [JsonProperty("Задержка на добавление в друзья по пермишону")]
                public Dictionary<string, float> permissionCooldown = new Dictionary<string, float>();
            }

            public class GUISetup 
            {
                [JsonProperty("Цвет задней панели (при использовании картинки используется для указания ее цвета)")]
                public string bgColor = "#242424";

                [JsonProperty("Цвет основной панели")]
                public string panelMainColor = "#333232";

                [JsonProperty("Цвет второстепенных панелей")]
                public string panelSecondColor = "#424242";

                [JsonProperty("Цвет кнопок перелистывания, панели информации о друзьях и опций")]
                public string panelThirdColor = "#525252";

                [JsonProperty("Цвет кнопок включить, отправить заявку в друзья")]
                public string greenButtonsColor = "#27ae60";

                [JsonProperty("Цвет кнопок выключить, удалить, закрыть")]
                public string redButtonsColor = "#e74c3c";

                [JsonProperty("Цвет дополнительных кнопок")]
                public string additionalButtonsColor = "#7f8c8d";

                [JsonProperty("Положение панели запроса в друзья")]
                public CuiRectTransformComponent panelRequest = new CuiRectTransformComponent();

                [JsonProperty("Картинка заднего фона")]
                public BackgroundImage image = new BackgroundImage();

                public class BackgroundImage 
                {
                    [JsonProperty("Использовать картинку для заднего фона?")]
                    public bool enableImage = false;

                    [JsonProperty("Ссылка на картинку")]
                    public string imageUrl = "";
                }
            }

            public static Configuration GetDefault()
            {
                Configuration configuration = new Configuration();
                
                configuration.friendButtons = new List<FriendButton>
                {
                    new FriendButton(),

                    new FriendButton
                    {
                        name = "Трейд",
                        command = "trade %FRIEND_ID% %FRIEND_NAME%"
                    }
                };

                configuration.gui.panelRequest = new CuiRectTransformComponent
                {
                    AnchorMin = "0.75 0.07",
                    AnchorMax = "0.75 0.07",

                    OffsetMin = "-120 -31",
                    OffsetMax = "100 25"
                };

                configuration.cooldowns.permissionCooldown.Add("friends.vip", 30f);
                configuration.cooldowns.permissionCooldown.Add("friends.premium", 10f);

                return configuration;
            }
        }

        protected override void LoadDefaultConfig() => _config = Configuration.GetDefault();

        protected override void SaveConfig() => Config.WriteObject(_config);

        protected override void LoadConfig()
        {
            base.LoadConfig();

            try 
            {
                _config = Config.ReadObject<Configuration>();
            }
            catch 
            {
                LoadDefaultConfig();
            }

            NextTick(SaveConfig);
        }

        #endregion

        #region Дата

        private DataFile _data;

        private class DataFile 
        {
            public Dictionary<ulong, PlayerData> playersData = new Dictionary<ulong, PlayerData>();

            public class PlayerData 
            {
                public List<FriendInfo> friends = new List<FriendInfo>();

                public List<uint> entitiesCupboard = new List<uint>();
                public List<uint> entitiesTurret = new List<uint>();

                public bool enableAuthorizeLocks, enableAuthorizeCupboards, enableAuthorizeTurrets, enableFF;
            
                public class FriendInfo 
                {
                    public ulong id; 
                    public string name;
                }
            }

            public PlayerData GetPlayerData(ulong userID)
            {
                PlayerData data;

                if(playersData.ContainsKey(userID)) data = playersData[userID];
                else
                {
                    data = new DataFile.PlayerData();
                    SetPlayerData(userID, data);
                }

                return data;
            }

            public void SetPlayerData(ulong userID, PlayerData data)
            {
                if(playersData.ContainsKey(userID)) playersData.Remove(userID);

                playersData.Add(userID, data);
            }
        }

        protected void LoadData() 
        {
            try 
            {
                _data = Interface.Oxide.DataFileSystem.ReadObject<DataFile>("Friends");
            }
            catch 
            {
                _data = new DataFile();
            }

            NextTick(() => SaveData());
        }

        protected void SaveData(bool needLog = false) 
        {
            Interface.Oxide.DataFileSystem.WriteObject("Friends", _data);
            
            if(needLog) Puts("Дата-файл сохранен.");
        }

        #endregion

        #region Локализация

        protected override void LoadDefaultMessages()
        {
            lang.RegisterMessages(new Dictionary<string, string>
            {
                ["Error_EnterName"] = "Введите никнейм игрока!",
                ["Error_NoPlayerFounded"] = "Не удалось найти игрока с таким никнеймом, возможно он не в сети!",
                ["Error_PlayerAlreadyFriend"] = "Игрок {0} уже у вас в друзьях!",
                ["Error_MaxFriends"] = "Вы достигли максимального кол-ва друзей!",
                ["Error_CooldownTime"] = "Подождите {0} секунд, прежде чем снова отправить заявку!",
                ["Error_HasIncoming"] = "У игрока уже есть другая входящая заявка в друзья!",
                ["Error_CantDelete"] = "Не удалось удалить друга!",
                ["Error_CantAccept"] = "Не удалось принять заявку в друзья!",
                ["Error_NoIncoming"] = "У вас нет входящих заявок в друзья!",
                ["Success_RequestSended"] = "Заявка успешно отправлена игроку {0}",
                ["Success_FriendDeleted"] = "Игрок {0} успешно удален из списка друзей!",
                ["Success_RequestDeclined"] = "Вы отклонили заявку в друзья",
                ["Success_RequestDeclined_Player"] = "Вы отклонили заявку в друзья от игрока {0}",
                ["Notice_FriendDeleted"] = "Игрок {0} удалил вас из списка друзей!",
                ["Notice_FriendClaimed_Target"] = "Игрок {0} теперь у вас в друзьях!",
                ["Notice_FriendClaimed_Player"] = "Теперь {0} является вашим другом!",
                ["Notice_RequestDeclined"] = "Игрок {0} отклонил вашу заявку в друзья",
                ["Notice_RequestOut_Target"] = "Время на принятие заявки истекло!",
                ["Notice_RequestOut_Sender"] = "Игрок {0} не принял вашу заявку вовремя!",
                ["Info_FF"] = "Огонь по друзьям: {0}",
                ["Info_Locks"] = "Авторизация в замках: {0}",
                ["Info_Turrets"] = "Авторизация в турелях: {0}",
                ["Info_Cupboard"] = "Авторизация в шкафах: {0}",
                ["Status_Enabled"] = "Включено",
                ["Status_Disabled"] = "Отключено",
                ["GUI_Header_Text"] = "RustyFriends",
                ["GUI_Settings"] = "Настройки",
                ["GUI_FriendList"] = "Список друзей",
                ["GUI_FriendAdd"] = "Добавить в друзья",
                ["GUI_Auth_Locks"] = "Авторизация в замках",
                ["GUI_Auth_Cupboard"] = "Авторизация в шкафах",
                ["GUI_Auth_Turret"] = "Авторизация в турелях",
                ["GUI_FF"] = "Урон по друзьям",
                ["GUI_FriendAdd_Nickname"] = "Введите никнейм",
                ["GUI_FriendAdd_SendRequest"] = "Отправить заявку в друзья",
                ["GUI_Disable_Text"] = "Выкл.",
                ["GUI_Enable_Text"] = "Вкл.",
                ["GUI_Request_Info"] = "Заявка в друзья от {0}",
                ["GUI_Request_Accept"] = "Принять",
                ["GUI_Request_Decline"] = "Отклонить",
                ["GUI_Card_Button_Remove"] = "Удалить"
            }, this, "ru");
        
            lang.RegisterMessages(new Dictionary<string, string>
            {
                ["Error_EnterName"] = "Enter player nickname!",
                ["Error_NoPlayerFounded"] = "Couldn't find a player with that nickname, maybe he's offline!",
                ["Error_PlayerAlreadyFriend"] = "Player {0} is already your friend!",
                ["Error_MaxFriends"] = "You have reached the maximum number of friends!",
                ["Error_CooldownTime"] = "Wait {0} seconds before send your friend request again!",
                ["Error_HasIncoming"] = "The player already has another incoming friend request!",
                ["Error_CantDelete"] = "Failed to delete friend!",
                ["Error_CantAccept"] = "Failed to accept friend request!",
                ["Error_NoIncoming"] = "You have no incoming friend requests!",
                ["Success_RequestSended"] = "The request has been successfully sent to player {0}",
                ["Success_FriendDeleted"] = "Player {0} has been successfully removed from your friends list!",
                ["Success_RequestDeclined"] = "You declined a friend request",
                ["Success_RequestDeclined_Player"] = "You declined a friend request from player {0}",
                ["Notice_FriendDeleted"] = "Player {0} has removed you from the friends list!",
                ["Notice_FriendClaimed_Target"] = "Player {0} is now your friend!",
                ["Notice_FriendClaimed_Player"] = "Now {0} is your friend!",
                ["Notice_RequestDeclined"] = "Player {0} has rejected your friend request",
                ["Notice_RequestOut_Target"] = "The time for accepting friend request has expired!",
                ["Notice_RequestOut_Sender"] = "Player {0} did not accept your friend request on time!",
                ["Info_FF"] = "Friendly Fire: {0}",
                ["Info_Locks"] = "Locks auth: {0}",
                ["Info_Turrets"] = "Turrets auth: {0}",
                ["Info_Cupboard"] = "Cupboards auth: {0}",
                ["Status_Enabled"] = "Enabled",
                ["Status_Disabled"] = "Disabled",
                ["GUI_Header_Text"] = "RustyFriends",
                ["GUI_Settings"] = "Settings",
                ["GUI_FriendList"] = "Friends List",
                ["GUI_FriendAdd"] = "Add as Friend",
                ["GUI_Auth_Locks"] = "Locks auth",
                ["GUI_Auth_Cupboard"] = "Cupboards auth",
                ["GUI_Auth_Turret"] = "Turrets auth",
                ["GUI_FF"] = "Friendly Fire",
                ["GUI_FriendAdd_Nickname"] = "Enter nickname",
                ["GUI_FriendAdd_SendRequest"] = "Send friend request",
                ["GUI_Disable_Text"] = "Off",
                ["GUI_Enable_Text"] = "On",
                ["GUI_Request_Info"] = "Friend request from {0}",
                ["GUI_Request_Accept"] = "Accept",
                ["GUI_Request_Decline"] = "Decline",
                ["GUI_Card_Button_Remove"] = "Remove"
            }, this, "en");
        }

        private string GetMessage(string key, BasePlayer player) => lang.GetMessage(key, this, player.UserIDString);

        #endregion

        #region Методы

        [ChatCommand("friends")]
        private void chatCommand(BasePlayer player, string command, string[] args) 
        {
            if(args == null || args?.Length == 0)
            {
                OpenMenu(player);
            }
            else 
            {
                if(args[0] == "add")
                {
                    if(args.Length != 1)
                    {
                        var nickname = args.ToList();
                        nickname.Remove("add");

                        var data = _data.GetPlayerData(player.userID);
                        var target = (BasePlayer)null;

                        foreach(var playerFind in BasePlayer.activePlayerList)
                        {
                            if(playerFind.displayName.Contains(string.Join(" ", nickname.ToArray())) )
                            {
                                target = playerFind;
                                break;
                            }
                        }

                        if(target == null) target = BasePlayer.Find(string.Join(" ", nickname.ToArray()));

                        if(target == null)
                        {
                            player.ChatMessage(GetMessage("Error_NoPlayerFounded", player));

                            return;
                        }

                        if(data.friends.Count + 2 > _config.maxFriends) 
                        {
                            player.ChatMessage(GetMessage("Error_MaxFriends", player));
                        }

                        if(_requestCooldown.ContainsKey(player.userID))
                        {
                            if(_requestCooldown[player.userID] > UnityEngine.Time.realtimeSinceStartup)
                            {
                                player.ChatMessage(string.Format(GetMessage("Error_CooldownTime", player), Mathf.RoundToInt(_requestCooldown[player.userID] - UnityEngine.Time.realtimeSinceStartup)));

                                return;
                            }
                            else _requestCooldown.Remove(player.userID);
                        }

                        var comp = target.GetComponent<PlayerPendingRequest>();

                        if(comp != null) 
                        {
                            player.ChatMessage(GetMessage("Error_HasIncoming", player));

                            return;
                        }

                        comp = target.gameObject.AddComponent<PlayerPendingRequest>();

                        comp.from = player.userID;
                        comp.to = target.userID;

                        comp.cooldownTime = _config.addTime;

                        RenderRequest(target, player);

                        foreach(var perm in _config.cooldowns.permissionCooldown.Keys)
                        {
                            if(permission.UserHasPermission(player.UserIDString, perm))
                            {
                                _requestCooldown.Add(player.userID, UnityEngine.Time.realtimeSinceStartup + _config.cooldowns.permissionCooldown[perm]);

                                return;
                            }
                        }

                        _requestCooldown.Add(player.userID, UnityEngine.Time.realtimeSinceStartup + _config.cooldowns.cooldown);

                        player.ChatMessage(string.Format(GetMessage("Success_RequestSended", player), target.displayName));
                    }
                    else 
                    {
                        player.ChatMessage(GetMessage("Error_EnterName", player));

                        return;
                    }
                }
            
                if(args[0] == "remove")
                {
                    if(args.Length != 1)
                    {
                        var target = BasePlayer.Find(args[1]);
                        
                        if(target == null) target = BasePlayer.FindSleeping(args[1]);

                        if(target == null)
                        {
                            player.ChatMessage(GetMessage("Error_CantDelete", player));

                            return;
                        } 
                        else 
                        {
                            var data = _data.GetPlayerData(player.userID);

                            if(data.friends.Where(x => x.id == target.userID)?.Count() != 0)
                            {
                                data.friends.RemoveAll(x => x.id == target.userID);
                            }

                            _data.SetPlayerData(player.userID, data);

                            player.ChatMessage(string.Format(GetMessage("Success_FriendDeleted", player), target.displayName));
                        
                            if(target.IsConnected) target.ChatMessage(string.Format(GetMessage("Notice_FriendDeleted", player), target.displayName));

                            var targetData = _data.GetPlayerData(target.userID);

                            targetData.friends.RemoveAll(x => x.id == player.userID);

                            _data.SetPlayerData(target.userID, targetData);

                            if(_config.logs.enableLogs)
                            {
                                if(_config.logs.logRemoveFriends)
                                {
                                    LogToFile("Log", $"Игрок {player} удалил из друзей игрока {target} | Друзей: {data.friends.Count}", this);
                                }
                            }

                            DeAuthFriend(player.userID, target.userID);
                            API_OnFriendRemoved(player.userID, target.userID);

                            SaveData();
                        }
                    }
                    else 
                    {
                        player.ChatMessage(GetMessage("Error_EnterName", player));

                        return;
                    }
                }
            
                if(args[0] == "accept")
                {
                    if(_pendingRequests.ContainsKey(player.userID))
                    {
                        string targetID = _pendingRequests[player.userID].ToString();

                        var target = BasePlayer.Find(targetID);

                        if(target == null) target = BasePlayer.FindSleeping(targetID);

                        if(target == null)
                        {
                            CuiHelper.DestroyUi(player, "Friends_Accept");

                            player.ChatMessage(GetMessage("Error_CantAccept", player));

                            _pendingRequests.Remove(player.userID);
                        }
                        else 
                        {
                            CuiHelper.DestroyUi(player, "Friends_Accept");

                            var data = _data.GetPlayerData(player.userID);

                            if(data.friends.Where(x => x.id == target.userID)?.Count() == 0)
                            {
                                data.friends.Add(new DataFile.PlayerData.FriendInfo
                                {
                                    id = target.userID,
                                    name = target.displayName
                                });
                            }

                            var data2 = _data.GetPlayerData(target.userID);

                            if(data2.friends.Where(x => x.id == player.userID)?.Count() == 0)
                            {
                                data2.friends.Add(new DataFile.PlayerData.FriendInfo
                                {
                                    id = player.userID,
                                    name = player.displayName
                                });
                            }

                            _data.SetPlayerData(player.userID, data);
                            _data.SetPlayerData(target.userID, data2);

                            if(player.IsConnected) player.ChatMessage(string.Format(GetMessage("Notice_FriendClaimed_Player", player), target.displayName));
                            if(target.IsConnected) target.ChatMessage(string.Format(GetMessage("Notice_FriendClaimed_Target", target), player.displayName));
                        
                            _pendingRequests.Remove(target.userID);

                            if(target.GetComponent<PlayerPendingRequest>() != null)
                                UnityEngine.Object.Destroy(target.GetComponent<PlayerPendingRequest>());

                            if(_config.logs.enableLogs)
                            {
                                if(_config.logs.logAddFriends)
                                {
                                    LogToFile("Log", $"Игрок {player} добавил в друзья игрока {target} | Друзей: {data.friends.Count}", this);
                                }
                            }

                            AuthFriend(target.userID, player.userID);
                            API_OnFriendAdded(player.userID, target.userID);

                            SaveData();
                        }
                    }
                    else 
                    {
                        player.ChatMessage(GetMessage("Error_NoIncoming", player));

                        return;
                    }
                }
            
                var playerData = _data.GetPlayerData(player.userID);

                if(args[0] == "ff")
                {
                    playerData.enableFF = !playerData.enableFF;

                    _data.SetPlayerData(player.userID, playerData);

                    player.ChatMessage(string.Format(GetMessage("Info_FF", player), ConvertBool(playerData.enableFF, player).ToLower()));
                }

                if(args[0] == "locks")
                {
                    playerData.enableAuthorizeLocks = !playerData.enableAuthorizeLocks;

                    _data.SetPlayerData(player.userID, playerData);

                    player.ChatMessage(string.Format(GetMessage("Info_Locks", player), ConvertBool(playerData.enableAuthorizeLocks, player).ToLower()));

                    return;
                }

                if(args[0] == "turrets")
                {
                    playerData.enableAuthorizeTurrets = !playerData.enableAuthorizeTurrets;

                    _data.SetPlayerData(player.userID, playerData);

                    player.ChatMessage(string.Format(GetMessage("Info_Turrets", player), ConvertBool(playerData.enableAuthorizeTurrets, player).ToLower()));

                    return;
                }

                if(args[0] == "cupboard")
                {
                    playerData.enableAuthorizeCupboards = !playerData.enableAuthorizeCupboards;

                    _data.SetPlayerData(player.userID, playerData);

                    player.ChatMessage(string.Format(GetMessage("Info_Cupboard", player), ConvertBool(playerData.enableAuthorizeCupboards, player).ToLower()));

                    return;
                }
            }
        }

        [ConsoleCommand("friends")]
        private void ConsoleCommand(ConsoleSystem.Arg arg)
        {
            if(arg.Player() != null)
            {
                var player = arg.Player();

                if(arg.HasArgs())
                { 
                    if(arg.Args[0] == "close")
                    {
                        CuiHelper.DestroyUi(player, "Friends_Background");
                    }

                    if(arg.Args[0] == "command")
                    {
                        if(arg.HasArgs(2))
                        {
                            string args = "";

                            if(arg.HasArgs(3))
                            {
                                for(int i = 3; i < arg.Args.Length; i++)
                                {
                                    args = args + $"\"{arg.Args[i]}\"";
                                }
                            }

                            rust.RunClientCommand(player, $"chat.say", new string[] { $"/{arg.Args[1]} {args}" });
                        }
                    }

                    if(arg.Args[0] == "deauthorize")
                    {
                        if(arg.HasArgs(2))
                        {
                            var playerData = _data.GetPlayerData(player.userID);

                            if(arg.Args[1] == "locks")
                            {
                                if(playerData.enableAuthorizeLocks) playerData.enableAuthorizeLocks = false;
                                else return;
                            }

                            if(arg.Args[1] == "turrets")
                            {
                                if(playerData.enableAuthorizeTurrets) playerData.enableAuthorizeTurrets = false;
                                else return;
                            }

                            if(arg.Args[1] == "cupboard")
                            {
                                if(playerData.enableAuthorizeCupboards) playerData.enableAuthorizeCupboards = false;
                                else return;
                            }

                            _data.SetPlayerData(player.userID, playerData);
                            RenderText(player, arg.Args[1] == "locks", arg.Args[1] == "turrets", false, arg.Args[1] == "cupboard");
                        }
                    }

                    if(arg.Args[0] == "authorize")
                    {
                        if(arg.HasArgs(2))
                        {
                            var playerData = _data.GetPlayerData(player.userID);

                            if(arg.Args[1] == "locks")
                            {
                                if(!playerData.enableAuthorizeLocks) playerData.enableAuthorizeLocks = true;
                                else return;
                            }

                            if(arg.Args[1] == "turrets")
                            {
                                if(!playerData.enableAuthorizeTurrets) playerData.enableAuthorizeTurrets = true;
                                else return;
                            }

                            if(arg.Args[1] == "cupboard")
                            {
                                if(!playerData.enableAuthorizeCupboards) playerData.enableAuthorizeCupboards = true;
                                else return;
                            }

                            _data.SetPlayerData(player.userID, playerData);
                            RenderText(player, arg.Args[1] == "locks", arg.Args[1] == "turrets", false, arg.Args[1] == "cupboard");
                        }
                    }

                    if(arg.Args[0] == "ff")
                    {
                        if(arg.HasArgs(2))
                        {
                            var playerData = _data.GetPlayerData(player.userID);

                            if(arg.Args[1] == "enable")
                            {
                                if(!playerData.enableFF) playerData.enableFF = true;
                                else return;
                            }

                            if(arg.Args[1] == "disable")
                            {
                                if(playerData.enableFF) playerData.enableFF = false;
                                else return;
                            }

                            _data.SetPlayerData(player.userID, playerData);
                            RenderText(player, false, false, true, false);
                        }
                    }

                    if(arg.Args[0] == "insert")
                    {
                        if(arg.HasArgs(2))
                        {
                            if(_lastInput.ContainsKey(player.userID)) _lastInput.Remove(player.userID);

                            _lastInput.Add(player.userID, arg.Args[1]);
                        }
                    }

                    if(arg.Args[0] == "add")
                    {
                        if(_lastInput.ContainsKey(player.userID))
                        {
                            var nickname = _lastInput[player.userID];

                            var target = (BasePlayer)null;
                            var data = _data.GetPlayerData(player.userID);

                            foreach(var playerFind in BasePlayer.activePlayerList)
                            {
                                if(playerFind.displayName.Contains(nickname))
                                {
                                    target = playerFind;
                                    break;
                                }
                            }

                            if(target == null) target = BasePlayer.Find(nickname);

                            if(target == null)
                            {
                                RenderNotice(player, GetMessage("Error_NoPlayerFounded", player));
                            }
                            else 
                            {
                                if(data.friends.Where(x => x.id == target.userID)?.Count() != 0)
                                {
                                    RenderNotice(player, string.Format(GetMessage("Error_PlayerAlreadyFriend", player), target.displayName));
                                }
                                else
                                {
                                    if(data.friends.Count + 2 > _config.maxFriends) 
                                    {
                                        RenderNotice(player, GetMessage("Error_MaxFriends", player));
                                    }
                                    else 
                                    {
                                        if(_requestCooldown.ContainsKey(player.userID))
                                        {
                                            if(_requestCooldown[player.userID] > UnityEngine.Time.realtimeSinceStartup)
                                            {
                                                RenderNotice(player, string.Format(GetMessage("Error_CooldownTime", player), Mathf.RoundToInt(_requestCooldown[player.userID] - UnityEngine.Time.realtimeSinceStartup)));

                                                return;
                                            }
                                            else _requestCooldown.Remove(player.userID);
                                        }

                                        var comp = target.GetComponent<PlayerPendingRequest>();

                                        if(comp != null) 
                                        {
                                            RenderNotice(player, GetMessage("Error_HasIncoming", player));
                                            return;
                                        }

                                        comp = target.gameObject.AddComponent<PlayerPendingRequest>();

                                        comp.from = player.userID;
                                        comp.to = target.userID;

                                        comp.cooldownTime = _config.addTime;

                                        RenderNotice(player, string.Format(GetMessage("Success_RequestSended", player), target.displayName));
                                        RenderRequest(target, player);

                                        foreach(var perm in _config.cooldowns.permissionCooldown.Keys)
                                        {
                                            if(permission.UserHasPermission(player.UserIDString, perm))
                                            {
                                                _requestCooldown.Add(player.userID, UnityEngine.Time.realtimeSinceStartup + _config.cooldowns.permissionCooldown[perm]);

                                                return;
                                            }
                                        }

                                        _requestCooldown.Add(player.userID, UnityEngine.Time.realtimeSinceStartup + _config.cooldowns.cooldown);
                                    }
                                }
                            }
                        }
                    }
                    
                    if(arg.Args[0] == "remove")
                    {
                        if(arg.HasArgs(2))
                        {
                            var target = BasePlayer.Find(arg.Args[1]);

                            if(target == null) target = BasePlayer.FindSleeping(arg.Args[1]);

                            if(target == null)
                            {
                                RenderNotice(player, GetMessage("Error_CantDelete", player));
                            } 
                            else 
                            {
                                var data = _data.GetPlayerData(player.userID);

                                if(data.friends.Where(x => x.id == target.userID)?.Count() != 0)
                                {
                                    data.friends.RemoveAll(x => x.id == target.userID);
                                }

                                _data.SetPlayerData(player.userID, data);

                                OpenMenu(player, 1, false);
                                RenderNotice(player, string.Format(GetMessage("Success_FriendDeleted", player), target.displayName));
                            
                                if(target.IsConnected) target.ChatMessage(string.Format(GetMessage("Notice_FriendDeleted", target), player.displayName));

                                var targetData = _data.GetPlayerData(target.userID);

                                targetData.friends.RemoveAll(x => x.id == player.userID);

                                _data.SetPlayerData(target.userID, targetData);

                                if(_config.logs.enableLogs)
                                {
                                    if(_config.logs.logRemoveFriends)
                                    {
                                        LogToFile("Log", $"Игрок {player} удалил из друзей игрока {target} | Друзей: {data.friends.Count}", this);
                                    }
                                }

                                DeAuthFriend(player.userID, target.userID);
                                API_OnFriendRemoved(player.userID, target.userID);

                                SaveData();
                            }
                        }
                    }

                    if(arg.Args[0] == "accept")
                    {
                        if(_pendingRequests.ContainsKey(player.userID))
                        {
                            string targetID = _pendingRequests[player.userID].ToString();

                            var target = BasePlayer.Find(targetID);

                            if(target == null) target = BasePlayer.FindSleeping(targetID);

                            if(target == null)
                            {
                                CuiHelper.DestroyUi(player, "Friends_Accept");

                                player.ChatMessage(GetMessage("Error_CantAccept", player));

                                _pendingRequests.Remove(player.userID);
                            }
                            else 
                            {
                                CuiHelper.DestroyUi(player, "Friends_Accept");

                                var data = _data.GetPlayerData(player.userID);

                                if(data.friends.Where(x => x.id == target.userID)?.Count() == 0)
                                {
                                    data.friends.Add(new DataFile.PlayerData.FriendInfo
                                    {
                                        id = target.userID,
                                        name = target.displayName
                                    });
                                }

                                var data2 = _data.GetPlayerData(target.userID);

                                if(data2.friends.Where(x => x.id == player.userID)?.Count() == 0)
                                {
                                    data2.friends.Add(new DataFile.PlayerData.FriendInfo
                                    {
                                        id = player.userID,
                                        name = player.displayName
                                    });
                                }

                                _data.SetPlayerData(player.userID, data);
                                _data.SetPlayerData(target.userID, data2);

                                if(player.IsConnected) player.ChatMessage(string.Format(GetMessage("Notice_FriendClaimed_Player", player), target.displayName));
                                if(target.IsConnected) target.ChatMessage(string.Format(GetMessage("Notice_FriendClaimed_Target", target), player.displayName));
                            
                                _pendingRequests.Remove(target.userID);

                                if(target.GetComponent<PlayerPendingRequest>() != null)
                                    UnityEngine.Object.Destroy(target.GetComponent<PlayerPendingRequest>());

                                if(_config.logs.enableLogs)
                                {
                                    if(_config.logs.logAddFriends)
                                    {
                                        LogToFile("Log", $"Игрок {player} добавил в друзья игрока {target} | Друзей: {data.friends.Count}", this);
                                    }
                                }

                                AuthFriend(target.userID, player.userID);
                                API_OnFriendAdded(player.userID, target.userID);

                                SaveData();
                            }
                        }
                    }

                    if(arg.Args[0] == "noaccept")
                    {
                        if(_pendingRequests.ContainsKey(player.userID))
                        {
                            CuiHelper.DestroyUi(player, "Friends_Accept");

                            ulong targetID = _pendingRequests[player.userID];

                            var target = BasePlayer.Find(targetID.ToString());

                            if(target == null) target = BasePlayer.FindSleeping(targetID.ToString());

                            if(target != null) target.ChatMessage(string.Format(GetMessage("Notice_RequestDeclined", target), player.displayName));

                            _pendingRequests.Remove(player.userID);

                            if(target.GetComponent<PlayerPendingRequest>() != null)
                                UnityEngine.Object.Destroy(target.GetComponent<PlayerPendingRequest>());

                            if(target != null) player.ChatMessage(string.Format(GetMessage("Success_RequestDeclined_Player", player), target.displayName));
                            else player.ChatMessage(GetMessage("Success_RequestDeclined", player));
                        }
                    }

                    if(arg.Args[0] == "page+")
                    {
                        if(!_viewingNow.ContainsKey(player.userID)) return;
                        else 
                        {
                            int page = _viewingNow[player.userID];
                            int allFriends = _data.GetPlayerData(player.userID).friends.Count;

                            if(10 * page < allFriends)
                            {
                                _viewingNow.Remove(player.userID);
                                _viewingNow.Add(player.userID, page + 1);

                                RenderFriends(player, null, page + 1);
                            }
                            else return;
                        }
                    }

                    if(arg.Args[0] == "page-")
                    {
                        if(!_viewingNow.ContainsKey(player.userID)) return;
                        else 
                        {
                            int page = _viewingNow[player.userID];

                            if(page <= 1) return;
                            else 
                            {
                                _viewingNow.Remove(player.userID);
                                _viewingNow.Add(player.userID, page - 1);

                                RenderFriends(player, null, page - 1);
                            }
                        }
                    }
                }   
            }
        }

        #endregion

        #region GUI

        private string ConvertBool(bool value, BasePlayer player)
        {
            if(value) return GetMessage("Status_Enabled", player);
            else return GetMessage("Status_Disabled", player);
        }

        private static string HexToRustFormat(string hex)
        {
            Color color;
            ColorUtility.TryParseHtmlString(hex, out color);

            var sb = new StringBuilder();
            return sb.AppendFormat("{0:F2} {1:F2} {2:F2} {3:F2}", color.r, color.g, color.b, color.a).ToString();
        }

        private void OpenMenu(BasePlayer player, int page = 1, bool recreateBackground = true)
        {
            var data = _data.GetPlayerData(player.userID);

            CuiElementContainer container = new CuiElementContainer();

            if(recreateBackground)
            {
                if(_config.gui.image.enableImage)
                {
                    if(ImageLibrary != null)
                    {
                        container.Add(new CuiElement 
                        {
                            Name = "Friends_Background",
                            Parent = "Overlay",

                            Components = 
                            {
                                new CuiRawImageComponent
                                {
                                    Png = ImageLibrary.Call<string>("GetImage", "Friends_Background"),
                                    Color = HexToRustFormat(_config.gui.bgColor)
                                },

                                new CuiNeedsCursorComponent(),

                                new CuiRectTransformComponent
                                {
                                    AnchorMin = "0 0",
                                    AnchorMax = "1 1"
                                },
                            }
                        });
                    }
                    else 
                    {
                        container.Add(new CuiElement 
                        {
                            Name = "Friends_Background",
                            Parent = "Overlay",

                            Components = 
                            {
                                new CuiRawImageComponent
                                {
                                    Url = _config.gui.image.imageUrl,
                                    Color = HexToRustFormat(_config.gui.bgColor)
                                },

                                new CuiNeedsCursorComponent(),

                                new CuiRectTransformComponent
                                {
                                    AnchorMin = "0 0",
                                    AnchorMax = "1 1"
                                },
                            }
                        });
                    }
                }
                else 
                {
                    container.Add(new CuiElement 
                    {
                        Name = "Friends_Background",
                        Parent = "Overlay",

                        Components = 
                        {
                            new CuiImageComponent
                            {
                                Color = HexToRustFormat(_config.gui.bgColor)
                            },

                            new CuiNeedsCursorComponent(),

                            new CuiRectTransformComponent
                            {
                                AnchorMin = "0 0",
                                AnchorMax = "1 1"
                            },
                        }
                    });
                }
            }

            container.Add(new CuiElement 
            {
                Name = "Friends_Main",
                Parent = "Friends_Background",

                Components = 
                {
                    new CuiRectTransformComponent
                    {
                        AnchorMin = _middleAnchor,
                        AnchorMax = _middleAnchor
                    }
                }
            });

            container.Add(new CuiElement 
            {
                Name = "Main_Panel",
                Parent = "Friends_Main",

        
// ... [Code preview truncated due to length. Full source in attached file] ...