More organized communication strategy.

Gameboard.ShogiUI.Sockets/Managers/SocketCommunicationManager.cs

@@ -1,6 +1,8 @@
 using Gameboard.ShogiUI.Sockets.Extensions;
 using Gameboard.ShogiUI.Sockets.Managers.ClientActionHandlers;
 using Gameboard.ShogiUI.Sockets.Managers.Utility;
+using Gameboard.ShogiUI.Sockets.Models;
+using Gameboard.ShogiUI.Sockets.ServiceModels.Socket.Interfaces;
 using Gameboard.ShogiUI.Sockets.ServiceModels.Socket.Types;
 using Microsoft.Extensions.Logging;
 using Newtonsoft.Json;
@@ -16,10 +18,10 @@ namespace Gameboard.ShogiUI.Sockets.Managers
   public interface ISocketCommunicationManager
   {
     Task CommunicateWith(WebSocket w, string s);
-    Task BroadcastToAll(string msg);
-    Task BroadcastToGame(string gameName, Func<string, WebSocket, string> msgBuilder);
-    Task BroadcastToGame(string gameName, string msg);
-    void SubscribeToGame(WebSocket socket, string gameName, string playerName);
+    Task BroadcastToAll(IResponse response);
+    Task BroadcastToGame(string gameName, IResponse response);
+    Task BroadcastToGame(string gameName, IResponse forPlayer1, IResponse forPlayer2);
+    void SubscribeToGame(WebSocket socket, Session session, string playerName);
     void SubscribeToBroadcast(WebSocket socket, string playerName);
     void UnsubscribeFromBroadcastAndGames(string playerName);
     void UnsubscribeFromGame(string gameName, string playerName);
@@ -27,8 +29,10 @@ namespace Gameboard.ShogiUI.Sockets.Managers
 
   public class SocketCommunicationManager : ISocketCommunicationManager
   {
+    /// <summary>Dictionary key is player name.</summary>
     private readonly ConcurrentDictionary<string, WebSocket> connections;
-    private readonly ConcurrentDictionary<string, List<string>> gameSeats;
+    /// <summary>Dictionary key is game name.</summary>
+    private readonly ConcurrentDictionary<string, Session> sessions;
     private readonly ILogger<SocketCommunicationManager> logger;
     private readonly ActionHandlerResolver handlerResolver;
 
@@ -39,7 +43,7 @@ namespace Gameboard.ShogiUI.Sockets.Managers
       this.logger = logger;
       this.handlerResolver = handlerResolver;
       connections = new ConcurrentDictionary<string, WebSocket>();
-      gameSeats = new ConcurrentDictionary<string, List<string>>();
+      sessions = new ConcurrentDictionary<string, Session>();
     }
 
     public async Task CommunicateWith(WebSocket socket, string userName)
@@ -52,7 +56,7 @@ namespace Gameboard.ShogiUI.Sockets.Managers
         {
           var message = await socket.ReceiveTextAsync();
           if (string.IsNullOrWhiteSpace(message)) continue;
-
+          logger.LogInformation("Request \n{0}\n", message);
           var request = JsonConvert.DeserializeObject<Request>(message);
           if (!Enum.IsDefined(typeof(ClientAction), request.Action))
           {
@@ -68,7 +72,7 @@ namespace Gameboard.ShogiUI.Sockets.Managers
         {
           logger.LogError(ex.Message);
         }
-        catch(WebSocketException ex)
+        catch (WebSocketException ex)
         {
           logger.LogInformation($"{nameof(WebSocketException)} in {nameof(SocketCommunicationManager)}.");
           logger.LogInformation("Probably tried writing to a closed socket.");
@@ -80,93 +84,79 @@ namespace Gameboard.ShogiUI.Sockets.Managers
 
     public void SubscribeToBroadcast(WebSocket socket, string playerName)
     {
-      logger.LogInformation("Subscribing [{0}] to broadcast", playerName);
       connections.TryAdd(playerName, socket);
     }
 
     public void UnsubscribeFromBroadcastAndGames(string playerName)
     {
-      logger.LogInformation("Unsubscribing [{0}] from broadcast", playerName);
       connections.TryRemove(playerName, out _);
-      foreach (var game in gameSeats)
+      foreach (var kvp in sessions)
       {
-        game.Value.Remove(playerName);
+        var sessionName = kvp.Key;
+        UnsubscribeFromGame(sessionName, playerName);
       }
     }
 
     /// <summary>
     /// Unsubscribes the player from their current game, then subscribes to the new game.
     /// </summary>
-    public void SubscribeToGame(WebSocket socket, string gameName, string playerName)
+    public void SubscribeToGame(WebSocket socket, Session session, string playerName)
     {
       // Unsubscribe from any other games
-      foreach (var kvp in gameSeats)
+      foreach (var kvp in sessions)
       {
         var gameNameKey = kvp.Key;
         UnsubscribeFromGame(gameNameKey, playerName);
       }
 
       // Subscribe
-      logger.LogInformation("Subscribing player [{0}] to game [{1}]", playerName, gameName);
-      var addSuccess = gameSeats.TryAdd(gameName, new List<string> { playerName });
-      if (!addSuccess && !gameSeats[gameName].Contains(playerName))
-      {
-        gameSeats[gameName].Add(playerName);
-      }
+      var s = sessions.GetOrAdd(session.Name, session);
+      s.Subscriptions.TryAdd(playerName, socket);
     }
 
     public void UnsubscribeFromGame(string gameName, string playerName)
     {
-      if (gameSeats.ContainsKey(gameName))
+      if (sessions.TryGetValue(gameName, out var s))
       {
-        logger.LogInformation("Unsubscribing player [{0}] from game [{1}]", playerName, gameName);
-        gameSeats[gameName].Remove(playerName);
-        if (gameSeats[gameName].Count == 0) gameSeats.TryRemove(gameName, out _);
+        s.Subscriptions.TryRemove(playerName, out _);
+        if (s.Subscriptions.IsEmpty) sessions.TryRemove(gameName, out _);
       }
     }
 
-    public async Task BroadcastToAll(string msg)
+    public Task BroadcastToAll(IResponse response)
     {
-      var tasks = connections.Select(kvp =>
+      var message = JsonConvert.SerializeObject(response);
+      logger.LogInformation($"Broadcasting\n{0}", message);
+      var tasks = new List<Task>(connections.Count);
+      foreach (var kvp in connections)
       {
-        var player = kvp.Key;
         var socket = kvp.Value;
-        logger.LogInformation("Broadcasting to player [{0}] \n{1}\n", new[] { player, msg });
-        return socket.SendTextAsync(msg);
-      });
-      await Task.WhenAll(tasks);
+        tasks.Add(socket.SendTextAsync(message));
+      }
+      return Task.WhenAll(tasks);
     }
 
-    public async Task BroadcastToGame(string gameName, string msg)
+    public Task BroadcastToGame(string gameName, IResponse forPlayer1, IResponse forPlayer2)
     {
-      if (gameSeats.ContainsKey(gameName))
+      if (sessions.TryGetValue(gameName, out var session))
       {
-        var tasks = gameSeats[gameName]
-            .Select(playerName =>
-            {
-              logger.LogInformation("Broadcasting to game [{0}], player [{0}] \n{1}\n", gameName, playerName, msg);
-              return connections[playerName];
-            })
-            .Where(stream => stream != null)
-            .Select(socket => socket.SendTextAsync(msg));
-        await Task.WhenAll(tasks);
+        var serialized1 = JsonConvert.SerializeObject(forPlayer1);
+        var serialized2 = JsonConvert.SerializeObject(forPlayer2);
+        return Task.WhenAll(
+          session.SendToPlayer1(serialized1),
+          session.SendToPlayer2(serialized2));
       }
+      return Task.CompletedTask;
     }
 
-    public async Task BroadcastToGame(string gameName, Func<string, WebSocket, string> msgBuilder)
+    public Task BroadcastToGame(string gameName, IResponse messageForAllPlayers)
     {
-      if (gameSeats.ContainsKey(gameName))
+      if (sessions.TryGetValue(gameName, out var session))
       {
-        var tasks = gameSeats[gameName]
-            .Select(playerName =>
-            {
-              var socket = connections[playerName];
-              var msg = msgBuilder(playerName, socket);
-              logger.LogInformation("Broadcasting to game [{0}], player [{0}] \n{1}\n", gameName, playerName, msg);
-              return socket.SendTextAsync(msg);
-            });
-        await Task.WhenAll(tasks);
+        var serialized = JsonConvert.SerializeObject(messageForAllPlayers);
+        return session.Broadcast(serialized);
       }
+      return Task.CompletedTask;
     }
   }
 }