1.12.0 - LightFinder + Bugfixes + Other fixes from 1.11.X (#39)

![image.png](/attachments/c984e826-254e-4ce3-af92-4e795ea717ab)

Lightless 1.12.0 is HERE! In this major update, we are introducing something we've been working on and testing for the last couple of weeks. In this update we are introducing a new (**OPTIONAL**) feature called **LightFinder**! We took inspiration from FFXIV's very own Party Finder and decided to implement something that allows users to not only look for fellow Lightless users, but also put up their Syncshell for others looking to join a sync community!

When you enable LightFinder, you will be visible to other LightFinder users for **3 hours** or when you want to disabled it. When the 3 hours are up, you can either leave it disabled or enable it again for another 3 hours. The tag shown above will show above your nameplate, and you will be able to receive pair requests in your UI from other users with LightFinder enabled without having to input their uid!

![image.png](/attachments/91a7ce60-7771-49d7-bae8-6d7a67e46fa3)

Are you at a Venue? In Limsa? Partying in the streets of Uldah? If you're looking for fellow Lightless users you can now enable LightFinder and you will be shown to others who also have LightFinder enabled!

Looking for a Syncshell to join? Enable LightFinder to see what SyncShells are available to join!

Want to advertise your Syncshell? Choose the syncshell you want to put up in LightFinder and enable LightFinder.

**IMPORTANT: We want to stress the fact that, if you just want to sync with just your friends and no one else, this does not take that away. No one will know you use Lightless unless you choose to tell them, or use this **OPTIONAL** feature. Your privacy is still maintained if you don't want to use the feature.**

# Major Changes

## LightFinder - **OPTIONAL FEATURE** - **DOES NOT AFFECT YOU IF YOU DON'T WANT TO USE IT**

![image.png](/attachments/9a1e7455-f9b3-4e3a-9ec5-5bc74ed43c26)

* New **OPTIONAL** syncing feature where one can enable something like a Party Finder so that other Lightless users in the area can see you are looking for people to sync with. Enable it by clicking the compass button and then the `Enable LightFinder` button.

![image.png](/attachments/7be5c1fc-439f-43fc-bb1e-8ae32ab5e52e)

* [L] Send Pair Request has been added to player context menus. You should still be able to send a request without Lightfinder on BUT you will need to know the other player is using Lightless and have them send a pair request back.

![image.png](/attachments/75e0d600-baf9-43d5-af37-e86b6a1e209b)

* When in LightFinder mode, for X mins you will be visible to all Lightless Users WHO ALSO HAVE LIGHTFINDER ON and will receive notifications of people wanting to pair with you. If you are the person using LightFinder, you understand the risks of pairing with someone you don't know. If you are the person sending a request to someone with LightFinder on, you also understand the risks of pairing with someone you don't know. **AGAIN, THIS IS OPTIONAL.**

* When in LightFinder mode, you can also put up a Syncshell you own on the Syncshell Finder so that others can easily find it and join. This has to be done prior to enabling LightFinder.

![image.png](/attachments/1929d8e0-778d-4ced-9bf0-f350887980db)

* Syncshell Finder allows you to join Syncshells that are indexed by LightFinder

![image.png](/attachments/fef7b786-b1a0-4967-a4a9-886cdddc1a61)

# Minor Changes

* Vanity addition to our supporters: On top of vanity ids you can find a fun addition under Your User Settings -> Edit Lightless Profile -> Vanity Settings to change the colour of your name in the lightless ui. This will be shown to all users.
![image.png](/attachments/9b950c07-6b27-4bd1-a0d4-5346396b23e2)

* Pairing nameplate colour override can also now override FC tag (new option_

* Bunch of UI fixes, updates, and changes

* kdb is now a whitelisted filetype that can upload

Co-authored-by: CakeAndBanana <admin@cakeandbanana.nl>
Co-authored-by: azyges <aaaaaa@aaa.aaa>
Co-authored-by: choco <thijmenhogenkamp@gmail.com>
Co-authored-by: choco <choco@noreply.git.lightless-sync.org>
Co-authored-by: defnotken <itsdefnotken@gmail.com>
Reviewed-on: #39

LightlessSync/UI/CompactUI.cs

@@ -24,6 +24,7 @@ using Microsoft.Extensions.Logging;
 using System.Collections.Concurrent;
 using System.Collections.Immutable;
 using System.Globalization;
+using System.Linq;
 using System.Numerics;
 using System.Reflection;
 
@@ -51,6 +52,8 @@ public class CompactUi : WindowMediatorSubscriberBase
     private readonly TopTabMenu _tabMenu;
     private readonly TagHandler _tagHandler;
     private readonly UiSharedService _uiSharedService;
+    private readonly BroadcastService _broadcastService;
+
     private List<IDrawFolder> _drawFolders;
     private Dictionary<ObjectKind, Dictionary<string, CharacterAnalyzer.FileDataEntry>>? _cachedAnalysis;
     private Pair? _lastAddedUser;
@@ -62,13 +65,28 @@ public class CompactUi : WindowMediatorSubscriberBase
     private bool _wasOpen;
     private float _windowContentWidth;
 
-    public CompactUi(ILogger<CompactUi> logger, UiSharedService uiShared, LightlessConfigService configService, ApiController apiController, PairManager pairManager,
-        ServerConfigurationManager serverManager, LightlessMediator mediator, FileUploadManager fileTransferManager,
-        TagHandler tagHandler, DrawEntityFactory drawEntityFactory,
-        SelectTagForPairUi selectTagForPairUi, SelectPairForTagUi selectPairForTagUi, RenamePairTagUi renameTagUi,
-        SelectTagForSyncshellUi selectTagForSyncshellUi, SelectSyncshellForTagUi selectSyncshellForTagUi, RenameSyncshellTagUi renameSyncshellTagUi,
-        PerformanceCollectorService performanceCollectorService, IpcManager ipcManager, CharacterAnalyzer characterAnalyzer, PlayerPerformanceConfigService playerPerformanceConfig, LightlessMediator lightlessMediator)
-        : base(logger, mediator, "###LightlessSyncMainUI", performanceCollectorService)
+    public CompactUi(
+        ILogger<CompactUi> logger,
+        UiSharedService uiShared,
+        LightlessConfigService configService,
+        ApiController apiController,
+        PairManager pairManager,
+        ServerConfigurationManager serverManager,
+        LightlessMediator mediator,
+        FileUploadManager fileTransferManager,
+        TagHandler tagHandler,
+        DrawEntityFactory drawEntityFactory,
+        SelectTagForPairUi selectTagForPairUi,
+        SelectPairForTagUi selectPairForTagUi,
+        RenamePairTagUi renameTagUi,
+        SelectTagForSyncshellUi selectTagForSyncshellUi,
+        SelectSyncshellForTagUi selectSyncshellForTagUi,
+        RenameSyncshellTagUi renameSyncshellTagUi,
+        PerformanceCollectorService performanceCollectorService,
+        IpcManager ipcManager,
+        BroadcastService broadcastService,
+        CharacterAnalyzer characterAnalyzer,
+        PlayerPerformanceConfigService playerPerformanceConfig, PairRequestService pairRequestService, DalamudUtilService dalamudUtilService) : base(logger, mediator, "###LightlessSyncMainUI", performanceCollectorService)
     {
         _uiSharedService = uiShared;
         _configService = configService;
@@ -85,7 +103,8 @@ public class CompactUi : WindowMediatorSubscriberBase
         _selectPairsForGroupUi = selectPairForTagUi;
         _renamePairTagUi = renameTagUi;
         _ipcManager = ipcManager;
-        _tabMenu = new TopTabMenu(Mediator, _apiController, _pairManager, _uiSharedService);
+        _broadcastService = broadcastService;
+        _tabMenu = new TopTabMenu(Mediator, _apiController, _pairManager, _uiSharedService, pairRequestService, dalamudUtilService);
 
         AllowPinning = true;
         AllowClickthrough = false;
@@ -120,10 +139,10 @@ public class CompactUi : WindowMediatorSubscriberBase
                     ImGui.Text("Open Lightless Event Viewer");
                     ImGui.EndTooltip();
                 }
-            }
+            },
         };
 
-        _drawFolders = [.. GetDrawFolders()];
+        _drawFolders = [.. DrawFolders];
 
 #if DEBUG
         string dev = "Dev Build";
@@ -140,7 +159,7 @@ public class CompactUi : WindowMediatorSubscriberBase
         Mediator.Subscribe<CutsceneEndMessage>(this, (_) => UiSharedService_GposeEnd());
         Mediator.Subscribe<DownloadStartedMessage>(this, (msg) => _currentDownloads[msg.DownloadId] = msg.DownloadStatus);
         Mediator.Subscribe<DownloadFinishedMessage>(this, (msg) => _currentDownloads.TryRemove(msg.DownloadId, out _));
-        Mediator.Subscribe<RefreshUiMessage>(this, (msg) => _drawFolders = GetDrawFolders().ToList());
+        Mediator.Subscribe<RefreshUiMessage>(this, (msg) => _drawFolders = DrawFolders.ToList());
 
         Flags |= ImGuiWindowFlags.NoDocking;
 
@@ -151,7 +170,7 @@ public class CompactUi : WindowMediatorSubscriberBase
         };
         _characterAnalyzer = characterAnalyzer;
         _playerPerformanceConfig = playerPerformanceConfig;
-        _lightlessMediator = lightlessMediator;
+        _lightlessMediator = mediator;
     }
 
     protected override void DrawInternal()
@@ -202,7 +221,7 @@ public class CompactUi : WindowMediatorSubscriberBase
         }
 
         using (ImRaii.PushId("header")) DrawUIDHeader();
-        _uiSharedService.ColoredSeparator(UIColors.Get("LightlessPurple"), 2f);
+        _uiSharedService.RoundedSeparator(UIColors.Get("LightlessPurple"), 2.5f, 1f, 12f);
         using (ImRaii.PushId("serverstatus")) DrawServerStatus();
         ImGui.Separator();
 
@@ -383,7 +402,7 @@ public class CompactUi : WindowMediatorSubscriberBase
             ImGui.TextUnformatted("No uploads in progress");
         }
 
-        var currentDownloads = _currentDownloads.SelectMany(d => d.Value.Values).ToList();
+        var currentDownloads = BuildCurrentDownloadSnapshot();
         ImGui.AlignTextToFramePadding();
         _uiSharedService.IconText(FontAwesomeIcon.Download);
         ImGui.SameLine(35 * ImGuiHelpers.GlobalScale);
@@ -410,26 +429,165 @@ public class CompactUi : WindowMediatorSubscriberBase
         }
     }
 
+
+    private List<FileDownloadStatus> BuildCurrentDownloadSnapshot()
+    {
+        List<FileDownloadStatus> snapshot = new();
+
+        foreach (var kvp in _currentDownloads.ToArray())
+        {
+            var value = kvp.Value;
+            if (value == null || value.Count == 0)
+                continue;
+
+            try
+            {
+                snapshot.AddRange(value.Values.ToArray());
+            }
+            catch (System.ArgumentException)
+            {
+                // skibidi
+            }
+        }
+
+        return snapshot;
+    }
+
     private void DrawUIDHeader()
     {
         var uidText = GetUidText();
 
+        Vector4? vanityTextColor = null;
+        Vector4? vanityGlowColor = null;
+        bool useVanityColors = false;
+
+        if (_configService.Current.useColoredUIDs && _apiController.HasVanity)
+        {
+            if (!string.IsNullOrWhiteSpace(_apiController.TextColorHex))
+            {
+                vanityTextColor = UIColors.HexToRgba(_apiController.TextColorHex);
+            }
+
+            if (!string.IsNullOrWhiteSpace(_apiController.TextGlowColorHex))
+            {
+                vanityGlowColor = UIColors.HexToRgba(_apiController.TextGlowColorHex);
+            }
+
+            useVanityColors = vanityTextColor is not null || vanityGlowColor is not null;
+        }
+
         //Getting information of character and triangles threshold to show overlimit status in UID bar.
         _cachedAnalysis = _characterAnalyzer.LastAnalysis.DeepClone();
 
+        Vector2 uidTextSize, iconSize;
         using (_uiSharedService.UidFont.Push())
+            uidTextSize = ImGui.CalcTextSize(uidText);
+
+        using (_uiSharedService.IconFont.Push())
+            iconSize = ImGui.CalcTextSize(FontAwesomeIcon.PersonCirclePlus.ToIconString());
+
+        float contentWidth = ImGui.GetWindowContentRegionMax().X - ImGui.GetWindowContentRegionMin().X;
+        float uidStartX = (contentWidth - uidTextSize.X) / 2f;
+        float cursorY = ImGui.GetCursorPosY();  
+
+        if (_configService.Current.BroadcastEnabled && _apiController.IsConnected)
         {
-            var uidTextSize = ImGui.CalcTextSize(uidText);
-            ImGui.SetCursorPosX((ImGui.GetWindowContentRegionMax().X - ImGui.GetWindowContentRegionMin().X) / 2 - (uidTextSize.X / 2));
-            ImGui.TextColored(GetUidColor(), uidText);
+            float iconYOffset = (uidTextSize.Y - iconSize.Y) * 0.5f;
+            var buttonSize = new Vector2(iconSize.X, uidTextSize.Y);
+
+            ImGui.SetCursorPos(new Vector2(ImGui.GetStyle().ItemSpacing.X + 5f, cursorY));
+            ImGui.InvisibleButton("BroadcastIcon", buttonSize);
+
+            var iconPos = ImGui.GetItemRectMin() + new Vector2(0f, iconYOffset);
+            using (_uiSharedService.IconFont.Push())
+                ImGui.GetWindowDrawList().AddText(iconPos, ImGui.GetColorU32(UIColors.Get("LightlessGreen")), FontAwesomeIcon.PersonCirclePlus.ToIconString());
+
+
+            if (ImGui.IsItemHovered())
+            {
+                ImGui.BeginTooltip();
+
+                ImGui.PushStyleColor(ImGuiCol.Text, UIColors.Get("PairBlue"));
+                ImGui.Text("Lightfinder");
+                ImGui.PopStyleColor();
+
+                ImGui.PushStyleColor(ImGuiCol.Text, UIColors.Get("DimRed"));
+                ImGui.TextWrapped("Use Lightfinder when you're okay with being visible to other users and understand that you are responsible for your own experience.");
+                ImGui.PopStyleColor();
+
+                ImGuiHelpers.ScaledDummy(0.2f);
+                _uiSharedService.ColoredSeparator(UIColors.Get("LightlessPurple"), 2f);
+
+                if (_configService.Current.BroadcastEnabled)
+                {
+                    ImGui.PushStyleColor(ImGuiCol.Text, UIColors.Get("LightlessGreen"));
+                    ImGui.Text("The Lightfinder calls, and somewhere, a soul may answer."); // cringe..
+                    ImGui.PopStyleColor();
+
+                    var ttl = _broadcastService.RemainingTtl;
+                    if (ttl is { } remaining && remaining > TimeSpan.Zero)
+                    {
+                        ImGui.PushStyleColor(ImGuiCol.Text, UIColors.Get("LightlessYellow"));
+                        ImGui.Text($"Still shining, for {remaining:hh\\:mm\\:ss}");
+                        ImGui.PopStyleColor();
+                    }
+                    else
+                    {
+                        ImGui.PushStyleColor(ImGuiCol.Text, UIColors.Get("DimRed"));
+                        ImGui.Text("The Lightfinder's light wanes, but not in vain."); // cringe..
+                        ImGui.PopStyleColor();
+                    }
+                }
+                else
+                {
+                    ImGui.PushStyleColor(ImGuiCol.Text, UIColors.Get("DimRed"));
+                    ImGui.Text("The Lightfinder rests, waiting to shine again."); // cringe..
+                    ImGui.PopStyleColor();
+                }
+
+                var cooldown = _broadcastService.RemainingCooldown;
+                if (cooldown is { } cd)
+                {
+                    ImGui.PushStyleColor(ImGuiCol.Text, UIColors.Get("DimRed"));
+                    ImGui.Text($"The Lightfinder gathers its strength... ({Math.Ceiling(cd.TotalSeconds)}s)");
+                    ImGui.PopStyleColor();
+                }
+
+                ImGui.EndTooltip();
+            }
+
+            if (ImGui.IsItemClicked())
+                _lightlessMediator.Publish(new UiToggleMessage(typeof(BroadcastUI)));
         }
 
-        UiSharedService.AttachToolTip("Click to copy");
-        if (ImGui.IsItemClicked())
+        ImGui.SetCursorPosY(cursorY);
+        ImGui.SetCursorPosX(uidStartX);
+
+        bool headerItemClicked;
+        using (_uiSharedService.UidFont.Push())
+        {
+            if (useVanityColors)
+            {
+                var seString = SeStringUtils.BuildFormattedPlayerName(uidText, vanityTextColor, vanityGlowColor);
+                var cursorPos = ImGui.GetCursorScreenPos();
+                var fontPtr = ImGui.GetFont();
+                SeStringUtils.RenderSeStringWithHitbox(seString, cursorPos, fontPtr);
+            }
+            else
+            {
+                ImGui.TextColored(GetUidColor(), uidText);
+            }
+        }
+
+        headerItemClicked = ImGui.IsItemClicked();
+
+        if (headerItemClicked)
         {
             ImGui.SetClipboardText(uidText);
         }
 
+        UiSharedService.AttachToolTip("Click to copy");
+
         if (_cachedAnalysis != null && _apiController.ServerState is ServerState.Connected)
         {
             var firstEntry = _cachedAnalysis.FirstOrDefault();
@@ -459,6 +617,7 @@ public class CompactUi : WindowMediatorSubscriberBase
                     if ((isOverTriHold || isOverVRAMUsage) && _playerPerformanceConfig.Current.WarnOnExceedingThresholds)
                     {
                         ImGui.SameLine();
+                        ImGui.SetCursorPosY(cursorY + 15f);
                         _uiSharedService.IconText(FontAwesomeIcon.ExclamationTriangle, UIColors.Get("LightlessYellow"));
                         
                         string warningMessage = "";
@@ -486,7 +645,7 @@ public class CompactUi : WindowMediatorSubscriberBase
 
         if (_apiController.ServerState is ServerState.Connected)
         {
-            if (ImGui.IsItemClicked())
+            if (headerItemClicked)
             {
                 ImGui.SetClipboardText(_apiController.DisplayName);
             }
@@ -495,9 +654,22 @@ public class CompactUi : WindowMediatorSubscriberBase
             {
                 var origTextSize = ImGui.CalcTextSize(_apiController.UID);
                 ImGui.SetCursorPosX((ImGui.GetWindowContentRegionMax().X - ImGui.GetWindowContentRegionMin().X) / 2 - (origTextSize.X / 2));
-                ImGui.TextColored(GetUidColor(), _apiController.UID);
+
+                if (useVanityColors)
+                {
+                    var seString = SeStringUtils.BuildFormattedPlayerName(_apiController.UID, vanityTextColor, vanityGlowColor);
+                    var cursorPos = ImGui.GetCursorScreenPos();
+                    var fontPtr = ImGui.GetFont();
+                    SeStringUtils.RenderSeStringWithHitbox(seString, cursorPos, fontPtr);
+                }
+                else
+                {
+                    ImGui.TextColored(GetUidColor(), _apiController.UID);
+                }
+
+                bool uidFooterClicked = ImGui.IsItemClicked();
                 UiSharedService.AttachToolTip("Click to copy");
-                if (ImGui.IsItemClicked())
+                if (uidFooterClicked)
                 {
                     _lightlessMediator.Publish(new UiToggleMessage(typeof(DataAnalysisUi)));
                 }
@@ -509,168 +681,166 @@ public class CompactUi : WindowMediatorSubscriberBase
         }
     }
 
-    private IEnumerable<IDrawFolder> GetDrawFolders()
+    private IEnumerable<IDrawFolder> DrawFolders
     {
-        List<IDrawFolder> drawFolders = [];
-
-        var allPairs = _pairManager.PairsWithGroups
-            .ToDictionary(k => k.Key, k => k.Value);
-        var filteredPairs = allPairs
-            .Where(p =>
-            {
-                if (_tabMenu.Filter.IsNullOrEmpty()) return true;
-                return p.Key.UserData.AliasOrUID.Contains(_tabMenu.Filter, StringComparison.OrdinalIgnoreCase) ||
-                       (p.Key.GetNote()?.Contains(_tabMenu.Filter, StringComparison.OrdinalIgnoreCase) ?? false) ||
-                       (p.Key.PlayerName?.Contains(_tabMenu.Filter, StringComparison.OrdinalIgnoreCase) ?? false);
-            })
-            .ToDictionary(k => k.Key, k => k.Value);
-
-        string? AlphabeticalSort(KeyValuePair<Pair, List<GroupFullInfoDto>> u)
-            => (_configService.Current.ShowCharacterNameInsteadOfNotesForVisible && !string.IsNullOrEmpty(u.Key.PlayerName)
-                    ? (_configService.Current.PreferNotesOverNamesForVisible ? u.Key.GetNote() : u.Key.PlayerName)
-                    : (u.Key.GetNote() ?? u.Key.UserData.AliasOrUID));
-        bool FilterOnlineOrPausedSelf(KeyValuePair<Pair, List<GroupFullInfoDto>> u)
-            => (u.Key.IsOnline || (!u.Key.IsOnline && !_configService.Current.ShowOfflineUsersSeparately)
-                    || u.Key.UserPair.OwnPermissions.IsPaused());
-        Dictionary<Pair, List<GroupFullInfoDto>> BasicSortedDictionary(IEnumerable<KeyValuePair<Pair, List<GroupFullInfoDto>>> u)
-            => u.OrderByDescending(u => u.Key.IsVisible)
-                .ThenByDescending(u => u.Key.IsOnline)
-                .ThenBy(AlphabeticalSort, StringComparer.OrdinalIgnoreCase)
-                .ToDictionary(u => u.Key, u => u.Value);
-        ImmutableList<Pair> ImmutablePairList(IEnumerable<KeyValuePair<Pair, List<GroupFullInfoDto>>> u)
-            => u.Select(k => k.Key).ToImmutableList();
-        bool FilterVisibleUsers(KeyValuePair<Pair, List<GroupFullInfoDto>> u)
-            => u.Key.IsVisible
-                && (_configService.Current.ShowSyncshellUsersInVisible || !(!_configService.Current.ShowSyncshellUsersInVisible && !u.Key.IsDirectlyPaired));
-        bool FilterTagUsers(KeyValuePair<Pair, List<GroupFullInfoDto>> u, string tag)
-            => u.Key.IsDirectlyPaired && !u.Key.IsOneSidedPair && _tagHandler.HasPairTag(u.Key.UserData.UID, tag);
-        bool FilterGroupUsers(KeyValuePair<Pair, List<GroupFullInfoDto>> u, GroupFullInfoDto group)
-            => u.Value.Exists(g => string.Equals(g.GID, group.GID, StringComparison.Ordinal));
-        bool FilterNotTaggedUsers(KeyValuePair<Pair, List<GroupFullInfoDto>> u)
-            => u.Key.IsDirectlyPaired && !u.Key.IsOneSidedPair && !_tagHandler.HasAnyPairTag(u.Key.UserData.UID);
-        bool FilterNotTaggedSyncshells(GroupFullInfoDto group)
-            => (!_tagHandler.HasAnySyncshellTag(group.GID) && !_configService.Current.ShowGroupedSyncshellsInAll) || true;
-        bool FilterOfflineUsers(KeyValuePair<Pair, List<GroupFullInfoDto>> u)
-            => ((u.Key.IsDirectlyPaired && _configService.Current.ShowSyncshellOfflineUsersSeparately)
-                || !_configService.Current.ShowSyncshellOfflineUsersSeparately)
-                && (!u.Key.IsOneSidedPair || u.Value.Any()) && !u.Key.IsOnline && !u.Key.UserPair.OwnPermissions.IsPaused();
-        bool FilterOfflineSyncshellUsers(KeyValuePair<Pair, List<GroupFullInfoDto>> u)
-            => (!u.Key.IsDirectlyPaired && !u.Key.IsOnline && !u.Key.UserPair.OwnPermissions.IsPaused());
-
-
-        if (_configService.Current.ShowVisibleUsersSeparately)
+        get
         {
-            var allVisiblePairs = ImmutablePairList(allPairs
-                .Where(FilterVisibleUsers));
-            var filteredVisiblePairs = BasicSortedDictionary(filteredPairs
-                .Where(FilterVisibleUsers));
+            var drawFolders = new List<IDrawFolder>();
+            var filter = _tabMenu.Filter;
 
-            drawFolders.Add(_drawEntityFactory.CreateDrawTagFolder(TagHandler.CustomVisibleTag, filteredVisiblePairs, allVisiblePairs));
-        }
+            var allPairs = _pairManager.PairsWithGroups.ToDictionary(k => k.Key, k => k.Value);
+            var filteredPairs = allPairs.Where(p => PassesFilter(p.Key, filter)).ToDictionary(k => k.Key, k => k.Value);
 
-        List<IDrawFolder> groupFolders = new();
-
-        foreach (var group in _pairManager.GroupPairs.Select(g => g.Key).OrderBy(g => g.GroupAliasOrGID, StringComparer.OrdinalIgnoreCase))
-        {
-            GetGroups(allPairs, filteredPairs, group, out ImmutableList<Pair> allGroupPairs, out Dictionary<Pair, List<GroupFullInfoDto>> filteredGroupPairs);
-            if (FilterNotTaggedSyncshells(group))
+            //Filter of online/visible pairs
+            if (_configService.Current.ShowVisibleUsersSeparately)
             {
-                groupFolders.Add(_drawEntityFactory.CreateDrawGroupFolder(group, filteredGroupPairs, allGroupPairs));
+                var allVisiblePairs = ImmutablePairList(allPairs.Where(p => FilterVisibleUsers(p.Key)));
+                var filteredVisiblePairs = BasicSortedDictionary(filteredPairs.Where(p => FilterVisibleUsers(p.Key)));
+
+                drawFolders.Add(_drawEntityFactory.CreateDrawTagFolder(TagHandler.CustomVisibleTag, filteredVisiblePairs, allVisiblePairs));
             }
-        }
 
-        if (_configService.Current.GroupUpSyncshells)
-            drawFolders.Add(new DrawGroupedGroupFolder(groupFolders, _tagHandler, _uiSharedService, _selectSyncshellForTagUi, _renameSyncshellTagUi, ""));
-        else
-            drawFolders.AddRange(groupFolders);
-
-        var tags = _tagHandler.GetAllPairTagsSorted();
-        foreach (var tag in tags)
-        {
-            var allTagPairs = ImmutablePairList(allPairs
-                .Where(u => FilterTagUsers(u, tag)));
-            var filteredTagPairs = BasicSortedDictionary(filteredPairs
-                .Where(u => FilterTagUsers(u, tag) && FilterOnlineOrPausedSelf(u)));
-
-            drawFolders.Add(_drawEntityFactory.CreateDrawTagFolder(tag, filteredTagPairs, allTagPairs));
-        }
-
-        var syncshellTags = _tagHandler.GetAllSyncshellTagsSorted();
-        foreach (var syncshelltag in syncshellTags)
-        {
-            List<IDrawFolder> syncshellFolderTags = [];
+            //Filter of not foldered syncshells
+            var groupFolders = new List<IDrawFolder>();
             foreach (var group in _pairManager.GroupPairs.Select(g => g.Key).OrderBy(g => g.GroupAliasOrGID, StringComparer.OrdinalIgnoreCase))
             {
-                if (_tagHandler.HasSyncshellTag(group.GID, syncshelltag))
+                GetGroups(allPairs, filteredPairs, group, out ImmutableList<Pair> allGroupPairs, out Dictionary<Pair, List<GroupFullInfoDto>> filteredGroupPairs);
+
+                if (FilterNotTaggedSyncshells(group))
                 {
-                    GetGroups(allPairs, filteredPairs, group, out ImmutableList<Pair> allGroupPairs, out Dictionary<Pair, List<GroupFullInfoDto>> filteredGroupPairs);
-                    syncshellFolderTags.Add(_drawEntityFactory.CreateDrawGroupFolder($"tag_{group.GID}", group, filteredGroupPairs, allGroupPairs));
+                    groupFolders.Add(_drawEntityFactory.CreateDrawGroupFolder(group, filteredGroupPairs, allGroupPairs));
                 }
             }
 
-            if (syncshellFolderTags.Count > 0)
+            //Filter of grouped up syncshells (All Syncshells Folder)
+            if (_configService.Current.GroupUpSyncshells)
+                drawFolders.Add(new DrawGroupedGroupFolder(groupFolders, _tagHandler, _uiSharedService,
+                    _selectSyncshellForTagUi, _renameSyncshellTagUi, ""));
+            else
+                drawFolders.AddRange(groupFolders);
+
+            //Filter of grouped/foldered pairs
+            foreach (var tag in _tagHandler.GetAllPairTagsSorted())
             {
-                drawFolders.Add(new DrawGroupedGroupFolder(syncshellFolderTags, _tagHandler, _uiSharedService, _selectSyncshellForTagUi, _renameSyncshellTagUi, syncshelltag));
+                var allTagPairs = ImmutablePairList(allPairs.Where(p => FilterTagUsers(p.Key, tag)));
+                var filteredTagPairs = BasicSortedDictionary(filteredPairs.Where(p => FilterTagUsers(p.Key, tag) && FilterOnlineOrPausedSelf(p.Key)));
+
+                drawFolders.Add(_drawEntityFactory.CreateDrawTagFolder(tag, filteredTagPairs, allTagPairs));
             }
-        }
 
-        var allOnlineNotTaggedPairs = ImmutablePairList(allPairs
-            .Where(FilterNotTaggedUsers));
-        var onlineNotTaggedPairs = BasicSortedDictionary(filteredPairs
-            .Where(u => FilterNotTaggedUsers(u) && FilterOnlineOrPausedSelf(u)));
-
-        drawFolders.Add(_drawEntityFactory.CreateDrawTagFolder((_configService.Current.ShowOfflineUsersSeparately ? TagHandler.CustomOnlineTag : TagHandler.CustomAllTag),
-            onlineNotTaggedPairs, allOnlineNotTaggedPairs));
-
-        if (_configService.Current.ShowOfflineUsersSeparately)
-        {
-            var allOfflinePairs = ImmutablePairList(allPairs
-                .Where(FilterOfflineUsers));
-            var filteredOfflinePairs = BasicSortedDictionary(filteredPairs
-                .Where(FilterOfflineUsers));
-
-            drawFolders.Add(_drawEntityFactory.CreateDrawTagFolder(TagHandler.CustomOfflineTag, filteredOfflinePairs, allOfflinePairs));
-            if (_configService.Current.ShowSyncshellOfflineUsersSeparately)
+            //Filter of grouped/foldered syncshells
+            foreach (var syncshellTag in _tagHandler.GetAllSyncshellTagsSorted())
             {
-                var allOfflineSyncshellUsers = ImmutablePairList(allPairs
-                    .Where(FilterOfflineSyncshellUsers));
-                var filteredOfflineSyncshellUsers = BasicSortedDictionary(filteredPairs
-                    .Where(FilterOfflineSyncshellUsers));
-
-                drawFolders.Add(_drawEntityFactory.CreateDrawTagFolder(TagHandler.CustomOfflineSyncshellTag,
-                    filteredOfflineSyncshellUsers,
-                    allOfflineSyncshellUsers));
-            }
-        }
-
-        drawFolders.Add(_drawEntityFactory.CreateDrawTagFolder(TagHandler.CustomUnpairedTag,
-            BasicSortedDictionary(filteredPairs.Where(u => u.Key.IsOneSidedPair)),
-            ImmutablePairList(allPairs.Where(u => u.Key.IsOneSidedPair))));
-
-        return drawFolders;
-
-        void GetGroups(Dictionary<Pair, List<GroupFullInfoDto>> allPairs, Dictionary<Pair, List<GroupFullInfoDto>> filteredPairs, GroupFullInfoDto group, out ImmutableList<Pair> allGroupPairs, out Dictionary<Pair, List<GroupFullInfoDto>> filteredGroupPairs)
-        {
-            allGroupPairs = ImmutablePairList(allPairs
-            .Where(u => FilterGroupUsers(u, group)));
-            filteredGroupPairs = filteredPairs
-                .Where(u => FilterGroupUsers(u, group) && FilterOnlineOrPausedSelf(u))
-                .OrderByDescending(u => u.Key.IsOnline)
-                .ThenBy(u =>
+                var syncshellFolderTags = new List<IDrawFolder>();
+                foreach (var group in _pairManager.GroupPairs.Select(g => g.Key).OrderBy(g => g.GroupAliasOrGID, StringComparer.OrdinalIgnoreCase))
                 {
-                    if (string.Equals(u.Key.UserData.UID, group.OwnerUID, StringComparison.Ordinal)) return 0;
-                    if (group.GroupPairUserInfos.TryGetValue(u.Key.UserData.UID, out var info))
+                    if (_tagHandler.HasSyncshellTag(group.GID, syncshellTag))
                     {
-                        if (info.IsModerator()) return 1;
-                        if (info.IsPinned()) return 2;
+                        GetGroups(allPairs, filteredPairs, group,
+                            out ImmutableList<Pair> allGroupPairs,
+                            out Dictionary<Pair, List<GroupFullInfoDto>> filteredGroupPairs);
+
+                        syncshellFolderTags.Add(_drawEntityFactory.CreateDrawGroupFolder($"tag_{group.GID}", group, filteredGroupPairs, allGroupPairs));
                     }
-                    return u.Key.IsVisible ? 3 : 4;
-                })
-                .ThenBy(AlphabeticalSort, StringComparer.OrdinalIgnoreCase)
-                .ToDictionary(k => k.Key, k => k.Value);
+                }
+
+                drawFolders.Add(new DrawGroupedGroupFolder(syncshellFolderTags, _tagHandler, _uiSharedService, _selectSyncshellForTagUi, _renameSyncshellTagUi, syncshellTag));
+            }
+
+            //Filter of not grouped/foldered and offline pairs
+            var allOnlineNotTaggedPairs = ImmutablePairList(allPairs.Where(p => FilterNotTaggedUsers(p.Key)));
+            var onlineNotTaggedPairs = BasicSortedDictionary(filteredPairs.Where(p => FilterNotTaggedUsers(p.Key) && FilterOnlineOrPausedSelf(p.Key)));
+
+            drawFolders.Add(_drawEntityFactory.CreateDrawTagFolder((_configService.Current.ShowOfflineUsersSeparately ? TagHandler.CustomOnlineTag : TagHandler.CustomAllTag), onlineNotTaggedPairs, allOnlineNotTaggedPairs));
+
+            if (_configService.Current.ShowOfflineUsersSeparately)
+            {
+                var allOfflinePairs = ImmutablePairList(allPairs.Where(p => FilterOfflineUsers(p.Key, p.Value)));
+                var filteredOfflinePairs = BasicSortedDictionary(filteredPairs.Where(p => FilterOfflineUsers(p.Key, p.Value)));
+
+                drawFolders.Add(_drawEntityFactory.CreateDrawTagFolder(TagHandler.CustomOfflineTag, filteredOfflinePairs, allOfflinePairs));
+
+                if (_configService.Current.ShowSyncshellOfflineUsersSeparately)
+                {
+                    var allOfflineSyncshellUsers = ImmutablePairList(allPairs.Where(p => FilterOfflineSyncshellUsers(p.Key)));
+                    var filteredOfflineSyncshellUsers = BasicSortedDictionary(filteredPairs.Where(p => FilterOfflineSyncshellUsers(p.Key)));
+
+                    drawFolders.Add(_drawEntityFactory.CreateDrawTagFolder(TagHandler.CustomOfflineSyncshellTag, filteredOfflineSyncshellUsers, allOfflineSyncshellUsers));
+                }
+            }
+
+            //Unpaired 
+            drawFolders.Add(_drawEntityFactory.CreateDrawTagFolder(TagHandler.CustomUnpairedTag,
+                BasicSortedDictionary(filteredPairs.Where(p => p.Key.IsOneSidedPair)),
+                ImmutablePairList(allPairs.Where(p => p.Key.IsOneSidedPair))));
+
+            return drawFolders;
         }
     }
 
+    private static bool PassesFilter(Pair pair, string filter)
+    {
+        if (string.IsNullOrEmpty(filter)) return true;
+
+        return pair.UserData.AliasOrUID.Contains(filter, StringComparison.OrdinalIgnoreCase) || (pair.GetNote()?.Contains(filter, StringComparison.OrdinalIgnoreCase) ?? false) || (pair.PlayerName?.Contains(filter, StringComparison.OrdinalIgnoreCase) ?? false);
+    }
+
+    private string AlphabeticalSortKey(Pair pair)
+    {
+        if (_configService.Current.ShowCharacterNameInsteadOfNotesForVisible && !string.IsNullOrEmpty(pair.PlayerName))
+        {
+            return _configService.Current.PreferNotesOverNamesForVisible ? (pair.GetNote() ?? string.Empty) : pair.PlayerName;
+        }
+
+        return pair.GetNote() ?? pair.UserData.AliasOrUID;
+    }
+
+    private bool FilterOnlineOrPausedSelf(Pair pair) => pair.IsOnline || (!pair.IsOnline && !_configService.Current.ShowOfflineUsersSeparately) || pair.UserPair.OwnPermissions.IsPaused();
+
+    private bool FilterVisibleUsers(Pair pair) => pair.IsVisible && (_configService.Current.ShowSyncshellUsersInVisible || pair.IsDirectlyPaired);
+
+    private bool FilterTagUsers(Pair pair, string tag) => pair.IsDirectlyPaired && !pair.IsOneSidedPair && _tagHandler.HasPairTag(pair.UserData.UID, tag);
+
+    private static bool FilterGroupUsers(List<GroupFullInfoDto> groups, GroupFullInfoDto group) => groups.Exists(g => string.Equals(g.GID, group.GID, StringComparison.Ordinal));
+
+    private bool FilterNotTaggedUsers(Pair pair) => pair.IsDirectlyPaired && !pair.IsOneSidedPair && !_tagHandler.HasAnyPairTag(pair.UserData.UID);
+
+    private bool FilterNotTaggedSyncshells(GroupFullInfoDto group) => !_tagHandler.HasAnySyncshellTag(group.GID) || _configService.Current.ShowGroupedSyncshellsInAll;
+
+    private bool FilterOfflineUsers(Pair pair, List<GroupFullInfoDto> groups) => ((pair.IsDirectlyPaired && _configService.Current.ShowSyncshellOfflineUsersSeparately) || !_configService.Current.ShowSyncshellOfflineUsersSeparately) && (!pair.IsOneSidedPair || groups.Count != 0) && !pair.IsOnline && !pair.UserPair.OwnPermissions.IsPaused();
+
+    private static bool FilterOfflineSyncshellUsers(Pair pair) => !pair.IsDirectlyPaired && !pair.IsOnline && !pair.UserPair.OwnPermissions.IsPaused();
+
+    private Dictionary<Pair, List<GroupFullInfoDto>> BasicSortedDictionary(IEnumerable<KeyValuePair<Pair, List<GroupFullInfoDto>>> pairs) => pairs.OrderByDescending(u => u.Key.IsVisible).ThenByDescending(u => u.Key.IsOnline).ThenBy(u => AlphabeticalSortKey(u.Key), StringComparer.OrdinalIgnoreCase).ToDictionary(u => u.Key, u => u.Value);
+
+    private static ImmutableList<Pair> ImmutablePairList(IEnumerable<KeyValuePair<Pair, List<GroupFullInfoDto>>> pairs) => [.. pairs.Select(k => k.Key)];
+
+    private void GetGroups(Dictionary<Pair, List<GroupFullInfoDto>> allPairs,
+                           Dictionary<Pair, List<GroupFullInfoDto>> filteredPairs,
+                           GroupFullInfoDto group,
+                           out ImmutableList<Pair> allGroupPairs,
+                           out Dictionary<Pair, List<GroupFullInfoDto>> filteredGroupPairs)
+    {
+        allGroupPairs = ImmutablePairList(allPairs
+            .Where(u => FilterGroupUsers(u.Value, group)));
+
+        filteredGroupPairs = filteredPairs
+            .Where(u => FilterGroupUsers( u.Value, group) && FilterOnlineOrPausedSelf(u.Key))
+            .OrderByDescending(u => u.Key.IsOnline)
+            .ThenBy(u =>
+            {
+                if (string.Equals(u.Key.UserData.UID, group.OwnerUID, StringComparison.Ordinal)) return 0;
+                if (group.GroupPairUserInfos.TryGetValue(u.Key.UserData.UID, out var info))
+                {
+                    if (info.IsModerator()) return 1;
+                    if (info.IsPinned()) return 2;
+                }
+                return u.Key.IsVisible ? 3 : 4;
+            })
+            .ThenBy(u => AlphabeticalSortKey(u.Key), StringComparer.OrdinalIgnoreCase)
+            .ToDictionary(k => k.Key, k => k.Value);
+    }
+
     private string GetServerError()
     {
         return _apiController.ServerState switch