Implemented ShuffleCubeViaSocketStrategy

Solution/CubeProxy/Controllers/CubeController.cs

@@ -12,7 +12,6 @@ namespace CubeProxy.Controllers
     public class CubeController : Controller
     {
         readonly CubeServiceFacade _cubeService = new CubeServiceFacade("CubeService");
-        readonly IShuffleCubeStrategy ShuffleStrategy = new ShuffleCubeViaAPIStrategy("CubeService");
 
         [HttpPost("[action]")]
         public async Task<IActionResult> Reset()
@@ -29,7 +28,7 @@ public async Task<IActionResult> ApplyShuffle([FromQuery] string? shuffle = null
                 try
                 {
                     List<CubeMove> moves = MoveParser.ParseMoveSequence(moveString);
-                    await ShuffleStrategy.ShuffleCubeAsync(shuffle);
+                    await _cubeService.ShuffleCubeAsync(shuffle);
                     return Ok();
                 }
                 catch
@@ -39,7 +38,7 @@ public async Task<IActionResult> ApplyShuffle([FromQuery] string? shuffle = null
             }
             else
             {
-                await ShuffleStrategy.ShuffleCubeAsync();
+                await _cubeService.ShuffleCubeAsync();
                 return Ok();
             }
         }

Solution/CubeService/Controllers/CubeController.cs

@@ -64,7 +64,7 @@ public IActionResult PerformMove([FromQuery] string? move = null)
                 {
                     //attempt to parse move as Enum
                     CubeMove parsedMove = MoveParser.ParseMove(move)!;
-                    _cubePuzzle.PerformMove(move);
+                    _cubePuzzle.PerformMove(parsedMove);
                     return Ok();
                 }
                 catch

Solution/DummyService/CubeInteractionHost.cs

@@ -36,7 +36,7 @@ public void Listen()
                     string move = ReadFromStream(nStream);
 
                     Console.WriteLine("Received bytes: \"" + move + "\"");
-                    ApplyMove(move);
+                    ProcessMoveString(move);
 
                     // SEND CUBE STATE
 
@@ -58,17 +58,23 @@ public CubeState GetCubeState()
             return Puzzle.GetState();
         }
 
-        public void ApplyMove(string move)
+        public void ProcessMoveString(string moveString)
         {
-            if (move == "RESET")
+            if (moveString == "RESET")
             {
                 ResetCube();
                 return;
             }
 
+            if (moveString == "SHUFFLE")
+            {
+                ShuffleCube();
+                return;
+            }
+
             try
             {
-                Puzzle.PerformMove(move);
+                Puzzle.ApplyMoveString(moveString);
             }
             catch
             {
@@ -81,6 +87,17 @@ private void ResetCube()
             Puzzle.Reset();
         }
 
+        private void ShuffleCube()
+        {
+            ResetCube();
+
+            List<CubeMove> moves = ScrambleAlgorithm.GenerateScramble();
+            foreach(CubeMove move in moves)
+            {
+                Puzzle.PerformMove(move);
+            }
+        }
+
         public byte[] CreateCubeResponse(CubeState state)
         {
             byte[] payload = state.Serialize();

Solution/LibCubeIntegration/Services/CubeServiceFacade.cs

@@ -1,6 +1,7 @@
 namespace LibCubeIntegration.Services;
 using GetCubeStrategies;
 using LibCubeIntegration.ResetCubeStrategies;
+using LibCubeIntegration.ShuffleCubeStrategies;
 using LibNetCube;
 using PerformMoveStrategies;
 
@@ -9,19 +10,22 @@ public class CubeServiceFacade
     private IGetCubeStrategy GetCubeStrategy;
     private IPerformMoveStrategy PerformMoveStrategy;
     private IResetCubeStrategy ResetCubeStrategy;
+    private IShuffleCubeStrategy ShuffleStrategy;
 
     public CubeServiceFacade(IGetCubeStrategy getCubeStrategy, IPerformMoveStrategy performMoveStrategy)
     {
         GetCubeStrategy = getCubeStrategy;
         PerformMoveStrategy = performMoveStrategy;
         ResetCubeStrategy = new ResetCubeViaAPIStrategy();
+        ShuffleStrategy = new ShuffleCubeViaAPIStrategy();
     }
 
     public CubeServiceFacade(string service)
     {
         GetCubeStrategy = StrategyVendor.CreateGetCubeStrategy(service);
         PerformMoveStrategy = StrategyVendor.CreateMoveStrategy(service);
         ResetCubeStrategy = StrategyVendor.CreateResetStrategy(service);
+        ShuffleStrategy = StrategyVendor.CreateShuffleStrategy(service);
     }
 
     public async Task<CubeState?> GetStateAsync()
@@ -38,4 +42,14 @@ public async Task ResetCubeAsync()
     {
         await ResetCubeStrategy.ResetCubeAsync();
     }
+
+    public async Task ShuffleCubeAsync()
+    {
+        await ShuffleStrategy.ShuffleCubeAsync();
+    }
+
+    public async Task ShuffleCubeAsync(string moveString)
+    {
+        await ShuffleStrategy.ShuffleCubeAsync(moveString);
+    }
 }

Solution/LibCubeIntegration/ShuffleCubeStrategies/ShuffleCubeViaSocketStrategy.cs

@@ -0,0 +1,29 @@
+using LibCubeIntegration.PerformMoveStrategies;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace LibCubeIntegration.ShuffleCubeStrategies
+{
+    internal class ShuffleCubeViaSocketStrategy : IShuffleCubeStrategy
+    {
+        private MoveViaSocketStrategy MoveStrategy;
+
+        public ShuffleCubeViaSocketStrategy(string serviceName = "DummyService")
+        {
+            MoveStrategy = new MoveViaSocketStrategy(serviceName);
+        }
+
+        public async Task<bool> ShuffleCubeAsync()
+        {
+            return await MoveStrategy.PerformMoveAsync("SHUFFLE");
+        }
+
+        public async Task<bool> ShuffleCubeAsync(string move)
+        {
+            return await MoveStrategy.PerformMoveAsync(move);
+        }
+    }
+}

Solution/LibCubeIntegration/StrategyVendor.cs

@@ -2,6 +2,7 @@
 using LibCubeIntegration.PerformMoveStrategies;
 using LibCubeIntegration.ResetCubeStrategies;
 using LibCubeIntegration.Services;
+using LibCubeIntegration.ShuffleCubeStrategies;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -53,5 +54,19 @@ public static IResetCubeStrategy CreateResetStrategy(string service)
                     return new ResetCubeViaAPIStrategy(service);
             }
         }
+
+        public static IShuffleCubeStrategy CreateShuffleStrategy(string service)
+        {
+            switch (service)
+            {
+                case "CubeService":
+                case "CubeProxy":
+                    return new ShuffleCubeViaAPIStrategy(service);
+                case "DummyService":
+                    return new ShuffleCubeViaSocketStrategy(service);
+                default:
+                    return new ShuffleCubeViaAPIStrategy(service);
+            }
+        }
     }
 }

Solution/LibNetCube/CubePuzzle.cs

@@ -79,6 +79,28 @@ public void SetState(CubeState state)
             }
         }
 
+        public bool ApplyMoveString(string moveString)
+        {
+            CubeState originalState = GetState();
+
+            try
+            {
+                List<CubeMove> moves = MoveParser.ParseMoveSequence(moveString);
+                foreach(CubeMove move in moves)
+                {
+                    PerformMove(move);
+                }
+
+                return true;
+            }
+            catch
+            {
+                SetState(originalState);
+                return false;
+            }
+        }
+
+
         public void PerformMove(CubeMove move)
         {
             if (IsTwoMove(move))
@@ -164,12 +186,6 @@ private CubeMove SimplifyComplexMove(CubeMove move)
             }
         }
 
-        public void PerformMove(string move)
-        {
-            CubeMove parsedMove = MoveParser.ParseMove(move);
-            PerformMove(parsedMove);
-        }
-
         private void ReplaceEntireFace(CubeFace face, int[,] values)
         {
             int[,] destination = GetFaceRef(face);