HellionChat/HellionChat/Services/TellRouterService.cs

using HellionChat.Code;
using HellionChat.Util;
using Microsoft.Extensions.Logging;

namespace HellionChat.Services;

// Routes an incoming tell to the configured TellAutoOpenMode (Off/main window/
// Popout). Deliberately decoupled from AutoTellTabsService: that service owns
// tab CREATION + lifecycle; this is the SINGLE place that decides where a tell
// becomes visible. Until v2.0.5 that service opened pop-outs too, off its own
// AutoTellTabsOpenAsPopout flag, and won every race by firing at tab creation --
// so this mode looked inert and the mid-sentence guard here could be walked
// past. Popout still guards on pool.IsOpen for the already-open case.
// Subscribes to the resolved
// MessageManager.MessageProcessed stream (a resolved Message), not the raw
// IChatGui event, and defers the reveal one tick so the tab exists regardless of
// subscriber order. Wired by TellRouterServiceInitHostedService.
internal sealed class TellRouterService : IDisposable
{
    private readonly MessageManager _messageManager;
    private readonly ILogger<TellRouterService> _logger;
    private bool _initialized;

    public TellRouterService(MessageManager messageManager, ILogger<TellRouterService> logger)
    {
        _messageManager = messageManager;
        _logger = logger;
    }

    public void Initialize()
    {
        if (_initialized)
            return;

        _messageManager.MessageProcessed += OnMessageProcessed;
        _initialized = true;
        _logger.LogDebug("TellRouterService online; routing incoming tells by TellAutoOpenMode.");
    }

    public void Dispose()
    {
        if (!_initialized)
            return;

        _messageManager.MessageProcessed -= OnMessageProcessed;
        _initialized = false;
    }

    private void OnMessageProcessed(Message message)
    {
        var mode = Plugin.Config.TellAutoOpenMode;
        if (mode == TellAutoOpenMode.Off)
            return;

        if (message.Code.Type != ChatType.TellIncoming)
            return;

        // Partner = sender for an incoming tell. Same payload idiom AutoTellTabs uses
        // (AutoTellTabsService.ExtractTellPartner), so the lookup never diverges.
        var partner =
            ChunkUtil.TryGetPlayerPayload(message.Sender)
            ?? ChunkUtil.TryGetPlayerPayload(message.SenderSource);
        if (partner == null)
            return;

        var name = partner.PlayerName;
        var world = partner.World.RowId;

        // Defer the reveal to the next framework tick. AutoTellTabsService also
        // handles this MessageProcessed (synchronously); by the next tick the tab
        // exists regardless of subscription order, and the reveal (ActivateTab / pool
        // mutation) is serialized with Draw (reference_dalamud_framework_thread).
        Plugin.Framework.RunOnFrameworkThread(() =>
        {
            // Lock-safe lookup: AutoTellTabs mutates Config.Tabs under its lock on the
            // worker thread, so we read through its guarded accessor, not the static.
            var tab = Plugin.Instance.AutoTellTabsService?.FindTempTabSafe(name, world);
            if (tab == null)
                return; // nothing to reveal (auto-tell-tabs off -> no tab created)

            // Switching to the tab on every tell is user-gated
            // (TellAutoOpenSwitchAlways, default on); when off the tab still
            // appears with its unread badge but the active tab is left alone. A
            // tab that is already popped out needs no reveal at all -- it is on
            // screen, and pulling the main window onto it costs the user the tab
            // they were reading.
            var reveal = TabLifecycleHelpers.PlanTellReveal(
                mode,
                Plugin.Config.TellAutoOpenSwitchAlways,
                Plugin.Instance.ChannelPopoutPool.IsOpen(tab.Identifier),
                Util.ChatInputBusy.Any()
            );

            switch (reveal)
            {
                case TabLifecycleHelpers.TellReveal.MainWindow:
                    // Deliberately does NOT touch MainWindowLayoutMode. It used to
                    // force the layout to match this mode and SAVE it, so a single
                    // incoming tell permanently undid the tab placement the user
                    // had chosen under Window -> Layout (Flo, 23.08.2026).
                    Plugin.Instance.MainWindow?.ActivateTab(tab);
                    break;

                case TabLifecycleHelpers.TellReveal.Popout:
                    Plugin.Instance.ChannelPopoutPool.TryOpen(tab);
                    break;
            }
        });
    }
}