performance cache + queued character data application

LightlessSync/PlayerData/Pairs/PairHandlerRegistry.cs

@@ -10,25 +10,32 @@ namespace LightlessSync.PlayerData.Pairs;
 public sealed class PairHandlerRegistry : IDisposable
 {
     private readonly object _gate = new();
+    private readonly object _pendingGate = new();
     private readonly Dictionary<string, PairHandlerEntry> _entriesByIdent = new(StringComparer.Ordinal);
     private readonly Dictionary<IPairHandlerAdapter, PairHandlerEntry> _entriesByHandler = new();
 
     private readonly IPairHandlerAdapterFactory _handlerFactory;
     private readonly PairManager _pairManager;
     private readonly PairStateCache _pairStateCache;
+    private readonly PairPerformanceMetricsCache _pairPerformanceMetricsCache;
     private readonly ILogger<PairHandlerRegistry> _logger;
 
     private readonly TimeSpan _deletionGracePeriod = TimeSpan.FromMinutes(5);
+    private static readonly TimeSpan _handlerReadyTimeout = TimeSpan.FromMinutes(3);
+    private const int _handlerReadyPollDelayMs = 500;
+    private readonly Dictionary<string, CancellationTokenSource> _pendingCharacterData = new(StringComparer.Ordinal);
 
     public PairHandlerRegistry(
         IPairHandlerAdapterFactory handlerFactory,
         PairManager pairManager,
         PairStateCache pairStateCache,
+        PairPerformanceMetricsCache pairPerformanceMetricsCache,
         ILogger<PairHandlerRegistry> logger)
     {
         _handlerFactory = handlerFactory;
         _pairManager = pairManager;
         _pairStateCache = pairStateCache;
+        _pairPerformanceMetricsCache = pairPerformanceMetricsCache;
         _logger = logger;
     }
 
@@ -150,7 +157,8 @@ public sealed class PairHandlerRegistry : IDisposable
 
             if (!TryGetHandler(registration.CharacterIdent, out handler) || handler is null)
             {
-                return PairOperationResult.Fail($"Handler not ready for {registration.PairIdent.UserId}.");
+                QueuePendingCharacterData(registration, dto);
+                return PairOperationResult.Ok();
             }
         }
 
@@ -285,6 +293,8 @@ public sealed class PairHandlerRegistry : IDisposable
             _entriesByHandler.Clear();
         }
 
+        CancelAllPendingCharacterData();
+
         foreach (var handler in handlers)
         {
             try
@@ -298,6 +308,10 @@ public sealed class PairHandlerRegistry : IDisposable
                     _logger.LogDebug(ex, "Failed to dispose handler for {Ident}", handler.Ident);
                 }
             }
+            finally
+            {
+                _pairPerformanceMetricsCache.Clear(handler.Ident);
+            }
         }
     }
 
@@ -311,9 +325,12 @@ public sealed class PairHandlerRegistry : IDisposable
             _entriesByHandler.Clear();
         }
 
+        CancelAllPendingCharacterData();
+
         foreach (var handler in handlers)
         {
             handler.Dispose();
+            _pairPerformanceMetricsCache.Clear(handler.Ident);
         }
     }
 
@@ -343,6 +360,7 @@ public sealed class PairHandlerRegistry : IDisposable
 
     private bool TryFinalizeHandlerRemoval(IPairHandlerAdapter handler)
     {
+        string? ident = null;
         lock (_gate)
         {
             if (!_entriesByHandler.TryGetValue(handler, out var entry) || entry.HasPairs)
@@ -351,9 +369,126 @@ public sealed class PairHandlerRegistry : IDisposable
                 return false;
             }
 
+            ident = entry.Ident;
             _entriesByHandler.Remove(handler);
             _entriesByIdent.Remove(entry.Ident);
-            return true;
+        }
+
+        if (ident is not null)
+        {
+            _pairPerformanceMetricsCache.Clear(ident);
+            CancelPendingCharacterData(ident);
+        }
+
+        return true;
+    }
+
+    private void QueuePendingCharacterData(PairRegistration registration, OnlineUserCharaDataDto dto)
+    {
+        if (registration.CharacterIdent is null)
+        {
+            return;
+        }
+
+        CancellationTokenSource? previous = null;
+        CancellationTokenSource cts;
+        lock (_pendingGate)
+        {
+            if (_pendingCharacterData.TryGetValue(registration.CharacterIdent, out previous))
+            {
+                previous.Cancel();
+            }
+
+            cts = new CancellationTokenSource();
+            _pendingCharacterData[registration.CharacterIdent] = cts;
+        }
+
+        previous?.Dispose();
+        cts.CancelAfter(_handlerReadyTimeout);
+        _ = Task.Run(() => WaitThenApplyPendingCharacterDataAsync(registration, dto, cts.Token, cts));
+    }
+
+    private void CancelPendingCharacterData(string ident)
+    {
+        CancellationTokenSource? cts = null;
+        lock (_pendingGate)
+        {
+            if (_pendingCharacterData.TryGetValue(ident, out cts))
+            {
+                _pendingCharacterData.Remove(ident);
+            }
+        }
+
+        if (cts is not null)
+        {
+            cts.Cancel();
+            cts.Dispose();
+        }
+    }
+
+    private void CancelAllPendingCharacterData()
+    {
+        List<CancellationTokenSource>? snapshot = null;
+        lock (_pendingGate)
+        {
+            if (_pendingCharacterData.Count > 0)
+            {
+                snapshot = _pendingCharacterData.Values.ToList();
+                _pendingCharacterData.Clear();
+            }
+        }
+
+        if (snapshot is null)
+        {
+            return;
+        }
+
+        foreach (var cts in snapshot)
+        {
+            cts.Cancel();
+            cts.Dispose();
+        }
+    }
+
+    private async Task WaitThenApplyPendingCharacterDataAsync(
+        PairRegistration registration,
+        OnlineUserCharaDataDto dto,
+        CancellationToken token,
+        CancellationTokenSource source)
+    {
+        if (registration.CharacterIdent is null)
+        {
+            return;
+        }
+
+        try
+        {
+            while (!token.IsCancellationRequested)
+            {
+                if (TryGetHandler(registration.CharacterIdent, out var handler) && handler is not null && handler.Initialized)
+                {
+                    handler.ApplyData(dto.CharaData);
+                    break;
+                }
+
+                await Task.Delay(_handlerReadyPollDelayMs, token).ConfigureAwait(false);
+            }
+        }
+        catch (OperationCanceledException)
+        {
+            // expected
+        }
+        finally
+        {
+            lock (_pendingGate)
+            {
+                if (_pendingCharacterData.TryGetValue(registration.CharacterIdent, out var current) && ReferenceEquals(current, source))
+                {
+                    _pendingCharacterData.Remove(registration.CharacterIdent);
+                }
+            }
+
+            source.Dispose();
         }
     }
 }