/// <summary>
 /// Tries to handle command from given string
 /// </summary>
 /// <param name="inputLine">Chat line</param>
 public void TryHandle(string inputLine)
 {
     string[] strArray = inputLine.Substring(1).Split(' ');
     if (!allCommands.TryGetValue(strArray[0].ToLower(), out ChatCommand cmd))
     {
         NotFound(strArray[0].ToLower());
         return;
     }
     if (cmd.RequireMC && !PhotonNetwork.IsMasterClient)
     {
         UI.Chat.Add(ChatCommand.Lang["errMC"]);
         return;
     }
     string[] args = CommandsExtensions.ParseCommandArgs(inputLine, 1);
     try
     {
         if (cmd.Execute(args))
         {
             cmd.OnSuccess();
         }
         else
         {
             cmd.OnFail();
         }
     }
     catch (System.Exception ex)
     {
         UI.Chat.Add(ChatCommand.Lang.Format("errExecute", cmd.CommandName));
         UnityEngine.Debug.Log($"Exception occured while executing command: {cmd.CommandName}\nException message: {ex.Message}\nStackTrace:\n{ex.StackTrace}");
     }
     cmd.OnFinalize();
 }
        /// <summary>
        /// Настройка обработчика команд
        /// </summary>
        private static void SetupCommands(CommandHandler commandHandler)
        {
            commandHandler.Add(new Command("set_protocol", (string[] args) =>
            {
                var networkService   = Toolbox.GetTool <INetworkService>();
                IPAddress recieverIp = null;
                int recieverPort     = -1;
                int listenerPort     = -1;

                if (networkService != null)
                {
                    recieverIp   = networkService.RecieverIp;
                    recieverPort = networkService.RecieverPort;
                    listenerPort = networkService.ListenerPort;

                    networkService.Dispose();
                    Toolbox.Remove(networkService);
                }
                else
                {
                    recieverIp = IPAddress.Loopback;
                }

                if (args.Length > 0)
                {
                    switch (args[0])
                    {
                    case "udp":
                        var udpService = new UdpService();
                        udpService.SetRecieverInfo(recieverIp.ToString(), recieverPort);

                        if (listenerPort >= 0)
                        {
                            udpService.SetListenerPort(listenerPort);
                        }

                        Toolbox.Add(udpService);
                        Print.Log("Установлен протокол UDP", Color.DarkBlue);
                        break;

                    case "tcp":
                        Print.Log("Установлен протокол TCP", Color.DarkBlue);
                        var tcpService = new TcpService();
                        tcpService.SetRecieverInfo(recieverIp.ToString(), recieverPort);

                        if (listenerPort >= 0)
                        {
                            tcpService.SetListenerPort(listenerPort);
                        }

                        Toolbox.Add(tcpService);
                        break;

                    default:
                        var udpServiceDefault = new UdpService();
                        udpServiceDefault.SetRecieverInfo(recieverIp.ToString(), recieverPort);

                        if (listenerPort >= 0)
                        {
                            udpServiceDefault.SetListenerPort(listenerPort);
                        }

                        Toolbox.Add(udpServiceDefault);
                        Print.LogWarning("По умолчанию выбран протокол UDP");
                        break;
                    }
                }
                else
                {
                    var udpServiceDefault = new UdpService();
                    udpServiceDefault.SetRecieverInfo(recieverIp.ToString(), recieverPort);

                    if (listenerPort >= 0)
                    {
                        udpServiceDefault.SetListenerPort(listenerPort);
                    }

                    Toolbox.Add(udpServiceDefault);
                    Print.LogWarning("По умолчанию выбран протокол UDP");
                }
            })).Invoke(new string[] { "tcp" });

            commandHandler.Add(new Command("set_reciever_ip", (string[] args) =>
            {
                var networkService = Toolbox.GetTool <INetworkService>();

                if (networkService == null)
                {
                    Print.LogWarning("Протокол не установлен!");
                    return;
                }

                if (args.Length > 0)
                {
                    networkService.SetRecieverIp(args[0]);
                    return;
                }

                Print.LogError("Отсутствует аргумент адреса!");
            }));

            commandHandler.Add(new Command("set_reciever_port", (string[] args) =>
            {
                var networkService = Toolbox.GetTool <INetworkService>();

                if (networkService == null)
                {
                    Print.LogWarning("Протокол не установлен!");
                    return;
                }

                if (args.Length > 0)
                {
                    var numList = CommandsExtensions.ParseInt(args);

                    if (numList.Count > 0)
                    {
                        networkService.SetRecieverPort(numList[0]);
                        return;
                    }
                }

                Print.LogError("Отсутствует аргумент порта!");
            }));

            commandHandler.Add(new Command("set_listener_port", (string[] args) =>
            {
                var networkService = Toolbox.GetTool <INetworkService>();

                if (networkService == null)
                {
                    Print.LogWarning("Протокол не установлен!");
                    return;
                }

                if (args.Length > 0)
                {
                    var numList = CommandsExtensions.ParseInt(args);

                    if (numList.Count > 0)
                    {
                        networkService.SetListenerPort(numList[0]);
                        return;
                    }
                }

                Print.LogError("Отсутствует аргумент порта!");
            }));

            commandHandler.Add(new Command("send_ping", (string[] args) =>
            {
                var networkService = Toolbox.GetTool <INetworkService>();

                if (networkService == null)
                {
                    Print.LogWarning("Протокол не установлен!");
                    return;
                }

                networkService.Send($"ping from {Process.GetCurrentProcess().Id}");
            }));

            commandHandler.Add(new Command("show_msbuf", (string[] args) =>
            {
                var msbuf = Toolbox.GetTool <MessageBuffer>();

                if (msbuf == null)
                {
                    Print.LogError("Буфер сообщений отсутствует.");
                    return;
                }

                if (msbuf.Messages.Count == 0)
                {
                    Print.Log("Сообщений нет.", Color.DarkBlue);
                    return;
                }

                foreach (var str in msbuf.QueryQueue())
                {
                    Print.Log(str, Color.Blue);
                }
            }));

            commandHandler.Handle("set_reciever_port : 7777");
            commandHandler.Handle("set_listener_port : 7777");
        }