Incomplete websocket implementation

Sources/App/Model/Database.swift

@@ -1,23 +1,15 @@
 import Foundation
 import Vapor
 
-let playerPerTable = 4
-
-typealias TableId = String
-typealias TableName = String
-
 final class Database {
 
     private let players: PlayerManagement
 
     private let tables: TableManagement
 
-    private var sessions: [SessionToken : WebSocket]
-
     init() {
         self.players = PlayerManagement()
         self.tables = TableManagement()
-        self.sessions = [:]
         // TODO: Load server data from disk
         // TODO: Save data to disk
     }
@@ -33,22 +25,19 @@ final class Database {
     }
 
     func deletePlayer(named name: PlayerName) {
-        if let sessionToken = players.deletePlayer(named: name) {
-            closeAndRemoveSession(for: sessionToken)
-        }
-        // TODO: Delete player from tables
+        _ = players.deletePlayer(named: name)
+        tables.remove(player: name)
     }
 
     func isValid(sessionToken token: SessionToken) -> Bool {
         players.isValid(sessionToken: token)
     }
 
-    func startSession(socket: WebSocket, sessionToken: SessionToken) {
-        closeAndRemoveSession(for: sessionToken)
-        sessions[sessionToken] = socket
-        socket.onText { [weak self] socket, text in
-            self?.didReceive(message: text, forSessionToken: sessionToken)
+    func startSession(socket: WebSocket, sessionToken: SessionToken) -> Bool {
+        guard let player = players.registeredPlayerExists(withSessionToken: sessionToken) else {
+            return false
         }
+        return tables.connect(player: player, using: socket)
     }
 
     private func didReceive(message: String, forSessionToken token: SessionToken) {
@@ -56,13 +45,15 @@ final class Database {
         print("Session \(token.prefix(6)): \(message)")
     }
 
-    func endSession(forSessionToken token: SessionToken) {
-        players.endSession(forSessionToken: token)
-        closeAndRemoveSession(for: token)
+    func endSession(forSessionToken sessionToken: SessionToken) {
+        guard let player = players.endSession(forSessionToken: sessionToken) else {
+            return
+        }
+        closeSession(for: player)
     }
 
-    private func closeAndRemoveSession(for token: SessionToken) {
-        _ = sessions.removeValue(forKey: token)?.close()
+    private func closeSession(for player: PlayerName) {
+        tables.disconnect(player: player)
     }
 
     /**
@@ -78,16 +69,12 @@ final class Database {
         players.registeredPlayerExists(withSessionToken: token)
     }
 
+    func currentTableOfPlayer(named player: PlayerName) -> TableId {
+        tables.currentTableOfPlayer(named: player) ?? ""
+    }
+
     // MARK: Tables
 
-    func tableExists(withId id: TableId) -> Bool {
-        tables.tableExists(withId: id)
-    }
-
-    func tableIsFull(withId id: TableId) -> Bool {
-        tables.tableIsFull(withId: id)
-    }
-
     /**
      Create a new table with optional players.
      - Parameter name: The name of the table
@@ -103,14 +90,7 @@ final class Database {
         tables.getPublicTableInfos()
     }
 
-    func join(tableId: TableId, player: PlayerName) {
-        let playersAtTable = tables.join(tableId: tableId, player: player)
-        playersAtTable
-            .compactMap { players.sessionToken(forPlayer: $0) } // Session Tokens
-            .compactMap { sessions[$0] } // Sockets
-            .forEach { socket in
-                // TODO: Notify sessions about changed players
-                // socket.send("")
-            }
+    func join(tableId: TableId, player: PlayerName) -> TableManagement.JoinTableResult {
+        tables.join(tableId: tableId, player: player)
     }
 }

Sources/App/Model/PlayerManagement.swift

@@ -86,11 +86,12 @@ final class PlayerManagement {
         return token
     }
 
-    func endSession(forSessionToken token: SessionToken) {
+    func endSession(forSessionToken token: SessionToken) -> PlayerName? {
         guard let player = playerNameForToken.removeValue(forKey: token) else {
-            return
+            return nil
         }
         sessionTokenForPlayer.removeValue(forKey: player)
+        return player
     }
 
     /**

Sources/App/Model/TableManagement.swift

@@ -1,4 +1,10 @@
 import Foundation
+import WebSocketKit
+
+let maximumPlayersPerTable = 4
+
+typealias TableId = String
+typealias TableName = String
 
 final class TableManagement {
 
@@ -14,16 +20,10 @@ final class TableManagement {
     /// A reverse list of players and their table id
     private var playerTables = [PlayerName: TableId]()
 
+    private var playerConnections = [PlayerName : WebSocket]()
+
     init() {
-        
-    }
 
-    func tableExists(withId id: TableId) -> Bool {
-        tableNames[id] != nil
-    }
-
-    func tableIsFull(withId id: TableId) -> Bool {
-        (tablePlayers[id]?.count ?? playerPerTable) < playerPerTable
     }
 
     /**
@@ -52,24 +52,54 @@ final class TableManagement {
         }.sorted()
     }
 
+    func currentTableOfPlayer(named player: PlayerName) -> TableId? {
+        playerTables[player]
+    }
+
     /**
      Join a table.
-     - Returns: The player names present at the table
+     - Returns: The result of the join operation
      */
-    func join(tableId: TableId, player: PlayerName) -> [PlayerName] {
+    func join(tableId: TableId, player: PlayerName) -> JoinTableResult {
         guard var players = tablePlayers[tableId] else {
-            return []
+            return .tableNotFound
+        }
+        guard !players.contains(player) else {
+            return .success
+        }
+        guard players.count < maximumPlayersPerTable else {
+            return .tableIsFull
         }
         players.append(player)
         if let oldTable = playerTables[tableId] {
             remove(player: player, fromTable: oldTable)
+            // TODO: End game if needed
+            // 
         }
         tablePlayers[tableId] = players
         playerTables[tableId] = tableId
-        return players
+        return .success
     }
 
     func remove(player: PlayerName, fromTable tableId: TableId) {
         tablePlayers[tableId] = tablePlayers[tableId]?.filter { $0 != player }
     }
+
+    func remove(player: PlayerName) {
+        fatalError()
+    }
+
+    func connect(player: PlayerName, using socket: WebSocket) -> Bool {
+        fatalError()
+    }
+
+    func disconnect(player: PlayerName) {
+        fatalError()
+    }
+
+    enum JoinTableResult {
+        case tableNotFound
+        case tableIsFull
+        case success
+    }
 }