392 lines
13 KiB
C#
392 lines
13 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Threading;
|
|
using Dalamud.Game.Text;
|
|
using Dalamud.Game.Text.SeStringHandling;
|
|
using HellionChat.Code;
|
|
using HellionChat.GameFunctions.Types;
|
|
using HellionChat.Resources;
|
|
using HellionChat.Util;
|
|
|
|
namespace HellionChat;
|
|
|
|
// Auto-Tell-Tabs: spawns session-only tabs per /tell partner.
|
|
// Subscribes to MessageManager.MessageProcessed and ClientState.Logout.
|
|
internal sealed class AutoTellTabsService : IDisposable
|
|
{
|
|
private readonly Plugin _plugin;
|
|
private readonly MessageManager _messageManager;
|
|
private readonly MessageStore _store;
|
|
private readonly object _tempTabsLock = new();
|
|
|
|
// F2.1: lock-free counter mirrors Config.Tabs.Count(IsTempTab) so the
|
|
// hot-path getter doesn't contend with HandleTell on every render frame.
|
|
// Bumped from inside the existing mutation paths so it stays consistent
|
|
// with the underlying list — see SpawnTempTab, DropOldestTempTab, OnLogout
|
|
// and ResyncTempTabCounter (used by Plugin.cs snapshot-restore).
|
|
// TEST-MIRROR: ../../Hellion Build test/_Helpers/TempTabCounterTests.cs
|
|
private int _activeTempTabCount;
|
|
|
|
private bool _initialized;
|
|
|
|
internal AutoTellTabsService(Plugin plugin, MessageManager messageManager, MessageStore store)
|
|
{
|
|
_plugin = plugin;
|
|
_messageManager = messageManager;
|
|
_store = store;
|
|
}
|
|
|
|
internal int ActiveTempTabCount => Volatile.Read(ref _activeTempTabCount);
|
|
|
|
internal void Initialize()
|
|
{
|
|
if (_initialized)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Seed the counter from the persisted Tabs list so a config that already
|
|
// contains TempTabs from a prior session starts in sync. Plugin.cs:168
|
|
// crash-recovery has already dropped TempTabs by the time we get here,
|
|
// so the snapshot reflects post-recovery reality.
|
|
Interlocked.Exchange(ref _activeTempTabCount, Plugin.Config.Tabs.Count(t => t.IsTempTab));
|
|
|
|
_messageManager.MessageProcessed += HandleTell;
|
|
Plugin.ClientState.Logout += OnLogout;
|
|
_initialized = true;
|
|
}
|
|
|
|
// F2.1: callable from outside paths that mutate Config.Tabs directly
|
|
// (Plugin.cs snapshot-restore). Atomically re-pegs the counter to the
|
|
// live IsTempTab count.
|
|
internal void ResyncTempTabCounter()
|
|
{
|
|
Interlocked.Exchange(ref _activeTempTabCount, Plugin.Config.Tabs.Count(t => t.IsTempTab));
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
if (!_initialized)
|
|
{
|
|
return;
|
|
}
|
|
|
|
Plugin.ClientState.Logout -= OnLogout;
|
|
_messageManager.MessageProcessed -= HandleTell;
|
|
_initialized = false;
|
|
}
|
|
|
|
internal void HandleTell(Message message)
|
|
{
|
|
if (!Plugin.Config.EnableAutoTellTabs)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (
|
|
message.Code.Type != ChatType.TellIncoming
|
|
&& message.Code.Type != ChatType.TellOutgoing
|
|
)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var partner = ExtractTellPartner(message);
|
|
if (partner == null)
|
|
{
|
|
// Diagnostics: helps detect regressions (FFXIV payload changes, new edge cases)
|
|
Plugin.Log.Warning(
|
|
$"[AutoTellTabs] Could not extract tell partner. type={message.Code.Type}, "
|
|
+ $"senderChunks={message.Sender.Count}, contentChunks={message.Content.Count}, "
|
|
+ $"senderSourcePayloads={message.SenderSource?.Payloads?.Count ?? 0}, "
|
|
+ $"contentSourcePayloads={message.ContentSource?.Payloads?.Count ?? 0}"
|
|
);
|
|
return;
|
|
}
|
|
|
|
lock (_tempTabsLock)
|
|
{
|
|
var existing = FindTempTab(partner.Value.Name, partner.Value.World);
|
|
if (existing != null)
|
|
{
|
|
// Already routed via MessageManager pipeline
|
|
return;
|
|
}
|
|
|
|
if (ActiveTempTabCount >= Plugin.Config.AutoTellTabsLimit)
|
|
{
|
|
DropOldestTempTab();
|
|
}
|
|
|
|
SpawnTempTab(partner.Value, message);
|
|
}
|
|
}
|
|
|
|
private (string Name, uint World)? ExtractTellPartner(Message message)
|
|
{
|
|
if (message.Code.Type == ChatType.TellIncoming)
|
|
{
|
|
// Sender is the partner; check chunks first, then raw SeString as fallback
|
|
var fromSender =
|
|
ChunkUtil.TryGetPlayerPayload(message.Sender)
|
|
?? ChunkUtil.TryGetPlayerPayload(message.SenderSource);
|
|
if (fromSender != null)
|
|
{
|
|
return (fromSender.PlayerName, fromSender.World.RowId);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// Outgoing tell: check content first, then channels's TellTarget as fallback
|
|
var fromContent =
|
|
ChunkUtil.TryGetPlayerPayload(message.Content)
|
|
?? ChunkUtil.TryGetPlayerPayload(message.ContentSource)
|
|
?? ChunkUtil.TryGetPlayerPayload(message.Sender)
|
|
?? ChunkUtil.TryGetPlayerPayload(message.SenderSource);
|
|
if (fromContent != null)
|
|
{
|
|
return (fromContent.PlayerName, fromContent.World.RowId);
|
|
}
|
|
|
|
var current =
|
|
_plugin.CurrentTab.CurrentChannel.TellTarget
|
|
?? _plugin.CurrentTab.CurrentChannel.TempTellTarget;
|
|
if (current != null && current.IsSet())
|
|
{
|
|
return (current.Name, current.World);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private Tab? FindTempTab(string name, uint world)
|
|
{
|
|
return Plugin.Config.Tabs.FirstOrDefault(t =>
|
|
t.IsTempTab
|
|
&& t.TellTarget != null
|
|
&& string.Equals(t.TellTarget.Name, name, StringComparison.OrdinalIgnoreCase)
|
|
&& t.TellTarget.World == world
|
|
);
|
|
}
|
|
|
|
private void DropOldestTempTab()
|
|
{
|
|
// Prioritize greeted tabs for drop; within each bucket, drop by oldest LastActivity
|
|
var victim = Plugin
|
|
.Config.Tabs.Select((tab, idx) => (Tab: tab, Index: idx))
|
|
.Where(t => t.Tab.IsTempTab)
|
|
.OrderByDescending(t => t.Tab.IsGreeted)
|
|
.ThenBy(t => t.Tab.LastActivity)
|
|
.FirstOrDefault();
|
|
|
|
if (victim.Tab == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Clean up pop-out window if tab is popped out
|
|
if (victim.Tab.PopOut)
|
|
{
|
|
var popout = _plugin.ChatLogWindow.ActivePopouts.FirstOrDefault(p =>
|
|
p.TabIdentifier == victim.Tab.Identifier
|
|
);
|
|
if (popout != null)
|
|
{
|
|
popout.IsOpen = false;
|
|
}
|
|
}
|
|
|
|
Plugin.Config.Tabs.RemoveAt(victim.Index);
|
|
Interlocked.Decrement(ref _activeTempTabCount);
|
|
|
|
// Re-anchor active tab to avoid silent switch when tab is dropped
|
|
if (victim.Index <= _plugin.LastTab)
|
|
{
|
|
_plugin.WantedTab = 0;
|
|
}
|
|
}
|
|
|
|
private void SpawnTempTab((string Name, uint World) partner, Message currentMessage)
|
|
{
|
|
var tab = BuildTempTab(partner.Name, partner.World);
|
|
|
|
// Preload history: chronological order with current message already persisted
|
|
PreloadHistory(tab, partner.Name, partner.World, currentMessage.Id);
|
|
|
|
tab.AddMessage(currentMessage, unread: true);
|
|
|
|
// Open as pop-out if configured (set before Tabs.Add for next render-tick)
|
|
if (Plugin.Config.AutoTellTabsOpenAsPopout)
|
|
{
|
|
tab.PopOut = true;
|
|
}
|
|
|
|
Plugin.Config.Tabs.Add(tab);
|
|
Interlocked.Increment(ref _activeTempTabCount);
|
|
}
|
|
|
|
private static Tab BuildTempTab(string playerName, uint worldRowId)
|
|
{
|
|
return new Tab
|
|
{
|
|
Name = FormatTabName(playerName, worldRowId),
|
|
IsTempTab = true,
|
|
AllSenderMessages = true,
|
|
TellTarget = new TellTarget(playerName, worldRowId, 0, TellReason.Direct),
|
|
Channel = InputChannel.Tell,
|
|
DisplayTimestamp = true,
|
|
UnreadMode = UnreadMode.Unseen,
|
|
HideWhenInactive = false,
|
|
SelectedChannels = new Dictionary<ChatType, (ChatSource, ChatSource)>
|
|
{
|
|
[ChatType.TellIncoming] = (ChatSourceExt.All, ChatSourceExt.All),
|
|
[ChatType.TellOutgoing] = (ChatSourceExt.All, ChatSourceExt.All),
|
|
},
|
|
};
|
|
}
|
|
|
|
private static string FormatTabName(string playerName, uint worldRowId)
|
|
{
|
|
if (Sheets.WorldSheet.TryGetRow(worldRowId, out var worldRow))
|
|
{
|
|
return $"{playerName}@{worldRow.Name}";
|
|
}
|
|
// Fallback if world lookup misses (rare; only for unseen worlds)
|
|
return $"{playerName}@World{worldRowId}";
|
|
}
|
|
|
|
private void PreloadHistory(Tab tab, string senderName, uint senderWorld, Guid currentMessageId)
|
|
{
|
|
var preloadCount = Plugin.Config.AutoTellTabsHistoryPreload;
|
|
if (preloadCount <= 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
// Pull one extra row: current message is already in store and would eat a preload slot
|
|
var history = _store.GetTellHistoryWithSender(
|
|
_messageManager.CurrentContentId,
|
|
senderName,
|
|
senderWorld,
|
|
preloadCount + 1
|
|
);
|
|
|
|
var historicMessages = history
|
|
.Where(m => m.Id != currentMessageId)
|
|
.Take(preloadCount)
|
|
.ToList();
|
|
|
|
if (historicMessages.Count == 0)
|
|
{
|
|
// No prior tells; leave tab empty to avoid orphaned "history loaded" marker
|
|
return;
|
|
}
|
|
|
|
// History is oldest-first; add in order for chronological display
|
|
foreach (var message in historicMessages)
|
|
{
|
|
tab.Messages.AddPrune(message, MessageManager.MessageDisplayLimit);
|
|
}
|
|
|
|
// Separator between history and live tell (sorts after history but before current)
|
|
tab.Messages.AddPrune(
|
|
MakeSystemMarker(HellionStrings.AutoTellTabs_HistorySeparator),
|
|
MessageManager.MessageDisplayLimit
|
|
);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// Non-fatal: tab still spawns with visible error notice instead of silent history loss
|
|
Plugin.Log.Error(ex, "[AutoTellTabs] History preload failed");
|
|
tab.Messages.AddPrune(
|
|
MakeSystemMarker(HellionStrings.AutoTellTabs_HistoryLoadError),
|
|
MessageManager.MessageDisplayLimit
|
|
);
|
|
}
|
|
}
|
|
|
|
private static Message MakeSystemMarker(string text)
|
|
{
|
|
var seString = new SeStringBuilder().AddText(text).Build();
|
|
var chunks = ChunkUtil.ToChunks(seString, ChunkSource.Content, ChatType.System).ToList();
|
|
var code = new ChatCode((XivChatType)ChatType.System, 0, 0);
|
|
return Message.FakeMessage(chunks, code);
|
|
}
|
|
|
|
internal void MarkGreeted(Tab tab)
|
|
{
|
|
SetGreeted(tab, true);
|
|
}
|
|
|
|
internal void UnmarkGreeted(Tab tab)
|
|
{
|
|
SetGreeted(tab, false);
|
|
}
|
|
|
|
internal bool IsGreeted(Tab tab)
|
|
{
|
|
return tab.IsGreeted;
|
|
}
|
|
|
|
private void SetGreeted(Tab tab, bool greeted)
|
|
{
|
|
if (tab == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
lock (_tempTabsLock)
|
|
{
|
|
// Guard against frame-race: sidebar might render a tab already removed by LRU or logout
|
|
if (!Plugin.Config.Tabs.Contains(tab))
|
|
{
|
|
return;
|
|
}
|
|
|
|
tab.IsGreeted = greeted;
|
|
}
|
|
}
|
|
|
|
private void OnLogout(int type, int code)
|
|
{
|
|
lock (_tempTabsLock)
|
|
{
|
|
// Snapshot active tab index before mutating list
|
|
var lastIndex = _plugin.LastTab;
|
|
var lastIndexValid = lastIndex >= 0 && lastIndex < Plugin.Config.Tabs.Count;
|
|
var currentWasTempTab = lastIndexValid && Plugin.Config.Tabs[lastIndex].IsTempTab;
|
|
|
|
// Clean up pop-out windows before removing temp tabs
|
|
var poppedTempTabIds = Plugin
|
|
.Config.Tabs.Where(t => t.IsTempTab && t.PopOut)
|
|
.Select(t => t.Identifier)
|
|
.ToList();
|
|
if (poppedTempTabIds.Count > 0)
|
|
{
|
|
var poppedSet = poppedTempTabIds.ToHashSet();
|
|
foreach (
|
|
var popout in _plugin
|
|
.ChatLogWindow.ActivePopouts.Where(p => poppedSet.Contains(p.TabIdentifier))
|
|
.ToList()
|
|
)
|
|
{
|
|
popout.IsOpen = false;
|
|
}
|
|
}
|
|
|
|
var removed = Plugin.Config.Tabs.RemoveAll(t => t.IsTempTab);
|
|
Interlocked.Add(ref _activeTempTabCount, -removed);
|
|
|
|
// Force switch to tab 0 if active tab was temp or index is now out of range
|
|
var stillValid = lastIndex >= 0 && lastIndex < Plugin.Config.Tabs.Count;
|
|
if (currentWasTempTab || !stillValid)
|
|
{
|
|
_plugin.WantedTab = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|