acdream/src/AcDream.Runtime/Gameplay/TurbineChatMembershipGate.cs

using AcDream.Core.Chat;
using AcDream.Core.Net.Messages;
using AcDream.Runtime.Session;

namespace AcDream.Runtime.Gameplay;

/// <summary>
/// Outcome of <see cref="TurbineChatMembershipGate.Evaluate"/>.
/// </summary>
public enum TurbineChatGateStatus
{
    /// <summary>The send may proceed to the wire.</summary>
    Allowed,

    /// <summary>
    /// Turbine chat is disabled, or this room's id is still 0 (not
    /// populated by <c>SetTurbineChatChannels</c> — e.g. no allegiance, no
    /// society). Retail: <c>"Turbine chat is not available."</c>
    /// (<see cref="ClientTextRefusals.TurbineChatUnavailable"/>), raised
    /// locally with NOTHING sent.
    /// </summary>
    Unavailable,

    /// <summary>
    /// The room exists and Turbine chat is enabled, but the player's own
    /// <c>Hear*Chat</c> option (or, for Olthoi, heritage) is off. Retail:
    /// <c>WeenieErrorWithString 0x0551 YouAreNotListeningTo_Channel</c>,
    /// raised locally with NOTHING sent.
    /// </summary>
    NotListening,
}

/// <summary>One evaluated gate decision, carrying the room/chatType/display
/// name a caller needs whether the send proceeds or gets refused.</summary>
public readonly record struct TurbineChatGateResult(
    TurbineChatGateStatus Status,
    uint RoomId,
    uint ChatType,
    string DisplayName);

/// <summary>
/// Retail's local pre-send membership gate for a Turbine-room chat channel,
/// ported from <c>ClientCommunicationSystem::SendTurbineChat @0x0057db10</c>
/// (Sept 2013 EoR build; research doc
/// <c>docs/research/2026-08-09-chat-side-channels-vs-ace.md</c> §4.2/§6.2).
///
/// <para>
/// Both the graphical (<c>LiveSessionCommandRouter</c>) and headless
/// (<c>DirectGameRuntimeCommandAdapter</c>) outbound chat paths call this
/// SAME chokepoint so the two hosts can never diverge on which channels are
/// joined and which local refusal a blocked send produces. Retail refuses
/// LOCALLY (nothing reaches the wire) in exactly two cases — Turbine chat
/// off / room id 0, or the player's own <c>Hear*Chat</c> option off — before
/// ever building a <c>TurbineChatBlob</c>.
/// </para>
/// </summary>
public static class TurbineChatMembershipGate
{
    public static TurbineChatGateResult Evaluate(
        ChatChannelKindLite kind,
        TurbineChatState turbineChat,
        RuntimeCharacterOptionsState options,
        bool isOlthoiPlayer)
    {
        ArgumentNullException.ThrowIfNull(turbineChat);
        ArgumentNullException.ThrowIfNull(options);

        // N2 (CH3 Opus review): reuse TurbineChatDisplayNames.Resolve — the
        // SAME assembly already has this room/chatType-to-display-name
        // table (LiveSessionEventRouter's inbound path uses it) rather than
        // maintaining a second copy of the same seven strings here.
        (uint room, uint chatType) = kind switch
        {
            ChatChannelKindLite.Allegiance => (
                turbineChat.AllegianceRoom,
                (uint)TurbineChat.ChatType.Allegiance),
            ChatChannelKindLite.General => (
                turbineChat.GeneralRoom,
                (uint)TurbineChat.ChatType.General),
            ChatChannelKindLite.Trade => (
                turbineChat.TradeRoom,
                (uint)TurbineChat.ChatType.Trade),
            ChatChannelKindLite.Lfg => (
                turbineChat.LfgRoom,
                (uint)TurbineChat.ChatType.Lfg),
            ChatChannelKindLite.Roleplay => (
                turbineChat.RoleplayRoom,
                (uint)TurbineChat.ChatType.Roleplay),
            ChatChannelKindLite.Society => (
                turbineChat.SocietyRoom,
                (uint)TurbineChat.ChatType.Society),
            ChatChannelKindLite.Olthoi => (
                turbineChat.OlthoiRoom,
                (uint)TurbineChat.ChatType.Olthoi),
            _ => (0u, 0u),
        };
        string name = TurbineChatDisplayNames.Resolve(room, chatType);

        if (!turbineChat.Enabled || room == 0u)
        {
            return new TurbineChatGateResult(
                TurbineChatGateStatus.Unavailable, room, chatType, name);
        }

        bool hearOption = kind switch
        {
            ChatChannelKindLite.Allegiance =>
                (options.Options1
                    & (uint)PlayerDescriptionParser.CharacterOptions1.HearAllegianceChat)
                != 0u,
            ChatChannelKindLite.General =>
                (options.Options2
                    & (uint)PlayerDescriptionParser.CharacterOptions2.HearGeneralChat)
                != 0u,
            ChatChannelKindLite.Trade =>
                (options.Options2
                    & (uint)PlayerDescriptionParser.CharacterOptions2.HearTradeChat)
                != 0u,
            ChatChannelKindLite.Lfg =>
                (options.Options2
                    & (uint)PlayerDescriptionParser.CharacterOptions2.HearLFGChat)
                != 0u,
            ChatChannelKindLite.Roleplay =>
                (options.Options2
                    & (uint)PlayerDescriptionParser.CharacterOptions2.HearRoleplayChat)
                != 0u,
            ChatChannelKindLite.Society =>
                (options.Options2
                    & (uint)PlayerDescriptionParser.CharacterOptions2.HearSocietyChat)
                != 0u,
            // Retail's Olthoi entry point passes CPlayerSystem::IsOlthoi()
            // as its hearOption argument instead of a PlayerModule flag —
            // there is no "Hear Olthoi chat" toggle, only heritage.
            ChatChannelKindLite.Olthoi => isOlthoiPlayer,
            _ => true,
        };

        return hearOption
            ? new TurbineChatGateResult(TurbineChatGateStatus.Allowed, room, chatType, name)
            : new TurbineChatGateResult(TurbineChatGateStatus.NotListening, room, chatType, name);
    }

    /// <summary>
    /// N3 (CH3 Opus review): the single shared mapping from an evaluated
    /// <see cref="TurbineChatGateResult"/> to the retail-exact local
    /// refusal text/type an <c>AddText</c> caller should raise instead of
    /// sending — collapses the identical
    /// <c>switch (gate.Status) { case Unavailable: ...; case NotListening:
    /// ...; }</c> block that used to live independently in both
    /// <c>LiveSessionCommandRouter.RouteTurbineChat</c> and
    /// <c>DirectGameRuntimeCommandAdapter.TrySendChannel</c>. Returns
    /// <c>null</c> when the gate allows the send to proceed to the wire.
    /// </summary>
    public static (string Text, RetailLogTextType Type)? ResolveRefusalText(
        TurbineChatGateResult gate)
    {
        switch (gate.Status)
        {
            case TurbineChatGateStatus.Unavailable:
                return (ClientTextRefusals.TurbineChatUnavailable, RetailLogTextType.Default);
            case TurbineChatGateStatus.NotListening:
                (string? text, RetailLogTextType type) =
                    WeenieErrorMessages.Resolve(0x0551u, gate.DisplayName);
                return text is not null ? (text, type) : null;
            default:
                return null;
        }
    }
}