changes

LightlessSync/PlayerData/Pairs/PairManager.cs

@@ -1,4 +1,4 @@
-using Dalamud.Plugin.Services;
+using Dalamud.Plugin.Services;
 using LightlessSync.API.Data;
 using LightlessSync.API.Data.Comparer;
 using LightlessSync.API.Data.Extensions;
@@ -7,10 +7,14 @@ using LightlessSync.API.Dto.User;
 using LightlessSync.LightlessConfiguration;
 using LightlessSync.LightlessConfiguration.Models;
 using LightlessSync.PlayerData.Factories;
+using LightlessSync.Services;
+
 using LightlessSync.Services.Events;
 using LightlessSync.Services.Mediator;
 using Microsoft.Extensions.Logging;
 using System.Collections.Concurrent;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace LightlessSync.PlayerData.Pairs;
 
@@ -24,14 +28,19 @@ public sealed class PairManager : DisposableMediatorSubscriberBase
     private Lazy<List<Pair>> _directPairsInternal;
     private Lazy<Dictionary<GroupFullInfoDto, List<Pair>>> _groupPairsInternal;
     private Lazy<Dictionary<Pair, List<GroupFullInfoDto>>> _pairsWithGroupsInternal;
+    private readonly PairProcessingLimiter _pairProcessingLimiter;
+    private readonly ConcurrentQueue<(Pair Pair, OnlineUserIdentDto? Ident)> _pairCreationQueue = new();
+    private CancellationTokenSource _pairCreationCts = new();
+    private int _pairCreationProcessorRunning;
 
     public PairManager(ILogger<PairManager> logger, PairFactory pairFactory,
                 LightlessConfigService configurationService, LightlessMediator mediator,
-                IContextMenu dalamudContextMenu) : base(logger, mediator)
+                IContextMenu dalamudContextMenu, PairProcessingLimiter pairProcessingLimiter) : base(logger, mediator)
     {
         _pairFactory = pairFactory;
         _configurationService = configurationService;
         _dalamudContextMenu = dalamudContextMenu;
+        _pairProcessingLimiter = pairProcessingLimiter;
         Mediator.Subscribe<DisconnectedMessage>(this, (_) => ClearPairs());
         Mediator.Subscribe<CutsceneEndMessage>(this, (_) => ReapplyPairData());
         _directPairsInternal = DirectPairsLazy();
@@ -112,6 +121,7 @@ public sealed class PairManager : DisposableMediatorSubscriberBase
     public void ClearPairs()
     {
         Logger.LogDebug("Clearing all Pairs");
+        ResetPairCreationQueue();
         DisposePairs();
         _allClientPairs.Clear();
         _allGroups.Clear();
@@ -161,7 +171,7 @@ public sealed class PairManager : DisposableMediatorSubscriberBase
             Mediator.Publish(new NotificationMessage("User online", msg, NotificationType.Info, TimeSpan.FromSeconds(5)));
         }
 
-        pair.CreateCachedPlayer(dto);
+        QueuePairCreation(pair, dto);
 
         RecreateLazy();
     }
@@ -332,6 +342,7 @@ public sealed class PairManager : DisposableMediatorSubscriberBase
     {
         base.Dispose(disposing);
 
+        ResetPairCreationQueue();
         _dalamudContextMenu.OnMenuOpened -= DalamudContextMenuOnOnOpenGameObjectContextMenu;
 
         DisposePairs();
@@ -390,6 +401,84 @@ public sealed class PairManager : DisposableMediatorSubscriberBase
         });
     }
 
+    private void QueuePairCreation(Pair pair, OnlineUserIdentDto? dto)
+    {
+        if (pair.HasCachedPlayer)
+        {
+            RecreateLazy();
+            return;
+        }
+
+        _pairCreationQueue.Enqueue((pair, dto));
+        StartPairCreationProcessor();
+    }
+
+    private void StartPairCreationProcessor()
+    {
+        if (_pairCreationCts.IsCancellationRequested)
+        {
+            return;
+        }
+
+        if (Interlocked.CompareExchange(ref _pairCreationProcessorRunning, 1, 0) == 0)
+        {
+            _ = Task.Run(ProcessPairCreationQueueAsync);
+        }
+    }
+
+    private async Task ProcessPairCreationQueueAsync()
+    {
+        try
+        {
+            while (!_pairCreationCts.IsCancellationRequested)
+            {
+                if (!_pairCreationQueue.TryDequeue(out var work))
+                {
+                    break;
+                }
+
+                try
+                {
+                    await using var lease = await _pairProcessingLimiter.AcquireAsync(_pairCreationCts.Token).ConfigureAwait(false);
+                    if (!work.Pair.HasCachedPlayer)
+                    {
+                        work.Pair.CreateCachedPlayer(work.Ident);
+                    }
+                }
+                catch (OperationCanceledException)
+                {
+                    break;
+                }
+                catch (Exception ex)
+                {
+                    Logger.LogError(ex, "Error creating cached player for {uid}", work.Pair.UserData.UID);
+                }
+
+                RecreateLazy();
+                await Task.Yield();
+            }
+        }
+        finally
+        {
+            Interlocked.Exchange(ref _pairCreationProcessorRunning, 0);
+            if (!_pairCreationQueue.IsEmpty && !_pairCreationCts.IsCancellationRequested)
+            {
+                StartPairCreationProcessor();
+            }
+        }
+    }
+
+    private void ResetPairCreationQueue()
+    {
+        _pairCreationCts.Cancel();
+        while (_pairCreationQueue.TryDequeue(out _))
+        {
+        }
+        _pairCreationCts.Dispose();
+        _pairCreationCts = new CancellationTokenSource();
+        Interlocked.Exchange(ref _pairCreationProcessorRunning, 0);
+    }
+
     private void ReapplyPairData()
     {
         foreach (var pair in _allClientPairs.Select(k => k.Value))