/// <summary>
 /// A fleck client, which provides high-level methods to send data to the client (socket).
 /// </summary>
 /// <param name="socket">Client socket connection</param>
 public Client(IWebSocketConnection socket)
 {
     State = ClientState.Unknown;
     Id = null;
     Name = null;
     _socket = socket;
 }

 public Player(IWebSocketConnection socket, IPrincipal principal)
 {
     Principal = principal;
     _socket = socket;
     _socket.OnMessage = message => MessageRecieved(this, message);
     _socket.OnClose += LeaveGame;
 }

        protected static bool _useSecure = false; //

        #endregion Fields

        #region Methods

        //Add a new device to the list of currently connected devices
        private static Device AddDevice(IWebSocketConnection conn, Request requestObject)
        {
            //Create the device
              Device device = new Device()
              {
            AccountName = requestObject.AccountName,
            ConnectionGuid = conn.ConnectionInfo.Id,
            FriendlyName = requestObject.FriendlyName,
            Id = Guid.Empty,
            IP = conn.ConnectionInfo.ClientIpAddress,
            Mode = requestObject.CurrentOperationMode
              };

              //Use the assigned id if the client is supplying one
              if (requestObject.DeviceGuid != null)
            device.Id = new Guid(requestObject.DeviceGuid); //We have a GUID so update to use that for this connection

              //Work out the if we still need a device id and if we do then make one up.
              if (device.Id == Guid.Empty) //If the device does not have a guid then request a new one
              {
            Guid generatedGuid = Guid.NewGuid();
            device.Id = generatedGuid;
              }//if

              //Now actually add the Id to the list
              _connectedDevices.TryAdd(device.Id.ToString(), device);

              //If we wish to send notifications of on / offline devices then send them now
              if (_deviceNotifications)
            NotifyDevices(true,device);

              //Return the device for use in reading
              return device;
        }

        private void handleGame(IWebSocketConnection socket, String message)
        {
            Room newRoom = JsonConvert.DeserializeObject<Room>(message);
            Room room = Main.ludo.Rooms[newRoom.RoomID];
            room.RoomAction = newRoom.RoomAction;

            if (room.Game.MoveCount == 0)
            {
                room.Game.Fields = ludoLogicHandler.initGame(room);
                Console.WriteLine(" Init Map: " + room.Game.Fields[0, 0]);
            }

            if (room.RoomAction.Equals("rollTheDice"))
            {
                room.Game.DiceValue = rollTheDice();
                room.RoomAction = "diceRolled";
                Console.WriteLine("Rolled Value: " + room.Game.DiceValue);
                room = getUsersTurnID(room);
            }

            Console.WriteLine("It's " + Main.ludo.Users[room.Game.UsersTurnID].UserName + "'s turn!");

            room.Game.MoveCount += 1;
            Main.ludo.Rooms[room.RoomID].Game = room.Game;

            Console.WriteLine("Field: 0 0" + room.Game.Fields[0, 0]);
            Console.WriteLine("Field: 9 0" + room.Game.Fields[9, 0]);

            syncGame();
            //sendGame(room);
        }

        public void Connection(IWebSocketConnection con, String name)
        {
            if (isNew) isNew = false;

            connections.Add(con, name);
            sendToAllNames();
        }

 private void sendOnlineUsers(IWebSocketConnection socket)
 {
     foreach (var s in onlineUserSocketList.ToList())
     {
         s.Send(JsonConvert.SerializeObject(Main.ludo));
     }
 }

        protected int ConfigureIntegrationTestConnectionAndGetId(IWebSocketConnection connection)
        {
            var id = Interlocked.Increment(ref _idSeed);

            connection.OnOpen = () =>
            {
                AddConnection(id, connection);
                Send(id, $"Open: {id}");
            };
            connection.OnClose = () =>
            {
                Send(id, $"Close: {id}");
                RemoveConnection(id);
            };
            connection.OnError = ex =>
            {
                Send(-1, $"Error: {id} - {ex.ToString()}");
            };
            connection.OnMessage = m =>
            {
                Send(id, $"User {id}: {m}");
            };

            return id;
        }

        private void handleRooms(IWebSocketConnection socket, String message)
        {
            Room room = JsonConvert.DeserializeObject<Room>(message);
            Console.WriteLine("JSON: " + message);
            if (room.RoomAction.Equals("createRoom"))
            {
                Console.WriteLine("Room " + room.RoomName + " created");
                createRoom(room);
            }

            if (room.RoomAction.Equals("joinRoom"))
            {
                joinRoom(room);
            }

            if (room.RoomAction.Equals("leaveRoom"))
            {
                leaveRoom(room);
            }

            if (room.RoomAction.Equals("setReady"))
            {
                setReady(room);
            }

            if (room.RoomAction.Equals("setStart"))
            {
                setStart(room);
            }
        }

 public void ServerConfig(IWebSocketConnection socket)
 {
     socket.OnOpen = () => OnOpen(socket);
     socket.OnClose = () => OnClose(socket);
     socket.OnMessage = message => OnMessage(socket, message);
     socket.OnBinary = bytes => OnBinary(socket, bytes);
 }

 public WebSocketService NewServiceMap(WebSocketServiceManager _manager, IWebSocketConnection socket)
 {
     WebSocketService service = null;
     switch (_manager.managerName)
     {
         case "/" + TargetDeiveName.GPS:
             service = new GPSService(_manager, socket);
             break;
         case "/" + TargetDeiveName.UHF:
             service = new UHFService(_manager, socket);
             break;
         case "/" + TargetDeiveName.绿灯:
             service = new GreenLightService(_manager, socket);
             break;
         case "/" + TargetDeiveName.红灯:
             service = new RedLightService(_manager, socket);
             break;
         case "/" + TargetDeiveName.黄灯:
             service = new YellowLightService(_manager, socket);
             break;
         case "/" + TargetDeiveName.电风扇:
             service = new FanService(_manager, socket);
             break;
         case "/" + TargetDeiveName.电机:
             service = new EngineService(_manager, socket);
             break;
     }
     return service;
 }

        public override ChatCommand Execute(IWebSocketConnection socket)
        {
            ChatServer.Instance.ClientConnected(this.ClientName, socket);

            ChatCommandConnected res = new ChatCommandConnected();
            return res;
        }

 public WebSocketService NewServiceMap(WebSocketServiceManager _manager, IWebSocketConnection socket)
 {
     WebSocketService service = null;
     switch (_manager.managerName)
     {
         case "/gps":
             service = new GPSService(_manager, socket);
             //service.
             break;
         case "/uhf":
             service = new UHFService(_manager, socket);
             break;
         case "/green_light":
             service = new GreenLightService(_manager, socket);
             break;
         case "/red_light":
             service = new RedLightService(_manager, socket);
             break;
         case "/yellow_light":
             service = new YellowLightService(_manager, socket);
             break;
         case "/fan":
             service = new FanService(_manager, socket);
             break;
         case "/engine":
             service = new EngineService(_manager, socket);
             break;
     }
     return service;
 }

 public void closeConnection(IWebSocketConnection socket)
 {
     foreach (var s in allSockets)
     {
         if (s == socket)
             s.Close();
     }
 }

 public void OnOpen(IWebSocketConnection socket)
 {
     Logger.Instance().InfoWithFormat(" >> client {0} - {1} connected.", socket.ConnectionInfo.ClientIpAddress, socket.ConnectionInfo.Id);
     lock (_lockObj)
     {
         _clientSocketList.Add(socket);
     }
 }

 public FanService(WebSocketServiceManager _manager, IWebSocketConnection socket)
 {
     services.register_service("fan", this);
     this.ID = socket.ConnectionInfo.Id.ToString();
     this._manager = _manager;
     this._websocket = socket;
     this._context = socket.ConnectionInfo;
 }

 public void sendMessage(IWebSocketConnection sock, string msg)
 {
     foreach (var s in allSockets)
     {
         if (s == sock)
             s.Send(msg);
     }
 }

 public void sendTo(IWebSocketConnection socket) {
     Dem2Hub.sendItTo(this, socket);
     if (operation == 'u' || operation == 'c')
     {
         var subs = new Subscription() { onEntityId = entity.Id };  //we presume, that the entity will be displayed at the client, so we subscribe him
         subs.subscribe(socket);
     }
 }

        private static void Close(IWebSocketConnection socket)
        {
            allSockets.Remove(socket);
            clientWindows.Remove(socket.ConnectionInfo.Id);
            clientDynamicWindows.Remove(socket.ConnectionInfo.Id);

            Console.WriteLine("> Socket to " + socket.ConnectionInfo.ClientIpAddress + " closed");
        }

 public void Remove(IWebSocketConnection con)
 {
     if (findIfInList(con))
     {
         connections.Remove(con);
         sendToAllNames();
     }
 }

        public void ClientConnected(string name, IWebSocketConnection socket)
        {
            this.clients.Add(new ChatClient(name, socket));

            SendAll(new ChatCommandClientConnected()
            {
                ClientName = name
            });
        }