Fix MatchQueue logic to integrate with CSS additions (#27)

Author: judebeans

app/Pages/MatchQueue.razor

@@ -27,20 +27,14 @@
     Icon="@Icons.Material.Filled.Favorite"
     Class="@HeartCssClass"      
     DisableRipple="true"
-    OnClick="ToggleHeart"
+    OnClick="ToggleMatching"
     AriaLabel="Start matching" />
-
-
+            <MudText class="spark-text" Typo="Typo.caption">
+                @PendingMessage
+            </MudText>
             @if (pendingAction != QueueAction.None) {
-                <MudText class="spark-text" Typo="Typo.caption">
-                    @PendingMessage
-                </MudText>
                 <MudProgressLinear Value="@((10 - secondsLeft) * 10)" Class="w-64" />
             }
-
-            @if (!string.IsNullOrEmpty(errorMessage)) {
-                <MudAlert Severity="Severity.Error" Dense="true" Elevation="0">@errorMessage</MudAlert>
-            }
         </MudStack>
     <MudSpacer />
 </MudStack>
@@ -69,145 +63,153 @@
 
 @code {
     // --- state ---
-    private int onlineUserCount;                  
-    private bool isQueueing = false;
+    private bool blnMatchStopped = false;
+    private int onlineUserCount;
     private string? errorMessage;
 
-    private enum QueueAction { None, Start, Stop }
+    private enum QueueAction { None, Pending, Queueing }
     private QueueAction pendingAction = QueueAction.None;
     private int secondsLeft = 0;
     private CancellationTokenSource? pendingCts;
 
     // --- computed UI text/classes ---
     private string TooltipText =>
         pendingAction switch {
-            QueueAction.Start => $"Starting in {secondsLeft}s… Tap to cancel",
-            QueueAction.Stop => $"Stopping…",
-            _ => isQueueing ? "Stop matching" : "Start matching"
+            QueueAction.Pending => $"Starting in {secondsLeft}s… Tap to cancel",
+            QueueAction.Queueing => "Stop Matching",
+            QueueAction.None => "Start Matching",
+            _ => "Start Matching"
         };
 
-    private string PendingMessage =>
-        pendingAction == QueueAction.Start
-            ? $"Match starting in {secondsLeft} second{(secondsLeft == 1 ? "" : "s")}… Tap again to cancel."
-            : $"Stopping…";
+    private string PendingMessage => pendingAction switch {
+            QueueAction.Pending => $"Match starting in {secondsLeft} second{(secondsLeft == 1 ? "" : "s")}… Tap again to cancel.",
+            QueueAction.Queueing => blnMatchStopped ? "Stopping..." : "Looking for a match... Tap again to cancel.",
+            QueueAction.None => "Tap heart to start matching."
+        };
 
     private string HeartCssClass =>
-        $"gold-heart {(pendingAction == QueueAction.Start ? "countdown" : isQueueing ? "steady" : "")}";
+        $"gold-heart {(pendingAction == QueueAction.None ? "steady" : "countdown" )}";
 
-    protected override async Task OnInitializedAsync() {
-        // safe to keep; remove if you don't render it
+    protected override async Task OnInitializedAsync()
+    {
         onlineUserCount = await UserService.GetOnlineUserCountAsync();
-
-        var existing = await MatchService.GetLatestActiveMatchAsync(UserSession.intUserID);
-        if (existing != null)
+        if (await MatchService.GetLatestActiveMatchAsync(UserSession.intUserID) != null)
+        {
             Navigation.NavigateTo("/match");
+        }
     }
-
-    public async ValueTask DisposeAsync()   // <- implements IAsyncDisposable
+    public async ValueTask DisposeAsync()
     {
-        // cancel any pending countdown
-        pendingCts?.Cancel();
-        pendingCts?.Dispose();
+        // cancel any pending countdown, stop matching
+        pendingCts?.Cancel();        
+        pendingCts?.Dispose();        
         pendingCts = null;
-
-        // optional: auto-exit queue on leave
-        // if (isQueueing)
-        //     await StopMatchingCore(CancellationToken.None);
+        blnMatchStopped = false;
+        await StopMatching();
     }
-
-    private async Task ToggleHeart() {
-        if (pendingAction != QueueAction.None) {
-            // cancel grace period
-            pendingCts?.Cancel();
-            pendingAction = QueueAction.None;
-            secondsLeft = 0;
-            StateHasChanged();
-            return;
+    private async Task ToggleMatching() {
+        switch (pendingAction) {
+            case QueueAction.Pending: {
+                pendingCts?.Cancel();        
+                pendingCts?.Dispose();
+                pendingCts = null;
+                pendingAction = QueueAction.None;
+                StateHasChanged( );
+            } break;
+            case QueueAction.Queueing: {
+                blnMatchStopped = true;
+                StateHasChanged( );
+                await StopMatching();
+            } break;
+            case QueueAction.None: {
+                StartGracePeriod();                
+            } break;
         }
-
-        if (!isQueueing)
-            StartGracePeriod(QueueAction.Start);
-        else
-            await StopMatching(); // stop immediately; animation stops
     }
-
-    private void StartGracePeriod(QueueAction action) {
+    private void StartGracePeriod() {
+        pendingAction = QueueAction.Pending;
         errorMessage = null;
-        pendingAction = action;
         secondsLeft = 5;
-
         pendingCts?.Cancel();
         pendingCts?.Dispose();
         pendingCts = new CancellationTokenSource();
         _ = RunGracePeriodAsync(pendingCts.Token);
-
         StateHasChanged();
     }
-
     private async Task RunGracePeriodAsync(CancellationToken token) {
         try {
             while (secondsLeft > 0) {
                 await Task.Delay(1000, token);
                 secondsLeft--;
                 StateHasChanged();
             }
-
-            if (pendingAction == QueueAction.Start)
-                await StartMatching();
+    
+            pendingCts?.Dispose();
+            pendingCts = null;
+            await StartMatching();
         }
         catch (OperationCanceledException) { /* user canceled */ }
         finally {
+            blnMatchStopped = false;
             pendingAction = QueueAction.None;
             secondsLeft = 0;
             StateHasChanged();
         }
     }
+    private async Task StartMatching()
+    {
+        errorMessage = null;
+        pendingAction = QueueAction.Queueing;
+        blnMatchStopped = false;
+        StateHasChanged();
 
-    private async Task StartMatching() {
-        try {
-            var resp = await HttpClient.GetAsync($"http://sparkcheck-matcher:9988/enterQueue?intUserID={UserSession.intUserID}");
-            if (!resp.IsSuccessStatusCode) {
-                errorMessage = $"Matcher error: {(int)resp.StatusCode} {resp.ReasonPhrase}";
-                return;
-            }
-
-            var content = await resp.Content.ReadAsStringAsync();
-            using var json = System.Text.Json.JsonDocument.Parse(content);
-            var status = json.RootElement.TryGetProperty("status", out var s) ? s.GetString() : null;
-
-            if (status == "success") {
-                isQueueing = true;             // keep pulse on
-                Navigation.NavigateTo("/match");
-            }
-            else if (status == "error") {
-                errorMessage = json.RootElement.TryGetProperty("message", out var m) ? m.GetString() : "Unknown error.";
-            }
-            else {
-                errorMessage = "Unexpected matcher response.";
+        try
+        {
+            var response = await
+            HttpClient.GetAsync($"http://sparkcheck-matcher:9988/enterQueue?intUserID={UserSession.intUserID}");
+            if (response.IsSuccessStatusCode)
+            {
+                var content = await response.Content.ReadAsStringAsync();
+                var json = System.Text.Json.JsonDocument.Parse(content);
+                var status = json.RootElement.GetProperty("status").GetString();
+                switch (status)
+                {
+                    case "success":
+                        Navigation.NavigateTo("/match");
+                        break;
+                    case "error":
+                        errorMessage = json.RootElement.GetProperty("message").GetString();
+                        await StopMatching();
+                        break;
+                    case "stopped":
+                        break;
+                    default:
+                        errorMessage = content;
+                        break;
+                }
             }
         }
-        catch (Exception ex) {
+        catch (Exception ex)
+        {
             errorMessage = $"Error starting match: {ex.Message}";
         }
-        finally {
+        finally
+        {
+            blnMatchStopped = false;
+            pendingAction = QueueAction.None;
             StateHasChanged();
         }
     }
 
-    private async Task StopMatching() {
-        try {
-            var resp = await HttpClient.GetAsync($"http://sparkcheck-matcher:9988/exitQueue?intUserID={UserSession.intUserID}");
-            if (!resp.IsSuccessStatusCode) {
-                errorMessage = $"Matcher error: {(int)resp.StatusCode} {resp.ReasonPhrase}";
-                return;
-            }
-            isQueueing = false;                // pulse off
+    private async Task StopMatching()
+    {
+        try
+        {
+            await HttpClient.GetAsync($"http://sparkcheck-matcher:9988/exitQueue?intUserID={UserSession.intUserID}");
         }
-        catch (Exception ex) {
+        catch (Exception ex)
+        {
             errorMessage = $"Error stopping match: {ex.Message}";
         }
-        finally {
-            StateHasChanged();
-        }
     }
 }