2.0.0 (#92)

2.0.0 Changes:

- Reworked shell finder UI with compact or list view with profile tags showing with the listing, allowing moderators to broadcast the syncshell as well to have it be used more.
- Reworked user list in syncshell admin screen to have filter visible and moved away from table to its own thing, allowing to copy uid/note/alias when clicking on the name.
- Reworked download bars and download box to make it look more modern, removed the jitter around, so it shouldn't vibrate around much.
- Chat has been added to the top menu, working in Zone or in Syncshells to be used there.
- Paired system has been revamped to make pausing and unpausing faster, and loading people should be faster as well.
- Moved to the internal object table to have faster load times for users; people should load in faster
- Compactor is running on a multi-threaded level instead of single-threaded; this should increase the speed of compacting files
- Nameplate Service has been reworked so it wouldn't use the nameplate handler anymore.
- Files can be resized when downloading to reduce load on users if they aren't compressed. (can be toggled to resize all).
- Penumbra Collections are now only made when people are visible, reducing the load on boot-up when having many syncshells in your list.
- Lightfinder plates have been moved away from using Nameplates, but will use an overlay.
- Main UI has been changed a bit with a gradient, and on hover will glow up now.
- Reworked Profile UI for Syncshell and Users to be more user-facing with more customizable items.
- Reworked Settings UI to look more modern.
- Performance should be better due to new systems that would dispose of the collections and better caching of items.

Co-authored-by: defnotken <itsdefnotken@gmail.com>
Co-authored-by: azyges <aaaaaa@aaa.aaa>
Co-authored-by: choco <choco@patat.nl>
Co-authored-by: cake <admin@cakeandbanana.nl>
Co-authored-by: Minmoose <KennethBohr@outlook.com>
Reviewed-on: #92

LightlessSync/Services/PairRequestService.cs

@@ -1,6 +1,6 @@
 using LightlessSync.LightlessConfiguration.Models;
-using LightlessSync.PlayerData.Pairs;
 using LightlessSync.Services.Mediator;
+using LightlessSync.UI.Services;
 using Microsoft.Extensions.Logging;
 
 namespace LightlessSync.Services;
@@ -8,10 +8,11 @@ namespace LightlessSync.Services;
 public sealed class PairRequestService : DisposableMediatorSubscriberBase
 {
     private readonly DalamudUtilService _dalamudUtil;
-    private readonly PairManager _pairManager;
+    private readonly PairUiService _pairUiService;
     private readonly Lazy<WebAPI.ApiController> _apiController;
     private readonly Lock _syncRoot = new();
     private readonly List<PairRequestEntry> _requests = [];
+    private readonly Dictionary<string, string> _displayNameCache = new(StringComparer.Ordinal);
 
     private static readonly TimeSpan _expiration = TimeSpan.FromMinutes(5);
 
@@ -19,12 +20,12 @@ public sealed class PairRequestService : DisposableMediatorSubscriberBase
         ILogger<PairRequestService> logger, 
         LightlessMediator mediator, 
         DalamudUtilService dalamudUtil, 
-        PairManager pairManager, 
+        PairUiService pairUiService, 
         Lazy<WebAPI.ApiController> apiController)
         : base(logger, mediator)
     {
         _dalamudUtil = dalamudUtil;
-        _pairManager = pairManager;
+        _pairUiService = pairUiService;
         _apiController = apiController;
 
         Mediator.Subscribe<PriorityFrameworkUpdateMessage>(this, _ =>
@@ -96,6 +97,10 @@ public sealed class PairRequestService : DisposableMediatorSubscriberBase
         lock (_syncRoot)
         {
             removed = _requests.RemoveAll(r => string.Equals(r.HashedCid, hashedCid, StringComparison.Ordinal)) > 0;
+            if (removed)
+            {
+                _displayNameCache.Remove(hashedCid);
+            }
         }
 
         if (removed)
@@ -129,6 +134,23 @@ public sealed class PairRequestService : DisposableMediatorSubscriberBase
             return string.Empty;
         }
 
+        if (TryGetCachedDisplayName(hashedCid, out var cached))
+        {
+            return cached;
+        }
+
+        var resolved = ResolveDisplayNameInternal(hashedCid);
+        if (!string.IsNullOrWhiteSpace(resolved))
+        {
+            CacheDisplayName(hashedCid, resolved);
+            return resolved;
+        }
+
+        return string.Empty;
+    }
+
+    private string ResolveDisplayNameInternal(string hashedCid)
+    {
         var (name, address) = _dalamudUtil.FindPlayerByNameHash(hashedCid);
         if (!string.IsNullOrWhiteSpace(name))
         {
@@ -138,8 +160,9 @@ public sealed class PairRequestService : DisposableMediatorSubscriberBase
                 : name;
         }
 
-        var pair = _pairManager
-            .GetOnlineUserPairs()
+        var snapshot = _pairUiService.GetSnapshot();
+        var pair = snapshot.PairsByUid.Values
+            .Where(p => !string.IsNullOrEmpty(p.GetPlayerNameHash()))
             .FirstOrDefault(p => string.Equals(p.Ident, hashedCid, StringComparison.Ordinal));
 
         if (pair != null)
@@ -185,7 +208,21 @@ public sealed class PairRequestService : DisposableMediatorSubscriberBase
         }
 
         var now = DateTime.UtcNow;
-        return _requests.RemoveAll(r => now - r.ReceivedAt > _expiration) > 0;
+        var removedAny = false;
+        for (var i = _requests.Count - 1; i >= 0; i--)
+        {
+            var entry = _requests[i];
+            if (now - entry.ReceivedAt <= _expiration)
+            {
+                continue;
+            }
+
+            _displayNameCache.Remove(entry.HashedCid);
+            _requests.RemoveAt(i);
+            removedAny = true;
+        }
+
+        return removedAny;
     }
 
     public void AcceptPairRequest(string hashedCid, string displayName)
@@ -229,4 +266,32 @@ public sealed class PairRequestService : DisposableMediatorSubscriberBase
     private record struct PairRequestEntry(string HashedCid, string MessageTemplate, DateTime ReceivedAt);
 
     public readonly record struct PairRequestDisplay(string HashedCid, string DisplayName, string Message, DateTime ReceivedAt);
+
+    private bool TryGetCachedDisplayName(string hashedCid, out string displayName)
+    {
+        lock (_syncRoot)
+        {
+            if (!string.IsNullOrWhiteSpace(hashedCid) && _displayNameCache.TryGetValue(hashedCid, out var cached))
+            {
+                displayName = cached;
+                return true;
+            }
+        }
+
+        displayName = string.Empty;
+        return false;
+    }
+
+    private void CacheDisplayName(string hashedCid, string displayName)
+    {
+        if (string.IsNullOrWhiteSpace(hashedCid) || string.IsNullOrWhiteSpace(displayName) || string.Equals(hashedCid, displayName, StringComparison.Ordinal))
+        {
+            return;
+        }
+
+        lock (_syncRoot)
+        {
+            _displayNameCache[hashedCid] = displayName;
+        }
+    }
 }