public static void CheckServer(Server server)
 {
     CheckPort(server.server_port);
     CheckPassword(server.password);
     CheckServer(server.server);
     CheckTimeout(server.timeout, Server.MaxServerTimeoutSec);
 }

        private bool SaveOldSelectedServer()
        {
            try
            {
                if (_lastSelectedIndex == -1 || _lastSelectedIndex >= _modifiedConfiguration.configs.Count)
                {
                    return true;
                }
                Server server = new Server
                {
                    server = IPTextBox.Text,
                    server_port = int.Parse(ServerPortTextBox.Text),
                    password = PasswordTextBox.Text,
                    method = EncryptionSelect.Text,
                    remarks = RemarksTextBox.Text
                };
                int localPort = int.Parse(ProxyPortTextBox.Text);
                Configuration.CheckServer(server);
                Configuration.CheckLocalPort(localPort);
                _modifiedConfiguration.configs[_lastSelectedIndex] = server;
                _modifiedConfiguration.localPort = localPort;

                return true;
            }
            catch (FormatException)
            {
                MessageBox.Show(I18N.GetString("Illegal port number format"));
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
            return false;
        }

 public StatisticsStrategy(ShadowsocksController controller)
 {
     _controller = controller;
     var servers = controller.GetCurrentConfiguration().configs;
     var randomIndex = new Random().Next() % servers.Count();
     _currentServer = servers[randomIndex];  //choose a server randomly at first
     _timer = new Timer(ReloadStatisticsAndChooseAServer);
 }

 public bool AddServerBySSURL(string ssURL)
 {
     try
     {
         var server = new Server(ssURL);
         _config.configs.Add(server);
         _config.index = _config.configs.Count - 1;
         SaveConfig(_config);
         return true;
     }
     catch (Exception e)
     {
         Logging.LogUsefulException(e);
         return false;
     }
 }

 /**
  * once failed, try after 5 min
  * and (last write - last read) < 5s
  * and (now - last read) <  5s  // means not stuck
  * and latency < 200ms, try after 30s
  */
 public void ChooseNewServer()
 {
     Server oldServer = _currentServer;
     List<ServerStatus> servers = new List<ServerStatus>(_serverStatus.Values);
     DateTime now = DateTime.Now;
     foreach (var status in servers)
     {
         // all of failure, latency, (lastread - lastwrite) normalized to 1000, then
         // 100 * failure - 2 * latency - 0.5 * (lastread - lastwrite)
         status.score =
             100 * 1000 * Math.Min(5 * 60, (now - status.lastFailure).TotalSeconds)
             -2 * 5 * (Math.Min(2000, status.latency.TotalMilliseconds) / (1 + (now - status.lastTimeDetectLatency).TotalSeconds / 30 / 10) +
             -0.5 * 200 * Math.Min(5, (status.lastRead - status.lastWrite).TotalSeconds));
         Logging.Debug(String.Format("server: {0} latency:{1} score: {2}", status.server.FriendlyName(), status.latency, status.score));
     }
     ServerStatus max = null;
     foreach (var status in servers)
     {
         if (max == null)
         {
             max = status;
         }
         else
         {
             if (status.score >= max.score)
             {
                 max = status;
             }
         }
     }
     if (max != null)
     {
         _currentServer = max.server;
         if (_currentServer != oldServer)
         {
             Console.WriteLine("HA switching to server: {0}", _currentServer.FriendlyName());
         }
         Logging.Debug(String.Format("choosing server: {0}", _currentServer.FriendlyName()));
     }
 }

        private void ConnectCallback(IAsyncResult ar)
        {
            Server server = null;
            if (closed)
            {
                return;
            }
            try
            {
                ServerTimer timer = (ServerTimer)ar.AsyncState;
                server = timer.Server;
                timer.Elapsed -= connectTimer_Elapsed;
                timer.Enabled = false;
                timer.Dispose();

                // Complete the connection.
                remote.EndConnect(ar);

                connected = true;

                Logging.Debug($"Socket connected to {remote.RemoteEndPoint}");

                var latency = DateTime.Now - _startConnectTime;
                IStrategy strategy = controller.GetCurrentStrategy();
                strategy?.UpdateLatency(server, latency);
                tcprelay.UpdateLatency(server, latency);

                StartPipe();
            }
            catch (ArgumentException)
            {
            }
            catch (Exception e)
            {
                if (server != null)
                {
                    IStrategy strategy = controller.GetCurrentStrategy();
                    if (strategy != null)
                    {
                        strategy.SetFailure(server);
                    }
                }
                Logging.LogUsefulException(e);
                RetryConnect();
            }
        }

 public void UpdateOutboundCounter(Server server, long n)
 {
     _controller.UpdateOutboundCounter(server, n);
 }

 public void UpdateLatency(Server server, int latency)
 {
     List<int> records;
     _latencyRecords.TryGetValue(server.Identifier(), out records);
     if (records == null)
     {
         records = new List<int>();
     }
     records.Add(latency);
     _latencyRecords[server.Identifier()] = records;
 }

 public void CreateRemote()
 {
     Server server = controller.GetAServer(IStrategyCallerType.TCP, (IPEndPoint)connection.RemoteEndPoint);
     if (server == null || server.server == "")
     {
         throw new ArgumentException("No server configured");
     }
     encryptor = EncryptorFactory.GetEncryptor(server.method, server.password, server.auth, false);
     this.server = server;
 }

 public Server Clone()
 {
     Server ret = new Server();
     ret.server = (string)server.Clone();
     ret.server_port = server_port;
     ret.password = (string)password.Clone();
     ret.method = (string)method.Clone();
     ret.obfs = (string)obfs.Clone();
     ret.remarks = (string)remarks.Clone();
     ret.enable = enable;
     ret.udp_over_tcp = udp_over_tcp;
     ret.tcp_protocol = tcp_protocol;
     ret.obfs_udp = obfs_udp;
     return ret;
 }

 public string GetSSRemarksLinkForServer(Server server)
 {
     string parts = server.method + ":" + server.password + "@" + server.server + ":" + server.server_port + "#" + server.remarks;
     string base64 = System.Convert.ToBase64String(Encoding.UTF8.GetBytes(parts));
     return "ss://" + base64;
 }

 public string GetSSLinkForServer(Server server)
 {
     string parts = server.method + ":" + server.password + "@" + server.server + ":" + server.server_port;
     if (server.obfs != "plain")
         parts = server.obfs + ":" + parts;
     string base64 = System.Convert.ToBase64String(Encoding.UTF8.GetBytes(parts));
     return "ss://" + base64;
 }

        public void ReConnect()
        {
            ResetTimeout(0);

            reconnectTimesRemain--;
            reconnectTimes++;

            lock (server)
            {
                server.ServerSpeedLog().AddDisconnectTimes();
                server.GetConnections().DecRef(this.connection);
            }

            if (reconnectTimes < 2)
            {
                server = this.getCurrentServer(true);
            }
            else
            {
                server = this.getCurrentServer(true, true);
            }

            CloseSocket(ref remote);
            CloseSocket(ref remoteUDP);
            if (remoteTDP != null)
            {
                try
                {
                    remoteTDP.Shutdown();
                    //remoteTDP.Close();
                }
                catch (Exception e)
                {
                    Logging.LogUsefulException(e);
                }
                remoteTDP = null;
            }
            if (obfs != null)
            {
                obfs.Dispose();
                obfs = null;
            }

            connectionShutdown = false;
            remoteShutdown = false;

            speedTester.sizeUpload = 0;
            speedTester.sizeDownload = 0;

            lastErrCode = 0;
            obfs = ObfsFactory.GetObfs(server.obfs);

            try
            {
                Connect();
            }
            catch (Exception e)
            {
                LogSocketException(e);
                if (!Logging.LogSocketException(server.remarks, server.server, e))
                    Logging.LogUsefulException(e);
                this.Close();
            }
        }

 public void UpdateLatency(Server server, TimeSpan latency)
 {
     if (_config.availabilityStatistics)
     {
         new Task(() => availabilityStatistics.UpdateLatency(server, (int) latency.TotalMilliseconds)).Start();
     }
 }

 public void UpdateOutboundCounter(Server server, long n)
 {
     Interlocked.Add(ref outboundCounter, n);
     if (_config.availabilityStatistics)
     {
         new Task(() => availabilityStatistics.UpdateOutboundCounter(server, n)).Start();
     }
 }

 public ServerIndex(int i, Server s)
 {
     index = i;
     this.server = s;
 }

        private async Task<ICMPResult> ICMPTest(Server server)
        {
            Logging.Debug("Ping " + server.FriendlyName());
            if (server.server == "") return null;
            var result = new ICMPResult(server);
            try
            {
                var IP =
                    Dns.GetHostAddresses(server.server)
                        .First(
                            ip =>
                                ip.AddressFamily == AddressFamily.InterNetwork ||
                                ip.AddressFamily == AddressFamily.InterNetworkV6);
                var ping = new Ping();

                foreach (var _ in Enumerable.Range(0, Repeat))
                {
                    try
                    {
                        var reply = await ping.SendTaskAsync(IP, TimeoutMilliseconds);
                        if (reply.Status.Equals(IPStatus.Success))
                        {
                            result.RoundtripTime.Add((int?) reply.RoundtripTime);
                        }
                        else
                        {
                            result.RoundtripTime.Add(null);
                        }

                        //Do ICMPTest in a random frequency
                        Thread.Sleep(TimeoutMilliseconds + new Random().Next()%TimeoutMilliseconds);
                    }
                    catch (Exception e)
                    {
                        Logging.Error($"An exception occured while eveluating {server.FriendlyName()}");
                        Logging.LogUsefulException(e);
                    }
                }
            }
            catch (Exception e)
            {
                Logging.Error($"An exception occured while eveluating {server.FriendlyName()}");
                Logging.LogUsefulException(e);
            }
            return result;
        }

 public void UpdateOutboundCounter(Server server, long n)
 {
     long count;
     if (_outboundCounter.TryGetValue(server.Identifier(), out count))
     {
         count += n;
     }
     else
     {
         count = n;
         _lastOutboundCounter[server.Identifier()] = 0;
     }
     _outboundCounter[server.Identifier()] = count;
 }

 public void UpdateLatency(Server server, TimeSpan latency)
 {
     _controller.UpdateLatency(server, latency);
 }

        private void ProxyConnectCallback(IAsyncResult ar)
        {
            Server server = null;
            if (_closed)
            {
                return;
            }
            try
            {
                var session = (AsyncSession<ProxyTimer>) ar.AsyncState;
                ProxyTimer timer = session.State;
                var destEndPoint = timer.DestEndPoint;
                server = timer.Server;
                timer.Elapsed -= proxyConnectTimer_Elapsed;
                timer.Enabled = false;
                timer.Dispose();

                var remote = session.Remote;

                // Complete the connection.
                remote.EndConnectProxy(ar);

                _proxyConnected = true;

                if (_config.isVerboseLogging)
                {
                    if (!(remote is DirectConnect))
                    {
                        Logging.Info($"Socket connected to proxy {remote.ProxyEndPoint}");
                    }
                }

                _startConnectTime = DateTime.Now;
                ServerTimer connectTimer = new ServerTimer(3000);
                connectTimer.AutoReset = false;
                connectTimer.Elapsed += destConnectTimer_Elapsed;
                connectTimer.Enabled = true;
                connectTimer.Session = session;
                connectTimer.Server = server;
                
                _destConnected = false;
                // Connect to the remote endpoint.
                remote.BeginConnectDest(destEndPoint, new AsyncCallback(ConnectCallback), new AsyncSession<ServerTimer>(session, connectTimer));
            }
            catch (ArgumentException)
            {
            }
            catch (Exception e)
            {
                Logging.LogUsefulException(e);
                RetryConnect();
            }
        }