public class Server
    {
        private readonly string _serverAddress;
        private CancellationTokenSource _cancellationTokenSource;
        private Task _acceptClientsTask;
        private Task _readCommandTask;
        private StringBuilder _buffer = new();
        private readonly object _bufferLocker = new();

        public Server(string serverAddress)
        {
            _serverAddress = serverAddress ?? "localhost";
        }

        public Task Start()
        {
            ResetCancellationToken();
            _acceptClientsTask = StartAcceptClients();
            _readCommandTask = ReadCommands();
            return Task.WhenAll(_acceptClientsTask, _readCommandTask);
        }
        public void Stop() => _cancellationTokenSource?.Cancel();

        private async Task StartAcceptClients()
        {
            CancellationToken stopToken = _cancellationTokenSource.Token;

            HttpListener server = new HttpListener();
            server.Prefixes.Add($"http://{_serverAddress}:8833/rcon/");

            if (stopToken.IsCancellationRequested)
                return;

            server.Start();

            while (!stopToken.IsCancellationRequested)
            {

                HttpListenerContext context = await server.GetContextAsync();
                HttpListenerRequest request = context.Request;
                HttpListenerResponse response = context.Response;

                string url = HttpUtility.UrlDecode(request.RawUrl);
                if (url.Length > 8)
                {
                    Console.WriteLine(url.Substring(8));
                }

                byte[] responceBytes = Encoding.UTF8.GetBytes(_buffer.ToString());
                response.ContentLength64 = responceBytes.Length;

                Stream output = response.OutputStream;
                await output.WriteAsync(responceBytes, 0, responceBytes.Length);

                lock(_bufferLocker)
                {
                    _buffer.Clear();
                }

                output.Close();
            }
            server.Stop();
        }

        private async Task ReadCommands()
        {
            var token = _cancellationTokenSource.Token;
            var consoleStream = Console.In;
            while (!token.IsCancellationRequested)
            {
                var toAppend = await consoleStream.ReadLineAsync();

                lock(_bufferLocker)
                {
                    _buffer.Append(toAppend);
                }
            }
        }

        private void ResetCancellationToken()
        {
            _cancellationTokenSource?.Cancel();
            _cancellationTokenSource?.Dispose();
            _cancellationTokenSource = new CancellationTokenSource();
        }
    }