using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Pipes;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security.AccessControl;
using System.Security.Cryptography;
using System.Security.Principal;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using BlueSage.QoLTweaks.Contracts;
using BlueSage.QoLTweaks.Core;
using BlueSage.QoLTweaks.Data;
using BlueSage.QoLTweaks.Patches;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using PurrNet;
using PurrNet.Modules;
using PurrNet.Packing;
using Steamworks;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.Profiling;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.6", FrameworkDisplayName = ".NET Framework 4.6")]
[assembly: AssemblyCompany("BlueSage_QoL_Tweaks_Beta")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.2.4.0")]
[assembly: AssemblyInformationalVersion("0.2.4+3726c5820cf95325339f9836749fe3c035da0d13")]
[assembly: AssemblyProduct("BlueSage_QoL_Tweaks_Beta")]
[assembly: AssemblyTitle("BlueSage_QoL_Tweaks_Beta")]
[assembly: AssemblyVersion("0.2.4.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace BlueSage.QoLTweaks
{
	public static class BlueSageExtensionRegistry
	{
		private sealed class ChainloaderExtensionCatalog : IBlueSageLoadedExtensionCatalogV1
		{
			public bool TryGetLoaded(string pluginGuid, out BlueSageLoadedExtensionV1 extension)
			{
				extension = default(BlueSageLoadedExtensionV1);
				if (!string.IsNullOrWhiteSpace(pluginGuid) && Chainloader.PluginInfos.TryGetValue(pluginGuid, out var value) && !((Object)(object)((value != null) ? value.Instance : null) == (Object)null))
				{
					BepInPlugin metadata = value.Metadata;
					if (!(((metadata != null) ? metadata.Version : null) == null))
					{
						Assembly assembly = ((object)value.Instance).GetType().Assembly;
						extension = new BlueSageLoadedExtensionV1(assembly, value.Metadata.Version, loaded: true);
						return true;
					}
				}
				return false;
			}
		}

		private sealed class DynamicDiagnosticsProvider : IBlueSageDiagnosticsProviderV1, IBlueSageDiagnosticsControlV2
		{
			private const int PayloadLength = 5;

			private readonly Func<long, long[]> _provider;

			private readonly Func<bool, bool> _overlayVisibilitySetter;

			internal DynamicDiagnosticsProvider(Func<long, long[]> provider, Func<bool, bool> overlayVisibilitySetter = null)
			{
				_provider = provider ?? throw new ArgumentNullException("provider");
				_overlayVisibilitySetter = overlayVisibilitySetter;
			}

			public BlueSageDiagnosticsSnapshotV1 GetSnapshot(long nowUtcTicks)
			{
				long[] array = _provider(nowUtcTicks);
				if (array == null || array.Length != 5 || array[0] < 0 || array[0] > 2 || array[1] < 0 || array[1] > 2 || array[2] < 100 || array[2] > 5000)
				{
					throw new InvalidOperationException("Diagnostics payload failed the public ABI bounds.");
				}
				return new BlueSageDiagnosticsSnapshotV1((BlueSageDiagnosticsOverlayStateV1)array[0], (BlueSageDiagnosticsFreshnessV1)array[1], (int)array[2], array[3], array[4]);
			}

			public bool TrySetOverlayVisible(bool visible)
			{
				if (_overlayVisibilitySetter != null)
				{
					return _overlayVisibilitySetter(visible);
				}
				return false;
			}
		}

		private static readonly object Sync = new object();

		private static readonly BlueSageExtensionRegistryCore Core = new BlueSageExtensionRegistryCore(new ChainloaderExtensionCatalog());

		public static BlueSageExtensionRegistrationTokenV1 RegisterBadgeContributionV1(IBlueSageBadgeContributionV1 provider, string ownerGuid, Version ownerVersion, int abiVersion)
		{
			lock (Sync)
			{
				return Core.RegisterBadgeContribution(provider, ownerGuid, ownerVersion, abiVersion);
			}
		}

		public static bool UnregisterBadgeContributionV1(BlueSageExtensionRegistrationTokenV1 token)
		{
			lock (Sync)
			{
				return Core.UnregisterBadgeContribution(token);
			}
		}

		public static BlueSageExtensionRegistrationTokenV1 RegisterDiagnosticsProviderV1(IBlueSageDiagnosticsProviderV1 provider, string ownerGuid, Version ownerVersion, int abiVersion)
		{
			lock (Sync)
			{
				return Core.RegisterDiagnostics(provider, ownerGuid, ownerVersion, abiVersion);
			}
		}

		public static bool UnregisterDiagnosticsProviderV1(BlueSageExtensionRegistrationTokenV1 token)
		{
			lock (Sync)
			{
				return Core.UnregisterDiagnostics(token);
			}
		}

		public static BlueSageExtensionRegistrationTokenV1 RegisterHostCapabilityProviderV1(IBlueSageHostCapabilityProviderV1 provider, string ownerGuid, Version ownerVersion, int abiVersion)
		{
			lock (Sync)
			{
				return Core.RegisterHostCapability(provider, ownerGuid, ownerVersion, abiVersion);
			}
		}

		public static bool UnregisterHostCapabilityProviderV1(BlueSageExtensionRegistrationTokenV1 token)
		{
			lock (Sync)
			{
				return Core.UnregisterHostCapability(token);
			}
		}

		public static long RegisterDiagnosticsProviderDynamicV1(Func<long, long[]> provider, string ownerGuid, Version ownerVersion, int abiVersion)
		{
			if (provider == null || provider.Target != null || !provider.Method.IsStatic || provider.Method.DeclaringType == null)
			{
				return 0L;
			}
			Assembly assembly = provider.Method.DeclaringType.Assembly;
			lock (Sync)
			{
				return Core.RegisterDiagnostics(new DynamicDiagnosticsProvider(provider), ownerGuid, ownerVersion, abiVersion, assembly).Generation;
			}
		}

		public static bool UnregisterDiagnosticsProviderDynamicV1(long generation)
		{
			lock (Sync)
			{
				return Core.UnregisterDiagnostics(new BlueSageExtensionRegistrationTokenV1(generation));
			}
		}

		public static long RegisterDiagnosticsProviderDynamicV2(Func<long, long[]> provider, Func<bool, bool> overlayVisibilitySetter, string ownerGuid, Version ownerVersion, int abiVersion)
		{
			if (provider == null || overlayVisibilitySetter == null || provider.Target != null || overlayVisibilitySetter.Target != null || !provider.Method.IsStatic || !overlayVisibilitySetter.Method.IsStatic || provider.Method.DeclaringType == null || overlayVisibilitySetter.Method.DeclaringType == null || provider.Method.DeclaringType.Assembly != overlayVisibilitySetter.Method.DeclaringType.Assembly)
			{
				return 0L;
			}
			Assembly assembly = provider.Method.DeclaringType.Assembly;
			lock (Sync)
			{
				return Core.RegisterDiagnostics(new DynamicDiagnosticsProvider(provider, overlayVisibilitySetter), ownerGuid, ownerVersion, abiVersion, assembly).Generation;
			}
		}

		internal static void BeginLobby(long lobbyEpoch, long evidenceGeneration)
		{
			lock (Sync)
			{
				Core.SetEvidenceContext(lobbyEpoch, evidenceGeneration);
			}
		}

		internal static void BeginBadgePresentation(long lobbyEpoch, long evidenceGeneration)
		{
			lock (Sync)
			{
				Core.SetBadgeEvidenceContext(lobbyEpoch, evidenceGeneration);
			}
		}

		internal static bool TryReadBadgeContribution(BlueSageBadgeContributionRequestV1 request, long nowUtcTicks, out BlueSageBadgeContributionResponseV1 response)
		{
			lock (Sync)
			{
				return Core.TryReadBadgeContribution(request, nowUtcTicks, out response);
			}
		}

		internal static bool TryReadDiagnostics(long nowUtcTicks, out BlueSageDiagnosticsSnapshotV1 snapshot)
		{
			lock (Sync)
			{
				return Core.TryReadDiagnostics(nowUtcTicks, out snapshot);
			}
		}

		internal static bool TrySetDiagnosticsOverlayVisible(bool visible)
		{
			lock (Sync)
			{
				return Core.TrySetDiagnosticsOverlayVisible(visible);
			}
		}

		internal static bool TryReadHostCapability(bool isHost, long nonce, long nowUtcTicks, out BlueSageHostCapabilitySnapshotV1 snapshot)
		{
			lock (Sync)
			{
				snapshot = default(BlueSageHostCapabilitySnapshotV1);
				BlueSageHostCapabilityRequestV1 request;
				return Core.TryCreateHostCapabilityRequest(isHost, nonce, nowUtcTicks, out request) && Core.TryReadHostCapability(request, nowUtcTicks, out snapshot);
			}
		}

		internal static bool TryExecuteHostCapability(BlueSageHostCapabilityActionV1 action, bool isHost, long nonce, long nowUtcTicks, out BlueSageHostCapabilityReceiptV1 receipt)
		{
			lock (Sync)
			{
				receipt = default(BlueSageHostCapabilityReceiptV1);
				BlueSageHostCapabilityRequestV1 request;
				return Core.TryCreateHostCapabilityRequest(isHost, nonce, nowUtcTicks, out request) && Core.TryExecuteHostCapability(action, request, nowUtcTicks, out receipt);
			}
		}

		internal static bool HasLiveHostCapabilityProvider()
		{
			lock (Sync)
			{
				return Core.HasLiveHostCapabilityProvider();
			}
		}

		internal static void ClearLobbyState()
		{
			lock (Sync)
			{
				Core.SetEvidenceContext(0L, 0L);
				Core.SetBadgeEvidenceContext(0L, 0L);
			}
		}

		internal static void ClearAll()
		{
			lock (Sync)
			{
				Core.Clear();
			}
		}
	}
	internal static class BlueSageHelpFrame
	{
		internal static HelpFrameLayout Resolve(BlueSageHelpFrameKind kind, Rect window)
		{
			return HelpFramePolicy.Resolve(kind, ((Rect)(ref window)).width, ((Rect)(ref window)).height);
		}

		internal static void BeginFooter(GUIStyle footerStyle, HelpFrameLayout layout)
		{
			GUILayout.BeginVertical(footerStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Height(layout.FooterHeight),
				GUILayout.MaxHeight(layout.FooterHeight)
			});
		}

		internal static void DrawStateAndHelp(GUIStyle textStyle, HelpFrameLayout layout, string stateLine, string helpLine)
		{
			GUILayout.Label(stateLine ?? string.Empty, textStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Height(layout.StateLineHeight),
				GUILayout.MaxHeight(layout.StateLineHeight)
			});
			GUILayout.Label(helpLine ?? string.Empty, textStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Height(layout.HelpLineHeight),
				GUILayout.MaxHeight(layout.HelpLineHeight)
			});
		}

		internal static void EndFooter()
		{
			GUILayout.EndVertical();
		}
	}
	internal sealed class BlueSageUiThemePalette
	{
		public string Key { get; }

		public string DisplayName { get; }

		public Color Window { get; }

		public Color Panel { get; }

		public Color Header { get; }

		public Color HeaderText { get; }

		public Color LabelText { get; }

		public Color SmallText { get; }

		public Color ButtonText { get; }

		public Color ActiveButtonText { get; }

		public Color FieldText { get; }

		public Color PreviewBackground { get; }

		public bool IsMidnightDock => string.Equals(Key, "Midnight Dock", StringComparison.OrdinalIgnoreCase);

		public bool UsesWarmContent
		{
			get
			{
				if (!string.Equals(Key, "BlueSage Harbor", StringComparison.OrdinalIgnoreCase) && !string.Equals(Key, "Vanilla Cream OT", StringComparison.OrdinalIgnoreCase))
				{
					return string.Equals(Key, "OG", StringComparison.OrdinalIgnoreCase);
				}
				return true;
			}
		}

		public Color SectionPanel
		{
			get
			{
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!string.Equals(Key, "BlueSage Harbor", StringComparison.OrdinalIgnoreCase))
				{
					return Color.Lerp(Panel, Window, 0.16f);
				}
				return new Color(0.975f, 0.945f, 0.885f, 1f);
			}
		}

		public Color SectionBorder
		{
			get
			{
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				if (!string.Equals(Key, "BlueSage Harbor", StringComparison.OrdinalIgnoreCase))
				{
					if (!string.Equals(Key, "Vanilla Cream OT", StringComparison.OrdinalIgnoreCase))
					{
						return Color.Lerp(Header, LabelText, 0.3f);
					}
					return Color.Lerp(Header, FieldText, 0.4f);
				}
				return new Color(0.65f, 0.52f, 0.39f, 1f);
			}
		}

		public Color FieldBackground
		{
			get
			{
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				if (!IsMidnightDock)
				{
					return Color.Lerp(SectionPanel, Color.white, UsesWarmContent ? 0.44f : 0.1f);
				}
				return new Color(0.045f, 0.065f, 0.105f, 1f);
			}
		}

		public Color FieldHoverBackground
		{
			get
			{
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				if (!IsMidnightDock)
				{
					return Color.Lerp(FieldBackground, Header, 0.1f);
				}
				return new Color(0.075f, 0.115f, 0.165f, 1f);
			}
		}

		public Color FieldFocusedBackground
		{
			get
			{
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				if (!IsMidnightDock)
				{
					return Color.Lerp(FieldBackground, Color.white, 0.16f);
				}
				return new Color(0.055f, 0.135f, 0.165f, 1f);
			}
		}

		public Color FieldBorder
		{
			get
			{
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				if (!IsMidnightDock)
				{
					return SectionBorder;
				}
				return new Color(0.28f, 0.42f, 0.56f, 1f);
			}
		}

		public Color FieldFocusedBorder
		{
			get
			{
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				if (!IsMidnightDock)
				{
					return Color.Lerp(ActiveAccent, DarkStateText, 0.18f);
				}
				return new Color(0.24f, 0.72f, 0.78f, 1f);
			}
		}

		public Color ActiveAccent
		{
			get
			{
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				if (!string.Equals(Key, "BlueSage Harbor", StringComparison.OrdinalIgnoreCase))
				{
					return Header;
				}
				return new Color(0.91f, 0.49f, 0.39f, 1f);
			}
		}

		public Color EnabledAccent
		{
			get
			{
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				if (!string.Equals(Key, "BlueSage Harbor", StringComparison.OrdinalIgnoreCase))
				{
					return Color.Lerp(Header, new Color(0.45f, 0.8f, 0.36f, 1f), 0.58f);
				}
				return new Color(0.39f, 0.55f, 0.24f, 1f);
			}
		}

		public string NavigationKeywordHex
		{
			get
			{
				if (!IsMidnightDock)
				{
					return "005A85";
				}
				return "70D6FF";
			}
		}

		public Color DisabledAccent
		{
			get
			{
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				if (!string.Equals(Key, "BlueSage Harbor", StringComparison.OrdinalIgnoreCase))
				{
					if (!IsMidnightDock)
					{
						return Color.Lerp(ButtonText, Window, 0.58f);
					}
					return new Color(0.26f, 0.31f, 0.39f, 1f);
				}
				return new Color(0.68f, 0.65f, 0.61f, 1f);
			}
		}

		public Color DarkStateText
		{
			get
			{
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				if (!IsMidnightDock)
				{
					if (!string.Equals(Key, "BlueSage Harbor", StringComparison.OrdinalIgnoreCase))
					{
						return FieldText;
					}
					return Header;
				}
				return Window;
			}
		}

		public Color ActiveStateText
		{
			get
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				if (!IsMidnightDock)
				{
					return DarkStateText;
				}
				return ActiveButtonText;
			}
		}

		public Color EnabledButtonText => DarkStateText;

		public Color DisabledButtonText
		{
			get
			{
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				if (!IsMidnightDock)
				{
					return DarkStateText;
				}
				return new Color(0.84f, 0.89f, 0.94f, 1f);
			}
		}

		public Color ExperimentalButtonText => DarkStateText;

		public Color NeutralButtonAccent
		{
			get
			{
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				if (!IsMidnightDock)
				{
					return Color.Lerp(Panel, ButtonText, 0.3f);
				}
				return Color.Lerp(Panel, Color.white, 0.12f);
			}
		}

		public Color NeutralButtonText
		{
			get
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				if (!IsMidnightDock)
				{
					return DarkStateText;
				}
				return ButtonText;
			}
		}

		public Color PreviewText
		{
			get
			{
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				if (!string.Equals(Key, "OG", StringComparison.OrdinalIgnoreCase) && !string.Equals(Key, "Vanilla Cream OT", StringComparison.OrdinalIgnoreCase))
				{
					return LabelText;
				}
				return Color.white;
			}
		}

		public Color PopupHeaderText
		{
			get
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				if (!IsMidnightDock)
				{
					return DarkStateText;
				}
				return ActiveButtonText;
			}
		}

		public Color PopupBodyText
		{
			get
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				if (!IsMidnightDock)
				{
					return DarkStateText;
				}
				return LabelText;
			}
		}

		public Color PopupHintText
		{
			get
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				if (!IsMidnightDock)
				{
					return DarkStateText;
				}
				return Color.Lerp(SmallText, LabelText, 0.35f);
			}
		}

		public Color ComfortAccent
		{
			get
			{
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				if (!IsMidnightDock)
				{
					return new Color(0.39f, 0.55f, 0.24f, 1f);
				}
				return new Color(0.42f, 0.76f, 0.49f, 1f);
			}
		}

		public Color ChatAccent
		{
			get
			{
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				if (!IsMidnightDock)
				{
					return new Color(0.1f, 0.56f, 0.62f, 1f);
				}
				return new Color(0.32f, 0.72f, 0.82f, 1f);
			}
		}

		public Color IdentityAccent
		{
			get
			{
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				if (!IsMidnightDock)
				{
					return new Color(0.47f, 0.4f, 0.68f, 1f);
				}
				return new Color(0.55f, 0.63f, 0.91f, 1f);
			}
		}

		public Color PersonalizationAccent
		{
			get
			{
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				if (!IsMidnightDock)
				{
					return new Color(0.72f, 0.39f, 0.5f, 1f);
				}
				return new Color(0.82f, 0.55f, 0.73f, 1f);
			}
		}

		public Color ExperimentalAccent => new Color(1f, 0.42f, 0.08f, 1f);

		public Color ExperimentalBorder
		{
			get
			{
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				if (!IsMidnightDock)
				{
					return Color.Lerp(ExperimentalAccent, DarkStateText, 0.35f);
				}
				return ExperimentalAccent;
			}
		}

		public Color FooterBackground
		{
			get
			{
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				if (!string.Equals(Key, "BlueSage Harbor", StringComparison.OrdinalIgnoreCase))
				{
					return Color.Lerp(Header, Window, 0.3f);
				}
				return new Color(0.055f, 0.075f, 0.115f, 1f);
			}
		}

		public Color FooterText
		{
			get
			{
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				if (!string.Equals(Key, "BlueSage Harbor", StringComparison.OrdinalIgnoreCase))
				{
					return HeaderText;
				}
				return new Color(0.84f, 0.93f, 0.98f, 1f);
			}
		}

		public Color FooterBorder
		{
			get
			{
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				if (!IsMidnightDock)
				{
					if (!string.Equals(Key, "BlueSage Harbor", StringComparison.OrdinalIgnoreCase))
					{
						return DarkStateText;
					}
					return SectionBorder;
				}
				return FieldFocusedBorder;
			}
		}

		public BlueSageUiThemePalette(string key, string displayName, Color window, Color panel, Color header, Color headerText, Color labelText, Color smallText, Color buttonText, Color activeButtonText, Color fieldText, Color previewBackground)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			Key = key;
			DisplayName = displayName;
			Window = window;
			Panel = panel;
			Header = header;
			HeaderText = headerText;
			LabelText = labelText;
			SmallText = smallText;
			ButtonText = buttonText;
			ActiveButtonText = activeButtonText;
			FieldText = fieldText;
			PreviewBackground = previewBackground;
		}
	}
	internal static class BlueSageUiTheme
	{
		public const string DefaultThemeKey = "BlueSage Harbor";

		private static readonly Dictionary<string, Texture2D> SolidTextures = new Dictionary<string, Texture2D>(StringComparer.Ordinal);

		private static readonly Dictionary<string, Texture2D> PanelTextures = new Dictionary<string, Texture2D>(StringComparer.Ordinal);

		private static readonly BlueSageUiThemePalette[] Palettes = new BlueSageUiThemePalette[4]
		{
			new BlueSageUiThemePalette("BlueSage Harbor", "BlueSage Harbor", new Color(0.93f, 0.875f, 0.79f, 0.995f), new Color(0.985f, 0.95f, 0.88f, 0.995f), new Color(0.055f, 0.075f, 0.115f, 1f), new Color(0.84f, 0.95f, 0.98f, 1f), new Color(0.2f, 0.16f, 0.15f, 1f), new Color(0.35f, 0.29f, 0.27f, 1f), new Color(0.22f, 0.18f, 0.17f, 1f), new Color(1f, 0.96f, 0.88f, 1f), new Color(0.12f, 0.1f, 0.1f, 1f), new Color(0.985f, 0.95f, 0.88f, 0.98f)),
			new BlueSageUiThemePalette("OG", "OG", new Color(0.93f, 0.9f, 0.83f, 0.99f), new Color(0.84f, 0.8f, 0.72f, 0.98f), new Color(0.55f, 0.52f, 0.47f, 1f), new Color(0.12f, 0.09f, 0.1f, 1f), new Color(0.22f, 0.14f, 0.17f, 1f), new Color(0.34f, 0.26f, 0.29f, 1f), new Color(0.24f, 0.17f, 0.2f, 1f), Color.white, new Color(0.14f, 0.11f, 0.12f, 1f), new Color(0.28f, 0.27f, 0.25f, 0.96f)),
			new BlueSageUiThemePalette("Vanilla Cream OT", "Vanilla Cream OT", new Color(0.98f, 0.93f, 0.84f, 0.99f), new Color(0.91f, 0.82f, 0.69f, 0.98f), new Color(0.91f, 0.49f, 0.42f, 1f), new Color(0.23f, 0.14f, 0.16f, 1f), new Color(0.32f, 0.22f, 0.25f, 1f), new Color(0.43f, 0.31f, 0.33f, 1f), new Color(0.31f, 0.22f, 0.25f, 1f), Color.white, new Color(0.15f, 0.11f, 0.12f, 1f), new Color(0.39f, 0.31f, 0.27f, 0.96f)),
			new BlueSageUiThemePalette("Midnight Dock", "Midnight Dock", new Color(0.08f, 0.1f, 0.16f, 0.99f), new Color(0.13f, 0.16f, 0.24f, 0.98f), new Color(0.08f, 0.36f, 0.42f, 1f), new Color(0.88f, 0.98f, 1f, 1f), new Color(0.91f, 0.96f, 1f, 1f), new Color(0.72f, 0.82f, 0.9f, 1f), new Color(0.89f, 0.94f, 1f, 1f), new Color(1f, 0.91f, 0.42f, 1f), new Color(0.96f, 0.98f, 1f, 1f), new Color(0.04f, 0.05f, 0.08f, 0.97f))
		};

		public static int RuntimeTextureGeneration { get; private set; } = 1;

		public static BlueSageUiThemePalette Current => Get(Plugin.UiThemePreset?.Value);

		public static string[] Names => Array.ConvertAll(Palettes, (BlueSageUiThemePalette palette) => palette.DisplayName);

		public static BlueSageUiThemePalette Get(string requested)
		{
			string b = Normalize(requested);
			BlueSageUiThemePalette[] palettes = Palettes;
			foreach (BlueSageUiThemePalette blueSageUiThemePalette in palettes)
			{
				if (string.Equals(blueSageUiThemePalette.Key, b, StringComparison.OrdinalIgnoreCase) || string.Equals(blueSageUiThemePalette.DisplayName, b, StringComparison.OrdinalIgnoreCase))
				{
					return blueSageUiThemePalette;
				}
			}
			return GetDefaultPalette();
		}

		public static string Normalize(string requested)
		{
			string text = (requested ?? string.Empty).Trim();
			if (text.Length == 0)
			{
				return "BlueSage Harbor";
			}
			BlueSageUiThemePalette[] palettes = Palettes;
			foreach (BlueSageUiThemePalette blueSageUiThemePalette in palettes)
			{
				if (string.Equals(blueSageUiThemePalette.Key, text, StringComparison.OrdinalIgnoreCase) || string.Equals(blueSageUiThemePalette.DisplayName, text, StringComparison.OrdinalIgnoreCase))
				{
					return blueSageUiThemePalette.Key;
				}
			}
			return "BlueSage Harbor";
		}

		public static string Next(string requested)
		{
			string b = Normalize(requested);
			for (int i = 0; i < Palettes.Length; i++)
			{
				if (string.Equals(Palettes[i].Key, b, StringComparison.OrdinalIgnoreCase))
				{
					return Palettes[(i + 1) % Palettes.Length].Key;
				}
			}
			return GetDefaultPalette().Key;
		}

		private static BlueSageUiThemePalette GetDefaultPalette()
		{
			BlueSageUiThemePalette[] palettes = Palettes;
			foreach (BlueSageUiThemePalette blueSageUiThemePalette in palettes)
			{
				if (string.Equals(blueSageUiThemePalette.Key, "BlueSage Harbor", StringComparison.OrdinalIgnoreCase))
				{
					return blueSageUiThemePalette;
				}
			}
			return Palettes[0];
		}

		public static GUIStyle CreateTextInputStyle(GUIStyle source, BlueSageUiThemePalette palette, int fontSize, bool wordWrap)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Expected O, but got Unknown
			GUIStyle val = new GUIStyle(source)
			{
				richText = false,
				fontSize = fontSize,
				wordWrap = wordWrap,
				border = new RectOffset(1, 1, 1, 1),
				padding = new RectOffset(8, 8, 5, 5)
			};
			ApplyState(val.normal, palette.FieldBackground, palette.FieldBorder, palette.FieldText);
			ApplyState(val.hover, palette.FieldHoverBackground, palette.FieldBorder, palette.FieldText);
			ApplyState(val.active, palette.FieldFocusedBackground, palette.FieldFocusedBorder, palette.FieldText);
			ApplyState(val.focused, palette.FieldFocusedBackground, palette.FieldFocusedBorder, palette.FieldText);
			ApplyState(val.onNormal, palette.FieldBackground, palette.FieldBorder, palette.FieldText);
			ApplyState(val.onHover, palette.FieldHoverBackground, palette.FieldBorder, palette.FieldText);
			ApplyState(val.onActive, palette.FieldFocusedBackground, palette.FieldFocusedBorder, palette.FieldText);
			ApplyState(val.onFocused, palette.FieldFocusedBackground, palette.FieldFocusedBorder, palette.FieldText);
			return val;
		}

		public static GUIStyle CreateStateButtonStyle(GUIStyle source, Color fill, Color border, Color text, int fontSize)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Expected O, but got Unknown
			GUIStyle val = new GUIStyle(source)
			{
				fontSize = fontSize,
				fontStyle = (FontStyle)1,
				border = new RectOffset(1, 1, 1, 1)
			};
			bool flag = RelativeLuminance(text) >= 0.5f;
			Color fill2 = Color.Lerp(fill, flag ? Color.black : Color.white, flag ? 0.08f : 0.11f);
			Color fill3 = Color.Lerp(fill, flag ? Color.black : Color.white, flag ? 0.18f : 0.2f);
			ApplyState(val.normal, fill, border, text);
			ApplyState(val.hover, fill2, Color.Lerp(border, Color.white, 0.16f), text);
			ApplyState(val.active, fill3, border, text);
			ApplyState(val.focused, fill2, Color.Lerp(border, Color.white, 0.16f), text);
			ApplyState(val.onNormal, fill, border, text);
			ApplyState(val.onHover, fill2, Color.Lerp(border, Color.white, 0.16f), text);
			ApplyState(val.onActive, fill3, border, text);
			ApplyState(val.onFocused, fill2, Color.Lerp(border, Color.white, 0.16f), text);
			return val;
		}

		public static GUIStyle CreateNeutralButtonStyle(GUIStyle source, BlueSageUiThemePalette palette, int fontSize)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			return CreateStateButtonStyle(source, palette.NeutralButtonAccent, palette.FieldBorder, palette.NeutralButtonText, fontSize);
		}

		public static GUIStyle CreateSwatchButtonStyle(GUIStyle source, int fontSize)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Expected O, but got Unknown
			GUIStyle val = new GUIStyle(source)
			{
				fontSize = fontSize,
				fontStyle = (FontStyle)1,
				border = new RectOffset(1, 1, 1, 1)
			};
			Color white = Color.white;
			Color fill = default(Color);
			((Color)(ref fill))..ctor(0.92f, 0.92f, 0.92f, 1f);
			Color fill2 = default(Color);
			((Color)(ref fill2))..ctor(0.82f, 0.82f, 0.82f, 1f);
			ApplyState(val.normal, white, Color.black, Color.white);
			ApplyState(val.hover, fill, Color.black, Color.white);
			ApplyState(val.active, fill2, Color.black, Color.white);
			ApplyState(val.focused, fill, Color.black, Color.white);
			ApplyState(val.onNormal, white, Color.black, Color.white);
			ApplyState(val.onHover, fill, Color.black, Color.white);
			ApplyState(val.onActive, fill2, Color.black, Color.white);
			ApplyState(val.onFocused, fill, Color.black, Color.white);
			return val;
		}

		public static Color BestTextColor(Color background, BlueSageUiThemePalette palette)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			Color val = palette?.DarkStateText ?? Color.black;
			if (!(ContrastRatio(val, background) >= ContrastRatio(Color.white, background)))
			{
				return Color.white;
			}
			return val;
		}

		private static float ContrastRatio(Color first, Color second)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			float val = RelativeLuminance(first);
			float val2 = RelativeLuminance(second);
			float num = Math.Max(val, val2);
			float num2 = Math.Min(val, val2);
			return (num + 0.05f) / (num2 + 0.05f);
		}

		private static float RelativeLuminance(Color color)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			return 0.2126f * Linearize(color.r) + 0.7152f * Linearize(color.g) + 0.0722f * Linearize(color.b);
		}

		private static float Linearize(float channel)
		{
			if (!(channel <= 0.03928f))
			{
				return (float)Math.Pow((channel + 0.055f) / 1.055f, 2.4000000953674316);
			}
			return channel / 12.92f;
		}

		public static Texture2D GetSolidTexture(Color color)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected O, but got Unknown
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			string text = ColorKey(color);
			if (SolidTextures.TryGetValue(text, out var value))
			{
				if ((Object)(object)value != (Object)null)
				{
					return value;
				}
				SolidTextures.Remove(text);
				RuntimeTextureGeneration++;
			}
			Texture2D val = new Texture2D(1, 1)
			{
				name = "BlueSageUi-Solid-" + text,
				hideFlags = (HideFlags)61,
				wrapMode = (TextureWrapMode)1,
				filterMode = (FilterMode)0
			};
			val.SetPixel(0, 0, color);
			val.Apply();
			SolidTextures[text] = val;
			return val;
		}

		public static Texture2D GetPanelTexture(Color fill, Color border)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Expected O, but got Unknown
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			string text = ColorKey(fill) + "-" + ColorKey(border);
			if (PanelTextures.TryGetValue(text, out var value))
			{
				if ((Object)(object)value != (Object)null)
				{
					return value;
				}
				PanelTextures.Remove(text);
				RuntimeTextureGeneration++;
			}
			Texture2D val = new Texture2D(3, 3)
			{
				name = "BlueSageUi-Panel-" + text,
				hideFlags = (HideFlags)61,
				wrapMode = (TextureWrapMode)1,
				filterMode = (FilterMode)0
			};
			for (int i = 0; i < 3; i++)
			{
				for (int j = 0; j < 3; j++)
				{
					bool flag = j == 0 || i == 0 || j == 2 || i == 2;
					val.SetPixel(j, i, flag ? border : fill);
				}
			}
			val.Apply();
			PanelTextures[text] = val;
			return val;
		}

		public static bool AreRuntimeTexturesAlive()
		{
			foreach (Texture2D value in SolidTextures.Values)
			{
				if ((Object)(object)value == (Object)null)
				{
					return false;
				}
			}
			foreach (Texture2D value2 in PanelTextures.Values)
			{
				if ((Object)(object)value2 == (Object)null)
				{
					return false;
				}
			}
			return true;
		}

		public static void ReleaseRuntimeTextures()
		{
			foreach (Texture2D value in SolidTextures.Values)
			{
				if ((Object)(object)value != (Object)null)
				{
					Object.Destroy((Object)(object)value);
				}
			}
			foreach (Texture2D value2 in PanelTextures.Values)
			{
				if ((Object)(object)value2 != (Object)null)
				{
					Object.Destroy((Object)(object)value2);
				}
			}
			SolidTextures.Clear();
			PanelTextures.Clear();
			RuntimeTextureGeneration++;
		}

		private static string ColorKey(Color color)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			Color32 val = Color32.op_Implicit(color);
			return val.r.ToString("X2") + val.g.ToString("X2") + val.b.ToString("X2") + val.a.ToString("X2");
		}

		private static void ApplyState(GUIStyleState state, Color fill, Color border, Color text)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			state.background = GetPanelTexture(fill, border);
			state.textColor = text;
		}
	}
	internal enum BlueSagePublicWindow
	{
		QolMenu,
		StyleHelper
	}
	internal static class BlueSageWindowCoordinator
	{
		private static bool _qolMenuVisible;

		private static bool _styleHelperVisible;

		internal static void SetVisible(BlueSagePublicWindow window, bool visible)
		{
			if (window == BlueSagePublicWindow.QolMenu)
			{
				_qolMenuVisible = visible;
			}
			else
			{
				_styleHelperVisible = visible;
			}
		}

		internal static WindowFitResult ResolveForOpen(BlueSagePublicWindow window, bool hasOpened, Rect current, float preferredMinWidth, float preferredMinHeight, float screenWidth, float screenHeight)
		{
			SetVisible(window, visible: true);
			return WindowFitPolicy.FitForOpen(hasOpened, ((Rect)(ref current)).x, ((Rect)(ref current)).y, ((Rect)(ref current)).width, ((Rect)(ref current)).height, preferredMinWidth, preferredMinHeight, screenWidth, screenHeight);
		}

		internal static WindowFitResult ResolveForFrame(BlueSagePublicWindow window, Rect current, float preferredMinWidth, float preferredMinHeight, float screenWidth, float screenHeight)
		{
			SetVisible(window, visible: true);
			return WindowFitPolicy.FitToScreen(((Rect)(ref current)).x, ((Rect)(ref current)).y, ((Rect)(ref current)).width, ((Rect)(ref current)).height, preferredMinWidth, preferredMinHeight, screenWidth, screenHeight, expandToMaximum: false);
		}
	}
	internal static class BlueSageWindowHoverScope
	{
		private static int _hoveredWindowId;

		private static int _hoveredPriority;

		private static int _hoveredFrame = -1;

		internal static void RegisterWindow(int windowId, Rect screenRect, int priority)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			Event current = Event.current;
			if (current != null && ((Rect)(ref screenRect)).Contains(current.mousePosition))
			{
				int frameCount = Time.frameCount;
				if (_hoveredFrame != frameCount || priority >= _hoveredPriority)
				{
					_hoveredWindowId = windowId;
					_hoveredPriority = priority;
					_hoveredFrame = frameCount;
				}
			}
		}

		internal static bool IsWindowHovered(int windowId)
		{
			if (_hoveredFrame == Time.frameCount)
			{
				return _hoveredWindowId == windowId;
			}
			return false;
		}

		internal static void UnregisterWindow(int windowId)
		{
			if (_hoveredFrame == Time.frameCount && _hoveredWindowId == windowId)
			{
				_hoveredWindowId = 0;
				_hoveredPriority = 0;
				_hoveredFrame = -1;
			}
		}
	}
	internal static class ChalkboardModerationController
	{
		internal static string DescribeAuthority()
		{
			if (!SteamIdModerationController.CanLocalIssue(out var isHost, out var _))
			{
				return "local-only";
			}
			if (!isHost)
			{
				return "authenticated Helper-to-Host";
			}
			return "Host-direct";
		}

		internal static int CountCompatibleRecipients()
		{
			return (PlayerIdentityEvidenceController.GetVerifiedRoster() ?? Array.Empty<PlayerIdentityEvidence>()).Count(IsCompatibleRecipient);
		}

		internal static bool IsCompatibleRecipient(PlayerIdentityEvidence evidence)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			if (evidence == null || evidence.IsLocal || !ulong.TryParse(evidence.SteamId, NumberStyles.None, CultureInfo.InvariantCulture, out var result) || !Plugin.TryGetRescueLobby(out var lobbyId) || lobbyId == CSteamID.Nil)
			{
				return false;
			}
			try
			{
				return CompatibleClientPresencePolicy.IsFresh(SteamMatchmaking.GetLobbyMemberData(lobbyId, new CSteamID(result), "bluesage_qol_client_v1"), DateTimeOffset.UtcNow.ToUnixTimeSeconds());
			}
			catch
			{
				return false;
			}
		}

		internal static string BuildTruth(string action, int boardIndex, string scene, string snapshot, string rollback, string vanillaObserver = "not-observed")
		{
			return ChalkboardCommandPolicy.BuildActionTruth(action, boardIndex, scene, DescribeAuthority(), CountCompatibleRecipients(), snapshot, rollback, vanillaObserver);
		}
	}
	internal static class ChalkboardPersistenceController
	{
		private const string ChalkyGuid = "com.andrewlin.ontogether.chalky";

		private const string Magic = "BSCH1";

		private const int MaxDimension = 512;

		private const int MaxColorIndex = 255;

		private const long MemberDataPollIntervalMilliseconds = 500L;

		private const int ClearCooldownSeconds = 5;

		private static readonly Regex SafeName = new Regex("^[A-Za-z0-9][A-Za-z0-9_-]{0,39}$", RegexOptions.Compiled);

		private static readonly FieldInfo BoardIndexField = AccessTools.Field(typeof(DrawingManager), "_boardIndex");

		private static readonly HashSet<string> SeenClearNonces = new HashSet<string>(StringComparer.Ordinal);

		private static readonly Queue<string> ClearNonceOrder = new Queue<string>();

		private static readonly Dictionary<string, long> LastClearRequestByIssuer = new Dictionary<string, long>(StringComparer.Ordinal);

		private static readonly Dictionary<string, DateTime> LastClearByBoard = new Dictionary<string, DateTime>(StringComparer.Ordinal);

		private static DateTime _lastSharedRestoreUtc = DateTime.MinValue;

		private static long _nextMemberDataPollUnixMilliseconds;

		private static string _memberDataLobbyKey = string.Empty;

		private static string _boardSetSignature = string.Empty;

		private static string _lastListedBoardSetSignature = string.Empty;

		private static long _lastListedBoardSetUnixSeconds;

		private static bool _rollbackUnresolved;

		internal static bool ChalkyInstalled => Chainloader.PluginInfos.ContainsKey("com.andrewlin.ontogether.chalky");

		internal static bool Available
		{
			get
			{
				ConfigEntry<bool> enableChalkboardPersistence = Plugin.EnableChalkboardPersistence;
				if (enableChalkboardPersistence != null && enableChalkboardPersistence.Value)
				{
					return !ChalkyInstalled;
				}
				return false;
			}
		}

		internal static string SaveDirectory => Path.Combine(Paths.ConfigPath, "BlueSageChalkboards");

		internal static string Status()
		{
			if (ChalkyInstalled)
			{
				return "Chalkboard Persistence: Andrew's Chalky is installed, so BlueSage is safely standing down.";
			}
			return "Chalkboard Persistence: " + (Available ? "on." : "off.") + " Catalog=0 River/Stage, 1 Classroom board A (face A), 2 Classroom board B (face B); index 3 is unsupported. Local view/save/delete/map refresh are available to every QoL user. Shared load/clear require Host-direct or authenticated Helper-to-Host authority, a fresh /chalk boards map, and exact current identity. Compatible clients receive full-state replacement; vanilla observer state remains not-observed until live UAT. There is no authoritative drawing-owner identity. rollback=" + ((_rollbackUnresolved || ChalkboardSnapshotTransportController.DestructiveActionsBlocked) ? ChalkboardSnapshotTransportController.RollbackState : "ready") + ".";
		}

		internal static string Save(string name, string boardToken)
		{
			if (!Available)
			{
				return Status();
			}
			if (!TryResolve(name, boardToken, out var normalized, out var board, out var index, out var error))
			{
				return error;
			}
			TrySaveResolved(normalized, board, index, out var message);
			return message;
		}

		private static bool TrySaveResolved(string normalized, QuadPainterGPU board, int index, out string message)
		{
			try
			{
				ValidateGrid(board.PaintColors);
				Directory.CreateDirectory(SaveDirectory);
				string text = Path.Combine(SaveDirectory, normalized + ".bschalk");
				string text2 = text + ".tmp";
				using (FileStream fileStream = new FileStream(text2, FileMode.Create, FileAccess.Write, FileShare.None))
				{
					using BinaryWriter binaryWriter = new BinaryWriter(fileStream);
					binaryWriter.Write("BSCH1");
					binaryWriter.Write(board.PaintColors.Length);
					binaryWriter.Write(board.PaintColors[0].Ints.Count);
					for (int i = 0; i < board.PaintColors.Length; i++)
					{
						for (int j = 0; j < board.PaintColors[i].Ints.Count; j++)
						{
							binaryWriter.Write(board.PaintColors[i].Ints[j]);
						}
					}
					fileStream.Flush(flushToDisk: true);
				}
				if (File.Exists(text))
				{
					string destinationBackupFileName = text + ".bak";
					File.Replace(text2, text, destinationBackupFileName, ignoreMetadataErrors: true);
				}
				else
				{
					File.Move(text2, text);
				}
				message = $"Chalkboard '{normalized}' saved locally from board {index}. " + ChalkboardModerationController.BuildTruth("save", index, DescribeBoardScene(board, index), normalized, "not-needed");
				return true;
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Chalkboard save failed safely: " + ex.GetType().Name + ": " + ex.Message));
				}
				message = "Chalkboard save failed safely; the existing save was left intact.";
				return false;
			}
		}

		internal static string Load(string name, string boardToken)
		{
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			if (!Available)
			{
				return Status();
			}
			if (!TryNormalizeName(name, out var normalized, out var error))
			{
				return error;
			}
			if (!TryResolveBoard(boardToken, out var board, out var index, out var fingerprint, out var error2))
			{
				return error2;
			}
			DrawingManager i = MonoSingleton<DrawingManager>.I;
			if (!ChalkboardCommandPolicy.TryAuthorizeDestructiveAction(index, (i?.QuadPainterGPUS?.Count).GetValueOrDefault(), _lastListedBoardSetSignature, _lastListedBoardSetUnixSeconds, BuildBoardSetSignature(i), DateTimeOffset.UtcNow.ToUnixTimeSeconds(), _rollbackUnresolved || ChalkboardSnapshotTransportController.DestructiveActionsBlocked, out var error3))
			{
				return error3;
			}
			if (!SteamIdModerationController.CanLocalIssue(out var isHost, out var reason))
			{
				return reason;
			}
			if (isHost)
			{
				string issuerSteamId = (SteamManager.Initialized ? ((ulong)SteamUser.GetSteamID()).ToString() : string.Empty);
				ExecuteLoadAsHost(normalized, index, fingerprint, issuerSteamId, out var message);
				return message;
			}
			if (!Plugin.TryGetRescueLobby(out var lobbyId) || lobbyId == CSteamID.Nil)
			{
				return "The Helper chalkboard restore request could not reach the current host; no board changed.";
			}
			try
			{
				string nonce = Guid.NewGuid().ToString("N").Substring(0, 16);
				string text = ChalkboardModerationPolicy.BuildRestoreMemberData(index, fingerprint, DateTimeOffset.UtcNow.ToUnixTimeSeconds(), nonce, normalized);
				SteamMatchmaking.SetLobbyMemberData(lobbyId, "bluesage_chalk_request_v2", text);
				return $"Helper restore request sent privately for host-local snapshot '{normalized}' and board {index}. " + "The host will revalidate exact Helper identity, current scene/index/fingerprint, freshness, request size/version, nonce/replay, and its own saved snapshot before changing the board; no chat line was sent. " + ChalkboardModerationController.BuildTruth("load-request", index, DescribeBoardScene(board, index), normalized, "pending-host");
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Helper chalkboard restore request failed safely: " + ex.GetType().Name + ": " + ex.Message));
				}
				return "The Helper chalkboard restore request failed safely; no board changed.";
			}
		}

		private static ChalkboardClearResult ExecuteLoadAsHost(string normalized, int index, string expectedFingerprint, string issuerSteamId, out string message)
		{
			message = "No chalkboard changed.";
			if (!SafeName.IsMatch(normalized ?? string.Empty) || !SteamIdModerationController.TryGetOwnedHostLobby(out var _, out var _) || !SteamIdModerationController.IsAuthorizedCurrentIssuer(issuerSteamId))
			{
				message = "Only the active host or a currently authorized Helper can request a shared chalkboard restore.";
				return ChalkboardClearResult.Rejected;
			}
			if (!TryResolveBoard(index.ToString(CultureInfo.InvariantCulture), out var board, out var index2, out var fingerprint, out var error))
			{
				message = error;
				return ChalkboardClearResult.Rejected;
			}
			if (index2 != index || !string.Equals(fingerprint, expectedFingerprint, StringComparison.Ordinal))
			{
				message = "The board identity changed after selection. No board changed; run /chalk boards again.";
				return ChalkboardClearResult.Rejected;
			}
			if (!((NetworkIdentity)board).isServer)
			{
				message = "The current client is not the authoritative board server. No board changed.";
				return ChalkboardClearResult.Rejected;
			}
			if (_rollbackUnresolved || ChalkboardSnapshotTransportController.DestructiveActionsBlocked)
			{
				message = "A prior chalkboard rollback remains unresolved. No destructive board action is allowed.";
				return ChalkboardClearResult.Rejected;
			}
			if ((DateTime.UtcNow - _lastSharedRestoreUtc).TotalSeconds < 8.0)
			{
				message = "Chalkboard restore is cooling down; wait a few seconds before another shared restore.";
				return ChalkboardClearResult.Rejected;
			}
			string path = Path.Combine(SaveDirectory, normalized + ".bschalk");
			if (!File.Exists(path))
			{
				message = "Host-local chalkboard snapshot '" + normalized + "' was not found. Use /chalk list.";
				return ChalkboardClearResult.Rejected;
			}
			int[][] array = null;
			string text = "preload-b" + index + "-" + DateTime.UtcNow.ToString("yyyyMMddTHHmmssZ", CultureInfo.InvariantCulture);
			try
			{
				int[][] grid = ReadGrid(path, board);
				if (!TrySaveResolved(text, board, index, out var message2))
				{
					message = "Pre-restore recovery snapshot failed, so BlueSage left the board unchanged. " + message2;
					return ChalkboardClearResult.Rejected;
				}
				array = CopyGrid(board.PaintColors);
				ChalkboardDeliveryResult chalkboardDeliveryResult = ApplyGridAndSync(board, grid);
				_lastSharedRestoreUtc = DateTime.UtcNow;
				string text2 = ChalkboardModerationController.BuildTruth("load", index, DescribeBoardScene(board, index), text, "ready");
				if (!chalkboardDeliveryResult.IsComplete)
				{
					message = $"Chalkboard '{normalized}' restored locally to board {index}, but compatible-recipient delivery was partial " + $"(attempted {chalkboardDeliveryResult.Attempted}, sent {chalkboardDeliveryResult.Sent}, skipped {chalkboardDeliveryResult.Skipped}). " + "After the restore cooldown, repeating the exact action is retry-safe. " + text2;
					return ChalkboardClearResult.Partial;
				}
				message = $"Chalkboard '{normalized}' restored to board {index}. Compatible QoL clients replace stale pixels before the native full-board repaint. " + text2;
				return ChalkboardClearResult.Complete;
			}
			catch (Exception ex)
			{
				bool flag = array == null;
				if (array != null)
				{
					try
					{
						ApplyGridAndSync(board, array);
						flag = true;
					}
					catch (Exception ex2)
					{
						RestoreGridValues(board, array);
						_rollbackUnresolved = true;
						ChalkboardSnapshotTransportController.MarkRollbackUnresolved("restore " + ex2.GetType().Name);
						ManualLogSource log = Plugin.Log;
						if (log != null)
						{
							log.LogError((object)("Chalkboard restore rollback repaint failed after restoring grid values: " + ex2.GetType().Name + ": " + ex2.Message));
						}
					}
				}
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogWarning((object)("Chalkboard restore rejected safely: " + ex.GetType().Name + ": " + ex.Message));
				}
				message = "Chalkboard restore failed; rollback=" + (flag ? "restored" : "unresolved-blocking") + ", recovery snapshot='" + text + "', vanillaObserver=not-observed.";
				return ChalkboardClearResult.Rejected;
			}
		}

		internal static string List()
		{
			if (ChalkyInstalled)
			{
				return Status();
			}
			if (!Directory.Exists(SaveDirectory))
			{
				return "Chalkboard saves: none yet.";
			}
			string[] array = (from value in Directory.GetFiles(SaveDirectory, "*.bschalk").Select(Path.GetFileNameWithoutExtension)
				orderby value
				select value).Take(30).ToArray();
			return ((array.Length == 0) ? "Chalkboard saves: none yet." : ("Chalkboard saves: " + string.Join(", ", array) + ".")) + " authority=local-only, snapshot=local-library, rollback=" + (_rollbackUnresolved ? "unresolved" : "ready") + ", vanillaObserver=not-applicable.";
		}

		internal static string Delete(string name)
		{
			if (ChalkyInstalled)
			{
				return Status();
			}
			if (!TryNormalizeName(name, out var normalized, out var error))
			{
				return error;
			}
			string text = Path.Combine(SaveDirectory, normalized + ".bschalk");
			if (!File.Exists(text))
			{
				return "Chalkboard '" + normalized + "' was not found in the local save library.";
			}
			try
			{
				string text2 = text + ".bak";
				File.Copy(text, text2, overwrite: true);
				File.Delete(text);
				return "Deleted local chalkboard save '" + normalized + "' after preserving '" + Path.GetFileName(text2) + "'. " + ChalkboardCommandPolicy.BuildActionTruth("delete", -1, "local-save-library", "local-only", 0, Path.GetFileName(text2), "reversible-from-backup", "not-applicable");
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Chalkboard local delete failed safely: " + ex.GetType().Name + ": " + ex.Message));
				}
				return "Chalkboard local delete failed safely; the saved snapshot was not intentionally removed.";
			}
		}

		internal static string RefreshMap()
		{
			return "Chalkboard map refreshed locally. " + Boards();
		}

		internal static string View(string boardToken)
		{
			if (!Available)
			{
				return Status();
			}
			if (!TryResolveBoard(boardToken, out var board, out var index, out var fingerprint, out var error))
			{
				return error;
			}
			return "Viewed exact board fingerprint " + fingerprint + ". " + ChalkboardModerationController.BuildTruth("view", index, DescribeBoardScene(board, index), "none", _rollbackUnresolved ? "unresolved" : "ready");
		}

		internal static string Boards()
		{
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_030a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0319: Unknown result type (might be due to invalid IL or missing references)
			if (!Available)
			{
				return Status();
			}
			DrawingManager i = MonoSingleton<DrawingManager>.I;
			if ((Object)(object)i == (Object)null || i.QuadPainterGPUS == null || i.QuadPainterGPUS.Count == 0)
			{
				return "Chalkboards are not ready in this scene.";
			}
			RefreshBoardSetState(i);
			_lastListedBoardSetSignature = _boardSetSignature;
			_lastListedBoardSetUnixSeconds = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
			int num = (int)(BoardIndexField?.GetValue(i) ?? ((object)(-1)));
			PlayerController val = NetworkSingleton<TextChannelManager>.I?.MainPlayerController;
			Vector3 val2 = (((Object)(object)val != (Object)null) ? ((Component)val).transform.position : Vector3.zero);
			bool flag = (Object)(object)val != (Object)null;
			int num2 = -1;
			float num3 = float.MaxValue;
			if (flag)
			{
				int num4 = Math.Min(i.QuadPainterGPUS.Count, 3);
				for (int j = 0; j < num4; j++)
				{
					QuadPainterGPU val3 = i.QuadPainterGPUS[j];
					if (!((Object)(object)val3 == (Object)null))
					{
						float num5 = Vector3.Distance(val2, ((Component)val3).transform.position);
						if (num5 < num3)
						{
							num3 = num5;
							num2 = j;
						}
					}
				}
			}
			List<string> list = new List<string>();
			foreach (ChalkboardCatalogEntry item in ChalkboardCatalogPolicy.Build24259292)
			{
				int index = item.Index;
				if (index >= i.QuadPainterGPUS.Count)
				{
					list.Add(index + " " + item.Label + " unavailable in current scene");
					continue;
				}
				QuadPainterGPU val4 = i.QuadPainterGPUS[index];
				if ((Object)(object)val4 == (Object)null)
				{
					list.Add(index + " " + item.Label + " unavailable");
					continue;
				}
				string text = BuildHierarchyPath(((Component)val4).transform);
				Scene scene = ((Component)val4).gameObject.scene;
				string value = ((Scene)(ref scene)).name ?? string.Empty;
				Vector3 position = ((Component)val4).transform.position;
				string text2 = (string.Equals(ChalkboardModerationPolicy.ClassifyBuild24259292Location(index, position.x, position.y, position.z), item.Label, StringComparison.Ordinal) ? "mapped" : "AMBIGUOUS-MAPPING");
				string text3 = ((index == num) ? " selected" : string.Empty) + ((index == num2) ? " nearest" : string.Empty);
				string text4 = (flag ? (", " + Vector3.Distance(val2, position).ToString("0.0", CultureInfo.InvariantCulture) + "m away") : string.Empty);
				string text5 = ((text.Length > 96) ? ("…" + text.Substring(text.Length - 95)) : text);
				list.Add($"{index} {item.Label} scene={SafeDisplayName(value)} state={text2} at ({position.x:0.0},{position.y:0.0},{position.z:0.0}){text4}" + ((text3.Length > 0) ? (" [" + text3.Trim() + "]") : string.Empty) + " — " + text5);
			}
			string text6 = ((i.QuadPainterGPUS.Count > 3) ? " Extra live surfaces are ignored and cannot become index 3." : string.Empty);
			return "Chalkboards (fresh for " + 30 + "s; exact build 24259292 catalog): " + string.Join("; ", list) + "." + text6 + " Local actions: view/save/delete/refresh. Shared actions: Host-direct or authenticated Helper-to-Host load/clear. compatibleRecipients=" + ChalkboardModerationController.CountCompatibleRecipients() + ", snapshot=required-before-destructive-action, rollback=" + (_rollbackUnresolved ? "unresolved" : "ready") + ", vanillaObserver=not-observed. Clear/load only after rechecking this list.";
		}

		internal static string TryClear(string boardToken)
		{
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			if (!Available)
			{
				return Status();
			}
			if (!TryResolveBoard(boardToken, out var board, out var index, out var fingerprint, out var error))
			{
				return error;
			}
			DrawingManager i = MonoSingleton<DrawingManager>.I;
			string currentBoardSetSignature = BuildBoardSetSignature(i);
			if (!ChalkboardCommandPolicy.TryAuthorizeDestructiveAction(index, (i?.QuadPainterGPUS?.Count).GetValueOrDefault(), _lastListedBoardSetSignature, _lastListedBoardSetUnixSeconds, currentBoardSetSignature, DateTimeOffset.UtcNow.ToUnixTimeSeconds(), _rollbackUnresolved || ChalkboardSnapshotTransportController.DestructiveActionsBlocked, out var error2))
			{
				return error2;
			}
			if (!SteamIdModerationController.CanLocalIssue(out var isHost, out var reason))
			{
				return reason;
			}
			if (isHost)
			{
				string issuerSteamId = (SteamManager.Initialized ? ((ulong)SteamUser.GetSteamID()).ToString() : string.Empty);
				ExecuteClearAsHost(index, fingerprint, issuerSteamId, out var message);
				return message;
			}
			if (!Plugin.TryGetRescueLobby(out var lobbyId) || lobbyId == CSteamID.Nil)
			{
				return "The Helper chalkboard clear request could not reach the current host; no board changed.";
			}
			try
			{
				string nonce = Guid.NewGuid().ToString("N").Substring(0, 16);
				string text = ChalkboardModerationPolicy.BuildMemberData(index, fingerprint, DateTimeOffset.UtcNow.ToUnixTimeSeconds(), nonce);
				SteamMatchmaking.SetLobbyMemberData(lobbyId, "bluesage_chalk_request_v2", text);
				return $"Helper clear request sent privately for board {index}. The host will recheck your Helper role, the live board fingerprint, freshness, nonce/replay guard, scene mapping, and exact index before clearing; no chat line was sent. " + ChalkboardModerationController.BuildTruth("clear-request", index, DescribeBoardScene(board, index), "host-pre-action-required", "pending-host");
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Helper chalkboard clear request failed safely: " + ex.GetType().Name + ": " + ex.Message));
				}
				return "The Helper chalkboard clear request failed safely; no board changed.";
			}
		}

		internal static void PollHostMemberDataRequests()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			long num = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
			if (num < _nextMemberDataPollUnixMilliseconds)
			{
				return;
			}
			_nextMemberDataPollUnixMilliseconds = num + 500;
			if (!Available || !SteamIdModerationController.TryGetOwnedHostLobby(out var lobby, out var ownerSteamId))
			{
				return;
			}
			string text = ((ulong)lobby).ToString();
			if (!string.Equals(_memberDataLobbyKey, text, StringComparison.Ordinal))
			{
				_memberDataLobbyKey = text;
				ResetRelayAndCooldownState();
			}
			RefreshBoardSetState(MonoSingleton<DrawingManager>.I);
			int numLobbyMembers = SteamMatchmaking.GetNumLobbyMembers(lobby);
			for (int i = 0; i < numLobbyMembers; i++)
			{
				CSteamID lobbyMemberByIndex = SteamMatchmaking.GetLobbyMemberByIndex(lobby, i);
				string text2 = ((ulong)lobbyMemberByIndex).ToString();
				if (!string.Equals(text2, ownerSteamId, StringComparison.Ordinal) && ChalkboardModerationPolicy.TryParseMemberData(SteamMatchmaking.GetLobbyMemberData(lobby, lobbyMemberByIndex, "bluesage_chalk_request_v2"), out var request))
				{
					ProcessHelperClearRequest(lobby, text2, request);
				}
			}
		}

		internal static void NotifyModerationBoardReview(string targetSteamId)
		{
			if (Available)
			{
				Plugin.AddLocalNotification("Chalkboard moderation follow-up for banned Steam …" + Suffix(targetSteamId) + ": build 24259292 exposes no authoritative drawing-owner identity, so BlueSage did not guess or auto-clear a board. If abusive chalk remains, run /chalk boards, verify the location/index, then /chalk clear <index>. A local recovery snapshot is saved before every clear.");
			}
		}

		internal static bool PrepareForFullSnapshot(QuadPainterGPU board)
		{
			return ChalkboardSnapshotTransportController.PrepareForFullSnapshot(board);
		}

		private static void ProcessHelperClearRequest(CSteamID lobby, string senderSteamId, ChalkboardClearRequest request)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			long num = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
			if (!ChalkboardModerationPolicy.IsFresh(request.IssuedUnixSeconds, num) || !PlayerIdentityEvidenceController.TryResolveExact(senderSteamId, out var _, out var _) || CountLobbyMembers(lobby, senderSteamId) != 1 || !SteamIdModerationController.IsAuthorizedCurrentIssuer(senderSteamId) || !RememberClearNonce(request.Nonce) || (LastClearRequestByIssuer.TryGetValue(senderSteamId, out var value) && num - value < 2))
			{
				return;
			}
			LastClearRequestByIssuer[senderSteamId] = num;
			ChalkboardClearResult chalkboardClearResult;
			string message;
			if (string.Equals(request.Action, "load", StringComparison.Ordinal))
			{
				chalkboardClearResult = ExecuteLoadAsHost(request.SnapshotName, request.BoardIndex, request.BoardFingerprint, senderSteamId, out message);
			}
			else
			{
				if (!string.Equals(request.Action, "clear", StringComparison.Ordinal))
				{
					return;
				}
				chalkboardClearResult = ExecuteClearAsHost(request.BoardIndex, request.BoardFingerprint, senderSteamId, out message);
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)("Host non-chat chalkboard " + request.Action + " request from Steam …" + Suffix(senderSteamId) + ": " + message));
			}
			Plugin.AddLocalNotification(chalkboardClearResult switch
			{
				ChalkboardClearResult.Partial => "Authorized Helper chalkboard action needs retry: ", 
				ChalkboardClearResult.Complete => "Authorized Helper chalkboard action: ", 
				_ => "Helper chalkboard action rejected: ", 
			} + message);
		}

		private static ChalkboardClearResult ExecuteClearAsHost(int index, string expectedFingerprint, string issuerSteamId, out string message)
		{
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			message = "No chalkboard changed.";
			if (!SteamIdModerationController.TryGetOwnedHostLobby(out var lobby, out var _) || !SteamIdModerationController.IsAuthorizedCurrentIssuer(issuerSteamId))
			{
				message = "Only the active host or a currently authorized Helper can request a shared chalkboard clear.";
				return ChalkboardClearResult.Rejected;
			}
			if (!TryResolveBoard(index.ToString(CultureInfo.InvariantCulture), out var board, out var index2, out var fingerprint, out var error))
			{
				message = error;
				return ChalkboardClearResult.Rejected;
			}
			if (index2 != index || !string.Equals(fingerprint, expectedFingerprint, StringComparison.Ordinal))
			{
				message = "The board identity changed after selection. No board changed; run /chalk boards again.";
				return ChalkboardClearResult.Rejected;
			}
			if (!((NetworkIdentity)board).isServer)
			{
				message = "The current client is not the authoritative board server. No board changed.";
				return ChalkboardClearResult.Rejected;
			}
			if (_rollbackUnresolved || ChalkboardSnapshotTransportController.DestructiveActionsBlocked)
			{
				message = "A prior chalkboard rollback remains unresolved. No destructive board action is allowed.";
				return ChalkboardClearResult.Rejected;
			}
			string key = (ulong)lobby + "|" + fingerprint;
			if (LastClearByBoard.TryGetValue(key, out var value) && (DateTime.UtcNow - value).TotalSeconds < 5.0)
			{
				message = "That board clear is cooling down; wait a few seconds, then recheck /chalk boards.";
				return ChalkboardClearResult.Rejected;
			}
			string text = "modclear-b" + index + "-" + DateTime.UtcNow.ToString("yyyyMMddTHHmmssZ", CultureInfo.InvariantCulture);
			if (!TrySaveResolved(text, board, index, out var message2))
			{
				message = "Pre-clear recovery snapshot failed, so BlueSage left the board unchanged. " + message2;
				return ChalkboardClearResult.Rejected;
			}
			int[][] grid = CopyGrid(board.PaintColors);
			try
			{
				int[][] grid2 = CreateBlankGrid(board.PaintColors);
				ChalkboardDeliveryResult chalkboardDeliveryResult = ApplyGridAndSync(board, grid2);
				LastClearByBoard[key] = DateTime.UtcNow;
				string text2 = ChalkboardModerationController.BuildTruth("clear", index, DescribeBoardScene(board, index), text, "ready");
				if (!chalkboardDeliveryResult.IsComplete)
				{
					message = $"Cleared board {index} locally after saving recovery snapshot '{text}', but verified-recipient delivery was partial " + $"(attempted {chalkboardDeliveryResult.Attempted}, sent {chalkboardDeliveryResult.Sent}, skipped {chalkboardDeliveryResult.Skipped}). " + $"After the {5}s cooldown, /chalk clear {index} is retry-safe because the authoritative board is already blank. " + text2;
					return ChalkboardClearResult.Partial;
				}
				message = $"Cleared board {index} after saving recovery snapshot '{text}'. " + $"Verified-recipient delivery completed (attempted {chalkboardDeliveryResult.Attempted}, sent {chalkboardDeliveryResult.Sent}, skipped {chalkboardDeliveryResult.Skipped}). " + "Compatible QoL clients replace stale pixels before the native full-board repaint; validate any vanilla observer separately. " + text2;
				return ChalkboardClearResult.Complete;
			}
			catch (Exception ex)
			{
				bool flag = false;
				try
				{
					ApplyGridAndSync(board, grid);
					flag = true;
				}
				catch (Exception ex2)
				{
					RestoreGridValues(board, grid);
					_rollbackUnresolved = true;
					ChalkboardSnapshotTransportController.MarkRollbackUnresolved("clear " + ex2.GetType().Name);
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogError((object)("Chalkboard clear rollback repaint failed: " + ex2.GetType().Name + ": " + ex2.Message));
					}
				}
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogWarning((object)("Chalkboard clear failed safely: " + ex.GetType().Name + ": " + ex.Message));
				}
				message = "Chalkboard clear failed; rollback=" + (flag ? "restored" : "unresolved-blocking") + ", recovery snapshot='" + text + "', vanillaObserver=not-observed.";
				return ChalkboardClearResult.Rejected;
			}
		}

		private unsafe static ChalkboardDeliveryResult ApplyGridAndSync(QuadPainterGPU board, int[][] grid)
		{
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)board == (Object)null || board.PaintColors == null || grid == null || grid.Length != board.PaintColors.Length)
			{
				throw new InvalidDataException("board grid dimensions changed");
			}
			for (int i = 0; i < grid.Length; i++)
			{
				if (board.PaintColors[i].Ints == null || grid[i] == null || grid[i].Length != board.PaintColors[i].Ints.Count)
				{
					throw new InvalidDataException("board grid dimensions changed");
				}
				for (int j = 0; j < grid[i].Length; j++)
				{
					board.PaintColors[i].Ints[j] = grid[i][j];
				}
			}
			if (!ChalkboardSnapshotTransportController.PrepareForFullSnapshot(board))
			{
				throw new InvalidOperationException("full-board render replacement could not clear the pending-pixel queue and render texture");
			}
			board.GetQuadImage_Original_1(default(PlayerID), board.PaintColors, default(RPCInfo));
			IReadOnlyList<PlayerIdentityEvidence> obj = PlayerIdentityEvidenceController.GetVerifiedRoster() ?? Array.Empty<PlayerIdentityEvidence>();
			PlayerPanelController i2 = NetworkSingleton<PlayerPanelController>.I;
			string b = ((object)((NetworkIdentity)board).localPlayerForced/*cast due to .constrained prefix*/).ToString();
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			foreach (PlayerIdentityEvidence item in obj)
			{
				if (item == null || item.IsLocal || string.Equals(item.NetworkPlayerId, b, StringComparison.Ordinal))
				{
					continue;
				}
				bool flag = ChalkboardModerationController.IsCompatibleRecipient(item);
				if (flag)
				{
					num++;
				}
				int rosterIndex = item.RosterIndex;
				if (i2?.PlayerIDs == null || rosterIndex < 0 || rosterIndex >= i2.PlayerIDs.Count)
				{
					if (flag)
					{
						num3++;
					}
					continue;
				}
				PlayerID val = i2.PlayerIDs[rosterIndex];
				if (!string.Equals(((object)(*(PlayerID*)(&val))/*cast due to .constrained prefix*/).ToString(), item.NetworkPlayerId, StringComparison.Ordinal) || val == ((NetworkIdentity)board).localPlayerForced)
				{
					if (flag)
					{
						num3++;
					}
					continue;
				}
				try
				{
					board.GetQuadImage(val, board.PaintColors, default(RPCInfo));
					if (flag)
					{
						num2++;
					}
				}
				catch (Exception ex)
				{
					if (flag)
					{
						num3++;
					}
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogWarning((object)("Chalkboard verified-recipient snapshot delivery skipped safely for roster " + rosterIndex + ": " + ex.GetType().Name + ": " + ex.Message));
					}
				}
			}
			return new ChalkboardDeliveryResult(num, num2, num3);
		}

		private static int[][] CopyGrid(IntList[] grid)
		{
			ValidateGrid(grid);
			int[][] array = new int[grid.Length][];
			for (int i = 0; i < grid.Length; i++)
			{
				array[i] = grid[i].Ints.ToArray();
			}
			return array;
		}

		private static int[][] CreateBlankGrid(IntList[] grid)
		{
			ValidateGrid(grid);
			int[][] array = new int[grid.Length][];
			for (int i = 0; i < grid.Length; i++)
			{
				array[i] = new int[grid[i].Ints.Count];
			}
			return array;
		}

		private static void RestoreGridValues(QuadPainterGPU board, int[][] grid)
		{
			if (board?.PaintColors == null || grid == null || grid.Length != board.PaintColors.Length)
			{
				return;
			}
			for (int i = 0; i < grid.Length; i++)
			{
				if (grid[i] != null && board.PaintColors[i].Ints != null && grid[i].Length == board.PaintColors[i].Ints.Count)
				{
					for (int j = 0; j < grid[i].Length; j++)
					{
						board.PaintColors[i].Ints[j] = grid[i][j];
					}
				}
			}
		}

		private static bool TryResolveBoard(string boardToken, out QuadPainterGPU board, out int index, out string fingerprint, out string error)
		{
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			board = null;
			index = -1;
			fingerprint = string.Empty;
			DrawingManager i = MonoSingleton<DrawingManager>.I;
			RefreshBoardSetState(i);
			int valueOrDefault = (i?.QuadPainterGPUS?.Count).GetValueOrDefault();
			if (!ChalkboardModerationPolicy.TryParseExplicitBoardIndex(boardToken, valueOrDefault, out index, out error))
			{
				return false;
			}
			board = i.QuadPainterGPUS[index];
			if ((Object)(object)board == (Object)null)
			{
				error = "Board " + index + " is unavailable. Run /chalk boards again.";
				return false;
			}
			if (!ChalkboardCatalogPolicy.TryGet(index, out var entry))
			{
				error = "Board " + index + " is outside build 24259292's exact catalog. Index 3 is never accepted.";
				return false;
			}
			Scene scene = ((Component)board).gameObject.scene;
			string sceneName = ((Scene)(ref scene)).name ?? string.Empty;
			string hierarchyPath = BuildHierarchyPath(((Component)board).transform);
			Vector3 position = ((Component)board).transform.position;
			if (!string.Equals(ChalkboardModerationPolicy.ClassifyBuild24259292Location(index, position.x, position.y, position.z), entry.Label, StringComparison.Ordinal))
			{
				error = "Board " + index + " has an ambiguous scene/position mapping. No action is allowed; refresh /chalk boards.";
				return false;
			}
			fingerprint = ChalkboardModerationPolicy.BuildBoardFingerprint(sceneName, hierarchyPath, position.x, position.y, position.z);
			return true;
		}

		private static void RefreshBoardSetState(DrawingManager manager)
		{
			string text = BuildBoardSetSignature(manager);
			if (!string.Equals(_boardSetSignature, text, StringComparison.Ordinal))
			{
				_boardSetSignature = text;
				ResetRelayAndCooldownState();
			}
		}

		private static string BuildBoardSetSignature(DrawingManager manager)
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			if (manager?.QuadPainterGPUS == null || manager.QuadPainterGPUS.Count == 0)
			{
				return "<no-boards>";
			}
			List<string> list = new List<string>(manager.QuadPainterGPUS.Count);
			for (int i = 0; i < manager.QuadPainterGPUS.Count; i++)
			{
				QuadPainterGPU val = manager.QuadPainterGPUS[i];
				if ((Object)(object)val == (Object)null)
				{
					list.Add(i.ToString(CultureInfo.InvariantCulture) + ":unavailable");
					continue;
				}
				Vector3 position = ((Component)val).transform.position;
				string text = i.ToString(CultureInfo.InvariantCulture);
				Scene scene = ((Component)val).gameObject.scene;
				list.Add(text + ":" + ChalkboardModerationPolicy.BuildBoardFingerprint(((Scene)(ref scene)).name ?? string.Empty, BuildHierarchyPath(((Component)val).transform), position.x, position.y, position.z));
			}
			return string.Join("|", list);
		}

		private static void ResetRelayAndCooldownState()
		{
			SeenClearNonces.Clear();
			ClearNonceOrder.Clear();
			LastClearRequestByIssuer.Clear();
			LastClearByBoard.Clear();
			_lastSharedRestoreUtc = DateTime.MinValue;
			_lastListedBoardSetSignature = string.Empty;
			_lastListedBoardSetUnixSeconds = 0L;
			_rollbackUnresolved = false;
			ChalkboardSnapshotTransportController.ResetForBoardSetChange();
		}

		private static string BuildHierarchyPath(Transform transform)
		{
			Stack<string> stack = new Stack<string>();
			Transform val = transform;
			while ((Object)(object)val != (Object)null)
			{
				stack.Push(SafeDisplayName(((Object)val).name) + "[" + val.GetSiblingIndex() + "]");
				val = val.parent;
			}
			return string.Join("/", stack.ToArray());
		}

		private static string SafeDisplayName(string value)
		{
			string text = (value ?? "Board").Replace("\r", " ").Replace("\n", " ").Replace("|", "/")
				.Trim();
			if (text.Length != 0)
			{
				return text;
			}
			return "Board";
		}

		private static int CountLobbyMembers(CSteamID lobby, string steamId)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			int numLobbyMembers = SteamMatchmaking.GetNumLobbyMembers(lobby);
			for (int i = 0; i < numLobbyMembers; i++)
			{
				if (string.Equals(((ulong)SteamMatchmaking.GetLobbyMemberByIndex(lobby, i)).ToString(), steamId, StringComparison.Ordinal))
				{
					num++;
				}
			}
			return num;
		}

		private static bool RememberClearNonce(string nonce)
		{
			if (!SeenClearNonces.Add(nonce))
			{
				return false;
			}
			ClearNonceOrder.Enqueue(nonce);
			while (ClearNonceOrder.Count > 128)
			{
				SeenClearNonces.Remove(ClearNonceOrder.Dequeue());
			}
			return true;
		}

		private static string Suffix(string steamId)
		{
			string text;
			if (steamId == null || steamId.Length <= 6)
			{
				text = steamId;
				if (text == null)
				{
					return "unknown";
				}
			}
			else
			{
				text = steamId.Substring(steamId.Length - 6);
			}
			return text;
		}

		private static int[][] ReadGrid(string path, QuadPainterGPU board)
		{
			using FileStream fileStream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read);
			using BinaryReader binaryReader = new BinaryReader(fileStream);
			if (binaryReader.ReadString() != "BSCH1")
			{
				throw new InvalidDataException("unsupported save version");
			}
			int num = binaryReader.ReadInt32();
			int num2 = binaryReader.ReadInt32();
			if (num != board.PaintColors.Length || num < 1 || num > 512 || num2 != board.PaintColors[0].Ints.Count || num2 < 1 || num2 > 512)
			{
				throw new InvalidDataException("board dimensions do not match this board");
			}
			int[][] array = new int[num][];
			for (int i = 0; i < num; i++)
			{
				array[i] = new int[num2];
				for (int j = 0; j < num2; j++)
				{
					int num3 = binaryReader.ReadInt32();
					if (num3 < 0 || num3 > 255)
					{
						throw new InvalidDataException("invalid chalk color index");
					}
					array[i][j] = num3;
				}
			}
			if (fileStream.Position != fileStream.Length)
			{
				throw new InvalidDataException("unexpected trailing board data");
			}
			return array;
		}

		private static bool TryNormalizeName(string name, out string normalized, out string error)
		{
			normalized = (name ?? string.Empty).Trim();
			error = string.Empty;
			if (SafeName.IsMatch(normalized))
			{
				return true;
			}
			error = "Chalkboard name must be 1-40 letters, numbers, underscores, or hyphens.";
			return false;
		}

		private static string DescribeBoardScene(QuadPainterGPU board, int index)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			ChalkboardCatalogEntry entry;
			string obj = (ChalkboardCatalogPolicy.TryGet(index, out entry) ? entry.Label : "unmapped");
			object obj2;
			if (board == null)
			{
				obj2 = null;
			}
			else
			{
				Scene scene = ((Component)board).gameObject.scene;
				obj2 = ((Scene)(ref scene)).name;
			}
			if (obj2 == null)
			{
				obj2 = "unavailable";
			}
			string value = (string)obj2;
			return obj + "@" + SafeDisplayName(value);
		}

		private static bool TryResolve(string name, string boardToken, out string normalized, out QuadPainterGPU board, out int index, out string error)
		{
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			normalized = string.Empty;
			board = null;
			index = -1;
			error = string.Empty;
			if (!TryNormalizeName(name, out normalized, out error))
			{
				return false;
			}
			DrawingManager i = MonoSingleton<DrawingManager>.I;
			if ((Object)(object)i == (Object)null || i.QuadPainterGPUS == null)
			{
				error = "Chalkboards are not ready in this scene.";
				return false;
			}
			RefreshBoardSetState(i);
			index = ((!string.IsNullOrWhiteSpace(boardToken) && int.TryParse(boardToken, out var result)) ? result : ((int)(BoardIndexField?.GetValue(i) ?? ((object)(-1)))));
			if (index < 0 || index >= i.QuadPainterGPUS.Count)
			{
				error = $"Choose a board first or provide an index from 0 to {Math.Max(0, i.QuadPainterGPUS.Count - 1)}.";
				return false;
			}
			board = i.QuadPainterGPUS[index];
			if ((Object)(object)board == (Object)null || !ChalkboardCatalogPolicy.TryGet(index, out var entry))
			{
				error = "The selected board is outside build 24259292's verified catalog 0-2.";
				return false;
			}
			Vector3 position = ((Component)board).transform.position;
			if (!string.Equals(ChalkboardModerationPolicy.ClassifyBuild24259292Location(index, position.x, position.y, position.z), entry.Label, StringComparison.Ordinal))
			{
				error = "The selected board mapping is ambiguous; use /chalk boards and choose exact index 0, 1, or 2.";
				return false;
			}
			return true;
		}

		private static void ValidateGrid(IntList[] grid)
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			if (grid == null || grid.Length < 1 || grid.Length > 512 || grid[0].Ints == null || grid[0].Ints.Count < 1 || grid[0].Ints.Count > 512)
			{
				throw new InvalidDataException("unsupported board dimensions");
			}
			int count = grid[0].Ints.Count;
			foreach (IntList val in grid)
			{
				if (val.Ints == null || val.Ints.Count != count || val.Ints.Any((int value) => value < 0 || value > 255))
				{
					throw new InvalidDataException("invalid board grid");
				}
			}
		}
	}
	internal static class ChalkboardSnapshotTransportController
	{
		private static readonly FieldInfo RenderTextureField = AccessTools.Field(typeof(QuadPainterGPU), "_rt");

		private static readonly FieldInfo PendingPixelsField = AccessTools.Field(typeof(QuadPainterGPU), "_pixelsToUpdate");

		private static bool _destructiveActionsBlocked;

		private static string _rollbackFailure = string.Empty;

		internal static bool DestructiveActionsBlocked => _destructiveActionsBlocked;

		internal static string RollbackState
		{
			get
			{
				if (!_destructiveActionsBlocked)
				{
					return "ready";
				}
				return "unresolved (" + _rollbackFailure + ")";
			}
		}

		internal static void MarkRollbackUnresolved(string reason)
		{
			_destructiveActionsBlocked = true;
			_rollbackFailure = Bound(reason);
		}

		internal static void ResetForBoardSetChange()
		{
			_destructiveActionsBlocked = false;
			_rollbackFailure = string.Empty;
		}

		internal static bool PrepareForFullSnapshot(QuadPainterGPU board)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			if (!ChalkboardPersistenceController.Available || (Object)(object)board == (Object)null)
			{
				return false;
			}
			try
			{
				object? obj = RenderTextureField?.GetValue(board);
				RenderTexture val = (RenderTexture)((obj is RenderTexture) ? obj : null);
				Dictionary<Vector2Int, Color> dictionary = PendingPixelsField?.GetValue(board) as Dictionary<Vector2Int, Color>;
				if ((Object)(object)val == (Object)null || dictionary == null)
				{
					return false;
				}
				dictionary.Clear();
				RenderTexture active = RenderTexture.active;
				try
				{
					RenderTexture.active = val;
					GL.Clear(true, true, Color.clear);
				}
				finally
				{
					RenderTexture.active = active;
				}
				return true;
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogDebug((object)("Chalkboard full-snapshot render clear skipped safely: " + ex.GetType().Name + ": " + ex.Message));
				}
				return false;
			}
		}

		private static string Bound(string value)
		{
			string text = (value ?? "unknown").Replace("\r", " ").Replace("\n", " ").Trim();
			if (text.Length > 96)
			{
				return text.Substring(0, 96);
			}
			return text;
		}
	}
	internal sealed class ChatReadabilityController : MonoBehaviour
	{
		private const float DestroyedStatePruneIntervalSeconds = 5f;

		private bool _lastReadability;

		private bool _lastBackdrop;

		private int _lastChatScalePercent;

		private int _lastChatFontPercent;

		private int _lastChatHeightPercent;

		private bool _lastMessagePanelHidden;

		private bool _lastMessagePanelActivated;

		private int _lastScreenWidth;

		private int _lastScreenHeight;

		private int _lastRefreshRequestVersion;

		private float _nextDestroyedStatePruneAt;

		private void Update()
		{
			bool shouldApplyChatReadability = Plugin.ShouldApplyChatReadability;
			bool shouldApplyPersistentChatBackdrop = Plugin.ShouldApplyPersistentChatBackdrop;
			int lockedChatUiScalePercent = Plugin.LockedChatUiScalePercent;
			int lockedChatFontSizePercent = Plugin.LockedChatFontSizePercent;
			int lockedChatWindowHeightPercent = Plugin.LockedChatWindowHeightPercent;
			if (!(shouldApplyChatReadability || shouldApplyPersistentChatBackdrop) && lockedChatUiScalePercent == 100 && lockedChatFontSizePercent == 100 && lockedChatWindowHeightPercent == 100 && !_lastReadability && !_lastBackdrop && _lastChatScalePercent == 100 && _lastChatFontPercent == 100 && _lastChatHeightPercent == 100)
			{
				if (Time.unscaledTime >= _nextDestroyedStatePruneAt)
				{
					_nextDestroyedStatePruneAt = Time.unscaledTime + 5f;
					ChatReadabilityPatch.PruneDestroyedState();
				}
				return;
			}
			if (Time.unscaledTime >= _nextDestroyedStatePruneAt)
			{
				_nextDestroyedStatePruneAt = Time.unscaledTime + 5f;
				ChatReadabilityPatch.PruneDestroyedState();
			}
			UIManager i = MonoSingleton<UIManager>.I;
			bool flag = (Object)(object)i != (Object)null && i.IsMessagePanelHidden;
			bool flag2 = (Object)(object)i != (Object)null && i.IsMessagePanelActivated;
			int width = Screen.width;
			int height = Screen.height;
			int refreshRequestVersion = ChatReadabilityPatch.RefreshRequestVersion;
			if (shouldApplyChatReadability != _lastReadability || shouldApplyPersistentChatBackdrop != _lastBackdrop || lockedChatUiScalePercent != _lastChatScalePercent || lockedChatFontSizePercent != _lastChatFontPercent || lockedChatWindowHeightPercent != _lastChatHeightPercent || flag != _lastMessagePanelHidden || flag2 != _lastMessagePanelActivated || width != _lastScreenWidth || height != _lastScreenHeight || refreshRequestVersion != _lastRefreshRequestVersion)
			{
				_lastReadability = shouldApplyChatReadability;
				_lastBackdrop = shouldApplyPersistentChatBackdrop;
				_lastChatScalePercent = lockedChatUiScalePercent;
				_lastChatFontPercent = lockedChatFontSizePercent;
				_lastChatHeightPercent = lockedChatWindowHeightPercent;
				_lastMessagePanelHidden = flag;
				_lastMessagePanelActivated = flag2;
				_lastScreenWidth = width;
				_lastScreenHeight = height;
				_lastRefreshRequestVersion = refreshRequestVersion;
				ChatReadabilityPatch.RefreshVisibleChat();
			}
		}
	}
	internal static class CloneIncidentActionController
	{
		private const int MemberDataPollIntervalMilliseconds = 1000;

		private static readonly HashSet<string> SeenResolutionNonces = new HashSet<string>(StringComparer.Ordinal);

		private static readonly Queue<string> ResolutionNonceOrder = new Queue<string>();

		private static readonly Dictionary<string, long> LastResolutionRequestByIssuer = new Dictionary<string, long>(StringComparer.Ordinal);

		private static string _lastLobbyResolutionNonce = string.Empty;

		private static long _nextMemberDataPollUnixMilliseconds;

		internal static void ResetLobbyState()
		{
			SeenResolutionNonces.Clear();
			ResolutionNonceOrder.Clear();
			LastResolutionRequestByIssuer.Clear();
			_lastLobbyResolutionNonce = string.Empty;
			_nextMemberDataPollUnixMilliseconds = 0L;
		}

		internal static IReadOnlyList<CloneIncident> GetOpenIncidents()
		{
			if (!Plugin.CanUseLobbySafety(out var _))
			{
				return Array.Empty<CloneIncident>();
			}
			CloneIncidentLedger.Prune(DateTimeOffset.UtcNow.ToUnixTimeSeconds());
			return CloneIncidentLedger.Snapshot.OrderByDescending((CloneIncident item) => item.LastObservedUnixSeconds).ToArray();
		}

		internal static IReadOnlyList<CloneIncident> GetIncidentHistory()
		{
			if (!Plugin.CanUseLobbySafety(out var _))
			{
				return Array.Empty<CloneIncident>();
			}
			CloneIncidentLedger.Prune(DateTimeOffset.UtcNow.ToUnixTimeSeconds());
			return CloneIncidentLedger.HistorySnapshot.OrderByDescending((CloneIncident item) => item.LastObservedUnixSeconds).ToArray();
		}

		internal static bool TryCopySteamId(string incidentId, bool suspect, out string message)
		{
			if (!Plugin.CanUseLobbySafety(out var _))
			{
				message = "Lobby Safety is available only to the current host or a Helper assigned by that host. No player or incident details were shown.";
				return false;
			}
			if (!CloneIncidentLedger.TryResolveIncident(incidentId, out CloneIncident incident))
			{
				message = "That Clone Shield incident is no longer open.";
				return false;
			}
			message = string.Concat(str2: PlayerIdentityEvidenceController.Suffix(GUIUtility.systemCopyBuffer = (suspect ? incident.SuspectSteamId : incident.VictimSteamId)), str0: suspect ? "Suspect" : "Protected victim", str1: " SteamID64 copied exactly: …", str3: ".");
			return true;
		}

		internal static bool TryCopyBanPreviewCommand(string incidentId, out string message)
		{
			if (!Plugin.CanUseLobbySafety(out var _))
			{
				message = "Lobby Safety is available only to the current host or a Helper assigned by that host. No player or incident details were shown.";
				return false;
			}
			if (!CloneIncidentLedger.TryResolveIncident(incidentId, out CloneIncident incident))
			{
				message = "That Clone Shield incident is no longer open.";
				return false;
			}
			GUIUtility.systemCopyBuffer = "/sidban " + incident.Id;
			message = "Exact suspect preview command copied for " + incident.Id + " (Steam …" + PlayerIdentityEvidenceController.Suffix(incident.SuspectSteamId) + "). Paste to preview; confirmation remains separate.";
			return true;
		}

		internal static bool TryResolveForLobby(string incidentId, out string message)
		{
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.CanUseLobbySafety(out var _))
			{
				message = "Lobby Safety is available only to the current host or a Helper assigned by that host. No player or incident details were shown.";
				return false;
			}
			if (!CloneIncidentLedger.TryResolveIncident(incidentId, out CloneIncident incident))
			{
				message = "That Clone Shield incident is no longer open.";
				return false;
			}
			if (!SteamIdModerationController.CanLocalIssue(out var isHost2, out var reason))
			{
				message = reason;
				return false;
			}
			long num = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
			CloneIncidentResolutionRequest request = new CloneIncidentResolutionRequest(incident.VictimSteamId, incident.SuspectSteamId, incident.StableId, num, Guid.NewGuid().ToString("N").Substring(0, 16));
			if (isHost2)
			{
				if (!TryPublishHostResolution(request, out message))
				{
					return false;
				}
				CloneIncidentLedger.MarkResolved(incident.Id, TryGetLocalSteamId(), num);
				PlayerIdentityRoleHighlightController.RefreshAll();
				RecordLifecycle("resolved", incident, "host-published", "lobby-safety-host");
				message = incident.Id + " resolved. The host-published QoL lobby state clears this incident without adding a chat line.";
				return true;
			}
			string text = CloneIncidentResolutionProtocolPolicy.BuildMemberDataRequest(request.VictimSteamId, request.SuspectSteamId, request.StableId, request.IssuedUnixSeconds, request.Nonce);
			if (string.IsNullOrWhiteSpace(text) || !Plugin.TryGetRescueLobby(out var lobbyId) || lobbyId == CSteamID.Nil)
			{
				message = "The non-chat resolution request could not reach the QoL host, so the incident stayed open.";
				return false;
			}
			try
			{
				SteamMatchmaking.SetLobbyMemberData(lobbyId, "bluesage_incident_request_v2", text);
			}
			catch (Exception ex)
			{
				message = "The non-chat resolution request failed safely (" + ex.GetType().Name + "), so the incident stayed open.";
				return false;
			}
			message = incident.Id + " resolution published through non-chat Steam member data. It stays open until host-authenticated lobby state confirms completion; no chat line was sent.";
			return true;
		}

		internal static bool TryDismissLocal(string incidentId, out string message)
		{
			if (!Plugin.CanUseLobbySafety(out var _))
			{
				message = "Lobby Safety is available only to the current host or a Helper assigned by that host. No player or incident details were shown.";
				return false;
			}
			if (!CloneIncidentLedger.TryResolveIncident(incidentId, out CloneIncident incident) || !CloneIncidentLedger.DismissLocal(incidentId, DateTimeOffset.UtcNow.ToUnixTimeSeconds()))
			{
				message = "That Clone Shield incident is no longer open.";
				return false;
			}
			PlayerIdentityRoleHighlightController.RefreshAll();
			message = incidentId.ToUpperInvariant() + " dismissed on this client only. No lobby moderation state changed.";
			RecordLifecycle("dismissed-local", incident, "closed", "lobby-safety-local");
			return true;
		}

		internal static bool TryDismissAllOpenLocal(out string message)
		{
			if (!Plugin.CanUseLobbySafety(out var _))
			{
				message = "Lobby Safety is available only to the current host or a Helper assigned by that host. No player or incident details were shown.";
				return false;
			}
			CloneIncident[] array = CloneIncidentLedger.Snapshot.ToArray();
			int num = CloneIncidentLedger.DismissAllOpenLocal(DateTimeOffset.UtcNow.ToUnixTimeSeconds());
			CloneIncident[] array2 = array;
			foreach (CloneIncident incident in array2)
			{
				RecordLifecycle("dismissed-local", incident, "bulk-closed", "lobby-safety-local");
			}
			if (num > 0)
			{
				PlayerIdentityRoleHighlightController.RefreshAll();
			}
			message = ((num == 0) ? "No open Clone Shield incidents needed local dismissal. No lobby moderation state changed." : ("Dismissed " + num + " open Clone Shield " + ((num == 1) ? "incident" : "incidents") + " on this client only. No bans, Helper state, or lobby moderation state changed."));
			return true;
		}

		internal static bool MarkStaleAbsent(string incidentId, out CloneIncident incident)
		{
			if (!CloneIncidentLedger.TryResolveIncident(incidentId, out incident))
			{
				return false;
			}
			if (!CloneIncidentLedger.MarkStaleAbsent(incidentId, DateTimeOffset.UtcNow.ToUnixTimeSeconds()))
			{
				return false;
			}
			RecordLifecycle("stale-absent", incident, "closed", "verified-roster-reconciliation");
			return true;
		}

		internal static bool MarkNoLongerMatching(string incidentId, out CloneIncident incident)
		{
			if (!CloneIncidentLedger.TryResolveIncident(incidentId, out incident))
			{
				return false;
			}
			if (!CloneIncidentLedger.MarkNoLongerMatching(incidentId, DateTimeOffset.UtcNow.ToUnixTimeSeconds()))
			{
				return false;
			}
			RecordLifecycle("no-longer-matching", incident, "closed", "verified-roster-reconciliation");
			return true;
		}

		internal static bool TryDismissOpenForVerifiedPlayer(string steamId, out string message)
		{
			if (!Plugin.CanUseLobbySafety(out var _))
			{
				message = "Lobby Safety is available only to the current host or a Helper assigned by that host. No player or incident details were shown.";
				return false;
			}
			if (!PlayerIdentityEvidenceController.TryResolveExact(steamId, out var evidence, out var error))
			{
				message = "Player incident cleanup refused: " + error + ".";
				return false;
			}
			IReadOnlyList<CloneIncident> readOnlyList = CloneIncidentLedger.DismissOpenForSteamId(evidence.SteamId, DateTimeOffset.UtcNow.ToUnixTimeSeconds());
			foreach (CloneIncident item in readOnlyList)
			{
				RecordLifecycle("dismissed-local", item, "player-flags-cleared", "lobby-safety-local");
			}
			if (readOnlyList.Count > 0)
			{
				PlayerIdentityRoleHighlightController.RefreshAll();
			}
			message = ((readOnlyList.Count == 0) ? "No open Clone Shield flags were attached to that verified row." : ("Cleared " + readOnlyList.Count + " open Clone Shield " + ((readOnlyList.Count == 1) ? "incident" : "incidents") + " involving " + evidence.DisplayName + " on this client only. Audit lifecycle records remain; no ban or lobby state changed."));
			return true;
		}

		internal static int ClearClosedHistory()
		{
			if (!Plugin.CanUseLobbySafety(out var _))
			{
				return 0;
			}
			return CloneIncidentLedger.ClearClosed();
		}

		internal static void RecordLifecycle(string action, CloneIncident incident, string outcome, string source)
		{
			if (incident != null)
			{
				string targetRole = "SUSPECT;victim=" + incident.VictimSteamId + ";stable=" + incident.StableId + ";match=" + incident.MatchType;
				SessionAuditController.RecordModeration("clone-incident-" + (action ?? "observed"), source ?? "clone-shield", outcome ?? string.Empty, incident.SuspectSteamId, incident.SuspectLabel, string.Empty, "", incident.Id, targetRole);
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)("Clone Shield incident " + incident.Id + " " + action + ": victim=…" + PlayerIdentityEvidenceController.Suffix(incident.VictimSteamId) + ", suspect=…" + PlayerIdentityEvidenceController.Suffix(incident.SuspectSteamId) + ", stable=" + incident.StableId + ", match=" + incident.MatchType + "."));
				}
			}
		}

		internal static void PollHostMemberDataRequests()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			long num = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
			if (num < _nextMemberDataPollUnixMilliseconds)
			{
				return;
			}
			_nextMemberDataPollUnixMilliseconds = num + 1000;
			try
			{
				if (!SteamIdModerationController.IsLocalHost() || !Plugin.TryGetRescueLobby(out var lobbyId) || lobbyId == CSteamID.Nil)
				{
					return;
				}
				string b = ((ulong)SteamMatchmaking.GetLobbyOwner(lobbyId)).ToString();
				int numLobbyMembers = SteamMatchmaking.GetNumLobbyMembers(lobbyId);
				for (int i = 0; i < numLobbyMembers; i++)
				{
					CSteamID lobbyMemberByIndex = SteamMatchmaking.GetLobbyMemberByIndex(lobbyId, i);
					string text = ((ulong)lobbyMemberByIndex).ToString();
					if (!string.Equals(text, b, StringComparison.Ordinal) && CloneIncidentResolutionProtocolPolicy.TryParseMemberDataRequest(SteamMatchmaking.GetLobbyMemberData(lobbyId, lobbyMemberByIndex, "bluesage_incident_request_v2"), out var request) && PlayerIdentityEvidenceController.TryResolveExact(text, out var _, out var _))
					{
						ProcessResolutionRequest(request, text);
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogDebug((object)("Clone Shield non-chat helper request poll failed closed: " + ex.GetType().Name + ": " + ex.Message));
				}
			}
		}

		private static void ProcessResolutionRequest(CloneIncidentResolutionRequest request, string senderSteamId)
		{
			long num = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
			if (!CloneIncidentResolutionProtocolPolicy.IsFresh(request, num) || !RememberResolutionNonce(request.Nonce))
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)"Rejected expired or replayed Clone Shield resolution request.");
				}
				return;
			}
			if (!PlayerIdentityEvidenceController.TryResolveExact(senderSteamId, out var _, out var _) || !SteamIdModerationController.IsAuthorizedCurrentIssuer(senderSteamId))
			{
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogWarning((object)"Rejected Clone Shield resolution request from a non-helper sender.");
				}
				return;
			}
			if (LastResolutionRequestByIssuer.TryGetValue(senderSteamId, out var value) && num - value < 2)
			{
				ManualLogSource log3 = Plugin.Log;
				if (log3 != null)
				{
					log3.LogWarning((object)("Rate-limited repeated Clone Shield resolution request from Steam …" + PlayerIdentityEvidenceController.Suffix(senderSteamId) + "."));
				}
				return;
			}
			if (!string.Equals(CloneIncidentLedger.BuildStableId(request.VictimSteamId, request.SuspectSteamId), request.StableId, StringComparison.Ordinal) || !CloneIncidentLedger.Snapshot.Any((CloneIncident item) => string.Equals(item.StableId, request.StableId, StringComparison.Ordinal) && string.Equals(item.VictimSteamId, request.VictimSteamId, StringComparison.Ordinal) && string.Equals(item.SuspectSteamId, request.SuspectSteamId, StringComparison.Ordinal)))
			{
				ManualLogSource log4 = Plugin.Log;
				if (log4 != null)
				{
					log4.LogWarning((object)"Rejected Clone Shield resolution request that did not match an open host incident.");
				}
				return;
			}
			LastResolutionRequestByIssuer[senderSteamId] = num;
			if (!TryPublishHostResolution(request, out string message))
			{
				ManualLogSource log5 = Plugin.Log;
				if (log5 != null)
				{
					log5.LogWarning((object)("Clone Shield host resolution publish failed safely: " + message));
				}
				return;
			}
			CloneIncidentLedger.MarkResolvedPair(request.VictimSteamId, request.SuspectSteamId, senderSteamId, num);
			PlayerIdentityRoleHighlightController.RefreshAll();
			RecordLifecycle("resolved", CloneIncidentLedger.HistorySnapshot.LastOrDefault((CloneIncident item) => string.Equals(item.StableId, request.StableId, StringComparison.Ordinal)), "helper-approved", "lobby-safety-host");
			Plugin.AddLocalNotification("Authorized helper resolved Clone Shield " + request.StableId + ". No chat message was sent.");
		}

		internal static void PollHostResolutionMetadata()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!Plugin.TryGetRescueLobby(out var lobbyId) || lobbyId == CSteamID.Nil || !SteamManager.Initialized)
				{
					return;
				}
				string text = ((ulong)SteamMatchmaking.GetLobbyOwner(lobbyId)).ToString();
				if (!CloneIncidentResolutionProtocolPolicy.TryParseLobbyValue(SteamMatchmaking.GetLobbyData(lobbyId, "bluesage_clone_resolution") ?? string.Empty, text, DateTimeOffset.UtcNow.ToUnixTimeSeconds(), out var request) || string.Equals(_lastLobbyResolutionNonce, request.Nonce, StringComparison.Ordinal))
				{
					return;
				}
				_lastLobbyResolutionNonce = request.Nonce;
				if (string.Equals(CloneIncidentLedger.BuildStableId(request.VictimSteamId, request.SuspectSteamId), request.StableId, StringComparison.Ordinal) && CloneIncidentLedger.MarkResolvedPair(request.VictimSteamId, request.SuspectSteamId, text, request.IssuedUnixSeconds))
				{
					PlayerIdentityRoleHighlightController.RefreshAll();
					RecordLifecycle("resolved", CloneIncidentLedger.HistorySnapshot.LastOrDefault((CloneIncident item) => string.Equals(item.StableId, request.StableId, StringComparison.Ordinal)), "host-confirmed", "lobby-safety-peer");
					if (Plugin.CanUseLobbySafety(out var _))
					{
						Plugin.AddLocalNotification("Clone Shield " + request.StableId + " was resolved by the verified host/helper team.");
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogDebug((object)("Clone Shield resolution metadata poll skipped safely: " + ex.GetType().Name + ": " + ex.Message));
				}
			}
		}

		private static bool TryPublishHostResolution(CloneIncidentResolutionRequest request, out string message)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			message = "Only the active QoL lobby host can publish incident completion.";
			try
			{
				if (!Plugin.TryGetRescueLobby(out var lobbyId) || lobbyId == CSteamID.Nil || !SteamManager.Initialized || (Object)(object)NetworkManager.main == (Object)null || !NetworkManager.main.isHost)
				{
					return false;
				}
				string text = ((ulong)SteamMatchmaking.GetLobbyOwner(lobbyId)).ToString();
				string b = ((ulong)SteamUser.GetSteamID()).ToString();
				if (!string.Equals(text, b, StringComparison.Ordinal))
				{
					return false;
				}
				string text2 = CloneIncidentResolutionProtocolPolicy.BuildLobbyValue(text, request);
				if (!SteamMatchmaking.SetLobbyData(lobbyId, "bluesage_clone_resolution", text2))
				{
					message = "Steam rejected the host incident-completion update.";
					return false;
				}
				message = "Host incident completion published.";
				return true;
			}
			catch (Exception ex)
			{
				message = "Host incident completion failed safely (" + ex.GetType().Name + ").";
				return false;
			}
		}

		private static bool RememberResolutionNonce(string nonce)
		{
			if (!SeenResolutionNonces.Add(nonce))
			{
				return false;
			}
			ResolutionNonceOrder.Enqueue(nonce);
			while (ResolutionNonceOrder.Count > 128)
			{
				SeenResolutionNonces.Remove(ResolutionNonceOrder.Dequeue());
			}
			return true;
		}

		private static string TryGetLocalSteamId()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				return ((ulong)SteamUser.GetSteamID()).ToString();
			}
			catch
			{
				return string.Empty;
			}
		}
	}
	internal sealed class CloneShieldController : MonoBehaviour
	{
		private sealed class RosterCloneState
		{
			public string SteamId = string.Empty;

			public string RichName = string.Empty;

			public string PlainName = string.Empty;

			public string AvatarFingerprint = string.Empty;
		}

		private const float ScanIntervalSeconds = 6f;

		private const float WarningCooldownSeconds = 300f;

		private static readonly FieldInfo CustomizationDataField = AccessTools.Field(typeof(PlayerCustomizationController), "_customizationData");

		private readonly Dictionary<string, float> _lastWarningTimes = new Dictionary<string, float>(StringComparer.Ordinal);

		private readonly Dictionary<string, RosterCloneState> _previousRoster = new Dictionary<string, RosterCloneState>(StringComparer.Ordinal);

		private readonly Dictionary<string, int> _missingIncidentScans = new Dictionary<string, int>(StringComparer.Ordinal);

		private readonly Dictionary<string, int> _nonMatchingIncidentScans = new Dictionary<string, int>(StringComparer.Ordinal);

		private float _nextScanAt;

		private float _nextAlignmentWaitLogAt;

		private bool _alignmentWaitWasLogged;

		private string _observedLobbyCode = string.Empty;

		private bool _wasEnabled;

		private void Update()
		{
			if (!Plugin.ShouldApplyCloneShield)
			{
				if (_wasEnabled || _observedLobbyCode.Length > 0 || _previousRoster.Count > 0)
				{
					ResetObservationState();
					PlayerIdentityRoleHighlightController.RefreshAll();
				}
				_wasEnabled = false;
			}
			else
			{
				_wasEnabled = true;
				if (!(Time.unscaledTime < _nextScanAt))
				{
					_nextScanAt = Time.unscaledTime + 6f;
					ScanVisibleRosterForClone();
				}
			}
		}

		private void ScanVisibleRosterForClone()
		{
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!TryGetActiveLobbyCode(out var lobbyCode))
				{
					ResetObservationState();
					return;
				}
				if (!string.Equals(_observedLobbyCode, lobbyCode, StringComparison.Ordinal))
				{
					ResetObservationState();
					_observedLobbyCode = lobbyCode;
					CloneIncidentLedger.Reset(lobbyCode);
				}
				CloneIncidentActionController.PollHostResolutionMetadata();
				PlayerPanelController i = NetworkSingleton<PlayerPanelController>.I;
				if ((Object)(object)i == (Object)null)
				{
					return;
				}
				int val = i.IDInfos?.Count ?? 0;
				int val2 = i.PlayerTransforms?.Count ?? 0;
				int val3 = i.PlayerSteamIDs?.Count ?? 0;
				_ = i.PlayerIDs?.Count;
				int num = Math.Max(val3, Math.Max(val, val2));
				if (num == 0)
				{
					return;
				}
				string error;
				bool coverageComplete;
				IReadOnlyList<string> verifiedCurrentSteamIds = PlayerIdentityEvidenceController.GetVerifiedCurrentSteamIds(out error, out coverageComplete);
				if (!(verifiedCurrentSteamIds.Count > 0 && coverageComplete))
				{
					LogAlignmentWait(error);
					return;
				}
				if (_alignmentWaitWasLogged)
				{
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogDebug((object)"Clone Shield roster alignment recovered; moderation-grade incident observation resumed.");
					}
				}
				_alignmentWaitWasLogged = false;
				_nextAlignmentWaitLogAt = 0f;
				string localSteamId = GetLocalSteamId();
				HashSet<string> hashSet = new HashSet<string>(verifiedCurrentSteamIds, StringComparer.Ordinal);
				Dictionary<string, RosterCloneState> dictionary = new Dictionary<string, RosterCloneState>(StringComparer.Ordinal);
				for (int j = 0; j < num; j++)
				{
					string text = ((i.PlayerSteamIDs != null && j < i.PlayerSteamIDs.Count) ? i.PlayerSteamIDs[j] : string.Empty);
					if (hashSet.Contains(text) && !dictionary.ContainsKey(text))
					{
						string text2 = ((i.IDInfos != null && j < i.IDInfos.Count) ? ReadIdInfoName(i.IDInfos[j]) : ReadTransformName(i, j));
						CustomizationData customizationData = (string.Equals(text, localSteamId, StringComparison.Ordinal) ? GetLocalCustomizationData() : GetCandidateCustomizationData(i, j));
						dictionary[text] = new RosterCloneState
						{
							SteamId = text,
							RichName = (text2 ?? string.Empty),
							PlainName = SanitizeDisplayName(PlayerMentionProvider.StripRichText(text2)),
							AvatarFingerprint = BuildCustomizationFingerprint(customizationData)
						};
					}
				}
				ReconcileAbsentIncidents(hashSet);
				if (_previousRoster.Count > 0)
				{
					DetectNewCloneTransitions(dictionary, localSteamId);
				}
				ReconcileNoLongerMatchingIncidents(dictionary);
				_previousRoster.Clear();
				foreach (KeyValuePair<string, RosterCloneState> item in dictionary)
				{
					_previousRoster[item.Key] = item.Value;
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogWarning((object)("Clone Shield scan skipped safely: " + ex.GetType().Name + ": " + ex.Message));
				}
			}
		}

		private void DetectNewCloneTransitions(Dictionary<string, RosterCloneState> currentRoster, string localSteamId)
		{
			foreach (RosterCloneState culprit in currentRoster.Values)
			{
				RosterCloneState value;
				bool flag = _previousRoster.TryGetValue(culprit.SteamId, out value);
				bool flag2 = !flag || !string.Equals(value.AvatarFingerprint, culprit.AvatarFingerprint, StringComparison.Ordinal);
				bool flag3 = !flag || !string.Equals(value.RichName, culprit.RichName, StringComparison.Ordinal);
				if (!flag2 && !flag3)
				{
					continue;
				}
				foreach (RosterCloneState victim in currentRoster.Values)
				{
					if (string.Equals(victim.SteamId, culprit.SteamId, StringComparison.Ordinal) || !_previousRoster.TryGetValue(victim.SteamId, out var value2))
					{
						continue;
					}
					CloneMatchKind num = CloneTransitionPolicy.Evaluate(flag, value?.AvatarFingerprint, culprit.AvatarFingerprint, value?.RichName, culprit.RichName, value2.AvatarFingerprint, victim.AvatarFingerprint, value2.RichName, victim.RichName, IsUsefulCustomizationFingerprint(culprit.AvatarFingerprint), IsUsefulExactName(culprit.RichName));
					bool flag4 = (num & CloneMatchKind.AvatarOutfit) != 0;
					bool flag5 = (num & CloneMatchKind.ExactStyledName) != 0;
					if (!flag4 && !flag5)
					{
						continue;
					}
					string matchType = ((flag4 && flag5) ? "avatar/outfit and exact styled name" : (flag4 ? "avatar/outfit" : "exact styled name"));
					bool flag6 = CloneIncidentLedger.Snapshot.Any((CloneIncident item) => string.Equals(item.VictimSteamId, victim.SteamId, StringComparison.Ordinal) && string.Equals(item.SuspectSteamId, culprit.SteamId, StringComparison.Ordinal));
					CloneIncident cloneIncident = CloneIncidentLedger.Record(victim.SteamId, culprit.SteamId, matchType, victim.PlainName, culprit.PlainName, DateTimeOffset.UtcNow.ToUnixTimeSeconds());
					if (cloneIncident != null)
					{
						PlayerIdentityRoleHighlightController.RefreshAll();
						if (!flag6)
						{
							CloneIncidentActionController.RecordLifecycle("opened", cloneIncident, "verified", "clone-shield-local");
						}
					}
					if (cloneIncident != null && !string.IsNullOrWhiteSpace(localSteamId) && string.Equals(victim.SteamId, localSteamId, StringComparison.Ordinal))
					{
						PublishPotentialClone(victim, culprit, matchType, cloneIncident.Id);
					}
				}
			}
		}

		private static string GetLocalSteamId()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				return ((ulong)SteamUser.GetSteamID()).ToString();
			}
			catch
			{
				return string.Empty;
			}
		}

		private void PublishPotentialClone(RosterCloneState victim, RosterCloneState culprit, string matchType, string incidentId)
		{
			string key = victim.SteamId + "|" + culprit.SteamId + "|" + matchType;
			if (!_lastWarningTimes.TryGetValue(key, out var value) || !(Time.unscaledTime - value < 300f))
			{
				_lastWarningTimes[key] = Time.unscaledTime;
				string text = BuildPublicIdentityLabel(victim.PlainName, victim.SteamId);
				string text2 = BuildPublicIdentityLabel(culprit.PlainName, culprit.SteamId);
				string text3 = "[Clone Shield] " + text + " was potentially cloned by " + text2 + " (" + matchType + "). Evidence IDs: victim ..." + PlayerIdentityEvidenceController.Suffix(victim.SteamId) + "; suspect ..." + PlayerIdentityEvidenceController.Suffix(culprit.SteamId) + "; match " + matchType + ". Be aware of the player list, Steam ID, and profile; verify identity in case this alert is incorrect.";
				if (!Plugin.TrySendLobbyChatMessage(text3))
				{
					Plugin.AddLocalNotification(text3 + " Public send was unavailable.");
				}
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)("Clone Shield public alert: victimSteam=…" + PlayerIdentityEvidenceController.Suffix(victim.SteamId) + ", culpritSteam=…" + PlayerIdentityEvidenceController.Suffix(culprit.SteamId) + ", match=" + matchType + "."));
				}
			}
		}

		private static string BuildPublicIdentityLabel(string displayName, string steamId)
		{
			string obj = (string.IsNullOrWhiteSpace(displayName) ? "Unknown player" : displayName);
			string text = (steamId ?? string.Empty).Trim();
			string text2 = ((text.Length > 6) ? text.Substring(text.Length - 6) : text);
			return obj + " (ID ..." + (string.IsNullOrWhiteSpace(text2) ? "unknown" : text2) + ")";
		}

		private static bool IsUsefulExactName(string richName)
		{
			if (string.IsNullOrWhiteSpace(richName))
			{
				return false;
			}
			return PlayerMentionProvider.StripRichText(richName).Trim().Length >= 2;
		}

		private static string SanitizeDisplayName(string displayName)
		{
			string text = (displayName ?? string.Empty).Replace("\r", " ").Replace("\n", " ").Trim();
			if (text.Length <= 48)
			{
				return text;
			}
			return text.Substring(0, 48);
		}

		private static bool TryGetActiveLobbyCode(out string lobbyCode)
		{
			lobbyCode = string.Empty;
			try
			{
				MultiplayerManager i = MonoSingleton<MultiplayerManager>.I;
				if ((Object)(object)i == (Object)null || !i.LobbyStatus)
				{
					return false;
				}
				lobbyCode = i.LobbyCode?.Trim() ?? string.Empty;
				if (!ulong.TryParse(lobbyCode, out var result) || result == 0L || !SteamManager.Initialized)
				{
					return false;
				}
				return true;
			}
			catch
			{
				lobbyCode = string.Empty;
				return false;
			}
		}

		private void ResetObservationState()
		{
			_observedLobbyCode = string.Empty;
			_previousRoster.Clear();
			_lastWarningTimes.Clear();
			_missingIncidentScans.Clear();
			_nonMatchingIncidentScans.Clear();
			_alignmentWaitWasLogged = false;
			_nextAlignmentWaitLogAt = 0f;
			CloneIncidentLedger.Reset(string.Empty);
			CloneIncidentActionController.ResetLobbyState();
		}

		private void LogAlignmentWait(string detail)
		{
			if (!_alignmentWaitWasLogged || !(Time.unscaledTime < _nextAlignmentWaitLogAt))
			{
				_alignmentWaitWasLogged = true;
				_nextAlignmentWaitLogAt = Time.unscaledTime + 60f;
				string text = (string.IsNullOrWhiteSpace(detail) ? "native/Steam roster verification is not ready" : detail);
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogDebug((object)("Clone Shield waiting for aligned unique Steam/PurrNet/Steam-lobby roster before recording evidence: " + text + ". Further identical waits are suppressed for 60 seconds."));
				}
			}
		}

		private void ReconcileAbsentIncidents(HashSet<string> verifiedSteamIds)
		{
			CloneIncident[] array = CloneIncidentLedger.Snapshot.ToArray();
			foreach (CloneIncident cloneIncident in array)
			{
				if (verifiedSteamIds.Contains(cloneIncident.VictimSteamId) && verifiedSteamIds.Contains(cloneIncident.SuspectSteamId))
				{
					_missingIncidentScans.Remove(cloneIncident.StableId);
					continue;
				}
				int value;
				int num = ((!_missingIncidentScans.TryGetValue(cloneIncident.StableId, out value)) ? 1 : (value + 1));
				_missingIncidentScans[cloneIncident.StableId] = num;
				if (num >= 2 && CloneIncidentActionController.MarkStaleAbsent(cloneIncident.Id, out CloneIncident _))
				{
					_missingIncidentScans.Remove(cloneIncident.StableId);
					PlayerIdentityRoleHighlightController.RefreshAll();
				}
			}
		}

		private void ReconcileNoLongerMatchingIncidents(Dictionary<string, RosterCloneState> currentRoster)
		{
			CloneIncident[] array = CloneIncidentLedger.Snapshot.ToArray();
			foreach (CloneIncident cloneIncident in array)
			{
				if (!currentRoster.TryGetValue(cloneIncident.VictimSteamId, out var value) || !currentRoster.TryGetValue(cloneIncident.SuspectSteamId, out var value2))
				{
					_nonMatchingIncidentScans.Remove(cloneIncident.StableId);
					continue;
				}
				bool num = cloneIncident.MatchType.IndexOf("avatar", StringComparison.OrdinalIgnoreCase) >= 0;
				bool flag = cloneIncident.MatchType.IndexOf("name", StringComparison.OrdinalIgnoreCase) >= 0;
				bool num2 = num && IsUsefulCustomizationFingerprint(value.AvatarFingerprint) && string.Equals(value.AvatarFingerprint, value2.AvatarFingerprint, StringComparison.Ordinal);
				bool flag2 = flag && IsUsefulExactName(value.RichName) && string.Equals(value.RichName, value2.RichName, StringComparison.Ordinal);
				if (num2 || flag2)
				{
					_nonMatchingIncidentScans.Remove(cloneIncident.StableId);
					continue;
				}
				int value3;
				int num3 = ((!_nonMatchingIncidentScans.TryGetValue(cloneIncident.StableId, out value3)) ? 1 : (value3 + 1));
				_nonMatchingIncidentScans[cloneIncident.StableId] = num3;
				if (num3 >= 2 && CloneIncidentActionController.MarkNoLongerMatching(cloneIncident.Id, out CloneIncident _))
				{
					_nonMatchingIncidentScans.Remove(cloneIncident.StableId);
					PlayerIdentityRoleHighlightController.RefreshAll();
				}
			}
		}

		private static string ReadIdInfoName(object idInfo)
		{
			if (idInfo == null)
			{
				return string.Empty;
			}
			object obj = AccessTools.Field(idInfo.GetType(), "Name")?.GetValue(idInfo);
			if (obj is string result)
			{
				return result;
			}
			if (obj is byte[] array && array.Length != 0)
			{
				return Encoding.Unicode.GetString(array).TrimEnd(new char[1]);
			}
			return string.Empty;
		}

		private static string ReadTransformName(PlayerPanelController panel, int index)
		{
			try
			{
				if (panel?.PlayerTransforms == null || index < 0 || index >= panel.PlayerTransforms.Count)
				{
					return string.Empty;
				}
				NetworkTransform val = panel.PlayerTransforms[index];
				PlayerController val2 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<PlayerController>() : null);
				if ((Object)(object)((val2 != null) ? val2.PlayerNameText : null) != (Object)null)
				{
					return ((TMP_Text)val2.PlayerNameText).text ?? string.Empty;
				}
				return ((Object)(object)val != (Object)null) ? ((Object)val).name : string.Empty;
			}
			catch
			{
				return string.Empty;
			}
		}

		private static CustomizationData GetLocalCustomizationData()
		{
			try
			{
				return MonoSingleton<DataManager>.I?.CustomizationData;
			}
			catch
			{
				return null;
			}
		}

		private static CustomizationData GetCandidateCustomizationData(PlayerPanelController panel, int index)
		{
			try
			{
				if (panel?.PlayerTransforms == null || index < 0 || index >= panel.PlayerTransforms.Count)
				{
					return null;
				}
				NetworkTransform val = panel.PlayerTransforms[index];
				PlayerCustomizationController val2 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<PlayerCustomizationController>() : null);
				return (CustomizationData)(((Object)(object)val2 != (Object)null) ? /*isinst with value type is only supported in some contexts*/: null);
			}
			catch
			{
				return null;
			}
		}

		private static string BuildCustomizationFingerprint(CustomizationData customizationData)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			if (customizationData == null)
			{
				return string.Empty;
			}
			try
			{
				CustomizationDataIDs3 val = new CustomizationDataIDs3(customizationData);
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.Append("full=").Append(val.IsFullBody ? "1" : "0");
				AppendShapeMap(stringBuilder, "A", val.AppearanceToShapeAndColors);
				AppendShapeMap(stringBuilder, "O", val.OutfitToShapeAndColors);
				return stringBuilder.ToString();
			}
			catch
			{
				return string.Empty;
			}
		}

		private static void AppendShapeMap<TKey>(StringBuilder builder, string prefix, IDictionary<TKey, ShapeAndColorsData> shapes)
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			if (builder == null || shapes == null)
			{
				return;
			}
			foreach (KeyValuePair<TKey, ShapeAndColorsData> item in shapes.OrderBy((KeyValuePair<TKey, ShapeAndColorsData> pair) => Convert.ToInt32(pair.Key)))
			{
				builder.Append('|').Append(prefix).Append(':')
					.Append(Convert.ToInt32(item.Key))
					.Append('=');
				builder.Append(item.Value.ShapeIndex).Append(':');
				if (item.Value.ColorIndexes == null || item.Value.ColorIndexes.Count == 0)
				{
					continue;
				}
				for (int num = 0; num < item.Value.ColorIndexes.Count; num++)
				{
					if (num > 0)
					{
						builder.Append(',');
					}
					builder.Append(item.Value.ColorIndexes[num]);
				}
			}
		}

		private static bool IsUsefulCustomizationFingerprint(string fingerprint)
		{
			if (!string.IsNullOrWhiteSpace(fingerprint) && fingerprint.Contains("|A:") && fingerprint.Contains("|O:"))
			{
				return fingerprint.Length > 32;
			}
			return false;
		}
	}
	internal sealed class CommandTypeaheadController : MonoBehaviour
	{
		private readonly struct CommandSuggestion
		{
			public string Label { get; }

			public string Completion { get; }

			public string ArgumentToken { get; }

			public string Hint { get; }

			public bool IsArgument { get; }

			public CommandSuggestion(string label, string completion, string argumentToken, string hint, bool isArgument)
			{
				Label = label ?? string.Empty;
				Completion = completion ?? string.Empty;
				ArgumentToken = argumentToken ?? string.Empty;
				Hint = hint ?? string.Empty;
				IsArgument = isArgument;
			}

			public static CommandSuggestion FromRegistryLine(string line)
			{
				string text = line ?? string.Empty;
				string completion = text.Split(new char[1] { ' ' }, 2)[0];
				string hint = (text.Contains(" - ") ? text.Substring(text.IndexOf(" - ", StringComparison.Ordinal) + 3) : "complete command");
				return new CommandSuggestion(text, completion, string.Empty, hint, isArgument: false);
			}
		}

		private const float AutocompleteCooldownSeconds = 0.15f;

		private const int MaxSuggestions = 7;

		private const int MaxBrowserSuggestions = 64;

		private const int MaxVisibleSuggestions = 8;

		private float _lastAutocompleteAt = -1f;

		private string _lastObservedInputText = string.Empty;

		private int _lastObservedCaret = -1;

		private IReadOnlyList<CommandSuggestion> _suggestions = Array.Empty<CommandSuggestion>();

		private Vector2 _scrollPosition;

		private GUIStyle _popupStyle;

		private GUIStyle _popupHeaderStyle;

		private GUIStyle _popupButtonStyle;

		private GUIStyle _popupHintStyle;

		private Texture2D _popupBackgroundTexture;

		private string _lastThemeKey = string.Empty;

		private int _renderedTextureGeneration;

		private static readonly Dictionary<string, IReadOnlyList<CommandSuggestion>> ArgumentSuggestions = new Dictionary<string, IReadOnlyList<CommandSuggestion>>(StringComparer.OrdinalIgnoreCase)
		{
			["assetsweep"] = CleanupChoices("assetsweep"),
			["sweep"] = CleanupChoices("sweep"),
			["as"] = CleanupChoices("as"),
			["hosthealth"] = ToggleWithRun("hosthealth"),
			["hh"] = ToggleWithRun("hh"),
			["leavenotices"] = Toggle("leavenotices"),
			["ln"] = Toggle("ln"),
			["timestamps"] = new CommandSuggestion[6]
			{
				Choice("timestamps", "on", "enable chat and notice timestamps"),
				Choice("timestamps", "off", "disable chat and notice timestamps"),
				Choice("timestamps", "12", "use 12-hour AM/PM"),
				Choice("timestamps", "24", "use 24-hour time"),
				Choice("timestamps", "reset", "restore enabled 12-hour defaults"),
				Choice("timestamps", "status", "show timestamp state and format")
			},
			["tt"] = new CommandSuggestion[6]
			{
				Choice("tt", "on", "enable chat and notice timestamps"),
				Choice("tt", "off", "disable chat and notice timestamps"),
				Choice("tt", "12", "use 12-hour AM/PM"),
				Choice("tt", "24", "use 24-hour time"),
				Choice("tt", "reset", "restore enabled 12-hour defaults"),
				Choice("tt", "status", "show timestamp state and format")
			},
			["chatreadability"] = Toggle("chatreadability"),
			["chatread"] = Toggle("chatread"),
			["chatbackdrop"] = Toggle("chatbackdrop"),
			["chatbg"] = Toggle("chatbg"),
			["chatoutline"] = new CommandSuggestion[4]
			{
				Choice("chatoutline", "75", "default outline"),
				Choice("chatoutline", "50", "lighter outline"),
				Choice("chatoutline", "100", "crisp outline"),
				Choice("chatoutline", "status", "show current intensity")
			},
			["outline"] = new CommandSuggestion[4]
			{
				Choice("outline", "75", "default outline"),
				Choice("outline", "50", "lighter outline"),
				Choice("outline", "100", "crisp outline"),
				Choice("outline", "status", "show current intensity")
			},
			["chatscale"] = new CommandSuggestion[5]
			{
				Choice("chatscale", "100", "vanilla whole chat UI"),
				Choice("chatscale", "125", "larger whole chat UI"),
				Choice("chatscale", "150", "extra large whole chat UI"),
				Choice("chatscale", "reset", "return whole UI to vanilla"),
				Choice("chatscale", "status", "show current whole UI scale")
			},
			["chatresize"] = new CommandSuggestion[5]
			{
				Choice("chatresize", "100", "vanilla whole chat UI"),
				Choice("chatresize", "125", "larger whole chat UI"),
				Choice("chatresize", "150", "extra large whole chat UI"),
				Choice("chatresize", "reset", "return whole UI to vanilla"),
				Choice("chatresize", "status", "show current whole UI scale")
			},
			["cr"] = new CommandSuggestion[5]
			{
				Choice("cr", "100", "vanilla whole chat UI"),
				Choice("cr", "125", "larger whole chat UI"),
				Choice("cr", "150", "extra large whole chat UI"),
				Choice("cr", "reset", "return whole UI to vanilla"),
				Choice("cr", "status", "show current whole UI scale")
			},
			["chatfont"] = ChatFontChoices("chatfont"),
			["chatfontsize"] = ChatFontChoices("chatfontsize"),
			["cf"] = ChatFontChoices("cf"),
			["chatheight"] = ChatHeightChoices("chatheight"),
			["chatstretch"] = ChatHeightChoices("chatstretch"),
			["chath"] = ChatHeightChoices("chath"),
			["chatrows"] = ChatHistoryChoices("chatrows"),
			["chathistory"] = ChatHistoryChoices("chathistory"),
			["chatr"] = ChatHistoryChoices("chatr"),
			["chatvanilla"] = Array.Empty<CommandSuggestion>(),
			["chatreset"] = Array.Empty<CommandSuggestion>(),
			["chatdefault"] = Array.Empty<CommandSuggestion>(),
			["chatoutlinecolor"] = HexColor("chatoutlinecolor", "normal outline"),
			["outlinecolor"] = HexColor("outlinecolor", "normal outline"),
			["blackoutlinecolor"] = HexColor("blackoutlinecolor", "black text outline"),
			["blackchatoutline"] = HexColor("blackchatoutline", "black text outline"),
			["blackoutline"] = HexColor("blackoutline", "black text outline"),
			["bettermove"] = Toggle("bettermove"),
			["bm"] = Toggle("bm"),
			["reconnectguard"] = Toggle("reconnectguard"),
			["rg"] = Toggle("rg"),
			["reconnectmessage"] = Toggle("reconnectmessage"),
			["rm"] = Toggle("rm"),
			["focusanywhere"] = Toggle("focusanywhere"),
			["fa"] = Toggle("fa"),
			["minimaplabels"] = Toggle("minimaplabels"),
			["mml"] = Toggle("mml"),
			["playersaver"] = PlayerRenderSaverChoices("playersaver"),
			["rendercull"] = PlayerRenderSaverChoices("rendercull"),
			["playercull"] = PlayerRenderSaverChoices("playercull"),
			["chalk"] = ChalkboardChoices("chalk"),
			["chalkboard"] = ChalkboardChoices("chalkboard"),
			["communitybans"] = CommunityBanChoices("communitybans"),
			["communityban"] = CommunityBanChoices("communityban"),
			["bansync"] = CommunityBanChoices("bansync"),
			["cloneshield"] = Toggle("cloneshield"),
			["cloneguard"] = Toggle("cloneguard"),
			["identityshield"] = Toggle("identityshield"),
			["idsync"] = IdentityResyncChoices("idsync"),
			["identitysync"] = IdentityResyncChoices("identitysync"),
			["rostersync"] = IdentityResyncChoices("rostersync"),
			["copychat"] = Toggle("copychat"),
			["ccopy"] = Toggle("ccopy"),
			["chatlinks"] = Toggle("chatlinks"),
			["clinks"] = Toggle("clinks"),
			["spoons"] = new CommandSuggestion[10]
			{
				Choice("spoons", "0", "empty spoon drawer"),
				Choice("spoons", "1", "show [1/5sp]"),
				Choice("spoons", "2", "show [2/5sp]"),
				Choice("spoons", "3", "show [3/5sp]"),
				Choice("spoons", "4", "show [4/5sp]"),
				Choice("spoons", "5", "show [5/5sp]"),
				Choice("spoons", "off", "hide spoon tag"),
				Choice("spoons", "on", "show spoon tag"),
				Choice("spoons", "status", "show spoon state"),
				Choice("spoons", "reset", "restore hidden [5/5sp] default")
			},
			["setmood"] = new CommandSuggestion[5]
			{
				Choice("setmood", "energy", "show [x/5energy]"),
				Choice("setmood", "spoons", "show [x/5spoons]"),
				Choice("setmood", "default", "restore [x/5sp]"),
				Choice("setmood", "reset", "restore [x/5sp]"),
				Choice("setmood", "status", "show current custom label")
			},
			["spoonlabel"] = new CommandSuggestion[5]
			{
				Choice("spoonlabel", "energy", "show [x/5energy]"),
				Choice("spoonlabel", "spoons", "show [x/5spoons]"),
				Choice("spoonlabel", "default", "restore [x/5sp]"),
				Choice("spoonlabel", "reset", "restore [x/5sp]"),
				Choice("spoonlabel", "status", "show current custom label")
			},
			["helper"] = new CommandSuggestion[4]
			{
				Choice("helper", "add", "host: authorize a current lobby player"),
				Choice("helper", "remove", "host: revoke a Helper"),
				Choice("helper", "list", "show the host-scoped Helper list"),
				Choice("helper", "reset", "host: remove every Helper")
			},
			["lobbyhelper"] = HelperAlias("lobbyhelper"),
			["lobbymod"] = HelperAlias("lobbymod"),
			["modhelper"] = HelperAlias("modhelper"),
			["moderationhelper"] = HelperAlias("moderationhelper"),
			["brb"] = Array.Empty<CommandSuggestion>(),
			["afk"] = Array.Empty<CommandSuggestion>(),
			["back"] = Array.Empty<CommandSuggestion>(),
			["pingsound"] = new CommandSuggestion[8]
			{
				Choice("pingsound", "on", "enable ping sound"),
				Choice("pingsound", "off", "disable ping sound"),
				Choice("pingsound", "status", "show sound status"),
				Choice("pingsound", "click", "soft UI click"),
				Choice("pingsound", "change", "UI change chirp"),
				Choice("pingsound", "error", "stronger alert"),
				Choice("pingsound", "task", "task-complete sound"),
				Choice("pingsound", "ticket", "ticket reward sound")
			},
			["setpingcolor"] = new CommandSuggestion[4]
			{
				Choice("setpingcolor", "FFD700", "classic ping yellow highlight"),
				Choice("setpingcolor", "9B59B6", "purple message highlight"),
				Choice("setpingcolor", "00C7BE", "cyan message highlight"),
				Choice("setpingcolor", "FF6B8A", "pink message highlight")
			},
			["statuscolor"] = HexColor("statuscolor", "status").Concat(new CommandSuggestion[1] { Choice("statuscolor", "reset", "restore warm gold status color") }).ToArray(),
			["setname"] = new CommandSuggestion[1] { Choice("setname", "reset", "restore your current Steam persona name") },
			["bsqol"] = QolChoices("bsqol"),
			["qol"] = QolChoices("qol"),
			["style"] = StyleChoices("style"),
			["sty"] = StyleChoices("sty"),
			["styleui"] = Array.Empty<CommandSuggestion>(),
			["sui"] = Array.Empty<CommandSuggestion>()
		};

		private void Update()
		{
			TMP_InputField chatInput = GetChatInput();
			if ((Object)(object)chatInput == (Object)null || !chatInput.isFocused)
			{
				ClearSuggestions();
				_lastObservedInputText = string.Empty;
				_lastObservedCaret = -1;
				return;
			}
			string text = chatInput.text ?? string.Empty;
			int caretPosition = chatInput.caretPosition;
			if (!string.Equals(text, _lastObservedInputText, StringComparison.Ordinal) || caretPosition != _lastObservedCaret)
			{
				_lastObservedInputText = text;
				_lastObservedCaret = caretPosition;
				RefreshSuggestions(chatInput);
			}
			if (Input.GetKeyDown((KeyCode)9) && !(Time.unscaledTime - _lastAutocompleteAt < 0.15f) && _suggestions.Count > 0 && TryAutocomplete(chatInput, _suggestions[0]))
			{
				_lastAutocompleteAt = Time.unscaledTime;
			}
		}

		private void OnGUI()
		{
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Expected O, but got Unknown
			if (_suggestions == null || _suggestions.Count == 0)
			{
				return;
			}
			EnsurePopupStyles();
			float num = Mathf.Clamp((float)Screen.width - 24f, 300f, 560f);
			float num2 = (float)Mathf.Min(_suggestions.Count, 8) * 40f;
			float num3 = 58f + num2;
			float num4 = Mathf.Clamp(36f, 8f, Mathf.Max(8f, (float)Screen.width - num - 8f));
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(num4, Mathf.Max(36f, (float)Screen.height - num3 - 118f), num, num3);
			if ((Object)(object)_popupBackgroundTexture != (Object)null)
			{
				GUI.DrawTexture(val, (Texture)(object)_popupBackgroundTexture);
			}
			GUILayout.BeginArea(val, _popupStyle);
			GUILayout.Label("BlueSage commands • Tab completes the first match", _popupHeaderStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label((_suggestions.Count > 8) ? "Scroll for more. Nothing sends until you press Enter." : "Nothing sends until you press Enter.", _popupHintStyle, Array.Empty<GUILayoutOption>());
			_scrollPosition = GUILayout.BeginScrollView(_scrollPosition, false, _suggestions.Count > 8, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(num - 24f),
				GUILayout.Height(num2 + 4f)
			});
			for (int i = 0; i < _suggestions.Count; i++)
			{
				CommandSuggestion suggestion = _suggestions[i];
				if (GUILayout.Button(new GUIContent(suggestion.Label, suggestion.Hint), _popupButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUILayout.Width(num - 48f),
					GUILayout.Height(36f)
				}))
				{
					TMP_InputField chatInput = GetChatInput();
					if ((Object)(object)chatInput != (Object)null)
					{
						TryAutocomplete(chatInput, suggestion);
					}
				}
			}
			GUILayout.EndScrollView();
			GUILayout.EndArea();
		}

		private void RefreshSuggestions(TMP_InputField input)
		{
			string text = input.text ?? string.Empty;
			if (!IsSlashCommandContext(text, input.caretPosition))
			{
				ClearSuggestions();
			}
			else
			{
				_suggestions = BuildSuggestions(text, input.caretPosition);
			}
		}

		private static IReadOnlyList<CommandSuggestion> BuildSuggestions(string text, int caretPosition)
		{
			string text2 = text.Substring(0, Math.Max(0, Math.Min(caretPosition, text.Length)));
			if (TryBuildArgumentSuggestions(text2, out var suggestions))
			{
				return suggestions;
			}
			int maxResults = (IsCommandBrowserQuery(text2) ? 64 : 7);
			return (from suggestion in Plugin.GetCommandSuggestions(text2, maxResults).Select(CommandSuggestion.FromRegistryLine)
				where !string.IsNullOrWhiteSpace(suggestion.Completion)
				select suggestion).ToArray();
		}

		private static bool TryBuildArgumentSuggestions(string current, out IReadOnlyList<CommandSuggestion> suggestions)
		{
			suggestions = Array.Empty<CommandSuggestion>();
			string text = current.TrimStart(Array.Empty<char>());
			if (!text.StartsWith("/", StringComparison.Ordinal) && !text.StartsWith("./", StringComparison.Ordinal))
			{
				return false;
			}
			string text2 = (text.StartsWith("./", StringComparison.Ordinal) ? text.Substring(2) : text.Substring(1));
			int num = text2.IndexOf(' ');
			if (num < 0)
			{
				return false;
			}
			string command = text2.Substring(0, num);
			string text3 = text2.Substring(num + 1).TrimStart(Array.Empty<char>());
			int num2 = text3.LastIndexOf(' ');
			string currentToken = ((num2 >= 0) ? text3.Substring(num2 + 1) : text3);
			if (Plugin.IsHelperManagementCommandName(command) && !Plugin.CanManageHelpers())
			{
				suggestions = Array.Empty<CommandSuggestion>();
				return true;
			}
			if (Plugin.IsLobbySafetyCommandName(command) && !Plugin.CanUseLobbySafety(out var _))
			{
				suggestions = Array.Empty<CommandSuggestion>();
				return true;
			}
			if (string.Equals(command, "sidincident", StringComparison.OrdinalIgnoreCase) || string.Equals(command, "cloneincident", StringComparison.OrdinalIgnoreCase))
			{
				suggestions = BuildIncidentSuggestions(command, text3, currentToken, num2);
				return true;
			}
			if (string.Equals(command, "sidban", StringComparison.OrdinalIgnoreCase) || string.Equals(command, "sidunban", StringComparison.OrdinalIgnoreCase) || string.Equals(command, "unbansid", StringComparison.OrdinalIgnoreCase))
			{
				if (num2 >= 0)
				{
					suggestions = new CommandSuggestion[1] { Choice(command, "confirm", "confirm the exact previewed target within 30 seconds") }.Where((CommandSuggestion choice) => choice.ArgumentToken.StartsWith(currentToken, StringComparison.OrdinalIgnoreCase)).ToArray();
					return suggestions.Count > 0;
				}
				suggestions = (from token in (from text4 in Plugin.GetModerationTargetSuggestions(!string.Equals(command, "sidban", StringComparison.OrdinalIgnoreCase))
						where text4.StartsWith(currentToken, StringComparison.OrdinalIgnoreCase)
						select text4).Take(64)
					select Choice(command, token, string.Equals(command, "sidban", StringComparison.OrdinalIgnoreCase) ? "Clone Shield suspect; preview before confirming" : "native banned Steam ID; preview before confirming")).ToArray();
				return suggestions.Count > 0;
			}
			if (string.Equals(command, "sidwho", StringComparison.OrdinalIgnoreCase) || string.Equals(command, "sidlookup", StringComparison.OrdinalIgnoreCase))
			{
				if (num2 >= 0 && text3.StartsWith("copy ", StringComparison.OrdinalIgnoreCase))
				{
					suggestions = (from token in (from text4 in Plugin.GetIdentityLookupSuggestions()
							where !string.Equals(text4, "list", StringComparison.OrdinalIgnoreCase) && text4.StartsWith(currentToken, StringComparison.OrdinalIgnoreCase)
							select text4).Take(64)
						select Choice(command, token, "copy this uniquely verified live identity record locally")).ToArray();
					return suggestions.Count > 0;
				}
				suggestions = (from text4 in (from text4 in Plugin.GetIdentityLookupSuggestions().Concat(new string[1] { "copy" })
						where text4.StartsWith(currentToken, StringComparison.OrdinalIgnoreCase)
						select text4).Take(64)
					select Choice(command, text4, (text4 == "list") ? "open the authorized verified roster in Lobby Safety" : "verify this current row before moderation")).ToArray();
				return suggestions.Count > 0;
			}
			if (!ArgumentSuggestions.TryGetValue(command, out var value))
			{
				return false;
			}
			suggestions = value.Where((CommandSuggestion choice) => choice.ArgumentToken.StartsWith(currentToken, StringComparison.OrdinalIgnoreCase)).Take(64).ToArray();
			return suggestions.Count > 0;
		}

		private static IReadOnlyList<CommandSuggestion> BuildIncidentSuggestions(string command, string argumentPrefix, string currentToken, int lastSpace)
		{
			if (lastSpace >= 0)
			{
				string text = argumentPrefix.Substring(0, lastSpace).Trim();
				if (string.Equals(text, "clear-player", StringComparison.OrdinalIgnoreCase) || string.Equals(text, "clear-row", StringComparison.OrdinalIgnoreCase))
				{
					return (from value in (from value in Plugin.GetIdentityLookupSuggestions()
							where !string.Equals(value, "list", StringComparison.OrdinalIgnoreCase) && value.StartsWith(currentToken, StringComparison.OrdinalIgnoreCase)
							select value).Take(64)
						select Choice(command, value, "clear local incident flags only after this verified row resolves uniquely")).ToArray();
				}
				if (text.Length > 1 && text.StartsWith("C", StringComparison.OrdinalIgnoreCase) && text.IndexOf(' ') < 0)
				{
					return new CommandSuggestion[2]
					{
						Choice(command, "resolve", "host-validated resolution for " + text.ToUpperInvariant()),
						Choice(command, "dismiss", "clear " + text.ToUpperInvariant() + " on this client only")
					}.Where((CommandSuggestion choice) => choice.ArgumentToken.StartsWith(currentToken, StringComparison.OrdinalIgnoreCase)).ToArray();
				}
				return Array.Empty<CommandSuggestion>();
			}
			CommandSuggestion[] first = new CommandSuggestion[5]
			{
				Choice(command, "status", "list open and closed Clone Shield incidents"),
				Choice(command, "dismiss-all", "clear every open incident on this client only"),
				Choice(command, "clear-player", "choose one verified player and clear their local incident flags"),
				Choice(command, "clear-history", "remove closed incident history only"),
				Choice(command, "clear-all", "dismiss open incidents locally and clear closed history")
			};
			IEnumerable<CommandSuggestion> second = from incident in CloneIncidentActionController.GetOpenIncidents()
				select Choice(command, incident.Id, "choose this incident, then resolve or dismiss");
			return (from choice in first.Concat(second)
				where choice.ArgumentToken.StartsWith(currentToken, StringComparison.OrdinalIgnoreCase)
				select choice).Take(64).ToArray();
		}

		private static bool IsCommandBrowserQuery(string current)
		{
			string a = (current ?? string.Empty).Trim();
			if (!string.Equals(a, "/", StringComparison.Ordinal))
			{
				return string.Equals(a, "./", StringComparison.Ordinal);
			}
			return true;
		}

		private static bool TryAutocomplete(TMP_InputField input, CommandSuggestion suggestion)
		{
			if ((Object)(object)input == (Object)null || string.IsNullOrWhiteSpace(suggestion.Completion))
			{
				return false;
			}
			string text = input.text ?? string.Empty;
			int num = Math.Max(0, Math.Min(input.caretPosition, text.Length));
			string beforeCaret = text.Substring(0, num);
			string text2 = text.Substring(num);
			string text3 = (suggestion.IsArgument ? ReplaceCurrentArgument(beforeCaret, suggestion.ArgumentToken) : (suggestion.Completion + " "));
			input.text = text3 + text2;
			input.caretPosition = text3.Length;
			((Selectable)input).Select();
			input.ActivateInputField();
			return true;
		}

		private static string ReplaceCurrentArgument(string beforeCaret, string argumentToken)
		{
			int num = beforeCaret.LastIndexOf(' ');
			if (num < 0)
			{
				return beforeCaret + argumentToken + " ";
			}
			return beforeCaret.Substring(0, num + 1) + argumentToken + " ";
		}

		private static bool IsSlashCommandContext(string text, int caretPosition)
		{
			if (string.IsNullOrWhiteSpace(text))
			{
				return false;
			}
			string text2 = text[..Math.Max(0, Math.Min(caretPosition, text.Length))].TrimStart(Array.Empty<char>());
			if (!text2.StartsWith("/", StringComparison.Ordinal))
			{
				return text2.StartsWith("./", StringComparison.Ordinal);
			}
			return true;
		}

		private static TMP_InputField GetChatInput()
		{
			try
			{
				UIManager i = MonoSingleton<UIManager>.I;
				return (i != null) ? i.MessageInput : null;
			}
			catch
			{
				return null;
			}
		}

		private void ClearSuggestions()
		{
			_suggestions = Array.Empty<CommandSuggestion>();
		}

		private void EnsurePopupStyles()
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Expected O, but got Unknown
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Expected O, but got Unknown
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Expected O, but got Unknown
			BlueSageUiThemePalette current = BlueSageUiTheme.Current;
			if (_popupStyle == null || !string.Equals(_lastThemeKey, current.Key, StringComparison.Ordinal) || _renderedTextureGeneration != BlueSageUiTheme.RuntimeTextureGeneration || !BlueSageUiTheme.AreRuntimeTexturesAlive())
			{
				_lastThemeKey = current.Key;
				_popupBackgroundTexture = BlueSageUiTheme.GetSolidTexture(PopupBackground(current));
				GUIStyle val = new GUIStyle(GUI.skin.box)
				{
					padding = new RectOffset(10, 10, 8, 10)
				};
				val.normal.background = _popupBackgroundTexture;
				val.normal.textColor = current.PopupBodyText;
				_popupStyle = val;
				GUIStyle val2 = new GUIStyle(GUI.skin.label)
				{
					fontSize = 12,
					fontStyle = (FontStyle)1
				};
				val2.normal.textColor = current.PopupHeaderText;
				_popupHeaderStyle = val2;
				GUIStyle val3 = new GUIStyle(GUI.skin.label)
				{
					fontSize = 11
				};
				val3.normal.textColor = current.PopupHintText;
				_popupHintStyle = val3;
				_popupButtonStyle = BlueSageUiTheme.CreateNeutralButtonStyle(GUI.skin.button, current, 13);
				_popupButtonStyle.alignment = (TextAnchor)3;
				_popupButtonStyle.wordWrap = true;
				_popupButtonStyle.clipping = (TextClipping)0;
				_renderedTextureGeneration = BlueSageUiTheme.RuntimeTextureGeneration;
			}
		}

		private static Color PopupBackground(BlueSageUiThemePalette theme)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			Color val = (Color)(((??)theme?.Panel) ?? new Color(0.06f, 0.07f, 0.11f, 1f));
			return new Color(val.r * 0.72f, val.g * 0.72f, val.b * 0.72f, 1f);
		}

		private static IReadOnlyList<CommandSuggestion> Toggle(string command)
		{
			return new CommandSuggestion[3]
			{
				Choice(command, "on", "turn this feature on"),
				Choice(command, "off", "turn this feature off"),
				Choice(command, "status", "show current state")
			};
		}

		private static IReadOnlyList<CommandSuggestion> IdentityResyncChoices(string command)
		{
			List<CommandSuggestion> list = new List<CommandSuggestion>
			{
				Choice(command, "status", "read-only exact-correlation coverage and last transaction"),
				Choice(command, "refresh", "local BlueSage surfaces from already-available native state")
			};
			bool isHost;
			string reason;
			switch (SteamIdModerationController.GetLocalAccessState(out isHost, out reason))
			{
			case LobbySafetyAccessState.Host:
				list.Add(Choice(command, "repair", "verified Host one-shot repair for this stable generation"));
				break;
			case LobbySafetyAccessState.HelperReady:
				list.Add(Choice(command, "request", "authenticated Helper request relayed for Host revalidation"));
				break;
			}
			return list;
		}

		private static IReadOnlyList<CommandSuggestion> CleanupChoices(string command)
		{
			return new CommandSuggestion[4]
			{
				Choice(command, "now", "run one manual cleanup now"),
				Choice(command, "on", "enable BlueSage Automatic Cleanup"),
				Choice(command, "off", "disable BlueSage Automatic Cleanup"),
				Choice(command, "status", "show Automatic Cleanup status")
			};
		}

		private static IReadOnlyList<CommandSuggestion> ToggleWithRun(string command)
		{
			return Toggle(command).Concat(new CommandSuggestion[1] { Choice(command, "run", "run a manual check now") }).ToArray();
		}

		private static IReadOnlyList<CommandSuggestion> HexColor(string command, string label)
		{
			return new CommandSuggestion[5]
			{
				Choice(command, "000000", label + " black"),
				Choice(command, "FFFFFF", label + " white"),
				Choice(command, "FFD45D", label + " warm"),
				Choice(command, "70D6FF", label + " cool"),
				Choice(command, "status", "show current color")
			};
		}

		private static IReadOnlyList<CommandSuggestion> ChatHeightChoices(string command)
		{
			return new CommandSuggestion[8]
			{
				Choice(command, "on", "moderate taller chat window"),
				Choice(command, "off", "vanilla chat window"),
				Choice(command, "toggle", "switch taller window on or off"),
				Choice(command, "100", "vanilla chat window"),
				Choice(command, "140", "taller chat window"),
				Choice(command, "180", "very tall chat window"),
				Choice(command, "reset", "return to vanilla window"),
				Choice(command, "status", "show current window size")
			};
		}

		private static IReadOnlyList<CommandSuggestion> ChatFontChoices(string command)
		{
			return new CommandSuggestion[8]
			{
				Choice(command, "on", "larger message text"),
				Choice(command, "off", "vanilla chat text"),
				Choice(command, "toggle", "switch larger message text on or off"),
				Choice(command, "100", "vanilla chat text"),
				Choice(command, "125", "larger message text"),
				Choice(command, "150", "extra large message text"),
				Choice(command, "reset", "return to vanilla text"),
				Choice(command, "status", "show current font size")
			};
		}

		private static IReadOnlyList<CommandSuggestion> ChatHistoryChoices(string command)
		{
			return new CommandSuggestion[6]
			{
				Choice(command, "50", "lighter busy-lobby scrollback"),
				Choice(command, "100", "lighter busy-lobby scrollback"),
				Choice(command, "150", "balanced default"),
				Choice(command, "250", "maximum scrollback; highest UI cost"),
				Choice(command, "reset", "restore the 150-row default"),
				Choice(command, "status", "show configured retained rows")
			};
		}

		private static IReadOnlyList<CommandSuggestion> PlayerRenderSaverChoices(string command)
		{
			return new CommandSuggestion[9]
			{
				Choice(command, "on", "hide far/overflow remote renderers locally"),
				Choice(command, "off", "restore all remote renderers"),
				Choice(command, "toggle", "switch local render saver on or off"),
				Choice(command, "status", "show visible and hidden counts"),
				Choice(command, "reset", "restore default radius and visible count"),
				Choice(command, "radius", "set hide radius in meters"),
				Choice(command, "max", "set closest visible player count"),
				Choice(command, "45", "default radius hint"),
				Choice(command, "32", "default closest visible hint")
			};
		}

		private static IReadOnlyList<CommandSuggestion> ChalkboardChoices(string command)
		{
			return new CommandSuggestion[9]
			{
				Choice(command, "boards", "map the current scene-local board indices and locations"),
				Choice(command, "view", "inspect one exact board locally without changing it"),
				Choice(command, "clear", "Host/Helper: clear an exact index after a recovery snapshot"),
				Choice(command, "status", "show chalkboard feature and compatibility state"),
				Choice(command, "list", "list local recovery and named board saves"),
				Choice(command, "save", "save a named local board snapshot"),
				Choice(command, "load", "Host/Helper: request an exact named snapshot restore"),
				Choice(command, "delete", "delete a local named save after preserving a backup"),
				Choice(command, "refresh", "refresh the exact local 0-2 board map")
			};
		}

		private static IReadOnlyList<CommandSuggestion> CommunityBanChoices(string command)
		{
			return new CommandSuggestion[5]
			{
				Choice(command, "status", "show bounded local upstream validation state"),
				Choice(command, "refresh", "validate now and append only missing local pairs"),
				Choice(command, "on", "enable local additive validation"),
				Choice(command, "off", "disable local additive validation"),
				Choice(command, "attestation", "show bounded attestation location and state")
			};
		}

		private static IReadOnlyList<CommandSuggestion> StyleChoices(string command)
		{
			return new CommandSuggestion[6]
			{
				Choice(command, "color", "wrap text with Color A"),
				Choice(command, "bold", "toggle bold styling"),
				Choice(command, "italic", "toggle italic styling"),
				Choice(command, "gradient", "use Color A to B"),
				Choice(command, "gradient3", "use Color A to B to C"),
				Choice(command, "status", "build colored status text: status #HEX text")
			};
		}

		private static IReadOnlyList<CommandSuggestion> QolChoices(string command)
		{
			return new CommandSuggestion[2]
			{
				Choice(command, "status", "show the current feature summary"),
				Choice(command, "hosthealth", "run one host-health check")
			};
		}

		private static IReadOnlyList<CommandSuggestion> HelperAlias(string command)
		{
			return new CommandSuggestion[4]
			{
				Choice(command, "add", "host: authorize a current lobby player"),
				Choice(command, "remove", "host: revoke a Helper"),
				Choice(command, "list", "show the host-scoped Helper list"),
				Choice(command, "reset", "host: remove every Helper")
			};
		}

		private static CommandSuggestion Choice(string command, string token, string hint)
		{
			return new CommandSuggestion("/" + command + " " + token + " - " + hint, "/" + command, token, hint, isArgument: true);
		}
	}
	internal static class CommunityBanListController
	{
		[Serializable]
		private sealed class CommunityBanPayload
		{
			public string[] BanServerPlayers = Array.Empty<string>();

			public string[] BanServerPlayerNicks = Array.Empty<string>();
		}

		internal const float SuccessIntervalSeconds = 21600f;

		internal const float RetryIntervalSeconds = 900f;

		internal const int MaxPayloadBytes = 262144;

		private static readonly CommunityBanSyncStatus CurrentStatus = new CommunityBanSyncStatus();

		internal static bool RefreshInFlight { get; private set; }

		internal static string StatusText()
		{
			CurrentStatus.Enabled = CanApply();
			return CommunityBanSyncPolicy.BuildStatusText(CurrentStatus);
		}

		internal static string FriendlyStatusText()
		{
			CurrentStatus.Enabled = CanApply();
			return CommunityBanSyncPolicy.BuildFriendlyStatusText(CurrentStatus);
		}

		internal static void SetNextAttempt(DateTime nextAttemptUtc)
		{
			CurrentStatus.Enabled = CanApply();
			CurrentStatus.NextAttemptUtc = nextAttemptUtc.ToUniversalTime();
			WriteCurrentAttestation();
		}

		internal static void MarkDisabled()
		{
			CurrentStatus.Enabled = false;
			CurrentStatus.NextAttemptUtc = null;
			WriteCurrentAttestation();
		}

		internal static IEnumerator ReconcileFromSource(Action<bool> completed)
		{
			bool succeeded = false;
			if (RefreshInFlight)
			{
				completed?.Invoke(obj: false);
				yield break;
			}
			RefreshInFlight = true;
			DateTime attemptUtc = DateTime.UtcNow;
			CommunityBanSyncPolicy.BeginAttempt(CurrentStatus, CanApply(), attemptUtc);
			try
			{
				if (!CanApply())
				{
					Fail("sync is disabled", attemptUtc);
					yield break;
				}
				CommunityBanSourceResult source = null;
				yield return CommunityBanSourceClient.Fetch(delegate(CommunityBanSourceResult result)
				{
					source = result;
				});
				if (source == null)
				{
					Fail("source client returned no result", attemptUtc);
					yield break;
				}
				CurrentStatus.HttpResult = CommunityBanSyncPolicy.BoundStatusField(source.HttpResult, "not attempted");
				CurrentStatus.SourceRevision = CommunityBanSyncPolicy.BoundStatusField(source.SourceRevision);
				CurrentStatus.SourceHash = source.SourceHash;
				if (!source.Succeeded)
				{
					Fail(source.Error, attemptUtc);
					yield break;
				}
				if (!TryParsePayload(source.Payload, out var payload, out var error))
				{
					Fail("JSON validation failed: " + error, attemptUtc);
					yield break;
				}
				BanData val = MonoSingleton<DataManager>.I?.BanData;
				if (val?.BanServerPlayers == null || val.BanServerPlayerNicks == null)
				{
					Fail("native paired storage is unavailable", attemptUtc);
					yield break;
				}
				if (!CommunityBanListMergePolicy.TryBuildAdditions(val.BanServerPlayers, val.BanServerPlayerNicks, payload?.BanServerPlayers, payload?.BanServerPlayerNicks, out var additions, out var error2))
				{
					Fail(error2, attemptUtc);
					yield break;
				}
				if (!NativeBanStoreAdapter.TryApplyAdditions(additions, out var existingCount, out var error3))
				{
					Fail("native persistence failed: " + error3, attemptUtc);
					yield break;
				}
				int valueOrDefault = (payload?.BanServerPlayers?.Length).GetValueOrDefault();
				CurrentStatus.AcceptedCount = valueOrDefault;
				CurrentStatus.LastSuccessUtc = DateTime.UtcNow;
				CurrentStatus.NextAttemptUtc = CommunityBanSyncPolicy.ComputeNextAttemptUtc(CurrentStatus.LastSuccessUtc.Value, succeeded: true);
				CurrentStatus.BoundedError = string.Empty;
				WriteCurrentAttestation();
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)("[BlueSageCommunityBanList] current upstream validated; accepted=" + valueOrDefault + "; existingPreserved=" + existingCount + "; addedMissing=" + additions.Length + "; liveActions=0; authorityGrants=0."));
				}
				succeeded = true;
			}
			finally
			{
				RefreshInFlight = false;
				completed?.Invoke(succeeded);
			}
		}

		internal static void WriteCurrentAttestation()
		{
			try
			{
				string text = Path.Combine(Paths.ConfigPath, "BlueSageAudit");
				Directory.CreateDirectory(text);
				string text2 = Path.Combine(text, "community-ban-source-attestation.json");
				string text3 = text2 + ".tmp";
				string destinationBackupFileName = text2 + ".bak";
				File.WriteAllText(text3, CommunityBanSyncPolicy.BuildAttestationJson(CurrentStatus), new UTF8Encoding(encoderShouldEmitUTF8Identifier: false));
				if (File.Exists(text2))
				{
					File.Replace(text3, text2, destinationBackupFileName, ignoreMetadataErrors: true);
				}
				else
				{
					File.Move(text3, text2);
				}
			}
			catch (Exception ex)
			{
				CurrentStatus.BoundedError = CommunityBanSyncPolicy.BoundError(string.IsNullOrWhiteSpace(CurrentStatus.BoundedError) ? ("attestation write failed: " + ex.GetType().Name) : (CurrentStatus.BoundedError + "; attestation write failed: " + ex.GetType().Name));
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("[BlueSageCommunityBanList] bounded attestation write failed: " + ex.GetType().Name + ". No identity fields were written."));
				}
			}
		}

		private static void Fail(string error, DateTime attemptUtc)
		{
			CurrentStatus.BoundedError = CommunityBanSyncPolicy.BoundError(error);
			CurrentStatus.NextAttemptUtc = CommunityBanSyncPolicy.ComputeNextAttemptUtc(attemptUtc, succeeded: false);
			WriteCurrentAttestation();
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogWarning((object)("[BlueSageCommunityBanList] refresh rejected safely: " + ((CurrentStatus.BoundedError.Length == 0) ? "unavailable" : CurrentStatus.BoundedError) + ". Local native ban pairs were not intentionally changed."));
			}
		}

		private static bool CanApply()
		{
			if (Plugin.EnableCommunityBanListSync != null)
			{
				return Plugin.EnableCommunityBanListSync.Value;
			}
			return false;
		}

		private static bool TryParsePayload(string json, out CommunityBanPayload payload, out string error)
		{
			payload = null;
			error = string.Empty;
			try
			{
				payload = JsonUtility.FromJson<CommunityBanPayload>(json ?? string.Empty);
				if (payload != null)
				{
					return true;
				}
				error = "empty document";
				return false;
			}
			catch (Exception ex)
			{
				error = ex.GetType().Name;
				return false;
			}
		}
	}
	internal sealed class CommunityBanSourceResult
	{
		internal bool Succeeded { get; set; }

		internal string Payload { get; set; } = string.Empty;

		internal string HttpResult { get; set; } = "not attempted";

		internal string SourceRevision { get; set; } = "unavailable";

		internal string SourceHash { get; set; } = "unavailable";

		internal string Error { get; set; } = string.Empty;
	}
	internal static class CommunityBanSourceClient
	{
		internal const int RequestTimeoutSeconds = 10;

		internal const string SourceUrl = "https://raw.githubusercontent.com/andrewlimforfun/ot-community-banlist/master/BanData.txt";

		internal static IEnumerator Fetch(Action<CommunityBanSourceResult> completed)
		{
			CommunityBanSourceResult result = new CommunityBanSourceResult();
			UnityWebRequest request = UnityWebRequest.Get("https://raw.githubusercontent.com/andrewlimforfun/ot-community-banlist/master/BanData.txt");
			try
			{
				request.timeout = 10;
				yield return request.SendWebRequest();
				long responseCode = request.responseCode;
				result.HttpResult = ((responseCode > 0) ? (responseCode + " " + ((object)request.result/*cast due to .constrained prefix*/).ToString()) : ((object)request.result/*cast due to .constrained prefix*/).ToString());
				if ((int)request.result != 1 || responseCode < 200 || responseCode >= 300)
				{
					result.Error = CommunityBanSyncPolicy.BoundError("fetch failed: " + ((object)request.result/*cast due to .constrained prefix*/).ToString() + " (HTTP " + responseCode + ")");
					completed?.Invoke(result);
					yield break;
				}
				DownloadHandler downloadHandler = request.downloadHandler;
				string text = ((downloadHandler != null) ? downloadHandler.text : null) ?? string.Empty;
				int byteCount = Encoding.UTF8.GetByteCount(text);
				if (byteCount <= 0 || byteCount > 262144)
				{
					result.Error = "payload size rejected";
					completed?.Invoke(result);
					yield break;
				}
				result.Payload = text;
				result.SourceHash = ComputeSha256(text);
				string responseHeader = request.GetResponseHeader("ETag");
				if (string.IsNullOrWhiteSpace(responseHeader))
				{
					responseHeader = request.GetResponseHeader("Last-Modified");
				}
				result.SourceRevision = CommunityBanSyncPolicy.BoundStatusField(responseHeader);
				result.Succeeded = true;
				completed?.Invoke(result);
			}
			finally
			{
				((IDisposable)request)?.Dispose();
			}
		}

		private static string ComputeSha256(string value)
		{
			using SHA256 sHA = SHA256.Create();
			byte[] array = sHA.ComputeHash(Encoding.UTF8.GetBytes(value ?? string.Empty));
			StringBuilder stringBuilder = new StringBuilder(array.Length * 2);
			for (int i = 0; i < array.Length; i++)
			{
				stringBuilder.Append(array[i].ToString("X2"));
			}
			return stringBuilder.ToString();
		}
	}
	internal static class StatisticsPulsePresentationPolicy
	{
		public static string BuildStreakValue(int currentStreak, int longestStreak)
		{
			return "\ud83d\udd25 " + Math.Max(0, currentStreak) + "  •  Best " + Math.Max(0, longestStreak);
		}
	}
	internal static class HostConsoleController
	{
		private static readonly long RefreshIntervalTicks = TimeSpan.FromSeconds(1.0).Ticks;

		private static HostConsoleSnapshot _lastSnapshot;

		private static long _lastCaptureUtcTicks;

		private static long _capabilityNonce;

		internal static BlueSageHostCapabilitySnapshotV1 LastCapabilitySnapshot { get; private set; }

		internal static bool HasCapabilitySnapshot { get; private set; }

		internal static int LastVerifiedRosterCount { get; private set; }

		internal static string LastRosterSummary { get; private set; } = "Roster has not been checked yet.";

		internal static string LastPlayerLimitSummary { get; private set; } = "PlayerLimit not checked.";

		internal static HostConsoleSnapshot Capture()
		{
			long ticks = DateTime.UtcNow.Ticks;
			long num = ticks - _lastCaptureUtcTicks;
			if (_lastSnapshot != null && num >= 0 && num < RefreshIntervalTicks)
			{
				return _lastSnapshot;
			}
			bool isHost;
			string reason;
			LobbySafetyAccessState localAccessState = SteamIdModerationController.GetLocalAccessState(out isHost, out reason);
			PlayerIdentityEvidenceController.GetVerifiedRoster(out var status);
			IdentityResyncCoverage cachedIdentityResyncCoverage = PlayerIdentityEvidenceController.GetCachedIdentityResyncCoverage();
			PlayerLimitCompanionStatus playerLimitCompanionStatus = Plugin.GetPlayerLimitCompanionStatus();
			LastVerifiedRosterCount = cachedIdentityResyncCoverage.VerifiedRows;
			LastRosterSummary = status;
			LastPlayerLimitSummary = playerLimitCompanionStatus.ToDiagnosticText();
			bool playerLimitHealthy = !playerLimitCompanionStatus.IsLoaded || (playerLimitCompanionStatus.EffectiveMaxLobbySize.GetValueOrDefault() > 0 && playerLimitCompanionStatus.EffectiveDefaultLobbySize.GetValueOrDefault() > 0 && playerLimitCompanionStatus.EffectiveShiftSkipRate.GetValueOrDefault() > 0 && playerLimitCompanionStatus.ChatRelayPatchEnabled.HasValue);
			bool flag = BlueSageExtensionRegistry.HasLiveHostCapabilityProvider();
			long num2 = Interlocked.Increment(ref _capabilityNonce);
			if (num2 <= 0)
			{
				Interlocked.Exchange(ref _capabilityNonce, 1L);
				num2 = 1L;
			}
			BlueSageHostCapabilitySnapshotV1 snapshot = default(BlueSageHostCapabilitySnapshotV1);
			HasCapabilitySnapshot = flag && BlueSageExtensionRegistry.TryReadHostCapability(isHost, num2, ticks, out snapshot);
			LastCapabilitySnapshot = (HasCapabilitySnapshot ? snapshot : default(BlueSageHostCapabilitySnapshotV1));
			_lastSnapshot = HostConsoleReadinessPolicy.Resolve(localAccessState == LobbySafetyAccessState.Host && isHost, cachedIdentityResyncCoverage.Ready, Plugin.HostCleanupLaneHealthy, Plugin.HostReconnectLaneHealthy, playerLimitHealthy, flag, HasCapabilitySnapshot && snapshot.State == BlueSageHostCapabilityStateV1.Ready, relayRequired: false, relayHealthy: false);
			_lastCaptureUtcTicks = ticks;
			return _lastSnapshot;
		}

		internal static bool TryExecuteCapability(BlueSageHostCapabilityActionV1 action, out string message)
		{
			bool isHost;
			string reason;
			LobbySafetyAccessState localAccessState = SteamIdModerationController.GetLocalAccessState(out isHost, out reason);
			long ticks = DateTime.UtcNow.Ticks;
			long num = Interlocked.Increment(ref _capabilityNonce);
			if (localAccessState != LobbySafetyAccessState.Host || !isHost || num <= 0 || !BlueSageExtensionRegistry.TryExecuteHostCapability(action, isHost: true, num, ticks, out var receipt))
			{
				message = "Private host action unavailable; live host and provider checks failed closed.";
				return false;
			}
			message = receipt.Message;
			_lastCaptureUtcTicks = 0L;
			return receipt.Succeeded;
		}

		internal static string AuditNativeModerationUi()
		{
			Type? typeFromHandle = typeof(PlayerItemController);
			bool value = typeFromHandle.GetMethod("ButtonMutePlayer", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic) != null;
			bool value2 = typeFromHandle.GetMethod("ButtonIgnorePlayer", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic) != null;
			bool value3 = typeFromHandle.GetMethod("ButtonReport", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic) != null;
			bool value4 = typeFromHandle.GetMethod("ButtonBan", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic) != null;
			return "Native moderation UI: mute=" + OnOff(value) + ", ignore=" + OnOff(value2) + ", report=" + OnOff(value3) + ", host remove=" + OnOff(value4) + ". Audit only; no moderation action fired.";
		}

		private static string OnOff(bool value)
		{
			if (!value)
			{
				return "unavailable";
			}
			return "ready";
		}
	}
	internal static class IdentityResyncController
	{
		private const long RuntimePollIntervalMilliseconds = 500L;

		private const long RequestPollIntervalMilliseconds = 500L;

		private const int MaximumRememberedNonces = 128;

		private static readonly IdentityResyncCoordinator Coordinator = new IdentityResyncCoordinator();

		private static readonly HashSet<string> SeenNonces = new HashSet<string>(StringComparer.Ordinal);

		private static readonly Queue<string> NonceOrder = new Queue<string>();

		private static IdentityResyncRuntimeShape _lastShape;

		private static bool _hasLastShape;

		private static long _nextRuntimePollMilliseconds;

		private static long _nextRequestPollMilliseconds;

		private static string _nonceScope = string.Empty;

		private static string _lastTransaction = "none";

		internal static void Tick()
		{
			long num = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
			if (num >= _nextRuntimePollMilliseconds)
			{
				_nextRuntimePollMilliseconds = num + 500;
				ObserveRuntimeShape(num);
			}
			if (num >= _nextRequestPollMilliseconds)
			{
				_nextRequestPollMilliseconds = num + 500;
				PollHostRequests(num);
			}
		}

		internal static BlueSageCommandResult HandleCommand(BlueSageCommandContext context)
		{
			long nowMilliseconds = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
			ObserveRuntimeShape(nowMilliseconds);
			bool isHost;
			string reason;
			LobbySafetyAccessState localAccessState = SteamIdModerationController.GetLocalAccessState(out isHost, out reason);
			IdentityResyncPlan identityResyncPlan = IdentityResyncPlanPolicy.Plan(context?.CommandName ?? "idsync", context?.Arguments ?? string.Empty, MapAccess(localAccessState));
			if (!identityResyncPlan.Allowed)
			{
				return BlueSageCommandResult.HandledWithMessages(identityResyncPlan.Reason, BuildStatus());
			}
			return identityResyncPlan.Action switch
			{
				IdentityResyncAction.Status => BlueSageCommandResult.HandledWithMessages(BuildStatus(), "Use /idsync refresh for local BlueSage presentation, verified Host /idsync repair for one exact pass, or authenticated Helper /idsync request for Host relay."), 
				IdentityResyncAction.RefreshLocalSurfaces => RefreshLocalSurfaces(), 
				IdentityResyncAction.RepairIncompleteRows => ExecuteRepairFromCommand(nowMilliseconds), 
				IdentityResyncAction.PublishHostRequest => PublishHelperRequest(nowMilliseconds), 
				_ => BlueSageCommandResult.HandledWithMessages(identityResyncPlan.Reason), 
			};
		}

		internal static string StatusText()
		{
			ObserveRuntimeShape(DateTimeOffset.UtcNow.ToUnixTimeMilliseconds());
			return BuildStatus();
		}

		internal static string ExecuteMenuAction(string action)
		{
			string text = (action ?? string.Empty).Trim().ToLowerInvariant();
			BlueSageCommandResult blueSageCommandResult = HandleCommand(new BlueSageCommandContext("/idsync " + text, "idsync", text));
			return string.Join(" ", blueSageCommandResult.Messages.ToArray());
		}

		internal static void Reset()
		{
			Coordinator.Reset();
			SeenNonces.Clear();
			NonceOrder.Clear();
			_lastShape = default(IdentityResyncRuntimeShape);
			_hasLastShape = false;
			_nextRuntimePollMilliseconds = 0L;
			_nextRequestPollMilliseconds = 0L;
			_nonceScope = string.Empty;
			_lastTransaction = "none";
		}

		private static BlueSageCommandResult RefreshLocalSurfaces()
		{
			IReadOnlyList<string> cachedIdentityResyncSurfaceTargets = PlayerIdentityEvidenceController.GetCachedIdentityResyncSurfaceTargets();
			if (cachedIdentityResyncSurfaceTargets.Count == 0)
			{
				return BlueSageCommandResult.HandledWithMessages("Identity refresh made no change because no already-available native row state exists. It did not force a Steam/PurrNet snapshot.", BuildStatus());
			}
			PlayerIdentityRoleHighlightController.RefreshRowsFromAlreadyAvailableSnapshot(cachedIdentityResyncSurfaceTargets);
			_lastTransaction = "local-refresh: rows=" + cachedIdentityResyncSurfaceTargets.Count;
			return BlueSageCommandResult.HandledWithMessages("Identity refresh rebuilt " + cachedIdentityResyncSurfaceTargets.Count + " BlueSage-owned local row surface(s) from already-available native state. No authoritative capture, name write, list clear, moderation action, or host request ran.", BuildStatus());
		}

		private static BlueSageCommandResult ExecuteRepairFromCommand(long nowMilliseconds)
		{
			if (!TryGetCurrentHostScope(out var _, out var _, out var scope))
			{
				return BlueSageCommandResult.HandledWithMessages("Identity repair stopped because this client is not the exact current Steam lobby owner and active PurrNet Host.");
			}
			long currentGeneration = Coordinator.CurrentGeneration;
			TryExecuteRepair("host-command", scope, currentGeneration, nowMilliseconds, string.Empty, string.Empty, string.Empty, out var result);
			return BlueSageCommandResult.HandledWithMessages(result, BuildStatus());
		}

		private static BlueSageCommandResult PublishHelperRequest(long nowMilliseconds)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			if (SteamIdModerationController.GetLocalAccessState(out var _, out var _) != LobbySafetyAccessState.HelperReady || !SteamIdModerationController.TryGetFreshCurrentCapability(out var lobby, out var ownerSteamId, out var capability))
			{
				return BlueSageCommandResult.HandledWithMessages("Identity repair request was not published because current Helper authentication is not ready.");
			}
			string text = IdentityResyncRequestProtocol.FingerprintScope(((ulong)lobby).ToString(), ownerSteamId);
			long currentGeneration = Coordinator.CurrentGeneration;
			if (!string.Equals(text, Coordinator.CurrentScope, StringComparison.Ordinal) || currentGeneration <= 0)
			{
				return BlueSageCommandResult.HandledWithMessages("Identity repair request was not published because the current lobby generation is not stable yet.");
			}
			string nonce = Guid.NewGuid().ToString("N").Substring(0, 16);
			if (!IdentityResyncRequestProtocol.TryBuild(text, currentGeneration, IdentityResyncRequestProtocol.FingerprintCapability(capability), DateTimeOffset.UtcNow.ToUnixTimeSeconds(), nonce, out var payload, out var error))
			{
				return BlueSageCommandResult.HandledWithMessages(error);
			}
			try
			{
				SteamMatchmaking.SetLobbyMemberData(lobby, "bluesage_idsync_request_v1", payload);
				_lastTransaction = "helper-request-published: generation=" + currentGeneration;
				return BlueSageCommandResult.HandledWithMessages("Identity repair request published through authenticated non-chat member data. The current Host will revalidate this Helper, lobby, owner, capability, generation, nonce, and exact row before one bounded repair.");
			}
			catch (Exception ex)
			{
				return BlueSageCommandResult.HandledWithMessages("Identity repair request failed safely (" + ex.GetType().Name + "); no repair or identity mutation ran.");
			}
		}

		private static void PollHostRequests(long nowMilliseconds)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			if (!TryGetCurrentHostScope(out var lobby, out var ownerSteamId, out var scope) || !SteamIdModerationController.TryGetFreshCurrentCapability(out var lobby2, out var ownerSteamId2, out var capability) || lobby2 != lobby || !string.Equals(ownerSteamId2, ownerSteamId, StringComparison.Ordinal) || !string.Equals(scope, Coordinator.CurrentScope, StringComparison.Ordinal))
			{
				return;
			}
			ReconcileNonceScope(scope);
			long currentGeneration = Coordinator.CurrentGeneration;
			string text = IdentityResyncRequestProtocol.FingerprintCapability(capability);
			int numLobbyMembers = SteamMatchmaking.GetNumLobbyMembers(lobby);
			for (int i = 0; i < numLobbyMembers; i++)
			{
				CSteamID lobbyMemberByIndex = SteamMatchmaking.GetLobbyMemberByIndex(lobby, i);
				string text2 = ((ulong)lobbyMemberByIndex).ToString();
				if (!string.Equals(text2, ownerSteamId, StringComparison.Ordinal) && IdentityResyncRequestProtocol.TryParse(SteamMatchmaking.GetLobbyMemberData(lobby, lobbyMemberByIndex, "bluesage_idsync_request_v1") ?? string.Empty, out var request, out var _) && IdentityResyncRequestProtocol.IsFresh(request, DateTimeOffset.UtcNow.ToUnixTimeSeconds()) && string.Equals(request.LobbyFingerprint, scope, StringComparison.Ordinal) && request.Generation == currentGeneration && string.Equals(request.CapabilityFingerprint, text, StringComparison.Ordinal) && SteamIdModerationController.IsUniqueCurrentLobbyMember(lobby, text2) && SteamIdModerationController.IsAuthorizedCurrentIssuer(text2) && !IsNonceRemembered(request.Nonce))
				{
					TryExecuteRepair("helper-request", scope, currentGeneration, nowMilliseconds, text2, text, request.Nonce, out var result);
					Plugin.AddLocalNotification(result);
				}
			}
		}

		private static bool TryExecuteRepair(string source, string expectedScope, long expectedGeneration, long nowMilliseconds, string helperSenderSteamId, string expectedCapabilityFingerprint, string requestNonce, out string result)
		{
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			result = "Identity repair did not run.";
			if (!TryGetCurrentHostScope(out var lobby, out var ownerSteamId, out var scope) || !string.Equals(expectedScope, scope, StringComparison.Ordinal) || expectedGeneration != Coordinator.CurrentGeneration)
			{
				result = "Identity repair stopped because the current Host, lobby, owner, or generation changed.";
				return false;
			}
			if (!Coordinator.TryBegin(expectedScope, expectedGeneration, nowMilliseconds, out var lease, out var decision))
			{
				result = FormatBeginRefusal(decision);
				return false;
			}
			if (!string.IsNullOrWhiteSpace(requestNonce) && !RememberNonce(requestNonce))
			{
				Coordinator.Abandon(lease);
				result = "Identity repair request was already consumed. No capture or row refresh ran.";
				return false;
			}
			Stopwatch stopwatch = Stopwatch.StartNew();
			int targetedRows = 0;
			int healedRowCount = 0;
			bool capturePerformed = false;
			string text = "refused";
			IdentityResyncCoverage cachedIdentityResyncCoverage = PlayerIdentityEvidenceController.GetCachedIdentityResyncCoverage();
			try
			{
				PlayerIdentityEvidenceController.ForceRefreshIncompleteRosterRowsOnce(out var _, out var after, out var _, out var targetedSteamIds, out healedRowCount, out capturePerformed);
				targetedRows = targetedSteamIds.Count;
				cachedIdentityResyncCoverage = PlayerIdentityEvidenceController.GetCachedIdentityResyncCoverage();
				if (!TryGetCurrentHostScope(out var lobby2, out var ownerSteamId2, out var scope2) || lobby2 != lobby || !string.Equals(ownerSteamId2, ownerSteamId, StringComparison.Ordinal) || !string.Equals(scope2, expectedScope, StringComparison.Ordinal) || expectedGeneration != Coordinator.CurrentGeneration)
				{
					result = "Identity repair stopped after capture because current Host/lobby ownership or generation migrated. No row surface was refreshed.";
					return false;
				}
				if (!string.IsNullOrWhiteSpace(helperSenderSteamId) && (!SteamIdModerationController.TryGetFreshCurrentCapability(out var lobby3, out var ownerSteamId3, out var capability) || lobby3 != lobby || !string.Equals(ownerSteamId3, ownerSteamId, StringComparison.Ordinal) || !string.Equals(IdentityResyncRequestProtocol.FingerprintCapability(capability), expectedCapabilityFingerprint, StringComparison.Ordinal) || !SteamIdModerationController.IsUniqueCurrentLobbyMember(lobby, helperSenderSteamId) || !SteamIdModerationController.IsAuthorizedCurrentIssuer(helperSenderSteamId) || !PlayerIdentityEvidenceController.TryResolveExactCached(helperSenderSteamId, out var _, out after)))
				{
					result = "Identity repair request failed final exact Helper/lobby revalidation. No row surface was refreshed.";
					return false;
				}
				PlayerIdentityRoleHighlightController.RefreshRows(targetedSteamIds);
				text = (cachedIdentityResyncCoverage.Ready ? "ready" : "locked");
				result = "Identity repair completed one bounded exact-correlation transaction: targetedRows=" + targetedRows + ", healedRows=" + healedRowCount + ", lockedRows=" + cachedIdentityResyncCoverage.LockedRows + ", capturePerformed=" + capturePerformed + ". " + (cachedIdentityResyncCoverage.Ready ? "Coverage is READY." : ("Unresolved or conflicting rows remain fail-closed: " + cachedIdentityResyncCoverage.Reason + "."));
				return true;
			}
			catch (Exception ex)
			{
				text = "failed-" + ex.GetType().Name;
				result = "Identity repair failed safely (" + ex.GetType().Name + "); exact-row locks remain in force.";
				return false;
			}
			finally
			{
				stopwatch.Stop();
				Coordinator.Complete(lease, DateTimeOffset.UtcNow.ToUnixTimeMilliseconds());
				_lastTransaction = source + ": outcome=" + text + ", targetedRows=" + targetedRows + ", healedRows=" + healedRowCount + ", lockedRows=" + cachedIdentityResyncCoverage.LockedRows + ", durationMs=" + stopwatch.ElapsedMilliseconds;
				string text2 = SafeReason(cachedIdentityResyncCoverage.Reason);
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)("[BlueSageIdentityResync] source=" + source + "; outcome=" + text + "; targetedRows=" + targetedRows + "; healedRows=" + healedRowCount + "; lockedRows=" + cachedIdentityResyncCoverage.LockedRows + "; capturePerformed=" + capturePerformed + "; durationMs=" + stopwatch.ElapsedMilliseconds + "; reason=" + text2 + "."));
				}
				SessionAuditController.RecordIdentityResync(source, text, targetedRows, healedRowCount, cachedIdentityResyncCoverage.LockedRows, stopwatch.ElapsedMilliseconds, text2);
			}
		}

		private static void ObserveRuntimeShape(long nowMilliseconds)
		{
			if (!TryCaptureRuntimeShape(out var shape))
			{
				Coordinator.ObserveScope(string.Empty, string.Empty, nowMilliseconds);
				_lastShape = default(IdentityResyncRuntimeShape);
				_hasLastShape = false;
				return;
			}
			IdentityResyncTrigger identityResyncTrigger = (_hasLastShape ? IdentityResyncTriggerPolicy.Classify(_lastShape, shape) : IdentityResyncTrigger.LobbyOrOwnerIdentityChanged);
			if (identityResyncTrigger == IdentityResyncTrigger.None)
			{
				Coordinator.ObserveScope(shape.LobbyFingerprint, shape.OwnerFingerprint, nowMilliseconds);
			}
			else
			{
				Coordinator.ObserveTrigger(shape.LobbyFingerprint, shape.OwnerFingerprint, identityResyncTrigger, nowMilliseconds);
			}
			_lastShape = shape;
			_hasLastShape = true;
		}

		private static bool TryCaptureRuntimeShape(out IdentityResyncRuntimeShape shape)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			shape = default(IdentityResyncRuntimeShape);
			try
			{
				if (!SteamManager.Initialized || !Plugin.TryGetRescueLobby(out var lobbyId) || lobbyId == CSteamID.Nil)
				{
					return false;
				}
				CSteamID lobbyOwner = SteamMatchmaking.GetLobbyOwner(lobbyId);
				if (lobbyOwner == CSteamID.Nil)
				{
					return false;
				}
				string lobbyIdentity = ((ulong)lobbyId).ToString();
				string text = ((ulong)lobbyOwner).ToString();
				PlayerPanelController i = NetworkSingleton<PlayerPanelController>.I;
				int panelToken = (((Object)(object)i != (Object)null) ? ((Object)i).GetInstanceID() : 0);
				int num = 0;
				long num2 = 1469598103934665603L;
				if (((i != null) ? i.PlayerItemControllers : null) != null)
				{
					foreach (PlayerItemController playerItemController in i.PlayerItemControllers)
					{
						if (!((Object)(object)playerItemController == (Object)null) && !((Object)(object)((Component)playerItemController).gameObject == (Object)null) && ((Component)playerItemController).gameObject.activeSelf)
						{
							num++;
							num2 = Mix(num2, ((Object)playerItemController).GetInstanceID());
						}
					}
				}
				if (i?.PlayerSteamIDs != null)
				{
					foreach (string playerSteamID in i.PlayerSteamIDs)
					{
						num2 = Mix(num2, playerSteamID ?? string.Empty);
					}
				}
				if (i?.PlayerIDs != null)
				{
					foreach (PlayerID playerID in i.PlayerIDs)
					{
						num2 = Mix(num2, ((object)playerID/*cast due to .constrained prefix*/).GetHashCode());
					}
				}
				if (i?.PlayerTransforms != null)
				{
					foreach (NetworkTransform playerTransform in i.PlayerTransforms)
					{
						num2 = Mix(num2, ((Object)(object)playerTransform != (Object)null) ? ((Object)playerTransform).GetInstanceID() : 0);
					}
				}
				shape = new IdentityResyncRuntimeShape(IdentityResyncRequestProtocol.FingerprintScope(lobbyIdentity, text), IdentityResyncRequestProtocol.FingerprintCapability("owner|" + text), panelToken, num, num2);
				return true;
			}
			catch
			{
				return false;
			}
		}

		private static bool TryGetCurrentHostScope(out CSteamID lobby, out string ownerSteamId, out string scope)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			scope = string.Empty;
			if (!SteamIdModerationController.TryGetOwnedHostLobby(out lobby, out ownerSteamId))
			{
				return false;
			}
			scope = IdentityResyncRequestProtocol.FingerprintScope(((ulong)lobby).ToString(), ownerSteamId);
			return true;
		}

		private static void ReconcileNonceScope(string scope)
		{
			if (!string.Equals(_nonceScope, scope, StringComparison.Ordinal))
			{
				_nonceScope = scope;
				SeenNonces.Clear();
				NonceOrder.Clear();
			}
		}

		private static bool RememberNonce(string nonce)
		{
			if (!SeenNonces.Add(nonce))
			{
				return false;
			}
			NonceOrder.Enqueue(nonce);
			while (NonceOrder.Count > 128)
			{
				SeenNonces.Remove(NonceOrder.Dequeue());
			}
			return true;
		}

		private static bool IsNonceRemembered(string nonce)
		{
			return SeenNonces.Contains(nonce ?? string.Empty);
		}

		private static string BuildStatus()
		{
			IdentityResyncCoverage cachedIdentityResyncCoverage = PlayerIdentityEvidenceController.GetCachedIdentityResyncCoverage();
			return "Identity resync status: coverage=" + (cachedIdentityResyncCoverage.Ready ? "READY" : "LOCKED") + "; verifiedRows=" + cachedIdentityResyncCoverage.VerifiedRows + "; nativeRows=" + cachedIdentityResyncCoverage.NativeRows + "; purrNetRows=" + cachedIdentityResyncCoverage.PurrNetRows + "; steamMembers=" + cachedIdentityResyncCoverage.SteamMembers + "; lockedRows=" + cachedIdentityResyncCoverage.LockedRows + "; generation=" + Coordinator.CurrentGeneration + "; inFlight=" + Coordinator.IsInFlight + "; why=" + SafeReason(cachedIdentityResyncCoverage.Reason) + "; lastTransaction=" + _lastTransaction + ".";
		}

		private static string FormatBeginRefusal(IdentityResyncBeginDecision decision)
		{
			if (decision.Reason == IdentityResyncBeginReason.QuietWindow)
			{
				return "Identity repair is waiting for the 500 ms generation quiet window (" + decision.RetryAfterMilliseconds + " ms remain). No repair ran.";
			}
			if (decision.Reason == IdentityResyncBeginReason.GlobalCooldown)
			{
				return "Identity repair is globally throttled for " + Math.Max(1L, (decision.RetryAfterMilliseconds + 999) / 1000) + " more second(s). No repair ran.";
			}
			return "Identity repair was refused before capture: " + decision.Reason.ToString() + ".";
		}

		private static IdentityResyncAccess MapAccess(LobbySafetyAccessState state)
		{
			return state switch
			{
				LobbySafetyAccessState.Host => IdentityResyncAccess.Host, 
				LobbySafetyAccessState.HelperReady => IdentityResyncAccess.HelperReady, 
				LobbySafetyAccessState.HelperWaitingForHost => IdentityResyncAccess.HelperWaitingForHost, 
				_ => IdentityResyncAccess.Ordinary, 
			};
		}

		private static string SafeReason(string value)
		{
			string text = (string.IsNullOrWhiteSpace(value) ? "none" : value.Replace("\r", " ").Replace("\n", " ").Replace(";", ",")
				.Trim());
			if (text.Length > 160)
			{
				return text.Substring(0, 160);
			}
			return text;
		}

		private static long Mix(long hash, int value)
		{
			return (hash ^ value) * 1099511628211L;
		}

		private static long Mix(long hash, string value)
		{
			string text = value ?? string.Empty;
			for (int i = 0; i < text.Length; i++)
			{
				hash = (hash ^ text[i]) * 1099511628211L;
			}
			return hash;
		}
	}
	internal sealed class MentionPingController : MonoBehaviour
	{
		private const float AutocompleteCooldownSeconds = 0.15f;

		private const int MaxSuggestions = 5;

		private float _lastAutocompleteAt = -1f;

		private IReadOnlyList<string> _suggestions = Array.Empty<string>();

		private int _mentionStart = -1;

		private int _mentionCaret = -1;

		private string _mentionQuery = string.Empty;

		private string _lastObservedInputText = string.Empty;

		private int _lastObservedCaret = -1;

		private GUIStyle _popupStyle;

		private GUIStyle _popupHeaderStyle;

		private GUIStyle _popupButtonStyle;

		private string _lastThemeKey = string.Empty;

		private int _renderedTextureGeneration;

		private bool _lastLobbyPingAccess;

		private void Update()
		{
			if (Plugin.EnablePingMentions == null || !Plugin.EnablePingMentions.Value)
			{
				ClearSuggestions();
				_lastObservedInputText = string.Empty;
				_lastObservedCaret = -1;
				return;
			}
			TMP_InputField chatInput = GetChatInput();
			if ((Object)(object)chatInput == (Object)null || !chatInput.isFocused)
			{
				ClearSuggestions();
				_lastObservedInputText = string.Empty;
				_lastObservedCaret = -1;
				return;
			}
			string text = chatInput.text ?? string.Empty;
			int caretPosition = chatInput.caretPosition;
			bool isHost;
			bool flag = Plugin.CanUseLobbySafety(out isHost);
			if (!string.Equals(text, _lastObservedInputText, StringComparison.Ordinal) || caretPosition != _lastObservedCaret || flag != _lastLobbyPingAccess)
			{
				_lastObservedInputText = text;
				_lastObservedCaret = caretPosition;
				_lastLobbyPingAccess = flag;
				RefreshSuggestions(chatInput);
			}
			if (Input.GetKeyDown((KeyCode)9) && !(Time.unscaledTime - _lastAutocompleteAt < 0.15f) && TryAutocomplete(chatInput, (_suggestions.Count > 0) ? _suggestions[0] : string.Empty))
			{
				_lastAutocompleteAt = Time.unscaledTime;
			}
		}

		private void OnGUI()
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Expected O, but got Unknown
			if (_suggestions == null || _suggestions.Count == 0)
			{
				return;
			}
			EnsurePopupStyles();
			float num = 340f;
			float num2 = 44f + (float)_suggestions.Count * 30f;
			GUILayout.BeginArea(new Rect(36f, Mathf.Max(36f, (float)Screen.height - num2 - 118f), num, num2), _popupStyle);
			GUILayout.Label("BlueSage @ mention suggestions - Tab completes the first match", _popupHeaderStyle, Array.Empty<GUILayoutOption>());
			for (int i = 0; i < _suggestions.Count; i++)
			{
				string text = _suggestions[i];
				if (GUILayout.Button(new GUIContent(text.Equals("lobby", StringComparison.OrdinalIgnoreCase) ? "@lobby - ping everyone using compatible ping mods" : ("@" + text), "Click or press Tab to complete the mention."), _popupButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(26f) }))
				{
					TMP_InputField chatInput = GetChatInput();
					if ((Object)(object)chatInput != (Object)null)
					{
						TryAutocomplete(chatInput, text);
					}
				}
			}
			GUILayout.EndArea();
		}

		public static void PlayConfiguredPing()
		{
			if (Plugin.EnablePingSound == null || !Plugin.EnablePingSound.Value)
			{
				return;
			}
			try
			{
				SFXManager i = MonoSingleton<SFXManager>.I;
				if ((Object)(object)i != (Object)null)
				{
					switch (Plugin.GetPingSoundMode())
					{
					case "change":
						i.PlayUIChange();
						break;
					case "error":
						i.PlayUIError();
						break;
					case "task":
						i.PlayTaskComplete();
						break;
					case "ticket":
						i.PlayEarnTicket();
						break;
					default:
						i.PlayUIClick();
						break;
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Ping Mentions sound skipped safely: " + ex.GetType().Name + ": " + ex.Message));
				}
			}
		}

		private static TMP_InputField GetChatInput()
		{
			try
			{
				UIManager i = MonoSingleton<UIManager>.I;
				return (i != null) ? i.MessageInput : null;
			}
			catch
			{
				return null;
			}
		}

		private void RefreshSuggestions(TMP_InputField input)
		{
			if (!TryFindMentionContext(input, out var atIndex, out var caret, out var query))
			{
				ClearSuggestions();
				return;
			}
			_mentionStart = atIndex;
			_mentionCaret = caret;
			_mentionQuery = query;
			_suggestions = PlayerMentionProvider.FindMentionMatches(query, 5);
		}

		private static bool TryAutocomplete(TMP_InputField input, string preferredMatch)
		{
			if (!TryFindMentionContext(input, out var atIndex, out var caret, out var query))
			{
				return false;
			}
			string text = (string.IsNullOrWhiteSpace(preferredMatch) ? PlayerMentionProvider.FindBestMentionMatch(query) : preferredMatch);
			if (string.IsNullOrWhiteSpace(text))
			{
				return false;
			}
			if (string.Equals(text, "lobby", StringComparison.OrdinalIgnoreCase) && !Plugin.CanUseLobbySafety(out var _))
			{
				return false;
			}
			string text2 = MentionNamePolicy.ToMentionInsertionToken(text);
			if (string.IsNullOrWhiteSpace(text2))
			{
				return false;
			}
			string obj = input.text ?? string.Empty;
			string text3 = obj.Substring(0, atIndex);
			string text4 = obj.Substring(caret);
			string text5 = "@" + text2 + " ";
			input.text = text3 + text5 + text4;
			input.caretPosition = text3.Length + text5.Length;
			((Selectable)input).Select();
			input.ActivateInputField();
			return true;
		}

		private static bool TryFindMentionContext(TMP_InputField input, out int atIndex, out int caret, out string query)
		{
			atIndex = -1;
			caret = -1;
			query = string.Empty;
			string text = input.text ?? string.Empty;
			caret = Math.Max(0, Math.Min(input.caretPosition, text.Length));
			if (caret <= 0)
			{
				return false;
			}
			atIndex = text.LastIndexOf('@', caret - 1);
			if (atIndex < 0)
			{
				return false;
			}
			if (atIndex > 0 && !char.IsWhiteSpace(text[atIndex - 1]))
			{
				return false;
			}
			query = text.Substring(atIndex + 1, caret - atIndex - 1);
			if (!string.IsNullOrWhiteSpace(query))
			{
				return query.IndexOfAny(new char[4] { ' ', '\t', '\r', '\n' }) < 0;
			}
			return false;
		}

		private void ClearSuggestions()
		{
			_suggestions = Array.Empty<string>();
			_mentionStart = -1;
			_mentionCaret = -1;
			_mentionQuery = string.Empty;
		}

		private void EnsurePopupStyles()
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Expected O, but got Unknown
			BlueSageUiThemePalette current = BlueSageUiTheme.Current;
			if (_popupStyle == null || !string.Equals(_lastThemeKey, current.Key, StringComparison.Ordinal) || _renderedTextureGeneration != BlueSageUiTheme.RuntimeTextureGeneration || !BlueSageUiTheme.AreRuntimeTexturesAlive())
			{
				_lastThemeKey = current.Key;
				GUIStyle val = new GUIStyle(GUI.skin.box)
				{
					padding = new RectOffset(10, 10, 8, 10)
				};
				val.normal.background = BlueSageUiTheme.GetSolidTexture(current.PreviewBackground);
				val.normal.textColor = current.PreviewText;
				_popupStyle = val;
				GUIStyle val2 = new GUIStyle(GUI.skin.label)
				{
					fontSize = 12,
					fontStyle = (FontStyle)1
				};
				val2.normal.textColor = current.PopupHeaderText;
				_popupHeaderStyle = val2;
				_popupButtonStyle = BlueSageUiTheme.CreateNeutralButtonStyle(GUI.skin.button, current, 13);
				_popupButtonStyle.alignment = (TextAnchor)3;
				_renderedTextureGeneration = BlueSageUiTheme.RuntimeTextureGeneration;
			}
		}
	}
	internal static class NativeBanStoreAdapter
	{
		internal static bool TryApplyAdditions(CommunityBanAddition[] additions, out int existingCount, out string error)
		{
			existingCount = 0;
			error = string.Empty;
			DataManager i = MonoSingleton<DataManager>.I;
			BanData val = i?.BanData;
			if (val?.BanServerPlayers == null || val.BanServerPlayerNicks == null)
			{
				error = "native paired storage is unavailable";
				return false;
			}
			if (val.BanServerPlayers.Count != val.BanServerPlayerNicks.Count)
			{
				error = "native paired storage is inconsistent";
				return false;
			}
			existingCount = val.BanServerPlayers.Count;
			int num = 0;
			try
			{
				CommunityBanAddition[] array = additions ?? Array.Empty<CommunityBanAddition>();
				foreach (CommunityBanAddition communityBanAddition in array)
				{
					if (communityBanAddition == null)
					{
						throw new InvalidOperationException("validated addition was unavailable");
					}
					val.BanServerPlayers.Add(communityBanAddition.SteamId);
					val.BanServerPlayerNicks.Add(communityBanAddition.Nickname);
					num++;
				}
				if (num > 0)
				{
					i.SaveBanData();
				}
				return true;
			}
			catch (Exception ex)
			{
				string text;
				try
				{
					Rollback(val, existingCount);
					i.SaveBanData();
					text = "persisted";
				}
				catch (Exception ex2)
				{
					Rollback(val, existingCount);
					text = "memory-only-unresolved-" + ex2.GetType().Name;
				}
				error = ex.GetType().Name + "; rolledBack=" + num + "; rollback=" + text;
				return false;
			}
		}

		private static void Rollback(BanData bans, int existingCount)
		{
			while (bans.BanServerPlayers.Count > existingCount)
			{
				bans.BanServerPlayers.RemoveAt(bans.BanServerPlayers.Count - 1);
			}
			while (bans.BanServerPlayerNicks.Count > existingCount)
			{
				bans.BanServerPlayerNicks.RemoveAt(bans.BanServerPlayerNicks.Count - 1);
			}
		}
	}
	internal sealed class NativeIdCardTarget
	{
		internal PlayerPanelController Panel;

		internal PlayerItemController Row;

		internal NetworkTransform NetworkTransform;

		internal PlayerController PlayerController;

		internal PlayerIDInfo PlayerInfo;

		internal string SteamId = string.Empty;

		internal string PlayerId = string.Empty;

		internal string DisplayNameRaw = string.Empty;

		internal int PlayerIndex = -1;
	}
	internal static class NativeIdCardController
	{
		private static readonly FieldInfo PlayerSteamIdField = AccessTools.Field(typeof(PlayerItemController), "_playerSteamId");

		internal static bool TryOpen(string source, string requestedSteamId, int observedIndex, string expectedPlayerId, PlayerItemController expectedRow, NetworkTransform expectedTransform, bool requireObservedIndex, NativeIdCardCallerKind callerKind = NativeIdCardCallerKind.OrdinaryUser)
		{
			if (!TryResolveCurrentRow(source, requestedSteamId, observedIndex, expectedPlayerId, expectedRow, expectedTransform, requireObservedIndex, callerKind, out var target, out var _))
			{
				return false;
			}
			TemporaryPhoto temporaryPhoto = MonoSingleton<TemporaryPhoto>.I;
			if ((Object)(object)temporaryPhoto == (Object)null)
			{
				LogOutcome(source, NativeIdCardResolutionState.FreshEvidenceUnavailable, observedIndex, requestedSteamId, "the native ID-card controller is unavailable");
				return false;
			}
			PlayerPanelController currentPanel = NetworkSingleton<PlayerPanelController>.I;
			int playerIndex = target.PlayerIndex;
			NativeIdCardInvocationState nativeIdCardInvocationState = NativeIdCardInvocationGuard.Invoke(() => IsFinalTupleStable(target), delegate
			{
				PlayerPanelController obj = currentPanel;
				if (obj != null)
				{
					obj.ButtonClosePanel();
				}
			}, delegate
			{
				TryOpenExactPlayerCard(temporaryPhoto, target);
			});
			if (nativeIdCardInvocationState != NativeIdCardInvocationState.Opened)
			{
				LogOutcome(source, NativeIdCardResolutionState.FinalTupleChanged, observedIndex, requestedSteamId, (nativeIdCardInvocationState == NativeIdCardInvocationState.TupleChangedAfterPanelClose) ? "the exact native identity tuple changed during panel close" : "the exact native identity tuple changed before panel close");
				return false;
			}
			LogOutcome(source, NativeIdCardResolutionState.Ready, playerIndex, requestedSteamId, "native exact-controller ID card opened");
			return true;
		}

		internal static bool TryResolveCurrentRow(string source, string requestedSteamId, int observedIndex, string expectedPlayerId, PlayerItemController expectedRow, NetworkTransform expectedTransform, bool requireObservedIndex, NativeIdCardCallerKind callerKind, out NativeIdCardTarget target, out NativeIdCardResolutionDecision decision)
		{
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_0348: Unknown result type (might be due to invalid IL or missing references)
			//IL_034a: Unknown result type (might be due to invalid IL or missing references)
			//IL_034f: Unknown result type (might be due to invalid IL or missing references)
			target = null;
			PlayerPanelController i = NetworkSingleton<PlayerPanelController>.I;
			PlayerIdentityEvidence evidence;
			string error;
			bool flag = PlayerIdentityEvidenceController.TryResolveExact(requestedSteamId, out evidence, out error);
			bool flag2 = AreNativeListsAligned(i);
			int num = ((i == null) ? ((int?)null) : i.PlayerItemControllers?.IndexOf(expectedRow)) ?? (-1);
			int expectedIndex = (requireObservedIndex ? observedIndex : num);
			PlayerItemController val = ((flag2 && num >= 0 && num < i.PlayerItemControllers.Count) ? i.PlayerItemControllers[num] : null);
			string currentRowSteamId = (((Object)(object)val != (Object)null) ? ((PlayerSteamIdField?.GetValue(val) as string) ?? string.Empty) : string.Empty);
			string text;
			if (!flag2 || num < 0 || num >= i.PlayerIDs.Count)
			{
				text = string.Empty;
			}
			else
			{
				PlayerID val2 = i.PlayerIDs[num];
				text = PurrNetPlayerIdPolicy.Format(PackedULong.op_Implicit(((PlayerID)(ref val2)).id));
			}
			string text2 = text;
			string expectedPlayerId2 = (requireObservedIndex ? (expectedPlayerId ?? string.Empty) : text2);
			int num2 = (flag ? evidence.RosterIndex : (-1));
			NetworkTransform val3 = ((flag2 && num2 >= 0 && num2 < i.PlayerTransforms.Count) ? i.PlayerTransforms[num2] : null);
			PlayerController val4 = ((flag2 && num2 >= 0 && num2 < i.PlayerControllers.Count) ? i.PlayerControllers[num2] : null);
			NetworkTransform val5 = (((Object)(object)val4 != (Object)null) ? ((Component)val4).GetComponent<NetworkTransform>() : null);
			PlayerIDInfo val6 = (PlayerIDInfo)((flag2 && num2 >= 0 && num2 < i.IDInfos.Count) ? i.IDInfos[num2] : default(PlayerIDInfo));
			NativeIdCardResolutionContext context = new NativeIdCardResolutionContext
			{
				CallerKind = callerKind,
				RequestedSteamId = (requestedSteamId ?? string.Empty),
				FreshResolutionSucceeded = flag,
				FreshResolvedSteamId = (flag ? evidence.SteamId : string.Empty),
				FreshResolvedPlayerId = (flag ? evidence.NetworkPlayerId : string.Empty),
				ExpectedPlayerId = expectedPlayerId2,
				FreshResolvedIndex = num2,
				ExpectedIndex = expectedIndex,
				CurrentRowIndex = num,
				CurrentRowReferenceMatches = ((Object)(object)val != (Object)null && (Object)(object)expectedRow != (Object)null && val == expectedRow),
				CurrentRowSteamId = currentRowSteamId,
				CurrentRowPlayerId = text2,
				HasLiveNetworkTransform = ((Object)(object)val3 != (Object)null),
				NativeListsAligned = flag2,
				ExpectedNetworkTransformMatches = (!requireObservedIndex || ((Object)(object)expectedTransform != (Object)null && val3 == expectedTransform)),
				FinalTupleStable = (flag && (Object)(object)val4 != (Object)null && IsCurrentTupleStable(i, num2, requestedSteamId, evidence.NetworkPlayerId, expectedRow, val3, val4, val6) && (Object)(object)val5 != (Object)null && val5 == val3)
			};
			decision = NativeIdCardResolutionPolicy.Evaluate(context);
			if (!decision.MayOpenNativeCard)
			{
				string detail = (string.IsNullOrWhiteSpace(decision.Reason) ? error : decision.Reason);
				LogOutcome(source, decision.State, observedIndex, requestedSteamId, detail);
				return false;
			}
			target = new NativeIdCardTarget
			{
				Panel = i,
				Row = val,
				NetworkTransform = val3,
				PlayerController = val4,
				PlayerInfo = SnapshotPlayerIdInfo(val6),
				SteamId = evidence.SteamId,
				PlayerId = evidence.NetworkPlayerId,
				DisplayNameRaw = evidence.DisplayNameRaw,
				PlayerIndex = decision.PlayerIndex
			};
			return true;
		}

		private static bool AreNativeListsAligned(PlayerPanelController panel)
		{
			if ((Object)(object)panel == (Object)null || panel.PlayerSteamIDs == null || panel.PlayerIDs == null || panel.PlayerTransforms == null || panel.PlayerControllers == null || panel.IDInfos == null || panel.PlayerItemControllers == null)
			{
				return false;
			}
			if (NativeRosterShapePolicy.HasAlignedActivePrefix(panel.PlayerSteamIDs.Count, panel.PlayerIDs.Count, panel.PlayerTransforms.Count, panel.IDInfos.Count, panel.PlayerItemControllers.Count))
			{
				return panel.PlayerControllers.Count >= panel.PlayerSteamIDs.Count;
			}
			return false;
		}

		private static bool IsCurrentTupleStable(PlayerPanelController panel, int index, string steamId, string playerId, PlayerItemController row, NetworkTransform networkTransform, PlayerController playerController, PlayerIDInfo playerInfo)
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			if (!AreNativeListsAligned(panel) || index < 0 || index >= panel.PlayerSteamIDs.Count)
			{
				return false;
			}
			PlayerController val = panel.PlayerControllers[index];
			NetworkTransform val2 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<NetworkTransform>() : null);
			if ((Object)(object)playerController != (Object)null && panel.PlayerControllers[index] == playerController && (Object)(object)val2 != (Object)null && val2 == networkTransform && PlayerIdInfoMatches(panel.IDInfos[index], playerInfo) && string.Equals(panel.PlayerSteamIDs[index], steamId, StringComparison.Ordinal))
			{
				PlayerID val3 = panel.PlayerIDs[index];
				if (string.Equals(PurrNetPlayerIdPolicy.Format(PackedULong.op_Implicit(((PlayerID)(ref val3)).id)), playerId, StringComparison.Ordinal) && (Object)(object)panel.PlayerTransforms[index] != (Object)null && panel.PlayerTransforms[index] == networkTransform && (Object)(object)panel.PlayerItemControllers[index] != (Object)null && panel.PlayerItemControllers[index] == row)
				{
					return string.Equals(PlayerSteamIdField?.GetValue(panel.PlayerItemControllers[index]) as string, steamId, StringComparison.Ordinal);
				}
			}
			return false;
		}

		private static bool IsFinalTupleStable(NativeIdCardTarget target)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			if (target == null)
			{
				return false;
			}
			PlayerPanelController i = NetworkSingleton<PlayerPanelController>.I;
			if ((Object)(object)i != (Object)null && i == target.Panel)
			{
				return IsCurrentTupleStable(i, target.PlayerIndex, target.SteamId, target.PlayerId, target.Row, target.NetworkTransform, target.PlayerController, target.PlayerInfo);
			}
			return false;
		}

		private static void TryOpenExactPlayerCard(TemporaryPhoto temporaryPhoto, NativeIdCardTarget target)
		{
			temporaryPhoto.CapturePhoto(target.PlayerController);
		}

		private static PlayerIDInfo SnapshotPlayerIdInfo(PlayerIDInfo source)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			return new PlayerIDInfo
			{
				Name = CloneBytes(source.Name),
				DateOfBirth = CloneBytes(source.DateOfBirth),
				HoroscopeSign = CloneBytes(source.HoroscopeSign),
				Location = CloneBytes(source.Location),
				AreaOfStudy = CloneBytes(source.AreaOfStudy),
				FavoriteQuote = CloneBytes(source.FavoriteQuote),
				IDCardColorIndex = source.IDCardColorIndex,
				IsGold = source.IsGold
			};
		}

		private static bool PlayerIdInfoMatches(PlayerIDInfo current, PlayerIDInfo expected)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			if (ByteArraysEqual(current.Name, expected.Name) && ByteArraysEqual(current.DateOfBirth, expected.DateOfBirth) && ByteArraysEqual(current.HoroscopeSign, expected.HoroscopeSign) && ByteArraysEqual(current.Location, expected.Location) && ByteArraysEqual(current.AreaOfStudy, expected.AreaOfStudy) && ByteArraysEqual(current.FavoriteQuote, expected.FavoriteQuote) && current.IDCardColorIndex == expected.IDCardColorIndex)
			{
				return current.IsGold == expected.IsGold;
			}
			return false;
		}

		private static byte[] CloneBytes(byte[] source)
		{
			if (source != null)
			{
				return (byte[])source.Clone();
			}
			return null;
		}

		private static bool ByteArraysEqual(byte[] left, byte[] right)
		{
			if (left == right)
			{
				return true;
			}
			if (left == null || right == null || left.Length != right.Length)
			{
				return false;
			}
			for (int i = 0; i < left.Length; i++)
			{
				if (left[i] != right[i])
				{
					return false;
				}
			}
			return true;
		}

		private static void LogOutcome(string source, NativeIdCardResolutionState state, int index, string steamId, string detail)
		{
			string text = (string.IsNullOrWhiteSpace(source) ? "unknown" : source.Replace("\r", string.Empty).Replace("\n", string.Empty));
			if (text.Length > 32)
			{
				text = text.Substring(0, 32);
			}
			string text2 = (string.IsNullOrWhiteSpace(detail) ? "none" : detail.Replace("\r", " ").Replace("\n", " "));
			if (text2.Length > 160)
			{
				text2 = text2.Substring(0, 159) + "…";
			}
			string text3 = "[BlueSageNativeId] source=" + text + "; outcome=" + state.ToString() + "; index=" + index + "; steamIdPresent=" + !string.IsNullOrWhiteSpace(steamId) + "; detail=" + text2 + ".";
			if (state == NativeIdCardResolutionState.Ready)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)text3);
				}
			}
			else
			{
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogWarning((object)text3);
				}
			}
		}
	}
	internal sealed class PerformanceOverlayController : MonoBehaviour
	{
		private const float OverlayHeight = 28f;

		private readonly PerformanceOverlayState _state = new PerformanceOverlayState();

		private string _label = "FPS --  PING --  RAM --";

		private float _nextRefreshAt;

		private Rect _rect;

		private bool _dragging;

		private Vector2 _dragOffset;

		private GUIStyle _style;

		private Texture2D _background;

		private void Update()
		{
			_state.SampleFrame(Time.unscaledDeltaTime);
			ConfigEntry<bool> enablePerformanceOverlay = Plugin.EnablePerformanceOverlay;
			if (enablePerformanceOverlay != null && enablePerformanceOverlay.Value && !(Time.unscaledTime < _nextRefreshAt))
			{
				PerformanceOverlaySettings performanceOverlaySettings = ReadSettings();
				_label = _state.BuildLabel(ReadActiveSessionPing(), ProcessRuntimeMetricsCapture.ReadWorkingSetBytes());
				_nextRefreshAt = Time.unscaledTime + (float)performanceOverlaySettings.RefreshSeconds;
			}
		}

		private void OnGUI()
		{
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			ConfigEntry<bool> enablePerformanceOverlay = Plugin.EnablePerformanceOverlay;
			if (enablePerformanceOverlay == null || !enablePerformanceOverlay.Value)
			{
				return;
			}
			PerformanceOverlaySettings performanceOverlaySettings = ReadSettings();
			EnsureStyle(performanceOverlaySettings.FontSize);
			if (!_dragging)
			{
				_rect = new Rect((float)performanceOverlaySettings.OffsetX, (float)performanceOverlaySettings.OffsetY, (float)performanceOverlaySettings.Width, 28f);
			}
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(((Rect)(ref _rect)).x, ((Rect)(ref _rect)).y, Mathf.Max(1f, ((Rect)(ref _rect)).width - 24f), ((Rect)(ref _rect)).height);
			Rect val2 = new Rect(((Rect)(ref _rect)).xMax - 24f, ((Rect)(ref _rect)).y, 24f, ((Rect)(ref _rect)).height);
			HandleDrag(performanceOverlaySettings, val);
			GUI.Label(val, _label, _style);
			if (GUI.Button(val2, "×"))
			{
				Plugin.EnablePerformanceOverlay.Value = false;
				Plugin.Instance?.SaveConfigFromQolMenu();
				_dragging = false;
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)"Public QoL performance overlay hidden from its in-bar shortcut; reopen it from QoL Menu > Toggles > Personalization.");
				}
			}
		}

		private static int? ReadActiveSessionPing()
		{
			try
			{
				NetworkManager main = NetworkManager.main;
				TickManager val = default(TickManager);
				if ((Object)(object)main == (Object)null || !main.TryGetModule<TickManager>(false, ref val) || val == null)
				{
					return null;
				}
				return TickManagerPingPolicy.FromRttSeconds(val.rtt);
			}
			catch
			{
				return null;
			}
		}

		private static PerformanceOverlaySettings ReadSettings()
		{
			return PerformanceOverlaySettingsPolicy.Normalize(Plugin.PerformanceOverlayRefreshSeconds?.Value ?? 0.25f, Plugin.PerformanceOverlayFontSize?.Value ?? 13, Plugin.PerformanceOverlayOffsetX?.Value ?? 12f, Plugin.PerformanceOverlayOffsetY?.Value ?? 174f, Plugin.PerformanceOverlayWidth?.Value ?? 320f);
		}

		private void EnsureStyle(int fontSize)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Expected O, but got Unknown
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Expected O, but got Unknown
			if (_style == null)
			{
				_background = new Texture2D(1, 1);
				((Object)_background).name = "BlueSagePublicPerformanceOverlayBackground";
				((Object)_background).hideFlags = (HideFlags)61;
				_background.SetPixel(0, 0, new Color(0.025f, 0.055f, 0.075f, 0.82f));
				_background.Apply(false, true);
				GUIStyle val = new GUIStyle(GUI.skin.label)
				{
					alignment = (TextAnchor)4,
					fontStyle = (FontStyle)1,
					wordWrap = false,
					clipping = (TextClipping)1
				};
				val.normal.background = _background;
				val.normal.textColor = new Color(0.72f, 0.92f, 0.94f, 1f);
				_style = val;
				_style.padding = new RectOffset(6, 6, 2, 2);
			}
			_style.fontSize = fontSize;
		}

		private void HandleDrag(PerformanceOverlaySettings settings, Rect dragRect)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Invalid comparison between Unknown and I4
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			Event current = Event.current;
			if (current != null)
			{
				if ((int)current.type == 0 && current.button == 0 && ((Rect)(ref dragRect)).Contains(current.mousePosition))
				{
					_dragging = true;
					_dragOffset = current.mousePosition - ((Rect)(ref _rect)).position;
					current.Use();
				}
				else if ((int)current.type == 3 && current.button == 0 && _dragging)
				{
					MoveTo(current.mousePosition - _dragOffset, settings);
					current.Use();
				}
				else if ((int)current.type == 1 && current.button == 0 && _dragging)
				{
					MoveTo(((Rect)(ref _rect)).position, settings);
					Plugin.PerformanceOverlayOffsetX.Value = ((Rect)(ref _rect)).x;
					Plugin.PerformanceOverlayOffsetY.Value = ((Rect)(ref _rect)).y;
					Plugin.Instance?.SaveConfigFromQolMenu();
					_dragging = false;
					current.Use();
				}
			}
		}

		private void MoveTo(Vector2 requested, PerformanceOverlaySettings settings)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			PerformanceOverlayPosition performanceOverlayPosition = PerformanceOverlayPositionPolicy.ClampToScreen(requested.x, requested.y, settings.Width, 28.0, Screen.width, Screen.height);
			((Rect)(ref _rect)).position = new Vector2((float)performanceOverlayPosition.OffsetX, (float)performanceOverlayPosition.OffsetY);
		}

		private void OnDestroy()
		{
			if ((Object)(object)_background != (Object)null)
			{
				Object.Destroy((Object)(object)_background);
				_background = null;
			}
		}
	}
	internal sealed class PlayerIdentityEvidence
	{
		internal string SteamId = string.Empty;

		internal string DisplayName = string.Empty;

		internal string DisplayNameRaw = string.Empty;

		internal string SteamPersona = string.Empty;

		internal string Role = "PLAYER";

		internal int RosterIndex = -1;

		internal string NetworkPlayerId = string.Empty;

		internal ulong PurrNetId;

		internal int TransformInstanceId;

		internal bool IsLocal;
	}
	internal static class PlayerIdentityEvidenceController
	{
		private sealed class SnapshotRoleContext
		{
			internal string LocalSteamId = string.Empty;

			internal string OwnerSteamId = string.Empty;

			internal string[] HelperSteamIds = Array.Empty<string>();

			internal readonly Dictionary<string, string> RoleBySteamId = new Dictionary<string, string>(StringComparer.Ordinal);
		}

		private sealed class RosterSnapshot
		{
			internal PlayerIdentityEvidence[] Verified = Array.Empty<PlayerIdentityEvidence>();

			internal string Error = string.Empty;

			internal string CoverageIssue = string.Empty;

			internal bool CoverageComplete;

			internal int NativeRowCount;

			internal int PurrNetRowCount;

			internal int LobbyMemberCount;

			internal int LiveSteamCheckCount;

			internal int LeftStaleCount;

			internal int AmbiguousCount;

			internal ulong LobbyId;

			internal ulong LocalSteamId;

			internal ulong LobbyOwnerSteamId;

			internal string[] NativeSteamIds = Array.Empty<string>();

			internal string[] NativePlayerIds = Array.Empty<string>();

			internal string[] NativePurrNetIds = Array.Empty<string>();

			internal bool[] HasLiveTransform = Array.Empty<bool>();

			internal int[] TransformInstanceIds = Array.Empty<int>();

			internal string[] LobbyMemberSteamIds = Array.Empty<string>();

			internal string[] PublishedHelperSteamIds = Array.Empty<string>();

			internal long CapturedUtcTicks;

			internal long CaptureStartedTimestamp;

			internal int CapturedFrame;
		}

		private static readonly FieldInfo PlayerSteamIdField = AccessTools.Field(typeof(PlayerItemController), "_playerSteamId");

		private static readonly long SnapshotLifetimeTicks = TimeSpan.FromSeconds(1.0).Ticks;

		private static RosterSnapshot _cachedSnapshot;

		private static bool _snapshotDirty = true;

		private static long _snapshotCaptureCount;

		private static double _lastSnapshotCaptureMilliseconds;

		private static double _maxSnapshotCaptureMilliseconds;

		private static string _lastCoverageTransitionKey = string.Empty;

		internal static void InvalidateRosterCache()
		{
			_snapshotDirty = true;
		}

		internal static bool TryResolveExact(string steamId, out PlayerIdentityEvidence evidence, out string error)
		{
			RosterSnapshot rosterSnapshot = CaptureRosterSnapshot(cacheAllowed: false);
			error = rosterSnapshot.Error;
			evidence = rosterSnapshot.Verified.SingleOrDefault((PlayerIdentityEvidence candidate) => string.Equals(candidate.SteamId, steamId, StringComparison.Ordinal));
			if (evidence != null)
			{
				return true;
			}
			error = DescribeUnresolvedExactRow(steamId, rosterSnapshot);
			return false;
		}

		internal static bool TryResolveExactWithAuthorityFingerprint(string steamId, ulong expectedLobbyId, out PlayerIdentityEvidence evidence, out string fingerprint, out bool contextValid, out string error)
		{
			fingerprint = string.Empty;
			RosterSnapshot rosterSnapshot = CaptureRosterSnapshot(cacheAllowed: true);
			contextValid = TryBuildAuthorityFingerprint(rosterSnapshot, expectedLobbyId, out fingerprint);
			error = rosterSnapshot.Error;
			if (!contextValid && string.IsNullOrWhiteSpace(error))
			{
				error = ((!string.IsNullOrWhiteSpace(rosterSnapshot.CoverageIssue)) ? rosterSnapshot.CoverageIssue : "the bounded current roster snapshot is incomplete");
			}
			evidence = (contextValid ? rosterSnapshot.Verified.SingleOrDefault((PlayerIdentityEvidence candidate) => string.Equals(candidate.SteamId, steamId, StringComparison.Ordinal)) : null);
			if (evidence != null)
			{
				return true;
			}
			if (contextValid)
			{
				error = DescribeUnresolvedExactRow(steamId, rosterSnapshot);
			}
			return false;
		}

		internal static bool TryResolveExactWithCompanionFingerprint(string steamId, ulong expectedLobbyId, out PlayerIdentityEvidence evidence, out string fingerprint, out bool contextValid, out string error)
		{
			fingerprint = string.Empty;
			string reason = string.Empty;
			RosterSnapshot rosterSnapshot = CaptureRosterSnapshot(cacheAllowed: true);
			contextValid = rosterSnapshot != null && string.IsNullOrWhiteSpace(rosterSnapshot.Error) && rosterSnapshot.LobbyId == expectedLobbyId && CompanionExactIdentityFingerprintPolicy.TryBuildFingerprint(rosterSnapshot.LobbyId, rosterSnapshot.LobbyOwnerSteamId, rosterSnapshot.LocalSteamId, rosterSnapshot.LobbyMemberSteamIds, rosterSnapshot.PublishedHelperSteamIds, rosterSnapshot.Verified.Select((PlayerIdentityEvidence candidate) => candidate.SteamId).ToArray(), rosterSnapshot.Verified.Select((PlayerIdentityEvidence candidate) => candidate.PurrNetId).ToArray(), rosterSnapshot.Verified.Select((PlayerIdentityEvidence candidate) => candidate.TransformInstanceId).ToArray(), out fingerprint, out reason);
			error = rosterSnapshot?.Error ?? "the bounded current roster snapshot is unavailable";
			evidence = (contextValid ? rosterSnapshot.Verified.SingleOrDefault((PlayerIdentityEvidence candidate) => string.Equals(candidate.SteamId, steamId, StringComparison.Ordinal)) : null);
			if (evidence != null)
			{
				return true;
			}
			if (contextValid)
			{
				error = DescribeUnresolvedExactRow(steamId, rosterSnapshot);
			}
			else if (string.IsNullOrWhiteSpace(error))
			{
				error = (string.IsNullOrWhiteSpace(reason) ? "the bounded exact-row companion identity context is invalid" : reason);
			}
			return false;
		}

		internal static bool TryCaptureAuthorityEvidenceFingerprint(ulong expectedLobbyId, out string fingerprint)
		{
			return TryBuildAuthorityFingerprint(CaptureRosterSnapshot(cacheAllowed: false), expectedLobbyId, out fingerprint);
		}

		internal static bool TryCaptureAuthorityEvidenceFingerprintCached(ulong expectedLobbyId, out string fingerprint)
		{
			return TryBuildAuthorityFingerprint(CaptureRosterSnapshot(cacheAllowed: true), expectedLobbyId, out fingerprint);
		}

		internal static bool TryCaptureCompleteAuthorityEvidenceAndRowsCached(ulong expectedLobbyId, out string fingerprint, out HashSet<PlayerItemController> currentRows)
		{
			fingerprint = string.Empty;
			currentRows = new HashSet<PlayerItemController>();
			RosterSnapshot rosterSnapshot = CaptureRosterSnapshot(cacheAllowed: true);
			if (rosterSnapshot == null || !rosterSnapshot.CoverageComplete || !TryBuildAuthorityFingerprint(rosterSnapshot, expectedLobbyId, out fingerprint))
			{
				return false;
			}
			return TryCaptureAlignedCurrentRows(rosterSnapshot, out currentRows);
		}

		private static bool TryCaptureAlignedCurrentRows(RosterSnapshot snapshot, out HashSet<PlayerItemController> currentRows)
		{
			currentRows = new HashSet<PlayerItemController>();
			PlayerPanelController i = NetworkSingleton<PlayerPanelController>.I;
			if (snapshot == null || (Object)(object)i == (Object)null || i.PlayerSteamIDs == null || i.PlayerIDs == null || i.PlayerTransforms == null || i.IDInfos == null || i.PlayerItemControllers == null || !NativeRosterShapePolicy.HasAlignedActivePrefix(i.PlayerSteamIDs.Count, i.PlayerIDs.Count, i.PlayerTransforms.Count, i.IDInfos.Count, i.PlayerItemControllers.Count) || snapshot.Verified == null || snapshot.Verified.Length == 0 || snapshot.Verified.Length != snapshot.LobbyMemberCount || !PanelAuthorityTupleMatchesSnapshot(i, snapshot))
			{
				return false;
			}
			Dictionary<int, PlayerItemController> dictionary = new Dictionary<int, PlayerItemController>();
			PlayerIdentityEvidence[] verified = snapshot.Verified;
			foreach (PlayerIdentityEvidence playerIdentityEvidence in verified)
			{
				int num = playerIdentityEvidence?.RosterIndex ?? (-1);
				if (num < 0 || num >= i.PlayerItemControllers.Count)
				{
					return false;
				}
				PlayerItemController val = i.PlayerItemControllers[num];
				if ((Object)(object)val == (Object)null || (Object)(object)((Component)val).gameObject == (Object)null || !string.Equals(PlayerSteamIdField?.GetValue(val) as string, playerIdentityEvidence.SteamId, StringComparison.Ordinal) || !currentRows.Add(val))
				{
					return false;
				}
				dictionary[num] = val;
			}
			if (currentRows.Count != snapshot.Verified.Length || NetworkSingleton<PlayerPanelController>.I != i || !PanelAuthorityTupleMatchesSnapshot(i, snapshot))
			{
				currentRows.Clear();
				return false;
			}
			foreach (KeyValuePair<int, PlayerItemController> item in dictionary)
			{
				if (item.Key < 0 || item.Key >= i.PlayerItemControllers.Count || i.PlayerItemControllers[item.Key] != item.Value || !string.Equals(PlayerSteamIdField?.GetValue(item.Value) as string, snapshot.NativeSteamIds[item.Key], StringComparison.Ordinal))
				{
					currentRows.Clear();
					return false;
				}
			}
			return true;
		}

		private static bool PanelAuthorityTupleMatchesSnapshot(PlayerPanelController panel, RosterSnapshot snapshot)
		{
			if ((Object)(object)panel != (Object)null && snapshot != null && panel.PlayerSteamIDs != null && panel.PlayerIDs != null && panel.PlayerTransforms != null && panel.IDInfos != null && panel.PlayerItemControllers != null && NativeRosterShapePolicy.HasAlignedActivePrefix(panel.PlayerSteamIDs.Count, panel.PlayerIDs.Count, panel.PlayerTransforms.Count, panel.IDInfos.Count, panel.PlayerItemControllers.Count) && panel.PlayerSteamIDs.SequenceEqual(snapshot.NativeSteamIds) && panel.PlayerIDs.Select((PlayerID id) => PackedULong.op_Implicit(((PlayerID)(ref id)).id).ToString(CultureInfo.InvariantCulture)).SequenceEqual(snapshot.NativePurrNetIds))
			{
				return panel.PlayerTransforms.Select((NetworkTransform transform) => (!((Object)(object)transform == (Object)null)) ? ((Object)transform).GetInstanceID() : 0).SequenceEqual(snapshot.TransformInstanceIds);
			}
			return false;
		}

		internal static bool TryResolveExactCached(string steamId, out PlayerIdentityEvidence evidence, out string error)
		{
			RosterSnapshot rosterSnapshot = CaptureRosterSnapshot(cacheAllowed: true);
			error = rosterSnapshot.Error;
			evidence = rosterSnapshot.Verified.SingleOrDefault((PlayerIdentityEvidence candidate) => string.Equals(candidate.SteamId, steamId, StringComparison.Ordinal));
			if (evidence != null)
			{
				return true;
			}
			error = DescribeUnresolvedExactRow(steamId, rosterSnapshot);
			return false;
		}

		internal static bool TryResolveRosterIndex(int senderIndex, out PlayerIdentityEvidence evidence, out string error)
		{
			return TryResolveRosterIndex(CaptureRosterSnapshot(cacheAllowed: true), senderIndex, out evidence, out error);
		}

		internal static bool TryResolveRosterIndexFresh(int senderIndex, out PlayerIdentityEvidence evidence, out string error)
		{
			return TryResolveRosterIndex(CaptureRosterSnapshot(cacheAllowed: false), senderIndex, out evidence, out error);
		}

		private static bool TryResolveRosterIndex(RosterSnapshot snapshot, int senderIndex, out PlayerIdentityEvidence evidence, out string error)
		{
			error = snapshot.Error;
			evidence = snapshot.Verified.SingleOrDefault((PlayerIdentityEvidence candidate) => candidate.RosterIndex == senderIndex);
			if (evidence != null)
			{
				return true;
			}
			if (string.IsNullOrWhiteSpace(error))
			{
				error = "the sender index is not a verified current player row";
			}
			return false;
		}

		internal static bool TryResolveLookup(string query, out PlayerIdentityEvidence evidence, out string error)
		{
			evidence = null;
			IReadOnlyList<PlayerIdentityEvidence> readOnlyList = ResolveLookupMatches(query, out error);
			if (readOnlyList.Count == 1)
			{
				evidence = readOnlyList[0];
				error = string.Empty;
				return true;
			}
			if (readOnlyList.Count > 1)
			{
				error = "That query matches " + readOnlyList.Count + " verified current players. Select the exact row or use more name/SteamID detail.";
			}
			return false;
		}

		internal static IReadOnlyList<PlayerIdentityEvidence> ResolveLookupMatches(string query, out string error)
		{
			if (!Plugin.CanUseLobbySafety(out var _))
			{
				error = "Lobby Safety is available only to the current host or a Helper assigned by that host. No player or incident details were shown.";
				return Array.Empty<PlayerIdentityEvidence>();
			}
			string clean = (query ?? string.Empty).Trim();
			RosterSnapshot rosterSnapshot = CaptureRosterSnapshot(cacheAllowed: false);
			IReadOnlyList<PlayerIdentityEvidence> verified = rosterSnapshot.Verified;
			string error2 = rosterSnapshot.Error;
			if (!string.IsNullOrWhiteSpace(error2) && verified.Count == 0)
			{
				error = error2;
				return Array.Empty<PlayerIdentityEvidence>();
			}
			if (CloneIncidentLedger.TryResolveIncident(clean, out CloneIncident incident))
			{
				PlayerIdentityEvidence playerIdentityEvidence = verified.SingleOrDefault((PlayerIdentityEvidence item) => string.Equals(item.SteamId, incident.SuspectSteamId, StringComparison.Ordinal));
				error = ((playerIdentityEvidence != null) ? string.Empty : ((!string.IsNullOrWhiteSpace(error2)) ? error2 : "The incident suspect is no longer a verified current player."));
				if (playerIdentityEvidence != null)
				{
					return new PlayerIdentityEvidence[1] { playerIdentityEvidence };
				}
				return Array.Empty<PlayerIdentityEvidence>();
			}
			if (ModerationProtocolPolicy.IsSteamId64(clean))
			{
				PlayerIdentityEvidence playerIdentityEvidence2 = verified.SingleOrDefault((PlayerIdentityEvidence item) => string.Equals(item.SteamId, clean, StringComparison.Ordinal));
				error = ((playerIdentityEvidence2 != null) ? string.Empty : ((!string.IsNullOrWhiteSpace(error2)) ? error2 : "That exact SteamID64 is not a verified current player."));
				if (playerIdentityEvidence2 != null)
				{
					return new PlayerIdentityEvidence[1] { playerIdentityEvidence2 };
				}
				return Array.Empty<PlayerIdentityEvidence>();
			}
			PlayerLookupCandidate[] candidates = verified.Select((PlayerIdentityEvidence item) => new PlayerLookupCandidate
			{
				SteamId = item.SteamId,
				DisplayNameRaw = item.DisplayNameRaw,
				DisplayNamePlain = item.DisplayName,
				SteamPersona = item.SteamPersona,
				Role = item.Role,
				IsLocal = item.IsLocal
			}).ToArray();
			IReadOnlyList<PlayerLookupCandidate> source = PlayerLookupPolicy.FindMatches(clean, candidates, out error);
			HashSet<string> ids = new HashSet<string>(source.Select((PlayerLookupCandidate item) => item.SteamId), StringComparer.Ordinal);
			PlayerIdentityEvidence[] array = verified.Where((PlayerIdentityEvidence item) => ids.Contains(item.SteamId)).ToArray();
			if (array.Length == 0 && !string.IsNullOrWhiteSpace(error2))
			{
				error = error2 + " Verified rows remain usable, but Clone Shield and absence-sensitive actions wait for complete coverage.";
			}
			return array;
		}

		internal static IReadOnlyList<PlayerIdentityEvidence> FilterVerifiedRoster(IReadOnlyList<PlayerIdentityEvidence> roster, string query, out string error)
		{
			if (string.IsNullOrWhiteSpace(query))
			{
				error = string.Empty;
				return roster ?? Array.Empty<PlayerIdentityEvidence>();
			}
			PlayerLookupCandidate[] candidates = (roster ?? Array.Empty<PlayerIdentityEvidence>()).Select((PlayerIdentityEvidence item) => new PlayerLookupCandidate
			{
				SteamId = item.SteamId,
				DisplayNameRaw = item.DisplayNameRaw,
				DisplayNamePlain = item.DisplayName,
				SteamPersona = item.SteamPersona,
				Role = item.Role,
				IsLocal = item.IsLocal
			}).ToArray();
			IReadOnlyList<PlayerLookupCandidate> source = PlayerLookupPolicy.FindMatches(query, candidates, out error);
			HashSet<string> ids = new HashSet<string>(source.Select((PlayerLookupCandidate item) => item.SteamId), StringComparer.Ordinal);
			return (roster ?? Array.Empty<PlayerIdentityEvidence>()).Where((PlayerIdentityEvidence item) => ids.Contains(item.SteamId)).ToArray();
		}

		internal static IReadOnlyList<PlayerIdentityEvidence> GetVerifiedRoster()
		{
			if (!Plugin.CanUseLobbySafety(out var _))
			{
				return Array.Empty<PlayerIdentityEvidence>();
			}
			return CaptureRosterSnapshot(cacheAllowed: true).Verified;
		}

		internal static IReadOnlyList<PlayerIdentityEvidence> GetVerifiedRoster(out string status)
		{
			if (!Plugin.CanUseLobbySafety(out var _))
			{
				status = "Lobby Safety is available only to the current host or a Helper assigned by that host. No player or incident details were shown.";
				return Array.Empty<PlayerIdentityEvidence>();
			}
			RosterSnapshot rosterSnapshot = CaptureRosterSnapshot(cacheAllowed: true);
			IReadOnlyList<PlayerIdentityEvidence> verified = rosterSnapshot.Verified;
			string error = rosterSnapshot.Error;
			string coverageIssue = rosterSnapshot.CoverageIssue;
			int nativeRowCount = rosterSnapshot.NativeRowCount;
			int lobbyMemberCount = rosterSnapshot.LobbyMemberCount;
			int num = Math.Max(0, nativeRowCount - verified.Count);
			if (!string.IsNullOrWhiteSpace(error) && verified.Count == 0)
			{
				status = "Verification paused: " + error + ". No hidden or guessed row is actionable.";
				return verified;
			}
			status = verified.Count + " active verified • " + nativeRowCount + " player-list rows • " + lobbyMemberCount + " Steam lobby members • " + num + " non-actionable.";
			if (rosterSnapshot.LeftStaleCount > 0)
			{
				status = status + " " + rosterSnapshot.LeftStaleCount + " left/stale history " + ((rosterSnapshot.LeftStaleCount == 1) ? "row is" : "rows are") + " locked.";
			}
			if (rosterSnapshot.AmbiguousCount > 0)
			{
				status = status + " " + rosterSnapshot.AmbiguousCount + " ambiguous/syncing " + ((rosterSnapshot.AmbiguousCount == 1) ? "row is" : "rows are") + " locked.";
			}
			if (!string.IsNullOrWhiteSpace(coverageIssue))
			{
				status = status + " " + coverageIssue + " Exact verified rows remain usable; Clone Shield and absence-sensitive actions wait for complete coverage.";
			}
			else if (!string.IsNullOrWhiteSpace(error))
			{
				status = status + " " + error;
			}
			status += " Mod installation is not part of identity verification.";
			return verified;
		}

		internal static string GetDiagnosticRosterSummary()
		{
			return FormatDiagnosticRosterSummary(CaptureRosterSnapshot(cacheAllowed: true));
		}

		internal static IdentityResyncCoverage GetCachedIdentityResyncCoverage()
		{
			RosterSnapshot cachedSnapshot = _cachedSnapshot;
			if (cachedSnapshot == null)
			{
				return IdentityResyncCoverage.Unavailable("no authoritative identity snapshot is available yet");
			}
			long num = DateTime.UtcNow.Ticks - cachedSnapshot.CapturedUtcTicks;
			string text = cachedSnapshot.Error;
			if ((_snapshotDirty || num < 0 || num > SnapshotLifetimeTicks) && string.IsNullOrWhiteSpace(text))
			{
				text = "the cached identity snapshot is stale; status remains fail-closed";
			}
			return new IdentityResyncCoverage(cachedSnapshot.Verified.Length, cachedSnapshot.NativeRowCount, cachedSnapshot.PurrNetRowCount, cachedSnapshot.LobbyMemberCount, cachedSnapshot.LiveSteamCheckCount, cachedSnapshot.LeftStaleCount, cachedSnapshot.AmbiguousCount, captureAvailable: true, text);
		}

		internal static IReadOnlyList<string> GetCachedIdentityResyncSurfaceTargets()
		{
			RosterSnapshot cachedSnapshot = _cachedSnapshot;
			if (cachedSnapshot == null)
			{
				return Array.Empty<string>();
			}
			return cachedSnapshot.NativeSteamIds.Where(ModerationProtocolPolicy.IsSteamId64).Distinct<string>(StringComparer.Ordinal).ToArray();
		}

		internal static HashSet<string> GetVerifiedCurrentSteamIdSetAlreadyCached()
		{
			return new HashSet<string>(_cachedSnapshot?.Verified.Select((PlayerIdentityEvidence item) => item.SteamId) ?? Enumerable.Empty<string>(), StringComparer.Ordinal);
		}

		internal static void ForceRefreshIncompleteRosterRowsOnce(out string before, out string after, out bool coverageComplete, out IReadOnlyList<string> targetedSteamIds, out int healedRowCount, out bool capturePerformed)
		{
			RosterSnapshot cachedSnapshot = _cachedSnapshot;
			if (cachedSnapshot == null)
			{
				before = "not-yet-captured";
				RosterSnapshot rosterSnapshot = CaptureRosterSnapshot(cacheAllowed: false);
				targetedSteamIds = PlayerIdentityEvidencePolicy.SelectManualResyncTargets(rosterSnapshot.NativeSteamIds, rosterSnapshot.LobbyMemberSteamIds, rosterSnapshot.Verified.Select((PlayerIdentityEvidence item) => item.SteamId).ToArray());
				after = FormatDiagnosticRosterSummary(rosterSnapshot);
				coverageComplete = rosterSnapshot.CoverageComplete;
				healedRowCount = 0;
				capturePerformed = true;
				return;
			}
			before = FormatDiagnosticRosterSummary(cachedSnapshot);
			IReadOnlyList<string> readOnlyList = PlayerIdentityEvidencePolicy.SelectManualResyncTargets(cachedSnapshot.NativeSteamIds, cachedSnapshot.LobbyMemberSteamIds, cachedSnapshot.Verified.Select((PlayerIdentityEvidence item) => item.SteamId).ToArray());
			long ticks = DateTime.UtcNow.Ticks;
			bool flag = ((ticks >= cachedSnapshot.CapturedUtcTicks) ? (ticks - cachedSnapshot.CapturedUtcTicks) : (SnapshotLifetimeTicks + 1)) > SnapshotLifetimeTicks;
			bool flag2 = _snapshotDirty || flag || !cachedSnapshot.CoverageComplete || !string.IsNullOrWhiteSpace(cachedSnapshot.Error);
			if (readOnlyList.Count == 0 && !flag2)
			{
				targetedSteamIds = readOnlyList;
				after = before;
				coverageComplete = cachedSnapshot.CoverageComplete;
				healedRowCount = 0;
				capturePerformed = false;
				return;
			}
			InvalidateRosterCache();
			RosterSnapshot rosterSnapshot2 = CaptureRosterSnapshot(cacheAllowed: false);
			after = FormatDiagnosticRosterSummary(rosterSnapshot2);
			coverageComplete = rosterSnapshot2.CoverageComplete;
			HashSet<string> hashSet = new HashSet<string>(rosterSnapshot2.Verified.Select((PlayerIdentityEvidence item) => item.SteamId), StringComparer.Ordinal);
			IReadOnlyList<string> second = PlayerIdentityEvidencePolicy.SelectManualResyncTargets(rosterSnapshot2.NativeSteamIds, rosterSnapshot2.LobbyMemberSteamIds, rosterSnapshot2.Verified.Select((PlayerIdentityEvidence item) => item.SteamId).ToArray());
			targetedSteamIds = readOnlyList.Concat(second).Distinct<string>(StringComparer.Ordinal).ToArray();
			healedRowCount = readOnlyList.Count(hashSet.Contains);
			capturePerformed = true;
		}

		private static string FormatDiagnosticRosterSummary(RosterSnapshot snapshot)
		{
			IReadOnlyList<PlayerIdentityEvidence> verified = snapshot.Verified;
			int nativeRowCount = snapshot.NativeRowCount;
			int lobbyMemberCount = snapshot.LobbyMemberCount;
			int num = Math.Max(0, nativeRowCount - verified.Count);
			return "verified=" + verified.Count + ",native=" + nativeRowCount + ",steam=" + lobbyMemberCount + ",excluded=" + num + ",liveSteamCheck=" + snapshot.LiveSteamCheckCount + ",leftStale=" + snapshot.LeftStaleCount + ",ambiguous=" + snapshot.AmbiguousCount + ",complete=" + snapshot.CoverageComplete + ",snapshotCaptures=" + _snapshotCaptureCount + ",snapshotLastMs=" + _lastSnapshotCaptureMilliseconds.ToString("0.0") + ",snapshotMaxMs=" + _maxSnapshotCaptureMilliseconds.ToString("0.0") + ",error=" + DiagnosticValue(snapshot.Error) + ",coverageIssue=" + DiagnosticValue(snapshot.CoverageIssue);
		}

		private static string DiagnosticValue(string value)
		{
			if (!string.IsNullOrWhiteSpace(value))
			{
				return value.Replace(",", ";").Replace("\r", " ").Replace("\n", " ")
					.Trim();
			}
			return "none";
		}

		internal static IReadOnlyList<string> GetVerifiedCurrentSteamIds(out string error)
		{
			bool coverageComplete;
			return GetVerifiedCurrentSteamIds(out error, out coverageComplete);
		}

		internal static IReadOnlyList<string> GetVerifiedCurrentSteamIds(out string error, out bool coverageComplete)
		{
			RosterSnapshot rosterSnapshot = CaptureRosterSnapshot(cacheAllowed: true);
			coverageComplete = rosterSnapshot.CoverageComplete;
			error = ((!string.IsNullOrWhiteSpace(rosterSnapshot.Error)) ? rosterSnapshot.Error : rosterSnapshot.CoverageIssue);
			return rosterSnapshot.Verified.Select((PlayerIdentityEvidence item) => item.SteamId).Distinct<string>(StringComparer.Ordinal).ToArray();
		}

		internal static HashSet<string> GetVerifiedCurrentSteamIdSetCached()
		{
			return new HashSet<string>(CaptureRosterSnapshot(cacheAllowed: true).Verified.Select((PlayerIdentityEvidence item) => item.SteamId), StringComparer.Ordinal);
		}

		internal static IReadOnlyList<string> GetLookupSuggestions()
		{
			if (!Plugin.CanUseLobbySafety(out var _))
			{
				return Array.Empty<string>();
			}
			List<string> list = new List<string> { "list" };
			list.AddRange(from item in CloneIncidentLedger.Snapshot.Reverse().Take(12)
				select item.Id);
			string error;
			string[] source = GetVerifiedCurrentSteamIds(out error).Distinct<string>(StringComparer.Ordinal).ToArray();
			foreach (string item in source.Take(64))
			{
				string suffix = Suffix(item);
				list.Add((source.Count((string other) => other.EndsWith(suffix, StringComparison.Ordinal)) == 1) ? suffix : item);
			}
			return list.Distinct<string>(StringComparer.OrdinalIgnoreCase).ToArray();
		}

		internal static string Suffix(string steamId)
		{
			string text;
			if (steamId == null || steamId.Length <= 6)
			{
				text = steamId;
				if (text == null)
				{
					return "unknown";
				}
			}
			else
			{
				text = steamId.Substring(steamId.Length - 6);
			}
			return text;
		}

		internal static string BuildCopyableEvidence(PlayerIdentityEvidence evidence)
		{
			if (evidence == null)
			{
				return string.Empty;
			}
			return "BlueSage verified live identity\nDisplayed name: " + RecordValue(evidence.DisplayName) + "\nRaw rendered name/TMP: " + RecordValue(evidence.DisplayNameRaw) + "\nSteam persona: " + RecordValue(string.IsNullOrWhiteSpace(evidence.SteamPersona) ? "not cached" : evidence.SteamPersona) + "\nSteamID64: " + evidence.SteamId + "\nVerified live row: #" + (evidence.RosterIndex + 1) + "\nPlayerID: " + RecordValue(evidence.NetworkPlayerId) + "\nCurrent role: " + RecordValue(evidence.Role);
		}

		private static string RecordValue(string value)
		{
			return (value ?? string.Empty).Replace("\r", "\\r").Replace("\n", "\\n").Trim();
		}

		private static bool TryBuildAuthorityFingerprint(RosterSnapshot snapshot, ulong expectedLobbyId, out string fingerprint)
		{
			fingerprint = string.Empty;
			if (snapshot != null && string.IsNullOrWhiteSpace(snapshot.Error) && snapshot.LobbyId == expectedLobbyId)
			{
				return IdentityEvidenceGenerationPolicy.TryBuildFingerprint(snapshot.LobbyId, snapshot.LobbyOwnerSteamId, snapshot.NativeSteamIds, snapshot.NativePurrNetIds, snapshot.TransformInstanceIds, snapshot.LobbyMemberSteamIds, snapshot.LocalSteamId, snapshot.PublishedHelperSteamIds, snapshot.CoverageComplete, snapshot.LiveSteamCheckCount, snapshot.LeftStaleCount, snapshot.AmbiguousCount, out fingerprint);
			}
			return false;
		}

		private static bool TryReadCurrentLobbyMembers(out CSteamID lobby, out List<string> members, out string error)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			lobby = CSteamID.Nil;
			members = new List<string>();
			error = "the current Steam lobby is unavailable";
			try
			{
				if (!SteamManager.Initialized || !Plugin.TryGetRescueLobby(out lobby) || lobby == CSteamID.Nil)
				{
					return false;
				}
				int numLobbyMembers = SteamMatchmaking.GetNumLobbyMembers(lobby);
				for (int i = 0; i < numLobbyMembers; i++)
				{
					members.Add(((ulong)SteamMatchmaking.GetLobbyMemberByIndex(lobby, i)).ToString());
				}
				error = string.Empty;
				return true;
			}
			catch (Exception ex)
			{
				error = "Steam lobby verification failed safely (" + ex.GetType().Name + ")";
				return false;
			}
		}

		private static SnapshotRoleContext BuildRoleContext(CSteamID lobby, IReadOnlyCollection<string> lobbyMembers)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			SnapshotRoleContext snapshotRoleContext = new SnapshotRoleContext();
			try
			{
				snapshotRoleContext.LocalSteamId = ((ulong)SteamUser.GetSteamID()).ToString(CultureInfo.InvariantCulture);
			}
			catch
			{
			}
			snapshotRoleContext.OwnerSteamId = ((ulong)SteamMatchmaking.GetLobbyOwner(lobby)).ToString(CultureInfo.InvariantCulture);
			HashSet<string> hashSet = new HashSet<string>((IEnumerable<string>)(((object)lobbyMembers) ?? ((object)Array.Empty<string>())), StringComparer.Ordinal);
			HashSet<string> publishedHelpers = SteamIdModerationController.GetPublishedHelpers(lobby, snapshotRoleContext.OwnerSteamId);
			snapshotRoleContext.HelperSteamIds = CurrentLobbyHelperPolicy.FilterCurrent(publishedHelpers, hashSet);
			HashSet<string> hashSet2 = new HashSet<string>(snapshotRoleContext.HelperSteamIds, StringComparer.Ordinal);
			if (!Plugin.CanUseLobbySafety(out var _))
			{
				return snapshotRoleContext;
			}
			Dictionary<string, List<string>> dictionary = new Dictionary<string, List<string>>(StringComparer.Ordinal);
			foreach (string item in hashSet)
			{
				if (string.Equals(snapshotRoleContext.LocalSteamId, item, StringComparison.Ordinal))
				{
					AddRole(dictionary, item, "SELF");
				}
				if (string.Equals(snapshotRoleContext.OwnerSteamId, item, StringComparison.Ordinal))
				{
					AddRole(dictionary, item, "HOST");
				}
				if (hashSet2.Contains(item))
				{
					AddRole(dictionary, item, "HELPER");
				}
			}
			foreach (CloneIncident item2 in CloneIncidentLedger.Snapshot)
			{
				if (hashSet.Contains(item2.VictimSteamId))
				{
					AddRole(dictionary, item2.VictimSteamId, "VICTIM " + item2.Id + " (PROTECTED)");
				}
				if (hashSet.Contains(item2.SuspectSteamId))
				{
					AddRole(dictionary, item2.SuspectSteamId, "SUSPECT " + item2.Id);
				}
			}
			foreach (KeyValuePair<string, List<string>> item3 in dictionary)
			{
				snapshotRoleContext.RoleBySteamId[item3.Key] = string.Join(" • ", item3.Value.Distinct<string>(StringComparer.Ordinal));
			}
			return snapshotRoleContext;
		}

		private static void AddRole(Dictionary<string, List<string>> roles, string steamId, string role)
		{
			if (!roles.TryGetValue(steamId, out var value))
			{
				value = (roles[steamId] = new List<string>());
			}
			value.Add(role);
		}

		private static RosterSnapshot CaptureRosterSnapshot(bool cacheAllowed)
		{
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_061c: Unknown result type (might be due to invalid IL or missing references)
			//IL_061e: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a1: Unknown result type (might be due to invalid IL or missing references)
			long ticks = DateTime.UtcNow.Ticks;
			RosterSnapshot cachedSnapshot = _cachedSnapshot;
			if (cacheAllowed && cachedSnapshot != null && (cachedSnapshot.CapturedFrame == Time.frameCount || (!_snapshotDirty && ticks - cachedSnapshot.CapturedUtcTicks <= SnapshotLifetimeTicks)))
			{
				return cachedSnapshot;
			}
			RosterSnapshot rosterSnapshot = new RosterSnapshot
			{
				CapturedUtcTicks = ticks,
				CaptureStartedTimestamp = Stopwatch.GetTimestamp(),
				CapturedFrame = Time.frameCount
			};
			PlayerPanelController i = NetworkSingleton<PlayerPanelController>.I;
			if ((Object)(object)i == (Object)null || i.PlayerSteamIDs == null || i.PlayerIDs == null || i.PlayerTransforms == null || i.IDInfos == null)
			{
				rosterSnapshot.Error = "the native player roster is not ready";
				return Cache(rosterSnapshot);
			}
			int num = (rosterSnapshot.NativeRowCount = i.PlayerSteamIDs.Count);
			rosterSnapshot.PurrNetRowCount = i.PlayerIDs.Count;
			if (i.PlayerIDs.Count != num || i.PlayerTransforms.Count != num || i.IDInfos.Count != num)
			{
				rosterSnapshot.Error = "the native Steam, network-player, transform, and identity lists are not aligned";
				return Cache(rosterSnapshot);
			}
			rosterSnapshot.NativeSteamIds = i.PlayerSteamIDs.ToArray();
			rosterSnapshot.NativePlayerIds = i.PlayerIDs.Select((PlayerID id) => PurrNetPlayerIdPolicy.Format(PackedULong.op_Implicit(((PlayerID)(ref id)).id))).ToArray();
			rosterSnapshot.NativePurrNetIds = i.PlayerIDs.Select((PlayerID id) => PackedULong.op_Implicit(((PlayerID)(ref id)).id).ToString(CultureInfo.InvariantCulture)).ToArray();
			rosterSnapshot.TransformInstanceIds = i.PlayerTransforms.Select((NetworkTransform transform) => (!((Object)(object)transform == (Object)null)) ? ((Object)transform).GetInstanceID() : 0).ToArray();
			rosterSnapshot.HasLiveTransform = rosterSnapshot.TransformInstanceIds.Select((int instanceId) => instanceId != 0).ToArray();
			if (!TryReadCurrentLobbyMembers(out var lobby, out var members, out var error))
			{
				rosterSnapshot.Error = error;
				return Cache(rosterSnapshot);
			}
			rosterSnapshot.LobbyId = (ulong)lobby;
			rosterSnapshot.LobbyMemberSteamIds = members.ToArray();
			rosterSnapshot.LobbyMemberCount = members.Count;
			if (members.Any((string id) => !ModerationProtocolPolicy.IsSteamId64(id)) || members.Distinct<string>(StringComparer.Ordinal).Count() != members.Count)
			{
				rosterSnapshot.Error = "the current Steam lobby member list is invalid or duplicated";
				return Cache(rosterSnapshot);
			}
			string[] nativeSteamIds = rosterSnapshot.NativeSteamIds;
			string[] nativePurrNetIds = rosterSnapshot.NativePurrNetIds;
			Dictionary<string, int> dictionary = CountValues(nativeSteamIds);
			Dictionary<string, int> dictionary2 = CountValues(nativePurrNetIds);
			HashSet<string> hashSet = new HashSet<string>(members, StringComparer.Ordinal);
			SnapshotRoleContext snapshotRoleContext = BuildRoleContext(lobby, members);
			if (!ulong.TryParse(snapshotRoleContext.LocalSteamId, NumberStyles.None, CultureInfo.InvariantCulture, out rosterSnapshot.LocalSteamId) || rosterSnapshot.LocalSteamId == 0L || !ulong.TryParse(snapshotRoleContext.OwnerSteamId, NumberStyles.None, CultureInfo.InvariantCulture, out rosterSnapshot.LobbyOwnerSteamId) || rosterSnapshot.LobbyOwnerSteamId == 0L || !hashSet.Contains(snapshotRoleContext.LocalSteamId) || !hashSet.Contains(snapshotRoleContext.OwnerSteamId))
			{
				rosterSnapshot.Error = "the current local or lobby-owner Steam identity is unavailable";
				return Cache(rosterSnapshot);
			}
			rosterSnapshot.PublishedHelperSteamIds = snapshotRoleContext.HelperSteamIds;
			List<PlayerIdentityEvidence> list = new List<PlayerIdentityEvidence>();
			for (int num2 = 0; num2 < nativeSteamIds.Length; num2++)
			{
				string text = nativeSteamIds[num2];
				string text2 = nativePurrNetIds[num2];
				bool num3 = ModerationProtocolPolicy.IsSteamId64(text);
				int value;
				int num4 = (dictionary.TryGetValue(text ?? string.Empty, out value) ? value : 0);
				int value2;
				int num5 = (dictionary2.TryGetValue(text2 ?? string.Empty, out value2) ? value2 : 0);
				bool flag = num3 && num4 == 1;
				ulong result;
				bool flag2 = ulong.TryParse(text2, NumberStyles.None, CultureInfo.InvariantCulture, out result) && result != 0L && num5 == 1;
				bool flag3 = rosterSnapshot.HasLiveTransform[num2];
				bool flag4 = num3 && hashSet.Contains(text);
				if (!flag || !flag2 || !flag3 || !flag4)
				{
					switch (PlayerIdentityEvidencePolicy.ClassifyUnresolvedRow(text, rosterSnapshot.LobbyMemberSteamIds, flag ? 1 : num4, flag2, flag3))
					{
					case PlayerIdentityEvidencePolicy.UnresolvedRowState.LiveSteamCheck:
						rosterSnapshot.LiveSteamCheckCount++;
						break;
					case PlayerIdentityEvidencePolicy.UnresolvedRowState.LeftStale:
						rosterSnapshot.LeftStaleCount++;
						break;
					default:
						rosterSnapshot.AmbiguousCount++;
						break;
					}
				}
				else
				{
					string text3 = ReadRosterNameRaw(i, num2);
					bool isLocal = string.Equals(snapshotRoleContext.LocalSteamId, text, StringComparison.Ordinal);
					string text4 = NormalizeName(text3);
					list.Add(new PlayerIdentityEvidence
					{
						SteamId = text,
						DisplayNameRaw = text3,
						DisplayName = (string.IsNullOrWhiteSpace(text4) ? "Player" : text4),
						SteamPersona = ReadSteamPersona(text),
						Role = (snapshotRoleContext.RoleBySteamId.TryGetValue(text, out var value3) ? value3 : "PLAYER"),
						RosterIndex = num2,
						NetworkPlayerId = text2,
						PurrNetId = result,
						TransformInstanceId = rosterSnapshot.TransformInstanceIds[num2],
						IsLocal = isLocal
					});
				}
			}
			if (i.PlayerSteamIDs.Count != nativeSteamIds.Length || !i.PlayerSteamIDs.SequenceEqual(nativeSteamIds) || i.PlayerIDs.Count != nativePurrNetIds.Length || !i.PlayerIDs.Select((PlayerID id) => PackedULong.op_Implicit(((PlayerID)(ref id)).id).ToString(CultureInfo.InvariantCulture)).SequenceEqual(nativePurrNetIds) || i.PlayerTransforms.Count != rosterSnapshot.TransformInstanceIds.Length || !i.PlayerTransforms.Select((NetworkTransform transform) => (!((Object)(object)transform == (Object)null)) ? ((Object)transform).GetInstanceID() : 0).SequenceEqual(rosterSnapshot.TransformInstanceIds))
			{
				rosterSnapshot.Error = "the native Steam/PurrNet/transform roster changed while BlueSage was reading it; refresh and try again";
				rosterSnapshot.Verified = Array.Empty<PlayerIdentityEvidence>();
				return Cache(rosterSnapshot);
			}
			if (!TryReadCurrentLobbyMembers(out var lobby2, out var members2, out var _) || lobby2 != lobby || !members2.OrderBy<string, string>((string result2) => result2, StringComparer.Ordinal).SequenceEqual(members.OrderBy<string, string>((string result2) => result2, StringComparer.Ordinal)))
			{
				rosterSnapshot.Error = "the Steam lobby membership changed while BlueSage was reading it; refresh and try again";
				rosterSnapshot.Verified = Array.Empty<PlayerIdentityEvidence>();
				return Cache(rosterSnapshot);
			}
			SnapshotRoleContext snapshotRoleContext2 = BuildRoleContext(lobby2, members2);
			if (!string.Equals(snapshotRoleContext2.LocalSteamId, snapshotRoleContext.LocalSteamId, StringComparison.Ordinal) || !string.Equals(snapshotRoleContext2.OwnerSteamId, snapshotRoleContext.OwnerSteamId, StringComparison.Ordinal) || !snapshotRoleContext2.HelperSteamIds.SequenceEqual(snapshotRoleContext.HelperSteamIds))
			{
				rosterSnapshot.Error = "the local/owner/helper authority context changed while BlueSage was reading it; refresh and try again";
				rosterSnapshot.Verified = Array.Empty<PlayerIdentityEvidence>();
				return Cache(rosterSnapshot);
			}
			HashSet<string> verifiedIds = new HashSet<string>(list.Select((PlayerIdentityEvidence item) => item.SteamId), StringComparer.Ordinal);
			string[] array = members.Where((string member) => !verifiedIds.Contains(member)).ToArray();
			rosterSnapshot.CoverageComplete = PlayerIdentityEvidencePolicy.IsCoverageComplete(string.IsNullOrWhiteSpace(rosterSnapshot.Error), array.Length, rosterSnapshot.LiveSteamCheckCount, rosterSnapshot.AmbiguousCount);
			rosterSnapshot.CoverageIssue = BuildCoverageIssue(rosterSnapshot, array.Length);
			rosterSnapshot.Verified = list.OrderBy((PlayerIdentityEvidence item) => item.RosterIndex).ToArray();
			return Cache(rosterSnapshot);
		}

		private static RosterSnapshot Cache(RosterSnapshot snapshot)
		{
			double num = (double)(Stopwatch.GetTimestamp() - snapshot.CaptureStartedTimestamp) * 1000.0 / (double)Stopwatch.Frequency;
			_snapshotCaptureCount++;
			_lastSnapshotCaptureMilliseconds = num;
			if (num > _maxSnapshotCaptureMilliseconds)
			{
				_maxSnapshotCaptureMilliseconds = num;
			}
			_snapshotDirty = false;
			_cachedSnapshot = snapshot;
			LogCoverageTransition(snapshot);
			return snapshot;
		}

		private static string BuildCoverageIssue(RosterSnapshot snapshot, int missingCurrentMembers)
		{
			List<string> list = new List<string>();
			if (missingCurrentMembers > 0)
			{
				list.Add(missingCurrentMembers + " current Steam " + ((missingCurrentMembers == 1) ? "member is" : "members are") + " still waiting for one unique live player row");
			}
			if (snapshot.LiveSteamCheckCount > 0)
			{
				list.Add(snapshot.LiveSteamCheckCount + " live game/PurrNet " + ((snapshot.LiveSteamCheckCount == 1) ? "row is" : "rows are") + " outside current Steam lobby membership. Profile access remains available; identity-sensitive actions stay locked");
			}
			if (snapshot.AmbiguousCount > 0)
			{
				list.Add(snapshot.AmbiguousCount + " live native " + ((snapshot.AmbiguousCount == 1) ? "row is" : "rows are") + " ambiguous and locked");
			}
			return string.Join("; ", list);
		}

		private static void LogCoverageTransition(RosterSnapshot snapshot)
		{
			string text = (string.IsNullOrWhiteSpace(snapshot.Error) ? "none" : snapshot.Error);
			string text2 = snapshot.CoverageComplete + "|" + snapshot.Verified.Length + "|" + snapshot.NativeRowCount + "|" + snapshot.LobbyMemberCount + "|" + snapshot.LiveSteamCheckCount + "|" + snapshot.LeftStaleCount + "|" + snapshot.AmbiguousCount + "|" + text;
			if (string.Equals(_lastCoverageTransitionKey, text2, StringComparison.Ordinal))
			{
				return;
			}
			_lastCoverageTransitionKey = text2;
			string text3 = "[BlueSageIdentityCoverage] complete=" + snapshot.CoverageComplete + "; verified=" + snapshot.Verified.Length + "; native=" + snapshot.NativeRowCount + "; steam=" + snapshot.LobbyMemberCount + "; liveNativeOnly=" + snapshot.LiveSteamCheckCount + "; leftStale=" + snapshot.LeftStaleCount + "; ambiguous=" + snapshot.AmbiguousCount + "; identitySensitiveActions=" + (snapshot.CoverageComplete ? "ready" : "fail-closed") + ".";
			if (snapshot.CoverageComplete)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)text3);
				}
			}
			else
			{
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogWarning((object)text3);
				}
			}
		}

		private static Dictionary<string, int> CountValues(IEnumerable<string> values)
		{
			Dictionary<string, int> dictionary = new Dictionary<string, int>(StringComparer.Ordinal);
			foreach (string value2 in values)
			{
				string key = value2 ?? string.Empty;
				dictionary[key] = ((!dictionary.TryGetValue(key, out var value)) ? 1 : (value + 1));
			}
			return dictionary;
		}

		private static string DescribeUnresolvedExactRow(string steamId, RosterSnapshot snapshot)
		{
			int num = snapshot.NativeSteamIds.Count((string candidate) => string.Equals(candidate, steamId, StringComparison.Ordinal));
			bool hasUniquePlayerId = false;
			bool hasLiveTransform = false;
			if (num == 1)
			{
				int num2 = Array.FindIndex(snapshot.NativeSteamIds, (string candidate) => string.Equals(candidate, steamId, StringComparison.Ordinal));
				if (num2 >= 0 && num2 < snapshot.NativePurrNetIds.Length)
				{
					string playerId = snapshot.NativePurrNetIds[num2];
					hasUniquePlayerId = !string.IsNullOrWhiteSpace(playerId) && snapshot.NativePurrNetIds.Count((string candidate) => string.Equals(candidate, playerId, StringComparison.Ordinal)) == 1;
					hasLiveTransform = num2 < snapshot.HasLiveTransform.Length && snapshot.HasLiveTransform[num2];
				}
			}
			return PlayerIdentityEvidencePolicy.DescribeUnresolvedExactRow(steamId, snapshot.LobbyMemberSteamIds, snapshot.Error, num, hasUniquePlayerId, hasLiveTransform);
		}

		private static string ReadRosterNameRaw(PlayerPanelController panel, int index)
		{
			try
			{
				IList iDInfos = panel.IDInfos;
				if (iDInfos == null || index < 0 || index >= iDInfos.Count)
				{
					return "Player";
				}
				object obj = AccessTools.Field(iDInfos[index].GetType(), "Name")?.GetValue(iDInfos[index]);
				string value = ((obj is byte[] bytes) ? Encoding.Unicode.GetString(bytes).TrimEnd(new char[1]) : ((obj as string) ?? string.Empty));
				return string.IsNullOrWhiteSpace(value) ? "Player" : Truncate(value, 4096);
			}
			catch
			{
				return "Player";
			}
		}

		private static string ReadSteamPersona(string steamId)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!ulong.TryParse(steamId, out var result))
				{
					return string.Empty;
				}
				return Truncate(NormalizeName(SteamFriends.GetFriendPersonaName(new CSteamID(result)) ?? string.Empty), 96);
			}
			catch
			{
				return string.Empty;
			}
		}

		private static string NormalizeName(string value)
		{
			return Regex.Replace(value ?? string.Empty, "<.*?>", string.Empty).Replace("\r", " ").Replace("\n", " ")
				.Trim();
		}

		private static string Truncate(string value, int maximum)
		{
			if (value.Length > maximum)
			{
				return value.Substring(0, maximum - 1) + "…";
			}
			return value;
		}
	}
	internal sealed class PlayerRenderSaverController : MonoBehaviour
	{
		private readonly struct RemotePlayerRenderCandidate
		{
			public Transform Root { get; }

			public float DistanceMeters { get; }

			public RemotePlayerRenderCandidate(Transform root, float distanceMeters)
			{
				Root = root;
				DistanceMeters = distanceMeters;
			}
		}

		private readonly struct SavedRendererState
		{
			public bool Enabled { get; }

			public int OwnerId { get; }

			public SavedRendererState(bool enabled, int ownerId)
			{
				Enabled = enabled;
				OwnerId = ownerId;
			}
		}

		private readonly struct SavedAnimatorState
		{
			public AnimatorCullingMode CullingMode { get; }

			public int OwnerId { get; }

			public SavedAnimatorState(AnimatorCullingMode cullingMode, int ownerId)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				CullingMode = cullingMode;
				OwnerId = ownerId;
			}
		}

		private readonly struct SavedParticleState
		{
			public bool EmissionEnabled { get; }

			public int OwnerId { get; }

			public SavedParticleState(bool emissionEnabled, int ownerId)
			{
				EmissionEnabled = emissionEnabled;
				OwnerId = ownerId;
			}
		}

		private readonly struct SavedAudioState
		{
			public bool Muted { get; }

			public int OwnerId { get; }

			public SavedAudioState(bool muted, int ownerId)
			{
				Muted = muted;
				OwnerId = ownerId;
			}
		}

		private sealed class CachedVisualSet
		{
			public Transform Root { get; }

			public Renderer[] Renderers { get; }

			public Animator[] Animators { get; }

			public ParticleSystem[] Particles { get; }

			public AudioSource[] AudioSources { get; }

			public CachedVisualSet(Transform root, Renderer[] renderers, Animator[] animators, ParticleSystem[] particles, AudioSource[] audioSources)
			{
				Root = root;
				Renderers = renderers;
				Animators = animators;
				Particles = particles;
				AudioSources = audioSources;
			}
		}

		private static readonly Dictionary<Renderer, SavedRendererState> RendererStates = new Dictionary<Renderer, SavedRendererState>();

		private static readonly Dictionary<Animator, SavedAnimatorState> AnimatorStates = new Dictionary<Animator, SavedAnimatorState>();

		private static readonly Dictionary<ParticleSystem, SavedParticleState> ParticleStates = new Dictionary<ParticleSystem, SavedParticleState>();

		private static readonly Dictionary<AudioSource, SavedAudioState> AudioStates = new Dictionary<AudioSource, SavedAudioState>();

		private static readonly Dictionary<int, CachedVisualSet> VisualCache = new Dictionary<int, CachedVisualSet>();

		private static readonly HashSet<int> HiddenOwners = new HashSet<int>();

		private float _nextRefreshAt;

		internal static int LastHiddenRemotePlayers { get; private set; }

		internal static int LastVisibleRemotePlayers { get; private set; }

		internal static int LastCandidateRemotePlayers { get; private set; }

		internal static int LastSuppressedRenderers { get; private set; }

		internal static string LastRuntimeState { get; private set; } = "not scanned yet";

		private void Update()
		{
			if (Time.unscaledTime < _nextRefreshAt)
			{
				return;
			}
			_nextRefreshAt = Time.unscaledTime + 1f;
			try
			{
				Refresh();
			}
			catch (Exception ex)
			{
				LastRuntimeState = "scan failed: " + ex.GetType().Name;
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Player Render Saver scan failed safely: " + ex.GetType().Name + ": " + ex.Message));
				}
				RestoreAll("scan failed; renderers restored");
			}
		}

		private void OnDestroy()
		{
			RestoreAll();
		}

		private static void Refresh()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.ShouldApplyPlayerRenderSaver)
			{
				RestoreAll("off");
				return;
			}
			if (!TryGetLocalPosition(out var position))
			{
				RestoreAll("waiting for local player");
				return;
			}
			List<RemotePlayerRenderCandidate> list = (from candidate in CollectRemoteCandidates(position)
				orderby candidate.DistanceMeters
				select candidate).ToList();
			LastCandidateRemotePlayers = list.Count;
			HashSet<int> hashSet = new HashSet<int>();
			int num = 0;
			int num2 = 0;
			for (int num3 = 0; num3 < list.Count; num3++)
			{
				RemotePlayerRenderCandidate remotePlayerRenderCandidate = list[num3];
				bool num4 = PlayerRenderSaverPolicy.ShouldHideRemotePlayer(remotePlayerRenderCandidate.DistanceMeters, num3, Plugin.LockedPlayerRenderSaverRadiusMeters, Plugin.LockedPlayerRenderSaverMaxVisiblePlayers, HiddenOwners.Contains(((Object)remotePlayerRenderCandidate.Root).GetInstanceID()));
				int instanceID = ((Object)remotePlayerRenderCandidate.Root).GetInstanceID();
				if (num4)
				{
					hashSet.Add(instanceID);
					HideRoot(remotePlayerRenderCandidate.Root, instanceID);
					num++;
				}
				else
				{
					RestoreRoot(instanceID);
					num2++;
				}
			}
			RestoreStale(hashSet);
			LastHiddenRemotePlayers = num;
			LastVisibleRemotePlayers = num2;
			LastSuppressedRenderers = RendererStates.Count;
			LastRuntimeState = ((list.Count == 0) ? "no remote player roots found" : ((num == 0) ? "active; every remote player is inside the current budgets" : ((LastSuppressedRenderers == 0) ? "players selected for hiding, but no avatar renderers were found under their panel roots" : "active; avatar renderers suppressed")));
		}

		internal static void RestoreAll()
		{
			RestoreAll(Plugin.ShouldApplyPlayerRenderSaver ? "restored" : "off");
		}

		private static void RestoreAll(string runtimeState)
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			KeyValuePair<Renderer, SavedRendererState>[] array = RendererStates.ToArray();
			for (int i = 0; i < array.Length; i++)
			{
				KeyValuePair<Renderer, SavedRendererState> keyValuePair = array[i];
				if ((Object)(object)keyValuePair.Key != (Object)null)
				{
					keyValuePair.Key.enabled = keyValuePair.Value.Enabled;
				}
			}
			KeyValuePair<Animator, SavedAnimatorState>[] array2 = AnimatorStates.ToArray();
			for (int i = 0; i < array2.Length; i++)
			{
				KeyValuePair<Animator, SavedAnimatorState> keyValuePair2 = array2[i];
				if ((Object)(object)keyValuePair2.Key != (Object)null)
				{
					keyValuePair2.Key.cullingMode = keyValuePair2.Value.CullingMode;
				}
			}
			KeyValuePair<ParticleSystem, SavedParticleState>[] array3 = ParticleStates.ToArray();
			for (int i = 0; i < array3.Length; i++)
			{
				KeyValuePair<ParticleSystem, SavedParticleState> keyValuePair3 = array3[i];
				if ((Object)(object)keyValuePair3.Key != (Object)null)
				{
					EmissionModule emission = keyValuePair3.Key.emission;
					((EmissionModule)(ref emission)).enabled = keyValuePair3.Value.EmissionEnabled;
				}
			}
			KeyValuePair<AudioSource, SavedAudioState>[] array4 = AudioStates.ToArray();
			for (int i = 0; i < array4.Length; i++)
			{
				KeyValuePair<AudioSource, SavedAudioState> keyValuePair4 = array4[i];
				if ((Object)(object)keyValuePair4.Key != (Object)null)
				{
					keyValuePair4.Key.mute = keyValuePair4.Value.Muted;
				}
			}
			RendererStates.Clear();
			AnimatorStates.Clear();
			ParticleStates.Clear();
			AudioStates.Clear();
			VisualCache.Clear();
			HiddenOwners.Clear();
			LastHiddenRemotePlayers = 0;
			LastVisibleRemotePlayers = 0;
			LastCandidateRemotePlayers = 0;
			LastSuppressedRenderers = 0;
			LastRuntimeState = runtimeState;
		}

		private static IEnumerable<RemotePlayerRenderCandidate> CollectRemoteCandidates(Vector3 localPosition)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			PlayerPanelController panel = NetworkSingleton<PlayerPanelController>.I;
			if (panel?.PlayerTransforms == null || panel.PlayerTransforms.Count == 0)
			{
				yield break;
			}
			string localSteamId = GetLocalSteamId();
			int count = panel.PlayerTransforms.Count;
			for (int index = 0; index < count; index++)
			{
				NetworkTransform val = panel.PlayerTransforms[index];
				Transform val2 = (((Object)(object)val != (Object)null) ? ((Component)val).transform : null);
				if (!((Object)(object)val2 == (Object)null))
				{
					string a = ((panel.PlayerSteamIDs != null && index < panel.PlayerSteamIDs.Count) ? panel.PlayerSteamIDs[index] : string.Empty);
					if (string.IsNullOrEmpty(localSteamId) || !string.Equals(a, localSteamId, StringComparison.Ordinal))
					{
						yield return new RemotePlayerRenderCandidate(val2, Vector3.Distance(localPosition, val2.position));
					}
				}
			}
		}

		private static bool TryGetLocalPosition(out Vector3 position)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			position = Vector3.zero;
			try
			{
				TextChannelManager i = NetworkSingleton<TextChannelManager>.I;
				if ((Object)(object)i?.MainPlayer == (Object)null)
				{
					return false;
				}
				position = i.MainPlayer.position;
				return true;
			}
			catch
			{
				return false;
			}
		}

		private static string GetLocalSteamId()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				return ((ulong)SteamUser.GetSteamID()).ToString();
			}
			catch
			{
				return string.Empty;
			}
		}

		private static void HideRoot(Transform root, int ownerId)
		{
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			CachedVisualSet orCreateVisualSet = GetOrCreateVisualSet(root, ownerId);
			Renderer[] renderers = orCreateVisualSet.Renderers;
			foreach (Renderer val in renderers)
			{
				if (!((Object)(object)val == (Object)null))
				{
					if (!RendererStates.ContainsKey(val))
					{
						RendererStates[val] = new SavedRendererState(val.enabled, ownerId);
					}
					val.enabled = false;
				}
			}
			Animator[] animators = orCreateVisualSet.Animators;
			foreach (Animator val2 in animators)
			{
				if (!((Object)(object)val2 == (Object)null))
				{
					if (!AnimatorStates.ContainsKey(val2))
					{
						AnimatorStates[val2] = new SavedAnimatorState(val2.cullingMode, ownerId);
					}
					val2.cullingMode = (AnimatorCullingMode)2;
				}
			}
			ParticleSystem[] particles = orCreateVisualSet.Particles;
			foreach (ParticleSystem val3 in particles)
			{
				if (!((Object)(object)val3 == (Object)null))
				{
					if (!ParticleStates.ContainsKey(val3))
					{
						Dictionary<ParticleSystem, SavedParticleState> particleStates = ParticleStates;
						EmissionModule emission = val3.emission;
						particleStates[val3] = new SavedParticleState(((EmissionModule)(ref emission)).enabled, ownerId);
					}
					EmissionModule emission2 = val3.emission;
					((EmissionModule)(ref emission2)).enabled = false;
				}
			}
			AudioSource[] audioSources = orCreateVisualSet.AudioSources;
			foreach (AudioSource val4 in audioSources)
			{
				if (!((Object)(object)val4 == (Object)null) && !IsEssentialAudio(val4))
				{
					if (!AudioStates.ContainsKey(val4))
					{
						AudioStates[val4] = new SavedAudioState(val4.mute, ownerId);
					}
					val4.mute = true;
				}
			}
			HiddenOwners.Add(ownerId);
		}

		private static bool IsEssentialAudio(AudioSource audio)
		{
			if (audio.spatialBlend <= 0.01f)
			{
				return true;
			}
			Transform val = ((Component)audio).transform;
			int num = 0;
			while ((Object)(object)val != (Object)null && num < 6)
			{
				string text = ((Object)val).name ?? string.Empty;
				if (text.IndexOf("voice", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("vivox", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("speech", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return true;
				}
				num++;
				val = val.parent;
			}
			return false;
		}

		private static void RestoreRoot(int ownerId)
		{
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			KeyValuePair<Renderer, SavedRendererState>[] array = RendererStates.ToArray();
			for (int i = 0; i < array.Length; i++)
			{
				KeyValuePair<Renderer, SavedRendererState> keyValuePair = array[i];
				if (keyValuePair.Value.OwnerId == ownerId)
				{
					if ((Object)(object)keyValuePair.Key != (Object)null)
					{
						keyValuePair.Key.enabled = keyValuePair.Value.Enabled;
					}
					RendererStates.Remove(keyValuePair.Key);
				}
			}
			KeyValuePair<Animator, SavedAnimatorState>[] array2 = AnimatorStates.ToArray();
			for (int i = 0; i < array2.Length; i++)
			{
				KeyValuePair<Animator, SavedAnimatorState> keyValuePair2 = array2[i];
				if (keyValuePair2.Value.OwnerId == ownerId)
				{
					if ((Object)(object)keyValuePair2.Key != (Object)null)
					{
						keyValuePair2.Key.cullingMode = keyValuePair2.Value.CullingMode;
					}
					AnimatorStates.Remove(keyValuePair2.Key);
				}
			}
			RestoreOwnedParticles(ownerId);
			RestoreOwnedAudio(ownerId);
			HiddenOwners.Remove(ownerId);
		}

		private static void RestoreStale(HashSet<int> hiddenOwnerIds)
		{
			KeyValuePair<Renderer, SavedRendererState>[] array = RendererStates.ToArray();
			for (int i = 0; i < array.Length; i++)
			{
				KeyValuePair<Renderer, SavedRendererState> keyValuePair = array[i];
				if ((Object)(object)keyValuePair.Key == (Object)null || !hiddenOwnerIds.Contains(keyValuePair.Value.OwnerId))
				{
					if ((Object)(object)keyValuePair.Key != (Object)null)
					{
						keyValuePair.Key.enabled = keyValuePair.Value.Enabled;
					}
					RendererStates.Remove(keyValuePair.Key);
				}
			}
			int[] array2 = HiddenOwners.ToArray();
			foreach (int num in array2)
			{
				if (!hiddenOwnerIds.Contains(num))
				{
					RestoreRoot(num);
				}
			}
			array2 = VisualCache.Keys.ToArray();
			foreach (int key in array2)
			{
				if ((Object)(object)VisualCache[key].Root == (Object)null)
				{
					VisualCache.Remove(key);
				}
			}
		}

		private static CachedVisualSet GetOrCreateVisualSet(Transform root, int ownerId)
		{
			if (VisualCache.TryGetValue(ownerId, out var value) && (Object)(object)value.Root == (Object)(object)root)
			{
				return value;
			}
			value = new CachedVisualSet(root, ((Component)root).GetComponentsInChildren<Renderer>(true), ((Component)root).GetComponentsInChildren<Animator>(true), ((Component)root).GetComponentsInChildren<ParticleSystem>(true), ((Component)root).GetComponentsInChildren<AudioSource>(true));
			VisualCache[ownerId] = value;
			return value;
		}

		private static void RestoreOwnedParticles(int ownerId)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			KeyValuePair<ParticleSystem, SavedParticleState>[] array = ParticleStates.ToArray();
			for (int i = 0; i < array.Length; i++)
			{
				KeyValuePair<ParticleSystem, SavedParticleState> keyValuePair = array[i];
				if (keyValuePair.Value.OwnerId == ownerId)
				{
					if ((Object)(object)keyValuePair.Key != (Object)null)
					{
						EmissionModule emission = keyValuePair.Key.emission;
						((EmissionModule)(ref emission)).enabled = keyValuePair.Value.EmissionEnabled;
					}
					ParticleStates.Remove(keyValuePair.Key);
				}
			}
		}

		private static void RestoreOwnedAudio(int ownerId)
		{
			KeyValuePair<AudioSource, SavedAudioState>[] array = AudioStates.ToArray();
			for (int i = 0; i < array.Length; i++)
			{
				KeyValuePair<AudioSource, SavedAudioState> keyValuePair = array[i];
				if (keyValuePair.Value.OwnerId == ownerId)
				{
					if ((Object)(object)keyValuePair.Key != (Object)null)
					{
						keyValuePair.Key.mute = keyValuePair.Value.Muted;
					}
					AudioStates.Remove(keyValuePair.Key);
				}
			}
		}
	}
	[BepInPlugin("com.bluesage.ontogether.qoltweaks.beta", "BlueSage QoL Tweaks - Beta", "0.2.4")]
	[BepInProcess("OnTogether.exe")]
	[BepInProcess("On-Together")]
	public sealed class Plugin : BaseUnityPlugin
	{
		private sealed class DisplayNameDraft
		{
			public string BaseName;

			public string StatusMessage;

			public string StatusColor;

			public string StatusBrackets;

			public bool SpoonsEnabled;

			public int SpoonCount;

			public string SpoonLabel;

			public string SpoonsUpdatedUtc;
		}

		private sealed class PendingModerationAction
		{
			public string Action;

			public string TargetSteamId;

			public string IncidentId;

			public string LobbyCode;

			public bool TargetWasOffline;

			public long ExpiresUnixSeconds;
		}

		private const string DefaultSpoonLabel = "sp";

		public const string PluginGuid = "com.bluesage.ontogether.qoltweaks.beta";

		public const string PluginName = "BlueSage QoL Tweaks - Beta";

		public const string PluginVersion = "0.2.4";

		public const string PluginDisplayVersion = "0.2.4";

		public const string PluginReleaseDate = "2026-07-30";

		internal const string PluginBuildIdentity = "0.2.4+20260730.1-public-24414155-release";

		private const string StyleStateMigrationTarget = "0.2.4-legacy-style-repair-v1";

		private readonly Harmony _harmony = new Harmony("com.bluesage.ontogether.qoltweaks.beta");

		private readonly SweepOperationGate _sweepOperationGate = new SweepOperationGate();

		private readonly SweepSchedulePolicy _sweepSchedule = new SweepSchedulePolicy();

		private Coroutine _sweepCoroutine;

		private Coroutine _activeSweepOperationCoroutine;

		private bool _ownsSweepRunInBackgroundOverride;

		private bool _runInBackgroundBeforeSweepOverride;

		private Coroutine _compatibilityRefreshCoroutine;

		private Coroutine _hostHealthCoroutine;

		private Coroutine _communityBanListCoroutine;

		private Coroutine _managedReconnectCoroutine;

		private Coroutine _lastLobbyRejoinFallbackCoroutine;

		private Coroutine _replacementLobbyDiscoveryCoroutine;

		private Coroutine _cleanMenuReconnectCoroutine;

		private Coroutine _reconnectAnnouncementCoroutine;

		private Coroutine _welcomeMessageCoroutine;

		private Coroutine _rescueReceiverCapabilityCoroutine;

		private CSteamID _rescueReceiverCapabilityLobby = CSteamID.Nil;

		private PluginCompatibilityResult _compatibility;

		private BlueSageCommandRegistry _commandRegistry;

		private float _lastLobbyVisibleAt = -1f;

		private float _lastManagedReconnectAttemptAt = -1f;

		private int _managedReconnectAttempt;

		private bool _managedReconnectActive;

		private bool _managedReconnectSuccessAnnounced;

		private int _reconnectReadySampleCount;

		private float _reconnectQuorumReadySince = -1f;

		private string _lastReconnectLobbyCode = string.Empty;

		private string _lastReconnectLobbyOwnerSteamId = string.Empty;

		private string _lastReconnectLobbyNameFingerprint = string.Empty;

		private bool _replacementLobbyDiscoveryAttempted;

		private bool _lastLobbyRejoinInProgress;

		private bool _reconnectMenuFallbackInProgress;

		private bool _cleanMenuReconnectActive;

		private int _cleanMenuReconnectGeneration;

		private string _cleanMenuReconnectPhase = "idle";

		private float _hostHealthStartedAt = -1f;

		private HostHealthDecision _lastHostHealthDecision;

		private GameObject _mentionPingControllerObject;

		private GameObject _commandTypeaheadControllerObject;

		private GameObject _chatReadabilityControllerObject;

		private GameObject _cloneShieldControllerObject;

		private GameObject _playerRenderSaverControllerObject;

		private GameObject _performanceOverlayControllerObject;

		private GameObject _sessionAuditControllerObject;

		private GameObject _sessionRunMarkerControllerObject;

		private GameObject _stewardAnnouncementBridgeControllerObject;

		private StyleHelperWindow _styleHelperWindow;

		private QolMenuWindow _qolMenuWindow;

		private bool _welcomeMessageShownForLobby;

		private bool _welcomePrimaryShownForLobby;

		private bool _welcomeContextShownForLobby;

		private string _welcomeVoiceStateLogKey = string.Empty;

		private string _welcomeLobbyKey = string.Empty;

		private string _lastStatusBeforePreset = string.Empty;

		private PendingModerationAction _pendingModerationAction;

		private float _nextModerationCapabilityPublishAt;

		private bool _hadLobbySafetyAccess;

		internal const int LockedHostHealthIntervalSeconds = 300;

		internal const bool LockedHostHealthRefreshLobbyMetadata = true;

		internal const bool LockedHostHealthRequestPersonaRefresh = true;

		internal const bool LockedHostHealthShowNotifications = false;

		internal const int LockedHostHealthWarnAfterHours = 12;

		internal const bool LockedReconnectRequireVisibleLobby = true;

		internal const bool LockedReconnectManageHostKick = false;

		internal const bool LockedReconnectUseLobbyGrace = true;

		internal const int LockedReconnectLobbyGraceSeconds = 20;

		internal const int LockedReconnectRetryIntervalSeconds = 5;

		internal const int LockedReconnectMaxAttempts = 3;

		internal const int LockedReconnectPostConnectValidationSeconds = 8;

		internal const int LockedReconnectReadyStabilitySeconds = 2;

		internal const int LockedReconnectCleanupTimeoutSeconds = 10;

		internal const int LockedReconnectJoinValidationTimeoutSeconds = 45;

		internal const bool LockedReconnectShowNotifications = true;

		internal const string LockedReconnectAnnouncementMessage = "Auto Reconnected by Blues - BlueSage QoL Tweaks Mod";

		internal const int LockedReconnectAnnouncementDelaySeconds = 3;

		private static NativeAssetSweepOwnershipState? _nativeAssetSweepOwnership;

		internal static ManualLogSource Log { get; private set; }

		internal static Plugin Instance { get; private set; }

		internal static int LockedMaxIdCardCharacters => InputFieldLimitPolicy.ClampProfileCharacters(MaxProfileCharacters?.Value ?? 3000);

		internal static int LockedMaxSessionNameCharacters => InputFieldLimitPolicy.ClampSessionNameCharacters(MaxSessionNameCharacters?.Value ?? 3000);

		internal static int LockedMaxChatCharacters => InputFieldLimitPolicy.ClampChatCharacters(MaxChatCharacters?.Value ?? 3000);

		internal static int LockedChatOutlineIntensityPercent => ChatReadabilityStylePolicy.ClampOutlineIntensityPercent(ChatOutlineIntensity?.Value ?? 75);

		internal static int LockedChatUiScalePercent => ChatAccessibilityScalePolicy.ClampScalePercent(ChatUiScalePercent?.Value ?? 100);

		internal static int LockedChatFontSizePercent => ChatFontSizePolicy.ClampFontSizePercent(ChatFontSizePercent?.Value ?? 100);

		internal static int LockedChatWindowHeightPercent => ChatWindowHeightPolicy.ClampHeightPercent(ChatWindowHeightPercent?.Value ?? 100);

		internal static int LockedChatHistoryRows => ChatHistoryLimitPolicy.ClampRows(ChatHistoryRows?.Value ?? 150);

		internal static int LockedPlayerRenderSaverRadiusMeters => PlayerRenderSaverPolicy.ClampRadiusMeters(PlayerRenderSaverRadiusMeters?.Value ?? 45);

		internal static int LockedPlayerRenderSaverMaxVisiblePlayers => PlayerRenderSaverPolicy.ClampMaxVisiblePlayers(PlayerRenderSaverMaxVisiblePlayers?.Value ?? 32);

		internal static float LockedSelfSpeedMultiplier => SelfMovementPolicy.ClampSpeed(SelfSpeedMultiplier?.Value ?? 1f);

		internal static float LockedSelfJumpMultiplier => SelfMovementPolicy.ClampJump(SelfJumpMultiplier?.Value ?? 1f);

		internal static float LockedSelfGravityMultiplier => SelfMovementPolicy.ClampGravity(SelfGravityMultiplier?.Value ?? 1f);

		internal static string LockedChatOutlineColorHex => ChatReadabilityStylePolicy.NormalizeHexColor(ChatOutlineColor?.Value, "000000");

		internal static string LockedBlackChatOutlineColorHex => ChatReadabilityStylePolicy.NormalizeHexColor(BlackChatOutlineColor?.Value, "C0C0C0");

		internal static ConfigEntry<bool> EnableAutoSweep { get; private set; }

		internal static ConfigEntry<bool> AutoDisableSweepWhenAndrewSweepInstalled { get; private set; }

		internal static ConfigEntry<bool> AllowManualSweepWhenAndrewSweepInstalled { get; private set; }

		internal static ConfigEntry<int> SweepIntervalMinutes { get; private set; }

		internal static ConfigEntry<bool> EnableManualSweepHotkey { get; private set; }

		internal static ConfigEntry<KeyCode> ManualSweepKey { get; private set; }

		internal static ConfigEntry<bool> EnableVivoxPositionRateGuard { get; private set; }

		internal static ConfigEntry<bool> EnableChatTimestamps { get; private set; }

		internal static ConfigEntry<bool> EnableNotificationTimestamps { get; private set; }

		internal static ConfigEntry<bool> Use24HourTime { get; private set; }

		internal static ConfigEntry<int> TimestampSizePercent { get; private set; }

		internal static ConfigEntry<string> TimestampColor { get; private set; }

		internal static ConfigEntry<bool> AutoDisableChatTweaksWhenSimpleQoLInstalled { get; private set; }

		internal static ConfigEntry<bool> EnableChatReadability { get; private set; }

		internal static ConfigEntry<bool> EnablePersistentChatBackdrop { get; private set; }

		internal static ConfigEntry<int> ChatOutlineIntensity { get; private set; }

		internal static ConfigEntry<int> ChatUiScalePercent { get; private set; }

		internal static ConfigEntry<int> ChatFontSizePercent { get; private set; }

		internal static ConfigEntry<int> ChatWindowHeightPercent { get; private set; }

		internal static ConfigEntry<int> ChatHistoryRows { get; private set; }

		internal static ConfigEntry<string> ChatOutlineColor { get; private set; }

		internal static ConfigEntry<string> BlackChatOutlineColor { get; private set; }

		internal static ConfigEntry<bool> BlackNamesOutline { get; private set; }

		internal static ConfigEntry<bool> EnableBetterMove { get; private set; }

		internal static ConfigEntry<bool> EnableUnlimitedConsumables { get; private set; }

		internal static ConfigEntry<bool> EnableNoclipFly { get; private set; }

		internal static ConfigEntry<string> SelfSavedPosition { get; private set; }

		internal static ConfigEntry<float> SelfSpeedMultiplier { get; private set; }

		internal static ConfigEntry<float> SelfJumpMultiplier { get; private set; }

		internal static ConfigEntry<float> SelfGravityMultiplier { get; private set; }

		internal static ConfigEntry<string> StatusBaseName { get; private set; }

		internal static ConfigEntry<string> StatusMessage { get; private set; }

		internal static ConfigEntry<string> StatusColor { get; private set; }

		internal static ConfigEntry<string> StatusBrackets { get; private set; }

		internal static ConfigEntry<bool> EnableSpoons { get; private set; }

		internal static ConfigEntry<int> SpoonCount { get; private set; }

		internal static ConfigEntry<string> SpoonLabel { get; private set; }

		internal static ConfigEntry<string> SpoonsUpdatedUtc { get; private set; }

		internal static ConfigEntry<string> StatusBaseNameLegacyBackup { get; private set; }

		internal static ConfigEntry<string> StyleStateMigrationVersion { get; private set; }

		internal static ConfigEntry<bool> EnableLeaveNotifications { get; private set; }

		internal static ConfigEntry<bool> EnableWelcomeMessage { get; private set; }

		internal static ConfigEntry<bool> EnableReconnectGuard { get; private set; }

		internal static ConfigEntry<bool> EnableReconnectAnnouncement { get; private set; }

		internal static ConfigEntry<bool> EnableHostHealthMonitor { get; private set; }

		internal static ConfigEntry<bool> EnableCommunityBanListSync { get; private set; }

		internal static ConfigEntry<bool> EnableFocusAnywhere { get; private set; }

		internal static ConfigEntry<bool> EnableEnhancedPlayerPanel { get; private set; }

		internal static ConfigEntry<bool> EnableCloneShield { get; private set; }

		internal static ConfigEntry<bool> EnablePlayerRenderSaver { get; private set; }

		internal static ConfigEntry<bool> EnablePerformanceOverlay { get; private set; }

		internal static ConfigEntry<float> PerformanceOverlayRefreshSeconds { get; private set; }

		internal static ConfigEntry<int> PerformanceOverlayFontSize { get; private set; }

		internal static ConfigEntry<float> PerformanceOverlayOffsetX { get; private set; }

		internal static ConfigEntry<float> PerformanceOverlayOffsetY { get; private set; }

		internal static ConfigEntry<float> PerformanceOverlayWidth { get; private set; }

		internal static ConfigEntry<int> PlayerRenderSaverRadiusMeters { get; private set; }

		internal static ConfigEntry<int> PlayerRenderSaverMaxVisiblePlayers { get; private set; }

		internal static ConfigEntry<bool> EnableHiddenDiagnostics { get; private set; }

		internal static ConfigEntry<bool> EnableLocalAuditExports { get; private set; }

		internal static ConfigEntry<bool> EnableStewardAnnouncementBridge { get; private set; }

		internal static ConfigEntry<string> StewardBridgeKeyPath { get; private set; }

		internal static ConfigEntry<string> StewardBridgeServiceIdentity { get; private set; }

		internal static ConfigEntry<bool> EnablePingMentions { get; private set; }

		internal static ConfigEntry<bool> EnablePingSound { get; private set; }

		internal static ConfigEntry<string> PingHighlightColor { get; private set; }

		internal static ConfigEntry<string> PingMentionColor { get; private set; }

		internal static ConfigEntry<string> PingSoundMode { get; private set; }

		internal static ConfigEntry<string> LobbyPingDelegates { get; private set; }

		internal static ConfigEntry<string> LobbyPingDelegateOwnerSteamId { get; private set; }

		internal static ConfigEntry<string> LobbyModerationDelegates { get; private set; }

		internal static ConfigEntry<string> LobbyModerationDelegateOwnerSteamId { get; private set; }

		internal static ConfigEntry<string> LobbyHelpers { get; private set; }

		internal static ConfigEntry<string> LobbyHelperOwnerSteamId { get; private set; }

		internal static int LockedLobbyHelperCount => LobbyPingAuthorizationPolicy.ParseDelegates(LobbyHelpers?.Value).Length;

		internal static int LockedLobbyPingDelegateCount => LockedLobbyHelperCount;

		internal static int LockedLobbyModerationDelegateCount => LockedLobbyHelperCount;

		internal static ConfigEntry<bool> EnableChatCopy { get; private set; }

		internal static ConfigEntry<bool> EnableChatUrlLinks { get; private set; }

		internal static ConfigEntry<bool> EnableStyleUi { get; private set; }

		internal static ConfigEntry<bool> EnableExtendedAvatarStyles { get; private set; }

		internal static ConfigEntry<bool> EnableChalkboardPersistence { get; private set; }

		internal static ConfigEntry<bool> EnableMiniMapPlayerLabels { get; private set; }

		internal static ConfigEntry<bool> EnableMiniMapFriendColors { get; private set; }

		internal static ConfigEntry<string> UiThemePreset { get; private set; }

		internal static ConfigEntry<int> MaxChatCharacters { get; private set; }

		internal static ConfigEntry<int> MaxProfileCharacters { get; private set; }

		internal static ConfigEntry<int> MaxSessionNameCharacters { get; private set; }

		internal static ConfigEntry<string> ConfigMigrationVersion { get; private set; }

		internal static NativeAssetSweepOwnershipState NativeAssetSweepOwnership
		{
			get
			{
				NativeAssetSweepOwnershipState? nativeAssetSweepOwnership = _nativeAssetSweepOwnership;
				if (!nativeAssetSweepOwnership.HasValue)
				{
					NativeAssetSweepOwnershipState? nativeAssetSweepOwnershipState = (_nativeAssetSweepOwnership = DetectNativeAssetSweepOwnership());
					return nativeAssetSweepOwnershipState.Value;
				}
				return nativeAssetSweepOwnership.GetValueOrDefault();
			}
		}

		internal static bool NativeAssetSweepDetected => NativeAssetSweepOwnership != NativeAssetSweepOwnershipState.BlueSage;

		internal static bool NativeAssetSweepOwnershipVerified => NativeAssetSweepOwnership == NativeAssetSweepOwnershipState.NativeGame;

		internal static bool AutoSweepAllowed
		{
			get
			{
				if ((Object)(object)Instance != (Object)null && Instance._compatibility != null)
				{
					return NativeAssetSweepPolicy.AllowBlueSageAutoSweep(NativeAssetSweepDetected, Instance._compatibility.AutoSweepAllowed, EnableAutoSweep?.Value ?? false);
				}
				return false;
			}
		}

		internal static bool ManualSweepAllowed
		{
			get
			{
				if ((Object)(object)Instance != (Object)null && Instance._compatibility != null)
				{
					return NativeAssetSweepPolicy.AllowBlueSageManualSweep(NativeAssetSweepDetected, Instance._compatibility.ManualSweepAllowed);
				}
				return false;
			}
		}

		internal static bool HostCleanupLaneHealthy
		{
			get
			{
				if (!NativeAssetSweepOwnershipVerified)
				{
					return AutoSweepAllowed;
				}
				return true;
			}
		}

		internal static bool HostReconnectLaneHealthy
		{
			get
			{
				if ((Object)(object)Instance != (Object)null)
				{
					ConfigEntry<bool> enableReconnectGuard = EnableReconnectGuard;
					if (enableReconnectGuard != null && enableReconnectGuard.Value && !Instance._managedReconnectActive)
					{
						return !Instance._cleanMenuReconnectActive;
					}
				}
				return false;
			}
		}

		internal static bool ChatTweaksAllowed
		{
			get
			{
				if ((Object)(object)Instance != (Object)null)
				{
					return Instance._compatibility.ChatTweaksAllowed;
				}
				return false;
			}
		}

		internal static bool HostHealthRepairsAllowed
		{
			get
			{
				if ((Object)(object)Instance != (Object)null && Instance._compatibility != null)
				{
					return Instance._compatibility.HostHealthRepairsAllowed;
				}
				return false;
			}
		}

		internal static bool ShouldApplyChatTimestamps
		{
			get
			{
				if (ChatTweaksAllowed)
				{
					return EnableChatTimestamps.Value;
				}
				return false;
			}
		}

		internal static bool ShouldApplyNotificationTimestamps
		{
			get
			{
				if (ChatTweaksAllowed)
				{
					return EnableNotificationTimestamps.Value;
				}
				return false;
			}
		}

		internal static bool ShouldApplyLeaveNotifications
		{
			get
			{
				if (ChatTweaksAllowed)
				{
					return EnableLeaveNotifications.Value;
				}
				return false;
			}
		}

		internal static bool ShouldApplyChatReadability
		{
			get
			{
				if (EnableChatReadability != null)
				{
					return EnableChatReadability.Value;
				}
				return false;
			}
		}

		internal static bool ShouldApplyPersistentChatBackdrop
		{
			get
			{
				if (EnablePersistentChatBackdrop != null)
				{
					return EnablePersistentChatBackdrop.Value;
				}
				return false;
			}
		}

		internal static bool ShouldApplyBlackNamesOutline
		{
			get
			{
				if (BlackNamesOutline != null)
				{
					return BlackNamesOutline.Value;
				}
				return false;
			}
		}

		internal static bool ShouldApplyBetterMove
		{
			get
			{
				if (EnableBetterMove != null)
				{
					return EnableBetterMove.Value;
				}
				return false;
			}
		}

		internal static bool ShouldApplyUnlimitedConsumables
		{
			get
			{
				if (EnableUnlimitedConsumables != null)
				{
					return EnableUnlimitedConsumables.Value;
				}
				return false;
			}
		}

		internal static bool ShouldApplyNoclipFly
		{
			get
			{
				if (EnableNoclipFly != null)
				{
					return EnableNoclipFly.Value;
				}
				return false;
			}
		}

		internal static bool ShouldApplySelfMovementTuning
		{
			get
			{
				if (!(Math.Abs(LockedSelfSpeedMultiplier - 1f) > 0.001f) && !(Math.Abs(LockedSelfJumpMultiplier - 1f) > 0.001f))
				{
					return Math.Abs(LockedSelfGravityMultiplier - 1f) > 0.001f;
				}
				return true;
			}
		}

		internal static bool ShouldApplySpoons
		{
			get
			{
				if (EnableSpoons != null)
				{
					return EnableSpoons.Value;
				}
				return false;
			}
		}

		internal static bool ShouldApplyFocusAnywhere
		{
			get
			{
				if (EnableFocusAnywhere != null)
				{
					return EnableFocusAnywhere.Value;
				}
				return false;
			}
		}

		internal static bool ShouldApplyEnhancedPlayerPanel
		{
			get
			{
				if (EnableEnhancedPlayerPanel != null)
				{
					return EnableEnhancedPlayerPanel.Value;
				}
				return false;
			}
		}

		internal static bool ShouldApplyCloneShield
		{
			get
			{
				if (EnableCloneShield != null)
				{
					return EnableCloneShield.Value;
				}
				return false;
			}
		}

		internal static bool ShouldApplyPlayerRenderSaver
		{
			get
			{
				if (EnablePlayerRenderSaver != null)
				{
					return EnablePlayerRenderSaver.Value;
				}
				return false;
			}
		}

		internal static bool ShouldApplyChatCopy
		{
			get
			{
				if (EnableChatCopy != null && EnableChatCopy.Value)
				{
					return !IsPluginLoaded("com.jai.ontogether.copychat");
				}
				return false;
			}
		}

		internal static bool ShouldApplyChatUrlLinks
		{
			get
			{
				if (EnableChatUrlLinks != null)
				{
					return EnableChatUrlLinks.Value;
				}
				return false;
			}
		}

		internal static bool ShouldApplyMiniMapPlayerLabels
		{
			get
			{
				if (EnableMiniMapPlayerLabels != null)
				{
					return EnableMiniMapPlayerLabels.Value;
				}
				return false;
			}
		}

		internal static bool ShouldApplyMiniMapFriendColors
		{
			get
			{
				if (EnableMiniMapFriendColors != null)
				{
					return EnableMiniMapFriendColors.Value;
				}
				return false;
			}
		}

		internal static bool ShouldEmitHiddenDiagnostics => true;

		public static bool IsPerformanceOverlayActive => PerformanceOverlayOwnershipPolicy.IsActive((Object)(object)Instance != (Object)null, (Object)(object)Instance != (Object)null && ((Behaviour)Instance).enabled, observationOnly: false, (Object)(object)Instance?._performanceOverlayControllerObject != (Object)null, EnablePerformanceOverlay?.Value ?? false);

		internal static bool IsStyleHelperVisible
		{
			get
			{
				Plugin instance = Instance;
				if (instance == null)
				{
					return false;
				}
				return instance._styleHelperWindow?.IsVisible == true;
			}
		}

		private static NativeAssetSweepOwnershipState DetectNativeAssetSweepOwnership()
		{
			bool mainSceneTimerPresent = false;
			bool settingsDurationPresent = false;
			bool unloadUnusedAssetsCallPresent = false;
			try
			{
				Type type = AccessTools.TypeByName("MainSceneManager") ?? AccessTools.TypeByName("AssetLoadingManager");
				Type type2 = AccessTools.TypeByName("SettingsData");
				if (type == null || type2 == null)
				{
					return NativeAssetSweepPolicy.ResolveOwnership(mainSceneTimerPresent, settingsDurationPresent, unloadUnusedAssetsCallPresent, inspectionFailed: true);
				}
				mainSceneTimerPresent = AccessTools.Field(type, "_sweepTimer") != null;
				settingsDurationPresent = AccessTools.Field(type2, "SweepDuration") != null;
				MethodInfo methodInfo = AccessTools.Method(type, "Update", Type.EmptyTypes, (Type[])null);
				if (methodInfo == null)
				{
					return NativeAssetSweepPolicy.ResolveOwnership(mainSceneTimerPresent, settingsDurationPresent, unloadUnusedAssetsCallPresent, inspectionFailed: true);
				}
				foreach (CodeInstruction originalInstruction in PatchProcessor.GetOriginalInstructions((MethodBase)methodInfo, (ILGenerator)null))
				{
					if (originalInstruction.operand is MethodInfo methodInfo2 && string.Equals(methodInfo2.DeclaringType?.FullName, "UnityEngine.Resources", StringComparison.Ordinal) && string.Equals(methodInfo2.Name, "UnloadUnusedAssets", StringComparison.Ordinal) && methodInfo2.GetParameters().Length == 0)
					{
						unloadUnusedAssetsCallPresent = true;
						break;
					}
				}
				return NativeAssetSweepPolicy.ResolveOwnership(mainSceneTimerPresent, settingsDurationPresent, unloadUnusedAssetsCallPresent, inspectionFailed: false);
			}
			catch
			{
				return NativeAssetSweepPolicy.ResolveOwnership(mainSceneTimerPresent, settingsDurationPresent, unloadUnusedAssetsCallPresent, inspectionFailed: true);
			}
		}

		private void Awake()
		{
			Instance = this;
			Log = ((BaseUnityPlugin)this).Logger;
			BindConfig();
			ApplyOneTimeConfigMigration();
			ApplyStyleStateMigration();
			SyncNotificationTimestampsWithChatTimestamps("startup config normalization");
			RegisterBlueSageCommands();
			RefreshCompatibility("initial BepInEx loaded-plugin scan");
			if (NativeAssetSweepOwnershipVerified)
			{
				Log.LogInfo((object)"The native game cleanup timer is present and remains untouched. BlueSage Automatic Cleanup is a separate opt-in loop; explicit manual cleanup remains available when compatibility allows it.");
			}
			else if (NativeAssetSweepDetected)
			{
				Log.LogWarning((object)"Native asset-cleanup inspection is incomplete. BlueSage will not alter native behavior; its separate automatic loop remains opt-in and explicit manual cleanup remains available when compatibility allows it.");
			}
			ApplyHarmonyPatchesFailOpen();
			StartRescueReceiverCapabilityPublisher();
			RestartSweepLoop();
			RestartHostHealthLoop();
			StartCommunityBanListMaintenance();
			StartMentionPingController();
			StartCommandTypeaheadController();
			StartChatReadabilityController();
			StartSessionAuditController();
			StartSessionRunMarkerController();
			StartStewardAnnouncementBridgeController();
			StartCloneShieldController();
			StartPlayerRenderSaverController();
			StartPerformanceOverlayController();
			StartStyleHelperWindow();
			_compatibilityRefreshCoroutine = ((MonoBehaviour)this).StartCoroutine(RefreshCompatibilityAfterLoadSettles());
			StartWelcomeMessageLoop();
			Log.LogInfo((object)string.Format("{0} {1} loaded. Build={2}, NativeAssetSweep={3}, AutoSweep={4}, ChatTweaksAllowed={5}.", "BlueSage QoL Tweaks - Beta", "0.2.4", "0.2.4+20260730.1-public-24414155-release", NativeAssetSweepDetected, AutoSweepAllowed, ChatTweaksAllowed));
		}

		private void ApplyHarmonyPatchesFailOpen()
		{
			Type[] typesFromAssembly = AccessTools.GetTypesFromAssembly(typeof(Plugin).Assembly);
			foreach (Type type in typesFromAssembly)
			{
				bool flag = type.GetCustomAttributes(typeof(HarmonyPatch), inherit: true).Length != 0;
				if (!flag)
				{
					MethodInfo[] methods = type.GetMethods(AccessTools.all);
					for (int j = 0; j < methods.Length; j++)
					{
						if (methods[j].GetCustomAttributes(typeof(HarmonyPatch), inherit: true).Length != 0)
						{
							flag = true;
							break;
						}
					}
				}
				if (flag)
				{
					ApplyHarmonyPatchTypeFailOpen(type);
				}
			}
		}

		private void ApplyHarmonyPatchTypeFailOpen(Type patchType)
		{
			try
			{
				_harmony.CreateClassProcessor(patchType).Patch();
			}
			catch (Exception ex)
			{
				Log.LogError((object)("Harmony patch type '" + patchType.FullName + "' skipped after compatibility failure: " + ex.GetType().Name + ": " + ex.Message + ". Continuing with compatible controllers; Home, Insert, sweep, and menu startup remain available."));
			}
		}

		private void Update()
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			if (PluginShutdownController.IsShuttingDown)
			{
				return;
			}
			SteamRuntimeFacade.CaptureLive();
			if (Input.GetKeyDown((KeyCode)278))
			{
				ToggleQolMenuFromHotkey();
			}
			if (Input.GetKeyDown((KeyCode)277))
			{
				ToggleStyleUiFromHotkey();
			}
			if (Input.GetKeyDown(ManualSweepKey.Value))
			{
				RunSweep("manual hotkey", requireManualPermission: true);
			}
			if (Time.unscaledTime >= _nextModerationCapabilityPublishAt)
			{
				_nextModerationCapabilityPublishAt = Time.unscaledTime + 5f;
				SteamIdModerationController.PublishHostCapability();
				bool isHost;
				bool flag = CanUseLobbySafety(out isHost);
				bool num = _hadLobbySafetyAccess != flag;
				if (_hadLobbySafetyAccess && !flag)
				{
					_pendingModerationAction = null;
				}
				_hadLobbySafetyAccess = flag;
				if (num)
				{
					PlayerIdentityEvidenceController.InvalidateRosterCache();
					PlayerIdentityRoleHighlightController.RefreshAll();
				}
			}
			SteamIdModerationController.PollHostMemberDataRequests();
			CloneIncidentActionController.PollHostMemberDataRequests();
			ChalkboardPersistenceController.PollHostMemberDataRequests();
			IdentityResyncController.Tick();
		}

		private void ToggleQolMenuFromHotkey()
		{
			if ((Object)(object)_qolMenuWindow == (Object)null)
			{
				StartQolMenuWindow();
			}
			if ((Object)(object)_qolMenuWindow == (Object)null)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)"QoL menu hotkey pressed, but QoL menu window could not start.");
				}
				return;
			}
			_qolMenuWindow.ToggleVisible();
			ManualLogSource log2 = Log;
			if (log2 != null)
			{
				log2.LogInfo((object)"QoL menu toggled via Home key.");
			}
		}

		private void ToggleStyleUiFromHotkey()
		{
			string text = ToggleStyleUiFromQolMenu();
			ManualLogSource log = Log;
			if (log != null)
			{
				log.LogInfo((object)("Style Helper toggled via Insert key. " + text));
			}
		}

		private void OnApplicationQuit()
		{
			BeginPluginShutdown("application-quit");
		}

		private void OnDestroy()
		{
			BeginPluginShutdown("destroy");
		}

		private void BeginPluginShutdown(string trigger)
		{
			PluginShutdownController.Begin(trigger, RunSteamShutdownCleanup, RunLocalShutdownCleanup);
		}

		private void RunSteamShutdownCleanup(SteamRuntimeSnapshot snapshot)
		{
			ClearRescueReceiverCapability(snapshot);
			SteamIdModerationController.ClearHostCapabilityForShutdown(snapshot);
			PlayerRoleLabelController.ClearPublishedStateForShutdown(snapshot);
			ClearHostHealthPresenceForShutdown(snapshot);
		}

		private static void ClearHostHealthPresenceForShutdown(SteamRuntimeSnapshot snapshot)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			if (snapshot == null || !snapshot.SteamWasReady || !snapshot.LocalWasOwner || snapshot.Lobby == CSteamID.Nil)
			{
				return;
			}
			try
			{
				SteamMatchmaking.SetLobbyData(snapshot.Lobby, "bluesage_qol_heartbeat", string.Empty);
				SteamMatchmaking.SetLobbyData(snapshot.Lobby, "heartbeat", string.Empty);
			}
			catch
			{
			}
		}

		private void RunLocalShutdownCleanup()
		{
			SessionRunMarkerController.MarkCleanClose();
			if (_rescueReceiverCapabilityCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_rescueReceiverCapabilityCoroutine);
				_rescueReceiverCapabilityCoroutine = null;
			}
			if (_sweepCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_sweepCoroutine);
				_sweepCoroutine = null;
			}
			_sweepSchedule.Reset();
			if (_activeSweepOperationCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_activeSweepOperationCoroutine);
				_activeSweepOperationCoroutine = null;
				_sweepOperationGate.Complete(_sweepOperationGate.ActiveSequence);
			}
			ReleaseSweepBackgroundExecution();
			if (_compatibilityRefreshCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_compatibilityRefreshCoroutine);
				_compatibilityRefreshCoroutine = null;
			}
			if (_managedReconnectCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_managedReconnectCoroutine);
				_managedReconnectCoroutine = null;
			}
			if (_lastLobbyRejoinFallbackCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_lastLobbyRejoinFallbackCoroutine);
				_lastLobbyRejoinFallbackCoroutine = null;
			}
			if (_replacementLobbyDiscoveryCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_replacementLobbyDiscoveryCoroutine);
				_replacementLobbyDiscoveryCoroutine = null;
			}
			if (_cleanMenuReconnectCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_cleanMenuReconnectCoroutine);
				_cleanMenuReconnectCoroutine = null;
			}
			_reconnectMenuFallbackInProgress = false;
			_cleanMenuReconnectActive = false;
			if (_hostHealthCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_hostHealthCoroutine);
				_hostHealthCoroutine = null;
			}
			if (_communityBanListCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_communityBanListCoroutine);
				_communityBanListCoroutine = null;
			}
			if (_reconnectAnnouncementCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_reconnectAnnouncementCoroutine);
				_reconnectAnnouncementCoroutine = null;
			}
			if (_welcomeMessageCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_welcomeMessageCoroutine);
				_welcomeMessageCoroutine = null;
			}
			if ((Object)(object)_mentionPingControllerObject != (Object)null)
			{
				Object.Destroy((Object)(object)_mentionPingControllerObject);
				_mentionPingControllerObject = null;
			}
			if ((Object)(object)_commandTypeaheadControllerObject != (Object)null)
			{
				Object.Destroy((Object)(object)_commandTypeaheadControllerObject);
				_commandTypeaheadControllerObject = null;
			}
			if ((Object)(object)_chatReadabilityControllerObject != (Object)null)
			{
				Object.Destroy((Object)(object)_chatReadabilityControllerObject);
				_chatReadabilityControllerObject = null;
			}
			if ((Object)(object)_cloneShieldControllerObject != (Object)null)
			{
				Object.Destroy((Object)(object)_cloneShieldControllerObject);
				_cloneShieldControllerObject = null;
			}
			if ((Object)(object)_playerRenderSaverControllerObject != (Object)null)
			{
				Object.Destroy((Object)(object)_playerRenderSaverControllerObject);
				_playerRenderSaverControllerObject = null;
			}
			if ((Object)(object)_performanceOverlayControllerObject != (Object)null)
			{
				Object.Destroy((Object)(object)_performanceOverlayControllerObject);
				_performanceOverlayControllerObject = null;
			}
			if ((Object)(object)_sessionAuditControllerObject != (Object)null)
			{
				Object.Destroy((Object)(object)_sessionAuditControllerObject);
				_sessionAuditControllerObject = null;
			}
			if ((Object)(object)_stewardAnnouncementBridgeControllerObject != (Object)null)
			{
				Object.Destroy((Object)(object)_stewardAnnouncementBridgeControllerObject);
				_stewardAnnouncementBridgeControllerObject = null;
			}
			if ((Object)(object)_sessionRunMarkerControllerObject != (Object)null)
			{
				Object.Destroy((Object)(object)_sessionRunMarkerControllerObject);
				_sessionRunMarkerControllerObject = null;
			}
			PlayerRenderSaverController.RestoreAll();
			SelfMovementPatch.CleanupRuntimeState();
			if (EnableNoclipFly != null && EnableNoclipFly.Value)
			{
				EnableNoclipFly.Value = false;
				((BaseUnityPlugin)this).Config.Save();
			}
			HostVisibilityProtocolPatch.RestoreAll();
			PlayerRoleLabelController.RestoreAll();
			PlayerIdentityRoleHighlightController.ClearAll();
			PlayerPanelSurfaceController.ClearAll();
			IdentityResyncController.Reset();
			MiniMapPlayerLabelPatch.ClearAll();
			if ((Object)(object)_styleHelperWindow != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)_styleHelperWindow).gameObject);
				_styleHelperWindow = null;
			}
			if ((Object)(object)_qolMenuWindow != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)_qolMenuWindow).gameObject);
				_qolMenuWindow = null;
			}
			BlueSageUiTheme.ReleaseRuntimeTextures();
			ChatReadabilityPatch.RestoreChatAccessibilityScale();
			ChatReadabilityPatch.RestoreChatFontSize();
			ChatReadabilityPatch.RestoreChatWindowHeight();
			_harmony.UnpatchSelf();
			ManualLogSource log = Log;
			if (log != null)
			{
				log.LogInfo((object)"BlueSage QoL Tweaks - Beta unloaded and Harmony patches removed.");
			}
			Instance = null;
		}

		private void BindConfig()
		{
			EnableAutoSweep = ((BaseUnityPlugin)this).Config.Bind<bool>("Asset Sweep", "EnableAutoSweep", true, "Run BlueSage Automatic Cleanup on its own coordinated 10-minute default timer. Existing saved off choices remain off; manual cleanup remains available.");
			AutoDisableSweepWhenAndrewSweepInstalled = ((BaseUnityPlugin)this).Config.Bind<bool>("Asset Sweep", "AutoDisableSweepWhenAndrewSweepInstalled", true, "Disable BlueSage auto sweep if AndrewLin Sweep is installed. On by default to avoid double sweeping.");
			AllowManualSweepWhenAndrewSweepInstalled = ((BaseUnityPlugin)this).Config.Bind<bool>("Asset Sweep", "AllowManualSweepWhenAndrewSweepInstalled", true, "Allow manual BlueSage cleanup when AndrewLin Sweep is installed. Compatibility guards still apply; Automatic Cleanup does not authorize manual actions.");
			SweepIntervalMinutes = ((BaseUnityPlugin)this).Config.Bind<int>("Asset Sweep", "SweepIntervalMinutes", 10, "Minutes between BlueSage automatic cleanups. Safe range 5 to 180. Used only when BlueSage Automatic Cleanup is explicitly enabled; the game native interval is never changed.");
			EnableManualSweepHotkey = ((BaseUnityPlugin)this).Config.Bind<bool>("Asset Sweep", "EnableManualSweepHotkey", true, "Deprecated compatibility key retained so existing configs still load. ManualSweepKey always remains active; menu and slash-command cleanup remain available.");
			ManualSweepKey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("Asset Sweep", "ManualSweepKey", (KeyCode)289, "Hotkey for manual sweep.");
			EnableVivoxPositionRateGuard = ((BaseUnityPlugin)this).Config.Bind<bool>("Performance Safety", "EnableVivoxPositionRateGuard", true, "Coalesce the game's per-frame Vivox 3D-position requests to the Unity-recommended 4 Hz. Disable only for compatibility testing.");
			EnableChatTimestamps = ((BaseUnityPlugin)this).Config.Bind<bool>("Chat", "EnableChatTimestamps", true, "Add local timestamps before player names.");
			EnableNotificationTimestamps = ((BaseUnityPlugin)this).Config.Bind<bool>("Chat", "EnableNotificationTimestamps", true, "Add local timestamps before system notifications.");
			Use24HourTime = ((BaseUnityPlugin)this).Config.Bind<bool>("Chat", "Use24HourTime", false, "Use 24-hour timestamps when timestamp features are enabled. Off uses 12-hour time with AM/PM.");
			TimestampSizePercent = ((BaseUnityPlugin)this).Config.Bind<int>("Chat", "TimestampSizePercent", 60, "Timestamp text size percentage. Clamped from 40 to 100.");
			TimestampColor = ((BaseUnityPlugin)this).Config.Bind<string>("Chat", "TimestampColor", "F5EDE1", "Timestamp color as a six-character hex code.");
			AutoDisableChatTweaksWhenSimpleQoLInstalled = ((BaseUnityPlugin)this).Config.Bind<bool>("Chat", "AutoDisableChatTweaksWhenSimpleQoLInstalled", true, "Disable BlueSage timestamps and leave notices if Simple_QOL/ChatTweaks-style mods are installed.");
			EnableChatReadability = ((BaseUnityPlugin)this).Config.Bind<bool>("Chat Readability", "EnableChatReadability", true, "Add local outline and shadow to chat text so white or colored messages stay readable on bright backgrounds.");
			EnablePersistentChatBackdrop = ((BaseUnityPlugin)this).Config.Bind<bool>("Chat Readability", "EnablePersistentChatBackdrop", true, "Keep the local chat panel/backdrop easier to read when the game exposes it. Local UI only; does not rewrite messages.");
			ChatOutlineIntensity = ((BaseUnityPlugin)this).Config.Bind<int>("Chat Readability", "ChatOutlineIntensity", 75, "Chat outline strength from 25 to 100. Default 75 keeps chat readable with a stronger outline; 100 is the crispest outline.");
			ChatUiScalePercent = ((BaseUnityPlugin)this).Config.Bind<int>("Chat Readability", "ChatUiScalePercent", 100, "Local chat UI accessibility scale from 75 to 200 percent. Default 100 keeps vanilla sizing; larger values enlarge the chat panel and visible message text.");
			ChatFontSizePercent = ((BaseUnityPlugin)this).Config.Bind<int>("Chat Readability", "ChatFontSizePercent", 100, "Local chat message font size from 75 to 200 percent. Default 100 keeps vanilla text size; larger values enlarge message text without scaling the whole chat shell.");
			ChatWindowHeightPercent = ((BaseUnityPlugin)this).Config.Bind<int>("Chat Readability", "ChatWindowHeightPercent", 100, "Local chat window height from 100 to 200 percent. Default 100 keeps vanilla size; larger values add vertical chat space without scaling text.");
			ChatHistoryRows = ((BaseUnityPlugin)this).Config.Bind<int>("Chat Readability", "ChatHistoryRows", 150, "Retained chat rows from 25 to 250. Default 150 balances useful scrollback with large-lobby UI cost; BlueSage never lowers a higher vanilla or other-mod limit.");
			ChatOutlineColor = ((BaseUnityPlugin)this).Config.Bind<string>("Chat Readability", "ChatOutlineColor", "000000", "Six-character hex color for the normal local chat outline path. Default 000000.");
			BlackChatOutlineColor = ((BaseUnityPlugin)this).Config.Bind<string>("Chat Readability", "BlackChatOutlineColor", "C0C0C0", "Six-character hex color for true-black styled chat/name outline path. Default C0C0C0 light grey.");
			BlackNamesOutline = ((BaseUnityPlugin)this).Config.Bind<bool>("Chat Readability", "BlackNamesOutline", true, "Use the black-text outline color for true-black chat/name rows. On by default so black styled names and messages stay readable; turn off to force the normal outline color.");
			EnableBetterMove = ((BaseUnityPlugin)this).Config.Bind<bool>("BetterMove", "EnableBetterMove", true, "Hold Shift to run or Ctrl to slow-walk. This changes only your character and is safe to turn off.");
			EnableUnlimitedConsumables = ((BaseUnityPlugin)this).Config.Bind<bool>("Consumables", "EnableUnlimitedConsumables", true, "Once you own a canteen item or chalk color, using it no longer lowers its count. Clothing, bait, rods, and bobbers stay vanilla. Turn this off to restore normal item use immediately.");
			EnableNoclipFly = ((BaseUnityPlugin)this).Config.Bind<bool>("Self Movement", "EnableNoclipFly", false, "Self-only noclip/fly mode. Always reset off when BlueSage loads or unloads. Controls: WASD, Space/E up, Ctrl/Q down, Shift boost, Alt precision.");
			SelfSavedPosition = ((BaseUnityPlugin)this).Config.Bind<string>("Self Movement", "SavedPosition", string.Empty, "Local saved self-teleport position in x,y,z format.");
			SelfSpeedMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Self Movement", "SpeedMultiplier", 1f, "Self-only movement speed multiplier. 1 is vanilla; range 0.25 to 5.");
			SelfJumpMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Self Movement", "JumpMultiplier", 1f, "Self-only jump-height multiplier. 1 is vanilla; range 0.25 to 5.");
			SelfGravityMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Self Movement", "GravityMultiplier", 1f, "Self-only gravity/fall multiplier. 1 is vanilla; range 0.1 to 5.");
			if (EnableNoclipFly.Value)
			{
				EnableNoclipFly.Value = false;
				((BaseUnityPlugin)this).Config.Save();
			}
			StatusBaseName = ((BaseUnityPlugin)this).Config.Bind<string>("Status Helper", "StatusBaseName", string.Empty, "Base display name used by BlueSage /setname and /status.");
			StatusMessage = ((BaseUnityPlugin)this).Config.Bind<string>("Status Helper", "StatusMessage", string.Empty, "Current BlueSage status text appended to your display name.");
			StatusColor = ((BaseUnityPlugin)this).Config.Bind<string>("Status Helper", "StatusColor", "FFD45D", "Six-character hex color for BlueSage status text.");
			StatusBrackets = ((BaseUnityPlugin)this).Config.Bind<string>("Status Helper", "StatusBrackets", "()", "Two characters used around BlueSage status text.");
			EnableSpoons = ((BaseUnityPlugin)this).Config.Bind<bool>("Spoons", "EnableSpoons", false, "Optional compact social-battery tag for your BlueSage display name. Use /spoons on, Save Spoons, or Show Tag if you want it visible.");
			SpoonCount = ((BaseUnityPlugin)this).Config.Bind<int>("Spoons", "SpoonCount", 5, "Social battery from 0 to 5. Use /spoons 3 or Style Helper > Status.");
			SpoonLabel = ((BaseUnityPlugin)this).Config.Bind<string>("Spoons", "SpoonLabel", "sp", "Short custom label used after 0/5. Use /setmood label; default is sp.");
			SpoonsUpdatedUtc = ((BaseUnityPlugin)this).Config.Bind<string>("Spoons", "SpoonsUpdatedUtc", string.Empty, "UTC timestamp for the last spoon update.");
			EnableStyleUi = ((BaseUnityPlugin)this).Config.Bind<bool>("Style Helper", "EnableStyleUi", true, "Enable the BlueSage /styleui preset and clipboard helper window.");
			EnableExtendedAvatarStyles = ((BaseUnityPlugin)this).Config.Bind<bool>("Avatar Styles", "EnableExtendedAvatarStyles", true, "Add reversible avatar preset slots 4-9 while preserving vanilla slots 1-3.");
			EnableChalkboardPersistence = ((BaseUnityPlugin)this).Config.Bind<bool>("Chalkboards", "EnableChalkboardPersistence", true, "Save chalkboards locally. Only the host can restore a saved board for the lobby. Automatically stands down when Chalky is installed.");
			MaxChatCharacters = ((BaseUnityPlugin)this).Config.Bind<int>("Text Limits", "MaxChatCharacters", 3000, "Default 3000. Advanced users may raise this up to 4000, but longer chat can behave oddly with UI wrapping, rich-text tags, or future game updates.");
			MaxProfileCharacters = ((BaseUnityPlugin)this).Config.Bind<int>("Text Limits", "MaxProfileCharacters", 3000, "Default 3000 for names, ID cards, and styled profile text. Raising this up to 4000 is optional and may be unstable in some UI fields.");
			MaxSessionNameCharacters = ((BaseUnityPlugin)this).Config.Bind<int>("Text Limits", "MaxSessionNameCharacters", 3000, "Default 3000 for room/session names. Raising this up to 4000 is optional and may be unstable or visually messy.");
			EnableLeaveNotifications = ((BaseUnityPlugin)this).Config.Bind<bool>("Notifications", "EnableLeaveNotifications", true, "Show a local notification when a player leaves. Auto-disabled when overlapping chat mods are detected.");
			EnableWelcomeMessage = ((BaseUnityPlugin)this).Config.Bind<bool>("Notifications", "EnableWelcomeMessage", true, "Show BlueSage QoL navigation tips once each time you join a lobby.");
			EnableReconnectGuard = ((BaseUnityPlugin)this).Config.Bind<bool>("Reconnect Guard", "EnableReconnectGuard", true, "Try one guarded rejoin after the game reports a real disconnect, then stop safely if the lobby is not playable.");
			EnableReconnectAnnouncement = ((BaseUnityPlugin)this).Config.Bind<bool>("Reconnect Guard", "EnableReconnectAnnouncement", true, "Send a small in-game chat message after BlueSage auto reconnect succeeds.");
			EnableHostHealthMonitor = ((BaseUnityPlugin)this).Config.Bind<bool>("Host Health", "EnableHostHealthMonitor", true, "Quiet background checks for long-running lobbies. Most useful for hosts; use /hh run for a manual check.");
			EnableCommunityBanListSync = ((BaseUnityPlugin)this).Config.Bind<bool>("Lobby Safety", "EnableCommunityBanListSync", false, "Off by default. Any QoL client may opt in to periodic local validation of the AndrewLimForFun On-Together community BanData source. Validation is atomic and appends only missing pairs to this client's native ban store. Existing rows are never changed or removed; refresh never kicks, bans, or grants authority.");
			EnableFocusAnywhere = ((BaseUnityPlugin)this).Config.Bind<bool>("Focus Anywhere", "EnableFocusAnywhere", true, "Allow focus mode from most places instead of only vanilla focus surfaces.");
			EnableEnhancedPlayerPanel = ((BaseUnityPlugin)this).Config.Bind<bool>("Enhanced Player Panel", "EnableEnhancedPlayerPanel", true, "Add local @mention and ID-card buttons, plus a verified Steam-ID tooltip on the native green profile button. Native player-panel actions remain available.");
			EnableEnhancedPlayerPanel.SettingChanged += delegate
			{
				if (!EnableEnhancedPlayerPanel.Value)
				{
					PlayerPanelSurfaceController.ClearAll();
				}
			};
			EnableCloneShield = ((BaseUnityPlugin)this).Config.Bind<bool>("Enhanced Player Panel", "EnableCloneShield", true, "Send one cautious public alert when someone newly matches your full avatar/outfit or exact styled name. The alert is a clue, not an automatic moderation action.");
			EnablePlayerRenderSaver = ((BaseUnityPlugin)this).Config.Bind<bool>("Performance", "EnablePlayerRenderSaver", false, "EXPERIMENTAL opt-in: locally hide far/overflow remote player renderers in very large lobbies while keeping chat and player-list rows visible.");
			EnablePerformanceOverlay = ((BaseUnityPlugin)this).Config.Bind<bool>("Performance Overlay", "EnablePerformanceOverlay", true, "Show the public draggable FPS/PING/RAM bar. Hosts honestly show PING -- because they have no remote round trip; clients show active-session RTT when available.");
			PerformanceOverlayRefreshSeconds = ((BaseUnityPlugin)this).Config.Bind<float>("Performance Overlay", "RefreshSeconds", 0.25f, "Overlay refresh interval. Runtime clamps 0.25 to 5 seconds.");
			PerformanceOverlayFontSize = ((BaseUnityPlugin)this).Config.Bind<int>("Performance Overlay", "FontSize", 13, "Overlay font size. Runtime clamps 8 to 32.");
			PerformanceOverlayOffsetX = ((BaseUnityPlugin)this).Config.Bind<float>("Performance Overlay", "OffsetX", 12f, "Saved draggable overlay X position.");
			PerformanceOverlayOffsetY = ((BaseUnityPlugin)this).Config.Bind<float>("Performance Overlay", "OffsetY", 174f, "Saved draggable overlay Y position.");
			PerformanceOverlayWidth = ((BaseUnityPlugin)this).Config.Bind<float>("Performance Overlay", "Width", 320f, "Overlay width. Runtime keeps at least 320 pixels so FPS/PING/RAM remain one straight line.");
			PlayerRenderSaverRadiusMeters = ((BaseUnityPlugin)this).Config.Bind<int>("Performance", "PlayerRenderSaverRadiusMeters", 45, "Player Render Saver keeps remote players inside this distance visible. Safe range 10 to 250 meters.");
			PlayerRenderSaverMaxVisiblePlayers = ((BaseUnityPlugin)this).Config.Bind<int>("Performance", "PlayerRenderSaverMaxVisiblePlayers", 32, "Player Render Saver also keeps this many closest remote players visible. Safe range 1 to 128.");
			EnablePingMentions = ((BaseUnityPlugin)this).Config.Bind<bool>("Ping Mentions", "EnablePingMentions", true, "Highlight personal mentions, offer simple autocomplete, and play a local ping sound when you are mentioned. Lobby-wide pings are limited to the current host and assigned Helpers.");
			EnablePingSound = ((BaseUnityPlugin)this).Config.Bind<bool>("Ping Mentions", "EnablePingSound", true, "Play the local UI ping sound when a message mentions you.");
			PingHighlightColor = ((BaseUnityPlugin)this).Config.Bind<string>("Ping Mentions", "PingHighlightColor", "9B59B6", "Six-character hex color for mentioned-message background highlight.");
			PingMentionColor = ((BaseUnityPlugin)this).Config.Bind<string>("Ping Mentions", "PingMentionColor", "FFD700", "Six-character hex color for @mention text.");
			PingSoundMode = ((BaseUnityPlugin)this).Config.Bind<string>("Ping Mentions", "PingSoundMode", "ticket", "Local mention ping sound: click, change, error, task, or ticket. Default ticket. Use /pingsound off to mute.");
			LobbyHelpers = ((BaseUnityPlugin)this).Config.Bind<string>("Helpers", "LobbyHelpers", string.Empty, "Exact SteamID64 values assigned by the current lobby host. Helpers may use @lobby and request host-validated moderation actions.");
			LobbyHelperOwnerSteamId = ((BaseUnityPlugin)this).Config.Bind<string>("Helpers", "LobbyHelperOwnerSteamId", string.Empty, "Steam ID of the host who granted the helper list; prevents permissions carrying across unrelated hosts.");
			LobbyPingDelegates = ((BaseUnityPlugin)this).Config.Bind<string>("Legacy Helpers", "LobbyPingDelegates", string.Empty, "Legacy @lobby helper list. BlueSage imports matching host-scoped entries into Helpers.");
			LobbyPingDelegateOwnerSteamId = ((BaseUnityPlugin)this).Config.Bind<string>("Legacy Helpers", "LobbyPingDelegateOwnerSteamId", string.Empty, "Legacy @lobby helper host scope retained for safe migration.");
			LobbyModerationDelegates = ((BaseUnityPlugin)this).Config.Bind<string>("Legacy Helpers", "LobbyModerationDelegates", string.Empty, "Legacy moderation helper list. BlueSage imports matching host-scoped entries into Helpers.");
			LobbyModerationDelegateOwnerSteamId = ((BaseUnityPlugin)this).Config.Bind<string>("Legacy Helpers", "LobbyModerationDelegateOwnerSteamId", string.Empty, "Legacy moderation helper host scope retained for safe migration.");
			EnableChatCopy = ((BaseUnityPlugin)this).Config.Bind<bool>("Chat Copy", "EnableChatCopy", true, "Ctrl-left-click a chat message to copy only its text while plain left-click stays with the vanilla ID card. Right-click remains supported where the game delivers it. Local-only; no names, timestamps, or status labels.");
			EnableChatUrlLinks = ((BaseUnityPlugin)this).Config.Bind<bool>("Chat Copy", "EnableChatUrlLinks", true, "Highlight safe http/https links. Shift-left-click once copies and warns; repeat within 10 seconds to open. Plain left-click remains the vanilla ID card.");
			EnableMiniMapPlayerLabels = ((BaseUnityPlugin)this).Config.Bind<bool>("MiniMap", "EnableMiniMapPlayerLabels", true, "Local minimap ID-click helper. Dot click can open ID cards when player index data resolves safely. Floating name labels were removed because they can cause FPS/CPU lag in large lobbies.");
			EnableMiniMapPlayerLabels.SettingChanged += delegate
			{
				if (!EnableMiniMapPlayerLabels.Value)
				{
					MiniMapPlayerLabelPatch.ClearAll();
				}
			};
			EnableMiniMapFriendColors = ((BaseUnityPlugin)this).Config.Bind<bool>("MiniMap", "EnableMiniMapFriendColors", true, "Color Steam friends green on the local minimap using cached Steam relationship checks. Automatically stands down when MinimapFriends is installed.");
			UiThemePreset = ((BaseUnityPlugin)this).Config.Bind<string>("Style Helper", "UiThemePreset", "BlueSage Harbor", "Menu theme: BlueSage Harbor, Midnight Dock, Vanilla Cream OT, or OG. Existing saved choices are preserved.");
			EnableHiddenDiagnostics = ((BaseUnityPlugin)this).Config.Bind<bool>("Developer", "EnableHiddenDiagnostics", true, "Locked on through 0.2.x Early Access so community logs retain consistent privacy-safe troubleshooting breadcrumbs. /bluedevdebug off explains the release lock and keeps this enabled.");
			EnableHiddenDiagnostics.SettingChanged += delegate
			{
				EnforceHiddenDiagnosticsLockedOn();
			};
			EnableLocalAuditExports = ((BaseUnityPlugin)this).Config.Bind<bool>("Local Audit", "EnableLocalAuditExports", true, "Export a bounded local chat/notification JSONL transcript and running BepInEx log mirror. Exact SteamID/persona enrichment is added only while you are the verified host or an assigned Helper. Never uploaded automatically; /auditlog controls it.");
			EnableStewardAnnouncementBridge = ((BaseUnityPlugin)this).Config.Bind<bool>("Local Steward", "EnableStewardAnnouncementBridge", false, "Accept authenticated local-only supporter announcements from the BlueSage Steward pipe. Off by default and Host-owned Global notification only.");
			StewardBridgeKeyPath = ((BaseUnityPlugin)this).Config.Bind<string>("Local Steward", "StewardBridgeKeyPath", string.Empty, "Absolute path to a DPAPI CurrentUser-protected bridge key bundle outside the mod package.");
			StewardBridgeServiceIdentity = ((BaseUnityPlugin)this).Config.Bind<string>("Local Steward", "StewardBridgeServiceIdentity", string.Empty, "Optional Windows service account allowed to write to the local steward pipe. Empty restricts access to the current Windows user.");
			EnableLocalAuditExports.SettingChanged += delegate
			{
				SessionAuditController.ReconcileEnabledState();
			};
			ConfigMigrationVersion = ((BaseUnityPlugin)this).Config.Bind<string>("Internal", "ConfigMigrationVersion", string.Empty, "Tracks one-time BlueSage QoL default migrations. Safe to ignore.");
			StatusBaseNameLegacyBackup = ((BaseUnityPlugin)this).Config.Bind<string>("Internal", "StatusBaseNameLegacyBackup", string.Empty, "One local rollback copy of a malformed pre-0.2.0 styled base repaired by BlueSage. Safe to leave unchanged.");
			StyleStateMigrationVersion = ((BaseUnityPlugin)this).Config.Bind<string>("Internal", "StyleStateMigrationVersion", string.Empty, "Tracks the idempotent pre-0.2.0 style-state repair. Safe to ignore.");
		}

		private void ApplyOneTimeConfigMigration()
		{
			bool alreadyMigrated = ConfigMigrationPolicy.HasCompletedMigration(ConfigMigrationVersion?.Value, "final-defaults-v2");
			bool alreadyMigrated2 = ConfigMigrationPolicy.HasCompletedMigration(ConfigMigrationVersion?.Value, "sweep-15-default-v1");
			bool alreadyMigrated3 = ConfigMigrationPolicy.HasCompletedMigration(ConfigMigrationVersion?.Value, "sweep-10-safety-v2");
			bool alreadyMigrated4 = ConfigMigrationPolicy.HasCompletedMigration(ConfigMigrationVersion?.Value, "sweep-auto-opt-in-v3");
			bool alreadyMigrated5 = ConfigMigrationPolicy.HasCompletedMigration(ConfigMigrationVersion?.Value, "community-ban-any-client-opt-in-v1");
			bool flag = false;
			if (SweepIntervalMinutes != null)
			{
				int configuredMinutes = SweepSettingsPolicy.MigrateLegacyDefaultIntervalMinutes(SweepIntervalMinutes.Value, alreadyMigrated2);
				configuredMinutes = SweepSettingsPolicy.MigrateTenMinuteSafetyInterval(configuredMinutes, alreadyMigrated3);
				if (configuredMinutes != SweepIntervalMinutes.Value)
				{
					SweepIntervalMinutes.Value = configuredMinutes;
					flag = true;
				}
			}
			if (EnableAutoSweep != null)
			{
				bool flag2 = SweepSettingsPolicy.MigrateAutomaticCleanupOptIn(EnableAutoSweep.Value, alreadyMigrated4);
				if (flag2 != EnableAutoSweep.Value)
				{
					EnableAutoSweep.Value = flag2;
					flag = true;
				}
			}
			if (ChatOutlineIntensity != null)
			{
				int currentValue = ConfigMigrationPolicy.MigrateOldDefaultInt(ChatOutlineIntensity.Value, 50, 75, alreadyMigrated);
				currentValue = ConfigMigrationPolicy.MigrateOldDefaultInt(currentValue, 60, 75, alreadyMigrated);
				if (currentValue != ChatOutlineIntensity.Value)
				{
					ChatOutlineIntensity.Value = currentValue;
					flag = true;
				}
			}
			if (ChatUiScalePercent != null)
			{
				int num = ChatAccessibilityScalePolicy.ClampScalePercent(ChatUiScalePercent.Value);
				if (num != ChatUiScalePercent.Value)
				{
					ChatUiScalePercent.Value = num;
					flag = true;
				}
			}
			if (ChatFontSizePercent != null)
			{
				int num2 = ChatFontSizePolicy.ClampFontSizePercent(ChatFontSizePercent.Value);
				if (num2 != ChatFontSizePercent.Value)
				{
					ChatFontSizePercent.Value = num2;
					flag = true;
				}
			}
			if (ChatWindowHeightPercent != null)
			{
				int num3 = ChatWindowHeightPolicy.ClampHeightPercent(ChatWindowHeightPercent.Value);
				if (num3 != ChatWindowHeightPercent.Value)
				{
					ChatWindowHeightPercent.Value = num3;
					flag = true;
				}
			}
			if (ChatHistoryRows != null)
			{
				int num4 = ConfigMigrationPolicy.MigrateOldDefaultInt(ChatHistoryRows.Value, 100, 150, alreadyMigrated);
				if (num4 != ChatHistoryRows.Value)
				{
					ChatHistoryRows.Value = num4;
					flag = true;
				}
			}
			if (BlackChatOutlineColor != null)
			{
				string text = ConfigMigrationPolicy.MigrateOldDefaultString(BlackChatOutlineColor.Value, "FFFFFF", "C0C0C0", alreadyMigrated);
				if (!string.Equals(text, BlackChatOutlineColor.Value, StringComparison.OrdinalIgnoreCase))
				{
					BlackChatOutlineColor.Value = text;
					flag = true;
				}
			}
			if (Use24HourTime != null)
			{
				bool flag3 = ConfigMigrationPolicy.MigrateOldDefaultBool(Use24HourTime.Value, oldDefault: true, newDefault: false, alreadyMigrated);
				if (flag3 != Use24HourTime.Value)
				{
					Use24HourTime.Value = flag3;
					flag = true;
				}
			}
			if (EnableExtendedAvatarStyles != null)
			{
				bool flag4 = ConfigMigrationPolicy.MigrateOldDefaultBool(EnableExtendedAvatarStyles.Value, oldDefault: false, newDefault: true, alreadyMigrated);
				if (flag4 != EnableExtendedAvatarStyles.Value)
				{
					EnableExtendedAvatarStyles.Value = flag4;
					flag = true;
				}
			}
			if (EnableChalkboardPersistence != null)
			{
				bool flag5 = ConfigMigrationPolicy.MigrateOldDefaultBool(EnableChalkboardPersistence.Value, oldDefault: false, newDefault: true, alreadyMigrated);
				if (flag5 != EnableChalkboardPersistence.Value)
				{
					EnableChalkboardPersistence.Value = flag5;
					flag = true;
				}
			}
			if (PlayerRenderSaverRadiusMeters != null)
			{
				int num5 = PlayerRenderSaverPolicy.ClampRadiusMeters(PlayerRenderSaverRadiusMeters.Value);
				if (num5 != PlayerRenderSaverRadiusMeters.Value)
				{
					PlayerRenderSaverRadiusMeters.Value = num5;
					flag = true;
				}
			}
			if (PlayerRenderSaverMaxVisiblePlayers != null)
			{
				int num6 = PlayerRenderSaverPolicy.ClampMaxVisiblePlayers(PlayerRenderSaverMaxVisiblePlayers.Value);
				if (num6 != PlayerRenderSaverMaxVisiblePlayers.Value)
				{
					PlayerRenderSaverMaxVisiblePlayers.Value = num6;
					flag = true;
				}
			}
			if (EnableHiddenDiagnostics != null && !EnableHiddenDiagnostics.Value)
			{
				EnableHiddenDiagnostics.Value = true;
				flag = true;
			}
			if (MaxChatCharacters != null)
			{
				int currentValue2 = ConfigMigrationPolicy.MigrateOldDefaultInt(MaxChatCharacters.Value, 1500, 3000, alreadyMigrated);
				currentValue2 = ConfigMigrationPolicy.MigrateOldDefaultInt(currentValue2, 2000, 3000, alreadyMigrated);
				if (currentValue2 != MaxChatCharacters.Value)
				{
					MaxChatCharacters.Value = currentValue2;
					flag = true;
				}
			}
			if (MaxProfileCharacters != null)
			{
				int currentValue3 = ConfigMigrationPolicy.MigrateOldDefaultInt(MaxProfileCharacters.Value, 1500, 3000, alreadyMigrated);
				currentValue3 = ConfigMigrationPolicy.MigrateOldDefaultInt(currentValue3, 2000, 3000, alreadyMigrated);
				if (currentValue3 != MaxProfileCharacters.Value)
				{
					MaxProfileCharacters.Value = currentValue3;
					flag = true;
				}
			}
			if (MaxSessionNameCharacters != null)
			{
				int currentValue4 = ConfigMigrationPolicy.MigrateOldDefaultInt(MaxSessionNameCharacters.Value, 1500, 3000, alreadyMigrated);
				currentValue4 = ConfigMigrationPolicy.MigrateOldDefaultInt(currentValue4, 2000, 3000, alreadyMigrated);
				if (currentValue4 != MaxSessionNameCharacters.Value)
				{
					MaxSessionNameCharacters.Value = currentValue4;
					flag = true;
				}
			}
			if (PingSoundMode != null)
			{
				string text2 = ConfigMigrationPolicy.MigrateOldDefaultString(PingSoundMode.Value, "click", "ticket", alreadyMigrated);
				if (!string.Equals(text2, PingSoundMode.Value, StringComparison.Ordinal))
				{
					PingSoundMode.Value = text2;
					flag = true;
				}
			}
			if (EnableSpoons != null && ConfigMigrationPolicy.ShouldDisableDefaultSpoons(EnableSpoons.Value, SpoonsUpdatedUtc?.Value, alreadyMigrated))
			{
				EnableSpoons.Value = false;
				flag = true;
			}
			if (EnableCommunityBanListSync != null)
			{
				bool flag6 = ConfigMigrationPolicy.MigrateOldDefaultBool(EnableCommunityBanListSync.Value, oldDefault: true, newDefault: false, alreadyMigrated5);
				if (flag6 != EnableCommunityBanListSync.Value)
				{
					EnableCommunityBanListSync.Value = flag6;
					flag = true;
				}
			}
			string ledger = ConfigMigrationPolicy.RecordMigration(ConfigMigrationVersion?.Value, "final-defaults-v2");
			ledger = ConfigMigrationPolicy.RecordMigration(ledger, "sweep-15-default-v1");
			ledger = ConfigMigrationPolicy.RecordMigration(ledger, "sweep-10-safety-v2");
			ledger = ConfigMigrationPolicy.RecordMigration(ledger, "sweep-auto-opt-in-v3");
			ledger = ConfigMigrationPolicy.RecordMigration(ledger, "community-ban-any-client-opt-in-v1");
			if (ConfigMigrationVersion != null && !string.Equals(ConfigMigrationVersion.Value, ledger, StringComparison.Ordinal))
			{
				ConfigMigrationVersion.Value = ledger;
				flag = true;
			}
			if (flag)
			{
				((BaseUnityPlugin)this).Config.Save();
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogInfo((object)"Applied BlueSage QoL one-time config migration for release defaults.");
				}
			}
		}

		private void StartWelcomeMessageLoop()
		{
			if (_welcomeMessageCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_welcomeMessageCoroutine);
			}
			_welcomeMessageCoroutine = ((MonoBehaviour)this).StartCoroutine(WelcomeMessageLoop());
		}

		private IEnumerator WelcomeMessageLoop()
		{
			yield return (object)new WaitForSecondsRealtime(4f);
			while (true)
			{
				if (EnableWelcomeMessage == null || !EnableWelcomeMessage.Value)
				{
					ResetWelcomeMessageLobbyState();
					yield return (object)new WaitForSecondsRealtime(2f);
					continue;
				}
				if (TryGetCurrentLobbyKeyForWelcomeMessage(out var lobbyKey))
				{
					if (!string.Equals(_welcomeLobbyKey, lobbyKey, StringComparison.Ordinal))
					{
						_welcomeLobbyKey = lobbyKey;
						_welcomeMessageShownForLobby = false;
						_welcomePrimaryShownForLobby = false;
						_welcomeContextShownForLobby = false;
						_welcomeVoiceStateLogKey = string.Empty;
					}
					if (!_welcomeMessageShownForLobby)
					{
						_welcomeMessageShownForLobby = ShowWelcomeMessageForLobby();
					}
				}
				else
				{
					ResetWelcomeMessageLobbyState();
				}
				yield return (object)new WaitForSecondsRealtime(2f);
			}
		}

		private void ResetWelcomeMessageLobbyState()
		{
			_welcomeLobbyKey = string.Empty;
			_welcomeMessageShownForLobby = false;
			_welcomePrimaryShownForLobby = false;
			_welcomeContextShownForLobby = false;
			_welcomeVoiceStateLogKey = string.Empty;
		}

		private static bool TryGetCurrentLobbyKeyForWelcomeMessage(out string lobbyKey)
		{
			lobbyKey = string.Empty;
			MultiplayerManager val = null;
			try
			{
				val = MonoSingleton<MultiplayerManager>.I;
				if ((Object)(object)val != (Object)null && val.LobbyStatus)
				{
					string lobbyCode = val.LobbyCode;
					if (!string.IsNullOrWhiteSpace(lobbyCode))
					{
						lobbyKey = "code:" + lobbyCode.Trim();
						return true;
					}
				}
			}
			catch
			{
			}
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			if (TryGetVisibleLobbyCounts(out var memberCount, out var _) && memberCount.HasValue && memberCount.Value >= 1)
			{
				lobbyKey = "visible-lobby";
				return true;
			}
			return false;
		}

		private bool ShowWelcomeMessageForLobby()
		{
			bool flag = (_welcomePrimaryShownForLobby = _welcomePrimaryShownForLobby || AddLocalNotification(NavigationCalloutPolicy.BuildPrimaryWelcomeMessage("0.2.4")));
			bool flag2 = _welcomeContextShownForLobby;
			if (!flag2)
			{
				string text = BuildVoiceWelcomeGuidance();
				flag2 = AddLocalNotification("Tip: " + text + " The game's Pomodoro/focus timer can earn tickets and XP for focus time; " + NavigationCalloutPolicy.BuildCommandBrowserHint() + " Quick status: /brb, /afk, /back. Local audit starts on; /auditlog status shows your private local logs. Green Steam-profile buttons verify player accounts.");
			}
			_welcomeContextShownForLobby = flag2;
			return flag && flag2;
		}

		private string BuildVoiceWelcomeGuidance()
		{
			bool? flag = null;
			bool? flag2 = null;
			bool? flag3 = null;
			try
			{
				SettingsData val = MonoSingleton<DataManager>.I?.SettingsData;
				if (val != null)
				{
					flag = val.PushToTalk;
					flag2 = val.VoiceChat;
				}
				VoiceManager i = MonoSingleton<VoiceManager>.I;
				if ((Object)(object)i != (Object)null)
				{
					flag3 = !i.IsVoiceLobbyOff;
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogDebug((object)("Welcome voice-state read deferred safely: " + ex.GetType().Name + ": " + ex.Message));
				}
			}
			string text = ((flag == true) ? "Push to Talk" : ((flag == false) ? "Voice Activation" : "not ready"));
			string text2 = ((flag3 == true) ? "on" : ((flag3 == false) ? "off" : "starting"));
			string text3 = ((flag2 == true) ? "on" : ((flag2 == false) ? "off" : "unknown"));
			string text4 = _welcomeLobbyKey + "|" + text2 + "|" + text + "|" + text3;
			if (!string.Equals(_welcomeVoiceStateLogKey, text4, StringComparison.Ordinal))
			{
				_welcomeVoiceStateLogKey = text4;
				ManualLogSource log2 = Log;
				if (log2 != null)
				{
					log2.LogInfo((object)("Welcome voice-state check: lobbyVoice=" + text2 + ", micMode=" + text + ", voicePlayback=" + text3 + ". No microphone device name was logged."));
				}
			}
			return VoiceWelcomePolicy.Build(flag2, flag3, flag);
		}

		private void RefreshCompatibility(string source)
		{
			string[] array = Chainloader.PluginInfos.Keys.ToArray();
			PluginCompatibilityResult compatibility = _compatibility;
			_compatibility = PluginCompatibility.Evaluate(array, AutoDisableSweepWhenAndrewSweepInstalled.Value, AllowManualSweepWhenAndrewSweepInstalled.Value, AutoDisableChatTweaksWhenSimpleQoLInstalled.Value);
			Log.LogInfo((object)$"Compatibility scan ({source}) checked {array.Length} loaded BepInEx plugin IDs only. Disabled, renamed, old, or backup DLL files are ignored.");
			foreach (string reason in _compatibility.Reasons)
			{
				Log.LogWarning((object)reason);
			}
			if (IsPluginLoaded("com.jai.ontogether.copychat"))
			{
				Log.LogWarning((object)"Legacy CopyChat is loaded; BlueSage Chat Copy is disabled to avoid duplicate click handlers.");
			}
			if (compatibility != null && (compatibility.AutoSweepAllowed != _compatibility.AutoSweepAllowed || compatibility.ManualSweepAllowed != _compatibility.ManualSweepAllowed || compatibility.ChatTweaksAllowed != _compatibility.ChatTweaksAllowed || compatibility.HostHealthRepairsAllowed != _compatibility.HostHealthRepairsAllowed))
			{
				Log.LogInfo((object)("Compatibility changed after " + source + ". Restarting BlueSage-controlled maintenance loops with updated ownership."));
				RestartSweepLoop();
				RestartHostHealthLoop();
			}
		}

		internal static string GetDefensiveCompatibilitySummary()
		{
			PluginCompatibilityResult pluginCompatibilityResult = Instance?._compatibility;
			if (pluginCompatibilityResult == null)
			{
				return "Compatibility: loaded-mod scan is not ready yet.";
			}
			List<string> list = new List<string>();
			if (pluginCompatibilityResult.HushLoaded)
			{
				list.Add("Hush shares the native ban store; BlueSage keeps separate exact-ID previews and authenticated Helpers");
			}
			if (pluginCompatibilityResult.EchoLoaded)
			{
				list.Add("Echo can intentionally copy names/outfits, so Clone Shield remains clues-not-proof");
			}
			if (pluginCompatibilityResult.DesyncLoaded)
			{
				list.Add("Desync owns periodic lobby/persona repair; BlueSage Host Health is read-only");
			}
			if (pluginCompatibilityResult.ChalkyLoaded)
			{
				list.Add("Chalky owns board persistence/sync; BlueSage stands down");
			}
			if (pluginCompatibilityResult.FomoLoaded)
			{
				list.Add("Fomo may observe visible chat; authenticated Helper moderation/resolution uses non-chat Steam member data");
			}
			if (pluginCompatibilityResult.AlphaLoaded && list.Count == 0)
			{
				list.Add("Alpha command utilities detected; no overlapping BlueSage owner changed");
			}
			if (list.Count != 0)
			{
				return "Compatibility: " + string.Join(" • ", list.ToArray()) + ".";
			}
			return "Compatibility: no overlapping Andrew defensive/runtime surfaces detected.";
		}

		private IEnumerator RefreshCompatibilityAfterLoadSettles()
		{
			yield return (object)new WaitForSecondsRealtime(3f);
			RefreshCompatibility("delayed post-load recheck");
			_compatibilityRefreshCoroutine = null;
		}

		private void RestartSweepLoop()
		{
			if (_sweepCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_sweepCoroutine);
				_sweepCoroutine = null;
			}
			_sweepSchedule.Reset();
			if (EnableAutoSweep.Value && AutoSweepAllowed)
			{
				EnsureSweepBackgroundExecution();
				_sweepSchedule.Start(Time.realtimeSinceStartupAsDouble, SweepIntervalMinutes.Value);
				_sweepCoroutine = ((MonoBehaviour)this).StartCoroutine(SweepLoop());
			}
			else
			{
				ReleaseSweepBackgroundExecution();
			}
		}

		private void EnsureSweepBackgroundExecution()
		{
			if (!_ownsSweepRunInBackgroundOverride && !Application.runInBackground)
			{
				_runInBackgroundBeforeSweepOverride = Application.runInBackground;
				Application.runInBackground = true;
				_ownsSweepRunInBackgroundOverride = true;
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogInfo((object)"Asset Sweep enabled background-safe scheduling for its real-time timer; the prior Unity run-in-background state will be restored when automatic Sweep stops.");
				}
			}
		}

		private void ReleaseSweepBackgroundExecution()
		{
			if (_ownsSweepRunInBackgroundOverride)
			{
				bool runInBackgroundBeforeSweepOverride = _runInBackgroundBeforeSweepOverride;
				_ownsSweepRunInBackgroundOverride = false;
				_runInBackgroundBeforeSweepOverride = false;
				Application.runInBackground = runInBackgroundBeforeSweepOverride;
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogInfo((object)$"Asset Sweep restored Unity run-in-background to {runInBackgroundBeforeSweepOverride}.");
				}
			}
		}

		private IEnumerator SweepLoop()
		{
			while (true)
			{
				double realtimeSinceStartupAsDouble = Time.realtimeSinceStartupAsDouble;
				_sweepSchedule.ReconcileInterval(realtimeSinceStartupAsDouble, SweepIntervalMinutes.Value);
				bool num = _sweepSchedule.IsDue(realtimeSinceStartupAsDouble);
				bool vanillaStateAvailable = false;
				float vanillaTimerSeconds = 0f;
				float vanillaDurationSeconds = 0f;
				bool vanillaSweepActive = false;
				if (num)
				{
					vanillaStateAvailable = ReadNativeSweepCoordinationState(out vanillaTimerSeconds, out vanillaDurationSeconds, out vanillaSweepActive);
				}
				switch (NativeAssetSweepPolicy.DecideAutomaticSweep(num, _sweepOperationGate.IsRunning, vanillaStateAvailable, vanillaTimerSeconds, vanillaDurationSeconds, vanillaSweepActive))
				{
				case NativeSweepCoordinationDecision.Run:
					RunSweep("automatic timer", requireManualPermission: false);
					break;
				case NativeSweepCoordinationDecision.SatisfiedByVanilla:
					_sweepSchedule.MarkAutomaticAttemptFinished(realtimeSinceStartupAsDouble, SweepIntervalMinutes.Value);
					Log.LogDebug((object)"[BlueSageSweep] pending automatic interval satisfied by the observed vanilla cleanup boundary.");
					break;
				}
				yield return (object)new WaitForSecondsRealtime(1f);
			}
		}

		private static bool ReadNativeSweepCoordinationState(out float vanillaTimerSeconds, out float vanillaDurationSeconds, out bool vanillaSweepActive)
		{
			vanillaTimerSeconds = 0f;
			vanillaDurationSeconds = 0f;
			vanillaSweepActive = false;
			try
			{
				object i = MonoSingleton<MainSceneManager>.I;
				object obj = MonoSingleton<DataManager>.I?.SettingsData;
				Type type = AccessTools.TypeByName("MainSceneManager");
				Type type2 = AccessTools.TypeByName("SettingsData");
				FieldInfo fieldInfo = AccessTools.Field(type, "_sweepTimer");
				FieldInfo fieldInfo2 = AccessTools.Field(type, "_sweepUI");
				FieldInfo fieldInfo3 = AccessTools.Field(type2, "SweepDuration");
				if (i == null || obj == null || fieldInfo == null || fieldInfo2 == null || fieldInfo3 == null)
				{
					return false;
				}
				vanillaTimerSeconds = Convert.ToSingle(fieldInfo.GetValue(i));
				vanillaDurationSeconds = Convert.ToSingle(fieldInfo3.GetValue(obj));
				object? value = fieldInfo2.GetValue(i);
				GameObject val = (GameObject)((value is GameObject) ? value : null);
				vanillaSweepActive = (Object)(object)val != (Object)null && val.activeSelf;
				return true;
			}
			catch
			{
				vanillaTimerSeconds = 0f;
				vanillaDurationSeconds = 0f;
				vanillaSweepActive = false;
				return false;
			}
		}

		internal bool RunSweep(string reason, bool requireManualPermission)
		{
			if (requireManualPermission && !ManualSweepAllowed)
			{
				Log.LogWarning((object)("Skipping asset cleanup via " + reason + ": a compatibility guard is active."));
				return false;
			}
			if (!_sweepOperationGate.TryStart(reason, out var sequence))
			{
				Log.LogInfo((object)$"[BlueSageSweep] utc={DateTime.UtcNow:O}; phase=skip; seq={sequence}; trigger={SanitizeSweepLogValue(reason)}; activeTrigger={SanitizeSweepLogValue(_sweepOperationGate.ActiveReason)}; reason=operation-in-flight");
				return false;
			}
			try
			{
				_activeSweepOperationCoroutine = ((MonoBehaviour)this).StartCoroutine(CompleteSweepOperation(sequence, reason));
				return true;
			}
			catch (Exception ex)
			{
				_sweepOperationGate.Complete(sequence);
				_activeSweepOperationCoroutine = null;
				Log.LogWarning((object)$"[BlueSageSweep] utc={DateTime.UtcNow:O}; phase=failed; seq={sequence}; trigger={SanitizeSweepLogValue(reason)}; error={ex.GetType().Name}");
				return false;
			}
		}

		private static bool TryCreateNativeSweepRoutine(out IEnumerator nativeSweepRoutine)
		{
			nativeSweepRoutine = null;
			try
			{
				object i = MonoSingleton<MainSceneManager>.I;
				if (i == null)
				{
					return false;
				}
				MethodInfo methodInfo = AccessTools.Method(i.GetType(), "SweepRoutine", Type.EmptyTypes, (Type[])null);
				if (methodInfo == null)
				{
					return false;
				}
				nativeSweepRoutine = methodInfo.Invoke(i, null) as IEnumerator;
				return nativeSweepRoutine != null;
			}
			catch (Exception ex)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)("Native sweep routine was unavailable; using compatibility cleanup: " + ex.GetType().Name + ": " + ex.Message));
				}
				nativeSweepRoutine = null;
				return false;
			}
		}

		private IEnumerator CompleteSweepOperation(int sequence, string reason)
		{
			long managedBeforeBytes = GC.GetTotalMemory(forceFullCollection: false);
			SweepResourceSnapshot resourceBefore = SweepResourceEvidenceCapture.Capture();
			SweepSessionSnapshot sessionBefore = SweepSessionEvidenceCapture.Capture();
			Stopwatch stopwatch = Stopwatch.StartNew();
			Log.LogInfo((object)$"[BlueSageSweep] utc={DateTime.UtcNow:O}; phase=start; seq={sequence}; trigger={SanitizeSweepLogValue(reason)}; managedBeforeMiB={(double)managedBeforeBytes / 1048576.0:0.0}; managedGc=disabled");
			bool nativeSweepFailed = false;
			if (TryCreateNativeSweepRoutine(out var nativeSweepRoutine))
			{
				while (true)
				{
					object obj = null;
					bool flag;
					try
					{
						flag = nativeSweepRoutine.MoveNext();
						if (flag)
						{
							obj = nativeSweepRoutine.Current;
						}
					}
					catch (Exception ex)
					{
						Log.LogWarning((object)$"[BlueSageSweep] utc={DateTime.UtcNow:O}; phase=native-fallback; seq={sequence}; trigger={SanitizeSweepLogValue(reason)}; error={ex.GetType().Name}");
						nativeSweepFailed = true;
						break;
					}
					if (!flag)
					{
						break;
					}
					yield return obj;
				}
			}
			if (nativeSweepRoutine == null || nativeSweepFailed)
			{
				AsyncOperation val;
				try
				{
					val = Resources.UnloadUnusedAssets();
				}
				catch (Exception ex2)
				{
					stopwatch.Stop();
					Log.LogWarning((object)$"[BlueSageSweep] utc={DateTime.UtcNow:O}; phase=failed; seq={sequence}; trigger={SanitizeSweepLogValue(reason)}; elapsedMs={stopwatch.ElapsedMilliseconds}; error={ex2.GetType().Name}");
					FinishSweepOperation(sequence, reason);
					yield break;
				}
				if (val != null)
				{
					yield return val;
				}
			}
			SweepResourceSnapshot after = SweepResourceEvidenceCapture.Capture();
			SweepSessionSnapshot after2 = SweepSessionEvidenceCapture.Capture();
			stopwatch.Stop();
			long totalMemory = GC.GetTotalMemory(forceFullCollection: false);
			double num = (double)(totalMemory - managedBeforeBytes) / 1048576.0;
			string text = SweepResourceEvidenceFormatter.Format(resourceBefore, after);
			string text2 = SweepSessionEvidenceFormatter.Format(sessionBefore, after2);
			Log.LogInfo((object)$"[BlueSageSweep] utc={DateTime.UtcNow:O}; phase=complete; seq={sequence}; trigger={SanitizeSweepLogValue(reason)}; elapsedMs={stopwatch.ElapsedMilliseconds}; managedBeforeMiB={(double)managedBeforeBytes / 1048576.0:0.0}; managedAfterMiB={(double)totalMemory / 1048576.0:0.0}; managedDeltaMiB={num:+0.0;-0.0;0.0}; managedGc=disabled; {text}; {text2}");
			FinishSweepOperation(sequence, reason);
		}

		private void FinishSweepOperation(int sequence, string reason)
		{
			_sweepOperationGate.Complete(sequence);
			_activeSweepOperationCoroutine = null;
			if (string.Equals(reason, "automatic timer", StringComparison.Ordinal))
			{
				_sweepSchedule.MarkAutomaticAttemptFinished(Time.realtimeSinceStartupAsDouble, SweepIntervalMinutes.Value);
			}
		}

		private static string SanitizeSweepLogValue(string value)
		{
			if (string.IsNullOrWhiteSpace(value))
			{
				return "unspecified";
			}
			return value.Trim().Replace(";", ",").Replace("\r", " ")
				.Replace("\n", " ");
		}

		internal static string BuildTimestampPrefix()
		{
			return TimestampFormatter.BuildPrefix(DateTime.Now, Use24HourTime.Value, TimestampSizePercent.Value, TimestampColor.Value);
		}

		internal static bool AddLocalNotification(string text)
		{
			try
			{
				TextChannelManager i = NetworkSingleton<TextChannelManager>.I;
				if ((Object)(object)i == (Object)null)
				{
					return false;
				}
				i.AddNotification(text);
				return true;
			}
			catch (Exception ex)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)("Could not show local notification: " + ex.GetType().Name + ": " + ex.Message));
				}
				return false;
			}
		}

		internal static string FormatBlueSageNotice(string message)
		{
			return "<color=#70D6FF><b>BlueSage</b></color> " + message;
		}

		internal static string FormatBlueSageWarning(string message)
		{
			return "<color=#FFD45D><b>BlueSage</b></color> " + message;
		}

		internal static string FormatBlueSageAction(string action, string detail, bool warning = false)
		{
			string text = (warning ? "FFD45D" : "70D6FF");
			string text2 = (string.IsNullOrWhiteSpace(action) ? "Notice" : action.Trim());
			string text3 = (string.IsNullOrWhiteSpace(detail) ? string.Empty : (" " + detail.Trim()));
			return "<color=#" + text + "><b>BlueSage</b></color> <color=#FFD700><b>" + text2 + "</b></color>" + text3;
		}

		internal static bool HandleOutgoingChatCommand(byte[] message)
		{
			if ((Object)(object)Instance == (Object)null || message == null || Instance._commandRegistry == null)
			{
				return true;
			}
			string input;
			try
			{
				input = Encoding.Unicode.GetString(message).Trim();
			}
			catch (Exception ex)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)("BlueSage command decode failed: " + ex.GetType().Name + ": " + ex.Message));
				}
				return true;
			}
			BlueSageCommandResult blueSageCommandResult = Instance._commandRegistry.TryExecute(input);
			if (!blueSageCommandResult.Handled)
			{
				return true;
			}
			foreach (string message2 in blueSageCommandResult.Messages)
			{
				AddLocalNotification(message2);
			}
			string commandName;
			string arguments;
			string text = (BlueSageCommandRegistry.TryParse(input, out commandName, out arguments) ? commandName.ToLowerInvariant() : "unknown");
			ManualLogSource log2 = Log;
			if (log2 != null)
			{
				log2.LogInfo((object)("BlueSage command handled locally: /" + text + " (arguments redacted)."));
			}
			return false;
		}

		internal static IReadOnlyList<string> GetCommandSuggestions(string input, int maxResults)
		{
			if ((Object)(object)Instance == (Object)null || Instance._commandRegistry == null)
			{
				return Array.Empty<string>();
			}
			return Instance._commandRegistry.Suggest(input, maxResults, CanSuggestCommand);
		}

		private void ApplyStyleStateMigration()
		{
			string text = (StatusBaseName?.Value ?? string.Empty).Trim();
			bool flag = false;
			bool flag2 = false;
			bool flag3 = false;
			if (!string.IsNullOrWhiteSpace(text))
			{
				DetectedDisplayNameState detectedDisplayNameState = StyleHelperNamePolicy.DetectCurrentState(text, text, StatusMessage?.Value ?? string.Empty, GetStatusColor(), StatusBrackets?.Value ?? "()", ShouldApplySpoons, SpoonCount?.Value ?? 5, GetSpoonLabel(), BuildStatusSuffix(), BuildSpoonSuffix());
				string text2 = (detectedDisplayNameState.BaseName ?? string.Empty).Trim();
				if (!string.Equals(text2, text, StringComparison.Ordinal))
				{
					if (StatusBaseNameLegacyBackup != null && string.IsNullOrEmpty(StatusBaseNameLegacyBackup.Value))
					{
						StatusBaseNameLegacyBackup.Value = text;
					}
					StatusBaseName.Value = text2;
					flag2 = true;
					flag3 = detectedDisplayNameState.UsedPlainTextFallback;
					flag = true;
				}
			}
			if (StyleStateMigrationVersion != null && !string.Equals(StyleStateMigrationVersion.Value, "0.2.4-legacy-style-repair-v1", StringComparison.Ordinal))
			{
				StyleStateMigrationVersion.Value = "0.2.4-legacy-style-repair-v1";
				flag = true;
			}
			if (!flag)
			{
				return;
			}
			((BaseUnityPlugin)this).Config.Save();
			if (flag2)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)("Status Helper repaired legacy local style state without exposing its contents. " + $"beforeLength={text.Length}, afterLength={(StatusBaseName.Value ?? string.Empty).Length}, " + $"plainTextFallback={flag3}. The original remains in the local rollback config entry."));
				}
			}
		}

		internal static bool CanUseLobbySafety(out bool isHost)
		{
			string reason;
			return SteamIdModerationController.CanLocalIssue(out isHost, out reason);
		}

		internal static bool ShouldShowLobbySafetyTab(out LobbySafetyAccessState state, out string reason)
		{
			return SteamIdModerationController.ShouldShowLocalSurface(out state, out reason);
		}

		internal static bool CanManageHelpers()
		{
			bool isHost;
			return CanUseLobbySafety(out isHost) && isHost;
		}

		internal static bool IsHelperManagementCommandName(string commandName)
		{
			string text = (commandName ?? string.Empty).Trim().TrimStart(new char[1] { '/' }).ToLowerInvariant();
			switch (text)
			{
			default:
				return text == "moderationhelper";
			case "helper":
			case "lobbyhelper":
			case "lobbymod":
			case "modhelper":
				return true;
			}
		}

		internal static bool IsLobbySafetyCommandName(string commandName)
		{
			string text = (commandName ?? string.Empty).Trim().TrimStart(new char[1] { '/' }).ToLowerInvariant();
			if (!IsHelperManagementCommandName(text))
			{
				switch (text)
				{
				default:
					return text == "cloneincident";
				case "sidlist":
				case "sidwho":
				case "sidlookup":
				case "sidban":
				case "sidunban":
				case "unbansid":
				case "sidincident":
					break;
				}
			}
			return true;
		}

		private static bool CanSuggestCommand(BlueSageCommand command)
		{
			if (command == null)
			{
				return false;
			}
			if (command.Matches("helper"))
			{
				return CanManageHelpers();
			}
			bool isHost;
			if (command.Matches("sidlist") || command.Matches("sidwho") || command.Matches("sidban") || command.Matches("sidunban") || command.Matches("sidincident"))
			{
				return CanUseLobbySafety(out isHost);
			}
			return true;
		}

		internal static IReadOnlyList<string> GetModerationTargetSuggestions(bool unban)
		{
			if (!CanUseLobbySafety(out var isHost))
			{
				return Array.Empty<string>();
			}
			if (unban)
			{
				if (!isHost)
				{
					return Array.Empty<string>();
				}
				return SteamIdModerationController.GetBannedSteamIds().Take(12).ToArray();
			}
			string[] array = (from item in CloneIncidentLedger.Snapshot.Reverse().Take(12)
				select item.Id).ToArray();
			if (array.Length == 0)
			{
				return Array.Empty<string>();
			}
			return array;
		}

		internal static IReadOnlyList<string> GetIdentityLookupSuggestions()
		{
			if (!CanUseLobbySafety(out var _))
			{
				return Array.Empty<string>();
			}
			return PlayerIdentityEvidenceController.GetLookupSuggestions();
		}

		internal string ShowCloneEvidenceFromQolMenu()
		{
			BlueSageCommandResult blueSageCommandResult = HandleSidListCommand(new BlueSageCommandContext("/sidlist", "sidlist", string.Empty));
			foreach (string message in blueSageCommandResult.Messages)
			{
				AddLocalNotification(message);
			}
			object obj;
			if (blueSageCommandResult.Messages.Count <= 1)
			{
				obj = blueSageCommandResult.Messages.FirstOrDefault();
				if (obj == null)
				{
					return "No Clone Shield evidence is available.";
				}
			}
			else
			{
				obj = "Clone Shield evidence was sent to local chat.";
			}
			return (string)obj;
		}

		internal string CheckModerationAccessFromQolMenu()
		{
			bool isHost;
			string reason;
			object obj = SteamIdModerationController.GetLocalAccessState(out isHost, out reason) switch
			{
				LobbySafetyAccessState.Host => "Helper / Safety access: you are the current lobby host.", 
				LobbySafetyAccessState.HelperReady => "Helper / Safety access: this host added you as a Helper. The host still rechecks and performs each moderation action.", 
				LobbySafetyAccessState.HelperWaitingForHost => "Helper / Safety waiting: " + reason, 
				_ => "Helper / Safety access: " + reason, 
			};
			AddLocalNotification((string)obj);
			return (string)obj;
		}

		internal string UpdateHelperFromQolMenu(string steamId, bool add)
		{
			string text = (add ? "add " : "remove ");
			string? obj = HandleHelperCommand(new BlueSageCommandContext("/helper " + text + steamId, "helper", text + steamId)).Messages.FirstOrDefault() ?? "Helpers: no change.";
			AddLocalNotification(obj);
			return obj;
		}

		internal string ResetHelpersFromQolMenu()
		{
			string? obj = HandleHelperCommand(new BlueSageCommandContext("/helper reset", "helper", "reset")).Messages.FirstOrDefault() ?? "Helpers: no change.";
			AddLocalNotification(obj);
			return obj;
		}

		internal string PreviewSidBanFromQolMenu(string steamId)
		{
			BlueSageCommandResult blueSageCommandResult = HandleSidBanCommand(new BlueSageCommandContext("/sidban " + steamId, "sidban", steamId));
			foreach (string message in blueSageCommandResult.Messages)
			{
				AddLocalNotification(message);
			}
			return blueSageCommandResult.Messages.FirstOrDefault() ?? "SID ban preview was not available.";
		}

		internal string ConfirmSidBanFromQolMenu(string steamId)
		{
			BlueSageCommandResult blueSageCommandResult = HandleSidBanCommand(new BlueSageCommandContext("/sidban " + steamId + " confirm", "sidban", steamId + " confirm"));
			foreach (string message in blueSageCommandResult.Messages)
			{
				AddLocalNotification(message);
			}
			return blueSageCommandResult.Messages.FirstOrDefault() ?? "SID ban confirmation was not available.";
		}

		internal string PreviewSidUnbanFromQolMenu(string steamId)
		{
			BlueSageCommandResult blueSageCommandResult = HandleSidUnbanCommand(new BlueSageCommandContext("/sidunban " + steamId, "sidunban", steamId));
			foreach (string message in blueSageCommandResult.Messages)
			{
				AddLocalNotification(message);
			}
			return blueSageCommandResult.Messages.FirstOrDefault() ?? "SID unban preview was not available.";
		}

		internal string ConfirmSidUnbanFromQolMenu(string steamId)
		{
			BlueSageCommandResult blueSageCommandResult = HandleSidUnbanCommand(new BlueSageCommandContext("/sidunban " + steamId + " confirm", "sidunban", steamId + " confirm"));
			foreach (string message in blueSageCommandResult.Messages)
			{
				AddLocalNotification(message);
			}
			return blueSageCommandResult.Messages.FirstOrDefault() ?? "SID unban confirmation was not available.";
		}

		internal ModerationConfirmationReadiness GetModerationConfirmationReadiness(string action, string target)
		{
			PendingModerationAction pendingModerationAction = _pendingModerationAction;
			if (pendingModerationAction == null)
			{
				return new ModerationConfirmationReadiness(isReady: false, 0);
			}
			MultiplayerManager i = MonoSingleton<MultiplayerManager>.I;
			return ModerationProtocolPolicy.EvaluateConfirmation(action, target, ((i != null) ? i.LobbyCode : null) ?? string.Empty, DateTimeOffset.UtcNow.ToUnixTimeSeconds(), pendingModerationAction.Action, pendingModerationAction.TargetSteamId, pendingModerationAction.IncidentId, pendingModerationAction.LobbyCode, pendingModerationAction.ExpiresUnixSeconds);
		}

		internal string CopySteamIdFromQolMenu(string steamId)
		{
			if (!CanUseLobbySafety(out var _))
			{
				return "Lobby Safety is available only to the current host or a Helper assigned by that host. No player or incident details were shown.";
			}
			if (!PlayerIdentityEvidenceController.TryResolveExact(steamId, out var evidence, out var error))
			{
				return "Steam ID copy failed safely: " + error + ". Re-select a verified active row.";
			}
			GUIUtility.systemCopyBuffer = evidence.SteamId;
			return "Copied exact SteamID64 " + evidence.SteamId + ".";
		}

		internal string CopySavedBanSteamIdFromQolMenu(string steamId)
		{
			if (!CanManageHelpers())
			{
				return "Only the verified current host can copy saved native-ban identities.";
			}
			IReadOnlyList<NativeBanRecord> records;
			string error;
			bool flag = SteamIdModerationController.TryGetNativeBanRecords(out records, out error);
			if (!ModerationProtocolPolicy.IsSteamId64(steamId) || !flag || !records.Any((NativeBanRecord record) => string.Equals(record.SteamId, steamId, StringComparison.Ordinal)))
			{
				string text = (string.IsNullOrWhiteSpace(error) ? "that exact native-ban row is no longer available" : error);
				return "Saved SteamID64 copy failed safely: " + text + ". Refresh the list.";
			}
			GUIUtility.systemCopyBuffer = steamId;
			return "Copied saved native-ban SteamID64 " + steamId + ".";
		}

		internal string CopyIdentityEvidenceFromQolMenu(string steamId)
		{
			if (!CanUseLobbySafety(out var _))
			{
				return "Lobby Safety is available only to the current host or a Helper assigned by that host. No player or incident details were shown.";
			}
			if (!PlayerIdentityEvidenceController.TryResolveExact(steamId, out var evidence, out var error))
			{
				return "Identity evidence copy failed safely: " + error + ". Re-select a verified active row.";
			}
			GUIUtility.systemCopyBuffer = PlayerIdentityEvidenceController.BuildCopyableEvidence(evidence);
			return "Copied the verified live identity record for row #" + (evidence.RosterIndex + 1) + " and Steam …" + PlayerIdentityEvidenceController.Suffix(evidence.SteamId) + ".";
		}

		internal string OpenSteamProfileFromQolMenu(string steamId)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			if (!CanUseLobbySafety(out var _))
			{
				return "Lobby Safety is available only to the current host or a Helper assigned by that host. No player or incident details were shown.";
			}
			if (!PlayerIdentityEvidenceController.TryResolveExact(steamId, out var evidence, out var error) || !SteamManager.Initialized || !ulong.TryParse(evidence.SteamId, out var result) || result == 0L)
			{
				return "Steam profile could not open safely: " + error + ". Re-select a verified active row.";
			}
			SteamFriends.ActivateGameOverlayToUser("steamid", new CSteamID(result));
			return "Opened the selected Steam profile for verification.";
		}

		internal string OpenOfflineSteamProfileFromQolMenu(string steamId)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			if (!CanManageHelpers())
			{
				return "Only the verified current host can inspect an off-roster profile from this form.";
			}
			if (!ModerationProtocolPolicy.IsSteamId64(steamId) || !ulong.TryParse(steamId, out var result) || result == 0L)
			{
				return "Steam profile could not open safely: enter one exact 17-digit SteamID64.";
			}
			string error;
			IReadOnlyList<string> verifiedCurrentSteamIds = PlayerIdentityEvidenceController.GetVerifiedCurrentSteamIds(out error);
			if (!string.IsNullOrWhiteSpace(error))
			{
				return "Steam profile could not open safely while current lobby coverage is incomplete: " + error;
			}
			if (verifiedCurrentSteamIds.Contains<string>(steamId, StringComparer.Ordinal))
			{
				return "That SteamID64 is currently in the lobby. Select its verified live row instead.";
			}
			if (!SteamManager.Initialized)
			{
				return "Steam profile could not open safely because Steam is not initialized.";
			}
			SteamFriends.ActivateGameOverlayToUser("steamid", new CSteamID(result));
			return "Opened the exact off-roster Steam profile for verification.";
		}

		private void RegisterBlueSageCommands()
		{
			_commandRegistry = new BlueSageCommandRegistry();
			_commandRegistry.Register(new BlueSageCommand("bsqol", "BlueSage QoL help and status", new string[1] { "qol" }, HandleBlueSageQoLCommand));
			_commandRegistry.Register(new BlueSageCommand("assetsweep", "Toggle BlueSage Automatic Cleanup or run one cleanup now", new string[2] { "sweep", "as" }, HandleAssetSweepCommand));
			_commandRegistry.Register(new BlueSageCommand("hosthealth", "Toggle Host Health or run a check now", new string[1] { "hh" }, (BlueSageCommandContext context) => HandleToggleCommand(context, "Host Health", EnableHostHealthMonitor, RestartHostHealthLoop, "run", () => RunHostHealthCheck("manual command"))));
			_commandRegistry.Register(new BlueSageCommand("leavenotices", "Toggle leave notices", new string[1] { "ln" }, (BlueSageCommandContext context) => HandleToggleCommand(context, "Leave Notices", EnableLeaveNotifications)));
			_commandRegistry.Register(new BlueSageCommand("timestamps", "Toggle chat and notification timestamps", new string[1] { "tt" }, HandleTimestampCommand));
			_commandRegistry.Register(new BlueSageCommand("chatreadability", "Toggle local chat text outline and shadow", new string[1] { "chatread" }, (BlueSageCommandContext context) => HandleToggleCommand(context, "Chat Readability", EnableChatReadability)));
			_commandRegistry.Register(new BlueSageCommand("chatbackdrop", "Toggle persistent local chat backdrop readability", new string[1] { "chatbg" }, (BlueSageCommandContext context) => HandleToggleCommand(context, "Chat Backdrop", EnablePersistentChatBackdrop)));
			_commandRegistry.Register(new BlueSageCommand("chatoutline", "Set chat outline intensity from 25 to 100", new string[1] { "outline" }, HandleChatOutlineCommand));
			_commandRegistry.Register(new BlueSageCommand("chatscale", "Set whole local chat UI accessibility scale from 75 to 200 percent", new string[2] { "chatresize", "cr" }, HandleChatScaleCommand));
			_commandRegistry.Register(new BlueSageCommand("chatfont", "Set local chat message font size from 75 to 200 percent", new string[2] { "chatfontsize", "cf" }, HandleChatFontCommand));
			_commandRegistry.Register(new BlueSageCommand("chatheight", "Resize local chat window height from 100 to 200 percent without scaling text", new string[2] { "chatstretch", "chath" }, HandleChatHeightCommand));
			_commandRegistry.Register(new BlueSageCommand("chatrows", "Set retained chat rows from 25 to 250; default/reset is 150", new string[2] { "chathistory", "chatr" }, HandleChatHistoryCommand));
			_commandRegistry.Register(new BlueSageCommand("chatvanilla", "Reset whole chat UI scale, message font size, and window height to vanilla", new string[2] { "chatreset", "chatdefault" }, HandleChatVanillaCommand));
			_commandRegistry.Register(new BlueSageCommand("chatoutlinecolor", "Set normal chat outline color as hex", new string[1] { "outlinecolor" }, (BlueSageCommandContext context) => HandleOutlineColorCommand(context, "Normal outline", ChatOutlineColor, "000000")));
			_commandRegistry.Register(new BlueSageCommand("blackoutlinecolor", "Set true-black chat/name outline color as hex", new string[2] { "blackchatoutline", "blackoutline" }, (BlueSageCommandContext context) => HandleOutlineColorCommand(context, "Black text outline", BlackChatOutlineColor, "C0C0C0")));
			_commandRegistry.Register(new BlueSageCommand("bettermove", "Toggle Shift run and Ctrl slow-walk", new string[1] { "bm" }, (BlueSageCommandContext context) => HandleToggleCommand(context, "BetterMove", EnableBetterMove)));
			_commandRegistry.Register(new BlueSageCommand("unlimitedconsumables", "Toggle reusable canteen items and chalk", new string[2] { "consumables", "infiniteconsumables" }, (BlueSageCommandContext context) => HandleToggleCommand(context, "Reusable Consumables", EnableUnlimitedConsumables)));
			_commandRegistry.Register(new BlueSageCommand("reconnectguard", "Toggle Reconnect Guard", new string[1] { "rg" }, (BlueSageCommandContext context) => HandleToggleCommand(context, "Reconnect Guard", EnableReconnectGuard, delegate
			{
				if (!EnableReconnectGuard.Value)
				{
					StopManagedReconnect("disabled by command");
				}
			})));
			_commandRegistry.Register(new BlueSageCommand("reconnectmessage", "Toggle reconnect success message", new string[1] { "rm" }, (BlueSageCommandContext context) => HandleToggleCommand(context, "Reconnect Message", EnableReconnectAnnouncement)));
			_commandRegistry.Register(new BlueSageCommand("focusanywhere", "Toggle Focus Anywhere", new string[1] { "fa" }, (BlueSageCommandContext context) => HandleToggleCommand(context, "Focus Anywhere", EnableFocusAnywhere)));
			_commandRegistry.Register(new BlueSageCommand("minimaplabels", "Toggle local minimap dot-to-ID-card clicks", new string[1] { "mml" }, (BlueSageCommandContext context) => HandleToggleCommand(context, "MiniMap ID Click", EnableMiniMapPlayerLabels)));
			_commandRegistry.Register(new BlueSageCommand("cloneshield", "Toggle public alerts when someone newly copies your avatar or styled name", new string[2] { "cloneguard", "identityshield" }, (BlueSageCommandContext context) => HandleToggleCommand(context, "Clone Shield", EnableCloneShield)));
			_commandRegistry.Register(new BlueSageCommand("playersaver", "Toggle local-only distant player render saver for large lobbies", new string[2] { "rendercull", "playercull" }, HandlePlayerRenderSaverCommand));
			_commandRegistry.Register(new BlueSageCommand("communitybans", "Local additive community BanData status or refresh", new string[2] { "communityban", "bansync" }, HandleCommunityBanCommand));
			_commandRegistry.Register(new BlueSageCommand("chalk", "View/save/delete local chalk data or request exact authorized load/clear actions", new string[1] { "chalkboard" }, HandleChalkCommand));
			_commandRegistry.Register(new BlueSageCommand("chalksave", "Save the current chalkboard locally: /chalksave name [board index]", Array.Empty<string>(), HandleChalkSaveCommand));
			_commandRegistry.Register(new BlueSageCommand("chalkload", "Authorized exact shared chalkboard restore: /chalkload name board-index", new string[1] { "chalkrestore" }, HandleChalkLoadCommand));
			_commandRegistry.Register(new BlueSageCommand("chalklist", "List local BlueSage chalkboard saves", Array.Empty<string>(), (BlueSageCommandContext context) => BlueSageCommandResult.HandledWithMessages(ChalkboardPersistenceController.List())));
			_commandRegistry.Register(new BlueSageCommand("copychat", "Toggle right-click-to-copy chat messages", new string[1] { "ccopy" }, (BlueSageCommandContext context) => HandleToggleCommand(context, "Chat Copy", EnableChatCopy)));
			_commandRegistry.Register(new BlueSageCommand("chatlinks", "Toggle safe chat link opening", new string[1] { "clinks" }, (BlueSageCommandContext context) => HandleToggleCommand(context, "Chat Links", EnableChatUrlLinks)));
			_commandRegistry.Register(new BlueSageCommand("auditlog", "Control local chat and BepInEx audit exports", new string[2] { "sessionaudit", "localaudit" }, HandleAuditLogCommand));
			_commandRegistry.Register(new BlueSageCommand("qolmenu", "Open the BlueSage QoL menu", new string[1] { "qm" }, HandleQolMenuCommand));
			_commandRegistry.Register(new BlueSageCommand("selfmove", "Self movement: status, save, teleport, fly, speed, jump, gravity, or reset", new string[2] { "bluemove", "qolmove" }, HandleSelfMovementCommand));
			_commandRegistry.Register(new BlueSageCommand("style", "Build styled name or status text you can paste", new string[1] { "sty" }, HandleStyleCommand));
			_commandRegistry.Register(new BlueSageCommand("styleui", "Open Style Helper for names, status, Spoons, colors, and templates", new string[1] { "sui" }, HandleStyleUiCommand));
			_commandRegistry.Register(new BlueSageCommand("setpingcolor", "Set BlueSage mention highlight color", Array.Empty<string>(), HandleSetPingColorCommand));
			_commandRegistry.Register(new BlueSageCommand("pingsound", "Toggle or choose BlueSage local ping sound", Array.Empty<string>(), HandlePingSoundCommand));
			_commandRegistry.Register(new BlueSageCommand("helper", "Host-managed helpers: add, remove, list, or reset", new string[4] { "lobbyhelper", "lobbymod", "modhelper", "moderationhelper" }, HandleHelperCommand));
			_commandRegistry.Register(new BlueSageCommand("sidlist", "Show local Clone Shield incident evidence and Steam ID suffixes", Array.Empty<string>(), HandleSidListCommand));
			_commandRegistry.Register(new BlueSageCommand("sidincident", "Review, resolve, or locally clear Clone Shield incidents", new string[1] { "cloneincident" }, HandleSidIncidentCommand));
			_commandRegistry.Register(new BlueSageCommand("sidwho", "Find verified live players by name, persona, SteamID digits, or regex", new string[1] { "sidlookup" }, HandleSidWhoCommand));
			_commandRegistry.Register(new BlueSageCommand("idsync", "Identity status/local refresh, Host repair, or authenticated Helper request", new string[2] { "identitysync", "rostersync" }, HandleIdentityResyncCommand));
			_commandRegistry.Register(new BlueSageCommand("sidban", "Preview or confirm a Steam ID ban checked by the host", Array.Empty<string>(), HandleSidBanCommand));
			_commandRegistry.Register(new BlueSageCommand("sidunban", "Preview or confirm removal from the host's Steam ID ban list", new string[1] { "unbansid" }, HandleSidUnbanCommand));
			_commandRegistry.Register(new BlueSageCommand("setname", "Set your BlueSage base display name", Array.Empty<string>(), HandleSetNameCommand));
			_commandRegistry.Register(new BlueSageCommand("status", "Set your BlueSage status message", new string[2] { "setstatus", "set-status" }, HandleStatusCommand));
			_commandRegistry.Register(new BlueSageCommand("brb", "Set your BlueSage status to BRB", Array.Empty<string>(), (BlueSageCommandContext context) => SetPresetStatus("BRB")));
			_commandRegistry.Register(new BlueSageCommand("afk", "Set your BlueSage status to AFK", Array.Empty<string>(), (BlueSageCommandContext context) => SetPresetStatus("AFK")));
			_commandRegistry.Register(new BlueSageCommand("back", "Restore your status from before BRB/AFK, or clear it", Array.Empty<string>(), HandleBackStatusCommand));
			_commandRegistry.Register(new BlueSageCommand("clearstatus", "Clear your BlueSage status message", new string[1] { "clear-status" }, HandleClearStatusCommand));
			_commandRegistry.Register(new BlueSageCommand("statuscolor", "Set your BlueSage status color", Array.Empty<string>(), HandleStatusColorCommand));
			_commandRegistry.Register(new BlueSageCommand("spoons", "Set, show, or hide your optional spoon tag", Array.Empty<string>(), HandleSpoonsCommand));
			_commandRegistry.Register(new BlueSageCommand("setmood", "Customize the short label shown in your optional 0/5 tag", new string[1] { "spoonlabel" }, HandleSetMoodCommand));
			string name = DecodeCommandName("cmvfefwefcvh");
			_commandRegistry.Register(new BlueSageCommand(name, "BlueSage internal", Array.Empty<string>(), HandleHiddenDiagnosticsCommand, isHidden: true));
			_commandRegistry.Register(new BlueSageCommand(BuildBlueSageClueCommandName(), "BlueSage internal", Array.Empty<string>(), HandleBlueSageClueCommand, isHidden: true));
			_commandRegistry.Register(new BlueSageCommand("boop", "BlueSage internal", Array.Empty<string>(), HandleBoopCommand, isHidden: true));
			_commandRegistry.Register(new BlueSageCommand("sagewave", "BlueSage internal", Array.Empty<string>(), HandleSageWaveCommand, isHidden: true));
		}

		private BlueSageCommandResult HandleBlueSageQoLCommand(BlueSageCommandContext context)
		{
			string text = ((context.Tokens.Count > 0) ? context.Tokens[0].ToLowerInvariant() : "help");
			if (text == "status")
			{
				LogDetailedQolStatus();
				return BlueSageCommandResult.HandledWithMessages(BuildQolStatusMessage());
			}
			if (text == "diag" && string.Equals(context.CommandName, "bsqol", StringComparison.OrdinalIgnoreCase))
			{
				return HandleHiddenDiagnosticsCommand(context);
			}
			if (text == "hosthealth")
			{
				return BlueSageCommandResult.HandledWithMessages(RunHostHealthCheck("manual command"));
			}
			List<string> list = new List<string> { "BlueSage basics: Home or /qolmenu, Insert or /styleui, /qol status, and type / then Tab or click a suggestion.", "Chat: /timestamps, /chatreadability, /chatbackdrop, /chatoutline, /chatscale, /chatfont, /chatheight, /chatrows, /chatvanilla, /copychat, /chatlinks.", "Style: /style, /setname, /status, /clearstatus, /brb, /afk, /back, /spoons, /setmood.", "Comfort: /as, /bettermove, /rg, /fa, /minimaplabels, /cloneshield. Chalkboards: /chalk boards, then authorized Host/Helper /chalk clear <index>. Experimental tools are opt-in under Home > Toggles; type / to browse their commands." };
			if (CanUseLobbySafety(out var isHost))
			{
				list.Add(isHost ? "Host-only Helper management and evidence tools are grouped in Lobby Safety. /idsync status is read-only, refresh is local-only, and verified Host repair runs one bounded exact-correlation transaction." : "This host assigned you as a Helper. /idsync status is read-only, refresh is local-only, and /idsync request uses authenticated member data for current-Host revalidation.");
			}
			return BlueSageCommandResult.HandledWithMessages(list.ToArray());
		}

		private BlueSageCommandResult HandleQolMenuCommand(BlueSageCommandContext context)
		{
			if ((Object)(object)_qolMenuWindow == (Object)null)
			{
				StartQolMenuWindow();
			}
			if ((Object)(object)_qolMenuWindow == (Object)null)
			{
				return BlueSageCommandResult.HandledWithMessages("QoL menu could not start; check BepInEx console.");
			}
			_qolMenuWindow.ToggleVisible();
			return BlueSageCommandResult.HandledWithMessages("QoL menu toggled. Use the BlueSage window to manage QoL features.");
		}

		private BlueSageCommandResult HandleStyleCommand(BlueSageCommandContext context)
		{
			RichTextStyleResult richTextStyleResult = RichTextStyleBuilder.TryBuild(context.Arguments, LockedMaxIdCardCharacters);
			if (!richTextStyleResult.Success)
			{
				return BlueSageCommandResult.HandledWithMessages(richTextStyleResult.Message);
			}
			GUIUtility.systemCopyBuffer = richTextStyleResult.GeneratedText;
			return BlueSageCommandResult.HandledWithMessages($"Style Helper: copied {richTextStyleResult.RawLength}/{LockedMaxIdCardCharacters} chars. Paste into an ID/name/profile/room field.");
		}

		private BlueSageCommandResult HandleStyleUiCommand(BlueSageCommandContext context)
		{
			if (!EnableStyleUi.Value)
			{
				return BlueSageCommandResult.HandledWithMessages("Style UI is disabled in config.");
			}
			if ((Object)(object)_styleHelperWindow == (Object)null)
			{
				StartStyleHelperWindow();
			}
			if ((Object)(object)_styleHelperWindow == (Object)null)
			{
				return BlueSageCommandResult.HandledWithMessages("Style UI could not start; check BepInEx console.");
			}
			_styleHelperWindow.ToggleVisible();
			return BlueSageCommandResult.HandledWithMessages("Style UI toggled. Use the BlueSage window to build and copy name/status text.");
		}

		internal string TryApplyStyledNameFromStyleUi(string styledName)
		{
			bool applied;
			return TryApplyStyledNameFromStyleUi(styledName, out applied);
		}

		internal string TryApplyStyledNameFromStyleUi(string styledName, out bool applied)
		{
			applied = false;
			string text = (styledName ?? string.Empty).Trim();
			if (string.IsNullOrWhiteSpace(text))
			{
				return "Style UI: build a style before applying it to your name.";
			}
			if (text.Length > LockedMaxIdCardCharacters)
			{
				return $"Style UI: styled name is too long ({text.Length}/{LockedMaxIdCardCharacters}). Shorten it or use fewer per-letter colors.";
			}
			DisplayNameDraft displayNameDraft = CaptureDisplayNameDraft(captureLiveBase: false);
			displayNameDraft.BaseName = text;
			BlueSageCommandResult blueSageCommandResult = TryApplyDisplayNameDraft(displayNameDraft, "Style UI: name updated.", out applied);
			if (blueSageCommandResult.Messages.Count <= 0)
			{
				return "Style UI: name updated.";
			}
			return blueSageCommandResult.Messages[0];
		}

		internal string TryApplyPlainNameFromStyleUi(string plainName)
		{
			bool applied;
			return TryApplyPlainNameFromStyleUi(plainName, out applied);
		}

		internal string TryApplyPlainNameFromStyleUi(string plainName, out bool applied)
		{
			applied = false;
			string text = (plainName ?? string.Empty).Trim();
			if (string.IsNullOrWhiteSpace(text) || string.Equals(text, "YOURNAMEHERE", StringComparison.OrdinalIgnoreCase))
			{
				return "Style UI: type your name first.";
			}
			if (text.Length > LockedMaxIdCardCharacters)
			{
				return $"Style UI: name is too long ({text.Length}/{LockedMaxIdCardCharacters}).";
			}
			DisplayNameDraft displayNameDraft = CaptureDisplayNameDraft(captureLiveBase: false);
			displayNameDraft.BaseName = text;
			BlueSageCommandResult blueSageCommandResult = TryApplyDisplayNameDraft(displayNameDraft, "Style UI: name updated.", out applied);
			if (blueSageCommandResult.Messages.Count <= 0)
			{
				return "Style UI: name updated.";
			}
			return blueSageCommandResult.Messages[0];
		}

		internal string TryApplyStatusFromStyleUi(string plainName, string status, string color)
		{
			bool applied;
			return TryApplyStatusFromStyleUi(plainName, status, color, out applied);
		}

		internal string TryApplyStatusFromStyleUi(string plainName, string status, string color, out bool applied)
		{
			applied = false;
			DisplayNameDraft displayNameDraft = CaptureDisplayNameDraft(captureLiveBase: true);
			string text = (plainName ?? string.Empty).Trim();
			if (!string.IsNullOrWhiteSpace(text) && !string.Equals(text, "YOURNAMEHERE", StringComparison.OrdinalIgnoreCase))
			{
				displayNameDraft.BaseName = text;
			}
			displayNameDraft.StatusMessage = (status ?? string.Empty).Trim();
			if (RichTextStyleBuilder.TryNormalizeHex(color, out var hex))
			{
				displayNameDraft.StatusColor = hex;
			}
			BlueSageCommandResult blueSageCommandResult = TryApplyDisplayNameDraft(displayNameDraft, "Style UI: status updated.", out applied);
			if (blueSageCommandResult.Messages.Count <= 0)
			{
				return "Style UI: status updated.";
			}
			return blueSageCommandResult.Messages[0];
		}

		internal string TryClearStatusFromStyleUi()
		{
			bool applied;
			return TryClearStatusFromStyleUi(out applied);
		}

		internal string TryClearStatusFromStyleUi(out bool applied)
		{
			DisplayNameDraft displayNameDraft = CaptureDisplayNameDraft(captureLiveBase: true);
			displayNameDraft.StatusMessage = string.Empty;
			BlueSageCommandResult blueSageCommandResult = TryApplyDisplayNameDraft(displayNameDraft, "Style UI: status cleared.", out applied);
			if (blueSageCommandResult.Messages.Count <= 0)
			{
				return "Style UI: status cleared.";
			}
			return blueSageCommandResult.Messages[0];
		}

		internal string GetCurrentPlayerDisplayNameForStyleUi()
		{
			return GetStatusBaseName();
		}

		internal string GetCurrentPlayerPlainNameForStyleUi()
		{
			return RichTextStyleBuilder.ToPlainStyleEditorText(GetCurrentDisplayNameStateForStyleUi().BaseName);
		}

		internal string GetCurrentPlayerStyledNameForStyleUi()
		{
			return GetCurrentDisplayNameStateForStyleUi().BaseName;
		}

		internal DetectedDisplayNameState GetCurrentDisplayNameStateForStyleUi()
		{
			return StyleHelperNamePolicy.DetectCurrentState(GetLivePlayerDisplayName(), GetStatusBaseName(), StatusMessage?.Value ?? string.Empty, GetStatusColor(), StatusBrackets?.Value ?? "()", ShouldApplySpoons, SpoonCount?.Value ?? 5, GetSpoonLabel(), BuildStatusSuffix(), BuildSpoonSuffix());
		}

		private static string GetLivePlayerDisplayName()
		{
			try
			{
				string text = MonoSingleton<DataManager>.I?.PlayerData?.Name?.Trim();
				if (!string.IsNullOrWhiteSpace(text))
				{
					return text;
				}
			}
			catch
			{
			}
			try
			{
				TextChannelManager i = NetworkSingleton<TextChannelManager>.I;
				return ((i == null) ? null : i.UserName?.Trim()) ?? string.Empty;
			}
			catch
			{
				return string.Empty;
			}
		}

		private BlueSageCommandResult HandleSetPingColorCommand(BlueSageCommandContext context)
		{
			string value = context.Arguments.Trim();
			if (string.IsNullOrWhiteSpace(value))
			{
				return BlueSageCommandResult.HandledWithMessages("Ping Mentions color: #" + GetPingHighlightColor() + ".");
			}
			if (!RichTextStyleBuilder.TryNormalizeHex(value, out var hex))
			{
				return BlueSageCommandResult.HandledWithMessages("Ping Mentions: expected a hex color like #9B59B6.");
			}
			PingHighlightColor.Value = hex;
			((BaseUnityPlugin)this).Config.Save();
			return BlueSageCommandResult.HandledWithMessages("Ping Mentions color set to <color=#" + hex + ">#" + hex + "</color>.");
		}

		private BlueSageCommandResult HandleBlueSageClueCommand(BlueSageCommandContext context)
		{
			string text = GetStatusBaseName();
			if (string.IsNullOrWhiteSpace(text))
			{
				text = "You";
			}
			string text2 = EasterEggTracker.Discover("command_clue", "the secret BlueSage clue glyph");
			return BlueSageCommandResult.HandledWithMessages("♥☻ " + text + " found a Clue! ☻♥ Screenshot this to @jollyblue (Blues) in Discord to make him giggle. " + text2);
		}

		private BlueSageCommandResult HandleBoopCommand(BlueSageCommandContext context)
		{
			string text = EasterEggTracker.Discover("command_boop", "the respectful server boop");
			return BlueSageCommandResult.HandledWithMessages("Boop accepted. The lobby turtle has been emotionally supported. " + text);
		}

		private BlueSageCommandResult HandleSageWaveCommand(BlueSageCommandContext context)
		{
			string text = EasterEggTracker.Discover("command_sagewave", "the tiny Sage wave from behind the UI");
			return BlueSageCommandResult.HandledWithMessages("Sage waves from the menu bar, then pretends nothing happened. " + text);
		}

		private BlueSageCommandResult HandleSetNameCommand(BlueSageCommandContext context)
		{
			string text = context.Arguments.Trim();
			if (string.IsNullOrWhiteSpace(text))
			{
				return BlueSageCommandResult.HandledWithMessages("Status Helper name: " + GetStatusBaseName() + ".");
			}
			bool applied;
			if (string.Equals(text, "reset", StringComparison.OrdinalIgnoreCase) || string.Equals(text, "default", StringComparison.OrdinalIgnoreCase))
			{
				string steamPersonaName = GetSteamPersonaName();
				if (string.IsNullOrWhiteSpace(steamPersonaName))
				{
					return BlueSageCommandResult.HandledWithMessages("Status Helper: Steam persona name is not ready yet; no name change was made.");
				}
				DisplayNameDraft displayNameDraft = CaptureDisplayNameDraft(captureLiveBase: false);
				displayNameDraft.BaseName = steamPersonaName;
				return TryApplyDisplayNameDraft(displayNameDraft, "Status Helper: name reset to your current Steam persona name.", out applied);
			}
			DisplayNameDraft displayNameDraft2 = CaptureDisplayNameDraft(captureLiveBase: false);
			displayNameDraft2.BaseName = text;
			return TryApplyDisplayNameDraft(displayNameDraft2, "Status Helper: name updated.", out applied);
		}

		private BlueSageCommandResult HandleStatusCommand(BlueSageCommandContext context)
		{
			string text = context.Arguments.Trim();
			if (string.IsNullOrWhiteSpace(text))
			{
				return BlueSageCommandResult.HandledWithMessages(string.IsNullOrWhiteSpace(StatusMessage.Value) ? "Status Helper: no status set. Use /status BRB or /clearstatus." : ("Status Helper status: " + StatusMessage.Value + "."));
			}
			DisplayNameDraft displayNameDraft = CaptureDisplayNameDraft(captureLiveBase: true);
			displayNameDraft.StatusMessage = text;
			bool applied;
			BlueSageCommandResult result = TryApplyDisplayNameDraft(displayNameDraft, "Status Helper: status updated.", out applied);
			if (applied)
			{
				_lastStatusBeforePreset = string.Empty;
			}
			return result;
		}

		private BlueSageCommandResult SetPresetStatus(string status)
		{
			DisplayNameDraft displayNameDraft = CaptureDisplayNameDraft(captureLiveBase: true);
			string text = (displayNameDraft.StatusMessage ?? string.Empty).Trim();
			string lastStatusBeforePreset = _lastStatusBeforePreset;
			if (!string.Equals(text, "BRB", StringComparison.OrdinalIgnoreCase) && !string.Equals(text, "AFK", StringComparison.OrdinalIgnoreCase))
			{
				lastStatusBeforePreset = text;
			}
			displayNameDraft.StatusMessage = status;
			bool applied;
			BlueSageCommandResult result = TryApplyDisplayNameDraft(displayNameDraft, "Status Helper: status set to " + status + ".", out applied);
			if (applied)
			{
				_lastStatusBeforePreset = lastStatusBeforePreset;
			}
			return result;
		}

		private BlueSageCommandResult HandleBackStatusCommand(BlueSageCommandContext context)
		{
			DisplayNameDraft displayNameDraft = CaptureDisplayNameDraft(captureLiveBase: true);
			string text = (displayNameDraft.StatusMessage = (_lastStatusBeforePreset ?? string.Empty).Trim());
			string successMessage = (string.IsNullOrWhiteSpace(text) ? "Status Helper: back cleared your BRB/AFK status." : ("Status Helper: back restored " + text + "."));
			bool applied;
			BlueSageCommandResult result = TryApplyDisplayNameDraft(displayNameDraft, successMessage, out applied);
			if (applied)
			{
				_lastStatusBeforePreset = string.Empty;
			}
			return result;
		}

		private BlueSageCommandResult HandleClearStatusCommand(BlueSageCommandContext context)
		{
			DisplayNameDraft displayNameDraft = CaptureDisplayNameDraft(captureLiveBase: true);
			displayNameDraft.StatusMessage = string.Empty;
			bool applied;
			BlueSageCommandResult result = TryApplyDisplayNameDraft(displayNameDraft, "Status Helper: status cleared.", out applied);
			if (applied)
			{
				_lastStatusBeforePreset = string.Empty;
			}
			return result;
		}

		private BlueSageCommandResult HandleStatusColorCommand(BlueSageCommandContext context)
		{
			string text = context.Arguments.Trim();
			if (string.IsNullOrWhiteSpace(text))
			{
				return BlueSageCommandResult.HandledWithMessages("Status Helper color: #" + GetStatusColor() + ".");
			}
			bool applied;
			if (string.Equals(text, "reset", StringComparison.OrdinalIgnoreCase) || string.Equals(text, "default", StringComparison.OrdinalIgnoreCase))
			{
				DisplayNameDraft displayNameDraft = CaptureDisplayNameDraft(captureLiveBase: true);
				displayNameDraft.StatusColor = "FFD45D";
				return TryApplyDisplayNameDraft(displayNameDraft, "Status Helper color: reset to #FFD45D.", out applied);
			}
			if (!RichTextStyleBuilder.TryNormalizeHex(text, out var hex))
			{
				return BlueSageCommandResult.HandledWithMessages("Status Helper: expected a hex color like #FFD45D.");
			}
			DisplayNameDraft displayNameDraft2 = CaptureDisplayNameDraft(captureLiveBase: true);
			displayNameDraft2.StatusColor = hex;
			return TryApplyDisplayNameDraft(displayNameDraft2, "Status Helper color: #" + hex + ".", out applied);
		}

		private BlueSageCommandResult HandleSpoonsCommand(BlueSageCommandContext context)
		{
			string text = context.Arguments.Trim();
			if (string.IsNullOrWhiteSpace(text) || string.Equals(text, "status", StringComparison.OrdinalIgnoreCase))
			{
				return BlueSageCommandResult.HandledWithMessages("Spoons: " + FormatSpoonStatus() + ".");
			}
			bool applied;
			if (string.Equals(text, "off", StringComparison.OrdinalIgnoreCase))
			{
				DisplayNameDraft displayNameDraft = CaptureDisplayNameDraft(captureLiveBase: true);
				displayNameDraft.SpoonsEnabled = false;
				return TryApplyDisplayNameDraft(displayNameDraft, "Spoons: hidden.", out applied);
			}
			if (string.Equals(text, "reset", StringComparison.OrdinalIgnoreCase) || string.Equals(text, "default", StringComparison.OrdinalIgnoreCase))
			{
				DisplayNameDraft displayNameDraft2 = CaptureDisplayNameDraft(captureLiveBase: true);
				displayNameDraft2.SpoonCount = 5;
				displayNameDraft2.SpoonLabel = "sp";
				displayNameDraft2.SpoonsEnabled = false;
				displayNameDraft2.SpoonsUpdatedUtc = DateTime.UtcNow.ToString("O");
				return TryApplyDisplayNameDraft(displayNameDraft2, "Spoons: reset to hidden default [5/5sp]. Use /spoons on when you want it visible.", out applied);
			}
			if (string.Equals(text, "on", StringComparison.OrdinalIgnoreCase))
			{
				DisplayNameDraft displayNameDraft3 = CaptureDisplayNameDraft(captureLiveBase: true);
				displayNameDraft3.SpoonsEnabled = true;
				return TryApplyDisplayNameDraft(displayNameDraft3, "Spoons: visible as [" + ClampSpoons(displayNameDraft3.SpoonCount) + "/5" + GetSpoonLabel(displayNameDraft3.SpoonLabel) + "].", out applied);
			}
			if (!int.TryParse(text, out var result))
			{
				return BlueSageCommandResult.HandledWithMessages("Spoons: use /spoons 0 through /spoons 5, /spoons status, /spoons on, /spoons off, or /spoons reset.");
			}
			DisplayNameDraft displayNameDraft4 = CaptureDisplayNameDraft(captureLiveBase: true);
			displayNameDraft4.SpoonCount = ClampSpoons(result);
			displayNameDraft4.SpoonsEnabled = true;
			displayNameDraft4.SpoonsUpdatedUtc = DateTime.UtcNow.ToString("O");
			return TryApplyDisplayNameDraft(displayNameDraft4, "Spoons: set to [" + displayNameDraft4.SpoonCount + "/5" + GetSpoonLabel(displayNameDraft4.SpoonLabel) + "].", out applied);
		}

		private void EnforceHiddenDiagnosticsLockedOn()
		{
			if (EnableHiddenDiagnostics != null && !EnableHiddenDiagnostics.Value)
			{
				EnableHiddenDiagnostics.Value = true;
				((BaseUnityPlugin)this).Config.Save();
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogInfo((object)"BlueSage diagnostics config was normalized to the 0.2.x locked-on state.");
				}
			}
		}

		private BlueSageCommandResult HandleSetMoodCommand(BlueSageCommandContext context)
		{
			string text = context.Arguments.Trim();
			if (string.IsNullOrWhiteSpace(text) || string.Equals(text, "status", StringComparison.OrdinalIgnoreCase))
			{
				return BlueSageCommandResult.HandledWithMessages("Mood label: " + GetSpoonLabel() + ". Use /setmood energy, /setmood spoons, or /setmood default.");
			}
			if (string.Equals(text, "default", StringComparison.OrdinalIgnoreCase) || string.Equals(text, "reset", StringComparison.OrdinalIgnoreCase))
			{
				text = "sp";
			}
			string text2 = new string(text.Where((char c) => char.IsLetterOrDigit(c) || c == '-' || c == '_').Take(12).ToArray());
			if (string.IsNullOrWhiteSpace(text2))
			{
				return BlueSageCommandResult.HandledWithMessages("Mood label: use 1-12 letters/numbers, '-' or '_'. Example: /setmood energy.");
			}
			DisplayNameDraft displayNameDraft = CaptureDisplayNameDraft(captureLiveBase: true);
			displayNameDraft.SpoonLabel = text2;
			displayNameDraft.SpoonsEnabled = true;
			displayNameDraft.SpoonsUpdatedUtc = DateTime.UtcNow.ToString("O");
			bool applied;
			return TryApplyDisplayNameDraft(displayNameDraft, "Mood label: now [" + ClampSpoons(displayNameDraft.SpoonCount) + "/5" + text2 + "]. /setmood default restores [x/5sp].", out applied);
		}

		internal string ApplySpoonVisibilityFromMenu()
		{
			bool applied;
			return TrySetSpoonVisibilityFromMenu(ShouldApplySpoons, out applied);
		}

		internal string TrySetSpoonVisibilityFromMenu(bool enabled, out bool applied)
		{
			DisplayNameDraft displayNameDraft = CaptureDisplayNameDraft(captureLiveBase: true);
			displayNameDraft.SpoonsEnabled = enabled;
			BlueSageCommandResult blueSageCommandResult = TryApplyDisplayNameDraft(displayNameDraft, enabled ? ("Spoons: visible as [" + ClampSpoons(displayNameDraft.SpoonCount) + "/5" + GetSpoonLabel(displayNameDraft.SpoonLabel) + "].") : "Spoons: hidden.", out applied);
			if (blueSageCommandResult.Messages.Count <= 0)
			{
				if (!enabled)
				{
					return "Spoons: hidden.";
				}
				return "Spoons: visible.";
			}
			return blueSageCommandResult.Messages[0];
		}

		internal string TryApplySpoonsFromStyleUi(int count, string label, bool enabled, string updatedUtc, out bool applied)
		{
			DisplayNameDraft displayNameDraft = CaptureDisplayNameDraft(captureLiveBase: true);
			displayNameDraft.SpoonCount = ClampSpoons(count);
			displayNameDraft.SpoonLabel = GetSpoonLabel(label);
			displayNameDraft.SpoonsEnabled = enabled;
			displayNameDraft.SpoonsUpdatedUtc = updatedUtc ?? string.Empty;
			BlueSageCommandResult blueSageCommandResult = TryApplyDisplayNameDraft(displayNameDraft, enabled ? ("Spoons: visible as [" + displayNameDraft.SpoonCount + "/5" + displayNameDraft.SpoonLabel + "].") : "Spoons: hidden.", out applied);
			if (blueSageCommandResult.Messages.Count <= 0)
			{
				return "Spoons updated.";
			}
			return blueSageCommandResult.Messages[0];
		}

		internal void CaptureLiveStyledBaseBeforeSuffixChange()
		{
		}

		private BlueSageCommandResult ApplyStatusNameToPlayerData(string successMessage)
		{
			bool applied;
			return TryApplyDisplayNameDraft(CaptureDisplayNameDraft(captureLiveBase: false), successMessage, out applied);
		}

		private DisplayNameDraft CaptureDisplayNameDraft(bool captureLiveBase)
		{
			DisplayNameDraft displayNameDraft = new DisplayNameDraft
			{
				BaseName = GetStatusBaseName(),
				StatusMessage = (StatusMessage?.Value ?? string.Empty),
				StatusColor = GetStatusColor(),
				StatusBrackets = (StatusBrackets?.Value ?? "()"),
				SpoonsEnabled = ShouldApplySpoons,
				SpoonCount = ClampSpoons(SpoonCount?.Value ?? 5),
				SpoonLabel = GetSpoonLabel(),
				SpoonsUpdatedUtc = (SpoonsUpdatedUtc?.Value ?? string.Empty)
			};
			if (captureLiveBase && string.IsNullOrWhiteSpace(displayNameDraft.BaseName))
			{
				string baseName = GetCurrentDisplayNameStateForStyleUi().BaseName;
				if (!string.IsNullOrWhiteSpace(RichTextStyleBuilder.ToPlainStyleEditorText(baseName)))
				{
					displayNameDraft.BaseName = baseName;
				}
			}
			return displayNameDraft;
		}

		public string GetCompanionStyledBase()
		{
			return CaptureDisplayNameDraft(captureLiveBase: false).BaseName ?? string.Empty;
		}

		public bool TryApplyCompanionStyledBase(string baseName, out string resultMessage)
		{
			DisplayNameDraft displayNameDraft = CaptureDisplayNameDraft(captureLiveBase: false);
			displayNameDraft.BaseName = baseName ?? string.Empty;
			bool applied;
			BlueSageCommandResult blueSageCommandResult = TryApplyDisplayNameDraft(displayNameDraft, "Companion style change applied through BlueSage QoL.", out applied);
			resultMessage = ((blueSageCommandResult.Messages.Count > 0) ? blueSageCommandResult.Messages[0] : (applied ? "Companion style change applied through BlueSage QoL." : "Companion style change failed."));
			return applied;
		}

		public bool TrySetCompanionHostRoleLabel(string richText, out string resultMessage)
		{
			return PlayerRoleLabelController.TrySetLocalHostLabelOverride(richText, out resultMessage);
		}

		public bool TryClearCompanionHostRoleLabel(out string resultMessage)
		{
			return PlayerRoleLabelController.TryClearLocalHostLabelOverride(out resultMessage);
		}

		public bool TryFocusCompanionHostConsole(out string resultMessage)
		{
			if ((Object)(object)_qolMenuWindow == (Object)null)
			{
				StartQolMenuWindow();
			}
			if ((Object)(object)_qolMenuWindow == (Object)null || !_qolMenuWindow.ShowHostConsole())
			{
				resultMessage = "Host Console unavailable; current verified host access is required.";
				return false;
			}
			resultMessage = "BlueSage Host Console opened.";
			return true;
		}

		public bool TryResolveCompanionIdentityTruthV1(ulong exactSteamId, ulong exactPurrNetId, out BlueSageIdentityTruthSnapshotV1 truth, out string resultMessage)
		{
			return PlayerBadgeController.TryResolveFreshIdentityTruth(exactSteamId, exactPurrNetId, out truth, out resultMessage);
		}

		public bool TryResolveCompanionIdentityTruthV2(ulong exactSteamId, out BlueSageIdentityTruthSnapshotV1 truth, out string resultMessage)
		{
			return PlayerBadgeController.TryResolveFreshIdentityTruthBySteam(exactSteamId, out truth, out resultMessage);
		}

		private BlueSageCommandResult TryApplyDisplayNameDraft(DisplayNameDraft draft, string successMessage, out bool applied)
		{
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			applied = false;
			if (draft == null)
			{
				return BlueSageCommandResult.HandledWithMessages("Status Helper: player name is not ready yet.");
			}
			int num = (PlayerIdInfoLimitPatch.HasExpectedCoverage ? LockedMaxIdCardCharacters : Math.Min(LockedMaxIdCardCharacters, 1000));
			if (!DisplayNameMutationPolicy.TryCompose(draft.BaseName, BuildStatusSuffix(draft), BuildSpoonSuffix(draft), num, out var displayName, out var error))
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)("Status Helper rejected a display-name draft before mutation. " + $"baseLength={(draft.BaseName ?? string.Empty).Length}, limit={num}, reason={error}"));
				}
				return BlueSageCommandResult.HandledWithMessages(error);
			}
			DataManager val;
			try
			{
				val = MonoSingleton<DataManager>.I;
			}
			catch
			{
				val = null;
			}
			if ((Object)(object)val == (Object)null || val.PlayerData == null)
			{
				return BlueSageCommandResult.HandledWithMessages("Status Helper: player data is not ready yet.");
			}
			TextChannelManager val2;
			try
			{
				val2 = NetworkSingleton<TextChannelManager>.I;
			}
			catch
			{
				val2 = null;
			}
			if ((Object)(object)val2 == (Object)null || (Object)(object)val2.MainCustomizationController == (Object)null)
			{
				return BlueSageCommandResult.HandledWithMessages("Status Helper: native player identity sync is not ready yet.");
			}
			DisplayNameDraft previous = CaptureDisplayNameDraft(captureLiveBase: false);
			string name = val.PlayerData.Name;
			string userName = val2.UserName;
			UIManager val3 = null;
			string uiName = string.Empty;
			try
			{
				val3 = MonoSingleton<UIManager>.I;
				if ((Object)(object)val3 != (Object)null && (Object)(object)val3.PlayerText != (Object)null)
				{
					uiName = ((TMP_Text)val3.PlayerText).text;
				}
				val.PlayerData.Name = displayName;
				val.SavePlayerData();
				PlayerIDInfo playerIdInfo = val.PlayerData.GetPlayerIdInfo();
				string text = Encoding.Unicode.GetString(playerIdInfo.Name ?? new byte[0]).TrimEnd(new char[1]);
				if (!string.Equals(val.PlayerData.Name, displayName, StringComparison.Ordinal) || !string.Equals(text, displayName, StringComparison.Ordinal))
				{
					throw new InvalidOperationException("native display-name readback did not match the requested value " + $"(requested={displayName.Length}, playerData={(val.PlayerData.Name ?? string.Empty).Length}, serialized={text.Length})");
				}
				val2.UserName = displayName;
				val2.MainCustomizationController.UpdatePlayerInfo(playerIdInfo, default(RPCInfo));
				if ((Object)(object)val3 != (Object)null && (Object)(object)val3.PlayerText != (Object)null)
				{
					((TMP_Text)val3.PlayerText).text = displayName;
				}
				if (!string.Equals(val2.UserName, displayName, StringComparison.Ordinal))
				{
					throw new InvalidOperationException("text-channel display-name readback did not match the requested value");
				}
				if ((Object)(object)val3 != (Object)null && (Object)(object)val3.PlayerText != (Object)null && !string.Equals(((TMP_Text)val3.PlayerText).text, displayName, StringComparison.Ordinal))
				{
					throw new InvalidOperationException("local UI display-name readback did not match the requested value");
				}
				CommitDisplayNameDraft(draft);
				((BaseUnityPlugin)this).Config.Save();
				applied = true;
				return BlueSageCommandResult.HandledWithMessages(successMessage);
			}
			catch (Exception ex)
			{
				RestoreDisplayNameConfig(previous);
				TryRestoreNativeDisplayName(val, name, val2, userName, val3, uiName);
				Log.LogWarning((object)("Status Helper update failed: " + ex.GetType().Name + ": " + ex.Message));
				return BlueSageCommandResult.HandledWithMessages("Status Helper: update failed; check BepInEx console.");
			}
		}

		private static void CommitDisplayNameDraft(DisplayNameDraft draft)
		{
			StatusBaseName.Value = (draft.BaseName ?? string.Empty).Trim();
			StatusMessage.Value = (draft.StatusMessage ?? string.Empty).Trim();
			StatusColor.Value = GetNormalizedStatusColor(draft.StatusColor);
			StatusBrackets.Value = (string.IsNullOrWhiteSpace(draft.StatusBrackets) ? "()" : draft.StatusBrackets);
			EnableSpoons.Value = draft.SpoonsEnabled;
			SpoonCount.Value = ClampSpoons(draft.SpoonCount);
			SpoonLabel.Value = GetSpoonLabel(draft.SpoonLabel);
			SpoonsUpdatedUtc.Value = draft.SpoonsUpdatedUtc ?? string.Empty;
		}

		private static void RestoreDisplayNameConfig(DisplayNameDraft previous)
		{
			if (previous == null)
			{
				return;
			}
			CommitDisplayNameDraft(previous);
			try
			{
				Plugin instance = Instance;
				if (instance != null)
				{
					((BaseUnityPlugin)instance).Config.Save();
				}
			}
			catch
			{
			}
		}

		private static void TryRestoreNativeDisplayName(DataManager dataManager, string playerName, TextChannelManager textChannelManager, string channelName, UIManager uiManager, string uiName)
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (dataManager?.PlayerData != null)
				{
					dataManager.PlayerData.Name = playerName;
					dataManager.SavePlayerData();
				}
				if ((Object)(object)textChannelManager != (Object)null)
				{
					textChannelManager.UserName = channelName;
					if ((Object)(object)textChannelManager.MainCustomizationController != (Object)null && dataManager?.PlayerData != null)
					{
						textChannelManager.MainCustomizationController.UpdatePlayerInfo(dataManager.PlayerData.GetPlayerIdInfo(), default(RPCInfo));
					}
				}
				if ((Object)(object)uiManager != (Object)null && (Object)(object)uiManager.PlayerText != (Object)null)
				{
					((TMP_Text)uiManager.PlayerText).text = uiName;
				}
			}
			catch
			{
			}
		}

		private static string BuildStatusDisplayName(string baseName)
		{
			string statusSuffix = BuildStatusSuffix();
			string spoonSuffix = BuildSpoonSuffix();
			return DisplayNameCompositionPolicy.Compose(baseName, statusSuffix, spoonSuffix);
		}

		private static string BuildStatusSuffix()
		{
			return BuildStatusSuffix(new DisplayNameDraft
			{
				StatusMessage = (StatusMessage?.Value ?? string.Empty),
				StatusColor = GetStatusColor(),
				StatusBrackets = (StatusBrackets?.Value ?? "()")
			});
		}

		private static string BuildStatusSuffix(DisplayNameDraft draft)
		{
			return StatusSuffixPolicy.Build(draft?.StatusMessage ?? string.Empty, GetNormalizedStatusColor(draft?.StatusColor), draft?.StatusBrackets ?? "()");
		}

		internal static string BuildSpoonSuffix()
		{
			return BuildSpoonSuffix(new DisplayNameDraft
			{
				SpoonsEnabled = ShouldApplySpoons,
				SpoonCount = (SpoonCount?.Value ?? 5),
				SpoonLabel = GetSpoonLabel()
			});
		}

		private static string BuildSpoonSuffix(DisplayNameDraft draft)
		{
			if (draft == null || !draft.SpoonsEnabled)
			{
				return string.Empty;
			}
			int num = ClampSpoons(draft.SpoonCount);
			return RichTextStyleBuilder.BuildColorTag("70FFBD", $"[{num}/5{GetSpoonLabel(draft.SpoonLabel)}]");
		}

		private static string FormatSpoonStatus()
		{
			int num = ClampSpoons(SpoonCount?.Value ?? 5);
			string text = SpoonsUpdatedUtc?.Value ?? string.Empty;
			string text2 = (string.IsNullOrWhiteSpace(text) ? "not stamped yet" : ("updated " + text));
			string text3 = (ShouldApplySpoons ? "visible" : "hidden");
			return $"{num}/5{GetSpoonLabel()}, {text3}, {text2}";
		}

		private static string GetSpoonLabel()
		{
			return GetSpoonLabel(SpoonLabel?.Value);
		}

		private static string GetSpoonLabel(string value)
		{
			string text = new string((value ?? "sp").Where((char c) => char.IsLetterOrDigit(c) || c == '-' || c == '_').Take(12).ToArray());
			if (!string.IsNullOrWhiteSpace(text))
			{
				return text;
			}
			return "sp";
		}

		private static int ClampSpoons(int value)
		{
			if (value < 0)
			{
				return 0;
			}
			if (value <= 5)
			{
				return value;
			}
			return 5;
		}

		private static void StampSpoonsUpdated()
		{
			if (SpoonsUpdatedUtc != null)
			{
				SpoonsUpdatedUtc.Value = DateTime.UtcNow.ToString("O");
			}
		}

		private static string GetStatusBaseName()
		{
			string text = (StatusBaseName.Value ?? string.Empty).Trim();
			if (!string.IsNullOrWhiteSpace(text))
			{
				return text;
			}
			try
			{
				return MonoSingleton<DataManager>.I?.PlayerData?.Name?.Trim() ?? string.Empty;
			}
			catch
			{
				return string.Empty;
			}
		}

		private static string GetStatusColor()
		{
			return GetNormalizedStatusColor(StatusColor?.Value);
		}

		private static string GetSteamPersonaName()
		{
			try
			{
				if (!SteamManager.Initialized)
				{
					return string.Empty;
				}
				return (SteamFriends.GetPersonaName() ?? string.Empty).Trim();
			}
			catch
			{
				return string.Empty;
			}
		}

		private static string GetNormalizedStatusColor(string value)
		{
			if (!RichTextStyleBuilder.TryNormalizeHex(value, out var hex))
			{
				return "FFD45D";
			}
			return hex;
		}

		internal static string GetPingHighlightColor()
		{
			if (!RichTextStyleBuilder.TryNormalizeHex(PingHighlightColor.Value, out var hex))
			{
				return "9B59B6";
			}
			return hex;
		}

		internal static string GetPingMentionColor()
		{
			if (!RichTextStyleBuilder.TryNormalizeHex(PingMentionColor.Value, out var hex))
			{
				return "FFD700";
			}
			return hex;
		}

		internal static string GetPingSoundMode()
		{
			string text = (PingSoundMode?.Value ?? "ticket").Trim().ToLowerInvariant();
			switch (text)
			{
			case "change":
			case "error":
			case "task":
			case "ticket":
				return text;
			default:
				return "ticket";
			}
		}

		private BlueSageCommandResult HandlePingSoundCommand(BlueSageCommandContext context)
		{
			string text = (context.Arguments ?? string.Empty).Trim().ToLowerInvariant();
			if (!string.IsNullOrWhiteSpace(text))
			{
				switch (text)
				{
				case "status":
					break;
				case "on":
				case "off":
					EnablePingSound.Value = text == "on";
					((BaseUnityPlugin)this).Config.Save();
					return BlueSageCommandResult.HandledWithMessages("Ping Sound: " + (EnablePingSound.Value ? "on." : "off."));
				case "click":
				case "change":
				case "error":
				case "task":
				case "ticket":
					PingSoundMode.Value = text;
					EnablePingSound.Value = true;
					((BaseUnityPlugin)this).Config.Save();
					MentionPingController.PlayConfiguredPing();
					return BlueSageCommandResult.HandledWithMessages("Ping Sound mode set to " + text + ".");
				default:
					return BlueSageCommandResult.HandledWithMessages("Ping Sound: use /pingsound click, change, error, task, ticket, on, off, or status.");
				}
			}
			return BlueSageCommandResult.HandledWithMessages("Ping Sound: " + (EnablePingSound.Value ? "on" : "off") + ", mode=" + GetPingSoundMode() + ". Use /pingsound click|change|error|task|ticket|on|off.");
		}

		private void StartMentionPingController()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			if (!((Object)(object)_mentionPingControllerObject != (Object)null))
			{
				_mentionPingControllerObject = new GameObject("BlueSage_MentionPingController");
				_mentionPingControllerObject.AddComponent<MentionPingController>();
				Object.DontDestroyOnLoad((Object)(object)_mentionPingControllerObject);
			}
		}

		private void StartCommandTypeaheadController()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			if (!((Object)(object)_commandTypeaheadControllerObject != (Object)null))
			{
				_commandTypeaheadControllerObject = new GameObject("BlueSage_CommandTypeaheadController");
				_commandTypeaheadControllerObject.AddComponent<CommandTypeaheadController>();
				Object.DontDestroyOnLoad((Object)(object)_commandTypeaheadControllerObject);
			}
		}

		private void StartChatReadabilityController()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			if (!((Object)(object)_chatReadabilityControllerObject != (Object)null))
			{
				_chatReadabilityControllerObject = new GameObject("BlueSage_ChatReadabilityController");
				_chatReadabilityControllerObject.AddComponent<ChatReadabilityController>();
				Object.DontDestroyOnLoad((Object)(object)_chatReadabilityControllerObject);
			}
		}

		private void StartSessionAuditController()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			if (!((Object)(object)_sessionAuditControllerObject != (Object)null))
			{
				_sessionAuditControllerObject = new GameObject("BlueSage_SessionAuditController");
				_sessionAuditControllerObject.AddComponent<SessionAuditController>();
				Object.DontDestroyOnLoad((Object)(object)_sessionAuditControllerObject);
			}
		}

		private void StartSessionRunMarkerController()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			if (!((Object)(object)_sessionRunMarkerControllerObject != (Object)null))
			{
				_sessionRunMarkerControllerObject = new GameObject("BlueSage_SessionRunMarkerController");
				_sessionRunMarkerControllerObject.AddComponent<SessionRunMarkerController>();
				Object.DontDestroyOnLoad((Object)(object)_sessionRunMarkerControllerObject);
			}
		}

		private void StartStewardAnnouncementBridgeController()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			if (!((Object)(object)_stewardAnnouncementBridgeControllerObject != (Object)null))
			{
				_stewardAnnouncementBridgeControllerObject = new GameObject("BlueSage_StewardAnnouncementBridgeController");
				_stewardAnnouncementBridgeControllerObject.AddComponent<StewardAnnouncementBridgeController>();
				Object.DontDestroyOnLoad((Object)(object)_stewardAnnouncementBridgeControllerObject);
			}
		}

		internal static bool IsLobbyMassPingAuthorized(string senderSteamId)
		{
			if (!TryGetCurrentSteamLobby(out var _))
			{
				return false;
			}
			if (string.IsNullOrWhiteSpace(senderSteamId) || !PlayerIdentityEvidenceController.TryResolveExact(senderSteamId, out var _, out var _))
			{
				return false;
			}
			return SteamIdModerationController.IsAuthorizedCurrentIssuer(senderSteamId);
		}

		private void StartRescueReceiverCapabilityPublisher()
		{
			if (_rescueReceiverCapabilityCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_rescueReceiverCapabilityCoroutine);
			}
			_rescueReceiverCapabilityCoroutine = ((MonoBehaviour)this).StartCoroutine(RescueReceiverCapabilityLoop());
		}

		private IEnumerator RescueReceiverCapabilityLoop()
		{
			while (true)
			{
				PublishRescueReceiverCapability();
				yield return (object)new WaitForSecondsRealtime(5f);
			}
		}

		private void PublishRescueReceiverCapability()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			if (PluginShutdownController.IsShuttingDown)
			{
				return;
			}
			try
			{
				if (!OptInRescuePatch.IsReceiverAvailable || !SteamManager.Initialized || !TryGetRescueLobby(out var lobbyId) || lobbyId == CSteamID.Nil || !IsLocalCurrentLobbyMember(lobbyId))
				{
					ClearRescueReceiverCapability();
					return;
				}
				if (_rescueReceiverCapabilityLobby != CSteamID.Nil && _rescueReceiverCapabilityLobby != lobbyId)
				{
					ClearRescueReceiverCapability();
				}
				string text = RescueReceiverCapabilityPolicy.BuildPayload("0.2.4", DateTimeOffset.UtcNow.ToUnixTimeSeconds());
				if (text.Length == 0)
				{
					ClearRescueReceiverCapability();
					return;
				}
				SteamMatchmaking.SetLobbyMemberData(lobbyId, "bluesage_qol_rescue_receiver_v1", text);
				_rescueReceiverCapabilityLobby = lobbyId;
			}
			catch
			{
				ClearRescueReceiverCapability();
			}
		}

		private void ClearRescueReceiverCapability()
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			if (PluginShutdownController.IsShuttingDown)
			{
				return;
			}
			CSteamID rescueReceiverCapabilityLobby = _rescueReceiverCapabilityLobby;
			_rescueReceiverCapabilityLobby = CSteamID.Nil;
			if (rescueReceiverCapabilityLobby == CSteamID.Nil || !SteamManager.Initialized)
			{
				return;
			}
			try
			{
				SteamMatchmaking.SetLobbyMemberData(rescueReceiverCapabilityLobby, "bluesage_qol_rescue_receiver_v1", string.Empty);
			}
			catch
			{
			}
		}

		private void ClearRescueReceiverCapability(SteamRuntimeSnapshot snapshot)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			CSteamID val = ((_rescueReceiverCapabilityLobby != CSteamID.Nil) ? _rescueReceiverCapabilityLobby : (snapshot?.Lobby ?? CSteamID.Nil));
			_rescueReceiverCapabilityLobby = CSteamID.Nil;
			if (snapshot == null || !snapshot.SteamWasReady || val == CSteamID.Nil)
			{
				return;
			}
			try
			{
				SteamMatchmaking.SetLobbyMemberData(val, "bluesage_qol_rescue_receiver_v1", string.Empty);
			}
			catch
			{
			}
		}

		private static bool IsLocalCurrentLobbyMember(CSteamID lobby)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			CSteamID steamID = SteamUser.GetSteamID();
			int numLobbyMembers = SteamMatchmaking.GetNumLobbyMembers(lobby);
			for (int i = 0; i < numLobbyMembers; i++)
			{
				if (SteamMatchmaking.GetLobbyMemberByIndex(lobby, i) == steamID)
				{
					return true;
				}
			}
			return false;
		}

		internal static bool TryGetRescueLobby(out CSteamID lobbyId)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if (PluginShutdownController.IsShuttingDown)
			{
				lobbyId = CSteamID.Nil;
				return false;
			}
			return TryGetCurrentSteamLobby(out lobbyId);
		}

		private BlueSageCommandResult HandleHelperCommand(BlueSageCommandContext context)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			if (!CanManageHelpers())
			{
				return BlueSageCommandResult.HandledWithMessages("Helper management is available only to the current lobby host. No Helper details were shown.");
			}
			if (!TryGetCurrentSteamLobby(out var lobbyId))
			{
				return BlueSageCommandResult.HandledWithMessages("Helpers: join a lobby first.");
			}
			CSteamID lobbyOwner = SteamMatchmaking.GetLobbyOwner(lobbyId);
			if (lobbyOwner == CSteamID.Nil || SteamUser.GetSteamID() != lobbyOwner || (Object)(object)NetworkManager.main == (Object)null || !NetworkManager.main.isHost)
			{
				return BlueSageCommandResult.HandledWithMessages("Helpers: this function is host only. You are not the current lobby host.");
			}
			string[] array = (context.Arguments ?? string.Empty).Split(new char[1] { ' ' }, 2, StringSplitOptions.RemoveEmptyEntries);
			string text = ((array.Length != 0) ? array[0].ToLowerInvariant() : "list");
			string text2 = ((ulong)lobbyOwner).ToString();
			HashSet<string> unifiedHelpersForOwner = GetUnifiedHelpersForOwner(text2, importLegacy: true);
			switch (text)
			{
			case "list":
			case "status":
			{
				string text3 = ((unifiedHelpersForOwner.Count == 0) ? "none" : string.Join(", ", unifiedHelpersForOwner.Select(FormatSteamIdSuffix)));
				return BlueSageCommandResult.HandledWithMessages("Helpers: " + text3 + ". One host-scoped list grants @lobby and host-validated moderation requests.");
			}
			case "reset":
			case "clear":
				SaveUnifiedHelpers(text2, Array.Empty<string>());
				SteamIdModerationController.PublishHostCapability();
				PlayerIdentityRoleHighlightController.RefreshAll();
				return BlueSageCommandResult.HandledWithMessages("Helpers: cleared. Only the host remains authorized.");
			default:
			{
				if ((text != "add" && text != "remove" && text != "revoke") || array.Length < 2)
				{
					return BlueSageCommandResult.HandledWithMessages("Helpers: use /helper add <current player>, remove <current player>, list, or reset.");
				}
				if (!TryResolveLobbyMemberSteamId(array[1], out var steamId, out var error))
				{
					return BlueSageCommandResult.HandledWithMessages("Helpers: " + error);
				}
				if (steamId == text2)
				{
					return BlueSageCommandResult.HandledWithMessages("Helpers: the host is already authorized.");
				}
				bool flag = text == "add";
				bool flag2 = (flag ? unifiedHelpersForOwner.Add(steamId) : unifiedHelpersForOwner.Remove(steamId));
				SaveUnifiedHelpers(text2, unifiedHelpersForOwner);
				SteamIdModerationController.PublishHostCapability();
				PlayerIdentityRoleHighlightController.RefreshAll();
				return BlueSageCommandResult.HandledWithMessages("Helpers: " + ((!flag2) ? "no change for " : (flag ? "authorized " : "revoked ")) + FormatSteamIdSuffix(steamId) + ". Helpers may use @lobby and request host-validated moderation actions.");
			}
			}
		}

		internal static HashSet<string> GetUnifiedHelpersForOwner(string ownerSteamId, bool importLegacy)
		{
			string text = UnifiedHelperPolicy.MergeForOwner(ownerSteamId, LobbyHelpers?.Value ?? string.Empty, LobbyHelperOwnerSteamId?.Value ?? string.Empty, (!importLegacy) ? string.Empty : (LobbyPingDelegates?.Value ?? string.Empty), (!importLegacy) ? string.Empty : (LobbyPingDelegateOwnerSteamId?.Value ?? string.Empty), (!importLegacy) ? string.Empty : (LobbyModerationDelegates?.Value ?? string.Empty), (!importLegacy) ? string.Empty : (LobbyModerationDelegateOwnerSteamId?.Value ?? string.Empty));
			HashSet<string> hashSet = new HashSet<string>(LobbyPingAuthorizationPolicy.ParseDelegates(text), StringComparer.Ordinal);
			if (importLegacy && (LobbyHelperOwnerSteamId == null || !string.Equals(LobbyHelperOwnerSteamId.Value, ownerSteamId, StringComparison.Ordinal) || !string.Equals(LobbyHelpers?.Value ?? string.Empty, text, StringComparison.Ordinal)))
			{
				SaveUnifiedHelpers(ownerSteamId, hashSet);
			}
			return hashSet;
		}

		private static void SaveUnifiedHelpers(string ownerSteamId, IEnumerable<string> helpers)
		{
			string value = LobbyPingAuthorizationPolicy.SerializeDelegates(helpers ?? Array.Empty<string>());
			LobbyHelpers.Value = value;
			LobbyHelperOwnerSteamId.Value = ownerSteamId;
			LobbyPingDelegates.Value = value;
			LobbyPingDelegateOwnerSteamId.Value = ownerSteamId;
			LobbyModerationDelegates.Value = value;
			LobbyModerationDelegateOwnerSteamId.Value = ownerSteamId;
			Plugin instance = Instance;
			if (instance != null)
			{
				((BaseUnityPlugin)instance).Config.Save();
			}
		}

		private BlueSageCommandResult HandleSidListCommand(BlueSageCommandContext context)
		{
			if (!CanUseLobbySafety(out var _))
			{
				return LobbySafetyDeniedResult();
			}
			IReadOnlyList<CloneIncident> snapshot = CloneIncidentLedger.Snapshot;
			if (snapshot.Count == 0)
			{
				return BlueSageCommandResult.HandledWithMessages("Clone Shield evidence: no open current-lobby incidents. Open the Lobby Safety tab for the verified roster, Helper controls, and closed history.");
			}
			List<string> list = new List<string> { "Clone Shield: " + snapshot.Count + " open incident(s). Open the Lobby Safety tab for exact IDs, profile buttons, highlights, preview, resolve, and dismiss controls." };
			foreach (CloneIncident item in snapshot.OrderByDescending((CloneIncident item) => item.LastObservedUnixSeconds).Take(3))
			{
				list.Add(item.Id + " | protected victim …" + FormatSteamIdSuffix(item.VictimSteamId).Replace("Steam …", string.Empty) + " | suspect …" + FormatSteamIdSuffix(item.SuspectSteamId).Replace("Steam …", string.Empty) + " | " + item.MatchType + ".");
			}
			if (snapshot.Count > 3)
			{
				list.Add(snapshot.Count - 3 + " more open incident(s) are available in Lobby Safety without filling chat.");
			}
			return BlueSageCommandResult.HandledWithMessages(list.ToArray());
		}

		private BlueSageCommandResult HandleSidIncidentCommand(BlueSageCommandContext context)
		{
			if (!CanUseLobbySafety(out var _))
			{
				return LobbySafetyDeniedResult();
			}
			string[] array = (context.Arguments ?? string.Empty).Split(new char[1] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
			if (array.Length == 0 || string.Equals(array[0], "status", StringComparison.OrdinalIgnoreCase) || string.Equals(array[0], "list", StringComparison.OrdinalIgnoreCase))
			{
				int count = CloneIncidentActionController.GetOpenIncidents().Count;
				int num = CloneIncidentActionController.GetIncidentHistory().Count((CloneIncident item) => item.State != CloneIncidentState.Open);
				return BlueSageCommandResult.HandledWithMessages("Clone incidents: " + count + " open, " + num + " closed locally. Use /sidincident <C001> resolve|dismiss, clear-player <verified player>, dismiss-all, clear-history, or clear-all.");
			}
			switch (array[0].ToLowerInvariant())
			{
			case "dismiss-all":
			case "dismissall":
			{
				CloneIncidentActionController.TryDismissAllOpenLocal(out string message3);
				return BlueSageCommandResult.HandledWithMessages(message3);
			}
			case "clear-history":
			case "clearhistory":
			{
				int num3 = CloneIncidentActionController.ClearClosedHistory();
				return BlueSageCommandResult.HandledWithMessages("Cleared " + num3 + " closed local Clone Shield " + ((num3 == 1) ? "record" : "records") + ". Open incidents and lobby moderation state were unchanged.");
			}
			case "clear-all":
			case "clearall":
			{
				CloneIncidentActionController.TryDismissAllOpenLocal(out string _);
				int num2 = CloneIncidentActionController.ClearClosedHistory();
				return BlueSageCommandResult.HandledWithMessages("Cleared the local Clone Shield incident view (" + num2 + " archived record" + ((num2 == 1) ? string.Empty : "s") + "). No bans, Helper state, or lobby moderation state changed.");
			}
			case "clear-player":
			case "clear-row":
			case "clearplayer":
			case "clearrow":
				if (array.Length >= 2)
				{
					if (!PlayerIdentityEvidenceController.TryResolveLookup(string.Join(" ", array.Skip(1)), out var evidence, out var error))
					{
						return BlueSageCommandResult.HandledWithMessages("Clone incident player cleanup refused: " + error);
					}
					CloneIncidentActionController.TryDismissOpenForVerifiedPlayer(evidence.SteamId, out string message);
					return BlueSageCommandResult.HandledWithMessages(message);
				}
				break;
			}
			if (array.Length >= 2 && array[0].StartsWith("C", StringComparison.OrdinalIgnoreCase))
			{
				string incidentId = array[0];
				string text = array[1].ToLowerInvariant();
				if (text == "dismiss")
				{
					CloneIncidentActionController.TryDismissLocal(incidentId, out string message4);
					return BlueSageCommandResult.HandledWithMessages(message4);
				}
				if (text == "resolve")
				{
					CloneIncidentActionController.TryResolveForLobby(incidentId, out string message5);
					return BlueSageCommandResult.HandledWithMessages(message5);
				}
			}
			return BlueSageCommandResult.HandledWithMessages("Clone incidents: use /sidincident status, <C001> resolve, <C001> dismiss, clear-player <verified player>, dismiss-all, clear-history, or clear-all. Clear actions are local-only.");
		}

		private BlueSageCommandResult HandleSidWhoCommand(BlueSageCommandContext context)
		{
			if (!CanUseLobbySafety(out var _))
			{
				return LobbySafetyDeniedResult();
			}
			string text = (context.Arguments ?? string.Empty).Trim();
			bool flag = text.StartsWith("copy ", StringComparison.OrdinalIgnoreCase);
			string text2 = (flag ? text.Substring("copy ".Length).Trim() : text);
			string[] array = text.Split(new char[1] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
			if (array.Length != 0 && string.Equals(array[0], "list", StringComparison.OrdinalIgnoreCase))
			{
				IReadOnlyList<PlayerIdentityEvidence> verifiedRoster = PlayerIdentityEvidenceController.GetVerifiedRoster();
				return BlueSageCommandResult.HandledWithMessages((verifiedRoster.Count == 0) ? "Lobby Safety: no player rows currently pass both native-roster and Steam-lobby verification." : ("Lobby Safety: " + verifiedRoster.Count + " verified player row(s). Open the authorized Lobby Safety tab for paging, exact copy, profile verification, incident evidence, and host-validated actions without filling chat."));
			}
			if (string.IsNullOrWhiteSpace(text))
			{
				return BlueSageCommandResult.HandledWithMessages("SID lookup: use /sidwho list, or /sidwho <C001 | partial display name | regex | partial Steam persona | 4+ SteamID digits | _host | _self>.", "This command is read-only. /sidban still refuses names and requires preview plus confirmation.");
			}
			string error;
			IReadOnlyList<PlayerIdentityEvidence> readOnlyList = PlayerIdentityEvidenceController.ResolveLookupMatches(text2, out error);
			if (readOnlyList.Count == 0)
			{
				return BlueSageCommandResult.HandledWithMessages("SID lookup NOT RESOLVED: " + error + " No moderation action was taken.");
			}
			List<string> list;
			if (readOnlyList.Count > 1)
			{
				list = new List<string>();
				list.Add("SID lookup: " + readOnlyList.Count + " verified current players match '" + text2 + "'. No player was selected and no moderation action was taken.");
				List<string> list2 = list;
				foreach (PlayerIdentityEvidence item in readOnlyList.Take(8))
				{
					list2.Add("row #" + (item.RosterIndex + 1) + " | " + item.DisplayName + " | " + item.SteamPersona + " | " + item.SteamId + " | " + item.Role);
				}
				if (readOnlyList.Count > 8)
				{
					list2.Add(readOnlyList.Count - 8 + " more match(es). Refine the query or use Lobby Safety's live filter.");
				}
				list2.Add("Read-only results only. Select the exact live row in Lobby Safety before any preview action.");
				return BlueSageCommandResult.HandledWithMessages(list2.ToArray());
			}
			PlayerIdentityEvidence playerIdentityEvidence = readOnlyList[0];
			if (flag)
			{
				GUIUtility.systemCopyBuffer = PlayerIdentityEvidenceController.BuildCopyableEvidence(playerIdentityEvidence);
				return BlueSageCommandResult.HandledWithMessages("SID lookup COPY: copied verified live row #" + (playerIdentityEvidence.RosterIndex + 1) + " with displayed name, raw TMP source, Steam persona, exact SteamID64, PlayerID, and current role. Nothing was sent to chat.");
			}
			list = new List<string>();
			list.Add("SID lookup VERIFIED | row #" + (playerIdentityEvidence.RosterIndex + 1) + " | " + playerIdentityEvidence.DisplayName);
			list.Add("SteamID64: " + playerIdentityEvidence.SteamId + " | PlayerID " + playerIdentityEvidence.NetworkPlayerId + " | ending …" + PlayerIdentityEvidenceController.Suffix(playerIdentityEvidence.SteamId) + " | " + playerIdentityEvidence.Role);
			List<string> list3 = list;
			if (!string.IsNullOrWhiteSpace(playerIdentityEvidence.SteamPersona))
			{
				list3.Add("Cached Steam persona: " + playerIdentityEvidence.SteamPersona + ". Use the green profile button to open this exact account.");
			}
			if (!string.Equals(playerIdentityEvidence.DisplayNameRaw, playerIdentityEvidence.DisplayName, StringComparison.Ordinal))
			{
				list3.Add("Raw TMP name source is visible and copyable in Lobby Safety and the local chat audit JSONL.");
			}
			list3.Add("Read-only evidence only. Recheck the profile before /sidban; cloned names never authorize or select a ban target.");
			return BlueSageCommandResult.HandledWithMessages(list3.ToArray());
		}

		private BlueSageCommandResult HandleIdentityResyncCommand(BlueSageCommandContext context)
		{
			return IdentityResyncController.HandleCommand(context);
		}

		private BlueSageCommandResult HandleSidBanCommand(BlueSageCommandContext context)
		{
			if (!CanUseLobbySafety(out var _))
			{
				return LobbySafetyDeniedResult();
			}
			string text = (context.Arguments ?? string.Empty).Trim();
			int num;
			object obj;
			if (!text.Equals("confirm", StringComparison.OrdinalIgnoreCase))
			{
				num = (text.EndsWith(" confirm", StringComparison.OrdinalIgnoreCase) ? 1 : 0);
				if (num == 0)
				{
					obj = text;
					goto IL_0079;
				}
			}
			else
			{
				num = 1;
			}
			obj = (text.Equals("confirm", StringComparison.OrdinalIgnoreCase) ? string.Empty : text.Substring(0, text.Length - " confirm".Length).Trim());
			goto IL_0079;
			IL_0079:
			string text2 = (string)obj;
			if (num != 0)
			{
				return ConfirmPendingModeration("ban", text2);
			}
			if (string.IsNullOrWhiteSpace(text2))
			{
				return BlueSageCommandResult.HandledWithMessages("SID ban: use a verified current row, C# incident, or exact SteamID64. The active host may also preview an exact off-roster SteamID64. Review the preview, then add confirm within 30 seconds.");
			}
			if (!SteamIdModerationController.CanLocalIssue(out var isHost2, out var reason))
			{
				return BlueSageCommandResult.HandledWithMessages("SID ban: " + reason);
			}
			string error;
			string[] array = PlayerIdentityEvidenceController.GetVerifiedCurrentSteamIds(out error).ToArray();
			if (!string.IsNullOrWhiteSpace(error))
			{
				return BlueSageCommandResult.HandledWithMessages("SID ban: verified live roster unavailable: " + error + ". No preview was created.");
			}
			bool flag = ModerationProtocolPolicy.IsSteamId64(text2) && !array.Contains<string>(text2, StringComparer.Ordinal);
			ModerationTarget target;
			string error2;
			if (flag)
			{
				if (!isHost2)
				{
					return BlueSageCommandResult.HandledWithMessages("SID ban: only the active lobby host can preview an exact SteamID64 that is not in the current lobby. Helpers must select a verified current player.");
				}
				target = new ModerationTarget(text2, "none");
			}
			else if (!ModerationTargetResolver.TryResolve(text2, array, out target, out error2))
			{
				return BlueSageCommandResult.HandledWithMessages("SID ban: " + error2);
			}
			if (CloneIncidentLedger.IsProtectedVictim(target.SteamId))
			{
				return BlueSageCommandResult.HandledWithMessages("SID ban blocked: Steam " + FormatSteamIdSuffix(target.SteamId) + " is the protected victim in an open Clone Shield incident. Use the C# incident to target its suspect.");
			}
			if (SteamIdModerationController.IsAuthorizedCurrentIssuer(target.SteamId))
			{
				return BlueSageCommandResult.HandledWithMessages("SID ban blocked: the selected Steam account is the current host or an assigned Helper. No preview or pending action was created.");
			}
			_pendingModerationAction = BuildPendingModeration("ban", target, flag);
			return BlueSageCommandResult.HandledWithMessages((flag ? "SID ban OFFLINE PREVIEW: " : "SID ban PREVIEW: SUSPECT ") + target.SteamId + ((target.IncidentId == "none") ? string.Empty : (" from " + target.IncidentId)) + (flag ? (". This exact ID is not in the current lobby. No kick will be attempted. Verify the Steam profile, then use /sidban " + target.SteamId + " confirm within 30 seconds.") : (". Victim IDs are protected. Verify the Steam profile, then use /sidban " + ((target.IncidentId == "none") ? target.SteamId : target.IncidentId) + " confirm within 30 seconds.")));
		}

		private BlueSageCommandResult HandleSidUnbanCommand(BlueSageCommandContext context)
		{
			if (!CanUseLobbySafety(out var _))
			{
				return LobbySafetyDeniedResult();
			}
			string text = (context.Arguments ?? string.Empty).Trim();
			int num;
			object obj;
			if (!text.Equals("confirm", StringComparison.OrdinalIgnoreCase))
			{
				num = (text.EndsWith(" confirm", StringComparison.OrdinalIgnoreCase) ? 1 : 0);
				if (num == 0)
				{
					obj = text;
					goto IL_0079;
				}
			}
			else
			{
				num = 1;
			}
			obj = (text.Equals("confirm", StringComparison.OrdinalIgnoreCase) ? string.Empty : text.Substring(0, text.Length - " confirm".Length).Trim());
			goto IL_0079;
			IL_0079:
			string text2 = (string)obj;
			if (num != 0)
			{
				return ConfirmPendingModeration("unban", text2);
			}
			if (string.IsNullOrWhiteSpace(text2))
			{
				return BlueSageCommandResult.HandledWithMessages("SID unban: host may use a full SteamID64 or unique 6+ digit suffix. Helpers must use the exact full SteamID64. Review the preview, then add confirm within 30 seconds.");
			}
			if (!SteamIdModerationController.CanLocalIssue(out var isHost2, out var reason))
			{
				return BlueSageCommandResult.HandledWithMessages("SID unban: " + reason);
			}
			ModerationTarget target;
			if (isHost2)
			{
				if (!ModerationTargetResolver.TryResolve(text2, SteamIdModerationController.GetBannedSteamIds(), out target, out var error))
				{
					return BlueSageCommandResult.HandledWithMessages("SID unban: " + error);
				}
			}
			else
			{
				if (!ModerationProtocolPolicy.IsSteamId64(text2))
				{
					return BlueSageCommandResult.HandledWithMessages("SID unban: Helpers must provide the exact 17-digit SteamID64 so the host can resolve its host-owned native ban list safely.");
				}
				target = new ModerationTarget(text2, "none");
			}
			_pendingModerationAction = BuildPendingModeration("unban", target, targetWasOffline: false);
			return BlueSageCommandResult.HandledWithMessages("SID unban PREVIEW: " + target.SteamId + ". Use /sidunban " + target.SteamId + " confirm within 30 seconds.");
		}

		private BlueSageCommandResult ConfirmPendingModeration(string action, string query)
		{
			if (!CanUseLobbySafety(out var _))
			{
				_pendingModerationAction = null;
				return LobbySafetyDeniedResult();
			}
			long num = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
			MultiplayerManager i = MonoSingleton<MultiplayerManager>.I;
			string b = ((i != null) ? i.LobbyCode : null) ?? string.Empty;
			PendingModerationAction pendingModerationAction = _pendingModerationAction;
			if (pendingModerationAction == null || pendingModerationAction.Action != action || pendingModerationAction.ExpiresUnixSeconds < num || !string.Equals(pendingModerationAction.LobbyCode, b, StringComparison.Ordinal))
			{
				_pendingModerationAction = null;
				return BlueSageCommandResult.HandledWithMessages("SID " + action + ": preview expired or lobby changed. Start again so the target is revalidated.");
			}
			if (string.IsNullOrWhiteSpace(query))
			{
				return BlueSageCommandResult.HandledWithMessages("SID " + action + ": confirmation must repeat the previewed incident ID or full SteamID64; bare confirm is refused and no action was taken.");
			}
			string b2 = ((pendingModerationAction.IncidentId == "none") ? pendingModerationAction.TargetSteamId : pendingModerationAction.IncidentId);
			if (!string.Equals(query, b2, StringComparison.OrdinalIgnoreCase))
			{
				return BlueSageCommandResult.HandledWithMessages("SID " + action + ": confirmation does not match the previewed target; no action was taken.");
			}
			if (action == "ban")
			{
				ModerationTarget target;
				string error2;
				if (pendingModerationAction.TargetWasOffline)
				{
					if (!SteamIdModerationController.CanLocalIssue(out var isHost2, out var reason) || !isHost2 || !ModerationProtocolPolicy.IsSteamId64(pendingModerationAction.TargetSteamId) || CloneIncidentLedger.IsProtectedVictim(pendingModerationAction.TargetSteamId))
					{
						_pendingModerationAction = null;
						return BlueSageCommandResult.HandledWithMessages("SID ban offline revalidation failed: " + reason + " No action was taken.");
					}
					string error;
					IReadOnlyList<string> verifiedCurrentSteamIds = PlayerIdentityEvidenceController.GetVerifiedCurrentSteamIds(out error);
					if (!string.IsNullOrWhiteSpace(error))
					{
						_pendingModerationAction = null;
						return BlueSageCommandResult.HandledWithMessages("SID ban offline revalidation failed: " + error + ". No action was taken.");
					}
					if (verifiedCurrentSteamIds.Contains<string>(pendingModerationAction.TargetSteamId, StringComparer.Ordinal))
					{
						_pendingModerationAction = null;
						return BlueSageCommandResult.HandledWithMessages("SID ban offline revalidation failed: that SteamID joined the verified live roster after preview. Start a new live-player preview; no ban or kick was attempted.");
					}
				}
				else if (!ModerationTargetResolver.TryResolve((pendingModerationAction.IncidentId == "none") ? pendingModerationAction.TargetSteamId : pendingModerationAction.IncidentId, SteamIdModerationController.GetCurrentPlayerSteamIds(), out target, out error2) || !string.Equals(target.SteamId, pendingModerationAction.TargetSteamId, StringComparison.Ordinal) || CloneIncidentLedger.IsProtectedVictim(pendingModerationAction.TargetSteamId))
				{
					_pendingModerationAction = null;
					return BlueSageCommandResult.HandledWithMessages("SID ban revalidation failed: " + (error2 ?? "target or victim role changed") + ". No action was taken.");
				}
			}
			_pendingModerationAction = null;
			string message;
			bool flag = SteamIdModerationController.TrySendHelperRequest(action, pendingModerationAction.TargetSteamId, pendingModerationAction.IncidentId, out message);
			return BlueSageCommandResult.HandledWithMessages((flag ? ("SID " + action + ": ") : ("SID " + action + " rejected: ")) + message);
		}

		private static PendingModerationAction BuildPendingModeration(string action, ModerationTarget target, bool targetWasOffline)
		{
			PendingModerationAction obj = new PendingModerationAction
			{
				Action = action,
				TargetSteamId = target.SteamId,
				IncidentId = target.IncidentId
			};
			MultiplayerManager i = MonoSingleton<MultiplayerManager>.I;
			obj.LobbyCode = ((i != null) ? i.LobbyCode : null) ?? string.Empty;
			obj.TargetWasOffline = targetWasOffline;
			obj.ExpiresUnixSeconds = DateTimeOffset.UtcNow.ToUnixTimeSeconds() + 30;
			return obj;
		}

		private static BlueSageCommandResult LobbySafetyDeniedResult()
		{
			bool isHost;
			string reason;
			LobbySafetyAccessState localAccessState = SteamIdModerationController.GetLocalAccessState(out isHost, out reason);
			return BlueSageCommandResult.HandledWithMessages((localAccessState == LobbySafetyAccessState.HelperWaitingForHost) ? (reason + " Protected data stayed locked and no moderation request was sent.") : "Lobby Safety is available only to the current host or a Helper assigned by that host. No player or incident details were shown.");
		}

		private static string SafeIncidentLabel(string value)
		{
			if (!string.IsNullOrWhiteSpace(value))
			{
				return value;
			}
			return "unknown";
		}

		private static bool TryGetCurrentSteamLobby(out CSteamID lobbyId)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			lobbyId = CSteamID.Nil;
			if (PluginShutdownController.IsShuttingDown)
			{
				return false;
			}
			MultiplayerManager i = MonoSingleton<MultiplayerManager>.I;
			string s = ((i != null) ? i.LobbyCode : null);
			if (!SteamManager.Initialized || !ulong.TryParse(s, out var result) || result == 0L)
			{
				return false;
			}
			lobbyId = new CSteamID(result);
			return SteamMatchmaking.GetLobbyOwner(lobbyId) != CSteamID.Nil;
		}

		private static bool TryResolveLobbyMemberSteamId(string query, out string steamId, out string error)
		{
			steamId = string.Empty;
			if (!PlayerIdentityEvidenceController.TryResolveLookup(query, out var evidence, out error))
			{
				return false;
			}
			steamId = evidence.SteamId;
			return true;
		}

		private static string FormatSteamIdSuffix(string steamId)
		{
			return "Steam …" + ((steamId != null && steamId.Length > 6) ? steamId.Substring(steamId.Length - 6) : steamId);
		}

		private void StartCloneShieldController()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			if (!((Object)(object)_cloneShieldControllerObject != (Object)null))
			{
				_cloneShieldControllerObject = new GameObject("BlueSage_CloneShieldController");
				_cloneShieldControllerObject.AddComponent<CloneShieldController>();
				Object.DontDestroyOnLoad((Object)(object)_cloneShieldControllerObject);
			}
		}

		private void StartPlayerRenderSaverController()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			if (!((Object)(object)_playerRenderSaverControllerObject != (Object)null))
			{
				_playerRenderSaverControllerObject = new GameObject("BlueSage_PlayerRenderSaverController");
				_playerRenderSaverControllerObject.AddComponent<PlayerRenderSaverController>();
				Object.DontDestroyOnLoad((Object)(object)_playerRenderSaverControllerObject);
			}
		}

		private void StartStyleHelperWindow()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			if (!((Object)(object)_styleHelperWindow != (Object)null))
			{
				GameObject val = new GameObject("BlueSage_StyleHelperWindow");
				_styleHelperWindow = val.AddComponent<StyleHelperWindow>();
				Object.DontDestroyOnLoad((Object)(object)val);
			}
		}

		private void StartQolMenuWindow()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			if (!((Object)(object)_qolMenuWindow != (Object)null))
			{
				GameObject val = new GameObject("BlueSage_QolMenuWindow");
				_qolMenuWindow = val.AddComponent<QolMenuWindow>();
				Object.DontDestroyOnLoad((Object)(object)val);
			}
		}

		internal string ToggleStyleUiFromQolMenu()
		{
			if (!EnableStyleUi.Value)
			{
				return "Style UI is disabled in config.";
			}
			if ((Object)(object)_styleHelperWindow == (Object)null)
			{
				StartStyleHelperWindow();
			}
			if ((Object)(object)_styleHelperWindow == (Object)null)
			{
				return "Style UI could not start; check BepInEx console.";
			}
			_styleHelperWindow.ToggleVisible();
			return "Style UI toggled.";
		}

		internal string RunManualSweepFromQolMenu()
		{
			return SweepMenuActionPolicy.BuildCompletionMessage(RunSweep("QoL menu", requireManualPermission: true));
		}

		internal string RunHostHealthFromQolMenu()
		{
			return RunHostHealthCheck("QoL menu");
		}

		internal string RunQolStatusFromQolMenu()
		{
			LogDetailedQolStatus();
			if (!AddLocalNotification(BuildQolStatusMessage()))
			{
				return "QoL status could not reach local chat yet; join a lobby or use /qol status after chat loads.";
			}
			return "QoL status was sent to your local chat.";
		}

		private void StartPerformanceOverlayController()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			if (!((Object)(object)_performanceOverlayControllerObject != (Object)null))
			{
				_performanceOverlayControllerObject = new GameObject("BlueSage_PublicPerformanceOverlay");
				((Object)_performanceOverlayControllerObject).hideFlags = (HideFlags)61;
				Object.DontDestroyOnLoad((Object)(object)_performanceOverlayControllerObject);
				_performanceOverlayControllerObject.AddComponent<PerformanceOverlayController>();
			}
		}

		internal void RunSweepRestartFromMenu()
		{
			RestartSweepLoop();
		}

		internal void ReconcileSweepScheduleFromMenu()
		{
			if (!EnableAutoSweep.Value || !AutoSweepAllowed)
			{
				return;
			}
			if (_sweepCoroutine == null)
			{
				RestartSweepLoop();
				return;
			}
			double realtimeSinceStartupAsDouble = Time.realtimeSinceStartupAsDouble;
			_sweepSchedule.ReconcileInterval(realtimeSinceStartupAsDouble, SweepIntervalMinutes.Value);
			double num = Math.Max(0.0, _sweepSchedule.DueSeconds - realtimeSinceStartupAsDouble);
			ManualLogSource log = Log;
			if (log != null)
			{
				log.LogInfo((object)$"Asset Sweep interval reconciled to {_sweepSchedule.ConfiguredIntervalMinutes} minutes without restarting elapsed time; next automatic deadline in {num:0} seconds.");
			}
		}

		internal void RestartHostHealthFromMenu()
		{
			RestartHostHealthLoop();
		}

		internal void SaveConfigFromQolMenu()
		{
			((BaseUnityPlugin)this).Config.Save();
		}

		internal string SaveSelfPositionFromQolMenu()
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			TextChannelManager i = NetworkSingleton<TextChannelManager>.I;
			object obj = i?.MainPlayer;
			if (obj == null)
			{
				if (i == null)
				{
					obj = null;
				}
				else
				{
					PlayerMovementController mainMovementController = i.MainMovementController;
					obj = ((mainMovementController != null) ? ((Component)mainMovementController).transform : null);
				}
			}
			Transform val = (Transform)obj;
			if ((Object)(object)val == (Object)null || !((Component)val).gameObject.activeInHierarchy)
			{
				return "Self movement: your player position is not ready yet.";
			}
			string text = SelfMovementPolicy.FormatPosition(val.position);
			SelfSavedPosition.Value = text;
			((BaseUnityPlugin)this).Config.Save();
			return "Self movement: saved your current position " + text + ".";
		}

		internal string TeleportSelfToSavedFromQolMenu()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			if (!SelfMovementPolicy.TryParsePosition(SelfSavedPosition?.Value, out var position))
			{
				return "Self movement: no saved position yet. Use Save Pos first.";
			}
			SelfMovementPatch.QueueTeleport(position);
			return "Self movement: queued teleport to your saved position " + SelfMovementPolicy.FormatPosition(position) + ".";
		}

		internal string ToggleNoclipFlyFromQolMenu()
		{
			if (EnableNoclipFly == null)
			{
				return "Self movement: noclip/fly is not ready yet.";
			}
			EnableNoclipFly.Value = !EnableNoclipFly.Value;
			OptInRescuePatch.Stop();
			SelfMovementPatch.ResetVerticalVelocity();
			((BaseUnityPlugin)this).Config.Save();
			if (!EnableNoclipFly.Value)
			{
				return "Self movement: noclip/fly off. Vanilla collision and movement resumed.";
			}
			return "Self movement: noclip/fly on. WASD moves, Space/E rises, Ctrl/Q lowers, Shift boosts, and Alt gives precision control.";
		}

		internal string SaveSelfMovementMultiplierFromQolMenu(string kind, string rawValue)
		{
			ConfigEntry<float> val;
			float num;
			float num2;
			string arg;
			switch ((kind ?? string.Empty).Trim().ToLowerInvariant())
			{
			case "speed":
				val = SelfSpeedMultiplier;
				num = 0.25f;
				num2 = 5f;
				arg = "speed";
				break;
			case "jump":
				val = SelfJumpMultiplier;
				num = 0.25f;
				num2 = 5f;
				arg = "jump";
				break;
			case "gravity":
				val = SelfGravityMultiplier;
				num = 0.1f;
				num2 = 5f;
				arg = "gravity";
				break;
			default:
				return "Self movement: unknown multiplier.";
			}
			string text = (rawValue ?? string.Empty).Trim();
			if (string.Equals(text, "reset", StringComparison.OrdinalIgnoreCase) || string.Equals(text, "default", StringComparison.OrdinalIgnoreCase) || string.Equals(text, "vanilla", StringComparison.OrdinalIgnoreCase))
			{
				text = "1";
			}
			if (val == null || !float.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
			{
				return $"Self movement: {arg} needs a multiplier from {num:0.##} to {num2:0.##}, or reset.";
			}
			val.Value = Mathf.Clamp(result, num, num2);
			((BaseUnityPlugin)this).Config.Save();
			return $"Self movement: {arg} saved at {val.Value:0.##}x.";
		}

		internal string ResetSelfMovementFromQolMenu()
		{
			EnableNoclipFly.Value = false;
			SelfSpeedMultiplier.Value = 1f;
			SelfJumpMultiplier.Value = 1f;
			SelfGravityMultiplier.Value = 1f;
			SelfMovementPatch.CleanupRuntimeState();
			((BaseUnityPlugin)this).Config.Save();
			return "Self movement reset: noclip/fly off; speed, jump, and gravity are back to 1x vanilla.";
		}

		private BlueSageCommandResult HandleSelfMovementCommand(BlueSageCommandContext context)
		{
			string text = ((context.Tokens.Count > 0) ? context.Tokens[0].Trim().ToLowerInvariant() : "status");
			switch (text)
			{
			case "status":
			case "?":
				return BlueSageCommandResult.HandledWithMessages(string.Format("Self movement: fly={0}, speed={1:0.##}x, jump={2:0.##}x, gravity={3:0.##}x, saved={4}.", FormatToggleState(ShouldApplyNoclipFly), LockedSelfSpeedMultiplier, LockedSelfJumpMultiplier, LockedSelfGravityMultiplier, string.IsNullOrWhiteSpace(SelfSavedPosition?.Value) ? "none" : SelfSavedPosition.Value));
			case "save":
			case "savepos":
				return BlueSageCommandResult.HandledWithMessages(SaveSelfPositionFromQolMenu());
			case "teleport":
			case "tp":
			case "saved":
				return BlueSageCommandResult.HandledWithMessages(TeleportSelfToSavedFromQolMenu());
			case "reset":
				return BlueSageCommandResult.HandledWithMessages(ResetSelfMovementFromQolMenu());
			case "fly":
			case "noclip":
			{
				string text2 = ((context.Tokens.Count > 1) ? context.Tokens[1].Trim().ToLowerInvariant() : "toggle");
				if (text2 == "status" || text2 == "?")
				{
					return BlueSageCommandResult.HandledWithMessages("Self movement fly: " + FormatToggleState(ShouldApplyNoclipFly) + ".");
				}
				bool? flag = ParseToggleRequestWithCurrent(text2, ShouldApplyNoclipFly);
				if (!flag.HasValue)
				{
					return BlueSageCommandResult.HandledWithMessages("Self movement fly: use on, off, toggle, or status.");
				}
				if (flag.Value == ShouldApplyNoclipFly)
				{
					return BlueSageCommandResult.HandledWithMessages("Self movement fly: " + FormatToggleState(ShouldApplyNoclipFly) + ".");
				}
				return BlueSageCommandResult.HandledWithMessages(ToggleNoclipFlyFromQolMenu());
			}
			case "speed":
			case "jump":
			case "gravity":
			{
				string rawValue = ((context.Tokens.Count > 1) ? context.Tokens[1] : string.Empty);
				return BlueSageCommandResult.HandledWithMessages(SaveSelfMovementMultiplierFromQolMenu(text, rawValue));
			}
			default:
				return BlueSageCommandResult.HandledWithMessages("Self movement: use status, save, teleport, fly [on|off], speed <0.25-5>, jump <0.25-5>, gravity <0.1-5>, or reset.");
			}
		}

		private static string BuildQolStatusMessage()
		{
			return QolStatusTextPolicy.BuildPlayerSummary(NativeAssetSweepOwnership, EnableAutoSweep.Value && AutoSweepAllowed, ManualSweepAllowed);
		}

		private static void LogDetailedQolStatus()
		{
			ManualLogSource log = Log;
			if (log != null)
			{
				log.LogInfo((object)("QoL detailed status: " + BuildDetailedQolStatusMessage()));
			}
		}

		private static string BuildDetailedQolStatusMessage()
		{
			return string.Format("BlueSage QoL: AutomaticCleanup={0}, ManualCleanup={1}, HostHealth={2}, LeaveNotices={3}, Welcome={4}, Timestamps={5}({6}), ChatReadability={7}, ChatBackdrop={8}, ChatOutline={9}%, ChatUIScale={10}%, ChatFont={11}%, ChatWindowHeight={12}%, ChatRows={13}, OutlineColors=#{14}/#{15}, BlackNamesOutline={16}, BetterMove={17}, UnlimitedConsumables={18}, FocusAnywhere={19}, PlayerPanel={20}, SelfFly={21}, SelfMove={22:0.##}x/{23:0.##}x/{24:0.##}x, ReconnectGuard={25}, ReconnectMessage={26}, PingMentions={27}, PingSound={28}, CloneShield={29}, RenderSaver={30}({31}m/max{32}, hidden={33}), ChatCopy={34}, ChatLinks={35}, LocalAudit={36}, Spoons={37}, StyleUI={38}, AvatarSlots4-9={39}, Chalkboards={40}, MiniMapIDClick={41}, MiniMapFriends={42}, QoLMenu=Home or /qolmenu, LongerText=always on.", FormatToggleState(EnableAutoSweep.Value && AutoSweepAllowed), FormatToggleState(ManualSweepAllowed), FormatToggleState(EnableHostHealthMonitor.Value), FormatToggleState(ShouldApplyLeaveNotifications), FormatToggleState(EnableWelcomeMessage.Value), FormatToggleState(ShouldApplyChatTimestamps), Use24HourTime.Value ? "24-hour" : "12-hour AM/PM", FormatToggleState(ShouldApplyChatReadability), FormatToggleState(ShouldApplyPersistentChatBackdrop), LockedChatOutlineIntensityPercent, LockedChatUiScalePercent, LockedChatFontSizePercent, LockedChatWindowHeightPercent, LockedChatHistoryRows, LockedChatOutlineColorHex, LockedBlackChatOutlineColorHex, FormatToggleState(ShouldApplyBlackNamesOutline), FormatToggleState(ShouldApplyBetterMove), FormatToggleState(ShouldApplyUnlimitedConsumables), FormatToggleState(EnableFocusAnywhere.Value), FormatToggleState(EnableEnhancedPlayerPanel.Value), FormatToggleState(ShouldApplyNoclipFly), LockedSelfSpeedMultiplier, LockedSelfJumpMultiplier, LockedSelfGravityMultiplier, FormatToggleState(EnableReconnectGuard.Value), FormatToggleState(EnableReconnectAnnouncement.Value), FormatToggleState(EnablePingMentions.Value), FormatToggleState(EnablePingSound.Value), FormatToggleState(ShouldApplyCloneShield), FormatToggleState(ShouldApplyPlayerRenderSaver), LockedPlayerRenderSaverRadiusMeters, LockedPlayerRenderSaverMaxVisiblePlayers, PlayerRenderSaverController.LastHiddenRemotePlayers, FormatToggleState(ShouldApplyChatCopy), FormatToggleState(ShouldApplyChatUrlLinks), FormatToggleState(EnableLocalAuditExports?.Value ?? false), FormatToggleState(ShouldApplySpoons), FormatToggleState(EnableStyleUi.Value), FormatToggleState(EnableExtendedAvatarStyles?.Value ?? false), FormatToggleState(ChalkboardPersistenceController.Available), FormatToggleState(EnableMiniMapPlayerLabels.Value), FormatToggleState(ShouldApplyMiniMapFriendColors));
		}

		private BlueSageCommandResult HandleChatOutlineCommand(BlueSageCommandContext context)
		{
			string text = ((context.Tokens.Count > 0) ? context.Tokens[0].Trim().ToLowerInvariant() : "status");
			if (text == "status" || text == "?")
			{
				return BlueSageCommandResult.HandledWithMessages($"Chat Outline: {LockedChatOutlineIntensityPercent}%.");
			}
			if (!int.TryParse(text.TrimEnd(new char[1] { '%' }), out var result))
			{
				return BlueSageCommandResult.HandledWithMessages("Chat Outline: use a number from 25 to 100, or status.");
			}
			int num = ChatReadabilityStylePolicy.ClampOutlineIntensityPercent(result);
			ChatOutlineIntensity.Value = num;
			((BaseUnityPlugin)this).Config.Save();
			ChatReadabilityPatch.RefreshVisibleChat();
			return BlueSageCommandResult.HandledWithMessages($"Chat Outline: {num}%.");
		}

		private BlueSageCommandResult HandleChatScaleCommand(BlueSageCommandContext context)
		{
			string text = ((context.Tokens.Count > 0) ? context.Tokens[0].Trim() : "status");
			if (string.Equals(text, "status", StringComparison.OrdinalIgnoreCase) || text == "?")
			{
				return BlueSageCommandResult.HandledWithMessages($"Chat UI Scale (whole panel): {LockedChatUiScalePercent}%.");
			}
			if (!ChatAccessibilityScalePolicy.TryParseScaleToken(text, out var percent))
			{
				return BlueSageCommandResult.HandledWithMessages("Chat UI Scale grows the whole panel/input/backdrop/text. Use 75-200, decimal scale like 1.25, reset, or status. Use /chatfont for message text only.");
			}
			ChatUiScalePercent.Value = percent;
			((BaseUnityPlugin)this).Config.Save();
			ChatReadabilityPatch.RequestRefreshSoon();
			return BlueSageCommandResult.HandledWithMessages($"Chat UI Scale (whole panel): {percent}%.");
		}

		private BlueSageCommandResult HandleChatFontCommand(BlueSageCommandContext context)
		{
			string text = ((context.Tokens.Count > 0) ? context.Tokens[0].Trim() : "status");
			if (string.Equals(text, "status", StringComparison.OrdinalIgnoreCase) || text == "?")
			{
				return BlueSageCommandResult.HandledWithMessages($"Chat Font (message text only): {LockedChatFontSizePercent}%.");
			}
			if (string.Equals(text, "toggle", StringComparison.OrdinalIgnoreCase))
			{
				int num = ((LockedChatFontSizePercent > 100) ? 100 : 125);
				ChatFontSizePercent.Value = num;
				((BaseUnityPlugin)this).Config.Save();
				ChatReadabilityPatch.RequestRefreshSoon();
				return BlueSageCommandResult.HandledWithMessages($"Chat Font (message text only): {num}%.");
			}
			if (!ChatFontSizePolicy.TryParseFontSizeToken(text, out var percent))
			{
				return BlueSageCommandResult.HandledWithMessages("Chat Font changes message text only. Use on/off/toggle, 75-200, decimal size like 1.25, reset, or status. Use /chatscale for the whole panel.");
			}
			ChatFontSizePercent.Value = percent;
			((BaseUnityPlugin)this).Config.Save();
			ChatReadabilityPatch.RequestRefreshSoon();
			return BlueSageCommandResult.HandledWithMessages($"Chat Font (message text only): {percent}%.");
		}

		private BlueSageCommandResult HandleChatHeightCommand(BlueSageCommandContext context)
		{
			string text = ((context.Tokens.Count > 0) ? context.Tokens[0].Trim() : "status");
			if (string.Equals(text, "status", StringComparison.OrdinalIgnoreCase) || text == "?")
			{
				return BlueSageCommandResult.HandledWithMessages($"Chat Window Height (vertical log space): {LockedChatWindowHeightPercent}%.");
			}
			if (string.Equals(text, "toggle", StringComparison.OrdinalIgnoreCase))
			{
				int num = ((LockedChatWindowHeightPercent > 100) ? 100 : 125);
				ChatWindowHeightPercent.Value = num;
				((BaseUnityPlugin)this).Config.Save();
				ChatReadabilityPatch.RequestRefreshSoon();
				return BlueSageCommandResult.HandledWithMessages($"Chat Window Height (vertical log space): {num}%.");
			}
			if (!ChatWindowHeightPolicy.TryParseHeightToken(text, out var percent))
			{
				return BlueSageCommandResult.HandledWithMessages("Chat Window Height adds vertical log space only. Use on/off/toggle, 100-200, decimal size like 1.5, reset, or status.");
			}
			ChatWindowHeightPercent.Value = percent;
			((BaseUnityPlugin)this).Config.Save();
			ChatReadabilityPatch.RequestRefreshSoon();
			return BlueSageCommandResult.HandledWithMessages($"Chat Window Height (vertical log space): {percent}%.");
		}

		private BlueSageCommandResult HandleChatHistoryCommand(BlueSageCommandContext context)
		{
			string text = ((context.Tokens.Count > 0) ? context.Tokens[0].Trim() : "status");
			if (string.Equals(text, "status", StringComparison.OrdinalIgnoreCase) || text == "?")
			{
				return BlueSageCommandResult.HandledWithMessages($"Chat Rows: {LockedChatHistoryRows}. Default 150; range 25-250. Higher vanilla/other-mod limits remain untouched.");
			}
			if (string.Equals(text, "reset", StringComparison.OrdinalIgnoreCase) || string.Equals(text, "default", StringComparison.OrdinalIgnoreCase))
			{
				ChatHistoryRows.Value = 150;
				((BaseUnityPlugin)this).Config.Save();
				return BlueSageCommandResult.HandledWithMessages("Chat Rows: reset to 150 (balanced default).");
			}
			if (!int.TryParse(text, out var result))
			{
				return BlueSageCommandResult.HandledWithMessages("Chat Rows: use 25-250, reset, or status.");
			}
			int num = ChatHistoryLimitPolicy.ClampRows(result);
			ChatHistoryRows.Value = num;
			((BaseUnityPlugin)this).Config.Save();
			return BlueSageCommandResult.HandledWithMessages($"Chat Rows: {num}. Larger histories cost more UI memory/work in busy lobbies.");
		}

		private BlueSageCommandResult HandleChatVanillaCommand(BlueSageCommandContext context)
		{
			ResetChatUiToVanilla();
			return BlueSageCommandResult.HandledWithMessages("Chat UI reset: whole-panel scale=100%, message font=100%, window height=100%.");
		}

		internal string ResetChatUiToVanillaFromMenu()
		{
			ResetChatUiToVanilla();
			return "Chat UI reset to vanilla whole-panel scale, message font size, and window height.";
		}

		private void ResetChatUiToVanilla()
		{
			if (ChatUiScalePercent != null)
			{
				ChatUiScalePercent.Value = 100;
			}
			if (ChatFontSizePercent != null)
			{
				ChatFontSizePercent.Value = 100;
			}
			if (ChatWindowHeightPercent != null)
			{
				ChatWindowHeightPercent.Value = 100;
			}
			((BaseUnityPlugin)this).Config.Save();
			ChatReadabilityPatch.RestoreChatWindowHeight();
			ChatReadabilityPatch.RestoreChatAccessibilityScale();
			ChatReadabilityPatch.RestoreChatFontSize();
			ChatReadabilityPatch.RequestRefreshSoon();
		}

		private BlueSageCommandResult HandlePlayerRenderSaverCommand(BlueSageCommandContext context)
		{
			string text = ((context.Tokens.Count > 0) ? context.Tokens[0].Trim().ToLowerInvariant() : "status");
			switch (text)
			{
			case "status":
			case "?":
				return BlueSageCommandResult.HandledWithMessages(BuildPlayerRenderSaverStatus());
			case "reset":
				PlayerRenderSaverRadiusMeters.Value = 45;
				PlayerRenderSaverMaxVisiblePlayers.Value = 32;
				((BaseUnityPlugin)this).Config.Save();
				if (!ShouldApplyPlayerRenderSaver)
				{
					PlayerRenderSaverController.RestoreAll();
				}
				return BlueSageCommandResult.HandledWithMessages(BuildPlayerRenderSaverStatus());
			case "radius":
			{
				if (context.Tokens.Count < 2 || !int.TryParse(context.Tokens[1].Trim().TrimEnd(new char[1] { 'm' }), out var result2))
				{
					return BlueSageCommandResult.HandledWithMessages("Player Render Saver radius: use /playersaver radius 45, range 10-250 meters.");
				}
				PlayerRenderSaverRadiusMeters.Value = PlayerRenderSaverPolicy.ClampRadiusMeters(result2);
				((BaseUnityPlugin)this).Config.Save();
				return BlueSageCommandResult.HandledWithMessages(BuildPlayerRenderSaverStatus());
			}
			case "max":
			case "maxvisible":
			{
				if (context.Tokens.Count < 2 || !int.TryParse(context.Tokens[1].Trim(), out var result))
				{
					return BlueSageCommandResult.HandledWithMessages("Player Render Saver max visible: use /playersaver max 32, range 1-128 closest players.");
				}
				PlayerRenderSaverMaxVisiblePlayers.Value = PlayerRenderSaverPolicy.ClampMaxVisiblePlayers(result);
				((BaseUnityPlugin)this).Config.Save();
				return BlueSageCommandResult.HandledWithMessages(BuildPlayerRenderSaverStatus());
			}
			default:
			{
				bool? flag = ParseToggleRequestWithCurrent(text, EnablePlayerRenderSaver.Value);
				if (!flag.HasValue)
				{
					return BlueSageCommandResult.HandledWithMessages("Player Render Saver: use on, off, toggle, status, reset, radius 45, or max 32.");
				}
				EnablePlayerRenderSaver.Value = flag.Value;
				((BaseUnityPlugin)this).Config.Save();
				if (!EnablePlayerRenderSaver.Value)
				{
					PlayerRenderSaverController.RestoreAll();
					return BlueSageCommandResult.HandledWithMessages("Player Render Saver: off. Restored all hidden player renderers.");
				}
				return BlueSageCommandResult.HandledWithMessages(BuildPlayerRenderSaverStatus());
			}
			}
		}

		private BlueSageCommandResult HandleChalkSaveCommand(BlueSageCommandContext context)
		{
			if (context.Tokens.Count < 1)
			{
				return BlueSageCommandResult.HandledWithMessages("Chalkboard save: use /chalksave name [board index].");
			}
			string boardToken = ((context.Tokens.Count > 1) ? context.Tokens[1] : string.Empty);
			return BlueSageCommandResult.HandledWithMessages(ChalkboardPersistenceController.Save(context.Tokens[0], boardToken));
		}

		private BlueSageCommandResult HandleChalkLoadCommand(BlueSageCommandContext context)
		{
			if (context.Tokens.Count < 2)
			{
				return BlueSageCommandResult.HandledWithMessages("Chalkboard restore: first run /chalk boards, then use /chalkload name <exact board index 0-2>.");
			}
			return BlueSageCommandResult.HandledWithMessages(ChalkboardPersistenceController.Load(context.Tokens[0], context.Tokens[1]));
		}

		private BlueSageCommandResult HandleChalkCommand(BlueSageCommandContext context)
		{
			switch ((context.Tokens.Count > 0) ? context.Tokens[0].Trim().ToLowerInvariant() : "status")
			{
			case "status":
			case "help":
			case "?":
				return BlueSageCommandResult.HandledWithMessages(ChalkboardPersistenceController.Status(), "Use /chalk boards or /chalk refresh to map exact indices 0-2. Local: view/save/list/delete/refresh. Shared: Host-direct or authenticated Helper-to-Host load/clear after a fresh map. Legacy /chalksave, /chalkload, and /chalklist remain available.");
			case "boards":
			case "where":
			case "here":
				return BlueSageCommandResult.HandledWithMessages(ChalkboardPersistenceController.Boards());
			case "refresh":
				return BlueSageCommandResult.HandledWithMessages(ChalkboardPersistenceController.RefreshMap());
			case "view":
			{
				string boardToken = ((context.Tokens.Count > 1) ? context.Tokens[1] : string.Empty);
				return BlueSageCommandResult.HandledWithMessages(ChalkboardPersistenceController.View(boardToken));
			}
			case "clear":
			{
				string boardToken3 = ((context.Tokens.Count > 1) ? context.Tokens[1] : string.Empty);
				return BlueSageCommandResult.HandledWithMessages(ChalkboardPersistenceController.TryClear(boardToken3));
			}
			case "save":
			{
				if (context.Tokens.Count < 2)
				{
					return BlueSageCommandResult.HandledWithMessages("Chalkboard save: use /chalk save name [board index].");
				}
				string boardToken2 = ((context.Tokens.Count > 2) ? context.Tokens[2] : string.Empty);
				return BlueSageCommandResult.HandledWithMessages(ChalkboardPersistenceController.Save(context.Tokens[1], boardToken2));
			}
			case "load":
			case "restore":
				if (context.Tokens.Count < 3)
				{
					return BlueSageCommandResult.HandledWithMessages("Chalkboard restore: first run /chalk boards, then use /chalk load name <exact board index 0-2>.");
				}
				return BlueSageCommandResult.HandledWithMessages(ChalkboardPersistenceController.Load(context.Tokens[1], context.Tokens[2]));
			case "list":
				return BlueSageCommandResult.HandledWithMessages(ChalkboardPersistenceController.List());
			case "delete":
				if (context.Tokens.Count < 2)
				{
					return BlueSageCommandResult.HandledWithMessages("Chalkboard local delete: use /chalk delete name.");
				}
				return BlueSageCommandResult.HandledWithMessages(ChalkboardPersistenceController.Delete(context.Tokens[1]));
			default:
				return BlueSageCommandResult.HandledWithMessages("Chalkboards: /chalk boards|refresh, view <index>, save name [index], list, delete name, load name <index>, or clear <index>. Index 3 is never accepted.");
			}
		}

		private static string BuildPlayerRenderSaverStatus()
		{
			return $"Player Render Saver: {FormatToggleState(ShouldApplyPlayerRenderSaver)}, radius={LockedPlayerRenderSaverRadiusMeters}m, maxVisible={LockedPlayerRenderSaverMaxVisiblePlayers}, candidates={PlayerRenderSaverController.LastCandidateRemotePlayers}, visible={PlayerRenderSaverController.LastVisibleRemotePlayers}, hidden={PlayerRenderSaverController.LastHiddenRemotePlayers}, renderersSuppressed={PlayerRenderSaverController.LastSuppressedRenderers}, state={PlayerRenderSaverController.LastRuntimeState}. Local-only optimization; chat and player list stay visible.";
		}

		private BlueSageCommandResult HandleOutlineColorCommand(BlueSageCommandContext context, string label, ConfigEntry<string> entry, string fallback)
		{
			if (entry == null)
			{
				return BlueSageCommandResult.HandledWithMessages(label + ": config is not ready yet.");
			}
			string text = ((context.Tokens.Count > 0) ? context.Tokens[0].Trim() : "status");
			if (string.Equals(text, "status", StringComparison.OrdinalIgnoreCase) || text == "?")
			{
				return BlueSageCommandResult.HandledWithMessages(label + ": #" + ChatReadabilityStylePolicy.NormalizeHexColor(entry.Value, fallback) + ".");
			}
			string text2 = ChatReadabilityStylePolicy.NormalizeHexColor(text, string.Empty);
			if (string.IsNullOrEmpty(text2))
			{
				return BlueSageCommandResult.HandledWithMessages(label + ": use a six-character hex color like #000000, or status.");
			}
			entry.Value = text2;
			((BaseUnityPlugin)this).Config.Save();
			ChatReadabilityPatch.RefreshVisibleChat();
			return BlueSageCommandResult.HandledWithMessages(label + ": #" + text2 + ".");
		}

		private static string BuildBlueSageClueCommandName()
		{
			return DecodeCommandName("cmvftdmvft");
		}

		private static string DecodeCommandName(string encoded)
		{
			char[] array = encoded.ToCharArray();
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = (char)(array[i] - 1);
			}
			return new string(array);
		}

		private BlueSageCommandResult HandleToggleCommand(BlueSageCommandContext context, string label, ConfigEntry<bool> configEntry, Action afterChange = null, string actionToken = null, Func<string> actionHandler = null)
		{
			string text = ((context.Tokens.Count > 0) ? context.Tokens[0].Trim().ToLowerInvariant() : "toggle");
			if (text == "status" || text == "?")
			{
				return BlueSageCommandResult.HandledWithMessages(label + ": " + FormatToggleState(configEntry.Value) + ".");
			}
			if (!string.IsNullOrWhiteSpace(actionToken) && (text == actionToken || (actionToken == "run" && text == "now") || (actionToken == "now" && text == "run")))
			{
				return BlueSageCommandResult.HandledWithMessages(actionHandler?.Invoke() ?? (label + ": action complete."));
			}
			bool? flag = ParseToggleRequestWithCurrent(text, configEntry.Value);
			if (!flag.HasValue)
			{
				return BlueSageCommandResult.HandledWithMessages(label + ": use on, off, toggle, or status.");
			}
			configEntry.Value = flag.Value;
			((BaseUnityPlugin)this).Config.Save();
			afterChange?.Invoke();
			return BlueSageCommandResult.HandledWithMessages(label + ": " + FormatToggleState(configEntry.Value) + ".");
		}

		private BlueSageCommandResult HandleAssetSweepCommand(BlueSageCommandContext context)
		{
			if (context.Tokens.Count == 0)
			{
				return BlueSageCommandResult.HandledWithMessages(SweepMenuActionPolicy.BuildCompletionMessage(RunSweep("manual command", requireManualPermission: true)));
			}
			return HandleToggleCommand(context, "Automatic Cleanup", EnableAutoSweep, RestartSweepLoop, "now", () => SweepMenuActionPolicy.BuildCompletionMessage(RunSweep("manual command", requireManualPermission: true)));
		}

		private BlueSageCommandResult HandleTimestampCommand(BlueSageCommandContext context)
		{
			string text = ((context.Tokens.Count > 0) ? context.Tokens[0].Trim().ToLowerInvariant() : "toggle");
			switch (text)
			{
			case "status":
			case "?":
				return BlueSageCommandResult.HandledWithMessages("Timestamps: chat=" + FormatToggleState(EnableChatTimestamps.Value) + ", join/leave=" + FormatToggleState(EnableNotificationTimestamps.Value) + ", format=" + (Use24HourTime.Value ? "24-hour" : "12-hour AM/PM") + ".");
			case "12":
			case "12h":
			case "12hr":
				Use24HourTime.Value = false;
				((BaseUnityPlugin)this).Config.Save();
				return BlueSageCommandResult.HandledWithMessages("Timestamps: 12-hour format with AM/PM.");
			case "24":
			case "24h":
			case "24hr":
				Use24HourTime.Value = true;
				((BaseUnityPlugin)this).Config.Save();
				return BlueSageCommandResult.HandledWithMessages("Timestamps: 24-hour format.");
			case "reset":
			case "default":
				EnableChatTimestamps.Value = true;
				EnableNotificationTimestamps.Value = true;
				Use24HourTime.Value = false;
				((BaseUnityPlugin)this).Config.Save();
				return BlueSageCommandResult.HandledWithMessages("Timestamps: reset to enabled 12-hour AM/PM defaults.");
			default:
			{
				bool? flag = ParseToggleRequestWithCurrent(text, EnableChatTimestamps.Value && EnableNotificationTimestamps.Value);
				if (!flag.HasValue)
				{
					return BlueSageCommandResult.HandledWithMessages("Timestamps: use on, off, toggle, status, 12, 24, or reset.");
				}
				EnableChatTimestamps.Value = flag.Value;
				SyncNotificationTimestampsWithChatTimestamps("timestamp command");
				((BaseUnityPlugin)this).Config.Save();
				return BlueSageCommandResult.HandledWithMessages("Timestamps: " + FormatToggleState(EnableChatTimestamps.Value) + ".");
			}
			}
		}

		private static void SyncNotificationTimestampsWithChatTimestamps(string reason)
		{
			if (EnableNotificationTimestamps.Value != EnableChatTimestamps.Value)
			{
				EnableNotificationTimestamps.Value = EnableChatTimestamps.Value;
				Plugin instance = Instance;
				if (instance != null)
				{
					((BaseUnityPlugin)instance).Config.Save();
				}
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogInfo((object)("Timestamps: synced join/leave/system notices with chat timestamps via " + reason + "."));
				}
			}
		}

		private static bool? ParseToggleRequest(string token)
		{
			switch (token)
			{
			case "toggle":
			case "t":
			case "":
				return null;
			case "enable":
			case "1":
			case "on":
			case "yes":
			case "enabled":
			case "true":
				return true;
			case "0":
			case "no":
			case "off":
			case "disable":
			case "false":
			case "disabled":
				return false;
			default:
			{
				if (!bool.TryParse(token, out var result))
				{
					return null;
				}
				return result;
			}
			}
		}

		private bool? ParseToggleRequestWithCurrent(string token, bool current)
		{
			bool? flag = ParseToggleRequest(token);
			if (flag.HasValue)
			{
				return flag.Value;
			}
			if (string.IsNullOrWhiteSpace(token) || token == "toggle" || token == "t")
			{
				return !current;
			}
			return null;
		}

		private static string FormatToggleState(bool enabled)
		{
			if (!enabled)
			{
				return "off";
			}
			return "on";
		}

		private static string FormatNullableCount(int? value)
		{
			if (!value.HasValue)
			{
				return "?";
			}
			return value.Value.ToString();
		}

		private void RestartHostHealthLoop()
		{
			if (_hostHealthCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_hostHealthCoroutine);
				_hostHealthCoroutine = null;
			}
			if (EnableHostHealthMonitor.Value && HostHealthRepairsAllowed)
			{
				_hostHealthCoroutine = ((MonoBehaviour)this).StartCoroutine(HostHealthLoop());
			}
		}

		private IEnumerator HostHealthLoop()
		{
			yield return (object)new WaitForSecondsRealtime(30f);
			while (true)
			{
				RunHostHealthCheck("automatic timer");
				int num = 300;
				yield return (object)new WaitForSecondsRealtime((float)num);
			}
		}

		private string RunHostHealthCheck(string reason)
		{
			bool flag = reason.IndexOf("manual", StringComparison.OrdinalIgnoreCase) >= 0;
			if (!EnableHostHealthMonitor.Value && !flag)
			{
				return "Host Health is disabled.";
			}
			CSteamID? lobbyId;
			string[] playerSteamIds;
			HostHealthInput input = CaptureHostHealthInput(out lobbyId, out playerSteamIds);
			PlayerLimitCompanionStatus playerLimitCompanionStatus = CapturePlayerLimitCompanionStatus();
			LogHiddenDiagnosticSnapshot(reason, input, lobbyId, playerSteamIds);
			HostHealthDecision hostHealthDecision = (_lastHostHealthDecision = HostHealthPolicy.Evaluate(input));
			bool hostHealthRepairsAllowed = HostHealthRepairsAllowed;
			if (!hostHealthDecision.ShouldRunDiagnostics)
			{
				Log.LogInfo((object)("Host Health skipped via " + reason + ": local player is not the host/lobby owner."));
				return "Host Health: client/no-op. Only the host runs lobby health checks.";
			}
			string text = ((hostHealthDecision.Issues.Count == 0) ? "healthy" : string.Join(", ", hostHealthDecision.Issues.Select((HostHealthIssue issue) => issue.ToString()).ToArray()));
			Log.LogInfo((object)("Host Health check via " + reason + ": " + text + ". " + playerLimitCompanionStatus.ToDiagnosticText() + "."));
			if (hostHealthRepairsAllowed && hostHealthDecision.Actions.Contains(HostHealthAction.RefreshLobbyMetadata))
			{
				RefreshLobbyMetadataHeartbeat(lobbyId, playerLimitCompanionStatus);
			}
			if (hostHealthRepairsAllowed && hostHealthDecision.Actions.Contains(HostHealthAction.RequestPersonaRefresh))
			{
				RequestPersonaRefresh(playerSteamIds);
			}
			if (hostHealthDecision.Issues.Count > 0)
			{
				Log.LogWarning((object)("Host Health diagnostic issue via " + reason + ": " + text + ". No recreate-lobby warning is emitted without join-failure evidence."));
			}
			string text2 = (hostHealthRepairsAllowed ? "Metadata refresh=on, persona refresh=on" : "Read-only compatibility mode; Desync owns metadata/persona repair");
			return "Host Health: " + text + ". " + text2 + ". No recreate-lobby warning without join-failure evidence. " + playerLimitCompanionStatus.ToDiagnosticText() + ".";
		}

		private BlueSageCommandResult HandleHiddenDiagnosticsCommand(BlueSageCommandContext context)
		{
			int num = (string.Equals(context.CommandName, "bsqol", StringComparison.OrdinalIgnoreCase) ? 1 : 0);
			switch ((context.Tokens.Count > num) ? context.Tokens[num].Trim().ToLowerInvariant() : "status")
			{
			case "on":
				EnableHiddenDiagnostics.Value = true;
				((BaseUnityPlugin)this).Config.Save();
				Log.LogInfo((object)("BlueSage diagnostics enabled. Watch for [BlueSageDiag] lines in BepInEx log: " + GetBepInExLogPath()));
				LogHiddenDiagnosticSnapshot("hidden diag enabled");
				return BlueSageCommandResult.HandledWithMessages("BlueSage diagnostics: on. BepInEx log: " + GetBepInExLogPath());
			case "off":
				EnableHiddenDiagnostics.Value = true;
				((BaseUnityPlugin)this).Config.Save();
				Log.LogInfo((object)"BlueSage diagnostics remain locked on through 0.2.x Early Access community troubleshooting.");
				return BlueSageCommandResult.HandledWithMessages("BlueSage diagnostics: locked on through 0.2.x Early Access; /bluedevdebug off cannot disable this release. Shareable BepInEx diagnostics omit exact player/lobby identities; protected mappings stay in authorized local audit files. BepInEx log: " + GetBepInExLogPath());
			case "status":
			case "?":
				return BlueSageCommandResult.HandledWithMessages("BlueSage diagnostics: locked on through 0.2.x Early Access. BepInEx log: " + GetBepInExLogPath());
			default:
				return BlueSageCommandResult.HandledWithMessages("BlueSage diagnostics: use on, off, or status. BepInEx log: " + GetBepInExLogPath());
			}
		}

		private void StartCommunityBanListMaintenance()
		{
			if (_communityBanListCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_communityBanListCoroutine);
			}
			_communityBanListCoroutine = ((MonoBehaviour)this).StartCoroutine(CommunityBanListMaintenanceLoop());
			ConfigEntry<bool> enableCommunityBanListSync = EnableCommunityBanListSync;
			if (enableCommunityBanListSync != null && enableCommunityBanListSync.Value)
			{
				CommunityBanListController.SetNextAttempt(DateTime.UtcNow.AddSeconds(45.0));
			}
			else
			{
				CommunityBanListController.MarkDisabled();
			}
		}

		private IEnumerator CommunityBanListMaintenanceLoop()
		{
			yield return (object)new WaitForSecondsRealtime(45f);
			while (true)
			{
				bool completed = false;
				bool succeeded = false;
				if (EnableCommunityBanListSync != null && EnableCommunityBanListSync.Value)
				{
					yield return CommunityBanListController.ReconcileFromSource(delegate(bool result)
					{
						succeeded = result;
						completed = true;
					});
				}
				else
				{
					CommunityBanListController.MarkDisabled();
				}
				float num = ((completed && succeeded) ? 21600f : 900f);
				if (EnableCommunityBanListSync?.Value ?? false)
				{
					CommunityBanListController.SetNextAttempt(DateTime.UtcNow.AddSeconds(num));
				}
				yield return (object)new WaitForSecondsRealtime(num);
			}
		}

		internal string RefreshCommunityBanListFromQolMenu()
		{
			ConfigEntry<bool> enableCommunityBanListSync = EnableCommunityBanListSync;
			if (enableCommunityBanListSync == null || !enableCommunityBanListSync.Value)
			{
				return "Community BanData refresh is off. Enable the local opt-in first.";
			}
			if (CommunityBanListController.RefreshInFlight)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogInfo((object)("Community BanData detailed status: " + CommunityBanListController.StatusText()));
				}
				return "Community BanData refresh is already running. " + CommunityBanListController.FriendlyStatusText();
			}
			((MonoBehaviour)this).StartCoroutine(RunCommunityBanManualRefresh());
			return "Community BanData refresh started locally. It can append only validated missing pairs; it cannot kick, ban, or grant authority.";
		}

		internal void ReconcileCommunityBanMaintenanceFromQolMenu()
		{
			StartCommunityBanListMaintenance();
		}

		private IEnumerator RunCommunityBanManualRefresh()
		{
			bool succeeded = false;
			yield return CommunityBanListController.ReconcileFromSource(delegate(bool result)
			{
				succeeded = result;
			});
			ManualLogSource log = Log;
			if (log != null)
			{
				log.LogInfo((object)("Community BanData manual refresh " + (succeeded ? "completed. " : "failed closed. ") + CommunityBanListController.StatusText()));
			}
			AddLocalNotification(CommunityBanListController.FriendlyStatusText());
		}

		private BlueSageCommandResult HandleCommunityBanCommand(BlueSageCommandContext context)
		{
			string text = ((context.Tokens.Count > 0) ? context.Tokens[0].Trim().ToLowerInvariant() : "status");
			ManualLogSource log = Log;
			if (log != null)
			{
				log.LogInfo((object)("Community BanData detailed status: " + CommunityBanListController.StatusText()));
			}
			switch (text)
			{
			case "status":
			case "?":
				return BlueSageCommandResult.HandledWithMessages(CommunityBanListController.FriendlyStatusText());
			case "attestation":
				return BlueSageCommandResult.HandledWithMessages(CommunityBanListController.FriendlyStatusText(), "Attestation: local BlueSageAudit/community-ban-source-attestation.json; bounded operational fields only, with no player identities.");
			case "refresh":
			case "validate":
				return BlueSageCommandResult.HandledWithMessages(RefreshCommunityBanListFromQolMenu());
			case "on":
			case "off":
				EnableCommunityBanListSync.Value = text == "on";
				((BaseUnityPlugin)this).Config.Save();
				StartCommunityBanListMaintenance();
				return BlueSageCommandResult.HandledWithMessages(CommunityBanListController.FriendlyStatusText());
			default:
				return BlueSageCommandResult.HandledWithMessages("Community BanData: use /communitybans status, refresh, on, off, or attestation. Refresh is local/additive and never performs a live moderation action.");
			}
		}

		private BlueSageCommandResult HandleAuditLogCommand(BlueSageCommandContext context)
		{
			string text = (context.Arguments ?? string.Empty).Trim().ToLowerInvariant();
			if (!string.IsNullOrWhiteSpace(text))
			{
				switch (text)
				{
				case "status":
				case "?":
					break;
				case "on":
					EnableLocalAuditExports.Value = true;
					((BaseUnityPlugin)this).Config.Save();
					SessionAuditController.ReconcileEnabledState();
					return BlueSageCommandResult.HandledWithMessages(SessionAuditController.StatusText());
				case "off":
					EnableLocalAuditExports.Value = false;
					((BaseUnityPlugin)this).Config.Save();
					SessionAuditController.ReconcileEnabledState();
					return BlueSageCommandResult.HandledWithMessages("Local session audit: off. Existing files remain local and are not deleted. /auditlog on resumes capture.");
				case "path":
				case "folder":
				case "copy":
					return BlueSageCommandResult.HandledWithMessages(SessionAuditController.CopyAuditFolder());
				case "snapshot":
				case "flush":
					return BlueSageCommandResult.HandledWithMessages(SessionAuditController.SnapshotNow());
				default:
					return BlueSageCommandResult.HandledWithMessages("Local session audit: use /auditlog status, on, off, path, or snapshot. Files are local-only and never uploaded automatically.");
				}
			}
			return BlueSageCommandResult.HandledWithMessages(SessionAuditController.StatusText());
		}

		private static string GetBepInExLogPath()
		{
			try
			{
				return Path.Combine(Paths.BepInExRootPath, "LogOutput.log");
			}
			catch
			{
				return "BepInEx/LogOutput.log";
			}
		}

		private void LogHiddenDiagnosticSnapshot(string reason)
		{
			CSteamID? lobbyId;
			string[] playerSteamIds;
			HostHealthInput input = CaptureHostHealthInput(out lobbyId, out playerSteamIds);
			LogHiddenDiagnosticSnapshot(reason, input, lobbyId, playerSteamIds);
		}

		private void LogHiddenDiagnosticSnapshot(string reason, HostHealthInput input, CSteamID? lobbyId, string[] playerSteamIds)
		{
			if (ShouldEmitHiddenDiagnostics && input != null)
			{
				TryGetVisibleLobbyCounts(out var memberCount, out var maxPlayers);
				TryGetSteamLobbyCounts(lobbyId, out var memberCount2, out var maxPlayers2);
				TryGetLobbySurfaceMetadata(lobbyId, out var _, out var tags, out var visibility);
				string text = ((_lastHostHealthDecision == null) ? "none" : ((_lastHostHealthDecision.Issues.Count == 0) ? "healthy" : string.Join("|", _lastHostHealthDecision.Issues.Select((HostHealthIssue issue) => issue.ToString()).ToArray())));
				string text2 = BuildPlayerRosterFingerprint(playerSteamIds);
				PlayerLimitCompanionStatus playerLimitCompanionStatus = CapturePlayerLimitCompanionStatus();
				bool isHost;
				LobbySafetyAccessState localAccessState = SteamIdModerationController.GetLocalAccessState(out isHost, out tags);
				string diagnosticRosterSummary = PlayerIdentityEvidenceController.GetDiagnosticRosterSummary();
				string text3 = BuildProcessMemoryDiagnosticSummary();
				string diagnosticSummary = BlueSageEnhancedPanelButtonMarker.GetDiagnosticSummary();
				string diagnosticStateSummary = ChatReadabilityPatch.GetDiagnosticStateSummary();
				string diagnosticSummary2 = VoicePositionRateGuardPatch.GetDiagnosticSummary();
				Log.LogInfo((object)($"[BlueSageDiag] utc={DateTime.UtcNow:O}; " + "build=0.2.4+20260730.1-public-24414155-release; reason=" + SanitizeDiagnosticValue(reason) + "; " + $"netIsHost={input.IsHost}; " + $"isHostMachine={input.IsHostMachine}; " + $"lobbyValid={input.LobbyValid}; " + "identityDetail=private-audit-only; " + $"panelSteamIds={input.PlayerSteamIds.Count}; " + "identityRoster=" + diagnosticRosterSummary + "; processMemory=" + text3 + "; panelObjects=" + diagnosticSummary + "; chatState=" + diagnosticStateSummary + "; voicePosition=" + diagnosticSummary2 + "; " + $"lobbySafety={localAccessState}; " + $"serverFlagCount={input.ServerPlayerCount}; " + "visibleLobby=" + FormatNullableCount(memberCount) + "/" + FormatNullableCount(maxPlayers) + "; steamLobbyMembers=" + FormatNullableCount(memberCount2) + "; steamLobbyLimit=" + FormatNullableCount(maxPlayers2) + "; lobbyVisibility=" + SanitizeDiagnosticValue(visibility) + "; " + $"loadedPlugins={Chainloader.PluginInfos.Count}; " + playerLimitCompanionStatus.ToDiagnosticText() + "; lastHostHealth=" + text + "; panelRosterFingerprint=" + text2 + "; panelSteamIdList=omitted-public"));
			}
		}

		private static string BuildProcessMemoryDiagnosticSummary()
		{
			try
			{
				using Process process = Process.GetCurrentProcess();
				return "managedMiB=" + Math.Round((double)GC.GetTotalMemory(forceFullCollection: false) / 1048576.0, 1) + ",workingSetMiB=" + Math.Round((double)process.WorkingSet64 / 1048576.0, 1) + ",privateMiB=" + Math.Round((double)process.PrivateMemorySize64 / 1048576.0, 1) + ",handles=" + process.HandleCount + ",gc=" + GC.CollectionCount(0) + "/" + GC.CollectionCount(1) + "/" + GC.CollectionCount(2);
			}
			catch (Exception ex)
			{
				return "unavailable-" + ex.GetType().Name;
			}
		}

		private static string BuildPlayerRosterFingerprint(string[] playerSteamIds)
		{
			if (playerSteamIds == null || playerSteamIds.Length == 0)
			{
				return "none";
			}
			string[] array = playerSteamIds.Where((string value) => !string.IsNullOrWhiteSpace(value)).OrderBy<string, string>((string value) => value, StringComparer.Ordinal).ToArray();
			if (array.Length == 0)
			{
				return "none";
			}
			ulong num = 14695981039346656037uL;
			string[] array2 = array;
			foreach (string text in array2)
			{
				foreach (char c in text)
				{
					num ^= c;
					num *= 1099511628211L;
				}
				num ^= 0x7C;
				num *= 1099511628211L;
			}
			return $"{array.Length}:{num:X16}";
		}

		private HostHealthInput CaptureHostHealthInput(out CSteamID? lobbyId, out string[] playerSteamIds)
		{
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			lobbyId = null;
			playerSteamIds = Array.Empty<string>();
			bool flag = false;
			bool lobbyValid = false;
			string localSteamId = string.Empty;
			string text = string.Empty;
			int serverPlayerCount = 0;
			string hostPersonaName = string.Empty;
			try
			{
				flag = (Object)(object)NetworkManager.main != (Object)null && NetworkManager.main.isHost;
			}
			catch
			{
				flag = false;
			}
			try
			{
				MultiplayerManager i = MonoSingleton<MultiplayerManager>.I;
				lobbyValid = (Object)(object)i != (Object)null && i.LobbyStatus;
				string text2 = ((i != null) ? i.LobbyCode : null);
				if (!string.IsNullOrWhiteSpace(text2) && ulong.TryParse(text2, out var result))
				{
					lobbyId = new CSteamID(result);
					text = ((ulong)SteamMatchmaking.GetLobbyOwner(lobbyId.Value)).ToString();
				}
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("Host Health could not read Steam lobby owner: " + ex.GetType().Name + ": " + ex.Message));
			}
			try
			{
				localSteamId = ((ulong)SteamUser.GetSteamID()).ToString();
			}
			catch (Exception ex2)
			{
				Log.LogWarning((object)("Host Health could not read local SteamID: " + ex2.GetType().Name + ": " + ex2.Message));
			}
			try
			{
				PlayerPanelController i2 = NetworkSingleton<PlayerPanelController>.I;
				if ((Object)(object)i2 != (Object)null)
				{
					playerSteamIds = i2.PlayerSteamIDs?.Where((string value) => !string.IsNullOrWhiteSpace(value)).ToArray() ?? Array.Empty<string>();
					serverPlayerCount = i2.PlayerIDs?.Count((PlayerID playerId) => ((PlayerID)(ref playerId)).isServer) ?? 0;
				}
			}
			catch (Exception ex3)
			{
				Log.LogWarning((object)("Host Health could not read player panel state: " + ex3.GetType().Name + ": " + ex3.Message));
			}
			try
			{
				if (TryParseSteamId(text, out var steamId))
				{
					hostPersonaName = SteamFriends.GetFriendPersonaName(steamId);
				}
			}
			catch (Exception ex4)
			{
				Log.LogWarning((object)("Host Health could not read host persona: " + ex4.GetType().Name + ": " + ex4.Message));
			}
			if (_hostHealthStartedAt < 0f)
			{
				_hostHealthStartedAt = Time.unscaledTime;
			}
			double lobbyAgeHours = Math.Max(0.0, (double)(Time.unscaledTime - _hostHealthStartedAt) / 3600.0);
			return new HostHealthInput(flag, lobbyValid, localSteamId, text, playerSteamIds, serverPlayerCount, hostPersonaName, lobbyAgeHours, 12.0);
		}

		private static void RefreshLobbyMetadataHeartbeat(CSteamID? lobbyId, PlayerLimitCompanionStatus playerLimitStatus)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			if (PluginShutdownController.IsShuttingDown)
			{
				return;
			}
			try
			{
				if (!lobbyId.HasValue || (ulong)lobbyId.Value == 0L)
				{
					Log.LogWarning((object)"Host Health H1: cannot refresh lobby metadata because lobby ID is unavailable.");
					return;
				}
				string text = DateTimeOffset.UtcNow.ToUnixTimeSeconds().ToString();
				string text2 = DateTime.UtcNow.Ticks.ToString();
				bool num = SteamMatchmaking.SetLobbyData(lobbyId.Value, "bluesage_qol_heartbeat", text);
				bool flag = SteamMatchmaking.SetLobbyData(lobbyId.Value, "heartbeat", text2);
				int num2 = RefreshLongRunningLobbySurfaceMetadata(lobbyId.Value);
				PublishPlayerLimitCompanionMetadata(lobbyId.Value, playerLimitStatus);
				if (num || flag)
				{
					string text3 = playerLimitStatus?.ToDiagnosticText() ?? "PlayerLimit=unknown";
					Log.LogInfo((object)string.Format("Host Health H1: refreshed Steam lobby heartbeat metadata at {0}; heartbeatCompat={1}; preservedSurfaceKeys={2}; {3}.", text, flag ? "ok" : "failed", num2, text3));
				}
				else
				{
					Log.LogWarning((object)"Host Health H1: SteamMatchmaking.SetLobbyData returned false.");
				}
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("Host Health H1 refresh failed: " + ex.GetType().Name + ": " + ex.Message));
			}
		}

		private static int RefreshLongRunningLobbySurfaceMetadata(CSteamID lobbyId)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			string[] array = new string[6] { "Name", "focus", "mature", "chill", "break", "modded" };
			foreach (string text in array)
			{
				try
				{
					string lobbyData = SteamMatchmaking.GetLobbyData(lobbyId, text);
					if (!string.IsNullOrWhiteSpace(lobbyData) && SteamMatchmaking.SetLobbyData(lobbyId, text, lobbyData))
					{
						num++;
					}
				}
				catch (Exception ex)
				{
					Log.LogDebug((object)("Host Health H1: skipped lobby surface metadata key '" + text + "': " + ex.GetType().Name + ": " + ex.Message));
				}
			}
			return num;
		}

		private static void PublishPlayerLimitCompanionMetadata(CSteamID lobbyId, PlayerLimitCompanionStatus playerLimitStatus)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			if (playerLimitStatus != null && playerLimitStatus.IsLoaded)
			{
				SetOptionalLobbyData(lobbyId, "bluesage_playerlimit_cap", playerLimitStatus.EffectiveMaxLobbySize);
				SetOptionalLobbyData(lobbyId, "bluesage_playerlimit_default", playerLimitStatus.EffectiveDefaultLobbySize);
				SetOptionalLobbyData(lobbyId, "bluesage_playerlimit_shift", playerLimitStatus.EffectiveShiftSkipRate);
				if (playerLimitStatus.ChatRelayPatchEnabled.HasValue)
				{
					SteamMatchmaking.SetLobbyData(lobbyId, "bluesage_playerlimit_chat_relay", playerLimitStatus.ChatRelayPatchEnabled.Value ? "true" : "false");
				}
			}
		}

		private static void SetOptionalLobbyData(CSteamID lobbyId, string key, int? value)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			if (value.HasValue)
			{
				SteamMatchmaking.SetLobbyData(lobbyId, key, value.Value.ToString());
			}
		}

		internal static PlayerLimitCompanionStatus GetPlayerLimitCompanionStatus()
		{
			return CapturePlayerLimitCompanionStatus();
		}

		private static PlayerLimitCompanionStatus CapturePlayerLimitCompanionStatus()
		{
			if (!IsPluginLoaded("com.bluesage.ontogether.playerlimitlift"))
			{
				return PlayerLimitCompanionStatus.NotLoaded();
			}
			try
			{
				Type type = (from assembly in AppDomain.CurrentDomain.GetAssemblies()
					select assembly.GetType("BlueSagePatched.PlayerLimitLift.Plugin", throwOnError: false)).FirstOrDefault((Type candidate) => candidate != null);
				if (type == null)
				{
					return PlayerLimitCompanionStatus.FromLoadedValues(null, null, null, null);
				}
				return PlayerLimitCompanionStatus.FromLoadedValues(ReadStaticNullableInt(type, "EffectiveMaxLobbySize"), ReadStaticNullableInt(type, "EffectiveDefaultLobbySize"), ReadStaticNullableInt(type, "EffectiveShiftSkipRate"), ReadStaticConfigEntryBool(type, "EnableChatRelayPatch"));
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("PlayerLimit companion probe failed: " + ex.GetType().Name + ": " + ex.Message));
				return PlayerLimitCompanionStatus.FromLoadedValues(null, null, null, null);
			}
		}

		private static int? ReadStaticNullableInt(Type type, string propertyName)
		{
			object obj = type.GetProperty(propertyName, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(null, null);
			if (!(obj is int))
			{
				return null;
			}
			return (int)obj;
		}

		private static bool? ReadStaticConfigEntryBool(Type type, string propertyName)
		{
			object obj = type.GetProperty(propertyName, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(null, null);
			object obj2 = obj?.GetType().GetProperty("Value")?.GetValue(obj, null);
			if (!(obj2 is bool))
			{
				return null;
			}
			return (bool)obj2;
		}

		private static void RequestPersonaRefresh(IEnumerable<string> playerSteamIds)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			foreach (string item in playerSteamIds ?? Array.Empty<string>())
			{
				try
				{
					if (TryParseSteamId(item, out var steamId))
					{
						SteamFriends.RequestUserInformation(steamId, true);
						num++;
					}
				}
				catch (Exception ex)
				{
					Log.LogWarning((object)("Host Health H4 persona refresh failed for " + item + ": " + ex.GetType().Name + ": " + ex.Message));
				}
			}
			Log.LogInfo((object)$"Host Health H4: requested Steam persona refresh for {num} player(s).");
		}

		private static bool TryParseSteamId(string value, out CSteamID steamId)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			steamId = default(CSteamID);
			if (string.IsNullOrWhiteSpace(value) || !ulong.TryParse(value, out var result) || result == 0L)
			{
				return false;
			}
			steamId = new CSteamID(result);
			return true;
		}

		internal static bool HandleConnectionLostForReconnectGuard(NotificationStatus notificationStatus)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Instance == (Object)null)
			{
				return true;
			}
			return Instance.HandleConnectionLostForReconnectGuardInstance(notificationStatus);
		}

		private unsafe bool HandleConnectionLostForReconnectGuardInstance(NotificationStatus notificationStatus)
		{
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			if (!EnableReconnectGuard.Value)
			{
				return true;
			}
			if (_reconnectMenuFallbackInProgress)
			{
				Log.LogInfo((object)"Reconnect Guard: menu fallback is already in progress; allowing normal disconnect flow.");
				return true;
			}
			if (_cleanMenuReconnectActive)
			{
				Log.LogInfo((object)$"Reconnect Guard: generation {_cleanMenuReconnectGeneration} already owns recovery in phase {_cleanMenuReconnectPhase}; suppressing duplicate ConnectionLost callback.");
				return false;
			}
			if (_lastLobbyRejoinInProgress)
			{
				Log.LogInfo((object)"Reconnect Guard: saved-lobby recovery is already in progress; suppressing re-entrant disconnect handling.");
				return false;
			}
			bool flag = IsPluginLoaded("com.andrewlin.ontogether.reconnect");
			bool flag2 = false;
			bool flag3 = false;
			try
			{
				flag2 = (Object)(object)NetworkManager.main != (Object)null && NetworkManager.main.isHost;
				flag3 = (Object)(object)NetworkManager.main != (Object)null && (int)NetworkManager.main.clientState == 1;
			}
			catch
			{
			}
			if (flag2 || flag3)
			{
				StopManagedReconnect("host/local client is already connected");
				return true;
			}
			TryCaptureReconnectLobbyCode();
			TryGetVisibleLobbyCounts(out var memberCount, out var maxPlayers);
			if (memberCount.HasValue && memberCount.Value >= 1 && _lastLobbyVisibleAt < 0f)
			{
				_lastLobbyVisibleAt = Time.unscaledTime;
			}
			ReconnectGuardDecision reconnectGuardDecision = ReconnectGuardPolicy.Evaluate(new ReconnectGuardInput(EnableReconnectGuard.Value, flag, suppressHostKickReconnect: true, blockDuringInitialLobbyGrace: true, requireVisibleLobby: true, 5, 20, 3, flag2, isIntentionalLeave: false, _cleanMenuReconnectActive, ((object)(*(NotificationStatus*)(&notificationStatus))/*cast due to .constrained prefix*/).ToString(), (_lastLobbyVisibleAt < 0f) ? ((float?)null) : new float?(Time.unscaledTime - _lastLobbyVisibleAt), (_lastManagedReconnectAttemptAt < 0f) ? ((float?)null) : new float?(Time.unscaledTime - _lastManagedReconnectAttemptAt), Math.Max(1, _managedReconnectAttempt + 1), memberCount, maxPlayers));
			switch (reconnectGuardDecision.Action)
			{
			case ReconnectGuardAction.AllowReconnectMod:
				Log.LogInfo((object)("Reconnect Guard: " + reconnectGuardDecision.Reason));
				return true;
			case ReconnectGuardAction.Noop:
				Log.LogInfo((object)("Reconnect Guard: " + reconnectGuardDecision.Reason));
				return true;
			case ReconnectGuardAction.StopManagedRetry:
				Log.LogWarning((object)("Reconnect Guard: " + reconnectGuardDecision.Reason));
				StopManagedReconnect(reconnectGuardDecision.Reason);
				return true;
			case ReconnectGuardAction.WaitForManagedRetryCadence:
				Log.LogInfo((object)("Reconnect Guard: " + reconnectGuardDecision.Reason));
				return true;
			case ReconnectGuardAction.ScheduleManagedRetry:
			case ReconnectGuardAction.RunManagedRetryNow:
				Log.LogWarning((object)("Reconnect Guard: " + reconnectGuardDecision.Reason));
				if (flag)
				{
					MarkAndrewReconnectIntentionalLeave();
				}
				StartCleanMenuReconnect($"native {notificationStatus}", nativeTeardownAlreadyStarting: true);
				return true;
			default:
				Log.LogWarning((object)$"Reconnect Guard: unexpected policy action {reconnectGuardDecision.Action}; allowing base reconnect flow.");
				return true;
			}
		}

		private void StartCleanMenuReconnect(string source, bool nativeTeardownAlreadyStarting)
		{
			if (_cleanMenuReconnectActive || _cleanMenuReconnectCoroutine != null)
			{
				Log.LogInfo((object)$"Reconnect Guard: existing generation {_cleanMenuReconnectGeneration} retained; ignored overlapping start from {source}.");
				return;
			}
			_cleanMenuReconnectActive = true;
			_managedReconnectSuccessAnnounced = false;
			_reconnectReadySampleCount = 0;
			_reconnectQuorumReadySince = -1f;
			_cleanMenuReconnectCoroutine = ((MonoBehaviour)this).StartCoroutine(CleanMenuReconnectLoop(++_cleanMenuReconnectGeneration, source, nativeTeardownAlreadyStarting));
		}

		private IEnumerator CleanMenuReconnectLoop(int generation, string source, bool nativeTeardownAlreadyStarting)
		{
			_cleanMenuReconnectPhase = "native-teardown";
			Log.LogWarning((object)$"Reconnect Guard generation {generation}: {source}; native teardown must reach the clean menu before any join attempt.");
			AddLocalNotification("BlueSage reconnect is cleaning up the old session first.");
			if (!nativeTeardownAlreadyStarting)
			{
				if (!IsCleanMenuReadyForReconnect(requireBlueSageJoinIdle: false, out var reason))
				{
					RequestNativeReturnToMenuForReconnect();
				}
				else
				{
					Log.LogWarning((object)$"Reconnect Guard generation {generation}: initial menu state is already clean; skipped redundant native ReturnMenu ({reason}).");
				}
			}
			float menuWaited = 0f;
			int consecutiveMenuReadyFrames = 0;
			while (menuWaited < 10f)
			{
				yield return null;
				menuWaited += Time.unscaledDeltaTime;
				if (generation != _cleanMenuReconnectGeneration)
				{
					yield break;
				}
				consecutiveMenuReadyFrames = (IsCleanMenuReadyForReconnect(out var reason2) ? (consecutiveMenuReadyFrames + 1) : 0);
				if (consecutiveMenuReadyFrames >= 3)
				{
					Log.LogWarning((object)$"Reconnect Guard generation {generation}: clean menu confirmed after {menuWaited:0.0}s ({reason2}).");
					break;
				}
			}
			if (consecutiveMenuReadyFrames < 3)
			{
				FinishCleanMenuReconnect(generation, "native teardown did not reach a clean menu; no rejoin was attempted");
				AddLocalNotification("BlueSage reconnect stopped safely at cleanup; use the menu to rejoin.");
				yield break;
			}
			string text = (_lastReconnectLobbyCode ?? string.Empty).Trim();
			if (!ulong.TryParse(text, out var result) || result == 0L)
			{
				FinishCleanMenuReconnect(generation, "saved lobby id was unavailable after native teardown");
				yield break;
			}
			_cleanMenuReconnectPhase = "joining-saved-lobby";
			_lastLobbyRejoinInProgress = true;
			Log.LogWarning((object)$"Reconnect Guard generation {generation}: joining saved lobby {RedactLobbyCode(text)} from clean menu with isChangeLobby=false.");
			AddLocalNotification("BlueSage reconnect is joining the saved lobby from the clean menu.");
			try
			{
				MonoSingleton<MultiplayerManager>.I.JoinByCode(text, false);
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)$"Reconnect Guard generation {generation}: clean-menu join could not start: {ex.GetType().Name}: {ex.Message}");
				FinishCleanMenuReconnect(generation, "clean-menu join threw before it started");
				yield break;
			}
			_cleanMenuReconnectPhase = "validating-playable-scene";
			float connectedSince = -1f;
			float validationWaited = 0f;
			while (validationWaited < 45f)
			{
				yield return null;
				validationWaited += Time.unscaledDeltaTime;
				if (generation != _cleanMenuReconnectGeneration)
				{
					yield break;
				}
				bool flag = IsNetworkClientConnected();
				if (flag && connectedSince < 0f)
				{
					connectedSince = Time.unscaledTime;
				}
				else if (!flag)
				{
					connectedSince = -1f;
				}
				ReconnectRuntimeHealthDecision reconnectRuntimeHealthDecision = EvaluateManagedReconnectRuntime(connectedSince);
				if (reconnectRuntimeHealthDecision.Action == ReconnectRuntimeHealthAction.ConfirmSuccess)
				{
					Log.LogWarning((object)$"Reconnect Guard generation {generation}: playable reconnect confirmed after {validationWaited:0.0}s: {reconnectRuntimeHealthDecision.Reason}");
					AnnounceManagedReconnectSuccess();
					FinishCleanMenuReconnect(generation, "playable scene confirmed");
					yield break;
				}
			}
			Log.LogWarning((object)$"Reconnect Guard generation {generation}: saved-lobby join did not produce a playable scene within {45}s; returning through native cleanup.");
			AddLocalNotification("BlueSage reconnect joined incompletely; cleaning up instead of looping.");
			if (!IsCleanMenuReadyForReconnect(requireBlueSageJoinIdle: false, out var reason3))
			{
				RequestNativeReturnToMenuForReconnect();
			}
			else
			{
				Log.LogWarning((object)$"Reconnect Guard generation {generation}: terminal menu state is already clean; skipped redundant native ReturnMenu ({reason3}).");
			}
			float fallbackMenuWaited = 0f;
			int fallbackMenuReadyFrames = 0;
			while (fallbackMenuWaited < 10f)
			{
				yield return null;
				fallbackMenuWaited += Time.unscaledDeltaTime;
				fallbackMenuReadyFrames = (IsCleanMenuReadyForReconnect(requireBlueSageJoinIdle: false, out var _) ? (fallbackMenuReadyFrames + 1) : 0);
				if (fallbackMenuReadyFrames >= 3)
				{
					break;
				}
			}
			FinishCleanMenuReconnect(generation, "saved-lobby validation failed without another same-lobby retry");
			if (fallbackMenuReadyFrames < 3 || !TryStartReplacementLobbyDiscovery())
			{
				AddLocalNotification("BlueSage reconnect stopped at the menu without starting another loop.");
			}
		}

		private void FinishCleanMenuReconnect(int generation, string reason)
		{
			if (generation == _cleanMenuReconnectGeneration)
			{
				Log.LogWarning((object)$"Reconnect Guard generation {generation} finished in phase {_cleanMenuReconnectPhase}: {reason}.");
				_cleanMenuReconnectActive = false;
				_cleanMenuReconnectPhase = "idle";
				_cleanMenuReconnectCoroutine = null;
				_lastLobbyRejoinInProgress = false;
				_reconnectMenuFallbackInProgress = false;
				_reconnectReadySampleCount = 0;
				_reconnectQuorumReadySince = -1f;
			}
		}

		private static bool IsCleanMenuReadyForReconnect(out string reason)
		{
			return IsCleanMenuReadyForReconnect(requireBlueSageJoinIdle: true, out reason);
		}

		private static bool IsCleanMenuReadyForReconnect(bool requireBlueSageJoinIdle, out string reason)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Scene activeScene = SceneManager.GetActiveScene();
				MultiplayerManager i = MonoSingleton<MultiplayerManager>.I;
				bool flag = (Object)(object)MonoSingleton<MainMenuUIController>.I != (Object)null;
				bool flag2 = !IsNetworkClientConnected();
				bool flag3 = (Object)(object)i == (Object)null || !i.LobbyStatus;
				bool flag4 = (Object)(object)i != (Object)null && i.IsConnecting;
				bool flag5 = (Object)(object)Instance == (Object)null || !Instance._lastLobbyRejoinInProgress;
				ReconnectMenuReadinessState state = new ReconnectMenuReadinessState(((Scene)(ref activeScene)).isLoaded, ((Scene)(ref activeScene)).buildIndex, flag, flag2, flag3, flag5);
				reason = $"scene={((Scene)(ref activeScene)).buildIndex}, menu={flag}, transportStopped={flag2}, lobbyCleared={flag3}, vanillaIsConnecting={flag4}, blueSageJoinIdle={flag5}, requireBlueSageJoinIdle={requireBlueSageJoinIdle}";
				return requireBlueSageJoinIdle ? ReconnectTerminalCleanupPolicy.IsReadyForNewJoin(state) : ReconnectTerminalCleanupPolicy.IsReady(state);
			}
			catch (Exception ex)
			{
				reason = "menu readiness unavailable: " + ex.GetType().Name;
				return false;
			}
		}

		private void StartManagedReconnectLoop(string source, int intervalSeconds, int maxAttempts)
		{
			if (_managedReconnectCoroutine == null)
			{
				_managedReconnectActive = true;
				_managedReconnectSuccessAnnounced = false;
				_managedReconnectCoroutine = ((MonoBehaviour)this).StartCoroutine(ManagedReconnectLoop(source, intervalSeconds, maxAttempts));
			}
		}

		private IEnumerator ManagedReconnectLoop(string source, int intervalSeconds, int maxAttempts)
		{
			Log.LogWarning((object)$"Reconnect Guard started managed retry loop after {source}. Interval={intervalSeconds}s, max={maxAttempts}.");
			float connectedSince = -1f;
			Log.LogWarning((object)$"Reconnect Guard initial wait {intervalSeconds}s before first canonical saved-lobby cleanup/rejoin attempt so lobby state can settle.");
			AddLocalNotification($"BlueSage reconnect will try in {intervalSeconds}s.");
			float initialWaited = 0f;
			while (initialWaited < (float)intervalSeconds)
			{
				yield return null;
				initialWaited += Time.unscaledDeltaTime;
				bool flag = IsNetworkClientConnected();
				if (flag && connectedSince < 0f)
				{
					connectedSince = Time.unscaledTime;
				}
				else if (!flag)
				{
					connectedSince = -1f;
				}
				ReconnectRuntimeHealthDecision reconnectRuntimeHealthDecision = EvaluateManagedReconnectRuntime(connectedSince);
				if (reconnectRuntimeHealthDecision.Action == ReconnectRuntimeHealthAction.ConfirmSuccess)
				{
					Log.LogWarning((object)("Reconnect Guard confirmed usable runtime during initial wait: " + reconnectRuntimeHealthDecision.Reason));
					AnnounceManagedReconnectSuccess();
					StopManagedReconnect("client connected during initial wait");
					yield break;
				}
				if (reconnectRuntimeHealthDecision.Action == ReconnectRuntimeHealthAction.ReturnToMenu)
				{
					Log.LogWarning((object)("Reconnect Guard could not confirm a usable runtime during initial wait: " + reconnectRuntimeHealthDecision.Reason));
					StopManagedReconnect(reconnectRuntimeHealthDecision.Reason);
					HandleReconnectFailureFallback(reconnectRuntimeHealthDecision.Reason);
					yield break;
				}
			}
			while (_managedReconnectAttempt < maxAttempts)
			{
				bool flag2 = IsNetworkClientConnected();
				if (flag2 && connectedSince < 0f)
				{
					connectedSince = Time.unscaledTime;
				}
				else if (!flag2)
				{
					connectedSince = -1f;
				}
				ReconnectRuntimeHealthDecision reconnectRuntimeHealthDecision2 = EvaluateManagedReconnectRuntime(connectedSince);
				if (reconnectRuntimeHealthDecision2.Action == ReconnectRuntimeHealthAction.ConfirmSuccess)
				{
					Log.LogWarning((object)("Reconnect Guard confirmed usable runtime: " + reconnectRuntimeHealthDecision2.Reason));
					AnnounceManagedReconnectSuccess();
					StopManagedReconnect("client connected");
					yield break;
				}
				if (reconnectRuntimeHealthDecision2.Action == ReconnectRuntimeHealthAction.ReturnToMenu)
				{
					Log.LogWarning((object)("Reconnect Guard could not confirm a usable runtime: " + reconnectRuntimeHealthDecision2.Reason));
					StopManagedReconnect(reconnectRuntimeHealthDecision2.Reason);
					HandleReconnectFailureFallback(reconnectRuntimeHealthDecision2.Reason);
					yield break;
				}
				TryGetVisibleLobbyCounts(out var memberCount, out var maxPlayers);
				bool flag3 = memberCount.HasValue && memberCount.Value >= 1;
				_managedReconnectAttempt++;
				_lastManagedReconnectAttemptAt = Time.unscaledTime;
				if (!flag2)
				{
					string text = (flag3 ? $"{memberCount}/{maxPlayers}" : "not confirmed");
					Log.LogWarning((object)("Reconnect Guard: transport is disconnected with lobby " + text + "; using canonical saved-lobby cleanup/rejoin instead of calling StartClient directly."));
					StopManagedReconnect("switching to canonical lobby rejoin");
					HandleReconnectFailureFallback("transport disconnected; canonical lobby rejoin required");
					yield break;
				}
				Log.LogWarning((object)$"Reconnect Guard attempt {_managedReconnectAttempt}/{maxAttempts}: {reconnectRuntimeHealthDecision2.Reason}");
				float waited = 0f;
				while (waited < (float)intervalSeconds)
				{
					yield return null;
					waited += Time.unscaledDeltaTime;
					bool flag4 = IsNetworkClientConnected();
					if (flag4 && connectedSince < 0f)
					{
						connectedSince = Time.unscaledTime;
					}
					else if (!flag4)
					{
						connectedSince = -1f;
					}
					ReconnectRuntimeHealthDecision reconnectRuntimeHealthDecision3 = EvaluateManagedReconnectRuntime(connectedSince);
					if (reconnectRuntimeHealthDecision3.Action == ReconnectRuntimeHealthAction.ConfirmSuccess)
					{
						Log.LogWarning((object)("Reconnect Guard confirmed usable runtime during wait: " + reconnectRuntimeHealthDecision3.Reason));
						AnnounceManagedReconnectSuccess();
						StopManagedReconnect("client connected during wait");
						yield break;
					}
					if (reconnectRuntimeHealthDecision3.Action == ReconnectRuntimeHealthAction.ReturnToMenu)
					{
						Log.LogWarning((object)("Reconnect Guard could not confirm a usable runtime during wait: " + reconnectRuntimeHealthDecision3.Reason));
						StopManagedReconnect(reconnectRuntimeHealthDecision3.Reason);
						HandleReconnectFailureFallback(reconnectRuntimeHealthDecision3.Reason);
						yield break;
					}
				}
			}
			StopManagedReconnect($"max attempts reached ({maxAttempts})");
			HandleReconnectFailureFallback($"max attempts reached ({maxAttempts})");
		}

		private void TryCaptureReconnectLobbyCode()
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				MultiplayerManager i = MonoSingleton<MultiplayerManager>.I;
				if ((Object)(object)i == (Object)null || !i.LobbyStatus)
				{
					return;
				}
				string lobbyCode = i.LobbyCode;
				if (string.IsNullOrWhiteSpace(lobbyCode))
				{
					return;
				}
				lobbyCode = lobbyCode.Trim();
				if (ulong.TryParse(lobbyCode, out var result) && result != 0L)
				{
					if (!string.Equals(_lastReconnectLobbyCode, lobbyCode, StringComparison.Ordinal))
					{
						_lastReconnectLobbyCode = lobbyCode;
						_lastLobbyRejoinInProgress = false;
						_replacementLobbyDiscoveryAttempted = false;
						Log.LogInfo((object)"Reconnect Guard saved current lobby id for last-lobby fallback.");
					}
					CSteamID val = new CSteamID(result);
					CSteamID lobbyOwner = SteamMatchmaking.GetLobbyOwner(val);
					if (lobbyOwner != CSteamID.Nil)
					{
						_lastReconnectLobbyOwnerSteamId = ((ulong)lobbyOwner).ToString();
					}
					string lobbyData = SteamMatchmaking.GetLobbyData(val, "Name");
					_lastReconnectLobbyNameFingerprint = GetLobbyNameFingerprint(lobbyData);
				}
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("Reconnect Guard could not capture current lobby id: " + ex.GetType().Name + ": " + ex.Message));
			}
		}

		private void HandleReconnectFailureFallback(string reason)
		{
			if (!TryRejoinLastLobbyBeforeMenuFallback(reason))
			{
				AddLocalNotification("BlueSage reconnect could not confirm a usable lobby; returning to menu.");
				ReturnToMenuAfterFailedReconnectCore();
			}
		}

		private bool TryRejoinLastLobbyBeforeMenuFallback(string reason)
		{
			if (_cleanMenuReconnectActive || string.IsNullOrWhiteSpace(_lastReconnectLobbyCode))
			{
				return false;
			}
			if (!ulong.TryParse(_lastReconnectLobbyCode, out var result) || result == 0L)
			{
				Log.LogWarning((object)"Reconnect Guard saved lobby id was invalid; skipping last-lobby rejoin fallback.");
				return false;
			}
			Log.LogWarning((object)("Reconnect Guard legacy fallback redirected into one clean-menu generation: " + reason + "."));
			StartCleanMenuReconnect("legacy fallback redirected: " + reason, nativeTeardownAlreadyStarting: false);
			return true;
		}

		private IEnumerator LastLobbyRejoinFallbackWait()
		{
			Log.LogWarning((object)"Reconnect Guard last-lobby rejoin attempted; waiting before menu fallback.");
			float connectedSince = -1f;
			float waited = 0f;
			float maxWaitSeconds = 13f;
			while (waited < maxWaitSeconds)
			{
				yield return null;
				waited += Time.unscaledDeltaTime;
				bool flag = IsNetworkClientConnected();
				if (flag && connectedSince < 0f)
				{
					connectedSince = Time.unscaledTime;
				}
				else if (!flag)
				{
					connectedSince = -1f;
				}
				ReconnectRuntimeHealthDecision reconnectRuntimeHealthDecision = EvaluateManagedReconnectRuntime(connectedSince);
				if (reconnectRuntimeHealthDecision.Action == ReconnectRuntimeHealthAction.ConfirmSuccess)
				{
					Log.LogWarning((object)("Reconnect Guard confirmed usable runtime after last-lobby rejoin: " + reconnectRuntimeHealthDecision.Reason));
					AnnounceManagedReconnectSuccess();
					_lastLobbyRejoinInProgress = false;
					_lastLobbyRejoinFallbackCoroutine = null;
					yield break;
				}
			}
			_lastLobbyRejoinInProgress = false;
			_lastLobbyRejoinFallbackCoroutine = null;
			if (!TryStartReplacementLobbyDiscovery())
			{
				AddLocalNotification("BlueSage reconnect could not rejoin the last lobby; returning to menu.");
				ReturnToMenuAfterFailedReconnectCore();
			}
		}

		private bool TryStartReplacementLobbyDiscovery()
		{
			if (_replacementLobbyDiscoveryAttempted || string.IsNullOrWhiteSpace(_lastReconnectLobbyOwnerSteamId) || _replacementLobbyDiscoveryCoroutine != null)
			{
				return false;
			}
			_replacementLobbyDiscoveryAttempted = true;
			_lastLobbyRejoinInProgress = true;
			_replacementLobbyDiscoveryCoroutine = ((MonoBehaviour)this).StartCoroutine(ReplacementLobbyDiscoveryLoop());
			AddLocalNotification("BlueSage reconnect is checking whether the same host re-created the public lobby.");
			return true;
		}

		private IEnumerator ReplacementLobbyDiscoveryLoop()
		{
			int[] array = new int[5] { 5, 5, 10, 10, 15 };
			int[] array2 = array;
			foreach (int num in array2)
			{
				yield return (object)new WaitForSecondsRealtime((float)num);
				List<string> candidates = new List<string>();
				for (int distance = 1; distance <= 3; distance++)
				{
					Task searchTask = StartReplacementLobbySearch(distance);
					if (searchTask == null)
					{
						continue;
					}
					float taskWaited = 0f;
					while (!searchTask.IsCompleted && taskWaited < 8f)
					{
						yield return null;
						taskWaited += Time.unscaledDeltaTime;
					}
					if (!searchTask.IsCompleted || searchTask.IsFaulted || searchTask.IsCanceled)
					{
						continue;
					}
					foreach (object item in ReadTaskResultItems(searchTask))
					{
						string text = ReadLobbyString(item, "lobbyId");
						string candidateName = ReadLobbyString(item, "Name");
						if (IsReplacementLobbyCandidate(text, candidateName) && !candidates.Contains(text))
						{
							candidates.Add(text);
						}
					}
				}
				if (candidates.Count == 1)
				{
					_lastReconnectLobbyCode = candidates[0];
					_lastLobbyRejoinInProgress = false;
					_replacementLobbyDiscoveryCoroutine = null;
					Log.LogWarning((object)"Reconnect Guard found one validated replacement lobby owned by the original host; starting one clean-menu join generation.");
					AddLocalNotification("BlueSage found the host's replacement lobby and is reconnecting.");
					StartCleanMenuReconnect("validated same-host replacement lobby discovered", nativeTeardownAlreadyStarting: false);
					yield break;
				}
				if (candidates.Count > 1)
				{
					Log.LogWarning((object)"Reconnect Guard found multiple same-host replacement candidates; refusing to guess.");
					break;
				}
			}
			_lastLobbyRejoinInProgress = false;
			_replacementLobbyDiscoveryCoroutine = null;
			AddLocalNotification("BlueSage could not uniquely validate a replacement lobby; returning to menu.");
			ReturnToMenuAfterFailedReconnectCore();
		}

		private static Task StartReplacementLobbySearch(int distance)
		{
			try
			{
				MultiplayerManager i = MonoSingleton<MultiplayerManager>.I;
				object obj = AccessTools.Field(typeof(MultiplayerManager), "_lobbyManager")?.GetValue(i);
				object obj2 = obj?.GetType().GetProperty("CurrentProvider")?.GetValue(obj, null);
				MethodInfo? obj3 = obj2?.GetType().GetMethod("SearchLobbiesAsync", new Type[3]
				{
					typeof(int),
					typeof(int),
					typeof(Dictionary<string, string>)
				});
				Dictionary<string, string> dictionary = new Dictionary<string, string>
				{
					{ "public", "t" },
					{
						"version",
						ConstData.Version.ToLowerInvariant()
					}
				};
				return obj3?.Invoke(obj2, new object[3] { distance, 50, dictionary }) as Task;
			}
			catch (Exception ex)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)("Reconnect Guard replacement-lobby search could not start: " + ex.GetType().Name + ": " + ex.Message));
				}
				return null;
			}
		}

		private static IEnumerable<object> ReadTaskResultItems(Task task)
		{
			if (!(task?.GetType().GetProperty("Result")?.GetValue(task, null) is IEnumerable enumerable))
			{
				yield break;
			}
			foreach (object item in enumerable)
			{
				yield return item;
			}
		}

		private bool IsReplacementLobbyCandidate(string candidateId, string candidateName)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			if (!ulong.TryParse(candidateId, out var result) || result == 0L || string.Equals(candidateId, _lastReconnectLobbyCode, StringComparison.Ordinal))
			{
				return false;
			}
			CSteamID val = default(CSteamID);
			((CSteamID)(ref val))..ctor(result);
			if (!string.Equals(((ulong)SteamMatchmaking.GetLobbyOwner(val)).ToString(), _lastReconnectLobbyOwnerSteamId, StringComparison.Ordinal))
			{
				return false;
			}
			if (!string.Equals(SteamMatchmaking.GetLobbyData(val, "public"), "t", StringComparison.OrdinalIgnoreCase) || string.Equals(SteamMatchmaking.GetLobbyData(val, "request"), "t", StringComparison.OrdinalIgnoreCase) || !string.Equals(SteamMatchmaking.GetLobbyData(val, "version"), ConstData.Version.ToLowerInvariant(), StringComparison.OrdinalIgnoreCase))
			{
				return false;
			}
			int numLobbyMembers = SteamMatchmaking.GetNumLobbyMembers(val);
			int lobbyMemberLimit = SteamMatchmaking.GetLobbyMemberLimit(val);
			if (numLobbyMembers < 1 || lobbyMemberLimit < 1 || numLobbyMembers >= lobbyMemberLimit - 1)
			{
				return false;
			}
			string lobbyNameFingerprint = GetLobbyNameFingerprint(candidateName);
			if (!string.IsNullOrEmpty(_lastReconnectLobbyNameFingerprint))
			{
				return string.Equals(lobbyNameFingerprint, _lastReconnectLobbyNameFingerprint, StringComparison.Ordinal);
			}
			return true;
		}

		private static string ReadLobbyString(object lobby, string memberName)
		{
			if (lobby == null)
			{
				return string.Empty;
			}
			return (lobby.GetType().GetProperty(memberName)?.GetValue(lobby, null) ?? lobby.GetType().GetField(memberName)?.GetValue(lobby))?.ToString() ?? string.Empty;
		}

		private static string GetLobbyNameFingerprint(string lobbyName)
		{
			string text = new string((from character in Regex.Replace(lobbyName ?? string.Empty, "<[^>]*>", string.Empty)
				where !char.IsWhiteSpace(character)
				select character).ToArray()).ToLowerInvariant();
			if (!text.Contains("♪blues♪"))
			{
				return text;
			}
			return "♪blues♪";
		}

		private static bool IsNetworkClientConnected()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Invalid comparison between Unknown and I4
			try
			{
				return (Object)(object)NetworkManager.main != (Object)null && (int)NetworkManager.main.clientState == 1;
			}
			catch (Exception ex)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)("Reconnect Guard could not read PurrNet client state: " + ex.GetType().Name + ": " + ex.Message));
				}
				return false;
			}
		}

		private static ReconnectRuntimeHealthDecision EvaluateManagedReconnectRuntime(float connectedSince)
		{
			bool num = IsNetworkClientConnected();
			int? memberCount;
			int? maxPlayers;
			bool localUserIsMember;
			bool flag = TryGetAuthoritativeLobbyState(out memberCount, out maxPlayers, out localUserIsMember) && memberCount.HasValue && memberCount.Value >= 1;
			string reason;
			bool flag2 = IsGameRuntimeUsableForReconnect(out reason);
			bool flag3 = IsVoiceRuntimeReadyForReconnect();
			bool flag4 = num && flag && localUserIsMember && flag2;
			float readyStableSeconds = 0f;
			if ((Object)(object)Instance != (Object)null)
			{
				Instance._reconnectReadySampleCount = (flag4 ? (Instance._reconnectReadySampleCount + 1) : 0);
				if (flag4)
				{
					if (Instance._reconnectQuorumReadySince < 0f)
					{
						Instance._reconnectQuorumReadySince = Time.unscaledTime;
					}
					readyStableSeconds = Time.unscaledTime - Instance._reconnectQuorumReadySince;
				}
				else
				{
					Instance._reconnectQuorumReadySince = -1f;
				}
			}
			ReconnectRuntimeHealthDecision reconnectRuntimeHealthDecision = ReconnectRuntimeHealthPolicy.Evaluate(new ReconnectRuntimeHealthInput(secondsSinceClientTransportConnected: (num && connectedSince >= 0f) ? new float?(Time.unscaledTime - connectedSince) : ((float?)null), clientTransportConnected: num, requireVisibleLobby: true, visibleLobbyConfirmed: flag, localUserIsAuthoritativeLobbyMember: localUserIsMember, gameRuntimeUsable: flag2, voiceRuntimeReady: flag3, consecutiveReadySamples: Instance?._reconnectReadySampleCount ?? 0, postConnectValidationSeconds: 8, readyStableSeconds: readyStableSeconds));
			if (reconnectRuntimeHealthDecision.Action == ReconnectRuntimeHealthAction.ConfirmSuccess)
			{
				return reconnectRuntimeHealthDecision;
			}
			return new ReconnectRuntimeHealthDecision(reconnectRuntimeHealthDecision.Action, $"{reconnectRuntimeHealthDecision.Reason} Runtime probe: {reason}; voiceReady={flag3}.");
		}

		private static bool TryGetAuthoritativeLobbyState(out int? memberCount, out int? maxPlayers, out bool localUserIsMember)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			memberCount = null;
			maxPlayers = null;
			localUserIsMember = false;
			try
			{
				MultiplayerManager i = MonoSingleton<MultiplayerManager>.I;
				if (!ulong.TryParse((i != null) ? i.LobbyCode : null, out var result) || result == 0L || !SteamManager.Initialized)
				{
					return false;
				}
				CSteamID val = default(CSteamID);
				((CSteamID)(ref val))..ctor(result);
				CSteamID steamID = SteamUser.GetSteamID();
				int numLobbyMembers = SteamMatchmaking.GetNumLobbyMembers(val);
				memberCount = numLobbyMembers;
				maxPlayers = SteamMatchmaking.GetLobbyMemberLimit(val);
				for (int j = 0; j < numLobbyMembers; j++)
				{
					if (SteamMatchmaking.GetLobbyMemberByIndex(val, j) == steamID)
					{
						localUserIsMember = true;
						break;
					}
				}
				return true;
			}
			catch (Exception ex)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)("Reconnect Guard could not read authoritative Steam lobby membership: " + ex.GetType().Name + ": " + ex.Message));
				}
				return false;
			}
		}

		private static bool IsVoiceRuntimeReadyForReconnect()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				MultiplayerManager i = MonoSingleton<MultiplayerManager>.I;
				string text = ((i != null) ? i.LobbyCode : null);
				if (!ulong.TryParse(text, out var result) || result == 0L)
				{
					return false;
				}
				if (string.Equals(SteamMatchmaking.GetLobbyData(new CSteamID(result), "voice"), "f", StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
				VoiceManager i2 = MonoSingleton<VoiceManager>.I;
				return (Object)(object)i2 != (Object)null && i2.IsJoined && string.Equals(i2.LobbyIDName, text, StringComparison.Ordinal);
			}
			catch (Exception ex)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)("Reconnect Guard could not verify Vivox lobby alignment: " + ex.GetType().Name + ": " + ex.Message));
				}
				return false;
			}
		}

		private static bool IsGameRuntimeUsableForReconnect(out string reason)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			reason = "unknown";
			try
			{
				Scene activeScene = SceneManager.GetActiveScene();
				if (!((Scene)(ref activeScene)).isLoaded || ((Scene)(ref activeScene)).buildIndex != 2)
				{
					reason = $"scene={((Scene)(ref activeScene)).buildIndex}, loaded={((Scene)(ref activeScene)).isLoaded}";
					return false;
				}
				MultiplayerManager i = MonoSingleton<MultiplayerManager>.I;
				if ((Object)(object)i == (Object)null || !i.LobbyStatus)
				{
					reason = string.Format("multiplayer={0}, lobbyStatus={1}", ((Object)(object)i == (Object)null) ? "missing" : "present", (i != null) ? new bool?(i.LobbyStatus) : ((bool?)null));
					return false;
				}
				string text = Instance?._lastReconnectLobbyCode;
				if (!string.IsNullOrWhiteSpace(text) && !string.Equals(i.LobbyCode, text, StringComparison.Ordinal))
				{
					reason = "active lobby does not match the reconnect target";
					return false;
				}
				TextChannelManager i2 = NetworkSingleton<TextChannelManager>.I;
				if ((Object)(object)i2 == (Object)null || (Object)(object)i2.MainPlayer == (Object)null || (Object)(object)i2.MainPlayerController == (Object)null || !((Component)i2.MainPlayer).gameObject.activeInHierarchy || !((Component)i2.MainPlayerController).gameObject.activeInHierarchy)
				{
					reason = string.Format("chat={0}, player={1}, controller={2}", ((Object)(object)i2 == (Object)null) ? "missing" : "present", (Object)(object)i2?.MainPlayer != (Object)null, (Object)(object)i2?.MainPlayerController != (Object)null);
					return false;
				}
				PlayerPanelController i3 = NetworkSingleton<PlayerPanelController>.I;
				if ((Object)(object)i3 == (Object)null || i3.PlayerSteamIDs == null || i3.PlayerControllers == null || i3.PlayerTransforms == null || !SteamManager.Initialized)
				{
					reason = string.Format("panel={0}, steamInitialized={1}", ((Object)(object)i3 == (Object)null) ? "missing" : "present", SteamManager.Initialized);
					return false;
				}
				string localSteamId = ((ulong)SteamUser.GetSteamID()).ToString();
				int num = i3.PlayerSteamIDs.Count((string value) => string.Equals(value, localSteamId, StringComparison.Ordinal));
				int num2 = i3.PlayerSteamIDs.FindIndex((string value) => string.Equals(value, localSteamId, StringComparison.Ordinal));
				bool flag = num == 1 && num2 >= 0 && num2 < i3.PlayerControllers.Count && num2 < i3.PlayerTransforms.Count && (Object)(object)i3.PlayerControllers[num2] != (Object)null && (Object)(object)i3.PlayerTransforms[num2] != (Object)null;
				reason = (flag ? "scene, lobby, chat/player controller, and unique local roster entry are playable" : $"localRosterOccurrences={num}, localIndex={num2}, controllers={i3.PlayerControllers.Count}, transforms={i3.PlayerTransforms.Count}");
				return flag;
			}
			catch (Exception ex)
			{
				reason = "probe exception " + ex.GetType().Name;
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)("Reconnect Guard could not read local runtime readiness: " + ex.GetType().Name + ": " + ex.Message));
				}
				return false;
			}
		}

		private void StopManagedReconnect(string reason)
		{
			if (_cleanMenuReconnectCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_cleanMenuReconnectCoroutine);
				_cleanMenuReconnectCoroutine = null;
				_cleanMenuReconnectGeneration++;
			}
			if (_cleanMenuReconnectActive)
			{
				Log.LogWarning((object)("Reconnect Guard stopped generation in phase " + _cleanMenuReconnectPhase + ": " + reason + "."));
			}
			_cleanMenuReconnectActive = false;
			_cleanMenuReconnectPhase = "idle";
			if (_managedReconnectCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_managedReconnectCoroutine);
				_managedReconnectCoroutine = null;
			}
			if (_managedReconnectActive)
			{
				Log.LogWarning((object)("Reconnect Guard stopped: " + reason + "."));
			}
			_managedReconnectActive = false;
			_managedReconnectAttempt = 0;
			_lastManagedReconnectAttemptAt = -1f;
			_reconnectReadySampleCount = 0;
			_reconnectQuorumReadySince = -1f;
		}

		private void AnnounceManagedReconnectSuccess()
		{
			if (_managedReconnectSuccessAnnounced)
			{
				return;
			}
			_managedReconnectSuccessAnnounced = true;
			if (EnableReconnectAnnouncement.Value)
			{
				string text = "Auto Reconnected by Blues - BlueSage QoL Tweaks Mod".Trim();
				if (!string.IsNullOrWhiteSpace(text))
				{
					_reconnectAnnouncementCoroutine = ((MonoBehaviour)this).StartCoroutine(DelayedReconnectAnnouncement(text));
				}
			}
		}

		private IEnumerator DelayedReconnectAnnouncement(string message)
		{
			int num = 3;
			if (num > 0)
			{
				yield return (object)new WaitForSecondsRealtime((float)num);
			}
			if (!TrySendLobbyChatMessage(message))
			{
				AddLocalNotification(message);
			}
			_reconnectAnnouncementCoroutine = null;
		}

		internal bool TrySendDoNotPressLobbyMessage()
		{
			return TrySendLobbyChatMessage("@Blue I found the tiny BlueSage lobby joke :3");
		}

		internal static bool TrySendLobbyChatMessage(string message)
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				TextChannelManager i = NetworkSingleton<TextChannelManager>.I;
				if ((Object)(object)i == (Object)null)
				{
					return false;
				}
				string s = i.UserName ?? "BlueSage QoL";
				string text = (AccessTools.Field(typeof(TextChannelManager), "_playerId")?.GetValue(i) as string) ?? string.Empty;
				Vector3 val = (((Object)(object)i.MainPlayer != (Object)null) ? i.MainPlayer.position : Vector3.zero);
				i.SendMessageAsync(Encoding.Unicode.GetBytes(message), Encoding.Unicode.GetBytes(s), false, val, text, default(RPCInfo));
				return true;
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("Lobby chat send failed: " + ex.GetType().Name + ": " + ex.Message));
				return false;
			}
		}

		private static int Clamp(int value, int min, int max)
		{
			if (value < min)
			{
				return min;
			}
			if (value > max)
			{
				return max;
			}
			return value;
		}

		internal static bool IsPluginLoaded(string pluginGuid)
		{
			return Chainloader.PluginInfos.Keys.Any((string key) => string.Equals(key, pluginGuid, StringComparison.OrdinalIgnoreCase));
		}

		private static void RequestNativeReturnToMenuForReconnect()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			Plugin instance = Instance;
			if ((Object)(object)instance != (Object)null)
			{
				instance._reconnectMenuFallbackInProgress = true;
			}
			try
			{
				MultiplayerManager i = MonoSingleton<MultiplayerManager>.I;
				if ((Object)(object)i != (Object)null)
				{
					i._notificationState = (NotificationStatus)3;
				}
				MainSceneManager i2 = MonoSingleton<MainSceneManager>.I;
				if ((Object)(object)i2 != (Object)null)
				{
					i2.ReturnMenu(false);
				}
				else if (i != null)
				{
					i.QuitSession();
				}
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("Reconnect Guard could not request native menu teardown: " + ex.GetType().Name + ": " + ex.Message));
			}
		}

		private static void ReturnToMenuAfterFailedReconnectCore()
		{
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			Plugin instance = Instance;
			if ((Object)(object)instance != (Object)null)
			{
				instance._reconnectMenuFallbackInProgress = true;
			}
			try
			{
				try
				{
					MultiplayerManager i = MonoSingleton<MultiplayerManager>.I;
					if (i != null)
					{
						i.QuitSession();
					}
				}
				catch (Exception ex)
				{
					Log.LogWarning((object)("Reconnect Guard could not quit unhealthy session before menu fallback: " + ex.GetType().Name + ": " + ex.Message));
				}
				MainSceneManager i2 = MonoSingleton<MainSceneManager>.I;
				if (!((Object)(object)i2 == (Object)null))
				{
					AccessTools.Field(typeof(MainSceneManager), "_returnMenuStarted")?.SetValue(i2, false);
					MultiplayerManager i3 = MonoSingleton<MultiplayerManager>.I;
					if ((Object)(object)i3 != (Object)null)
					{
						i3._notificationState = (NotificationStatus)3;
					}
					i2.ReturnMenu(false);
				}
			}
			catch (Exception ex2)
			{
				Log.LogWarning((object)("Reconnect Guard fallback to menu failed: " + ex2.GetType().Name + ": " + ex2.Message));
			}
			finally
			{
				if ((Object)(object)instance != (Object)null)
				{
					((MonoBehaviour)instance).StartCoroutine(instance.ClearReconnectMenuFallbackFlagSoon());
				}
			}
		}

		private IEnumerator ClearReconnectMenuFallbackFlagSoon()
		{
			yield return null;
			yield return null;
			_reconnectMenuFallbackInProgress = false;
		}

		private static string RedactLobbyCode(string lobbyCode)
		{
			if (string.IsNullOrWhiteSpace(lobbyCode))
			{
				return "[none]";
			}
			lobbyCode = lobbyCode.Trim();
			if (lobbyCode.Length <= 4)
			{
				return "[redacted]";
			}
			return "[redacted:" + lobbyCode.Substring(lobbyCode.Length - 4) + "]";
		}

		private static void MarkAndrewReconnectIntentionalLeave()
		{
			try
			{
				PropertyInfo propertyInfo = (from assembly in AppDomain.CurrentDomain.GetAssemblies()
					select assembly.GetType("Reconnect.ReconnectPlugin", throwOnError: false)).FirstOrDefault((Type candidate) => candidate != null)?.GetProperty("IsIntentionalLeave", BindingFlags.Static | BindingFlags.Public);
				if ((object)propertyInfo != null && propertyInfo.CanWrite)
				{
					propertyInfo.SetValue(null, true, null);
					Log.LogInfo((object)"Reconnect Guard marked AndrewLin Reconnect intentional-leave flag to prevent immediate retry.");
				}
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("Reconnect Guard could not mark AndrewLin Reconnect intentional leave: " + ex.GetType().Name + ": " + ex.Message));
			}
		}

		private static bool TryGetVisibleLobbyCounts(out int? memberCount, out int? maxPlayers)
		{
			memberCount = null;
			maxPlayers = null;
			try
			{
				MultiplayerManager i = MonoSingleton<MultiplayerManager>.I;
				object obj = AccessTools.Field(typeof(MultiplayerManager), "_lobbyManager")?.GetValue(i);
				object obj2 = obj?.GetType().GetProperty("CurrentLobby")?.GetValue(obj, null);
				if (obj2 == null)
				{
					return false;
				}
				object obj3 = obj2.GetType().GetProperty("Members")?.GetValue(obj2, null);
				object obj4 = obj2.GetType().GetProperty("MaxPlayers")?.GetValue(obj2, null);
				PropertyInfo propertyInfo = obj3?.GetType().GetProperty("Count");
				if (propertyInfo != null)
				{
					memberCount = Convert.ToInt32(propertyInfo.GetValue(obj3, null));
				}
				if (obj4 != null)
				{
					maxPlayers = Convert.ToInt32(obj4);
				}
				return memberCount.HasValue || maxPlayers.HasValue;
			}
			catch (Exception ex)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)("Reconnect Guard could not read visible lobby counts: " + ex.GetType().Name + ": " + ex.Message));
				}
				return false;
			}
		}

		private static bool TryGetSteamLobbyCounts(CSteamID? lobbyId, out int? memberCount, out int? maxPlayers)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			memberCount = null;
			maxPlayers = null;
			try
			{
				if (!lobbyId.HasValue || (ulong)lobbyId.Value == 0L)
				{
					return false;
				}
				int numLobbyMembers = SteamMatchmaking.GetNumLobbyMembers(lobbyId.Value);
				int lobbyMemberLimit = SteamMatchmaking.GetLobbyMemberLimit(lobbyId.Value);
				if (numLobbyMembers > 0)
				{
					memberCount = numLobbyMembers;
				}
				if (lobbyMemberLimit > 0)
				{
					maxPlayers = lobbyMemberLimit;
				}
				return memberCount.HasValue || maxPlayers.HasValue;
			}
			catch (Exception ex)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)("Host Health could not read Steam lobby count/limit: " + ex.GetType().Name + ": " + ex.Message));
				}
				return false;
			}
		}

		private static bool TryGetLobbySurfaceMetadata(CSteamID? lobbyId, out string title, out string tags, out string visibility)
		{
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			title = "?";
			tags = "?";
			visibility = "?";
			bool flag = false;
			try
			{
				MultiplayerManager i = MonoSingleton<MultiplayerManager>.I;
				object obj = AccessTools.Field(typeof(MultiplayerManager), "_lobbyManager")?.GetValue(i);
				object obj2 = obj?.GetType().GetProperty("CurrentLobby")?.GetValue(obj, null);
				if (obj2 != null)
				{
					if (TryReadStringProperty(obj2, out var value, "Name", "Title", "LobbyName", "SessionName"))
					{
						title = value;
						flag = true;
					}
					if (TryReadStringProperty(obj2, out var value2, "Tags", "TagString", "SearchTags"))
					{
						tags = value2;
						flag = true;
					}
					bool value4;
					if (TryReadStringProperty(obj2, out var value3, "Visibility", "LobbyType", "Type"))
					{
						visibility = value3;
						flag = true;
					}
					else if (TryReadBoolProperty(obj2, out value4, "IsPublic", "Public"))
					{
						visibility = (value4 ? "public" : "private");
						flag = true;
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)("Host Health could not read reflected lobby surface metadata: " + ex.GetType().Name + ": " + ex.Message));
				}
			}
			if (lobbyId.HasValue && (ulong)lobbyId.Value != 0L)
			{
				title = FirstUseful(title, ReadLobbyData(lobbyId.Value, "name", "title", "lobby_name", "session_name"));
				tags = FirstUseful(tags, ReadLobbyData(lobbyId.Value, "tags", "tag", "search_tags", "description"));
				visibility = FirstUseful(visibility, ReadLobbyData(lobbyId.Value, "visibility", "public", "lobby_type", "type"));
				flag = flag || title != "?" || tags != "?" || visibility != "?";
			}
			return flag;
		}

		private static string ReadLobbyData(CSteamID lobbyId, params string[] keys)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			foreach (string text in keys)
			{
				try
				{
					string lobbyData = SteamMatchmaking.GetLobbyData(lobbyId, text);
					if (!string.IsNullOrWhiteSpace(lobbyData))
					{
						return lobbyData;
					}
				}
				catch
				{
				}
			}
			return "?";
		}

		private static bool TryReadStringProperty(object target, out string value, params string[] names)
		{
			value = string.Empty;
			foreach (string name in names)
			{
				object obj = target.GetType().GetProperty(name)?.GetValue(target, null);
				if (obj != null && !string.IsNullOrWhiteSpace(obj.ToString()))
				{
					value = obj.ToString();
					return true;
				}
			}
			return false;
		}

		private static bool TryReadBoolProperty(object target, out bool value, params string[] names)
		{
			value = false;
			foreach (string name in names)
			{
				object obj = target.GetType().GetProperty(name)?.GetValue(target, null);
				if (obj is bool flag)
				{
					value = flag;
					return true;
				}
				if (obj != null && bool.TryParse(obj.ToString(), out var result))
				{
					value = result;
					return true;
				}
			}
			return false;
		}

		private static string FirstUseful(string current, string candidate)
		{
			if (!(current == "?") || string.IsNullOrWhiteSpace(candidate) || !(candidate != "?"))
			{
				return current;
			}
			return candidate;
		}

		private static string SanitizeDiagnosticValue(string value)
		{
			if (string.IsNullOrWhiteSpace(value))
			{
				return "?";
			}
			return value.Replace("\r", " ").Replace("\n", " ").Replace(";", ",")
				.Trim();
		}
	}
	internal static class PluginShutdownController
	{
		private static readonly PluginShutdownPolicy Policy = new PluginShutdownPolicy();

		internal static bool IsShuttingDown => Policy.IsShuttingDown;

		internal static void Begin(string trigger, Action<SteamRuntimeSnapshot> steamCleanup, Action localCleanup)
		{
			if (!Policy.TryBegin(trigger))
			{
				return;
			}
			SteamRuntimeSnapshot obj = SteamRuntimeFacade.SnapshotForShutdown();
			if (Policy.TryClaimSteamCleanup())
			{
				try
				{
					steamCleanup?.Invoke(obj);
				}
				finally
				{
					Policy.FinishSteamCleanup();
				}
			}
			if (!Policy.TryClaimLocalCleanup())
			{
				return;
			}
			try
			{
				localCleanup?.Invoke();
			}
			finally
			{
				Policy.FinishLocalCleanup();
			}
		}
	}
	internal sealed class QolMenuWindow : MonoBehaviour
	{
		private sealed class ThanksCard
		{
			internal string Name { get; }

			internal string Received { get; }

			internal IReadOnlyList<string> Messages { get; }

			internal ThanksCard(string name, string received, params string[] messages)
			{
				Name = name;
				Received = received;
				Messages = messages ?? Array.Empty<string>();
			}
		}

		private enum FeatureSectionTone
		{
			Comfort,
			Chat,
			Identity,
			Personalization,
			Experimental
		}

		private const float MinWindowWidth = 920f;

		private const float MinWindowHeight = 640f;

		private const float ResizeGripSize = 42f;

		private const float FooterHeight = 120f;

		private const float ContentChromeHeight = 272f;

		private const float ContentHorizontalChrome = 96f;

		private const string DoNotPressEggKey = "menu_do_not_press";

		private static readonly ThanksCard[] CommunityCrewCards = new ThanksCard[2]
		{
			new ThanksCard("bloo_bamboo", "Quality \"the sacrifice\" Tester", "Large-lobby QA, crash logs, and patient reconnect testing when things go sideways."),
			new ThanksCard("Rowan", "Partner in Crime ♥", "BlueSage's trusted co-conspirator for testing, experiments, and keeping Blue honest.")
		};

		private static readonly SupporterIdentityRollup[] SupporterRollups = SupporterLedgerPolicy.RollUp(SupporterLedgerData.Transactions);

		private Rect _windowRect = new Rect(120f, 95f, 960f, 720f);

		private bool _visible;

		private bool _hasOpened;

		private int _tab;

		private string _message = "Manage BlueSage QoL features without memorizing slash commands.";

		private string _sweepIntervalText = string.Empty;

		private string _pingHighlightText = string.Empty;

		private string _pingMentionText = string.Empty;

		private string _pingSoundModeText = string.Empty;

		private string _chatOutlineIntensityText = string.Empty;

		private string _chatUiScaleText = string.Empty;

		private string _chatFontSizeText = string.Empty;

		private string _chatWindowHeightText = string.Empty;

		private string _chatHistoryRowsText = string.Empty;

		private string _chatOutlineColorText = string.Empty;

		private string _blackChatOutlineColorText = string.Empty;

		private string _playerRenderSaverRadiusText = string.Empty;

		private string _playerRenderSaverMaxVisibleText = string.Empty;

		private string _chatLimitText = string.Empty;

		private string _profileLimitText = string.Empty;

		private string _sessionLimitText = string.Empty;

		private string _selfSpeedText = string.Empty;

		private string _selfJumpText = string.Empty;

		private string _selfGravityText = string.Empty;

		private int _safetyRosterPage;

		private string _selectedSafetySteamId = string.Empty;

		private string _safetyRosterQuery = string.Empty;

		private int _nativeBanPage;

		private string _selectedBannedSteamId = string.Empty;

		private string _offlineBanSteamIdText = string.Empty;

		private bool _showClosedIncidentHistory;

		private int _selectedSupporterIndex;

		private Vector2 _contentScroll;

		private GUIStyle _windowStyle;

		private GUIStyle _headerBoxStyle;

		private GUIStyle _headerStyle;

		private GUIStyle _labelStyle;

		private GUIStyle _smallStyle;

		private GUIStyle _buttonStyle;

		private GUIStyle _activeButtonStyle;

		private GUIStyle _enabledButtonStyle;

		private GUIStyle _disabledButtonStyle;

		private GUIStyle _experimentalButtonStyle;

		private GUIStyle _boxStyle;

		private GUIStyle _sectionBoxStyle;

		private GUIStyle _comfortSectionBoxStyle;

		private GUIStyle _chatSectionBoxStyle;

		private GUIStyle _identitySectionBoxStyle;

		private GUIStyle _personalizationSectionBoxStyle;

		private GUIStyle _experimentalBoxStyle;

		private GUIStyle _sectionHeaderStyle;

		private GUIStyle _navigationHintStyle;

		private GUIStyle _footerBoxStyle;

		private GUIStyle _footerTextStyle;

		private GUIStyle _textFieldStyle;

		private Texture2D _windowBackgroundTexture;

		private bool _isResizing;

		private string _renderedThemeKey = string.Empty;

		private int _renderedTextureGeneration;

		private BlueSageUiThemePalette _theme;

		private string _stateLabel = "Saved";

		private string _stateDetail = "Loaded saved menu values.";

		private readonly StatisticsPulseReader _statisticsPulseReader = new StatisticsPulseReader();

		private StatisticsPulseSnapshot _statisticsPulse;

		private string _statisticsPulseUnavailableReason = "Native statistics have not been read yet.";

		private string _statisticsPulseNote = "Achievements are counted only when you press Refresh.";

		private readonly Dictionary<string, string> _settingUndoValues = new Dictionary<string, string>(StringComparer.Ordinal);

		public void ToggleVisible()
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			_visible = !_visible;
			BlueSageWindowCoordinator.SetVisible(BlueSagePublicWindow.QolMenu, _visible);
			if (!_visible)
			{
				BlueSageWindowHoverScope.UnregisterWindow(47058);
			}
			if (_visible)
			{
				WindowFitResult windowFitResult = BlueSageWindowCoordinator.ResolveForOpen(BlueSagePublicWindow.QolMenu, _hasOpened, _windowRect, 920f, 640f, Screen.width, Screen.height);
				_windowRect = new Rect(windowFitResult.X, windowFitResult.Y, windowFitResult.Width, windowFitResult.Height);
				_hasOpened = true;
				HydrateFields();
				RefreshStatisticsPulse(includeAchievements: false);
				MarkSaved("Loaded saved menu values. Edit Customize fields to start a draft.");
			}
		}

		internal bool ShowHostConsole()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.ShouldShowLobbySafetyTab(out var state, out var _) || state != LobbySafetyAccessState.Host)
			{
				return false;
			}
			_tab = 4;
			_contentScroll = Vector2.zero;
			if (!_visible)
			{
				ToggleVisible();
			}
			return true;
		}

		private void OnGUI()
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			if (!_visible)
			{
				BlueSageWindowCoordinator.SetVisible(BlueSagePublicWindow.QolMenu, visible: false);
				return;
			}
			BlueSageWindowCoordinator.SetVisible(BlueSagePublicWindow.QolMenu, visible: true);
			EnsureStyles();
			ClampWindowToScreen();
			BlueSageWindowHoverScope.RegisterWindow(47058, _windowRect, 0);
			_windowRect = GUI.Window(47058, _windowRect, new WindowFunction(DrawWindow), string.Empty, _windowStyle);
			ClampWindowToScreen();
		}

		private void DrawWindow(int id)
		{
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			GUI.tooltip = string.Empty;
			LobbySafetyAccessState state;
			string reason;
			bool flag = Plugin.ShouldShowLobbySafetyTab(out state, out reason);
			if (_tab == 4 && !flag)
			{
				_tab = 0;
				_contentScroll = Vector2.zero;
				ClearLobbySafetyTransientState();
			}
			if ((Object)(object)_windowBackgroundTexture != (Object)null)
			{
				GUI.DrawTexture(new Rect(0f, 0f, ((Rect)(ref _windowRect)).width, ((Rect)(ref _windowRect)).height), (Texture)(object)_windowBackgroundTexture);
			}
			DrawHeader();
			GUILayout.Space(10f);
			DrawTabs();
			GUILayout.Space(8f);
			_contentScroll = GUILayout.BeginScrollView(_contentScroll, false, true, GUIStyle.none, GUI.skin.verticalScrollbar, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(GetContentScrollHeight()) });
			if (_tab == 0)
			{
				DrawMainTab();
			}
			else if (_tab == 1)
			{
				DrawTogglesTab();
			}
			else if (_tab == 2)
			{
				DrawCustomizeTab();
			}
			else if (_tab == 3)
			{
				DrawCreditsOtherTab();
			}
			else if (flag)
			{
				DrawLobbySafetyTab();
			}
			else
			{
				DrawMainTab();
			}
			GUILayout.EndScrollView();
			GUILayout.FlexibleSpace();
			DrawFooter();
			DrawResizeGrip();
			GUI.DragWindow(new Rect(0f, 0f, ((Rect)(ref _windowRect)).width - 138f, 34f));
		}

		private void DrawHeader()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Expected O, but got Unknown
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Expected O, but got Unknown
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Expected O, but got Unknown
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Expected O, but got Unknown
			GUI.Box(new Rect(0f, 0f, ((Rect)(ref _windowRect)).width, 38f), GUIContent.none, _headerBoxStyle);
			GUI.Label(new Rect(18f, 7f, ((Rect)(ref _windowRect)).width - 330f, 28f), "▣ BlueSage QoL Menu  v0.2.4", _headerStyle);
			if (GUI.Button(new Rect(((Rect)(ref _windowRect)).width - 308f, 5f, 108f, 28f), new GUIContent("Thunderstore", "Open the BlueSage QoL Tweaks Thunderstore page."), _buttonStyle))
			{
				Application.OpenURL("https://thunderstore.io/c/on-together/p/Blues/BlueSage_QoL_Tweaks_Beta/");
			}
			if (GUI.Button(new Rect(((Rect)(ref _windowRect)).width - 192f, 5f, 58f, 28f), new GUIContent("Ko-fi", "Support Blue's community modding work on Ko-fi."), _buttonStyle))
			{
				Application.OpenURL("https://ko-fi.com/Q5Q1JRPW");
			}
			if (GUI.Button(new Rect(((Rect)(ref _windowRect)).width - 126f, 5f, 76f, 28f), new GUIContent("Discord", "Open Blue's On-Together community Discord."), _buttonStyle))
			{
				Application.OpenURL("https://discord.gg/JujMEwtN3q");
			}
			if (GUI.Button(new Rect(((Rect)(ref _windowRect)).width - 42f, 5f, 30f, 28f), new GUIContent("X", "Close this window"), _activeButtonStyle))
			{
				_visible = false;
				BlueSageWindowCoordinator.SetVisible(BlueSagePublicWindow.QolMenu, visible: false);
				BlueSageWindowHoverScope.UnregisterWindow(47058);
			}
		}

		private float GetContentScrollHeight()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return Mathf.Max(24f, BlueSageHelpFrame.Resolve(BlueSageHelpFrameKind.QolMenu, _windowRect).ContentHeight);
		}

		private float GetContentLayoutWidth()
		{
			return Mathf.Max(280f, ((Rect)(ref _windowRect)).width - 96f);
		}

		private void DrawTabs()
		{
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.FlexibleSpace();
			GUILayout.Label("v0.2.4  •  Updated 2026-07-30", _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.EndHorizontal();
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			DrawTabButton(0, "Main", "Fast actions, how-to examples, current feature status, and the quickest path to Style Helper.");
			DrawTabButton(1, "Toggles", "Turn major QoL features on/off with one normal On/Off button per row.");
			DrawTabButton(2, "Customize", "Edit movement, ping, sweep, and text-limit settings. Names, status, and Spoons live in Style Helper.");
			DrawTabButton(3, "Credits / Other", "Themes, credits, community notes, and one optional lobby joke.");
			if (Plugin.ShouldShowLobbySafetyTab(out var state, out var _))
			{
				bool flag = state == LobbySafetyAccessState.Host;
				bool flag2 = state == LobbySafetyAccessState.Host || state == LobbySafetyAccessState.HelperReady;
				DrawTabButton(4, flag ? "Host Console" : "Safety", (state == LobbySafetyAccessState.Host) ? "Host-only Helper management plus verified identities, Clone Shield evidence, and careful moderation actions." : (flag2 ? "Assigned Helper access: verified identities, Clone Shield evidence, and host-validated actions." : "Helper assignment detected. Protected details stay locked until the host publishes a fresh compatible 0.2.0 Helper capability."));
			}
			GUILayout.EndHorizontal();
		}

		private void DrawTabButton(int index, string label, string tooltip)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			bool flag = _tab == index;
			if (GUILayout.Button(new GUIContent(label, tooltip), flag ? _activeButtonStyle : _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(34f) }))
			{
				_tab = index;
				_contentScroll = Vector2.zero;
			}
		}

		private void DrawMainTab()
		{
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Expected O, but got Unknown
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Expected O, but got Unknown
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Expected O, but got Unknown
			GUILayout.BeginVertical(_boxStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandHeight(false) });
			GUILayout.Label("Welcome to BlueSage QoL", _sectionHeaderStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label("Comfort, clarity, personalization, and safer community tools—each one can be adjusted without memorizing commands.", _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Space(8f);
			GUILayout.Label("Quick actions", _labelStyle, Array.Empty<GUILayoutOption>());
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			float num = Mathf.Max(150f, (((Rect)(ref _windowRect)).width - 108f) / 3f);
			SweepMenuActionState sweepMenuActionState = SweepMenuActionPolicy.Resolve(Plugin.ManualSweepAllowed);
			bool enabled = GUI.enabled;
			GUI.enabled = enabled && sweepMenuActionState.Enabled;
			bool num2 = GUILayout.Button(new GUIContent(sweepMenuActionState.Label, sweepMenuActionState.Tooltip), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(num),
				GUILayout.Height(34f)
			});
			GUI.enabled = enabled;
			if (num2)
			{
				_message = (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.RunManualSweepFromQolMenu() : "Plugin is not ready.");
				MarkAction("Run Cleanup Now requested.");
			}
			if (GUILayout.Button(new GUIContent("Run QoL Status", "Shows the same easy feature summary as /qol status so players can quickly see what is on or off."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(num),
				GUILayout.Height(34f)
			}))
			{
				if ((Object)(object)Plugin.Instance != (Object)null)
				{
					_message = Plugin.Instance.RunQolStatusFromQolMenu();
				}
				else
				{
					_message = "Plugin is not ready.";
				}
				MarkAction(_message);
			}
			bool isStyleHelperVisible = Plugin.IsStyleHelperVisible;
			if (GUILayout.Button(new GUIContent(isStyleHelperVisible ? "Close Style Helper" : "Open Style Helper", "Open or close Style Helper for name styling, status tags, templates, and Spoons."), isStyleHelperVisible ? _enabledButtonStyle : _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(num),
				GUILayout.Height(34f)
			}))
			{
				_message = (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.ToggleStyleUiFromQolMenu() : "Plugin is not ready.");
				MarkAction("Style Helper toggled.");
			}
			GUILayout.EndHorizontal();
			GUILayout.Space(10f);
			DrawMainStatusStrip();
			DrawFocusPulse();
			DrawLobbySafetyAccessBanner();
			GUILayout.Space(12f);
			GUILayout.Label("Getting started", _labelStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label(NavigationCalloutPolicy.BuildMenuNavigationHint(_theme.NavigationKeywordHex), _navigationHintStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label("Use /styleui for name, status, and Spoons identity edits. Name Styler changes your visible name style; Status Styler changes only the activity tag and optional Spoons tag.", _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label("Chat actions: plain left-click keeps the vanilla ID card. Ctrl-left-click copies message text. Shift-left-click a safe http/https link once to copy and warn, then repeat to open.", _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label("Quick checks: /qol status or Run QoL Status shows enabled features. Type / in chat to browse commands with autocomplete.", _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label("When something feels noisy: open Toggles and turn off only that feature. Use Customize for ping colors, ping sound, sweep timing, and text limits.", _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Space(12f);
			DrawCommunityThanks();
			GUILayout.EndVertical();
		}

		private void DrawMainStatusStrip()
		{
			float contentLayoutWidth = GetContentLayoutWidth();
			bool num = ((Rect)(ref _windowRect)).width < 1040f;
			float width = (num ? ((contentLayoutWidth - 8f) / 2f) : ((contentLayoutWidth - 24f) / 4f));
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			ConfigEntry<bool> enableChatReadability = Plugin.EnableChatReadability;
			DrawStatusCard("Comfort", (enableChatReadability != null && enableChatReadability.Value) ? "Ready" : "Adjusted", "Chat, movement, and notices", width);
			GUILayout.Space(8f);
			ConfigEntry<bool> enableStyleUi = Plugin.EnableStyleUi;
			DrawStatusCard("Styling", (enableStyleUi != null && enableStyleUi.Value) ? "Ready" : "Off", "Names, status, Spoons, templates", width);
			if (!num)
			{
				GUILayout.Space(8f);
				ConfigEntry<bool> enableReconnectGuard = Plugin.EnableReconnectGuard;
				DrawStatusCard("Reconnect Guard", (enableReconnectGuard != null && enableReconnectGuard.Value) ? "Ready" : "Off", "Saved-lobby recovery protection", width);
				GUILayout.Space(8f);
				ConfigEntry<bool> enablePlayerRenderSaver = Plugin.EnablePlayerRenderSaver;
				DrawStatusCard("Experimental", (enablePlayerRenderSaver != null && enablePlayerRenderSaver.Value) ? "On" : "Off", "Player Render Saver only", width, experimental: true);
			}
			GUILayout.EndHorizontal();
			if (num)
			{
				GUILayout.Space(8f);
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				ConfigEntry<bool> enableReconnectGuard2 = Plugin.EnableReconnectGuard;
				DrawStatusCard("Reconnect Guard", (enableReconnectGuard2 != null && enableReconnectGuard2.Value) ? "Ready" : "Off", "Saved-lobby recovery protection", width);
				GUILayout.Space(8f);
				ConfigEntry<bool> enablePlayerRenderSaver2 = Plugin.EnablePlayerRenderSaver;
				DrawStatusCard("Experimental", (enablePlayerRenderSaver2 != null && enablePlayerRenderSaver2.Value) ? "On" : "Off", "Player Render Saver only", width, experimental: true);
				GUILayout.EndHorizontal();
			}
		}

		private void DrawStatusCard(string title, string state, string detail, float width, bool experimental = false)
		{
			GUILayout.BeginVertical(experimental ? _experimentalBoxStyle : _sectionBoxStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(width),
				GUILayout.Height(86f)
			});
			GUILayout.Label(title + "  •  " + state, _labelStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label(detail, _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.EndVertical();
		}

		private void DrawFocusPulse()
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Expected O, but got Unknown
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Expected O, but got Unknown
			GUILayout.Space(8f);
			GUILayout.BeginVertical(_identitySectionBoxStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label("Focus Pulse", _sectionHeaderStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
			if (GUILayout.Button(new GUIContent("Refresh", "Refresh these read-only values and count unlocked achievements once."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(112f),
				GUILayout.Height(30f)
			}))
			{
				RefreshStatisticsPulse(includeAchievements: true);
				_message = ((_statisticsPulse != null) ? "Focus Pulse refreshed from the native statistics data." : "Focus Pulse is unavailable on this game build.");
				MarkAction(_message);
			}
			GUILayout.EndHorizontal();
			if (_statisticsPulse == null)
			{
				GUILayout.Label("Native statistics unavailable. " + _statisticsPulseUnavailableReason, _smallStyle, Array.Empty<GUILayoutOption>());
				GUILayout.Label(new GUIContent("Full Report - Open with ESC", "The full achievement gallery remains in the native Report. Focus Pulse never opens or changes it."), _smallStyle, Array.Empty<GUILayoutOption>());
				GUILayout.EndVertical();
				return;
			}
			float contentLayoutWidth = GetContentLayoutWidth();
			float width = Mathf.Max(140f, (contentLayoutWidth - 24f) / 4f);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			DrawFocusPulseMetric("Total focus", _statisticsPulse.TotalFocusLabel, width);
			GUILayout.Space(8f);
			DrawFocusPulseMetric("Today's sessions", _statisticsPulse.TodaySessions.ToString(), width);
			GUILayout.Space(8f);
			DrawFocusPulseMetric("Current streak", StatisticsPulsePresentationPolicy.BuildStreakValue(_statisticsPulse.CurrentStreak, _statisticsPulse.LongestStreak), width);
			GUILayout.Space(8f);
			DrawFocusPulseMetric("Task checks recorded", _statisticsPulse.TaskChecks.ToString(), width);
			GUILayout.EndHorizontal();
			GUILayout.Space(8f);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			DrawFocusPulseMetric("Achievements unlocked", _statisticsPulse.AchievementsLabel, width);
			GUILayout.Space(8f);
			GUILayout.BeginVertical(_sectionBoxStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.ExpandWidth(true),
				GUILayout.Height(64f)
			});
			GUILayout.Label(new GUIContent("Full Report - Open with ESC", "The full achievement gallery remains in the native Report. Focus Pulse never opens or changes it."), _labelStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label("Focus Pulse reads the game's saved totals without opening or changing the Report. " + _statisticsPulseNote, _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.EndVertical();
			GUILayout.EndHorizontal();
			GUILayout.EndVertical();
		}

		private void DrawFocusPulseMetric(string title, string value, float width)
		{
			GUILayout.BeginVertical(_sectionBoxStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(width),
				GUILayout.Height(64f)
			});
			GUILayout.Label(title, _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label(value, _labelStyle, Array.Empty<GUILayoutOption>());
			GUILayout.EndVertical();
		}

		private void RefreshStatisticsPulse(bool includeAchievements)
		{
			if (!_statisticsPulseReader.TryCapturePulse(out var snapshot, out var unavailableReason))
			{
				_statisticsPulse = null;
				_statisticsPulseUnavailableReason = (string.IsNullOrWhiteSpace(unavailableReason) ? "This game build does not expose the expected read-only surface." : unavailableReason);
				_statisticsPulseNote = "The rest of the QoL menu remains available.";
				return;
			}
			_statisticsPulseUnavailableReason = string.Empty;
			_statisticsPulseNote = "Achievements are counted only when you press Refresh.";
			string unavailableReason2 = string.Empty;
			if (includeAchievements && _statisticsPulseReader.TryCountAchievements(out var unlocked, out var total, out unavailableReason2))
			{
				snapshot = snapshot.WithAchievementProgress(unlocked, total);
				_statisticsPulseNote = "Achievement progress refreshed once from the native gallery.";
			}
			else if (includeAchievements)
			{
				_statisticsPulseNote = (string.IsNullOrWhiteSpace(unavailableReason2) ? "Achievement progress is unavailable on this game build." : unavailableReason2);
			}
			_statisticsPulse = snapshot;
		}

		private void DrawLobbySafetyAccessBanner()
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Expected O, but got Unknown
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.ShouldShowLobbySafetyTab(out var state, out var _))
			{
				bool flag = state == LobbySafetyAccessState.Host || state == LobbySafetyAccessState.HelperReady;
				object obj = state switch
				{
					LobbySafetyAccessState.Host => "HOST  •  Helper management and Lobby Safety ready", 
					LobbySafetyAccessState.HelperReady => "HELPER  •  Lobby Safety ready", 
					_ => "HELPER DETECTED  •  Waiting for compatible host capability", 
				};
				GUILayout.Space(8f);
				GUILayout.BeginHorizontal(_identitySectionBoxStyle, Array.Empty<GUILayoutOption>());
				GUILayout.Label((string)obj, _smallStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
				if (GUILayout.Button(new GUIContent("Open Helper / Safety", flag ? "Open authorized Helper and Lobby Safety tools." : "Open the access status. Protected player details and actions remain locked until the host publishes a fresh compatible v3 member-data capability."), flag ? _enabledButtonStyle : _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUILayout.Width(210f),
					GUILayout.Height(30f)
				}))
				{
					_tab = 4;
					_contentScroll = Vector2.zero;
					_message = (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.CheckModerationAccessFromQolMenu() : "Helper / Safety is not ready yet.");
					MarkAction(_message);
				}
				GUILayout.EndHorizontal();
			}
		}

		private void DrawCommunityThanks()
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			GUILayout.BeginVertical(_identitySectionBoxStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
			GUILayout.Label("♥ COMMUNITY SUPPORTERS ♥", _sectionHeaderStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label("15 community supporters shared 16 public thank-you messages. Their thank-you wall lives in Credits / Other.", _smallStyle, Array.Empty<GUILayoutOption>());
			if (GUILayout.Button(new GUIContent("Open Community Supporters in Credits / Other", "Open the community thank-you wall. Supporter totals and public messages are shown; account and payment identifiers are never included."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(34f) }))
			{
				OpenCommunitySupporters();
			}
			GUILayout.EndVertical();
		}

		private void OpenCommunitySupporters()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			_tab = 3;
			_contentScroll = Vector2.zero;
			_message = "Community Supporters opened in Credits / Other.";
			MarkAction(_message);
		}

		private void DrawSupporterCredits()
		{
			GUILayout.Label("15 community supporters • 16 public thank-you messages", _labelStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label("Choose a supporter to read their public messages. Only each person's combined support is shown; account and payment identifiers are excluded.", _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Space(8f);
			DrawSupporterDirectory();
			GUILayout.Space(10f);
			DrawSelectedSupporterMessages();
		}

		private void DrawSupporterDirectory()
		{
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Expected O, but got Unknown
			float contentLayoutWidth = GetContentLayoutWidth();
			int thanksGridColumnCount = GetThanksGridColumnCount(contentLayoutWidth);
			float num = (float)(thanksGridColumnCount - 1) * 8f;
			float num2 = Mathf.Max(180f, (contentLayoutWidth - num) / (float)thanksGridColumnCount);
			for (int i = 0; i < SupporterRollups.Length; i += thanksGridColumnCount)
			{
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				int num3 = Math.Min(SupporterRollups.Length, i + thanksGridColumnCount);
				for (int j = i; j < num3; j++)
				{
					SupporterIdentityRollup supporterIdentityRollup = SupporterRollups[j];
					bool flag = j == _selectedSupporterIndex;
					if (GUILayout.Button(new GUIContent(SupporterLedgerPolicy.SanitizeForDisplay(supporterIdentityRollup.Name) + " ♥ " + SupporterLedgerPolicy.FormatReceived(supporterIdentityRollup.TotalReceived), flag ? "Close this supporter's thank-you messages." : "Read this supporter's public thank-you messages."), flag ? _activeButtonStyle : _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
					{
						GUILayout.Width(num2),
						GUILayout.Height(34f)
					}))
					{
						SelectSupporterInCredits(j);
					}
					if (j + 1 < num3)
					{
						GUILayout.Space(8f);
					}
				}
				GUILayout.FlexibleSpace();
				GUILayout.EndHorizontal();
				if (num3 < SupporterRollups.Length)
				{
					GUILayout.Space(6f);
				}
			}
		}

		private void SelectSupporterInCredits(int index)
		{
			if (index >= 0 && index < SupporterRollups.Length)
			{
				_selectedSupporterIndex = ((_selectedSupporterIndex == index) ? (-1) : index);
				_tab = 3;
				_message = ((_selectedSupporterIndex < 0) ? "Community supporter details closed." : ("Community supporter selected: " + SupporterRollups[index].Name + "."));
				MarkAction(_message);
			}
		}

		private void DrawSelectedSupporterMessages()
		{
			if (_selectedSupporterIndex < 0 || _selectedSupporterIndex >= SupporterRollups.Length)
			{
				return;
			}
			SupporterIdentityRollup supporterIdentityRollup = SupporterRollups[_selectedSupporterIndex];
			SupporterTransaction[] publicMessages = SupporterLedgerPolicy.GetPublicMessages(supporterIdentityRollup);
			GUILayout.BeginVertical(_identitySectionBoxStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
			GUILayout.Label(SupporterLedgerPolicy.SanitizeForDisplay(supporterIdentityRollup.Name) + " ♥ " + SupporterLedgerPolicy.FormatReceived(supporterIdentityRollup.TotalReceived) + " total", _sectionHeaderStyle, Array.Empty<GUILayoutOption>());
			if (publicMessages.Length == 0)
			{
				GUILayout.Label("Supported with love and chose not to leave a public message.", _smallStyle, Array.Empty<GUILayoutOption>());
			}
			GUILayout.EndVertical();
			for (int i = 0; i < publicMessages.Length; i++)
			{
				SupporterTransaction supporterTransaction = publicMessages[i];
				GUILayout.Space(6f);
				GUILayout.BeginVertical(_sectionBoxStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
				GUILayout.Label("♥ " + SupporterLedgerPolicy.FormatDateLabel(supporterTransaction.DateTimeUtc), _labelStyle, Array.Empty<GUILayoutOption>());
				GUILayout.Label(SupporterLedgerPolicy.SanitizeForDisplay(supporterTransaction.Message), _smallStyle, Array.Empty<GUILayoutOption>());
				GUILayout.EndVertical();
				if (i + 1 < publicMessages.Length)
				{
					GUILayout.Space(6f);
				}
			}
		}

		private void DrawCommunityCrew()
		{
			DrawThanksCardGrid(CommunityCrewCards);
		}

		private void DrawThanksCardGrid(IReadOnlyList<ThanksCard> cards)
		{
			float contentLayoutWidth = GetContentLayoutWidth();
			int thanksGridColumnCount = GetThanksGridColumnCount(contentLayoutWidth);
			float num = (float)(thanksGridColumnCount - 1) * 8f;
			float cardWidth = Mathf.Max(220f, (contentLayoutWidth - num) / (float)thanksGridColumnCount);
			for (int i = 0; i < cards.Count; i += thanksGridColumnCount)
			{
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				int num2 = Math.Min(cards.Count, i + thanksGridColumnCount);
				for (int j = i; j < num2; j++)
				{
					ThanksCard thanksCard = cards[j];
					DrawThanksCard(thanksCard.Name, thanksCard.Received, thanksCard.Messages, cardWidth);
					if (j + 1 < num2)
					{
						GUILayout.Space(8f);
					}
				}
				GUILayout.FlexibleSpace();
				GUILayout.EndHorizontal();
				if (num2 < cards.Count)
				{
					GUILayout.Space(8f);
				}
			}
		}

		private static int GetThanksGridColumnCount(float availableWidth)
		{
			if (availableWidth >= 1400f)
			{
				return 4;
			}
			if (availableWidth >= 1020f)
			{
				return 3;
			}
			if (availableWidth >= 680f)
			{
				return 2;
			}
			return 1;
		}

		private void DrawThanksCard(string name, string received, IReadOnlyList<string> messages, float cardWidth)
		{
			GUILayout.BeginVertical(_boxStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(cardWidth),
				GUILayout.MinHeight(118f)
			});
			GUILayout.Label(name, _labelStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label(received, _smallStyle, Array.Empty<GUILayoutOption>());
			foreach (string message in messages)
			{
				if (!string.IsNullOrWhiteSpace(message))
				{
					GUILayout.Label(message, _smallStyle, Array.Empty<GUILayoutOption>());
				}
			}
			GUILayout.EndVertical();
		}

		private void DrawTogglesTab()
		{
			GUILayout.BeginVertical(_boxStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandHeight(false) });
			GUILayout.Label("Click a feature's On/Off button, then read the footer for what changed. Your saved choices remain yours.", _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Space(8f);
			int num = ((((Rect)(ref _windowRect)).width >= 1320f) ? 3 : ((!(((Rect)(ref _windowRect)).width >= 880f)) ? 1 : 2));
			float contentLayoutWidth = GetContentLayoutWidth();
			float width = (contentLayoutWidth - 12f * (float)(num - 1)) / (float)num;
			if (num == 1)
			{
				DrawFeatureSection("Comfort & Movement", "Reduce friction and stay informed while you move.", DrawComfortMovementToggles, contentLayoutWidth, FeatureSectionTone.Comfort);
				GUILayout.Space(12f);
				DrawFeatureSection("Chat & Readability", "Improve chat clarity, context, and everyday usability.", DrawChatReadabilityToggles, contentLayoutWidth, FeatureSectionTone.Chat);
				GUILayout.Space(12f);
				DrawFeatureSection("Identity & Safety", "Protect identity and reduce reconnect friction.", DrawIdentitySafetyToggles, contentLayoutWidth, FeatureSectionTone.Identity);
				GUILayout.Space(12f);
				DrawFeatureSection("Personalization", "Customize how your BlueSage experience looks and feels.", DrawPersonalizationToggles, contentLayoutWidth, FeatureSectionTone.Personalization);
				GUILayout.Space(12f);
				DrawFeatureSection("Experimental (Opt-In)", "Unproven local-only tools stay separate and default off.", DrawExperimentalToggles, contentLayoutWidth, FeatureSectionTone.Experimental);
			}
			else
			{
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				DrawFeatureSection("Comfort & Movement", "Reduce friction and stay informed while you move.", DrawComfortMovementToggles, width, FeatureSectionTone.Comfort);
				GUILayout.Space(12f);
				DrawFeatureSection("Chat & Readability", "Improve chat clarity, context, and everyday usability.", DrawChatReadabilityToggles, width, FeatureSectionTone.Chat);
				if (num == 3)
				{
					GUILayout.Space(12f);
					DrawFeatureSection("Identity & Safety", "Protect identity and reduce reconnect friction.", DrawIdentitySafetyToggles, width, FeatureSectionTone.Identity);
				}
				GUILayout.EndHorizontal();
				GUILayout.Space(12f);
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				if (num == 2)
				{
					DrawFeatureSection("Identity & Safety", "Protect identity and reduce reconnect friction.", DrawIdentitySafetyToggles, width, FeatureSectionTone.Identity);
					GUILayout.Space(12f);
					DrawFeatureSection("Personalization", "Customize how your BlueSage experience looks and feels.", DrawPersonalizationToggles, width, FeatureSectionTone.Personalization);
				}
				else
				{
					float width2 = (contentLayoutWidth - 12f) / 2f;
					DrawFeatureSection("Personalization", "Customize how your BlueSage experience looks and feels.", DrawPersonalizationToggles, width2, FeatureSectionTone.Personalization);
					GUILayout.Space(12f);
					DrawFeatureSection("Experimental (Opt-In)", "Unproven local-only tools stay separate and default off.", DrawExperimentalToggles, width2, FeatureSectionTone.Experimental);
				}
				GUILayout.EndHorizontal();
				if (num == 2)
				{
					GUILayout.Space(12f);
					DrawFeatureSection("Experimental (Opt-In)", "Unproven local-only tools stay separate and default off.", DrawExperimentalToggles, contentLayoutWidth, FeatureSectionTone.Experimental);
				}
			}
			GUILayout.EndVertical();
		}

		private void DrawComfortMovementToggles()
		{
			DrawToggle("Automatic Cleanup", Plugin.EnableAutoSweep, "On for fresh installs at a user-controlled 10-minute interval; an existing saved Off choice stays Off. BlueSage coordinates its unused-asset cleanup with the game's native sweep. Run Cleanup Now, F8, and /sweep now remain independent; the game's timer is unchanged.", delegate
			{
				Plugin.Instance?.RunSweepRestartFromMenu();
			});
			DrawToggle("Host Health", Plugin.EnableHostHealthMonitor, "Background lobby-health checks for long sessions. Most useful for hosts; quiet/local unless a health action has something to report.", delegate
			{
				Plugin.Instance?.RestartHostHealthFromMenu();
			});
			DrawToggle("Leave Notices", Plugin.EnableLeaveNotifications, "Shows you a local notice when someone leaves. Other players do not see it, and overlapping chat mods can make BlueSage back off.");
			DrawToggle("Welcome Message", Plugin.EnableWelcomeMessage, "Shows two local tips once per lobby: Home/Insert navigation, commands/audit/profile checks, your saved Push to Talk or Voice Activation setting, and the game's Pomodoro/focus ticket + XP reminder. Never posts globally.");
			DrawToggle("BetterMove", Plugin.EnableBetterMove, "Local movement helper: hold Shift to run and Ctrl to slow-walk. It only affects your character input.");
			DrawToggle("Reusable Consumables", Plugin.EnableUnlimitedConsumables, "Once you own a canteen item or chalk color, using it no longer lowers the count, so you do not keep spending tickets to replace it. Clothing, bait, rods, and bobbers stay vanilla. Turn Off to restore normal item use immediately.");
			DrawToggle("Focus Anywhere", Plugin.EnableFocusAnywhere, "Lets focus mode start from more places instead of only vanilla focus spots.");
		}

		private void DrawChatReadabilityToggles()
		{
			DrawToggle("Chat + notice timestamps", Plugin.EnableChatTimestamps, "Adds local timestamps to chat plus join/leave/system notices. Use this if you like knowing when messages happened.", delegate
			{
				Plugin.EnableNotificationTimestamps.Value = Plugin.EnableChatTimestamps.Value;
				Plugin.Instance?.SaveConfigFromQolMenu();
			});
			DrawTimestampFormatRow();
			DrawToggle("Chat Readability", Plugin.EnableChatReadability, "Adds local outline/shadow to chat text so white or colored messages stay readable on bright maps. Does not change chat for others.", ChatReadabilityPatch.RefreshVisibleChat);
			DrawToggle("Persistent Chat Backdrop", Plugin.EnablePersistentChatBackdrop, "Keeps the chat panel/backdrop easier to read when the game exposes it. Local UI only; does not rewrite messages.", ChatReadabilityPatch.RefreshVisibleChat);
			DrawToggle("Ping Mentions", Plugin.EnablePingMentions, "Highlights messages that mention your name. Authorized lobby-wide pings are handled automatically for the host and assigned Helpers.");
			DrawToggle("Ping Sound", Plugin.EnablePingSound, "Plays your selected local ping sound when a message mentions you. Change the sound in Customize.");
			DrawToggle("Copy Chat Messages", Plugin.EnableChatCopy, "Plain left-click keeps the vanilla ID card. Ctrl-left-click copies only the message text. Names, timestamps, statuses, and sender labels are left out.");
			DrawToggle("Chat Links", Plugin.EnableChatUrlLinks, "Recolors safe web links. Shift-left-click once copies/warns, then repeat within 10 seconds to open.");
			DrawToggle("Local Audit Exports", Plugin.EnableLocalAuditExports, "Keeps a bounded local rendered-chat transcript and running BepInEx log mirror for troubleshooting or incident review. Nothing uploads automatically. Use /auditlog path or snapshot when you need the files.", SessionAuditController.ReconcileEnabledState);
			DrawLocalAuditActions(showIdentityNote: false);
		}

		private void DrawIdentitySafetyToggles()
		{
			DrawToggle("Reconnect Guard", Plugin.EnableReconnectGuard, "After the game reports a real disconnect, allows up to 10 seconds for clean-menu teardown, makes one saved-lobby join, then validates a stable playable session for up to 45 seconds.");
			DrawToggle("Reconnect Message", Plugin.EnableReconnectAnnouncement, "Sends the small BlueSage reconnect success message after a guarded reconnect works.");
			DrawToggle("Enhanced Player Panel", Plugin.EnableEnhancedPlayerPanel, "Adds local @mention and ID-card buttons. Hover the game's green Steam-profile button for a verified ID check. Native report, ignore, kick, and ban buttons stay reachable.");
			DrawToggle("Clone Shield", Plugin.EnableCloneShield, "Warns the lobby once when someone newly matches your avatar/outfit or exact styled name. The message is a clue, not proof, and asks everyone to check Steam profiles before acting.");
			DrawCommunityBanControls();
			DrawToggle("MiniMap ID Click", Plugin.EnableMiniMapPlayerLabels, "Click minimap player dots to open ID cards when BlueSage can safely match the player. Floating labels stay removed for performance.");
			DrawToggle("MiniMap Friend Colors", Plugin.EnableMiniMapFriendColors, "Colors Steam friends green on your minimap. Uses cached Steam relationship data and stands down when the standalone MinimapFriends mod is installed.");
		}

		private void DrawPersonalizationToggles()
		{
			DrawSpoonsToggle();
			DrawToggle("Style UI", Plugin.EnableStyleUi, "Enables /styleui for names, status tags, Spoons, templates, and styled text.");
			DrawToggle("Performance Overlay", Plugin.EnablePerformanceOverlay, "Shows the public draggable one-line FPS/PING/RAM bar. Hosts show PING -- honestly; connected clients show active-session round-trip latency when available. The bar's × is only a shortcut—you can always restore it here.");
			DrawToggle("Avatar Presets 4-9", Plugin.EnableExtendedAvatarStyles, "Adds six reversible avatar preset slots to the vanilla dropdown. Slots 1-3 remain game-owned and are never replaced.", AvatarStyleSlotsBridge.RefreshEnabledState);
			DrawToggle("Chalkboard Recovery", Plugin.EnableChalkboardPersistence, "Keeps local recovery copies. Use /chalk boards for 0 Stage, 1 Classroom A, and 2 Classroom B. View, save, list, delete, and refresh stay on this computer. Only the Host or an authenticated Helper can request a shared load or clear; BlueSage rechecks the exact board and saves recovery first. Existing Chalky takes ownership when installed.");
		}

		private void DrawCommunityBanControls()
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Expected O, but got Unknown
			DrawToggle("Community Safety List", Plugin.EnableCommunityBanListSync, "Off by default. Any QoL client may opt in to local additive validation. Refresh validates the bounded upstream source atomically, appends only missing pairs to this client's native ban store, and preserves every existing row. It cannot kick, ban, or grant authority. Use /communitybans status|refresh|attestation for complete bounded state without identities.", delegate
			{
				Plugin.Instance?.ReconcileCommunityBanMaintenanceFromQolMenu();
			});
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (GUILayout.Button(new GUIContent("Safety List Status", "Off by default. Any QoL client may opt in to local additive validation. Refresh validates the bounded upstream source atomically, appends only missing pairs to this client's native ban store, and preserves every existing row. It cannot kick, ban, or grant authority. Use /communitybans status|refresh|attestation for complete bounded state without identities."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(28f) }))
			{
				_message = CommunityBanListController.FriendlyStatusText();
				MarkAction(_message);
			}
			if (GUILayout.Button(new GUIContent("Refresh Safety List", "Check the trusted community safety list now. Your existing local list stays unchanged unless the new copy validates completely."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(28f) }))
			{
				_message = (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.RefreshCommunityBanListFromQolMenu() : "Community BanData refresh is not ready yet.");
				MarkAction(_message);
			}
			GUILayout.EndHorizontal();
			GUILayout.Label(CommunityBanListController.FriendlyStatusText(), _smallStyle, Array.Empty<GUILayoutOption>());
		}

		private void DrawExperimentalToggles()
		{
			DrawExperimentalToggle("EXPERIMENTAL - Player Render Saver", Plugin.EnablePlayerRenderSaver, "Opt-in local-only performance test for huge lobbies. Hides far/overflow remote player renderers on your PC only; chat and the player list stay visible. Use /playersaver status to confirm actual renderer suppression.", delegate
			{
				if (!Plugin.ShouldApplyPlayerRenderSaver)
				{
					PlayerRenderSaverController.RestoreAll();
				}
			});
			GUILayout.Space(4f);
			GUILayout.Label("Local-only performance test for very large lobbies. It never hides you from other players.", _smallStyle, Array.Empty<GUILayoutOption>());
		}

		private void DrawTimestampFormatRow()
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Expected O, but got Unknown
			GUILayout.Label("Timestamp format", _labelStyle, Array.Empty<GUILayoutOption>());
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (GUILayout.Button(new GUIContent("12-hour AM/PM", "Show timestamps like 3:37 PM."), (Plugin.Use24HourTime != null && !Plugin.Use24HourTime.Value) ? _activeButtonStyle : _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.ExpandWidth(true),
				GUILayout.Height(30f)
			}))
			{
				Plugin.Use24HourTime.Value = false;
				Plugin.Instance?.SaveConfigFromQolMenu();
				_message = "Timestamps: 12-hour format with AM/PM.";
				MarkSaved(_message);
			}
			GUILayout.Space(6f);
			if (GUILayout.Button(new GUIContent("24-hour", "Show timestamps like 15:37 without AM/PM."), (Plugin.Use24HourTime != null && Plugin.Use24HourTime.Value) ? _activeButtonStyle : _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.ExpandWidth(true),
				GUILayout.Height(30f)
			}))
			{
				Plugin.Use24HourTime.Value = true;
				Plugin.Instance?.SaveConfigFromQolMenu();
				_message = "Timestamps: 24-hour format.";
				MarkSaved(_message);
			}
			GUILayout.EndHorizontal();
		}

		private void DrawFeatureSection(string title, string description, Action drawContent, float width, FeatureSectionTone tone)
		{
			GUILayout.BeginVertical(GetFeatureSectionStyle(tone), (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(width),
				GUILayout.ExpandHeight(false)
			});
			GUILayout.Label(title, _sectionHeaderStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label(description, _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Space(5f);
			drawContent?.Invoke();
			GUILayout.EndVertical();
		}

		private GUIStyle GetFeatureSectionStyle(FeatureSectionTone tone)
		{
			return (GUIStyle)(tone switch
			{
				FeatureSectionTone.Comfort => _comfortSectionBoxStyle, 
				FeatureSectionTone.Chat => _chatSectionBoxStyle, 
				FeatureSectionTone.Identity => _identitySectionBoxStyle, 
				FeatureSectionTone.Personalization => _personalizationSectionBoxStyle, 
				FeatureSectionTone.Experimental => _experimentalBoxStyle, 
				_ => _sectionBoxStyle, 
			});
		}

		private Color GetFeatureSectionAccent(FeatureSectionTone tone)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			return (Color)(tone switch
			{
				FeatureSectionTone.Comfort => _theme.ComfortAccent, 
				FeatureSectionTone.Chat => _theme.ChatAccent, 
				FeatureSectionTone.Identity => _theme.IdentityAccent, 
				FeatureSectionTone.Personalization => _theme.PersonalizationAccent, 
				FeatureSectionTone.Experimental => _theme.ExperimentalAccent, 
				_ => _theme.LabelText, 
			});
		}

		private void DrawCustomizeTab()
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			GUILayout.BeginVertical(_boxStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandHeight(false) });
			GUILayout.Label("Customize safely", _sectionHeaderStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label("Every editable row has Save and Undo. Undo discards an unsaved draft or restores the value from before your last Save.", _smallStyle, Array.Empty<GUILayoutOption>());
			bool isStyleHelperVisible = Plugin.IsStyleHelperVisible;
			if (GUILayout.Button(new GUIContent(isStyleHelperVisible ? "Close Style Helper" : "Open Style Helper", "Open or close the helper for names, status tags, colors, templates, and Spoons."), isStyleHelperVisible ? _enabledButtonStyle : _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(34f) }))
			{
				_message = (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.ToggleStyleUiFromQolMenu() : "Plugin is not ready.");
				MarkAction("Style Helper toggled.");
			}
			GUILayout.Space(8f);
			bool num = ((Rect)(ref _windowRect)).width >= 1280f;
			float contentLayoutWidth = GetContentLayoutWidth();
			float num2 = (num ? ((contentLayoutWidth - 12f) / 2f) : contentLayoutWidth);
			if (num)
			{
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				GUILayout.BeginVertical((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(num2) });
				DrawSettingsSection("General", "Safe housekeeping timing.", DrawGeneralSettings, num2);
				GUILayout.Space(12f);
				DrawSelfMovementSection(num2);
				GUILayout.Space(12f);
				DrawSettingsSection("Mentions & Pings", "Choose how local alerts look and sound.", DrawPingSettings, num2);
				GUILayout.EndVertical();
				GUILayout.Space(12f);
				DrawSettingsSection("Chat & Readability", "Scale text, space, outline, and retained history independently.", DrawChatSettings, num2);
				GUILayout.EndHorizontal();
				GUILayout.Space(12f);
				DrawSettingsSection("Text Limits", "Defaults favor stability; power users may raise them.", DrawTextLimitSettings, contentLayoutWidth);
			}
			else
			{
				DrawSettingsSection("General", "Safe housekeeping timing.", DrawGeneralSettings, num2);
				GUILayout.Space(12f);
				DrawSelfMovementSection(num2);
				GUILayout.Space(12f);
				DrawSettingsSection("Mentions & Pings", "Choose how local alerts look and sound.", DrawPingSettings, num2);
				GUILayout.Space(12f);
				DrawSettingsSection("Chat & Readability", "Scale text, space, outline, and retained history independently.", DrawChatSettings, num2);
				GUILayout.Space(12f);
				DrawSettingsSection("Text Limits", "Defaults favor stability; power users may raise them.", DrawTextLimitSettings, num2);
			}
			GUILayout.EndVertical();
		}

		private void DrawGeneralSettings()
		{
			DrawTextSetting("Automatic cleanup interval (minutes)", ref _sweepIntervalText, "Save 5-180", SaveSweepInterval, () => Plugin.SweepIntervalMinutes?.Value.ToString() ?? "10");
		}

		private void DrawSelfMovementSection(float width)
		{
			DrawSettingsSection("Self movement", "Optional self-only movement and rescue-from-a-glitch controls.", DrawSelfMovementTools, width);
		}

		private void DrawPingSettings()
		{
			DrawTextSetting("Ping highlight color", ref _pingHighlightText, "Save", delegate
			{
				SaveHex(Plugin.PingHighlightColor, _pingHighlightText, "Ping highlight");
			}, () => Plugin.PingHighlightColor?.Value ?? "9B59B6");
			DrawTextSetting("Ping @mention color", ref _pingMentionText, "Save", delegate
			{
				SaveHex(Plugin.PingMentionColor, _pingMentionText, "Ping mention");
			}, () => Plugin.PingMentionColor?.Value ?? "FFD700");
			DrawTextSetting("Ping sound mode", ref _pingSoundModeText, "Save", SavePingSoundMode, () => Plugin.GetPingSoundMode());
		}

		private void DrawChatSettings()
		{
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Expected O, but got Unknown
			GUILayout.Label("Chat font size grows message text only. Whole chat UI scale grows the panel/input/backdrop too.", _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label("Chat window height adds vertical log space. Native Global/Local tabs stay game-owned.", _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Space(5f);
			DrawTextSetting("Chat outline intensity", ref _chatOutlineIntensityText, "Save 25-100", SaveOutlineIntensity, () => Plugin.LockedChatOutlineIntensityPercent.ToString());
			DrawTextSetting("Whole chat UI scale", ref _chatUiScaleText, "Save 75-200", SaveChatUiScale, () => Plugin.LockedChatUiScalePercent.ToString());
			DrawTextSetting("Chat font size", ref _chatFontSizeText, "Save 75-200", SaveChatFontSize, () => Plugin.LockedChatFontSizePercent.ToString());
			DrawTextSetting("Chat window height", ref _chatWindowHeightText, "Save 100-200", SaveChatWindowHeight, () => Plugin.LockedChatWindowHeightPercent.ToString());
			DrawTextSetting("Retained chat rows", ref _chatHistoryRowsText, "Save 25-250", SaveChatHistoryRows, () => Plugin.LockedChatHistoryRows.ToString());
			if (GUILayout.Button(new GUIContent("Reset Chat UI to Vanilla", "Sets whole chat UI scale, message font size, and window height back to 100% and restores the saved vanilla transform where possible."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) }))
			{
				_message = (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.ResetChatUiToVanillaFromMenu() : "Plugin is not ready.");
				HydrateFields();
				MarkSaved("Chat UI reset to vanilla.");
			}
			DrawTextSetting("Normal outline color", ref _chatOutlineColorText, "Save", delegate
			{
				SaveHex(Plugin.ChatOutlineColor, _chatOutlineColorText, "Normal outline");
			}, () => Plugin.LockedChatOutlineColorHex);
			DrawTextSetting("Black text outline color", ref _blackChatOutlineColorText, "Save", delegate
			{
				SaveHex(Plugin.BlackChatOutlineColor, _blackChatOutlineColorText, "Black text outline");
			}, () => Plugin.LockedBlackChatOutlineColorHex);
			DrawToggle("BlackNamesOutline", Plugin.BlackNamesOutline, "Uses the black-text outline color for true-black chat/name rows. On by default for readable black styles; turn off to force the normal outline color.", ChatReadabilityPatch.RefreshVisibleChat);
		}

		private void DrawTextLimitSettings()
		{
			GUILayout.Label("Default is 3000. Values above 3000 may wrap, clip, or look odd in some game UI.", _smallStyle, Array.Empty<GUILayoutOption>());
			DrawTextSetting("Chat text limit", ref _chatLimitText, "Save 1-4000", delegate
			{
				SaveCharacterLimit(Plugin.MaxChatCharacters, _chatLimitText, "Chat text", InputFieldLimitPolicy.ClampChatCharacters, delegate(int value)
				{
					_chatLimitText = value.ToString();
				});
			}, () => Plugin.LockedMaxChatCharacters.ToString());
			DrawTextSetting("Name/ID limit", ref _profileLimitText, "Save 1-4000", delegate
			{
				SaveCharacterLimit(Plugin.MaxProfileCharacters, _profileLimitText, "Name and ID card text", InputFieldLimitPolicy.ClampProfileCharacters, delegate(int value)
				{
					_profileLimitText = value.ToString();
				});
			}, () => Plugin.LockedMaxIdCardCharacters.ToString());
			DrawTextSetting("Room name limit", ref _sessionLimitText, "Save 1-4000", delegate
			{
				SaveCharacterLimit(Plugin.MaxSessionNameCharacters, _sessionLimitText, "Room name text", InputFieldLimitPolicy.ClampSessionNameCharacters, delegate(int value)
				{
					_sessionLimitText = value.ToString();
				});
			}, () => Plugin.LockedMaxSessionNameCharacters.ToString());
		}

		private void DrawSettingsSection(string title, string description, Action drawContent, float width)
		{
			GUILayout.BeginVertical(_sectionBoxStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(width),
				GUILayout.ExpandHeight(false)
			});
			GUILayout.Label(title, _sectionHeaderStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label(description, _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Space(5f);
			drawContent?.Invoke();
			GUILayout.EndVertical();
		}

		private void DrawCreditsOtherTab()
		{
			GUILayout.BeginVertical(_boxStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandHeight(false) });
			GUILayout.Label("Tools, safety, and credits", _sectionHeaderStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label("Less-used controls live here so the everyday tabs stay calm. Each section keeps its existing behavior and exact hover help.", _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Space(8f);
			bool num = ((Rect)(ref _windowRect)).width >= 1280f;
			float contentLayoutWidth = GetContentLayoutWidth();
			float num2 = (num ? ((contentLayoutWidth - 12f) / 2f) : contentLayoutWidth);
			DrawSettingsSection("♥ COMMUNITY SUPPORTERS ♥", "A simple thank-you wall for the people who helped BlueSage keep building, with private payment details excluded.", DrawSupporterCredits, contentLayoutWidth);
			GUILayout.Space(12f);
			DrawSettingsSection("Community crew", "Testing, crash evidence, and trusted co-conspirators who help BlueSage stay honest.", DrawCommunityCrew, contentLayoutWidth);
			GUILayout.Space(12f);
			if (num)
			{
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				GUILayout.BeginVertical((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(num2) });
				DrawSettingsSection("About BlueSage QoL", "Community-built comfort, clarity, and safer lobby tools.", DrawAboutAndCredits, num2);
				GUILayout.EndVertical();
				GUILayout.Space(12f);
				GUILayout.BeginVertical((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(num2) });
				DrawSettingsSection("Menu appearance", "Choose one shared theme for the QoL Menu, Style Helper, and command popups.", DrawThemeSelector, num2);
				GUILayout.Space(12f);
				DrawFeatureSection("Experimental performance", "Player Render Saver stays opt-in while large-lobby renderer suppression is tested.", DrawPlayerRenderSaverTuning, num2, FeatureSectionTone.Experimental);
				GUILayout.EndVertical();
				GUILayout.EndHorizontal();
			}
			else
			{
				DrawSettingsSection("Menu appearance", "Choose one shared theme for the QoL Menu, Style Helper, and command popups.", DrawThemeSelector, num2);
				GUILayout.Space(12f);
				DrawFeatureSection("Experimental performance", "Player Render Saver stays opt-in while large-lobby renderer suppression is tested.", DrawPlayerRenderSaverTuning, num2, FeatureSectionTone.Experimental);
				GUILayout.Space(12f);
				DrawSettingsSection("About BlueSage QoL", "Community-built comfort, clarity, and safer lobby tools.", DrawAboutAndCredits, num2);
			}
			GUILayout.EndVertical();
		}

		private void DrawAboutAndCredits()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			GUILayout.Label("BlueSage QoL Tweaks brings common comfort, readability, personalization, reconnect, and community-safety tools into one guided menu.", _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label("Asset Sweep asks Unity to unload assets that are no longer used. It never deletes files or touches profiles. MiniMap ID Click stays lightweight; floating name labels remain removed after large-lobby performance reports.", _smallStyle, Array.Empty<GUILayoutOption>());
			if (GUILayout.Button(new GUIContent("Run Host Health", "Optional host-focused lobby-health check. Most players only need Run QoL Status on Main."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) }))
			{
				_message = (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.RunHostHealthFromQolMenu() : "Plugin is not ready.");
				MarkAction("Host Health check requested.");
			}
			GUILayout.Space(8f);
			GUILayout.Label("Optional lobby joke", _labelStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label("Sends one playful lobby chat line the first time. It never changes moderation or game state.", _smallStyle, Array.Empty<GUILayoutOption>());
			DrawDoNotPressButton();
			GUILayout.Label("Share finds in Blue's Discord if you uncover another harmless oddity.", _smallStyle, Array.Empty<GUILayoutOption>());
		}

		private void DrawPlayerRenderSaverTuning()
		{
			GUILayout.Label("Player Render Saver", _labelStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label("Opt-in local tuning for very large lobbies. It never hides chat or player-list rows. Use /playersaver status to verify actual renderer suppression.", _smallStyle, Array.Empty<GUILayoutOption>());
			DrawTextSetting("Render saver radius", ref _playerRenderSaverRadiusText, "Save 10-250", SavePlayerRenderSaverRadius, () => Plugin.LockedPlayerRenderSaverRadiusMeters.ToString());
			DrawTextSetting("Render saver max visible", ref _playerRenderSaverMaxVisibleText, "Save 1-128", SavePlayerRenderSaverMaxVisible, () => Plugin.LockedPlayerRenderSaverMaxVisiblePlayers.ToString());
		}

		private void DrawLobbySafetyTab()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Expected O, but got Unknown
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Expected O, but got Unknown
			//IL_029c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bf: Expected O, but got Unknown
			bool isHost;
			string reason;
			LobbySafetyAccessState localAccessState = SteamIdModerationController.GetLocalAccessState(out isHost, out reason);
			if (localAccessState == LobbySafetyAccessState.Denied)
			{
				_tab = 0;
				_contentScroll = Vector2.zero;
				ClearLobbySafetyTransientState();
				GUILayout.Label("Lobby Safety is available only to the current host or a Helper assigned by that host. No player or incident details were shown.", _smallStyle, Array.Empty<GUILayoutOption>());
				return;
			}
			GUILayout.BeginVertical(_boxStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandHeight(false) });
			GUILayout.Label(isHost ? "Host Console" : "Safety", _sectionHeaderStyle, Array.Empty<GUILayoutOption>());
			if (isHost)
			{
				DrawHostReadinessCard();
				GUILayout.Space(10f);
			}
			DrawIdentityResyncControls(localAccessState, isHost);
			GUILayout.Space(10f);
			if (localAccessState == LobbySafetyAccessState.HelperWaitingForHost)
			{
				GUILayout.Label("Helper assigned • secure host channel pending", _labelStyle, Array.Empty<GUILayoutOption>());
				GUILayout.Label("Protected player details stay locked until the host publishes a compatible capability. This unlocks automatically; no command is required.", _smallStyle, Array.Empty<GUILayoutOption>());
				GUILayout.Space(8f);
				if (GUILayout.Button(new GUIContent("Refresh Access Now", "Optional immediate check for the current v3 member-data capability. Automatic checks continue without this button. Technical state: " + reason), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(32f) }))
				{
					_message = (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.CheckModerationAccessFromQolMenu() : "Helper / Safety is not ready yet.");
					MarkAction("Helper access rechecked. Waiting for a fresh compatible host capability if the tools remain locked.");
				}
				GUILayout.EndVertical();
				return;
			}
			GUILayout.Label(isHost ? "Host access. Act only after checking the Steam profile for the exact current row; Clone Shield is an advisory clue, not proof." : "Helper access assigned by this host. Act only after checking the Steam profile for the exact current row; the host rechecks every request.", _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Space(8f);
			string status;
			IReadOnlyList<PlayerIdentityEvidence> verifiedRoster = PlayerIdentityEvidenceController.GetVerifiedRoster(out status);
			DrawVerifiedSafetyRoster(verifiedRoster, status, isHost);
			GUILayout.Space(10f);
			GUILayout.BeginVertical(_identitySectionBoxStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label("Defensive compatibility", _labelStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label(Plugin.GetDefensiveCompatibilitySummary(), _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label("The optional community safety list checks trusted entries locally. Existing rows remain untouched; an invalid refresh is discarded and cannot kick, ban, or grant authority. " + CommunityBanListController.FriendlyStatusText(), _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.EndVertical();
			GUILayout.Space(10f);
			GUILayout.BeginVertical(_identitySectionBoxStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label("Local audit evidence", _labelStyle, Array.Empty<GUILayoutOption>());
			DrawLocalAuditActions(showIdentityNote: true);
			GUILayout.EndVertical();
			GUILayout.Space(10f);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (GUILayout.Button(new GUIContent("Check My Access", "Shows whether you are the current host, a host-assigned Helper, or a regular player."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(32f) }))
			{
				_message = (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.CheckModerationAccessFromQolMenu() : "Lobby Safety is not ready yet.");
				MarkAction(_message);
			}
			if (isHost && GUILayout.Button(new GUIContent("Clear All Helpers", "Remove every Helper from your persistent host-owned list. Your own host access remains."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(32f) }))
			{
				_message = (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.ResetHelpersFromQolMenu() : "Lobby Safety is not ready yet.");
				MarkAction(_message);
			}
			GUILayout.EndHorizontal();
			GUILayout.Space(10f);
			DrawCloneIncidentReview();
			if (isHost)
			{
				GUILayout.Space(12f);
				DrawOfflineBanEntry();
				GUILayout.Space(12f);
				DrawNativeBanRecords();
			}
			GUILayout.EndVertical();
		}

		private void DrawHostReadinessCard()
		{
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Expected O, but got Unknown
			HostConsoleSnapshot hostConsoleSnapshot = HostConsoleController.Capture();
			string obj = ((hostConsoleSnapshot.OverallState == HostConsoleOverallState.Ready) ? "24/7 Ready" : ((hostConsoleSnapshot.OverallState == HostConsoleOverallState.Degraded) ? "24/7 Degraded" : "24/7 Unavailable"));
			GUIStyle val = ((hostConsoleSnapshot.OverallState == HostConsoleOverallState.Ready) ? _enabledButtonStyle : ((hostConsoleSnapshot.OverallState == HostConsoleOverallState.Degraded) ? _experimentalButtonStyle : _disabledButtonStyle));
			GUILayout.BeginVertical(_identitySectionBoxStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label(obj, _sectionHeaderStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label(hostConsoleSnapshot.Reason, _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label("Host " + hostConsoleSnapshot.HostState + "  •  Roster " + hostConsoleSnapshot.RosterState + " (" + HostConsoleController.LastVerifiedRosterCount + " verified)  •  Cleanup " + hostConsoleSnapshot.CleanupState + "  •  Reconnect " + hostConsoleSnapshot.ReconnectState, _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label(HostConsoleController.LastPlayerLimitSummary + "  •  Provider " + hostConsoleSnapshot.ProviderState + "  •  Relay " + hostConsoleSnapshot.RelayState, _smallStyle, Array.Empty<GUILayoutOption>());
			if (GUILayout.Button(new GUIContent("Audit Native UI", "Read-only check for native mute, ignore, report, and host-remove surfaces. No moderation action fires."), val, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) }))
			{
				_message = HostConsoleController.AuditNativeModerationUi();
				MarkAction(_message);
			}
			if (HostConsoleController.HasCapabilitySnapshot)
			{
				BlueSageHostCapabilitySnapshotV1 lastCapabilitySnapshot = HostConsoleController.LastCapabilitySnapshot;
				GUILayout.Space(8f);
				GUILayout.Label(lastCapabilitySnapshot.Title, _labelStyle, Array.Empty<GUILayoutOption>());
				GUILayout.Label(lastCapabilitySnapshot.Summary, _smallStyle, Array.Empty<GUILayoutOption>());
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				if ((lastCapabilitySnapshot.Actions & BlueSageHostCapabilityActionMaskV1.RefreshSnapshot) != BlueSageHostCapabilityActionMaskV1.None && GUILayout.Button("Refresh Private Status", _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(28f) }))
				{
					HostConsoleController.TryExecuteCapability(BlueSageHostCapabilityActionV1.RefreshSnapshot, out _message);
					MarkAction(_message);
				}
				if ((lastCapabilitySnapshot.Actions & BlueSageHostCapabilityActionMaskV1.ResetMovement) != BlueSageHostCapabilityActionMaskV1.None && GUILayout.Button("Reset Private Movement", _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(28f) }))
				{
					HostConsoleController.TryExecuteCapability(BlueSageHostCapabilityActionV1.ResetMovement, out _message);
					MarkAction(_message);
				}
				if ((lastCapabilitySnapshot.Actions & BlueSageHostCapabilityActionMaskV1.AuditNativeModeration) != BlueSageHostCapabilityActionMaskV1.None && GUILayout.Button("Private Audit", _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(28f) }))
				{
					HostConsoleController.TryExecuteCapability(BlueSageHostCapabilityActionV1.AuditNativeModeration, out _message);
					MarkAction(_message);
				}
				GUILayout.EndHorizontal();
			}
			GUILayout.EndVertical();
		}

		private void DrawIdentityResyncControls(LobbySafetyAccessState accessState, bool isHost)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Expected O, but got Unknown
			GUILayout.BeginVertical(_identitySectionBoxStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label("Steam / PurrNet / lobby identity truth", _labelStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label(IdentityResyncController.StatusText(), _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (GUILayout.Button(new GUIContent("Rebuild Local View", "Rebuild only BlueSage-owned local presentation from already-available native state. This does not delete stale native/PurrNet objects or run moderation."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) }))
			{
				_message = IdentityResyncController.ExecuteMenuAction("refresh");
				MarkAction(_message);
			}
			if (isHost || accessState == LobbySafetyAccessState.HelperReady)
			{
				string obj = (isHost ? "Recheck Exact Rows" : "Request Host Recheck");
				string text = (isHost ? "Run one generation-bound exact-correlation recheck after the quiet/cooldown gates. This does not delete stale native/PurrNet objects." : "Ask a compatible 0.2.4+ host to run one authenticated exact-correlation recheck. The host revalidates Helper, lobby, owner, capability, generation, nonce, and exact row. This does not delete stale native/PurrNet objects.");
				if (GUILayout.Button(new GUIContent(obj, text), _experimentalButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) }))
				{
					_message = IdentityResyncController.ExecuteMenuAction(isHost ? "repair" : "request");
					MarkAction(_message);
				}
			}
			GUILayout.EndHorizontal();
			GUILayout.Label("Truth is read-only. Conflicting rows stay locked; a recheck can recapture exact correlation but cannot remove a game/network ghost. Private callers receive no ambiguity bypass.", _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.EndVertical();
		}

		private void DrawCloneIncidentReview()
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Expected O, but got Unknown
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Expected O, but got Unknown
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Expected O, but got Unknown
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Expected O, but got Unknown
			//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c4: Expected O, but got Unknown
			//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0312: Expected O, but got Unknown
			//IL_034c: Unknown result type (might be due to invalid IL or missing references)
			//IL_036f: Expected O, but got Unknown
			//IL_06a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_06cb: Expected O, but got Unknown
			//IL_041b: Unknown result type (might be due to invalid IL or missing references)
			//IL_044f: Expected O, but got Unknown
			//IL_04a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c9: Expected O, but got Unknown
			//IL_04f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0516: Expected O, but got Unknown
			IReadOnlyList<CloneIncident> openIncidents = CloneIncidentActionController.GetOpenIncidents();
			GUILayout.BeginVertical(_identitySectionBoxStyle, Array.Empty<GUILayoutOption>());
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label("Clone Shield incidents • " + openIncidents.Count + " open", _sectionHeaderStyle, Array.Empty<GUILayoutOption>());
			GUILayout.FlexibleSpace();
			if (GUILayout.Button(new GUIContent(_showClosedIncidentHistory ? "Hide History" : "Show History", "Show or hide resolved and locally dismissed incident history."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(104f),
				GUILayout.Height(28f)
			}))
			{
				_showClosedIncidentHistory = !_showClosedIncidentHistory;
			}
			GUILayout.EndHorizontal();
			GUILayout.Label("C# is a local shortcut. Victim and suspect SteamID64 values remain exact; resolve clears the role highlights for QoL clients that receive the verified host/Helper notice.", _smallStyle, Array.Empty<GUILayoutOption>());
			if (openIncidents.Count > 0 && GUILayout.Button(new GUIContent("Dismiss All Open Locally", "Clear every open Clone Shield advisory and highlight on this client only. This never bans, changes Helpers, or publishes lobby state. Use /sidincident dismiss-all for the same action."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) }))
			{
				CloneIncidentActionController.TryDismissAllOpenLocal(out _message);
				MarkAction(_message);
				GUILayout.EndVertical();
				return;
			}
			if (openIncidents.Count == 0)
			{
				GUILayout.Label("No open incidents. Clone Shield highlights and moderation protections are clear on this client.", _smallStyle, Array.Empty<GUILayoutOption>());
			}
			foreach (CloneIncident item in openIncidents.Take(4))
			{
				GUILayout.BeginVertical(_boxStyle, Array.Empty<GUILayoutOption>());
				GUILayout.Label(item.Id + "  •  " + item.MatchType + "  •  " + item.StableId, _labelStyle, Array.Empty<GUILayoutOption>());
				GUILayout.Label("Protected victim: " + item.VictimLabel + "  •  …" + PlayerIdentityEvidenceController.Suffix(item.VictimSteamId), _smallStyle, Array.Empty<GUILayoutOption>());
				GUILayout.Label("Suspect: " + item.SuspectLabel + "  •  …" + PlayerIdentityEvidenceController.Suffix(item.SuspectSteamId), _smallStyle, Array.Empty<GUILayoutOption>());
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				if (GUILayout.Button(new GUIContent("Select Victim", "Select the exact protected-victim row in the verified live roster above. Ban controls remain blocked for this row."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(28f) }))
				{
					SelectSafetyPlayer(item.VictimSteamId);
				}
				if (GUILayout.Button(new GUIContent("Select Suspect", "Select the exact suspected-copier row in the verified live roster above for profile verification."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(28f) }))
				{
					SelectSafetyPlayer(item.SuspectSteamId);
				}
				GUILayout.EndHorizontal();
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				if (GUILayout.Button(new GUIContent("Copy Victim ID", "Copy the protected victim's exact SteamID64."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(28f) }))
				{
					CloneIncidentActionController.TryCopySteamId(item.Id, suspect: false, out _message);
					MarkAction(_message);
				}
				if (GUILayout.Button(new GUIContent("Copy Suspect ID", "Copy the suspect's exact SteamID64."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(28f) }))
				{
					CloneIncidentActionController.TryCopySteamId(item.Id, suspect: true, out _message);
					MarkAction(_message);
				}
				GUILayout.EndHorizontal();
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				if (GUILayout.Button(new GUIContent("Preview Suspect Ban", "Create a safe preview for the exact suspect. Confirmation remains separate."), _experimentalButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(28f) }))
				{
					_message = (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.PreviewSidBanFromQolMenu(item.SuspectSteamId) : "SID preview is not ready yet.");
					MarkAction(_message);
				}
				ModerationConfirmationReadiness moderationConfirmationReadiness = (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.GetModerationConfirmationReadiness("ban", item.SuspectSteamId) : new ModerationConfirmationReadiness(isReady: false, 0));
				GUI.enabled = moderationConfirmationReadiness.IsReady;
				if (GUILayout.Button(new GUIContent(moderationConfirmationReadiness.IsReady ? $"Confirm Suspect Ban  •  {moderationConfirmationReadiness.SecondsRemaining}s" : "Preview Required", moderationConfirmationReadiness.IsReady ? "Confirm the matching exact-suspect preview before its visible countdown expires." : "Create a matching suspect-ban preview first; confirmation stays disabled until then."), moderationConfirmationReadiness.IsReady ? _enabledButtonStyle : _disabledButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(28f) }))
				{
					_message = (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.ConfirmSidBanFromQolMenu(item.SuspectSteamId) : "SID confirmation is not ready yet.");
					MarkAction(_message);
				}
				GUI.enabled = true;
				GUILayout.EndHorizontal();
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				if (GUILayout.Button(new GUIContent("Resolve for Lobby", "Host or Helper: mark this incident handled and clear its victim/suspect highlights for compatible QoL clients."), _enabledButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(28f) }))
				{
					CloneIncidentActionController.TryResolveForLobby(item.Id, out _message);
					MarkAction(_message);
				}
				if (GUILayout.Button(new GUIContent("Dismiss Locally", "Remove this advisory incident and its highlights on this client only. No moderation state changes."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(28f) }))
				{
					CloneIncidentActionController.TryDismissLocal(item.Id, out _message);
					MarkAction(_message);
				}
				GUILayout.EndHorizontal();
				GUILayout.EndVertical();
			}
			if (openIncidents.Count > 4)
			{
				GUILayout.Label("Showing the newest 4 open incidents below the live roster. Use /sidlist for a compact summary, dismiss handled entries, or dismiss all locally to clear advisory clutter.", _smallStyle, Array.Empty<GUILayoutOption>());
			}
			if (_showClosedIncidentHistory)
			{
				IReadOnlyList<CloneIncident> readOnlyList = (from item in CloneIncidentActionController.GetIncidentHistory()
					where item.State != CloneIncidentState.Open
					select item).Take(12).ToArray();
				GUILayout.Space(8f);
				GUILayout.Label("Closed history • " + readOnlyList.Count + ((readOnlyList.Count == 12) ? "+" : string.Empty), _labelStyle, Array.Empty<GUILayoutOption>());
				foreach (CloneIncident item2 in readOnlyList)
				{
					GUILayout.Label(item2.Id + "  •  " + item2.State.ToString() + "  •  victim …" + PlayerIdentityEvidenceController.Suffix(item2.VictimSteamId) + "  •  suspect …" + PlayerIdentityEvidenceController.Suffix(item2.SuspectSteamId), _smallStyle, Array.Empty<GUILayoutOption>());
				}
				if (GUILayout.Button(new GUIContent("Clear Closed History", "Remove resolved and locally dismissed history. Open incidents are never removed by this button."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(28f) }))
				{
					int num = CloneIncidentActionController.ClearClosedHistory();
					_message = "Cleared " + num + " closed Clone Shield " + ((num == 1) ? "incident" : "incidents") + ".";
					MarkAction(_message);
				}
			}
			GUILayout.EndVertical();
		}

		private void SelectSafetyPlayer(string steamId)
		{
			_safetyRosterQuery = string.Empty;
			_selectedSafetySteamId = steamId ?? string.Empty;
			int num = PlayerIdentityEvidenceController.GetVerifiedRoster().ToList().FindIndex((PlayerIdentityEvidence item) => string.Equals(item.SteamId, _selectedSafetySteamId, StringComparison.Ordinal));
			if (num >= 0)
			{
				_safetyRosterPage = num / 8;
			}
		}

		private void DrawVerifiedSafetyRoster(IReadOnlyList<PlayerIdentityEvidence> liveRoster, string rosterStatus, bool isHost)
		{
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Expected O, but got Unknown
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Expected O, but got Unknown
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_0280: Expected O, but got Unknown
			//IL_04b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e8: Expected O, but got Unknown
			//IL_0388: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b7: Expected O, but got Unknown
			//IL_06c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_06eb: Expected O, but got Unknown
			//IL_072e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0751: Expected O, but got Unknown
			//IL_0823: Unknown result type (might be due to invalid IL or missing references)
			//IL_0846: Expected O, but got Unknown
			//IL_07b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d6: Expected O, but got Unknown
			//IL_08b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_08d5: Expected O, but got Unknown
			//IL_09ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_09ce: Expected O, but got Unknown
			//IL_0a64: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a98: Expected O, but got Unknown
			GUILayout.BeginVertical(_identitySectionBoxStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label("Find a verified live player", _labelStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label("Type part of the displayed name, raw TMP tags, Steam persona, 4+ SteamID digits, _host, _self, or a regex pattern. Matching never grants ban authority; it only filters rows whose live game and lobby identity agrees.", _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label(rosterStatus, _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			string safetyRosterQuery = _safetyRosterQuery;
			_safetyRosterQuery = GUILayout.TextField(_safetyRosterQuery ?? string.Empty, 96, _textFieldStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) });
			if (!string.Equals(safetyRosterQuery, _safetyRosterQuery, StringComparison.Ordinal))
			{
				_safetyRosterPage = 0;
				_selectedSafetySteamId = string.Empty;
			}
			if (GUILayout.Button(new GUIContent("Clear", "Show every currently verified row again."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(72f),
				GUILayout.Height(30f)
			}))
			{
				_safetyRosterQuery = string.Empty;
				_safetyRosterPage = 0;
				_selectedSafetySteamId = string.Empty;
			}
			GUILayout.EndHorizontal();
			string error;
			IReadOnlyList<PlayerIdentityEvidence> readOnlyList = PlayerIdentityEvidenceController.FilterVerifiedRoster(liveRoster, _safetyRosterQuery, out error);
			if (!string.IsNullOrWhiteSpace(error))
			{
				GUILayout.Label(error, _smallStyle, Array.Empty<GUILayoutOption>());
			}
			GUILayout.EndVertical();
			GUILayout.Space(8f);
			int num = Math.Max(1, (readOnlyList.Count + 8 - 1) / 8);
			_safetyRosterPage = Mathf.Clamp(_safetyRosterPage, 0, num - 1);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label($"Verified active roster • {readOnlyList.Count}/{liveRoster.Count} matching • page {_safetyRosterPage + 1}/{num}", _labelStyle, Array.Empty<GUILayoutOption>());
			GUILayout.FlexibleSpace();
			GUI.enabled = _safetyRosterPage > 0;
			if (GUILayout.Button(new GUIContent("◀ Previous", "Show the previous eight verified current-lobby rows."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(104f),
				GUILayout.Height(28f)
			}))
			{
				_safetyRosterPage--;
				_selectedSafetySteamId = string.Empty;
			}
			GUI.enabled = _safetyRosterPage + 1 < num;
			if (GUILayout.Button(new GUIContent("Next ▶", "Show the next eight verified current-lobby rows."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(104f),
				GUILayout.Height(28f)
			}))
			{
				_safetyRosterPage++;
				_selectedSafetySteamId = string.Empty;
			}
			GUI.enabled = true;
			GUILayout.EndHorizontal();
			GUILayout.Label("Select a row below; BlueSage keeps the exact SteamID64 attached to that selection. No retyping is needed.", _smallStyle, Array.Empty<GUILayoutOption>());
			if (readOnlyList.Count == 0)
			{
				GUILayout.Label(string.IsNullOrWhiteSpace(_safetyRosterQuery) ? "The verified player roster is not ready yet. Close and reopen the player panel, then return here." : "No current verified player matches this filter. Clear it or add more exact detail.", _smallStyle, Array.Empty<GUILayoutOption>());
				return;
			}
			int num2 = _safetyRosterPage * 8;
			int num3 = Math.Min(readOnlyList.Count, num2 + 8);
			for (int i = num2; i < num3; i++)
			{
				PlayerIdentityEvidence playerIdentityEvidence = readOnlyList[i];
				bool flag = string.Equals(_selectedSafetySteamId, playerIdentityEvidence.SteamId, StringComparison.Ordinal);
				string text = $"#{playerIdentityEvidence.RosterIndex + 1:00}  {playerIdentityEvidence.DisplayName}  •  …{PlayerIdentityEvidenceController.Suffix(playerIdentityEvidence.SteamId)}  •  {playerIdentityEvidence.Role}";
				string text2 = (flag ? "Selected. Click again to clear this player selection." : "Select this exact verified player-to-SteamID row.");
				if (GUILayout.Button(new GUIContent(text, text2), flag ? _activeButtonStyle : _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) }))
				{
					_selectedSafetySteamId = (flag ? string.Empty : playerIdentityEvidence.SteamId);
					MarkAction(flag ? "Cleared the selected player." : ("Selected " + playerIdentityEvidence.DisplayName + " (Steam …" + PlayerIdentityEvidenceController.Suffix(playerIdentityEvidence.SteamId) + ")."));
				}
			}
			PlayerIdentityEvidence playerIdentityEvidence2 = readOnlyList.FirstOrDefault((PlayerIdentityEvidence item) => string.Equals(item.SteamId, _selectedSafetySteamId, StringComparison.Ordinal));
			if (playerIdentityEvidence2 == null)
			{
				_selectedSafetySteamId = string.Empty;
				GUILayout.Space(8f);
				GUILayout.Label("No player is selected. Click the exact verified row you intend to inspect; BlueSage never silently retargets actions after filtering or roster changes.", _smallStyle, Array.Empty<GUILayoutOption>());
				return;
			}
			GUILayout.Space(10f);
			GUILayout.BeginVertical(_identitySectionBoxStyle, Array.Empty<GUILayoutOption>());
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label("Selected player", _sectionHeaderStyle, Array.Empty<GUILayoutOption>());
			GUILayout.FlexibleSpace();
			if (GUILayout.Button(new GUIContent("Clear Selection", "Deselect this player and disarm every selection-scoped moderation control."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(130f),
				GUILayout.Height(28f)
			}))
			{
				_selectedSafetySteamId = string.Empty;
				MarkAction("Cleared the selected player.");
				GUILayout.EndHorizontal();
				GUILayout.EndVertical();
				return;
			}
			GUILayout.EndHorizontal();
			GUILayout.Label(playerIdentityEvidence2.DisplayName + "  •  " + playerIdentityEvidence2.Role, _labelStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label("Steam persona: " + (string.IsNullOrWhiteSpace(playerIdentityEvidence2.SteamPersona) ? "not cached" : playerIdentityEvidence2.SteamPersona), _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label("SteamID64: " + playerIdentityEvidence2.SteamId, _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label("Verified live row #" + (playerIdentityEvidence2.RosterIndex + 1) + " • PlayerID " + playerIdentityEvidence2.NetworkPlayerId, _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label("Raw rendered name / TMP tags (copyable audit source):", _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.TextArea(playerIdentityEvidence2.DisplayNameRaw ?? string.Empty, _textFieldStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.MinHeight(42f),
				GUILayout.MaxHeight(70f)
			});
			bool isLocal = playerIdentityEvidence2.IsLocal;
			bool flag2 = playerIdentityEvidence2.Role.Split(new char[1] { '•' }).Any((string role) => role.Trim().StartsWith("HOST", StringComparison.Ordinal));
			bool flag3 = playerIdentityEvidence2.Role.Split(new char[1] { '•' }).Any((string role) => role.Trim().StartsWith("HELPER", StringComparison.Ordinal));
			bool flag4 = playerIdentityEvidence2.Role.Contains("VICTIM");
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (GUILayout.Button(new GUIContent("Copy SteamID64", "Copy this exact verified 17-digit Steam ID to the clipboard."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(32f) }))
			{
				_message = (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.CopySteamIdFromQolMenu(playerIdentityEvidence2.SteamId) : "Copy is not ready yet.");
				MarkAction(_message);
			}
			if (GUILayout.Button(new GUIContent("Open Steam Profile", "Open this exact Steam account in the Steam overlay for identity verification."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(32f) }))
			{
				_message = (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.OpenSteamProfileFromQolMenu(playerIdentityEvidence2.SteamId) : "Steam profile lookup is not ready yet.");
				MarkAction(_message);
			}
			if (Plugin.CanManageHelpers())
			{
				GUI.enabled = !flag2;
				if (GUILayout.Button(new GUIContent(flag3 ? "Remove Helper" : "Add Helper", "Manage your persistent host-owned Helper list. Exact SteamIDs keep access stable across lobbies you recreate."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(32f) }))
				{
					_message = (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.UpdateHelperFromQolMenu(playerIdentityEvidence2.SteamId, !flag3) : "Helper controls are not ready yet.");
					MarkAction(_message);
				}
			}
			GUILayout.EndHorizontal();
			if (GUILayout.Button(new GUIContent("Copy Identity Evidence", "Copy one local audit record containing the displayed name, raw TMP source, cached Steam persona, exact SteamID64, verified row, PlayerID, and current role. Nothing is sent to chat."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(32f) }))
			{
				_message = (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.CopyIdentityEvidenceFromQolMenu(playerIdentityEvidence2.SteamId) : "Identity evidence copy is not ready yet.");
				MarkAction(_message);
			}
			if ((playerIdentityEvidence2.Role.Contains("VICTIM") || playerIdentityEvidence2.Role.Contains("SUSPECT")) && GUILayout.Button(new GUIContent("Clear This Player's Incident Flags Locally", "Dismiss every open Clone Shield incident involving this exact verified row on this client. Lifecycle evidence remains in the local audit; no ban, Helper, or lobby state changes."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(32f) }))
			{
				CloneIncidentActionController.TryDismissOpenForVerifiedPlayer(playerIdentityEvidence2.SteamId, out _message);
				MarkAction(_message);
			}
			bool flag5 = isLocal || flag2 || flag3 || flag4;
			ModerationConfirmationReadiness moderationConfirmationReadiness = (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.GetModerationConfirmationReadiness("ban", playerIdentityEvidence2.SteamId) : new ModerationConfirmationReadiness(isReady: false, 0));
			HostModerationSurfaceDecision hostModerationSurfaceDecision = HostModerationSurfacePolicy.Evaluate(isHost, exactTargetReady: true, isLocal, moderationConfirmationReadiness.IsReady);
			string obj = (flag4 ? "Protected Victim" : (isLocal ? "Protected Self" : (flag2 ? "Protected Host" : (flag3 ? "Protected Helper" : "Preview SID Ban"))));
			string text3 = (flag5 ? "This verified role is protected from BlueSage ban previews." : "Create a safe preview only. The exact target is revalidated and still requires a separate confirmation.");
			GUI.enabled = !flag5 && (!isHost || hostModerationSurfaceDecision.CanArmHostRemove);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (GUILayout.Button(new GUIContent(obj, text3), _experimentalButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(32f) }))
			{
				_message = (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.PreviewSidBanFromQolMenu(playerIdentityEvidence2.SteamId) : "SID preview is not ready yet.");
				MarkAction(_message);
			}
			GUI.enabled = !flag5 && moderationConfirmationReadiness.IsReady && (!isHost || hostModerationSurfaceDecision.CanExecuteHostRemove);
			if (GUILayout.Button(new GUIContent(moderationConfirmationReadiness.IsReady ? $"Confirm Exact SID Ban  •  {moderationConfirmationReadiness.SecondsRemaining}s" : "Preview Required", moderationConfirmationReadiness.IsReady ? "Confirm the matching exact-player preview before its visible countdown expires." : "Create a matching SID-ban preview first; confirmation stays disabled until then."), moderationConfirmationReadiness.IsReady ? _enabledButtonStyle : _disabledButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(32f) }))
			{
				_message = (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.ConfirmSidBanFromQolMenu(playerIdentityEvidence2.SteamId) : "SID confirmation is not ready yet.");
				MarkAction(_message);
			}
			GUI.enabled = true;
			GUILayout.EndHorizontal();
			GUILayout.Label("Your own row is marked SELF and automatically protected; a host never adds itself as a Helper. A ban preview never acts immediately. Recheck the profile, then use the explicit confirmation shown locally. Protected victims, host, Helpers, self, and ambiguous rows are blocked.", _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.EndVertical();
		}

		private void DrawNativeBanRecords()
		{
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Expected O, but got Unknown
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Expected O, but got Unknown
			//IL_038d: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bd: Expected O, but got Unknown
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_041c: Expected O, but got Unknown
			//IL_045f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0482: Expected O, but got Unknown
			//IL_027f: Expected O, but got Unknown
			//IL_0530: Unknown result type (might be due to invalid IL or missing references)
			//IL_0564: Expected O, but got Unknown
			IReadOnlyList<NativeBanRecord> records;
			string error;
			bool flag = SteamIdModerationController.TryGetNativeBanRecords(out records, out error);
			int num = Math.Max(1, (records.Count + 8 - 1) / 8);
			_nativeBanPage = Mathf.Clamp(_nativeBanPage, 0, num - 1);
			GUILayout.BeginVertical(_identitySectionBoxStyle, Array.Empty<GUILayoutOption>());
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label($"Native banned players • {records.Count} saved • page {_nativeBanPage + 1}/{num}", _sectionHeaderStyle, Array.Empty<GUILayoutOption>());
			GUILayout.FlexibleSpace();
			GUI.enabled = _nativeBanPage > 0;
			if (GUILayout.Button(new GUIContent("◀ Previous", "Show the previous eight host-native ban records."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(104f),
				GUILayout.Height(28f)
			}))
			{
				_nativeBanPage--;
				_selectedBannedSteamId = string.Empty;
			}
			GUI.enabled = _nativeBanPage + 1 < num;
			if (GUILayout.Button(new GUIContent("Next ▶", "Show the next eight host-native ban records."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(104f),
				GUILayout.Height(28f)
			}))
			{
				_nativeBanPage++;
				_selectedBannedSteamId = string.Empty;
			}
			GUI.enabled = true;
			GUILayout.EndHorizontal();
			GUILayout.Label("Host-only view of the game's paired saved nickname and SteamID64 records. Select a row to copy its exact ID or create a separate unban preview. Click the selected row again, or use Clear Selection, to disarm it.", _smallStyle, Array.Empty<GUILayoutOption>());
			if (!flag)
			{
				_selectedBannedSteamId = string.Empty;
				GUILayout.Label("Native banned-player list is NOT AVAILABLE: " + error + ". No empty-list claim or unban action is shown.", _smallStyle, Array.Empty<GUILayoutOption>());
				GUILayout.EndVertical();
				return;
			}
			if (records.Count == 0)
			{
				_selectedBannedSteamId = string.Empty;
				GUILayout.Label("The game's native banned-player list is empty.", _smallStyle, Array.Empty<GUILayoutOption>());
				GUILayout.EndVertical();
				return;
			}
			int num2 = _nativeBanPage * 8;
			int num3 = Math.Min(records.Count, num2 + 8);
			for (int i = num2; i < num3; i++)
			{
				NativeBanRecord nativeBanRecord = records[i];
				bool flag2 = string.Equals(_selectedBannedSteamId, nativeBanRecord.SteamId, StringComparison.Ordinal);
				string text = $"#{i + 1:00}  {nativeBanRecord.DisplayName}  •  …{PlayerIdentityEvidenceController.Suffix(nativeBanRecord.SteamId)}";
				string text2 = (flag2 ? "Selected. Click again to clear this native-ban selection." : "Select this exact paired native ban record.");
				if (GUILayout.Button(new GUIContent(text, text2), flag2 ? _activeButtonStyle : _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) }))
				{
					_selectedBannedSteamId = (flag2 ? string.Empty : nativeBanRecord.SteamId);
					MarkAction(flag2 ? "Cleared the selected native ban." : ("Selected native ban for " + nativeBanRecord.DisplayName + " (Steam …" + PlayerIdentityEvidenceController.Suffix(nativeBanRecord.SteamId) + ")."));
				}
			}
			NativeBanRecord nativeBanRecord2 = records.FirstOrDefault((NativeBanRecord record) => string.Equals(record.SteamId, _selectedBannedSteamId, StringComparison.Ordinal));
			if (nativeBanRecord2 == null)
			{
				_selectedBannedSteamId = string.Empty;
				GUILayout.Space(8f);
				GUILayout.Label("No native ban is selected. Click the exact saved row you intend to inspect; BlueSage never silently selects or retargets an unban action.", _smallStyle, Array.Empty<GUILayoutOption>());
				GUILayout.EndVertical();
				return;
			}
			GUILayout.Space(8f);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label("Selected native ban: " + nativeBanRecord2.DisplayName + "  •  SteamID64 " + nativeBanRecord2.SteamId, _labelStyle, Array.Empty<GUILayoutOption>());
			GUILayout.FlexibleSpace();
			if (GUILayout.Button(new GUIContent("Clear Selection", "Deselect this native ban and disarm every selection-scoped unban control."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(130f),
				GUILayout.Height(28f)
			}))
			{
				_selectedBannedSteamId = string.Empty;
				MarkAction("Cleared the selected native ban.");
				GUILayout.EndHorizontal();
				GUILayout.EndVertical();
				return;
			}
			GUILayout.EndHorizontal();
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (GUILayout.Button(new GUIContent("Copy Banned SteamID64", "Copy this exact saved native-ban Steam ID."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(32f) }))
			{
				_message = (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.CopySavedBanSteamIdFromQolMenu(nativeBanRecord2.SteamId) : "Copy is not ready yet.");
				MarkAction(_message);
			}
			if (GUILayout.Button(new GUIContent("Preview SID Unban", "Create a safe unban preview only. A separate exact confirmation is still required."), _experimentalButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(32f) }))
			{
				_message = (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.PreviewSidUnbanFromQolMenu(nativeBanRecord2.SteamId) : "SID unban preview is not ready yet.");
				MarkAction(_message);
			}
			ModerationConfirmationReadiness moderationConfirmationReadiness = (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.GetModerationConfirmationReadiness("unban", nativeBanRecord2.SteamId) : new ModerationConfirmationReadiness(isReady: false, 0));
			GUI.enabled = moderationConfirmationReadiness.IsReady;
			if (GUILayout.Button(new GUIContent(moderationConfirmationReadiness.IsReady ? $"Confirm SID Unban  •  {moderationConfirmationReadiness.SecondsRemaining}s" : "Preview Required", moderationConfirmationReadiness.IsReady ? "Confirm the matching saved-ban preview before its visible countdown expires." : "Create a matching SID-unban preview first; confirmation stays disabled until then."), moderationConfirmationReadiness.IsReady ? _enabledButtonStyle : _disabledButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(32f) }))
			{
				_message = (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.ConfirmSidUnbanFromQolMenu(nativeBanRecord2.SteamId) : "SID unban confirmation is not ready yet.");
				MarkAction(_message);
			}
			GUI.enabled = true;
			GUILayout.EndHorizontal();
			GUILayout.Label("Preview never removes a ban. Recheck the saved nickname and SteamID64, then use the exact confirmation shown locally within 30 seconds.", _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.EndVertical();
		}

		private void ClearLobbySafetyTransientState()
		{
			_selectedSafetySteamId = string.Empty;
			_selectedBannedSteamId = string.Empty;
			_safetyRosterPage = 0;
			_nativeBanPage = 0;
			_offlineBanSteamIdText = string.Empty;
			_showClosedIncidentHistory = false;
		}

		private void DrawOfflineBanEntry()
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Expected O, but got Unknown
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Expected O, but got Unknown
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Expected O, but got Unknown
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Expected O, but got Unknown
			//IL_029f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cf: Expected O, but got Unknown
			GUILayout.BeginVertical(_identitySectionBoxStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label("Add exact off-roster SteamID64", _sectionHeaderStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label("Host only. Use this when another trusted host gives you an exact SteamID64 for advance protection. BlueSage saves the game's native ban entry without pretending the absent player was kicked.", _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label("Always open and verify the Steam profile first. Reports and names never auto-fill or authorize this field.", _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label(new GUIContent("SteamID64", "Paste the exact 17-digit SteamID64. Display names, profile names, suffixes, and URLs are intentionally refused here."), _labelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(100f) });
			string text = GUILayout.TextField(_offlineBanSteamIdText ?? string.Empty, 17, _textFieldStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) });
			if (!string.Equals(text, _offlineBanSteamIdText, StringComparison.Ordinal))
			{
				_offlineBanSteamIdText = text;
				MarkDraft("Offline SteamID64 changed. Verify its profile, then preview it.");
			}
			GUILayout.EndHorizontal();
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (GUILayout.Button(new GUIContent("Open Steam Profile", "Open this exact SteamID64 in the Steam overlay before previewing a ban."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(32f) }))
			{
				_message = (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.OpenOfflineSteamProfileFromQolMenu(_offlineBanSteamIdText) : "Steam profile lookup is not ready yet.");
				MarkAction(_message);
			}
			if (GUILayout.Button(new GUIContent("Preview Offline SID Ban", "Create a 30-second host-only preview. This does not save or kick anything."), _experimentalButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(32f) }))
			{
				_message = (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.PreviewSidBanFromQolMenu(_offlineBanSteamIdText) : "SID preview is not ready yet.");
				MarkAction(_message);
			}
			ModerationConfirmationReadiness moderationConfirmationReadiness = (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.GetModerationConfirmationReadiness("ban", _offlineBanSteamIdText) : new ModerationConfirmationReadiness(isReady: false, 0));
			GUI.enabled = moderationConfirmationReadiness.IsReady;
			if (GUILayout.Button(new GUIContent(moderationConfirmationReadiness.IsReady ? $"Confirm Preview  •  {moderationConfirmationReadiness.SecondsRemaining}s" : "Preview Required", moderationConfirmationReadiness.IsReady ? "Confirm this exact offline-SID preview before its visible countdown expires." : "Create a matching offline-SID preview first; confirmation stays disabled until then."), moderationConfirmationReadiness.IsReady ? _enabledButtonStyle : _disabledButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(32f) }))
			{
				_message = (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.ConfirmSidBanFromQolMenu(_offlineBanSteamIdText) : "SID confirmation is not ready yet.");
				MarkAction(_message);
			}
			GUI.enabled = true;
			if (GUILayout.Button(new GUIContent("Clear Field", "Clear the local draft. This does not change saved bans."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(112f),
				GUILayout.Height(32f)
			}))
			{
				_offlineBanSteamIdText = string.Empty;
				MarkSaved("Cleared the offline SteamID64 draft. Saved native bans were unchanged.");
			}
			GUILayout.EndHorizontal();
			GUILayout.Label("Every preview expires after 30 seconds or a lobby change. Saved entries appear below and can be reversed with Preview SID Unban plus confirmation.", _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.EndVertical();
		}

		private void DrawLocalAuditActions(bool showIdentityNote)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Expected O, but got Unknown
			GUILayout.Label(SessionAuditController.StatusText(), _smallStyle, Array.Empty<GUILayoutOption>());
			if (showIdentityNote)
			{
				GUILayout.Label("Chat records preserve the displayed raw TMP name/message beside plain text. Exact SteamID64 and Steam persona fields are populated only for this verified host/Helper role. Files rotate locally and are never uploaded automatically.", _smallStyle, Array.Empty<GUILayoutOption>());
			}
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (GUILayout.Button(new GUIContent("Snapshot Now", "Create a fresh timestamped copy of the true live BepInEx LogOutput.log, flush the running audit, and copy the new snapshot folder path."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) }))
			{
				_message = SessionAuditController.SnapshotNow();
				MarkAction(_message);
			}
			if (GUILayout.Button(new GUIContent("Copy Audit Folder", "Copy the local session folder path so you can review or attach the files manually."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) }))
			{
				_message = SessionAuditController.CopyAuditFolder();
				MarkAction(_message);
			}
			GUILayout.EndHorizontal();
		}

		private void DrawSelfMovementTools()
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Expected O, but got Unknown
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Expected O, but got Unknown
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Expected O, but got Unknown
			GUILayout.Label("These controls only move your own character. Save Pos stores one local spot; teleport returns you there. Noclip/fly resets off whenever BlueSage loads or unloads.", _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (GUILayout.Button(new GUIContent("Save Pos", "Save your current local player position. It persists locally until you replace it."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) }))
			{
				_message = (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.SaveSelfPositionFromQolMenu() : "Self movement is not ready yet.");
				MarkMovementResult(_message);
			}
			if (GUILayout.Button(new GUIContent("Teleport Saved", "Teleport only your own character to the position saved by Save Pos."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) }))
			{
				_message = (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.TeleportSelfToSavedFromQolMenu() : "Self movement is not ready yet.");
				MarkMovementResult(_message);
			}
			if (GUILayout.Button(new GUIContent(Plugin.ShouldApplyNoclipFly ? "Noclip / Fly: On" : "Noclip / Fly: Off", "Self-only fly: WASD, Space/E up, Ctrl/Q down, Shift boost, Alt precision. Always starts off."), Plugin.ShouldApplyNoclipFly ? _enabledButtonStyle : _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) }))
			{
				_message = (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.ToggleNoclipFlyFromQolMenu() : "Self movement is not ready yet.");
				MarkMovementResult(_message);
			}
			GUILayout.EndHorizontal();
			DrawSelfMovementSetting("Speed x", ref _selfSpeedText, "speed", "0.25-5; 1 is vanilla. This also scales fly speed.");
			DrawSelfMovementSetting("Jump x", ref _selfJumpText, "jump", "0.25-5; 1 is vanilla.");
			DrawSelfMovementSetting("Gravity x", ref _selfGravityText, "gravity", "0.1-5; 1 is vanilla.");
			if (GUILayout.Button(new GUIContent("Reset Self Movement", "Turn fly off and return speed, jump, and gravity to 1x vanilla. Your saved position is kept."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) }))
			{
				_message = (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.ResetSelfMovementFromQolMenu() : "Self movement is not ready yet.");
				HydrateSelfMovementFields();
				MarkMovementResult(_message);
			}
		}

		private void DrawSelfMovementSetting(string label, ref string value, string kind, string rangeHelp)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Expected O, but got Unknown
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Expected O, but got Unknown
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label(new GUIContent(label, "Self-only multiplier. " + rangeHelp), _labelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(110f) });
			string text = GUILayout.TextField(value ?? string.Empty, 12, _textFieldStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(28f) });
			if (!string.Equals(text, value, StringComparison.Ordinal))
			{
				value = text;
				MarkDraft(label + " changed. Save it when ready.");
			}
			if (GUILayout.Button(new GUIContent("Save", "Save " + label + ". " + rangeHelp), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(100f),
				GUILayout.Height(28f)
			}))
			{
				_message = (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.SaveSelfMovementMultiplierFromQolMenu(kind, value) : "Self movement is not ready yet.");
				HydrateSelfMovementFields();
				MarkMovementResult(_message);
			}
			if (GUILayout.Button(new GUIContent("Reset", "Return " + label + " to 1x vanilla."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(100f),
				GUILayout.Height(28f)
			}))
			{
				_message = (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.SaveSelfMovementMultiplierFromQolMenu(kind, "reset") : "Self movement is not ready yet.");
				HydrateSelfMovementFields();
				MarkMovementResult(_message);
			}
			GUILayout.EndHorizontal();
		}

		private void DrawThemeSelector()
		{
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Expected O, but got Unknown
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Expected O, but got Unknown
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Expected O, but got Unknown
			GUILayout.Label("Menu theme", _labelStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label("Applies to the QoL Menu, Style Helper, and command/typeahead popups. Pick what is easiest on your eyes.", _smallStyle, Array.Empty<GUILayoutOption>());
			string[] names = BlueSageUiTheme.Names;
			for (int i = 0; i < names.Length; i += 2)
			{
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				for (int j = 0; j < 2 && i + j < names.Length; j++)
				{
					string text = names[i + j];
					bool flag = string.Equals(BlueSageUiTheme.Normalize(Plugin.UiThemePreset?.Value), BlueSageUiTheme.Normalize(text), StringComparison.OrdinalIgnoreCase);
					if (GUILayout.Button(new GUIContent(flag ? (text + " ✓") : text, "Switch all BlueSage helper UI to " + text + "."), flag ? _activeButtonStyle : _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) }))
					{
						SetTheme(text);
					}
				}
				GUILayout.EndHorizontal();
			}
			if (GUILayout.Button(new GUIContent("Cycle Theme", "Rotate through every available BlueSage menu theme."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) }))
			{
				SetTheme(BlueSageUiTheme.Next(Plugin.UiThemePreset?.Value));
			}
			if (GUILayout.Button(new GUIContent("Reset to BlueSage Harbor", "Return BlueSage helper UI to the balanced cream, coral, sage, and midnight default theme."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) }))
			{
				SetTheme("BlueSage Harbor");
			}
		}

		private void SetTheme(string themeName)
		{
			if (Plugin.UiThemePreset == null)
			{
				_message = "Theme config is not ready yet.";
				return;
			}
			Plugin.UiThemePreset.Value = BlueSageUiTheme.Normalize(themeName);
			Plugin.Instance?.SaveConfigFromQolMenu();
			_message = "Theme set to " + BlueSageUiTheme.Current.DisplayName + ". Other BlueSage UI updates on the next draw.";
			MarkSaved("Theme saved.");
		}

		private void DrawDoNotPressButton()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			if (GUILayout.Button(new GUIContent("DO NOT PRESS", "Extremely dangerous. Definitely not a harmless one-time easter egg. Probably."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(168f),
				GUILayout.Height(28f)
			}))
			{
				bool num = !EasterEggTracker.HasDiscovered("menu_do_not_press");
				string text = EasterEggTracker.Discover("menu_do_not_press", "BlueSage lobby joke discovered");
				if (num)
				{
					bool flag = (Object)(object)Plugin.Instance != (Object)null && Plugin.Instance.TrySendDoNotPressLobbyMessage();
					_message = (flag ? (text + ". One playful line was sent to lobby chat.") : (text + ". Chat was unavailable, so nothing left this client."));
					MarkAction("Optional lobby joke requested.");
				}
				else
				{
					_message = "Already discovered. Repeat presses stay local and send nothing.";
					MarkAction("Optional lobby joke checked again.");
				}
			}
		}

		private void DrawFooter()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			HelpFrameLayout layout = BlueSageHelpFrame.Resolve(BlueSageHelpFrameKind.QolMenu, _windowRect);
			BlueSageHelpFrame.BeginFooter(_footerBoxStyle, layout);
			string stateLine = "State: " + _stateLabel + " — " + _stateDetail;
			BlueSageHelpFrame.DrawStateAndHelp(_footerTextStyle, layout, stateLine, BuildScopedFooterTooltip());
			BlueSageHelpFrame.EndFooter();
		}

		private string BuildScopedFooterTooltip()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = ((Event.current != null) ? Event.current.mousePosition : Vector2.zero);
			if (BlueSageWindowHoverScope.IsWindowHovered(47058))
			{
				Rect val2 = new Rect(0f, 0f, ((Rect)(ref _windowRect)).width, ((Rect)(ref _windowRect)).height);
				if (((Rect)(ref val2)).Contains(val) && !string.IsNullOrWhiteSpace(GUI.tooltip))
				{
					return GUI.tooltip;
				}
			}
			return "Tip: hover a visible QoL Menu control for exact help.";
		}

		private void DrawToggle(string label, ConfigEntry<bool> entry, Action afterChange = null)
		{
			DrawToggle(label, entry, string.Empty, afterChange);
		}

		private void DrawToggle(string label, ConfigEntry<bool> entry, string tooltip, Action afterChange = null)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			if (entry != null)
			{
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				GUILayout.Label(new GUIContent(label, tooltip), _labelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(190f) });
				if (GUILayout.Button(new GUIContent(entry.Value ? "On" : "Off", tooltip), entry.Value ? _enabledButtonStyle : _disabledButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUILayout.Width(88f),
					GUILayout.Height(30f)
				}))
				{
					entry.Value = !entry.Value;
					Plugin.Instance?.SaveConfigFromQolMenu();
					_message = label + ": " + (entry.Value ? "on." : "off.");
					afterChange?.Invoke();
					MarkSaved(label + " saved " + (entry.Value ? "On." : "Off."));
				}
				GUILayout.EndHorizontal();
			}
		}

		private void DrawSpoonsToggle()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Expected O, but got Unknown
			if (Plugin.EnableSpoons == null)
			{
				return;
			}
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label(new GUIContent("Spoons", "Shows or hides your compact [1/5sp] display-name tag. Edit the number in Style Helper > Status."), _labelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(190f) });
			if (GUILayout.Button(new GUIContent(Plugin.EnableSpoons.Value ? "On" : "Off", "Shows or hides your compact [1/5sp] display-name tag. Edit the number in Style Helper > Status."), Plugin.EnableSpoons.Value ? _enabledButtonStyle : _disabledButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(88f),
				GUILayout.Height(30f)
			}))
			{
				bool flag = !Plugin.EnableSpoons.Value;
				bool applied = false;
				_message = (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.TrySetSpoonVisibilityFromMenu(flag, out applied) : "Spoons could not change because the player is not ready yet.");
				if (applied)
				{
					MarkSaved("Spoons saved " + (flag ? "On." : "Off."));
				}
				else
				{
					MarkDraft("Spoons stayed unchanged; fix the reported problem and try again.");
				}
			}
			GUILayout.EndHorizontal();
		}

		private void DrawExperimentalToggle(string label, ConfigEntry<bool> entry, string tooltip, Action afterChange = null)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			if (entry != null)
			{
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				GUILayout.Label(new GUIContent(label, tooltip), _labelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(190f) });
				if (GUILayout.Button(new GUIContent(entry.Value ? "On" : "Off", tooltip), entry.Value ? _experimentalButtonStyle : _disabledButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUILayout.Width(88f),
					GUILayout.Height(30f)
				}))
				{
					entry.Value = !entry.Value;
					Plugin.Instance?.SaveConfigFromQolMenu();
					_message = label + ": " + (entry.Value ? "on." : "off.");
					afterChange?.Invoke();
					MarkSaved(label + " saved " + (entry.Value ? "On." : "Off."));
				}
				GUILayout.EndHorizontal();
			}
		}

		private void DrawTextSetting(string label, ref string value, string buttonLabel, Action saveAction, Func<string> savedValueProvider)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Expected O, but got Unknown
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Expected O, but got Unknown
			string text = BuildTextSettingTooltip(label);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label(new GUIContent(label, text), _labelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(170f) });
			string text2 = value ?? string.Empty;
			string text3 = GUILayout.TextField(text2, 120, _textFieldStyle, (GUILayoutOption[])(object)new GUILayoutOption[3]
			{
				GUILayout.MinWidth(130f),
				GUILayout.ExpandWidth(true),
				GUILayout.Height(28f)
			});
			if (!string.Equals(text3, text2, StringComparison.Ordinal))
			{
				MarkDraft(label + " changed. Press Save or Undo.");
			}
			value = text3;
			if (GUILayout.Button(new GUIContent(buttonLabel, text), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(112f),
				GUILayout.Height(28f)
			}))
			{
				string text4 = ((savedValueProvider != null) ? savedValueProvider() : string.Empty);
				saveAction();
				string b = ((savedValueProvider != null) ? savedValueProvider() : string.Empty);
				if (!string.Equals(text4, b, StringComparison.Ordinal))
				{
					_settingUndoValues[label] = text4;
				}
			}
			string text5 = (_settingUndoValues.ContainsKey(label) ? "Restore the value from before the last successful Save." : "Discard this unsaved edit and reload the saved value.");
			if (GUILayout.Button(new GUIContent("Undo", text5), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(80f),
				GUILayout.Height(28f)
			}))
			{
				if (_settingUndoValues.TryGetValue(label, out var value2))
				{
					value = value2;
					saveAction();
					_settingUndoValues.Remove(label);
					_message = label + " restored to its previous saved value.";
					MarkSaved(label + " change undone.");
				}
				else
				{
					value = ((savedValueProvider != null) ? savedValueProvider() : string.Empty);
					_message = label + " draft discarded; saved value restored.";
					MarkSaved(label + " draft discarded.");
				}
			}
			GUILayout.EndHorizontal();
		}

		private static string BuildTextSettingTooltip(string label)
		{
			switch (label)
			{
			case "Ping sound mode":
				return "Use click, change, error, task, or ticket. Save plays a preview.";
			case "Ping highlight color":
				return "Color behind the whole pinged message. Use hex like FFD700.";
			case "Ping @mention color":
				return "Color for the @name or @lobby token. Default is ping-yellow.";
			case "Chat outline intensity":
				return "Percent from 25 to 100. Default 75 is a stronger readable outline; 100 is crispest.";
			case "Whole chat UI scale":
				return "Percent from 75 to 200. Default 100 keeps vanilla size; larger values scale the whole chat panel, input, backdrop, visible text, and outlines.";
			case "Chat font size":
				return "Percent from 75 to 200. Default 100 keeps vanilla text size; larger values enlarge only message text without scaling the chat shell.";
			case "Chat window height":
				return "Percent from 100 to 200. Default 100 keeps vanilla height; larger values add vertical chat space and deeper visible scrollback without scaling text.";
			case "Normal outline color":
				return "Hex outline color for normal chat text. Default is black: 000000.";
			case "Black text outline color":
				return "Hex outline color for true-black styled chat/name text. Default is light grey: C0C0C0.";
			case "Render saver radius":
				return "Meters around you that stay fully rendered when Player Render Saver is on. Default 45; safe range 10-250.";
			case "Render saver max visible":
				return "Closest remote players kept visible even outside the radius. Default 32; safe range 1-128.";
			case "Spoons 0-5":
				return "Set your optional spoon tag from 0 to 5. Use /spoons off or Hide Spoon Tag to remove it from your name.";
			case "Chat text limit":
			case "Room name limit":
			case "Name/ID limit":
				return "Default/recommended is 3000. Power users can raise up to 4000, but long text may wrap or clip.";
			case "Retained chat rows":
				return "25-250 rows. Default 150 balances useful scrollback with busy-lobby UI cost; BlueSage never lowers a higher vanilla or other-mod limit.";
			default:
				return "Edit this safe local config value, then Save.";
			}
		}

		private void HydrateFields()
		{
			_sweepIntervalText = Plugin.SweepIntervalMinutes?.Value.ToString() ?? "10";
			_pingHighlightText = Plugin.PingHighlightColor?.Value ?? "9B59B6";
			_pingMentionText = Plugin.PingMentionColor?.Value ?? "FFD700";
			_pingSoundModeText = Plugin.GetPingSoundMode();
			_chatOutlineIntensityText = Plugin.LockedChatOutlineIntensityPercent.ToString();
			_chatUiScaleText = Plugin.LockedChatUiScalePercent.ToString();
			_chatFontSizeText = Plugin.LockedChatFontSizePercent.ToString();
			_chatWindowHeightText = Plugin.LockedChatWindowHeightPercent.ToString();
			_chatHistoryRowsText = Plugin.LockedChatHistoryRows.ToString();
			_chatOutlineColorText = Plugin.LockedChatOutlineColorHex;
			_blackChatOutlineColorText = Plugin.LockedBlackChatOutlineColorHex;
			_playerRenderSaverRadiusText = Plugin.LockedPlayerRenderSaverRadiusMeters.ToString();
			_playerRenderSaverMaxVisibleText = Plugin.LockedPlayerRenderSaverMaxVisiblePlayers.ToString();
			_chatLimitText = Plugin.LockedMaxChatCharacters.ToString();
			_profileLimitText = Plugin.LockedMaxIdCardCharacters.ToString();
			_sessionLimitText = Plugin.LockedMaxSessionNameCharacters.ToString();
			HydrateSelfMovementFields();
			MarkSaved("Loaded saved Customize values.");
		}

		private void HydrateSelfMovementFields()
		{
			_selfSpeedText = Plugin.LockedSelfSpeedMultiplier.ToString("0.##", CultureInfo.InvariantCulture);
			_selfJumpText = Plugin.LockedSelfJumpMultiplier.ToString("0.##", CultureInfo.InvariantCulture);
			_selfGravityText = Plugin.LockedSelfGravityMultiplier.ToString("0.##", CultureInfo.InvariantCulture);
		}

		private string BuildStatusLine()
		{
			string text = (Plugin.CanManageHelpers() ? $", Helpers={Plugin.LockedLobbyHelperCount}" : string.Empty);
			object[] array = new object[48];
			array[0] = OnOff(Plugin.EnableAutoSweep);
			array[1] = OnOff(Plugin.EnableHostHealthMonitor);
			array[2] = OnOff(Plugin.EnableLeaveNotifications);
			array[3] = OnOff(Plugin.EnableWelcomeMessage);
			array[4] = OnOff(Plugin.EnableChatTimestamps);
			ConfigEntry<bool> use24HourTime = Plugin.Use24HourTime;
			array[5] = ((use24HourTime != null && !use24HourTime.Value) ? "12hr" : "24hr");
			array[6] = OnOff(Plugin.EnableChatReadability);
			array[7] = OnOff(Plugin.EnablePersistentChatBackdrop);
			array[8] = Plugin.LockedChatOutlineIntensityPercent;
			array[9] = Plugin.LockedChatUiScalePercent;
			array[10] = Plugin.LockedChatFontSizePercent;
			array[11] = Plugin.LockedChatWindowHeightPercent;
			array[12] = Plugin.LockedChatHistoryRows;
			array[13] = Plugin.LockedChatOutlineColorHex;
			array[14] = Plugin.LockedBlackChatOutlineColorHex;
			array[15] = OnOff(Plugin.BlackNamesOutline);
			array[16] = OnOff(Plugin.EnableBetterMove);
			array[17] = OnOff(Plugin.EnableFocusAnywhere);
			array[18] = OnOff(Plugin.EnableEnhancedPlayerPanel);
			array[19] = OnOff(Plugin.EnableReconnectGuard);
			array[20] = OnOff(Plugin.EnableReconnectAnnouncement);
			array[21] = OnOff(Plugin.EnablePingMentions);
			array[22] = text;
			array[23] = OnOff(Plugin.EnablePingSound);
			array[24] = OnOff(Plugin.EnableNoclipFly);
			array[25] = Plugin.LockedSelfSpeedMultiplier;
			array[26] = Plugin.LockedSelfJumpMultiplier;
			array[27] = Plugin.LockedSelfGravityMultiplier;
			array[28] = OnOff(Plugin.EnableCloneShield);
			array[29] = OnOff(Plugin.EnablePlayerRenderSaver);
			array[30] = Plugin.LockedPlayerRenderSaverRadiusMeters;
			array[31] = Plugin.LockedPlayerRenderSaverMaxVisiblePlayers;
			array[32] = PlayerRenderSaverController.LastCandidateRemotePlayers;
			array[33] = PlayerRenderSaverController.LastHiddenRemotePlayers;
			array[34] = PlayerRenderSaverController.LastSuppressedRenderers;
			array[35] = PlayerRenderSaverController.LastRuntimeState;
			array[36] = OnOff(Plugin.EnableChatCopy);
			array[37] = OnOff(Plugin.EnableChatUrlLinks);
			array[38] = OnOff(Plugin.EnableLocalAuditExports);
			array[39] = OnOff(Plugin.EnableSpoons);
			array[40] = OnOff(Plugin.EnableStyleUi);
			array[41] = OnOff(Plugin.EnableExtendedAvatarStyles);
			array[42] = OnOff(Plugin.EnableChalkboardPersistence);
			array[43] = OnOff(Plugin.EnableMiniMapPlayerLabels);
			array[44] = OnOff(Plugin.EnableMiniMapFriendColors);
			array[45] = Plugin.LockedMaxChatCharacters;
			array[46] = Plugin.LockedMaxIdCardCharacters;
			array[47] = Plugin.LockedMaxSessionNameCharacters;
			return string.Format("AutomaticCleanup={0}, HostHealth={1}, LeaveNotices={2}, Welcome={3}, Timestamps={4}/{5}, ChatReadability={6}, ChatBackdrop={7}, ChatOutline={8}%, ChatUIScale={9}%, ChatFont={10}%, ChatWindowHeight={11}%, ChatRows={12}, OutlineColors=#{13}/#{14}, BlackNamesOutline={15}, BetterMove={16}, FocusAnywhere={17}, PlayerPanel={18}, ReconnectGuard={19}, ReconnectMessage={20}, Ping={21}{22}, PingSound={23}, SelfFly={24}, SelfMove={25:0.##}x/{26:0.##}x/{27:0.##}x, CloneShield={28}, RenderSaver={29}({30}m/max{31}, candidates={32}, hidden={33}, renderers={34}, state={35}), CopyChat={36}, ChatLinks={37}, LocalAudit={38}, Spoons={39}, StyleUI={40}, AvatarSlots4-9={41}, Chalkboards={42}, MiniMapIDClick={43}, MiniMapFriends={44}, TextLimits={45}/{46}/{47}.", array);
		}

		private static string OnOff(ConfigEntry<bool> entry)
		{
			if (entry == null || !entry.Value)
			{
				return "off";
			}
			return "on";
		}

		private void MarkDraft(string detail)
		{
			_stateLabel = "Draft";
			_stateDetail = detail ?? "Changes are local until you save or undo.";
		}

		private void MarkSaved(string detail)
		{
			_stateLabel = "Saved";
			_stateDetail = detail ?? "Ready.";
		}

		private void MarkAction(string detail)
		{
			_stateLabel = "Done";
			_stateDetail = detail ?? "Done.";
		}

		private void MarkMovementResult(string detail)
		{
			string text = detail ?? string.Empty;
			if (string.IsNullOrWhiteSpace(text) || text.IndexOf("not ready", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("no saved position", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("unknown multiplier", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("use a number", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				MarkDraft((text.Length > 0) ? text : "Self movement action did not run.");
			}
			else
			{
				MarkSaved(text);
			}
		}

		private void SaveSweepInterval()
		{
			if (!int.TryParse(_sweepIntervalText, out var result))
			{
				_message = "Sweep interval must be a number from 5 to 180.";
				MarkDraft("Fix sweep interval to a number from 5 to 180.");
				return;
			}
			int value = SweepSettingsPolicy.ClampIntervalMinutes(result);
			Plugin.SweepIntervalMinutes.Value = value;
			Plugin.Instance?.SaveConfigFromQolMenu();
			Plugin.Instance?.ReconcileSweepScheduleFromMenu();
			_sweepIntervalText = value.ToString();
			_message = "Sweep interval saved: " + value + " minutes.";
			MarkSaved("Sweep interval saved.");
		}

		private void SaveHex(ConfigEntry<string> entry, string value, string label)
		{
			if (entry != null)
			{
				if (!RichTextStyleBuilder.TryNormalizeHex(value, out var hex))
				{
					_message = label + ": use a hex color like FF66CC or #83E.";
					MarkDraft("Fix " + label + " to a valid hex color.");
					return;
				}
				entry.Value = hex;
				Plugin.Instance?.SaveConfigFromQolMenu();
				_message = label + " saved: #" + hex + ".";
				MarkSaved(label + " saved.");
			}
		}

		private void SaveText(ConfigEntry<string> entry, string value, string label)
		{
			if (entry != null)
			{
				entry.Value = (value ?? string.Empty).Trim();
				Plugin.Instance?.SaveConfigFromQolMenu();
				_message = label + " saved.";
				MarkSaved(label + " saved.");
			}
		}

		private void SaveCharacterLimit(ConfigEntry<int> entry, string value, string label, Func<int, int> clamp, Action<int> hydrate)
		{
			if (entry != null)
			{
				if (!int.TryParse(value, out var result))
				{
					_message = label + ": enter a number from 1 to 4000. Default/recommended is 3000.";
					MarkDraft("Fix " + label + " to a number from 1 to 4000.");
					return;
				}
				int num = (entry.Value = clamp(result));
				Plugin.Instance?.SaveConfigFromQolMenu();
				hydrate(num);
				_message = ((num > 3000) ? (label + " saved at " + num + ". Heads up: past 3000 may wrap, clip, or look visually messy.") : (label + " saved at " + num + "."));
				MarkSaved(label + " saved.");
			}
		}

		private void SaveOutlineIntensity()
		{
			if (Plugin.ChatOutlineIntensity != null)
			{
				if (!int.TryParse((_chatOutlineIntensityText ?? string.Empty).Trim().TrimEnd(new char[1] { '%' }), out var result))
				{
					_message = "Chat outline intensity: enter a number from 25 to 100.";
					MarkDraft("Fix chat outline intensity to a number from 25 to 100.");
					return;
				}
				int value = ChatReadabilityStylePolicy.ClampOutlineIntensityPercent(result);
				Plugin.ChatOutlineIntensity.Value = value;
				Plugin.Instance?.SaveConfigFromQolMenu();
				ChatReadabilityPatch.RefreshVisibleChat();
				_chatOutlineIntensityText = value.ToString();
				_message = "Chat outline intensity saved: " + value + "%.";
				MarkSaved("Chat outline intensity saved.");
			}
		}

		private void SaveChatUiScale()
		{
			if (Plugin.ChatUiScalePercent != null)
			{
				if (!ChatAccessibilityScalePolicy.TryParseScaleToken((_chatUiScaleText ?? string.Empty).Trim(), out var percent))
				{
					_message = "Whole chat UI scale: enter 75-200, decimal scale like 1.25, or reset. Use Chat font size for text-only growth.";
					MarkDraft("Fix whole chat UI scale to a number from 75 to 200.");
					return;
				}
				Plugin.ChatUiScalePercent.Value = percent;
				Plugin.Instance?.SaveConfigFromQolMenu();
				ChatReadabilityPatch.RequestRefreshSoon();
				_chatUiScaleText = percent.ToString();
				_message = "Whole chat UI scale saved: " + percent + "%. This grows the panel, input, backdrop, text, and outlines together.";
				MarkSaved("Whole chat UI scale saved.");
			}
		}

		private void SaveChatFontSize()
		{
			if (Plugin.ChatFontSizePercent != null)
			{
				if (!ChatFontSizePolicy.TryParseFontSizeToken((_chatFontSizeText ?? string.Empty).Trim(), out var percent))
				{
					_message = "Chat font size: enter 75-200, decimal size like 1.25, on/off, or reset. This changes message text only.";
					MarkDraft("Fix chat font size to a number from 75 to 200.");
					return;
				}
				Plugin.ChatFontSizePercent.Value = percent;
				Plugin.Instance?.SaveConfigFromQolMenu();
				ChatReadabilityPatch.RequestRefreshSoon();
				_chatFontSizeText = percent.ToString();
				_message = "Chat font size saved: " + percent + "%. Message text grows without scaling the chat panel.";
				MarkSaved("Chat font size saved.");
			}
		}

		private void SaveChatWindowHeight()
		{
			if (Plugin.ChatWindowHeightPercent != null)
			{
				if (!ChatWindowHeightPolicy.TryParseHeightToken((_chatWindowHeightText ?? string.Empty).Trim(), out var percent))
				{
					_message = "Chat window height: enter 100-200, decimal size like 1.5, or reset. This adds vertical log space only.";
					MarkDraft("Fix chat window height to a number from 100 to 200.");
					return;
				}
				Plugin.ChatWindowHeightPercent.Value = percent;
				Plugin.Instance?.SaveConfigFromQolMenu();
				ChatReadabilityPatch.RequestRefreshSoon();
				_chatWindowHeightText = percent.ToString();
				_message = "Chat window height saved: " + percent + "%. Drag the vanilla chat handle if you want to reposition it.";
				MarkSaved("Chat window height saved.");
			}
		}

		private void SaveChatHistoryRows()
		{
			if (Plugin.ChatHistoryRows != null)
			{
				string text = (_chatHistoryRowsText ?? string.Empty).Trim();
				if (string.Equals(text, "reset", StringComparison.OrdinalIgnoreCase) || string.Equals(text, "default", StringComparison.OrdinalIgnoreCase))
				{
					text = 150.ToString();
				}
				if (!int.TryParse(text, out var result))
				{
					_message = "Retained chat rows: enter 25-250 or reset. Default 150 is recommended for busy lobbies.";
					MarkDraft("Fix retained chat rows to a number from 25 to 250.");
					return;
				}
				int value = ChatHistoryLimitPolicy.ClampRows(result);
				Plugin.ChatHistoryRows.Value = value;
				Plugin.Instance?.SaveConfigFromQolMenu();
				_chatHistoryRowsText = value.ToString();
				_message = "Retained chat rows saved: " + value + ". Higher values use more UI memory/work; higher vanilla or other-mod limits are never reduced.";
				MarkSaved("Retained chat rows saved.");
			}
		}

		private void SavePlayerRenderSaverRadius()
		{
			if (Plugin.PlayerRenderSaverRadiusMeters != null)
			{
				if (!int.TryParse((_playerRenderSaverRadiusText ?? string.Empty).Trim().TrimEnd(new char[1] { 'm' }), out var result))
				{
					_message = "Render saver radius: enter meters from 10 to 250.";
					MarkDraft("Fix render saver radius to a number from 10 to 250.");
					return;
				}
				int value = PlayerRenderSaverPolicy.ClampRadiusMeters(result);
				Plugin.PlayerRenderSaverRadiusMeters.Value = value;
				Plugin.Instance?.SaveConfigFromQolMenu();
				_playerRenderSaverRadiusText = value.ToString();
				_message = "Render saver radius saved: " + value + "m.";
				MarkSaved("Render saver radius saved.");
			}
		}

		private void SavePlayerRenderSaverMaxVisible()
		{
			if (Plugin.PlayerRenderSaverMaxVisiblePlayers != null)
			{
				if (!int.TryParse((_playerRenderSaverMaxVisibleText ?? string.Empty).Trim(), out var result))
				{
					_message = "Render saver max visible: enter a number from 1 to 128.";
					MarkDraft("Fix render saver max visible to a number from 1 to 128.");
					return;
				}
				int value = PlayerRenderSaverPolicy.ClampMaxVisiblePlayers(result);
				Plugin.PlayerRenderSaverMaxVisiblePlayers.Value = value;
				Plugin.Instance?.SaveConfigFromQolMenu();
				_playerRenderSaverMaxVisibleText = value.ToString();
				_message = "Render saver max visible saved: " + value + ".";
				MarkSaved("Render saver max visible saved.");
			}
		}

		private void SavePingSoundMode()
		{
			string text = (_pingSoundModeText ?? string.Empty).Trim().ToLowerInvariant();
			switch (text)
			{
			case "click":
			case "change":
			case "error":
			case "task":
			case "ticket":
				Plugin.PingSoundMode.Value = text;
				Plugin.EnablePingSound.Value = true;
				Plugin.Instance?.SaveConfigFromQolMenu();
				_pingSoundModeText = text;
				MentionPingController.PlayConfiguredPing();
				_message = "Ping sound mode saved: " + text + ".";
				MarkSaved("Ping sound mode saved.");
				break;
			default:
				_message = "Ping sound mode: use click, change, error, task, or ticket.";
				MarkDraft("Fix ping sound mode to click, change, error, task, or ticket.");
				break;
			}
		}

		private void ClampWindowToScreen()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			WindowFitResult windowFitResult = BlueSageWindowCoordinator.ResolveForFrame(BlueSagePublicWindow.QolMenu, _windowRect, 920f, 640f, Screen.width, Screen.height);
			_windowRect = new Rect(windowFitResult.X, windowFitResult.Y, windowFitResult.Width, windowFitResult.Height);
		}

		private void OnDisable()
		{
			BlueSageWindowCoordinator.SetVisible(BlueSagePublicWindow.QolMenu, visible: false);
			BlueSageWindowHoverScope.UnregisterWindow(47058);
		}

		private void DrawResizeGrip()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Invalid comparison between Unknown and I4
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(((Rect)(ref _windowRect)).width - 42f - 8f, ((Rect)(ref _windowRect)).height - 42f - 8f, 42f, 42f);
			GUI.Box(val, new GUIContent("↘", "Drag this larger corner handle to resize the QoL Menu."), _buttonStyle);
			Event current = Event.current;
			if (current != null)
			{
				if ((int)current.type == 0 && ((Rect)(ref val)).Contains(current.mousePosition))
				{
					_isResizing = true;
					current.Use();
				}
				else if (_isResizing && (int)current.type == 3)
				{
					ref Rect windowRect = ref _windowRect;
					((Rect)(ref windowRect)).width = ((Rect)(ref windowRect)).width + current.delta.x;
					ref Rect windowRect2 = ref _windowRect;
					((Rect)(ref windowRect2)).height = ((Rect)(ref windowRect2)).height + current.delta.y;
					ClampWindowToScreen();
					current.Use();
				}
				else if (_isResizing && (int)current.rawType == 1)
				{
					_isResizing = false;
					current.Use();
				}
			}
		}

		private void EnsureStyles()
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected O, but got Unknown
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Expected O, but got Unknown
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Expected O, but got Unknown
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Expected O, but got Unknown
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Expected O, but got Unknown
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Expected O, but got Unknown
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_027e: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f5: Expected O, but got Unknown
			//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0301: Unknown result type (might be due to invalid IL or missing references)
			//IL_0310: Unknown result type (might be due to invalid IL or missing references)
			//IL_031c: Unknown result type (might be due to invalid IL or missing references)
			//IL_032b: Expected O, but got Unknown
			//IL_0336: Unknown result type (might be due to invalid IL or missing references)
			//IL_033b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0344: Unknown result type (might be due to invalid IL or missing references)
			//IL_034e: Expected O, but got Unknown
			//IL_034e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0353: Unknown result type (might be due to invalid IL or missing references)
			//IL_035d: Expected O, but got Unknown
			//IL_035d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0362: Unknown result type (might be due to invalid IL or missing references)
			//IL_036c: Expected O, but got Unknown
			//IL_036c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0378: Unknown result type (might be due to invalid IL or missing references)
			//IL_0383: Unknown result type (might be due to invalid IL or missing references)
			//IL_0392: Unknown result type (might be due to invalid IL or missing references)
			//IL_039e: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ad: Expected O, but got Unknown
			//IL_03b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0410: Unknown result type (might be due to invalid IL or missing references)
			//IL_0415: Unknown result type (might be due to invalid IL or missing references)
			//IL_0421: Unknown result type (might be due to invalid IL or missing references)
			//IL_042c: Unknown result type (might be due to invalid IL or missing references)
			//IL_043b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0447: Unknown result type (might be due to invalid IL or missing references)
			//IL_0456: Expected O, but got Unknown
			//IL_045d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0462: Unknown result type (might be due to invalid IL or missing references)
			//IL_046a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0476: Unknown result type (might be due to invalid IL or missing references)
			//IL_0485: Expected O, but got Unknown
			//IL_048c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0491: Unknown result type (might be due to invalid IL or missing references)
			//IL_049d: Expected O, but got Unknown
			//IL_04a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c0: Expected O, but got Unknown
			//IL_04c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cf: Expected O, but got Unknown
			//IL_04cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_04db: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0501: Unknown result type (might be due to invalid IL or missing references)
			//IL_0510: Expected O, but got Unknown
			//IL_051b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0520: Unknown result type (might be due to invalid IL or missing references)
			//IL_0527: Unknown result type (might be due to invalid IL or missing references)
			//IL_052f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0536: Unknown result type (might be due to invalid IL or missing references)
			//IL_053d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0549: Unknown result type (might be due to invalid IL or missing references)
			//IL_0558: Expected O, but got Unknown
			_theme = BlueSageUiTheme.Current;
			if (_windowStyle == null || !string.Equals(_renderedThemeKey, _theme.Key, StringComparison.Ordinal) || _renderedTextureGeneration != BlueSageUiTheme.RuntimeTextureGeneration || !BlueSageUiTheme.AreRuntimeTexturesAlive())
			{
				_renderedThemeKey = _theme.Key;
				_windowBackgroundTexture = BlueSageUiTheme.GetSolidTexture(_theme.Window);
				GUIStyle val = new GUIStyle(GUI.skin.window)
				{
					padding = new RectOffset(16, 16, 46, 14)
				};
				val.normal.background = _windowBackgroundTexture;
				val.normal.textColor = _theme.LabelText;
				_windowStyle = val;
				GUIStyle val2 = new GUIStyle(GUI.skin.box);
				val2.normal.background = BlueSageUiTheme.GetSolidTexture(_theme.Header);
				_headerBoxStyle = val2;
				GUIStyle val3 = new GUIStyle(GUI.skin.label)
				{
					fontSize = 18,
					fontStyle = (FontStyle)1
				};
				val3.normal.textColor = _theme.HeaderText;
				_headerStyle = val3;
				GUIStyle val4 = new GUIStyle(GUI.skin.label)
				{
					fontSize = 14,
					fontStyle = (FontStyle)1
				};
				val4.normal.textColor = _theme.LabelText;
				_labelStyle = val4;
				GUIStyle val5 = new GUIStyle(GUI.skin.label)
				{
					richText = false,
					fontSize = 15,
					fontStyle = (FontStyle)1,
					wordWrap = true
				};
				val5.normal.textColor = Color.Lerp(_theme.SmallText, _theme.LabelText, 0.35f);
				_smallStyle = val5;
				_buttonStyle = BlueSageUiTheme.CreateNeutralButtonStyle(GUI.skin.button, _theme, 13);
				_activeButtonStyle = BlueSageUiTheme.CreateStateButtonStyle(_buttonStyle, _theme.ActiveAccent, _theme.FieldFocusedBorder, _theme.ActiveStateText, 13);
				_enabledButtonStyle = BlueSageUiTheme.CreateStateButtonStyle(_buttonStyle, _theme.EnabledAccent, Color.Lerp(_theme.EnabledAccent, Color.white, 0.28f), _theme.EnabledButtonText, 13);
				_disabledButtonStyle = BlueSageUiTheme.CreateStateButtonStyle(_buttonStyle, _theme.DisabledAccent, Color.Lerp(_theme.DisabledAccent, Color.white, 0.2f), _theme.DisabledButtonText, 13);
				_experimentalButtonStyle = BlueSageUiTheme.CreateStateButtonStyle(_buttonStyle, _theme.ExperimentalAccent, Color.Lerp(_theme.ExperimentalAccent, Color.black, 0.25f), _theme.ExperimentalButtonText, 13);
				GUIStyle val6 = new GUIStyle(GUI.skin.box)
				{
					padding = new RectOffset(12, 12, 10, 10)
				};
				val6.normal.background = BlueSageUiTheme.GetSolidTexture(_theme.Panel);
				val6.normal.textColor = _theme.LabelText;
				_boxStyle = val6;
				GUIStyle val7 = new GUIStyle(GUI.skin.box)
				{
					padding = new RectOffset(14, 14, 12, 12),
					margin = new RectOffset(0, 0, 0, 0),
					border = new RectOffset(1, 1, 1, 1)
				};
				val7.normal.background = BlueSageUiTheme.GetPanelTexture(_theme.SectionPanel, _theme.SectionBorder);
				val7.normal.textColor = _theme.LabelText;
				_sectionBoxStyle = val7;
				_comfortSectionBoxStyle = CreateAccentedSectionStyle(_theme.ComfortAccent);
				_chatSectionBoxStyle = CreateAccentedSectionStyle(_theme.ChatAccent);
				_identitySectionBoxStyle = CreateAccentedSectionStyle(_theme.IdentityAccent);
				_personalizationSectionBoxStyle = CreateAccentedSectionStyle(_theme.PersonalizationAccent);
				GUIStyle val8 = new GUIStyle(_sectionBoxStyle);
				val8.normal.background = BlueSageUiTheme.GetPanelTexture(_theme.SectionPanel, _theme.ExperimentalBorder);
				val8.normal.textColor = _theme.LabelText;
				_experimentalBoxStyle = val8;
				GUIStyle val9 = new GUIStyle(_labelStyle)
				{
					fontSize = 17
				};
				val9.normal.textColor = _theme.LabelText;
				_sectionHeaderStyle = val9;
				_navigationHintStyle = new GUIStyle(_smallStyle)
				{
					richText = true
				};
				GUIStyle val10 = new GUIStyle(GUI.skin.box)
				{
					padding = new RectOffset(14, 56, 10, 10),
					border = new RectOffset(1, 1, 1, 1)
				};
				val10.normal.background = BlueSageUiTheme.GetPanelTexture(_theme.FooterBackground, _theme.FooterBorder);
				val10.normal.textColor = _theme.FooterText;
				_footerBoxStyle = val10;
				GUIStyle val11 = new GUIStyle(GUI.skin.label)
				{
					richText = false,
					fontSize = 14,
					fontStyle = (FontStyle)1,
					wordWrap = true
				};
				val11.normal.textColor = _theme.FooterText;
				_footerTextStyle = val11;
				_textFieldStyle = BlueSageUiTheme.CreateTextInputStyle(GUI.skin.textField, _theme, 14, wordWrap: true);
				_renderedTextureGeneration = BlueSageUiTheme.RuntimeTextureGeneration;
			}
		}

		private GUIStyle CreateAccentedSectionStyle(Color accent)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			GUIStyle val = new GUIStyle(_sectionBoxStyle);
			val.normal.background = BlueSageUiTheme.GetPanelTexture(_theme.SectionPanel, accent);
			val.normal.textColor = _theme.LabelText;
			return val;
		}

		private static void SetAllStateTextColors(GUIStyle style, Color text)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			style.normal.textColor = text;
			style.hover.textColor = text;
			style.active.textColor = text;
			style.focused.textColor = text;
			style.onNormal.textColor = text;
			style.onHover.textColor = text;
			style.onActive.textColor = text;
			style.onFocused.textColor = text;
		}
	}
	internal sealed class SessionAuditController : MonoBehaviour
	{
		private sealed class PendingModerationSave
		{
			internal string Action = string.Empty;

			internal string Source = string.Empty;

			internal string SteamId = string.Empty;

			internal string DisplayNameRaw = string.Empty;

			internal string Persona = string.Empty;

			internal string IssuerSteamId = string.Empty;

			internal string IncidentId = string.Empty;

			internal string TargetRole = string.Empty;
		}

		private const long MaxChatPartBytes = 16777216L;

		private const long MaxBepInExPartBytes = 67108864L;

		private const int MaxChatParts = 4;

		private const int MaxBepInExParts = 2;

		private const int MaxRetainedSessions = 12;

		private const int RetentionDays = 14;

		private const int MirrorChunkBytes = 524288;

		private static SessionAuditController _instance;

		private static PendingModerationSave _pendingModerationSave;

		private readonly Dictionary<string, NativeBanRecord> _nativeBanSnapshot = new Dictionary<string, NativeBanRecord>(StringComparer.Ordinal);

		private readonly AuditMirrorTransferBuffer _bepInExMirrorBuffer = new AuditMirrorTransferBuffer();

		private string _sessionDirectory = string.Empty;

		private string _chatPath = string.Empty;

		private string _bepInExPath = string.Empty;

		private StreamWriter _chatWriter;

		private FileStream _bepInExWriter;

		private long _bepInExSourceOffset;

		private int _chatPart = 1;

		private int _bepInExPart = 1;

		private float _nextMaintenanceAt;

		private bool _nativeBanSnapshotReady;

		private bool _initializationFailed;

		private bool _wasDisabled;

		private bool _suppressNextBanBaselineEvents;

		internal static string AuditRoot
		{
			get
			{
				try
				{
					return Path.Combine(Paths.BepInExRootPath, "BlueSageAudit");
				}
				catch
				{
					return Path.Combine(Environment.CurrentDirectory, "BepInEx", "BlueSageAudit");
				}
			}
		}

		internal static bool Enabled
		{
			get
			{
				if (Plugin.EnableLocalAuditExports != null)
				{
					return Plugin.EnableLocalAuditExports.Value;
				}
				return false;
			}
		}

		internal static string CurrentSessionDirectory => _instance?._sessionDirectory ?? AuditRoot;

		internal static string CurrentChatPath => _instance?._chatPath ?? Path.Combine(AuditRoot, "chat-audit-not-started.jsonl");

		internal static string CurrentBepInExPath => _instance?._bepInExPath ?? Path.Combine(AuditRoot, "bepinex-not-started.log");

		private void Awake()
		{
			_instance = this;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			EnsureInitialized();
		}

		private void Update()
		{
			if (!(Time.unscaledTime < _nextMaintenanceAt))
			{
				_nextMaintenanceAt = Time.unscaledTime + 1f;
				if (!Enabled)
				{
					PauseCapture();
					return;
				}
				EnsureInitialized();
				MirrorBepInExLog(524288);
				PollNativeBanStore();
			}
		}

		private void OnDestroy()
		{
			if (Enabled)
			{
				MirrorBepInExLog(8388608);
				PollNativeBanStore();
			}
			CloseWriters();
			if (_instance == this)
			{
				_instance = null;
			}
		}

		internal static void RecordChat(string displayNameRaw, string messageRaw, bool isLocal, int senderIndex, AuthoritativeChatSenderContext senderContext)
		{
			if (!Enabled || (Object)(object)_instance == (Object)null)
			{
				return;
			}
			_instance.EnsureInitialized();
			if (_instance._chatWriter != null)
			{
				bool isHost;
				bool num = Plugin.CanUseLobbySafety(out isHost);
				string identityState = (num ? "unverified-current-row" : "redacted-normal-client");
				string observerAuthority = ((!num) ? "normal-client" : (isHost ? "host" : "helper"));
				string senderRole = string.Empty;
				string steamId = string.Empty;
				string rosterNameRaw = string.Empty;
				string steamPersona = string.Empty;
				int senderIndex2 = senderIndex;
				if (num && senderContext != null && senderContext.ExactTupleCaptured)
				{
					identityState = "verified-current-row";
					senderRole = senderContext.Role;
					steamId = senderContext.SteamId;
					rosterNameRaw = senderContext.RosterNameRaw;
					steamPersona = senderContext.SteamPersona;
					senderIndex2 = senderContext.NativeRowIndex;
				}
				_instance.AppendChatLine(SessionAuditPolicy.BuildChatRecord(UtcNow(), isLocal ? "local" : "global", senderIndex2, identityState, observerAuthority, senderRole, steamId, displayNameRaw ?? string.Empty, rosterNameRaw, steamPersona, messageRaw ?? string.Empty, CurrentAuditLobbyId()));
			}
		}

		internal static void RecordNotification(string text)
		{
			if (Enabled && !((Object)(object)_instance == (Object)null))
			{
				_instance.EnsureInitialized();
				_instance.AppendChatLine(SessionAuditPolicy.BuildNotificationRecord(UtcNow(), text ?? string.Empty, CurrentAuditLobbyId()));
			}
		}

		internal static void RecordRunMarker(string classification, string ageBucket, string markerPath)
		{
			if (Enabled && !((Object)(object)_instance == (Object)null))
			{
				_instance.EnsureInitialized();
				_instance.AppendChatLine(SessionAuditPolicy.BuildRunMarkerRecord(UtcNow(), classification ?? string.Empty, ageBucket ?? string.Empty, Path.GetFileName(markerPath ?? string.Empty)));
			}
		}

		internal static void RecordIdentityResync(string source, string outcome, int targetedRows, int healedRows, int lockedRows, long durationMilliseconds, string reason)
		{
			if (Enabled && !((Object)(object)_instance == (Object)null))
			{
				_instance.EnsureInitialized();
				string text = (reason ?? string.Empty).Replace("\r", " ").Replace("\n", " ").Replace("|", "/")
					.Trim();
				if (text.Length > 160)
				{
					text = text.Substring(0, 160);
				}
				string textRaw = "identity-resync|source=" + (source ?? string.Empty) + "|outcome=" + (outcome ?? string.Empty) + "|targetedRows=" + Math.Max(0, targetedRows) + "|healedRows=" + Math.Max(0, healedRows) + "|lockedRows=" + Math.Max(0, lockedRows) + "|durationMilliseconds=" + Math.Max(0L, durationMilliseconds) + "|reason=" + text;
				_instance.AppendChatLine(SessionAuditPolicy.BuildNotificationRecord(UtcNow(), textRaw, string.Empty));
			}
		}

		internal static void RecordModeration(string action, string source, string outcome, string steamId, string displayNameRaw, string persona, string issuerSteamId = "", string incidentId = "", string targetRole = "")
		{
			if (!Enabled || (Object)(object)_instance == (Object)null || !Plugin.CanUseLobbySafety(out var _))
			{
				return;
			}
			_instance.EnsureInitialized();
			if (_instance._nativeBanSnapshotReady && ModerationProtocolPolicy.IsSteamId64(steamId))
			{
				if (string.Equals(action, "ban-added", StringComparison.Ordinal))
				{
					_instance._nativeBanSnapshot[steamId] = new NativeBanRecord(steamId, displayNameRaw);
				}
				else if (string.Equals(action, "ban-removed", StringComparison.Ordinal))
				{
					_instance._nativeBanSnapshot.Remove(steamId);
				}
			}
			_instance.AppendChatLine(SessionAuditPolicy.BuildModerationRecord(UtcNow(), action ?? string.Empty, source ?? string.Empty, outcome ?? string.Empty, steamId ?? string.Empty, displayNameRaw ?? string.Empty, persona ?? string.Empty, CurrentAuditLobbyId(), issuerSteamId ?? string.Empty, incidentId ?? string.Empty, targetRole ?? string.Empty));
		}

		internal static void ArmPersistedModerationAudit(string action, string source, string steamId, string displayNameRaw, string persona, string issuerSteamId, string incidentId, string targetRole)
		{
			if (Enabled && !((Object)(object)_instance == (Object)null) && Plugin.CanUseLobbySafety(out var isHost) && isHost)
			{
				_pendingModerationSave = new PendingModerationSave
				{
					Action = (action ?? string.Empty),
					Source = (source ?? string.Empty),
					SteamId = (steamId ?? string.Empty),
					DisplayNameRaw = (displayNameRaw ?? string.Empty),
					Persona = (persona ?? string.Empty),
					IssuerSteamId = (issuerSteamId ?? string.Empty),
					IncidentId = (incidentId ?? string.Empty),
					TargetRole = (targetRole ?? string.Empty)
				};
			}
		}

		internal static void CancelPersistedModerationAudit()
		{
			_pendingModerationSave = null;
		}

		internal static void CapturePersistedNativeBanSave()
		{
			if (!Enabled || (Object)(object)_instance == (Object)null || !Plugin.CanUseLobbySafety(out var isHost) || !isHost)
			{
				_pendingModerationSave = null;
				return;
			}
			PendingModerationSave pendingModerationSave = _pendingModerationSave;
			_pendingModerationSave = null;
			if (pendingModerationSave != null)
			{
				RecordModeration(pendingModerationSave.Action, pendingModerationSave.Source, "persisted", pendingModerationSave.SteamId, pendingModerationSave.DisplayNameRaw, pendingModerationSave.Persona, pendingModerationSave.IssuerSteamId, pendingModerationSave.IncidentId, pendingModerationSave.TargetRole);
				_instance.SynchronizeNativeBanSnapshot();
			}
			else
			{
				_instance.PollNativeBanStore("native-ban-save-observed");
			}
		}

		internal static string StatusText()
		{
			if (!Enabled)
			{
				return "Local session audit: off. Use /auditlog on to resume local chat and BepInEx exports.";
			}
			if ((Object)(object)_instance == (Object)null || _instance._initializationFailed || _instance._chatWriter == null || _instance._bepInExWriter == null)
			{
				return "Local session audit: configured on but NOT WRITING. Use /auditlog on to retry; check the BepInEx log for the local file error before relying on incident evidence.";
			}
			bool isHost;
			string text = ((!Plugin.CanUseLobbySafety(out isHost)) ? "normal-client transcript; exact Steam IDs are not added by BlueSage" : (isHost ? "exact identity enrichment active for host" : "exact identity enrichment active for assigned Helper"));
			return "Local session audit: on; " + text + ". Chat JSONL and a running BepInEx mirror are stored under " + CurrentSessionDirectory + ". Snapshot Now creates a fresh timestamped copy of the true live BepInEx LogOutput.log.";
		}

		internal static string CopyAuditFolder()
		{
			GUIUtility.systemCopyBuffer = CurrentSessionDirectory;
			return "Local audit folder copied. It stays on this computer until you choose to share it.";
		}

		internal static string SnapshotNow()
		{
			if (!Enabled || (Object)(object)_instance == (Object)null)
			{
				return "Local session audit is off.";
			}
			_instance.EnsureInitialized();
			if (_instance._initializationFailed || _instance._chatWriter == null || _instance._bepInExWriter == null)
			{
				return "Local audit snapshot FAILED: one or both local writers are unavailable. Use /auditlog on to retry, then /auditlog status before relying on the export.";
			}
			_instance.MirrorBepInExLog(8388608);
			if (_instance._initializationFailed || _instance._chatWriter == null || _instance._bepInExWriter == null)
			{
				return "Local audit snapshot FAILED while mirroring BepInEx output. Use /auditlog on to retry, then /auditlog status before relying on the export.";
			}
			_instance.WriteRosterCheckpoint();
			_instance.PollNativeBanStore();
			try
			{
				_instance._chatWriter.Flush();
				_instance._bepInExWriter.Flush();
			}
			catch (Exception ex)
			{
				_instance.MarkCaptureFailed("snapshot flush", ex);
				return "Local audit snapshot FAILED while flushing files. Use /auditlog on to retry, then /auditlog status before relying on the export.";
			}
			if (!AuditSnapshotPolicy.TryCreate(Path.Combine(Paths.BepInExRootPath, "LogOutput.log"), _instance._sessionDirectory, DateTime.UtcNow, Guid.NewGuid().ToString("N").Substring(0, 8), out var snapshotDirectory, out var capturedBytes, out var error))
			{
				return "Local audit snapshot FAILED while copying the true BepInEx LogOutput.log: " + error;
			}
			GUIUtility.systemCopyBuffer = snapshotDirectory;
			return "Local audit snapshot saved: " + snapshotDirectory + " (" + capturedBytes + " bytes from the true BepInEx LogOutput.log). The snapshot folder path was copied.";
		}

		internal static void ReconcileEnabledState()
		{
			if ((Object)(object)_instance == (Object)null)
			{
				return;
			}
			if (Enabled)
			{
				bool wasDisabled = _instance._wasDisabled;
				if (_instance._wasDisabled)
				{
					_instance.AdvanceBepInExSourceOffsetToEnd();
					_instance._wasDisabled = false;
				}
				_instance._initializationFailed = false;
				_instance.EnsureInitialized();
				if (wasDisabled)
				{
					_instance.AppendChatLine(SessionAuditPolicy.BuildNotificationRecord(UtcNow(), "Local audit capture resumed after an opt-out gap; events from the disabled period were not backfilled.", CurrentAuditLobbyId()));
				}
			}
			else
			{
				_instance.PauseCapture();
			}
		}

		private void EnsureInitialized()
		{
			if (_initializationFailed || !Enabled || (_chatWriter != null && _bepInExWriter != null))
			{
				return;
			}
			try
			{
				Directory.CreateDirectory(AuditRoot);
				PruneOldSessions();
				if (string.IsNullOrWhiteSpace(_sessionDirectory))
				{
					string text = DateTime.UtcNow.ToString("yyyyMMddTHHmmssZ") + "-" + Guid.NewGuid().ToString("N").Substring(0, 8);
					_sessionDirectory = Path.Combine(AuditRoot, "session-" + text);
					Directory.CreateDirectory(_sessionDirectory);
					File.WriteAllText(Path.Combine(_sessionDirectory, "README.txt"), "BlueSage QoL local session audit\r\nContains a chat/notification JSONL transcript and a running mirror of BepInEx/LogOutput.log.\r\nChat raw fields are the rendered UI arguments seen after the game's/mods' earlier patches, not a pristine network payload.\r\nExact SteamID/persona enrichment is written only while this client is the verified host or an assigned Helper.\r\nThe BepInEx mirror faithfully preserves whatever the game and installed mods already write, which may include player identifiers.\r\nThese files are never uploaded automatically. Review them before sharing.\r\n", new UTF8Encoding(encoderShouldEmitUTF8Identifier: false));
					PruneOldSessions();
				}
				OpenChatWriter();
				OpenBepInExWriter();
				MirrorBepInExLog(8388608);
			}
			catch (Exception ex)
			{
				_initializationFailed = true;
				CloseWriters();
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Local audit export could not start: " + ex.GetType().Name + ": " + ex.Message));
				}
			}
		}

		private void OpenChatWriter(bool truncate = false)
		{
			_chatPath = Path.Combine(_sessionDirectory, PartName("chat-audit", _chatPart, ".jsonl"));
			_chatWriter = new StreamWriter(new FileStream(_chatPath, truncate ? FileMode.Create : FileMode.Append, FileAccess.Write, FileShare.Read), new UTF8Encoding(encoderShouldEmitUTF8Identifier: false))
			{
				AutoFlush = true
			};
		}

		private void OpenBepInExWriter(bool truncate = false)
		{
			_bepInExPath = Path.Combine(_sessionDirectory, PartName("bepinex", _bepInExPart, ".log"));
			_bepInExWriter = new FileStream(_bepInExPath, truncate ? FileMode.Create : FileMode.Append, FileAccess.Write, FileShare.Read);
		}

		private void AppendChatLine(string line)
		{
			if (_chatWriter == null || string.IsNullOrWhiteSpace(line))
			{
				return;
			}
			try
			{
				if (_chatWriter.BaseStream.Length >= 16777216)
				{
					_chatWriter.Dispose();
					_chatWriter = null;
					_chatPart++;
					OpenChatWriter(truncate: true);
					PruneAuditParts("chat-audit*.jsonl", _chatPath, 4);
				}
				_chatWriter.WriteLine(line);
			}
			catch (Exception ex)
			{
				MarkCaptureFailed("chat write", ex);
			}
		}

		private void MirrorBepInExLog(int maximumBytes)
		{
			if (_bepInExWriter == null || maximumBytes <= 0)
			{
				return;
			}
			string path = Path.Combine(Paths.BepInExRootPath, "LogOutput.log");
			try
			{
				using FileStream fileStream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete);
				if (fileStream.Length < _bepInExSourceOffset)
				{
					_bepInExSourceOffset = 0L;
				}
				fileStream.Position = _bepInExSourceOffset;
				int num = maximumBytes;
				while (num > 0 && fileStream.Position < fileStream.Length)
				{
					if (_bepInExWriter.Length >= 67108864)
					{
						_bepInExWriter.Dispose();
						_bepInExWriter = null;
						_bepInExPart++;
						OpenBepInExWriter(truncate: true);
						PruneAuditParts("bepinex*.log", _bepInExPath, 2);
					}
					byte[] array = _bepInExMirrorBuffer.Acquire(fileStream.Length, fileStream.Position, num);
					if (array == null)
					{
						break;
					}
					int num2 = fileStream.Read(array, 0, Math.Min(array.Length, num));
					if (num2 <= 0)
					{
						break;
					}
					_bepInExWriter.Write(array, 0, num2);
					_bepInExSourceOffset += num2;
					num -= num2;
				}
				_bepInExWriter.Flush();
			}
			catch (FileNotFoundException)
			{
			}
			catch (Exception ex2)
			{
				MarkCaptureFailed("BepInEx mirror", ex2);
			}
		}

		private void PollNativeBanStore(string observedSource = "native-ban-store-observed")
		{
			if (!Plugin.CanUseLobbySafety(out var isHost) || !isHost)
			{
				return;
			}
			if (!SteamIdModerationController.TryGetNativeBanRecords(out var records, out var error))
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogDebug((object)("Native ban audit observation skipped safely: " + error));
				}
				return;
			}
			if (!_nativeBanSnapshotReady)
			{
				foreach (NativeBanRecord item in records)
				{
					_nativeBanSnapshot[item.SteamId] = item;
					if (!_suppressNextBanBaselineEvents)
					{
						WriteNativeBanChange("ban-existing", item);
					}
				}
				_nativeBanSnapshotReady = true;
				_suppressNextBanBaselineEvents = false;
				return;
			}
			Dictionary<string, NativeBanRecord> now = records.GroupBy<NativeBanRecord, string>((NativeBanRecord nativeBanRecord) => nativeBanRecord.SteamId, StringComparer.Ordinal).ToDictionary<IGrouping<string, NativeBanRecord>, string, NativeBanRecord>((IGrouping<string, NativeBanRecord> group) => group.Key, (IGrouping<string, NativeBanRecord> group) => group.First(), StringComparer.Ordinal);
			NativeBanRecord[] array = records.Where((NativeBanRecord nativeBanRecord) => !_nativeBanSnapshot.ContainsKey(nativeBanRecord.SteamId)).ToArray();
			NativeBanRecord[] array2 = _nativeBanSnapshot.Values.Where((NativeBanRecord prior) => !now.ContainsKey(prior.SteamId)).ToArray();
			NativeBanRecord value;
			NativeBanRecord[] array3 = records.Where((NativeBanRecord nativeBanRecord) => _nativeBanSnapshot.TryGetValue(nativeBanRecord.SteamId, out value) && !string.Equals(nativeBanRecord.DisplayNameRaw, value.DisplayNameRaw, StringComparison.Ordinal)).ToArray();
			_nativeBanSnapshot.Clear();
			foreach (KeyValuePair<string, NativeBanRecord> item2 in now)
			{
				_nativeBanSnapshot[item2.Key] = item2.Value;
			}
			NativeBanRecord[] array4 = array;
			foreach (NativeBanRecord record in array4)
			{
				WriteNativeBanChange("ban-added", record, observedSource);
			}
			array4 = array2;
			foreach (NativeBanRecord record2 in array4)
			{
				WriteNativeBanChange("ban-removed", record2, observedSource);
			}
			array4 = array3;
			foreach (NativeBanRecord record3 in array4)
			{
				WriteNativeBanChange("ban-name-updated", record3, observedSource);
			}
		}

		private void WriteNativeBanChange(string action, NativeBanRecord record, string source = "native-ban-store-observed")
		{
			RecordModeration(action, (action == "ban-existing") ? "native-ban-store-baseline" : source, "persisted", record.SteamId, record.DisplayNameRaw, ReadSteamPersona(record.SteamId));
		}

		private void SynchronizeNativeBanSnapshot()
		{
			if (!SteamIdModerationController.TryGetNativeBanRecords(out var records, out var _))
			{
				return;
			}
			_nativeBanSnapshot.Clear();
			foreach (NativeBanRecord item in records)
			{
				_nativeBanSnapshot[item.SteamId] = item;
			}
			_nativeBanSnapshotReady = true;
			_suppressNextBanBaselineEvents = false;
		}

		private void WriteRosterCheckpoint()
		{
			if (!Plugin.CanUseLobbySafety(out var _))
			{
				return;
			}
			foreach (PlayerIdentityEvidence item in PlayerIdentityEvidenceController.GetVerifiedRoster())
			{
				RecordModeration("roster-checkpoint", "manual-audit-snapshot", item.Role, item.SteamId, item.DisplayNameRaw, item.SteamPersona, "", "", item.Role + ";rosterIndex=" + item.RosterIndex + ";playerId=" + item.NetworkPlayerId);
			}
		}

		private void CloseWriters()
		{
			try
			{
				_chatWriter?.Flush();
			}
			catch
			{
			}
			try
			{
				_chatWriter?.Dispose();
			}
			catch
			{
			}
			try
			{
				_bepInExWriter?.Flush();
			}
			catch
			{
			}
			try
			{
				_bepInExWriter?.Dispose();
			}
			catch
			{
			}
			_chatWriter = null;
			_bepInExWriter = null;
		}

		private void MarkCaptureFailed(string operation, Exception ex)
		{
			_initializationFailed = true;
			CloseWriters();
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogWarning((object)("Local audit " + operation + " failed; capture is NOT WRITING until /auditlog on retries: " + ex.GetType().Name + ": " + ex.Message));
			}
		}

		private void PauseCapture()
		{
			CloseWriters();
			AdvanceBepInExSourceOffsetToEnd();
			_nativeBanSnapshot.Clear();
			_nativeBanSnapshotReady = false;
			_suppressNextBanBaselineEvents = true;
			_wasDisabled = true;
		}

		private void AdvanceBepInExSourceOffsetToEnd()
		{
			try
			{
				using FileStream fileStream = new FileStream(Path.Combine(Paths.BepInExRootPath, "LogOutput.log"), FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete);
				_bepInExSourceOffset = fileStream.Length;
			}
			catch (FileNotFoundException)
			{
			}
			catch (Exception ex2)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogDebug((object)("BepInEx audit opt-out cursor update skipped safely: " + ex2.GetType().Name + ": " + ex2.Message));
				}
			}
		}

		private static void PruneOldSessions()
		{
			string text = Path.GetFullPath(AuditRoot).TrimEnd(new char[1] { Path.DirectorySeparatorChar });
			char directorySeparatorChar = Path.DirectorySeparatorChar;
			string value = text + directorySeparatorChar;
			DirectoryInfo[] array = (from directory in new DirectoryInfo(AuditRoot).GetDirectories("session-*")
				orderby directory.CreationTimeUtc descending
				select directory).ToArray();
			DateTime dateTime = DateTime.UtcNow.AddDays(-14.0);
			for (int num = 0; num < array.Length; num++)
			{
				DirectoryInfo directoryInfo = array[num];
				string text2 = Path.GetFullPath(directoryInfo.FullName).TrimEnd(new char[1] { Path.DirectorySeparatorChar });
				directorySeparatorChar = Path.DirectorySeparatorChar;
				if ((text2 + directorySeparatorChar).StartsWith(value, StringComparison.OrdinalIgnoreCase) && (num >= 12 || directoryInfo.CreationTimeUtc < dateTime))
				{
					try
					{
						directoryInfo.Delete(recursive: true);
					}
					catch
					{
					}
				}
			}
		}

		private void PruneAuditParts(string pattern, string currentPath, int maximumParts)
		{
			try
			{
				FileInfo[] array = (from file in new DirectoryInfo(_sessionDirectory).GetFiles(pattern)
					where !string.Equals(file.FullName, currentPath, StringComparison.OrdinalIgnoreCase)
					orderby file.LastWriteTimeUtc
					select file).ToArray();
				int num = Math.Max(0, array.Length + 1 - maximumParts);
				for (int num2 = 0; num2 < num; num2++)
				{
					array[num2].Delete();
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogDebug((object)("Local audit old-part cleanup skipped safely: " + ex.GetType().Name + ": " + ex.Message));
				}
			}
		}

		private static string PartName(string stem, int part, string extension)
		{
			if (part > 1)
			{
				return stem + ".part" + part.ToString("00") + extension;
			}
			return stem + extension;
		}

		private static string UtcNow()
		{
			return DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ss.fffZ");
		}

		private static string CurrentLobbyId()
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				CSteamID lobbyId;
				return (Plugin.TryGetRescueLobby(out lobbyId) && lobbyId != CSteamID.Nil) ? ((ulong)lobbyId).ToString() : string.Empty;
			}
			catch
			{
				return string.Empty;
			}
		}

		private static string CurrentAuditLobbyId()
		{
			if (!Plugin.CanUseLobbySafety(out var _))
			{
				return string.Empty;
			}
			return CurrentLobbyId();
		}

		private static string ReadSteamPersona(string steamId)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				ulong result;
				return ulong.TryParse(steamId, out result) ? (SteamFriends.GetFriendPersonaName(new CSteamID(result)) ?? string.Empty) : string.Empty;
			}
			catch
			{
				return string.Empty;
			}
		}
	}
	internal sealed class SessionRunMarkerController : MonoBehaviour
	{
		private const string MarkerFileName = "run-marker.v1";

		private static readonly object Sync = new object();

		private static SessionRunMarkerController _instance;

		private string _path = string.Empty;

		private SessionRunMarker _current;

		private float _nextHeartbeatAt;

		private void Awake()
		{
			_instance = this;
			_path = Path.Combine(SessionAuditController.AuditRoot, "run-marker.v1");
			Directory.CreateDirectory(SessionAuditController.AuditRoot);
			SessionAuditController.RecordRunMarker(ReadAndClassifyPrior().ToString().ToLowerInvariant(), AgeBucket(ReadPriorHeartbeatUtcTicks()), _path);
			Process currentProcess = Process.GetCurrentProcess();
			long num = SafeProcessStartUtcTicks(currentProcess);
			long ticks = DateTime.UtcNow.Ticks;
			_current = SessionRunMarkerPolicy.CreateRunning("0.2.4+20260730.1-public-24414155-release", currentProcess.Id, (num > 0) ? num : ticks, ticks, "runtime");
			AtomicWrite(_path, SessionRunMarkerPolicy.Serialize(_current));
			_nextHeartbeatAt = Time.realtimeSinceStartup + 5f;
		}

		private void Update()
		{
			if (!PluginShutdownController.IsShuttingDown && _current != null && !(Time.realtimeSinceStartup < _nextHeartbeatAt))
			{
				_nextHeartbeatAt = Time.realtimeSinceStartup + 5f;
				_current = SessionRunMarkerPolicy.WithHeartbeat(_current, DateTime.UtcNow.Ticks, "runtime");
				AtomicWrite(_path, SessionRunMarkerPolicy.Serialize(_current));
			}
		}

		internal static void MarkCleanClose()
		{
			lock (Sync)
			{
				if (!((Object)(object)_instance == (Object)null) && _instance._current != null && !string.IsNullOrEmpty(_instance._path))
				{
					_instance._current = SessionRunMarkerPolicy.CreateCleanClose(_instance._current, DateTime.UtcNow.Ticks);
					AtomicWrite(_instance._path, SessionRunMarkerPolicy.Serialize(_instance._current));
				}
			}
		}

		private SessionRunClassification ReadAndClassifyPrior()
		{
			if (!TryReadMarker(out var marker))
			{
				if (!File.Exists(_path))
				{
					return SessionRunClassification.None;
				}
				return SessionRunClassification.Uncertain;
			}
			bool processExists = false;
			bool processStartMatches = false;
			try
			{
				using Process process = Process.GetProcessById(marker.ProcessId);
				processExists = !process.HasExited;
				processStartMatches = SafeProcessStartUtcTicks(process) == marker.StartedUtcTicks;
			}
			catch
			{
				processExists = false;
				processStartMatches = false;
			}
			return SessionRunMarkerPolicy.ClassifyPrior(marker, DateTime.UtcNow.Ticks, processExists, processStartMatches);
		}

		private long ReadPriorHeartbeatUtcTicks()
		{
			if (!TryReadMarker(out var marker))
			{
				return 0L;
			}
			return marker.HeartbeatUtcTicks;
		}

		private bool TryReadMarker(out SessionRunMarker marker)
		{
			marker = null;
			try
			{
				return File.Exists(_path) && SessionRunMarkerPolicy.TryParse(File.ReadAllText(_path), out marker);
			}
			catch
			{
				return false;
			}
		}

		private static string AgeBucket(long heartbeatUtcTicks)
		{
			if (heartbeatUtcTicks <= 0)
			{
				return "unknown";
			}
			long num = Math.Max(0L, (DateTime.UtcNow.Ticks - heartbeatUtcTicks) / 10000000);
			if (num <= 15)
			{
				return "0-15s";
			}
			if (num <= 60)
			{
				return "16-60s";
			}
			if (num <= 300)
			{
				return "1-5m";
			}
			return "over-5m";
		}

		private static long SafeProcessStartUtcTicks(Process process)
		{
			try
			{
				return process.StartTime.ToUniversalTime().Ticks;
			}
			catch
			{
				return 0L;
			}
		}

		private static void AtomicWrite(string path, string content)
		{
			string text = path + ".tmp";
			string text2 = path + ".bak";
			File.WriteAllText(text, content);
			if (File.Exists(path))
			{
				try
				{
					File.Replace(text, path, text2, ignoreMetadataErrors: true);
					TryDelete(text2);
					return;
				}
				catch
				{
					TryDelete(text);
					return;
				}
			}
			File.Move(text, path);
		}

		private static void TryDelete(string path)
		{
			try
			{
				if (File.Exists(path))
				{
					File.Delete(path);
				}
			}
			catch
			{
			}
		}
	}
	internal sealed class StatisticsPulseReader
	{
		private sealed class StatisticsSurface
		{
			public Type StatisticsDataType { get; }

			public Type DataManagerType { get; }

			public Type AchievementManagerType { get; }

			public Type AchievementType { get; }

			public StatisticsSurface(Type statisticsDataType, Type dataManagerType, Type achievementManagerType, Type achievementType)
			{
				StatisticsDataType = statisticsDataType;
				DataManagerType = dataManagerType;
				AchievementManagerType = achievementManagerType;
				AchievementType = achievementType;
			}
		}

		private const BindingFlags ReadFlags = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;

		public bool TryCapturePulse(out StatisticsPulseSnapshot snapshot, out string unavailableReason)
		{
			snapshot = null;
			unavailableReason = string.Empty;
			try
			{
				if (!TryResolveSurface(out var surface, out unavailableReason))
				{
					return false;
				}
				Object val = FindLiveObject(surface.DataManagerType);
				if (val == (Object)null)
				{
					unavailableReason = "Native DataManager is not live.";
					return false;
				}
				object obj = ReadRequiredMember(val, surface.DataManagerType, "StatisticsData");
				if (obj == null || !surface.StatisticsDataType.IsInstanceOfType(obj))
				{
					unavailableReason = "Native StatisticsData is unavailable.";
					return false;
				}
				float totalFocusSeconds = ReadSingle(obj, surface.StatisticsDataType, "TotalFocusDuration");
				int todaySessions = ReadInt32(obj, surface.StatisticsDataType, "TodaySessionCount");
				int currentStreak = ReadInt32(obj, surface.StatisticsDataType, "CurrentStreak");
				int longestStreak = ReadInt32(obj, surface.StatisticsDataType, "LongestStreak");
				int taskChecks = ReadInt32(obj, surface.StatisticsDataType, "ToDoCompleted");
				if (!StatisticsPulseSnapshot.TryCreate(totalFocusSeconds, todaySessions, currentStreak, longestStreak, taskChecks, null, null, out snapshot))
				{
					unavailableReason = "Native statistics contain an invalid focus duration.";
					return false;
				}
				return true;
			}
			catch (Exception ex)
			{
				snapshot = null;
				unavailableReason = "Native statistics read failed: " + ex.GetType().Name;
				return false;
			}
		}

		public bool TryCountAchievements(out int unlocked, out int total, out string unavailableReason)
		{
			unlocked = 0;
			total = 0;
			unavailableReason = string.Empty;
			try
			{
				if (!TryResolveSurface(out var surface, out unavailableReason))
				{
					return false;
				}
				Object val = FindLiveObject(surface.AchievementManagerType);
				if (val == (Object)null)
				{
					unavailableReason = "Native AchievementManager is not live.";
					return false;
				}
				MethodInfo method = surface.AchievementManagerType.GetMethod("GetAchievement", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { surface.AchievementType }, null);
				if (method == null)
				{
					unavailableReason = "Native achievement reader is unavailable.";
					return false;
				}
				Array values = Enum.GetValues(surface.AchievementType);
				total = values.Length;
				bool flag = default(bool);
				foreach (object item in values)
				{
					object obj = method.Invoke(method.IsStatic ? null : val, new object[1] { item });
					int num;
					if (obj is bool)
					{
						flag = (bool)obj;
						num = 1;
					}
					else
					{
						num = 0;
					}
					if (((uint)num & (flag ? 1u : 0u)) != 0)
					{
						unlocked++;
					}
				}
				return true;
			}
			catch (Exception ex)
			{
				unlocked = 0;
				total = 0;
				unavailableReason = "Native achievement read failed: " + ex.GetType().Name;
				return false;
			}
		}

		private static bool TryResolveSurface(out StatisticsSurface surface, out string unavailableReason)
		{
			surface = null;
			unavailableReason = string.Empty;
			Assembly assembly = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault((Assembly assembly2) => string.Equals(assembly2.GetName().Name, "Assembly-CSharp", StringComparison.Ordinal));
			if (assembly == null || !StatisticsTypeResolutionPolicy.IsExactGameSurface(assembly.GetName().Name, (string name) => assembly.GetType(name, throwOnError: false) != null))
			{
				unavailableReason = "Native statistics are not available on this game build.";
				return false;
			}
			Type type = assembly.GetType("StatisticsData", throwOnError: false);
			Type type2 = assembly.GetType("DataManager", throwOnError: false);
			Type type3 = assembly.GetType("AchievementManager", throwOnError: false);
			Type type4 = assembly.GetType("Achievement", throwOnError: false);
			if (type == null || type2 == null || type3 == null || type4 == null || !type4.IsEnum)
			{
				unavailableReason = "Native statistics surface is incomplete.";
				return false;
			}
			surface = new StatisticsSurface(type, type2, type3, type4);
			return true;
		}

		private static Object FindLiveObject(Type type)
		{
			Object[] array = Resources.FindObjectsOfTypeAll(type);
			if (array == null)
			{
				return null;
			}
			Object[] array2 = array;
			foreach (Object val in array2)
			{
				if (val != null && !(val == (Object)null))
				{
					return val;
				}
			}
			return null;
		}

		private static object ReadRequiredMember(object target, Type ownerType, string name)
		{
			FieldInfo field = ownerType.GetField(name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			if (field != null)
			{
				return field.GetValue(field.IsStatic ? null : target);
			}
			MethodInfo methodInfo = ownerType.GetProperty(name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)?.GetGetMethod(nonPublic: true);
			if (methodInfo != null)
			{
				return methodInfo.Invoke(methodInfo.IsStatic ? null : target, null);
			}
			throw new MissingMemberException(ownerType.FullName, name);
		}

		private static float ReadSingle(object target, Type ownerType, string name)
		{
			return Convert.ToSingle(ReadRequiredMember(target, ownerType, name), CultureInfo.InvariantCulture);
		}

		private static int ReadInt32(object target, Type ownerType, string name)
		{
			return Convert.ToInt32(ReadRequiredMember(target, ownerType, name), CultureInfo.InvariantCulture);
		}
	}
	internal sealed class NativeBanRecord
	{
		internal string SteamId { get; }

		internal string DisplayNameRaw { get; }

		internal string DisplayName { get; }

		internal NativeBanRecord(string steamId, string displayNameRaw)
		{
			SteamId = steamId ?? string.Empty;
			DisplayNameRaw = displayNameRaw ?? string.Empty;
			DisplayName = PlayerMentionProvider.StripRichText(DisplayNameRaw).Trim();
			if (DisplayName.Length == 0)
			{
				DisplayName = "Saved native ban";
			}
		}
	}
	internal enum LobbySafetyAccessState
	{
		Denied,
		Host,
		HelperReady,
		HelperWaitingForHost
	}
	internal static class SteamIdModerationController
	{
		private const int MemberDataPollIntervalMilliseconds = 1000;

		internal const string LobbySafetyDeniedMessage = "Lobby Safety is available only to the current host or a Helper assigned by that host. No player or incident details were shown.";

		private const string CapabilityKey = "bluesage_qol_moderation";

		private const string HelpersKey = "bluesage_helpers";

		private const string LegacyHelpersKey = "bluesage_mod_helpers";

		private const string RescueHelpersKey = "bluesage_rescue_helpers";

		private static readonly HashSet<string> SeenNonces = new HashSet<string>(StringComparer.Ordinal);

		private static readonly Queue<string> NonceOrder = new Queue<string>();

		private static readonly Dictionary<string, long> LastIssuerRequest = new Dictionary<string, long>(StringComparer.Ordinal);

		private static long _nextMemberDataPollUnixMilliseconds;

		private static string _memberDataLobbyKey = string.Empty;

		internal static void PublishHostCapability()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			if (PluginShutdownController.IsShuttingDown)
			{
				return;
			}
			try
			{
				if (TryGetOwnedHostLobby(out var lobby, out var ownerSteamId))
				{
					long issuedUnixSeconds = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
					SteamMatchmaking.SetLobbyData(lobby, "bluesage_qol_moderation", ModerationCapabilityPolicy.Build(ownerSteamId, issuedUnixSeconds));
					string text = LobbyPingAuthorizationPolicy.SerializeDelegates(Plugin.GetUnifiedHelpersForOwner(ownerSteamId, importLegacy: true));
					string text2 = ownerSteamId + "|" + text;
					SteamMatchmaking.SetLobbyData(lobby, "bluesage_helpers", text2);
					SteamMatchmaking.SetLobbyData(lobby, "bluesage_mod_helpers", text2);
					SteamMatchmaking.SetLobbyData(lobby, "bluesage_rescue_helpers", text2);
					PlayerRoleLabelController.PublishHostHeartbeat();
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogDebug((object)("Moderation capability publish skipped: " + ex.GetType().Name + ": " + ex.Message));
				}
			}
		}

		internal static void ClearHostCapability()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			if (PluginShutdownController.IsShuttingDown)
			{
				return;
			}
			try
			{
				if (TryGetOwnedHostLobby(out var lobby, out var _))
				{
					SteamMatchmaking.SetLobbyData(lobby, "bluesage_qol_moderation", string.Empty);
					SteamMatchmaking.SetLobbyData(lobby, "bluesage_helpers", string.Empty);
					SteamMatchmaking.SetLobbyData(lobby, "bluesage_mod_helpers", string.Empty);
					SteamMatchmaking.SetLobbyData(lobby, "bluesage_rescue_helpers", string.Empty);
					PlayerRoleLabelController.ClearPublishedHostLabel();
				}
			}
			catch
			{
			}
		}

		internal static void ClearHostCapabilityForShutdown(SteamRuntimeSnapshot snapshot)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			if (snapshot == null || !snapshot.SteamWasReady || !snapshot.LocalWasOwner || snapshot.Lobby == CSteamID.Nil)
			{
				return;
			}
			try
			{
				SteamMatchmaking.SetLobbyData(snapshot.Lobby, "bluesage_qol_moderation", string.Empty);
				SteamMatchmaking.SetLobbyData(snapshot.Lobby, "bluesage_helpers", string.Empty);
				SteamMatchmaking.SetLobbyData(snapshot.Lobby, "bluesage_mod_helpers", string.Empty);
				SteamMatchmaking.SetLobbyData(snapshot.Lobby, "bluesage_rescue_helpers", string.Empty);
			}
			catch
			{
			}
		}

		internal static bool CanLocalIssue(out bool isHost, out string reason)
		{
			LobbySafetyAccessState localAccessState = GetLocalAccessState(out isHost, out reason);
			if (localAccessState != LobbySafetyAccessState.Host)
			{
				return localAccessState == LobbySafetyAccessState.HelperReady;
			}
			return true;
		}

		internal static bool ShouldShowLocalSurface(out LobbySafetyAccessState state, out string reason)
		{
			state = GetLocalAccessState(out var _, out reason);
			return state != LobbySafetyAccessState.Denied;
		}

		internal static LobbySafetyAccessState GetLocalAccessState(out bool isHost, out string reason)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			isHost = false;
			reason = "Lobby Safety is available only to the current host or a Helper assigned by that host. No player or incident details were shown.";
			try
			{
				if (!Plugin.TryGetRescueLobby(out var lobbyId) || lobbyId == CSteamID.Nil || !SteamManager.Initialized)
				{
					return LobbySafetyAccessState.Denied;
				}
				string text = ((ulong)SteamMatchmaking.GetLobbyOwner(lobbyId)).ToString();
				string text2 = ((ulong)SteamUser.GetSteamID()).ToString();
				isHost = string.Equals(text, text2, StringComparison.Ordinal) && (Object)(object)NetworkManager.main != (Object)null && NetworkManager.main.isHost;
				if (isHost)
				{
					reason = "You are the verified current lobby host.";
					return LobbySafetyAccessState.Host;
				}
				if (!IsPublishedHelper(lobbyId, text, text2))
				{
					return LobbySafetyAccessState.Denied;
				}
				if (!ModerationCapabilityPolicy.IsFresh(SteamMatchmaking.GetLobbyData(lobbyId, "bluesage_qol_moderation"), text, DateTimeOffset.UtcNow.ToUnixTimeSeconds()))
				{
					reason = "This lobby lists you as a Helper, but the host has not published a fresh compatible 0.2.0 v3 member-data capability. The status tab stays visible, but protected player data and actions remain locked. No request is sent until the capability matches.";
					return LobbySafetyAccessState.HelperWaitingForHost;
				}
				reason = "This host assigned you as a Helper and published a fresh compatible v3 member-data capability.";
				return LobbySafetyAccessState.HelperReady;
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogDebug((object)("Lobby Safety access check failed closed: " + ex.GetType().Name + ": " + ex.Message));
				}
				reason = "Lobby Safety is available only to the current host or a Helper assigned by that host. No player or incident details were shown.";
				return LobbySafetyAccessState.Denied;
			}
		}

		internal static bool IsLocalHost()
		{
			bool isHost;
			string reason;
			return CanLocalIssue(out isHost, out reason) && isHost;
		}

		internal static bool IsAuthorizedCurrentIssuer(string steamId)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!ModerationProtocolPolicy.IsSteamId64(steamId) || !Plugin.TryGetRescueLobby(out var lobbyId) || lobbyId == CSteamID.Nil || !SteamManager.Initialized)
				{
					return false;
				}
				string text = ((ulong)SteamMatchmaking.GetLobbyOwner(lobbyId)).ToString();
				if (string.Equals(text, steamId, StringComparison.Ordinal))
				{
					return true;
				}
				if ((Object)(object)NetworkManager.main != (Object)null && NetworkManager.main.isHost && SteamUser.GetSteamID() == SteamMatchmaking.GetLobbyOwner(lobbyId))
				{
					return ModerationAuthorizationPolicy.IsAuthorizedIssuer(steamId, text, Plugin.LobbyHelpers?.Value ?? string.Empty, Plugin.LobbyHelperOwnerSteamId?.Value ?? string.Empty, hasLobby: true);
				}
				return ModerationCapabilityPolicy.IsFresh(SteamMatchmaking.GetLobbyData(lobbyId, "bluesage_qol_moderation"), text, DateTimeOffset.UtcNow.ToUnixTimeSeconds()) && IsPublishedHelper(lobbyId, text, steamId);
			}
			catch
			{
				return false;
			}
		}

		internal static bool IsPublishedHelper(CSteamID lobby, string ownerSteamId, string steamId)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return GetPublishedHelpers(lobby, ownerSteamId).Contains(steamId);
		}

		internal static bool TryGetFreshCurrentCapability(out CSteamID lobby, out string ownerSteamId, out string capability)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			lobby = CSteamID.Nil;
			ownerSteamId = string.Empty;
			capability = string.Empty;
			try
			{
				if (!SteamManager.Initialized || !Plugin.TryGetRescueLobby(out lobby) || lobby == CSteamID.Nil)
				{
					return false;
				}
				CSteamID lobbyOwner = SteamMatchmaking.GetLobbyOwner(lobby);
				if (lobbyOwner == CSteamID.Nil)
				{
					return false;
				}
				ownerSteamId = ((ulong)lobbyOwner).ToString();
				capability = SteamMatchmaking.GetLobbyData(lobby, "bluesage_qol_moderation") ?? string.Empty;
				return ModerationCapabilityPolicy.IsFresh(capability, ownerSteamId, DateTimeOffset.UtcNow.ToUnixTimeSeconds());
			}
			catch
			{
				lobby = CSteamID.Nil;
				ownerSteamId = string.Empty;
				capability = string.Empty;
				return false;
			}
		}

		internal static bool IsUniqueCurrentLobbyMember(CSteamID lobby, string steamId)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if (lobby != CSteamID.Nil)
			{
				return IsUniqueSteamLobbyMember(lobby, steamId);
			}
			return false;
		}

		internal static HashSet<string> GetPublishedHelpers(CSteamID lobby, string ownerSteamId)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			string lobbyData = SteamMatchmaking.GetLobbyData(lobby, "bluesage_helpers");
			if (string.IsNullOrWhiteSpace(lobbyData))
			{
				lobbyData = SteamMatchmaking.GetLobbyData(lobby, "bluesage_mod_helpers");
			}
			string[] array = (lobbyData ?? string.Empty).Split(new char[1] { '|' }, 2);
			if (array.Length != 2 || !string.Equals(array[0], ownerSteamId, StringComparison.Ordinal))
			{
				return new HashSet<string>(StringComparer.Ordinal);
			}
			return new HashSet<string>(LobbyPingAuthorizationPolicy.ParseDelegates(array[1]), StringComparer.Ordinal);
		}

		internal static bool TrySendHelperRequest(string action, string targetSteamId, string incidentId, out string message)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			if (!CanLocalIssue(out var isHost, out message))
			{
				return false;
			}
			if (isHost)
			{
				string issuerSteamId = ((ulong)SteamUser.GetSteamID()).ToString();
				return TryExecuteHostAction(action, targetSteamId, incidentId, issuerSteamId, out message);
			}
			string nonce = Guid.NewGuid().ToString("N").Substring(0, 16);
			string text = ModerationProtocolPolicy.BuildMemberData(action, targetSteamId, incidentId, DateTimeOffset.UtcNow.ToUnixTimeSeconds(), nonce);
			if (string.IsNullOrWhiteSpace(text) || !Plugin.TryGetRescueLobby(out var lobbyId) || lobbyId == CSteamID.Nil)
			{
				message = "The moderation request could not reach the host; no action was taken.";
				return false;
			}
			try
			{
				SteamMatchmaking.SetLobbyMemberData(lobbyId, "bluesage_moderation_request_v2", text);
			}
			catch (Exception ex)
			{
				message = "The non-chat moderation request failed safely (" + ex.GetType().Name + "); no action was taken.";
				return false;
			}
			message = "Moderation request published through non-chat Steam member data for authoritative QoL-host validation. The host performs the native action; no local ban was written and no chat line was sent.";
			return true;
		}

		internal static void PollHostMemberDataRequests()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			long num = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
			if (num < _nextMemberDataPollUnixMilliseconds)
			{
				return;
			}
			_nextMemberDataPollUnixMilliseconds = num + 1000;
			if (!TryGetOwnedHostLobby(out var lobby, out var ownerSteamId))
			{
				return;
			}
			string text = ((ulong)lobby).ToString();
			if (!string.Equals(_memberDataLobbyKey, text, StringComparison.Ordinal))
			{
				_memberDataLobbyKey = text;
				SeenNonces.Clear();
				NonceOrder.Clear();
				LastIssuerRequest.Clear();
			}
			int numLobbyMembers = SteamMatchmaking.GetNumLobbyMembers(lobby);
			for (int i = 0; i < numLobbyMembers; i++)
			{
				CSteamID lobbyMemberByIndex = SteamMatchmaking.GetLobbyMemberByIndex(lobby, i);
				string text2 = ((ulong)lobbyMemberByIndex).ToString();
				if (!string.Equals(text2, ownerSteamId, StringComparison.Ordinal) && ModerationProtocolPolicy.TryParseMemberData(SteamMatchmaking.GetLobbyMemberData(lobby, lobbyMemberByIndex, "bluesage_moderation_request_v2"), out var request))
				{
					ProcessMemberDataRequest(lobby, ownerSteamId, text2, request);
				}
			}
		}

		private static void ProcessMemberDataRequest(CSteamID lobby, string ownerSteamId, string senderSteamId, ModerationRequest request)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			long num = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
			if (ModerationProtocolPolicy.IsFresh(request, num) && PlayerIdentityEvidenceController.TryResolveExact(senderSteamId, out var _, out var _) && IsUniqueSteamLobbyMember(lobby, senderSteamId) && ModerationAuthorizationPolicy.IsAuthorizedIssuer(senderSteamId, ownerSteamId, Plugin.LobbyHelpers?.Value ?? string.Empty, Plugin.LobbyHelperOwnerSteamId?.Value ?? string.Empty, hasLobby: true) && RememberNonce(request.Nonce) && (!LastIssuerRequest.TryGetValue(senderSteamId, out var value) || num - value >= 2))
			{
				LastIssuerRequest[senderSteamId] = num;
				string message;
				bool num2 = TryExecuteHostAction(request.Action, request.TargetSteamId, request.IncidentId, senderSteamId, out message);
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)("Host non-chat moderation request from Steam …" + Suffix(senderSteamId) + ": " + message));
				}
				Plugin.AddLocalNotification((num2 ? "Authorized helper action: " : "Helper action rejected: ") + message);
			}
		}

		internal static bool TryExecuteHostAction(string action, string targetSteamId, string incidentId, string issuerSteamId, out string message)
		{
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			message = "No moderation action was taken.";
			if (!TryGetOwnedHostLobby(out var lobby, out var ownerSteamId))
			{
				message = "Only the active Steam/PurrNet lobby host can write native moderation state.";
				return false;
			}
			if (!ModerationAuthorizationPolicy.IsAuthorizedIssuer(issuerSteamId, ownerSteamId, Plugin.LobbyHelpers?.Value ?? string.Empty, Plugin.LobbyHelperOwnerSteamId?.Value ?? string.Empty, hasLobby: true))
			{
				message = "The issuing Steam ID is not on this host's Helper list.";
				return false;
			}
			string incidentId2 = ((!string.Equals(issuerSteamId, ownerSteamId, StringComparison.Ordinal) && !string.Equals(incidentId, "none", StringComparison.OrdinalIgnoreCase)) ? ("issuer-local:" + incidentId) : incidentId);
			if (!(action == "ban"))
			{
				if (action == "unban")
				{
					return TryUnban(targetSteamId, issuerSteamId, incidentId2, out message);
				}
				return false;
			}
			return TryBan(lobby, ownerSteamId, issuerSteamId, targetSteamId, incidentId2, out message);
		}

		internal static string[] GetCurrentPlayerSteamIds()
		{
			string error;
			return PlayerIdentityEvidenceController.GetVerifiedCurrentSteamIds(out error).ToArray();
		}

		internal static string[] GetBannedSteamIds()
		{
			try
			{
				return MonoSingleton<DataManager>.I?.BanData?.BanServerPlayers?.Where(ModerationProtocolPolicy.IsSteamId64).Distinct<string>(StringComparer.Ordinal).ToArray() ?? Array.Empty<string>();
			}
			catch
			{
				return Array.Empty<string>();
			}
		}

		internal static IReadOnlyList<NativeBanRecord> GetNativeBanRecords()
		{
			if (!TryGetNativeBanRecords(out var records, out var _))
			{
				return Array.Empty<NativeBanRecord>();
			}
			return records;
		}

		internal static bool TryGetNativeBanRecords(out IReadOnlyList<NativeBanRecord> records, out string error)
		{
			records = Array.Empty<NativeBanRecord>();
			error = string.Empty;
			if (!Plugin.CanManageHelpers())
			{
				error = "current client is not the verified host";
				return false;
			}
			try
			{
				BanData val = MonoSingleton<DataManager>.I?.BanData;
				if (val?.BanServerPlayers == null || val.BanServerPlayerNicks == null || val.BanServerPlayers.Count != val.BanServerPlayerNicks.Count)
				{
					error = "native ban storage is unavailable or misaligned";
					return false;
				}
				List<NativeBanRecord> list = new List<NativeBanRecord>();
				HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
				for (int i = 0; i < val.BanServerPlayers.Count; i++)
				{
					string text = val.BanServerPlayers[i] ?? string.Empty;
					if (ModerationProtocolPolicy.IsSteamId64(text))
					{
						if (!hashSet.Add(text))
						{
							error = "native ban storage contains duplicate SteamID64 rows";
							return false;
						}
						list.Add(new NativeBanRecord(text, val.BanServerPlayerNicks[i] ?? string.Empty));
					}
				}
				records = list;
				return true;
			}
			catch (Exception ex)
			{
				error = "native ban storage read failed safely (" + ex.GetType().Name + ")";
				return false;
			}
		}

		private static bool TryBan(CSteamID lobby, string ownerSteamId, string issuerSteamId, string targetSteamId, string incidentId, out string message)
		{
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0406: Unknown result type (might be due to invalid IL or missing references)
			//IL_040c: Unknown result type (might be due to invalid IL or missing references)
			message = "No ban was made.";
			PlayerPanelController panel = NetworkSingleton<PlayerPanelController>.I;
			if (panel?.PlayerSteamIDs == null || panel.PlayerIDs == null || panel.PlayerSteamIDs.Count != panel.PlayerIDs.Count)
			{
				message = "The native player roster is missing or misaligned.";
				return false;
			}
			int targetIndex = panel.PlayerSteamIDs.FindIndex((string id) => string.Equals(id, targetSteamId, StringComparison.Ordinal));
			int num = panel.PlayerSteamIDs.Count((string id) => string.Equals(id, targetSteamId, StringComparison.Ordinal));
			int num2 = CountSteamLobbyMembers(lobby, targetSteamId);
			bool flag = targetIndex >= 0 && targetIndex < panel.PlayerIDs.Count && panel.PlayerIDs.Count((PlayerID id) => ((PlayerID)(ref id)).Equals(panel.PlayerIDs[targetIndex])) == 1;
			bool flag2 = targetIndex >= 0 && num == 1 && targetIndex < panel.PlayerIDs.Count && flag && num2 == 1;
			bool flag3 = OfflineBanPolicy.IsConfirmedAbsentFromCurrentLobby(num2);
			bool targetIsProtectedVictim = CloneIncidentLedger.IsProtectedVictim(targetSteamId);
			if (!flag2 && !flag3)
			{
				message = "Target failed the Steam/PurrNet roster alignment check. No live or offline ban was saved.";
				return false;
			}
			if (flag2)
			{
				if (!ModerationAuthorizationPolicy.CanBanTarget(targetSteamId, ownerSteamId, Plugin.LobbyHelpers?.Value ?? string.Empty, issuerSteamId, targetIsProtectedVictim, targetIsPresent: true))
				{
					message = "Target failed the live Steam/PurrNet safety checks (protected victim, host, helper, issuer, or ambiguous).";
					return false;
				}
			}
			else if (!OfflineBanPolicy.CanSave(ownerSteamId, issuerSteamId, targetSteamId, Plugin.LobbyHelpers?.Value ?? string.Empty, targetIsProtectedVictim, targetIsAbsent: true, out message))
			{
				return false;
			}
			DataManager i = MonoSingleton<DataManager>.I;
			BanData val = i?.BanData;
			if (val?.BanServerPlayers == null || val.BanServerPlayerNicks == null || val.BanServerPlayers.Count != val.BanServerPlayerNicks.Count)
			{
				message = "Native ban storage is unavailable or its paired lists are inconsistent.";
				return false;
			}
			if (val.BanServerPlayers.Contains(targetSteamId))
			{
				message = "Steam …" + Suffix(targetSteamId) + " is already in the host's native ban list.";
				return true;
			}
			string text = (flag3 ? SafeOfflinePersona(targetSteamId) : SafePersona(targetSteamId));
			string displayNameRaw = text;
			string persona = text;
			string targetRole = (flag3 ? "ABSENT" : "PLAYER");
			if (flag2 && PlayerIdentityEvidenceController.TryResolveExact(targetSteamId, out var evidence, out var _))
			{
				displayNameRaw = evidence.DisplayNameRaw;
				persona = evidence.SteamPersona;
				targetRole = evidence.Role;
			}
			val.BanServerPlayers.Add(targetSteamId);
			val.BanServerPlayerNicks.Add(text);
			SessionAuditController.ArmPersistedModerationAudit("ban-added", flag3 ? "bluesage-sidban-offline" : "bluesage-sidban-live", targetSteamId, displayNameRaw, persona, issuerSteamId, incidentId, targetRole);
			try
			{
				i.SaveBanData();
			}
			catch (Exception ex)
			{
				SessionAuditController.CancelPersistedModerationAudit();
				val.BanServerPlayers.RemoveAt(val.BanServerPlayers.Count - 1);
				val.BanServerPlayerNicks.RemoveAt(val.BanServerPlayerNicks.Count - 1);
				message = "Native ban save failed and was rolled back: " + ex.GetType().Name + ".";
				return false;
			}
			if (flag3)
			{
				message = "Offline native ban saved for exact SteamID64 " + targetSteamId + ". The player was not in the current lobby, so no kick was attempted. Use /sidunban " + targetSteamId + " to reverse it.";
				return true;
			}
			ChalkboardPersistenceController.NotifyModerationBoardReview(targetSteamId);
			PlayerController val2 = NetworkSingleton<TextChannelManager>.I?.MainPlayerController;
			if ((Object)(object)val2 == (Object)null)
			{
				message = "Persisted native ban for Steam …" + Suffix(targetSteamId) + ", but the current-player kick could not be confirmed.";
				return true;
			}
			try
			{
				val2.BanRPC(panel.PlayerIDs[targetIndex], true, default(RPCInfo));
				message = "Native ban applied to suspect Steam …" + Suffix(targetSteamId) + ((incidentId == "none") ? "." : (" from " + incidentId + ".")) + " Victim IDs were not targeted.";
				return true;
			}
			catch (Exception ex2)
			{
				message = "Persisted native ban for Steam …" + Suffix(targetSteamId) + ", but live kick raised " + ex2.GetType().Name + ".";
				return true;
			}
		}

		private static bool TryUnban(string targetSteamId, string issuerSteamId, string incidentId, out string message)
		{
			message = "No unban was made.";
			DataManager i = MonoSingleton<DataManager>.I;
			BanData val = i?.BanData;
			if (val?.BanServerPlayers == null || val.BanServerPlayerNicks == null || val.BanServerPlayers.Count != val.BanServerPlayerNicks.Count)
			{
				message = "Native ban storage is unavailable or its paired lists are inconsistent.";
				return false;
			}
			int num = val.BanServerPlayers.FindIndex((string id) => string.Equals(id, targetSteamId, StringComparison.Ordinal));
			if (num < 0)
			{
				message = "Steam …" + Suffix(targetSteamId) + " is not in the host's native ban list.";
				return false;
			}
			string item = val.BanServerPlayers[num];
			string text = val.BanServerPlayerNicks[num];
			val.BanServerPlayers.RemoveAt(num);
			val.BanServerPlayerNicks.RemoveAt(num);
			SessionAuditController.ArmPersistedModerationAudit("ban-removed", "bluesage-sidunban", targetSteamId, text, SafePersona(targetSteamId), issuerSteamId, incidentId, "SAVED BAN");
			try
			{
				i.SaveBanData();
				message = "Native ban removed for Steam …" + Suffix(targetSteamId) + ".";
				return true;
			}
			catch (Exception ex)
			{
				SessionAuditController.CancelPersistedModerationAudit();
				val.BanServerPlayers.Insert(num, item);
				val.BanServerPlayerNicks.Insert(num, text);
				message = "Native unban save failed and was rolled back: " + ex.GetType().Name + ".";
				return false;
			}
		}

		internal static bool TryGetOwnedHostLobby(out CSteamID lobby, out string ownerSteamId)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			lobby = CSteamID.Nil;
			ownerSteamId = string.Empty;
			if (!Plugin.TryGetRescueLobby(out lobby) || lobby == CSteamID.Nil || !SteamManager.Initialized || (Object)(object)NetworkManager.main == (Object)null || !NetworkManager.main.isHost)
			{
				return false;
			}
			CSteamID lobbyOwner = SteamMatchmaking.GetLobbyOwner(lobby);
			CSteamID steamID = SteamUser.GetSteamID();
			if (lobbyOwner == CSteamID.Nil || lobbyOwner != steamID)
			{
				return false;
			}
			ownerSteamId = ((ulong)lobbyOwner).ToString();
			return true;
		}

		private static bool IsUniqueSteamLobbyMember(CSteamID lobby, string steamId)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return CountSteamLobbyMembers(lobby, steamId) == 1;
		}

		private static int CountSteamLobbyMembers(CSteamID lobby, string steamId)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			int numLobbyMembers = SteamMatchmaking.GetNumLobbyMembers(lobby);
			for (int i = 0; i < numLobbyMembers; i++)
			{
				if (string.Equals(((ulong)SteamMatchmaking.GetLobbyMemberByIndex(lobby, i)).ToString(), steamId, StringComparison.Ordinal))
				{
					num++;
				}
			}
			return num;
		}

		private static bool RememberNonce(string nonce)
		{
			if (!SeenNonces.Add(nonce))
			{
				return false;
			}
			NonceOrder.Enqueue(nonce);
			while (NonceOrder.Count > 128)
			{
				SeenNonces.Remove(NonceOrder.Dequeue());
			}
			return true;
		}

		private static string SafePersona(string steamId)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			if (!ulong.TryParse(steamId, out var result))
			{
				return "Steam …" + Suffix(steamId);
			}
			string text = SteamFriends.GetFriendPersonaName(new CSteamID(result)) ?? string.Empty;
			text = text.Replace("\r", " ").Replace("\n", " ").Trim();
			if (string.IsNullOrWhiteSpace(text))
			{
				return "Steam …" + Suffix(steamId);
			}
			if (text.Length <= 48)
			{
				return text;
			}
			return text.Substring(0, 48);
		}

		private static string SafeOfflinePersona(string steamId)
		{
			string text = SafePersona(steamId) + " (offline)";
			if (text.Length <= 48)
			{
				return text;
			}
			return text.Substring(0, 48);
		}

		private static string Suffix(string steamId)
		{
			string text;
			if (steamId == null || steamId.Length <= 6)
			{
				text = steamId;
				if (text == null)
				{
					return "unknown";
				}
			}
			else
			{
				text = steamId.Substring(steamId.Length - 6);
			}
			return text;
		}
	}
	internal sealed class SteamRuntimeSnapshot
	{
		internal static readonly SteamRuntimeSnapshot Empty = new SteamRuntimeSnapshot(steamWasReady: false, CSteamID.Nil, CSteamID.Nil, localWasOwner: false);

		internal bool SteamWasReady { get; }

		internal CSteamID Lobby { get; }

		internal CSteamID LocalUser { get; }

		internal bool LocalWasOwner { get; }

		internal SteamRuntimeSnapshot(bool steamWasReady, CSteamID lobby, CSteamID localUser, bool localWasOwner)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			SteamWasReady = steamWasReady;
			Lobby = lobby;
			LocalUser = localUser;
			LocalWasOwner = localWasOwner;
		}
	}
	internal static class SteamRuntimeFacade
	{
		private static readonly object Sync = new object();

		private static SteamRuntimeSnapshot _lastKnown = SteamRuntimeSnapshot.Empty;

		internal static void CaptureLive()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			if (PluginShutdownController.IsShuttingDown)
			{
				return;
			}
			try
			{
				if (!SteamManager.Initialized || !Plugin.TryGetRescueLobby(out var lobbyId) || lobbyId == CSteamID.Nil)
				{
					return;
				}
				CSteamID steamID = SteamUser.GetSteamID();
				if (steamID == CSteamID.Nil)
				{
					return;
				}
				lock (Sync)
				{
					_lastKnown = new SteamRuntimeSnapshot(steamWasReady: true, lobbyId, steamID, SteamMatchmaking.GetLobbyOwner(lobbyId) == steamID);
				}
			}
			catch
			{
			}
		}

		internal static SteamRuntimeSnapshot SnapshotForShutdown()
		{
			lock (Sync)
			{
				return _lastKnown;
			}
		}
	}
	internal interface IStewardPipeHost
	{
		bool TryStart(string keyPath, string serviceIdentity, Action<StewardAnnouncementEnvelope> accepted, out string boundedError);

		void Stop();
	}
	internal sealed class StewardAnnouncementBridgeController : MonoBehaviour
	{
		private const string WindowsHostTypeName = "BlueSage.QoLTweaks.WindowsStewardPipeHost";

		private const string StewardPipeName = "BlueSage.OnTogether.Steward.v1";

		private const int MaximumQueuedAnnouncements = 8;

		private const int MaximumPerFrame = 2;

		private readonly object _queueSync = new object();

		private readonly Queue<StewardAnnouncementEnvelope> _queue = new Queue<StewardAnnouncementEnvelope>(8);

		private readonly StewardAnnouncementReplayCache _replay = new StewardAnnouncementReplayCache();

		private readonly StewardAnnouncementRateLimiter _rate = new StewardAnnouncementRateLimiter();

		private IStewardPipeHost _host;

		private string _replayPath = string.Empty;

		private bool _started;

		private void Awake()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Invalid comparison between Unknown and I4
			if (!string.Equals("BlueSage.OnTogether.Steward.v1", "BlueSage.OnTogether.Steward.v1", StringComparison.Ordinal) || Plugin.EnableStewardAnnouncementBridge == null || !Plugin.EnableStewardAnnouncementBridge.Value || (int)Application.platform != 2)
			{
				return;
			}
			Type type = Assembly.GetExecutingAssembly().GetType("BlueSage.QoLTweaks.WindowsStewardPipeHost", throwOnError: false);
			if (type == null || !typeof(IStewardPipeHost).IsAssignableFrom(type))
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)"Steward announcement bridge could not start: Windows pipe host is unavailable.");
				}
				return;
			}
			_replayPath = Path.Combine(Paths.ConfigPath, "BlueSageSteward", "steward-replay-cache.v1");
			LoadReplay();
			try
			{
				_host = (IStewardPipeHost)Activator.CreateInstance(type);
				_started = _host.TryStart(Plugin.StewardBridgeKeyPath?.Value ?? string.Empty, Plugin.StewardBridgeServiceIdentity?.Value ?? string.Empty, EnqueueAuthenticated, out var boundedError);
				if (!_started)
				{
					ManualLogSource log2 = Plugin.Log;
					if (log2 != null)
					{
						log2.LogWarning((object)("Steward announcement bridge stayed off: " + BoundError(boundedError)));
					}
				}
			}
			catch
			{
				_started = false;
				_host = null;
				ManualLogSource log3 = Plugin.Log;
				if (log3 != null)
				{
					log3.LogWarning((object)"Steward announcement bridge stayed off after local initialization failed.");
				}
			}
		}

		private void Update()
		{
			if (!_started || PluginShutdownController.IsShuttingDown)
			{
				return;
			}
			for (int i = 0; i < 2; i++)
			{
				StewardAnnouncementEnvelope envelope;
				lock (_queueSync)
				{
					if (_queue.Count == 0)
					{
						break;
					}
					envelope = _queue.Dequeue();
				}
				TryPresent(envelope);
			}
		}

		private void OnDestroy()
		{
			try
			{
				_host?.Stop();
			}
			catch
			{
			}
			_host = null;
			_started = false;
			lock (_queueSync)
			{
				_queue.Clear();
			}
		}

		private void EnqueueAuthenticated(StewardAnnouncementEnvelope envelope)
		{
			if (envelope == null || PluginShutdownController.IsShuttingDown)
			{
				return;
			}
			lock (_queueSync)
			{
				if (_queue.Count < 8)
				{
					_queue.Enqueue(envelope);
				}
			}
		}

		private void TryPresent(StewardAnnouncementEnvelope envelope)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Invalid comparison between Unknown and I4
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			long ticks = DateTime.UtcNow.Ticks;
			bool steamOwnerMatchesLocal = false;
			bool purrNetHost = false;
			string currentLobbyToken = string.Empty;
			TextChannelManager val = null;
			try
			{
				if (SteamManager.Initialized && Plugin.TryGetRescueLobby(out var lobbyId) && lobbyId != CSteamID.Nil)
				{
					CSteamID steamID = SteamUser.GetSteamID();
					CSteamID lobbyOwner = SteamMatchmaking.GetLobbyOwner(lobbyId);
					steamOwnerMatchesLocal = steamID != CSteamID.Nil && lobbyOwner == steamID;
					purrNetHost = (Object)(object)NetworkManager.main != (Object)null && NetworkManager.main.isHost;
					currentLobbyToken = StewardAnnouncementPolicy.FingerprintLobby(((ulong)lobbyId).ToString(), "0.2.4+20260730.1-public-24414155-release");
					val = NetworkSingleton<TextChannelManager>.I;
				}
			}
			catch
			{
				steamOwnerMatchesLocal = false;
				purrNetHost = false;
				currentLobbyToken = string.Empty;
				val = null;
			}
			StewardAnnouncementContext context = new StewardAnnouncementContext(Plugin.EnableStewardAnnouncementBridge != null && Plugin.EnableStewardAnnouncementBridge.Value, (int)Application.platform == 2, PluginShutdownController.IsShuttingDown, steamOwnerMatchesLocal, purrNetHost, (Object)(object)val != (Object)null, "0.2.4+20260730.1-public-24414155-release", currentLobbyToken, ticks);
			if (StewardAnnouncementPolicy.TryAuthorize(envelope, context, _replay, _rate, out string safeText, out string _))
			{
				val.AddNotification(safeText);
				PersistReplay(ticks);
			}
		}

		private void LoadReplay()
		{
			try
			{
				if (File.Exists(_replayPath))
				{
					_replay.Import(File.ReadAllText(_replayPath), DateTime.UtcNow.Ticks);
				}
			}
			catch
			{
			}
		}

		private void PersistReplay(long nowUtcTicks)
		{
			try
			{
				AtomicReplace(_replayPath, _replay.Export(nowUtcTicks));
			}
			catch
			{
			}
		}

		private static void AtomicReplace(string path, string content)
		{
			string directoryName = Path.GetDirectoryName(path);
			if (string.IsNullOrWhiteSpace(directoryName))
			{
				return;
			}
			Directory.CreateDirectory(directoryName);
			string text = path + ".tmp";
			string text2 = path + ".bak";
			File.WriteAllText(text, content ?? string.Empty);
			if (File.Exists(path))
			{
				try
				{
					File.Replace(text, path, text2, ignoreMetadataErrors: true);
					TryDelete(text2);
					return;
				}
				catch
				{
					TryDelete(text);
					return;
				}
			}
			File.Move(text, path);
		}

		private static void TryDelete(string path)
		{
			try
			{
				if (File.Exists(path))
				{
					File.Delete(path);
				}
			}
			catch
			{
			}
		}

		private static string BoundError(string value)
		{
			string text = (value ?? string.Empty).Replace("\r", " ").Replace("\n", " ").Trim();
			if (text.Length > 120)
			{
				return text.Substring(0, 120);
			}
			return text;
		}
	}
	internal sealed class StyleHelperWindow : MonoBehaviour
	{
		private struct StyleHelperSnapshot
		{
			public string Action;

			public string Text;

			public string ColorA;

			public string ColorB;

			public string ColorC;

			public string Status;

			public string StatusColorDraft;

			public string Preview;

			public string Message;

			public bool PreviewIsValid;

			public string DetectedNamePreview;

			public bool Bold;

			public bool Italic;

			public int Mode;

			public int Tab;

			public int ActiveColorSlot;

			public bool RestoreName;

			public bool RestoreStatus;

			public string PlayerName;

			public string PlayerStatus;

			public string PlayerStatusColor;

			public string SpoonCountText;

			public string SpoonLabelText;

			public string StateLabel;

			public string StateDetail;

			public bool RestoreSpoons;

			public bool SpoonsEnabled;

			public int SpoonCount;

			public string SavedSpoonLabel;

			public string SpoonsUpdatedUtc;
		}

		private const string PlaceholderName = "YOURNAMEHERE";

		private const float MinWindowWidth = 920f;

		private const float MinWindowHeight = 640f;

		private const float ResizeGripSize = 42f;

		private const float FooterHeight = 156f;

		private const float CompactFooterHeight = 198f;

		private const float ContentChromeHeight = 78f;

		private const string DefaultColorA = "0E6EED";

		private const string DefaultColorB = "A59";

		private const string DefaultColorC = "D85";

		private const string NameStylerDescription = "Build styled name/chat text with colors, bold, italic, and gradients.";

		private const string StatusStylerDescription = "Set your activity tag and Spoons together without overwriting your styled name.";

		private const string TemplatesDescription = "Save or load five local name-style templates. Status and Spoons stay separate.";

		private static readonly string[] PresetColors = new string[84]
		{
			"0E6EED", "1E90FF", "5AC8FA", "00C7BE", "70FFBD", "34C759", "FFD45D", "FFB347", "FF9500", "FF6B8A",
			"FF2D55", "FF3B30", "AF52DE", "9B59B6", "8833EE", "A550A5", "D88555", "C7A17A", "FFFFFF", "F7E7CE",
			"D8CAB8", "9B8E7E", "7B5B63", "2D1B2F", "FFFD82", "B8FF70", "70D6FF", "B388FF", "FFAFCC", "CDB4DB",
			"000000", "808080", "C0C0C0", "800000", "FF0000", "FFA500", "FFFF00", "808000", "008000", "00FF00",
			"008080", "00FFFF", "000080", "0000FF", "800080", "FF00FF", "4B0082", "F5DEB3", "CD853F", "D2691E",
			"8B4513", "2F4F4F", "4682B4", "DA70D6", "FF69B4", "FF1493", "DB7093", "E6E6FA", "DDA0DD", "BA55D3",
			"7FFFD4", "40E0D0", "48D1CC", "20B2AA", "66CDAA", "00FA9A", "ADFF2F", "7CFC00", "32CD32", "228B22",
			"556B2F", "6B8E23", "FFFACD", "FFE4B5", "FFDAB9", "F4A460", "DEB887", "A0522D", "B0E0E6", "87CEEB",
			"6495ED", "4169E1", "191970", "708090"
		};

		private Rect _windowRect = new Rect(80f, 80f, 960f, 720f);

		private bool _visible;

		private bool _hasOpened;

		private string _text = "YOURNAMEHERE";

		private string _colorA = "0E6EED";

		private string _colorB = "A59";

		private string _colorC = "D85";

		private string _status = "BRB";

		private string _statusColor = "FFD45D";

		private string _spoonCountText = "5";

		private string _spoonLabelText = "sp";

		private string _preview = string.Empty;

		private string _message = "Pick a tab, choose colors, then Apply or Copy.";

		private bool _previewIsValid;

		private bool _bold;

		private bool _italic;

		private int _mode = 3;

		private int _tab;

		private int _activeColorSlot;

		private string _detectedNamePreview = string.Empty;

		private Vector2 _scroll;

		private Vector2 _contentScroll;

		private GUIStyle _windowStyle;

		private GUIStyle _headerBoxStyle;

		private GUIStyle _headerStyle;

		private GUIStyle _labelStyle;

		private GUIStyle _smallStyle;

		private GUIStyle _buttonStyle;

		private GUIStyle _activeButtonStyle;

		private GUIStyle _boxStyle;

		private GUIStyle _footerBoxStyle;

		private GUIStyle _footerTextStyle;

		private GUIStyle _textFieldStyle;

		private GUIStyle _generatedTextStyle;

		private GUIStyle _swatchButtonStyle;

		private GUIStyle _previewStyle;

		private Texture2D _windowBackgroundTexture;

		private bool _isResizing;

		private string _lastThemeKey = string.Empty;

		private int _renderedTextureGeneration;

		private BlueSageUiThemePalette _theme;

		private readonly Stack<StyleHelperSnapshot> _undoHistory = new Stack<StyleHelperSnapshot>();

		private readonly Stack<StyleHelperSnapshot> _redoHistory = new Stack<StyleHelperSnapshot>();

		private string _stateLabel = "Saved";

		private string _stateDetail = "Detected current in-game values.";

		private string _lastOwnedFooterTooltip = string.Empty;

		internal bool IsVisible => _visible;

		private bool _hasUndo => _undoHistory.Count > 0;

		public void ToggleVisible()
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			_visible = !_visible;
			BlueSageWindowCoordinator.SetVisible(BlueSagePublicWindow.StyleHelper, _visible);
			if (!_visible)
			{
				BlueSageWindowHoverScope.UnregisterWindow(47057);
			}
			if (_visible)
			{
				_lastOwnedFooterTooltip = string.Empty;
				WindowFitResult windowFitResult = BlueSageWindowCoordinator.ResolveForOpen(BlueSagePublicWindow.StyleHelper, _hasOpened, _windowRect, 920f, 640f, Screen.width, Screen.height);
				_windowRect = new Rect(windowFitResult.X, windowFitResult.Y, windowFitResult.Width, windowFitResult.Height);
				_hasOpened = true;
				ResetTransientEditorStateForLiveSync(resetTab: true);
				DetectedDisplayNameState detectedDisplayNameState = (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.GetCurrentDisplayNameStateForStyleUi() : null);
				HydrateCurrentName(force: true, detectedDisplayNameState);
				HydrateCurrentStatus(detectedDisplayNameState);
				HydrateSpoons(detectedDisplayNameState);
				RebuildPreview();
				MarkSaved(detectedDisplayNameState?.DriftSummary ?? "Detected current in-game values. Edit a field to start a draft.");
			}
		}

		private void OnGUI()
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			if (!_visible || Plugin.EnableStyleUi == null || !Plugin.EnableStyleUi.Value)
			{
				BlueSageWindowCoordinator.SetVisible(BlueSagePublicWindow.StyleHelper, visible: false);
				return;
			}
			BlueSageWindowCoordinator.SetVisible(BlueSagePublicWindow.StyleHelper, visible: true);
			EnsureStyles();
			ClampWindowToScreen();
			BlueSageWindowHoverScope.RegisterWindow(47057, _windowRect, 10);
			_windowRect = GUI.Window(47057, _windowRect, new WindowFunction(DrawWindow), string.Empty, _windowStyle);
			ClampWindowToScreen();
		}

		private void DrawWindow(int id)
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			string tooltip = GUI.tooltip;
			GUI.tooltip = string.Empty;
			if ((Object)(object)_windowBackgroundTexture != (Object)null)
			{
				GUI.DrawTexture(new Rect(0f, 0f, ((Rect)(ref _windowRect)).width, ((Rect)(ref _windowRect)).height), (Texture)(object)_windowBackgroundTexture);
			}
			DrawHeader();
			GUILayout.Space(10f);
			DrawTabs();
			GUILayout.Space(8f);
			_contentScroll = GUILayout.BeginScrollView(_contentScroll, false, true, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(GetContentScrollHeight()) });
			if (_tab == 0)
			{
				DrawStyleTab();
			}
			else if (_tab == 1)
			{
				DrawStatusTab();
			}
			else
			{
				DrawTemplatesTab();
			}
			GUILayout.EndScrollView();
			DrawFooter(tooltip);
			DrawResizeGrip();
			GUI.DragWindow(new Rect(0f, 0f, ((Rect)(ref _windowRect)).width - 138f, 34f));
		}

		private void DrawHeader()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Expected O, but got Unknown
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Expected O, but got Unknown
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Expected O, but got Unknown
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Expected O, but got Unknown
			GUI.Box(new Rect(0f, 0f, ((Rect)(ref _windowRect)).width, 38f), GUIContent.none, _headerBoxStyle);
			GUI.Label(new Rect(18f, 7f, ((Rect)(ref _windowRect)).width - 330f, 28f), "▣ BlueSage Style Helper  v0.2.4", _headerStyle);
			if (GUI.Button(new Rect(((Rect)(ref _windowRect)).width - 308f, 5f, 108f, 28f), new GUIContent("Thunderstore", "Open the BlueSage QoL Tweaks Thunderstore page."), _buttonStyle))
			{
				Application.OpenURL("https://thunderstore.io/c/on-together/p/Blues/BlueSage_QoL_Tweaks_Beta/");
			}
			if (GUI.Button(new Rect(((Rect)(ref _windowRect)).width - 192f, 5f, 58f, 28f), new GUIContent("Ko-fi", "Support Blue's community modding work on Ko-fi."), _buttonStyle))
			{
				Application.OpenURL("https://ko-fi.com/Q5Q1JRPW");
			}
			if (GUI.Button(new Rect(((Rect)(ref _windowRect)).width - 126f, 5f, 76f, 28f), new GUIContent("Discord", "Open Blue's On-Together community Discord."), _buttonStyle))
			{
				Application.OpenURL("https://discord.gg/JujMEwtN3q");
			}
			if (GUI.Button(new Rect(((Rect)(ref _windowRect)).width - 42f, 5f, 30f, 28f), new GUIContent("X", "Close this window"), _activeButtonStyle))
			{
				_visible = false;
				BlueSageWindowCoordinator.SetVisible(BlueSagePublicWindow.StyleHelper, visible: false);
				BlueSageWindowHoverScope.UnregisterWindow(47057);
			}
		}

		private float GetContentScrollHeight()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return Mathf.Max(36f, BlueSageHelpFrame.Resolve(BlueSageHelpFrameKind.StyleHelper, _windowRect).ContentHeight);
		}

		private float GetFooterHeight()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return BlueSageHelpFrame.Resolve(BlueSageHelpFrameKind.StyleHelper, _windowRect).FooterHeight;
		}

		private void DrawTabs()
		{
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			DrawTabButton(0, "Name Styler", "Build styled name/chat text with colors, bold, italic, and gradients.");
			DrawTabButton(1, "Status Styler", "Set your activity tag and Spoons together without overwriting your styled name.");
			DrawTabButton(2, "Templates", "Save or load five local name-style templates. Status and Spoons stay separate.");
			GUILayout.EndHorizontal();
		}

		private void DrawTabButton(int index, string label, string tooltip)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			bool flag = _tab == index;
			if (GUILayout.Button(new GUIContent(label, tooltip), flag ? _activeButtonStyle : _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(32f) }))
			{
				if (_tab != index)
				{
					_tab = index;
					_contentScroll = Vector2.zero;
				}
				RebuildPreview();
			}
		}

		private void DrawStyleTab()
		{
			GUILayout.BeginVertical(_boxStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandHeight(false) });
			GUILayout.Label("NAME STYLER: type the name text players should see, choose color/bold/italic/gradient, then use Apply Name Styler or Copy Name Style Text.", _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label("Tip: choose Color A/B/C first, then tap a swatch. The highlighted slot is the one the shared color library will change.", _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label("Detected rich-text tags stay visible and editable here, including nested <b>, <rotate>, and <size>. Undo/Redo keeps up to 50 steps.", _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Space(4f);
			GUILayout.Label("Text", _labelStyle, Array.Empty<GUILayoutOption>());
			string text = GUILayout.TextArea(_text ?? string.Empty, _textFieldStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.MinHeight(54f),
				GUILayout.MaxHeight(92f)
			});
			if (text != _text)
			{
				CaptureUndo("Text edit");
				_text = text;
				ClearDetectedNamePreview();
				RebuildPreview();
				MarkDraft("Name draft changed. Apply Name Styler or Copy Name Style Text when ready.");
			}
			GUILayout.Space(6f);
			DrawColorRow();
			GUILayout.Space(6f);
			DrawModeRow();
			if ((_text ?? string.Empty).IndexOf('<') >= 0)
			{
				GUILayout.Label("Custom Rich Text mode: the exact balanced markup is authoritative. BlueSage verifies tag structure; the game decides whether each tag/value renders. Presets do not rewrite custom markup unless you remove it first.", _smallStyle, Array.Empty<GUILayoutOption>());
			}
			GUILayout.Space(6f);
			DrawPreview();
			GUILayout.EndVertical();
		}

		private void DrawStatusTab()
		{
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Expected O, but got Unknown
			GUILayout.BeginVertical(_boxStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandHeight(false) });
			GUILayout.Label("STATUS STYLER: set the short activity tag after your name, like Rowan (Testing). Spoons is the optional compact [3/5sp] tag.", _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label("Tip: Status Styler changes only the activity tag. Name Styler colors stay separate; the color library here updates the status color.", _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label("Clear Status removes the live status. Undo tries to restore the last Style Helper apply/clear/edit.", _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Space(4f);
			GUILayout.Label("Status", _labelStyle, Array.Empty<GUILayoutOption>());
			string text = GUILayout.TextArea(_status ?? string.Empty, _textFieldStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.MinHeight(54f),
				GUILayout.MaxHeight(92f)
			});
			if (text != _status)
			{
				CaptureUndo("Status edit");
				_status = text;
				RebuildPreview();
				MarkDraft("Status draft changed. Apply Status Styler when ready.");
			}
			GUILayout.Space(6f);
			DrawStatusColorRow();
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (GUILayout.Button(new GUIContent("Clear Status", "Remove only the activity/status text from your display name. Your styled base name and Spoons setting remain separate."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(32f) }))
			{
				CaptureUndo("Clear Status", restoreName: false, restoreStatus: true);
				bool applied = false;
				_message = (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.TryClearStatusFromStyleUi(out applied) : "Style UI: plugin is not ready yet.");
				MarkApplyOutcome(applied, "Live status cleared. Name and Spoons settings were left alone.", "Status was not cleared; fix the reported problem and try again.");
			}
			GUILayout.EndHorizontal();
			DrawSpoonsControls();
			DrawPreview();
			GUILayout.EndVertical();
		}

		private void DrawSpoonsControls()
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Expected O, but got Unknown
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Expected O, but got Unknown
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Expected O, but got Unknown
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Expected O, but got Unknown
			GUILayout.Space(8f);
			GUILayout.Label("Spoons", _labelStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label("Optional compact social-battery tag, like [3/5sp]. Default is hidden; Save Spoons or Show Tag opts in, Hide Tag removes it from your name.", _smallStyle, Array.Empty<GUILayoutOption>());
			DrawSpoonCustomLabelRow();
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label(new GUIContent("Spoons 0-5", "Set your optional spoon tag from 0 to 5. Lower numbers can mean lower social battery."), _labelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(120f) });
			string text = _spoonCountText ?? string.Empty;
			string text2 = GUILayout.TextField(text, 3, _textFieldStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(80f),
				GUILayout.Height(28f)
			});
			if (!string.Equals(text2, text, StringComparison.Ordinal))
			{
				CaptureUndo("Spoons edit");
				_spoonCountText = text2;
				MarkDraft("Spoons draft changed. Save Spoons or Show Tag to apply it.");
			}
			if (GUILayout.Button(new GUIContent("Save Spoons", "Save the compact [0/5sp]-[5/5sp] tag and apply it to your display name."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(28f) }))
			{
				CaptureUndo("Save Spoons", restoreName: true, restoreStatus: false, restoreSpoons: true);
				SaveSpoonsFromStyleUi();
			}
			if (GUILayout.Button(new GUIContent("Show Tag", "Show your saved [0/5sp]-[5/5sp] tag in your display name."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(28f) }))
			{
				CaptureUndo("Show Spoon Tag", restoreName: true, restoreStatus: false, restoreSpoons: true);
				if ((Object)(object)Plugin.Instance != (Object)null)
				{
					_message = Plugin.Instance.TrySetSpoonVisibilityFromMenu(enabled: true, out var applied);
					MarkApplyOutcome(applied, "Spoons tag is visible in your name.", "Spoons stayed unchanged; fix the reported problem and try again.");
				}
			}
			if (GUILayout.Button(new GUIContent("Hide Tag", "Hide the optional [spoons] tag from your display name. Your saved spoon number stays here for later."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(28f) }))
			{
				CaptureUndo("Hide Spoon Tag", restoreName: true, restoreStatus: false, restoreSpoons: true);
				if ((Object)(object)Plugin.Instance != (Object)null)
				{
					_message = Plugin.Instance.TrySetSpoonVisibilityFromMenu(enabled: false, out var applied2);
					MarkApplyOutcome(applied2, "Spoons tag is hidden. Saved spoon number remains here.", "Spoons stayed unchanged; fix the reported problem and try again.");
				}
			}
			if (GUILayout.Button(new GUIContent("Undo Spoons", "Undo only the last Spoons save/show/hide action. Name, status, and template undo still live in the main footer Undo."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(104f),
				GUILayout.Height(28f)
			}))
			{
				UndoSpoonsLastAction();
			}
			GUILayout.EndHorizontal();
		}

		private void DrawSpoonCustomLabelRow()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label(new GUIContent("Custom label", "Optional 1-12 character label after 0/5. Default 'sp' makes [3/5sp]; try energy or spoons."), _labelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(120f) });
			string text = GUILayout.TextField(_spoonLabelText ?? string.Empty, 12, _textFieldStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(140f),
				GUILayout.Height(28f)
			});
			if (!string.Equals(text, _spoonLabelText, StringComparison.Ordinal))
			{
				CaptureUndo("Mood label edit");
				_spoonLabelText = text;
				MarkDraft("Mood label changed. Save Spoons applies it; /setmood does the same from chat.");
			}
			GUILayout.Label("Default is 'sp'. /setmood default restores it.", _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.EndHorizontal();
		}

		private void DrawStatusColorRow()
		{
			DrawStatusColorPicker();
			GUILayout.Label("Status color library: tap a swatch to color only the status tag.", _labelStyle, Array.Empty<GUILayoutOption>());
			DrawPresetColorLibrary((string preset) => new GUIContent("#" + preset, "Use #" + preset + " for only your status tag. It will not recolor your styled name."), delegate(string preset)
			{
				CaptureUndo("Status color swatch");
				_statusColor = preset;
				_message = "Status color set to #" + preset + ".";
				RebuildPreview();
				MarkDraft("Status color draft changed. Apply Status Styler when ready.");
			});
		}

		private void DrawStatusColorPicker()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Expected O, but got Unknown
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label(new GUIContent("Status color", "This color belongs only to Status Styler. It will not change Name Styler Color A."), _labelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(120f) });
			string text = _statusColor ?? string.Empty;
			string text2 = GUILayout.TextField(text, 8, _textFieldStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(112f),
				GUILayout.Height(28f)
			});
			if (text2 != text)
			{
				CaptureUndo("Status color edit");
				_statusColor = text2;
				RebuildPreview();
				MarkDraft("Status color draft changed. Apply Status Styler when ready.");
			}
			Color backgroundColor = GUI.backgroundColor;
			GUI.backgroundColor = HexToColor(_statusColor, backgroundColor);
			GUILayout.Button(new GUIContent(" ", "Current color preview for your status tag only."), _swatchButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(38f),
				GUILayout.Height(28f)
			});
			GUI.backgroundColor = backgroundColor;
			GUILayout.EndHorizontal();
		}

		private void DrawTemplatesTab()
		{
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected O, but got Unknown
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Expected O, but got Unknown
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Expected O, but got Unknown
			GUILayout.BeginVertical(_boxStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandHeight(false) });
			GUILayout.Label("Tip: Templates save name styling only: text, colors, style mode, bold, and italic. Load applies the saved name style right away; Status and Spoons stay separate.", _smallStyle, Array.Empty<GUILayoutOption>());
			for (int i = 1; i <= 5; i++)
			{
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				GUILayout.Label("Template " + i, _labelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(110f) });
				if (GUILayout.Button(new GUIContent("Save " + i, "Save the current Style tab text/colors/mode into this local template slot."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) }))
				{
					SaveTemplate(i);
				}
				if (GUILayout.Button(new GUIContent("Undo", "Undo the last template save/load or other Style Helper action."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) }))
				{
					UndoLastAction();
				}
				if (GUILayout.Button(new GUIContent("Load " + i, "Load and apply this saved name-style template now. Use Undo if it was not what you wanted."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) }))
				{
					LoadTemplate(i);
				}
				GUILayout.EndHorizontal();
			}
			GUILayout.EndVertical();
		}

		private void DrawColorRow()
		{
			DrawColorPicker("Color A", 0);
			DrawColorPicker("Color B", 1);
			DrawColorPicker("Color C", 2);
			GUILayout.Label("Color library: tap Color A/B/C first, then tap a swatch. Color mode uses A, Gradient uses A/B, Gradient 3 uses A/B/C.", _labelStyle, Array.Empty<GUILayoutOption>());
			DrawPresetColorLibrary((string preset) => new GUIContent("#" + preset, "Apply #" + preset + " to Color " + (char)(65 + _activeColorSlot) + " in the editor preview."), delegate(string preset)
			{
				CaptureUndo("Color swatch");
				SetColorSlot(_activeColorSlot, preset);
				RebuildPreview();
				MarkDraft("Color draft changed. Apply Name Styler or Copy Name Style Text when ready.");
			});
		}

		private void DrawPresetColorLibrary(Func<string, GUIContent> buildContent, Action<string> applyPreset)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			int num = Mathf.Clamp(Mathf.FloorToInt((((Rect)(ref _windowRect)).width - 72f) / 96f), 4, 9);
			int num2 = Mathf.CeilToInt((float)PresetColors.Length / (float)num);
			for (int i = 0; i < num2; i++)
			{
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				for (int j = i * num; j < Math.Min(PresetColors.Length, i * num + num); j++)
				{
					string text = PresetColors[j];
					Color backgroundColor = GUI.backgroundColor;
					Color contentColor = GUI.contentColor;
					GUI.contentColor = BlueSageUiTheme.BestTextColor(GUI.backgroundColor = HexToColor(text, backgroundColor), _theme);
					if (GUILayout.Button(buildContent(text), _swatchButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
					{
						GUILayout.MinWidth(84f),
						GUILayout.Height(28f)
					}))
					{
						applyPreset(text);
					}
					GUI.contentColor = contentColor;
					GUI.backgroundColor = backgroundColor;
				}
				GUILayout.EndHorizontal();
			}
		}

		private void DrawColorPicker(string label, int slot)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Expected O, but got Unknown
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (GUILayout.Button(new GUIContent(label, "Choose which color slot the swatch library changes. A is used by every style mode."), (_activeColorSlot == slot) ? _activeButtonStyle : _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(92f),
				GUILayout.Height(28f)
			}))
			{
				_activeColorSlot = slot;
			}
			string colorSlot = GetColorSlot(slot);
			string text = GUILayout.TextField(colorSlot ?? string.Empty, 8, _textFieldStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(112f),
				GUILayout.Height(28f)
			});
			if (text != colorSlot)
			{
				CaptureUndo(label + " edit");
				SetColorSlot(slot, text);
				RebuildPreview();
				MarkDraft(label + " draft changed. Apply when ready.");
			}
			Color backgroundColor = GUI.backgroundColor;
			GUI.backgroundColor = HexToColor(colorSlot, backgroundColor);
			GUILayout.Button(new GUIContent(" ", "Current color preview for this slot."), _swatchButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(38f),
				GUILayout.Height(28f)
			});
			GUI.backgroundColor = backgroundColor;
			GUILayout.EndHorizontal();
		}

		private void DrawModeRow()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Expected O, but got Unknown
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Expected O, but got Unknown
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Expected O, but got Unknown
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Expected O, but got Unknown
			GUILayout.Label("Style toggles", _labelStyle, Array.Empty<GUILayoutOption>());
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (GUILayout.Button(new GUIContent(_bold ? "Bold On" : "Bold Off", "Adds bold tags when using Color mode. Gradients ignore bold for cleaner output."), _bold ? _activeButtonStyle : _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) }))
			{
				CaptureUndo("Bold toggle");
				_bold = !_bold;
				ClearDetectedNamePreview();
				RebuildPreview();
				MarkDraft("Bold style draft changed. Apply Name Styler when ready.");
			}
			if (GUILayout.Button(new GUIContent(_italic ? "Italic On" : "Italic Off", "Adds italic tags when using Color mode. Gradients ignore italic for cleaner output."), _italic ? _activeButtonStyle : _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) }))
			{
				CaptureUndo("Italic toggle");
				_italic = !_italic;
				ClearDetectedNamePreview();
				RebuildPreview();
				MarkDraft("Italic style draft changed. Apply Name Styler when ready.");
			}
			if (GUILayout.Button(new GUIContent((_mode == 1) ? "Color On" : "Color", "Use Color A across the whole text. Best for simple readable names."), (_mode == 1) ? _activeButtonStyle : _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) }))
			{
				CaptureUndo("Color mode");
				_mode = 1;
				ClearDetectedNamePreview();
				RebuildPreview();
				MarkDraft("Color mode draft changed. Apply Name Styler when ready.");
			}
			if (GUILayout.Button(new GUIContent((_mode == 2) ? "Gradient On" : "Gradient", "Blend from Color A to Color B across the text."), (_mode == 2) ? _activeButtonStyle : _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) }))
			{
				CaptureUndo("Gradient mode");
				_mode = 2;
				ClearDetectedNamePreview();
				RebuildPreview();
				MarkDraft("Gradient mode draft changed. Apply Name Styler when ready.");
			}
			if (GUILayout.Button(new GUIContent((_mode == 3) ? "Gradient 3 On" : "Gradient 3", "Blend from Color A to B to C. Best for playful names, but can create longer hidden text."), (_mode == 3) ? _activeButtonStyle : _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) }))
			{
				CaptureUndo("Gradient 3 mode");
				_mode = 3;
				ClearDetectedNamePreview();
				RebuildPreview();
				MarkDraft("Gradient 3 mode draft changed. Apply Name Styler when ready.");
			}
			GUILayout.EndHorizontal();
		}

		private void DrawPreview()
		{
			GUILayout.Space(6f);
			int num = (_previewIsValid ? (_preview ?? string.Empty).Length : ((_tab == 1) ? (_status ?? string.Empty).Length : (_text ?? string.Empty).Length));
			GUILayout.Label($"Rich-text length: {num}/{Plugin.LockedMaxIdCardCharacters} characters (tags count too)", _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label(_message ?? string.Empty, _smallStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Box(_previewIsValid ? _preview : "Build a style to preview it here.", _previewStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Height(70f),
				GUILayout.ExpandWidth(true)
			});
			GUILayout.Label("Copy/paste text", _labelStyle, Array.Empty<GUILayoutOption>());
			DrawGeneratedTextArea();
		}

		private void DrawGeneratedTextArea()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			_scroll = GUILayout.BeginScrollView(_scroll, true, true, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height((_mode == 3) ? 116f : 90f) });
			GUILayout.TextArea(_preview ?? string.Empty, _generatedTextStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.ExpandHeight(true),
				GUILayout.ExpandWidth(true)
			});
			GUILayout.EndScrollView();
		}

		private void DrawFooter(string inheritedTooltip)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Expected O, but got Unknown
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Expected O, but got Unknown
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Expected O, but got Unknown
			//IL_0271: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Expected O, but got Unknown
			//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0322: Expected O, but got Unknown
			HelpFrameLayout layout = BlueSageHelpFrame.Resolve(BlueSageHelpFrameKind.StyleHelper, _windowRect);
			BlueSageHelpFrame.BeginFooter(_footerBoxStyle, layout);
			bool flag = ((Rect)(ref _windowRect)).width < 1100f;
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (GUILayout.Button(new GUIContent("Detect Current", "Re-detect your current in-game name, status, and Spoons into this helper. It does not apply anything by itself."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(34f) }))
			{
				CaptureUndo("Detect Current");
				ResetToCurrentPlayerState();
			}
			if (GUILayout.Button(new GUIContent("Undo", _hasUndo ? "Undo the last Style Helper apply, clear, template save/load, color pick, or local edit." : "No Style Helper action to undo yet."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(34f) }))
			{
				UndoLastAction();
			}
			if (GUILayout.Button(new GUIContent("Redo", (_redoHistory.Count > 0) ? "Redo the last undone Style Helper action." : "No Style Helper action to redo yet."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(34f) }))
			{
				RedoLastAction();
			}
			if (flag)
			{
				GUILayout.EndHorizontal();
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			}
			string obj = ((_tab == 1) ? "Apply Status Styler" : "Apply Name Styler");
			string text = ((_tab == 1) ? "Apply only the activity/status tag after your current name. Use Save Spoons for the Spoons tag." : "Apply the styled preview to your display name. Status and Spoons stay separate.");
			if (GUILayout.Button(new GUIContent(obj, text), _activeButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(34f) }))
			{
				if (_tab == 1 && _previewIsValid)
				{
					CaptureUndo("Apply Status Styler", restoreName: false, restoreStatus: true);
					bool applied = false;
					_message = (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.TryApplyStatusFromStyleUi(null, _status, CleanColor(_statusColor), out applied) : "Style UI: plugin is not ready yet.");
					MarkApplyOutcome(applied, "Status Styler applied to your live name.", "Status Styler did not apply; fix the reported problem and try again.");
				}
				else if (_tab != 1 && _previewIsValid)
				{
					CaptureUndo("Apply Name Styler", restoreName: true);
					bool applied2 = false;
					_message = (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.TryApplyStyledNameFromStyleUi(_preview, out applied2) : "Style UI: plugin is not ready yet.");
					MarkApplyOutcome(applied2, "Name Styler applied to your live name.", "Name Styler did not apply; fix the reported problem and try again.");
				}
				else
				{
					_message = "Build a valid style before applying it to your name.";
					MarkDraft("Fix the draft before applying.");
				}
			}
			string text2 = ((_tab == 1) ? "Copy Status Style Text" : "Copy Name Style Text");
			if (GUILayout.Button(new GUIContent(text2, "Copy the generated rich text to clipboard so you can paste it into chat, ID card, room, or profile fields."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(34f) }))
			{
				if (_previewIsValid)
				{
					CaptureUndo(text2);
					GUIUtility.systemCopyBuffer = _preview ?? string.Empty;
					_message = "Copied. Paste it into your name, ID card, room, status, or chat field.";
					Plugin.AddLocalNotification("Style UI: copied styled text.");
					MarkAction("Copied current style text to clipboard.");
				}
				else
				{
					_message = "Build a valid style before copying.";
					MarkDraft("Fix the draft before copying.");
				}
			}
			if (GUILayout.Button(new GUIContent("Clear Draft", "Clear only the current editor draft. It does not change your live name/status; use Apply Status Styler or Clear Status for live status changes."), _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(34f) }))
			{
				CaptureUndo("Clear Draft");
				if (_tab == 1)
				{
					_status = string.Empty;
				}
				else
				{
					_text = "YOURNAMEHERE";
					ClearDetectedNamePreview();
				}
				_preview = string.Empty;
				_previewIsValid = false;
				_message = ((_tab == 1) ? "Status draft cleared only. Use Clear Status to remove your live status." : "Draft cleared. Type your name or load a template.");
				MarkDraft("Draft cleared locally. Live name/status is unchanged until you apply.");
			}
			GUILayout.EndHorizontal();
			string stateLine = "State: " + _stateLabel + " — " + _stateDetail;
			BlueSageHelpFrame.DrawStateAndHelp(_footerTextStyle, layout, stateLine, BuildActiveTabFooterDescription(inheritedTooltip));
			BlueSageHelpFrame.EndFooter();
		}

		private string BuildActiveTabFooterDescription(string inheritedTooltip)
		{
			string result = ((_tab == 1) ? "Set your activity tag and Spoons together without overwriting your styled name." : ((_tab == 2) ? "Save or load five local name-style templates. Status and Spoons stay separate." : "Build styled name/chat text with colors, bold, italic, and gradients."));
			string tooltip = GUI.tooltip;
			bool flag = string.Equals(inheritedTooltip, _lastOwnedFooterTooltip, StringComparison.Ordinal);
			if (string.IsNullOrWhiteSpace(tooltip))
			{
				_lastOwnedFooterTooltip = string.Empty;
				return result;
			}
			if (string.Equals(tooltip, inheritedTooltip, StringComparison.Ordinal) && !flag)
			{
				_lastOwnedFooterTooltip = string.Empty;
				return result;
			}
			_lastOwnedFooterTooltip = tooltip;
			return tooltip;
		}

		private void RebuildPreview()
		{
			if (_tab != 1 && UseDetectedNamePreviewIfAvailable())
			{
				return;
			}
			string usableName = GetUsableName();
			if (!RichTextDraftPolicy.TryValidate((_tab == 1) ? (_status ?? string.Empty) : usableName, out var message))
			{
				_previewIsValid = false;
				_preview = message;
				_message = message;
				return;
			}
			if (_tab != 1 && usableName.IndexOf('<') >= 0)
			{
				_previewIsValid = usableName.Length <= Plugin.LockedMaxIdCardCharacters;
				_preview = usableName;
				_message = (_previewIsValid ? $"Ready: {_preview.Length}/{Plugin.LockedMaxIdCardCharacters} chars. Custom Rich Text mode preserves exact balanced markup; verify uncommon TMP tags in preview/game." : $"Styled text is too long ({usableName.Length}/{Plugin.LockedMaxIdCardCharacters}).");
				return;
			}
			if (_tab == 1)
			{
				_preview = StatusSuffixPolicy.Build(_status ?? string.Empty, CleanColor(_statusColor), Plugin.StatusBrackets?.Value ?? "()");
				_previewIsValid = _preview.Length <= Plugin.LockedMaxIdCardCharacters;
				_message = (_previewIsValid ? $"Ready: {_preview.Length}/{Plugin.LockedMaxIdCardCharacters} chars. Preview, Copy, and Apply use your saved status brackets." : $"Styled status is too long ({_preview.Length}/{Plugin.LockedMaxIdCardCharacters}).");
				return;
			}
			string arguments;
			if (_mode != 1)
			{
				arguments = ((_mode != 2) ? ("gradient3 #" + CleanColor(_colorA) + " #" + CleanColor(_colorB) + " #" + CleanColor(_colorC) + " " + usableName) : ("gradient #" + CleanColor(_colorA) + " #" + CleanColor(_colorB) + " " + usableName));
			}
			else
			{
				string text = ((_bold && _italic) ? "bolditalic" : (_bold ? "bold" : (_italic ? "italic" : "color")));
				arguments = text + " #" + CleanColor(_colorA) + " " + usableName;
			}
			RichTextStyleResult richTextStyleResult = RichTextStyleBuilder.TryBuild(arguments, Plugin.LockedMaxIdCardCharacters);
			_previewIsValid = richTextStyleResult.Success;
			_preview = (richTextStyleResult.Success ? richTextStyleResult.GeneratedText : richTextStyleResult.Message);
			_message = (richTextStyleResult.Success ? $"Ready: {_preview.Length}/{Plugin.LockedMaxIdCardCharacters} chars. Apply Name Styler or Copy Name Style Text." : richTextStyleResult.Message);
		}

		private void HydrateCurrentName()
		{
			HydrateCurrentName(force: false);
		}

		private void HydrateCurrentName(bool force, DetectedDisplayNameState detectedState = null)
		{
			if (force || string.Equals(_text, "YOURNAMEHERE", StringComparison.Ordinal))
			{
				string text = ((detectedState != null) ? RichTextStyleBuilder.ToPlainStyleEditorText(detectedState.BaseName) : (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.GetCurrentPlayerPlainNameForStyleUi() : string.Empty));
				_detectedNamePreview = detectedState?.BaseName ?? (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.GetCurrentPlayerStyledNameForStyleUi() : string.Empty);
				if (!string.IsNullOrWhiteSpace(_detectedNamePreview))
				{
					_text = _detectedNamePreview;
					HydrateDetectedStyleControls(_detectedNamePreview);
				}
				else if (!string.IsNullOrWhiteSpace(text))
				{
					_text = text;
				}
			}
		}

		private void HydrateDetectedStyleControls(string styledName)
		{
			MatchCollection matchCollection = Regex.Matches(styledName ?? string.Empty, "<(?:color\\s*=\\s*#?|#)([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})\\s*>", RegexOptions.IgnoreCase);
			List<string> list = new List<string>();
			foreach (Match item in matchCollection)
			{
				if (RichTextStyleBuilder.TryNormalizeHex(item.Groups[1].Value, out var hex) && !list.Contains(hex))
				{
					list.Add(hex);
				}
			}
			if (list.Count > 0)
			{
				_colorA = list[0];
				_colorB = list[Math.Min(list.Count - 1, Math.Max(1, list.Count / 2))];
				_colorC = list[list.Count - 1];
				_mode = DetectColorMode(list);
			}
			_bold = Regex.IsMatch(styledName ?? string.Empty, "<\\s*b(?:\\s|>)", RegexOptions.IgnoreCase);
			_italic = Regex.IsMatch(styledName ?? string.Empty, "<\\s*i(?:\\s|>)", RegexOptions.IgnoreCase);
		}

		private void ResetToCurrentPlayerState()
		{
			ResetTransientEditorStateForLiveSync(resetTab: false, clearHistory: false);
			DetectedDisplayNameState detectedDisplayNameState = (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.GetCurrentDisplayNameStateForStyleUi() : null);
			HydrateCurrentName(force: true, detectedDisplayNameState);
			HydrateCurrentStatus(detectedDisplayNameState);
			HydrateSpoons(detectedDisplayNameState);
			_message = ((_tab == 1) ? ("Detected current status and Spoons. " + (detectedDisplayNameState?.DriftSummary ?? "No live player state was available yet.")) : ("Detected current name. " + (detectedDisplayNameState?.DriftSummary ?? "No live player state was available yet.")));
			RebuildPreview();
			MarkSaved(detectedDisplayNameState?.DriftSummary ?? "Detected current in-game values. Edit a field to start a draft.");
		}

		private void ResetTransientEditorStateForLiveSync(bool resetTab, bool clearHistory = true)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if (resetTab)
			{
				_tab = 0;
			}
			_activeColorSlot = 0;
			_scroll = Vector2.zero;
			_contentScroll = Vector2.zero;
			if (clearHistory)
			{
				_undoHistory.Clear();
				_redoHistory.Clear();
			}
			_text = "YOURNAMEHERE";
			_colorA = "0E6EED";
			_colorB = "A59";
			_colorC = "D85";
			_bold = false;
			_italic = false;
			_mode = 3;
			_detectedNamePreview = string.Empty;
			_preview = string.Empty;
			_previewIsValid = false;
		}

		private void HydrateCurrentStatus(DetectedDisplayNameState detectedState = null)
		{
			_status = detectedState?.StatusMessage ?? Plugin.StatusMessage?.Value ?? string.Empty;
			_statusColor = detectedState?.StatusColor ?? Plugin.StatusColor?.Value ?? "FFD45D";
		}

		private void HydrateSpoons(DetectedDisplayNameState detectedState = null)
		{
			_spoonCountText = ((detectedState != null) ? detectedState.SpoonCount.ToString() : (Plugin.SpoonCount?.Value.ToString() ?? "5"));
			_spoonLabelText = detectedState?.SpoonLabel ?? Plugin.SpoonLabel?.Value ?? "sp";
		}

		private string GetUsableName()
		{
			string text = (_text ?? string.Empty).Trim();
			if (!string.IsNullOrWhiteSpace(text))
			{
				return text;
			}
			return "YOURNAMEHERE";
		}

		private void SaveTemplate(int index)
		{
			CaptureUndo("Save Template " + index);
			string text = TemplatePrefix(index);
			PlayerPrefs.SetString(text + "Text", _text ?? string.Empty);
			PlayerPrefs.SetString(text + "ColorA", _colorA ?? string.Empty);
			PlayerPrefs.SetString(text + "ColorB", _colorB ?? string.Empty);
			PlayerPrefs.SetString(text + "ColorC", _colorC ?? string.Empty);
			PlayerPrefs.SetInt(text + "Mode", _mode);
			PlayerPrefs.SetInt(text + "Bold", _bold ? 1 : 0);
			PlayerPrefs.SetInt(text + "Italic", _italic ? 1 : 0);
			PlayerPrefs.Save();
			_message = "Saved template " + index + ".";
			MarkSaved("Template " + index + " saved locally.");
		}

		private void LoadTemplate(int index)
		{
			CaptureUndo("Load Template " + index, restoreName: true);
			string text = TemplatePrefix(index);
			if (!PlayerPrefs.HasKey(text + "Text"))
			{
				_message = "Template " + index + " is empty. Detect Current loads live player data; Save " + index + " stores this slot.";
				MarkDraft("Template " + index + " is empty; live player data was left unchanged.");
				return;
			}
			_text = PlayerPrefs.GetString(text + "Text", "YOURNAMEHERE");
			ClearDetectedNamePreview();
			_colorA = PlayerPrefs.GetString(text + "ColorA", "0E6EED");
			_colorB = PlayerPrefs.GetString(text + "ColorB", "A59");
			_colorC = PlayerPrefs.GetString(text + "ColorC", "D85");
			_mode = PlayerPrefs.GetInt(text + "Mode", 3);
			_bold = PlayerPrefs.GetInt(text + "Bold", 0) == 1;
			_italic = PlayerPrefs.GetInt(text + "Italic", 0) == 1;
			RebuildPreview();
			if (!_previewIsValid)
			{
				_message = "Template " + index + " loaded, but it cannot apply yet: " + _message;
				MarkDraft("Template " + index + " loaded into a draft that needs fixing.");
				return;
			}
			bool applied = false;
			string text2 = (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.TryApplyStyledNameFromStyleUi(_preview, out applied) : "Style UI: plugin is not ready yet.");
			_message = (applied ? "Loaded and applied template " : "Loaded template but could not apply it ") + index + ". " + text2;
			MarkApplyOutcome(applied, "Template " + index + " loaded and applied to your live name.", "Template " + index + " remains a draft because the live apply failed.");
		}

		private void SaveSpoonsFromStyleUi()
		{
			if (Plugin.SpoonCount == null || Plugin.EnableSpoons == null)
			{
				_message = "Spoons config is not ready yet.";
				MarkDraft("Spoons could not save because config is not ready.");
				return;
			}
			if (!int.TryParse((_spoonCountText ?? string.Empty).Trim(), out var result))
			{
				_message = "Spoons must be a number from 0 to 5.";
				MarkDraft("Fix Spoons to a number from 0 to 5.");
				return;
			}
			int count = Mathf.Clamp(result, 0, 5);
			string text = new string((_spoonLabelText ?? string.Empty).Where((char c) => char.IsLetterOrDigit(c) || c == '-' || c == '_').Take(12).ToArray());
			if (string.IsNullOrWhiteSpace(text))
			{
				_message = "Custom label must use 1-12 letters/numbers, '-' or '_'. Use 'sp' for the default.";
				MarkDraft("Fix the custom Spoons/mood label before saving.");
				return;
			}
			bool applied = false;
			_message = (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.TryApplySpoonsFromStyleUi(count, text, enabled: true, DateTime.UtcNow.ToString("O"), out applied) : "Spoons config is not ready yet.");
			if (applied)
			{
				_spoonCountText = count.ToString();
			}
			MarkApplyOutcome(applied, "Spoons saved and applied to your live name.", "Spoons were not saved; fix the reported problem and try again.");
		}

		private void CaptureUndo(string action, bool restoreName = false, bool restoreStatus = false, bool restoreSpoons = false)
		{
			_undoHistory.Push(CaptureSnapshot(action, restoreName, restoreStatus, restoreSpoons));
			while (_undoHistory.Count > 50)
			{
				StyleHelperSnapshot[] array = _undoHistory.ToArray();
				_undoHistory.Clear();
				for (int num = Math.Min(49, array.Length - 1); num >= 0; num--)
				{
					_undoHistory.Push(array[num]);
				}
			}
			_redoHistory.Clear();
		}

		private StyleHelperSnapshot CaptureSnapshot(string action, bool restoreName = false, bool restoreStatus = false, bool restoreSpoons = false)
		{
			return new StyleHelperSnapshot
			{
				Action = (action ?? "Action"),
				Text = _text,
				ColorA = _colorA,
				ColorB = _colorB,
				ColorC = _colorC,
				Status = _status,
				StatusColorDraft = _statusColor,
				Preview = _preview,
				Message = _message,
				PreviewIsValid = _previewIsValid,
				DetectedNamePreview = _detectedNamePreview,
				Bold = _bold,
				Italic = _italic,
				Mode = _mode,
				Tab = _tab,
				ActiveColorSlot = _activeColorSlot,
				RestoreName = restoreName,
				RestoreStatus = restoreStatus,
				PlayerName = (((Object)(object)Plugin.Instance != (Object)null) ? Plugin.Instance.GetCurrentPlayerDisplayNameForStyleUi() : string.Empty),
				PlayerStatus = (Plugin.StatusMessage?.Value ?? string.Empty),
				PlayerStatusColor = (Plugin.StatusColor?.Value ?? "FFD45D"),
				SpoonCountText = _spoonCountText,
				SpoonLabelText = _spoonLabelText,
				StateLabel = _stateLabel,
				StateDetail = _stateDetail,
				RestoreSpoons = restoreSpoons,
				SpoonsEnabled = (Plugin.EnableSpoons != null && Plugin.EnableSpoons.Value),
				SpoonCount = (Plugin.SpoonCount?.Value ?? 5),
				SavedSpoonLabel = (Plugin.SpoonLabel?.Value ?? "sp"),
				SpoonsUpdatedUtc = (Plugin.SpoonsUpdatedUtc?.Value ?? string.Empty)
			};
		}

		private bool UndoLastAction()
		{
			if (!_hasUndo)
			{
				_message = "Nothing to undo yet.";
				return false;
			}
			_redoHistory.Push(CaptureSnapshot("Redo " + _undoHistory.Peek().Action, _undoHistory.Peek().RestoreName, _undoHistory.Peek().RestoreStatus, _undoHistory.Peek().RestoreSpoons));
			StyleHelperSnapshot snapshot = _undoHistory.Pop();
			return RestoreSnapshot(snapshot, "Undid ");
		}

		private bool RedoLastAction()
		{
			if (_redoHistory.Count == 0)
			{
				_message = "Nothing to redo yet.";
				return false;
			}
			StyleHelperSnapshot styleHelperSnapshot = _redoHistory.Peek();
			_undoHistory.Push(CaptureSnapshot("Undo " + styleHelperSnapshot.Action, styleHelperSnapshot.RestoreName, styleHelperSnapshot.RestoreStatus, styleHelperSnapshot.RestoreSpoons));
			return RestoreSnapshot(_redoHistory.Pop(), "Redid ");
		}

		private bool RestoreSnapshot(StyleHelperSnapshot snapshot, string verb)
		{
			_text = snapshot.Text;
			_colorA = snapshot.ColorA;
			_colorB = snapshot.ColorB;
			_colorC = snapshot.ColorC;
			_status = snapshot.Status;
			_statusColor = snapshot.StatusColorDraft;
			_preview = snapshot.Preview;
			_detectedNamePreview = snapshot.DetectedNamePreview;
			_message = snapshot.Message;
			_previewIsValid = snapshot.PreviewIsValid;
			_bold = snapshot.Bold;
			_italic = snapshot.Italic;
			_mode = snapshot.Mode;
			_tab = snapshot.Tab;
			_activeColorSlot = snapshot.ActiveColorSlot;
			_spoonCountText = snapshot.SpoonCountText;
			_spoonLabelText = snapshot.SpoonLabelText;
			_stateLabel = snapshot.StateLabel;
			_stateDetail = snapshot.StateDetail;
			bool flag = true;
			string text = verb + snapshot.Action + ".";
			if (snapshot.RestoreSpoons && (Object)(object)Plugin.Instance != (Object)null)
			{
				bool applied;
				string text2 = Plugin.Instance.TryApplySpoonsFromStyleUi(snapshot.SpoonCount, snapshot.SavedSpoonLabel ?? "sp", snapshot.SpoonsEnabled, snapshot.SpoonsUpdatedUtc, out applied);
				text = text + " " + text2;
				flag = flag && applied;
				if (applied)
				{
					_spoonCountText = Mathf.Clamp(snapshot.SpoonCount, 0, 5).ToString();
					_spoonLabelText = snapshot.SavedSpoonLabel ?? "sp";
				}
			}
			if (snapshot.RestoreName && (Object)(object)Plugin.Instance != (Object)null && !string.IsNullOrWhiteSpace(snapshot.PlayerName))
			{
				text = text + " " + Plugin.Instance.TryApplyStyledNameFromStyleUi(snapshot.PlayerName, out var applied2);
				flag = flag && applied2;
			}
			if (snapshot.RestoreStatus && (Object)(object)Plugin.Instance != (Object)null)
			{
				bool applied3;
				string text3 = (string.IsNullOrWhiteSpace(snapshot.PlayerStatus) ? Plugin.Instance.TryClearStatusFromStyleUi(out applied3) : Plugin.Instance.TryApplyStatusFromStyleUi(null, snapshot.PlayerStatus, snapshot.PlayerStatusColor, out applied3));
				text = text + " " + text3;
				flag = flag && applied3;
			}
			RebuildPreview();
			_message = text;
			MarkApplyOutcome(flag, verb.Trim() + " restored the saved/live state for that action.", verb.Trim() + " could not restore every live value; rejected values stayed unchanged.");
			return flag;
		}

		private void UndoSpoonsLastAction()
		{
			if (!_hasUndo || !_undoHistory.Peek().RestoreSpoons)
			{
				_message = "Nothing to undo for Spoons yet.";
				MarkDraft("Spoons undo needs a prior Save Spoons, Show Tag, or Hide Tag action.");
			}
			else
			{
				bool applied = UndoLastAction();
				MarkApplyOutcome(applied, "Spoons undo restored only the last Spoons state.", "Spoons undo could not apply; saved/live values stayed unchanged.");
			}
		}

		private static string TemplatePrefix(int index)
		{
			return "BlueSageQoL.StyleTemplate." + index + ".";
		}

		private string GetColorSlot(int slot)
		{
			return slot switch
			{
				1 => _colorB, 
				2 => _colorC, 
				_ => _colorA, 
			};
		}

		private void MarkDraft(string detail)
		{
			_stateLabel = "Draft";
			_stateDetail = detail ?? "Changes are local until you apply or save.";
		}

		private void MarkSaved(string detail)
		{
			_stateLabel = "Saved";
			_stateDetail = detail ?? "Ready.";
		}

		private void MarkApplyOutcome(bool applied, string savedDetail, string failedDetail)
		{
			if (applied)
			{
				MarkSaved(savedDetail);
			}
			else
			{
				MarkDraft(failedDetail);
			}
		}

		private void MarkAction(string detail)
		{
			_stateLabel = "Done";
			_stateDetail = detail ?? "Done.";
		}

		private void SetColorSlot(int slot, string value)
		{
			switch (slot)
			{
			case 1:
				ClearDetectedNamePreview();
				_colorB = value;
				break;
			case 2:
				ClearDetectedNamePreview();
				_colorC = value;
				break;
			default:
				ClearDetectedNamePreview();
				_colorA = value;
				break;
			}
		}

		private bool UseDetectedNamePreviewIfAvailable()
		{
			if (string.IsNullOrWhiteSpace(_detectedNamePreview))
			{
				return false;
			}
			string a = RichTextStyleBuilder.ToPlainStyleEditorText(_detectedNamePreview);
			if (!string.Equals(_detectedNamePreview, GetUsableName(), StringComparison.Ordinal) && !string.Equals(a, GetUsableName(), StringComparison.Ordinal))
			{
				return false;
			}
			_preview = _detectedNamePreview;
			string message = string.Empty;
			_previewIsValid = _preview.Length <= Plugin.LockedMaxIdCardCharacters && RichTextDraftPolicy.TryValidate(_preview, out message);
			_message = (_previewIsValid ? "Detected current live name style." : ((_preview.Length > Plugin.LockedMaxIdCardCharacters) ? $"Detected current live name style is too long ({_preview.Length}/{Plugin.LockedMaxIdCardCharacters}). Shorten before applying." : message));
			return true;
		}

		private static int DetectColorMode(IReadOnlyList<string> colors)
		{
			if (colors == null || colors.Count <= 1)
			{
				return 1;
			}
			if (colors.Count == 2)
			{
				return 2;
			}
			if (!TryParseRgb(colors[0], out var red, out var green, out var blue) || !TryParseRgb(colors[colors.Count - 1], out var red2, out var green2, out var blue2))
			{
				return 3;
			}
			for (int i = 1; i < colors.Count - 1; i++)
			{
				if (!TryParseRgb(colors[i], out var red3, out var green3, out var blue3))
				{
					return 3;
				}
				double num = (double)i / (double)(colors.Count - 1);
				int num2 = (int)Math.Round((double)red + (double)(red2 - red) * num);
				int num3 = (int)Math.Round((double)green + (double)(green2 - green) * num);
				int num4 = (int)Math.Round((double)blue + (double)(blue2 - blue) * num);
				if (Math.Abs(red3 - num2) > 1 || Math.Abs(green3 - num3) > 1 || Math.Abs(blue3 - num4) > 1)
				{
					return 3;
				}
			}
			return 2;
		}

		private static bool TryParseRgb(string value, out int red, out int green, out int blue)
		{
			red = (green = (blue = 0));
			if (!RichTextStyleBuilder.TryNormalizeHex(value, out var hex))
			{
				return false;
			}
			red = Convert.ToInt32(hex.Substring(0, 2), 16);
			green = Convert.ToInt32(hex.Substring(2, 2), 16);
			blue = Convert.ToInt32(hex.Substring(4, 2), 16);
			return true;
		}

		private void ClearDetectedNamePreview()
		{
			_detectedNamePreview = string.Empty;
		}

		private static string CleanColor(string value)
		{
			string text = (value ?? string.Empty).Trim().TrimStart(new char[1] { '#' });
			if (!string.IsNullOrWhiteSpace(text))
			{
				return text;
			}
			return "0E6EED";
		}

		private static Color HexToColor(string value, Color fallback)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (!RichTextStyleBuilder.TryNormalizeHex(value, out var hex))
			{
				return fallback;
			}
			float num = (float)Convert.ToInt32(hex.Substring(0, 2), 16) / 255f;
			float num2 = (float)Convert.ToInt32(hex.Substring(2, 2), 16) / 255f;
			float num3 = (float)Convert.ToInt32(hex.Substring(4, 2), 16) / 255f;
			return new Color(num, num2, num3, 1f);
		}

		private void ClampWindowToScreen()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			WindowFitResult windowFitResult = BlueSageWindowCoordinator.ResolveForFrame(BlueSagePublicWindow.StyleHelper, _windowRect, 920f, 640f, Screen.width, Screen.height);
			_windowRect = new Rect(windowFitResult.X, windowFitResult.Y, windowFitResult.Width, windowFitResult.Height);
		}

		private void OnDisable()
		{
			BlueSageWindowCoordinator.SetVisible(BlueSagePublicWindow.StyleHelper, visible: false);
			BlueSageWindowHoverScope.UnregisterWindow(47057);
		}

		private void DrawResizeGrip()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Invalid comparison between Unknown and I4
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(((Rect)(ref _windowRect)).width - 42f - 8f, ((Rect)(ref _windowRect)).height - 42f - 8f, 42f, 42f);
			GUI.Box(val, new GUIContent("↘", "Drag this larger corner handle to resize the Style Helper."), _buttonStyle);
			Event current = Event.current;
			if (current != null)
			{
				if ((int)current.type == 0 && ((Rect)(ref val)).Contains(current.mousePosition))
				{
					_isResizing = true;
					current.Use();
				}
				else if (_isResizing && (int)current.type == 3)
				{
					ref Rect windowRect = ref _windowRect;
					((Rect)(ref windowRect)).width = ((Rect)(ref windowRect)).width + current.delta.x;
					ref Rect windowRect2 = ref _windowRect;
					((Rect)(ref windowRect2)).height = ((Rect)(ref windowRect2)).height + current.delta.y;
					ClampWindowToScreen();
					current.Use();
				}
				else if (_isResizing && (int)current.rawType == 1)
				{
					_isResizing = false;
					current.Use();
				}
			}
		}

		private void EnsureStyles()
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Expected O, but got Unknown
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Expected O, but got Unknown
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Expected O, but got Unknown
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Expected O, but got Unknown
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Expected O, but got Unknown
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Expected O, but got Unknown
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Expected O, but got Unknown
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_027b: Unknown result type (might be due to invalid IL or missing references)
			//IL_028a: Expected O, but got Unknown
			//IL_0295: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b2: Expected O, but got Unknown
			//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02be: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e8: Expected O, but got Unknown
			//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0307: Unknown result type (might be due to invalid IL or missing references)
			//IL_030e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0315: Unknown result type (might be due to invalid IL or missing references)
			//IL_0321: Unknown result type (might be due to invalid IL or missing references)
			//IL_0330: Expected O, but got Unknown
			//IL_0355: Unknown result type (might be due to invalid IL or missing references)
			//IL_035a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0366: Expected O, but got Unknown
			//IL_0371: Unknown result type (might be due to invalid IL or missing references)
			//IL_0376: Unknown result type (might be due to invalid IL or missing references)
			//IL_037d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0384: Unknown result type (might be due to invalid IL or missing references)
			//IL_038b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0393: Unknown result type (might be due to invalid IL or missing references)
			//IL_039f: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c9: Expected O, but got Unknown
			_theme = BlueSageUiTheme.Current;
			if (_windowStyle == null || !string.Equals(_lastThemeKey, _theme.Key, StringComparison.Ordinal) || _renderedTextureGeneration != BlueSageUiTheme.RuntimeTextureGeneration || !BlueSageUiTheme.AreRuntimeTexturesAlive())
			{
				_lastThemeKey = _theme.Key;
				Texture2D solidTexture = BlueSageUiTheme.GetSolidTexture(_theme.Window);
				Texture2D solidTexture2 = BlueSageUiTheme.GetSolidTexture(_theme.Panel);
				_windowBackgroundTexture = solidTexture;
				GUIStyle val = new GUIStyle(GUI.skin.window)
				{
					padding = new RectOffset(16, 16, 46, 14)
				};
				val.normal.background = solidTexture;
				val.normal.textColor = _theme.LabelText;
				val.onNormal.background = solidTexture;
				val.onNormal.textColor = _theme.LabelText;
				_windowStyle = val;
				GUIStyle val2 = new GUIStyle(GUI.skin.box);
				val2.normal.background = BlueSageUiTheme.GetSolidTexture(_theme.Header);
				_headerBoxStyle = val2;
				GUIStyle val3 = new GUIStyle(GUI.skin.label)
				{
					fontSize = 18,
					fontStyle = (FontStyle)1
				};
				val3.normal.textColor = _theme.HeaderText;
				_headerStyle = val3;
				GUIStyle val4 = new GUIStyle(GUI.skin.label)
				{
					fontSize = 15,
					fontStyle = (FontStyle)1
				};
				val4.normal.textColor = _theme.LabelText;
				_labelStyle = val4;
				GUIStyle val5 = new GUIStyle(GUI.skin.label)
				{
					richText = false,
					fontSize = 15,
					fontStyle = (FontStyle)1,
					wordWrap = true
				};
				val5.normal.textColor = Color.Lerp(_theme.SmallText, _theme.LabelText, 0.35f);
				_smallStyle = val5;
				_buttonStyle = BlueSageUiTheme.CreateNeutralButtonStyle(GUI.skin.button, _theme, 14);
				_activeButtonStyle = BlueSageUiTheme.CreateStateButtonStyle(_buttonStyle, _theme.ActiveAccent, _theme.FieldFocusedBorder, _theme.ActiveStateText, 14);
				GUIStyle val6 = new GUIStyle(GUI.skin.box)
				{
					stretchHeight = false,
					padding = new RectOffset(12, 12, 10, 10)
				};
				val6.normal.background = solidTexture2;
				val6.normal.textColor = _theme.LabelText;
				_boxStyle = val6;
				GUIStyle val7 = new GUIStyle(GUI.skin.box)
				{
					stretchHeight = false,
					padding = new RectOffset(12, 12, 8, 8)
				};
				val7.normal.background = BlueSageUiTheme.GetSolidTexture(_theme.FooterBackground);
				val7.normal.textColor = _theme.FooterText;
				_footerBoxStyle = val7;
				GUIStyle val8 = new GUIStyle(GUI.skin.label)
				{
					richText = false,
					fontSize = 14,
					fontStyle = (FontStyle)1,
					wordWrap = true
				};
				val8.normal.textColor = _theme.FooterText;
				_footerTextStyle = val8;
				_textFieldStyle = BlueSageUiTheme.CreateTextInputStyle(GUI.skin.textField, _theme, 15, wordWrap: true);
				_generatedTextStyle = new GUIStyle(_textFieldStyle)
				{
					wordWrap = false
				};
				GUIStyle val9 = new GUIStyle(GUI.skin.box)
				{
					richText = true,
					wordWrap = true,
					alignment = (TextAnchor)4,
					fontSize = 17
				};
				val9.normal.background = BlueSageUiTheme.GetSolidTexture(_theme.PreviewBackground);
				val9.normal.textColor = _theme.PreviewText;
				_previewStyle = val9;
				_swatchButtonStyle = BlueSageUiTheme.CreateSwatchButtonStyle(GUI.skin.button, 13);
				_renderedTextureGeneration = BlueSageUiTheme.RuntimeTextureGeneration;
			}
		}

		private static void SetAllStateTextColors(GUIStyle style, Color text)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			style.normal.textColor = text;
			style.hover.textColor = text;
			style.active.textColor = text;
			style.focused.textColor = text;
			style.onNormal.textColor = text;
			style.onHover.textColor = text;
			style.onActive.textColor = text;
			style.onFocused.textColor = text;
		}
	}
	internal static class SweepResourceEvidenceCapture
	{
		internal const int MaximumAssetFacts = 50000;

		public static SweepResourceSnapshot Capture()
		{
			try
			{
				List<SweepResourceCategoryTotal> list = new List<SweepResourceCategoryTotal>(5);
				List<SweepResourceAssetFact> list2 = new List<SweepResourceAssetFact>(Math.Min(50000, 8192));
				bool detailTruncated = false;
				CaptureResourceType<Texture2D>(Resources.FindObjectsOfTypeAll<Texture2D>(), "Texture2D", list, list2, ref detailTruncated);
				CaptureResourceType<RenderTexture>(Resources.FindObjectsOfTypeAll<RenderTexture>(), "RenderTexture", list, list2, ref detailTruncated);
				CaptureResourceType<Material>(Resources.FindObjectsOfTypeAll<Material>(), "Material", list, list2, ref detailTruncated);
				CaptureResourceType<Mesh>(Resources.FindObjectsOfTypeAll<Mesh>(), "Mesh", list, list2, ref detailTruncated);
				CaptureResourceType<AudioClip>(Resources.FindObjectsOfTypeAll<AudioClip>(), "AudioClip", list, list2, ref detailTruncated);
				return new SweepResourceSnapshot
				{
					Captured = true,
					Status = "ok",
					SceneObjectCount = Resources.FindObjectsOfTypeAll<GameObject>().Length,
					Categories = list.ToArray(),
					Assets = list2.ToArray(),
					DetailTruncated = detailTruncated
				};
			}
			catch (Exception ex)
			{
				return SweepResourceSnapshot.Unavailable(ex.GetType().Name);
			}
		}

		private static void CaptureResourceType<T>(T[] resources, string category, List<SweepResourceCategoryTotal> categories, List<SweepResourceAssetFact> assets, ref bool detailTruncated) where T : Object
		{
			int num = 0;
			long num2 = 0L;
			if (resources != null)
			{
				foreach (T val in resources)
				{
					if (!((Object)(object)val == (Object)null))
					{
						num++;
						long num3 = Profiler.GetRuntimeMemorySizeLong((Object)(object)val);
						if (num3 < 0)
						{
							num3 = 0L;
						}
						num2 += num3;
						if (assets.Count < 50000)
						{
							assets.Add(new SweepResourceAssetFact(((Object)val).GetInstanceID(), category, num3));
						}
						else
						{
							detailTruncated = true;
						}
					}
				}
			}
			categories.Add(new SweepResourceCategoryTotal(category, num, num2));
		}
	}
	internal static class SweepSessionEvidenceCapture
	{
		internal static SweepSessionSnapshot Capture()
		{
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				long workingSet;
				long privateMemorySize;
				int handleCount;
				int count;
				using (Process process = Process.GetCurrentProcess())
				{
					process.Refresh();
					workingSet = process.WorkingSet64;
					privateMemorySize = process.PrivateMemorySize64;
					handleCount = process.HandleCount;
					count = process.Threads.Count;
				}
				int nativeRows = NetworkSingleton<PlayerPanelController>.I?.PlayerSteamIDs?.Count ?? (-1);
				int steamMembers = -1;
				MultiplayerManager i = MonoSingleton<MultiplayerManager>.I;
				if (SteamManager.Initialized && (Object)(object)i != (Object)null && ulong.TryParse(i.LobbyCode, out var result) && result != 0)
				{
					steamMembers = SteamMatchmaking.GetNumLobbyMembers(new CSteamID(result));
				}
				VoiceManager i2 = MonoSingleton<VoiceManager>.I;
				return new SweepSessionSnapshot(captured: true, "ok", workingSet, privateMemorySize, handleCount, count, nativeRows, steamMembers, (Object)(object)i2 != (Object)null, i2?.IsVoiceLobbyOff ?? false, i2 != null && i2.IsJoined, CountQueuedVoiceParticipants(i2));
			}
			catch (Exception ex)
			{
				return SweepSessionSnapshot.Unavailable(ex.GetType().Name);
			}
		}

		private static int CountQueuedVoiceParticipants(VoiceManager voiceManager)
		{
			if ((Object)(object)voiceManager == (Object)null)
			{
				return -1;
			}
			try
			{
				return (typeof(VoiceManager).GetField("QueuedParticipants", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(voiceManager) is ICollection collection) ? collection.Count : (-1);
			}
			catch
			{
				return -1;
			}
		}
	}
	internal sealed class WindowsStewardPipeHost : IStewardPipeHost
	{
		private static readonly UTF8Encoding StrictUtf8 = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true);

		private readonly object _sync = new object();

		private Thread _thread;

		private NamedPipeServerStream _activePipe;

		private volatile bool _stopping;

		private StewardAnnouncementKeyRing _keys = StewardAnnouncementKeyRing.Empty;

		private Action<StewardAnnouncementEnvelope> _accepted;

		private string _serviceIdentity = string.Empty;

		private SecurityIdentifier _serviceSid;

		private string _keyPath = string.Empty;

		private long _keyLastWriteUtcTicks;

		public bool TryStart(string keyPath, string serviceIdentity, Action<StewardAnnouncementEnvelope> accepted, out string boundedError)
		{
			boundedError = string.Empty;
			if (accepted == null)
			{
				boundedError = "Receiver callback is unavailable.";
				return false;
			}
			if (!Path.IsPathRooted(keyPath ?? string.Empty) || !IsPathOutsidePackage(keyPath) || !TryLoadKeyRing(keyPath, out _keys))
			{
				boundedError = "Protected CurrentUser key bundle is missing, invalid, or inside the package.";
				return false;
			}
			_keyPath = Path.GetFullPath(keyPath);
			_keyLastWriteUtcTicks = File.GetLastWriteTimeUtc(_keyPath).Ticks;
			_serviceIdentity = serviceIdentity ?? string.Empty;
			if (!TryResolveServiceSid(_serviceIdentity, out _serviceSid))
			{
				_keys.ClearSecrets();
				_keys = StewardAnnouncementKeyRing.Empty;
				boundedError = "Configured Windows service identity could not be resolved.";
				return false;
			}
			_accepted = accepted;
			_stopping = false;
			_thread = new Thread(ListenLoop)
			{
				IsBackground = true,
				Name = "BlueSage-Steward-Pipe"
			};
			_thread.Start();
			return true;
		}

		public void Stop()
		{
			_stopping = true;
			lock (_sync)
			{
				try
				{
					_activePipe?.Dispose();
				}
				catch
				{
				}
				_activePipe = null;
			}
			try
			{
				if (_thread != null && _thread.IsAlive)
				{
					_thread.Join(1000);
				}
			}
			catch
			{
			}
			_thread = null;
			_accepted = null;
			_keys.ClearSecrets();
			_keys = StewardAnnouncementKeyRing.Empty;
			_keyPath = string.Empty;
			_keyLastWriteUtcTicks = 0L;
			_serviceSid = null;
		}

		private void ListenLoop()
		{
			while (!_stopping)
			{
				NamedPipeServerStream namedPipeServerStream = null;
				try
				{
					namedPipeServerStream = CreatePipe();
					lock (_sync)
					{
						_activePipe = namedPipeServerStream;
					}
					namedPipeServerStream.WaitForConnection();
					if (_stopping)
					{
						break;
					}
					if (TryReadFrame(namedPipeServerStream, out var payload) && RefreshKeyRingIfChanged() && StewardAnnouncementPolicy.TryAuthenticate(payload, "0.2.4+20260730.1-public-24414155-release", DateTime.UtcNow.Ticks, _keys, out StewardAnnouncementEnvelope envelope, out string _))
					{
						_accepted?.Invoke(envelope);
					}
				}
				catch
				{
					if (_stopping)
					{
						break;
					}
					Thread.Sleep(250);
				}
				finally
				{
					lock (_sync)
					{
						if (_activePipe == namedPipeServerStream)
						{
							_activePipe = null;
						}
					}
					try
					{
						namedPipeServerStream?.Dispose();
					}
					catch
					{
					}
				}
			}
		}

		private bool RefreshKeyRingIfChanged()
		{
			try
			{
				long ticks = File.GetLastWriteTimeUtc(_keyPath).Ticks;
				if (ticks == _keyLastWriteUtcTicks)
				{
					return _keys.HasCurrentKey;
				}
				_keyLastWriteUtcTicks = ticks;
				if (!TryLoadKeyRing(_keyPath, out var keys))
				{
					_keys.ClearSecrets();
					_keys = StewardAnnouncementKeyRing.Empty;
					return false;
				}
				_keys.ClearSecrets();
				_keys = keys;
				return true;
			}
			catch
			{
				_keys.ClearSecrets();
				_keys = StewardAnnouncementKeyRing.Empty;
				return false;
			}
		}

		private NamedPipeServerStream CreatePipe()
		{
			PipeSecurity pipeSecurity = new PipeSecurity();
			pipeSecurity.SetAccessRuleProtection(isProtected: true, preserveInheritance: false);
			using (WindowsIdentity windowsIdentity = WindowsIdentity.GetCurrent())
			{
				if (windowsIdentity?.User == null)
				{
					throw new InvalidOperationException("Current Windows identity has no SID.");
				}
				pipeSecurity.AddAccessRule(new PipeAccessRule(windowsIdentity.User, PipeAccessRights.ReadWrite | PipeAccessRights.CreateNewInstance, AccessControlType.Allow));
			}
			pipeSecurity.AddAccessRule(new PipeAccessRule(new SecurityIdentifier(WellKnownSidType.NetworkSid, null), PipeAccessRights.FullControl, AccessControlType.Deny));
			if (_serviceSid != null)
			{
				pipeSecurity.AddAccessRule(new PipeAccessRule(_serviceSid, PipeAccessRights.ReadWrite, AccessControlType.Allow));
			}
			return new NamedPipeServerStream("BlueSage.OnTogether.Steward.v1", PipeDirection.In, 1, PipeTransmissionMode.Byte, PipeOptions.None, 2052, 2052, pipeSecurity);
		}

		private static bool TryReadFrame(Stream stream, out byte[] payload)
		{
			payload = Array.Empty<byte>();
			byte[] array = new byte[4];
			if (!ReadExactly(stream, array, 0, array.Length))
			{
				return false;
			}
			int num = array[0] | (array[1] << 8) | (array[2] << 16) | (array[3] << 24);
			if (num <= 0 || num > 2048)
			{
				return false;
			}
			payload = new byte[num];
			return ReadExactly(stream, payload, 0, num);
		}

		private static bool ReadExactly(Stream stream, byte[] buffer, int offset, int count)
		{
			int num;
			for (int i = 0; i < count; i += num)
			{
				num = stream.Read(buffer, offset + i, count - i);
				if (num <= 0)
				{
					return false;
				}
			}
			return true;
		}

		private static bool TryLoadKeyRing(string keyPath, out StewardAnnouncementKeyRing keys)
		{
			keys = StewardAnnouncementKeyRing.Empty;
			try
			{
				byte[] array = ProtectedData.Unprotect(File.ReadAllBytes(keyPath), (byte[])null, (DataProtectionScope)0);
				string text = StrictUtf8.GetString(array);
				Array.Clear(array, 0, array.Length);
				string[] array2 = text.Replace("\r\n", "\n").Split(new char[1] { '\n' });
				if (array2.Length != 8 || array2[7].Length != 0 || !TryValue(array2[0], "schema", out var value) || value != "1" || !TryValue(array2[1], "rotatedUtcTicks", out var value2) || !TryValue(array2[2], "currentKeyId", out var value3) || !TryValue(array2[3], "currentKey", out var value4) || !TryValue(array2[4], "previousKeyId", out var value5) || !TryValue(array2[5], "previousKey", out var value6) || !TryValue(array2[6], "previousValidUntilUtcTicks", out var value7) || !long.TryParse(value2, NumberStyles.None, CultureInfo.InvariantCulture, out var result) || !long.TryParse(value7, NumberStyles.None, CultureInfo.InvariantCulture, out var result2))
				{
					return false;
				}
				byte[] array3 = Convert.FromBase64String(value4);
				byte[] array4 = (string.IsNullOrEmpty(value6) ? null : Convert.FromBase64String(value6));
				if (result >= 621355968000000000L)
				{
					long num = result;
					DateTime maxValue = DateTime.MaxValue;
					if (num <= maxValue.Ticks - TimeSpan.FromMinutes(5.0).Ticks && !string.IsNullOrWhiteSpace(value3))
					{
						long num2 = result + TimeSpan.FromMinutes(5.0).Ticks;
						if (array3.Length < 32 || result2 > num2 || result2 < result || (array4 != null && array4.Length < 32) || array4 == null != string.IsNullOrEmpty(value5))
						{
							Array.Clear(array3, 0, array3.Length);
							if (array4 != null)
							{
								Array.Clear(array4, 0, array4.Length);
							}
							return false;
						}
						keys = new StewardAnnouncementKeyRing(value3, array3, value5, array4, result, result2);
						Array.Clear(array3, 0, array3.Length);
						if (array4 != null)
						{
							Array.Clear(array4, 0, array4.Length);
						}
						return keys.HasCurrentKey;
					}
				}
				return false;
			}
			catch
			{
				keys = StewardAnnouncementKeyRing.Empty;
				return false;
			}
		}

		private static bool TryValue(string line, string name, out string value)
		{
			string text = name + "=";
			if (!(line ?? string.Empty).StartsWith(text, StringComparison.Ordinal))
			{
				value = string.Empty;
				return false;
			}
			value = line.Substring(text.Length);
			return true;
		}

		private static bool TryResolveServiceSid(string serviceIdentity, out SecurityIdentifier serviceSid)
		{
			serviceSid = null;
			if (string.IsNullOrWhiteSpace(serviceIdentity))
			{
				return true;
			}
			try
			{
				NTAccount nTAccount = new NTAccount(serviceIdentity.Trim());
				serviceSid = (SecurityIdentifier)nTAccount.Translate(typeof(SecurityIdentifier));
				return serviceSid != null;
			}
			catch
			{
				serviceSid = null;
				return false;
			}
		}

		internal static bool IsPathOutsidePackage(string path)
		{
			try
			{
				string fullPath = Path.GetFullPath(path);
				string text = Path.GetFullPath(Path.GetDirectoryName(typeof(Plugin).Assembly.Location)).TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
				char directorySeparatorChar = Path.DirectorySeparatorChar;
				string value = text + directorySeparatorChar;
				return !fullPath.StartsWith(value, StringComparison.OrdinalIgnoreCase) && !HasGitAncestor(Path.GetDirectoryName(fullPath));
			}
			catch
			{
				return false;
			}
		}

		private static bool HasGitAncestor(string directory)
		{
			try
			{
				for (DirectoryInfo directoryInfo = new DirectoryInfo(directory); directoryInfo != null; directoryInfo = directoryInfo.Parent)
				{
					if (Directory.Exists(Path.Combine(directoryInfo.FullName, ".git")) || File.Exists(Path.Combine(directoryInfo.FullName, ".git")))
					{
						return true;
					}
				}
			}
			catch
			{
				return true;
			}
			return false;
		}

		internal static void AtomicReplace(string path, string content)
		{
			string? directoryName = Path.GetDirectoryName(path);
			if (string.IsNullOrWhiteSpace(directoryName))
			{
				throw new InvalidOperationException("State path has no directory.");
			}
			Directory.CreateDirectory(directoryName);
			string text = path + ".tmp";
			string text2 = path + ".bak";
			File.WriteAllText(text, content ?? string.Empty, StrictUtf8);
			if (File.Exists(path))
			{
				try
				{
					File.Replace(text, path, text2, ignoreMetadataErrors: true);
					TryDelete(text2);
					return;
				}
				catch
				{
					TryDelete(text);
					return;
				}
			}
			File.Move(text, path);
		}

		private static void TryDelete(string path)
		{
			try
			{
				if (File.Exists(path))
				{
					File.Delete(path);
				}
			}
			catch
			{
			}
		}
	}
}
namespace BlueSage.QoLTweaks.Patches
{
	internal static class AvatarStyleSlotsBridge
	{
		internal const int NativeSlotCount = 3;

		internal const int TotalSlotCount = 9;

		private const string PayloadVersion = "BSAS1";

		private const string RowMarkerPrefix = "BlueSage_StyleSlot_";

		private static readonly FieldInfo StyleDropdownPanelField = AccessTools.Field(typeof(CustomizationUIController), "_styleDropdownPanel");

		private static readonly FieldInfo StyleTextsField = AccessTools.Field(typeof(CustomizationUIController), "_styleTexts");

		private static readonly FieldInfo StyleSelectedBgsField = AccessTools.Field(typeof(CustomizationUIController), "_styleSelectedBgs");

		private static readonly FieldInfo StyleNameInputField = AccessTools.Field(typeof(CustomizationUIController), "_styleNameInputField");

		private static readonly FieldInfo StyleNumTextField = AccessTools.Field(typeof(CustomizationUIController), "_styleNumText");

		private static readonly FieldInfo CustomizationDataField = AccessTools.Field(typeof(CustomizationUIController), "_customizationData");

		private static readonly FieldInfo IsStyleChangedField = AccessTools.Field(typeof(CustomizationUIController), "_isStyleChanged");

		private static readonly FieldInfo CustomizationTypeField = AccessTools.Field(typeof(CustomizationUIController), "_customizationType");

		private static readonly FieldInfo GroupIndexField = AccessTools.Field(typeof(CustomizationUIController), "_groupIndex");

		private static readonly MethodInfo ResetUnsavedCustomizationMethod = AccessTools.Method(typeof(CustomizationUIController), "ResetUnsavedCustomization", (Type[])null, (Type[])null);

		private static readonly MethodInfo SetGroupUiMethod = AccessTools.Method(typeof(CustomizationUIController), "SetGroupUI", (Type[])null, (Type[])null);

		private static readonly MethodInfo PointerExitStyleNamingMethod = AccessTools.Method(typeof(CustomizationUIController), "PointerExitStyleNaming", (Type[])null, (Type[])null);

		private static readonly MethodInfo SetPartOptionUiMethod = AccessTools.Method(typeof(CustomizationUIController), "SetPartOptionUI", (Type[])null, (Type[])null);

		private static readonly MethodInfo SetCharacterMethod = AccessTools.Method(typeof(CustomizationUIController), "SetCharacter", (Type[])null, (Type[])null);

		private static readonly MethodInfo UpdateCustomizationCameraMethod = AccessTools.Method(typeof(CustomizationUIController), "UpdateCustomizationCamera", (Type[])null, (Type[])null);

		private static readonly MethodInfo WaitAndCaptureMethod = AccessTools.Method(typeof(CustomizationUIController), "WaitAndCapture", (Type[])null, (Type[])null);

		private static ConfigFile _config;

		private static ConfigEntry<int> _selectedExtendedSlot;

		private static readonly ConfigEntry<string>[] Names = new ConfigEntry<string>[6];

		private static readonly ConfigEntry<string>[] Payloads = new ConfigEntry<string>[6];

		private static readonly Dictionary<int, TextMeshProUGUI> RowTexts = new Dictionary<int, TextMeshProUGUI>();

		private static readonly Dictionary<int, GameObject> RowSelectedBgs = new Dictionary<int, GameObject>();

		private static int _activeExtendedSlot = -1;

		private static bool _closingExtendedSlot;

		private static CustomizationUIController _lastController;

		private static CustomizationDataIDs3 _nativeSlotSnapshot;

		private static int _nativeSlotSnapshotIndex = -1;

		internal static bool IsExtendedActive
		{
			get
			{
				if (_activeExtendedSlot >= 3)
				{
					return _activeExtendedSlot < 9;
				}
				return false;
			}
		}

		private static void EnsureConfig()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			if (_config == null)
			{
				_config = new ConfigFile(Path.Combine(Paths.ConfigPath, "com.bluesage.ontogether.qol-avatar-styles.cfg"), true);
				_selectedExtendedSlot = _config.Bind<int>("State", "SelectedExtendedSlot", -1, "Last selected BlueSage avatar style slot. -1 means a vanilla slot is active.");
				for (int i = 3; i < 9; i++)
				{
					int num = i - 3;
					Names[num] = _config.Bind<string>("Style " + (i + 1), "Name", string.Empty, "Display name for BlueSage avatar style slot " + (i + 1) + ".");
					Payloads[num] = _config.Bind<string>("Style " + (i + 1), "Payload", string.Empty, "Versioned avatar customization payload. Managed by BlueSage QoL.");
				}
			}
		}

		internal static void ExtendDropdown(CustomizationUIController controller)
		{
			if ((Object)(object)controller == (Object)null || Plugin.EnableExtendedAvatarStyles == null || !Plugin.EnableExtendedAvatarStyles.Value)
			{
				return;
			}
			_lastController = controller;
			EnsureConfig();
			List<TextMeshProUGUI> list = StyleTextsField?.GetValue(controller) as List<TextMeshProUGUI>;
			List<GameObject> list2 = StyleSelectedBgsField?.GetValue(controller) as List<GameObject>;
			object? obj = StyleDropdownPanelField?.GetValue(controller);
			GameObject val = (GameObject)((obj is GameObject) ? obj : null);
			if (list == null || list.Count < 3 || list2 == null || list2.Count < 3 || (Object)(object)val == (Object)null)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)"Avatar Styles 4-9 skipped: the vanilla three-slot dropdown surface was not complete.");
				}
				return;
			}
			GameObject val2 = FindSharedRow(((TMP_Text)list[2]).transform, list2[2].transform);
			if ((Object)(object)val2 == (Object)null || (Object)(object)val2.transform.parent == (Object)null)
			{
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogWarning((object)"Avatar Styles 4-9 skipped: no safe vanilla style row root was found.");
				}
				return;
			}
			Transform parent = val2.transform.parent;
			int num = 0;
			for (int i = 3; i < 9; i++)
			{
				string text = "BlueSage_StyleSlot_" + (i + 1);
				Transform val3 = parent.Find(text);
				GameObject val4 = (((Object)(object)val3 != (Object)null) ? ((Component)val3).gameObject : Object.Instantiate<GameObject>(val2, parent));
				if ((Object)(object)val3 == (Object)null)
				{
					num++;
				}
				((Object)val4).name = text;
				val4.transform.SetSiblingIndex(val2.transform.GetSiblingIndex() + (i - 3) + 1);
				TextMeshProUGUI val5 = FindMatchingText(val2, list[2], val4);
				GameObject val6 = FindMatchingObject(val2, list2[2], val4);
				if ((Object)(object)val5 == (Object)null || (Object)(object)val6 == (Object)null)
				{
					Object.Destroy((Object)(object)val4);
					ManualLogSource log3 = Plugin.Log;
					if (log3 != null)
					{
						log3.LogWarning((object)$"Avatar style slot {i + 1} skipped because its cloned row could not be mapped safely.");
					}
				}
				else
				{
					ConfigureRowNumber(val4, val5, i + 1);
					((TMP_Text)val5).text = "- " + GetName(i);
					val6.SetActive(i == _activeExtendedSlot);
					ConfigureRowButton(val4, controller, i);
					RowTexts[i] = val5;
					RowSelectedBgs[i] = val6;
				}
			}
			ExpandPanelForRows(val, val2, num);
			try
			{
				RestoreExtendedSelectionIfNeeded(controller, list2);
			}
			catch (Exception ex)
			{
				_activeExtendedSlot = -1;
				if (_selectedExtendedSlot != null)
				{
					_selectedExtendedSlot.Value = -1;
				}
				ManualLogSource log4 = Plugin.Log;
				if (log4 != null)
				{
					log4.LogWarning((object)("Avatar Styles 4-9 deferred an invalid saved-slot restore without interrupting CustomizationUI startup: " + ex.GetType().Name + ": " + ex.Message));
				}
			}
		}

		internal static void RefreshEnabledState()
		{
			CustomizationUIController val = _lastController;
			if ((Object)(object)val == (Object)null)
			{
				val = Object.FindFirstObjectByType<CustomizationUIController>();
			}
			if (!((Object)(object)val == (Object)null))
			{
				_lastController = val;
				if (Plugin.EnableExtendedAvatarStyles != null && Plugin.EnableExtendedAvatarStyles.Value)
				{
					ExtendDropdown(val);
				}
				else
				{
					DisableAndRestoreVanilla(val);
				}
			}
		}

		private static void DisableAndRestoreVanilla(CustomizationUIController controller)
		{
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			if (IsExtendedActive)
			{
				int slot = Mathf.Clamp(MonoSingleton<DataManager>.I.PlayerDataZip.SelectedStyleIndex, 0, 2);
				SelectNativeFromExtended(controller, slot);
			}
			object? obj = StyleDropdownPanelField?.GetValue(controller);
			GameObject val = (GameObject)((obj is GameObject) ? obj : null);
			int num = 0;
			KeyValuePair<int, TextMeshProUGUI>[] array = RowTexts.ToArray();
			for (int i = 0; i < array.Length; i++)
			{
				KeyValuePair<int, TextMeshProUGUI> keyValuePair = array[i];
				if (!((Object)(object)keyValuePair.Value == (Object)null))
				{
					Transform val2 = ((TMP_Text)keyValuePair.Value).transform;
					while ((Object)(object)val2.parent != (Object)null && !((Object)val2).name.StartsWith("BlueSage_StyleSlot_", StringComparison.Ordinal))
					{
						val2 = val2.parent;
					}
					if (((Object)val2).name.StartsWith("BlueSage_StyleSlot_", StringComparison.Ordinal))
					{
						Object.Destroy((Object)(object)((Component)val2).gameObject);
						num++;
					}
				}
			}
			RowTexts.Clear();
			RowSelectedBgs.Clear();
			if ((Object)(object)val != (Object)null && num > 0)
			{
				RectTransform component = val.GetComponent<RectTransform>();
				if ((Object)(object)component != (Object)null && (Object)(object)val.GetComponent<ContentSizeFitter>() == (Object)null)
				{
					float num2 = 0f;
					Rect rect;
					if (StyleTextsField?.GetValue(controller) is List<TextMeshProUGUI> { Count: >=3 } list)
					{
						GameObject obj2 = FindSharedRow(((TMP_Text)list[2]).transform, ((List<GameObject>)StyleSelectedBgsField.GetValue(controller))[2].transform);
						float? obj3;
						if (obj2 == null)
						{
							obj3 = null;
						}
						else
						{
							RectTransform component2 = obj2.GetComponent<RectTransform>();
							if (component2 == null)
							{
								obj3 = null;
							}
							else
							{
								rect = component2.rect;
								obj3 = ((Rect)(ref rect)).height;
							}
						}
						float? num3 = obj3;
						num2 = Mathf.Abs(num3.GetValueOrDefault());
					}
					if (num2 > 1f)
					{
						rect = component.rect;
						component.SetSizeWithCurrentAnchors((Axis)1, Mathf.Max(((Rect)(ref rect)).height - num2 * (float)num, num2));
					}
				}
			}
			_activeExtendedSlot = -1;
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)"Avatar preset slots 4-9 disabled; vanilla slots 1-3 restored and QoL preset data retained.");
			}
		}

		internal static void SelectExtended(CustomizationUIController controller, int slot)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)controller == (Object)null || slot < 3 || slot >= 9)
			{
				return;
			}
			EnsureConfig();
			try
			{
				bool num = !IsExtendedActive;
				SaveDepartingSlot(controller);
				if (num)
				{
					CaptureNativeSlotSnapshot();
				}
				else
				{
					RestoreNativeSlotSnapshot();
				}
				SetAllSelectionBgs(controller, -1);
				_activeExtendedSlot = slot;
				_selectedExtendedSlot.Value = slot;
				CustomizationDataIDs3 ids = (CustomizationDataIDs3)(((object)LoadPayload(slot)) ?? ((object)new CustomizationDataIDs3()));
				ApplyToEditor(controller, ids);
				SetAllSelectionBgs(controller, slot);
				UpdateHeader(controller, slot, GetName(slot));
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)$"Avatar style slot {slot + 1} selected through the BlueSage compatibility bridge.");
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogWarning((object)$"Avatar style slot {slot + 1} selection failed safely: {ex.GetType().Name}: {ex.Message}");
				}
			}
		}

		internal static bool SelectNativeFromExtended(CustomizationUIController controller, int slot)
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Expected O, but got Unknown
			if (!IsExtendedActive || (Object)(object)controller == (Object)null || slot < 0 || slot >= 3)
			{
				return false;
			}
			try
			{
				SaveExtended(controller, _activeExtendedSlot);
				RestoreNativeSlotSnapshot();
				SetAllSelectionBgs(controller, -1);
				_activeExtendedSlot = -1;
				_selectedExtendedSlot.Value = -1;
				PlayerDataZip playerDataZip = MonoSingleton<DataManager>.I.PlayerDataZip;
				int num = ((_nativeSlotSnapshotIndex >= 0) ? _nativeSlotSnapshotIndex : Mathf.Clamp(playerDataZip.SelectedStyleIndex, 0, 2));
				CustomizationData val = new CustomizationData(playerDataZip.CurrentCustomizationDataIDs);
				MonoSingleton<DataManager>.I.CustomizationData = new CustomizationData(val);
				CustomizationDataField?.SetValue(controller, (object?)new CustomizationData(val));
				IsStyleChangedField?.SetValue(controller, false);
				if (slot != num)
				{
					return false;
				}
				ApplyToEditor(controller, playerDataZip.CurrentCustomizationDataIDs);
				SetAllSelectionBgs(controller, num);
				UpdateHeader(controller, num, playerDataZip.StyleNames[num]);
				return true;
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)$"Returning to vanilla avatar style {slot + 1} failed safely: {ex.GetType().Name}: {ex.Message}");
				}
				return true;
			}
		}

		internal static bool SaveExtendedClose(CustomizationUIController controller, bool notFromStyleChanged)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Expected O, but got Unknown
			if (!IsExtendedActive || _closingExtendedSlot || (Object)(object)controller == (Object)null)
			{
				return false;
			}
			_closingExtendedSlot = true;
			try
			{
				object? obj = CustomizationDataField?.GetValue(controller);
				CustomizationData val = (CustomizationData)((obj is CustomizationData) ? obj : null);
				if (val == null)
				{
					return true;
				}
				CustomizationData val2 = new CustomizationData(val);
				if (notFromStyleChanged)
				{
					PointerExitStyleNamingMethod?.Invoke(controller, null);
				}
				object obj2 = CustomizationTypeField?.GetValue(controller);
				object obj3 = GroupIndexField?.GetValue(controller);
				if (obj2 != null && obj3 != null)
				{
					ResetUnsavedCustomizationMethod?.Invoke(controller, new object[2] { obj2, obj3 });
				}
				SetGroupUiMethod?.Invoke(controller, null);
				MonoSingleton<DataManager>.I.CustomizationData = new CustomizationData(val2);
				SaveExtendedData(val2, _activeExtendedSlot);
				RestoreNativeSlotSnapshot();
				if (WaitAndCaptureMethod?.Invoke(controller, null) is IEnumerator enumerator)
				{
					((MonoBehaviour)controller).StartCoroutine(enumerator);
				}
				if ((Object)(object)NetworkSingleton<TextChannelManager>.I != (Object)null)
				{
					NetworkSingleton<TextChannelManager>.I.MainCustomizationController.ApplyCustomization(val2);
				}
				controller.IsAnyCustomize = true;
				IsStyleChangedField?.SetValue(controller, false);
				return true;
			}
			finally
			{
				_closingExtendedSlot = false;
			}
		}

		internal static bool RenameExtended(CustomizationUIController controller, string styleName)
		{
			if (!IsExtendedActive)
			{
				return false;
			}
			EnsureConfig();
			string text = styleName ?? string.Empty;
			Names[_activeExtendedSlot - 3].Value = text;
			if (RowTexts.TryGetValue(_activeExtendedSlot, out var value) && (Object)(object)value != (Object)null)
			{
				((TMP_Text)value).text = "- " + text;
			}
			return true;
		}

		private static void RestoreExtendedSelectionIfNeeded(CustomizationUIController controller, List<GameObject> nativeBgs)
		{
			int num = _selectedExtendedSlot?.Value ?? (-1);
			if (num < 3 || num >= 9 || string.IsNullOrWhiteSpace(Payloads[num - 3].Value))
			{
				_activeExtendedSlot = -1;
				return;
			}
			_activeExtendedSlot = num;
			foreach (GameObject nativeBg in nativeBgs)
			{
				if (nativeBg != null)
				{
					nativeBg.SetActive(false);
				}
			}
			CustomizationDataIDs3 val = LoadPayload(num);
			if (val != null)
			{
				ApplyToEditor(controller, val);
				SetAllSelectionBgs(controller, num);
				UpdateHeader(controller, num, GetName(num));
			}
		}

		private static void SaveDepartingSlot(CustomizationUIController controller)
		{
			if (IsExtendedActive)
			{
				SaveExtended(controller, _activeExtendedSlot);
				return;
			}
			controller.CloseAvatarPanel(false);
			MonoSingleton<DataManager>.I.SavePlayerZipData();
		}

		private static void CaptureNativeSlotSnapshot()
		{
			PlayerDataZip val = MonoSingleton<DataManager>.I?.PlayerDataZip;
			if (val == null)
			{
				_nativeSlotSnapshot = null;
				_nativeSlotSnapshotIndex = -1;
			}
			else
			{
				_nativeSlotSnapshotIndex = Mathf.Clamp(val.SelectedStyleIndex, 0, 2);
				_nativeSlotSnapshot = CloneIds(val.CurrentCustomizationDataIDs);
			}
		}

		private static void RestoreNativeSlotSnapshot()
		{
			PlayerDataZip val = MonoSingleton<DataManager>.I?.PlayerDataZip;
			if (val != null && _nativeSlotSnapshot != null && _nativeSlotSnapshotIndex >= 0)
			{
				val.SelectedStyleIndex = _nativeSlotSnapshotIndex;
				val.CurrentCustomizationDataIDs = CloneIds(_nativeSlotSnapshot);
			}
		}

		private static CustomizationDataIDs3 CloneIds(CustomizationDataIDs3 source)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			if (source != null)
			{
				return new CustomizationDataIDs3(new CustomizationData(source));
			}
			return null;
		}

		private static void SaveExtended(CustomizationUIController controller, int slot)
		{
			object? obj = CustomizationDataField?.GetValue(controller);
			CustomizationData val = (CustomizationData)((obj is CustomizationData) ? obj : null);
			if (val != null)
			{
				SaveExtendedData(val, slot);
			}
		}

		private static void SaveExtendedData(CustomizationData data, int slot)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			if (data != null && slot >= 3 && slot < 9)
			{
				Payloads[slot - 3].Value = Serialize(new CustomizationDataIDs3(data));
			}
		}

		private static void ApplyToEditor(CustomizationUIController controller, CustomizationDataIDs3 ids)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			CustomizationData val = new CustomizationData(ids);
			MonoSingleton<DataManager>.I.CustomizationData = new CustomizationData(val);
			CustomizationDataField?.SetValue(controller, (object?)new CustomizationData(val));
			IsStyleChangedField?.SetValue(controller, true);
			SetPartOptionUiMethod?.Invoke(controller, null);
			SetCharacterMethod?.Invoke(controller, null);
			UpdateCustomizationCameraMethod?.Invoke(controller, null);
			if ((Object)(object)NetworkSingleton<TextChannelManager>.I != (Object)null)
			{
				NetworkSingleton<TextChannelManager>.I.MainCustomizationController.ApplyCustomization(val);
			}
			controller.IsAnyCustomize = true;
		}

		private static void SetAllSelectionBgs(CustomizationUIController controller, int selectedSlot)
		{
			if (StyleSelectedBgsField?.GetValue(controller) is List<GameObject> list)
			{
				for (int i = 0; i < list.Count; i++)
				{
					GameObject obj = list[i];
					if (obj != null)
					{
						obj.SetActive(i == selectedSlot);
					}
				}
			}
			foreach (KeyValuePair<int, GameObject> rowSelectedBg in RowSelectedBgs)
			{
				GameObject value = rowSelectedBg.Value;
				if (value != null)
				{
					value.SetActive(rowSelectedBg.Key == selectedSlot);
				}
			}
		}

		private static void UpdateHeader(CustomizationUIController controller, int slot, string name)
		{
			object? obj = StyleNumTextField?.GetValue(controller);
			TextMeshProUGUI val = (TextMeshProUGUI)((obj is TextMeshProUGUI) ? obj : null);
			if (val != null)
			{
				((TMP_Text)val).text = (slot + 1).ToString(CultureInfo.InvariantCulture);
			}
			object? obj2 = StyleNameInputField?.GetValue(controller);
			TMP_InputField val2 = (TMP_InputField)((obj2 is TMP_InputField) ? obj2 : null);
			if (val2 != null)
			{
				val2.SetTextWithoutNotify(name ?? string.Empty);
			}
		}

		private static string GetName(int slot)
		{
			return Names[slot - 3]?.Value ?? string.Empty;
		}

		private static void ConfigureRowButton(GameObject row, CustomizationUIController controller, int slot)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			Button val = row.GetComponent<Button>() ?? row.GetComponentInChildren<Button>(true);
			if (!((Object)(object)val == (Object)null))
			{
				val.onClick = new ButtonClickedEvent();
				((UnityEvent)val.onClick).AddListener((UnityAction)delegate
				{
					SelectExtended(controller, slot);
				});
			}
		}

		private static void ConfigureRowNumber(GameObject row, TextMeshProUGUI nameText, int displayNumber)
		{
			TextMeshProUGUI[] componentsInChildren = row.GetComponentsInChildren<TextMeshProUGUI>(true);
			foreach (TextMeshProUGUI val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)(object)nameText) && int.TryParse((((TMP_Text)val).text ?? string.Empty).Trim().TrimEnd('-', ' '), out var _))
				{
					((TMP_Text)val).text = displayNumber.ToString(CultureInfo.InvariantCulture);
					break;
				}
			}
		}

		private static GameObject FindSharedRow(Transform text, Transform selectedBg)
		{
			HashSet<Transform> hashSet = new HashSet<Transform>();
			Transform val = text;
			while ((Object)(object)val != (Object)null)
			{
				hashSet.Add(val);
				val = val.parent;
			}
			Transform val2 = selectedBg;
			while ((Object)(object)val2 != (Object)null)
			{
				if (hashSet.Contains(val2) && (Object)(object)((Component)val2).GetComponentInChildren<Button>(true) != (Object)null)
				{
					return ((Component)val2).gameObject;
				}
				val2 = val2.parent;
			}
			Transform parent = text.parent;
			if (parent == null)
			{
				return null;
			}
			return ((Component)parent).gameObject;
		}

		private static TextMeshProUGUI FindMatchingText(GameObject sourceRoot, TextMeshProUGUI source, GameObject cloneRoot)
		{
			Transform obj = cloneRoot.transform.Find(GetRelativePath(sourceRoot.transform, ((TMP_Text)source).transform));
			return ((obj != null) ? ((Component)obj).GetComponent<TextMeshProUGUI>() : null) ?? ((IEnumerable<TextMeshProUGUI>)cloneRoot.GetComponentsInChildren<TextMeshProUGUI>(true)).FirstOrDefault((Func<TextMeshProUGUI, bool>)((TextMeshProUGUI text) => ((Object)text).name == ((Object)source).name));
		}

		private static GameObject FindMatchingObject(GameObject sourceRoot, GameObject source, GameObject cloneRoot)
		{
			Transform obj = cloneRoot.transform.Find(GetRelativePath(sourceRoot.transform, source.transform));
			object obj2 = ((obj != null) ? ((Component)obj).gameObject : null);
			if (obj2 == null)
			{
				Transform? obj3 = ((IEnumerable<Transform>)cloneRoot.GetComponentsInChildren<Transform>(true)).FirstOrDefault((Func<Transform, bool>)((Transform item) => ((Object)item).name == ((Object)source).name));
				if (obj3 == null)
				{
					return null;
				}
				obj2 = ((Component)obj3).gameObject;
			}
			return (GameObject)obj2;
		}

		private static string GetRelativePath(Transform root, Transform child)
		{
			List<string> list = new List<string>();
			Transform val = child;
			while ((Object)(object)val != (Object)null && (Object)(object)val != (Object)(object)root)
			{
				list.Add(((Object)val).name);
				val = val.parent;
			}
			list.Reverse();
			return string.Join("/", list);
		}

		private static void ExpandPanelForRows(GameObject panel, GameObject referenceRow, int addedRows)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = panel.GetComponent<RectTransform>();
			RectTransform component2 = referenceRow.GetComponent<RectTransform>();
			if (!((Object)(object)component == (Object)null) && !((Object)(object)component2 == (Object)null) && !((Object)(object)panel.GetComponent<ContentSizeFitter>() != (Object)null))
			{
				Rect rect = component2.rect;
				float num = Mathf.Abs(((Rect)(ref rect)).height);
				if (num > 1f)
				{
					rect = component.rect;
					component.SetSizeWithCurrentAnchors((Axis)1, ((Rect)(ref rect)).height + num * (float)addedRows);
					FitPanelToScreen(component);
				}
			}
		}

		private static void FitPanelToScreen(RectTransform panelRect)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			Canvas componentInParent = ((Component)panelRect).GetComponentInParent<Canvas>();
			if (!((Object)(object)componentInParent == (Object)null))
			{
				Canvas rootCanvas = componentInParent.rootCanvas;
				Camera val = (((int)rootCanvas.renderMode == 0) ? null : rootCanvas.worldCamera);
				Canvas.ForceUpdateCanvases();
				Vector3[] array = (Vector3[])(object)new Vector3[4];
				panelRect.GetWorldCorners(array);
				float num = float.MaxValue;
				float num2 = float.MinValue;
				for (int i = 0; i < array.Length; i++)
				{
					float y = RectTransformUtility.WorldToScreenPoint(val, array[i]).y;
					num = Mathf.Min(num, y);
					num2 = Mathf.Max(num2, y);
				}
				float num3 = 0f;
				if (num < 8f)
				{
					num3 = 8f - num;
				}
				else if (num2 > (float)Screen.height - 8f)
				{
					num3 = (float)Screen.height - 8f - num2;
				}
				if (Mathf.Abs(num3) > 0.5f)
				{
					float num4 = Mathf.Max(rootCanvas.scaleFactor, 0.01f);
					panelRect.anchoredPosition += Vector2.up * (num3 / num4);
				}
			}
		}

		internal static string Serialize(CustomizationDataIDs3 data)
		{
			if (data == null)
			{
				return string.Empty;
			}
			string text = SerializeMap(data.AppearanceToShapeAndColors.Select((KeyValuePair<AppearanceType, ShapeAndColorsData> pair) => new KeyValuePair<int, ShapeAndColorsData>((int)pair.Key, pair.Value)));
			string text2 = SerializeMap(data.OutfitToShapeAndColors.Select((KeyValuePair<OutfitType, ShapeAndColorsData> pair) => new KeyValuePair<int, ShapeAndColorsData>((int)pair.Key, pair.Value)));
			return string.Join(";", "BSAS1", data.IsFullBody ? "1" : "0", text, text2);
		}

		internal static CustomizationDataIDs3 Deserialize(string payload)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected O, but got Unknown
			if (string.IsNullOrWhiteSpace(payload))
			{
				return null;
			}
			string[] array = payload.Split(new char[1] { ';' });
			if (array.Length != 4 || array[0] != "BSAS1")
			{
				return null;
			}
			CustomizationDataIDs3 val = new CustomizationDataIDs3
			{
				IsFullBody = (array[1] == "1"),
				AppearanceToShapeAndColors = ParseMap<AppearanceType>(array[2]),
				OutfitToShapeAndColors = ParseMap<OutfitType>(array[3])
			};
			if (val.AppearanceToShapeAndColors.Count != Enum.GetValues(typeof(AppearanceType)).Length || val.OutfitToShapeAndColors.Count != Enum.GetValues(typeof(OutfitType)).Length)
			{
				return null;
			}
			return val;
		}

		private static CustomizationDataIDs3 LoadPayload(int slot)
		{
			try
			{
				return Deserialize(Payloads[slot - 3].Value);
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)$"Avatar style slot {slot + 1} payload was invalid and will use a fresh default: {ex.GetType().Name}.");
				}
				return null;
			}
		}

		private static string SerializeMap(IEnumerable<KeyValuePair<int, ShapeAndColorsData>> entries)
		{
			return string.Join("|", from pair in entries
				orderby pair.Key
				select pair.Key.ToString(CultureInfo.InvariantCulture) + ":" + pair.Value.ShapeIndex.ToString(CultureInfo.InvariantCulture) + ":" + string.Join(",", pair.Value.ColorIndexes ?? new List<int>()));
		}

		private static Dictionary<TEnum, ShapeAndColorsData> ParseMap<TEnum>(string section) where TEnum : struct
		{
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<TEnum, ShapeAndColorsData> dictionary = new Dictionary<TEnum, ShapeAndColorsData>();
			string[] array = section.Split(new char[1] { '|' });
			for (int i = 0; i < array.Length; i++)
			{
				string[] array2 = array[i].Split(new char[1] { ':' });
				if (array2.Length == 3 && int.TryParse(array2[0], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) && int.TryParse(array2[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2))
				{
					List<int> list = (string.IsNullOrEmpty(array2[2]) ? new List<int>() : (from value in array2[2].Split(new char[1] { ',' })
						select int.Parse(value, CultureInfo.InvariantCulture)).ToList());
					dictionary[(TEnum)Enum.ToObject(typeof(TEnum), result)] = new ShapeAndColorsData(result2, list);
				}
			}
			return dictionary;
		}
	}
	[HarmonyPatch(typeof(CustomizationUIController), "InitStyleDropdown")]
	internal static class AvatarStyleSlotsInitPatch
	{
		[HarmonyPostfix]
		private static void Postfix(CustomizationUIController __instance)
		{
			AvatarStyleSlotsBridge.ExtendDropdown(__instance);
		}
	}
	[HarmonyPatch(typeof(CustomizationUIController), "ButtonSelectStyle")]
	internal static class AvatarStyleSlotsNativeSelectionPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(CustomizationUIController __instance, int styleIndex)
		{
			return !AvatarStyleSlotsBridge.SelectNativeFromExtended(__instance, styleIndex);
		}
	}
	[HarmonyPatch(typeof(CustomizationUIController), "CloseAvatarPanel")]
	internal static class AvatarStyleSlotsClosePatch
	{
		[HarmonyPrefix]
		private static bool Prefix(CustomizationUIController __instance, bool notFromStyleChanged)
		{
			return !AvatarStyleSlotsBridge.SaveExtendedClose(__instance, notFromStyleChanged);
		}
	}
	[HarmonyPatch(typeof(CustomizationUIController), "OnDeselectStyleInputField")]
	internal static class AvatarStyleSlotsRenamePatch
	{
		[HarmonyPrefix]
		private static bool Prefix(CustomizationUIController __instance, string styleName)
		{
			return !AvatarStyleSlotsBridge.RenameExtended(__instance, styleName);
		}
	}
	internal static class BetterMoveState
	{
		internal static bool IsSlowWalkActive { get; set; }
	}
	[HarmonyPatch(typeof(PlayerMovementController))]
	internal static class BetterMoveMovementPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("Update")]
		private static void Update_Prefix(PlayerMovementController __instance)
		{
			if (!Plugin.ShouldApplyBetterMove || !IsLocalOwner((Component)(object)__instance))
			{
				BetterMoveState.IsSlowWalkActive = false;
				return;
			}
			bool flag = (Object)(object)MonoSingleton<InputManager>.I != (Object)null && MonoSingleton<InputManager>.I.IsShiftKey;
			bool num = Input.GetKey((KeyCode)306) || Input.GetKey((KeyCode)305);
			__instance.IsTurbo = flag;
			BetterMoveState.IsSlowWalkActive = num && !flag;
		}

		[HarmonyPrefix]
		[HarmonyPatch("MovePlayer")]
		private static void MovePlayer_Prefix(PlayerMovementController __instance)
		{
			if (Plugin.ShouldApplyBetterMove && BetterMoveState.IsSlowWalkActive && IsLocalOwner((Component)(object)__instance))
			{
				SetLocalPopsicle((Component)(object)__instance, active: true);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("MovePlayer")]
		private static void MovePlayer_Postfix(PlayerMovementController __instance)
		{
			if (Plugin.ShouldApplyBetterMove && BetterMoveState.IsSlowWalkActive && IsLocalOwner((Component)(object)__instance))
			{
				SetLocalPopsicle((Component)(object)__instance, active: false);
			}
		}

		internal static bool IsLocalOwner(Component component)
		{
			try
			{
				NetworkIdentity val = (NetworkIdentity)(object)((component is NetworkIdentity) ? component : null);
				return val != null && val.isOwner;
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogDebug((object)("BetterMove owner check skipped: " + ex.Message));
				}
				return false;
			}
		}

		private static void SetLocalPopsicle(Component component, bool active)
		{
			try
			{
				PlayerFXController component2 = component.GetComponent<PlayerFXController>();
				if (!((Object)(object)component2 == (Object)null))
				{
					component2.IsPopsicleDouble = active;
					component2.IsFreeze = false;
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogDebug((object)("BetterMove MovePlayer visual guard skipped: " + ex.Message));
				}
			}
		}
	}
	[HarmonyPatch(typeof(PlayerAnimationController), "SetWalk")]
	internal static class BetterMoveAnimationPatch
	{
		[HarmonyPrefix]
		private static void Prefix(PlayerAnimationController __instance)
		{
			if (Plugin.ShouldApplyBetterMove && BetterMoveState.IsSlowWalkActive && BetterMoveMovementPatch.IsLocalOwner((Component)(object)__instance))
			{
				SetAnimationPopsicle(__instance, active: true);
			}
		}

		[HarmonyPostfix]
		private static void Postfix(PlayerAnimationController __instance)
		{
			if (Plugin.ShouldApplyBetterMove && BetterMoveState.IsSlowWalkActive && BetterMoveMovementPatch.IsLocalOwner((Component)(object)__instance))
			{
				SetAnimationPopsicle(__instance, active: false);
			}
		}

		private static void SetAnimationPopsicle(PlayerAnimationController instance, bool active)
		{
			try
			{
				object? obj = AccessTools.Field(typeof(PlayerAnimationController), "_playerFXController")?.GetValue(instance);
				PlayerFXController val = (PlayerFXController)((obj is PlayerFXController) ? obj : null);
				if (!((Object)(object)val == (Object)null))
				{
					val.IsPopsicleDouble = active;
					val.IsFreeze = false;
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogDebug((object)("BetterMove SetWalk visual guard skipped: " + ex.Message));
				}
			}
		}
	}
	[HarmonyPatch(typeof(PlayerFXController), "SetPopsicle")]
	internal static class BetterMovePopsiclePatch
	{
		[HarmonyPrefix]
		private static bool Prefix()
		{
			if (Plugin.ShouldApplyBetterMove)
			{
				return !BetterMoveState.IsSlowWalkActive;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(TextChannelManager))]
	internal static class BlueSageCommandPatch
	{
		[HarmonyPatch("SendMessageAsync", new Type[]
		{
			typeof(byte[]),
			typeof(byte[]),
			typeof(bool),
			typeof(Vector3),
			typeof(string),
			typeof(RPCInfo)
		})]
		[HarmonyPrefix]
		private static bool SendMessageAsyncPrefix(byte[] __0, RPCInfo __5)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			if (!IsLocalCommandInvocation(__5))
			{
				return true;
			}
			return Plugin.HandleOutgoingChatCommand(__0);
		}

		private static bool IsLocalCommandInvocation(RPCInfo info)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)info.manager == (Object)null)
			{
				return ((PlayerID)(ref info.sender)).Equals(default(PlayerID));
			}
			return false;
		}
	}
	internal sealed class BlueSagePlayerBadgeMarker : MonoBehaviour, IPointerEnterHandler, IEventSystemHandler, IPointerExitHandler
	{
		private const int TooltipMinimumFontSize = 16;

		private const float TooltipBackgroundAlpha = 0.97f;

		private static Texture2D _tooltipBackground;

		private static GUIStyle _tooltipStyle;

		internal string BoundSteamId = string.Empty;

		internal bool IsRetired;

		internal PlayerItemController OwnerRow;

		internal int OwnerRowInstanceId;

		internal int NameAnchorInstanceId;

		internal int Generation;

		internal TextMeshProUGUI Label;

		internal TextMeshProUGUI HostLabel;

		internal TMP_Text NativeName;

		internal string TooltipText = string.Empty;

		private bool _hovered;

		private bool _nativeNameReplacementActive;

		private string _nativeNameBaseline = string.Empty;

		private string _nativeNameApplied = string.Empty;

		private readonly PlayerBadgeNativeTextPresentationLease _nativePresentationLease = new PlayerBadgeNativeTextPresentationLease();

		private readonly PlayerBadgeLayoutMeasurementCache _layoutCache = new PlayerBadgeLayoutMeasurementCache();

		private readonly PlayerRowGeometryReadinessPolicy _geometryReadiness = new PlayerRowGeometryReadinessPolicy();

		internal bool HasLivePresentation()
		{
			if ((Object)(object)NativeName != (Object)null && (Object)(object)Label != (Object)null)
			{
				return (Object)(object)HostLabel != (Object)null;
			}
			return false;
		}

		internal bool HasLivePresentation(TMP_Text expectedNativeName)
		{
			if ((Object)(object)expectedNativeName != (Object)null && HasLivePresentation())
			{
				return NativeName == expectedNativeName;
			}
			return false;
		}

		internal bool TryGetCachedLayout(PlayerBadgeLayoutCacheKey key, out PlayerBadgeLayout layout)
		{
			if (!_layoutCache.TryGet(key, out layout))
			{
				return false;
			}
			if (layout.NativeNameReservation <= 0f)
			{
				return !_nativePresentationLease.HasActiveLease;
			}
			if ((Object)(object)NativeName != (Object)null)
			{
				return _nativePresentationLease.MatchesApplied(CaptureNativePresentation(NativeName));
			}
			return false;
		}

		internal void StoreCachedLayout(PlayerBadgeLayoutCacheKey key, PlayerBadgeLayout layout)
		{
			_layoutCache.Store(key, layout);
		}

		internal void BeginRowLifecycle()
		{
			_geometryReadiness.Reset();
		}

		internal bool ObserveGeometry(float width, int geometryFingerprint)
		{
			return _geometryReadiness.Observe(width, geometryFingerprint);
		}

		internal void ResetGeometryReadiness()
		{
			_geometryReadiness.Reset();
		}

		internal void BindNativeName(TMP_Text nativeName)
		{
			if (NativeName != nativeName)
			{
				RestoreNativePresentation();
				RestoreNativeName();
				NativeName = nativeName;
			}
		}

		internal void ApplyNativePresentationReservation(float rightReservation)
		{
			if ((Object)(object)NativeName == (Object)null || rightReservation <= 0f)
			{
				RestoreNativePresentation();
				return;
			}
			PlayerBadgeNativeTextPresentation presentation = _nativePresentationLease.Apply(CaptureNativePresentation(NativeName), rightReservation, 0, 1);
			ApplyNativePresentation(NativeName, presentation);
		}

		internal void RestoreNativePresentation()
		{
			if ((Object)(object)NativeName == (Object)null)
			{
				_nativePresentationLease.Restore(default(PlayerBadgeNativeTextPresentation));
				return;
			}
			PlayerBadgeNativeTextPresentation presentation = _nativePresentationLease.Restore(CaptureNativePresentation(NativeName));
			ApplyNativePresentation(NativeName, presentation);
		}

		internal string GetNativeNameSourceText()
		{
			if ((Object)(object)NativeName == (Object)null)
			{
				return string.Empty;
			}
			string text = NativeName.text ?? string.Empty;
			if (!_nativeNameReplacementActive)
			{
				return text;
			}
			if (string.Equals(text, _nativeNameApplied, StringComparison.Ordinal))
			{
				return _nativeNameBaseline;
			}
			ClearNativeNameReplacementState();
			return text;
		}

		internal void ApplyNativeNameReplacement(string replacement)
		{
			if ((Object)(object)NativeName == (Object)null || string.IsNullOrWhiteSpace(replacement))
			{
				RestoreNativeName();
				return;
			}
			string nativeNameSourceText = GetNativeNameSourceText();
			if (!string.Equals(nativeNameSourceText, replacement, StringComparison.Ordinal))
			{
				_nativeNameBaseline = nativeNameSourceText;
				_nativeNameApplied = replacement;
				_nativeNameReplacementActive = true;
				NativeName.text = replacement;
			}
		}

		internal void RestoreNativeName()
		{
			if (_nativeNameReplacementActive && (Object)(object)NativeName != (Object)null && string.Equals(NativeName.text, _nativeNameApplied, StringComparison.Ordinal))
			{
				NativeName.text = _nativeNameBaseline;
			}
			ClearNativeNameReplacementState();
		}

		private void ClearNativeNameReplacementState()
		{
			_nativeNameReplacementActive = false;
			_nativeNameBaseline = string.Empty;
			_nativeNameApplied = string.Empty;
		}

		public void OnPointerEnter(PointerEventData eventData)
		{
			_hovered = !string.IsNullOrWhiteSpace(TooltipText);
		}

		public void OnPointerExit(PointerEventData eventData)
		{
			_hovered = false;
		}

		private void OnDisable()
		{
			_hovered = false;
			ResetGeometryReadiness();
			RestoreNativePresentation();
			RestoreNativeName();
		}

		private void OnGUI()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			if (_hovered && !string.IsNullOrWhiteSpace(TooltipText))
			{
				GUIContent val = new GUIContent(TooltipText);
				GUIStyle tooltipStyle = GetTooltipStyle();
				float num = Mathf.Clamp((float)Screen.height / 1080f, 1f, 1.35f);
				float requestedWidth = Mathf.Clamp(340f * num, 300f, 520f);
				float num2 = BadgeTooltipLayoutPolicy.ResolveWidth(Screen.width, requestedWidth);
				float measuredHeight = tooltipStyle.CalcHeight(val, num2);
				float pointerY = (float)Screen.height - Input.mousePosition.y;
				BadgeTooltipLayout badgeTooltipLayout = BadgeTooltipLayoutPolicy.Resolve(Screen.width, Screen.height, Input.mousePosition.x, pointerY, num2, measuredHeight, num);
				GUI.Box(new Rect(badgeTooltipLayout.X, badgeTooltipLayout.Y, badgeTooltipLayout.Width, badgeTooltipLayout.Height), val, tooltipStyle);
			}
		}

		private static GUIStyle GetTooltipStyle()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected O, but got Unknown
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Expected O, but got Unknown
			//IL_009f: Expected O, but got Unknown
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_tooltipBackground == (Object)null)
			{
				_tooltipBackground = new Texture2D(1, 1);
				((Object)_tooltipBackground).name = "BlueSage_RoleTooltip_Background";
				_tooltipBackground.SetPixel(0, 0, new Color(0.025f, 0.045f, 0.08f, 0.97f));
				_tooltipBackground.Apply();
			}
			if (_tooltipStyle == null)
			{
				_tooltipStyle = new GUIStyle
				{
					alignment = (TextAnchor)0,
					wordWrap = true,
					richText = false,
					padding = new RectOffset(16, 16, 12, 12),
					border = new RectOffset(1, 1, 1, 1)
				};
				_tooltipStyle.normal.background = _tooltipBackground;
				_tooltipStyle.normal.textColor = Color.white;
			}
			float num = Mathf.Clamp((float)Screen.height / 1080f, 1f, 1.35f);
			_tooltipStyle.fontSize = Mathf.Clamp(Mathf.RoundToInt(16f * num), 16, 22);
			return _tooltipStyle;
		}

		private void OnDestroy()
		{
			ResetGeometryReadiness();
			RestoreNativePresentation();
			RestoreNativeName();
			PlayerBadgeController.UnregisterOwnedMarker(this);
		}

		private static PlayerBadgeNativeTextPresentation CaptureNativePresentation(TMP_Text nativeName)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected I4, but got Unknown
			//IL_0030: Expected I4, but got Unknown
			Vector4 margin = nativeName.margin;
			return new PlayerBadgeNativeTextPresentation(margin.x, margin.y, margin.z, margin.w, (int)nativeName.textWrappingMode, (int)nativeName.overflowMode);
		}

		private static void ApplyNativePresentation(TMP_Text nativeName, PlayerBadgeNativeTextPresentation presentation)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			nativeName.margin = new Vector4(presentation.MarginLeft, presentation.MarginTop, presentation.MarginRight, presentation.MarginBottom);
			nativeName.textWrappingMode = (TextWrappingModes)presentation.WrappingMode;
			nativeName.overflowMode = (TextOverflowModes)presentation.OverflowMode;
		}
	}
	internal sealed class BlueSagePlayerPanelWidthLease : MonoBehaviour
	{
		private RectTransform _background;

		private RectTransform _scrollView;

		private Vector2 _backgroundSize;

		private Vector2 _backgroundPosition;

		private Vector2 _scrollSize;

		private Vector2 _scrollPosition;

		private float _appliedExpansion;

		private bool _captured;

		internal float AppliedExpansion => _appliedExpansion;

		internal void Bind(RectTransform background, RectTransform scrollView)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			if (!_captured && !((Object)(object)background == (Object)null) && !((Object)(object)scrollView == (Object)null))
			{
				_background = background;
				_scrollView = scrollView;
				_backgroundSize = background.sizeDelta;
				_backgroundPosition = background.anchoredPosition;
				_scrollSize = scrollView.sizeDelta;
				_scrollPosition = scrollView.anchoredPosition;
				_captured = true;
			}
		}

		internal void Apply(float expansion)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			if (_captured)
			{
				float num = Mathf.Max(0f, expansion);
				if (!(num <= _appliedExpansion + 0.01f))
				{
					_appliedExpansion = num;
					ApplyRect(_background, _backgroundSize, _backgroundPosition, num);
					ApplyRect(_scrollView, _scrollSize, _scrollPosition, num);
					Canvas.ForceUpdateCanvases();
				}
			}
		}

		private static void ApplyRect(RectTransform rect, Vector2 baselineSize, Vector2 baselinePosition, float expansion)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)rect == (Object)null))
			{
				rect.sizeDelta = new Vector2(baselineSize.x + expansion, baselineSize.y);
				rect.anchoredPosition = new Vector2(baselinePosition.x + expansion * 0.5f, baselinePosition.y);
			}
		}

		private void OnDestroy()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			ApplyRect(_background, _backgroundSize, _backgroundPosition, 0f);
			ApplyRect(_scrollView, _scrollSize, _scrollPosition, 0f);
		}
	}
	[HarmonyPatch(typeof(QuadPainterGPU), "GetQuadImage_Original_1")]
	internal static class ChalkboardSnapshotPatch
	{
		[HarmonyPrefix]
		private static void Prefix(QuadPainterGPU __instance)
		{
			ChalkboardSnapshotTransportController.PrepareForFullSnapshot(__instance);
		}
	}
	[HarmonyPatch(typeof(TextChannelManager))]
	internal static class ChatCopyMessagePatch
	{
		private sealed class ChatRowCreationSnapshot
		{
			internal Transform Container { get; }

			internal int[] BeforeInstanceIds { get; }

			internal ChatRowCreationSnapshot(Transform container, int[] beforeInstanceIds)
			{
				Container = container;
				BeforeInstanceIds = beforeInstanceIds ?? Array.Empty<int>();
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("AddMessageUI", new Type[]
		{
			typeof(string),
			typeof(string),
			typeof(bool),
			typeof(int),
			typeof(bool)
		})]
		private static void AddMessageUI_Prefix(bool isLocal, out ChatRowCreationSnapshot __state)
		{
			object obj;
			if (!isLocal)
			{
				UIManager i = MonoSingleton<UIManager>.I;
				obj = ((i != null) ? i.TextContentGlobalTransform : null);
			}
			else
			{
				UIManager i2 = MonoSingleton<UIManager>.I;
				obj = ((i2 != null) ? i2.TextContentLocalTransform : null);
			}
			Transform container = (Transform)obj;
			__state = CaptureRows(container);
		}

		[HarmonyPostfix]
		[HarmonyPatch("AddMessageUI", new Type[]
		{
			typeof(string),
			typeof(string),
			typeof(bool),
			typeof(int),
			typeof(bool)
		})]
		private static void AddMessageUI_Postfix(string userName, string text, bool isLocal, int senderIndex, bool sendByPlayer, ChatRowCreationSnapshot __state)
		{
			AuthoritativeChatSenderContext senderContext = (sendByPlayer ? ChatSenderContextPatch.CurrentSenderContext : null);
			SessionAuditController.RecordChat(userName, text, isLocal, senderIndex, senderContext);
			if (!Plugin.ShouldApplyChatCopy)
			{
				return;
			}
			try
			{
				AttachToCreatedRow(__state, text, senderContext);
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Chat Copy could not attach click handler: " + ex.GetType().Name + ": " + ex.Message));
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("AddNotification", new Type[] { typeof(string) })]
		private static void AddNotification_Prefix(out ChatRowCreationSnapshot __state)
		{
			UIManager i = MonoSingleton<UIManager>.I;
			__state = CaptureRows((i != null) ? i.TextContentGlobalTransform : null);
		}

		[HarmonyPostfix]
		[HarmonyPatch("AddNotification", new Type[] { typeof(string) })]
		private static void AddNotification_Postfix(string text, ChatRowCreationSnapshot __state)
		{
			SessionAuditController.RecordNotification(text);
			if (!Plugin.ShouldApplyChatCopy)
			{
				return;
			}
			try
			{
				AttachToCreatedRow(__state, text, null);
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Chat Copy could not attach to local notification: " + ex.GetType().Name + ": " + ex.Message));
				}
			}
		}

		private static ChatRowCreationSnapshot CaptureRows(Transform container)
		{
			if ((Object)(object)container == (Object)null || !Plugin.ShouldApplyChatCopy)
			{
				return new ChatRowCreationSnapshot(container, Array.Empty<int>());
			}
			int[] array = new int[container.childCount];
			for (int i = 0; i < container.childCount; i++)
			{
				array[i] = ((Object)container.GetChild(i)).GetInstanceID();
			}
			return new ChatRowCreationSnapshot(container, array);
		}

		private static void AttachToCreatedRow(ChatRowCreationSnapshot snapshot, string sourceText, AuthoritativeChatSenderContext senderContext)
		{
			Transform val = snapshot?.Container;
			if ((Object)(object)val == (Object)null || val.childCount <= 0)
			{
				return;
			}
			int[] array = new int[val.childCount];
			for (int i = 0; i < val.childCount; i++)
			{
				array[i] = ((Object)val.GetChild(i)).GetInstanceID();
			}
			ChatRowReconciliationDecision chatRowReconciliationDecision = ChatRowReconciliationPolicy.Resolve(snapshot.BeforeInstanceIds, array);
			if (!chatRowReconciliationDecision.HasExactCreatedRow)
			{
				return;
			}
			string text = ChatCopySanitizer.ToClipboardText(sourceText);
			if (string.IsNullOrWhiteSpace(text))
			{
				return;
			}
			string url;
			string text2 = ((Plugin.ShouldApplyChatUrlLinks && ChatUrlDetector.TryGetFirstUrl(text, out url)) ? url : string.Empty);
			GameObject val2 = null;
			for (int j = 0; j < val.childCount; j++)
			{
				Transform child = val.GetChild(j);
				if (((Object)child).GetInstanceID() == chatRowReconciliationDecision.CreatedRowInstanceId)
				{
					val2 = ((Component)child).gameObject;
					break;
				}
			}
			if (!((Object)(object)val2 == (Object)null))
			{
				if (!string.IsNullOrWhiteSpace(text2))
				{
					ApplyLinkVisuals(val2);
				}
				GameObject val3 = ResolveInteractionSurface(val2);
				(val3.GetComponent<ChatMessageInteractionController>() ?? val3.AddComponent<ChatMessageInteractionController>()).Initialize(text, text2, senderContext);
			}
		}

		private static GameObject ResolveInteractionSurface(GameObject messageRow)
		{
			if ((Object)(object)messageRow == (Object)null)
			{
				return null;
			}
			MonoBehaviour[] componentsInChildren = messageRow.GetComponentsInChildren<MonoBehaviour>(true);
			foreach (MonoBehaviour val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && !(val is ChatMessageInteractionController) && val is IPointerClickHandler)
				{
					Graphic component = ((Component)val).GetComponent<Graphic>();
					if ((Object)(object)component != (Object)null && component.raycastTarget)
					{
						return ((Component)val).gameObject;
					}
				}
			}
			return messageRow;
		}

		private static void ApplyLinkVisuals(GameObject messageRow)
		{
			if ((Object)(object)messageRow == (Object)null)
			{
				return;
			}
			TMP_Text[] componentsInChildren = messageRow.GetComponentsInChildren<TMP_Text>(true);
			foreach (TMP_Text val in componentsInChildren)
			{
				if ((Object)(object)val != (Object)null && ChatLinkFormatter.TryColorizeUrls(val.text, out var formatted))
				{
					val.text = formatted;
				}
			}
		}
	}
	[HarmonyPatch(typeof(GameSettings))]
	internal static class ChatHistoryLimitPatch
	{
		[HarmonyPostfix]
		[HarmonyPriority(0)]
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		private static void GlobalMessageLimitCount_Postfix(ref int __result)
		{
			__result = ChatHistoryLimitPolicy.ApplyConfiguredRows(__result, Plugin.LockedChatHistoryRows);
		}

		[HarmonyPostfix]
		[HarmonyPriority(0)]
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		private static void LocalMessageLimitCount_Postfix(ref int __result)
		{
			__result = ChatHistoryLimitPolicy.ApplyConfiguredRows(__result, Plugin.LockedChatHistoryRows);
		}
	}
	internal sealed class ChatMessageInteractionController : MonoBehaviour, IPointerClickHandler, IEventSystemHandler
	{
		private const float ClickCooldownSeconds = 0.25f;

		private const float LinkConfirmationSeconds = 10f;

		private string _payload = string.Empty;

		private string _safeUrl = string.Empty;

		private AuthoritativeChatSenderContext _sender;

		private float _lastActionTime;

		private string _pendingOpenUrl = string.Empty;

		private float _pendingOpenUntil;

		private Button _nativeButton;

		private bool _nativeButtonListenerRegistered;

		internal void Initialize(string payload, string safeUrl, AuthoritativeChatSenderContext sender)
		{
			_payload = payload ?? string.Empty;
			_safeUrl = safeUrl ?? string.Empty;
			_sender = ((sender != null && sender.ExactTupleCaptured) ? sender : null);
			_pendingOpenUrl = string.Empty;
			_pendingOpenUntil = 0f;
			EnsureRaycastSurface();
			RegisterNativeButtonClick();
		}

		public void OnPointerClick(PointerEventData eventData)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Invalid comparison between Unknown and I4
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (eventData != null)
			{
				if ((int)eventData.button == 1)
				{
					HandleClick(isRightButton: true);
				}
				else if ((int)eventData.button == 0 && HasAnyModifierHeld())
				{
					HandleClick(isRightButton: false);
				}
			}
		}

		private void HandleNativeButtonClick()
		{
			HandleClick(isRightButton: false);
		}

		private static bool HasAnyModifierHeld()
		{
			if (!Input.GetKey((KeyCode)304) && !Input.GetKey((KeyCode)303) && !Input.GetKey((KeyCode)306) && !Input.GetKey((KeyCode)305) && !Input.GetKey((KeyCode)308))
			{
				return Input.GetKey((KeyCode)307);
			}
			return true;
		}

		private void HandleClick(bool isRightButton)
		{
			bool shiftHeld = Input.GetKey((KeyCode)304) || Input.GetKey((KeyCode)303);
			bool controlHeld = Input.GetKey((KeyCode)306) || Input.GetKey((KeyCode)305);
			bool altHeld = Input.GetKey((KeyCode)308) || Input.GetKey((KeyCode)307);
			ChatClickDecision chatClickDecision = ChatClickActionPolicy.Decide(new ChatClickContext
			{
				IsRightButton = isRightButton,
				ShiftHeld = shiftHeld,
				ControlHeld = controlHeld,
				AltHeld = altHeld,
				HasPayload = !string.IsNullOrWhiteSpace(_payload),
				LinkOpeningEnabled = Plugin.ShouldApplyChatUrlLinks,
				HasSafeUrl = !string.IsNullOrWhiteSpace(_safeUrl),
				HasSenderBinding = (_sender?.ExactTupleCaptured ?? false)
			});
			if (chatClickDecision.Action != ChatClickAction.Ignore && Plugin.ShouldApplyChatCopy && !(Time.unscaledTime - _lastActionTime < 0.25f))
			{
				_lastActionTime = Time.unscaledTime;
				switch (chatClickDecision.Action)
				{
				case ChatClickAction.CopyMessage:
					CopyMessage();
					break;
				case ChatClickAction.GuardedSafeLink:
					HandleGuardedSafeLink();
					break;
				case ChatClickAction.CopyScopedIdentityEvidence:
					CopyScopedIdentityEvidence();
					break;
				case ChatClickAction.OpenNativeIdCard:
					OpenNativeIdCard();
					break;
				case ChatClickAction.Denied:
					NotifyDenied(chatClickDecision.Reason);
					break;
				}
			}
		}

		private void CopyMessage()
		{
			GUIUtility.systemCopyBuffer = _payload;
			PlayClickCue();
			Plugin.AddLocalNotification(string.IsNullOrWhiteSpace(_safeUrl) ? Plugin.FormatBlueSageAction("Copied", "chat text.") : Plugin.FormatBlueSageAction("Copied", "chat text. Shift-left-click once copies/warns; Shift-left-click again opens the link.", warning: true));
		}

		private void HandleGuardedSafeLink()
		{
			if (string.Equals(_pendingOpenUrl, _safeUrl, StringComparison.OrdinalIgnoreCase) && Time.unscaledTime <= _pendingOpenUntil)
			{
				Application.OpenURL(_safeUrl);
				_pendingOpenUrl = string.Empty;
				_pendingOpenUntil = 0f;
				PlayClickCue();
				Plugin.AddLocalNotification(Plugin.FormatBlueSageAction("Opening chat link", "Be careful with random links.", warning: true));
			}
			else
			{
				GUIUtility.systemCopyBuffer = _safeUrl;
				_pendingOpenUrl = _safeUrl;
				_pendingOpenUntil = Time.unscaledTime + 10f;
				PlayClickCue();
				Plugin.AddLocalNotification(Plugin.FormatBlueSageAction("Link copied", "Be careful with random links. Shift-left-click the same link again within 10s to open.", warning: true));
			}
		}

		private void CopyScopedIdentityEvidence()
		{
			if (!TryResolveCurrentSender(out var target))
			{
				NotifyDenied("the exact sender tuple changed; use the native player panel and a fresh local audit snapshot");
				return;
			}
			bool isHost;
			string reason;
			LobbySafetyAccessState localAccessState = SteamIdModerationController.GetLocalAccessState(out isHost, out reason);
			bool privilegedObserver = localAccessState == LobbySafetyAccessState.Host || localAccessState == LobbySafetyAccessState.HelperReady;
			if (!ScopedSenderEvidencePolicy.TryBuild(new ScopedSenderEvidenceContext
			{
				HasSenderBinding = _sender.ExactTupleCaptured,
				UniqueCurrentAgreement = true,
				FreshAtClick = true,
				ExactTupleMatches = ExactTupleMatches(target),
				PrivilegedObserver = privilegedObserver,
				SteamId = target.SteamId,
				PlayerId = target.PlayerId,
				NativeRowIndex = target.PlayerIndex,
				SessionRowCorrelator = _sender.SessionRowCorrelator
			}, out var evidence, out var error))
			{
				NotifyDenied(error);
				return;
			}
			GUIUtility.systemCopyBuffer = evidence;
			PlayClickCue();
			Plugin.AddLocalNotification(Plugin.FormatBlueSageAction("Exact identity evidence copied locally", "Evidence only; revalidate the current native row before moderation.", warning: true));
		}

		private void OpenNativeIdCard()
		{
			if (_sender == null)
			{
				NotifyDenied("this row has no exact player-sender binding");
			}
			else if (!NativeIdCardController.TryOpen("chat-row", _sender.SteamId, _sender.NativeRowIndex, _sender.PlayerId, _sender.Row, _sender.NetworkTransform, requireObservedIndex: true, CurrentCallerKind()))
			{
				NotifyDenied("the exact sender tuple changed; reopen the current player panel before trying again");
			}
			else
			{
				PlayClickCue();
			}
		}

		private bool TryResolveCurrentSender(out NativeIdCardTarget target)
		{
			target = null;
			if (_sender != null && NativeIdCardController.TryResolveCurrentRow("chat-evidence", _sender.SteamId, _sender.NativeRowIndex, _sender.PlayerId, _sender.Row, _sender.NetworkTransform, requireObservedIndex: true, CurrentCallerKind(), out target, out var _))
			{
				return ExactTupleMatches(target);
			}
			return false;
		}

		private bool ExactTupleMatches(NativeIdCardTarget target)
		{
			if (_sender != null && target != null && target.PlayerIndex == _sender.NativeRowIndex && string.Equals(target.SteamId, _sender.SteamId, StringComparison.Ordinal) && string.Equals(target.PlayerId, _sender.PlayerId, StringComparison.Ordinal) && target.Row == _sender.Row)
			{
				return target.NetworkTransform == _sender.NetworkTransform;
			}
			return false;
		}

		private static NativeIdCardCallerKind CurrentCallerKind()
		{
			bool isHost;
			string reason;
			return SteamIdModerationController.GetLocalAccessState(out isHost, out reason) switch
			{
				LobbySafetyAccessState.Host => NativeIdCardCallerKind.Host, 
				LobbySafetyAccessState.HelperReady => NativeIdCardCallerKind.AuthenticatedHelper, 
				_ => NativeIdCardCallerKind.OrdinaryUser, 
			};
		}

		private static void NotifyDenied(string reason)
		{
			string text = (string.IsNullOrWhiteSpace(reason) ? "the requested row action was not safe" : reason.Replace("\r", " ").Replace("\n", " "));
			if (text.Length > 180)
			{
				text = text.Substring(0, 179) + "…";
			}
			Plugin.AddLocalNotification(Plugin.FormatBlueSageAction("Chat row action stayed locked", text + ".", warning: true));
		}

		private static void PlayClickCue()
		{
			try
			{
				SFXManager i = MonoSingleton<SFXManager>.I;
				if (i != null)
				{
					i.PlayUIClick();
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Chat row click cue skipped safely: " + ex.GetType().Name + "."));
				}
			}
		}

		private void EnsureRaycastSurface()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			Graphic component = ((Component)this).GetComponent<Graphic>();
			if ((Object)(object)component == (Object)null)
			{
				Image obj = ((Component)this).gameObject.AddComponent<Image>();
				((Graphic)obj).color = new Color(1f, 1f, 1f, 0.001f);
				((Graphic)obj).raycastTarget = true;
			}
			else
			{
				component.raycastTarget = true;
			}
		}

		private void RegisterNativeButtonClick()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			if (!_nativeButtonListenerRegistered)
			{
				Button component = ((Component)this).GetComponent<Button>();
				if (!((Object)(object)component == (Object)null))
				{
					_nativeButton = component;
					((UnityEvent)component.onClick).AddListener(new UnityAction(HandleNativeButtonClick));
					_nativeButtonListenerRegistered = true;
				}
			}
		}

		private void OnDestroy()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			if (_nativeButtonListenerRegistered && (Object)(object)_nativeButton != (Object)null)
			{
				((UnityEvent)_nativeButton.onClick).RemoveListener(new UnityAction(HandleNativeButtonClick));
			}
			_nativeButton = null;
			_nativeButtonListenerRegistered = false;
		}
	}
	[HarmonyPatch(typeof(UIManager), "Awake")]
	internal static class ChatReadabilityUiAwakePatch
	{
		[HarmonyPostfix]
		private static void Awake_Postfix()
		{
			ChatReadabilityPatch.RequestRefreshSoon();
		}
	}
	[HarmonyPatch(typeof(UIManager))]
	internal static class ChatReadabilityFontOutlinePatch
	{
		private static bool Prepare()
		{
			return AccessTools.Method(typeof(UIManager), "SetMessageFontOutline", new Type[1] { typeof(bool) }, (Type[])null) != null;
		}

		[HarmonyPostfix]
		[HarmonyPatch("SetMessageFontOutline", new Type[] { typeof(bool) })]
		private static void SetMessageFontOutline_Postfix(bool value)
		{
			ChatReadabilityPatch.RequestRefreshSoon();
		}
	}
	[HarmonyPatch(typeof(TextChannelManager), "ResetTextMaterials")]
	internal static class ChatReadabilityTextMaterialResetPatch
	{
		[HarmonyPostfix]
		private static void ResetTextMaterials_Postfix()
		{
			ChatReadabilityPatch.RequestRefreshSoon();
		}
	}
	[HarmonyPatch(typeof(TextChannelManager))]
	internal static class ChatReadabilityPatch
	{
		private sealed class TextReadabilityState
		{
			public TextMeshProUGUI Text;

			public bool HadOutline;

			public Color OutlineColor;

			public Vector2 OutlineDistance;

			public bool OutlineUseGraphicAlpha;

			public bool HadShadow;

			public Color ShadowColor;

			public Vector2 ShadowDistance;

			public bool ShadowUseGraphicAlpha;

			public Material OriginalFontMaterial;

			public Material AppliedFontMaterial;

			public int LastAppliedSignature;
		}

		private sealed class BackdropState
		{
			public Image Image;

			public Color OriginalColor;
		}

		private sealed class ChatSurfaceScaleState
		{
			public Transform Transform;

			public Vector3 OriginalScale;

			public bool HadRectTransform;

			public Vector2 OriginalAnchoredPosition;

			public Vector3 OriginalPosition;
		}

		private sealed class ChatTextFontSizeState
		{
			public TextMeshProUGUI Text;

			public float OriginalFontSize;
		}

		private sealed class ChatSurfaceWindowSizeState
		{
			public RectTransform Transform;

			public Vector2 OriginalSizeDelta;

			public Vector2 OriginalAnchoredPosition;

			public Vector3 OriginalPosition;

			public float OriginalWidth;

			public float OriginalHeight;
		}

		private static readonly Color DarkOutlineColor = new Color(0f, 0f, 0f, 0.95f);

		private static readonly Color LightOutlineColor = new Color(1f, 1f, 1f, 0.92f);

		private static readonly Color ShadowColor = new Color(0f, 0f, 0f, 0.72f);

		private const float MinTmpOutlineWidth = 0.08f;

		private const float MaxTmpOutlineWidth = 0.22f;

		private const float ScreenClampMargin = 8f;

		private const float MinChatWindowBaselineSize = 24f;

		private static readonly Vector2 MaxOutlineDistance = new Vector2(1.65f, -1.65f);

		private static readonly Vector2 MaxShadowDistance = new Vector2(2.25f, -2.25f);

		private static readonly Dictionary<int, BackdropState> OriginalBackdropColors = new Dictionary<int, BackdropState>();

		private static readonly Dictionary<int, GameObject> OwnedBackdropOverlays = new Dictionary<int, GameObject>();

		private static readonly Dictionary<int, TextReadabilityState> OriginalTextStates = new Dictionary<int, TextReadabilityState>();

		private static readonly Dictionary<int, ChatSurfaceScaleState> OriginalSurfaceScales = new Dictionary<int, ChatSurfaceScaleState>();

		private static readonly Dictionary<int, ChatTextFontSizeState> OriginalFontSizes = new Dictionary<int, ChatTextFontSizeState>();

		private static readonly Dictionary<int, ChatSurfaceWindowSizeState> OriginalSurfaceWindowSizes = new Dictionary<int, ChatSurfaceWindowSizeState>();

		private static readonly List<Transform> ScratchChatSurfaces = new List<Transform>(6);

		private static int _refreshRequestVersion;

		private static int _lastLoggedWindowPercent = -1;

		private static int _lastLoggedWindowApplied = -1;

		internal static int RefreshRequestVersion => _refreshRequestVersion;

		[HarmonyPostfix]
		[HarmonyPatch("AddMessageUI", new Type[]
		{
			typeof(string),
			typeof(string),
			typeof(bool),
			typeof(int),
			typeof(bool)
		})]
		private static void AddMessageUI_Postfix(string userName, string text, bool isLocal, int senderIndex, bool sendByPlayer)
		{
			try
			{
				RefreshNewestRows();
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Chat Readability could not update chat UI: " + ex.GetType().Name + ": " + ex.Message));
				}
			}
		}

		internal static void RequestRefreshSoon()
		{
			_refreshRequestVersion++;
		}

		internal static void RefreshNewestRows()
		{
			try
			{
				UIManager i = MonoSingleton<UIManager>.I;
				RefreshNewestRow((i != null) ? i.TextContentLocalTransform : null);
				RefreshNewestRow((i != null) ? i.TextContentGlobalTransform : null);
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Chat Readability row refresh skipped: " + ex.GetType().Name + ": " + ex.Message));
				}
			}
		}

		private static void RefreshNewestRow(Transform content)
		{
			if ((Object)(object)content == (Object)null || content.childCount == 0)
			{
				return;
			}
			Transform child = content.GetChild(content.childCount - 1);
			if (!((Object)(object)child == (Object)null))
			{
				ApplyChatFontSizeToContent(child, ChatFontSizePolicy.NormalizeFontSize(Plugin.LockedChatFontSizePercent));
				if (Plugin.ShouldApplyChatReadability)
				{
					ApplyReadability(((Component)child).gameObject);
				}
			}
		}

		internal static void RefreshVisibleChat()
		{
			try
			{
				UIManager i = MonoSingleton<UIManager>.I;
				ApplyChatWindowHeight(i);
				ApplyChatAccessibilityScale(i);
				ApplyChatFontSize(i);
				RefreshChatContents(i);
				PruneDestroyedState();
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Chat Readability refresh skipped: " + ex.GetType().Name + ": " + ex.Message));
				}
			}
		}

		private static void RefreshChatContents(UIManager ui)
		{
			Transform val = ((ui != null) ? ui.TextContentLocalTransform : null);
			Transform val2 = ((ui != null) ? ui.TextContentGlobalTransform : null);
			RefreshContent(val);
			if ((Object)(object)val2 != (Object)(object)val)
			{
				RefreshContent(val2);
			}
			RefreshBackdropTopology(val, val2);
		}

		private static void ApplyChatAccessibilityScale(UIManager ui)
		{
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			ScratchChatSurfaces.Clear();
			AddChatPanelSurface((ui != null) ? ui.TextContentLocalTransform : null, ScratchChatSurfaces);
			AddChatPanelSurface((ui != null) ? ui.TextContentGlobalTransform : null, ScratchChatSurfaces);
			float num = ChatAccessibilityScalePolicy.NormalizeScale(Plugin.LockedChatUiScalePercent);
			if (Mathf.Approximately(num, 1f))
			{
				RestoreChatAccessibilityScale();
				return;
			}
			foreach (Transform scratchChatSurface in ScratchChatSurfaces)
			{
				if (!((Object)(object)scratchChatSurface == (Object)null))
				{
					int instanceID = ((Object)scratchChatSurface).GetInstanceID();
					if (!OriginalSurfaceScales.TryGetValue(instanceID, out var value))
					{
						ChatSurfaceScaleState obj = new ChatSurfaceScaleState
						{
							Transform = scratchChatSurface,
							OriginalScale = scratchChatSurface.localScale,
							HadRectTransform = (scratchChatSurface is RectTransform)
						};
						RectTransform val = (RectTransform)(object)((scratchChatSurface is RectTransform) ? scratchChatSurface : null);
						obj.OriginalAnchoredPosition = ((val != null) ? val.anchoredPosition : Vector2.zero);
						obj.OriginalPosition = scratchChatSurface.position;
						value = obj;
						OriginalSurfaceScales[instanceID] = value;
					}
					scratchChatSurface.localScale = new Vector3(value.OriginalScale.x * num, value.OriginalScale.y * num, value.OriginalScale.z);
					RectTransform val2 = (RectTransform)(object)((scratchChatSurface is RectTransform) ? scratchChatSurface : null);
					if (val2 != null)
					{
						ClampScaledChatSurfaceToScreen(val2);
						LayoutRebuilder.MarkLayoutForRebuild(val2);
					}
				}
			}
		}

		private static void ApplyChatWindowHeight(UIManager ui)
		{
			ScratchChatSurfaces.Clear();
			AddChatWindowSurfaces((ui != null) ? ui.TextContentLocalTransform : null, ScratchChatSurfaces);
			AddChatWindowSurfaces((ui != null) ? ui.TextContentGlobalTransform : null, ScratchChatSurfaces);
			float num = ChatWindowHeightPolicy.NormalizeHeight(Plugin.LockedChatWindowHeightPercent);
			if (Mathf.Approximately(num, 1f))
			{
				RestoreChatWindowHeight();
				return;
			}
			int num2 = 0;
			foreach (Transform scratchChatSurface in ScratchChatSurfaces)
			{
				num2 += (ResizeChatWindowRect((RectTransform)(object)((scratchChatSurface is RectTransform) ? scratchChatSurface : null), num, clampToScreen: true) ? 1 : 0);
			}
			int lockedChatWindowHeightPercent = Plugin.LockedChatWindowHeightPercent;
			if (lockedChatWindowHeightPercent != _lastLoggedWindowPercent || num2 != _lastLoggedWindowApplied)
			{
				_lastLoggedWindowPercent = lockedChatWindowHeightPercent;
				_lastLoggedWindowApplied = num2;
				string text = ((num2 > 0) ? "ready" : "waiting for visible layout");
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)$"Chat window height {lockedChatWindowHeightPercent}% {text}; applied to {num2} surface rect(s); {ScratchChatSurfaces.Count} primary surface(s) checked.");
				}
			}
		}

		private static void ApplyChatFontSize(UIManager ui)
		{
			float num = ChatFontSizePolicy.NormalizeFontSize(Plugin.LockedChatFontSizePercent);
			if (Mathf.Approximately(num, 1f))
			{
				RestoreChatFontSize();
			}
			else
			{
				_ = 0 + ApplyChatFontSizeToContent((ui != null) ? ui.TextContentLocalTransform : null, num) + ApplyChatFontSizeToContent((ui != null) ? ui.TextContentGlobalTransform : null, num);
			}
		}

		private static int ApplyChatFontSizeToContent(Transform content, float scale)
		{
			if ((Object)(object)content == (Object)null)
			{
				return 0;
			}
			int num = 0;
			TextMeshProUGUI[] componentsInChildren = ((Component)content).GetComponentsInChildren<TextMeshProUGUI>(true);
			foreach (TextMeshProUGUI val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null))
				{
					int instanceID = ((Object)val).GetInstanceID();
					if (!OriginalFontSizes.TryGetValue(instanceID, out var value))
					{
						value = new ChatTextFontSizeState
						{
							Text = val,
							OriginalFontSize = Mathf.Max(1f, ((TMP_Text)val).fontSize)
						};
						OriginalFontSizes[instanceID] = value;
					}
					float num2 = Mathf.Max(1f, value.OriginalFontSize * scale);
					if (!Mathf.Approximately(((TMP_Text)val).fontSize, num2))
					{
						((TMP_Text)val).fontSize = num2;
						((Graphic)val).SetLayoutDirty();
						((Graphic)val).SetVerticesDirty();
						num++;
					}
				}
			}
			return num;
		}

		private static bool ResizeChatWindowRect(RectTransform rectTransform, float heightScale, bool clampToScreen)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)rectTransform == (Object)null)
			{
				return false;
			}
			Rect rect = rectTransform.rect;
			float width = Mathf.Max(0f, ((Rect)(ref rect)).width);
			rect = rectTransform.rect;
			float num = Mathf.Max(0f, ((Rect)(ref rect)).height);
			if (!IsValidChatWindowBaseline(width, num))
			{
				OriginalSurfaceWindowSizes.Remove(((Object)rectTransform).GetInstanceID());
				return false;
			}
			int instanceID = ((Object)rectTransform).GetInstanceID();
			if (!OriginalSurfaceWindowSizes.TryGetValue(instanceID, out var value))
			{
				ChatSurfaceWindowSizeState obj = new ChatSurfaceWindowSizeState
				{
					Transform = rectTransform,
					OriginalSizeDelta = rectTransform.sizeDelta,
					OriginalAnchoredPosition = rectTransform.anchoredPosition,
					OriginalPosition = ((Transform)rectTransform).position
				};
				rect = rectTransform.rect;
				obj.OriginalWidth = Mathf.Max(1f, ((Rect)(ref rect)).width);
				rect = rectTransform.rect;
				obj.OriginalHeight = Mathf.Max(1f, ((Rect)(ref rect)).height);
				value = obj;
				OriginalSurfaceWindowSizes[instanceID] = value;
			}
			else if (!IsValidChatWindowBaseline(value.OriginalWidth, value.OriginalHeight))
			{
				value.OriginalSizeDelta = rectTransform.sizeDelta;
				value.OriginalAnchoredPosition = rectTransform.anchoredPosition;
				value.OriginalPosition = ((Transform)rectTransform).position;
				ChatSurfaceWindowSizeState chatSurfaceWindowSizeState = value;
				rect = rectTransform.rect;
				chatSurfaceWindowSizeState.OriginalWidth = Mathf.Max(1f, ((Rect)(ref rect)).width);
				ChatSurfaceWindowSizeState chatSurfaceWindowSizeState2 = value;
				rect = rectTransform.rect;
				chatSurfaceWindowSizeState2.OriginalHeight = Mathf.Max(1f, ((Rect)(ref rect)).height);
			}
			float num2 = rectTransform.anchoredPosition.y - num * Mathf.Clamp01(rectTransform.pivot.y);
			float num3 = Mathf.Max(1f, value.OriginalHeight * heightScale);
			rectTransform.SetSizeWithCurrentAnchors((Axis)1, num3);
			rectTransform.anchoredPosition = new Vector2(rectTransform.anchoredPosition.x, num2 + num3 * Mathf.Clamp01(rectTransform.pivot.y));
			if (clampToScreen)
			{
				ClampScaledChatSurfaceToScreen(rectTransform);
			}
			LayoutRebuilder.MarkLayoutForRebuild(rectTransform);
			return true;
		}

		private static void ClampScaledChatSurfaceToScreen(RectTransform rectTransform)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)rectTransform == (Object)null)
			{
				return;
			}
			Camera uiCamera = GetUiCamera(rectTransform);
			Vector3[] array = (Vector3[])(object)new Vector3[4];
			rectTransform.GetWorldCorners(array);
			float num = float.MaxValue;
			float num2 = float.MinValue;
			float num3 = float.MaxValue;
			float num4 = float.MinValue;
			for (int i = 0; i < array.Length; i++)
			{
				Vector2 val = RectTransformUtility.WorldToScreenPoint(uiCamera, array[i]);
				num = Mathf.Min(num, val.x);
				num2 = Mathf.Max(num2, val.x);
				num3 = Mathf.Min(num3, val.y);
				num4 = Mathf.Max(num4, val.y);
			}
			if (ChatAccessibilityScalePolicy.TryCalculateScreenClampDelta(num, num2, num3, num4, Screen.width, Screen.height, 8f, out var deltaX, out var deltaY))
			{
				Transform parent = ((Transform)rectTransform).parent;
				RectTransform val2 = (RectTransform)(object)((parent is RectTransform) ? parent : null);
				Vector2 val3 = default(Vector2);
				Vector2 val4 = default(Vector2);
				if (val2 != null && RectTransformUtility.ScreenPointToLocalPointInRectangle(val2, Vector2.zero, uiCamera, ref val3) && RectTransformUtility.ScreenPointToLocalPointInRectangle(val2, new Vector2(deltaX, deltaY), uiCamera, ref val4))
				{
					rectTransform.anchoredPosition += val4 - val3;
				}
				else
				{
					((Transform)rectTransform).position = ((Transform)rectTransform).position + new Vector3(deltaX, deltaY, 0f);
				}
			}
		}

		private static Camera GetUiCamera(RectTransform rectTransform)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			Canvas val = (((Object)(object)rectTransform != (Object)null) ? ((Component)rectTransform).GetComponentInParent<Canvas>() : null);
			if ((Object)(object)val == (Object)null || (int)val.renderMode == 0)
			{
				return null;
			}
			if (!((Object)(object)val.worldCamera != (Object)null))
			{
				return Camera.main;
			}
			return val.worldCamera;
		}

		private static void AddChatPanelSurface(Transform content, List<Transform> surfaces)
		{
			Transform val = ResolveChatPanelSurface(content);
			if (!((Object)(object)val == (Object)null) && !surfaces.Contains(val))
			{
				surfaces.Add(val);
			}
		}

		private static void AddChatWindowSurfaces(Transform content, List<Transform> surfaces)
		{
			AddUniqueSurface(surfaces, ResolveChatScrollView(content));
		}

		private static void AddUniqueSurface(List<Transform> surfaces, Transform surface)
		{
			if (!((Object)(object)surface == (Object)null) && !surfaces.Contains(surface))
			{
				surfaces.Add(surface);
			}
		}

		private static Transform ResolveChatPanelSurface(Transform content)
		{
			Transform obj = ResolveChatScrollView(content);
			return ((obj != null) ? obj.parent : null) ?? content;
		}

		private static Transform ResolveChatScrollView(Transform content)
		{
			if (content == null)
			{
				return null;
			}
			Transform parent = content.parent;
			if (parent == null)
			{
				return null;
			}
			return parent.parent;
		}

		private static bool IsValidChatWindowBaseline(float width, float height)
		{
			if (width >= 24f)
			{
				return height >= 24f;
			}
			return false;
		}

		internal static void RestoreChatWindowHeight()
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			if (OriginalSurfaceWindowSizes.Count == 0)
			{
				return;
			}
			foreach (int item in new List<int>(OriginalSurfaceWindowSizes.Keys))
			{
				ChatSurfaceWindowSizeState chatSurfaceWindowSizeState = OriginalSurfaceWindowSizes[item];
				if (chatSurfaceWindowSizeState == null || (Object)(object)chatSurfaceWindowSizeState.Transform == (Object)null)
				{
					OriginalSurfaceWindowSizes.Remove(item);
					continue;
				}
				RectTransform transform = chatSurfaceWindowSizeState.Transform;
				transform.sizeDelta = chatSurfaceWindowSizeState.OriginalSizeDelta;
				transform.anchoredPosition = chatSurfaceWindowSizeState.OriginalAnchoredPosition;
				((Transform)transform).position = chatSurfaceWindowSizeState.OriginalPosition;
				LayoutRebuilder.MarkLayoutForRebuild(transform);
				OriginalSurfaceWindowSizes.Remove(item);
			}
		}

		internal static void RestoreChatFontSize()
		{
			if (OriginalFontSizes.Count == 0)
			{
				return;
			}
			foreach (int item in new List<int>(OriginalFontSizes.Keys))
			{
				ChatTextFontSizeState chatTextFontSizeState = OriginalFontSizes[item];
				if (chatTextFontSizeState == null || (Object)(object)chatTextFontSizeState.Text == (Object)null)
				{
					OriginalFontSizes.Remove(item);
					continue;
				}
				((TMP_Text)chatTextFontSizeState.Text).fontSize = chatTextFontSizeState.OriginalFontSize;
				((Graphic)chatTextFontSizeState.Text).SetLayoutDirty();
				((Graphic)chatTextFontSizeState.Text).SetVerticesDirty();
				OriginalFontSizes.Remove(item);
			}
		}

		internal static void RestoreChatAccessibilityScale()
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			if (OriginalSurfaceScales.Count == 0)
			{
				return;
			}
			foreach (int item in new List<int>(OriginalSurfaceScales.Keys))
			{
				ChatSurfaceScaleState chatSurfaceScaleState = OriginalSurfaceScales[item];
				if (chatSurfaceScaleState == null || (Object)(object)chatSurfaceScaleState.Transform == (Object)null)
				{
					OriginalSurfaceScales.Remove(item);
					continue;
				}
				chatSurfaceScaleState.Transform.localScale = chatSurfaceScaleState.OriginalScale;
				Transform transform = chatSurfaceScaleState.Transform;
				RectTransform val = (RectTransform)(object)((transform is RectTransform) ? transform : null);
				if (val != null)
				{
					val.anchoredPosition = chatSurfaceScaleState.OriginalAnchoredPosition;
					((Transform)val).position = chatSurfaceScaleState.OriginalPosition;
					LayoutRebuilder.MarkLayoutForRebuild(val);
				}
				else
				{
					chatSurfaceScaleState.Transform.position = chatSurfaceScaleState.OriginalPosition;
				}
				OriginalSurfaceScales.Remove(item);
			}
		}

		private static void RefreshContent(Transform container)
		{
			if (!((Object)(object)container == (Object)null))
			{
				if (Plugin.ShouldApplyChatReadability)
				{
					ApplyReadability(((Component)container).gameObject);
				}
				else
				{
					RestoreReadability(((Component)container).gameObject);
				}
			}
		}

		private static void RefreshBackdropTopology(Transform localContent, Transform globalContent)
		{
			if (Plugin.ShouldApplyPersistentChatBackdrop)
			{
				ApplyPersistentBackdrop(localContent);
				if ((Object)(object)globalContent != (Object)(object)localContent)
				{
					ApplyPersistentBackdrop(globalContent);
				}
			}
			else
			{
				RestorePersistentBackdrop(localContent);
				RestorePersistentBackdrop(globalContent);
			}
		}

		internal static void PruneDestroyedState()
		{
			foreach (int item in new List<int>(OriginalTextStates.Keys))
			{
				TextReadabilityState textReadabilityState = OriginalTextStates[item];
				if (textReadabilityState == null || (Object)(object)textReadabilityState.Text == (Object)null)
				{
					DestroyOwnedMaterial(textReadabilityState?.AppliedFontMaterial);
					OriginalTextStates.Remove(item);
				}
			}
			foreach (int item2 in new List<int>(OriginalFontSizes.Keys))
			{
				if ((Object)(object)OriginalFontSizes[item2]?.Text == (Object)null)
				{
					OriginalFontSizes.Remove(item2);
				}
			}
			foreach (int item3 in new List<int>(OriginalBackdropColors.Keys))
			{
				if ((Object)(object)OriginalBackdropColors[item3]?.Image == (Object)null)
				{
					OriginalBackdropColors.Remove(item3);
				}
			}
			foreach (int item4 in new List<int>(OwnedBackdropOverlays.Keys))
			{
				if ((Object)(object)OwnedBackdropOverlays[item4] == (Object)null)
				{
					OwnedBackdropOverlays.Remove(item4);
				}
			}
			foreach (int item5 in new List<int>(OriginalSurfaceScales.Keys))
			{
				ChatSurfaceScaleState chatSurfaceScaleState = OriginalSurfaceScales[item5];
				if (chatSurfaceScaleState == null || (Object)(object)chatSurfaceScaleState.Transform == (Object)null)
				{
					OriginalSurfaceScales.Remove(item5);
				}
			}
			foreach (int item6 in new List<int>(OriginalSurfaceWindowSizes.Keys))
			{
				ChatSurfaceWindowSizeState chatSurfaceWindowSizeState = OriginalSurfaceWindowSizes[item6];
				if (chatSurfaceWindowSizeState == null || (Object)(object)chatSurfaceWindowSizeState.Transform == (Object)null)
				{
					OriginalSurfaceWindowSizes.Remove(item6);
				}
			}
		}

		internal static string GetDiagnosticStateSummary()
		{
			return "text=" + OriginalTextStates.Count + ",font=" + OriginalFontSizes.Count + ",backdrop=" + OriginalBackdropColors.Count + ",overlay=" + OwnedBackdropOverlays.Count + ",scale=" + OriginalSurfaceScales.Count + ",window=" + OriginalSurfaceWindowSizes.Count;
		}

		private static void ApplyReadability(GameObject messageRow)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)messageRow == (Object)null)
			{
				return;
			}
			TextMeshProUGUI[] componentsInChildren = messageRow.GetComponentsInChildren<TextMeshProUGUI>(true);
			foreach (TextMeshProUGUI val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null))
				{
					TextReadabilityState textReadabilityState = CaptureOriginalState(val);
					float num = ChatReadabilityStylePolicy.NormalizeOutlineIntensity(Plugin.LockedChatOutlineIntensityPercent);
					Color outlineColorForText = GetOutlineColorForText(val);
					int num2 = ComputeReadabilitySignature(val, outlineColorForText, num);
					if (textReadabilityState.LastAppliedSignature != num2 || !((Object)(object)textReadabilityState.AppliedFontMaterial != (Object)null) || !((Object)(object)((TMP_Text)val).fontMaterial == (Object)(object)textReadabilityState.AppliedFontMaterial))
					{
						outlineColorForText.a *= Mathf.Lerp(0.58f, 1f, num);
						Color shadowColor = ShadowColor;
						shadowColor.a *= Mathf.Lerp(0.42f, 1f, num);
						Vector2 effectDistance = MaxOutlineDistance * Mathf.Lerp(0.52f, 1f, num);
						Vector2 effectDistance2 = MaxShadowDistance * Mathf.Lerp(0.46f, 1f, num);
						Outline obj = ((Component)val).gameObject.GetComponent<Outline>() ?? ((Component)val).gameObject.AddComponent<Outline>();
						((Shadow)obj).effectColor = outlineColorForText;
						((Shadow)obj).effectDistance = effectDistance;
						((Shadow)obj).useGraphicAlpha = false;
						Shadow obj2 = ((Component)val).gameObject.GetComponent<Shadow>() ?? ((Component)val).gameObject.AddComponent<Shadow>();
						obj2.effectColor = shadowColor;
						obj2.effectDistance = effectDistance2;
						obj2.useGraphicAlpha = false;
						ApplyTmpMaterialOutline(val, textReadabilityState, outlineColorForText, num);
						((Graphic)val).SetMaterialDirty();
						((Graphic)val).SetVerticesDirty();
						textReadabilityState.LastAppliedSignature = num2;
					}
				}
			}
		}

		private unsafe static int ComputeReadabilitySignature(TextMeshProUGUI text, Color outlineColor, float intensity)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			return (((17 * 31 + ((object)(*(Color*)(&outlineColor))/*cast due to .constrained prefix*/).GetHashCode()) * 31 + intensity.GetHashCode()) * 31 + ((text != null) ? ((object)((Graphic)text).color/*cast due to .constrained prefix*/).GetHashCode() : 0)) * 31 + (ChatReadabilityStylePolicy.ContainsTrueBlackRichTextColorTag((text != null) ? ((TMP_Text)text).text : null) ? 1 : 0);
		}

		private static void ApplyTmpMaterialOutline(TextMeshProUGUI text, TextReadabilityState state, Color outlineColor, float intensity)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			if ((Object)(object)text == (Object)null || state == null)
			{
				return;
			}
			Material appliedFontMaterial = state.AppliedFontMaterial;
			if ((Object)(object)appliedFontMaterial == (Object)null)
			{
				appliedFontMaterial = ((TMP_Text)text).fontMaterial;
				if ((Object)(object)appliedFontMaterial == (Object)null)
				{
					return;
				}
				state.AppliedFontMaterial = new Material(appliedFontMaterial)
				{
					name = ((Object)appliedFontMaterial).name + " BlueSage Chat Outline"
				};
				appliedFontMaterial = state.AppliedFontMaterial;
			}
			float num = Mathf.Lerp(0.08f, 0.22f, intensity);
			appliedFontMaterial.SetColor(ShaderUtilities.ID_OutlineColor, outlineColor);
			appliedFontMaterial.SetFloat(ShaderUtilities.ID_OutlineWidth, num);
			((TMP_Text)text).fontMaterial = appliedFontMaterial;
			((TMP_Text)text).UpdateMeshPadding();
		}

		private static TextReadabilityState CaptureOriginalState(TextMeshProUGUI text)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			int instanceID = ((Object)text).GetInstanceID();
			if (OriginalTextStates.TryGetValue(instanceID, out var value))
			{
				return value;
			}
			Outline component = ((Component)text).gameObject.GetComponent<Outline>();
			Shadow component2 = ((Component)text).gameObject.GetComponent<Shadow>();
			value = new TextReadabilityState
			{
				Text = text,
				HadOutline = ((Object)(object)component != (Object)null),
				OutlineColor = (((Object)(object)component != (Object)null) ? ((Shadow)component).effectColor : Color.clear),
				OutlineDistance = (((Object)(object)component != (Object)null) ? ((Shadow)component).effectDistance : Vector2.zero),
				OutlineUseGraphicAlpha = ((Object)(object)component != (Object)null && ((Shadow)component).useGraphicAlpha),
				HadShadow = ((Object)(object)component2 != (Object)null),
				ShadowColor = (((Object)(object)component2 != (Object)null) ? component2.effectColor : Color.clear),
				ShadowDistance = (((Object)(object)component2 != (Object)null) ? component2.effectDistance : Vector2.zero),
				ShadowUseGraphicAlpha = ((Object)(object)component2 != (Object)null && component2.useGraphicAlpha),
				OriginalFontMaterial = ((TMP_Text)text).fontMaterial
			};
			OriginalTextStates[instanceID] = value;
			return value;
		}

		private static Color GetOutlineColorForText(TextMeshProUGUI text)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)text == (Object)null)
			{
				return DarkOutlineColor;
			}
			Color color = ((Graphic)text).color;
			if (!Plugin.ShouldApplyBlackNamesOutline || (!ChatReadabilityStylePolicy.ShouldUseLightOutline(color.r, color.g, color.b) && !ChatReadabilityStylePolicy.ContainsTrueBlackRichTextColorTag(((TMP_Text)text).text)))
			{
				return ColorFromHex(Plugin.LockedChatOutlineColorHex, DarkOutlineColor);
			}
			return ColorFromHex(Plugin.LockedBlackChatOutlineColorHex, LightOutlineColor);
		}

		private static Color ColorFromHex(string value, Color fallback)
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			string text = ChatReadabilityStylePolicy.NormalizeHexColor(value, string.Empty);
			if (string.IsNullOrEmpty(text))
			{
				return fallback;
			}
			try
			{
				byte b = Convert.ToByte(text.Substring(0, 2), 16);
				byte b2 = Convert.ToByte(text.Substring(2, 2), 16);
				byte b3 = Convert.ToByte(text.Substring(4, 2), 16);
				return new Color((float)(int)b / 255f, (float)(int)b2 / 255f, (float)(int)b3 / 255f, fallback.a);
			}
			catch (Exception)
			{
				return fallback;
			}
		}

		private static void RestoreReadability(GameObject messageRoot)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)messageRoot == (Object)null || OriginalTextStates.Count == 0)
			{
				return;
			}
			TextMeshProUGUI[] componentsInChildren = messageRoot.GetComponentsInChildren<TextMeshProUGUI>(true);
			foreach (TextMeshProUGUI val in componentsInChildren)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				int instanceID = ((Object)val).GetInstanceID();
				if (OriginalTextStates.TryGetValue(instanceID, out var value))
				{
					RestoreUiEffect((Shadow)(object)((Component)val).gameObject.GetComponent<Outline>(), value.HadOutline, value.OutlineColor, value.OutlineDistance, value.OutlineUseGraphicAlpha);
					RestoreUiEffect(((Component)val).gameObject.GetComponent<Shadow>(), value.HadShadow, value.ShadowColor, value.ShadowDistance, value.ShadowUseGraphicAlpha);
					if ((Object)(object)value.OriginalFontMaterial != (Object)null)
					{
						((TMP_Text)val).fontMaterial = value.OriginalFontMaterial;
						((TMP_Text)val).UpdateMeshPadding();
						((Graphic)val).SetMaterialDirty();
						((Graphic)val).SetVerticesDirty();
					}
					DestroyOwnedMaterial(value.AppliedFontMaterial);
					value.AppliedFontMaterial = null;
					OriginalTextStates.Remove(instanceID);
				}
			}
		}

		private static void DestroyOwnedMaterial(Material material)
		{
			if (!((Object)(object)material == (Object)null))
			{
				Object.Destroy((Object)(object)material);
			}
		}

		private static void RestoreUiEffect(Shadow outline, bool hadEffect, Color color, Vector2 distance, bool useGraphicAlpha)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)outline == (Object)null))
			{
				if (!hadEffect)
				{
					Object.Destroy((Object)(object)outline);
					return;
				}
				outline.effectColor = color;
				outline.effectDistance = distance;
				outline.useGraphicAlpha = useGraphicAlpha;
			}
		}

		private static void ApplyPersistentBackdrop(Transform content)
		{
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected O, but got Unknown
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			Transform obj = ResolveChatScrollView(content);
			RectTransform val = (RectTransform)(object)((obj is RectTransform) ? obj : null);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			Image component = ((Component)val).GetComponent<Image>();
			if ((Object)(object)component == (Object)null)
			{
				int instanceID = ((Object)val).GetInstanceID();
				if (!OwnedBackdropOverlays.TryGetValue(instanceID, out var value) || (Object)(object)value == (Object)null)
				{
					value = new GameObject("BlueSage Chat Backdrop", new Type[4]
					{
						typeof(RectTransform),
						typeof(CanvasRenderer),
						typeof(Image),
						typeof(CanvasGroup)
					});
					RectTransform component2 = value.GetComponent<RectTransform>();
					((Transform)component2).SetParent((Transform)(object)val, false);
					component2.anchorMin = Vector2.zero;
					component2.anchorMax = Vector2.one;
					component2.offsetMin = Vector2.zero;
					component2.offsetMax = Vector2.zero;
					((Transform)component2).SetAsFirstSibling();
					value.GetComponent<CanvasGroup>().blocksRaycasts = false;
					OwnedBackdropOverlays[instanceID] = value;
				}
				component = value.GetComponent<Image>();
				((Graphic)component).color = new Color(0.1f, 0.09f, 0.11f, 0.62f);
			}
			else
			{
				Color color = ((Graphic)component).color;
				int instanceID2 = ((Object)component).GetInstanceID();
				if (!OriginalBackdropColors.ContainsKey(instanceID2))
				{
					OriginalBackdropColors[instanceID2] = new BackdropState
					{
						Image = component,
						OriginalColor = color
					};
				}
				((Graphic)component).color = new Color(Mathf.Min(color.r, 0.22f), Mathf.Min(color.g, 0.2f), Mathf.Min(color.b, 0.2f), Mathf.Max(color.a, 0.72f));
			}
		}

		private static void RestorePersistentBackdrop(Transform content)
		{
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			Transform obj = ResolveChatScrollView(content);
			RectTransform val = (RectTransform)(object)((obj is RectTransform) ? obj : null);
			if ((Object)(object)val != (Object)null && OwnedBackdropOverlays.TryGetValue(((Object)val).GetInstanceID(), out var value))
			{
				OwnedBackdropOverlays.Remove(((Object)val).GetInstanceID());
				if ((Object)(object)value != (Object)null)
				{
					Object.Destroy((Object)(object)value);
				}
			}
			if (OriginalBackdropColors.Count == 0)
			{
				return;
			}
			foreach (int item in new List<int>(OriginalBackdropColors.Keys))
			{
				BackdropState backdropState = OriginalBackdropColors[item];
				if ((Object)(object)backdropState?.Image != (Object)null)
				{
					((Graphic)backdropState.Image).color = backdropState.OriginalColor;
				}
				OriginalBackdropColors.Remove(item);
			}
		}
	}
	internal sealed class AuthoritativeChatSenderContext
	{
		internal string SteamId = string.Empty;

		internal string PlayerId = string.Empty;

		internal int NativeRowIndex = -1;

		internal PlayerItemController Row;

		internal NetworkTransform NetworkTransform;

		internal string SessionRowCorrelator = string.Empty;

		internal string RosterNameRaw = string.Empty;

		internal string SteamPersona = string.Empty;

		internal string Role = string.Empty;

		internal bool ExactTupleCaptured
		{
			get
			{
				if (SteamId.Length == 17 && !string.IsNullOrWhiteSpace(PlayerId) && NativeRowIndex >= 0 && (Object)(object)Row != (Object)null && (Object)(object)NetworkTransform != (Object)null)
				{
					return !string.IsNullOrWhiteSpace(SessionRowCorrelator);
				}
				return false;
			}
		}
	}
	[HarmonyPatch(typeof(TextChannelManager), "SendMessageAsync_Original_0", new Type[]
	{
		typeof(byte[]),
		typeof(byte[]),
		typeof(bool),
		typeof(Vector3),
		typeof(string),
		typeof(RPCInfo)
	})]
	internal static class ChatSenderContextPatch
	{
		private const int MaximumChatPayloadBytes = 8000;

		private static bool _captureFailureLogged;

		private static ulong _sessionLobby;

		private static ulong _sessionOwner;

		private static PlayerPanelController _sessionPanel;

		private static string _sessionScope = string.Empty;

		[ThreadStatic]
		private static AuthoritativeChatSenderContext _currentSenderContext;

		internal static AuthoritativeChatSenderContext CurrentSenderContext => _currentSenderContext;

		internal static string CurrentSenderSteamId => _currentSenderContext?.SteamId ?? string.Empty;

		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static void Prefix(byte[] __0, RPCInfo info, out AuthoritativeChatSenderContext __state)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			__state = _currentSenderContext;
			_currentSenderContext = null;
			if (__0 != null && __0.Length != 0 && __0.Length <= 8000 && (__0.Length & 1) == 0)
			{
				_currentSenderContext = (TryCaptureAuthoritativeSender(info, out var sender) ? sender : null);
			}
		}

		[HarmonyFinalizer]
		[HarmonyPriority(0)]
		private static Exception Finalizer(Exception __exception, AuthoritativeChatSenderContext __state)
		{
			_currentSenderContext = __state;
			return __exception;
		}

		private static bool TryCaptureAuthoritativeSender(RPCInfo info, out AuthoritativeChatSenderContext sender)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			sender = null;
			try
			{
				PlayerPanelController i = NetworkSingleton<PlayerPanelController>.I;
				if (!((Object)(object)info.manager == (Object)null) && i?.PlayerSteamIDs != null && i.PlayerIDs != null && i.PlayerTransforms != null && i.PlayerItemControllers != null && AuthoritativeChatSenderPolicy.TryResolveUniqueIndex(info.sender, i.PlayerIDs, out var index) && index >= 0 && index < i.PlayerSteamIDs.Count && index < i.PlayerIDs.Count && index < i.PlayerTransforms.Count && index < i.PlayerItemControllers.Count && !((Object)(object)i.PlayerTransforms[index] == (Object)null) && !((Object)(object)i.PlayerItemControllers[index] == (Object)null) && PlayerIdentityEvidenceController.TryResolveRosterIndexFresh(index, out var evidence, out var _) && string.Equals(i.PlayerSteamIDs[index], evidence.SteamId, StringComparison.Ordinal))
				{
					PlayerID val = i.PlayerIDs[index];
					if (string.Equals(PurrNetPlayerIdPolicy.Format(PackedULong.op_Implicit(((PlayerID)(ref val)).id)), evidence.NetworkPlayerId, StringComparison.Ordinal) && TryGetSessionScope(out var sessionScope) && SessionRowCorrelatorPolicy.TryCreate(sessionScope, evidence.SteamId, evidence.NetworkPlayerId, index, out var correlator))
					{
						sender = new AuthoritativeChatSenderContext
						{
							SteamId = evidence.SteamId,
							PlayerId = evidence.NetworkPlayerId,
							NativeRowIndex = index,
							Row = i.PlayerItemControllers[index],
							NetworkTransform = i.PlayerTransforms[index],
							SessionRowCorrelator = correlator,
							RosterNameRaw = evidence.DisplayNameRaw,
							SteamPersona = evidence.SteamPersona,
							Role = evidence.Role
						};
						return sender.ExactTupleCaptured;
					}
				}
				return false;
			}
			catch (Exception ex)
			{
				if (!_captureFailureLogged)
				{
					_captureFailureLogged = true;
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogDebug((object)("Authoritative chat sender capture failed closed once: " + ex.GetType().Name + "."));
					}
				}
				return false;
			}
		}

		private static bool TryGetSessionScope(out string sessionScope)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			sessionScope = string.Empty;
			if (!SteamManager.Initialized || !Plugin.TryGetRescueLobby(out var lobbyId) || lobbyId == CSteamID.Nil)
			{
				_sessionLobby = 0uL;
				_sessionOwner = 0uL;
				_sessionPanel = null;
				_sessionScope = string.Empty;
				return false;
			}
			ulong num = (ulong)lobbyId;
			ulong num2 = (ulong)SteamMatchmaking.GetLobbyOwner(lobbyId);
			PlayerPanelController i = NetworkSingleton<PlayerPanelController>.I;
			if (_sessionLobby != num || _sessionOwner != num2 || _sessionPanel != i || string.IsNullOrWhiteSpace(_sessionScope))
			{
				_sessionLobby = num;
				_sessionOwner = num2;
				_sessionPanel = i;
				_sessionScope = Guid.NewGuid().ToString("N");
			}
			sessionScope = _sessionScope;
			return true;
		}
	}
	[HarmonyPatch(typeof(TextChannelManager))]
	internal static class ChatSendLimitPatch
	{
		[HarmonyPatch("OnEnterPressed")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> OnEnterPressedTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			bool replacedVanillaSendLimit = false;
			foreach (CodeInstruction instruction in instructions)
			{
				if (!replacedVanillaSendLimit && IsVanillaSendLimit(instruction))
				{
					replacedVanillaSendLimit = true;
					yield return new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ChatSendLimitPatch), "GetMaxChatSendCharacters", (Type[])null, (Type[])null));
				}
				else
				{
					yield return instruction;
				}
			}
			if (!replacedVanillaSendLimit)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)"ChatLimitRemover could not find the vanilla 250-character send cap in TextChannelManager.OnEnterPressed.");
				}
			}
		}

		private static int GetMaxChatSendCharacters()
		{
			return Plugin.LockedMaxChatCharacters;
		}

		private static bool IsVanillaSendLimit(CodeInstruction instruction)
		{
			if (instruction.opcode == OpCodes.Ldc_I4 && instruction.operand is int num)
			{
				return num == 250;
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(TextChannelManager))]
	internal static class ChatTimestampPatch
	{
		[HarmonyPatch("AddMessageUI", new Type[]
		{
			typeof(string),
			typeof(string),
			typeof(bool),
			typeof(int),
			typeof(bool)
		})]
		[HarmonyPrefix]
		private static void AddMessageUiPrefix(ref string userName)
		{
			if (Plugin.ShouldApplyChatTimestamps && !string.IsNullOrEmpty(userName))
			{
				userName = Plugin.BuildTimestampPrefix() + userName;
			}
		}

		[HarmonyPatch("AddNotification")]
		[HarmonyPrefix]
		private static void AddNotificationPrefix(ref string text)
		{
			if (Plugin.ShouldApplyNotificationTimestamps && !string.IsNullOrEmpty(text))
			{
				text = Plugin.BuildTimestampPrefix() + text;
			}
		}
	}
	[HarmonyPatch(typeof(PlayerItemController), "Init")]
	internal static class EnhancedPlayerPanelPatch
	{
		[HarmonyPostfix]
		private static void Postfix(PlayerItemController __instance, string playerSteamId, bool isSelf)
		{
			PlayerPanelSurfaceController.RefreshRow(__instance, playerSteamId, isSelf, Plugin.ShouldApplyEnhancedPlayerPanel);
		}
	}
	[HarmonyPatch(typeof(TaskManager), "IsReadyForFreeFocus")]
	internal static class FocusAnywhereFreeFocusPatch
	{
		[HarmonyPostfix]
		private static void Postfix(ref bool __result)
		{
			if (Plugin.ShouldApplyFocusAnywhere)
			{
				__result = true;
			}
		}
	}
	[HarmonyPatch(typeof(TaskManager), "IsReadyForAreaFocus")]
	internal static class FocusAnywhereAreaFocusPatch
	{
		[HarmonyPostfix]
		private static void Postfix(ref bool __result)
		{
			if (Plugin.ShouldApplyFocusAnywhere)
			{
				__result = true;
			}
		}
	}
	[HarmonyPatch]
	internal static class FocusAnywhereIsFocusablePatch
	{
		[HarmonyTargetMethod]
		private static MethodBase TargetMethod()
		{
			return AccessTools.Method(typeof(PlayerFocusController), "IsFocusable", (Type[])null, (Type[])null);
		}

		[HarmonyPostfix]
		private static void Postfix(ref bool __result)
		{
			if (Plugin.ShouldApplyFocusAnywhere)
			{
				__result = true;
			}
		}
	}
	[HarmonyPatch(typeof(PlayerMovementController), "get_IsLake")]
	internal static class FocusAnywhereLakePatch
	{
		[HarmonyPostfix]
		private static void Postfix(ref bool __result)
		{
			if (Plugin.ShouldApplyFocusAnywhere)
			{
				__result = false;
			}
		}
	}
	internal static class HostVisibilityProtocolPatch
	{
		private static readonly Dictionary<Renderer, bool> RendererStates = new Dictionary<Renderer, bool>();

		private static readonly Dictionary<Canvas, bool> CanvasStates = new Dictionary<Canvas, bool>();

		private static readonly Dictionary<TMP_Text, bool> TextStates = new Dictionary<TMP_Text, bool>();

		private static readonly FieldInfo PlayerCanvasesField = AccessTools.Field(typeof(PlayerController), "_canvases");

		private static readonly FieldInfo PlayerCanvasField = AccessTools.Field(typeof(PlayerController), "_playerCanvas");

		private static readonly FieldInfo PlayerNameTextField = AccessTools.Field(typeof(PlayerController), "_playerNameText");

		private static readonly FieldInfo TextBubbleCanvasField = AccessTools.Field(typeof(TextBubbleController), "_textBubbleCanvas");

		private static readonly FieldInfo TextBubbleTextField = AccessTools.Field(typeof(TextBubbleController), "_textBubble");

		private static readonly FieldInfo TextBubbleNameTextField = AccessTools.Field(typeof(TextBubbleController), "_nameText");

		private static Transform _hostRoot;

		private static float _lastReceivedAt = -100f;

		private static float _nextValidationAt;

		private static string _ownerSteam = string.Empty;

		private static int _lastReportedRendererCount;

		private const string MemberDataKey = "bluesage_visibility_v2";

		private const int MemberDataExpirySeconds = 8;

		internal static void Tick()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			if (Time.unscaledTime < _nextValidationAt)
			{
				return;
			}
			_nextValidationAt = Time.unscaledTime + 0.5f;
			PollOwnerMemberData();
			if (!((Object)(object)_hostRoot == (Object)null))
			{
				PlayerPanelController i = NetworkSingleton<PlayerPanelController>.I;
				if (!Plugin.TryGetRescueLobby(out var lobbyId) || !string.Equals(((ulong)SteamMatchmaking.GetLobbyOwner(lobbyId)).ToString(), _ownerSteam, StringComparison.Ordinal) || Time.unscaledTime - _lastReceivedAt > 8f || (Object)(object)((Component)_hostRoot).gameObject == (Object)null || !((Component)_hostRoot).gameObject.activeInHierarchy || i?.PlayerSteamIDs == null || !i.PlayerSteamIDs.Contains(_ownerSteam))
				{
					RestoreAll();
				}
			}
		}

		private static void PollOwnerMemberData()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!SteamManager.Initialized || !Plugin.TryGetRescueLobby(out var lobbyId) || lobbyId == CSteamID.Nil)
				{
					RestoreAll();
					return;
				}
				CSteamID lobbyOwner = SteamMatchmaking.GetLobbyOwner(lobbyId);
				string text = ((ulong)lobbyOwner).ToString();
				string localSteamId = ((ulong)SteamUser.GetSteamID()).ToString();
				if (!HostVisibilityReceiverPolicy.ShouldConsumeRemoteOwnerState(text, localSteamId))
				{
					ReleaseTrackedStateWithoutRestore("local owner heartbeat ignored");
					return;
				}
				string[] array = (SteamMatchmaking.GetLobbyMemberData(lobbyId, lobbyOwner, "bluesage_visibility_v2") ?? string.Empty).Split(new char[1] { '|' });
				if (array.Length != 4 || array[0] != "v2" || (array[1] != "hide" && array[1] != "show") || !long.TryParse(array[2], out var result) || array[3].Length < 4 || array[3].Length > 16)
				{
					return;
				}
				string text2 = array[3];
				for (int i = 0; i < text2.Length; i++)
				{
					if (!char.IsLetterOrDigit(text2[i]))
					{
						return;
					}
				}
				long num = DateTimeOffset.UtcNow.ToUnixTimeSeconds() - result;
				if (num < -2 || num > 8)
				{
					return;
				}
				_lastReceivedAt = Time.unscaledTime;
				if (array[1] == "show")
				{
					RestoreAll();
					_nextValidationAt = Time.unscaledTime + 0.5f;
					return;
				}
				PlayerPanelController i2 = NetworkSingleton<PlayerPanelController>.I;
				if (i2?.PlayerSteamIDs == null || i2.PlayerTransforms == null)
				{
					return;
				}
				int num2 = -1;
				for (int j = 0; j < i2.PlayerSteamIDs.Count && j < i2.PlayerTransforms.Count; j++)
				{
					if (!string.Equals(i2.PlayerSteamIDs[j], text, StringComparison.Ordinal))
					{
						continue;
					}
					NetworkTransform obj = i2.PlayerTransforms[j];
					Transform val = ((obj != null) ? ((Component)obj).transform : null);
					if ((Object)(object)val == (Object)null || (Object)(object)((Component)val).gameObject == (Object)null || !((Component)val).gameObject.activeInHierarchy)
					{
						continue;
					}
					if (num2 >= 0)
					{
						ManualLogSource log = Plugin.Log;
						if (log != null)
						{
							log.LogDebug((object)"BlueSage hidden visibility poll rejected duplicate active owner rows.");
						}
						return;
					}
					num2 = j;
				}
				if (num2 < 0)
				{
					return;
				}
				NetworkTransform obj2 = i2.PlayerTransforms[num2];
				Transform val2 = ((obj2 != null) ? ((Component)obj2).transform : null);
				if (!((Object)(object)val2 == (Object)null))
				{
					if ((Object)(object)_hostRoot != (Object)(object)val2 || !string.Equals(_ownerSteam, text, StringComparison.Ordinal))
					{
						RestoreAll();
						_hostRoot = val2;
						_ownerSteam = text;
					}
					_ownerSteam = text;
					_lastReceivedAt = Time.unscaledTime;
					HideCurrentVisuals();
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogDebug((object)("BlueSage hidden visibility poll failed closed: " + ex.GetType().Name + ": " + ex.Message));
				}
			}
		}

		private static void HideCurrentVisuals()
		{
			if ((Object)(object)_hostRoot == (Object)null)
			{
				return;
			}
			Renderer[] componentsInChildren = ((Component)_hostRoot).GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null))
				{
					if (!RendererStates.ContainsKey(val))
					{
						RendererStates[val] = val.enabled;
					}
					val.enabled = false;
				}
			}
			PlayerController val2 = ((Component)_hostRoot).GetComponent<PlayerController>() ?? ((Component)_hostRoot).GetComponentInChildren<PlayerController>(true);
			if ((Object)(object)val2 != (Object)null)
			{
				if (PlayerCanvasesField?.GetValue(val2) is List<Canvas> list)
				{
					foreach (Canvas item in list)
					{
						CaptureAndHideCanvas(item);
					}
				}
				object? obj = PlayerCanvasField?.GetValue(val2);
				GameObject val3 = (GameObject)((obj is GameObject) ? obj : null);
				if ((Object)(object)val3 != (Object)null)
				{
					CaptureAndHideCanvas(val3.GetComponent<Canvas>());
				}
				object? obj2 = PlayerNameTextField?.GetValue(val2);
				CaptureAndHideText((TMP_Text)((obj2 is TMP_Text) ? obj2 : null));
				TextBubbleController componentInChildren = ((Component)val2).GetComponentInChildren<TextBubbleController>(true);
				if ((Object)(object)componentInChildren != (Object)null)
				{
					object? obj3 = TextBubbleCanvasField?.GetValue(componentInChildren);
					CaptureAndHideCanvas((Canvas)((obj3 is Canvas) ? obj3 : null));
					object? obj4 = TextBubbleTextField?.GetValue(componentInChildren);
					CaptureAndHideText((TMP_Text)((obj4 is TMP_Text) ? obj4 : null));
					object? obj5 = TextBubbleNameTextField?.GetValue(componentInChildren);
					CaptureAndHideText((TMP_Text)((obj5 is TMP_Text) ? obj5 : null));
				}
			}
			int num = RendererStates.Count + CanvasStates.Count + TextStates.Count;
			if (num != _lastReportedRendererCount)
			{
				_lastReportedRendererCount = num;
				string text = ((_ownerSteam.Length > 4) ? _ownerSteam.Substring(_ownerSteam.Length - 4) : _ownerSteam);
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogDebug((object)("BlueSage hidden visibility receiver: owner *" + text + ", avatar visuals hidden=" + num + "."));
				}
			}
		}

		private static void CaptureAndHideCanvas(Canvas canvas)
		{
			if (!((Object)(object)canvas == (Object)null))
			{
				if (!CanvasStates.ContainsKey(canvas))
				{
					CanvasStates[canvas] = ((Behaviour)canvas).enabled;
				}
				((Behaviour)canvas).enabled = false;
			}
		}

		private static void CaptureAndHideText(TMP_Text text)
		{
			if (!((Object)(object)text == (Object)null))
			{
				if (!TextStates.ContainsKey(text))
				{
					TextStates[text] = ((Behaviour)text).enabled;
				}
				((Behaviour)text).enabled = false;
			}
		}

		internal static void RestoreAll()
		{
			int num = RendererStates.Count + CanvasStates.Count + TextStates.Count;
			foreach (KeyValuePair<Renderer, bool> rendererState in RendererStates)
			{
				if ((Object)(object)rendererState.Key != (Object)null)
				{
					rendererState.Key.enabled = rendererState.Value;
				}
			}
			foreach (KeyValuePair<Canvas, bool> canvasState in CanvasStates)
			{
				if ((Object)(object)canvasState.Key != (Object)null)
				{
					((Behaviour)canvasState.Key).enabled = canvasState.Value;
				}
			}
			foreach (KeyValuePair<TMP_Text, bool> textState in TextStates)
			{
				if ((Object)(object)textState.Key != (Object)null)
				{
					((Behaviour)textState.Key).enabled = textState.Value;
				}
			}
			ClearVisualSnapshots();
			_hostRoot = null;
			_nextValidationAt = 0f;
			_ownerSteam = string.Empty;
			_lastReportedRendererCount = 0;
			if (num > 0)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogDebug((object)("BlueSage hidden visibility receiver: restored=" + num + "."));
				}
			}
		}

		private static void ReleaseTrackedStateWithoutRestore(string reason)
		{
			int num = RendererStates.Count + CanvasStates.Count + TextStates.Count;
			ClearVisualSnapshots();
			_hostRoot = null;
			_ownerSteam = string.Empty;
			_lastReceivedAt = -100f;
			_lastReportedRendererCount = 0;
			if (num > 0)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogDebug((object)("BlueSage hidden visibility receiver: released=" + num + " without replay (" + reason + ")."));
				}
			}
		}

		private static void ClearVisualSnapshots()
		{
			RendererStates.Clear();
			CanvasStates.Clear();
			TextStates.Clear();
		}
	}
	[HarmonyPatch(typeof(TMP_InputField))]
	internal static class InputFieldLimitPatch
	{
		[HarmonyPatch("OnEnable")]
		[HarmonyPostfix]
		private static void OnEnablePostfix(TMP_InputField __instance)
		{
			if (!((Object)(object)__instance == (Object)null))
			{
				int? limit = InputFieldLimitPolicy.GetLimit(((Object)__instance).name, Plugin.LockedMaxIdCardCharacters, Plugin.LockedMaxSessionNameCharacters, Plugin.LockedMaxChatCharacters);
				if (limit.HasValue)
				{
					__instance.characterLimit = limit.Value;
				}
			}
		}
	}
	[HarmonyPatch(typeof(TextChannelManager), "AddMessageUI", new Type[]
	{
		typeof(string),
		typeof(string),
		typeof(bool),
		typeof(int),
		typeof(bool)
	})]
	internal static class MentionHighlighterPatch
	{
		private static readonly Regex MentionRegex = MentionNamePolicy.MentionReferenceRegex;

		[HarmonyPrefix]
		private static void Prefix(ref string text, ref string userName, bool isLocal, int senderIndex)
		{
			if (Plugin.EnablePingMentions == null || !Plugin.EnablePingMentions.Value || string.IsNullOrWhiteSpace(text) || text.StartsWith("/", StringComparison.Ordinal) || senderIndex < 0)
			{
				return;
			}
			try
			{
				string localName = PlayerMentionProvider.GetLocalPlayerName();
				bool shouldPing = false;
				string mentionColor = "#" + Plugin.GetPingMentionColor();
				text = MentionRegex.Replace(text, delegate(Match match)
				{
					string value = match.Groups[1].Value;
					if (string.Equals(value, "lobby", StringComparison.OrdinalIgnoreCase))
					{
						if (!Plugin.IsLobbyMassPingAuthorized(ChatSenderContextPatch.CurrentSenderSteamId))
						{
							return match.Value;
						}
						shouldPing = true;
						return "<size=115%><b><color=" + mentionColor + ">@lobby</color></b></size>";
					}
					string text2 = PlayerMentionProvider.FindBestMentionMatch(value);
					if (string.IsNullOrWhiteSpace(text2))
					{
						return match.Value;
					}
					string text3 = MentionNamePolicy.ToMentionDisplayLabel(text2);
					if (MentionNamePolicy.IsLocalMentionMatch(text2, localName, value))
					{
						shouldPing = true;
					}
					string text4 = (string.IsNullOrWhiteSpace(text3) ? MentionNamePolicy.ToMentionDisplayName(value) : text3);
					return "<size=115%><b><color=" + mentionColor + ">@" + text4 + "</color></b></size>";
				});
				if (shouldPing)
				{
					text = "<mark=#" + Plugin.GetPingHighlightColor() + "30><b><color=" + mentionColor + ">[PING]</color></b> " + text + "</mark>";
					userName = "<b><color=" + mentionColor + ">" + userName + "</color></b>";
					MentionPingController.PlayConfiguredPing();
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Ping Mentions skipped message highlight safely: " + ex.GetType().Name + ": " + ex.Message));
				}
			}
		}
	}
	[HarmonyPatch(typeof(MapManager), "UpdatePosition")]
	internal static class MiniMapPlayerLabelPatch
	{
		private const float RefreshIntervalSeconds = 2f;

		private const float FailureLogRepeatSeconds = 30f;

		private const string MiniMapFriendsGuid = "com.xaviergmail.minimapfriends";

		private static readonly Color FriendColor = new Color(0.24f, 0.86f, 0.35f, 1f);

		private static readonly Dictionary<string, bool> FriendCache = new Dictionary<string, bool>(StringComparer.Ordinal);

		private static readonly Dictionary<int, MiniMapIdCardClickHandler> OwnedHandlersByIconInstanceId = new Dictionary<int, MiniMapIdCardClickHandler>();

		private static readonly FieldInfo PlayerIconsField = AccessTools.Field(typeof(MapManager), "_playerIcons");

		private static float _nextRefreshAt;

		private static float _nextFailureLogAt;

		[HarmonyPostfix]
		private static void Postfix(MapManager __instance)
		{
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance == (Object)null || Time.unscaledTime < _nextRefreshAt)
			{
				return;
			}
			_nextRefreshAt = Time.unscaledTime + 2f;
			try
			{
				if (!(PlayerIconsField?.GetValue(__instance) is List<RectTransform> { Count: not 0 } list))
				{
					return;
				}
				PlayerPanelController i = NetworkSingleton<PlayerPanelController>.I;
				bool flag = Plugin.ShouldApplyMiniMapFriendColors && !Chainloader.PluginInfos.ContainsKey("com.xaviergmail.minimapfriends");
				if ((!Plugin.ShouldApplyMiniMapPlayerLabels && !flag) || (Object)(object)i == (Object)null || i.IDInfos == null || i.PlayerSteamIDs == null || i.PlayerIDs == null || i.PlayerTransforms == null || i.PlayerItemControllers == null)
				{
					SetAllIconEnhancementsEnabled(list, enabled: false);
					return;
				}
				int num = Math.Min(list.Count, Math.Min(i.IDInfos.Count, Math.Min(i.PlayerSteamIDs.Count, Math.Min(i.PlayerIDs.Count, Math.Min(i.PlayerTransforms.Count, i.PlayerItemControllers.Count)))));
				for (int j = 0; j < list.Count; j++)
				{
					RectTransform val = list[j];
					if ((Object)(object)val == (Object)null)
					{
						continue;
					}
					if (j >= num)
					{
						ConfigureIconClick(val, -1, string.Empty, string.Empty, null, null, enabled: false);
						continue;
					}
					string text = i.PlayerSteamIDs[j] ?? string.Empty;
					PlayerID val2 = i.PlayerIDs[j];
					string text2 = PurrNetPlayerIdPolicy.Format(PackedULong.op_Implicit(((PlayerID)(ref val2)).id));
					NetworkTransform val3 = i.PlayerTransforms[j];
					PlayerItemController val4 = i.PlayerItemControllers[j];
					bool flag2 = ModerationProtocolPolicy.IsSteamId64(text) && !string.IsNullOrWhiteSpace(text2) && (Object)(object)val3 != (Object)null && (Object)(object)val4 != (Object)null;
					ConfigureIconClick(val, j, text, text2, val4, val3, Plugin.ShouldApplyMiniMapPlayerLabels && flag2);
					Graphic component = ((Component)val).GetComponent<Graphic>();
					if ((Object)(object)component != (Object)null)
					{
						component.color = ((flag && IsSteamFriendCached(text)) ? FriendColor : Color.white);
						if (flag && component.color == FriendColor)
						{
							((Transform)val).SetAsLastSibling();
						}
					}
				}
			}
			catch (Exception ex)
			{
				if (Time.unscaledTime >= _nextFailureLogAt)
				{
					_nextFailureLogAt = Time.unscaledTime + 30f;
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogWarning((object)("MiniMap ID Click skipped safely: " + ex.GetType().Name + ": " + ex.Message));
					}
				}
			}
		}

		private static bool IsSteamFriendCached(string steamId)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Invalid comparison between Unknown and I4
			if (string.IsNullOrWhiteSpace(steamId))
			{
				return false;
			}
			if (FriendCache.TryGetValue(steamId, out var value))
			{
				return value;
			}
			ulong result;
			bool flag = ulong.TryParse(steamId, out result) && (int)SteamFriends.GetFriendRelationship(new CSteamID(result)) == 3;
			if (FriendCache.Count > 256)
			{
				FriendCache.Clear();
			}
			FriendCache[steamId] = flag;
			return flag;
		}

		private static void ConfigureIconClick(RectTransform icon, int playerIndex, string steamId, string playerId, PlayerItemController expectedRow, NetworkTransform expectedTransform, bool enabled)
		{
			if ((Object)(object)icon == (Object)null)
			{
				return;
			}
			int instanceID = ((Object)((Component)icon).gameObject).GetInstanceID();
			OwnedHandlersByIconInstanceId.TryGetValue(instanceID, out var value);
			if ((Object)(object)value == (Object)null)
			{
				value = ((Component)icon).GetComponent<MiniMapIdCardClickHandler>();
			}
			if (!enabled)
			{
				if ((Object)(object)value != (Object)null)
				{
					value.DisableAndDestroy();
				}
				return;
			}
			if ((Object)(object)value == (Object)null)
			{
				value = ((Component)icon).gameObject.AddComponent<MiniMapIdCardClickHandler>();
			}
			OwnedHandlersByIconInstanceId[instanceID] = value;
			value.SetOwnerIconInstanceId(instanceID);
			value.Configure(playerIndex, steamId, playerId, expectedRow, expectedTransform, enabled);
		}

		internal static void OpenIdCardFromMiniMap(int playerIndex, string steamId, string playerId, PlayerItemController expectedRow, NetworkTransform expectedTransform)
		{
			NativeIdCardController.TryOpen("minimap-id", steamId, playerIndex, playerId, expectedRow, expectedTransform, requireObservedIndex: true);
		}

		private static void SetAllIconEnhancementsEnabled(IEnumerable<RectTransform> icons, bool enabled)
		{
			foreach (RectTransform icon in icons)
			{
				if (!((Object)(object)icon == (Object)null))
				{
					MiniMapIdCardClickHandler component = ((Component)icon).GetComponent<MiniMapIdCardClickHandler>();
					if ((Object)(object)component != (Object)null)
					{
						component.DisableAndDestroy();
					}
				}
			}
		}

		internal static void ClearAll()
		{
			List<MiniMapIdCardClickHandler> list = new List<MiniMapIdCardClickHandler>(OwnedHandlersByIconInstanceId.Values);
			OwnedHandlersByIconInstanceId.Clear();
			foreach (MiniMapIdCardClickHandler item in list)
			{
				if ((Object)(object)item != (Object)null)
				{
					item.DisableAndDestroy();
				}
			}
			FriendCache.Clear();
			_nextRefreshAt = 0f;
			_nextFailureLogAt = 0f;
		}

		internal static void UnregisterOwnedHandler(int iconInstanceId, MiniMapIdCardClickHandler handler)
		{
			if (OwnedHandlersByIconInstanceId.TryGetValue(iconInstanceId, out var value) && (Object)(object)value == (Object)(object)handler)
			{
				OwnedHandlersByIconInstanceId.Remove(iconInstanceId);
			}
		}
	}
	internal sealed class MiniMapIdCardClickHandler : MonoBehaviour, IPointerClickHandler, IEventSystemHandler
	{
		private int _playerIndex = -1;

		private string _steamId = string.Empty;

		private string _playerId = string.Empty;

		private PlayerItemController _expectedRow;

		private NetworkTransform _expectedTransform;

		private bool _enabled;

		private bool _raycastCaptured;

		private bool _originalRaycastTarget;

		private int _ownerIconInstanceId;

		private bool _destroyRequested;

		internal void SetOwnerIconInstanceId(int iconInstanceId)
		{
			_ownerIconInstanceId = iconInstanceId;
		}

		public void Configure(int playerIndex, string steamId, string playerId, PlayerItemController expectedRow, NetworkTransform expectedTransform, bool enabled)
		{
			_playerIndex = playerIndex;
			_steamId = steamId ?? string.Empty;
			_playerId = playerId ?? string.Empty;
			_expectedRow = expectedRow;
			_expectedTransform = expectedTransform;
			_enabled = enabled;
			Graphic component = ((Component)this).GetComponent<Graphic>();
			if (!((Object)(object)component == (Object)null))
			{
				if (!_raycastCaptured)
				{
					_originalRaycastTarget = component.raycastTarget;
					_raycastCaptured = true;
				}
				component.raycastTarget = enabled || _originalRaycastTarget;
			}
		}

		public void OnPointerClick(PointerEventData eventData)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			if (_enabled && eventData != null && (int)eventData.button == 0)
			{
				MiniMapPlayerLabelPatch.OpenIdCardFromMiniMap(_playerIndex, _steamId, _playerId, _expectedRow, _expectedTransform);
			}
		}

		internal void DisableAndDestroy()
		{
			if (!_destroyRequested)
			{
				_enabled = false;
				_playerIndex = -1;
				_steamId = string.Empty;
				_playerId = string.Empty;
				_expectedRow = null;
				_expectedTransform = null;
				Graphic component = ((Component)this).GetComponent<Graphic>();
				if ((Object)(object)component != (Object)null && _raycastCaptured)
				{
					component.raycastTarget = _originalRaycastTarget;
				}
				_destroyRequested = true;
				((Behaviour)this).enabled = false;
				Object.Destroy((Object)(object)this);
			}
		}

		private void OnDestroy()
		{
			Graphic component = ((Component)this).GetComponent<Graphic>();
			if ((Object)(object)component != (Object)null && _raycastCaptured)
			{
				component.raycastTarget = _originalRaycastTarget;
			}
			MiniMapPlayerLabelPatch.UnregisterOwnedHandler(_ownerIconInstanceId, this);
		}
	}
	[HarmonyPatch(typeof(TextChannelManager), "HandleRPCGenerated_0", new Type[]
	{
		typeof(RPCPacket),
		typeof(RPCInfo),
		typeof(bool)
	})]
	internal static class ModerationRelayPatch
	{
		private static bool _legacyPacketWarningLogged;

		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static bool Prefix(RPCPacket packet, RPCInfo info, bool asServer)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			if (!asServer)
			{
				return true;
			}
			bool flag = false;
			BitPacker val = BitPackerPool.Get(false);
			try
			{
				val.WriteBitDataWithoutConsumingIt(packet.data);
				val.ResetPositionAndMode(true);
				byte[] array = null;
				Packer<byte[]>.Read(val, ref array);
				if (array == null || array.Length == 0 || array.Length > 1024)
				{
					return true;
				}
				string text = Encoding.Unicode.GetString(array).Trim();
				if (text.StartsWith("!bsincident:v1:resolve:", StringComparison.Ordinal) || text.StartsWith("!bsmod:v1:", StringComparison.Ordinal))
				{
					flag = true;
					if (!_legacyPacketWarningLogged)
					{
						_legacyPacketWarningLogged = true;
						ManualLogSource log = Plugin.Log;
						if (log != null)
						{
							log.LogWarning((object)"Rejected a legacy chat-shaped BlueSage moderation request. Matching 0.2.0 v3 member-data capability is required; no action was taken and no packet was relayed to public chat.");
						}
					}
					return false;
				}
				return true;
			}
			catch (Exception ex)
			{
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogWarning((object)("Moderation relay decode failed safely: " + ex.GetType().Name + ": " + ex.Message));
				}
				return !flag;
			}
			finally
			{
				val.Dispose();
			}
		}
	}
	[HarmonyPatch(typeof(DataManager), "SaveBanData")]
	internal static class NativeBanAuditPatch
	{
		[HarmonyPostfix]
		private static void SaveBanData_Postfix()
		{
			SessionAuditController.CapturePersistedNativeBanSave();
		}

		[HarmonyFinalizer]
		private static Exception SaveBanData_Finalizer(Exception __exception)
		{
			if (__exception != null)
			{
				SessionAuditController.CancelPersistedModerationAudit();
			}
			return __exception;
		}
	}
	[HarmonyPatch(typeof(NetworkReflection), "ObserversRpc_Original_1")]
	internal static class NetworkReflectionNullGuardPatch
	{
		private static readonly FieldInfo ReflectedValuesField = AccessTools.Field(typeof(NetworkReflection), "_reflectedValues");

		private const int MaximumDistinctDiagnostics = 32;

		private static readonly HashSet<string> ReportedSurfaces = new HashSet<string>(StringComparer.Ordinal);

		[HarmonyPrefix]
		private static bool Prefix(NetworkReflection __instance)
		{
			if ((Object)(object)__instance == (Object)null)
			{
				return false;
			}
			if (ReflectedValuesField?.GetValue(__instance) is ICollection)
			{
				return true;
			}
			string text = (string.IsNullOrWhiteSpace(((Object)__instance).name) ? "<unnamed>" : ((Object)__instance).name.Trim());
			string item = ((object)__instance).GetType().FullName + "|" + text;
			if (ReportedSurfaces.Count < 32 && ReportedSurfaces.Add(item))
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("PurrNet NetworkReflection '" + text + "' received an observer update without initialized reflected values; skipped the impossible update instead of throwing every tick. Repeated instances of the same surface are suppressed."));
				}
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(PlayerMovementController), "Update")]
	internal static class OptInRescuePatch
	{
		private static Transform _ownerTransform;

		private static float _cooldownUntil;

		private static float _hookUntil;

		private static string _authorizedOwnerSteam = string.Empty;

		private static RescueFollowLease _followLease;

		private static float _nextMemberDataPollAt;

		private static float _nextHookForceSyncAt;

		private static readonly HashSet<string> SeenMemberDataNonces = new HashSet<string>(StringComparer.Ordinal);

		private static readonly Queue<string> SeenMemberDataNonceOrder = new Queue<string>();

		internal static bool IsReceiverAvailable
		{
			get
			{
				if ((Object)(object)Plugin.Instance != (Object)null)
				{
					return (Object)(object)NetworkSingleton<TextChannelManager>.I?.MainMovementController != (Object)null;
				}
				return false;
			}
		}

		internal static string Stop()
		{
			_ownerTransform = null;
			_hookUntil = 0f;
			_authorizedOwnerSteam = string.Empty;
			_followLease = default(RescueFollowLease);
			_nextHookForceSyncAt = 0f;
			return "Rescue follow stopped.";
		}

		private static void PollMemberData()
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			if (Time.unscaledTime < _nextMemberDataPollAt)
			{
				return;
			}
			_nextMemberDataPollAt = Time.unscaledTime + 0.25f;
			try
			{
				if (!SteamManager.Initialized || !Plugin.TryGetRescueLobby(out var lobbyId) || lobbyId == CSteamID.Nil)
				{
					return;
				}
				string localSteamId = ((ulong)SteamUser.GetSteamID()).ToString();
				TextChannelManager i = NetworkSingleton<TextChannelManager>.I;
				object obj;
				if (i == null)
				{
					obj = null;
				}
				else
				{
					NetworkTransform mainNetTransform = i.MainNetTransform;
					obj = ((mainNetTransform != null) ? ((NetworkIdentity)mainNetTransform).owner.ToString() : null);
				}
				if (obj == null)
				{
					obj = string.Empty;
				}
				string localPlayerId = (string)obj;
				string text = ((ulong)SteamMatchmaking.GetLobbyOwner(lobbyId)).ToString();
				HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal) { text };
				string[] array = (SteamMatchmaking.GetLobbyData(lobbyId, "bluesage_rescue_helpers") ?? string.Empty).Split(new char[1] { '|' }, 2);
				if (array.Length == 2 && string.Equals(array[0], text, StringComparison.Ordinal))
				{
					string[] array2 = array[1].Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries);
					foreach (string text2 in array2)
					{
						hashSet.Add(text2.Trim());
					}
				}
				CSteamID val = default(CSteamID);
				foreach (string item in hashSet)
				{
					if (ulong.TryParse(item, out var result))
					{
						((CSteamID)(ref val))..ctor(result);
						if (RescueProtocolPolicy.TryParseMemberData(SteamMatchmaking.GetLobbyMemberData(lobbyId, val, "bluesage_rescue_v2"), out var request) && RescueProtocolPolicy.IsLocalTarget(request, localSteamId, localPlayerId) && !SeenMemberDataNonces.Contains(request.Nonce) && RescueProtocolPolicy.IsFresh(request, DateTimeOffset.UtcNow.ToUnixTimeSeconds()) && IsAuthorizedMemberDataSender(lobbyId, text, item) && IsCurrentLobbyMember(lobbyId, val) && RescueProtocolPolicy.ShouldRememberNonce(ApplyMemberDataRequest(lobbyId, text, item, request)))
						{
							RememberNonce(request.Nonce);
						}
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogDebug((object)("BlueSage hidden rescue poll failed closed: " + ex.GetType().Name + ": " + ex.Message));
				}
			}
		}

		private static bool IsCurrentLobbyMember(CSteamID lobby, CSteamID expected)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			int numLobbyMembers = SteamMatchmaking.GetNumLobbyMembers(lobby);
			for (int i = 0; i < numLobbyMembers; i++)
			{
				if (SteamMatchmaking.GetLobbyMemberByIndex(lobby, i) == expected)
				{
					return true;
				}
			}
			return false;
		}

		private static bool IsAuthorizedMemberDataSender(CSteamID lobby, string ownerSteam, string senderSteam)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			if (string.Equals(ownerSteam, senderSteam, StringComparison.Ordinal))
			{
				return true;
			}
			string[] array = (SteamMatchmaking.GetLobbyData(lobby, "bluesage_rescue_helpers") ?? string.Empty).Split(new char[1] { '|' }, 2);
			if (array.Length == 2 && string.Equals(array[0], ownerSteam, StringComparison.Ordinal))
			{
				return Array.IndexOf(array[1].Split(new char[1] { ',' }), senderSteam) >= 0;
			}
			return false;
		}

		private static RescueApplyResult ApplyMemberDataRequest(CSteamID lobby, string ownerSteam, string senderSteam, RescueRequest request)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			if (request.Action == "hooklong" && !string.Equals(SteamMatchmaking.GetLobbyData(lobby, "bluesage_rescue_longhaul"), ownerSteam + "|1", StringComparison.Ordinal))
			{
				return RescueApplyResult.Rejected;
			}
			if (request.Action == "unhook")
			{
				Stop();
				Plugin.AddLocalNotification("BlueSage rescue: lobby owner released follow.");
				return RescueApplyResult.Applied;
			}
			if (Time.unscaledTime < _cooldownUntil)
			{
				return RescueApplyResult.Deferred;
			}
			PlayerPanelController i = NetworkSingleton<PlayerPanelController>.I;
			TextChannelManager i2 = NetworkSingleton<TextChannelManager>.I;
			if (i?.PlayerSteamIDs == null || i.PlayerTransforms == null || (Object)(object)i2?.MainMovementController == (Object)null)
			{
				return RescueApplyResult.Deferred;
			}
			int num = -1;
			int num2 = 0;
			for (int j = 0; j < i.PlayerSteamIDs.Count && j < i.PlayerTransforms.Count; j++)
			{
				if (string.Equals(i.PlayerSteamIDs[j], ownerSteam, StringComparison.Ordinal))
				{
					NetworkTransform obj = i.PlayerTransforms[j];
					Transform val = ((obj != null) ? ((Component)obj).transform : null);
					if (!((Object)(object)val == (Object)null) && !((Object)(object)((Component)val).gameObject == (Object)null) && ((Component)val).gameObject.activeInHierarchy)
					{
						num = j;
						num2++;
					}
				}
			}
			if (num2 != 1 || num < 0)
			{
				return RescueApplyResult.Deferred;
			}
			NetworkTransform obj2 = i.PlayerTransforms[num];
			_ownerTransform = ((obj2 != null) ? ((Component)obj2).transform : null);
			if ((Object)(object)_ownerTransform == (Object)null)
			{
				return RescueApplyResult.Deferred;
			}
			_authorizedOwnerSteam = ownerSteam;
			_followLease = new RescueFollowLease(((ulong)lobby).ToString(), ownerSteam, senderSteam, request.Action == "hooklong");
			_cooldownUntil = Time.unscaledTime + 1f;
			ApplyLocalRescuePosition(i2, _ownerTransform.position + Vector3.right * 1.25f, forceOwnerSync: true);
			_nextHookForceSyncAt = 0f;
			_hookUntil = ((request.Action == "hook") ? (Time.unscaledTime + (float)request.Seconds) : ((request.Action == "hooklong") ? float.PositiveInfinity : 0f));
			Plugin.AddLocalNotification((!(request.Action == "hook") && !(request.Action == "hooklong")) ? "BlueSage rescue: moved near the current lobby owner." : ((request.Action == "hooklong") ? "BlueSage rescue: long-haul follow active until release or disconnect." : $"BlueSage rescue: following the lobby owner for up to {request.Seconds}s."));
			return RescueApplyResult.Applied;
		}

		private static void ApplyLocalRescuePosition(TextChannelManager chat, Vector3 target, bool forceOwnerSync)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)chat?.MainMovementController == (Object)null))
			{
				((Component)chat.MainMovementController).transform.position = target;
				chat.MainMovementController.SpeedY = 0f;
				if ((Object)(object)chat.MainPlayer != (Object)null)
				{
					chat.MainPlayer.position = target;
				}
				if (forceOwnerSync)
				{
					TryForceSyncLocalOwner();
				}
			}
		}

		private static void TryForceSyncLocalOwner()
		{
			try
			{
				TextChannelManager i = NetworkSingleton<TextChannelManager>.I;
				if (i != null)
				{
					NetworkTransform mainNetTransform = i.MainNetTransform;
					if (mainNetTransform != null)
					{
						mainNetTransform.ForceSync();
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogDebug((object)("BlueSage rescue: owner transform sync will fall back to the normal network tick: " + ex.GetType().Name + "."));
				}
			}
		}

		private static void RememberNonce(string nonce)
		{
			if (SeenMemberDataNonces.Add(nonce))
			{
				SeenMemberDataNonceOrder.Enqueue(nonce);
				while (SeenMemberDataNonceOrder.Count > 64)
				{
					SeenMemberDataNonces.Remove(SeenMemberDataNonceOrder.Dequeue());
				}
			}
		}

		[HarmonyPostfix]
		private static void UpdatePostfix(PlayerMovementController __instance)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance != (Object)(object)NetworkSingleton<TextChannelManager>.I?.MainMovementController)
			{
				return;
			}
			PollMemberData();
			HostVisibilityProtocolPatch.Tick();
			PlayerRoleLabelController.Tick();
			if ((Object)(object)_ownerTransform == (Object)null)
			{
				return;
			}
			if (!Plugin.TryGetRescueLobby(out var lobbyId) || lobbyId == CSteamID.Nil)
			{
				Stop();
				return;
			}
			string text = ((ulong)SteamMatchmaking.GetLobbyOwner(lobbyId)).ToString();
			ulong result;
			bool issuerIsCurrentMember = ulong.TryParse(_followLease.IssuerSteamId, out result) && IsCurrentLobbyMember(lobbyId, new CSteamID(result));
			bool issuerIsAuthorized = IsAuthorizedMemberDataSender(lobbyId, text, _followLease.IssuerSteamId);
			bool longHaulIsEnabled = string.Equals(SteamMatchmaking.GetLobbyData(lobbyId, "bluesage_rescue_longhaul"), text + "|1", StringComparison.Ordinal);
			if (!RescueFollowLeasePolicy.IsCurrent(_followLease, ((ulong)lobbyId).ToString(), text, issuerIsCurrentMember, issuerIsAuthorized, longHaulIsEnabled) || !string.Equals(text, _authorizedOwnerSteam, StringComparison.Ordinal))
			{
				Stop();
				return;
			}
			if (Time.unscaledTime > _hookUntil || (Object)(object)((Component)_ownerTransform).gameObject == (Object)null || !((Component)_ownerTransform).gameObject.activeInHierarchy)
			{
				Stop();
				return;
			}
			TextChannelManager i = NetworkSingleton<TextChannelManager>.I;
			bool flag = Time.unscaledTime >= _nextHookForceSyncAt;
			if (flag)
			{
				_nextHookForceSyncAt = Time.unscaledTime + 0.25f;
			}
			ApplyLocalRescuePosition(i, _ownerTransform.position + Vector3.right * 1.25f, flag);
		}
	}
	internal static class PlayerBadgeController
	{
		private const string BadgeStripName = "BlueSage_BadgeStrip";

		private const float MinimumAccessibleFontSize = 14f;

		private const float MaximumAccessibleFontSize = 18f;

		private const float BadgeHorizontalPadding = 0f;

		private const float BadgeSegmentGap = 4f;

		private const float NativeNameBadgeGap = 0f;

		private const float OverflowLaneGap = 2f;

		private const int BadgeCapacity = 7;

		private const float MinimumReadableNativeNameWidth = 160f;

		private const float PollIntervalSeconds = 0.5f;

		private static readonly FieldInfo PlayerNameTextField = AccessTools.Field(typeof(PlayerItemController), "_playerNameText");

		private static readonly Dictionary<int, BlueSagePlayerBadgeMarker> OwnedMarkersByRowInstanceId = new Dictionary<int, BlueSagePlayerBadgeMarker>();

		private static ulong _lobbyKey;

		private static long _lobbyEpoch;

		private static long _evidenceGeneration;

		private static long _companionEvidenceGeneration;

		private static long _badgePresentationGeneration;

		private static string _evidenceFingerprint = string.Empty;

		private static string _companionEvidenceFingerprint = string.Empty;

		private static string _selfLayoutDiagnosticFingerprint = string.Empty;

		private static bool _evidenceContextValid;

		private static bool _companionEvidenceContextValid;

		private static long _requestNonce;

		private static float _nextPollAt;

		internal static void RegisterRow(PlayerItemController row, string playerSteamId)
		{
			if ((Object)(object)row == (Object)null || string.IsNullOrWhiteSpace(playerSteamId))
			{
				return;
			}
			try
			{
				object? obj = PlayerNameTextField?.GetValue(row);
				TMP_Text val = (TMP_Text)((obj is TMP_Text) ? obj : null);
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				RectTransform rectTransform = val.rectTransform;
				if (!((Object)(object)rectTransform == (Object)null) && !((Object)(object)((Transform)rectTransform).parent == (Object)null))
				{
					int instanceID = ((Object)row).GetInstanceID();
					BlueSagePlayerBadgeMarker blueSagePlayerBadgeMarker = FindOwnedMarker(row);
					int instanceID2 = ((Object)rectTransform).GetInstanceID();
					if ((Object)(object)blueSagePlayerBadgeMarker != (Object)null && (!string.Equals(blueSagePlayerBadgeMarker.BoundSteamId, playerSteamId, StringComparison.Ordinal) || blueSagePlayerBadgeMarker.NameAnchorInstanceId != instanceID2 || !blueSagePlayerBadgeMarker.HasLivePresentation(val)))
					{
						DestroyOwnedMarker(blueSagePlayerBadgeMarker);
						blueSagePlayerBadgeMarker = null;
					}
					if ((Object)(object)blueSagePlayerBadgeMarker == (Object)null)
					{
						blueSagePlayerBadgeMarker = CreateOwnedMarker(row, val, rectTransform);
					}
					if (!((Object)(object)blueSagePlayerBadgeMarker == (Object)null))
					{
						blueSagePlayerBadgeMarker.BoundSteamId = playerSteamId;
						blueSagePlayerBadgeMarker.OwnerRow = row;
						blueSagePlayerBadgeMarker.OwnerRowInstanceId = instanceID;
						blueSagePlayerBadgeMarker.NameAnchorInstanceId = instanceID2;
						blueSagePlayerBadgeMarker.BindNativeName(val);
						blueSagePlayerBadgeMarker.Generation++;
						blueSagePlayerBadgeMarker.BeginRowLifecycle();
						((Component)blueSagePlayerBadgeMarker).gameObject.SetActive(true);
						OwnedMarkersByRowInstanceId[instanceID] = blueSagePlayerBadgeMarker;
						RefreshMarker(blueSagePlayerBadgeMarker);
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogDebug((object)("Player badge row registration failed closed: " + ex.GetType().Name));
				}
			}
		}

		internal static void Tick()
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			if (Time.unscaledTime < _nextPollAt)
			{
				return;
			}
			_nextPollAt = Time.unscaledTime + 0.5f;
			try
			{
				if (!TryGetLobby(out var lobby))
				{
					LeaveLobby();
					HideAllPresentations();
					PruneInactivePooledRows();
					return;
				}
				if (!BeginLobby((ulong)lobby) || !PlayerIdentityEvidenceController.TryCaptureCompleteAuthorityEvidenceAndRowsCached((ulong)lobby, out var fingerprint, out var currentRows) || !RefreshEvidenceGeneration(fingerprint))
				{
					RefreshPresentationsWithoutCompleteRoster();
					return;
				}
				PlayerPanelSurfaceController.PruneRowsNotIn(currentRows);
				PruneRowsNotIn(currentRows);
				PruneInactivePooledRows();
				BlueSagePlayerBadgeMarker[] array = OwnedMarkersByRowInstanceId.Values.ToArray();
				for (int i = 0; i < array.Length; i++)
				{
					RefreshMarker(array[i]);
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogDebug((object)("Player badge refresh failed closed: " + ex.GetType().Name));
				}
				InvalidateEvidenceGeneration();
				HideAllPresentations();
			}
		}

		private static void RefreshPresentationsWithoutCompleteRoster()
		{
			InvalidateEvidenceGeneration();
			BeginReadOnlyBadgePresentationContext();
			PruneInactivePooledRows();
			BlueSagePlayerBadgeMarker[] array = OwnedMarkersByRowInstanceId.Values.ToArray();
			for (int i = 0; i < array.Length; i++)
			{
				RefreshMarker(array[i]);
			}
		}

		internal static void PruneInactivePooledRows()
		{
			BlueSagePlayerBadgeMarker[] array = OwnedMarkersByRowInstanceId.Values.ToArray();
			foreach (BlueSagePlayerBadgeMarker blueSagePlayerBadgeMarker in array)
			{
				if ((Object)(object)blueSagePlayerBadgeMarker == (Object)null || (Object)(object)blueSagePlayerBadgeMarker.OwnerRow == (Object)null || (Object)(object)((Component)blueSagePlayerBadgeMarker.OwnerRow).gameObject == (Object)null || !((Component)blueSagePlayerBadgeMarker.OwnerRow).gameObject.activeInHierarchy || !blueSagePlayerBadgeMarker.HasLivePresentation())
				{
					DestroyOwnedMarker(blueSagePlayerBadgeMarker);
				}
			}
		}

		internal static void PruneRowsNotIn(ISet<PlayerItemController> currentRows)
		{
			if (currentRows == null || currentRows.Count == 0)
			{
				return;
			}
			List<int> list = new List<int>();
			foreach (PlayerItemController currentRow in currentRows)
			{
				if ((Object)(object)currentRow == (Object)null || (Object)(object)((Component)currentRow).gameObject == (Object)null)
				{
					return;
				}
				list.Add(((Object)currentRow).GetInstanceID());
			}
			AuthoritativePlayerRowReconciliationPolicy.Reconcile(authoritativeCoverageComplete: true, list, OwnedMarkersByRowInstanceId.Keys.ToArray(), delegate(int rowInstanceId)
			{
				if (!OwnedMarkersByRowInstanceId.TryGetValue(rowInstanceId, out var value) || (Object)(object)value == (Object)null)
				{
					OwnedMarkersByRowInstanceId.Remove(rowInstanceId);
				}
				else
				{
					DestroyOwnedMarker(value);
				}
			});
		}

		internal static void ClearAll()
		{
			BlueSagePlayerBadgeMarker[] array = OwnedMarkersByRowInstanceId.Values.ToArray();
			for (int i = 0; i < array.Length; i++)
			{
				DestroyOwnedMarker(array[i]);
			}
			OwnedMarkersByRowInstanceId.Clear();
			_lobbyKey = 0uL;
			_lobbyEpoch = 0L;
			_evidenceGeneration = 0L;
			_companionEvidenceGeneration = 0L;
			_badgePresentationGeneration = 0L;
			_evidenceFingerprint = string.Empty;
			_companionEvidenceFingerprint = string.Empty;
			_selfLayoutDiagnosticFingerprint = string.Empty;
			_evidenceContextValid = false;
			_companionEvidenceContextValid = false;
			_requestNonce = 0L;
			_nextPollAt = 0f;
			BlueSageExtensionRegistry.ClearAll();
		}

		internal static void UnregisterOwnedMarker(BlueSagePlayerBadgeMarker marker)
		{
			if (!((Object)(object)marker == (Object)null))
			{
				marker.ResetGeometryReadiness();
				int ownerRowInstanceId = marker.OwnerRowInstanceId;
				if (ownerRowInstanceId != 0 && OwnedMarkersByRowInstanceId.TryGetValue(ownerRowInstanceId, out var value) && value == marker)
				{
					OwnedMarkersByRowInstanceId.Remove(ownerRowInstanceId);
				}
			}
		}

		private static bool BeginLobby(ulong lobbyKey)
		{
			if (_lobbyKey == lobbyKey)
			{
				return _lobbyEpoch > 0;
			}
			BlueSageExtensionRegistry.ClearLobbyState();
			_lobbyKey = lobbyKey;
			if (_lobbyEpoch == long.MaxValue)
			{
				_lobbyKey = 0uL;
				_evidenceGeneration = 0L;
				_companionEvidenceGeneration = 0L;
				_badgePresentationGeneration = 0L;
				_evidenceFingerprint = string.Empty;
				_companionEvidenceFingerprint = string.Empty;
				_evidenceContextValid = false;
				_companionEvidenceContextValid = false;
				return false;
			}
			_lobbyEpoch = Math.Max(1L, _lobbyEpoch + 1);
			_evidenceGeneration = 0L;
			_companionEvidenceGeneration = 0L;
			_badgePresentationGeneration = 0L;
			_evidenceFingerprint = string.Empty;
			_companionEvidenceFingerprint = string.Empty;
			_selfLayoutDiagnosticFingerprint = string.Empty;
			_evidenceContextValid = false;
			_companionEvidenceContextValid = false;
			_requestNonce = 0L;
			return true;
		}

		private static void LeaveLobby()
		{
			if (_lobbyKey != 0L)
			{
				_lobbyKey = 0uL;
				_evidenceGeneration = 0L;
				_companionEvidenceGeneration = 0L;
				_badgePresentationGeneration = 0L;
				_evidenceFingerprint = string.Empty;
				_companionEvidenceFingerprint = string.Empty;
				_evidenceContextValid = false;
				_companionEvidenceContextValid = false;
				_requestNonce = 0L;
				BlueSageExtensionRegistry.ClearLobbyState();
			}
		}

		private static void RefreshMarker(BlueSagePlayerBadgeMarker marker)
		{
			string hostLabel = string.Empty;
			if (!IsActive(marker) || !TryBuildEvidence(marker, out var evidence, out hostLabel))
			{
				ApplyPresentation(marker, PlayerBadgePolicy.Compose(default(PlayerBadgeEvidence), 7), string.Empty);
			}
			else
			{
				ApplyPresentation(marker, PlayerBadgePolicy.Compose(evidence, 7), hostLabel, ResolveNativeHostReplacement(marker, evidence));
			}
		}

		private static string ResolveNativeHostReplacement(BlueSagePlayerBadgeMarker marker, PlayerBadgeEvidence evidence)
		{
			if ((Object)(object)marker == (Object)null)
			{
				return string.Empty;
			}
			if (!PlayerHostLabelDisplayPolicy.TrySuppressNativeHostSuffix(marker.GetNativeNameSourceText(), MonoSingleton<SettingsController>.I?.HostString?.String ?? string.Empty, evidence.UniqueExactRow, evidence.OwnerMatchesRow, evidence.NativeHostAgreement, evidence.OwnerPublishedCreatorHostLabelFresh, out var replacement))
			{
				return string.Empty;
			}
			return replacement;
		}

		private static bool TryBuildEvidence(BlueSagePlayerBadgeMarker marker, out PlayerBadgeEvidence evidence, out string hostLabel)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			evidence = default(PlayerBadgeEvidence);
			hostLabel = string.Empty;
			if (!TryGetLobby(out var lobby) || !ulong.TryParse(marker.BoundSteamId, NumberStyles.None, CultureInfo.InvariantCulture, out var result) || !PlayerIdentityEvidenceController.TryResolveExactCached(marker.BoundSteamId, out var evidence2, out var _) || !IsExactCurrentRow(marker.OwnerRow, evidence2))
			{
				return false;
			}
			CSteamID lobbyOwner = SteamMatchmaking.GetLobbyOwner(lobby);
			if (lobbyOwner == CSteamID.Nil)
			{
				return false;
			}
			string text = ((ulong)lobbyOwner).ToString(CultureInfo.InvariantCulture);
			long nowUnixSeconds = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
			bool flag = result == (ulong)lobbyOwner;
			PlayerHostLabelDisplayPolicy.TryResolve(flag ? SteamMatchmaking.GetLobbyMemberData(lobby, lobbyOwner, "bluesage_role_label_v1") : string.Empty, nowUnixSeconds, flag && marker.OwnerRow.IsHost, out hostLabel);
			bool ownerPublishedCreatorHostLabelFresh = flag && marker.OwnerRow.IsHost && !string.IsNullOrWhiteSpace(hostLabel);
			bool moderationCapabilityFresh = ModerationCapabilityPolicy.IsFresh(SteamMatchmaking.GetLobbyData(lobby, "bluesage_qol_moderation"), text, nowUnixSeconds);
			HashSet<string> publishedHelpers = SteamIdModerationController.GetPublishedHelpers(lobby, text);
			bool compatibleHeartbeatFresh = CompatibleClientPresencePolicy.IsFresh(SteamMatchmaking.GetLobbyMemberData(lobby, new CSteamID(result), "bluesage_qol_client_v1"), nowUnixSeconds);
			bool isHost;
			bool localSafetyAuthorized = Plugin.CanUseLobbySafety(out isHost);
			CloneIncidentLedger.GetRoleState(marker.BoundSteamId, out var isVictim, out var isSuspect);
			bool creatorContributionFresh = TryReadCreatorContribution(result, evidence2);
			evidence = new PlayerBadgeEvidence(uniqueExactRow: true, uniqueCurrentMember: true, flag, marker.OwnerRow.IsHost, moderationCapabilityFresh, publishedHelpers.Contains(marker.BoundSteamId), compatibleHeartbeatFresh, Plugin.ShouldApplyCloneShield, localSafetyAuthorized, isVictim, isSuspect, creatorContributionFresh, SupporterBadgeIdentityPolicy.IsRecognizedExactIdentity(marker.BoundSteamId), ownerPublishedCreatorHostLabelFresh);
			return true;
		}

		private static bool TryReadCreatorContribution(ulong rowSteamId, PlayerIdentityEvidence identity)
		{
			long num = (_evidenceContextValid ? _evidenceGeneration : _badgePresentationGeneration);
			if (_lobbyEpoch <= 0 || num <= 0 || identity == null || !TryGetExactPurrNetId(identity, out var purrNetId))
			{
				return false;
			}
			long num2 = Interlocked.Increment(ref _requestNonce);
			if (num2 <= 0)
			{
				Interlocked.Exchange(ref _requestNonce, 1L);
				num2 = 1L;
			}
			long ticks = DateTime.UtcNow.Ticks;
			if (BlueSageExtensionRegistry.TryReadBadgeContribution(new BlueSageBadgeContributionRequestV1(rowSteamId, purrNetId, _lobbyEpoch, num, num2, ticks), ticks, out var response))
			{
				return response.CreatorPresent;
			}
			return false;
		}

		private static void BeginReadOnlyBadgePresentationContext()
		{
			if (_lobbyEpoch <= 0)
			{
				_badgePresentationGeneration = 0L;
				return;
			}
			_badgePresentationGeneration = Math.Max(1L, _badgePresentationGeneration);
			BlueSageExtensionRegistry.BeginBadgePresentation(_lobbyEpoch, _badgePresentationGeneration);
		}

		internal static bool TryResolveFreshLocalCreatorContribution(CSteamID expectedLobby, out bool creatorPresent)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			creatorPresent = false;
			if (!SteamManager.Initialized || expectedLobby == CSteamID.Nil)
			{
				return false;
			}
			CSteamID steamID = SteamUser.GetSteamID();
			if (steamID == CSteamID.Nil || !TryResolveFreshIdentityTruthBySteam((ulong)steamID, out var truth, out var _) || _lobbyKey != (ulong)expectedLobby || truth.SteamId != (ulong)steamID || truth.PurrNetId == 0L || truth.LobbyEpoch != _lobbyEpoch || truth.EvidenceGeneration != _evidenceGeneration)
			{
				return false;
			}
			long num = Interlocked.Increment(ref _requestNonce);
			if (num <= 0)
			{
				Interlocked.Exchange(ref _requestNonce, 1L);
				num = 1L;
			}
			long ticks = DateTime.UtcNow.Ticks;
			if (truth.FreshUntilUtcTicks < ticks)
			{
				return false;
			}
			if (!BlueSageExtensionRegistry.TryReadBadgeContribution(new BlueSageBadgeContributionRequestV1(truth.SteamId, truth.PurrNetId, truth.LobbyEpoch, truth.EvidenceGeneration, num, ticks), ticks, out var response))
			{
				return false;
			}
			creatorPresent = response.CreatorPresent;
			return true;
		}

		private static bool TryGetExactPurrNetId(PlayerIdentityEvidence identity, out ulong purrNetId)
		{
			purrNetId = identity?.PurrNetId ?? 0;
			return purrNetId != 0;
		}

		internal static bool TryResolveFreshIdentityTruth(ulong exactSteamId, ulong exactPurrNetId, out BlueSageIdentityTruthSnapshotV1 truth, out string resultMessage)
		{
			if (!TryResolveFreshIdentityTruthBySteam(exactSteamId, out truth, out resultMessage))
			{
				return false;
			}
			if (exactPurrNetId == 0L || truth.PurrNetId != exactPurrNetId)
			{
				truth = default(BlueSageIdentityTruthSnapshotV1);
				resultMessage = "public QoL exact Steam/PurrNet tuple does not match the current native row";
				return false;
			}
			return true;
		}

		internal static bool TryResolveFreshIdentityTruthBySteam(ulong exactSteamId, out BlueSageIdentityTruthSnapshotV1 truth, out string resultMessage)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			truth = default(BlueSageIdentityTruthSnapshotV1);
			resultMessage = "public QoL exact Steam identity truth is unavailable";
			if (exactSteamId == 0L)
			{
				resultMessage = "public QoL rejected an empty Steam identity";
				return false;
			}
			try
			{
				if (!TryGetLobby(out var lobby) || lobby == CSteamID.Nil)
				{
					LeaveLobby();
					resultMessage = "public QoL has no current Steam lobby";
					return false;
				}
				if (!BeginLobby((ulong)lobby))
				{
					resultMessage = "public QoL could not begin the current lobby identity epoch";
					return false;
				}
				PlayerIdentityEvidence evidence;
				string fingerprint;
				bool contextValid;
				string error;
				bool flag = PlayerIdentityEvidenceController.TryResolveExactWithCompanionFingerprint(exactSteamId.ToString(CultureInfo.InvariantCulture), (ulong)lobby, out evidence, out fingerprint, out contextValid, out error);
				if (!contextValid)
				{
					InvalidateCompanionEvidenceGeneration();
					resultMessage = "public QoL identity context is incomplete: " + error;
					return false;
				}
				if (!RefreshCompanionEvidenceGeneration(fingerprint) || !flag || !TryGetExactPurrNetId(evidence, out var purrNetId))
				{
					resultMessage = (flag ? "public QoL could not publish a fresh identity generation" : ("public QoL could not resolve one exact current native row: " + error));
					return false;
				}
				int num = 0;
				int numLobbyMembers = SteamMatchmaking.GetNumLobbyMembers(lobby);
				for (int i = 0; i < numLobbyMembers; i++)
				{
					if ((ulong)SteamMatchmaking.GetLobbyMemberByIndex(lobby, i) == exactSteamId)
					{
						num++;
					}
				}
				if (num != 1)
				{
					InvalidateCompanionEvidenceGeneration();
					resultMessage = "public QoL Steam membership is not unique for the requested identity";
					return false;
				}
				long ticks = DateTime.UtcNow.Ticks;
				truth = new BlueSageIdentityTruthSnapshotV1(exactSteamId, purrNetId, _lobbyEpoch, _companionEvidenceGeneration, ticks, ticks + 10000000);
				resultMessage = "public QoL exact canonical identity truth resolved";
				return true;
			}
			catch (Exception ex)
			{
				InvalidateCompanionEvidenceGeneration();
				resultMessage = "public QoL exact identity truth failed closed: " + ex.GetType().Name;
				truth = default(BlueSageIdentityTruthSnapshotV1);
				return false;
			}
		}

		private static bool RefreshEvidenceGeneration(string fingerprint)
		{
			return ObserveEvidenceGeneration(fingerprint, observedValid: true);
		}

		private static void InvalidateEvidenceGeneration()
		{
			ObserveEvidenceGeneration(string.Empty, observedValid: false);
		}

		private static bool RefreshCompanionEvidenceGeneration(string fingerprint)
		{
			return ObserveCompanionEvidenceGeneration(fingerprint, observedValid: true);
		}

		private static void InvalidateCompanionEvidenceGeneration()
		{
			ObserveCompanionEvidenceGeneration(string.Empty, observedValid: false);
		}

		private static bool ObserveCompanionEvidenceGeneration(string fingerprint, bool observedValid)
		{
			if (!IdentityEvidenceGenerationPolicy.TryObserve(_companionEvidenceFingerprint, _companionEvidenceGeneration, _companionEvidenceContextValid, fingerprint, observedValid, out var nextFingerprint, out var nextGeneration, out var nextValid, out var changed, out var requiresEpochAdvance))
			{
				if (!requiresEpochAdvance || !TryAdvanceEvidenceEpoch())
				{
					_companionEvidenceContextValid = false;
					return false;
				}
				if (!IdentityEvidenceGenerationPolicy.TryObserve(_companionEvidenceFingerprint, _companionEvidenceGeneration, _companionEvidenceContextValid, fingerprint, observedValid, out nextFingerprint, out nextGeneration, out nextValid, out changed, out var _))
				{
					_companionEvidenceContextValid = false;
					return false;
				}
			}
			_companionEvidenceFingerprint = nextFingerprint;
			_companionEvidenceGeneration = nextGeneration;
			_companionEvidenceContextValid = nextValid;
			return _companionEvidenceContextValid;
		}

		private static bool ObserveEvidenceGeneration(string fingerprint, bool observedValid)
		{
			if (!IdentityEvidenceGenerationPolicy.TryObserve(_evidenceFingerprint, _evidenceGeneration, _evidenceContextValid, fingerprint, observedValid, out var nextFingerprint, out var nextGeneration, out var nextValid, out var changed, out var requiresEpochAdvance))
			{
				if (!requiresEpochAdvance || !TryAdvanceEvidenceEpoch())
				{
					_evidenceContextValid = false;
					BlueSageExtensionRegistry.ClearLobbyState();
					return false;
				}
				if (!IdentityEvidenceGenerationPolicy.TryObserve(_evidenceFingerprint, _evidenceGeneration, _evidenceContextValid, fingerprint, observedValid, out nextFingerprint, out nextGeneration, out nextValid, out changed, out var _))
				{
					_evidenceContextValid = false;
					BlueSageExtensionRegistry.ClearLobbyState();
					return false;
				}
			}
			_evidenceFingerprint = nextFingerprint;
			_evidenceGeneration = nextGeneration;
			_evidenceContextValid = nextValid;
			if (!_evidenceContextValid)
			{
				BlueSageExtensionRegistry.ClearLobbyState();
				return false;
			}
			BlueSageExtensionRegistry.BeginLobby(_lobbyEpoch, _evidenceGeneration);
			return true;
		}

		private static bool TryAdvanceEvidenceEpoch()
		{
			if (_lobbyKey == 0L || _lobbyEpoch == long.MaxValue)
			{
				return false;
			}
			_lobbyEpoch++;
			_evidenceGeneration = 0L;
			_companionEvidenceGeneration = 0L;
			_badgePresentationGeneration = 0L;
			_evidenceFingerprint = string.Empty;
			_companionEvidenceFingerprint = string.Empty;
			_evidenceContextValid = false;
			_companionEvidenceContextValid = false;
			BlueSageExtensionRegistry.ClearLobbyState();
			return true;
		}

		private static bool IsExactCurrentRow(PlayerItemController row, PlayerIdentityEvidence identity)
		{
			PlayerPanelController i = NetworkSingleton<PlayerPanelController>.I;
			int num = identity?.RosterIndex ?? (-1);
			if ((Object)(object)i != (Object)null && i.PlayerItemControllers != null && num >= 0 && num < i.PlayerItemControllers.Count)
			{
				return i.PlayerItemControllers[num] == row;
			}
			return false;
		}

		private static BlueSagePlayerBadgeMarker CreateOwnedMarker(PlayerItemController row, TMP_Text nativeName, RectTransform nameRect)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("BlueSage_BadgeStrip", new Type[5]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(LayoutElement),
				typeof(TextMeshProUGUI),
				typeof(BlueSagePlayerBadgeMarker)
			});
			val.transform.SetParent(((Transform)nameRect).parent, false);
			val.GetComponent<LayoutElement>().ignoreLayout = true;
			BlueSagePlayerBadgeMarker component = val.GetComponent<BlueSagePlayerBadgeMarker>();
			component.OwnerRow = row;
			component.OwnerRowInstanceId = ((Object)row).GetInstanceID();
			component.NameAnchorInstanceId = ((Object)nameRect).GetInstanceID();
			component.BindNativeName(nativeName);
			ConfigureGeometry(component, nameRect, default(PlayerBadgeLayout));
			TextMeshProUGUI component2 = val.GetComponent<TextMeshProUGUI>();
			((TMP_Text)component2).font = nativeName.font;
			((TMP_Text)component2).fontSize = AccessibleFontSize(nativeName.fontSize);
			((TMP_Text)component2).fontStyle = (FontStyles)1;
			((TMP_Text)component2).alignment = (TextAlignmentOptions)4100;
			((TMP_Text)component2).textWrappingMode = (TextWrappingModes)0;
			((TMP_Text)component2).overflowMode = (TextOverflowModes)1;
			((TMP_Text)component2).richText = true;
			((Graphic)component2).raycastTarget = true;
			((TMP_Text)component2).text = string.Empty;
			component.Label = component2;
			GameObject val2 = new GameObject("BlueSage_HostLabel", new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(TextMeshProUGUI)
			});
			val2.transform.SetParent(val.transform, false);
			RectTransform component3 = val2.GetComponent<RectTransform>();
			component3.anchorMin = new Vector2(0f, 0f);
			component3.anchorMax = new Vector2(0f, 1f);
			component3.offsetMin = Vector2.zero;
			component3.offsetMax = Vector2.zero;
			TextMeshProUGUI component4 = val2.GetComponent<TextMeshProUGUI>();
			((TMP_Text)component4).font = nativeName.font;
			((TMP_Text)component4).fontSize = AccessibleFontSize(nativeName.fontSize);
			((TMP_Text)component4).fontStyle = (FontStyles)1;
			((TMP_Text)component4).alignment = (TextAlignmentOptions)4097;
			((TMP_Text)component4).textWrappingMode = (TextWrappingModes)0;
			((TMP_Text)component4).overflowMode = (TextOverflowModes)1;
			((TMP_Text)component4).richText = true;
			((Graphic)component4).raycastTarget = true;
			((TMP_Text)component4).text = string.Empty;
			component.HostLabel = component4;
			return component;
		}

		private static float AccessibleFontSize(float nativeFontSize)
		{
			return Mathf.Clamp(Mathf.Max(nativeFontSize, 14f), 14f, 18f);
		}

		private static void ConfigureGeometry(BlueSagePlayerBadgeMarker marker, RectTransform nameRect, PlayerBadgeLayout layout)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = ((Component)marker).GetComponent<RectTransform>();
			float x = nameRect.anchorMax.x;
			component.anchorMin = new Vector2(x, nameRect.anchorMin.y);
			component.anchorMax = new Vector2(x, nameRect.anchorMax.y);
			component.pivot = new Vector2(1f, nameRect.pivot.y);
			component.offsetMin = new Vector2(nameRect.offsetMax.x - layout.LaneWidth, nameRect.offsetMin.y);
			component.offsetMax = new Vector2(nameRect.offsetMax.x, nameRect.offsetMax.y);
			if ((Object)(object)marker.Label != (Object)null)
			{
				float num = Mathf.Max(0f, layout.LaneWidth - layout.BadgeStart - layout.BadgeWidth);
				((TMP_Text)marker.Label).margin = new Vector4(layout.BadgeStart, 0f, num, 0f);
			}
			TextMeshProUGUI hostLabel = marker.HostLabel;
			RectTransform val = (((Object)(object)hostLabel != (Object)null) ? ((TMP_Text)hostLabel).rectTransform : null);
			if ((Object)(object)val != (Object)null)
			{
				val.anchorMin = new Vector2(0f, 0f);
				val.anchorMax = new Vector2(0f, 1f);
				val.offsetMin = new Vector2(layout.HostStart, 0f);
				val.offsetMax = new Vector2(layout.HostStart + layout.HostWidth, 0f);
			}
		}

		private static void ApplyPresentation(BlueSagePlayerBadgeMarker marker, PlayerBadgePresentation presentation, string hostLabel = "", string nativeHostReplacement = "")
		{
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)marker == (Object)null)
			{
				return;
			}
			if (string.IsNullOrWhiteSpace(nativeHostReplacement))
			{
				marker.RestoreNativeName();
			}
			else
			{
				marker.ApplyNativeNameReplacement(nativeHostReplacement);
			}
			string text = hostLabel ?? string.Empty;
			if (!string.Equals(marker.TooltipText, presentation.TooltipText, StringComparison.Ordinal))
			{
				marker.TooltipText = presentation.TooltipText;
			}
			TextMeshProUGUI label = marker.Label;
			TextMeshProUGUI hostLabel2 = marker.HostLabel;
			TMP_Text nativeName = marker.NativeName;
			if ((Object)(object)label == (Object)null || (Object)(object)hostLabel2 == (Object)null || (Object)(object)nativeName == (Object)null)
			{
				marker.RestoreNativePresentation();
				return;
			}
			if (!string.Equals(((TMP_Text)hostLabel2).text, text, StringComparison.Ordinal))
			{
				((TMP_Text)hostLabel2).text = text;
			}
			bool flag = !string.IsNullOrWhiteSpace(text);
			if (((Behaviour)hostLabel2).enabled != flag)
			{
				((Behaviour)hostLabel2).enabled = flag;
			}
			RectTransform rectTransform = nativeName.rectTransform;
			if ((Object)(object)rectTransform == (Object)null)
			{
				marker.RestoreNativePresentation();
				return;
			}
			Rect rect = rectTransform.rect;
			float width = ((Rect)(ref rect)).width;
			int geometryFingerprint = RectGeometryFingerprint(rectTransform, ((Transform)rectTransform).lossyScale.y);
			if (!marker.ObserveGeometry(width, geometryFingerprint))
			{
				((Behaviour)label).enabled = false;
				((Behaviour)hostLabel2).enabled = false;
				marker.RestoreNativePresentation();
				ConfigureGeometry(marker, rectTransform, default(PlayerBadgeLayout));
				return;
			}
			PlayerBadgeLayoutCacheKey key = CreateLayoutCacheKey((TMP_Text)(object)label, (TMP_Text)(object)hostLabel2, nativeName, rectTransform, presentation.DisplayText, text);
			if (marker.TryGetCachedLayout(key, out var _))
			{
				return;
			}
			int num = Math.Min(7, presentation.AllBadges.Count);
			if (num <= 0 && !flag)
			{
				((TMP_Text)label).text = string.Empty;
				((Behaviour)label).enabled = false;
				marker.RestoreNativePresentation();
				ConfigureGeometry(marker, rectTransform, default(PlayerBadgeLayout));
				marker.StoreCachedLayout(key, default(PlayerBadgeLayout));
				return;
			}
			((TMP_Text)label).margin = Vector4.zero;
			float hostPreferredWidth = (flag ? ((TMP_Text)hostLabel2).GetPreferredValues(((TMP_Text)hostLabel2).text).x : 0f);
			float[] array = new float[num];
			string[] array2 = new string[num];
			for (int i = 1; i <= num; i++)
			{
				array[i - 1] = ((TMP_Text)label).GetPreferredValues(array2[i - 1] = PlayerBadgeRenderPolicy.RenderCompactRichText(PlayerBadgePolicy.Collapse(presentation, i).DisplayText)).x;
			}
			float x = nativeName.GetPreferredValues(nativeName.text ?? string.Empty).x;
			float overflowLaneAvailableWidth = MeasureRightOverflowCapacity(marker.OwnerRow, rectTransform, x);
			PlayerBadgeAllocation allocation = PlayerBadgeLayoutPolicy.ResolveResponsiveAllocation(width, x, Mathf.Min(x, 160f), 0f, hostPreferredWidth, 4f, 0f, array, overflowLaneAvailableWidth);
			EmitSelfLayoutDiagnostic(marker, rectTransform, width, x, hostPreferredWidth, array, overflowLaneAvailableWidth, allocation);
			float ownedLaneWidth = allocation.OwnedLaneWidth;
			int badgeCapacity = allocation.BadgeCapacity;
			string text2 = ((badgeCapacity > 0) ? array2[badgeCapacity - 1] : string.Empty);
			float badgePreferredWidth = ((badgeCapacity > 0) ? array[badgeCapacity - 1] : 0f);
			if (!string.Equals(((TMP_Text)label).text, text2, StringComparison.Ordinal))
			{
				((TMP_Text)label).text = text2;
			}
			bool flag2 = !string.IsNullOrEmpty(text2);
			if (((Behaviour)label).enabled != flag2)
			{
				((Behaviour)label).enabled = flag2;
			}
			PlayerBadgeLayout layout2 = PlayerBadgeLayoutPolicy.Resolve(hostPreferredWidth, badgePreferredWidth, ownedLaneWidth, 0f, 4f, 0f);
			if (layout2.LaneWidth <= 0f)
			{
				marker.RestoreNativePresentation();
				ConfigureGeometry(marker, rectTransform, default(PlayerBadgeLayout));
				marker.StoreCachedLayout(key, default(PlayerBadgeLayout));
				return;
			}
			if (allocation.UseOverflowLane)
			{
				ConfigureOverflowGeometry(marker, rectTransform, layout2, x);
				marker.RestoreNativePresentation();
			}
			else
			{
				ConfigureGeometry(marker, rectTransform, layout2);
				marker.ApplyNativePresentationReservation(layout2.NativeNameReservation);
			}
			marker.StoreCachedLayout(key, layout2);
		}

		private static float MeasureRightOverflowCapacity(PlayerItemController row, RectTransform nameRect, float nativePreferredWidth)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)row == (Object)null || (Object)(object)nameRect == (Object)null)
			{
				return 0f;
			}
			float num = Mathf.Abs(((Transform)nameRect).lossyScale.x);
			if (num <= 0.0001f)
			{
				return 0f;
			}
			Vector3[] array = (Vector3[])(object)new Vector3[4];
			nameRect.GetWorldCorners(array);
			float num2 = array.Min((Vector3 corner) => corner.x) + Mathf.Max(0f, nativePreferredWidth) * num;
			float num3 = float.PositiveInfinity;
			BlueSagePlayerPanelSurfaceMarker componentInChildren = ((Component)row).GetComponentInChildren<BlueSagePlayerPanelSurfaceMarker>(true);
			RectTransform val = (RectTransform)(((Object)(object)componentInChildren != (Object)null) ? /*isinst with value type is only supported in some contexts*/: null);
			if ((Object)(object)val != (Object)null && ((Component)val).gameObject.activeInHierarchy)
			{
				val.GetWorldCorners(array);
				num3 = array.Min((Vector3 corner) => corner.x);
			}
			Button[] componentsInChildren = ((Component)row).GetComponentsInChildren<Button>(true);
			foreach (Button val2 in componentsInChildren)
			{
				RectTransform val3 = (RectTransform)(((Object)(object)val2 != (Object)null) ? /*isinst with value type is only supported in some contexts*/: null);
				if (!((Object)(object)val3 == (Object)null) && ((Component)val2).gameObject.activeInHierarchy)
				{
					val3.GetWorldCorners(array);
					float num5 = array.Min((Vector3 corner) => corner.x);
					if (num5 > num2)
					{
						num3 = Mathf.Min(num3, num5);
					}
				}
			}
			if (float.IsPositiveInfinity(num3))
			{
				Transform transform = ((Component)row).transform;
				RectTransform val4 = (RectTransform)(object)((transform is RectTransform) ? transform : null);
				if ((Object)(object)val4 == (Object)null)
				{
					return 0f;
				}
				val4.GetWorldCorners(array);
				num3 = array.Max((Vector3 corner) => corner.x);
			}
			return Mathf.Max(0f, (num3 - num2) / num - 2f);
		}

		private static void ConfigureOverflowGeometry(BlueSagePlayerBadgeMarker marker, RectTransform nameRect, PlayerBadgeLayout layout, float nativePreferredWidth)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = ((Component)marker).GetComponent<RectTransform>();
			float x = nameRect.anchorMax.x;
			Rect rect = nameRect.rect;
			float num = Mathf.Max(0f, nativePreferredWidth - ((Rect)(ref rect)).width);
			float num2 = nameRect.offsetMax.x + num + 2f;
			component.anchorMin = new Vector2(x, nameRect.anchorMin.y);
			component.anchorMax = new Vector2(x, nameRect.anchorMax.y);
			component.pivot = new Vector2(0f, nameRect.pivot.y);
			component.offsetMin = new Vector2(num2, nameRect.offsetMin.y);
			component.offsetMax = new Vector2(num2 + layout.LaneWidth, nameRect.offsetMax.y);
			if ((Object)(object)marker.Label != (Object)null)
			{
				float num3 = Mathf.Max(0f, layout.LaneWidth - layout.BadgeStart - layout.BadgeWidth);
				((TMP_Text)marker.Label).margin = new Vector4(layout.BadgeStart, 0f, num3, 0f);
			}
			TextMeshProUGUI hostLabel = marker.HostLabel;
			RectTransform val = (((Object)(object)hostLabel != (Object)null) ? ((TMP_Text)hostLabel).rectTransform : null);
			if ((Object)(object)val != (Object)null)
			{
				val.anchorMin = new Vector2(0f, 0f);
				val.anchorMax = new Vector2(0f, 1f);
				val.offsetMin = new Vector2(layout.HostStart, 0f);
				val.offsetMax = new Vector2(layout.HostStart + layout.HostWidth, 0f);
			}
		}

		private static void EmitSelfLayoutDiagnostic(BlueSagePlayerBadgeMarker marker, RectTransform nameRect, float nativeNameWidth, float nativePreferredWidth, float hostPreferredWidth, IReadOnlyList<float> badgePreferredWidths, float overflowLaneAvailableWidth, PlayerBadgeAllocation allocation)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0312: Unknown result type (might be due to invalid IL or missing references)
			//IL_0317: Unknown result type (might be due to invalid IL or missing references)
			//IL_033d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0342: Unknown result type (might be due to invalid IL or missing references)
			//IL_0368: Unknown result type (might be due to invalid IL or missing references)
			//IL_036d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0393: Unknown result type (might be due to invalid IL or missing references)
			//IL_0398: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)marker == (Object)null || (Object)(object)nameRect == (Object)null || string.IsNullOrWhiteSpace(marker.BoundSteamId) || !string.Equals(marker.BoundSteamId, ((ulong)SteamUser.GetSteamID()).ToString(CultureInfo.InvariantCulture), StringComparison.Ordinal))
			{
				return;
			}
			string text = ((badgePreferredWidths == null) ? string.Empty : string.Join(",", badgePreferredWidths.Select((float width) => width.ToString("0.0", CultureInfo.InvariantCulture))));
			string text2 = string.Join("|", nativeNameWidth.ToString("0.0", CultureInfo.InvariantCulture), nativePreferredWidth.ToString("0.0", CultureInfo.InvariantCulture), hostPreferredWidth.ToString("0.0", CultureInfo.InvariantCulture), text, allocation.NativeNameWidth.ToString("0.0", CultureInfo.InvariantCulture), allocation.OwnedLaneWidth.ToString("0.0", CultureInfo.InvariantCulture), allocation.BadgeCapacity.ToString(CultureInfo.InvariantCulture), overflowLaneAvailableWidth.ToString("0.0", CultureInfo.InvariantCulture), allocation.UseOverflowLane ? "1" : "0", nameRect.anchorMin.x.ToString("0.000", CultureInfo.InvariantCulture), nameRect.anchorMax.x.ToString("0.000", CultureInfo.InvariantCulture), nameRect.offsetMin.x.ToString("0.0", CultureInfo.InvariantCulture), nameRect.offsetMax.x.ToString("0.0", CultureInfo.InvariantCulture));
			if (!string.Equals(text2, _selfLayoutDiagnosticFingerprint, StringComparison.Ordinal))
			{
				_selfLayoutDiagnosticFingerprint = text2;
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)("[BlueSagePlayerRowLayout] self=true; nativeWidth=" + nativeNameWidth.ToString("0.0", CultureInfo.InvariantCulture) + "; nativePreferred=" + nativePreferredWidth.ToString("0.0", CultureInfo.InvariantCulture) + "; hostPreferred=" + hostPreferredWidth.ToString("0.0", CultureInfo.InvariantCulture) + "; badgePreferredByCapacity=" + text + "; allocatedName=" + allocation.NativeNameWidth.ToString("0.0", CultureInfo.InvariantCulture) + "; allocatedLane=" + allocation.OwnedLaneWidth.ToString("0.0", CultureInfo.InvariantCulture) + "; badgeCapacity=" + allocation.BadgeCapacity.ToString(CultureInfo.InvariantCulture) + "; overflowAvailable=" + overflowLaneAvailableWidth.ToString("0.0", CultureInfo.InvariantCulture) + "; useOverflow=" + allocation.UseOverflowLane + "; anchor=" + nameRect.anchorMin.x.ToString("0.000", CultureInfo.InvariantCulture) + ".." + nameRect.anchorMax.x.ToString("0.000", CultureInfo.InvariantCulture) + "; offsets=" + nameRect.offsetMin.x.ToString("0.0", CultureInfo.InvariantCulture) + ".." + nameRect.offsetMax.x.ToString("0.0", CultureInfo.InvariantCulture) + "; hierarchy=" + DescribeRectHierarchy(nameRect)));
				}
			}
		}

		private static string DescribeRectHierarchy(RectTransform start)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			List<string> list = new List<string>();
			Transform val = (Transform)(object)start;
			int num = 0;
			while ((Object)(object)val != (Object)null && num < 8)
			{
				RectTransform val2 = (RectTransform)(object)((val is RectTransform) ? val : null);
				if ((Object)(object)val2 == (Object)null)
				{
					list.Add(((Object)val).name + "[non-rect]");
				}
				else
				{
					string[] obj = new string[14]
					{
						((Object)val).name,
						"[w=",
						null,
						null,
						null,
						null,
						null,
						null,
						null,
						null,
						null,
						null,
						null,
						null
					};
					Rect rect = val2.rect;
					obj[2] = ((Rect)(ref rect)).width.ToString("0.0", CultureInfo.InvariantCulture);
					obj[3] = ",x=";
					obj[4] = val2.anchoredPosition.x.ToString("0.0", CultureInfo.InvariantCulture);
					obj[5] = ",a=";
					obj[6] = val2.anchorMin.x.ToString("0.00", CultureInfo.InvariantCulture);
					obj[7] = "..";
					obj[8] = val2.anchorMax.x.ToString("0.00", CultureInfo.InvariantCulture);
					obj[9] = ",o=";
					obj[10] = val2.offsetMin.x.ToString("0.0", CultureInfo.InvariantCulture);
					obj[11] = "..";
					obj[12] = val2.offsetMax.x.ToString("0.0", CultureInfo.InvariantCulture);
					obj[13] = "]";
					list.Add(string.Concat(obj));
				}
				num++;
				val = val.parent;
			}
			return string.Join(" <- ", list);
		}

		private static PlayerBadgeLayoutCacheKey CreateLayoutCacheKey(TMP_Text badgeLabel, TMP_Text hostLabel, TMP_Text nativeName, RectTransform nameRect, string badgeText, string hostText)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			Canvas componentInParent = ((Component)nameRect).GetComponentInParent<Canvas>();
			float num = (((Object)(object)componentInParent != (Object)null) ? componentInParent.scaleFactor : 1f);
			Vector3 lossyScale = ((Transform)nameRect).lossyScale;
			float scale = num * Mathf.Abs(lossyScale.x);
			int hash = 17;
			AddFingerprint(ref hash, TextMeasurementFingerprint(badgeLabel));
			AddFingerprint(ref hash, TextMeasurementFingerprint(hostLabel));
			AddFingerprint(ref hash, TextMeasurementFingerprint(nativeName));
			int geometryFingerprint = RectGeometryFingerprint(nameRect, lossyScale.y);
			string nativeText = nativeName.text ?? string.Empty;
			int measurementFingerprint = hash;
			Rect rect = nameRect.rect;
			return new PlayerBadgeLayoutCacheKey(badgeText, hostText, nativeText, measurementFingerprint, geometryFingerprint, ((Rect)(ref rect)).width, scale);
		}

		private static int TextMeasurementFingerprint(TMP_Text text)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected I4, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected I4, but got Unknown
			int hash = 17;
			TMP_FontAsset font = text.font;
			Material fontSharedMaterial = text.fontSharedMaterial;
			AddFingerprint(ref hash, ((Object)(object)font != (Object)null) ? ((Object)font).GetInstanceID() : 0);
			AddFingerprint(ref hash, ((Object)(object)fontSharedMaterial != (Object)null) ? ((Object)fontSharedMaterial).GetInstanceID() : 0);
			AddFingerprint(ref hash, text.fontSize);
			AddFingerprint(ref hash, (int)text.fontStyle);
			AddFingerprint(ref hash, (int)text.fontWeight);
			AddFingerprint(ref hash, text.characterSpacing);
			AddFingerprint(ref hash, text.wordSpacing);
			AddFingerprint(ref hash, text.enableAutoSizing ? 1 : 0);
			AddFingerprint(ref hash, text.fontSizeMin);
			AddFingerprint(ref hash, text.fontSizeMax);
			AddFingerprint(ref hash, text.richText ? 1 : 0);
			return hash;
		}

		private static int RectGeometryFingerprint(RectTransform rect, float lossyScaleY)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			int hash = 17;
			AddFingerprint(ref hash, rect.anchorMin.x);
			AddFingerprint(ref hash, rect.anchorMin.y);
			AddFingerprint(ref hash, rect.anchorMax.x);
			AddFingerprint(ref hash, rect.anchorMax.y);
			AddFingerprint(ref hash, rect.pivot.x);
			AddFingerprint(ref hash, rect.pivot.y);
			AddFingerprint(ref hash, rect.offsetMin.x);
			AddFingerprint(ref hash, rect.offsetMin.y);
			AddFingerprint(ref hash, rect.offsetMax.x);
			AddFingerprint(ref hash, rect.offsetMax.y);
			Rect rect2 = rect.rect;
			AddFingerprint(ref hash, ((Rect)(ref rect2)).height);
			AddFingerprint(ref hash, lossyScaleY);
			return hash;
		}

		private static void AddFingerprint(ref int hash, int value)
		{
			hash = hash * 31 + value;
		}

		private static void AddFingerprint(ref int hash, float value)
		{
			AddFingerprint(ref hash, value.GetHashCode());
		}

		private static BlueSagePlayerBadgeMarker FindOwnedMarker(PlayerItemController row)
		{
			int instanceID = ((Object)row).GetInstanceID();
			if (OwnedMarkersByRowInstanceId.TryGetValue(instanceID, out var value))
			{
				if ((Object)(object)value != (Object)null && !value.IsRetired && (Object)(object)value.OwnerRow != (Object)null && value.OwnerRow == row)
				{
					return value;
				}
				OwnedMarkersByRowInstanceId.Remove(instanceID);
			}
			return ((Component)row).GetComponentsInChildren<BlueSagePlayerBadgeMarker>(true).FirstOrDefault((BlueSagePlayerBadgeMarker candidate) => (Object)(object)candidate != (Object)null && !candidate.IsRetired && (Object)(object)candidate.OwnerRow != (Object)null && candidate.OwnerRow == row);
		}

		private static void DestroyOwnedMarker(BlueSagePlayerBadgeMarker marker)
		{
			if (!((Object)(object)marker == (Object)null))
			{
				marker.IsRetired = true;
				UnregisterOwnedMarker(marker);
				((Component)marker).gameObject.SetActive(false);
				Object.Destroy((Object)(object)((Component)marker).gameObject);
			}
		}

		private static void HideAllPresentations()
		{
			PlayerBadgePresentation presentation = PlayerBadgePolicy.Compose(default(PlayerBadgeEvidence), 7);
			BlueSagePlayerBadgeMarker[] array = OwnedMarkersByRowInstanceId.Values.ToArray();
			for (int i = 0; i < array.Length; i++)
			{
				ApplyPresentation(array[i], presentation);
			}
		}

		private static bool IsActive(BlueSagePlayerBadgeMarker marker)
		{
			if ((Object)(object)marker != (Object)null && (Object)(object)marker.OwnerRow != (Object)null && (Object)(object)((Component)marker.OwnerRow).gameObject != (Object)null && ((Component)marker.OwnerRow).gameObject.activeInHierarchy)
			{
				return marker.HasLivePresentation();
			}
			return false;
		}

		private static bool TryGetLobby(out CSteamID lobby)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			lobby = CSteamID.Nil;
			if (SteamManager.Initialized && Plugin.TryGetRescueLobby(out lobby))
			{
				return lobby != CSteamID.Nil;
			}
			return false;
		}
	}
	internal sealed class BlueSageIdentityRoleHighlightMarker : MonoBehaviour
	{
		internal Outline Effect;
	}
	internal static class PlayerIdentityRoleHighlightController
	{
		private static readonly Color VictimColor = new Color(0.2f, 0.82f, 0.92f, 1f);

		private static readonly Color SuspectColor = new Color(1f, 0.43f, 0.18f, 1f);

		private static readonly Color BothColor = new Color(0.72f, 0.46f, 0.94f, 1f);

		private static readonly FieldInfo PlayerSteamIdField = AccessTools.Field(typeof(PlayerItemController), "_playerSteamId");

		private static readonly FieldInfo SteamButtonField = AccessTools.Field(typeof(PlayerItemController), "_steamButton");

		internal static void RefreshAll()
		{
			try
			{
				PlayerPanelController i = NetworkSingleton<PlayerPanelController>.I;
				if (((i != null) ? i.PlayerItemControllers : null) == null)
				{
					return;
				}
				bool isHost;
				bool flag = Plugin.ShouldApplyCloneShield && Plugin.ShouldApplyEnhancedPlayerPanel && Plugin.CanUseLobbySafety(out isHost);
				HashSet<string> verifiedSteamIds = (flag ? PlayerIdentityEvidenceController.GetVerifiedCurrentSteamIdSetCached() : null);
				foreach (PlayerItemController playerItemController in i.PlayerItemControllers)
				{
					RefreshRow(playerItemController, flag, verifiedSteamIds);
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogDebug((object)("Clone Shield role highlights refreshed safely with partial results: " + ex.GetType().Name + ": " + ex.Message));
				}
			}
		}

		internal static void RefreshRows(IReadOnlyCollection<string> targetedSteamIds)
		{
			if (targetedSteamIds == null || targetedSteamIds.Count == 0)
			{
				return;
			}
			try
			{
				PlayerPanelController i = NetworkSingleton<PlayerPanelController>.I;
				if (((i != null) ? i.PlayerItemControllers : null) == null)
				{
					return;
				}
				HashSet<string> hashSet = new HashSet<string>(targetedSteamIds, StringComparer.Ordinal);
				bool isHost;
				bool flag = Plugin.ShouldApplyCloneShield && Plugin.ShouldApplyEnhancedPlayerPanel && Plugin.CanUseLobbySafety(out isHost);
				HashSet<string> verifiedSteamIds = (flag ? PlayerIdentityEvidenceController.GetVerifiedCurrentSteamIdSetCached() : null);
				foreach (PlayerItemController playerItemController in i.PlayerItemControllers)
				{
					string item = (PlayerSteamIdField?.GetValue(playerItemController) as string) ?? string.Empty;
					if (hashSet.Contains(item))
					{
						RefreshRow(playerItemController, flag, verifiedSteamIds);
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogDebug((object)("Clone Shield targeted identity-row highlights refreshed safely with partial results: " + ex.GetType().Name + ": " + ex.Message));
				}
			}
		}

		internal static void RefreshRowsFromAlreadyAvailableSnapshot(IReadOnlyCollection<string> targetedSteamIds)
		{
			if (targetedSteamIds == null || targetedSteamIds.Count == 0)
			{
				return;
			}
			try
			{
				PlayerPanelController i = NetworkSingleton<PlayerPanelController>.I;
				if (((i != null) ? i.PlayerItemControllers : null) == null)
				{
					return;
				}
				HashSet<string> hashSet = new HashSet<string>(targetedSteamIds, StringComparer.Ordinal);
				bool isHost;
				bool flag = Plugin.ShouldApplyCloneShield && Plugin.ShouldApplyEnhancedPlayerPanel && Plugin.CanUseLobbySafety(out isHost);
				HashSet<string> verifiedSteamIds = (flag ? PlayerIdentityEvidenceController.GetVerifiedCurrentSteamIdSetAlreadyCached() : null);
				foreach (PlayerItemController playerItemController in i.PlayerItemControllers)
				{
					string item = (PlayerSteamIdField?.GetValue(playerItemController) as string) ?? string.Empty;
					if (hashSet.Contains(item))
					{
						RefreshRow(playerItemController, flag, verifiedSteamIds);
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogDebug((object)("Clone Shield cached identity-row refresh failed safely: " + ex.GetType().Name + ": " + ex.Message));
				}
			}
		}

		internal static void ClearAll()
		{
			try
			{
				PlayerPanelController i = NetworkSingleton<PlayerPanelController>.I;
				if (((i != null) ? i.PlayerItemControllers : null) == null)
				{
					return;
				}
				foreach (PlayerItemController playerItemController in i.PlayerItemControllers)
				{
					RefreshRow(playerItemController, applyHighlights: false, null);
				}
			}
			catch
			{
			}
		}

		internal static void RefreshInitializedRow(PlayerItemController row)
		{
			if (!((Object)(object)row == (Object)null))
			{
				bool isHost;
				bool applyHighlights = Plugin.ShouldApplyCloneShield && Plugin.ShouldApplyEnhancedPlayerPanel && Plugin.CanUseLobbySafety(out isHost);
				RefreshRow(row, applyHighlights, null);
			}
		}

		internal static Color GetRoleTextColor(string steamId, Color fallback)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.ShouldApplyCloneShield || !Plugin.CanUseLobbySafety(out var _))
			{
				return fallback;
			}
			CloneIncidentLedger.GetRoleState(steamId, out var isVictim, out var isSuspect);
			if (isVictim && isSuspect)
			{
				return BothColor;
			}
			if (isVictim)
			{
				return VictimColor;
			}
			if (isSuspect)
			{
				return SuspectColor;
			}
			return fallback;
		}

		internal static string GetRoleHeader(string steamId)
		{
			if (!Plugin.ShouldApplyCloneShield || !Plugin.CanUseLobbySafety(out var _))
			{
				return "Steam Profile • VERIFIED";
			}
			CloneIncidentLedger.GetRoleState(steamId, out var isVictim, out var isSuspect);
			if (isVictim && isSuspect)
			{
				return "Steam Profile • INCIDENT ROLES";
			}
			if (isVictim)
			{
				return "Steam Profile • PROTECTED VICTIM";
			}
			if (isSuspect)
			{
				return "Steam Profile • SUSPECT — VERIFY";
			}
			return "Steam Profile • VERIFIED";
		}

		private static void RefreshRow(PlayerItemController row, bool applyHighlights, HashSet<string> verifiedSteamIds)
		{
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)row == (Object)null)
			{
				return;
			}
			string text = (PlayerSteamIdField?.GetValue(row) as string) ?? string.Empty;
			CloneIncidentLedger.GetRoleState(text, out var isVictim, out var isSuspect);
			if (!applyHighlights || (!isVictim && !isSuspect))
			{
				RemoveMarker(((Component)row).transform);
				return;
			}
			if (!(verifiedSteamIds?.Contains(text) ?? PlayerIdentityEvidenceController.TryResolveExactCached(text, out var _, out var _)))
			{
				isVictim = false;
				isSuspect = false;
			}
			Transform val = FindSteamProfileButton(((Component)row).transform);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			BlueSageIdentityRoleHighlightMarker blueSageIdentityRoleHighlightMarker = ((Component)val).GetComponent<BlueSageIdentityRoleHighlightMarker>();
			if (!isVictim && !isSuspect)
			{
				if ((Object)(object)blueSageIdentityRoleHighlightMarker?.Effect != (Object)null)
				{
					Object.Destroy((Object)(object)blueSageIdentityRoleHighlightMarker.Effect);
				}
				if ((Object)(object)blueSageIdentityRoleHighlightMarker != (Object)null)
				{
					Object.Destroy((Object)(object)blueSageIdentityRoleHighlightMarker);
				}
				return;
			}
			if ((Object)(object)blueSageIdentityRoleHighlightMarker == (Object)null)
			{
				blueSageIdentityRoleHighlightMarker = ((Component)val).gameObject.AddComponent<BlueSageIdentityRoleHighlightMarker>();
			}
			if ((Object)(object)blueSageIdentityRoleHighlightMarker.Effect == (Object)null)
			{
				blueSageIdentityRoleHighlightMarker.Effect = ((Component)val).gameObject.AddComponent<Outline>();
			}
			((Shadow)blueSageIdentityRoleHighlightMarker.Effect).effectColor = ((isVictim && isSuspect) ? BothColor : (isVictim ? VictimColor : SuspectColor));
			((Shadow)blueSageIdentityRoleHighlightMarker.Effect).effectDistance = new Vector2(3f, -3f);
			((Shadow)blueSageIdentityRoleHighlightMarker.Effect).useGraphicAlpha = false;
		}

		private static void RemoveMarker(Transform row)
		{
			Transform val = FindSteamProfileButton(row);
			if (!((Object)(object)val == (Object)null))
			{
				BlueSageIdentityRoleHighlightMarker component = ((Component)val).GetComponent<BlueSageIdentityRoleHighlightMarker>();
				if ((Object)(object)component?.Effect != (Object)null)
				{
					Object.Destroy((Object)(object)component.Effect);
				}
				if ((Object)(object)component != (Object)null)
				{
					Object.Destroy((Object)(object)component);
				}
			}
		}

		private static Transform FindSteamProfileButton(Transform row)
		{
			if ((Object)(object)row == (Object)null)
			{
				return null;
			}
			PlayerItemController component = ((Component)row).GetComponent<PlayerItemController>();
			object? obj = SteamButtonField?.GetValue(component);
			Button val = (Button)((obj is Button) ? obj : null);
			if ((Object)(object)val != (Object)null)
			{
				return ((Component)val).transform;
			}
			return (from button in ((Component)row).GetComponentsInChildren<Button>(true)
				select ((Component)button).transform).FirstOrDefault((Func<Transform, bool>)delegate(Transform transform)
			{
				string text = ((Object)transform).name ?? string.Empty;
				return text.IndexOf("friend", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("steam", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("profile", StringComparison.OrdinalIgnoreCase) >= 0;
			});
		}
	}
	[HarmonyPatch(typeof(PlayerPanelController), "OpenButtonInfoPopup")]
	internal static class PlayerIdentityTooltipPatch
	{
		private static bool _defaultPanelSizeCaptured;

		private static int _capturedPanelInstanceId;

		private static Vector2 _defaultPanelSize;

		private static TextWrappingModes _defaultWrappingMode;

		private static TextOverflowModes _defaultOverflowMode;

		private static bool _defaultAutoSizing;

		private static float _defaultBodyFontSize;

		private static float _defaultFontSizeMin;

		private static float _defaultFontSizeMax;

		private static Color _defaultHeaderColor;

		[HarmonyPrefix]
		private static void Prefix(PlayerPanelController __instance)
		{
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			object? obj = AccessTools.Field(typeof(PlayerPanelController), "_buttonInfoPanelTransfrom")?.GetValue(__instance);
			RectTransform val = (RectTransform)((obj is RectTransform) ? obj : null);
			object? obj2 = AccessTools.Field(typeof(PlayerPanelController), "_buttonInfoHeaderText")?.GetValue(__instance);
			TMP_Text val2 = (TMP_Text)((obj2 is TMP_Text) ? obj2 : null);
			object? obj3 = AccessTools.Field(typeof(PlayerPanelController), "_buttonInfoText")?.GetValue(__instance);
			TMP_Text val3 = (TMP_Text)((obj3 is TMP_Text) ? obj3 : null);
			if (!((Object)(object)val == (Object)null) && !((Object)(object)val2 == (Object)null) && !((Object)(object)val3 == (Object)null))
			{
				int instanceID = ((Object)val).GetInstanceID();
				if (!_defaultPanelSizeCaptured || instanceID != _capturedPanelInstanceId)
				{
					_capturedPanelInstanceId = instanceID;
					_defaultPanelSize = val.sizeDelta;
					_defaultWrappingMode = val3.textWrappingMode;
					_defaultOverflowMode = val3.overflowMode;
					_defaultAutoSizing = val3.enableAutoSizing;
					_defaultBodyFontSize = val3.fontSize;
					_defaultFontSizeMin = val3.fontSizeMin;
					_defaultFontSizeMax = val3.fontSizeMax;
					_defaultHeaderColor = ((Graphic)val2).color;
					_defaultPanelSizeCaptured = true;
				}
				else
				{
					val.sizeDelta = _defaultPanelSize;
					val3.textWrappingMode = _defaultWrappingMode;
					val3.overflowMode = _defaultOverflowMode;
					val3.enableAutoSizing = _defaultAutoSizing;
					val3.fontSize = _defaultBodyFontSize;
					val3.fontSizeMin = _defaultFontSizeMin;
					val3.fontSizeMax = _defaultFontSizeMax;
					((Graphic)val2).color = _defaultHeaderColor;
				}
			}
		}

		[HarmonyPostfix]
		private static void Postfix(PlayerPanelController __instance, PlayerPanelButtonType buttonType, RectTransform buttonTransform)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.ShouldApplyEnhancedPlayerPanel || (Object)(object)__instance == (Object)null || (Object)(object)buttonTransform == (Object)null || (int)buttonType != 0)
			{
				return;
			}
			try
			{
				PlayerItemController componentInParent = ((Component)buttonTransform).GetComponentInParent<PlayerItemController>();
				string steamId = (AccessTools.Field(typeof(PlayerItemController), "_playerSteamId")?.GetValue(componentInParent) as string) ?? string.Empty;
				object? obj = AccessTools.Field(typeof(PlayerPanelController), "_buttonInfoHeaderText")?.GetValue(__instance);
				TMP_Text val = (TMP_Text)((obj is TMP_Text) ? obj : null);
				object? obj2 = AccessTools.Field(typeof(PlayerPanelController), "_buttonInfoText")?.GetValue(__instance);
				TMP_Text val2 = (TMP_Text)((obj2 is TMP_Text) ? obj2 : null);
				if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null)
				{
					return;
				}
				ExpandProfilePopup(__instance, val2);
				bool isHost;
				bool flag = Plugin.CanUseLobbySafety(out isHost);
				if (PlayerIdentityEvidenceController.TryResolveExactCached(steamId, out var evidence, out var error))
				{
					if (!flag)
					{
						val.text = "Steam Profile • LIVE";
						((Graphic)val).color = Color.white;
						val2.text = "Current Steam-lobby member.\nClick to open profile; QoL is not required.";
						return;
					}
					string roleHeader = PlayerIdentityRoleHighlightController.GetRoleHeader(steamId);
					val.text = (string.IsNullOrWhiteSpace(roleHeader) ? "Steam Profile • VERIFIED" : roleHeader);
					((Graphic)val).color = PlayerIdentityRoleHighlightController.GetRoleTextColor(steamId, Color.white);
					val2.text = "SteamID64: " + evidence.SteamId + "\nVerified live row #" + (evidence.RosterIndex + 1) + " • PlayerID " + Compact(evidence.NetworkPlayerId, 12) + "\nSteam: " + Compact(evidence.SteamPersona, 24) + " • " + BuildCompactRoleSummary(evidence) + "\nClick profile • HOME > Lobby Safety to review or clear flags.";
				}
				else
				{
					bool flag2 = error.StartsWith("left/stale", StringComparison.OrdinalIgnoreCase);
					bool flag3 = error.StartsWith("live/steam-check", StringComparison.OrdinalIgnoreCase);
					val.text = (flag2 ? "Steam Profile • LEFT / STALE" : (flag3 ? "Steam Profile • LIVE / STEAM CHECK" : "Steam Profile • CHECKING"));
					((Graphic)val).color = Color.white;
					val2.text = (flag2 ? "Player-history row; not in the current lobby.\nProfile opens, but moderation stays locked." : (flag3 ? "Live game/PurrNet row; this SteamID is absent from current Steam lobby membership.\nProfile opens; identity-sensitive actions remain locked." : "Live identity is still syncing.\nReopen the player list before using this row."));
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogDebug((object)("Steam-profile identity tooltip skipped safely: " + ex.GetType().Name + ": " + ex.Message));
				}
			}
		}

		private static void ExpandProfilePopup(PlayerPanelController instance, TMP_Text body)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			object? obj = AccessTools.Field(typeof(PlayerPanelController), "_buttonInfoPanelTransfrom")?.GetValue(instance);
			RectTransform val = (RectTransform)((obj is RectTransform) ? obj : null);
			if ((Object)(object)val != (Object)null)
			{
				val.sizeDelta = new Vector2(Mathf.Max(val.sizeDelta.x, 390f), Mathf.Max(val.sizeDelta.y, 156f));
			}
			body.textWrappingMode = (TextWrappingModes)1;
			body.overflowMode = (TextOverflowModes)1;
			body.enableAutoSizing = true;
			body.fontSizeMin = 12f;
			body.fontSizeMax = Mathf.Min(body.fontSizeMax, 20f);
		}

		private static string Compact(string value, int maximum)
		{
			string text = (value ?? string.Empty).Replace("\r", " ").Replace("\n", " ").Trim();
			if (text.Length > maximum)
			{
				return text.Substring(0, maximum - 1) + "…";
			}
			return text;
		}

		private static string BuildCompactRoleSummary(PlayerIdentityEvidence evidence)
		{
			string[] array = (from role in (evidence.Role ?? string.Empty).Split(new char[1] { '•' })
				select role.Trim() into role
				where role.Length > 0 && !role.StartsWith("VICTIM", StringComparison.Ordinal) && !role.StartsWith("SUSPECT", StringComparison.Ordinal)
				select role).ToArray();
			int num = CloneIncidentLedger.Snapshot.Count((CloneIncident item) => string.Equals(item.VictimSteamId, evidence.SteamId, StringComparison.Ordinal));
			int num2 = CloneIncidentLedger.Snapshot.Count((CloneIncident item) => string.Equals(item.SuspectSteamId, evidence.SteamId, StringComparison.Ordinal));
			string text = ((array.Length == 0) ? "PLAYER" : string.Join("/", array));
			if (num + num2 != 0)
			{
				return text + " • flags V" + num + "/S" + num2;
			}
			return text;
		}
	}
	[HarmonyPatch(typeof(PlayerData), "GetPlayerIdInfo")]
	internal static class PlayerIdInfoLimitPatch
	{
		internal const int VanillaSafeMaxCharacters = 1000;

		internal static bool HasExpectedCoverage { get; private set; }

		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> GetPlayerIdInfoTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			int replacedVanillaIdCardCaps = 0;
			foreach (CodeInstruction instruction in instructions)
			{
				if (instruction.opcode == OpCodes.Ldc_I4 && instruction.operand is int num && num == 1000)
				{
					replacedVanillaIdCardCaps++;
					yield return new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(PlayerIdInfoLimitPatch), "GetMaxIdCardCharacters", (Type[])null, (Type[])null));
				}
				else
				{
					yield return instruction;
				}
			}
			HasExpectedCoverage = replacedVanillaIdCardCaps == 6;
			if (!HasExpectedCoverage)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)$"ID-card text limit patch expected 6 vanilla 1000-character caps but replaced {replacedVanillaIdCardCaps}.");
				}
			}
		}

		private static int GetMaxIdCardCharacters()
		{
			return Plugin.LockedMaxIdCardCharacters;
		}
	}
	[HarmonyPatch(typeof(PlayerPanelController))]
	internal static class PlayerLeftPatch
	{
		[HarmonyPatch("DespawnHandle")]
		[HarmonyPrefix]
		private static void DespawnHandlePrefix(NetworkTransform netTransform, PlayerPanelController __instance)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			PlayerIdentityEvidenceController.InvalidateRosterCache();
			if (!Plugin.ShouldApplyLeaveNotifications || (Object)(object)__instance == (Object)null || (Object)(object)netTransform == (Object)null)
			{
				return;
			}
			try
			{
				int num = Math.Min(__instance.PlayerTransforms.Count, __instance.IDInfos.Count);
				for (int i = 0; i < num; i++)
				{
					if (!((Object)(object)__instance.PlayerTransforms[i] != (Object)(object)netTransform))
					{
						byte[] name = __instance.IDInfos[i].Name;
						string text = ((name == null) ? "Someone" : Encoding.Unicode.GetString(name));
						if (string.IsNullOrWhiteSpace(text))
						{
							text = "Someone";
						}
						Plugin.AddLocalNotification(text + " has left the server.");
						break;
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Leave notification skipped: " + ex.GetType().Name + ": " + ex.Message));
				}
			}
		}
	}
	internal static class PlayerPanelSurfaceController
	{
		private const string LaneName = "BlueSage_ActionLane";

		private const int HierarchyDiagnosticMaximumEntries = 128;

		private const float HierarchyDiagnosticRepeatSeconds = 30f;

		private const int HierarchyDiagnosticMaximumDepth = 8;

		private const int HierarchyDiagnosticMaximumPathLength = 256;

		private static readonly FieldInfo ReportButtonField = AccessTools.Field(typeof(PlayerItemController), "_reportButton");

		private static readonly FieldInfo SyncButtonField = AccessTools.Field(typeof(PlayerItemController), "_syncButton");

		private static readonly FieldInfo SyncImageField = AccessTools.Field(typeof(PlayerItemController), "_syncImage");

		private static readonly FieldInfo SteamButtonField = AccessTools.Field(typeof(PlayerItemController), "_steamButton");

		private static readonly FieldInfo VoiceButtonField = AccessTools.Field(typeof(PlayerItemController), "_voiceMuteButton");

		private static readonly Dictionary<string, float> LastHierarchyDiagnosticAt = new Dictionary<string, float>(StringComparer.Ordinal);

		private static readonly Dictionary<int, BlueSagePlayerPanelSurfaceMarker> OwnedLanesByRowInstanceId = new Dictionary<int, BlueSagePlayerPanelSurfaceMarker>();

		internal static void RefreshRow(PlayerItemController row, string playerSteamId, bool isSelf, bool featureEnabled)
		{
			//IL_031b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0320: Unknown result type (might be due to invalid IL or missing references)
			//IL_0324: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)row == (Object)null)
			{
				return;
			}
			try
			{
				object? obj = ReportButtonField?.GetValue(row);
				Button val = (Button)((obj is Button) ? obj : null);
				Transform val2 = ResolveSerializedReportButtonParent(row, val);
				BlueSagePlayerPanelSurfaceMarker blueSagePlayerPanelSurfaceMarker = FindOwnedLane(row, val2);
				PlayerPanelController i = NetworkSingleton<PlayerPanelController>.I;
				int num = (((Object)(object)i != (Object)null) ? ((Object)i).GetInstanceID() : 0);
				int num2 = (((Object)(object)val2 != (Object)null) ? ((Object)val2).GetInstanceID() : 0);
				PlayerPanelSurfaceDecision playerPanelSurfaceDecision = PlayerPanelSurfacePolicy.Evaluate(new PlayerPanelSurfaceContext
				{
					FeatureEnabled = featureEnabled,
					IsSelf = isSelf,
					RowActive = ((Component)row).gameObject.activeSelf,
					SerializedReportButtonPresent = ((Object)(object)val != (Object)null),
					SerializedReportButtonParentPresent = ((Object)(object)val2 != (Object)null),
					OwnedLanePresent = ((Object)(object)blueSagePlayerPanelSurfaceMarker != (Object)null),
					IdentityChanged = ((Object)(object)blueSagePlayerPanelSurfaceMarker != (Object)null && !string.Equals(blueSagePlayerPanelSurfaceMarker.BoundSteamId, playerSteamId, StringComparison.Ordinal)),
					PanelChanged = ((Object)(object)blueSagePlayerPanelSurfaceMarker != (Object)null && blueSagePlayerPanelSurfaceMarker.PanelInstanceId != num),
					AnchorChanged = ((Object)(object)blueSagePlayerPanelSurfaceMarker != (Object)null && blueSagePlayerPanelSurfaceMarker.AnchorInstanceId != num2),
					RuntimeHierarchyObserved = false,
					PomoState = ReadPomoState(row)
				});
				if (playerPanelSurfaceDecision.Action == PlayerPanelSurfaceAction.Remove)
				{
					DestroyOwnedLane(blueSagePlayerPanelSurfaceMarker);
					EmitHierarchyDiagnosticIfEnabled("owned-lane-removed", row, val, val2);
					return;
				}
				if (playerPanelSurfaceDecision.Action == PlayerPanelSurfaceAction.None)
				{
					EmitHierarchyDiagnosticIfEnabled(((Object)(object)val2 == (Object)null) ? "serialized-report-anchor-unavailable" : "surface-ineligible", row, val, val2);
					return;
				}
				if ((Object)(object)blueSagePlayerPanelSurfaceMarker == (Object)null)
				{
					blueSagePlayerPanelSurfaceMarker = CreateOwnedLane(val2, row);
				}
				if ((Object)(object)blueSagePlayerPanelSurfaceMarker == (Object)null || (Object)(object)val2 == (Object)null || (Object)(object)val == (Object)null)
				{
					DestroyOwnedLane(blueSagePlayerPanelSurfaceMarker);
					EmitHierarchyDiagnosticIfEnabled("owned-lane-create-failed", row, val, val2);
					return;
				}
				if (playerPanelSurfaceDecision.RebindAnchor && (Object)(object)((Component)blueSagePlayerPanelSurfaceMarker).transform.parent != (Object)(object)val2)
				{
					((Component)blueSagePlayerPanelSurfaceMarker).transform.SetParent(val2, false);
				}
				ConfigureLaneLayout(blueSagePlayerPanelSurfaceMarker, val2, val);
				blueSagePlayerPanelSurfaceMarker.RequestLayoutSettle(val);
				PlayerPanelController i2 = NetworkSingleton<PlayerPanelController>.I;
				int observedIndex = ((i2 == null) ? ((int?)null) : i2.PlayerItemControllers?.IndexOf(row)) ?? (-1);
				NetworkTransform expectedTransform = (((Object)(object)i2 != (Object)null && i2.PlayerTransforms != null && observedIndex >= 0 && observedIndex < i2.PlayerTransforms.Count) ? i2.PlayerTransforms[observedIndex] : null);
				string text;
				if (!((Object)(object)i2 != (Object)null) || i2.PlayerIDs == null || observedIndex < 0 || observedIndex >= i2.PlayerIDs.Count)
				{
					text = string.Empty;
				}
				else
				{
					PlayerID val3 = i2.PlayerIDs[observedIndex];
					text = PurrNetPlayerIdPolicy.Format(PackedULong.op_Implicit(((PlayerID)(ref val3)).id));
				}
				string expectedPlayerId = text;
				Button val4 = EnsureOwnedButton(((Component)blueSagePlayerPanelSurfaceMarker).transform, "Button_BlueSageMention", "@", val, 0);
				Button val5 = EnsureOwnedButton(((Component)blueSagePlayerPanelSurfaceMarker).transform, "Button_BlueSageNativeId", "ID", val, 1);
				if ((Object)(object)val4 == (Object)null || (Object)(object)val5 == (Object)null)
				{
					DestroyOwnedLane(blueSagePlayerPanelSurfaceMarker);
					EmitHierarchyDiagnosticIfEnabled("owned-button-create-failed", row, val, val2);
					return;
				}
				((Selectable)val4).interactable = playerPanelSurfaceDecision.ShowMentionAction;
				((Selectable)val5).interactable = playerPanelSurfaceDecision.ShowNativeIdAction;
				if (playerPanelSurfaceDecision.ShowMentionAction)
				{
					BindOwnedListener(val4, delegate
					{
						MentionCurrentPlayer(row, playerSteamId, observedIndex, expectedPlayerId, expectedTransform);
					});
				}
				else
				{
					((UnityEventBase)val4.onClick).RemoveAllListeners();
				}
				if (playerPanelSurfaceDecision.ShowNativeIdAction)
				{
					BindOwnedListener(val5, delegate
					{
						NativeIdCardController.TryOpen("player-row-id", playerSteamId, observedIndex, expectedPlayerId, row, expectedTransform, requireObservedIndex: false);
					});
				}
				else
				{
					((UnityEventBase)val5.onClick).RemoveAllListeners();
				}
				if (playerPanelSurfaceDecision.RebindIdentityAndListeners)
				{
					blueSagePlayerPanelSurfaceMarker.Generation++;
				}
				blueSagePlayerPanelSurfaceMarker.BoundSteamId = playerSteamId ?? string.Empty;
				blueSagePlayerPanelSurfaceMarker.AnchorInstanceId = num2;
				blueSagePlayerPanelSurfaceMarker.PanelInstanceId = num;
				blueSagePlayerPanelSurfaceMarker.ObservedIndex = observedIndex;
				blueSagePlayerPanelSurfaceMarker.ExpectedPlayerId = expectedPlayerId;
				blueSagePlayerPanelSurfaceMarker.ExpectedNetworkTransform = expectedTransform;
				PlayerIdentityRoleHighlightController.RefreshInitializedRow(row);
				EmitHierarchyDiagnosticIfEnabled("owned-lane-ready", row, val, val2);
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Enhanced Player Panel skipped a row without interrupting native UI: " + ex.GetType().Name + ": " + ex.Message));
				}
			}
		}

		internal static void PruneInactivePooledRows(PlayerPanelController panel)
		{
			foreach (KeyValuePair<int, BlueSagePlayerPanelSurfaceMarker> item in new List<KeyValuePair<int, BlueSagePlayerPanelSurfaceMarker>>(OwnedLanesByRowInstanceId))
			{
				BlueSagePlayerPanelSurfaceMarker value = item.Value;
				if ((Object)(object)value == (Object)null || (Object)(object)value.OwnerRow == (Object)null || (Object)(object)((Component)value.OwnerRow).gameObject == (Object)null || !((Component)value.OwnerRow).gameObject.activeSelf || value.IsRetired)
				{
					if ((Object)(object)value == (Object)null)
					{
						OwnedLanesByRowInstanceId.Remove(item.Key);
					}
					else
					{
						DestroyOwnedLane(value);
					}
				}
			}
		}

		internal static void PruneRowsNotIn(ISet<PlayerItemController> currentRows)
		{
			if (currentRows == null || currentRows.Count == 0)
			{
				return;
			}
			List<int> list = new List<int>();
			foreach (PlayerItemController currentRow in currentRows)
			{
				if ((Object)(object)currentRow == (Object)null || (Object)(object)((Component)currentRow).gameObject == (Object)null)
				{
					return;
				}
				list.Add(((Object)currentRow).GetInstanceID());
			}
			AuthoritativePlayerRowReconciliationPolicy.Reconcile(authoritativeCoverageComplete: true, list, new List<int>(OwnedLanesByRowInstanceId.Keys), delegate(int rowInstanceId)
			{
				if (!OwnedLanesByRowInstanceId.TryGetValue(rowInstanceId, out var value) || (Object)(object)value == (Object)null)
				{
					OwnedLanesByRowInstanceId.Remove(rowInstanceId);
				}
				else
				{
					DestroyOwnedLane(value);
				}
			});
		}

		internal static void ClearAll()
		{
			List<BlueSagePlayerPanelSurfaceMarker> list = new List<BlueSagePlayerPanelSurfaceMarker>(OwnedLanesByRowInstanceId.Values);
			OwnedLanesByRowInstanceId.Clear();
			foreach (BlueSagePlayerPanelSurfaceMarker item in list)
			{
				DestroyOwnedLane(item);
			}
			LastHierarchyDiagnosticAt.Clear();
		}

		internal static void UnregisterOwnedLane(BlueSagePlayerPanelSurfaceMarker marker)
		{
			if (!((Object)(object)marker == (Object)null) && marker.OwnerRowInstanceId != 0 && OwnedLanesByRowInstanceId.TryGetValue(marker.OwnerRowInstanceId, out var value) && value == marker)
			{
				OwnedLanesByRowInstanceId.Remove(marker.OwnerRowInstanceId);
			}
		}

		internal static void RefreshOwnedLaneGeometry(BlueSagePlayerPanelSurfaceMarker marker)
		{
			if (!((Object)(object)marker == (Object)null) && !marker.IsRetired && !((Object)(object)marker.OwnerRow == (Object)null) && ((Component)marker.OwnerRow).gameObject.activeInHierarchy && !((Object)(object)marker.LayoutReferenceButton == (Object)null))
			{
				Transform val = ResolveSerializedReportButtonParent(marker.OwnerRow, marker.LayoutReferenceButton);
				if (!((Object)(object)val == (Object)null) && !((Object)(object)((Component)marker).transform.parent != (Object)(object)val))
				{
					ConfigureLaneLayout(marker, val, marker.LayoutReferenceButton);
				}
			}
		}

		private static BlueSagePlayerPanelSurfaceMarker FindOwnedLane(PlayerItemController row, Transform anchor)
		{
			int instanceID = ((Object)row).GetInstanceID();
			if (OwnedLanesByRowInstanceId.TryGetValue(instanceID, out var value))
			{
				if ((Object)(object)value != (Object)null && !value.IsRetired && (Object)(object)value.OwnerRow != (Object)null && value.OwnerRow == row)
				{
					return value;
				}
				OwnedLanesByRowInstanceId.Remove(instanceID);
			}
			if ((Object)(object)anchor == (Object)null)
			{
				return null;
			}
			for (int i = 0; i < anchor.childCount; i++)
			{
				BlueSagePlayerPanelSurfaceMarker component = ((Component)anchor.GetChild(i)).GetComponent<BlueSagePlayerPanelSurfaceMarker>();
				if ((Object)(object)component != (Object)null && !component.IsRetired && (Object)(object)component.OwnerRow != (Object)null && component.OwnerRow == row)
				{
					component.OwnerRowInstanceId = instanceID;
					OwnedLanesByRowInstanceId[instanceID] = component;
					return component;
				}
			}
			return null;
		}

		private static Transform ResolveSerializedReportButtonParent(PlayerItemController row, Button reportButton)
		{
			if ((Object)(object)row == (Object)null || (Object)(object)reportButton == (Object)null || (Object)(object)((Component)reportButton).transform == (Object)null || !((Component)reportButton).transform.IsChildOf(((Component)row).transform))
			{
				return null;
			}
			Transform parent = ((Component)reportButton).transform.parent;
			if ((Object)(object)parent == (Object)null || ((Object)(object)parent != (Object)(object)((Component)row).transform && !parent.IsChildOf(((Component)row).transform)))
			{
				return null;
			}
			return parent;
		}

		private static BlueSagePlayerPanelSurfaceMarker CreateOwnedLane(Transform anchor, PlayerItemController row)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)anchor == (Object)null || (Object)(object)row == (Object)null)
			{
				return null;
			}
			GameObject val = new GameObject("BlueSage_ActionLane", new Type[3]
			{
				typeof(RectTransform),
				typeof(LayoutElement),
				typeof(BlueSagePlayerPanelSurfaceMarker)
			});
			val.transform.SetParent(anchor, false);
			val.GetComponent<LayoutElement>().ignoreLayout = true;
			BlueSagePlayerPanelSurfaceMarker component = val.GetComponent<BlueSagePlayerPanelSurfaceMarker>();
			component.OwnerRow = row;
			component.OwnerRowInstanceId = ((Object)row).GetInstanceID();
			OwnedLanesByRowInstanceId[component.OwnerRowInstanceId] = component;
			return component;
		}

		private static void ConfigureLaneLayout(BlueSagePlayerPanelSurfaceMarker marker, Transform anchor, Button reportButton)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = ((Component)marker).transform;
			RectTransform val = (RectTransform)(object)((transform is RectTransform) ? transform : null);
			Transform transform2 = ((Component)reportButton).transform;
			RectTransform val2 = (RectTransform)(object)((transform2 is RectTransform) ? transform2 : null);
			if (!((Object)(object)val == (Object)null) && !((Object)(object)val2 == (Object)null))
			{
				Rect rect = val2.rect;
				float num = Dimension(((Rect)(ref rect)).width, val2.sizeDelta.x, 36f);
				rect = val2.rect;
				float num2 = Dimension(((Rect)(ref rect)).height, val2.sizeDelta.y, 36f);
				float num3 = Mathf.Clamp(num, 30f, 38f);
				float num4 = Mathf.Clamp(num2, 30f, 38f);
				float num5 = 4f;
				float num6 = 9f;
				float num7 = MeasureNativeLeftEdge(anchor, ((Component)marker).transform, val2);
				val.anchorMin = val2.anchorMin;
				val.anchorMax = val2.anchorMax;
				val.pivot = new Vector2(1f, 0.5f);
				val.sizeDelta = new Vector2(num3 * 2f + num5, num4);
				val.anchoredPosition = new Vector2(num7 - num6, val2.anchoredPosition.y);
			}
		}

		private static float MeasureNativeLeftEdge(Transform anchor, Transform ownedLane, RectTransform reportRect)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			float x = reportRect.anchoredPosition.x;
			Rect rect = reportRect.rect;
			float num = x - Dimension(((Rect)(ref rect)).width, reportRect.sizeDelta.x, 36f) * reportRect.pivot.x;
			for (int i = 0; i < anchor.childCount; i++)
			{
				Transform child = anchor.GetChild(i);
				if (!((Object)(object)child == (Object)null) && !((Object)(object)child == (Object)(object)ownedLane) && !((Object)(object)((Component)child).GetComponent<BlueSagePlayerPanelSurfaceMarker>() != (Object)null) && !((Object)(object)((Component)child).GetComponent<Button>() == (Object)null))
				{
					RectTransform val = (RectTransform)(object)((child is RectTransform) ? child : null);
					if (!((Object)(object)val == (Object)null))
					{
						rect = val.rect;
						float num2 = Dimension(((Rect)(ref rect)).width, val.sizeDelta.x, 36f);
						num = Mathf.Min(num, val.anchoredPosition.x - num2 * val.pivot.x);
					}
				}
			}
			return num;
		}

		private static Button EnsureOwnedButton(Transform lane, string objectName, string label, Button referenceButton, int slot)
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Expected O, but got Unknown
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			BlueSageEnhancedPanelButtonMarker blueSageEnhancedPanelButtonMarker = null;
			for (int i = 0; i < lane.childCount; i++)
			{
				BlueSageEnhancedPanelButtonMarker component = ((Component)lane.GetChild(i)).GetComponent<BlueSageEnhancedPanelButtonMarker>();
				if ((Object)(object)component != (Object)null && string.Equals(component.ActionName, objectName, StringComparison.Ordinal))
				{
					blueSageEnhancedPanelButtonMarker = component;
					break;
				}
			}
			GameObject val;
			if ((Object)(object)blueSageEnhancedPanelButtonMarker == (Object)null)
			{
				val = new GameObject(objectName, new Type[4]
				{
					typeof(RectTransform),
					typeof(Image),
					typeof(Button),
					typeof(BlueSageEnhancedPanelButtonMarker)
				});
				val.transform.SetParent(lane, false);
				blueSageEnhancedPanelButtonMarker = val.GetComponent<BlueSageEnhancedPanelButtonMarker>();
				blueSageEnhancedPanelButtonMarker.ActionName = objectName;
			}
			else
			{
				val = ((Component)blueSageEnhancedPanelButtonMarker).gameObject;
			}
			RectTransform val2 = (RectTransform)(object)((lane is RectTransform) ? lane : null);
			Transform transform = val.transform;
			RectTransform val3 = (RectTransform)(object)((transform is RectTransform) ? transform : null);
			if ((Object)(object)val2 == (Object)null || (Object)(object)val3 == (Object)null)
			{
				return null;
			}
			float num = 4f;
			float num2 = Mathf.Max(1f, (val2.sizeDelta.x - num) / 2f);
			float num3 = Mathf.Max(1f, val2.sizeDelta.y);
			val3.anchorMin = new Vector2(1f, 0.5f);
			val3.anchorMax = new Vector2(1f, 0.5f);
			val3.pivot = new Vector2(1f, 0.5f);
			val3.sizeDelta = new Vector2(num2, num3);
			val3.anchoredPosition = new Vector2(0f - (float)slot * (num2 + num), 0f);
			CopyReferenceVisual(referenceButton, val);
			AddOrRefreshLabel(val.transform, label);
			return val.GetComponent<Button>();
		}

		private static void CopyReferenceVisual(Button referenceButton, GameObject ownedButton)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ownedButton == (Object)null)
			{
				return;
			}
			Button component = ownedButton.GetComponent<Button>();
			Image component2 = ownedButton.GetComponent<Image>();
			if ((Object)(object)referenceButton == (Object)null)
			{
				((Graphic)component2).color = new Color(0.38f, 0.73f, 0.95f, 1f);
				return;
			}
			((Selectable)component).transition = ((Selectable)referenceButton).transition;
			((Selectable)component).colors = ((Selectable)referenceButton).colors;
			((Selectable)component).spriteState = ((Selectable)referenceButton).spriteState;
			((Selectable)component).navigation = ((Selectable)referenceButton).navigation;
			Image component3 = ((Component)referenceButton).GetComponent<Image>();
			if ((Object)(object)component3 != (Object)null)
			{
				component2.sprite = component3.sprite;
				component2.type = component3.type;
				component2.preserveAspect = component3.preserveAspect;
				((Graphic)component2).color = ((Graphic)component3).color;
			}
		}

		private static void AddOrRefreshLabel(Transform parent, string label)
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			TextMeshProUGUI val = null;
			for (int i = 0; i < parent.childCount; i++)
			{
				val = ((Component)parent.GetChild(i)).GetComponent<TextMeshProUGUI>();
				if ((Object)(object)val != (Object)null)
				{
					break;
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				GameObject val2 = new GameObject("Label", new Type[2]
				{
					typeof(RectTransform),
					typeof(TextMeshProUGUI)
				});
				val2.transform.SetParent(parent, false);
				val = val2.GetComponent<TextMeshProUGUI>();
			}
			Transform transform = ((TMP_Text)val).transform;
			Transform obj = ((transform is RectTransform) ? transform : null);
			((RectTransform)obj).anchorMin = Vector2.zero;
			((RectTransform)obj).anchorMax = Vector2.one;
			((RectTransform)obj).offsetMin = Vector2.zero;
			((RectTransform)obj).offsetMax = Vector2.zero;
			((TMP_Text)val).text = label;
			((TMP_Text)val).fontSize = ((label.Length > 1) ? 15f : 22f);
			((TMP_Text)val).alignment = (TextAlignmentOptions)514;
			((Graphic)val).color = Color.white;
			((Graphic)val).raycastTarget = false;
		}

		private static void BindOwnedListener(Button button, Action action)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			if ((Object)(object)button == (Object)null)
			{
				return;
			}
			((UnityEventBase)button.onClick).RemoveAllListeners();
			((UnityEvent)button.onClick).AddListener((UnityAction)delegate
			{
				action?.Invoke();
				SFXManager i = MonoSingleton<SFXManager>.I;
				if ((Object)(object)i != (Object)null)
				{
					i.PlayUIClick();
				}
			});
		}

		private static void MentionCurrentPlayer(PlayerItemController row, string steamId, int observedIndex, string expectedPlayerId, NetworkTransform expectedTransform)
		{
			if (!NativeIdCardController.TryResolveCurrentRow("player-row-mention", steamId, observedIndex, expectedPlayerId, row, expectedTransform, requireObservedIndex: false, NativeIdCardCallerKind.OrdinaryUser, out var target, out var _))
			{
				return;
			}
			UIManager i = MonoSingleton<UIManager>.I;
			if ((Object)(object)i == (Object)null || (Object)(object)i.MessageInput == (Object)null)
			{
				return;
			}
			string text = MentionNamePolicy.ToMentionInsertionToken(target.DisplayNameRaw);
			if (!string.IsNullOrWhiteSpace(text))
			{
				PlayerPanelController i2 = NetworkSingleton<PlayerPanelController>.I;
				if ((Object)(object)i2 != (Object)null)
				{
					i2.ButtonClosePanel();
				}
				if (i.IsMessagePanelHidden)
				{
					i.ButtonHide();
				}
				if (!i.IsMessagePanelActivated)
				{
					i.OsSelectMessageInput();
				}
				string text2 = "@" + text + " ";
				TMP_InputField messageInput = i.MessageInput;
				if (string.IsNullOrWhiteSpace(messageInput.text))
				{
					messageInput.text = text2;
				}
				else
				{
					string text3 = (messageInput.text.EndsWith(" ", StringComparison.Ordinal) ? string.Empty : " ");
					messageInput.text = messageInput.text + text3 + text2;
				}
				((Selectable)messageInput).Select();
				messageInput.ActivateInputField();
				messageInput.caretPosition = messageInput.text.Length;
			}
		}

		private static PlayerPanelPomoState ReadPomoState(PlayerItemController row)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			string a = ((object)row.CurrentPomoState/*cast due to .constrained prefix*/).ToString();
			if (string.Equals(a, "Syncable", StringComparison.Ordinal))
			{
				return PlayerPanelPomoState.Syncable;
			}
			if (string.Equals(a, "Synced", StringComparison.Ordinal))
			{
				return PlayerPanelPomoState.Synced;
			}
			if (string.Equals(a, "SyncedWithMe", StringComparison.Ordinal))
			{
				return PlayerPanelPomoState.SyncedWithMe;
			}
			return PlayerPanelPomoState.Inactive;
		}

		private static void DestroyOwnedLane(BlueSagePlayerPanelSurfaceMarker marker)
		{
			if ((Object)(object)marker != (Object)null)
			{
				marker.IsRetired = true;
				UnregisterOwnedLane(marker);
				RemoveOwnedListeners(marker);
				((Component)marker).gameObject.SetActive(false);
				Object.Destroy((Object)(object)((Component)marker).gameObject);
			}
		}

		private static void RemoveOwnedListeners(BlueSagePlayerPanelSurfaceMarker marker)
		{
			if ((Object)(object)marker == (Object)null)
			{
				return;
			}
			Transform transform = ((Component)marker).transform;
			for (int i = 0; i < transform.childCount; i++)
			{
				Button component = ((Component)transform.GetChild(i)).GetComponent<Button>();
				if ((Object)(object)component != (Object)null)
				{
					((UnityEventBase)component.onClick).RemoveAllListeners();
					((Selectable)component).interactable = false;
				}
			}
		}

		private static void EmitHierarchyDiagnosticIfEnabled(string reason, PlayerItemController row, Button reportButton, Transform anchor)
		{
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.ShouldEmitHiddenDiagnostics || (Object)(object)row == (Object)null)
			{
				return;
			}
			float unscaledTime = Time.unscaledTime;
			string key = ((Object)row).GetInstanceID() + "|" + (reason ?? string.Empty);
			if (!LastHierarchyDiagnosticAt.TryGetValue(key, out var value) || !(unscaledTime - value < 30f))
			{
				if (LastHierarchyDiagnosticAt.Count >= 128)
				{
					LastHierarchyDiagnosticAt.Clear();
				}
				LastHierarchyDiagnosticAt[key] = unscaledTime;
				object? obj = SyncButtonField?.GetValue(row);
				Button val = (Button)((obj is Button) ? obj : null);
				object? obj2 = SyncImageField?.GetValue(row);
				Image val2 = (Image)((obj2 is Image) ? obj2 : null);
				object? obj3 = SteamButtonField?.GetValue(row);
				Button val3 = (Button)((obj3 is Button) ? obj3 : null);
				object? obj4 = VoiceButtonField?.GetValue(row);
				Button val4 = (Button)((obj4 is Button) ? obj4 : null);
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)("[BlueSagePanelHierarchy] authority=diagnostic-only; fallbackEnabled=false; reason=" + SafeDiagnosticValue(reason) + "; rowPath=" + BuildBoundedPath(((Component)row).transform, ((Component)row).transform) + "; reportPath=" + BuildBoundedPath(((Component)row).transform, (reportButton != null) ? ((Component)reportButton).transform : null) + "; anchorPath=" + BuildBoundedPath(((Component)row).transform, anchor) + "; syncSharesAnchor=" + SharesParent((val != null) ? ((Component)val).transform : null, anchor) + "; syncImageSharesAnchor=" + SharesParent((val2 != null) ? ((Component)val2).transform : null, anchor) + "; steamSharesAnchor=" + SharesParent((val3 != null) ? ((Component)val3).transform : null, anchor) + "; voiceSharesAnchor=" + SharesParent((val4 != null) ? ((Component)val4).transform : null, anchor) + "; pomoState=" + ((object)row.CurrentPomoState/*cast due to .constrained prefix*/).ToString() + "."));
				}
			}
		}

		private static bool SharesParent(Transform control, Transform expectedParent)
		{
			if ((Object)(object)control != (Object)null && (Object)(object)expectedParent != (Object)null)
			{
				return control.parent == expectedParent;
			}
			return false;
		}

		private static string BuildBoundedPath(Transform root, Transform node)
		{
			if ((Object)(object)root == (Object)null || (Object)(object)node == (Object)null)
			{
				return "unavailable";
			}
			List<string> list = new List<string>();
			Transform val = node;
			int num = 0;
			while ((Object)(object)val != (Object)null && num < 8)
			{
				list.Add(SafeDiagnosticValue(((Object)val).name));
				if ((Object)(object)val == (Object)(object)root)
				{
					break;
				}
				val = val.parent;
				num++;
			}
			list.Reverse();
			string text = string.Join("/", list.ToArray());
			if (text.Length > 256)
			{
				return text.Substring(0, 255) + "…";
			}
			return text;
		}

		private static string SafeDiagnosticValue(string value)
		{
			string text = (string.IsNullOrWhiteSpace(value) ? "none" : value.Replace("\r", " ").Replace("\n", " ").Replace(";", "_"));
			if (text.Length > 64)
			{
				return text.Substring(0, 63) + "…";
			}
			return text;
		}

		private static float Dimension(float rectValue, float sizeDeltaValue, float fallback)
		{
			if (rectValue > 0f)
			{
				return rectValue;
			}
			if (Mathf.Abs(sizeDeltaValue) > 0f)
			{
				return Mathf.Abs(sizeDeltaValue);
			}
			return fallback;
		}
	}
	[HarmonyPatch(typeof(PlayerPanelController), "UpdateServerPanel")]
	internal static class PlayerPanelSurfaceRosterLifecyclePatch
	{
		[HarmonyPostfix]
		private static void Postfix(PlayerPanelController __instance)
		{
			PlayerPanelSurfaceController.PruneInactivePooledRows(__instance);
		}
	}
	internal sealed class BlueSagePlayerPanelSurfaceMarker : MonoBehaviour
	{
		private const int LayoutSettleFrameBudget = 30;

		private static int _created;

		private static int _destroyed;

		private static int _live;

		internal string BoundSteamId = string.Empty;

		internal bool IsRetired;

		internal PlayerItemController OwnerRow;

		internal int OwnerRowInstanceId;

		internal int AnchorInstanceId;

		internal int PanelInstanceId;

		internal int Generation;

		internal int ObservedIndex = -1;

		internal string ExpectedPlayerId = string.Empty;

		internal NetworkTransform ExpectedNetworkTransform;

		internal Button LayoutReferenceButton;

		private int _layoutSettleFramesRemaining;

		private void Awake()
		{
			Interlocked.Increment(ref _created);
			Interlocked.Increment(ref _live);
		}

		internal void RequestLayoutSettle(Button reportButton)
		{
			LayoutReferenceButton = reportButton;
			_layoutSettleFramesRemaining = 30;
		}

		private void OnEnable()
		{
			_layoutSettleFramesRemaining = 30;
		}

		private void LateUpdate()
		{
			if (_layoutSettleFramesRemaining > 0 && !IsRetired)
			{
				PlayerPanelSurfaceController.RefreshOwnedLaneGeometry(this);
				_layoutSettleFramesRemaining--;
			}
		}

		private void OnDestroy()
		{
			PlayerPanelSurfaceController.UnregisterOwnedLane(this);
			Interlocked.Increment(ref _destroyed);
			Interlocked.Decrement(ref _live);
		}

		internal static string GetDiagnosticSummary()
		{
			return "lanesLive=" + Interlocked.CompareExchange(ref _live, 0, 0) + ",lanesCreated=" + Interlocked.CompareExchange(ref _created, 0, 0) + ",lanesDestroyed=" + Interlocked.CompareExchange(ref _destroyed, 0, 0);
		}
	}
	internal sealed class BlueSageEnhancedPanelButtonMarker : MonoBehaviour
	{
		private static int _created;

		private static int _destroyed;

		private static int _live;

		internal string ActionName = string.Empty;

		private void Awake()
		{
			Interlocked.Increment(ref _created);
			Interlocked.Increment(ref _live);
		}

		private void OnDestroy()
		{
			Interlocked.Increment(ref _destroyed);
			Interlocked.Decrement(ref _live);
		}

		internal static string GetDiagnosticSummary()
		{
			return "buttonsLive=" + Interlocked.CompareExchange(ref _live, 0, 0) + ",buttonsCreated=" + Interlocked.CompareExchange(ref _created, 0, 0) + ",buttonsDestroyed=" + Interlocked.CompareExchange(ref _destroyed, 0, 0) + "," + BlueSagePlayerPanelSurfaceMarker.GetDiagnosticSummary();
		}
	}
	internal static class PlayerRoleLabelController
	{
		internal const string MemberDataKey = "bluesage_role_label_v1";

		private const float PublishIntervalSeconds = 2f;

		private static string _localHostLabelOverride = string.Empty;

		private static float _nextRolePublishAt;

		private static float _nextCompatiblePublishAt;

		private static ulong _compatibleLobbyKey;

		internal static void Tick()
		{
			if (!PluginShutdownController.IsShuttingDown)
			{
				PublishHostHeartbeat();
				PublishCompatibleClientHeartbeat();
				PlayerBadgeController.Tick();
			}
		}

		internal static bool TrySetLocalHostLabelOverride(string richText, out string result)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			result = string.Empty;
			if (!SteamIdModerationController.TryGetOwnedHostLobby(out var lobby, out var ownerSteamId))
			{
				result = "Host role label was not changed because this client is not the exact current Steam lobby owner and active host.";
				return false;
			}
			if (!RoleLabelProtocolPolicy.TryValidateLabel(richText, out var clean, out var error))
			{
				result = error;
				return false;
			}
			bool creatorPresent;
			bool exactIdentityGenerationFresh = PlayerBadgeController.TryResolveFreshLocalCreatorContribution(lobby, out creatorPresent);
			if (!CreatorHostLabelPublicationPolicy.CanPublish(exactOwnedHost: true, exactIdentityGenerationFresh, creatorPresent))
			{
				StopAndClearPublishedHostLabel(lobby, out ownerSteamId);
				result = "Host role label was not changed because fresh exact local creator evidence is unavailable.";
				return false;
			}
			_localHostLabelOverride = clean;
			if (!TryPublishRoleLabel(lobby, RoleLabelProtocolAction.Set, clean, out var error2))
			{
				_localHostLabelOverride = string.Empty;
				result = error2;
				return false;
			}
			result = "Host role-label compatibility heartbeat published. Current public QoL rows use the separate exact-truth badge strip and never rewrite player names.";
			return true;
		}

		internal static bool TryClearLocalHostLabelOverride(out string result)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			result = string.Empty;
			if (!SteamIdModerationController.TryGetOwnedHostLobby(out var lobby, out var _))
			{
				result = "Host role label was not cleared because this client is not the exact current Steam lobby owner and active host.";
				return false;
			}
			if (!StopAndClearPublishedHostLabel(lobby, out var error))
			{
				result = error;
				return false;
			}
			result = "Host role-label compatibility heartbeat cleared. The exact-truth badge strip is unchanged.";
			return true;
		}

		internal static void PublishHostHeartbeat()
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			if (PluginShutdownController.IsShuttingDown || string.IsNullOrWhiteSpace(_localHostLabelOverride) || Time.unscaledTime < _nextRolePublishAt)
			{
				return;
			}
			CSteamID lobby;
			string ownerSteamId;
			bool flag = SteamIdModerationController.TryGetOwnedHostLobby(out lobby, out ownerSteamId);
			bool exactIdentityGenerationFresh = false;
			bool creatorPresent = false;
			if (flag)
			{
				exactIdentityGenerationFresh = PlayerBadgeController.TryResolveFreshLocalCreatorContribution(lobby, out creatorPresent);
			}
			switch (CreatorHostLabelPublicationPolicy.DecideHeartbeat(labelActive: true, heartbeatDue: true, flag, exactIdentityGenerationFresh, creatorPresent))
			{
			case CreatorHostLabelHeartbeatDecision.ClearAndStop:
			{
				StopAndClearPublishedHostLabel(lobby, out var error2);
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogDebug((object)("Host role-label compatibility heartbeat stopped: " + error2));
				}
				break;
			}
			case CreatorHostLabelHeartbeatDecision.Publish:
			{
				if (!TryPublishRoleLabel(lobby, RoleLabelProtocolAction.Set, _localHostLabelOverride, out var error))
				{
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogDebug((object)("Host role-label compatibility heartbeat skipped: " + error));
					}
				}
				break;
			}
			}
		}

		internal static void ClearPublishedHostLabel()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if (PluginShutdownController.IsShuttingDown)
			{
				return;
			}
			try
			{
				if (SteamIdModerationController.TryGetOwnedHostLobby(out var lobby, out var ownerSteamId))
				{
					TryPublishRoleLabel(lobby, RoleLabelProtocolAction.Clear, string.Empty, out ownerSteamId);
				}
				ClearCompatibleClientHeartbeat();
			}
			catch
			{
			}
			_localHostLabelOverride = string.Empty;
			_nextRolePublishAt = 0f;
		}

		internal static void ClearPublishedStateForShutdown(SteamRuntimeSnapshot snapshot)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			if (snapshot != null && snapshot.SteamWasReady && snapshot.Lobby != CSteamID.Nil)
			{
				try
				{
					SteamMatchmaking.SetLobbyMemberData(snapshot.Lobby, "bluesage_role_label_v1", string.Empty);
					SteamMatchmaking.SetLobbyMemberData(snapshot.Lobby, "bluesage_qol_client_v1", string.Empty);
				}
				catch
				{
				}
			}
			_localHostLabelOverride = string.Empty;
			_nextRolePublishAt = 0f;
			_nextCompatiblePublishAt = 0f;
			_compatibleLobbyKey = 0uL;
		}

		internal static void RestoreAll()
		{
			ClearCompatibleClientHeartbeat();
			PlayerBadgeController.ClearAll();
			_localHostLabelOverride = string.Empty;
			_nextRolePublishAt = 0f;
			_nextCompatiblePublishAt = 0f;
			_compatibleLobbyKey = 0uL;
		}

		private static bool StopAndClearPublishedHostLabel(CSteamID preferredLobby, out string error)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			_localHostLabelOverride = string.Empty;
			_nextRolePublishAt = 0f;
			CSteamID lobbyId = preferredLobby;
			if (lobbyId == CSteamID.Nil && (!SteamManager.Initialized || !Plugin.TryGetRescueLobby(out lobbyId) || lobbyId == CSteamID.Nil))
			{
				error = "Role-label member-data clear could not reach a current Steam lobby; the stale packet will expire fail closed.";
				return false;
			}
			bool result = TryPublishRoleLabel(lobbyId, RoleLabelProtocolAction.Clear, string.Empty, out error);
			_localHostLabelOverride = string.Empty;
			_nextRolePublishAt = 0f;
			return result;
		}

		private static void PublishCompatibleClientHeartbeat()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			if (PluginShutdownController.IsShuttingDown)
			{
				return;
			}
			if (!SteamManager.Initialized || !Plugin.TryGetRescueLobby(out var lobbyId) || lobbyId == CSteamID.Nil)
			{
				_compatibleLobbyKey = 0uL;
				_nextCompatiblePublishAt = 0f;
				return;
			}
			ulong num = (ulong)lobbyId;
			if (_compatibleLobbyKey != num)
			{
				_compatibleLobbyKey = num;
				_nextCompatiblePublishAt = 0f;
			}
			if (Time.unscaledTime < _nextCompatiblePublishAt || !CompatibleClientPresencePolicy.TryBuild(DateTimeOffset.UtcNow.ToUnixTimeSeconds(), out var payload))
			{
				return;
			}
			try
			{
				SteamMatchmaking.SetLobbyMemberData(lobbyId, "bluesage_qol_client_v1", payload);
				_nextCompatiblePublishAt = Time.unscaledTime + 2f;
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogDebug((object)("Compatible-client heartbeat skipped: " + ex.GetType().Name));
				}
			}
		}

		private static void ClearCompatibleClientHeartbeat()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			if (PluginShutdownController.IsShuttingDown)
			{
				return;
			}
			try
			{
				if (SteamManager.Initialized && Plugin.TryGetRescueLobby(out var lobbyId) && lobbyId != CSteamID.Nil)
				{
					SteamMatchmaking.SetLobbyMemberData(lobbyId, "bluesage_qol_client_v1", string.Empty);
				}
			}
			catch
			{
			}
			_compatibleLobbyKey = 0uL;
			_nextCompatiblePublishAt = 0f;
		}

		private static bool TryPublishRoleLabel(CSteamID lobby, RoleLabelProtocolAction action, string label, out string error)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			if (PluginShutdownController.IsShuttingDown)
			{
				error = "Role-label member-data publish is unavailable during shutdown.";
				return false;
			}
			string nonce = Guid.NewGuid().ToString("N").Substring(0, 12);
			long issuedUnixSeconds = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
			if (!((action == RoleLabelProtocolAction.Set) ? RoleLabelProtocolPolicy.TryBuildSet(label, issuedUnixSeconds, nonce, out var payload, out error) : RoleLabelProtocolPolicy.TryBuildClear(issuedUnixSeconds, nonce, out payload, out error)))
			{
				return false;
			}
			try
			{
				SteamMatchmaking.SetLobbyMemberData(lobby, "bluesage_role_label_v1", payload);
				_nextRolePublishAt = Time.unscaledTime + 2f;
				return true;
			}
			catch (Exception ex)
			{
				error = "Role-label member-data publish failed: " + ex.GetType().Name + ".";
				return false;
			}
		}
	}
	[HarmonyPatch(typeof(PlayerItemController), "Init")]
	internal static class PlayerRoleLabelPatch
	{
		[HarmonyPostfix]
		private static void Postfix(PlayerItemController __instance, string playerSteamId)
		{
			PlayerBadgeController.RegisterRow(__instance, playerSteamId);
		}
	}
	[HarmonyPatch(typeof(MainSceneManager))]
	internal static class ReconnectGuardPatch
	{
		[HarmonyPatch("ConnectionLost")]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		[HarmonyBefore(new string[] { "com.andrewlin.ontogether.reconnect" })]
		private static bool ConnectionLostPrefix(NotificationStatus notificationStatus)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return Plugin.HandleConnectionLostForReconnectGuard(notificationStatus);
		}
	}
	[HarmonyPatch(typeof(PlayerCustomizationController), "UpdateOnNewPeopleJoin_Original_0")]
	internal static class RosterRegistrationGuardPatch
	{
		private static int _invalidRegistrationCount;

		private static int _exactDuplicateCount;

		private static int _replacementCount;

		[HarmonyPrefix]
		private static bool Prefix(PlayerCustomizationController __instance, string playerSteamID, NetworkTransform networkTransform, string vivoxId)
		{
			if ((Object)(object)__instance == (Object)null || !((NetworkIdentity)__instance).isServer)
			{
				return true;
			}
			PlayerPanelController i = NetworkSingleton<PlayerPanelController>.I;
			if ((Object)(object)i == (Object)null)
			{
				return true;
			}
			RosterRegistrationDecision rosterRegistrationDecision = RosterRegistrationPolicy.Evaluate(playerSteamID, vivoxId, networkTransform, i.PlayerSteamIDs, i.VivoxIDs, i.PlayerTransforms);
			switch (rosterRegistrationDecision.Action)
			{
			case RosterRegistrationAction.RejectInvalid:
			{
				_invalidRegistrationCount++;
				ManualLogSource log3 = Plugin.Log;
				if (log3 != null)
				{
					log3.LogWarning((object)$"[BlueSageRosterGuard] utc={DateTime.UtcNow:O}; action=reject-invalid; count={_invalidRegistrationCount}; identityDetail=private-audit-only");
				}
				return false;
			}
			case RosterRegistrationAction.IgnoreExactDuplicate:
				_exactDuplicateCount++;
				if (_exactDuplicateCount == 1 || _exactDuplicateCount % 25 == 0)
				{
					ManualLogSource log2 = Plugin.Log;
					if (log2 != null)
					{
						log2.LogInfo((object)$"[BlueSageRosterGuard] utc={DateTime.UtcNow:O}; action=ignore-exact-duplicate; count={_exactDuplicateCount}; identityDetail=private-audit-only");
					}
				}
				return false;
			case RosterRegistrationAction.ReplaceStableIdentity:
				if (IsServerBannedIdentity(playerSteamID))
				{
					return true;
				}
				if (PanelRosterRowGuard.RemoveParallelRow(i, rosterRegistrationDecision.ExistingIndex))
				{
					_replacementCount++;
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogInfo((object)$"[BlueSageRosterGuard] utc={DateTime.UtcNow:O}; action=replace-stale-identity; count={_replacementCount}; identityDetail=private-audit-only");
					}
				}
				return true;
			default:
				return true;
			}
		}

		private static bool IsServerBannedIdentity(string playerSteamId)
		{
			try
			{
				return (Object)(object)MonoSingleton<DataManager>.I != (Object)null && MonoSingleton<DataManager>.I.BanData != null && MonoSingleton<DataManager>.I.BanData.BanServerPlayers.Contains(playerSteamId);
			}
			catch
			{
				return false;
			}
		}
	}
	[HarmonyPatch(typeof(PlayerPanelController), "DespawnHandle", new Type[] { typeof(NetworkTransform) })]
	internal static class RosterDespawnDuplicateGuardPatch
	{
		[HarmonyPostfix]
		private static void Postfix(PlayerPanelController __instance, NetworkTransform netTransform)
		{
			if ((Object)(object)__instance == (Object)null || netTransform == null)
			{
				return;
			}
			int num = 0;
			for (int num2 = __instance.PlayerTransforms.Count - 1; num2 >= 0; num2--)
			{
				if (__instance.PlayerTransforms[num2] == netTransform && PanelRosterRowGuard.RemoveParallelRow(__instance, num2))
				{
					num++;
				}
			}
			if (num > 0)
			{
				__instance.UpdateServerPanelOnChange();
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)$"[BlueSageRosterGuard] utc={DateTime.UtcNow:O}; action=remove-despawn-duplicates; removed={num}; identityDetail=private-audit-only");
				}
			}
		}
	}
	internal static class PanelRosterRowGuard
	{
		internal static bool RemoveParallelRow(PlayerPanelController panel, int index)
		{
			if ((Object)(object)panel == (Object)null || index < 0 || panel.PlayerSteamIDs == null || panel.PlayerSteamIDs.Count <= index || panel.VivoxIDs == null || panel.VivoxIDs.Count <= index || panel.PomoShows == null || panel.PomoShows.Count <= index || panel.IsVoiceChatActive == null || panel.IsVoiceChatActive.Count <= index || panel.PlayerTransforms == null || panel.PlayerTransforms.Count <= index || panel.PlayerIDs == null || panel.PlayerIDs.Count <= index || panel.IDInfos == null || panel.IDInfos.Count <= index || panel.PlayerControllers == null || panel.PlayerControllers.Count <= index)
			{
				return false;
			}
			panel.PlayerSteamIDs.RemoveAt(index);
			panel.VivoxIDs.RemoveAt(index);
			panel.PomoShows.RemoveAt(index);
			panel.IsVoiceChatActive.RemoveAt(index);
			panel.PlayerTransforms.RemoveAt(index);
			panel.PlayerIDs.RemoveAt(index);
			panel.IDInfos.RemoveAt(index);
			panel.PlayerControllers.RemoveAt(index);
			return true;
		}
	}
	[HarmonyPatch(typeof(PlayerMovementController))]
	internal static class SelfMovementPatch
	{
		private static Vector3? _pendingTeleport;

		internal static void QueueTeleport(Vector3 target)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			OptInRescuePatch.Stop();
			ResetVerticalVelocity();
			_pendingTeleport = target;
		}

		internal static void CleanupRuntimeState()
		{
			_pendingTeleport = null;
			BetterMoveState.IsSlowWalkActive = false;
			ResetVerticalVelocity();
		}

		internal static void ResetVerticalVelocity()
		{
			try
			{
				PlayerMovementController val = NetworkSingleton<TextChannelManager>.I?.MainMovementController;
				if ((Object)(object)val != (Object)null)
				{
					val.SpeedY = 0f;
				}
			}
			catch
			{
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("MovePlayer")]
		private static bool MovePlayerPrefix(PlayerMovementController __instance, ref CharacterController ____characterController)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			if (!IsLocalMainMovement(__instance))
			{
				return true;
			}
			if (_pendingTeleport.HasValue)
			{
				Vector3 value = _pendingTeleport.Value;
				_pendingTeleport = null;
				ApplyPosition(__instance, ____characterController, value);
				TryForceSyncLocalOwner();
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)("Self movement: saved-position teleport applied to " + SelfMovementPolicy.FormatPosition(value) + "."));
				}
				return false;
			}
			return !Plugin.ShouldApplyNoclipFly;
		}

		private static void TryForceSyncLocalOwner()
		{
			try
			{
				TextChannelManager i = NetworkSingleton<TextChannelManager>.I;
				if (i != null)
				{
					NetworkTransform mainNetTransform = i.MainNetTransform;
					if (mainNetTransform != null)
					{
						mainNetTransform.ForceSync();
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogDebug((object)("Self movement: owner transform sync will fall back to the normal network tick: " + ex.GetType().Name + "."));
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("MovePlayer")]
		private static void MovePlayerPostfix(PlayerMovementController __instance, ref CharacterController ____characterController)
		{
			if (IsLocalMainMovement(__instance))
			{
				ApplyMovementTuning(__instance, ____characterController);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("Update")]
		private static void UpdatePostfix(PlayerMovementController __instance)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.ShouldApplyNoclipFly || !IsLocalMainMovement(__instance))
			{
				return;
			}
			try
			{
				BetterMoveState.IsSlowWalkActive = false;
				Vector3 val = Vector3.zero;
				InputManager i = MonoSingleton<InputManager>.I;
				if ((Object)(object)i != (Object)null)
				{
					val += Flatten(((Component)__instance).transform.forward) * i.Vertical;
					val += Flatten(((Component)__instance).transform.right) * i.Horizontal;
				}
				if (Input.GetKey((KeyCode)32) || Input.GetKey((KeyCode)101))
				{
					val += Vector3.up;
				}
				if (Input.GetKey((KeyCode)306) || Input.GetKey((KeyCode)305) || Input.GetKey((KeyCode)113))
				{
					val += Vector3.down;
				}
				if (!(((Vector3)(ref val)).sqrMagnitude <= 0.0001f))
				{
					float num = 1f;
					if (Input.GetKey((KeyCode)304) || Input.GetKey((KeyCode)303))
					{
						num = 2.5f;
					}
					else if (Input.GetKey((KeyCode)308) || Input.GetKey((KeyCode)307))
					{
						num = 0.35f;
					}
					float num2 = 8f * Plugin.LockedSelfSpeedMultiplier;
					Vector3 target = ((Component)__instance).transform.position + ((Vector3)(ref val)).normalized * num2 * num * Time.deltaTime;
					ApplyPosition(__instance, null, target);
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Self movement fly update skipped: " + ex.GetType().Name + ": " + ex.Message));
				}
			}
		}

		private static void ApplyMovementTuning(PlayerMovementController instance, CharacterController controller)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.ShouldApplySelfMovementTuning || Plugin.ShouldApplyNoclipFly)
			{
				return;
			}
			try
			{
				InputManager i = MonoSingleton<InputManager>.I;
				if ((Object)(object)i == (Object)null)
				{
					return;
				}
				float lockedSelfSpeedMultiplier = Plugin.LockedSelfSpeedMultiplier;
				if (Math.Abs(lockedSelfSpeedMultiplier - 1f) > 0.001f)
				{
					Vector3 val = Flatten(((Component)instance).transform.forward) * i.Vertical + Flatten(((Component)instance).transform.right) * i.Horizontal;
					if (((Vector3)(ref val)).sqrMagnitude > 0.0001f)
					{
						float walkSpeed = ScriptableSingleton<GameSettings>.I.WalkSpeed;
						ApplyDelta(instance, controller, ((Vector3)(ref val)).normalized * (walkSpeed * (lockedSelfSpeedMultiplier - 1f) * Time.deltaTime));
					}
				}
				float lockedSelfJumpMultiplier = Plugin.LockedSelfJumpMultiplier;
				if (Math.Abs(lockedSelfJumpMultiplier - 1f) > 0.001f && Input.GetKeyDown((KeyCode)32) && instance.SpeedY > 0f)
				{
					instance.SpeedY = Mathf.Max(instance.SpeedY, ScriptableSingleton<GameSettings>.I.JumpSpeed * lockedSelfJumpMultiplier);
				}
				float lockedSelfGravityMultiplier = Plugin.LockedSelfGravityMultiplier;
				if (Math.Abs(lockedSelfGravityMultiplier - 1f) > 0.001f && instance.SpeedY < 0f)
				{
					instance.SpeedY -= ScriptableSingleton<GameSettings>.I.FallAcceleration * (lockedSelfGravityMultiplier - 1f) * Time.deltaTime;
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Self movement tuning skipped: " + ex.GetType().Name + ": " + ex.Message));
				}
			}
		}

		private static void ApplyDelta(PlayerMovementController instance, CharacterController controller, Vector3 delta)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)controller != (Object)null)
			{
				controller.Move(delta);
			}
			else if ((Object)(object)instance != (Object)null)
			{
				Transform transform = ((Component)instance).transform;
				transform.position += delta;
			}
			TextChannelManager i = NetworkSingleton<TextChannelManager>.I;
			if ((Object)(object)i?.MainPlayer != (Object)null && ((Object)(object)controller == (Object)null || (Object)(object)i.MainPlayer != (Object)(object)((Component)controller).transform))
			{
				Transform mainPlayer = i.MainPlayer;
				mainPlayer.position += delta;
			}
		}

		private static bool IsLocalMainMovement(PlayerMovementController instance)
		{
			try
			{
				return (Object)(object)instance != (Object)null && (Object)(object)instance == (Object)(object)NetworkSingleton<TextChannelManager>.I?.MainMovementController;
			}
			catch
			{
				return false;
			}
		}

		private static void ApplyPosition(PlayerMovementController instance, CharacterController controller, Vector3 target)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)controller != (Object)null)
			{
				((Component)controller).transform.position = target;
			}
			if ((Object)(object)instance != (Object)null)
			{
				((Component)instance).transform.position = target;
			}
			TextChannelManager i = NetworkSingleton<TextChannelManager>.I;
			if ((Object)(object)i?.MainPlayer != (Object)null)
			{
				i.MainPlayer.position = target;
			}
		}

		private static Vector3 Flatten(Vector3 value)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			value.y = 0f;
			if (!(((Vector3)(ref value)).sqrMagnitude <= 0.0001f))
			{
				return ((Vector3)(ref value)).normalized;
			}
			return Vector3.zero;
		}
	}
	[HarmonyPatch(typeof(InventoryManager), "DecreaseItemCount")]
	internal static class UnlimitedConsumablesPatch
	{
		private unsafe static bool Prefix(ShopItemType itemType)
		{
			if (!Plugin.ShouldApplyUnlimitedConsumables)
			{
				return true;
			}
			return !UnlimitedConsumablesPolicy.IsUnlimitedConsumable(((object)(*(ShopItemType*)(&itemType))/*cast due to .constrained prefix*/).ToString());
		}
	}
	[HarmonyPatch]
	internal static class VoicePositionRateGuardPatch
	{
		private sealed class PositionState
		{
			internal WeakReference Participant;

			internal float LastForwardedAt = -1f;

			internal float LastSeenAt;

			internal string Channel = string.Empty;
		}

		private const int MaximumTrackedObjects = 64;

		private const float StaleStateSeconds = 30f;

		private static readonly Dictionary<int, PositionState> States = new Dictionary<int, PositionState>();

		private static readonly object TargetResolutionSync = new object();

		private static MethodBase _targetMethod;

		private static bool _targetResolutionAttempted;

		private static float _nextPruneAt;

		private static long _forwarded;

		private static long _suppressed;

		private static bool _activationLogged;

		[HarmonyPrepare]
		private static bool Prepare()
		{
			bool num = TargetMethod() != null;
			if (!num)
			{
				ManualLogSource log = Plugin.Log;
				if (log == null)
				{
					return num;
				}
				log.LogWarning((object)"Vivox 3D-position rate guard is unavailable on this game build; the original call path remains untouched.");
			}
			return num;
		}

		[HarmonyTargetMethod]
		private static MethodBase TargetMethod()
		{
			lock (TargetResolutionSync)
			{
				if (_targetResolutionAttempted)
				{
					return _targetMethod;
				}
				try
				{
					Type type = AccessTools.TypeByName("Unity.Services.Vivox.VivoxServiceInternal");
					if (type != null)
					{
						_targetMethod = AccessTools.Method(type, "Set3DPosition", new Type[3]
						{
							typeof(GameObject),
							typeof(string),
							typeof(bool)
						}, (Type[])null);
					}
				}
				finally
				{
					_targetResolutionAttempted = true;
				}
				return _targetMethod;
			}
		}

		[HarmonyPrefix]
		private static bool Prefix(GameObject participantObject, string channelName)
		{
			if (Plugin.EnableVivoxPositionRateGuard == null || !Plugin.EnableVivoxPositionRateGuard.Value)
			{
				return true;
			}
			if ((Object)(object)participantObject == (Object)null || string.IsNullOrWhiteSpace(channelName))
			{
				return true;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			PruneIfNeeded(realtimeSinceStartup);
			int instanceID = ((Object)participantObject).GetInstanceID();
			if (!States.TryGetValue(instanceID, out var value) || value.Participant == null || value.Participant.Target != participantObject)
			{
				if (States.Count >= 64)
				{
					States.Clear();
				}
				value = new PositionState
				{
					Participant = new WeakReference(participantObject)
				};
				States[instanceID] = value;
			}
			value.LastSeenAt = realtimeSinceStartup;
			if (!VoicePositionRatePolicy.ShouldForward(realtimeSinceStartup, value.LastForwardedAt, channelName, value.Channel))
			{
				_suppressed++;
				if (!_activationLogged)
				{
					_activationLogged = true;
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogInfo((object)"Vivox 3D-position safety guard active: coalescing the game's per-frame requests to 4 Hz; exact voice identities remain private.");
					}
				}
				return false;
			}
			value.LastForwardedAt = realtimeSinceStartup;
			value.Channel = channelName;
			_forwarded++;
			return true;
		}

		private static void PruneIfNeeded(float now)
		{
			if (now < _nextPruneAt && States.Count < 64)
			{
				return;
			}
			_nextPruneAt = now + 10f;
			List<int> list = new List<int>();
			foreach (KeyValuePair<int, PositionState> state in States)
			{
				PositionState value = state.Value;
				if (value == null || value.Participant == null || !value.Participant.IsAlive || now - value.LastSeenAt > 30f)
				{
					list.Add(state.Key);
				}
			}
			foreach (int item in list)
			{
				States.Remove(item);
			}
		}

		internal static string GetDiagnosticSummary()
		{
			return $"enabled={Plugin.EnableVivoxPositionRateGuard?.Value ?? false},available={_targetMethod != null},tracked={States.Count},forwarded={_forwarded},suppressed={_suppressed}";
		}
	}
}
namespace BlueSage.QoLTweaks.Data
{
	internal static class SupporterLedgerData
	{
		public static readonly SupporterTransaction[] Transactions = new SupporterTransaction[19]
		{
			new SupporterTransaction("2026-07-06 21:12 UTC", "Marbles", "Thank you for all of your constant hard work in creating mods for On Together and maintaining such a positive, safe, and  supportive server for everyone. ", "20.00"),
			new SupporterTransaction("2026-07-15 00:58 UTC", "Nell", "Share with Rowan!!!", "20.00"),
			new SupporterTransaction("2026-07-15 20:58 UTC", "Anon", "Thank you for your mods!! Wishing you the best! :)", "10.00"),
			new SupporterTransaction("2026-07-17 22:55 UTC", "Dawn", "Thanks for hosting a great community, made many friends thanks to you", "5.00"),
			new SupporterTransaction("2026-07-17 23:06 UTC", "Forty", "Thanks for giving me a lil community to work with <3", "2.00"),
			new SupporterTransaction("2026-07-17 23:26 UTC", "keke", "thank you for all you've done in the OT community!! we appreciate you!!", "20.00"),
			new SupporterTransaction("2026-07-17 23:29 UTC", "Brettknee", "Thank you for this little world. I'm new to it, but I already feel at home <3", "2.00"),
			new SupporterTransaction("2026-07-17 23:29 UTC", "smorescubed", "", "50.00"),
			new SupporterTransaction("2026-07-17 23:34 UTC", "smorescubed", "", "50.00"),
			new SupporterTransaction("2026-07-17 23:50 UTC", "smorescubed", "", "20.00"),
			new SupporterTransaction("2026-07-18 00:04 UTC", "Lexiaphantasia", "You do amazing work! <3 Appreciate it.", "50.00"),
			new SupporterTransaction("2026-07-18 00:10 UTC", "ShyGuy", "For the price of an average coffee from a certain barnes and noble-affiliated cafe, it's worth contributing even a little to someone who is doing something so big for the community.", "10.00"),
			new SupporterTransaction("2026-07-18 00:49 UTC", "Marbles", "It's not about the mods. You've created a community. ", "50.00"),
			new SupporterTransaction("2026-07-18 01:16 UTC", "smorescubed", "<333", "2.00"),
			new SupporterTransaction("2026-07-18 01:25 UTC", "Akayra", "Look at you, building communities and stuff! Hang in there bud!", "100.00"),
			new SupporterTransaction("2026-07-18 04:08 UTC", "Ashcan", "Thank you for the community you’ve built! I’m always excited to get online to see my “coworkers.” ", "20.00"),
			new SupporterTransaction("2026-07-18 23:29 UTC", "Lily1chan", "hey blue!! its lily :D not sure if u remember me! but a little birdie told me you've been struggling the past few weeks. I dont have much... but I hope this will help a bit! thank you so much for being super kind, your community has been one of the lovelist ive been a part of! ", "2.00"),
			new SupporterTransaction("2026-07-25 15:31 UTC", "Neonicalle", "Thanks for all your help in the community! Mods aside (though they are great), you've made a corner of the internet a cosier place!", "15.00"),
			new SupporterTransaction("2026-07-25 19:32 UTC", "Bochi", "You're a great person blue, and I love the community you've built! Wish I could hang out in game but its lags, though I love hanging out and chatting in the discord! Keep up the good work, and thanks for being an awesome friend! ♥", "50.00")
		};
	}
}
namespace BlueSage.QoLTweaks.Contracts
{
	public static class BlueSageExtensionAbiV1
	{
		public const int Version = 1;

		public const long MaximumContributionLifetimeTicks = 50000000L;

		public const long MaximumRequestFutureSkewTicks = 20000000L;
	}
	public interface IBlueSageIdentityTruthV1
	{
		ulong SteamId { get; }

		ulong PurrNetId { get; }

		long LobbyEpoch { get; }

		long EvidenceGeneration { get; }
	}
	public readonly struct BlueSageIdentityTruthSnapshotV1 : IBlueSageIdentityTruthV1
	{
		public ulong SteamId { get; }

		public ulong PurrNetId { get; }

		public long LobbyEpoch { get; }

		public long EvidenceGeneration { get; }

		public long CapturedUtcTicks { get; }

		public long FreshUntilUtcTicks { get; }

		public BlueSageIdentityTruthSnapshotV1(ulong steamId, ulong purrNetId, long lobbyEpoch, long evidenceGeneration, long capturedUtcTicks, long freshUntilUtcTicks)
		{
			SteamId = steamId;
			PurrNetId = purrNetId;
			LobbyEpoch = lobbyEpoch;
			EvidenceGeneration = evidenceGeneration;
			CapturedUtcTicks = capturedUtcTicks;
			FreshUntilUtcTicks = freshUntilUtcTicks;
		}
	}
	public readonly struct BlueSageBadgeContributionRequestV1 : IBlueSageIdentityTruthV1
	{
		public ulong SteamId { get; }

		public ulong PurrNetId { get; }

		public long LobbyEpoch { get; }

		public long EvidenceGeneration { get; }

		public long Nonce { get; }

		public long IssuedUtcTicks { get; }

		public BlueSageBadgeContributionRequestV1(ulong steamId, ulong purrNetId, long lobbyEpoch, long evidenceGeneration, long nonce, long issuedUtcTicks)
		{
			SteamId = steamId;
			PurrNetId = purrNetId;
			LobbyEpoch = lobbyEpoch;
			EvidenceGeneration = evidenceGeneration;
			Nonce = nonce;
			IssuedUtcTicks = issuedUtcTicks;
		}
	}
	public readonly struct BlueSageBadgeContributionResponseV1
	{
		public bool CreatorPresent { get; }

		public long LobbyEpoch { get; }

		public long EvidenceGeneration { get; }

		public long Nonce { get; }

		public long FreshUntilUtcTicks { get; }

		public BlueSageBadgeContributionResponseV1(bool creatorPresent, long lobbyEpoch, long evidenceGeneration, long nonce, long freshUntilUtcTicks)
		{
			CreatorPresent = creatorPresent;
			LobbyEpoch = lobbyEpoch;
			EvidenceGeneration = evidenceGeneration;
			Nonce = nonce;
			FreshUntilUtcTicks = freshUntilUtcTicks;
		}
	}
	public interface IBlueSageBadgeContributionV1
	{
		BlueSageBadgeContributionResponseV1 GetBadgeContribution(BlueSageBadgeContributionRequestV1 request);
	}
	public enum BlueSageDiagnosticsOverlayStateV1
	{
		Unavailable,
		Hidden,
		Visible
	}
	public enum BlueSageDiagnosticsFreshnessV1
	{
		Unavailable,
		Fresh,
		Stale
	}
	public readonly struct BlueSageDiagnosticsSnapshotV1
	{
		public BlueSageDiagnosticsOverlayStateV1 OverlayState { get; }

		public BlueSageDiagnosticsFreshnessV1 Freshness { get; }

		public int IntervalMilliseconds { get; }

		public long CapturedUtcTicks { get; }

		public long FreshUntilUtcTicks { get; }

		public BlueSageDiagnosticsSnapshotV1(BlueSageDiagnosticsOverlayStateV1 overlayState, BlueSageDiagnosticsFreshnessV1 freshness, int intervalMilliseconds, long capturedUtcTicks, long freshUntilUtcTicks)
		{
			OverlayState = overlayState;
			Freshness = freshness;
			IntervalMilliseconds = BlueSageDiagnosticsPolicyV1.ClampIntervalMilliseconds(intervalMilliseconds);
			CapturedUtcTicks = capturedUtcTicks;
			FreshUntilUtcTicks = freshUntilUtcTicks;
		}
	}
	public interface IBlueSageDiagnosticsProviderV1
	{
		BlueSageDiagnosticsSnapshotV1 GetSnapshot(long nowUtcTicks);
	}
	public interface IBlueSageDiagnosticsControlV2
	{
		bool TrySetOverlayVisible(bool visible);
	}
	public enum BlueSageHostCapabilityStateV1
	{
		Unavailable,
		Ready,
		Degraded
	}
	[Flags]
	public enum BlueSageHostCapabilityActionMaskV1
	{
		None = 0,
		RefreshSnapshot = 1,
		ResetMovement = 2,
		RescueLocalPlayer = 4,
		AuditNativeModeration = 8
	}
	public enum BlueSageHostCapabilityActionV1
	{
		RefreshSnapshot,
		ResetMovement,
		RescueLocalPlayer,
		AuditNativeModeration
	}
	public readonly struct BlueSageHostCapabilityRequestV1
	{
		public long LobbyEpoch { get; }

		public long EvidenceGeneration { get; }

		public bool IsHost { get; }

		public long Nonce { get; }

		public long IssuedUtcTicks { get; }

		public BlueSageHostCapabilityRequestV1(long lobbyEpoch, long evidenceGeneration, bool isHost, long nonce, long issuedUtcTicks)
		{
			LobbyEpoch = lobbyEpoch;
			EvidenceGeneration = evidenceGeneration;
			IsHost = isHost;
			Nonce = nonce;
			IssuedUtcTicks = issuedUtcTicks;
		}
	}
	public readonly struct BlueSageHostCapabilitySnapshotV1
	{
		public BlueSageHostCapabilityStateV1 State { get; }

		public string Title { get; }

		public string Summary { get; }

		public long LobbyEpoch { get; }

		public long EvidenceGeneration { get; }

		public long Nonce { get; }

		public long CapturedUtcTicks { get; }

		public long FreshUntilUtcTicks { get; }

		public BlueSageHostCapabilityActionMaskV1 Actions { get; }

		public BlueSageHostCapabilitySnapshotV1(BlueSageHostCapabilityStateV1 state, string title, string summary, long lobbyEpoch, long evidenceGeneration, long nonce, long capturedUtcTicks, long freshUntilUtcTicks, BlueSageHostCapabilityActionMaskV1 actions)
		{
			State = state;
			Title = title ?? string.Empty;
			Summary = summary ?? string.Empty;
			LobbyEpoch = lobbyEpoch;
			EvidenceGeneration = evidenceGeneration;
			Nonce = nonce;
			CapturedUtcTicks = capturedUtcTicks;
			FreshUntilUtcTicks = freshUntilUtcTicks;
			Actions = actions;
		}
	}
	public readonly struct BlueSageHostCapabilityReceiptV1
	{
		public bool Succeeded { get; }

		public string Message { get; }

		public long LobbyEpoch { get; }

		public long EvidenceGeneration { get; }

		public long Nonce { get; }

		public long CompletedUtcTicks { get; }

		public BlueSageHostCapabilityReceiptV1(bool succeeded, string message, long lobbyEpoch, long evidenceGeneration, long nonce, long completedUtcTicks)
		{
			Succeeded = succeeded;
			Message = message ?? string.Empty;
			LobbyEpoch = lobbyEpoch;
			EvidenceGeneration = evidenceGeneration;
			Nonce = nonce;
			CompletedUtcTicks = completedUtcTicks;
		}
	}
	public interface IBlueSageHostCapabilityProviderV1
	{
		BlueSageHostCapabilitySnapshotV1 GetSnapshot(BlueSageHostCapabilityRequestV1 request);

		BlueSageHostCapabilityReceiptV1 TryExecute(BlueSageHostCapabilityActionV1 action, BlueSageHostCapabilityRequestV1 request);
	}
	public static class BlueSageDiagnosticsPolicyV1
	{
		public const int MinimumIntervalMilliseconds = 100;

		public const int MaximumIntervalMilliseconds = 5000;

		public static int ClampIntervalMilliseconds(int requested)
		{
			if (requested < 100)
			{
				return 100;
			}
			if (requested > 5000)
			{
				return 5000;
			}
			return requested;
		}
	}
	public readonly struct BlueSageExtensionRegistrationTokenV1
	{
		public long Generation { get; }

		public bool IsValid => Generation > 0;

		public BlueSageExtensionRegistrationTokenV1(long generation)
		{
			Generation = generation;
		}
	}
	internal readonly struct BlueSageLoadedExtensionV1
	{
		internal Assembly OwnerAssembly { get; }

		internal Version Version { get; }

		internal bool Loaded { get; }

		internal BlueSageLoadedExtensionV1(Assembly ownerAssembly, Version version, bool loaded)
		{
			OwnerAssembly = ownerAssembly;
			Version = version;
			Loaded = loaded;
		}
	}
	internal interface IBlueSageLoadedExtensionCatalogV1
	{
		bool TryGetLoaded(string pluginGuid, out BlueSageLoadedExtensionV1 extension);
	}
	internal sealed class BlueSageExtensionRegistryCore
	{
		private readonly IBlueSageLoadedExtensionCatalogV1 _catalog;

		private IBlueSageBadgeContributionV1 _badgeProvider;

		private string _badgeOwnerGuid = string.Empty;

		private Version _badgeOwnerVersion;

		private Assembly _badgeOwnerAssembly;

		private IBlueSageDiagnosticsProviderV1 _diagnosticsProvider;

		private string _diagnosticsOwnerGuid = string.Empty;

		private Version _diagnosticsOwnerVersion;

		private Assembly _diagnosticsOwnerAssembly;

		private IBlueSageHostCapabilityProviderV1 _hostCapabilityProvider;

		private string _hostCapabilityOwnerGuid = string.Empty;

		private Version _hostCapabilityOwnerVersion;

		private Assembly _hostCapabilityOwnerAssembly;

		private long _registrationGeneration;

		private long _badgeRegistrationGeneration;

		private long _diagnosticsRegistrationGeneration;

		private long _hostCapabilityRegistrationGeneration;

		private long _lobbyEpoch;

		private long _evidenceGeneration;

		private long _badgeLobbyEpoch;

		private long _badgeEvidenceGeneration;

		internal BlueSageExtensionRegistryCore(IBlueSageLoadedExtensionCatalogV1 catalog)
		{
			_catalog = catalog ?? throw new ArgumentNullException("catalog");
		}

		internal BlueSageExtensionRegistrationTokenV1 RegisterBadgeContribution(IBlueSageBadgeContributionV1 provider, string ownerGuid, Version ownerVersion, int abiVersion)
		{
			if (_badgeProvider != null || provider == null || string.IsNullOrWhiteSpace(ownerGuid) || ownerVersion == null || abiVersion != 1 || !_catalog.TryGetLoaded(ownerGuid, out var extension) || !IsExactLoadedOwner(provider, ownerVersion, extension))
			{
				return default(BlueSageExtensionRegistrationTokenV1);
			}
			BlueSageExtensionRegistrationTokenV1 result = NextRegistrationToken();
			_badgeProvider = provider;
			_badgeOwnerGuid = ownerGuid;
			_badgeOwnerVersion = ownerVersion;
			_badgeOwnerAssembly = provider.GetType().Assembly;
			_badgeRegistrationGeneration = result.Generation;
			return result;
		}

		internal BlueSageExtensionRegistrationTokenV1 RegisterDiagnostics(IBlueSageDiagnosticsProviderV1 provider, string ownerGuid, Version ownerVersion, int abiVersion)
		{
			return RegisterDiagnostics(provider, ownerGuid, ownerVersion, abiVersion, provider?.GetType().Assembly);
		}

		internal BlueSageExtensionRegistrationTokenV1 RegisterDiagnostics(IBlueSageDiagnosticsProviderV1 provider, string ownerGuid, Version ownerVersion, int abiVersion, Assembly ownerAssembly)
		{
			if (_diagnosticsProvider != null || provider == null || ownerAssembly == null || string.IsNullOrWhiteSpace(ownerGuid) || ownerVersion == null || abiVersion != 1 || !_catalog.TryGetLoaded(ownerGuid, out var extension) || !IsExactLoadedOwner(ownerAssembly, ownerVersion, extension))
			{
				return default(BlueSageExtensionRegistrationTokenV1);
			}
			BlueSageExtensionRegistrationTokenV1 result = NextRegistrationToken();
			_diagnosticsProvider = provider;
			_diagnosticsOwnerGuid = ownerGuid;
			_diagnosticsOwnerVersion = ownerVersion;
			_diagnosticsOwnerAssembly = ownerAssembly;
			_diagnosticsRegistrationGeneration = result.Generation;
			return result;
		}

		internal BlueSageExtensionRegistrationTokenV1 RegisterHostCapability(IBlueSageHostCapabilityProviderV1 provider, string ownerGuid, Version ownerVersion, int abiVersion)
		{
			if (_hostCapabilityProvider != null || provider == null || string.IsNullOrWhiteSpace(ownerGuid) || ownerVersion == null || abiVersion != 1 || !_catalog.TryGetLoaded(ownerGuid, out var extension) || !IsExactLoadedOwner(provider, ownerVersion, extension))
			{
				return default(BlueSageExtensionRegistrationTokenV1);
			}
			BlueSageExtensionRegistrationTokenV1 result = NextRegistrationToken();
			_hostCapabilityProvider = provider;
			_hostCapabilityOwnerGuid = ownerGuid;
			_hostCapabilityOwnerVersion = ownerVersion;
			_hostCapabilityOwnerAssembly = provider.GetType().Assembly;
			_hostCapabilityRegistrationGeneration = result.Generation;
			return result;
		}

		internal bool Unregister(BlueSageExtensionRegistrationTokenV1 token)
		{
			if (UnregisterBadgeContribution(token))
			{
				return true;
			}
			if (UnregisterDiagnostics(token))
			{
				return true;
			}
			return UnregisterHostCapability(token);
		}

		internal bool UnregisterBadgeContribution(BlueSageExtensionRegistrationTokenV1 token)
		{
			if (_badgeProvider == null || !token.IsValid || token.Generation != _badgeRegistrationGeneration)
			{
				return false;
			}
			ClearBadgeProvider();
			return true;
		}

		internal bool UnregisterDiagnostics(BlueSageExtensionRegistrationTokenV1 token)
		{
			if (_diagnosticsProvider == null || !token.IsValid || token.Generation != _diagnosticsRegistrationGeneration)
			{
				return false;
			}
			ClearDiagnosticsProvider();
			return true;
		}

		internal bool UnregisterHostCapability(BlueSageExtensionRegistrationTokenV1 token)
		{
			if (_hostCapabilityProvider == null || !token.IsValid || token.Generation != _hostCapabilityRegistrationGeneration)
			{
				return false;
			}
			ClearHostCapabilityProvider();
			return true;
		}

		internal void SetEvidenceContext(long lobbyEpoch, long evidenceGeneration)
		{
			if (lobbyEpoch <= 0 || evidenceGeneration <= 0)
			{
				_lobbyEpoch = 0L;
				_evidenceGeneration = 0L;
				_badgeLobbyEpoch = 0L;
				_badgeEvidenceGeneration = 0L;
			}
			else
			{
				_lobbyEpoch = lobbyEpoch;
				_evidenceGeneration = evidenceGeneration;
				_badgeLobbyEpoch = lobbyEpoch;
				_badgeEvidenceGeneration = evidenceGeneration;
			}
		}

		internal void SetBadgeEvidenceContext(long lobbyEpoch, long evidenceGeneration)
		{
			if (lobbyEpoch <= 0 || evidenceGeneration <= 0)
			{
				_badgeLobbyEpoch = 0L;
				_badgeEvidenceGeneration = 0L;
			}
			else
			{
				_badgeLobbyEpoch = lobbyEpoch;
				_badgeEvidenceGeneration = evidenceGeneration;
			}
		}

		internal bool TryReadBadgeContribution(BlueSageBadgeContributionRequestV1 request, long nowUtcTicks, out BlueSageBadgeContributionResponseV1 response)
		{
			response = default(BlueSageBadgeContributionResponseV1);
			if (_badgeProvider == null || nowUtcTicks <= 0 || request.SteamId == 0L || request.PurrNetId == 0L || request.LobbyEpoch != _badgeLobbyEpoch || request.EvidenceGeneration != _badgeEvidenceGeneration || request.Nonce <= 0 || request.IssuedUtcTicks <= 0 || request.IssuedUtcTicks > nowUtcTicks + 20000000 || nowUtcTicks - request.IssuedUtcTicks > 50000000 || !_catalog.TryGetLoaded(_badgeOwnerGuid, out var extension) || !extension.Loaded || extension.OwnerAssembly != _badgeOwnerAssembly || extension.Version == null || !_badgeOwnerVersion.Equals(extension.Version))
			{
				return false;
			}
			try
			{
				BlueSageBadgeContributionResponseV1 badgeContribution = _badgeProvider.GetBadgeContribution(request);
				if (badgeContribution.LobbyEpoch != request.LobbyEpoch || badgeContribution.EvidenceGeneration != request.EvidenceGeneration || badgeContribution.Nonce != request.Nonce || badgeContribution.FreshUntilUtcTicks < nowUtcTicks || badgeContribution.FreshUntilUtcTicks > request.IssuedUtcTicks + 50000000)
				{
					return false;
				}
				response = badgeContribution;
				return true;
			}
			catch
			{
				response = default(BlueSageBadgeContributionResponseV1);
				return false;
			}
		}

		internal bool TryReadDiagnostics(long nowUtcTicks, out BlueSageDiagnosticsSnapshotV1 snapshot)
		{
			snapshot = default(BlueSageDiagnosticsSnapshotV1);
			if (_diagnosticsProvider == null || nowUtcTicks <= 0 || !_catalog.TryGetLoaded(_diagnosticsOwnerGuid, out var extension) || !extension.Loaded || extension.OwnerAssembly != _diagnosticsOwnerAssembly || extension.Version == null || !_diagnosticsOwnerVersion.Equals(extension.Version))
			{
				return false;
			}
			try
			{
				BlueSageDiagnosticsSnapshotV1 snapshot2 = _diagnosticsProvider.GetSnapshot(nowUtcTicks);
				if (!IsValidDiagnosticsSnapshot(snapshot2, nowUtcTicks))
				{
					return false;
				}
				snapshot = snapshot2;
				return true;
			}
			catch
			{
				snapshot = default(BlueSageDiagnosticsSnapshotV1);
				return false;
			}
		}

		internal bool TrySetDiagnosticsOverlayVisible(bool visible)
		{
			if (!TryGetLiveDiagnosticsOwner() || !(_diagnosticsProvider is IBlueSageDiagnosticsControlV2 blueSageDiagnosticsControlV))
			{
				return false;
			}
			try
			{
				return blueSageDiagnosticsControlV.TrySetOverlayVisible(visible);
			}
			catch
			{
				return false;
			}
		}

		internal bool TryReadHostCapability(BlueSageHostCapabilityRequestV1 request, long nowUtcTicks, out BlueSageHostCapabilitySnapshotV1 snapshot)
		{
			snapshot = default(BlueSageHostCapabilitySnapshotV1);
			if (!IsValidHostRequest(request, nowUtcTicks, requireHost: false) || !TryGetLiveHostCapabilityOwner())
			{
				return false;
			}
			try
			{
				BlueSageHostCapabilitySnapshotV1 snapshot2 = _hostCapabilityProvider.GetSnapshot(request);
				if (!Enum.IsDefined(typeof(BlueSageHostCapabilityStateV1), snapshot2.State) || snapshot2.State == BlueSageHostCapabilityStateV1.Unavailable || string.IsNullOrWhiteSpace(snapshot2.Title) || snapshot2.Title.Length > 48 || string.IsNullOrWhiteSpace(snapshot2.Summary) || snapshot2.Summary.Length > 240 || snapshot2.LobbyEpoch != request.LobbyEpoch || snapshot2.EvidenceGeneration != request.EvidenceGeneration || snapshot2.Nonce != request.Nonce || snapshot2.CapturedUtcTicks <= 0 || snapshot2.CapturedUtcTicks > nowUtcTicks + 20000000 || snapshot2.FreshUntilUtcTicks < nowUtcTicks || snapshot2.FreshUntilUtcTicks > snapshot2.CapturedUtcTicks + 50000000)
				{
					return false;
				}
				snapshot = snapshot2;
				return true;
			}
			catch
			{
				snapshot = default(BlueSageHostCapabilitySnapshotV1);
				return false;
			}
		}

		internal bool TryCreateHostCapabilityRequest(bool isHost, long nonce, long nowUtcTicks, out BlueSageHostCapabilityRequestV1 request)
		{
			request = default(BlueSageHostCapabilityRequestV1);
			if (_lobbyEpoch <= 0 || _evidenceGeneration <= 0 || nonce <= 0 || nowUtcTicks <= 0)
			{
				return false;
			}
			request = new BlueSageHostCapabilityRequestV1(_lobbyEpoch, _evidenceGeneration, isHost, nonce, nowUtcTicks);
			return true;
		}

		internal bool TryExecuteHostCapability(BlueSageHostCapabilityActionV1 action, BlueSageHostCapabilityRequestV1 request, long nowUtcTicks, out BlueSageHostCapabilityReceiptV1 receipt)
		{
			receipt = default(BlueSageHostCapabilityReceiptV1);
			if (!Enum.IsDefined(typeof(BlueSageHostCapabilityActionV1), action) || !IsValidHostRequest(request, nowUtcTicks, requireHost: true) || !TryGetLiveHostCapabilityOwner())
			{
				return false;
			}
			try
			{
				BlueSageHostCapabilityReceiptV1 blueSageHostCapabilityReceiptV = _hostCapabilityProvider.TryExecute(action, request);
				if (blueSageHostCapabilityReceiptV.LobbyEpoch != request.LobbyEpoch || blueSageHostCapabilityReceiptV.EvidenceGeneration != request.EvidenceGeneration || blueSageHostCapabilityReceiptV.Nonce != request.Nonce || blueSageHostCapabilityReceiptV.CompletedUtcTicks < request.IssuedUtcTicks || blueSageHostCapabilityReceiptV.CompletedUtcTicks > nowUtcTicks + 20000000 || string.IsNullOrWhiteSpace(blueSageHostCapabilityReceiptV.Message) || blueSageHostCapabilityReceiptV.Message.Length > 240)
				{
					return false;
				}
				receipt = blueSageHostCapabilityReceiptV;
				return true;
			}
			catch
			{
				receipt = default(BlueSageHostCapabilityReceiptV1);
				return false;
			}
		}

		private bool IsValidHostRequest(BlueSageHostCapabilityRequestV1 request, long nowUtcTicks, bool requireHost)
		{
			if (_hostCapabilityProvider != null && nowUtcTicks > 0 && (!requireHost || request.IsHost) && request.LobbyEpoch == _lobbyEpoch && request.EvidenceGeneration == _evidenceGeneration && request.Nonce > 0 && request.IssuedUtcTicks > 0 && request.IssuedUtcTicks <= nowUtcTicks + 20000000)
			{
				return nowUtcTicks - request.IssuedUtcTicks <= 50000000;
			}
			return false;
		}

		private bool TryGetLiveHostCapabilityOwner()
		{
			if (_hostCapabilityProvider != null && _catalog.TryGetLoaded(_hostCapabilityOwnerGuid, out var extension) && extension.Loaded && extension.OwnerAssembly == _hostCapabilityOwnerAssembly && extension.Version != null && _hostCapabilityOwnerVersion != null)
			{
				return _hostCapabilityOwnerVersion.Equals(extension.Version);
			}
			return false;
		}

		internal bool HasLiveHostCapabilityProvider()
		{
			return TryGetLiveHostCapabilityOwner();
		}

		private bool TryGetLiveDiagnosticsOwner()
		{
			if (_diagnosticsProvider != null && _catalog.TryGetLoaded(_diagnosticsOwnerGuid, out var extension) && extension.Loaded && extension.OwnerAssembly == _diagnosticsOwnerAssembly && extension.Version != null && _diagnosticsOwnerVersion != null)
			{
				return _diagnosticsOwnerVersion.Equals(extension.Version);
			}
			return false;
		}

		internal void Clear()
		{
			ClearBadgeProvider();
			ClearDiagnosticsProvider();
			ClearHostCapabilityProvider();
			_lobbyEpoch = 0L;
			_evidenceGeneration = 0L;
			_badgeLobbyEpoch = 0L;
			_badgeEvidenceGeneration = 0L;
		}

		private static bool IsExactLoadedOwner(object provider, Version requestedVersion, BlueSageLoadedExtensionV1 loaded)
		{
			if (loaded.Loaded && loaded.OwnerAssembly != null && (object)loaded.OwnerAssembly == provider.GetType().Assembly && loaded.Version != null)
			{
				return requestedVersion.Equals(loaded.Version);
			}
			return false;
		}

		private static bool IsExactLoadedOwner(Assembly ownerAssembly, Version requestedVersion, BlueSageLoadedExtensionV1 loaded)
		{
			if (loaded.Loaded && loaded.OwnerAssembly != null && (object)loaded.OwnerAssembly == ownerAssembly && loaded.Version != null)
			{
				return requestedVersion.Equals(loaded.Version);
			}
			return false;
		}

		private BlueSageExtensionRegistrationTokenV1 NextRegistrationToken()
		{
			_registrationGeneration++;
			if (_registrationGeneration <= 0)
			{
				_registrationGeneration = 1L;
			}
			return new BlueSageExtensionRegistrationTokenV1(_registrationGeneration);
		}

		private static bool IsValidDiagnosticsSnapshot(BlueSageDiagnosticsSnapshotV1 snapshot, long nowUtcTicks)
		{
			if (!Enum.IsDefined(typeof(BlueSageDiagnosticsOverlayStateV1), snapshot.OverlayState) || !Enum.IsDefined(typeof(BlueSageDiagnosticsFreshnessV1), snapshot.Freshness) || snapshot.IntervalMilliseconds < 100 || snapshot.IntervalMilliseconds > 5000)
			{
				return false;
			}
			bool flag = snapshot.OverlayState == BlueSageDiagnosticsOverlayStateV1.Unavailable;
			bool flag2 = snapshot.Freshness == BlueSageDiagnosticsFreshnessV1.Unavailable;
			if (flag || flag2)
			{
				if (flag && flag2 && snapshot.CapturedUtcTicks == 0L)
				{
					return snapshot.FreshUntilUtcTicks == 0;
				}
				return false;
			}
			if (snapshot.CapturedUtcTicks <= 0 || snapshot.CapturedUtcTicks > nowUtcTicks + 20000000 || snapshot.FreshUntilUtcTicks <= 0 || snapshot.FreshUntilUtcTicks > snapshot.CapturedUtcTicks + 50000000)
			{
				return false;
			}
			return snapshot.Freshness switch
			{
				BlueSageDiagnosticsFreshnessV1.Fresh => snapshot.FreshUntilUtcTicks >= nowUtcTicks, 
				BlueSageDiagnosticsFreshnessV1.Stale => snapshot.FreshUntilUtcTicks < nowUtcTicks, 
				_ => false, 
			};
		}

		private void ClearBadgeProvider()
		{
			_badgeProvider = null;
			_badgeOwnerGuid = string.Empty;
			_badgeOwnerVersion = null;
			_badgeOwnerAssembly = null;
			_badgeRegistrationGeneration = 0L;
		}

		private void ClearDiagnosticsProvider()
		{
			_diagnosticsProvider = null;
			_diagnosticsOwnerGuid = string.Empty;
			_diagnosticsOwnerVersion = null;
			_diagnosticsOwnerAssembly = null;
			_diagnosticsRegistrationGeneration = 0L;
		}

		private void ClearHostCapabilityProvider()
		{
			_hostCapabilityProvider = null;
			_hostCapabilityOwnerGuid = string.Empty;
			_hostCapabilityOwnerVersion = null;
			_hostCapabilityOwnerAssembly = null;
			_hostCapabilityRegistrationGeneration = 0L;
		}
	}
}
namespace BlueSage.QoLTweaks.Core
{
	internal sealed class AuditMirrorTransferBuffer
	{
		internal const int Capacity = 65536;

		private byte[] _buffer;

		internal int AllocationCount { get; private set; }

		internal byte[] Acquire(long sourceLength, long sourceOffset, int maximumBytes)
		{
			if (maximumBytes <= 0 || sourceOffset < 0 || sourceOffset >= sourceLength)
			{
				return null;
			}
			if (_buffer == null)
			{
				_buffer = new byte[65536];
				AllocationCount++;
			}
			return _buffer;
		}
	}
	internal static class AuditSnapshotPolicy
	{
		public const int MaxRetainedSnapshots = 8;

		public static bool TryCreate(string sourceLogPath, string sessionDirectory, DateTime utcNow, string nonce, out string snapshotDirectory, out long capturedBytes, out string error)
		{
			snapshotDirectory = string.Empty;
			capturedBytes = 0L;
			error = string.Empty;
			string text = string.Empty;
			try
			{
				if (string.IsNullOrWhiteSpace(sourceLogPath) || !File.Exists(sourceLogPath))
				{
					throw new FileNotFoundException("The true BepInEx LogOutput.log was not found.", sourceLogPath);
				}
				if (string.IsNullOrWhiteSpace(sessionDirectory))
				{
					throw new ArgumentException("The audit session directory is unavailable.", "sessionDirectory");
				}
				string text2 = NormalizeNonce(nonce);
				string text3 = Path.Combine(Path.GetFullPath(sessionDirectory), "snapshots");
				Directory.CreateDirectory(text3);
				string path = "snapshot-" + utcNow.ToUniversalTime().ToString("yyyyMMdd'T'HHmmssfff'Z'", CultureInfo.InvariantCulture) + "-" + text2;
				snapshotDirectory = Path.Combine(text3, path);
				Directory.CreateDirectory(snapshotDirectory);
				string destFileName = Path.Combine(snapshotDirectory, "LogOutput.log");
				text = Path.Combine(snapshotDirectory, "LogOutput.log.tmp");
				using (FileStream fileStream = new FileStream(sourceLogPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete, 65536, FileOptions.SequentialScan))
				{
					long length = fileStream.Length;
					using FileStream fileStream2 = new FileStream(text, FileMode.CreateNew, FileAccess.Write, FileShare.None, 65536, FileOptions.SequentialScan);
					byte[] array = new byte[65536];
					while (capturedBytes < length)
					{
						int count = (int)Math.Min(array.Length, length - capturedBytes);
						int num = fileStream.Read(array, 0, count);
						if (num <= 0)
						{
							throw new EndOfStreamException("The live BepInEx log changed before its captured boundary could be copied.");
						}
						fileStream2.Write(array, 0, num);
						capturedBytes += num;
					}
					fileStream2.Flush(flushToDisk: true);
				}
				File.Move(text, destFileName);
				PruneSnapshots(text3, snapshotDirectory);
				return true;
			}
			catch (Exception ex)
			{
				error = ex.Message;
				TryDeleteFile(text);
				TryDeleteEmptyDirectory(snapshotDirectory);
				snapshotDirectory = string.Empty;
				capturedBytes = 0L;
				return false;
			}
		}

		private static string NormalizeNonce(string nonce)
		{
			string text = new string((nonce ?? string.Empty).Where(char.IsLetterOrDigit).Take(16).ToArray()).ToLowerInvariant();
			if (text.Length < 4)
			{
				throw new ArgumentException("Snapshot nonce must contain at least four letters or digits.", "nonce");
			}
			return text;
		}

		private static void PruneSnapshots(string snapshotsRoot, string keepDirectory)
		{
			string text = Path.GetFullPath(snapshotsRoot).TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
			char directorySeparatorChar = Path.DirectorySeparatorChar;
			string value = text + directorySeparatorChar;
			string fullPath = Path.GetFullPath(keepDirectory);
			foreach (DirectoryInfo item in new DirectoryInfo(snapshotsRoot).GetDirectories("snapshot-*").OrderByDescending<DirectoryInfo, string>((DirectoryInfo directory) => directory.Name, StringComparer.Ordinal).ToList()
				.Skip(8))
			{
				string fullPath2 = Path.GetFullPath(item.FullName);
				if (fullPath2.StartsWith(value, StringComparison.OrdinalIgnoreCase) && !string.Equals(fullPath2, fullPath, StringComparison.OrdinalIgnoreCase))
				{
					item.Delete(recursive: true);
				}
			}
		}

		private static void TryDeleteFile(string path)
		{
			try
			{
				if (!string.IsNullOrEmpty(path) && File.Exists(path))
				{
					File.Delete(path);
				}
			}
			catch
			{
			}
		}

		private static void TryDeleteEmptyDirectory(string path)
		{
			try
			{
				if (!string.IsNullOrEmpty(path) && Directory.Exists(path) && !Directory.EnumerateFileSystemEntries(path).Any())
				{
					Directory.Delete(path);
				}
			}
			catch
			{
			}
		}
	}
	internal static class AuthoritativeChatSenderPolicy
	{
		public static bool ContainsLobbyPingToken(string message)
		{
			if (string.IsNullOrWhiteSpace(message))
			{
				return false;
			}
			foreach (Match item in MentionNamePolicy.MentionReferenceRegex.Matches(message))
			{
				if (string.Equals(item.Groups[1].Value, "lobby", StringComparison.OrdinalIgnoreCase))
				{
					if (item.Index == 0)
					{
						return true;
					}
					char c = message[item.Index - 1];
					if (!char.IsLetterOrDigit(c) && c != '_' && c != '@')
					{
						return true;
					}
				}
			}
			return false;
		}

		public static bool TryResolveUniqueIndex<T>(T senderPlayerId, IReadOnlyList<T> playerIds, out int index)
		{
			index = -1;
			if (playerIds == null || playerIds.Count == 0)
			{
				return false;
			}
			EqualityComparer<T> equalityComparer = EqualityComparer<T>.Default;
			for (int i = 0; i < playerIds.Count; i++)
			{
				if (equalityComparer.Equals(senderPlayerId, playerIds[i]))
				{
					if (index >= 0)
					{
						index = -1;
						return false;
					}
					index = i;
				}
			}
			return index >= 0;
		}
	}
	internal static class AuthoritativePlayerRowReconciliationPolicy
	{
		internal static int Reconcile(bool authoritativeCoverageComplete, IReadOnlyCollection<int> currentRowInstanceIds, IEnumerable<int> ownedRowInstanceIds, Action<int> pruneOwnedRow)
		{
			if (!authoritativeCoverageComplete || currentRowInstanceIds == null || currentRowInstanceIds.Count == 0 || ownedRowInstanceIds == null || pruneOwnedRow == null)
			{
				return 0;
			}
			HashSet<int> currentRows = new HashSet<int>();
			foreach (int currentRowInstanceId in currentRowInstanceIds)
			{
				if (currentRowInstanceId == 0 || !currentRows.Add(currentRowInstanceId))
				{
					return 0;
				}
			}
			int[] array = ownedRowInstanceIds.Where((int rowInstanceId) => rowInstanceId != 0 && !currentRows.Contains(rowInstanceId)).Distinct().ToArray();
			int[] array2 = array;
			foreach (int obj in array2)
			{
				pruneOwnedRow(obj);
			}
			return array.Length;
		}
	}
	internal struct BadgeTooltipLayout
	{
		public float X { get; }

		public float Y { get; }

		public float Width { get; }

		public float Height { get; }

		public BadgeTooltipLayout(float x, float y, float width, float height)
		{
			X = x;
			Y = y;
			Width = width;
			Height = height;
		}
	}
	internal static class BadgeTooltipLayoutPolicy
	{
		private const float ScreenMargin = 8f;

		private const float PointerGap = 14f;

		private const float MaximumContentHeight = 240f;

		public static BadgeTooltipLayout Resolve(float screenWidth, float screenHeight, float pointerX, float pointerY, float requestedWidth, float measuredHeight, float scale)
		{
			float margin = GetMargin(screenHeight);
			float val = Math.Max(0f, screenHeight - margin * 2f);
			float margin2 = GetMargin(screenWidth);
			float num = ResolveWidth(screenWidth, requestedWidth);
			float val2 = 240f * Math.Max(0f, scale);
			float num2 = Clamp(measuredHeight, 0f, Math.Min(val2, val));
			float num3 = margin2;
			float maximum = Math.Max(num3, screenWidth - num - margin2);
			float num4 = pointerX - num - 14f;
			float value = ((num4 >= num3) ? num4 : (pointerX + 14f));
			float num5 = margin;
			float num6 = Math.Max(num5, screenHeight - num2 - margin);
			float num7 = pointerY + 14f;
			float value2 = ((num7 <= num6) ? num7 : (pointerY - num2 - 14f));
			return new BadgeTooltipLayout(Clamp(value, num3, maximum), Clamp(value2, num5, num6), num, num2);
		}

		public static float ResolveWidth(float screenWidth, float requestedWidth)
		{
			float margin = GetMargin(screenWidth);
			float maximum = Math.Max(0f, screenWidth - margin * 2f);
			return Clamp(requestedWidth, 0f, maximum);
		}

		private static float GetMargin(float screenSize)
		{
			return Math.Min(8f, Math.Max(0f, screenSize) / 2f);
		}

		private static float Clamp(float value, float minimum, float maximum)
		{
			if (value < minimum)
			{
				return minimum;
			}
			if (value > maximum)
			{
				return maximum;
			}
			return value;
		}
	}
	internal sealed class BlueSageCommand
	{
		public string Name { get; }

		public string Description { get; }

		public IReadOnlyList<string> Aliases { get; }

		public Func<BlueSageCommandContext, BlueSageCommandResult> Handler { get; }

		public bool IsHidden { get; }

		public BlueSageCommand(string name, string description, IEnumerable<string> aliases, Func<BlueSageCommandContext, BlueSageCommandResult> handler, bool isHidden = false)
		{
			Name = NormalizeName(name);
			Description = description ?? string.Empty;
			Aliases = (from alias in (aliases ?? Enumerable.Empty<string>()).Select(NormalizeName)
				where alias.Length > 0
				select alias).Distinct<string>(StringComparer.OrdinalIgnoreCase).ToArray();
			Handler = handler ?? throw new ArgumentNullException("handler");
			IsHidden = isHidden;
		}

		public bool Matches(string commandName)
		{
			string normalized = NormalizeName(commandName);
			if (!string.Equals(Name, normalized, StringComparison.OrdinalIgnoreCase))
			{
				return Aliases.Any((string alias) => string.Equals(alias, normalized, StringComparison.OrdinalIgnoreCase));
			}
			return true;
		}

		public bool CouldMatch(string commandPrefix)
		{
			string normalized = NormalizeName(commandPrefix);
			if (!Name.StartsWith(normalized, StringComparison.OrdinalIgnoreCase))
			{
				return Aliases.Any((string alias) => alias.StartsWith(normalized, StringComparison.OrdinalIgnoreCase));
			}
			return true;
		}

		private static string NormalizeName(string value)
		{
			return (value ?? string.Empty).Trim().TrimStart(new char[1] { '/' }).ToLowerInvariant();
		}
	}
	internal sealed class BlueSageCommandContext
	{
		public string RawInput { get; }

		public string CommandName { get; }

		public string Arguments { get; }

		public IReadOnlyList<string> Tokens { get; }

		public BlueSageCommandContext(string rawInput, string commandName, string arguments)
		{
			RawInput = rawInput ?? string.Empty;
			CommandName = commandName ?? string.Empty;
			Arguments = arguments ?? string.Empty;
			Tokens = Arguments.Split(new char[1] { ' ' }, StringSplitOptions.RemoveEmptyEntries).ToArray();
		}
	}
	internal sealed class BlueSageCommandResult
	{
		public bool Handled { get; }

		public IReadOnlyList<string> Messages { get; }

		private BlueSageCommandResult(bool handled, IEnumerable<string> messages)
		{
			Handled = handled;
			Messages = (messages ?? Enumerable.Empty<string>()).Where((string message) => !string.IsNullOrWhiteSpace(message)).ToArray();
		}

		public static BlueSageCommandResult Unhandled()
		{
			return new BlueSageCommandResult(handled: false, Array.Empty<string>());
		}

		public static BlueSageCommandResult HandledWithMessages(params string[] messages)
		{
			return new BlueSageCommandResult(handled: true, messages);
		}
	}
	internal sealed class BlueSageCommandRegistry
	{
		private readonly List<BlueSageCommand> _commands = new List<BlueSageCommand>();

		public IReadOnlyList<BlueSageCommand> Commands => _commands;

		public void Register(BlueSageCommand command)
		{
			if (command == null)
			{
				throw new ArgumentNullException("command");
			}
			if (_commands.Any((BlueSageCommand existing) => existing.Matches(command.Name)))
			{
				throw new InvalidOperationException("BlueSage command already registered: /" + command.Name);
			}
			_commands.Add(command);
		}

		public BlueSageCommandResult TryExecute(string input)
		{
			if (!TryParse(input, out string commandName, out string arguments))
			{
				return BlueSageCommandResult.Unhandled();
			}
			BlueSageCommand blueSageCommand = _commands.FirstOrDefault((BlueSageCommand candidate) => candidate.Matches(commandName));
			if (blueSageCommand == null)
			{
				return BlueSageCommandResult.Unhandled();
			}
			return blueSageCommand.Handler(new BlueSageCommandContext(input, commandName, arguments));
		}

		public IReadOnlyList<string> Suggest(string input, int maxResults, Func<BlueSageCommand, bool>? include = null)
		{
			if (maxResults < 1)
			{
				return Array.Empty<string>();
			}
			string text = input?.TrimStart(Array.Empty<char>()) ?? string.Empty;
			if (!text.StartsWith("/", StringComparison.Ordinal) && !text.StartsWith("./", StringComparison.Ordinal))
			{
				return Array.Empty<string>();
			}
			string prefix = TrimCommandPrefix(text).Split(new char[1] { ' ' }, 2)[0];
			return (from command in _commands.Where((BlueSageCommand command) => !command.IsHidden && (include == null || include(command)) && command.CouldMatch(prefix)).OrderBy<BlueSageCommand, string>((BlueSageCommand command) => command.Name, StringComparer.OrdinalIgnoreCase).Take(maxResults)
				select "/" + command.Name + " - " + command.Description).ToArray();
		}

		internal static bool TryParse(string input, out string commandName, out string arguments)
		{
			commandName = string.Empty;
			arguments = string.Empty;
			string text = (input ?? string.Empty).Trim();
			if ((!text.StartsWith("/", StringComparison.Ordinal) && !text.StartsWith("./", StringComparison.Ordinal)) || text == "/" || text == "./")
			{
				return false;
			}
			string text2 = TrimCommandPrefix(text);
			int num = text2.IndexOf(' ');
			if (num < 0)
			{
				commandName = text2;
				return true;
			}
			commandName = text2.Substring(0, num);
			arguments = text2.Substring(num + 1).Trim();
			return commandName.Length > 0;
		}

		private static string TrimCommandPrefix(string input)
		{
			if (!input.StartsWith("./", StringComparison.Ordinal))
			{
				return input.Substring(1);
			}
			return input.Substring(2);
		}
	}
	internal readonly struct ChalkboardCatalogEntry
	{
		internal int Index { get; }

		internal string Label { get; }

		internal ChalkboardCatalogEntry(int index, string label)
		{
			Index = index;
			Label = label;
		}
	}
	internal static class ChalkboardCatalogPolicy
	{
		internal const string CatalogRevision = "build-24259292-v1";

		internal const int MaxCatalogIndex = 2;

		private static readonly ChalkboardCatalogEntry[] Entries = new ChalkboardCatalogEntry[3]
		{
			new ChalkboardCatalogEntry(0, "River/Stage"),
			new ChalkboardCatalogEntry(1, "Classroom board A (face A)"),
			new ChalkboardCatalogEntry(2, "Classroom board B (face B)")
		};

		internal static IReadOnlyList<ChalkboardCatalogEntry> Build24259292 => Entries;

		internal static bool TryGet(int index, out ChalkboardCatalogEntry entry)
		{
			if (index < 0 || index > 2)
			{
				entry = default(ChalkboardCatalogEntry);
				return false;
			}
			entry = Entries[index];
			return true;
		}

		internal static bool TryParseExactIndex(string token, int liveBoardCount, out ChalkboardCatalogEntry entry, out string error)
		{
			entry = default(ChalkboardCatalogEntry);
			error = string.Empty;
			if (string.IsNullOrWhiteSpace(token) || !int.TryParse(token.Trim(), NumberStyles.None, CultureInfo.InvariantCulture, out var result))
			{
				error = "Choose an exact board index 0, 1, or 2 from /chalk boards.";
				return false;
			}
			if (!TryGet(result, out entry))
			{
				error = "Board index " + result + " is outside build 24259292's verified catalog 0-2; index 3 never identifies a supported board.";
				return false;
			}
			if (liveBoardCount <= result)
			{
				error = "Board " + result + " is not available in the current scene. Refresh /chalk boards.";
				return false;
			}
			return true;
		}
	}
	internal static class ChalkboardCommandPolicy
	{
		internal const int FreshListSeconds = 30;

		internal static bool TryAuthorizeDestructiveAction(int boardIndex, int liveBoardCount, string lastListedBoardSetSignature, long lastListedUnixSeconds, string currentBoardSetSignature, long nowUnixSeconds, bool rollbackUnresolved, out string error)
		{
			error = string.Empty;
			if (rollbackUnresolved)
			{
				error = "A prior board replacement has unresolved rollback state. Destructive chalk actions remain locked until the board set changes or the game is restarted.";
				return false;
			}
			if (!ChalkboardCatalogPolicy.TryGet(boardIndex, out var _) || liveBoardCount <= boardIndex)
			{
				error = "That exact board is not present in build 24259292's current verified 0-2 catalog.";
				return false;
			}
			if (string.IsNullOrWhiteSpace(lastListedBoardSetSignature) || string.IsNullOrWhiteSpace(currentBoardSetSignature) || !string.Equals(lastListedBoardSetSignature, currentBoardSetSignature, StringComparison.Ordinal))
			{
				error = "The live board map changed or has not been listed. Run /chalk boards, then repeat the exact action within 30 seconds.";
				return false;
			}
			long num = nowUnixSeconds - lastListedUnixSeconds;
			if (num < 0 || num > 30)
			{
				error = "The board map is stale. Run /chalk boards, then repeat the exact action within 30 seconds.";
				return false;
			}
			return true;
		}

		internal static string BuildActionTruth(string action, int boardIndex, string scene, string authority, int compatibleRecipients, string snapshot, string rollback, string vanillaObserver)
		{
			return "Chalk " + Bound(action, "status") + ": board=" + boardIndex.ToString(CultureInfo.InvariantCulture) + ", scene=" + Bound(scene, "unavailable") + ", authority=" + Bound(authority, "local-only") + ", compatibleRecipients=" + Math.Max(0, compatibleRecipients).ToString(CultureInfo.InvariantCulture) + ", snapshot=" + Bound(snapshot, "none") + ", rollback=" + Bound(rollback, "not-needed") + ", vanillaObserver=" + Bound(vanillaObserver, "not-observed") + ".";
		}

		private static string Bound(string value, string fallback)
		{
			string text = (value ?? string.Empty).Trim();
			StringBuilder stringBuilder = new StringBuilder(Math.Min(text.Length, 96));
			bool flag = false;
			for (int i = 0; i < text.Length; i++)
			{
				if (stringBuilder.Length >= 96)
				{
					break;
				}
				char c = text[i];
				if (char.IsControl(c) || char.IsWhiteSpace(c))
				{
					if (stringBuilder.Length > 0 && !flag)
					{
						stringBuilder.Append(' ');
						flag = true;
					}
				}
				else if (c != '<' && c != '>')
				{
					stringBuilder.Append(c);
					flag = false;
				}
			}
			string text2 = stringBuilder.ToString().Trim();
			if (text2.Length != 0)
			{
				return text2;
			}
			return fallback;
		}
	}
	internal enum ChalkboardClearResult
	{
		Rejected,
		Complete,
		Partial
	}
	internal readonly struct ChalkboardDeliveryResult
	{
		internal int Attempted { get; }

		internal int Sent { get; }

		internal int Skipped { get; }

		internal bool IsComplete
		{
			get
			{
				if (Sent == Attempted)
				{
					return Skipped == 0;
				}
				return false;
			}
		}

		internal ChalkboardDeliveryResult(int attempted, int sent, int skipped)
		{
			if (attempted < 0)
			{
				throw new ArgumentOutOfRangeException("attempted");
			}
			if (sent < 0 || sent > attempted)
			{
				throw new ArgumentOutOfRangeException("sent");
			}
			if (skipped < 0 || skipped > attempted)
			{
				throw new ArgumentOutOfRangeException("skipped");
			}
			if (sent + skipped != attempted)
			{
				throw new ArgumentException("Sent and skipped counts must account for every attempted recipient.");
			}
			Attempted = attempted;
			Sent = sent;
			Skipped = skipped;
		}
	}
	internal readonly struct ChalkboardClearRequest
	{
		internal string Action { get; }

		internal int BoardIndex { get; }

		internal string BoardFingerprint { get; }

		internal long IssuedUnixSeconds { get; }

		internal string Nonce { get; }

		internal string SnapshotName { get; }

		internal ChalkboardClearRequest(string action, int boardIndex, string boardFingerprint, long issuedUnixSeconds, string nonce, string snapshotName)
		{
			Action = action;
			BoardIndex = boardIndex;
			BoardFingerprint = boardFingerprint;
			IssuedUnixSeconds = issuedUnixSeconds;
			Nonce = nonce;
			SnapshotName = snapshotName;
		}
	}
	internal static class ChalkboardModerationPolicy
	{
		internal const string MemberDataKey = "bluesage_chalk_request_v2";

		internal const int RequestExpirySeconds = 15;

		internal const int AllowedFutureClockSkewSeconds = 2;

		internal const int MaxProtocolBoardIndex = 2;

		internal const int MaxPayloadBytes = 256;

		private const double RiverCoordinateTolerance = 0.25;

		private const double ClassroomFaceCoordinateTolerance = 0.02;

		private const string Prefix = "v2|";

		private static readonly Regex NoncePattern = new Regex("^[A-Za-z0-9_-]{8,64}$", RegexOptions.Compiled);

		private static readonly Regex FingerprintPattern = new Regex("^[0-9A-F]{16}$", RegexOptions.Compiled);

		private static readonly Regex SnapshotNamePattern = new Regex("^[A-Za-z0-9][A-Za-z0-9_-]{0,39}$", RegexOptions.Compiled);

		internal static string BuildMemberData(int boardIndex, string boardFingerprint, long issuedUnixSeconds, string nonce)
		{
			string text = boardFingerprint ?? string.Empty;
			string text2 = nonce ?? string.Empty;
			if (boardIndex < 0 || boardIndex > 2)
			{
				throw new ArgumentOutOfRangeException("boardIndex");
			}
			if (!FingerprintPattern.IsMatch(text))
			{
				throw new ArgumentException("Board fingerprint must be sixteen uppercase hexadecimal characters.", "boardFingerprint");
			}
			if (issuedUnixSeconds < 1)
			{
				throw new ArgumentOutOfRangeException("issuedUnixSeconds");
			}
			if (!NoncePattern.IsMatch(text2))
			{
				throw new ArgumentException("Nonce must be 8-64 URL-safe characters.", "nonce");
			}
			return BuildMemberData("clear", boardIndex, text, issuedUnixSeconds, text2, string.Empty);
		}

		internal static string BuildRestoreMemberData(int boardIndex, string boardFingerprint, long issuedUnixSeconds, string nonce, string snapshotName)
		{
			string text = snapshotName ?? string.Empty;
			if (!SnapshotNamePattern.IsMatch(text))
			{
				throw new ArgumentException("Snapshot name must be 1-40 safe characters.", "snapshotName");
			}
			return BuildMemberData("load", boardIndex, boardFingerprint, issuedUnixSeconds, nonce, text);
		}

		private static string BuildMemberData(string action, int boardIndex, string boardFingerprint, long issuedUnixSeconds, string nonce, string snapshotName)
		{
			if (boardIndex < 0 || boardIndex > 2)
			{
				throw new ArgumentOutOfRangeException("boardIndex");
			}
			if (!FingerprintPattern.IsMatch(boardFingerprint ?? string.Empty))
			{
				throw new ArgumentException("Board fingerprint must be sixteen uppercase hexadecimal characters.", "boardFingerprint");
			}
			if (issuedUnixSeconds < 1)
			{
				throw new ArgumentOutOfRangeException("issuedUnixSeconds");
			}
			if (!NoncePattern.IsMatch(nonce ?? string.Empty))
			{
				throw new ArgumentException("Nonce must be 8-64 URL-safe characters.", "nonce");
			}
			string text = "v2|" + action + "|" + boardIndex.ToString(CultureInfo.InvariantCulture) + "|" + boardFingerprint + "|" + issuedUnixSeconds.ToString(CultureInfo.InvariantCulture) + "|" + nonce + ((snapshotName.Length > 0) ? ("|" + snapshotName) : string.Empty);
			if (Encoding.UTF8.GetByteCount(text) > 256)
			{
				throw new ArgumentException("Chalkboard request exceeds the transport limit.");
			}
			return text;
		}

		internal static bool TryParseMemberData(string payload, out ChalkboardClearRequest request)
		{
			request = default(ChalkboardClearRequest);
			if (Encoding.UTF8.GetByteCount(payload ?? string.Empty) > 256)
			{
				return false;
			}
			string[] array = (payload ?? string.Empty).Split(new char[1] { '|' });
			bool num = array.Length == 6 && array.Length > 1 && string.Equals(array[1], "clear", StringComparison.Ordinal);
			bool flag = array.Length == 7 && array.Length > 1 && string.Equals(array[1], "load", StringComparison.Ordinal);
			if ((!num && !flag) || !string.Equals(array[0], "v2", StringComparison.Ordinal) || !int.TryParse(array[2], NumberStyles.None, CultureInfo.InvariantCulture, out var result) || result < 0 || result > 2 || !FingerprintPattern.IsMatch(array[3]) || !long.TryParse(array[4], NumberStyles.None, CultureInfo.InvariantCulture, out var result2) || result2 < 1 || !NoncePattern.IsMatch(array[5]))
			{
				return false;
			}
			string text = (flag ? array[6] : string.Empty);
			if (flag && !SnapshotNamePattern.IsMatch(text))
			{
				return false;
			}
			request = new ChalkboardClearRequest(array[1], result, array[3], result2, array[5], text);
			return true;
		}

		internal static bool IsFresh(long issuedUnixSeconds, long nowUnixSeconds)
		{
			long num = nowUnixSeconds - issuedUnixSeconds;
			if (num >= -2)
			{
				return num <= 15;
			}
			return false;
		}

		internal static bool TryParseExplicitBoardIndex(string token, int boardCount, out int boardIndex, out string error)
		{
			boardIndex = -1;
			error = string.Empty;
			ChalkboardCatalogEntry entry;
			bool flag = ChalkboardCatalogPolicy.TryParseExactIndex(token, boardCount, out entry, out error);
			boardIndex = (flag ? entry.Index : (-1));
			return flag;
		}

		internal static string ClassifyLocation(string sceneName, string hierarchyPath)
		{
			string value = ((sceneName ?? string.Empty) + "/" + (hierarchyPath ?? string.Empty)).ToLowerInvariant();
			if (ContainsAny(value, "classroom", "school", "lesson", "teacher", "academy"))
			{
				return "Classroom";
			}
			if (ContainsAny(value, "river", "stream", "water", "bridge", "dock"))
			{
				return "River";
			}
			return "Unmapped";
		}

		internal static string ClassifyBuild24259292Location(int boardIndex, double x, double y, double z)
		{
			if (boardIndex == 0 && Near(x, 38.909, 0.25) && Near(y, 1.601, 0.25) && Near(z, -12.322, 0.25))
			{
				return "River/Stage";
			}
			if (boardIndex == 1 && Near(x, -19.605, 0.02) && Near(y, 4.999, 0.02) && Near(z, 7.912, 0.02))
			{
				return "Classroom board A (face A)";
			}
			if (boardIndex == 2 && Near(x, -19.62, 0.02) && Near(y, 4.999, 0.02) && Near(z, 7.954, 0.02))
			{
				return "Classroom board B (face B)";
			}
			return "Unmapped";
		}

		internal static string BuildBoardFingerprint(string sceneName, string hierarchyPath)
		{
			return BuildBoardFingerprint(sceneName, hierarchyPath, 0.0, 0.0, 0.0);
		}

		internal static string BuildBoardFingerprint(string sceneName, string hierarchyPath, double worldX, double worldY, double worldZ)
		{
			string s = ((sceneName ?? string.Empty).Trim() + "|" + (hierarchyPath ?? string.Empty).Trim() + "|" + QuantizeCoordinate(worldX) + "," + QuantizeCoordinate(worldY) + "," + QuantizeCoordinate(worldZ)).ToLowerInvariant();
			byte[] bytes = Encoding.UTF8.GetBytes(s);
			ulong num = 14695981039346656037uL;
			for (int i = 0; i < bytes.Length; i++)
			{
				num ^= bytes[i];
				num *= 1099511628211L;
			}
			return num.ToString("X16", CultureInfo.InvariantCulture);
		}

		private static string QuantizeCoordinate(double value)
		{
			if (double.IsNaN(value) || double.IsInfinity(value))
			{
				throw new ArgumentOutOfRangeException("value", "Board coordinates must be finite.");
			}
			return checked((long)Math.Round(value * 100.0, MidpointRounding.AwayFromZero)).ToString(CultureInfo.InvariantCulture);
		}

		private static bool ContainsAny(string value, params string[] candidates)
		{
			foreach (string value2 in candidates)
			{
				if (value.IndexOf(value2, StringComparison.Ordinal) >= 0)
				{
					return true;
				}
			}
			return false;
		}

		private static bool Near(double actual, double expected, double tolerance)
		{
			return Math.Abs(actual - expected) <= tolerance;
		}
	}
	internal static class ChatAccessibilityScalePolicy
	{
		public const int MinScalePercent = 75;

		public const int DefaultScalePercent = 100;

		public const int MaxScalePercent = 200;

		public static int ClampScalePercent(int configured)
		{
			if (configured < 75)
			{
				return 75;
			}
			if (configured > 200)
			{
				return 200;
			}
			return configured;
		}

		public static float NormalizeScale(int configured)
		{
			return (float)ClampScalePercent(configured) / 100f;
		}

		public static bool TryParseScaleToken(string token, out int percent)
		{
			percent = 100;
			string text = (token ?? string.Empty).Trim();
			if (string.Equals(text, "reset", StringComparison.OrdinalIgnoreCase) || string.Equals(text, "default", StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			if (string.IsNullOrWhiteSpace(text) || string.Equals(text, "status", StringComparison.OrdinalIgnoreCase) || text == "?")
			{
				return false;
			}
			text = text.TrimEnd(new char[1] { '%' });
			if (text.Contains(".") && float.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
			{
				percent = ClampScalePercent((int)Math.Round(result * 100f));
				return true;
			}
			if (int.TryParse(text, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2))
			{
				percent = ClampScalePercent(result2);
				return true;
			}
			return false;
		}

		public static bool TryCalculateScreenClampDelta(float left, float right, float bottom, float top, float screenWidth, float screenHeight, float margin, out float deltaX, out float deltaY)
		{
			deltaX = 0f;
			deltaY = 0f;
			if (screenWidth <= 0f || screenHeight <= 0f)
			{
				return false;
			}
			float num = Math.Max(0f, margin);
			float num2 = Math.Max(num, screenWidth - num);
			float num3 = Math.Max(num, screenHeight - num);
			if (left < num)
			{
				deltaX = num - left;
			}
			else if (right > num2)
			{
				deltaX = num2 - right;
			}
			if (bottom < num)
			{
				deltaY = num - bottom;
			}
			else if (top > num3)
			{
				deltaY = num3 - top;
			}
			if (!(Math.Abs(deltaX) > 0.001f))
			{
				return Math.Abs(deltaY) > 0.001f;
			}
			return true;
		}
	}
	internal enum ChatClickAction
	{
		Ignore,
		CopyMessage,
		GuardedSafeLink,
		CopyScopedIdentityEvidence,
		OpenNativeIdCard,
		Denied
	}
	internal sealed class ChatClickContext
	{
		internal bool IsRightButton { get; set; }

		internal bool ShiftHeld { get; set; }

		internal bool ControlHeld { get; set; }

		internal bool AltHeld { get; set; }

		internal bool HasPayload { get; set; }

		internal bool LinkOpeningEnabled { get; set; }

		internal bool HasSafeUrl { get; set; }

		internal bool HasSenderBinding { get; set; }
	}
	internal readonly struct ChatClickDecision
	{
		internal ChatClickAction Action { get; }

		internal string Reason { get; }

		internal ChatClickDecision(ChatClickAction action, string reason)
		{
			Action = action;
			Reason = reason ?? string.Empty;
		}
	}
	internal static class ChatClickActionPolicy
	{
		internal static ChatClickDecision Decide(ChatClickContext context)
		{
			if (context == null)
			{
				return new ChatClickDecision(ChatClickAction.Ignore, "no click context");
			}
			if ((context.ShiftHeld ? 1 : 0) + (context.ControlHeld ? 1 : 0) + (context.AltHeld ? 1 : 0) > 1)
			{
				return Denied("use exactly one modifier");
			}
			if (!context.IsRightButton)
			{
				if (context.ControlHeld)
				{
					if (!context.HasPayload)
					{
						return Denied("the row has no bounded copy payload");
					}
					return new ChatClickDecision(ChatClickAction.CopyMessage, "copy the bounded message from the native button path");
				}
				if (context.ShiftHeld)
				{
					if (!context.HasPayload || !context.LinkOpeningEnabled || !context.HasSafeUrl)
					{
						return Denied("this row has no enabled safe HTTP(S) link");
					}
					return new ChatClickDecision(ChatClickAction.GuardedSafeLink, "use the two-step safe-link path from the native button");
				}
				if (!context.HasSenderBinding)
				{
					return new ChatClickDecision(ChatClickAction.Ignore, "plain left click without an exact sender binding remains owned by the game");
				}
				return new ChatClickDecision(ChatClickAction.OpenNativeIdCard, "override the native listener with the fresh exact sender tuple");
			}
			if (!context.HasPayload)
			{
				return Denied("the row has no bounded copy payload");
			}
			if (context.ControlHeld)
			{
				if (!context.HasSenderBinding)
				{
					return Denied("this row has no exact player-sender binding");
				}
				return new ChatClickDecision(ChatClickAction.CopyScopedIdentityEvidence, "fresh exact sender revalidation is required");
			}
			if (context.AltHeld)
			{
				if (!context.HasSenderBinding)
				{
					return Denied("this row has no exact player-sender binding");
				}
				return new ChatClickDecision(ChatClickAction.OpenNativeIdCard, "fresh exact sender revalidation is required");
			}
			if (context.ShiftHeld)
			{
				if (!context.LinkOpeningEnabled || !context.HasSafeUrl)
				{
					return Denied("this row has no enabled safe HTTP(S) link");
				}
				return new ChatClickDecision(ChatClickAction.GuardedSafeLink, "use the two-step safe-link path");
			}
			return new ChatClickDecision(ChatClickAction.CopyMessage, "copy only the bounded message payload");
		}

		private static ChatClickDecision Denied(string reason)
		{
			return new ChatClickDecision(ChatClickAction.Denied, reason);
		}
	}
	public static class ChatCopySanitizer
	{
		private static readonly Regex RichTextTagPattern = new Regex("<[^>]+>", RegexOptions.Compiled);

		public static string ToClipboardText(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return string.Empty;
			}
			return RichTextTagPattern.Replace(value, string.Empty).Replace("\r\n", "\n").Replace('\r', '\n')
				.Trim();
		}
	}
	internal static class ChatFontSizePolicy
	{
		public const int MinFontSizePercent = 75;

		public const int DefaultFontSizePercent = 100;

		public const int EnabledFontSizePercent = 125;

		public const int MaxFontSizePercent = 200;

		public static int ClampFontSizePercent(int configured)
		{
			if (configured < 75)
			{
				return 75;
			}
			if (configured > 200)
			{
				return 200;
			}
			return configured;
		}

		public static float NormalizeFontSize(int configured)
		{
			return (float)ClampFontSizePercent(configured) / 100f;
		}

		public static bool TryParseFontSizeToken(string token, out int percent)
		{
			percent = 100;
			string text = (token ?? string.Empty).Trim();
			if (string.Equals(text, "reset", StringComparison.OrdinalIgnoreCase) || string.Equals(text, "default", StringComparison.OrdinalIgnoreCase) || string.Equals(text, "off", StringComparison.OrdinalIgnoreCase) || string.Equals(text, "disable", StringComparison.OrdinalIgnoreCase) || string.Equals(text, "disabled", StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			if (string.Equals(text, "on", StringComparison.OrdinalIgnoreCase) || string.Equals(text, "enable", StringComparison.OrdinalIgnoreCase) || string.Equals(text, "enabled", StringComparison.OrdinalIgnoreCase))
			{
				percent = 125;
				return true;
			}
			if (string.IsNullOrWhiteSpace(text) || string.Equals(text, "status", StringComparison.OrdinalIgnoreCase) || text == "?")
			{
				return false;
			}
			text = text.TrimEnd(new char[1] { '%' });
			if (text.Contains(".") && float.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
			{
				percent = ClampFontSizePercent((int)Math.Round(result * 100f));
				return true;
			}
			if (int.TryParse(text, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2))
			{
				percent = ClampFontSizePercent(result2);
				return true;
			}
			return false;
		}
	}
	internal static class ChatHistoryLimitPolicy
	{
		public const int DefaultRows = 150;

		public const int MinRows = 25;

		public const int MaxRows = 250;

		public static int ClampRows(int configuredRows)
		{
			return Math.Max(25, Math.Min(250, configuredRows));
		}

		public static int ApplyConfiguredRows(int originalLimit, int configuredRows)
		{
			return Math.Max(originalLimit, ClampRows(configuredRows));
		}
	}
	internal static class ChatLinkFormatter
	{
		private const string LinkColor = "70D6FF";

		private static readonly Regex WebUrlPattern = new Regex("(?<![=>\"'])\\b((?:https?://|www\\.)[^\\s<>\"']+)", RegexOptions.IgnoreCase | RegexOptions.Compiled);

		private static readonly char[] TrailingSentencePunctuation = new char[9] { '.', ',', '!', '?', ';', ':', ')', ']', '}' };

		internal static bool TryColorizeUrls(string value, out string formatted)
		{
			formatted = value ?? string.Empty;
			if (string.IsNullOrWhiteSpace(formatted) || formatted.Contains("<color=#70D6FF>"))
			{
				return false;
			}
			bool changed = false;
			formatted = WebUrlPattern.Replace(formatted, delegate(Match match)
			{
				string value2 = match.Groups[1].Value;
				string text = value2.TrimEnd(TrailingSentencePunctuation);
				if (text.Length == 0)
				{
					return value2;
				}
				changed = true;
				string text2 = value2.Substring(text.Length);
				return "<color=#70D6FF><u>" + text + "</u></color>" + text2;
			});
			return changed;
		}
	}
	internal static class ChatReadabilityStylePolicy
	{
		public const int MinOutlineIntensityPercent = 25;

		public const int DefaultOutlineIntensityPercent = 75;

		public const int MaxOutlineIntensityPercent = 100;

		private const float AbsoluteBlackTolerance = 1E-05f;

		private static readonly Regex ColorTagRegex = new Regex("<\\s*(?:color\\s*=\\s*)?(?:#(?<hex>[0-9a-fA-F]{6}(?:[0-9a-fA-F]{2})?)|(?<name>black))\\s*>", RegexOptions.IgnoreCase | RegexOptions.Compiled);

		public static int ClampOutlineIntensityPercent(int configured)
		{
			if (configured < 25)
			{
				return 25;
			}
			if (configured > 100)
			{
				return 100;
			}
			return configured;
		}

		public static float NormalizeOutlineIntensity(int configured)
		{
			return (float)ClampOutlineIntensityPercent(configured) / 100f;
		}

		public static bool ShouldUseLightOutline(float red, float green, float blue)
		{
			if (red <= 1E-05f && green <= 1E-05f)
			{
				return blue <= 1E-05f;
			}
			return false;
		}

		public static bool ContainsTrueBlackRichTextColorTag(string text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return false;
			}
			foreach (Match item in ColorTagRegex.Matches(text))
			{
				if (string.Equals(item.Groups["name"].Value, "black", StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
				string value = item.Groups["hex"].Value;
				if (value.Length >= 6 && string.Equals(value.Substring(0, 6), "000000", StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

		public static string NormalizeHexColor(string value, string fallback)
		{
			string result = NormalizeHexColorOrEmpty(fallback);
			string text = NormalizeHexColorOrEmpty(value);
			if (!string.IsNullOrEmpty(text))
			{
				return text;
			}
			return result;
		}

		private static bool IsHexCharacter(char value)
		{
			if ((value < '0' || value > '9') && (value < 'a' || value > 'f'))
			{
				if (value >= 'A')
				{
					return value <= 'F';
				}
				return false;
			}
			return true;
		}

		private static string NormalizeHexColorOrEmpty(string value)
		{
			if (string.IsNullOrWhiteSpace(value))
			{
				return string.Empty;
			}
			string text = value.Trim().TrimStart(new char[1] { '#' });
			if (text.Length != 6)
			{
				return string.Empty;
			}
			for (int i = 0; i < text.Length; i++)
			{
				if (!IsHexCharacter(text[i]))
				{
					return string.Empty;
				}
			}
			return text.ToUpperInvariant();
		}
	}
	internal readonly struct ChatRowReconciliationDecision
	{
		internal bool HasExactCreatedRow { get; }

		internal int CreatedRowInstanceId { get; }

		internal ChatRowReconciliationDecision(bool hasExactCreatedRow, int createdRowInstanceId)
		{
			HasExactCreatedRow = hasExactCreatedRow;
			CreatedRowInstanceId = createdRowInstanceId;
		}
	}
	internal static class ChatRowReconciliationPolicy
	{
		internal static ChatRowReconciliationDecision Resolve(IReadOnlyList<int> beforeInstanceIds, IReadOnlyList<int> afterInstanceIds)
		{
			if (afterInstanceIds == null || afterInstanceIds.Count == 0)
			{
				return default(ChatRowReconciliationDecision);
			}
			HashSet<int> hashSet = new HashSet<int>();
			if (beforeInstanceIds != null)
			{
				for (int i = 0; i < beforeInstanceIds.Count; i++)
				{
					hashSet.Add(beforeInstanceIds[i]);
				}
			}
			int createdRowInstanceId = 0;
			int num = 0;
			for (int j = 0; j < afterInstanceIds.Count; j++)
			{
				int num2 = afterInstanceIds[j];
				if (!hashSet.Contains(num2))
				{
					createdRowInstanceId = num2;
					num++;
					if (num > 1)
					{
						return default(ChatRowReconciliationDecision);
					}
				}
			}
			if (num != 1)
			{
				return default(ChatRowReconciliationDecision);
			}
			return new ChatRowReconciliationDecision(hasExactCreatedRow: true, createdRowInstanceId);
		}
	}
	internal static class ChatUrlDetector
	{
		private static readonly Regex WebUrlPattern = new Regex("\\b((?:https?://|www\\.)[^\\s<>\"']+)", RegexOptions.IgnoreCase | RegexOptions.Compiled);

		private static readonly char[] TrailingSentencePunctuation = new char[9] { '.', ',', '!', '?', ';', ':', ')', ']', '}' };

		internal static bool TryGetFirstUrl(string value, out string url)
		{
			url = string.Empty;
			string text = ChatCopySanitizer.ToClipboardText(value);
			if (string.IsNullOrWhiteSpace(text))
			{
				return false;
			}
			Match match = WebUrlPattern.Match(text);
			if (!match.Success)
			{
				return false;
			}
			string text2 = match.Groups[1].Value.Trim().TrimEnd(TrailingSentencePunctuation);
			if (text2.StartsWith("www.", StringComparison.OrdinalIgnoreCase))
			{
				text2 = "https://" + text2;
			}
			if (!Uri.TryCreate(text2, UriKind.Absolute, out Uri result))
			{
				return false;
			}
			if (!string.Equals(result.Scheme, Uri.UriSchemeHttp, StringComparison.OrdinalIgnoreCase) && !string.Equals(result.Scheme, Uri.UriSchemeHttps, StringComparison.OrdinalIgnoreCase))
			{
				return false;
			}
			url = result.AbsoluteUri;
			return true;
		}
	}
	internal static class ChatWindowHeightPolicy
	{
		public const int MinHeightPercent = 100;

		public const int DefaultHeightPercent = 100;

		public const int EnabledHeightPercent = 125;

		public const int MaxHeightPercent = 200;

		public static int ClampHeightPercent(int configured)
		{
			if (configured < 100)
			{
				return 100;
			}
			if (configured > 200)
			{
				return 200;
			}
			return configured;
		}

		public static float NormalizeHeight(int configured)
		{
			return (float)ClampHeightPercent(configured) / 100f;
		}

		public static bool TryParseHeightToken(string token, out int percent)
		{
			percent = 100;
			string text = (token ?? string.Empty).Trim();
			if (string.Equals(text, "reset", StringComparison.OrdinalIgnoreCase) || string.Equals(text, "default", StringComparison.OrdinalIgnoreCase) || string.Equals(text, "off", StringComparison.OrdinalIgnoreCase) || string.Equals(text, "disable", StringComparison.OrdinalIgnoreCase) || string.Equals(text, "disabled", StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			if (string.Equals(text, "on", StringComparison.OrdinalIgnoreCase) || string.Equals(text, "enable", StringComparison.OrdinalIgnoreCase) || string.Equals(text, "enabled", StringComparison.OrdinalIgnoreCase))
			{
				percent = 125;
				return true;
			}
			if (string.IsNullOrWhiteSpace(text) || string.Equals(text, "status", StringComparison.OrdinalIgnoreCase) || text == "?")
			{
				return false;
			}
			text = text.TrimEnd(new char[1] { '%' });
			if (text.Contains(".") && float.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
			{
				percent = ClampHeightPercent((int)Math.Round(result * 100f));
				return true;
			}
			if (int.TryParse(text, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2))
			{
				percent = ClampHeightPercent(result2);
				return true;
			}
			return false;
		}

		public static float CalculateAnchoredYForBottomLockedStretch(float originalY, float originalHeight, float newHeight, float pivotY)
		{
			float num = ((pivotY < 0f) ? 0f : ((pivotY > 1f) ? 1f : pivotY));
			return originalY + Math.Max(0f, newHeight - originalHeight) * num;
		}
	}
	internal sealed class CloneIncident
	{
		internal string Id { get; set; } = string.Empty;

		internal string VictimSteamId { get; set; } = string.Empty;

		internal string SuspectSteamId { get; set; } = string.Empty;

		internal string VictimLabel { get; set; } = string.Empty;

		internal string SuspectLabel { get; set; } = string.Empty;

		internal string MatchType { get; set; } = string.Empty;

		internal long FirstObservedUnixSeconds { get; set; }

		internal long LastObservedUnixSeconds { get; set; }

		internal string StableId { get; set; } = string.Empty;

		internal CloneIncidentState State { get; set; }

		internal long ClosedUnixSeconds { get; set; }

		internal string ClosedBySteamId { get; set; } = string.Empty;
	}
	internal enum CloneIncidentState
	{
		Open,
		Resolved,
		DismissedLocal,
		StaleAbsent,
		NoLongerMatching
	}
	internal static class CloneIncidentLedger
	{
		private const int MaximumIncidents = 64;

		private const long MaximumIncidentAgeSeconds = 7200L;

		private static readonly List<CloneIncident> Incidents = new List<CloneIncident>();

		private static string _lobbyKey = string.Empty;

		private static int _nextIncident = 1;

		internal static IReadOnlyList<CloneIncident> Snapshot => Incidents.Where((CloneIncident item) => item.State == CloneIncidentState.Open).ToArray();

		internal static IReadOnlyList<CloneIncident> HistorySnapshot => Incidents.ToArray();

		internal static void Reset(string lobbyKey)
		{
			_lobbyKey = (lobbyKey ?? string.Empty).Trim();
			_nextIncident = 1;
			Incidents.Clear();
		}

		internal static CloneIncident Record(string victimSteamId, string suspectSteamId, string matchType, string victimLabel, string suspectLabel, long observedUnixSeconds)
		{
			if (!ModerationProtocolPolicy.IsSteamId64(victimSteamId) || !ModerationProtocolPolicy.IsSteamId64(suspectSteamId) || string.Equals(victimSteamId, suspectSteamId, StringComparison.Ordinal))
			{
				return null;
			}
			Prune(observedUnixSeconds);
			CloneIncident cloneIncident = Incidents.LastOrDefault((CloneIncident item) => item.State == CloneIncidentState.Open && string.Equals(item.VictimSteamId, victimSteamId, StringComparison.Ordinal) && string.Equals(item.SuspectSteamId, suspectSteamId, StringComparison.Ordinal));
			if (cloneIncident != null)
			{
				cloneIncident.MatchType = MergeMatch(cloneIncident.MatchType, matchType);
				cloneIncident.VictimLabel = SanitizeLabel(victimLabel);
				cloneIncident.SuspectLabel = SanitizeLabel(suspectLabel);
				cloneIncident.LastObservedUnixSeconds = observedUnixSeconds;
				return cloneIncident;
			}
			CloneIncident cloneIncident2 = new CloneIncident
			{
				Id = "C" + _nextIncident++.ToString("000"),
				VictimSteamId = victimSteamId,
				SuspectSteamId = suspectSteamId,
				VictimLabel = SanitizeLabel(victimLabel),
				SuspectLabel = SanitizeLabel(suspectLabel),
				MatchType = NormalizeMatch(matchType),
				FirstObservedUnixSeconds = observedUnixSeconds,
				LastObservedUnixSeconds = observedUnixSeconds,
				StableId = BuildStableId(victimSteamId, suspectSteamId),
				State = CloneIncidentState.Open
			};
			Incidents.Add(cloneIncident2);
			while (Incidents.Count > 64)
			{
				Incidents.RemoveAt(0);
			}
			return cloneIncident2;
		}

		internal static bool TryResolveIncident(string incidentId, out CloneIncident incident)
		{
			incident = Incidents.LastOrDefault((CloneIncident item) => item.State == CloneIncidentState.Open && string.Equals(item.Id, (incidentId ?? string.Empty).Trim(), StringComparison.OrdinalIgnoreCase));
			return incident != null;
		}

		internal static bool TryResolveStableIncident(string stableId, out CloneIncident incident)
		{
			incident = Incidents.LastOrDefault((CloneIncident item) => item.State == CloneIncidentState.Open && string.Equals(item.StableId, (stableId ?? string.Empty).Trim(), StringComparison.OrdinalIgnoreCase));
			return incident != null;
		}

		internal static bool MarkResolved(string incidentId, string actorSteamId, long closedUnixSeconds)
		{
			if (!TryResolveIncident(incidentId, out CloneIncident incident))
			{
				return false;
			}
			Close(incident, CloneIncidentState.Resolved, actorSteamId, closedUnixSeconds);
			return true;
		}

		internal static bool MarkResolvedPair(string victimSteamId, string suspectSteamId, string actorSteamId, long closedUnixSeconds)
		{
			CloneIncident cloneIncident = Incidents.LastOrDefault((CloneIncident item) => item.State == CloneIncidentState.Open && string.Equals(item.VictimSteamId, victimSteamId, StringComparison.Ordinal) && string.Equals(item.SuspectSteamId, suspectSteamId, StringComparison.Ordinal));
			if (cloneIncident == null)
			{
				return false;
			}
			Close(cloneIncident, CloneIncidentState.Resolved, actorSteamId, closedUnixSeconds);
			return true;
		}

		internal static bool DismissLocal(string incidentId, long closedUnixSeconds)
		{
			if (!TryResolveIncident(incidentId, out CloneIncident incident))
			{
				return false;
			}
			Close(incident, CloneIncidentState.DismissedLocal, string.Empty, closedUnixSeconds);
			return true;
		}

		internal static int DismissAllOpenLocal(long closedUnixSeconds)
		{
			CloneIncident[] array = Incidents.Where((CloneIncident item) => item.State == CloneIncidentState.Open).ToArray();
			CloneIncident[] array2 = array;
			for (int num = 0; num < array2.Length; num++)
			{
				Close(array2[num], CloneIncidentState.DismissedLocal, string.Empty, closedUnixSeconds);
			}
			return array.Length;
		}

		internal static bool MarkStaleAbsent(string incidentId, long closedUnixSeconds)
		{
			if (!TryResolveIncident(incidentId, out CloneIncident incident))
			{
				return false;
			}
			Close(incident, CloneIncidentState.StaleAbsent, string.Empty, closedUnixSeconds);
			return true;
		}

		internal static bool MarkNoLongerMatching(string incidentId, long closedUnixSeconds)
		{
			if (!TryResolveIncident(incidentId, out CloneIncident incident))
			{
				return false;
			}
			Close(incident, CloneIncidentState.NoLongerMatching, string.Empty, closedUnixSeconds);
			return true;
		}

		internal static IReadOnlyList<CloneIncident> DismissOpenForSteamId(string steamId, long closedUnixSeconds)
		{
			if (!ModerationProtocolPolicy.IsSteamId64(steamId))
			{
				return Array.Empty<CloneIncident>();
			}
			CloneIncident[] array = Incidents.Where((CloneIncident item) => item.State == CloneIncidentState.Open && (string.Equals(item.VictimSteamId, steamId, StringComparison.Ordinal) || string.Equals(item.SuspectSteamId, steamId, StringComparison.Ordinal))).ToArray();
			CloneIncident[] array2 = array;
			for (int num = 0; num < array2.Length; num++)
			{
				Close(array2[num], CloneIncidentState.DismissedLocal, string.Empty, closedUnixSeconds);
			}
			return array;
		}

		internal static int ClearClosed()
		{
			int count = Incidents.Count;
			Incidents.RemoveAll((CloneIncident item) => item.State != CloneIncidentState.Open);
			return count - Incidents.Count;
		}

		internal static void Prune(long nowUnixSeconds)
		{
			if (nowUnixSeconds > 0)
			{
				Incidents.RemoveAll((CloneIncident item) => item.State != CloneIncidentState.Open && item.LastObservedUnixSeconds > 0 && nowUnixSeconds - item.LastObservedUnixSeconds > 7200);
				TrimToBound();
			}
		}

		internal static bool IsProtectedVictim(string steamId)
		{
			return Incidents.Any((CloneIncident item) => item.State == CloneIncidentState.Open && string.Equals(item.VictimSteamId, steamId, StringComparison.Ordinal));
		}

		internal static CloneIncidentState? GetRoleState(string steamId, out bool isVictim, out bool isSuspect)
		{
			isVictim = Incidents.Any((CloneIncident item) => item.State == CloneIncidentState.Open && string.Equals(item.VictimSteamId, steamId, StringComparison.Ordinal));
			isSuspect = Incidents.Any((CloneIncident item) => item.State == CloneIncidentState.Open && string.Equals(item.SuspectSteamId, steamId, StringComparison.Ordinal));
			if (!(isVictim | isSuspect))
			{
				return null;
			}
			return CloneIncidentState.Open;
		}

		internal static string BuildStableId(string victimSteamId, string suspectSteamId)
		{
			string text = (victimSteamId ?? string.Empty) + ">" + (suspectSteamId ?? string.Empty);
			uint num = 2166136261u;
			for (int i = 0; i < text.Length; i++)
			{
				num ^= text[i];
				num *= 16777619;
			}
			return "I" + num.ToString("X8");
		}

		private static void Close(CloneIncident incident, CloneIncidentState state, string actorSteamId, long closedUnixSeconds)
		{
			incident.State = state;
			incident.ClosedBySteamId = (ModerationProtocolPolicy.IsSteamId64(actorSteamId) ? actorSteamId : string.Empty);
			incident.ClosedUnixSeconds = closedUnixSeconds;
		}

		private static void TrimToBound()
		{
			while (Incidents.Count > 64)
			{
				int num = Incidents.FindIndex((CloneIncident item) => item.State != CloneIncidentState.Open);
				if (num >= 0)
				{
					Incidents.RemoveAt(num);
					continue;
				}
				break;
			}
		}

		private static string MergeMatch(string current, string added)
		{
			string text = NormalizeMatch(added);
			if (string.IsNullOrEmpty(current))
			{
				return text;
			}
			if (current.IndexOf(text, StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return current;
			}
			return current + "+" + text;
		}

		private static string NormalizeMatch(string value)
		{
			string text = (value ?? string.Empty).Trim().ToLowerInvariant();
			if (!string.IsNullOrEmpty(text))
			{
				return text;
			}
			return "clone";
		}

		private static string SanitizeLabel(string value)
		{
			string text = (value ?? string.Empty).Replace("\r", " ").Replace("\n", " ").Trim();
			if (text.Length <= 48)
			{
				return text;
			}
			return text.Substring(0, 48);
		}
	}
	internal readonly struct CloneIncidentNotice
	{
		internal string VictimSuffix { get; }

		internal string SuspectSuffix { get; }

		internal string MatchType { get; }

		internal string StableId { get; }

		internal CloneIncidentNotice(string victimSuffix, string suspectSuffix, string matchType, string stableId)
		{
			VictimSuffix = victimSuffix;
			SuspectSuffix = suspectSuffix;
			MatchType = matchType;
			StableId = stableId;
		}
	}
	internal static class CloneIncidentMessagePolicy
	{
		private static readonly Regex AlertPattern = new Regex("^\\[Clone Shield\\].*? was potentially cloned by .*?\\. Evidence IDs: victim \\.\\.\\.(?<victim>\\d{6}); suspect \\.\\.\\.(?<suspect>\\d{6}); match (?<match>[^\\r\\n.]{1,80})\\. Be aware of the player list, Steam ID, and profile; verify identity in case this alert is incorrect\\.$", RegexOptions.Compiled | RegexOptions.CultureInvariant);

		internal static bool TryParseAlert(string text, out CloneIncidentNotice notice)
		{
			notice = default(CloneIncidentNotice);
			Match match = AlertPattern.Match((text ?? string.Empty).Trim());
			if (!match.Success)
			{
				return false;
			}
			notice = new CloneIncidentNotice(match.Groups["victim"].Value, match.Groups["suspect"].Value, NormalizeMatch(match.Groups["match"].Value), string.Empty);
			return true;
		}

		private static string NormalizeMatch(string value)
		{
			string text = (value ?? string.Empty).Replace("\r", " ").Replace("\n", " ").Trim()
				.ToLowerInvariant();
			if (!string.IsNullOrWhiteSpace(text))
			{
				return text;
			}
			return "clone";
		}
	}
	internal readonly struct CloneIncidentResolutionRequest
	{
		internal string VictimSteamId { get; }

		internal string SuspectSteamId { get; }

		internal string StableId { get; }

		internal long IssuedUnixSeconds { get; }

		internal string Nonce { get; }

		internal CloneIncidentResolutionRequest(string victimSteamId, string suspectSteamId, string stableId, long issuedUnixSeconds, string nonce)
		{
			VictimSteamId = victimSteamId;
			SuspectSteamId = suspectSteamId;
			StableId = stableId;
			IssuedUnixSeconds = issuedUnixSeconds;
			Nonce = nonce;
		}
	}
	internal static class CloneIncidentResolutionProtocolPolicy
	{
		internal const string Prefix = "!bsincident:v1:resolve:";

		internal const string MemberDataKey = "bluesage_incident_request_v2";

		internal const string MemberDataPrefix = "v2|";

		internal const string LobbyDataKey = "bluesage_clone_resolution";

		internal const int RequestExpirySeconds = 15;

		internal const int LobbyResolutionExpirySeconds = 300;

		internal static string BuildRequest(string victimSteamId, string suspectSteamId, string stableId, long issuedUnixSeconds, string nonce)
		{
			return "!bsincident:v1:resolve:" + victimSteamId + ":" + suspectSteamId + ":" + stableId + ":" + issuedUnixSeconds + ":" + nonce;
		}

		internal static string BuildMemberDataRequest(string victimSteamId, string suspectSteamId, string stableId, long issuedUnixSeconds, string nonce)
		{
			if (!TryParseRequest(BuildRequest(victimSteamId, suspectSteamId, stableId, issuedUnixSeconds, nonce), out var _))
			{
				return string.Empty;
			}
			return "v2|" + victimSteamId + "|" + suspectSteamId + "|" + stableId + "|" + issuedUnixSeconds + "|" + nonce;
		}

		internal static bool TryParseMemberDataRequest(string value, out CloneIncidentResolutionRequest request)
		{
			request = default(CloneIncidentResolutionRequest);
			if (string.IsNullOrWhiteSpace(value) || !value.StartsWith("v2|", StringComparison.Ordinal))
			{
				return false;
			}
			string[] array = value.Substring("v2|".Length).Split(new char[1] { '|' });
			if (array.Length == 5)
			{
				return TryParseRequest("!bsincident:v1:resolve:" + string.Join(":", array), out request);
			}
			return false;
		}

		internal static bool TryParseRequest(string text, out CloneIncidentResolutionRequest request)
		{
			request = default(CloneIncidentResolutionRequest);
			if (string.IsNullOrWhiteSpace(text) || !text.StartsWith("!bsincident:v1:resolve:", StringComparison.Ordinal))
			{
				return false;
			}
			string[] array = text.Substring("!bsincident:v1:resolve:".Length).Split(new char[1] { ':' });
			if (array.Length != 5 || !ModerationProtocolPolicy.IsSteamId64(array[0]) || !ModerationProtocolPolicy.IsSteamId64(array[1]) || string.Equals(array[0], array[1], StringComparison.Ordinal) || !IsStableId(array[2]) || !long.TryParse(array[3], out var result) || result <= 0 || !IsNonce(array[4]))
			{
				return false;
			}
			request = new CloneIncidentResolutionRequest(array[0], array[1], array[2], result, array[4]);
			return true;
		}

		internal static bool IsFresh(CloneIncidentResolutionRequest request, long nowUnixSeconds)
		{
			long num = nowUnixSeconds - request.IssuedUnixSeconds;
			if (num >= -2)
			{
				return num <= 15;
			}
			return false;
		}

		internal static string BuildLobbyValue(string ownerSteamId, CloneIncidentResolutionRequest request)
		{
			return ownerSteamId + "|" + request.StableId + "|" + request.VictimSteamId + "|" + request.SuspectSteamId + "|" + request.IssuedUnixSeconds + "|" + request.Nonce;
		}

		internal static bool TryParseLobbyValue(string value, string expectedOwnerSteamId, long nowUnixSeconds, out CloneIncidentResolutionRequest request)
		{
			request = default(CloneIncidentResolutionRequest);
			string[] array = (value ?? string.Empty).Split(new char[1] { '|' });
			if (array.Length != 6 || !string.Equals(array[0], expectedOwnerSteamId, StringComparison.Ordinal))
			{
				return false;
			}
			if (!TryParseRequest("!bsincident:v1:resolve:" + array[2] + ":" + array[3] + ":" + array[1] + ":" + array[4] + ":" + array[5], out request))
			{
				return false;
			}
			long num = nowUnixSeconds - request.IssuedUnixSeconds;
			if (num >= -2)
			{
				return num <= 300;
			}
			return false;
		}

		private static bool IsStableId(string value)
		{
			if (value == null || value.Length != 9 || value[0] != 'I')
			{
				return false;
			}
			for (int i = 1; i < value.Length; i++)
			{
				char c = value[i];
				if ((c < '0' || c > '9') && (c < 'A' || c > 'F'))
				{
					return false;
				}
			}
			return true;
		}

		private static bool IsNonce(string value)
		{
			if (value == null || value.Length < 8 || value.Length > 24)
			{
				return false;
			}
			for (int i = 0; i < value.Length; i++)
			{
				if (!char.IsLetterOrDigit(value[i]))
				{
					return false;
				}
			}
			return true;
		}
	}
	[Flags]
	internal enum CloneMatchKind
	{
		None = 0,
		AvatarOutfit = 1,
		ExactStyledName = 2
	}
	internal static class CloneTransitionPolicy
	{
		public static CloneMatchKind Evaluate(bool culpritPreviouslyObserved, string previousCulpritAvatar, string currentCulpritAvatar, string previousCulpritName, string currentCulpritName, string previousVictimAvatar, string currentVictimAvatar, string previousVictimName, string currentVictimName, bool avatarFingerprintUseful, bool exactNameUseful)
		{
			bool num = !culpritPreviouslyObserved || !string.Equals(previousCulpritAvatar, currentCulpritAvatar, StringComparison.Ordinal);
			bool flag = !culpritPreviouslyObserved || !string.Equals(previousCulpritName, currentCulpritName, StringComparison.Ordinal);
			bool flag2 = string.Equals(previousVictimAvatar, currentVictimAvatar, StringComparison.Ordinal);
			bool flag3 = string.Equals(previousVictimName, currentVictimName, StringComparison.Ordinal);
			CloneMatchKind cloneMatchKind = CloneMatchKind.None;
			if (num && avatarFingerprintUseful && flag2 && string.Equals(currentCulpritAvatar, currentVictimAvatar, StringComparison.Ordinal))
			{
				cloneMatchKind |= CloneMatchKind.AvatarOutfit;
			}
			if (flag && exactNameUseful && flag3 && string.Equals(currentCulpritName, currentVictimName, StringComparison.Ordinal))
			{
				cloneMatchKind |= CloneMatchKind.ExactStyledName;
			}
			return cloneMatchKind;
		}
	}
	internal sealed class CommunityBanAddition
	{
		internal string SteamId { get; }

		internal string Nickname { get; }

		internal CommunityBanAddition(string steamId, string nickname)
		{
			SteamId = steamId;
			Nickname = nickname;
		}
	}
	internal static class CommunityBanListMergePolicy
	{
		internal const int MaxRemoteRows = 1024;

		private const int MaxNicknameLength = 64;

		private const string FallbackNickname = "Community list";

		internal static bool TryBuildAdditions(IReadOnlyList<string> localSteamIds, IReadOnlyList<string> localNicknames, IReadOnlyList<string> remoteSteamIds, IReadOnlyList<string> remoteNicknames, out CommunityBanAddition[] additions, out string error)
		{
			additions = Array.Empty<CommunityBanAddition>();
			error = string.Empty;
			if (!ArePaired(localSteamIds, localNicknames))
			{
				error = "Local native ban storage paired lists are unavailable or inconsistent.";
				return false;
			}
			if (!ArePaired(remoteSteamIds, remoteNicknames))
			{
				error = "Community BanData paired lists are unavailable or inconsistent.";
				return false;
			}
			if (remoteSteamIds.Count > 1024)
			{
				error = "Community BanData row count exceeds the validation limit.";
				return false;
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			for (int i = 0; i < remoteSteamIds.Count; i++)
			{
				string text = (remoteSteamIds[i] ?? string.Empty).Trim();
				if (!IsSteamId64(text))
				{
					error = "Community BanData contains an invalid SteamID64 row.";
					return false;
				}
				if (!hashSet.Add(text))
				{
					error = "Community BanData contains a duplicate SteamID64 row.";
					return false;
				}
			}
			HashSet<string> hashSet2 = new HashSet<string>(StringComparer.Ordinal);
			for (int j = 0; j < localSteamIds.Count; j++)
			{
				string text2 = (localSteamIds[j] ?? string.Empty).Trim();
				if (text2.Length > 0)
				{
					hashSet2.Add(text2);
				}
			}
			List<CommunityBanAddition> list = new List<CommunityBanAddition>();
			for (int k = 0; k < remoteSteamIds.Count; k++)
			{
				string text3 = (remoteSteamIds[k] ?? string.Empty).Trim();
				if (!hashSet2.Contains(text3))
				{
					list.Add(new CommunityBanAddition(text3, SanitizeNickname(remoteNicknames[k])));
				}
			}
			additions = list.ToArray();
			return true;
		}

		private static bool ArePaired(IReadOnlyList<string> steamIds, IReadOnlyList<string> nicknames)
		{
			if (steamIds != null && nicknames != null)
			{
				return steamIds.Count == nicknames.Count;
			}
			return false;
		}

		private static bool IsSteamId64(string value)
		{
			ulong result;
			if (value != null && value.Length == 17 && value.StartsWith("7656119", StringComparison.Ordinal))
			{
				return ulong.TryParse(value, out result);
			}
			return false;
		}

		private static string SanitizeNickname(string value)
		{
			string text = (value ?? string.Empty).Trim();
			StringBuilder stringBuilder = new StringBuilder(Math.Min(text.Length, 64));
			bool flag = false;
			for (int i = 0; i < text.Length; i++)
			{
				if (stringBuilder.Length >= 64)
				{
					break;
				}
				char c = text[i];
				if (IsUnsafeDisplayCharacter(c))
				{
					continue;
				}
				if (char.IsControl(c) || char.IsWhiteSpace(c))
				{
					if (stringBuilder.Length > 0 && !flag)
					{
						stringBuilder.Append(' ');
						flag = true;
					}
				}
				else
				{
					stringBuilder.Append(c);
					flag = false;
				}
			}
			string text2 = stringBuilder.ToString().Trim();
			if (text2.Length != 0)
			{
				return text2;
			}
			return "Community list";
		}

		private static bool IsUnsafeDisplayCharacter(char character)
		{
			switch (character)
			{
			default:
				if (character < '\u2066' || character > '\u2069')
				{
					return char.GetUnicodeCategory(character) == UnicodeCategory.Format;
				}
				break;
			case '<':
			case '>':
			case '\u061c':
			case '\u200e':
			case '\u200f':
			case '\u202a':
			case '\u202b':
			case '\u202c':
			case '\u202d':
			case '\u202e':
				break;
			}
			return true;
		}
	}
	internal sealed class CommunityBanSyncStatus
	{
		internal bool Enabled { get; set; }

		internal DateTime? LastAttemptUtc { get; set; }

		internal DateTime? LastSuccessUtc { get; set; }

		internal string HttpResult { get; set; } = "not attempted";

		internal string SourceRevision { get; set; } = "unavailable";

		internal string SourceHash { get; set; } = "unavailable";

		internal int AcceptedCount { get; set; }

		internal DateTime? NextAttemptUtc { get; set; }

		internal string BoundedError { get; set; } = string.Empty;
	}
	internal static class CommunityBanSyncPolicy
	{
		internal const int MaxStatusFieldCharacters = 128;

		internal const int MaxErrorCharacters = 192;

		internal const int SuccessIntervalSeconds = 21600;

		internal const int RetryIntervalSeconds = 900;

		internal static void BeginAttempt(CommunityBanSyncStatus status, bool enabled, DateTime attemptUtc)
		{
			if (status == null)
			{
				throw new ArgumentNullException("status");
			}
			status.Enabled = enabled;
			status.LastAttemptUtc = EnsureUtc(attemptUtc);
			status.HttpResult = "not attempted";
			status.SourceRevision = "unavailable";
			status.SourceHash = "unavailable";
			status.AcceptedCount = 0;
			status.NextAttemptUtc = null;
			status.BoundedError = string.Empty;
		}

		internal static string BoundStatusField(string value, string fallback = "unavailable")
		{
			string text = Normalize(value, 128);
			if (text.Length != 0)
			{
				return text;
			}
			return fallback;
		}

		internal static string BoundError(string value)
		{
			return Normalize(value, 192);
		}

		internal static DateTime ComputeNextAttemptUtc(DateTime nowUtc, bool succeeded)
		{
			return EnsureUtc(nowUtc).AddSeconds(succeeded ? 21600 : 900);
		}

		internal static string BuildStatusText(CommunityBanSyncStatus status)
		{
			CommunityBanSyncStatus communityBanSyncStatus = status ?? new CommunityBanSyncStatus();
			return "Community BanData: enabled=" + (communityBanSyncStatus.Enabled ? "yes" : "no") + ", lastAttempt=" + FormatUtc(communityBanSyncStatus.LastAttemptUtc) + ", lastSuccess=" + FormatUtc(communityBanSyncStatus.LastSuccessUtc) + ", http=" + BoundStatusField(communityBanSyncStatus.HttpResult, "not attempted") + ", revision=" + BoundStatusField(communityBanSyncStatus.SourceRevision) + ", sha256=" + NormalizeHash(communityBanSyncStatus.SourceHash) + ", accepted=" + Math.Max(0, communityBanSyncStatus.AcceptedCount).ToString(CultureInfo.InvariantCulture) + ", nextAttempt=" + FormatUtc(communityBanSyncStatus.NextAttemptUtc) + ", error=" + ((BoundError(communityBanSyncStatus.BoundedError).Length == 0) ? "none" : BoundError(communityBanSyncStatus.BoundedError)) + ". Additive local validation only; refresh never kicks, bans, or grants authority.";
		}

		internal static string BuildFriendlyStatusText(CommunityBanSyncStatus status)
		{
			CommunityBanSyncStatus communityBanSyncStatus = status ?? new CommunityBanSyncStatus();
			if (!communityBanSyncStatus.Enabled)
			{
				return "Community safety list is off.";
			}
			if (BoundError(communityBanSyncStatus.BoundedError).Length > 0)
			{
				return "Community safety list could not refresh safely. Your existing local list was left unchanged.";
			}
			if (communityBanSyncStatus.LastSuccessUtc.HasValue)
			{
				return "Community safety list ready: " + Math.Max(0, communityBanSyncStatus.AcceptedCount).ToString(CultureInfo.InvariantCulture) + " trusted entries checked locally. No player action was taken.";
			}
			return "Community safety list is on and will check locally when ready.";
		}

		internal static string BuildAttestationJson(CommunityBanSyncStatus status)
		{
			CommunityBanSyncStatus communityBanSyncStatus = status ?? new CommunityBanSyncStatus();
			StringBuilder stringBuilder = new StringBuilder(512);
			stringBuilder.Append("{\n");
			AppendJson(stringBuilder, "schema", "bluesage-community-ban-attestation-v1", comma: true);
			AppendJson(stringBuilder, "enabled", communityBanSyncStatus.Enabled ? "true" : "false", comma: true, raw: true);
			AppendJson(stringBuilder, "lastAttemptUtc", FormatUtc(communityBanSyncStatus.LastAttemptUtc), comma: true);
			AppendJson(stringBuilder, "lastSuccessUtc", FormatUtc(communityBanSyncStatus.LastSuccessUtc), comma: true);
			AppendJson(stringBuilder, "httpResult", BoundStatusField(communityBanSyncStatus.HttpResult, "not attempted"), comma: true);
			AppendJson(stringBuilder, "sourceRevision", BoundStatusField(communityBanSyncStatus.SourceRevision), comma: true);
			AppendJson(stringBuilder, "sourceSha256", NormalizeHash(communityBanSyncStatus.SourceHash), comma: true);
			AppendJson(stringBuilder, "acceptedCount", Math.Max(0, communityBanSyncStatus.AcceptedCount).ToString(CultureInfo.InvariantCulture), comma: true, raw: true);
			AppendJson(stringBuilder, "nextAttemptUtc", FormatUtc(communityBanSyncStatus.NextAttemptUtc), comma: true);
			AppendJson(stringBuilder, "error", BoundError(communityBanSyncStatus.BoundedError), comma: false);
			stringBuilder.Append("}\n");
			return stringBuilder.ToString();
		}

		private static void AppendJson(StringBuilder target, string key, string value, bool comma, bool raw = false)
		{
			target.Append("  \"").Append(key).Append("\": ");
			if (raw)
			{
				target.Append(value);
			}
			else
			{
				target.Append('"').Append(EscapeJson(value)).Append('"');
			}
			target.Append(comma ? ",\n" : "\n");
		}

		private static string FormatUtc(DateTime? value)
		{
			if (!value.HasValue)
			{
				return "never";
			}
			return EnsureUtc(value.Value).ToString("yyyy-MM-ddTHH:mm:ssZ", CultureInfo.InvariantCulture);
		}

		private static DateTime EnsureUtc(DateTime value)
		{
			if (value.Kind != DateTimeKind.Utc)
			{
				return value.ToUniversalTime();
			}
			return value;
		}

		private static string NormalizeHash(string value)
		{
			string text = (value ?? string.Empty).Trim().ToUpperInvariant();
			if (text.Length != 64)
			{
				return "unavailable";
			}
			foreach (char c in text)
			{
				if ((c < '0' || c > '9') && (c < 'A' || c > 'F'))
				{
					return "unavailable";
				}
			}
			return text;
		}

		private static string Normalize(string value, int limit)
		{
			StringBuilder stringBuilder = new StringBuilder();
			string text = (value ?? string.Empty).Trim();
			bool flag = false;
			for (int i = 0; i < text.Length; i++)
			{
				if (stringBuilder.Length >= limit)
				{
					break;
				}
				char c = text[i];
				if (char.IsControl(c) || char.IsWhiteSpace(c))
				{
					if (stringBuilder.Length > 0 && !flag)
					{
						stringBuilder.Append(' ');
						flag = true;
					}
				}
				else if (c != '<' && c != '>')
				{
					stringBuilder.Append(c);
					flag = false;
				}
			}
			return stringBuilder.ToString().Trim();
		}

		private static string EscapeJson(string value)
		{
			return (value ?? string.Empty).Replace("\\", "\\\\").Replace("\"", "\\\"");
		}
	}
	internal static class CompanionExactIdentityFingerprintPolicy
	{
		private readonly struct ExactRow
		{
			internal string SteamId { get; }

			internal ulong PurrNetId { get; }

			internal int TransformInstanceId { get; }

			internal ExactRow(string steamId, ulong purrNetId, int transformInstanceId)
			{
				SteamId = steamId;
				PurrNetId = purrNetId;
				TransformInstanceId = transformInstanceId;
			}
		}

		internal static bool TryBuildFingerprint(ulong lobbyId, ulong ownerSteamId, ulong localSteamId, IReadOnlyList<string> lobbyMemberSteamIds, IReadOnlyList<string> helperSteamIds, IReadOnlyList<string> verifiedSteamIds, IReadOnlyList<ulong> verifiedPurrNetIds, IReadOnlyList<int> verifiedTransformInstanceIds, out string fingerprint)
		{
			string reason;
			return TryBuildFingerprint(lobbyId, ownerSteamId, localSteamId, lobbyMemberSteamIds, helperSteamIds, verifiedSteamIds, verifiedPurrNetIds, verifiedTransformInstanceIds, out fingerprint, out reason);
		}

		internal static bool TryBuildFingerprint(ulong lobbyId, ulong ownerSteamId, ulong localSteamId, IReadOnlyList<string> lobbyMemberSteamIds, IReadOnlyList<string> helperSteamIds, IReadOnlyList<string> verifiedSteamIds, IReadOnlyList<ulong> verifiedPurrNetIds, IReadOnlyList<int> verifiedTransformInstanceIds, out string fingerprint, out string reason)
		{
			fingerprint = string.Empty;
			reason = string.Empty;
			if (lobbyId == 0L || ownerSteamId == 0L || localSteamId == 0L || lobbyMemberSteamIds == null || helperSteamIds == null || verifiedSteamIds == null || verifiedPurrNetIds == null || verifiedTransformInstanceIds == null || lobbyMemberSteamIds.Count == 0 || verifiedSteamIds.Count == 0 || verifiedSteamIds.Count != verifiedPurrNetIds.Count || verifiedSteamIds.Count != verifiedTransformInstanceIds.Count)
			{
				reason = "required lobby or exact-row identity data is missing or misaligned";
				return false;
			}
			HashSet<string> members = new HashSet<string>(lobbyMemberSteamIds, StringComparer.Ordinal);
			if (members.Count != lobbyMemberSteamIds.Count || members.Any(string.IsNullOrWhiteSpace) || !members.Contains(ownerSteamId.ToString(CultureInfo.InvariantCulture)) || !members.Contains(localSteamId.ToString(CultureInfo.InvariantCulture)))
			{
				reason = "Steam lobby membership is invalid, duplicated, or missing the owner/local identity";
				return false;
			}
			HashSet<string> hashSet = new HashSet<string>(helperSteamIds, StringComparer.Ordinal);
			if (hashSet.Count != helperSteamIds.Count || hashSet.Any(string.IsNullOrWhiteSpace))
			{
				reason = "published helper identities are empty or duplicated";
				return false;
			}
			if (hashSet.Any((string helper) => !members.Contains(helper)))
			{
				reason = "published helper is not a current Steam lobby member";
				return false;
			}
			List<ExactRow> list = new List<ExactRow>(verifiedSteamIds.Count);
			HashSet<string> hashSet2 = new HashSet<string>(StringComparer.Ordinal);
			HashSet<ulong> hashSet3 = new HashSet<ulong>();
			HashSet<int> hashSet4 = new HashSet<int>();
			for (int num = 0; num < verifiedSteamIds.Count; num++)
			{
				string text = verifiedSteamIds[num];
				ulong num2 = verifiedPurrNetIds[num];
				int num3 = verifiedTransformInstanceIds[num];
				if (string.IsNullOrWhiteSpace(text) || !members.Contains(text) || num2 == 0L || num3 == 0 || !hashSet2.Add(text) || !hashSet3.Add(num2) || !hashSet4.Add(num3))
				{
					reason = "verified Steam/PurrNet/native-transform tuples are invalid, duplicated, or outside the current lobby";
					return false;
				}
				list.Add(new ExactRow(text, num2, num3));
			}
			StringBuilder stringBuilder = new StringBuilder(256);
			Append(stringBuilder, "scope", "companion-exact-v1");
			Append(stringBuilder, "lobby", lobbyId.ToString(CultureInfo.InvariantCulture));
			Append(stringBuilder, "owner", ownerSteamId.ToString(CultureInfo.InvariantCulture));
			Append(stringBuilder, "local", localSteamId.ToString(CultureInfo.InvariantCulture));
			foreach (string item in members.OrderBy<string, string>((string value) => value, StringComparer.Ordinal))
			{
				Append(stringBuilder, "member", item);
			}
			foreach (string item2 in hashSet.OrderBy<string, string>((string value) => value, StringComparer.Ordinal))
			{
				Append(stringBuilder, "helper", item2);
			}
			foreach (ExactRow item3 in list.OrderBy<ExactRow, string>((ExactRow value) => value.SteamId, StringComparer.Ordinal))
			{
				Append(stringBuilder, "steam", item3.SteamId);
				Append(stringBuilder, "purr", item3.PurrNetId.ToString(CultureInfo.InvariantCulture));
				Append(stringBuilder, "transform", item3.TransformInstanceId.ToString(CultureInfo.InvariantCulture));
			}
			fingerprint = stringBuilder.ToString();
			if (fingerprint.Length == 0)
			{
				reason = "canonical exact-row identity fingerprint is empty";
				return false;
			}
			return true;
		}

		private static void Append(StringBuilder destination, string label, string value)
		{
			destination.Append(label);
			destination.Append(':');
			destination.Append(value.Length.ToString(CultureInfo.InvariantCulture));
			destination.Append(':');
			destination.Append(value);
			destination.Append(';');
		}
	}
	internal readonly struct CompatibleClientPresence
	{
		internal int Version { get; }

		internal long PublishedUnixSeconds { get; }

		internal CompatibleClientPresence(int version, long publishedUnixSeconds)
		{
			Version = version;
			PublishedUnixSeconds = publishedUnixSeconds;
		}
	}
	internal static class CompatibleClientPresencePolicy
	{
		internal const string MemberDataKey = "bluesage_qol_client_v1";

		internal const int ProtocolVersion = 1;

		internal const long FreshnessSeconds = 8L;

		internal const long MaximumFutureSkewSeconds = 3L;

		private const int MaximumPayloadCharacters = 32;

		internal static bool TryBuild(long nowUnixSeconds, out string payload)
		{
			payload = string.Empty;
			if (nowUnixSeconds <= 0)
			{
				return false;
			}
			payload = 1.ToString(CultureInfo.InvariantCulture) + "|" + nowUnixSeconds.ToString(CultureInfo.InvariantCulture);
			return payload.Length <= 32;
		}

		internal static bool IsFresh(string payload, long nowUnixSeconds)
		{
			CompatibleClientPresence presence;
			return TryParse(payload, nowUnixSeconds, out presence);
		}

		internal static bool TryParse(string payload, long nowUnixSeconds, out CompatibleClientPresence presence)
		{
			presence = default(CompatibleClientPresence);
			if (nowUnixSeconds <= 0 || string.IsNullOrWhiteSpace(payload) || payload.Length > 32)
			{
				return false;
			}
			string[] array = payload.Split(new char[1] { '|' });
			if (array.Length != 2 || !int.TryParse(array[0], NumberStyles.None, CultureInfo.InvariantCulture, out var result) || result != 1 || !long.TryParse(array[1], NumberStyles.None, CultureInfo.InvariantCulture, out var result2) || result2 <= 0)
			{
				return false;
			}
			long num = nowUnixSeconds - result2;
			if (num > 8 || num < -3)
			{
				return false;
			}
			presence = new CompatibleClientPresence(result, result2);
			return true;
		}
	}
	internal static class ConfigMigrationPolicy
	{
		internal const string FinalDefaultsV2Migration = "final-defaults-v2";

		internal const string SweepFifteenMinuteV1Migration = "sweep-15-default-v1";

		internal const string SweepTenMinuteSafetyV2Migration = "sweep-10-safety-v2";

		internal const string SweepAutomaticOptInV3Migration = "sweep-auto-opt-in-v3";

		internal const string CommunityBanAnyClientOptInV1Migration = "community-ban-any-client-opt-in-v1";

		internal const string CurrentMigrationLedger = "final-defaults-v2;sweep-15-default-v1;sweep-10-safety-v2;sweep-auto-opt-in-v3;community-ban-any-client-opt-in-v1";

		private const string LegacyVersionDerivedV2Marker = "0.2.0-final-defaults-v2";

		public static bool HasCompletedMigration(string ledger, string migration)
		{
			if (string.IsNullOrWhiteSpace(migration))
			{
				return false;
			}
			string[] array = (ledger ?? string.Empty).Split(new char[1] { ';' }, StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < array.Length; i++)
			{
				string a = array[i].Trim();
				if (string.Equals(a, migration, StringComparison.Ordinal) || (string.Equals(migration, "final-defaults-v2", StringComparison.Ordinal) && string.Equals(a, "0.2.0-final-defaults-v2", StringComparison.Ordinal)))
				{
					return true;
				}
			}
			return false;
		}

		public static string RecordMigration(string ledger, string migration)
		{
			List<string> list = new List<string>();
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			string[] array = (ledger ?? string.Empty).Split(new char[1] { ';' }, StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (text.Length > 0 && hashSet.Add(text))
				{
					list.Add(text);
				}
			}
			string text2 = migration?.Trim() ?? string.Empty;
			string ledger2 = string.Join(";", list.ToArray());
			if (text2.Length > 0 && text2.IndexOf(';') < 0 && !HasCompletedMigration(ledger2, text2) && hashSet.Add(text2))
			{
				list.Add(text2);
			}
			return string.Join(";", list.ToArray());
		}

		public static int MigrateOldDefaultInt(int currentValue, int oldDefault, int newDefault, bool alreadyMigrated)
		{
			if (alreadyMigrated || currentValue != oldDefault)
			{
				return currentValue;
			}
			return newDefault;
		}

		public static string MigrateOldDefaultString(string currentValue, string oldDefault, string newDefault, bool alreadyMigrated)
		{
			if (alreadyMigrated || !string.Equals(currentValue, oldDefault, StringComparison.OrdinalIgnoreCase))
			{
				return currentValue;
			}
			return newDefault;
		}

		public static bool MigrateOldDefaultBool(bool currentValue, bool oldDefault, bool newDefault, bool alreadyMigrated)
		{
			if (alreadyMigrated || currentValue != oldDefault)
			{
				return currentValue;
			}
			return newDefault;
		}

		public static bool ShouldDisableDefaultSpoons(bool enabled, string spoonsUpdatedUtc, bool alreadyMigrated)
		{
			if (alreadyMigrated || !enabled)
			{
				return false;
			}
			DateTimeOffset result;
			return !DateTimeOffset.TryParse(spoonsUpdatedUtc, CultureInfo.InvariantCulture, DateTimeStyles.AllowWhiteSpaces | DateTimeStyles.AssumeUniversal, out result);
		}
	}
	internal static class CurrentLobbyHelperPolicy
	{
		internal static string[] FilterCurrent(IReadOnlyCollection<string> publishedHelperSteamIds, IReadOnlyCollection<string> currentLobbyMemberSteamIds)
		{
			HashSet<string> members = new HashSet<string>((IEnumerable<string>)(((object)currentLobbyMemberSteamIds) ?? ((object)Array.Empty<string>())), StringComparer.Ordinal);
			return ((IEnumerable<string>)(((object)publishedHelperSteamIds) ?? ((object)Array.Empty<string>()))).Where((string value) => !string.IsNullOrWhiteSpace(value) && members.Contains(value)).Distinct<string>(StringComparer.Ordinal).OrderBy<string, string>((string value) => value, StringComparer.Ordinal)
				.ToArray();
		}
	}
	internal static class DisplayNameCompositionPolicy
	{
		public static string Compose(string styledBaseName, string statusSuffix, string spoonSuffix)
		{
			string text = (styledBaseName ?? string.Empty).Trim();
			string text2 = (statusSuffix ?? string.Empty).Trim();
			string text3 = (spoonSuffix ?? string.Empty).Trim();
			if (!string.IsNullOrWhiteSpace(text2))
			{
				text = text + " " + text2;
			}
			if (!string.IsNullOrWhiteSpace(text3))
			{
				text = text + " " + text3;
			}
			return text;
		}
	}
	internal static class DisplayNameMutationPolicy
	{
		public static bool TryCompose(string styledBaseName, string statusSuffix, string spoonSuffix, int maxCharacters, out string displayName, out string error)
		{
			string text = styledBaseName ?? string.Empty;
			if (string.IsNullOrWhiteSpace(text.Trim()))
			{
				displayName = string.Empty;
				error = "Status Helper: player name is not ready yet.";
				return false;
			}
			if (!TryValidateComponent(text, "name", out error) || !TryValidateComponent(statusSuffix, "status", out error) || !TryValidateComponent(spoonSuffix, "Spoons", out error))
			{
				displayName = string.Empty;
				return false;
			}
			displayName = DisplayNameCompositionPolicy.Compose(text, statusSuffix, spoonSuffix);
			if (displayName.Length > maxCharacters)
			{
				error = $"Status Helper: display name is too long ({displayName.Length}/{maxCharacters}). Shorten your name or status.";
				return false;
			}
			error = string.Empty;
			return true;
		}

		private static bool TryValidateComponent(string value, string label, out string error)
		{
			if (string.IsNullOrEmpty(value) || RichTextDraftPolicy.TryValidate(value, out var message))
			{
				error = string.Empty;
				return true;
			}
			error = "Status Helper: " + label + " rich text is not balanced. " + message;
			return false;
		}
	}
	internal static class EasterEggTracker
	{
		private const string TotalKey = "BlueSageQoL.EasterEggs.Total";

		private const string Prefix = "BlueSageQoL.EasterEggs.";

		public static int Count => PlayerPrefs.GetInt("BlueSageQoL.EasterEggs.Total", 0);

		public static bool HasDiscovered(string id)
		{
			return PlayerPrefs.GetInt("BlueSageQoL.EasterEggs." + id, 0) != 0;
		}

		public static string Discover(string id, string label)
		{
			string text = "BlueSageQoL.EasterEggs." + id;
			bool num = PlayerPrefs.GetInt(text, 0) == 0;
			if (num)
			{
				PlayerPrefs.SetInt(text, 1);
				PlayerPrefs.SetInt("BlueSageQoL.EasterEggs.Total", Count + 1);
				PlayerPrefs.Save();
			}
			string arg = (num ? "New BlueSage easter egg found" : "BlueSage easter egg already found");
			return $"{arg}: {label}. Eggs found: {Count}.";
		}
	}
	internal enum BlueSageHelpFrameKind
	{
		QolMenu,
		StyleHelper
	}
	internal struct HelpFrameLayout
	{
		public float ContentHeight { get; }

		public float FooterHeight { get; }

		public float StateLineHeight { get; }

		public float HelpLineHeight { get; }

		public float FixedChromeHeight { get; }

		public float FooterVerticalPadding { get; }

		public int ActionRows { get; }

		public float ActionRowHeight { get; }

		public HelpFrameLayout(float contentHeight, float footerHeight, float stateLineHeight, float helpLineHeight, float fixedChromeHeight, float footerVerticalPadding, int actionRows, float actionRowHeight)
		{
			ContentHeight = contentHeight;
			FooterHeight = footerHeight;
			StateLineHeight = stateLineHeight;
			HelpLineHeight = helpLineHeight;
			FixedChromeHeight = fixedChromeHeight;
			FooterVerticalPadding = footerVerticalPadding;
			ActionRows = actionRows;
			ActionRowHeight = actionRowHeight;
		}
	}
	internal static class HelpFramePolicy
	{
		public static HelpFrameLayout Resolve(BlueSageHelpFrameKind kind, float windowWidth, float windowHeight)
		{
			bool flag = kind == BlueSageHelpFrameKind.StyleHelper;
			bool flag2 = flag && windowWidth < 1100f;
			float num = (flag ? 78f : 152f);
			float val = ((!flag) ? 120f : (flag2 ? 198f : 156f));
			int num2 = (flag ? ((!flag2) ? 1 : 2) : 0);
			float num3 = (flag ? 40f : 0f);
			float num4 = 22f;
			float num5 = 22f;
			float num6 = (flag ? 16f : 12f);
			float val2 = num4 + num5 + num6 + (float)num2 * num3;
			float num7 = (flag ? 36f : 24f);
			float val3 = Math.Max(val2, windowHeight - num - num7);
			float val4 = Math.Min(val, val3);
			val4 = Math.Max(val2, val4);
			float num8 = Math.Max(num7, windowHeight - num - val4);
			if (num8 + val4 + num > windowHeight)
			{
				num8 = Math.Max(1f, windowHeight - num - val4);
			}
			return new HelpFrameLayout(num8, val4, num4, num5, num, num6, num2, num3);
		}
	}
	internal enum HostConsoleOverallState
	{
		Ready,
		Degraded,
		Unavailable
	}
	internal sealed class HostConsoleSnapshot
	{
		internal HostConsoleOverallState OverallState { get; }

		internal string HostState { get; }

		internal string RosterState { get; }

		internal string CleanupState { get; }

		internal string ReconnectState { get; }

		internal string PlayerLimitState { get; }

		internal string ProviderState { get; }

		internal string RelayState { get; }

		internal string Reason { get; }

		internal HostConsoleSnapshot(HostConsoleOverallState overallState, string hostState, string rosterState, string cleanupState, string reconnectState, string playerLimitState, string providerState, string relayState, string reason)
		{
			OverallState = overallState;
			HostState = hostState;
			RosterState = rosterState;
			CleanupState = cleanupState;
			ReconnectState = reconnectState;
			PlayerLimitState = playerLimitState;
			ProviderState = providerState;
			RelayState = relayState;
			Reason = reason;
		}
	}
	internal static class HostConsoleReadinessPolicy
	{
		internal static HostConsoleSnapshot Resolve(bool isHost, bool rosterConverged, bool cleanupHealthy, bool reconnectHealthy, bool playerLimitHealthy, bool providerRequired, bool providerHealthy, bool relayRequired, bool relayHealthy)
		{
			string provider = OptionalState(providerRequired, providerHealthy);
			string relay = OptionalState(relayRequired, relayHealthy);
			if (!isHost)
			{
				return Snapshot(HostConsoleOverallState.Unavailable, isHost, rosterConverged, cleanupHealthy, reconnectHealthy, playerLimitHealthy, provider, relay, "Current client is not the verified lobby host.");
			}
			string text = FirstRequiredFailure(rosterConverged, cleanupHealthy, reconnectHealthy, playerLimitHealthy, providerRequired, providerHealthy, relayRequired, relayHealthy);
			return Snapshot((!string.IsNullOrEmpty(text)) ? HostConsoleOverallState.Degraded : HostConsoleOverallState.Ready, isHost, rosterConverged, cleanupHealthy, reconnectHealthy, playerLimitHealthy, provider, relay, string.IsNullOrEmpty(text) ? "All required host lanes are ready." : text);
		}

		private static HostConsoleSnapshot Snapshot(HostConsoleOverallState state, bool host, bool roster, bool cleanup, bool reconnect, bool playerLimit, string provider, string relay, string reason)
		{
			return new HostConsoleSnapshot(state, OnOff(host), OnOff(roster), OnOff(cleanup), OnOff(reconnect), OnOff(playerLimit), provider, relay, reason);
		}

		private static string FirstRequiredFailure(bool roster, bool cleanup, bool reconnect, bool playerLimit, bool providerRequired, bool providerHealthy, bool relayRequired, bool relayHealthy)
		{
			if (!roster)
			{
				return "Verified roster is not converged.";
			}
			if (!cleanup)
			{
				return "Automatic cleanup is not healthy.";
			}
			if (!reconnect)
			{
				return "Reconnect protection is not healthy.";
			}
			if (!playerLimit)
			{
				return "PlayerLimit host integration is not healthy.";
			}
			if (providerRequired && !providerHealthy)
			{
				return "Required host capability provider is not healthy.";
			}
			if (relayRequired && !relayHealthy)
			{
				return "Required Discord relay is not healthy.";
			}
			return string.Empty;
		}

		private static string OptionalState(bool required, bool healthy)
		{
			if (required)
			{
				if (!healthy)
				{
					return "Degraded";
				}
				return "Ready";
			}
			if (!healthy)
			{
				return "Optional / off";
			}
			return "Ready (optional)";
		}

		private static string OnOff(bool value)
		{
			if (!value)
			{
				return "Degraded";
			}
			return "Ready";
		}
	}
	internal enum HostHealthIssue
	{
		LobbyOwnerInvalid,
		HostIdentityLost,
		HostMissingFromPlayerList,
		HostPersonaEmpty
	}
	internal enum HostHealthAction
	{
		RefreshLobbyMetadata,
		RequestPersonaRefresh
	}
	internal sealed class HostHealthInput
	{
		public bool IsHost { get; }

		public bool LobbyValid { get; }

		public string LocalSteamId { get; }

		public string LobbyOwnerSteamId { get; }

		public IReadOnlyList<string> PlayerSteamIds { get; }

		public int ServerPlayerCount { get; }

		public string HostPersonaName { get; }

		public double LobbyAgeHours { get; }

		public double WarnAfterHours { get; }

		public bool IsHostMachine
		{
			get
			{
				if (!IsHost)
				{
					if (!IsInvalidSteamId(LocalSteamId) && !IsInvalidSteamId(LobbyOwnerSteamId))
					{
						return string.Equals(LocalSteamId, LobbyOwnerSteamId, StringComparison.Ordinal);
					}
					return false;
				}
				return true;
			}
		}

		public HostHealthInput(bool isHost, bool lobbyValid, string localSteamId, string lobbyOwnerSteamId, IEnumerable<string> playerSteamIds, int serverPlayerCount, string hostPersonaName, double lobbyAgeHours, double warnAfterHours)
		{
			IsHost = isHost;
			LobbyValid = lobbyValid;
			LocalSteamId = localSteamId ?? string.Empty;
			LobbyOwnerSteamId = lobbyOwnerSteamId ?? string.Empty;
			PlayerSteamIds = (playerSteamIds ?? Array.Empty<string>()).Where((string value) => !string.IsNullOrWhiteSpace(value)).ToArray();
			ServerPlayerCount = serverPlayerCount;
			HostPersonaName = hostPersonaName ?? string.Empty;
			LobbyAgeHours = lobbyAgeHours;
			WarnAfterHours = warnAfterHours;
		}

		public static HostHealthInput DefaultForTests(bool isHost = true, bool lobbyValid = true, string localSteamId = "111", string lobbyOwnerSteamId = "111", IEnumerable<string>? playerSteamIds = null, int serverPlayerCount = 1, string hostPersonaName = "Blue", double lobbyAgeHours = 1.0, double warnAfterHours = 12.0)
		{
			return new HostHealthInput(isHost, lobbyValid, localSteamId, lobbyOwnerSteamId, playerSteamIds ?? new string[1] { lobbyOwnerSteamId }, serverPlayerCount, hostPersonaName, lobbyAgeHours, warnAfterHours);
		}

		private static bool IsInvalidSteamId(string steamId)
		{
			if (!string.IsNullOrWhiteSpace(steamId))
			{
				return steamId == "0";
			}
			return true;
		}
	}
	internal sealed class HostHealthDecision
	{
		public bool ShouldRunDiagnostics { get; }

		public IReadOnlyList<HostHealthIssue> Issues { get; }

		public IReadOnlyList<HostHealthAction> Actions { get; }

		public bool IsHealthy
		{
			get
			{
				if (ShouldRunDiagnostics)
				{
					return Issues.Count == 0;
				}
				return false;
			}
		}

		public HostHealthDecision(bool shouldRunDiagnostics, IReadOnlyList<HostHealthIssue> issues, IReadOnlyList<HostHealthAction> actions)
		{
			ShouldRunDiagnostics = shouldRunDiagnostics;
			Issues = issues;
			Actions = actions;
		}
	}
	internal static class HostHealthPolicy
	{
		public static HostHealthDecision Evaluate(HostHealthInput input)
		{
			if (input == null || !input.IsHostMachine)
			{
				return new HostHealthDecision(shouldRunDiagnostics: false, Array.Empty<HostHealthIssue>(), Array.Empty<HostHealthAction>());
			}
			List<HostHealthIssue> list = new List<HostHealthIssue>();
			HashSet<HostHealthAction> hashSet = new HashSet<HostHealthAction>();
			hashSet.Add(HostHealthAction.RefreshLobbyMetadata);
			int num;
			if (input.LobbyValid && !string.IsNullOrWhiteSpace(input.LobbyOwnerSteamId))
			{
				num = ((input.LobbyOwnerSteamId == "0") ? 1 : 0);
				if (num == 0)
				{
					goto IL_0062;
				}
			}
			else
			{
				num = 1;
			}
			list.Add(HostHealthIssue.LobbyOwnerInvalid);
			goto IL_0062;
			IL_0062:
			if (num == 0 && !input.PlayerSteamIds.Contains(input.LobbyOwnerSteamId))
			{
				list.Add(HostHealthIssue.HostMissingFromPlayerList);
			}
			if (num == 0 && !list.Contains(HostHealthIssue.HostMissingFromPlayerList) && string.IsNullOrWhiteSpace(input.HostPersonaName))
			{
				list.Add(HostHealthIssue.HostPersonaEmpty);
				hashSet.Add(HostHealthAction.RequestPersonaRefresh);
			}
			return new HostHealthDecision(shouldRunDiagnostics: true, list, hashSet.ToArray());
		}

		public static int ClampIntervalSeconds(int value)
		{
			if (value < 60)
			{
				return 60;
			}
			if (value <= 3600)
			{
				return value;
			}
			return 3600;
		}
	}
	internal readonly struct HostModerationSurfaceDecision
	{
		internal bool CanInspectNativeActions { get; }

		internal bool CanArmHostRemove { get; }

		internal bool CanExecuteHostRemove { get; }

		internal HostModerationSurfaceDecision(bool canInspectNativeActions, bool canArmHostRemove, bool canExecuteHostRemove)
		{
			CanInspectNativeActions = canInspectNativeActions;
			CanArmHostRemove = canArmHostRemove;
			CanExecuteHostRemove = canExecuteHostRemove;
		}
	}
	internal static class HostModerationSurfacePolicy
	{
		internal static HostModerationSurfaceDecision Evaluate(bool isHost, bool exactTargetReady, bool isSelf, bool confirmationArmed)
		{
			bool flag = isHost && exactTargetReady && !isSelf;
			return new HostModerationSurfaceDecision(exactTargetReady, flag, flag && confirmationArmed);
		}
	}
	internal static class HostVisibilityReceiverPolicy
	{
		public static bool ShouldConsumeRemoteOwnerState(string ownerSteamId, string localSteamId)
		{
			if (string.IsNullOrWhiteSpace(ownerSteamId) || string.IsNullOrWhiteSpace(localSteamId))
			{
				return false;
			}
			return !string.Equals(ownerSteamId, localSteamId, StringComparison.Ordinal);
		}
	}
	internal static class IdentityEvidenceGenerationPolicy
	{
		internal static bool TryBuildFingerprint(ulong lobbyId, ulong ownerSteamId, IReadOnlyList<string> nativeSteamIds, IReadOnlyList<string> nativePurrNetIds, IReadOnlyList<int> transformInstanceIds, IReadOnlyList<string> lobbyMemberSteamIds, ulong localSteamId, IReadOnlyList<string> helperSteamIds, bool coverageComplete, int liveSteamCheckCount, int leftStaleCount, int ambiguousCount, out string fingerprint)
		{
			fingerprint = string.Empty;
			if (lobbyId == 0L || ownerSteamId == 0L || localSteamId == 0L || nativeSteamIds == null || nativePurrNetIds == null || transformInstanceIds == null || lobbyMemberSteamIds == null || helperSteamIds == null || nativeSteamIds.Count == 0 || nativeSteamIds.Count != nativePurrNetIds.Count || nativeSteamIds.Count != transformInstanceIds.Count || lobbyMemberSteamIds.Count == 0 || lobbyMemberSteamIds.Any(string.IsNullOrWhiteSpace) || lobbyMemberSteamIds.Distinct<string>(StringComparer.Ordinal).Count() != lobbyMemberSteamIds.Count || helperSteamIds.Any(string.IsNullOrWhiteSpace) || helperSteamIds.Distinct<string>(StringComparer.Ordinal).Count() != helperSteamIds.Count || transformInstanceIds.Any((int value) => value == 0) || liveSteamCheckCount < 0 || leftStaleCount < 0 || ambiguousCount < 0)
			{
				return false;
			}
			StringBuilder stringBuilder = new StringBuilder(256);
			Append(stringBuilder, "lobby", lobbyId.ToString(CultureInfo.InvariantCulture));
			Append(stringBuilder, "owner", ownerSteamId.ToString(CultureInfo.InvariantCulture));
			Append(stringBuilder, "local", localSteamId.ToString(CultureInfo.InvariantCulture));
			Append(stringBuilder, "coverage", coverageComplete ? "1" : "0");
			Append(stringBuilder, "live-native-only", liveSteamCheckCount.ToString(CultureInfo.InvariantCulture));
			Append(stringBuilder, "left-stale", leftStaleCount.ToString(CultureInfo.InvariantCulture));
			Append(stringBuilder, "ambiguous", ambiguousCount.ToString(CultureInfo.InvariantCulture));
			for (int num = 0; num < nativeSteamIds.Count; num++)
			{
				Append(stringBuilder, "row", num.ToString(CultureInfo.InvariantCulture));
				Append(stringBuilder, "steam", nativeSteamIds[num]);
				Append(stringBuilder, "purr", nativePurrNetIds[num]);
				Append(stringBuilder, "live", transformInstanceIds[num].ToString(CultureInfo.InvariantCulture));
			}
			foreach (string item in lobbyMemberSteamIds.OrderBy<string, string>((string value) => value, StringComparer.Ordinal))
			{
				Append(stringBuilder, "member", item);
			}
			foreach (string item2 in helperSteamIds.OrderBy<string, string>((string value) => value, StringComparer.Ordinal))
			{
				Append(stringBuilder, "helper", item2);
			}
			fingerprint = stringBuilder.ToString();
			return fingerprint.Length > 0;
		}

		internal static bool TryObserve(string acceptedFingerprint, long acceptedGeneration, bool acceptedValid, string observedFingerprint, bool observedValid, out string nextFingerprint, out long nextGeneration, out bool nextValid, out bool changed, out bool requiresEpochAdvance)
		{
			nextFingerprint = acceptedFingerprint ?? string.Empty;
			nextGeneration = acceptedGeneration;
			nextValid = false;
			changed = false;
			requiresEpochAdvance = false;
			if (acceptedGeneration < 0 || (observedValid && string.IsNullOrWhiteSpace(observedFingerprint)))
			{
				return false;
			}
			if (acceptedValid == observedValid && (!observedValid || (acceptedGeneration > 0 && string.Equals(acceptedFingerprint, observedFingerprint, StringComparison.Ordinal))))
			{
				nextValid = acceptedValid;
				return true;
			}
			if (acceptedGeneration == long.MaxValue)
			{
				requiresEpochAdvance = true;
				return false;
			}
			if (observedValid && string.Equals(acceptedFingerprint, observedFingerprint, StringComparison.Ordinal))
			{
				nextFingerprint = observedFingerprint;
			}
			else if (observedValid)
			{
				nextFingerprint = observedFingerprint;
			}
			nextGeneration = Math.Max(1L, acceptedGeneration + 1);
			nextValid = observedValid;
			changed = true;
			return true;
		}

		private static void Append(StringBuilder destination, string label, string value)
		{
			destination.Append(label);
			destination.Append(':');
			destination.Append(value.Length.ToString(CultureInfo.InvariantCulture));
			destination.Append(':');
			destination.Append(value);
			destination.Append(';');
		}
	}
	internal enum IdentityResyncBeginReason
	{
		Ready,
		NoCurrentScope,
		ScopeMigrated,
		StaleGeneration,
		QuietWindow,
		GlobalCooldown,
		SingleFlight,
		GenerationAlreadyCompleted
	}
	internal readonly struct IdentityResyncBeginDecision
	{
		internal IdentityResyncBeginReason Reason { get; }

		internal long RetryAfterMilliseconds { get; }

		internal IdentityResyncBeginDecision(IdentityResyncBeginReason reason, long retryAfterMilliseconds)
		{
			Reason = reason;
			RetryAfterMilliseconds = Math.Max(0L, retryAfterMilliseconds);
		}
	}
	internal readonly struct IdentityResyncLease
	{
		internal long Sequence { get; }

		internal string Scope { get; }

		internal long Generation { get; }

		internal bool IsValid
		{
			get
			{
				if (Sequence > 0 && Scope.Length > 0)
				{
					return Generation > 0;
				}
				return false;
			}
		}

		internal IdentityResyncLease(long sequence, string scope, long generation)
		{
			Sequence = sequence;
			Scope = scope ?? string.Empty;
			Generation = generation;
		}
	}
	internal sealed class IdentityResyncCoordinator
	{
		internal const long QuietWindowMilliseconds = 500L;

		internal const long GlobalCooldownMilliseconds = 5000L;

		private string _currentScope = string.Empty;

		private string _currentOwner = string.Empty;

		private long _generation;

		private long _quietUntilMilliseconds;

		private long _lastBeginMilliseconds = long.MinValue;

		private long _completedGeneration;

		private string _completedScope = string.Empty;

		private long _sequence;

		private IdentityResyncLease _inFlight;

		internal long CurrentGeneration => _generation;

		internal string CurrentScope => _currentScope;

		internal bool IsInFlight => _inFlight.IsValid;

		internal long ObserveScope(string scope, string owner, long nowMilliseconds)
		{
			string text = (scope ?? string.Empty).Trim();
			string text2 = (owner ?? string.Empty).Trim();
			if (text.Length == 0 || text2.Length == 0)
			{
				ClearCurrentScope();
				return 0L;
			}
			if (!string.Equals(_currentScope, text, StringComparison.Ordinal) || !string.Equals(_currentOwner, text2, StringComparison.Ordinal))
			{
				_currentScope = text;
				_currentOwner = text2;
				AdvanceGeneration(nowMilliseconds);
			}
			return _generation;
		}

		internal long ObserveTrigger(string scope, string owner, IdentityResyncTrigger trigger, long nowMilliseconds)
		{
			ObserveScope(scope, owner, nowMilliseconds);
			if (_currentScope.Length == 0)
			{
				return 0L;
			}
			if (IdentityResyncTriggerPolicy.AdvancesGeneration(trigger) && trigger != IdentityResyncTrigger.LobbyOrOwnerIdentityChanged)
			{
				AdvanceGeneration(nowMilliseconds);
			}
			return _generation;
		}

		internal bool TryBegin(string scope, long generation, long nowMilliseconds, out IdentityResyncLease lease, out IdentityResyncBeginDecision decision)
		{
			lease = default(IdentityResyncLease);
			if (_currentScope.Length == 0)
			{
				decision = new IdentityResyncBeginDecision(IdentityResyncBeginReason.NoCurrentScope, 0L);
				return false;
			}
			if (!string.Equals(scope, _currentScope, StringComparison.Ordinal))
			{
				decision = new IdentityResyncBeginDecision(IdentityResyncBeginReason.ScopeMigrated, 0L);
				return false;
			}
			if (generation <= 0 || generation != _generation)
			{
				decision = new IdentityResyncBeginDecision(IdentityResyncBeginReason.StaleGeneration, 0L);
				return false;
			}
			if (_inFlight.IsValid)
			{
				decision = new IdentityResyncBeginDecision(IdentityResyncBeginReason.SingleFlight, 0L);
				return false;
			}
			if (string.Equals(_completedScope, _currentScope, StringComparison.Ordinal) && _completedGeneration == _generation)
			{
				decision = new IdentityResyncBeginDecision(IdentityResyncBeginReason.GenerationAlreadyCompleted, 0L);
				return false;
			}
			if (nowMilliseconds < _quietUntilMilliseconds)
			{
				decision = new IdentityResyncBeginDecision(IdentityResyncBeginReason.QuietWindow, _quietUntilMilliseconds - nowMilliseconds);
				return false;
			}
			if (_lastBeginMilliseconds != long.MinValue)
			{
				long num = _lastBeginMilliseconds + 5000;
				if (nowMilliseconds < num)
				{
					decision = new IdentityResyncBeginDecision(IdentityResyncBeginReason.GlobalCooldown, num - nowMilliseconds);
					return false;
				}
			}
			_sequence++;
			_inFlight = new IdentityResyncLease(_sequence, _currentScope, _generation);
			_lastBeginMilliseconds = nowMilliseconds;
			lease = _inFlight;
			decision = new IdentityResyncBeginDecision(IdentityResyncBeginReason.Ready, 0L);
			return true;
		}

		internal void Complete(IdentityResyncLease lease, long nowMilliseconds)
		{
			if (_inFlight.IsValid && lease.IsValid && lease.Sequence == _inFlight.Sequence)
			{
				_completedScope = lease.Scope;
				_completedGeneration = lease.Generation;
				_inFlight = default(IdentityResyncLease);
			}
		}

		internal void Abandon(IdentityResyncLease lease)
		{
			if (_inFlight.IsValid && lease.IsValid && lease.Sequence == _inFlight.Sequence)
			{
				_inFlight = default(IdentityResyncLease);
			}
		}

		internal void Reset()
		{
			_currentScope = string.Empty;
			_currentOwner = string.Empty;
			_generation = 0L;
			_quietUntilMilliseconds = 0L;
			_lastBeginMilliseconds = long.MinValue;
			_completedGeneration = 0L;
			_completedScope = string.Empty;
			_sequence = 0L;
			_inFlight = default(IdentityResyncLease);
		}

		private void AdvanceGeneration(long nowMilliseconds)
		{
			_generation++;
			_quietUntilMilliseconds = nowMilliseconds + 500;
			_inFlight = default(IdentityResyncLease);
		}

		private void ClearCurrentScope()
		{
			_currentScope = string.Empty;
			_currentOwner = string.Empty;
			_quietUntilMilliseconds = 0L;
			_inFlight = default(IdentityResyncLease);
		}
	}
	internal enum IdentityResyncAccess
	{
		Ordinary,
		Host,
		HelperReady,
		HelperWaitingForHost
	}
	internal enum IdentityResyncAction
	{
		Denied,
		Status,
		RefreshLocalSurfaces,
		RepairIncompleteRows,
		PublishHostRequest
	}
	internal sealed class IdentityResyncPlan
	{
		internal bool Allowed { get; }

		internal IdentityResyncAction Action { get; }

		internal bool ReadOnly { get; }

		internal bool RequiresAuthoritativeCapture { get; }

		internal bool MayWriteNativeIdentity => false;

		internal string Reason { get; }

		internal IdentityResyncPlan(bool allowed, IdentityResyncAction action, bool readOnly, bool requiresAuthoritativeCapture, string reason)
		{
			Allowed = allowed;
			Action = action;
			ReadOnly = readOnly;
			RequiresAuthoritativeCapture = requiresAuthoritativeCapture;
			Reason = reason ?? string.Empty;
		}
	}
	internal static class IdentityResyncPlanPolicy
	{
		internal static IdentityResyncPlan Plan(string commandName, string arguments, IdentityResyncAccess access)
		{
			string text = Normalize(commandName);
			if (text != "idsync" && text != "identitysync" && text != "rostersync")
			{
				return Denied("That command is not an identity-resync command.");
			}
			string[] array = (arguments ?? string.Empty).Split(new char[1] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
			string text2 = ((array.Length == 0) ? "status" : array[0].Trim().ToLowerInvariant());
			if (array.Length > 1)
			{
				return Denied("Identity resync accepts one operation only: status, refresh, repair, or request.");
			}
			switch (text2)
			{
			case "status":
			case "?":
			case "help":
				return new IdentityResyncPlan(allowed: true, IdentityResyncAction.Status, readOnly: true, requiresAuthoritativeCapture: false, "Read-only identity agreement status.");
			case "refresh":
				return new IdentityResyncPlan(allowed: true, IdentityResyncAction.RefreshLocalSurfaces, readOnly: false, requiresAuthoritativeCapture: false, "Refresh only BlueSage-owned local presentation from already available native state.");
			case "repair":
				if (access != IdentityResyncAccess.Host)
				{
					return Denied("Direct identity repair requires the verified current Host.");
				}
				return new IdentityResyncPlan(allowed: true, IdentityResyncAction.RepairIncompleteRows, readOnly: false, requiresAuthoritativeCapture: true, "Verified current Host may run one bounded exact-correlation repair.");
			case "request":
				if (access != IdentityResyncAccess.HelperReady)
				{
					return Denied((access == IdentityResyncAccess.HelperWaitingForHost) ? "Identity repair request is locked until the current Host capability is fresh." : "Identity repair request requires a Helper authenticated by the current Host.");
				}
				return new IdentityResyncPlan(allowed: true, IdentityResyncAction.PublishHostRequest, readOnly: false, requiresAuthoritativeCapture: false, "Authenticated Helper may publish one generation-bound request for Host revalidation.");
			default:
				return Denied("Identity resync accepts status, refresh, repair, or request.");
			}
		}

		private static IdentityResyncPlan Denied(string reason)
		{
			return new IdentityResyncPlan(allowed: false, IdentityResyncAction.Denied, readOnly: true, requiresAuthoritativeCapture: false, reason);
		}

		private static string Normalize(string value)
		{
			return (value ?? string.Empty).Trim().TrimStart(new char[1] { '/' }).ToLowerInvariant();
		}
	}
	internal sealed class IdentityResyncCoverage
	{
		internal int VerifiedRows { get; }

		internal int NativeRows { get; }

		internal int PurrNetRows { get; }

		internal int SteamMembers { get; }

		internal int LiveNativeOnlyRows { get; }

		internal int LeftStaleRows { get; }

		internal int AmbiguousRows { get; }

		internal int LockedRows { get; }

		internal bool CaptureAvailable { get; }

		internal bool Ready { get; }

		internal string ErrorReason { get; }

		internal string Reason { get; }

		internal IdentityResyncCoverage(int verifiedRows, int nativeRows, int purrNetRows, int steamMembers, int liveNativeOnlyRows, int leftStaleRows, int ambiguousRows, bool captureAvailable, string errorReason)
		{
			VerifiedRows = Math.Max(0, verifiedRows);
			NativeRows = Math.Max(0, nativeRows);
			PurrNetRows = Math.Max(0, purrNetRows);
			SteamMembers = Math.Max(0, steamMembers);
			LiveNativeOnlyRows = Math.Max(0, liveNativeOnlyRows);
			LeftStaleRows = Math.Max(0, leftStaleRows);
			AmbiguousRows = Math.Max(0, ambiguousRows);
			CaptureAvailable = captureAvailable;
			ErrorReason = errorReason ?? string.Empty;
			int val = Math.Max(0, NativeRows - VerifiedRows);
			int val2 = Math.Max(0, PurrNetRows - VerifiedRows);
			int val3 = Math.Max(0, SteamMembers - VerifiedRows);
			LockedRows = Math.Max(Math.Max(val, val2), Math.Max(val3, LiveNativeOnlyRows + LeftStaleRows + AmbiguousRows));
			Ready = CaptureAvailable && string.IsNullOrWhiteSpace(ErrorReason) && VerifiedRows == NativeRows && NativeRows == PurrNetRows && PurrNetRows == SteamMembers && LiveNativeOnlyRows == 0 && LeftStaleRows == 0 && AmbiguousRows == 0;
			Reason = BuildReason();
		}

		internal static IdentityResyncCoverage Unavailable(string reason)
		{
			return new IdentityResyncCoverage(0, 0, 0, 0, 0, 0, 0, captureAvailable: false, reason);
		}

		private string BuildReason()
		{
			if (!CaptureAvailable)
			{
				if (!string.IsNullOrWhiteSpace(ErrorReason))
				{
					return ErrorReason;
				}
				return "no authoritative identity snapshot is available yet";
			}
			if (!string.IsNullOrWhiteSpace(ErrorReason))
			{
				return ErrorReason;
			}
			if (NativeRows > SteamMembers || PurrNetRows > SteamMembers)
			{
				return "native/PurrNet rows exceed current Steam membership; unmatched rows remain locked";
			}
			if (SteamMembers > NativeRows || SteamMembers > PurrNetRows)
			{
				return "current Steam members are still waiting for exact native/PurrNet rows";
			}
			if (AmbiguousRows > 0)
			{
				return "ambiguous native/PurrNet rows remain locked";
			}
			if (LiveNativeOnlyRows > 0)
			{
				return "live native-only rows remain outside current Steam membership and locked";
			}
			if (LeftStaleRows > 0)
			{
				return "departed native history rows remain non-actionable";
			}
			if (!Ready)
			{
				return "exact Steam/PurrNet/native-row coverage is incomplete";
			}
			return "exact Steam/PurrNet/native-row coverage is ready";
		}
	}
	internal sealed class IdentityResyncRequest
	{
		internal int Version;

		internal string LobbyFingerprint = string.Empty;

		internal long Generation;

		internal string CapabilityFingerprint = string.Empty;

		internal long IssuedUnixSeconds;

		internal string Nonce = string.Empty;
	}
	internal static class IdentityResyncRequestProtocol
	{
		internal const string MemberDataKey = "bluesage_idsync_request_v1";

		internal const int MaximumPayloadBytes = 256;

		internal const long TimeToLiveSeconds = 15L;

		private const long FutureSkewSeconds = 2L;

		internal static bool TryBuild(string lobbyFingerprint, long generation, string capabilityFingerprint, long issuedUnixSeconds, string nonce, out string payload, out string error)
		{
			payload = string.Empty;
			error = string.Empty;
			if (!IsFingerprint(lobbyFingerprint) || !IsFingerprint(capabilityFingerprint) || generation <= 0 || issuedUnixSeconds <= 0 || !IsNonce(nonce))
			{
				error = "Identity-resync request fields were invalid.";
				return false;
			}
			payload = string.Join("|", "v1", "request", lobbyFingerprint, generation.ToString(CultureInfo.InvariantCulture), capabilityFingerprint, issuedUnixSeconds.ToString(CultureInfo.InvariantCulture), nonce);
			if (Encoding.UTF8.GetByteCount(payload) > 256)
			{
				payload = string.Empty;
				error = "Identity-resync request exceeded the 256-byte member-data limit.";
				return false;
			}
			return true;
		}

		internal static bool TryParse(string payload, out IdentityResyncRequest request, out string error)
		{
			request = new IdentityResyncRequest();
			error = string.Empty;
			if (string.IsNullOrWhiteSpace(payload) || Encoding.UTF8.GetByteCount(payload) > 256)
			{
				error = "Identity-resync request was empty or oversized.";
				return false;
			}
			string[] array = payload.Split(new char[1] { '|' });
			if (array.Length != 7 || !string.Equals(array[0], "v1", StringComparison.Ordinal) || !string.Equals(array[1], "request", StringComparison.Ordinal) || !IsFingerprint(array[2]) || !long.TryParse(array[3], NumberStyles.None, CultureInfo.InvariantCulture, out var result) || result <= 0 || !IsFingerprint(array[4]) || !long.TryParse(array[5], NumberStyles.None, CultureInfo.InvariantCulture, out var result2) || result2 <= 0 || !IsNonce(array[6]))
			{
				error = "Identity-resync request format or version was invalid.";
				return false;
			}
			request = new IdentityResyncRequest
			{
				Version = 1,
				LobbyFingerprint = array[2],
				Generation = result,
				CapabilityFingerprint = array[4],
				IssuedUnixSeconds = result2,
				Nonce = array[6]
			};
			return true;
		}

		internal static bool IsFresh(IdentityResyncRequest request, long nowUnixSeconds)
		{
			if (request != null && request.IssuedUnixSeconds <= nowUnixSeconds + 2)
			{
				return nowUnixSeconds - request.IssuedUnixSeconds <= 15;
			}
			return false;
		}

		internal static string FingerprintScope(string lobbyIdentity, string ownerIdentity)
		{
			return Fingerprint((lobbyIdentity ?? string.Empty) + "|" + (ownerIdentity ?? string.Empty));
		}

		internal static string FingerprintCapability(string capability)
		{
			return Fingerprint(capability ?? string.Empty);
		}

		private static string Fingerprint(string value)
		{
			ulong num = 14695981039346656037uL;
			byte[] bytes = Encoding.UTF8.GetBytes(value ?? string.Empty);
			for (int i = 0; i < bytes.Length; i++)
			{
				num ^= bytes[i];
				num *= 1099511628211L;
			}
			return num.ToString("X16", CultureInfo.InvariantCulture);
		}

		private static bool IsFingerprint(string value)
		{
			if (value == null || value.Length != 16)
			{
				return false;
			}
			foreach (char c in value)
			{
				bool num = c >= '0' && c <= '9';
				bool flag = c >= 'A' && c <= 'F';
				if (!num && !flag)
				{
					return false;
				}
			}
			return true;
		}

		private static bool IsNonce(string value)
		{
			if (value == null || value.Length != 16)
			{
				return false;
			}
			for (int i = 0; i < value.Length; i++)
			{
				if (!char.IsLetterOrDigit(value[i]))
				{
					return false;
				}
			}
			return true;
		}
	}
	internal enum IdentityResyncTrigger
	{
		None,
		RowInitialized,
		RowDisabledOrDespawned,
		LobbyOrOwnerIdentityChanged,
		PanelReplacement
	}
	internal readonly struct IdentityResyncRuntimeShape
	{
		internal string LobbyFingerprint { get; }

		internal string OwnerFingerprint { get; }

		internal int PanelToken { get; }

		internal int ActiveRows { get; }

		internal long RowSignature { get; }

		internal bool Available
		{
			get
			{
				if (LobbyFingerprint.Length > 0)
				{
					return OwnerFingerprint.Length > 0;
				}
				return false;
			}
		}

		internal IdentityResyncRuntimeShape(string lobbyFingerprint, string ownerFingerprint, int panelToken, int activeRows, long rowSignature)
		{
			LobbyFingerprint = lobbyFingerprint ?? string.Empty;
			OwnerFingerprint = ownerFingerprint ?? string.Empty;
			PanelToken = panelToken;
			ActiveRows = Math.Max(0, activeRows);
			RowSignature = rowSignature;
		}
	}
	internal static class IdentityResyncTriggerPolicy
	{
		internal static bool AdvancesGeneration(IdentityResyncTrigger trigger)
		{
			if (trigger != IdentityResyncTrigger.RowInitialized && trigger != IdentityResyncTrigger.RowDisabledOrDespawned && trigger != IdentityResyncTrigger.LobbyOrOwnerIdentityChanged)
			{
				return trigger == IdentityResyncTrigger.PanelReplacement;
			}
			return true;
		}

		internal static IdentityResyncTrigger Classify(IdentityResyncRuntimeShape before, IdentityResyncRuntimeShape after)
		{
			if (!after.Available)
			{
				return IdentityResyncTrigger.None;
			}
			if (!before.Available || !string.Equals(before.LobbyFingerprint, after.LobbyFingerprint, StringComparison.Ordinal) || !string.Equals(before.OwnerFingerprint, after.OwnerFingerprint, StringComparison.Ordinal))
			{
				return IdentityResyncTrigger.LobbyOrOwnerIdentityChanged;
			}
			if (before.PanelToken != after.PanelToken)
			{
				return IdentityResyncTrigger.PanelReplacement;
			}
			if (after.ActiveRows < before.ActiveRows)
			{
				return IdentityResyncTrigger.RowDisabledOrDespawned;
			}
			if (after.ActiveRows > before.ActiveRows || after.RowSignature != before.RowSignature)
			{
				return IdentityResyncTrigger.RowInitialized;
			}
			return IdentityResyncTrigger.None;
		}
	}
	internal static class InputFieldLimitPolicy
	{
		public const int DefaultMaxChatCharacters = 3000;

		public const int DefaultMaxProfileCharacters = 3000;

		public const int DefaultMaxSessionNameCharacters = 3000;

		public const int MinChatCharacters = 1;

		public const int AbsoluteMaxChatCharacters = 4000;

		public const int AbsoluteMaxProfileCharacters = 4000;

		public const int AbsoluteMaxSessionNameCharacters = 4000;

		private static readonly HashSet<string> SessionNameFields = new HashSet<string>(StringComparer.Ordinal) { "InputField_SesionName", "InputField_SessionName" };

		private static readonly HashSet<string> IdCardFields = new HashSet<string>(StringComparer.Ordinal)
		{
			"InputField_Name", "InputField_DateOfBirth", "InputField_HoroscopeSign", "InputField_Location", "InputField_AreaOfStudy", "InputField_FavoriteQuote", "NameInputField", "DateOfBirthInputField", "HoroscopeSignInputField", "LocationInputField",
			"AreaOfStudyInputField", "FavoriteQuoteInputField"
		};

		private static readonly HashSet<string> ChatInputFields = new HashSet<string>(StringComparer.Ordinal) { "InputField_Chat", "InputField_Message", "InputField_ChatMessage", "ChatInputField", "MessageInputField" };

		public static int? GetLimit(string fieldName, int maxIdCardCharacters, int maxSessionNameCharacters, int maxChatCharacters)
		{
			if (string.IsNullOrEmpty(fieldName))
			{
				return null;
			}
			if (IdCardFields.Contains(fieldName))
			{
				return ClampProfileCharacters(maxIdCardCharacters);
			}
			if (SessionNameFields.Contains(fieldName))
			{
				return ClampSessionNameCharacters(maxSessionNameCharacters);
			}
			if (LooksLikeChatInput(fieldName))
			{
				return ClampChatCharacters(maxChatCharacters);
			}
			return null;
		}

		public static int ClampChatCharacters(int value)
		{
			return Clamp(value, 1, 4000);
		}

		public static int ClampProfileCharacters(int value)
		{
			return Clamp(value, 1, 4000);
		}

		public static int ClampSessionNameCharacters(int value)
		{
			return Clamp(value, 1, 4000);
		}

		private static bool LooksLikeChatInput(string fieldName)
		{
			if (ChatInputFields.Contains(fieldName))
			{
				return true;
			}
			if (fieldName.IndexOf("chat", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return fieldName.IndexOf("message", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return true;
		}

		private static int Clamp(int value, int min, int max)
		{
			if (value < min)
			{
				return min;
			}
			if (value > max)
			{
				return max;
			}
			return value;
		}
	}
	internal static class LobbyPingAuthorizationPolicy
	{
		public static string[] ParseDelegates(string persisted)
		{
			ulong result;
			return (from value in (persisted ?? string.Empty).Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries)
				select value.Trim() into value
				where ulong.TryParse(value, out result) && result != 0
				select value).Distinct<string>(StringComparer.Ordinal).OrderBy<string, string>((string value) => value, StringComparer.Ordinal).ToArray();
		}

		public static string SerializeDelegates(IEnumerable<string> values)
		{
			return string.Join(",", ParseDelegates(string.Join(",", values ?? Array.Empty<string>())));
		}

		public static bool IsAuthorized(string senderSteamId, string ownerSteamId, string persistedDelegates, string persistedDelegateOwnerSteamId, bool hasLobby)
		{
			if (!hasLobby || !ulong.TryParse(senderSteamId, out var result) || result == 0L)
			{
				return false;
			}
			if (!string.Equals(senderSteamId, ownerSteamId, StringComparison.Ordinal))
			{
				if (string.Equals(ownerSteamId, persistedDelegateOwnerSteamId, StringComparison.Ordinal))
				{
					return ParseDelegates(persistedDelegates).Contains<string>(senderSteamId, StringComparer.Ordinal);
				}
				return false;
			}
			return true;
		}
	}
	internal static class MentionNamePolicy
	{
		private sealed class MentionCandidate
		{
			public string OriginalName { get; }

			public string CanonicalName { get; }

			public MentionCandidate(string originalName, string canonicalName)
			{
				OriginalName = originalName ?? string.Empty;
				CanonicalName = canonicalName ?? string.Empty;
			}
		}

		private const string StatusGroupPattern = "(?:\\[[^\\[\\]]+\\]|\\([^\\(\\)]+\\))";

		private static readonly Regex RichTextTagRegex = new Regex("<[^>]+>", RegexOptions.Compiled);

		private static readonly Regex TrailingStatusGroups = new Regex("(?:\\s*(?:\\[[^\\[\\]]+\\]|\\([^\\(\\)]+\\)))+\\s*$", RegexOptions.Compiled);

		private static readonly Regex RepeatedWhitespace = new Regex("\\s+", RegexOptions.Compiled);

		private static readonly Regex MentionSafeWord = new Regex("[\\p{L}\\p{Nd}_][\\p{L}\\p{Nd}\\p{M}_.'-]*", RegexOptions.Compiled);

		private static readonly Regex MentionSafeFallback = new Regex("\\S+", RegexOptions.Compiled);

		public static readonly Regex MentionReferenceRegex = new Regex("@([^\\s<]+)((?:\\s*(?:\\[[^\\[\\]]+\\]|\\([^\\(\\)]+\\)))*)", RegexOptions.IgnoreCase | RegexOptions.Compiled);

		public static string ToMentionDisplayName(string value)
		{
			string text = ToMentionDisplayLabel(value);
			if (string.IsNullOrWhiteSpace(text))
			{
				return string.Empty;
			}
			string text2 = TrailingStatusGroups.Replace(text, string.Empty).Trim();
			if (!string.IsNullOrWhiteSpace(text2))
			{
				return text2;
			}
			return text.Trim();
		}

		public static string ToMentionDisplayLabel(string value)
		{
			return RichTextTagRegex.Replace(value ?? string.Empty, string.Empty).Trim().Trim(new char[1]);
		}

		public static string ToCanonicalMentionName(string value)
		{
			string text = ToMentionDisplayName(value);
			if (string.IsNullOrWhiteSpace(text))
			{
				return string.Empty;
			}
			string text2 = RepeatedWhitespace.Replace(text.Normalize(NormalizationForm.FormKC), " ").Trim();
			int i = 0;
			int num;
			for (num = text2.Length - 1; i <= num && IsHarmlessBoundaryDecoration(text2[i]); i++)
			{
			}
			while (num >= i && IsHarmlessBoundaryDecoration(text2[num]))
			{
				num--;
			}
			if (i > num)
			{
				return text2;
			}
			return text2.Substring(i, num - i + 1).Trim();
		}

		public static string ToMentionInsertionToken(string value)
		{
			string text = ToCanonicalMentionName(value);
			if (string.IsNullOrWhiteSpace(text))
			{
				return string.Empty;
			}
			Match match = MentionSafeWord.Match(text);
			if (match.Success)
			{
				return match.Value;
			}
			Match match2 = MentionSafeFallback.Match(text);
			if (!match2.Success)
			{
				return string.Empty;
			}
			return match2.Value;
		}

		public static string FindUniqueMentionMatch(string query, IEnumerable<string> candidates)
		{
			string cleanQuery = ToCanonicalMentionName(query);
			if (string.IsNullOrWhiteSpace(cleanQuery) || candidates == null)
			{
				return string.Empty;
			}
			MentionCandidate[] candidates2 = (from value in candidates
				select new MentionCandidate(value, ToCanonicalMentionName(value)) into candidate
				where !string.IsNullOrWhiteSpace(candidate.CanonicalName)
				select candidate).ToArray();
			string result = FindUniqueTier(candidates2, (MentionCandidate candidate) => string.Equals(candidate.CanonicalName, cleanQuery, StringComparison.OrdinalIgnoreCase), out var hadMatches);
			if (hadMatches)
			{
				return result;
			}
			result = FindUniqueTier(candidates2, (MentionCandidate candidate) => candidate.CanonicalName.StartsWith(cleanQuery, StringComparison.OrdinalIgnoreCase), out hadMatches);
			if (hadMatches)
			{
				return result;
			}
			bool hadMatches2;
			return FindUniqueTier(candidates2, (MentionCandidate candidate) => candidate.CanonicalName.IndexOf(cleanQuery, StringComparison.OrdinalIgnoreCase) >= 0, out hadMatches2);
		}

		public static bool IsLocalMentionMatch(string matchedName, string localName, string token)
		{
			string text = ToCanonicalMentionName(matchedName);
			string text2 = ToCanonicalMentionName(localName);
			if (string.IsNullOrWhiteSpace(text2) || string.IsNullOrWhiteSpace(text))
			{
				return false;
			}
			return string.Equals(text, text2, StringComparison.OrdinalIgnoreCase);
		}

		private static string FindUniqueTier(IEnumerable<MentionCandidate> candidates, Func<MentionCandidate, bool> predicate, out bool hadMatches)
		{
			MentionCandidate[] array = candidates.Where(predicate).Take(2).ToArray();
			hadMatches = array.Length != 0;
			if (array.Length != 1)
			{
				return string.Empty;
			}
			return array[0].OriginalName;
		}

		private static bool IsHarmlessBoundaryDecoration(char value)
		{
			if (char.IsWhiteSpace(value) || char.IsSurrogate(value))
			{
				return true;
			}
			switch (CharUnicodeInfo.GetUnicodeCategory(value))
			{
			case UnicodeCategory.NonSpacingMark:
			case UnicodeCategory.SpacingCombiningMark:
			case UnicodeCategory.EnclosingMark:
			case UnicodeCategory.Control:
			case UnicodeCategory.Format:
			case UnicodeCategory.DashPunctuation:
			case UnicodeCategory.OpenPunctuation:
			case UnicodeCategory.ClosePunctuation:
			case UnicodeCategory.InitialQuotePunctuation:
			case UnicodeCategory.FinalQuotePunctuation:
			case UnicodeCategory.OtherPunctuation:
			case UnicodeCategory.MathSymbol:
			case UnicodeCategory.CurrencySymbol:
			case UnicodeCategory.ModifierSymbol:
			case UnicodeCategory.OtherSymbol:
				return true;
			default:
				return false;
			}
		}
	}
	internal static class ModerationAuthorizationPolicy
	{
		internal static bool IsAuthorizedIssuer(string senderSteamId, string ownerSteamId, string persistedDelegates, string persistedDelegateOwnerSteamId, bool hasLobby)
		{
			return LobbyPingAuthorizationPolicy.IsAuthorized(senderSteamId, ownerSteamId, persistedDelegates, persistedDelegateOwnerSteamId, hasLobby);
		}

		internal static bool CanBanTarget(string targetSteamId, string ownerSteamId, string persistedDelegates, string issuerSteamId, bool targetIsProtectedVictim, bool targetIsPresent)
		{
			if (!targetIsPresent || targetIsProtectedVictim || !ModerationProtocolPolicy.IsSteamId64(targetSteamId))
			{
				return false;
			}
			if (targetSteamId == ownerSteamId || targetSteamId == issuerSteamId)
			{
				return false;
			}
			return Array.IndexOf(LobbyPingAuthorizationPolicy.ParseDelegates(persistedDelegates), targetSteamId) < 0;
		}
	}
	internal static class ModerationCapabilityPolicy
	{
		internal const long MaxLeaseAgeSeconds = 20L;

		private const long MaxFutureClockSkewSeconds = 5L;

		private const string Version = "v3-memberdata";

		internal static string Build(string ownerSteamId, long issuedUnixSeconds)
		{
			return (ownerSteamId ?? string.Empty).Trim() + "|v3-memberdata|" + issuedUnixSeconds;
		}

		internal static bool IsFresh(string value, string expectedOwnerSteamId, long nowUnixSeconds)
		{
			string[] array = (value ?? string.Empty).Split(new char[1] { '|' });
			if (array.Length != 3 || !string.Equals(array[0], expectedOwnerSteamId, StringComparison.Ordinal) || !string.Equals(array[1], "v3-memberdata", StringComparison.Ordinal) || !long.TryParse(array[2], out var result))
			{
				return false;
			}
			long num = nowUnixSeconds - result;
			if (num >= -5)
			{
				return num <= 20;
			}
			return false;
		}
	}
	internal readonly struct ModerationRequest
	{
		internal string Action { get; }

		internal string TargetSteamId { get; }

		internal string IncidentId { get; }

		internal long IssuedUnixSeconds { get; }

		internal string Nonce { get; }

		internal ModerationRequest(string action, string targetSteamId, string incidentId, long issuedUnixSeconds, string nonce)
		{
			Action = action;
			TargetSteamId = targetSteamId;
			IncidentId = incidentId;
			IssuedUnixSeconds = issuedUnixSeconds;
			Nonce = nonce;
		}
	}
	internal readonly struct ModerationConfirmationReadiness
	{
		internal bool IsReady { get; }

		internal int SecondsRemaining { get; }

		internal ModerationConfirmationReadiness(bool isReady, int secondsRemaining)
		{
			IsReady = isReady;
			SecondsRemaining = secondsRemaining;
		}
	}
	internal static class ModerationProtocolPolicy
	{
		internal const string Prefix = "!bsmod:v1:";

		internal const string MemberDataKey = "bluesage_moderation_request_v2";

		internal const string MemberDataPrefix = "v2|";

		internal const int RequestExpirySeconds = 15;

		internal static string Build(string action, string targetSteamId, string incidentId, long issuedUnixSeconds, string nonce)
		{
			return "!bsmod:v1:" + action + ":" + targetSteamId + ":" + NormalizeIncident(incidentId) + ":" + issuedUnixSeconds + ":" + nonce;
		}

		internal static string BuildMemberData(string action, string targetSteamId, string incidentId, long issuedUnixSeconds, string nonce)
		{
			if ((action != "ban" && action != "unban") || !IsSteamId64(targetSteamId) || !IsIncident(NormalizeIncident(incidentId)) || issuedUnixSeconds <= 0 || !IsNonce(nonce))
			{
				return string.Empty;
			}
			return "v2|" + action + "|" + targetSteamId + "|" + NormalizeIncident(incidentId) + "|" + issuedUnixSeconds + "|" + nonce;
		}

		internal static bool TryParseMemberData(string value, out ModerationRequest request)
		{
			request = default(ModerationRequest);
			if (string.IsNullOrWhiteSpace(value) || !value.StartsWith("v2|", StringComparison.Ordinal))
			{
				return false;
			}
			string[] array = value.Substring("v2|".Length).Split(new char[1] { '|' });
			if (array.Length == 5)
			{
				return TryParse("!bsmod:v1:" + string.Join(":", array), out request);
			}
			return false;
		}

		internal static bool TryParse(string text, out ModerationRequest request)
		{
			request = default(ModerationRequest);
			if (string.IsNullOrWhiteSpace(text) || !text.StartsWith("!bsmod:v1:", StringComparison.Ordinal))
			{
				return false;
			}
			string[] array = text.Substring("!bsmod:v1:".Length).Split(new char[1] { ':' });
			if (array.Length != 5 || (array[0] != "ban" && array[0] != "unban"))
			{
				return false;
			}
			if (!IsSteamId64(array[1]) || !IsIncident(array[2]) || !long.TryParse(array[3], out var result) || result <= 0)
			{
				return false;
			}
			string text2 = array[4];
			if (text2.Length < 8 || text2.Length > 24)
			{
				return false;
			}
			string text3 = text2;
			for (int i = 0; i < text3.Length; i++)
			{
				if (!char.IsLetterOrDigit(text3[i]))
				{
					return false;
				}
			}
			request = new ModerationRequest(array[0], array[1], array[2], result, text2);
			return true;
		}

		internal static bool IsFresh(ModerationRequest request, long nowUnixSeconds)
		{
			long num = nowUnixSeconds - request.IssuedUnixSeconds;
			if (num >= -2)
			{
				return num <= 15;
			}
			return false;
		}

		internal static ModerationConfirmationReadiness EvaluateConfirmation(string requestedAction, string requestedTarget, string currentLobbyCode, long nowUnixSeconds, string pendingAction, string pendingTargetSteamId, string pendingIncidentId, string pendingLobbyCode, long pendingExpiresUnixSeconds)
		{
			bool flag = string.Equals(requestedTarget, pendingTargetSteamId, StringComparison.Ordinal) || (!string.Equals(pendingIncidentId, "none", StringComparison.Ordinal) && string.Equals(requestedTarget, pendingIncidentId, StringComparison.OrdinalIgnoreCase));
			long num = pendingExpiresUnixSeconds - nowUnixSeconds;
			if (!(!string.IsNullOrWhiteSpace(requestedAction) && !string.IsNullOrWhiteSpace(requestedTarget) && string.Equals(requestedAction, pendingAction, StringComparison.Ordinal) && flag) || !string.Equals(currentLobbyCode ?? string.Empty, pendingLobbyCode ?? string.Empty, StringComparison.Ordinal) || num < 0)
			{
				return new ModerationConfirmationReadiness(isReady: false, 0);
			}
			return new ModerationConfirmationReadiness(isReady: true, (int)Math.Min(2147483647L, num));
		}

		internal static bool IsSteamId64(string value)
		{
			if (value != null && value.Length == 17 && ulong.TryParse(value, out var result))
			{
				return result != 0;
			}
			return false;
		}

		private static bool IsIncident(string value)
		{
			if (string.Equals(value, "none", StringComparison.Ordinal))
			{
				return true;
			}
			if (string.IsNullOrEmpty(value) || value.Length < 2 || value.Length > 8 || value[0] != 'C')
			{
				return false;
			}
			for (int i = 1; i < value.Length; i++)
			{
				if (!char.IsDigit(value[i]))
				{
					return false;
				}
			}
			return true;
		}

		private static string NormalizeIncident(string value)
		{
			if (!IsIncident(value))
			{
				return "none";
			}
			return value;
		}

		private static bool IsNonce(string value)
		{
			if (string.IsNullOrEmpty(value) || value.Length < 8 || value.Length > 24)
			{
				return false;
			}
			for (int i = 0; i < value.Length; i++)
			{
				if (!char.IsLetterOrDigit(value[i]))
				{
					return false;
				}
			}
			return true;
		}
	}
	internal readonly struct ModerationTarget
	{
		internal string SteamId { get; }

		internal string IncidentId { get; }

		internal ModerationTarget(string steamId, string incidentId)
		{
			SteamId = steamId;
			IncidentId = incidentId;
		}
	}
	internal static class ModerationTargetResolver
	{
		internal static bool TryResolve(string query, IEnumerable<string> presentSteamIds, out ModerationTarget target, out string error)
		{
			target = default(ModerationTarget);
			error = "Use a clone incident ID, full SteamID64, or unique 6+ digit suffix.";
			string clean = (query ?? string.Empty).Trim();
			string[] source = (presentSteamIds ?? Array.Empty<string>()).Where(ModerationProtocolPolicy.IsSteamId64).Distinct<string>(StringComparer.Ordinal).ToArray();
			if (CloneIncidentLedger.TryResolveIncident(clean, out CloneIncident incident))
			{
				if (!source.Contains<string>(incident.SuspectSteamId, StringComparer.Ordinal))
				{
					error = incident.Id + " suspect is no longer present; no action was taken.";
					return false;
				}
				target = new ModerationTarget(incident.SuspectSteamId, incident.Id);
				return true;
			}
			if (ModerationProtocolPolicy.IsSteamId64(clean))
			{
				if (!source.Contains<string>(clean, StringComparer.Ordinal))
				{
					error = "That SteamID64 is not uniquely present in the current lobby.";
					return false;
				}
				target = new ModerationTarget(clean, "none");
				return true;
			}
			if (clean.Length < 6 || clean.Any((char c) => !char.IsDigit(c)))
			{
				return false;
			}
			string[] array = source.Where((string id) => id.EndsWith(clean, StringComparison.Ordinal)).ToArray();
			if (array.Length != 1)
			{
				error = ((array.Length > 1) ? "That Steam ID suffix is ambiguous; use more digits or the full SteamID64." : "No current lobby member matches that Steam ID suffix.");
				return false;
			}
			target = new ModerationTarget(array[0], "none");
			return true;
		}
	}
	internal enum NativeAssetSweepOwnershipState
	{
		BlueSage,
		NativeGame,
		InspectionIncomplete
	}
	internal enum NativeSweepCoordinationDecision
	{
		Skip,
		Defer,
		SatisfiedByVanilla,
		Run
	}
	internal static class NativeAssetSweepPolicy
	{
		internal const float VanillaBoundaryWindowSeconds = 60f;

		public static bool IsPresent(bool mainSceneTimerPresent, bool settingsDurationPresent, bool unloadUnusedAssetsCallPresent)
		{
			return mainSceneTimerPresent && settingsDurationPresent && unloadUnusedAssetsCallPresent;
		}

		public static bool ShouldStandDown(bool mainSceneTimerPresent, bool settingsDurationPresent, bool unloadUnusedAssetsCallPresent, bool inspectionFailed)
		{
			return ResolveOwnership(mainSceneTimerPresent, settingsDurationPresent, unloadUnusedAssetsCallPresent, inspectionFailed) != NativeAssetSweepOwnershipState.BlueSage;
		}

		public static NativeAssetSweepOwnershipState ResolveOwnership(bool mainSceneTimerPresent, bool settingsDurationPresent, bool unloadUnusedAssetsCallPresent, bool inspectionFailed)
		{
			if (!inspectionFailed && IsPresent(mainSceneTimerPresent, settingsDurationPresent, unloadUnusedAssetsCallPresent))
			{
				return NativeAssetSweepOwnershipState.NativeGame;
			}
			if (!(inspectionFailed || mainSceneTimerPresent || settingsDurationPresent || unloadUnusedAssetsCallPresent))
			{
				return NativeAssetSweepOwnershipState.BlueSage;
			}
			return NativeAssetSweepOwnershipState.InspectionIncomplete;
		}

		public static bool AllowBlueSageAutoSweep(bool nativeSweepPresent, bool compatibilityAllows, bool savedEnabled)
		{
			return compatibilityAllows && savedEnabled;
		}

		public static bool AllowBlueSageManualSweep(bool nativeSweepPresent, bool compatibilityAllows)
		{
			return compatibilityAllows;
		}

		public static NativeSweepCoordinationDecision DecideAutomaticSweep(bool automaticDue, bool blueSageSweepRunning, bool vanillaStateAvailable, float vanillaTimerSeconds, float vanillaDurationSeconds, bool vanillaSweepActive)
		{
			if (!automaticDue || blueSageSweepRunning)
			{
				return NativeSweepCoordinationDecision.Skip;
			}
			if (!vanillaStateAvailable)
			{
				return NativeSweepCoordinationDecision.Defer;
			}
			if (float.IsNaN(vanillaTimerSeconds) || float.IsInfinity(vanillaTimerSeconds) || float.IsNaN(vanillaDurationSeconds) || float.IsInfinity(vanillaDurationSeconds) || vanillaTimerSeconds < 0f || vanillaDurationSeconds <= 0f)
			{
				return NativeSweepCoordinationDecision.Defer;
			}
			float num = vanillaDurationSeconds - vanillaTimerSeconds;
			if (vanillaSweepActive || vanillaTimerSeconds <= 60f)
			{
				return NativeSweepCoordinationDecision.SatisfiedByVanilla;
			}
			if (num <= 60f)
			{
				return NativeSweepCoordinationDecision.Defer;
			}
			return NativeSweepCoordinationDecision.Run;
		}
	}
	internal enum NativeIdCardCallerKind
	{
		OrdinaryUser,
		Host,
		AuthenticatedHelper,
		BluePrivateConsumer
	}
	internal enum NativeIdCardResolutionState
	{
		Ready,
		InvalidSteamIdentity,
		FreshEvidenceUnavailable,
		FreshSteamIdentityMismatch,
		NativeListsMisaligned,
		ExpectedIndexUnavailable,
		StaleExpectedIndex,
		NativeRowIndexMismatch,
		NativeRowReferenceMismatch,
		RowSteamIdentityChanged,
		PurrNetIdentityUnavailable,
		ObservedPurrNetIdentityChanged,
		PurrNetIdentityMismatch,
		UnityTransformUnavailable,
		UnityTransformIdentityChanged,
		FinalTupleChanged
	}
	internal sealed class NativeIdCardResolutionContext
	{
		internal NativeIdCardCallerKind CallerKind;

		internal string RequestedSteamId = string.Empty;

		internal bool FreshResolutionSucceeded;

		internal string FreshResolvedSteamId = string.Empty;

		internal string FreshResolvedPlayerId = string.Empty;

		internal string ExpectedPlayerId = string.Empty;

		internal int FreshResolvedIndex = -1;

		internal int ExpectedIndex = -1;

		internal int CurrentRowIndex = -1;

		internal bool CurrentRowReferenceMatches;

		internal string CurrentRowSteamId = string.Empty;

		internal string CurrentRowPlayerId = string.Empty;

		internal bool HasLiveNetworkTransform;

		internal bool NativeListsAligned;

		internal bool ExpectedNetworkTransformMatches;

		internal bool FinalTupleStable;
	}
	internal sealed class NativeIdCardResolutionDecision
	{
		internal NativeIdCardResolutionState State;

		internal int PlayerIndex = -1;

		internal bool MayOpenNativeCard;

		internal string Reason = string.Empty;
	}
	internal static class NativeIdCardResolutionPolicy
	{
		internal static NativeIdCardResolutionDecision Evaluate(NativeIdCardResolutionContext? context)
		{
			if (context == null || !ModerationProtocolPolicy.IsSteamId64(context.RequestedSteamId))
			{
				return Reject(NativeIdCardResolutionState.InvalidSteamIdentity, "the request does not contain one valid SteamID64");
			}
			_ = context.CallerKind;
			if (!context.FreshResolutionSucceeded)
			{
				return Reject(NativeIdCardResolutionState.FreshEvidenceUnavailable, "fresh current identity evidence is unavailable");
			}
			if (!string.Equals(context.FreshResolvedSteamId, context.RequestedSteamId, StringComparison.Ordinal))
			{
				return Reject(NativeIdCardResolutionState.FreshSteamIdentityMismatch, "fresh evidence resolved a different Steam identity");
			}
			if (!context.NativeListsAligned)
			{
				return Reject(NativeIdCardResolutionState.NativeListsMisaligned, "the current native roster lists are not aligned");
			}
			if (context.ExpectedIndex < 0)
			{
				return Reject(NativeIdCardResolutionState.ExpectedIndexUnavailable, "the clicked surface has no current native roster index");
			}
			if (context.ExpectedIndex != context.FreshResolvedIndex)
			{
				return Reject(NativeIdCardResolutionState.StaleExpectedIndex, "the clicked surface index is stale");
			}
			if (context.CurrentRowIndex != context.FreshResolvedIndex)
			{
				return Reject(NativeIdCardResolutionState.NativeRowIndexMismatch, "the current player-row index disagrees with fresh evidence");
			}
			if (!context.CurrentRowReferenceMatches)
			{
				return Reject(NativeIdCardResolutionState.NativeRowReferenceMismatch, "the current native row object no longer matches the clicked surface");
			}
			if (!string.Equals(context.CurrentRowSteamId, context.RequestedSteamId, StringComparison.Ordinal))
			{
				return Reject(NativeIdCardResolutionState.RowSteamIdentityChanged, "the native row now belongs to another Steam identity");
			}
			if (string.IsNullOrWhiteSpace(context.ExpectedPlayerId) || string.IsNullOrWhiteSpace(context.CurrentRowPlayerId) || string.IsNullOrWhiteSpace(context.FreshResolvedPlayerId))
			{
				return Reject(NativeIdCardResolutionState.PurrNetIdentityUnavailable, "the current PurrNet player identity is unavailable");
			}
			if (!string.Equals(context.ExpectedPlayerId, context.CurrentRowPlayerId, StringComparison.Ordinal))
			{
				return Reject(NativeIdCardResolutionState.ObservedPurrNetIdentityChanged, "the clicked surface now points at another PurrNet identity");
			}
			if (!string.Equals(context.CurrentRowPlayerId, context.FreshResolvedPlayerId, StringComparison.Ordinal))
			{
				return Reject(NativeIdCardResolutionState.PurrNetIdentityMismatch, "the current PurrNet player identity changed");
			}
			if (!context.HasLiveNetworkTransform)
			{
				return Reject(NativeIdCardResolutionState.UnityTransformUnavailable, "the current Unity/PurrNet transform is unavailable");
			}
			if (!context.ExpectedNetworkTransformMatches)
			{
				return Reject(NativeIdCardResolutionState.UnityTransformIdentityChanged, "the clicked surface now points at another Unity/PurrNet transform");
			}
			if (!context.FinalTupleStable)
			{
				return Reject(NativeIdCardResolutionState.FinalTupleChanged, "the native identity tuple changed before invocation");
			}
			return new NativeIdCardResolutionDecision
			{
				State = NativeIdCardResolutionState.Ready,
				PlayerIndex = context.FreshResolvedIndex,
				MayOpenNativeCard = true,
				Reason = "exact current Steam/PurrNet/Unity/native-row agreement"
			};
		}

		private static NativeIdCardResolutionDecision Reject(NativeIdCardResolutionState state, string reason)
		{
			return new NativeIdCardResolutionDecision
			{
				State = state,
				PlayerIndex = -1,
				MayOpenNativeCard = false,
				Reason = reason
			};
		}
	}
	internal enum NativeIdCardInvocationState
	{
		Opened,
		TupleUnavailableBeforePanelClose,
		TupleChangedAfterPanelClose
	}
	internal static class NativeIdCardInvocationGuard
	{
		internal static NativeIdCardInvocationState Invoke(Func<bool> isTupleStable, Action closePanel, Action openNativeCard)
		{
			if (isTupleStable == null || closePanel == null || openNativeCard == null || !isTupleStable())
			{
				return NativeIdCardInvocationState.TupleUnavailableBeforePanelClose;
			}
			closePanel();
			if (!isTupleStable())
			{
				return NativeIdCardInvocationState.TupleChangedAfterPanelClose;
			}
			openNativeCard();
			return NativeIdCardInvocationState.Opened;
		}
	}
	internal static class NativeRosterShapePolicy
	{
		internal static bool HasAlignedActivePrefix(int steamIdCount, int playerIdCount, int transformCount, int idInfoCount, int pooledRowCount)
		{
			if (steamIdCount >= 0 && playerIdCount == steamIdCount && transformCount == steamIdCount && idInfoCount == steamIdCount)
			{
				return pooledRowCount >= steamIdCount;
			}
			return false;
		}
	}
	internal static class NavigationCalloutPolicy
	{
		internal const string NotificationKeywordHex = "0B6FA4";

		internal static string BuildPrimaryWelcomeMessage(string version)
		{
			return "BlueSage QoL v" + SanitizeVersion(version) + ": " + Highlight("HOME", "0B6FA4") + " opens QoL Menu. " + Highlight("INSERT", "0B6FA4") + " opens Style Helper for names, status, Spoons, colors, and templates. /qol status shows what is on.";
		}

		internal static string BuildCommandBrowserHint()
		{
			return "open " + Highlight("SLASH COMMANDS", "0B6FA4") + " by typing /, then press Tab or click a suggestion.";
		}

		internal static string BuildMenuNavigationHint(string keywordHex)
		{
			return Highlight("HOME", keywordHex) + " reopens this menu. " + Highlight("INSERT", keywordHex) + " opens Style Helper. Type / to browse " + Highlight("SLASH COMMANDS", keywordHex) + ".";
		}

		private static string Highlight(string keyword, string hex)
		{
			return "<b><color=#" + SanitizeHex(hex) + ">" + keyword + "</color></b>";
		}

		private static string SanitizeVersion(string version)
		{
			if (string.IsNullOrEmpty(version))
			{
				return "unknown";
			}
			StringBuilder stringBuilder = new StringBuilder(version.Length);
			foreach (char c in version)
			{
				if (char.IsLetterOrDigit(c) || c == '.' || c == '+' || c == '-')
				{
					stringBuilder.Append(c);
				}
			}
			if (stringBuilder.Length <= 0)
			{
				return "unknown";
			}
			return stringBuilder.ToString();
		}

		private static string SanitizeHex(string hex)
		{
			if (hex != null && hex.Length == 6)
			{
				for (int i = 0; i < hex.Length; i++)
				{
					if (!Uri.IsHexDigit(hex[i]))
					{
						return "0B6FA4";
					}
				}
				return hex.ToUpperInvariant();
			}
			return "0B6FA4";
		}
	}
	internal static class OfflineBanPolicy
	{
		internal static bool IsConfirmedAbsentFromCurrentLobby(int currentLobbyMatches)
		{
			return currentLobbyMatches == 0;
		}

		internal static bool CanSave(string ownerSteamId, string issuerSteamId, string targetSteamId, string persistedHelpers, bool targetIsProtectedVictim, bool targetIsAbsent, out string reason)
		{
			reason = "Offline SteamID64 bans require the active host, an exact absent target, and a valid native ban list.";
			if (!ModerationProtocolPolicy.IsSteamId64(ownerSteamId) || !ModerationProtocolPolicy.IsSteamId64(issuerSteamId) || !ModerationProtocolPolicy.IsSteamId64(targetSteamId) || !targetIsAbsent || targetIsProtectedVictim)
			{
				return false;
			}
			if (!string.Equals(ownerSteamId, issuerSteamId, StringComparison.Ordinal))
			{
				reason = "Only the active lobby host can save a SteamID64 that is not in the current lobby.";
				return false;
			}
			if (string.Equals(targetSteamId, ownerSteamId, StringComparison.Ordinal))
			{
				reason = "The host's own SteamID64 cannot be added to the host's native ban list.";
				return false;
			}
			if (Array.IndexOf(LobbyPingAuthorizationPolicy.ParseDelegates(persistedHelpers), targetSteamId) >= 0)
			{
				reason = "Remove this SteamID64 from Helpers before creating an offline native ban.";
				return false;
			}
			reason = string.Empty;
			return true;
		}
	}
	internal static class PerformanceOverlayOwnershipPolicy
	{
		public static bool IsActive(bool pluginReady, bool pluginEnabled, bool observationOnly, bool controllerStarted, bool overlayEnabled)
		{
			return pluginReady && pluginEnabled && !observationOnly && controllerStarted && overlayEnabled;
		}
	}
	internal sealed class PerformanceOverlayPosition
	{
		public double OffsetX { get; }

		public double OffsetY { get; }

		public PerformanceOverlayPosition(double offsetX, double offsetY)
		{
			OffsetX = offsetX;
			OffsetY = offsetY;
		}
	}
	internal static class PerformanceOverlayPositionPolicy
	{
		public static PerformanceOverlayPosition ClampToScreen(double offsetX, double offsetY, double overlayWidth, double overlayHeight, double screenWidth, double screenHeight)
		{
			double maximum = Math.Max(0.0, PositiveFiniteOrZero(screenWidth) - PositiveFiniteOrZero(overlayWidth));
			double maximum2 = Math.Max(0.0, PositiveFiniteOrZero(screenHeight) - PositiveFiniteOrZero(overlayHeight));
			return new PerformanceOverlayPosition(ClampFinite(offsetX, maximum), ClampFinite(offsetY, maximum2));
		}

		private static double PositiveFiniteOrZero(double value)
		{
			if (!double.IsNaN(value) && !double.IsInfinity(value) && !(value <= 0.0))
			{
				return value;
			}
			return 0.0;
		}

		private static double ClampFinite(double value, double maximum)
		{
			if (!double.IsNaN(value) && !double.IsInfinity(value))
			{
				return Math.Max(0.0, Math.Min(maximum, value));
			}
			return 0.0;
		}
	}
	internal sealed class PerformanceOverlaySettings
	{
		public double RefreshSeconds { get; }

		public int FontSize { get; }

		public double OffsetX { get; }

		public double OffsetY { get; }

		public double Width { get; }

		public PerformanceOverlaySettings(double refreshSeconds, int fontSize, double offsetX, double offsetY, double width)
		{
			RefreshSeconds = refreshSeconds;
			FontSize = fontSize;
			OffsetX = offsetX;
			OffsetY = offsetY;
			Width = width;
		}
	}
	internal static class PerformanceOverlaySettingsPolicy
	{
		public static PerformanceOverlaySettings Normalize(double refreshSeconds, int fontSize, double offsetX, double offsetY, double width)
		{
			return new PerformanceOverlaySettings(ClampFinite(refreshSeconds, 0.25, 5.0, 0.25), (fontSize <= 0) ? 13 : Math.Max(8, Math.Min(32, fontSize)), ClampFinite(offsetX, -2048.0, 2048.0, 12.0), ClampFinite(offsetY, -2048.0, 2048.0, 174.0), ClampFinite(width, 320.0, 1024.0, 320.0));
		}

		private static double ClampFinite(double value, double minimum, double maximum, double fallback)
		{
			if (!double.IsNaN(value) && !double.IsInfinity(value))
			{
				return Math.Max(minimum, Math.Min(maximum, value));
			}
			return fallback;
		}
	}
	internal sealed class PerformanceOverlayState
	{
		private const double SmoothingFactor = 0.2;

		public double SmoothedFramesPerSecond { get; private set; }

		public void SampleFrame(double unscaledDeltaSeconds)
		{
			if (!(unscaledDeltaSeconds <= 0.0) && !double.IsNaN(unscaledDeltaSeconds) && !double.IsInfinity(unscaledDeltaSeconds))
			{
				double num = Math.Min(1000.0, 1.0 / unscaledDeltaSeconds);
				SmoothedFramesPerSecond = ((SmoothedFramesPerSecond <= 0.0) ? num : (SmoothedFramesPerSecond + (num - SmoothedFramesPerSecond) * 0.2));
			}
		}

		public string BuildLabel(int? pingMilliseconds, long? workingSetBytes)
		{
			string text = ((SmoothedFramesPerSecond > 0.0) ? Math.Round(SmoothedFramesPerSecond, MidpointRounding.AwayFromZero).ToString(CultureInfo.InvariantCulture) : "--");
			string text2 = ((pingMilliseconds.HasValue && pingMilliseconds.Value >= 0) ? (pingMilliseconds.Value.ToString(CultureInfo.InvariantCulture) + " ms") : "--");
			return "FPS " + text + "  PING " + text2 + "  RAM " + FormatWorkingSet(workingSetBytes);
		}

		private static string FormatWorkingSet(long? workingSetBytes)
		{
			if (!workingSetBytes.HasValue || workingSetBytes.Value <= 0)
			{
				return "--";
			}
			if (!((double)workingSetBytes.Value >= 1073741824.0))
			{
				return Math.Round((double)workingSetBytes.Value / 1048576.0, MidpointRounding.AwayFromZero).ToString(CultureInfo.InvariantCulture) + " MB";
			}
			return ((double)workingSetBytes.Value / 1073741824.0).ToString("0.00", CultureInfo.InvariantCulture) + " GB";
		}
	}
	internal readonly struct PlayerBadgeLayout
	{
		internal float LaneWidth { get; }

		internal float NativeNameReservation { get; }

		internal float HostStart { get; }

		internal float HostWidth { get; }

		internal float BadgeStart { get; }

		internal float BadgeWidth { get; }

		internal PlayerBadgeLayout(float laneWidth, float nativeNameReservation, float hostStart, float hostWidth, float badgeStart, float badgeWidth)
		{
			LaneWidth = laneWidth;
			NativeNameReservation = nativeNameReservation;
			HostStart = hostStart;
			HostWidth = hostWidth;
			BadgeStart = badgeStart;
			BadgeWidth = badgeWidth;
		}
	}
	internal readonly struct PlayerBadgeAllocation
	{
		internal float NativeNameWidth { get; }

		internal float OwnedLaneWidth { get; }

		internal int BadgeCapacity { get; }

		internal bool UseOverflowLane { get; }

		internal PlayerBadgeAllocation(float nativeNameWidth, float ownedLaneWidth, int badgeCapacity, bool useOverflowLane = false)
		{
			NativeNameWidth = nativeNameWidth;
			OwnedLaneWidth = ownedLaneWidth;
			BadgeCapacity = badgeCapacity;
			UseOverflowLane = useOverflowLane;
		}
	}
	internal readonly struct PlayerBadgeLayoutCacheKey : IEquatable<PlayerBadgeLayoutCacheKey>
	{
		internal string BadgeText { get; }

		internal string HostText { get; }

		internal string NativeText { get; }

		internal int MeasurementFingerprint { get; }

		internal int GeometryFingerprint { get; }

		internal float NativeRectWidth { get; }

		internal float Scale { get; }

		internal PlayerBadgeLayoutCacheKey(string badgeText, string hostText, string nativeText, int measurementFingerprint, int geometryFingerprint, float nativeRectWidth, float scale)
		{
			BadgeText = badgeText ?? string.Empty;
			HostText = hostText ?? string.Empty;
			NativeText = nativeText ?? string.Empty;
			MeasurementFingerprint = measurementFingerprint;
			GeometryFingerprint = geometryFingerprint;
			NativeRectWidth = nativeRectWidth;
			Scale = scale;
		}

		public bool Equals(PlayerBadgeLayoutCacheKey other)
		{
			if (string.Equals(BadgeText, other.BadgeText, StringComparison.Ordinal) && string.Equals(HostText, other.HostText, StringComparison.Ordinal) && string.Equals(NativeText, other.NativeText, StringComparison.Ordinal) && MeasurementFingerprint == other.MeasurementFingerprint && GeometryFingerprint == other.GeometryFingerprint && NativeRectWidth.Equals(other.NativeRectWidth))
			{
				return Scale.Equals(other.Scale);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return ((((((17 * 31 + StringComparer.Ordinal.GetHashCode(BadgeText)) * 31 + StringComparer.Ordinal.GetHashCode(HostText)) * 31 + StringComparer.Ordinal.GetHashCode(NativeText)) * 31 + MeasurementFingerprint) * 31 + GeometryFingerprint) * 31 + NativeRectWidth.GetHashCode()) * 31 + Scale.GetHashCode();
		}
	}
	internal sealed class PlayerBadgeLayoutMeasurementCache
	{
		private bool _hasValue;

		private PlayerBadgeLayoutCacheKey _key;

		private PlayerBadgeLayout _layout;

		internal bool TryGet(PlayerBadgeLayoutCacheKey key, out PlayerBadgeLayout layout)
		{
			if (_hasValue && _key.Equals(key))
			{
				layout = _layout;
				return true;
			}
			layout = default(PlayerBadgeLayout);
			return false;
		}

		internal void Store(PlayerBadgeLayoutCacheKey key, PlayerBadgeLayout layout)
		{
			_key = key;
			_layout = layout;
			_hasValue = true;
		}
	}
	internal static class PlayerBadgeLayoutPolicy
	{
		internal static float ResolveRequiredContainerExpansion(float nativeNameWidth, float nativePreferredWidth, float horizontalPadding, float hostPreferredWidth, float segmentGap, float nativeNameGap, float fullBadgePreferredWidth, float maximumExpansion)
		{
			float num = PositiveFinite(nativeNameWidth);
			float num2 = PositiveFinite(maximumExpansion);
			if (num <= 0f || num2 <= 0f)
			{
				return 0f;
			}
			float num3 = PositiveFinite(horizontalPadding);
			float num4 = PositiveFinite(hostPreferredWidth);
			float num5 = PositiveFinite(fullBadgePreferredWidth);
			float num6 = num3 * 2f + num4 + ((num4 > 0f && num5 > 0f) ? PositiveFinite(segmentGap) : 0f) + num5;
			float num7 = PositiveFinite(nativePreferredWidth) + ((num6 > 0f) ? PositiveFinite(nativeNameGap) : 0f) + num6;
			return Math.Min(num2, Math.Max(0f, num7 - num));
		}

		internal static PlayerBadgeAllocation ResolveResponsiveAllocation(float nativeNameWidth, float nativePreferredWidth, float minimumReadableNameWidth, float horizontalPadding, float hostPreferredWidth, float segmentGap, float nativeNameGap, IReadOnlyList<float> preferredWidthsByCapacity, float overflowLaneAvailableWidth = 0f)
		{
			float num = PositiveFinite(nativeNameWidth);
			if (num <= 0f)
			{
				return default(PlayerBadgeAllocation);
			}
			float num2 = Math.Min(num, PositiveFinite(nativePreferredWidth));
			float num3 = Math.Min(num2, PositiveFinite(minimumReadableNameWidth));
			float num4 = Math.Min(PositiveFinite(horizontalPadding), num * 0.5f);
			float num5 = Math.Min(PositiveFinite(hostPreferredWidth), Math.Max(0f, num - num3));
			float num6 = PositiveFinite(segmentGap);
			float num7 = PositiveFinite(nativeNameGap);
			if (preferredWidthsByCapacity != null && preferredWidthsByCapacity.Count > 0)
			{
				float num8 = PositiveFinite(preferredWidthsByCapacity[preferredWidthsByCapacity.Count - 1]);
				float num9 = num4 * 2f + num5 + ((num5 > 0f) ? num6 : 0f) + num8;
				float num10 = PositiveFinite(overflowLaneAvailableWidth);
				bool flag = num2 + num9 + num7 > num;
				if (num8 > 0f && flag && num9 <= num10)
				{
					return new PlayerBadgeAllocation(num2, num9, preferredWidthsByCapacity.Count, useOverflowLane: true);
				}
			}
			if (preferredWidthsByCapacity != null)
			{
				for (int num11 = preferredWidthsByCapacity.Count - 1; num11 >= 0; num11--)
				{
					float num12 = PositiveFinite(preferredWidthsByCapacity[num11]);
					if (!(num12 <= 0f))
					{
						float num13 = num4 * 2f + num5 + ((num5 > 0f) ? num6 : 0f) + num12;
						float num14 = Math.Max(0f, num - num13 - num7);
						if (!(num14 < num3))
						{
							return new PlayerBadgeAllocation(Math.Min(num2, num14), num13, num11 + 1);
						}
					}
				}
			}
			float val = ((num5 > 0f) ? (num4 * 2f + num5) : 0f);
			val = Math.Min(val, Math.Max(0f, num - num3 - num7));
			float num15 = ((val > 0f) ? num7 : 0f);
			return new PlayerBadgeAllocation(Math.Min(num2, Math.Max(0f, num - val - num15)), val, 0);
		}

		internal static float ResolveNativeNameWidth(float nativeNameWidth, float nativePreferredWidth, float minimumOwnedLaneWidth)
		{
			float num = PositiveFinite(nativeNameWidth);
			if (num <= 0f)
			{
				return 0f;
			}
			float val = PositiveFinite(nativePreferredWidth);
			float num2 = Math.Min(num, PositiveFinite(minimumOwnedLaneWidth));
			return Math.Min(val, Math.Max(0f, num - num2));
		}

		internal static int ResolveBadgeCapacity(float maximumLaneWidth, float horizontalPadding, float hostPreferredWidth, float segmentGap, IReadOnlyList<float> preferredWidthsByCapacity)
		{
			if (preferredWidthsByCapacity == null || preferredWidthsByCapacity.Count == 0)
			{
				return 0;
			}
			float num = PositiveFinite(maximumLaneWidth);
			if (num <= 0f)
			{
				return 0;
			}
			float num2 = Math.Min(PositiveFinite(horizontalPadding), num * 0.5f);
			float num3 = Math.Max(0f, num - num2 * 2f);
			float num4 = Math.Min(PositiveFinite(hostPreferredWidth), num3);
			float num5 = Math.Max(0f, num3 - num4);
			if (num4 > 0f && num5 > 0f)
			{
				num5 = Math.Max(0f, num5 - Math.Min(PositiveFinite(segmentGap), num5));
			}
			for (int num6 = preferredWidthsByCapacity.Count - 1; num6 >= 0; num6--)
			{
				float num7 = PositiveFinite(preferredWidthsByCapacity[num6]);
				if (num7 > 0f && num7 <= num5)
				{
					return num6 + 1;
				}
			}
			return 0;
		}

		internal static PlayerBadgeLayout Resolve(float hostPreferredWidth, float badgePreferredWidth, float maximumLaneWidth, float horizontalPadding, float segmentGap, float nativeNameGap)
		{
			float num = PositiveFinite(hostPreferredWidth);
			float num2 = PositiveFinite(badgePreferredWidth);
			float num3 = PositiveFinite(maximumLaneWidth);
			if (num3 <= 0f || (num <= 0f && num2 <= 0f))
			{
				return default(PlayerBadgeLayout);
			}
			float num4 = Math.Min(PositiveFinite(horizontalPadding), num3 * 0.5f);
			float num5 = Math.Max(0f, num3 - num4 * 2f);
			float num6 = Math.Min(num, num5);
			float num7 = 0f;
			float num8 = 0f;
			if (num > 0f && num2 > 0f)
			{
				float num9 = Math.Max(0f, num5 - num6);
				num8 = Math.Min(PositiveFinite(segmentGap), num9);
				num7 = Math.Min(num2, Math.Max(0f, num9 - num8));
				if (num7 <= 0f)
				{
					num8 = 0f;
				}
			}
			else if (num2 > 0f)
			{
				num7 = Math.Min(num2, num5);
			}
			float num10 = Math.Min(num3, num4 * 2f + num6 + num8 + num7);
			float num11 = num4;
			float badgeStart = Math.Max(num11 + num6 + num8, num10 - num4 - num7);
			float nativeNameReservation = Math.Min(num3, num10 + PositiveFinite(nativeNameGap));
			return new PlayerBadgeLayout(num10, nativeNameReservation, num11, num6, badgeStart, num7);
		}

		private static float PositiveFinite(float value)
		{
			if (!float.IsNaN(value) && !float.IsInfinity(value) && !(value <= 0f))
			{
				return value;
			}
			return 0f;
		}
	}
	internal readonly struct PlayerBadgeNativeTextPresentation
	{
		internal float MarginLeft { get; }

		internal float MarginTop { get; }

		internal float MarginRight { get; }

		internal float MarginBottom { get; }

		internal int WrappingMode { get; }

		internal int OverflowMode { get; }

		internal PlayerBadgeNativeTextPresentation(float marginLeft, float marginTop, float marginRight, float marginBottom, int wrappingMode, int overflowMode)
		{
			MarginLeft = marginLeft;
			MarginTop = marginTop;
			MarginRight = marginRight;
			MarginBottom = marginBottom;
			WrappingMode = wrappingMode;
			OverflowMode = overflowMode;
		}
	}
	internal sealed class PlayerBadgeNativeTextPresentationLease
	{
		private bool _active;

		private PlayerBadgeNativeTextPresentation _baseline;

		private PlayerBadgeNativeTextPresentation _applied;

		internal bool HasActiveLease => _active;

		internal PlayerBadgeNativeTextPresentation Apply(PlayerBadgeNativeTextPresentation current, float rightReservation, int noWrapMode, int ellipsisMode)
		{
			if (_active)
			{
				_baseline = AdoptExternalChanges(current, _baseline, _applied);
			}
			else
			{
				_baseline = current;
			}
			float num = ((float.IsNaN(rightReservation) || float.IsInfinity(rightReservation) || rightReservation <= 0f) ? 0f : rightReservation);
			_applied = new PlayerBadgeNativeTextPresentation(_baseline.MarginLeft, _baseline.MarginTop, _baseline.MarginRight + num, _baseline.MarginBottom, noWrapMode, ellipsisMode);
			_active = true;
			return _applied;
		}

		internal PlayerBadgeNativeTextPresentation Restore(PlayerBadgeNativeTextPresentation current)
		{
			if (!_active)
			{
				return current;
			}
			PlayerBadgeNativeTextPresentation result = new PlayerBadgeNativeTextPresentation(Owned(current.MarginLeft, _applied.MarginLeft) ? _baseline.MarginLeft : current.MarginLeft, Owned(current.MarginTop, _applied.MarginTop) ? _baseline.MarginTop : current.MarginTop, Owned(current.MarginRight, _applied.MarginRight) ? _baseline.MarginRight : current.MarginRight, Owned(current.MarginBottom, _applied.MarginBottom) ? _baseline.MarginBottom : current.MarginBottom, (current.WrappingMode == _applied.WrappingMode) ? _baseline.WrappingMode : current.WrappingMode, (current.OverflowMode == _applied.OverflowMode) ? _baseline.OverflowMode : current.OverflowMode);
			_active = false;
			_baseline = default(PlayerBadgeNativeTextPresentation);
			_applied = default(PlayerBadgeNativeTextPresentation);
			return result;
		}

		internal bool MatchesApplied(PlayerBadgeNativeTextPresentation current)
		{
			if (_active && Owned(current.MarginLeft, _applied.MarginLeft) && Owned(current.MarginTop, _applied.MarginTop) && Owned(current.MarginRight, _applied.MarginRight) && Owned(current.MarginBottom, _applied.MarginBottom) && current.WrappingMode == _applied.WrappingMode)
			{
				return current.OverflowMode == _applied.OverflowMode;
			}
			return false;
		}

		private static PlayerBadgeNativeTextPresentation AdoptExternalChanges(PlayerBadgeNativeTextPresentation current, PlayerBadgeNativeTextPresentation baseline, PlayerBadgeNativeTextPresentation applied)
		{
			return new PlayerBadgeNativeTextPresentation(Owned(current.MarginLeft, applied.MarginLeft) ? baseline.MarginLeft : current.MarginLeft, Owned(current.MarginTop, applied.MarginTop) ? baseline.MarginTop : current.MarginTop, Owned(current.MarginRight, applied.MarginRight) ? baseline.MarginRight : current.MarginRight, Owned(current.MarginBottom, applied.MarginBottom) ? baseline.MarginBottom : current.MarginBottom, (current.WrappingMode == applied.WrappingMode) ? baseline.WrappingMode : current.WrappingMode, (current.OverflowMode == applied.OverflowMode) ? baseline.OverflowMode : current.OverflowMode);
		}

		private static bool Owned(float current, float applied)
		{
			return current.Equals(applied);
		}
	}
	internal enum PlayerBadgeKind
	{
		Host,
		Helper,
		CompatibleClient,
		ProtectedVictim,
		Suspect,
		Supporter,
		Creator
	}
	internal readonly struct PlayerBadgeEvidence
	{
		internal bool UniqueExactRow { get; }

		internal bool UniqueCurrentMember { get; }

		internal bool OwnerMatchesRow { get; }

		internal bool NativeHostAgreement { get; }

		internal bool ModerationCapabilityFresh { get; }

		internal bool OwnerListsRowAsHelper { get; }

		internal bool CompatibleHeartbeatFresh { get; }

		internal bool CloneFeatureEnabled { get; }

		internal bool LocalSafetyAuthorized { get; }

		internal bool OpenVictim { get; }

		internal bool OpenSuspect { get; }

		internal bool CreatorContributionFresh { get; }

		internal bool SupporterIdentityHashMatched { get; }

		internal bool OwnerPublishedCreatorHostLabelFresh { get; }

		internal PlayerBadgeEvidence(bool uniqueExactRow, bool uniqueCurrentMember, bool ownerMatchesRow, bool nativeHostAgreement, bool moderationCapabilityFresh, bool ownerListsRowAsHelper, bool compatibleHeartbeatFresh, bool cloneFeatureEnabled, bool localSafetyAuthorized, bool openVictim, bool openSuspect, bool creatorContributionFresh, bool supporterIdentityHashMatched = false, bool ownerPublishedCreatorHostLabelFresh = false)
		{
			UniqueExactRow = uniqueExactRow;
			UniqueCurrentMember = uniqueCurrentMember;
			OwnerMatchesRow = ownerMatchesRow;
			NativeHostAgreement = nativeHostAgreement;
			ModerationCapabilityFresh = moderationCapabilityFresh;
			OwnerListsRowAsHelper = ownerListsRowAsHelper;
			CompatibleHeartbeatFresh = compatibleHeartbeatFresh;
			CloneFeatureEnabled = cloneFeatureEnabled;
			LocalSafetyAuthorized = localSafetyAuthorized;
			OpenVictim = openVictim;
			OpenSuspect = openSuspect;
			CreatorContributionFresh = creatorContributionFresh;
			SupporterIdentityHashMatched = supporterIdentityHashMatched;
			OwnerPublishedCreatorHostLabelFresh = ownerPublishedCreatorHostLabelFresh;
		}

		internal PlayerBadgeEvidence With(bool? uniqueExactRow = null, bool? uniqueCurrentMember = null, bool? ownerMatchesRow = null, bool? nativeHostAgreement = null, bool? moderationCapabilityFresh = null, bool? ownerListsRowAsHelper = null, bool? compatibleHeartbeatFresh = null, bool? cloneFeatureEnabled = null, bool? localSafetyAuthorized = null, bool? openVictim = null, bool? openSuspect = null, bool? creatorContributionFresh = null, bool? supporterIdentityHashMatched = null, bool? ownerPublishedCreatorHostLabelFresh = null)
		{
			return new PlayerBadgeEvidence(uniqueExactRow ?? UniqueExactRow, uniqueCurrentMember ?? UniqueCurrentMember, ownerMatchesRow ?? OwnerMatchesRow, nativeHostAgreement ?? NativeHostAgreement, moderationCapabilityFresh ?? ModerationCapabilityFresh, ownerListsRowAsHelper ?? OwnerListsRowAsHelper, compatibleHeartbeatFresh ?? CompatibleHeartbeatFresh, cloneFeatureEnabled ?? CloneFeatureEnabled, localSafetyAuthorized ?? LocalSafetyAuthorized, openVictim ?? OpenVictim, openSuspect ?? OpenSuspect, creatorContributionFresh ?? CreatorContributionFresh, supporterIdentityHashMatched ?? SupporterIdentityHashMatched, ownerPublishedCreatorHostLabelFresh ?? OwnerPublishedCreatorHostLabelFresh);
		}
	}
	internal sealed class PlayerBadgePresentation
	{
		internal IReadOnlyList<PlayerBadgeKind> AllBadges { get; }

		internal string DisplayText { get; }

		internal string TooltipText { get; }

		internal int HiddenCount { get; }

		internal PlayerBadgePresentation(IReadOnlyList<PlayerBadgeKind> allBadges, string displayText, string tooltipText, int hiddenCount)
		{
			AllBadges = allBadges ?? Array.Empty<PlayerBadgeKind>();
			DisplayText = displayText ?? string.Empty;
			TooltipText = tooltipText ?? string.Empty;
			HiddenCount = Math.Max(0, hiddenCount);
		}
	}
	internal static class PlayerBadgePolicy
	{
		private static readonly PlayerBadgeKind[] OrderedBadges = new PlayerBadgeKind[7]
		{
			PlayerBadgeKind.Host,
			PlayerBadgeKind.Helper,
			PlayerBadgeKind.CompatibleClient,
			PlayerBadgeKind.ProtectedVictim,
			PlayerBadgeKind.Suspect,
			PlayerBadgeKind.Supporter,
			PlayerBadgeKind.Creator
		};

		private static readonly PlayerBadgeKind[] OverflowPriority = new PlayerBadgeKind[7]
		{
			PlayerBadgeKind.Host,
			PlayerBadgeKind.Helper,
			PlayerBadgeKind.Creator,
			PlayerBadgeKind.Supporter,
			PlayerBadgeKind.CompatibleClient,
			PlayerBadgeKind.ProtectedVictim,
			PlayerBadgeKind.Suspect
		};

		internal static IReadOnlyList<PlayerBadgeKind> PresentationOrder => OrderedBadges;

		internal static PlayerBadgePresentation Compose(PlayerBadgeEvidence evidence, int capacity)
		{
			List<PlayerBadgeKind> list = new List<PlayerBadgeKind>(OrderedBadges.Length);
			int num;
			if (evidence.UniqueExactRow)
			{
				num = (evidence.UniqueCurrentMember ? 1 : 0);
				if (num != 0 && evidence.OwnerMatchesRow && evidence.NativeHostAgreement)
				{
					list.Add(PlayerBadgeKind.Host);
				}
			}
			else
			{
				num = 0;
			}
			if (num != 0 && !evidence.OwnerMatchesRow && !evidence.NativeHostAgreement && evidence.ModerationCapabilityFresh && evidence.OwnerListsRowAsHelper)
			{
				list.Add(PlayerBadgeKind.Helper);
			}
			if (num != 0 && evidence.CompatibleHeartbeatFresh)
			{
				list.Add(PlayerBadgeKind.CompatibleClient);
			}
			int num2;
			if (num != 0 && evidence.CloneFeatureEnabled)
			{
				num2 = (evidence.LocalSafetyAuthorized ? 1 : 0);
				if (num2 != 0 && evidence.OpenVictim)
				{
					list.Add(PlayerBadgeKind.ProtectedVictim);
				}
			}
			else
			{
				num2 = 0;
			}
			if (num2 != 0 && evidence.OpenSuspect)
			{
				list.Add(PlayerBadgeKind.Suspect);
			}
			if (num != 0 && evidence.SupporterIdentityHashMatched)
			{
				list.Add(PlayerBadgeKind.Supporter);
			}
			if (num != 0 && (evidence.CreatorContributionFresh || (evidence.OwnerPublishedCreatorHostLabelFresh && evidence.OwnerMatchesRow && evidence.NativeHostAgreement)))
			{
				list.Add(PlayerBadgeKind.Creator);
			}
			string tooltip = string.Join("\n", list.Select(Describe));
			return BuildPresentation(list, tooltip, capacity);
		}

		internal static PlayerBadgePresentation Collapse(PlayerBadgePresentation source, int capacity)
		{
			if (source == null)
			{
				return new PlayerBadgePresentation(Array.Empty<PlayerBadgeKind>(), string.Empty, string.Empty, 0);
			}
			return BuildPresentation(source.AllBadges, source.TooltipText, capacity);
		}

		private static PlayerBadgePresentation BuildPresentation(IReadOnlyList<PlayerBadgeKind> badges, string tooltip, int capacity)
		{
			if (badges == null || badges.Count == 0 || capacity <= 0)
			{
				return new PlayerBadgePresentation(badges?.ToArray() ?? Array.Empty<PlayerBadgeKind>(), string.Empty, tooltip, badges?.Count ?? 0);
			}
			if (badges.Count <= capacity)
			{
				return new PlayerBadgePresentation(badges.ToArray(), string.Join(" ", badges.Select(Token)), tooltip, 0);
			}
			int num = Math.Max(0, capacity - 1);
			int hiddenCount = badges.Count - num;
			string[] value = OverflowPriority.Where(((IEnumerable<PlayerBadgeKind>)badges).Contains<PlayerBadgeKind>).Take(num).ToArray()
				.Select(Token)
				.Concat(new string[1] { "[+" + hiddenCount + "]" })
				.ToArray();
			return new PlayerBadgePresentation(badges.ToArray(), string.Join(" ", value), tooltip, hiddenCount);
		}

		private static string Token(PlayerBadgeKind badge)
		{
			return badge switch
			{
				PlayerBadgeKind.Host => "[O]", 
				PlayerBadgeKind.Helper => "[M]", 
				PlayerBadgeKind.CompatibleClient => "[U]", 
				PlayerBadgeKind.ProtectedVictim => "[V]", 
				PlayerBadgeKind.Suspect => "[S]", 
				PlayerBadgeKind.Supporter => "[♥]", 
				PlayerBadgeKind.Creator => "[♪]", 
				_ => string.Empty, 
			};
		}

		private static string Describe(PlayerBadgeKind badge)
		{
			return badge switch
			{
				PlayerBadgeKind.Host => "[O]  Owner / Host", 
				PlayerBadgeKind.Helper => "[M] BlueSage Helper (this lobby)", 
				PlayerBadgeKind.CompatibleClient => "[U]  Compatible QoL User", 
				PlayerBadgeKind.ProtectedVictim => "[V] — Protected clone-incident victim", 
				PlayerBadgeKind.Suspect => "[S] — Open clone-incident suspect", 
				PlayerBadgeKind.Supporter => "[♥] — BlueSage community supporter", 
				PlayerBadgeKind.Creator => "[♪] — BlueSage creator identity", 
				_ => string.Empty, 
			};
		}
	}
	internal static class SupporterBadgeIdentityPolicy
	{
		private static readonly string[] CompiledIdentityHashes = Array.Empty<string>();

		internal static bool IsRecognizedExactIdentity(string exactIdentity)
		{
			return MatchesCompiledIdentityHash(exactIdentity, CompiledIdentityHashes);
		}

		internal static bool MatchesCompiledIdentityHash(string exactIdentity, IEnumerable<string> compiledIdentityHashes)
		{
			if (!IsExactSteamIdentityShape(exactIdentity) || compiledIdentityHashes == null)
			{
				return false;
			}
			string a = ComputeSha256Hex(exactIdentity);
			foreach (string compiledIdentityHash in compiledIdentityHashes)
			{
				if (IsSha256Hex(compiledIdentityHash) && string.Equals(a, compiledIdentityHash, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

		private static bool IsExactSteamIdentityShape(string value)
		{
			if (string.IsNullOrWhiteSpace(value) || value.Length != 17)
			{
				return false;
			}
			for (int i = 0; i < value.Length; i++)
			{
				if (value[i] < '0' || value[i] > '9')
				{
					return false;
				}
			}
			return true;
		}

		private static bool IsSha256Hex(string value)
		{
			if (string.IsNullOrWhiteSpace(value) || value.Length != 64)
			{
				return false;
			}
			foreach (char c in value)
			{
				if ((c < '0' || c > '9') && (c < 'a' || c > 'f') && (c < 'A' || c > 'F'))
				{
					return false;
				}
			}
			return true;
		}

		private static string ComputeSha256Hex(string value)
		{
			byte[] bytes = Encoding.UTF8.GetBytes(value);
			byte[] array;
			using (SHA256 sHA = SHA256.Create())
			{
				array = sHA.ComputeHash(bytes);
			}
			StringBuilder stringBuilder = new StringBuilder(array.Length * 2);
			byte[] array2 = array;
			foreach (byte b in array2)
			{
				stringBuilder.Append(b.ToString("X2"));
			}
			return stringBuilder.ToString();
		}
	}
	internal static class PlayerBadgeRenderPolicy
	{
		internal static string RenderCompactRichText(string displayText)
		{
			if (string.IsNullOrWhiteSpace(displayText))
			{
				return string.Empty;
			}
			return string.Concat(displayText.Split(new char[1] { ' ' }, StringSplitOptions.RemoveEmptyEntries).Select(RenderToken));
		}

		private static string RenderToken(string token)
		{
			return token switch
			{
				"[O]" => "<color=#70D6FF>[O]</color>", 
				"[M]" => "<color=#A8D27A>[M]</color>", 
				"[U]" => "<color=#F4A261>[U]</color>", 
				"[V]" => "<color=#54D9E8>[V]</color>", 
				"[S]" => "<color=#FF5C5C>[S]</color>", 
				"[♥]" => "<color=#FF9EC4>[♥]</color>", 
				"[♪]" => "<color=#C29BFF>[♪]</color>", 
				_ => "<color=#B9C7D6>" + token + "</color>", 
			};
		}
	}
	internal enum CreatorHostLabelHeartbeatDecision
	{
		None,
		Publish,
		ClearAndStop
	}
	internal static class CreatorHostLabelPublicationPolicy
	{
		internal static bool CanPublish(bool exactOwnedHost, bool exactIdentityGenerationFresh, bool creatorContributionFresh)
		{
			return exactOwnedHost && exactIdentityGenerationFresh && creatorContributionFresh;
		}

		internal static CreatorHostLabelHeartbeatDecision DecideHeartbeat(bool labelActive, bool heartbeatDue, bool exactOwnedHost, bool exactIdentityGenerationFresh, bool creatorContributionFresh)
		{
			if (!labelActive || !heartbeatDue)
			{
				return CreatorHostLabelHeartbeatDecision.None;
			}
			if (!CanPublish(exactOwnedHost, exactIdentityGenerationFresh, creatorContributionFresh))
			{
				return CreatorHostLabelHeartbeatDecision.ClearAndStop;
			}
			return CreatorHostLabelHeartbeatDecision.Publish;
		}
	}
	internal static class PlayerHostLabelDisplayPolicy
	{
		internal static bool TryResolve(string payload, long nowUnixSeconds, bool isExactCurrentOwner, out string label)
		{
			label = string.Empty;
			if (!isExactCurrentOwner || !RoleLabelProtocolPolicy.TryParse(payload, nowUnixSeconds, out var message, out var _) || message.Action != RoleLabelProtocolAction.Set || string.IsNullOrWhiteSpace(message.Label))
			{
				return false;
			}
			label = message.Label;
			return true;
		}

		internal static bool TrySuppressNativeHostSuffix(string renderedName, string nativeHostLabel, bool uniqueExactRow, bool ownerMatchesRow, bool nativeHostAgreement, bool customHostLabelActive, out string replacement)
		{
			string text = (nativeHostLabel ?? string.Empty).Trim();
			string text2 = (string.IsNullOrWhiteSpace(text) ? string.Empty : (" " + text));
			replacement = string.Empty;
			if (!uniqueExactRow || !ownerMatchesRow || !nativeHostAgreement || !customHostLabelActive || string.IsNullOrWhiteSpace(text2) || string.IsNullOrWhiteSpace(renderedName) || !renderedName.EndsWith(text2, StringComparison.Ordinal))
			{
				return false;
			}
			replacement = renderedName.Substring(0, renderedName.Length - text2.Length);
			return !string.IsNullOrWhiteSpace(replacement);
		}

		internal static bool TrySuppressNativeHostSuffix(string renderedName, bool uniqueExactRow, bool ownerMatchesRow, bool nativeHostAgreement, bool creatorContributionFresh, bool customHostLabelActive, out string replacement)
		{
			replacement = string.Empty;
			if (creatorContributionFresh)
			{
				return TrySuppressNativeHostSuffix(renderedName, "(Host)", uniqueExactRow, ownerMatchesRow, nativeHostAgreement, customHostLabelActive, out replacement);
			}
			return false;
		}
	}
	internal static class PlayerIdentityEvidencePolicy
	{
		internal enum UnresolvedRowState
		{
			Checking,
			LiveSteamCheck,
			LeftStale
		}

		internal static bool TryResolveExactRosterIndex(string steamId, IReadOnlyList<string>? rosterSteamIds, int playerIdCount, int transformCount, out int index, out string error)
		{
			index = -1;
			error = "The row does not contain a valid SteamID64.";
			if (!ModerationProtocolPolicy.IsSteamId64(steamId) || rosterSteamIds == null)
			{
				return false;
			}
			int num = 0;
			for (int i = 0; i < rosterSteamIds.Count; i++)
			{
				if (string.Equals(rosterSteamIds[i], steamId, StringComparison.Ordinal))
				{
					num++;
					index = i;
				}
			}
			if (num != 1)
			{
				index = -1;
				error = ((num == 0) ? "That Steam ID is no longer in the native player roster." : "That Steam ID appears more than once in the native player roster.");
				return false;
			}
			if (index >= playerIdCount || index >= transformCount)
			{
				index = -1;
				error = "The native Steam, network-player, and transform lists are not aligned for this row.";
				return false;
			}
			error = string.Empty;
			return true;
		}

		internal static bool IsUniqueCurrentLobbyMember(string steamId, IReadOnlyList<string>? lobbyMemberSteamIds)
		{
			if (!ModerationProtocolPolicy.IsSteamId64(steamId) || lobbyMemberSteamIds == null)
			{
				return false;
			}
			int num = 0;
			for (int i = 0; i < lobbyMemberSteamIds.Count; i++)
			{
				if (string.Equals(lobbyMemberSteamIds[i], steamId, StringComparison.Ordinal))
				{
					num++;
				}
			}
			return num == 1;
		}

		internal static bool IsCoverageComplete(bool captureReady, int missingCurrentSteamMembers, int liveNativeOnlyRows, int ambiguousRows)
		{
			if (captureReady && missingCurrentSteamMembers == 0 && liveNativeOnlyRows == 0)
			{
				return ambiguousRows == 0;
			}
			return false;
		}

		internal static bool TryAcquireManualResync(long nowUtcTicks, long lastAcquiredUtcTicks, long cooldownTicks, out long acquiredUtcTicks, out int retryAfterSeconds)
		{
			long num = Math.Max(0L, cooldownTicks);
			if (lastAcquiredUtcTicks <= 0 || num == 0L)
			{
				acquiredUtcTicks = nowUtcTicks;
				retryAfterSeconds = 0;
				return true;
			}
			long num2 = ((nowUtcTicks >= lastAcquiredUtcTicks) ? (nowUtcTicks - lastAcquiredUtcTicks) : 0);
			if (num2 >= num)
			{
				acquiredUtcTicks = nowUtcTicks;
				retryAfterSeconds = 0;
				return true;
			}
			long num3 = num - num2;
			long num4 = num3 / 10000000;
			if (num3 % 10000000 != 0L)
			{
				num4++;
			}
			acquiredUtcTicks = lastAcquiredUtcTicks;
			retryAfterSeconds = (int)Math.Min(2147483647L, Math.Max(1L, num4));
			return false;
		}

		internal static IReadOnlyList<string> SelectManualResyncTargets(IReadOnlyList<string>? nativeSteamIds, IReadOnlyList<string>? lobbyMemberSteamIds, IReadOnlyList<string>? verifiedSteamIds)
		{
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			if (verifiedSteamIds != null)
			{
				for (int i = 0; i < verifiedSteamIds.Count; i++)
				{
					string text = verifiedSteamIds[i] ?? string.Empty;
					if (!string.IsNullOrWhiteSpace(text))
					{
						hashSet.Add(text);
					}
				}
			}
			List<string> list = new List<string>();
			HashSet<string> seen = new HashSet<string>(StringComparer.Ordinal);
			AddUnverified(nativeSteamIds, hashSet, seen, list);
			AddUnverified(lobbyMemberSteamIds, hashSet, seen, list);
			return list;
		}

		private static void AddUnverified(IReadOnlyList<string>? candidates, HashSet<string> verified, HashSet<string> seen, List<string> targets)
		{
			if (candidates == null)
			{
				return;
			}
			for (int i = 0; i < candidates.Count; i++)
			{
				string text = candidates[i] ?? string.Empty;
				if (ModerationProtocolPolicy.IsSteamId64(text) && !verified.Contains(text) && seen.Add(text))
				{
					targets.Add(text);
				}
			}
		}

		internal static string DescribeUnresolvedExactRow(string steamId, IReadOnlyList<string>? currentLobbyMembers, string captureError, int nativeSteamMatches = 0, bool hasUniquePlayerId = false, bool hasLiveTransform = false)
		{
			if (!ModerationProtocolPolicy.IsSteamId64(steamId))
			{
				return "the row does not contain a valid SteamID64";
			}
			switch (ClassifyUnresolvedRow(steamId, currentLobbyMembers, nativeSteamMatches, hasUniquePlayerId, hasLiveTransform))
			{
			case UnresolvedRowState.LiveSteamCheck:
				return "live/steam-check row; the game/PurrNet row is live but its SteamID is absent from current Steam lobby membership";
			case UnresolvedRowState.LeftStale:
				return "left/stale player-history row; no live native player is attached to this row";
			default:
				if (!string.IsNullOrWhiteSpace(captureError))
				{
					return captureError;
				}
				return "the live identity row is still syncing";
			}
		}

		internal static UnresolvedRowState ClassifyUnresolvedRow(string steamId, IReadOnlyList<string>? currentLobbyMembers, int nativeSteamMatches, bool hasUniquePlayerId, bool hasLiveTransform)
		{
			if (!ModerationProtocolPolicy.IsSteamId64(steamId))
			{
				return UnresolvedRowState.Checking;
			}
			if (nativeSteamMatches == 1 && hasUniquePlayerId && hasLiveTransform && currentLobbyMembers != null && !IsUniqueCurrentLobbyMember(steamId, currentLobbyMembers))
			{
				return UnresolvedRowState.LiveSteamCheck;
			}
			if (nativeSteamMatches == 0 || (nativeSteamMatches == 1 && !hasLiveTransform))
			{
				return UnresolvedRowState.LeftStale;
			}
			return UnresolvedRowState.Checking;
		}

		internal static bool IsVerifiedActiveRow(string steamId, IReadOnlyList<string>? rosterSteamIds, string playerId, IReadOnlyList<string>? rosterPlayerIds, bool hasLiveTransform, IReadOnlyList<string>? lobbyMemberSteamIds)
		{
			if (!hasLiveTransform || !ModerationProtocolPolicy.IsSteamId64(steamId) || rosterSteamIds == null || rosterPlayerIds == null || string.IsNullOrWhiteSpace(playerId) || !IsUniqueCurrentLobbyMember(steamId, lobbyMemberSteamIds))
			{
				return false;
			}
			int num = 0;
			for (int i = 0; i < rosterSteamIds.Count; i++)
			{
				if (string.Equals(rosterSteamIds[i], steamId, StringComparison.Ordinal))
				{
					num++;
				}
			}
			int num2 = 0;
			for (int j = 0; j < rosterPlayerIds.Count; j++)
			{
				if (string.Equals(rosterPlayerIds[j], playerId, StringComparison.Ordinal))
				{
					num2++;
				}
			}
			if (num == 1)
			{
				return num2 == 1;
			}
			return false;
		}
	}
	internal sealed class PlayerLimitCompanionStatus
	{
		public bool IsLoaded { get; }

		public int? EffectiveMaxLobbySize { get; }

		public int? EffectiveDefaultLobbySize { get; }

		public int? EffectiveShiftSkipRate { get; }

		public bool? ChatRelayPatchEnabled { get; }

		private PlayerLimitCompanionStatus(bool isLoaded, int? effectiveMaxLobbySize, int? effectiveDefaultLobbySize, int? effectiveShiftSkipRate, bool? chatRelayPatchEnabled)
		{
			IsLoaded = isLoaded;
			EffectiveMaxLobbySize = effectiveMaxLobbySize;
			EffectiveDefaultLobbySize = effectiveDefaultLobbySize;
			EffectiveShiftSkipRate = effectiveShiftSkipRate;
			ChatRelayPatchEnabled = chatRelayPatchEnabled;
		}

		public static PlayerLimitCompanionStatus NotLoaded()
		{
			return new PlayerLimitCompanionStatus(isLoaded: false, null, null, null, null);
		}

		public static PlayerLimitCompanionStatus FromLoadedValues(int? effectiveMaxLobbySize, int? effectiveDefaultLobbySize, int? effectiveShiftSkipRate, bool? chatRelayPatchEnabled)
		{
			return new PlayerLimitCompanionStatus(isLoaded: true, effectiveMaxLobbySize, effectiveDefaultLobbySize, effectiveShiftSkipRate, chatRelayPatchEnabled);
		}

		public string ToDiagnosticText()
		{
			if (!IsLoaded)
			{
				return "PlayerLimit=not loaded";
			}
			return "PlayerLimit=loaded cap=" + FormatInt(EffectiveMaxLobbySize) + " default=" + FormatInt(EffectiveDefaultLobbySize) + " shift=" + FormatInt(EffectiveShiftSkipRate) + " chatRelay=" + FormatBool(ChatRelayPatchEnabled);
		}

		private static string FormatInt(int? value)
		{
			if (!value.HasValue)
			{
				return "?";
			}
			return value.Value.ToString();
		}

		private static string FormatBool(bool? value)
		{
			if (!value.HasValue)
			{
				return "?";
			}
			if (!value.Value)
			{
				return "off";
			}
			return "on";
		}
	}
	internal sealed class PlayerLookupCandidate
	{
		internal string SteamId { get; set; } = string.Empty;

		internal string DisplayNameRaw { get; set; } = string.Empty;

		internal string DisplayNamePlain { get; set; } = string.Empty;

		internal string SteamPersona { get; set; } = string.Empty;

		internal string Role { get; set; } = string.Empty;

		internal bool IsLocal { get; set; }
	}
	internal static class PlayerLookupPolicy
	{
		internal const int MinimumPartialSteamIdDigits = 4;

		internal const int MaximumQueryCharacters = 96;

		private static readonly TimeSpan RegexTimeout = TimeSpan.FromMilliseconds(30.0);

		internal static IReadOnlyList<PlayerLookupCandidate> FindMatches(string? query, IEnumerable<PlayerLookupCandidate>? candidates, out string error)
		{
			string clean = (query ?? string.Empty).Trim().TrimStart(new char[1] { '@' });
			if (clean.Length == 0)
			{
				error = "Enter part of a display name or Steam persona, 4+ SteamID digits, _host, _self, or a regex pattern.";
				return Array.Empty<PlayerLookupCandidate>();
			}
			if (clean.Length > 96)
			{
				error = "Player lookup is limited to 96 characters.";
				return Array.Empty<PlayerLookupCandidate>();
			}
			PlayerLookupCandidate[] array = (from @group in (candidates ?? Array.Empty<PlayerLookupCandidate>()).Where((PlayerLookupCandidate candidate) => candidate != null && ModerationProtocolPolicy.IsSteamId64(candidate.SteamId)).GroupBy<PlayerLookupCandidate, string>((PlayerLookupCandidate candidate) => candidate.SteamId, StringComparer.Ordinal)
				select @group.First()).ToArray();
			if (string.Equals(clean, "_host", StringComparison.OrdinalIgnoreCase))
			{
				return Finish(array.Where((PlayerLookupCandidate candidate) => Contains(candidate.Role, "HOST")), out error);
			}
			if (string.Equals(clean, "_self", StringComparison.OrdinalIgnoreCase))
			{
				return Finish(array.Where((PlayerLookupCandidate candidate) => candidate.IsLocal), out error);
			}
			if (clean.All(char.IsDigit))
			{
				if (clean.Length < 4)
				{
					error = "Use at least 4 SteamID digits for a read-only lookup.";
					return Array.Empty<PlayerLookupCandidate>();
				}
				return Finish(array.Where((PlayerLookupCandidate candidate) => candidate.SteamId.IndexOf(clean, StringComparison.Ordinal) >= 0), out error);
			}
			List<PlayerLookupCandidate> list = array.Where((PlayerLookupCandidate candidate) => Contains(candidate.DisplayNamePlain, clean) || Contains(candidate.DisplayNameRaw, clean) || Contains(candidate.SteamPersona, clean)).ToList();
			Regex regex = null;
			try
			{
				regex = new Regex(clean, RegexOptions.IgnoreCase | RegexOptions.CultureInvariant, RegexTimeout);
			}
			catch (ArgumentException)
			{
			}
			HashSet<string> hashSet = new HashSet<string>(list.Select((PlayerLookupCandidate candidate) => candidate.SteamId), StringComparer.Ordinal);
			Stopwatch stopwatch = Stopwatch.StartNew();
			PlayerLookupCandidate[] array2 = array;
			foreach (PlayerLookupCandidate playerLookupCandidate in array2)
			{
				if (regex == null || hashSet.Contains(playerLookupCandidate.SteamId) || stopwatch.ElapsedMilliseconds >= 50)
				{
					continue;
				}
				try
				{
					if (regex.IsMatch(playerLookupCandidate.DisplayNamePlain ?? string.Empty) || regex.IsMatch(playerLookupCandidate.SteamPersona ?? string.Empty))
					{
						list.Add(playerLookupCandidate);
						hashSet.Add(playerLookupCandidate.SteamId);
					}
				}
				catch (RegexMatchTimeoutException)
				{
					regex = null;
				}
			}
			return Finish(list, out error);
		}

		private static IReadOnlyList<PlayerLookupCandidate> Finish(IEnumerable<PlayerLookupCandidate> matches, out string error)
		{
			PlayerLookupCandidate[] array = (from @group in matches.GroupBy<PlayerLookupCandidate, string>((PlayerLookupCandidate candidate) => candidate.SteamId, StringComparer.Ordinal)
				select @group.First()).ToArray();
			error = ((array.Length == 0) ? "No verified current player matches that query." : string.Empty);
			return array;
		}

		private static bool Contains(string? value, string query)
		{
			if (string.IsNullOrWhiteSpace(value))
			{
				return false;
			}
			return value.IndexOf(query, StringComparison.OrdinalIgnoreCase) >= 0;
		}
	}
	internal static class PlayerMentionProvider
	{
		private static readonly Regex RichTextTagRegex = new Regex("<[^>]+>", RegexOptions.Compiled);

		public static string GetLocalPlayerName()
		{
			try
			{
				TextChannelManager i = NetworkSingleton<TextChannelManager>.I;
				string text = StripRichText((i != null) ? i.UserName : null);
				if (!string.IsNullOrWhiteSpace(text))
				{
					return text;
				}
			}
			catch
			{
			}
			try
			{
				return StripRichText(MonoSingleton<DataManager>.I?.PlayerData?.Name);
			}
			catch
			{
				return string.Empty;
			}
		}

		public static IReadOnlyList<string> GetAllPlayerNames()
		{
			List<string> list = new List<string>();
			try
			{
				PlayerPanelController i = NetworkSingleton<PlayerPanelController>.I;
				if (AccessTools.Field(typeof(PlayerPanelController), "IDInfos")?.GetValue(i) is IEnumerable enumerable)
				{
					foreach (object item in enumerable)
					{
						string text = ReadNameFromIdInfo(item);
						if (!string.IsNullOrWhiteSpace(text))
						{
							list.Add(text);
						}
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Ping Mentions could not read PlayerPanelController.IDInfos: " + ex.GetType().Name + ": " + ex.Message));
				}
			}
			return (from value in list.Select(MentionNamePolicy.ToMentionDisplayLabel)
				where !string.IsNullOrWhiteSpace(value)
				select value).OrderBy<string, string>((string value) => value, StringComparer.OrdinalIgnoreCase).ToArray();
		}

		public static string FindBestMentionMatch(string query)
		{
			string text = MentionNamePolicy.ToCanonicalMentionName(query);
			if (string.IsNullOrWhiteSpace(text))
			{
				return string.Empty;
			}
			return MentionNamePolicy.FindUniqueMentionMatch(text, GetAllPlayerNames());
		}

		public static IReadOnlyList<string> FindMentionMatches(string query, int maxMatches)
		{
			string cleanQuery = MentionNamePolicy.ToCanonicalMentionName(query);
			if (string.IsNullOrWhiteSpace(cleanQuery) || maxMatches <= 0)
			{
				return Array.Empty<string>();
			}
			List<string> matches = new List<string>();
			if (Plugin.CanUseLobbySafety(out var _) && "lobby".StartsWith(cleanQuery, StringComparison.OrdinalIgnoreCase))
			{
				matches.Add("lobby");
			}
			IReadOnlyList<string> source = (from @group in GetAllPlayerNames().GroupBy<string, string>(MentionNamePolicy.ToCanonicalMentionName, StringComparer.OrdinalIgnoreCase)
				where !string.IsNullOrWhiteSpace(@group.Key) && @group.Count() == 1
				select @group.Single()).ToArray();
			matches.AddRange(source.Where((string name) => MentionNamePolicy.ToCanonicalMentionName(name).StartsWith(cleanQuery, StringComparison.OrdinalIgnoreCase)));
			matches.AddRange(source.Where((string name) => MentionNamePolicy.ToCanonicalMentionName(name).IndexOf(cleanQuery, StringComparison.OrdinalIgnoreCase) >= 0 && !matches.Contains<string>(name, StringComparer.OrdinalIgnoreCase)));
			return matches.Where((string value) => !string.IsNullOrWhiteSpace(value)).Distinct<string>(StringComparer.OrdinalIgnoreCase).Take(maxMatches)
				.ToArray();
		}

		public static string StripRichText(string value)
		{
			return RichTextTagRegex.Replace(value ?? string.Empty, string.Empty).Trim().Trim(new char[1]);
		}

		private static string ReadNameFromIdInfo(object idInfo)
		{
			if (idInfo == null)
			{
				return string.Empty;
			}
			object obj = idInfo.GetType().GetField("Name", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(idInfo);
			if (obj is string result)
			{
				return result;
			}
			if (obj is byte[] array && array.Length != 0)
			{
				return Encoding.Unicode.GetString(array).Trim(new char[1]);
			}
			return string.Empty;
		}
	}
	internal enum PlayerPanelPomoState
	{
		Inactive,
		Syncable,
		Synced,
		SyncedWithMe
	}
	internal enum PlayerPanelAnchor
	{
		None,
		SerializedReportButtonParent
	}
	internal enum PlayerPanelSurfaceAction
	{
		None,
		Create,
		Refresh,
		Remove
	}
	internal sealed class PlayerPanelSurfaceContext
	{
		internal bool FeatureEnabled;

		internal bool IsSelf;

		internal bool RowActive;

		internal bool SerializedReportButtonPresent;

		internal bool SerializedReportButtonParentPresent;

		internal bool OwnedLanePresent;

		internal bool IdentityChanged;

		internal bool PanelChanged;

		internal bool AnchorChanged;

		internal bool RuntimeHierarchyObserved;

		internal PlayerPanelPomoState PomoState;
	}
	internal sealed class PlayerPanelSurfaceDecision
	{
		internal PlayerPanelSurfaceAction Action;

		internal PlayerPanelAnchor Anchor;

		internal bool ShowMentionAction;

		internal bool ShowNativeIdAction;

		internal bool PreserveNativeControls = true;

		internal bool ReserveAlignedLane;

		internal bool AllowUnverifiedHierarchyFallback;

		internal bool RebindIdentityAndListeners;

		internal bool RebindAnchor;
	}
	internal static class PlayerPanelSurfacePolicy
	{
		internal const bool UnverifiedHierarchyFallbackEnabled = false;

		internal static PlayerPanelSurfaceDecision Evaluate(PlayerPanelSurfaceContext? context)
		{
			PlayerPanelSurfaceDecision playerPanelSurfaceDecision = new PlayerPanelSurfaceDecision
			{
				PreserveNativeControls = true,
				AllowUnverifiedHierarchyFallback = false
			};
			if (context == null)
			{
				return playerPanelSurfaceDecision;
			}
			playerPanelSurfaceDecision.ReserveAlignedLane = context.FeatureEnabled && context.IsSelf && context.RowActive && context.SerializedReportButtonPresent && context.SerializedReportButtonParentPresent;
			if (!context.FeatureEnabled || !context.RowActive)
			{
				playerPanelSurfaceDecision.Action = (context.OwnedLanePresent ? PlayerPanelSurfaceAction.Remove : PlayerPanelSurfaceAction.None);
				return playerPanelSurfaceDecision;
			}
			if (!context.SerializedReportButtonPresent || !context.SerializedReportButtonParentPresent)
			{
				playerPanelSurfaceDecision.Action = (context.OwnedLanePresent ? PlayerPanelSurfaceAction.Remove : PlayerPanelSurfaceAction.None);
				return playerPanelSurfaceDecision;
			}
			_ = context.PomoState;
			_ = context.RuntimeHierarchyObserved;
			playerPanelSurfaceDecision.Anchor = PlayerPanelAnchor.SerializedReportButtonParent;
			playerPanelSurfaceDecision.ShowMentionAction = !context.IsSelf;
			playerPanelSurfaceDecision.ShowNativeIdAction = !context.IsSelf;
			playerPanelSurfaceDecision.Action = ((!context.OwnedLanePresent) ? PlayerPanelSurfaceAction.Create : PlayerPanelSurfaceAction.Refresh);
			playerPanelSurfaceDecision.RebindIdentityAndListeners = !context.OwnedLanePresent || context.IdentityChanged || context.PanelChanged || context.AnchorChanged;
			playerPanelSurfaceDecision.RebindAnchor = !context.OwnedLanePresent || context.PanelChanged || context.AnchorChanged;
			return playerPanelSurfaceDecision;
		}
	}
	internal static class PlayerRenderSaverPolicy
	{
		public const int MinRadiusMeters = 10;

		public const int DefaultRadiusMeters = 45;

		public const int MaxRadiusMeters = 250;

		public const int MinMaxVisiblePlayers = 1;

		public const int DefaultMaxVisiblePlayers = 32;

		public const int MaxMaxVisiblePlayers = 128;

		public const float RefreshIntervalSeconds = 1f;

		public const int DistanceHysteresisMeters = 6;

		public const int RankHysteresisPlayers = 2;

		public static int ClampRadiusMeters(int configured)
		{
			if (configured < 10)
			{
				return 10;
			}
			if (configured > 250)
			{
				return 250;
			}
			return configured;
		}

		public static int ClampMaxVisiblePlayers(int configured)
		{
			if (configured < 1)
			{
				return 1;
			}
			if (configured > 128)
			{
				return 128;
			}
			return configured;
		}

		public static bool ShouldHideRemotePlayer(float distanceMeters, int distanceRank, int radiusMeters, int maxVisiblePlayers)
		{
			return ShouldHideRemotePlayer(distanceMeters, distanceRank, radiusMeters, maxVisiblePlayers, currentlyHidden: false);
		}

		public static bool ShouldHideRemotePlayer(float distanceMeters, int distanceRank, int radiusMeters, int maxVisiblePlayers, bool currentlyHidden)
		{
			int num = ClampRadiusMeters(radiusMeters);
			int num2 = ClampMaxVisiblePlayers(maxVisiblePlayers);
			int num3 = Math.Max(0, distanceRank);
			if (currentlyHidden)
			{
				if (!(distanceMeters > (float)Math.Max(10, num - 6)))
				{
					return num3 >= Math.Max(1, num2 - 2);
				}
				return true;
			}
			if (!(distanceMeters > (float)(num + 6)))
			{
				return num3 >= num2;
			}
			return true;
		}
	}
	internal enum PlayerRoleLabelKind
	{
		None,
		Host,
		Helper
	}
	internal readonly struct PlayerRoleLabelCompositionResult
	{
		internal PlayerRoleLabelKind Role { get; }

		internal string RenderedText { get; }

		internal bool Applied { get; }

		internal PlayerRoleLabelCompositionResult(PlayerRoleLabelKind role, string renderedText, bool applied)
		{
			Role = role;
			RenderedText = renderedText ?? string.Empty;
			Applied = applied;
		}
	}
	internal static class PlayerRoleLabelCompositionPolicy
	{
		internal static PlayerRoleLabelCompositionResult Compose(string nativeText, string localizedHostSuffix, string hostLabel, string helperLabel, string rowSteamId, string ownerSteamId, bool rowIsHost, bool uniqueRow, bool capabilityFresh, IEnumerable<string> ownerHelpers)
		{
			string text = nativeText ?? string.Empty;
			if (!uniqueRow || string.IsNullOrWhiteSpace(rowSteamId) || string.IsNullOrWhiteSpace(ownerSteamId))
			{
				return None(text);
			}
			if (rowIsHost)
			{
				if (!string.Equals(rowSteamId, ownerSteamId, StringComparison.Ordinal) || string.IsNullOrWhiteSpace(localizedHostSuffix) || string.IsNullOrWhiteSpace(hostLabel))
				{
					return None(text);
				}
				string text2 = " " + hostLabel;
				if (text.EndsWith(text2, StringComparison.Ordinal))
				{
					return new PlayerRoleLabelCompositionResult(PlayerRoleLabelKind.Host, text, applied: true);
				}
				string text3 = " " + localizedHostSuffix;
				if (!text.EndsWith(text3, StringComparison.Ordinal))
				{
					return None(text);
				}
				return new PlayerRoleLabelCompositionResult(PlayerRoleLabelKind.Host, text.Substring(0, text.Length - text3.Length) + text2, applied: true);
			}
			if (string.Equals(rowSteamId, ownerSteamId, StringComparison.Ordinal) || !capabilityFresh || string.IsNullOrWhiteSpace(helperLabel) || !ContainsExact(ownerHelpers, rowSteamId))
			{
				return None(text);
			}
			string text4 = " " + helperLabel;
			return new PlayerRoleLabelCompositionResult(PlayerRoleLabelKind.Helper, text.EndsWith(text4, StringComparison.Ordinal) ? text : (text + text4), applied: true);
		}

		internal static bool TryRestore(string currentText, string appliedText, string nativeText, out string restoredText)
		{
			if (!string.Equals(restoredText = currentText ?? string.Empty, appliedText ?? string.Empty, StringComparison.Ordinal))
			{
				return false;
			}
			restoredText = nativeText ?? string.Empty;
			return true;
		}

		private static PlayerRoleLabelCompositionResult None(string text)
		{
			return new PlayerRoleLabelCompositionResult(PlayerRoleLabelKind.None, text, applied: false);
		}

		private static bool ContainsExact(IEnumerable<string> values, string expected)
		{
			if (values == null)
			{
				return false;
			}
			foreach (string value in values)
			{
				if (string.Equals(value, expected, StringComparison.Ordinal))
				{
					return true;
				}
			}
			return false;
		}
	}
	internal sealed class PlayerRowGeometryReadinessPolicy
	{
		private bool _hasValidObservation;

		private bool _hasReachedReady;

		private float _width;

		private int _geometryFingerprint;

		internal bool Observe(float width, int geometryFingerprint)
		{
			if (float.IsNaN(width) || float.IsInfinity(width) || width <= 0f)
			{
				Reset();
				return false;
			}
			if (!_hasValidObservation || !_width.Equals(width) || _geometryFingerprint != geometryFingerprint)
			{
				bool hasReachedReady = _hasReachedReady;
				_hasValidObservation = true;
				_width = width;
				_geometryFingerprint = geometryFingerprint;
				return hasReachedReady;
			}
			_hasReachedReady = true;
			return true;
		}

		internal void Reset()
		{
			_hasValidObservation = false;
			_hasReachedReady = false;
			_width = 0f;
			_geometryFingerprint = 0;
		}
	}
	internal sealed class PluginCompatibilityResult
	{
		public bool AutoSweepAllowed { get; }

		public bool ManualSweepAllowed { get; }

		public bool ChatTweaksAllowed { get; }

		public bool HostHealthRepairsAllowed { get; }

		public bool HushLoaded { get; }

		public bool FomoLoaded { get; }

		public bool EchoLoaded { get; }

		public bool AlphaLoaded { get; }

		public bool ChalkyLoaded { get; }

		public bool DesyncLoaded { get; }

		public IReadOnlyList<string> Reasons { get; }

		public PluginCompatibilityResult(bool autoSweepAllowed, bool manualSweepAllowed, bool chatTweaksAllowed, bool hostHealthRepairsAllowed, bool hushLoaded, bool fomoLoaded, bool echoLoaded, bool alphaLoaded, bool chalkyLoaded, bool desyncLoaded, IReadOnlyList<string> reasons)
		{
			AutoSweepAllowed = autoSweepAllowed;
			ManualSweepAllowed = manualSweepAllowed;
			ChatTweaksAllowed = chatTweaksAllowed;
			HostHealthRepairsAllowed = hostHealthRepairsAllowed;
			HushLoaded = hushLoaded;
			FomoLoaded = fomoLoaded;
			EchoLoaded = echoLoaded;
			AlphaLoaded = alphaLoaded;
			ChalkyLoaded = chalkyLoaded;
			DesyncLoaded = desyncLoaded;
			Reasons = reasons;
		}
	}
	internal static class PluginCompatibility
	{
		public const string AndrewSweepGuid = "com.andrewlin.ontogether.sweep";

		public const string AndrewReconnectGuid = "com.andrewlin.ontogether.reconnect";

		public const string SimpleQolGuid = "tinyplume.SimpleQOL";

		public const string BlueSagePlayerLimitLiftGuid = "com.bluesage.ontogether.playerlimitlift";

		public const string LegacyCopyChatGuid = "com.jai.ontogether.copychat";

		public const string AndrewHushGuid = "com.andrewlin.ontogether.hush";

		public const string AndrewFomoGuid = "com.andrewlin.ontogether.fomo";

		public const string AndrewEchoGuid = "com.andrewlin.ontogether.echo";

		public const string AndrewAlphaGuid = "com.andrewlin.ontogether.alpha";

		public const string AndrewChalkyGuid = "com.andrewlin.ontogether.chalky";

		public const string AndrewDesyncGuid = "com.andrewlin.ontogether.desync";

		public static PluginCompatibilityResult Evaluate(IEnumerable<string> loadedPluginGuids, bool autoDisableSweepWhenAndrewSweepInstalled, bool allowManualSweepWhenAndrewSweepInstalled, bool autoDisableChatTweaksWhenSimpleQoLInstalled)
		{
			HashSet<string> hashSet = new HashSet<string>(loadedPluginGuids ?? Enumerable.Empty<string>(), StringComparer.OrdinalIgnoreCase);
			List<string> list = new List<string>();
			bool autoSweepAllowed = true;
			bool manualSweepAllowed = true;
			bool chatTweaksAllowed = true;
			bool hushLoaded = hashSet.Contains("com.andrewlin.ontogether.hush");
			bool fomoLoaded = hashSet.Contains("com.andrewlin.ontogether.fomo");
			bool echoLoaded = hashSet.Contains("com.andrewlin.ontogether.echo");
			bool alphaLoaded = hashSet.Contains("com.andrewlin.ontogether.alpha");
			bool chalkyLoaded = hashSet.Contains("com.andrewlin.ontogether.chalky");
			bool flag = hashSet.Contains("com.andrewlin.ontogether.desync");
			bool hostHealthRepairsAllowed = !flag;
			bool flag2 = HasGuidOrFuzzyMatch(hashSet, "com.andrewlin.ontogether.sweep", "sweep");
			if (autoDisableSweepWhenAndrewSweepInstalled && flag2)
			{
				autoSweepAllowed = false;
				list.Add("AndrewLin Sweep is loaded; BlueSage auto sweep is disabled to avoid double sweeping.");
				if (!allowManualSweepWhenAndrewSweepInstalled)
				{
					manualSweepAllowed = false;
					list.Add("AndrewLin Sweep is loaded; BlueSage manual sweep hotkey is disabled unless explicitly allowed in config.");
				}
			}
			if (autoDisableChatTweaksWhenSimpleQoLInstalled && (HasGuidOrFuzzyMatch(hashSet, "tinyplume.SimpleQOL", "simpleqol", "simple_qol") || HasGuidOrFuzzyMatch(hashSet, "officerballs.ChatTweaks", "chattweaks", "chat_tweaks")))
			{
				chatTweaksAllowed = false;
				list.Add("Tiny_Plume Simple_QOL is loaded; BlueSage timestamps and leave notices are disabled to avoid duplicate chat formatting.");
			}
			if (flag)
			{
				list.Add("AndrewLin Desync is loaded; BlueSage automatic Host Health repairs are paused to avoid duplicate lobby metadata and persona refresh work. Manual Host Health remains read-only.");
			}
			return new PluginCompatibilityResult(autoSweepAllowed, manualSweepAllowed, chatTweaksAllowed, hostHealthRepairsAllowed, hushLoaded, fomoLoaded, echoLoaded, alphaLoaded, chalkyLoaded, flag, list);
		}

		private static bool HasGuidOrFuzzyMatch(HashSet<string> loaded, string exactGuid, params string[] fuzzyNeedles)
		{
			if (loaded.Contains(exactGuid))
			{
				return true;
			}
			foreach (string item in loaded)
			{
				if (!LooksLikeLoadedPluginGuid(item))
				{
					continue;
				}
				string text = item.Replace("-", string.Empty).Replace("_", string.Empty).Replace(".", string.Empty);
				for (int i = 0; i < fuzzyNeedles.Length; i++)
				{
					string value = fuzzyNeedles[i].Replace("-", string.Empty).Replace("_", string.Empty).Replace(".", string.Empty);
					if (text.IndexOf(value, StringComparison.OrdinalIgnoreCase) >= 0)
					{
						return true;
					}
				}
			}
			return false;
		}

		private static bool LooksLikeLoadedPluginGuid(string value)
		{
			if (string.IsNullOrWhiteSpace(value))
			{
				return false;
			}
			if (value.IndexOfAny(new char[3] { '\\', '/', ':' }) >= 0)
			{
				return false;
			}
			string text = value.ToLowerInvariant();
			if (!text.EndsWith(".dll") && !text.Contains(".dll.") && !text.EndsWith(".old") && !text.EndsWith(".bak"))
			{
				return !text.EndsWith(".disabled");
			}
			return false;
		}
	}
	internal sealed class PluginShutdownPolicy
	{
		private const int Running = 0;

		private const int ShutdownStarted = 1;

		private const int SteamCleanupClaimed = 2;

		private const int SteamCleanupFinished = 3;

		private const int LocalCleanupClaimed = 4;

		private const int Complete = 5;

		private int _phase;

		private string _trigger = string.Empty;

		internal bool IsShuttingDown => Volatile.Read(in _phase) != 0;

		internal bool IsComplete => Volatile.Read(in _phase) == 5;

		internal string Trigger => _trigger;

		internal bool TryBegin(string trigger)
		{
			if (Interlocked.CompareExchange(ref _phase, 1, 0) != 0)
			{
				return false;
			}
			_trigger = Bound(trigger, 48);
			return true;
		}

		internal bool TryClaimSteamCleanup()
		{
			return Interlocked.CompareExchange(ref _phase, 2, 1) == 1;
		}

		internal void FinishSteamCleanup()
		{
			int num = Volatile.Read(in _phase);
			while (num >= 1 && num < 3)
			{
				int num2 = Interlocked.CompareExchange(ref _phase, 3, num);
				if (num2 == num)
				{
					break;
				}
				num = num2;
			}
		}

		internal bool TryClaimLocalCleanup()
		{
			return Interlocked.CompareExchange(ref _phase, 4, 3) == 3;
		}

		internal void FinishLocalCleanup()
		{
			if (Volatile.Read(in _phase) == 4)
			{
				Interlocked.Exchange(ref _phase, 5);
			}
		}

		private static string Bound(string value, int maximum)
		{
			string text = (value ?? string.Empty).Replace("\r", " ").Replace("\n", " ").Trim();
			if (text.Length > maximum)
			{
				return text.Substring(0, maximum);
			}
			return text;
		}
	}
	internal static class ProcessRuntimeMetricsCapture
	{
		private struct ProcessMemoryCountersEx
		{
			internal uint Size;

			internal uint PageFaultCount;

			internal UIntPtr PeakWorkingSetSize;

			internal UIntPtr WorkingSetSize;

			internal UIntPtr QuotaPeakPagedPoolUsage;

			internal UIntPtr QuotaPagedPoolUsage;

			internal UIntPtr QuotaPeakNonPagedPoolUsage;

			internal UIntPtr QuotaNonPagedPoolUsage;

			internal UIntPtr PagefileUsage;

			internal UIntPtr PeakPagefileUsage;

			internal UIntPtr PrivateUsage;
		}

		[DllImport("psapi.dll", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool GetProcessMemoryInfo(IntPtr process, out ProcessMemoryCountersEx counters, uint size);

		public static long? ReadWorkingSetBytes()
		{
			try
			{
				using Process process = Process.GetCurrentProcess();
				process.Refresh();
				TryReadWindowsProcessMemory(process, out var workingSetBytes);
				return SelectPositiveBytes(process.WorkingSet64, workingSetBytes);
			}
			catch
			{
				return null;
			}
		}

		internal static long? SelectPositiveBytes(long primary, long fallback)
		{
			if (primary > 0)
			{
				return primary;
			}
			if (fallback <= 0)
			{
				return null;
			}
			return fallback;
		}

		private static bool TryReadWindowsProcessMemory(Process process, out long workingSetBytes)
		{
			workingSetBytes = 0L;
			if (process == null || Environment.OSVersion.Platform != PlatformID.Win32NT)
			{
				return false;
			}
			try
			{
				ProcessMemoryCountersEx counters = new ProcessMemoryCountersEx
				{
					Size = (uint)Marshal.SizeOf(typeof(ProcessMemoryCountersEx))
				};
				if (!GetProcessMemoryInfo(process.Handle, out counters, counters.Size))
				{
					return false;
				}
				workingSetBytes = ToPositiveInt64(counters.WorkingSetSize);
				return workingSetBytes > 0;
			}
			catch
			{
				return false;
			}
		}

		private static long ToPositiveInt64(UIntPtr value)
		{
			ulong num = value.ToUInt64();
			if (num != 0L)
			{
				if (num <= long.MaxValue)
				{
					return (long)num;
				}
				return long.MaxValue;
			}
			return 0L;
		}
	}
	internal static class PurrNetPlayerIdPolicy
	{
		internal static string Format(ulong value)
		{
			return value.ToString(CultureInfo.InvariantCulture);
		}
	}
	internal static class QolStatusTextPolicy
	{
		internal const int MaxPlayerCharacters = 240;

		internal static string BuildPlayerSummary(bool nativeSweepDetected, bool blueSageSweepEnabled)
		{
			return BuildPlayerSummary(nativeSweepDetected ? NativeAssetSweepOwnershipState.NativeGame : NativeAssetSweepOwnershipState.BlueSage, blueSageSweepEnabled, blueSageManualControlsReady: true);
		}

		internal static string BuildPlayerSummary(NativeAssetSweepOwnershipState nativeSweepOwnership, bool blueSageSweepEnabled)
		{
			return BuildPlayerSummary(nativeSweepOwnership, blueSageSweepEnabled, blueSageManualControlsReady: true);
		}

		internal static string BuildPlayerSummary(NativeAssetSweepOwnershipState nativeSweepOwnership, bool blueSageAutomaticLoopReady, bool blueSageManualControlsReady)
		{
			string text = nativeSweepOwnership switch
			{
				NativeAssetSweepOwnershipState.NativeGame => "native timer detected; unchanged", 
				NativeAssetSweepOwnershipState.InspectionIncomplete => "inspection incomplete; native behavior unchanged", 
				_ => "not detected", 
			};
			string text2 = ((blueSageAutomaticLoopReady && blueSageManualControlsReady) ? "automatic cleanup on; manual controls ready" : (blueSageAutomaticLoopReady ? "automatic cleanup on; manual controls off" : ((!blueSageManualControlsReady) ? "automatic cleanup off; manual controls off" : "automatic cleanup off; manual controls ready")));
			return "BlueSage QoL is ready. Game cleanup: " + text + "; BlueSage cleanup: " + text2 + ". Comfort, chat, safety, and player tools are managed from Home or /qolmenu.";
		}
	}
	internal enum ReconnectGuardAction
	{
		Noop,
		AllowReconnectMod,
		ScheduleManagedRetry,
		WaitForManagedRetryCadence,
		RunManagedRetryNow,
		StopManagedRetry
	}
	internal sealed class ReconnectGuardDecision
	{
		public ReconnectGuardAction Action { get; }

		public string Reason { get; }

		public int RecommendedAttemptIntervalSeconds { get; }

		public int RecommendedMaxAttempts { get; }

		public ReconnectGuardDecision(ReconnectGuardAction action, string reason)
			: this(action, reason, 15, 20)
		{
		}

		public ReconnectGuardDecision(ReconnectGuardAction action, string reason, int recommendedAttemptIntervalSeconds, int recommendedMaxAttempts)
		{
			Action = action;
			Reason = reason;
			RecommendedAttemptIntervalSeconds = recommendedAttemptIntervalSeconds;
			RecommendedMaxAttempts = recommendedMaxAttempts;
		}
	}
	internal sealed class ReconnectGuardInput
	{
		public bool GuardEnabled { get; }

		public bool ReconnectLoaded { get; }

		public bool SuppressHostKickReconnect { get; }

		public bool BlockDuringInitialLobbyGrace { get; }

		public bool RequireVisibleLobby { get; }

		public int ReconnectAttemptIntervalSeconds { get; }

		public int InitialLobbyGraceSeconds { get; }

		public int MaxGuardedAttempts { get; }

		public bool IsHost { get; }

		public bool IsIntentionalLeave { get; }

		public bool IsAlreadyReconnecting { get; }

		public string NotificationStatusName { get; }

		public float? SecondsSinceLobbyCreated { get; }

		public float? SecondsSinceLastManagedAttempt { get; }

		public int ReconnectAttempt { get; }

		public int? VisibleLobbyMemberCount { get; }

		public int? VisibleLobbyMaxPlayers { get; }

		public ReconnectGuardInput(bool guardEnabled, bool reconnectLoaded, bool suppressHostKickReconnect, bool blockDuringInitialLobbyGrace, bool requireVisibleLobby, int reconnectAttemptIntervalSeconds, int initialLobbyGraceSeconds, int maxGuardedAttempts, bool isHost, bool isIntentionalLeave, bool isAlreadyReconnecting, string notificationStatusName, float? secondsSinceLobbyCreated, float? secondsSinceLastManagedAttempt, int reconnectAttempt, int? visibleLobbyMemberCount, int? visibleLobbyMaxPlayers)
		{
			GuardEnabled = guardEnabled;
			ReconnectLoaded = reconnectLoaded;
			SuppressHostKickReconnect = suppressHostKickReconnect;
			BlockDuringInitialLobbyGrace = blockDuringInitialLobbyGrace;
			RequireVisibleLobby = requireVisibleLobby;
			ReconnectAttemptIntervalSeconds = reconnectAttemptIntervalSeconds;
			InitialLobbyGraceSeconds = initialLobbyGraceSeconds;
			MaxGuardedAttempts = maxGuardedAttempts;
			IsHost = isHost;
			IsIntentionalLeave = isIntentionalLeave;
			IsAlreadyReconnecting = isAlreadyReconnecting;
			NotificationStatusName = notificationStatusName ?? string.Empty;
			SecondsSinceLobbyCreated = secondsSinceLobbyCreated;
			SecondsSinceLastManagedAttempt = secondsSinceLastManagedAttempt;
			ReconnectAttempt = reconnectAttempt;
			VisibleLobbyMemberCount = visibleLobbyMemberCount;
			VisibleLobbyMaxPlayers = visibleLobbyMaxPlayers;
		}

		public static ReconnectGuardInput DefaultForTests(bool guardEnabled = true, bool reconnectLoaded = false, bool suppressHostKickReconnect = true, bool blockDuringInitialLobbyGrace = true, bool requireVisibleLobby = true, int reconnectAttemptIntervalSeconds = 5, int initialLobbyGraceSeconds = 20, int maxGuardedAttempts = 3, bool isHost = false, bool isIntentionalLeave = false, bool isAlreadyReconnecting = false, string notificationStatusName = "HostLost", float? secondsSinceLobbyCreated = 30f, float? secondsSinceLastManagedAttempt = null, int reconnectAttempt = 1, int? visibleLobbyMemberCount = 1, int? visibleLobbyMaxPlayers = 128)
		{
			return new ReconnectGuardInput(guardEnabled, reconnectLoaded, suppressHostKickReconnect, blockDuringInitialLobbyGrace, requireVisibleLobby, reconnectAttemptIntervalSeconds, initialLobbyGraceSeconds, maxGuardedAttempts, isHost, isIntentionalLeave, isAlreadyReconnecting, notificationStatusName, secondsSinceLobbyCreated, secondsSinceLastManagedAttempt, reconnectAttempt, visibleLobbyMemberCount, visibleLobbyMaxPlayers);
		}
	}
	internal static class ReconnectGuardPolicy
	{
		public static ReconnectGuardDecision Evaluate(ReconnectGuardInput input)
		{
			if (!input.GuardEnabled)
			{
				return Allow("Reconnect guard disabled.");
			}
			if (input.IsHost)
			{
				return Allow("Host flow is not guarded.");
			}
			if (input.IsIntentionalLeave)
			{
				return Allow("Reconnect already sees this as an intentional leave.");
			}
			int num = ClampSeconds(input.ReconnectAttemptIntervalSeconds, 5, 30);
			int num2 = ClampSeconds(input.MaxGuardedAttempts, 1, 3);
			if (input.IsAlreadyReconnecting)
			{
				return Noop("BlueSage managed reconnect is already active; suppressing overlapping reconnect pressure.", num, num2);
			}
			if (input.ReconnectAttempt > num2)
			{
				return Stop($"Stopping managed reconnect after guarded attempt limit ({input.ReconnectAttempt}/{num2}).", num, num2);
			}
			if (input.SuppressHostKickReconnect && LooksLikeHostKick(input.NotificationStatusName))
			{
				return Noop("Host kick style disconnect (" + input.NotificationStatusName + ") detected; not auto reconnecting because the host may have removed this client intentionally.", num, num2);
			}
			if (input.BlockDuringInitialLobbyGrace && input.SecondsSinceLobbyCreated.HasValue && input.SecondsSinceLobbyCreated.Value >= 0f && input.SecondsSinceLobbyCreated.Value < (float)ClampSeconds(input.InitialLobbyGraceSeconds, 0, 300))
			{
				return Schedule($"Scheduling managed reconnect during lobby grace window ({input.SecondsSinceLobbyCreated.Value:0.0}s since lobby seen).", num, num2);
			}
			if (input.RequireVisibleLobby && (!input.VisibleLobbyMemberCount.HasValue || !input.VisibleLobbyMaxPlayers.HasValue))
			{
				return Schedule("Native disconnect recovery accepted; the visible lobby count is already unavailable.", num, num2);
			}
			int valueOrDefault = input.VisibleLobbyMemberCount.GetValueOrDefault();
			int valueOrDefault2 = input.VisibleLobbyMaxPlayers.GetValueOrDefault();
			if (input.RequireVisibleLobby && valueOrDefault < 1)
			{
				return Schedule($"Native disconnect recovery accepted; the visible lobby count is now {valueOrDefault}/{valueOrDefault2}.", num, num2);
			}
			if (input.SecondsSinceLastManagedAttempt.HasValue && input.SecondsSinceLastManagedAttempt.Value >= 0f && input.SecondsSinceLastManagedAttempt.Value < (float)num)
			{
				return Wait($"Waiting for managed reconnect {num}s cadence ({input.SecondsSinceLastManagedAttempt.Value:0.0}s elapsed).", num, num2);
			}
			string arg = (input.ReconnectLoaded ? " AndrewLin Reconnect is loaded; BlueSage will suppress its transport-only retry." : string.Empty);
			return Run($"Visible lobby confirmed at {valueOrDefault}/{valueOrDefault2} players; managed reconnect retry may run now.{arg}", num, num2);
		}

		private static ReconnectGuardDecision Allow(string reason)
		{
			return new ReconnectGuardDecision(ReconnectGuardAction.AllowReconnectMod, reason);
		}

		private static ReconnectGuardDecision Noop(string reason, int intervalSeconds, int maxAttempts)
		{
			return new ReconnectGuardDecision(ReconnectGuardAction.Noop, reason, intervalSeconds, maxAttempts);
		}

		private static ReconnectGuardDecision Schedule(string reason, int intervalSeconds, int maxAttempts)
		{
			return new ReconnectGuardDecision(ReconnectGuardAction.ScheduleManagedRetry, reason, intervalSeconds, maxAttempts);
		}

		private static ReconnectGuardDecision Wait(string reason, int intervalSeconds, int maxAttempts)
		{
			return new ReconnectGuardDecision(ReconnectGuardAction.WaitForManagedRetryCadence, reason, intervalSeconds, maxAttempts);
		}

		private static ReconnectGuardDecision Run(string reason, int intervalSeconds, int maxAttempts)
		{
			return new ReconnectGuardDecision(ReconnectGuardAction.RunManagedRetryNow, reason, intervalSeconds, maxAttempts);
		}

		private static ReconnectGuardDecision Stop(string reason, int intervalSeconds, int maxAttempts)
		{
			return new ReconnectGuardDecision(ReconnectGuardAction.StopManagedRetry, reason, intervalSeconds, maxAttempts);
		}

		private static bool LooksLikeHostKick(string notificationStatusName)
		{
			string text = (notificationStatusName ?? string.Empty).Replace("_", string.Empty).Replace("-", string.Empty);
			if (text.IndexOf("kick", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return text.IndexOf("removedbyhost", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return true;
		}

		private static int ClampSeconds(int value, int min, int max)
		{
			if (value < min)
			{
				return min;
			}
			if (value <= max)
			{
				return value;
			}
			return max;
		}
	}
	internal enum ReconnectRuntimeHealthAction
	{
		KeepWaiting,
		ConfirmSuccess,
		ReturnToMenu
	}
	internal sealed class ReconnectRuntimeHealthDecision
	{
		public ReconnectRuntimeHealthAction Action { get; }

		public string Reason { get; }

		public ReconnectRuntimeHealthDecision(ReconnectRuntimeHealthAction action, string reason)
		{
			Action = action;
			Reason = reason;
		}
	}
	internal sealed class ReconnectRuntimeHealthInput
	{
		public bool ClientTransportConnected { get; }

		public bool RequireVisibleLobby { get; }

		public bool VisibleLobbyConfirmed { get; }

		public bool LocalUserIsAuthoritativeLobbyMember { get; }

		public bool GameRuntimeUsable { get; }

		public bool VoiceRuntimeReady { get; }

		public int ConsecutiveReadySamples { get; }

		public float? SecondsSinceClientTransportConnected { get; }

		public int PostConnectValidationSeconds { get; }

		public float ReadyStableSeconds { get; }

		public int RequiredReadyStabilitySeconds { get; }

		public ReconnectRuntimeHealthInput(bool clientTransportConnected, bool requireVisibleLobby, bool visibleLobbyConfirmed, bool localUserIsAuthoritativeLobbyMember, bool gameRuntimeUsable, bool voiceRuntimeReady, int consecutiveReadySamples, float? secondsSinceClientTransportConnected, int postConnectValidationSeconds, float readyStableSeconds = 0f, int requiredReadyStabilitySeconds = 2)
		{
			ClientTransportConnected = clientTransportConnected;
			RequireVisibleLobby = requireVisibleLobby;
			VisibleLobbyConfirmed = visibleLobbyConfirmed;
			LocalUserIsAuthoritativeLobbyMember = localUserIsAuthoritativeLobbyMember;
			GameRuntimeUsable = gameRuntimeUsable;
			VoiceRuntimeReady = voiceRuntimeReady;
			ConsecutiveReadySamples = consecutiveReadySamples;
			SecondsSinceClientTransportConnected = secondsSinceClientTransportConnected;
			PostConnectValidationSeconds = postConnectValidationSeconds;
			ReadyStableSeconds = readyStableSeconds;
			RequiredReadyStabilitySeconds = requiredReadyStabilitySeconds;
		}
	}
	internal static class ReconnectRuntimeHealthPolicy
	{
		public static ReconnectRuntimeHealthDecision Evaluate(ReconnectRuntimeHealthInput input)
		{
			if (!input.ClientTransportConnected)
			{
				return new ReconnectRuntimeHealthDecision(ReconnectRuntimeHealthAction.KeepWaiting, "Client transport is not connected yet.");
			}
			bool num = (!input.RequireVisibleLobby || input.VisibleLobbyConfirmed) && input.LocalUserIsAuthoritativeLobbyMember && input.GameRuntimeUsable;
			int num2 = Clamp(input.RequiredReadyStabilitySeconds, 1, 10);
			if (num && input.ConsecutiveReadySamples >= 3 && input.ReadyStableSeconds >= (float)num2)
			{
				return new ReconnectRuntimeHealthDecision(ReconnectRuntimeHealthAction.ConfirmSuccess, input.VoiceRuntimeReady ? "Client transport, authoritative Steam membership, local player runtime, and voice state are stable." : "Client transport, authoritative Steam membership, and local player runtime are stable; voice is still unavailable, so the playable session is preserved instead of being disconnected.");
			}
			int num3 = Clamp(input.PostConnectValidationSeconds, 3, 30);
			if (input.SecondsSinceClientTransportConnected.HasValue && input.SecondsSinceClientTransportConnected.Value >= (float)num3)
			{
				return new ReconnectRuntimeHealthDecision(ReconnectRuntimeHealthAction.ReturnToMenu, $"Client transport connected, but authoritative lobby/player/voice state did not converge within {num3}s.");
			}
			return new ReconnectRuntimeHealthDecision(ReconnectRuntimeHealthAction.KeepWaiting, (!input.LocalUserIsAuthoritativeLobbyMember) ? "Client transport is connected, but the local user is not an authoritative Steam lobby member; rejecting ghost-member state." : "Client transport is connected; waiting for lobby, local player, and voice readiness to remain stable before declaring reconnect success.");
		}

		private static int Clamp(int value, int min, int max)
		{
			if (value < min)
			{
				return min;
			}
			if (value <= max)
			{
				return value;
			}
			return max;
		}
	}
	internal readonly struct ReconnectMenuReadinessState
	{
		public bool SceneLoaded { get; }

		public int ActiveSceneBuildIndex { get; }

		public bool MenuAvailable { get; }

		public bool TransportStopped { get; }

		public bool LobbyCleared { get; }

		public bool BlueSageJoinIdle { get; }

		public ReconnectMenuReadinessState(bool sceneLoaded, int activeSceneBuildIndex, bool menuAvailable, bool transportStopped, bool lobbyCleared, bool blueSageJoinIdle)
		{
			SceneLoaded = sceneLoaded;
			ActiveSceneBuildIndex = activeSceneBuildIndex;
			MenuAvailable = menuAvailable;
			TransportStopped = transportStopped;
			LobbyCleared = lobbyCleared;
			BlueSageJoinIdle = blueSageJoinIdle;
		}
	}
	internal static class ReconnectTerminalCleanupPolicy
	{
		public static bool IsReady(ReconnectMenuReadinessState state)
		{
			return IsNativeMenuReady(state);
		}

		public static bool IsReadyForNewJoin(ReconnectMenuReadinessState state)
		{
			if (IsNativeMenuReady(state))
			{
				return state.BlueSageJoinIdle;
			}
			return false;
		}

		private static bool IsNativeMenuReady(ReconnectMenuReadinessState state)
		{
			if (state.SceneLoaded && state.ActiveSceneBuildIndex == 1 && state.MenuAvailable && state.TransportStopped)
			{
				return state.LobbyCleared;
			}
			return false;
		}
	}
	internal readonly struct RescueFollowLease
	{
		internal string LobbyId { get; }

		internal string OwnerSteamId { get; }

		internal string IssuerSteamId { get; }

		internal bool LongHaul { get; }

		internal RescueFollowLease(string lobbyId, string ownerSteamId, string issuerSteamId, bool longHaul)
		{
			LobbyId = lobbyId ?? string.Empty;
			OwnerSteamId = ownerSteamId ?? string.Empty;
			IssuerSteamId = issuerSteamId ?? string.Empty;
			LongHaul = longHaul;
		}
	}
	internal static class RescueFollowLeasePolicy
	{
		internal static bool IsCurrent(RescueFollowLease lease, string currentLobbyId, string currentOwnerSteamId, bool issuerIsCurrentMember, bool issuerIsAuthorized, bool longHaulIsEnabled)
		{
			if (string.IsNullOrWhiteSpace(lease.LobbyId) || string.IsNullOrWhiteSpace(lease.OwnerSteamId) || string.IsNullOrWhiteSpace(lease.IssuerSteamId))
			{
				return false;
			}
			if (string.Equals(lease.LobbyId, currentLobbyId, StringComparison.Ordinal) && string.Equals(lease.OwnerSteamId, currentOwnerSteamId, StringComparison.Ordinal) && issuerIsCurrentMember && issuerIsAuthorized)
			{
				return !lease.LongHaul || longHaulIsEnabled;
			}
			return false;
		}
	}
	internal readonly struct RescueRequest
	{
		internal string Action { get; }

		internal int Seconds { get; }

		internal long IssuedUnixSeconds { get; }

		internal string Nonce { get; }

		internal string TargetKind { get; }

		internal string TargetValue { get; }

		internal string TargetSteamId
		{
			get
			{
				if (!(TargetKind == "steam"))
				{
					return string.Empty;
				}
				return TargetValue;
			}
		}

		internal string TargetPlayerId
		{
			get
			{
				if (!(TargetKind == "pid"))
				{
					return string.Empty;
				}
				return TargetValue;
			}
		}

		internal RescueRequest(string targetSteamId, string action, int seconds, long issuedUnixSeconds, string nonce)
			: this("steam", targetSteamId, action, seconds, issuedUnixSeconds, nonce)
		{
		}

		internal RescueRequest(string targetKind, string targetValue, string action, int seconds, long issuedUnixSeconds, string nonce)
		{
			TargetKind = targetKind ?? string.Empty;
			TargetValue = targetValue ?? string.Empty;
			Action = action;
			Seconds = seconds;
			IssuedUnixSeconds = issuedUnixSeconds;
			Nonce = nonce;
		}
	}
	internal enum RescueApplyResult
	{
		Applied,
		Deferred,
		Rejected
	}
	internal static class RescueProtocolPolicy
	{
		internal const string MemberDataKey = "bluesage_rescue_v2";

		internal const string MemberDataPrefix = "v2|";

		internal const string PlayerIdMemberDataPrefix = "v3|pid|";

		internal const int MaxHookSeconds = 30;

		internal const int RequestExpirySeconds = 15;

		internal const int CooldownSeconds = 1;

		internal static bool ShouldRememberNonce(RescueApplyResult result)
		{
			return result != RescueApplyResult.Deferred;
		}

		internal static bool IsFresh(RescueRequest request, long nowUnixSeconds)
		{
			long num = nowUnixSeconds - request.IssuedUnixSeconds;
			if (num >= -2)
			{
				return num <= 15;
			}
			return false;
		}

		internal static string BuildMemberData(string targetSteamId, string action, int seconds, long issuedUnixSeconds, string nonce)
		{
			if (!IsSteamId64(targetSteamId) || !IsAction(action) || issuedUnixSeconds <= 0 || !IsNonce(nonce))
			{
				return string.Empty;
			}
			int num = ((action == "hook") ? Math.Max(1, Math.Min(30, seconds)) : ((action == "hooklong") ? int.MaxValue : 0));
			return "v2|" + targetSteamId + "|" + action + "|" + num + "|" + issuedUnixSeconds + "|" + nonce;
		}

		internal static string BuildPlayerIdMemberData(string targetPlayerId, string action, int seconds, long issuedUnixSeconds, string nonce)
		{
			if (!IsPlayerId(targetPlayerId) || !IsAction(action) || issuedUnixSeconds <= 0 || !IsNonce(nonce))
			{
				return string.Empty;
			}
			int num = ((action == "hook") ? Math.Max(1, Math.Min(30, seconds)) : ((action == "hooklong") ? int.MaxValue : 0));
			return "v3|pid|" + targetPlayerId + "|" + action + "|" + num + "|" + issuedUnixSeconds + "|" + nonce;
		}

		internal static bool TryParseMemberData(string value, out RescueRequest request)
		{
			request = default(RescueRequest);
			if (string.IsNullOrWhiteSpace(value))
			{
				return false;
			}
			if (value.StartsWith("v2|", StringComparison.Ordinal))
			{
				string[] array = value.Substring("v2|".Length).Split(new char[1] { '|' });
				if (array.Length != 5 || !IsSteamId64(array[0]) || !IsAction(array[1]) || !int.TryParse(array[2], out var result) || !long.TryParse(array[3], out var result2) || result2 <= 0 || !IsNonce(array[4]))
				{
					return false;
				}
				result = ((array[1] == "hook") ? Math.Max(1, Math.Min(30, result)) : ((array[1] == "hooklong") ? int.MaxValue : 0));
				request = new RescueRequest(array[0], array[1], result, result2, array[4]);
				return true;
			}
			if (!value.StartsWith("v3|pid|", StringComparison.Ordinal))
			{
				return false;
			}
			string[] array2 = value.Substring("v3|pid|".Length).Split(new char[1] { '|' });
			if (array2.Length != 5 || !IsPlayerId(array2[0]) || !IsAction(array2[1]) || !int.TryParse(array2[2], out var result3) || !long.TryParse(array2[3], out var result4) || result4 <= 0 || !IsNonce(array2[4]))
			{
				return false;
			}
			result3 = ((array2[1] == "hook") ? Math.Max(1, Math.Min(30, result3)) : ((array2[1] == "hooklong") ? int.MaxValue : 0));
			request = new RescueRequest("pid", array2[0], array2[1], result3, result4, array2[4]);
			return true;
		}

		internal static bool IsLocalTarget(RescueRequest request, string localSteamId, string localPlayerId)
		{
			if (!(request.TargetKind == "steam"))
			{
				if (request.TargetKind == "pid")
				{
					return string.Equals(request.TargetValue, localPlayerId, StringComparison.Ordinal);
				}
				return false;
			}
			return string.Equals(request.TargetValue, localSteamId, StringComparison.Ordinal);
		}

		private static bool IsAction(string action)
		{
			switch (action)
			{
			default:
				return action == "unhook";
			case "teleport":
			case "hook":
			case "hooklong":
				return true;
			}
		}

		private static bool IsNonce(string nonce)
		{
			if (string.IsNullOrWhiteSpace(nonce) || nonce.Length < 4 || nonce.Length > 16)
			{
				return false;
			}
			for (int i = 0; i < nonce.Length; i++)
			{
				if (!char.IsLetterOrDigit(nonce[i]))
				{
					return false;
				}
			}
			return true;
		}

		private static bool IsSteamId64(string value)
		{
			if (value != null && value.Length == 17 && value.StartsWith("7656119", StringComparison.Ordinal) && ulong.TryParse(value, out var result))
			{
				return result != 0;
			}
			return false;
		}

		private static bool IsPlayerId(string value)
		{
			if (string.IsNullOrWhiteSpace(value) || value.Length > 32)
			{
				return false;
			}
			foreach (char c in value)
			{
				if (!char.IsLetterOrDigit(c) && c != ':' && c != '-' && c != '_')
				{
					return false;
				}
			}
			return true;
		}
	}
	internal static class RescueReceiverCapabilityPolicy
	{
		internal const string MemberDataKey = "bluesage_qol_rescue_receiver_v1";

		internal const int PublishIntervalSeconds = 5;

		internal const int MaximumAgeSeconds = 15;

		private const int MaximumFutureSkewSeconds = 2;

		private const string Prefix = "v1|";

		internal static string BuildPayload(string pluginVersion, long issuedUnixSeconds)
		{
			string text = (pluginVersion ?? string.Empty).Trim();
			if (text.Length == 0 || text.IndexOf('|') >= 0 || issuedUnixSeconds <= 0)
			{
				return string.Empty;
			}
			return "v1|" + text + "|" + issuedUnixSeconds.ToString(CultureInfo.InvariantCulture);
		}

		internal static bool IsFresh(string payload, string expectedPluginVersion, long nowUnixSeconds)
		{
			if (string.IsNullOrWhiteSpace(payload) || !payload.StartsWith("v1|", StringComparison.Ordinal))
			{
				return false;
			}
			string[] array = payload.Substring("v1|".Length).Split(new char[1] { '|' });
			if (array.Length != 2 || !string.Equals(array[0], expectedPluginVersion, StringComparison.Ordinal) || !long.TryParse(array[1], NumberStyles.None, CultureInfo.InvariantCulture, out var result))
			{
				return false;
			}
			long num = nowUnixSeconds - result;
			if (num >= -2)
			{
				return num <= 15;
			}
			return false;
		}
	}
	internal sealed class RichTextRepairResult
	{
		public string Value { get; }

		public bool Changed { get; }

		public bool UsedPlainTextFallback { get; }

		public string Message { get; }

		public RichTextRepairResult(string value, bool changed, bool usedPlainTextFallback, string message)
		{
			Value = value ?? string.Empty;
			Changed = changed;
			UsedPlainTextFallback = usedPlainTextFallback;
			Message = message ?? string.Empty;
		}
	}
	internal static class RichTextDraftPolicy
	{
		private static readonly Regex TokenPattern = new Regex("<[^<>]*>", RegexOptions.Compiled);

		private static readonly Regex NamedTagPattern = new Regex("^<\\s*(/)?\\s*([a-zA-Z][a-zA-Z0-9-]*)(?:\\s*=\\s*[^>]*)?\\s*(/)?>$", RegexOptions.Compiled);

		private static readonly Regex ShorthandColorPattern = new Regex("^<\\s*#(?:[0-9A-Fa-f]{3}|[0-9A-Fa-f]{4}|[0-9A-Fa-f]{6}|[0-9A-Fa-f]{8})\\s*>$", RegexOptions.Compiled);

		private static readonly Regex IncompleteTagPattern = new Regex("<\\s*(?:/|#|[a-zA-Z])[^<>]*", RegexOptions.Compiled);

		private static readonly HashSet<string> StandaloneTags = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "br", "page", "pos", "space", "sprite" };

		public static bool TryValidate(string value, out string message)
		{
			string input = value ?? string.Empty;
			string text = TokenPattern.Replace(input, string.Empty);
			if (IncompleteTagPattern.IsMatch(text) || text.IndexOf('>') >= 0)
			{
				message = "Rich text contains a cut-off tag. Finish or remove the incomplete <...> markup before applying.";
				return false;
			}
			Stack<string> stack = new Stack<string>();
			foreach (Match item in TokenPattern.Matches(input))
			{
				string value2 = item.Value;
				if (ShorthandColorPattern.IsMatch(value2))
				{
					stack.Push("color");
					continue;
				}
				Match match = NamedTagPattern.Match(value2);
				if (!match.Success)
				{
					message = "Rich text contains an unsupported or malformed tag: " + value2;
					return false;
				}
				string value3 = match.Groups[2].Value;
				bool success = match.Groups[1].Success;
				if (match.Groups[3].Success || StandaloneTags.Contains(value3))
				{
					if (success)
					{
						message = "Rich text tag " + value2 + " cannot close a standalone TMP tag.";
						return false;
					}
				}
				else if (!success)
				{
					stack.Push(value3);
				}
				else if (stack.Count == 0 || !string.Equals(stack.Pop(), value3, StringComparison.OrdinalIgnoreCase))
				{
					message = "Rich text tags must close in reverse order (for example <b><size=120%>text</size></b>).";
					return false;
				}
			}
			if (stack.Count > 0)
			{
				message = "Rich text tag <" + stack.Peek() + "> is missing its closing tag.";
				return false;
			}
			message = string.Empty;
			return true;
		}

		public static RichTextRepairResult RepairLegacy(string value)
		{
			string text = (value ?? string.Empty).Trim();
			if (TryValidate(text, out var message))
			{
				return new RichTextRepairResult(text, changed: false, usedPlainTextFallback: false, string.Empty);
			}
			string text2 = TokenPattern.Replace(text, string.Empty);
			if (IncompleteTagPattern.IsMatch(text2) || text2.IndexOf('>') >= 0)
			{
				return BuildPlainTextFallback(text, "A cut-off legacy tag could not be balanced safely.");
			}
			StringBuilder stringBuilder = new StringBuilder(text.Length + 32);
			List<string> list = new List<string>();
			int num = 0;
			foreach (Match item in TokenPattern.Matches(text))
			{
				stringBuilder.Append(text, num, item.Index - num);
				num = item.Index + item.Length;
				string value2 = item.Value;
				if (ShorthandColorPattern.IsMatch(value2))
				{
					stringBuilder.Append(value2);
					list.Add("color");
					continue;
				}
				Match match2 = NamedTagPattern.Match(value2);
				if (!match2.Success)
				{
					return BuildPlainTextFallback(text, "An unsupported legacy tag could not be balanced safely.");
				}
				string value3 = match2.Groups[2].Value;
				bool success = match2.Groups[1].Success;
				if (match2.Groups[3].Success || StandaloneTags.Contains(value3))
				{
					if (!success)
					{
						stringBuilder.Append(value2);
					}
					continue;
				}
				if (!success)
				{
					stringBuilder.Append(value2);
					list.Add(value3);
					continue;
				}
				int num2 = FindOpenTag(list, value3);
				if (num2 >= 0)
				{
					for (int num3 = list.Count - 1; num3 > num2; num3--)
					{
						stringBuilder.Append("</").Append(list[num3]).Append('>');
						list.RemoveAt(num3);
					}
					stringBuilder.Append("</").Append(value3).Append('>');
					list.RemoveAt(num2);
				}
			}
			stringBuilder.Append(text, num, text.Length - num);
			for (int num4 = list.Count - 1; num4 >= 0; num4--)
			{
				stringBuilder.Append("</").Append(list[num4]).Append('>');
			}
			string text3 = stringBuilder.ToString().Trim();
			if (TryValidate(text3, out message) && !string.IsNullOrWhiteSpace(RichTextStyleBuilder.ToPlainStyleEditorText(text3)))
			{
				return new RichTextRepairResult(text3, !string.Equals(text3, text, StringComparison.Ordinal), usedPlainTextFallback: false, "Legacy rich text was balanced while preserving its visible text and supported tags.");
			}
			return BuildPlainTextFallback(text, "Legacy markup could not be balanced deterministically.");
		}

		private static int FindOpenTag(List<string> openTags, string name)
		{
			for (int num = openTags.Count - 1; num >= 0; num--)
			{
				if (string.Equals(openTags[num], name, StringComparison.OrdinalIgnoreCase))
				{
					return num;
				}
			}
			return -1;
		}

		private static RichTextRepairResult BuildPlainTextFallback(string input, string reason)
		{
			string input2 = TokenPattern.Replace(input ?? string.Empty, string.Empty);
			input2 = IncompleteTagPattern.Replace(input2, string.Empty);
			input2 = input2.Replace(">", string.Empty).Trim().Trim(new char[1]);
			return new RichTextRepairResult(input2, !string.Equals(input2, (input ?? string.Empty).Trim(), StringComparison.Ordinal), usedPlainTextFallback: true, reason + " BlueSage kept the visible plain text instead.");
		}
	}
	internal sealed class RichTextStyleResult
	{
		public bool Success { get; }

		public string GeneratedText { get; }

		public string Message { get; }

		public int RawLength { get; }

		private RichTextStyleResult(bool success, string generatedText, string message, int rawLength)
		{
			Success = success;
			GeneratedText = generatedText ?? string.Empty;
			Message = message ?? string.Empty;
			RawLength = rawLength;
		}

		public static RichTextStyleResult Ok(string generatedText)
		{
			return new RichTextStyleResult(success: true, generatedText, "Style copied.", generatedText?.Length ?? 0);
		}

		public static RichTextStyleResult Fail(string message, int rawLength = 0)
		{
			return new RichTextStyleResult(success: false, string.Empty, message, rawLength);
		}
	}
	internal static class RichTextStyleBuilder
	{
		private sealed class GradientTextElement
		{
			public string Value { get; }

			public bool IsTag { get; }

			public bool IsWhitespace
			{
				get
				{
					if (!IsTag)
					{
						return string.IsNullOrWhiteSpace(Value);
					}
					return false;
				}
			}

			public GradientTextElement(string value, bool isTag)
			{
				Value = value ?? string.Empty;
				IsTag = isTag;
			}
		}

		private sealed class ColorRgb
		{
			private int Red { get; }

			private int Green { get; }

			private int Blue { get; }

			private ColorRgb(int red, int green, int blue)
			{
				Red = red;
				Green = green;
				Blue = blue;
			}

			public static ColorRgb Parse(string hex)
			{
				return new ColorRgb(Convert.ToInt32(hex.Substring(0, 2), 16), Convert.ToInt32(hex.Substring(2, 2), 16), Convert.ToInt32(hex.Substring(4, 2), 16));
			}

			public static ColorRgb Lerp(ColorRgb start, ColorRgb end, double ratio)
			{
				return new ColorRgb(LerpChannel(start.Red, end.Red, ratio), LerpChannel(start.Green, end.Green, ratio), LerpChannel(start.Blue, end.Blue, ratio));
			}

			public string ToHex()
			{
				return Red.ToString("X2") + Green.ToString("X2") + Blue.ToString("X2");
			}

			private static int LerpChannel(int start, int end, double ratio)
			{
				int num = (int)Math.Round((double)start + (double)(end - start) * ratio, MidpointRounding.AwayFromZero);
				if (num < 0)
				{
					return 0;
				}
				if (num <= 255)
				{
					return num;
				}
				return 255;
			}
		}

		public const int DefaultMaxGeneratedCharacters = 3000;

		private static readonly Regex RichTextTagPattern = new Regex("<[^>]+>", RegexOptions.Compiled);

		private static readonly Regex OrphanRichTextFragmentPattern = new Regex("(?:#?[0-9A-Fa-f]{3}(?:[0-9A-Fa-f]{3})?>|/?(?:color|b|i|u)>)", RegexOptions.Compiled);

		public static RichTextStyleResult TryBuild(string arguments, int maxGeneratedCharacters = 3000)
		{
			string text = (arguments ?? string.Empty).Trim();
			if (string.IsNullOrWhiteSpace(text))
			{
				return RichTextStyleResult.Fail(Usage());
			}
			switch (text.Split(new char[1] { ' ' }, StringSplitOptions.RemoveEmptyEntries)[0].ToLowerInvariant())
			{
			case "color":
				return BuildColorMode(text, maxGeneratedCharacters, bold: false, italic: false);
			case "bold":
				return BuildColorMode(text, maxGeneratedCharacters, bold: true, italic: false);
			case "italic":
				return BuildColorMode(text, maxGeneratedCharacters, bold: false, italic: true);
			case "bolditalic":
			case "bi":
				return BuildColorMode(text, maxGeneratedCharacters, bold: true, italic: true);
			case "grad":
			case "gradient":
				return BuildGradientMode(text, maxGeneratedCharacters, 2);
			case "grad3":
			case "gradient3":
				return BuildGradientMode(text, maxGeneratedCharacters, 3);
			case "status":
				return BuildStatusMode(text, maxGeneratedCharacters);
			default:
				return RichTextStyleResult.Fail(Usage());
			}
		}

		private static RichTextStyleResult BuildColorMode(string input, int maxGeneratedCharacters, bool bold, bool italic)
		{
			string[] array = input.Split(new char[1] { ' ' }, 3, StringSplitOptions.RemoveEmptyEntries);
			if (array.Length < 3)
			{
				return RichTextStyleResult.Fail("Style Helper: use /style color #83E Your Text.");
			}
			if (!TryNormalizeHex(array[1], out var hex))
			{
				return RichTextStyleResult.Fail("Style Helper: expected a hex color like #83E or #8833EE.");
			}
			if (!RichTextDraftPolicy.TryValidate(array[2], out var message))
			{
				return RichTextStyleResult.Fail("Style Helper: " + message);
			}
			return EnforceLength(WrapStyle(BuildColorTag(hex, array[2]), bold, italic), maxGeneratedCharacters);
		}

		private static RichTextStyleResult BuildGradientMode(string input, int maxGeneratedCharacters, int colorCount)
		{
			string[] array = input.Split(new char[1] { ' ' }, colorCount + 2, StringSplitOptions.RemoveEmptyEntries);
			if (array.Length < colorCount + 2)
			{
				return RichTextStyleResult.Fail((colorCount == 2) ? "Style Helper: use /style gradient #83E #A59 Your Text." : "Style Helper: use /style gradient3 #83E #A59 #D85 Your Text.");
			}
			if (!TryNormalizeHex(array[1], out var hex) || !TryNormalizeHex(array[2], out var hex2))
			{
				return RichTextStyleResult.Fail("Style Helper: expected hex colors like #83E or #8833EE.");
			}
			string hex3 = hex2;
			string text;
			if (colorCount == 3)
			{
				if (!TryNormalizeHex(array[3], out hex3))
				{
					return RichTextStyleResult.Fail("Style Helper: expected hex colors like #83E or #8833EE.");
				}
				text = array[4];
			}
			else
			{
				text = array[3];
			}
			if (!RichTextDraftPolicy.TryValidate(text, out var message))
			{
				return RichTextStyleResult.Fail("Style Helper: " + message);
			}
			return EnforceLength((colorCount == 2) ? BuildGradient(text, ColorRgb.Parse(hex), ColorRgb.Parse(hex2)) : BuildGradient(text, ColorRgb.Parse(hex), ColorRgb.Parse(hex2), ColorRgb.Parse(hex3)), maxGeneratedCharacters);
		}

		private static RichTextStyleResult BuildStatusMode(string input, int maxGeneratedCharacters)
		{
			string[] array = input.Split(new char[1] { ' ' }, 3, StringSplitOptions.RemoveEmptyEntries);
			if (array.Length < 3)
			{
				return RichTextStyleResult.Fail("Style Helper: use /style status #FFD45D BRB.");
			}
			if (!TryNormalizeHex(array[1], out var hex))
			{
				return RichTextStyleResult.Fail("Style Helper: expected a hex color like #FFD45D.");
			}
			if (!RichTextDraftPolicy.TryValidate(array[2], out var message))
			{
				return RichTextStyleResult.Fail("Style Helper: " + message);
			}
			return EnforceLength(BuildColorTag(hex, "(" + array[2] + ")"), maxGeneratedCharacters);
		}

		internal static string BuildColorTag(string hex, string text)
		{
			string hex2;
			string text2 = (TryNormalizeHex(hex, out hex2) ? hex2 : "FFFFFF");
			return "<#" + text2 + ">" + (text ?? string.Empty) + "</color>";
		}

		internal static string ToPlainStyleEditorText(string value)
		{
			string text = value ?? string.Empty;
			for (int i = 0; i < 8; i++)
			{
				string input = RichTextTagPattern.Replace(text, string.Empty);
				input = OrphanRichTextFragmentPattern.Replace(input, string.Empty);
				if (string.Equals(input, text, StringComparison.Ordinal))
				{
					break;
				}
				text = input;
			}
			return text.Trim().Trim(new char[1]);
		}

		private static string WrapStyle(string value, bool bold, bool italic)
		{
			string text = value;
			if (italic)
			{
				text = "<i>" + text + "</i>";
			}
			if (bold)
			{
				text = "<b>" + text + "</b>";
			}
			return text;
		}

		private static string BuildGradient(string text, ColorRgb start, ColorRgb end)
		{
			return BuildGradient(text, start, end, end, useMiddle: false);
		}

		private static string BuildGradient(string text, ColorRgb start, ColorRgb middle, ColorRgb end)
		{
			return BuildGradient(text, start, middle, end, useMiddle: true);
		}

		private static string BuildGradient(string text, ColorRgb start, ColorRgb middle, ColorRgb end, bool useMiddle)
		{
			List<GradientTextElement> list = TokenizeGradientText(text ?? string.Empty);
			int num = list.Count((GradientTextElement element) => !element.IsTag && !element.IsWhitespace);
			if (num == 0)
			{
				return string.Empty;
			}
			StringBuilder stringBuilder = new StringBuilder();
			int num2 = 0;
			foreach (GradientTextElement item in list)
			{
				if (item.IsTag || item.IsWhitespace)
				{
					stringBuilder.Append(item.Value);
					continue;
				}
				double ratio = ((num == 1) ? 0.0 : ((double)num2 / (double)(num - 1)));
				ColorRgb colorRgb = ((!useMiddle) ? ColorRgb.Lerp(start, end, ratio) : LerpThreePoint(start, middle, end, ratio));
				stringBuilder.Append(BuildColorTag(colorRgb.ToHex(), item.Value));
				num2++;
			}
			return stringBuilder.ToString();
		}

		private static List<GradientTextElement> TokenizeGradientText(string value)
		{
			List<GradientTextElement> list = new List<GradientTextElement>();
			int num = 0;
			while (num < value.Length)
			{
				if (value[num] == '<')
				{
					int num2 = value.IndexOf('>', num + 1);
					if (num2 >= 0)
					{
						list.Add(new GradientTextElement(value.Substring(num, num2 - num + 1), isTag: true));
						num = num2 + 1;
						continue;
					}
				}
				int num3 = value.IndexOf('<', num);
				if (num3 < 0)
				{
					num3 = value.Length;
				}
				else if (num3 == num)
				{
					num3 = num + 1;
				}
				TextElementEnumerator textElementEnumerator = StringInfo.GetTextElementEnumerator(value.Substring(num, num3 - num));
				while (textElementEnumerator.MoveNext())
				{
					list.Add(new GradientTextElement(textElementEnumerator.GetTextElement(), isTag: false));
				}
				num = num3;
			}
			return list;
		}

		private static ColorRgb LerpThreePoint(ColorRgb start, ColorRgb middle, ColorRgb end, double ratio)
		{
			if (ratio <= 0.5)
			{
				return ColorRgb.Lerp(start, middle, ratio * 2.0);
			}
			return ColorRgb.Lerp(middle, end, (ratio - 0.5) * 2.0);
		}

		private static RichTextStyleResult EnforceLength(string generated, int maxGeneratedCharacters)
		{
			int length = generated.Length;
			if (length == 0)
			{
				return RichTextStyleResult.Fail("Style Helper: add some text to style.");
			}
			if (length > maxGeneratedCharacters)
			{
				return RichTextStyleResult.Fail($"Style Helper: generated text is too long ({length}/{maxGeneratedCharacters}). Shorten the text or use fewer per-letter colors.", length);
			}
			return RichTextStyleResult.Ok(generated);
		}

		internal static bool TryNormalizeHex(string value, out string hex)
		{
			hex = string.Empty;
			string text = (value ?? string.Empty).Trim().TrimStart(new char[1] { '#' });
			if (text.Length == 3)
			{
				text = new string(new char[6]
				{
					text[0],
					text[0],
					text[1],
					text[1],
					text[2],
					text[2]
				});
			}
			if (text.Length != 6 || text.Any((char character) => !Uri.IsHexDigit(character)))
			{
				return false;
			}
			hex = text.ToUpperInvariant();
			return true;
		}

		private static string Usage()
		{
			return "Style Helper: /style color #83E Blue, /style bold #83E Blue, /style gradient #83E #A59 Blue, /style gradient3 #83E #A59 #D85 Blue, /style status #FFD45D BRB.";
		}
	}
	internal enum RoleLabelProtocolAction
	{
		Set,
		Clear
	}
	internal readonly struct RoleLabelProtocolMessage
	{
		internal RoleLabelProtocolAction Action { get; }

		internal long IssuedUnixSeconds { get; }

		internal string Nonce { get; }

		internal string Label { get; }

		internal RoleLabelProtocolMessage(RoleLabelProtocolAction action, long issuedUnixSeconds, string nonce, string label)
		{
			Action = action;
			IssuedUnixSeconds = issuedUnixSeconds;
			Nonce = nonce ?? string.Empty;
			Label = label ?? string.Empty;
		}
	}
	internal static class RoleLabelProtocolPolicy
	{
		internal const int FreshnessSeconds = 8;

		internal const int MaxLabelCharacters = 96;

		private const int MaxPayloadCharacters = 640;

		private static readonly UTF8Encoding StrictUtf8 = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true);

		internal static bool TryBuildSet(string label, long issuedUnixSeconds, string nonce, out string payload, out string error)
		{
			payload = string.Empty;
			if (!TryValidateEnvelope(issuedUnixSeconds, nonce, out error) || !TryValidateLabel(label, out var clean, out error))
			{
				return false;
			}
			string text = EncodeBase64Url(StrictUtf8.GetBytes(clean));
			payload = string.Join("|", "v1", "set", issuedUnixSeconds.ToString(CultureInfo.InvariantCulture), nonce, text);
			if (payload.Length > 640)
			{
				payload = string.Empty;
				error = "Role label payload exceeds the bounded transport size.";
				return false;
			}
			error = string.Empty;
			return true;
		}

		internal static bool TryBuildClear(long issuedUnixSeconds, string nonce, out string payload, out string error)
		{
			payload = string.Empty;
			if (!TryValidateEnvelope(issuedUnixSeconds, nonce, out error))
			{
				return false;
			}
			payload = string.Join("|", "v1", "clear", issuedUnixSeconds.ToString(CultureInfo.InvariantCulture), nonce, "-");
			error = string.Empty;
			return true;
		}

		internal static bool TryParse(string payload, long nowUnixSeconds, out RoleLabelProtocolMessage message, out string error)
		{
			message = default(RoleLabelProtocolMessage);
			error = "Role label payload is invalid.";
			if (string.IsNullOrWhiteSpace(payload) || payload.Length > 640)
			{
				return false;
			}
			string[] array = payload.Split(new char[1] { '|' });
			if (array.Length != 5 || !string.Equals(array[0], "v1", StringComparison.Ordinal) || !long.TryParse(array[2], NumberStyles.None, CultureInfo.InvariantCulture, out var result) || !TryValidateEnvelope(result, array[3], out error))
			{
				return false;
			}
			long num = nowUnixSeconds - result;
			if (num < -2 || num > 8)
			{
				error = "Role label payload is outside the freshness window.";
				return false;
			}
			if (string.Equals(array[1], "clear", StringComparison.Ordinal))
			{
				if (!string.Equals(array[4], "-", StringComparison.Ordinal))
				{
					error = "Clear payload must not contain a label.";
					return false;
				}
				message = new RoleLabelProtocolMessage(RoleLabelProtocolAction.Clear, result, array[3], string.Empty);
				error = string.Empty;
				return true;
			}
			if (!string.Equals(array[1], "set", StringComparison.Ordinal) || !TryDecodeBase64Url(array[4], out var value) || !TryValidateLabel(value, out var clean, out error))
			{
				return false;
			}
			message = new RoleLabelProtocolMessage(RoleLabelProtocolAction.Set, result, array[3], clean);
			error = string.Empty;
			return true;
		}

		internal static bool TryValidateLabel(string label, out string clean, out string error)
		{
			clean = label ?? string.Empty;
			error = string.Empty;
			if (clean.Length < 1 || clean.Length > 96)
			{
				error = "Role label must be between 1 and 96 characters.";
				return false;
			}
			if (clean.IndexOf('\r') >= 0 || clean.IndexOf('\n') >= 0 || clean.IndexOf('\0') >= 0)
			{
				error = "Role label must stay on one line.";
				return false;
			}
			if (!RichTextDraftPolicy.TryValidate(clean, out var message))
			{
				error = "Role label rich text is invalid: " + message;
				return false;
			}
			return true;
		}

		private static bool TryValidateEnvelope(long issuedUnixSeconds, string nonce, out string error)
		{
			if (issuedUnixSeconds <= 0)
			{
				error = "Role label timestamp is invalid.";
				return false;
			}
			if (string.IsNullOrEmpty(nonce) || nonce.Length < 4 || nonce.Length > 16)
			{
				error = "Role label nonce must be 4-16 alphanumeric characters.";
				return false;
			}
			for (int i = 0; i < nonce.Length; i++)
			{
				if (!char.IsLetterOrDigit(nonce[i]))
				{
					error = "Role label nonce must be alphanumeric.";
					return false;
				}
			}
			error = string.Empty;
			return true;
		}

		private static string EncodeBase64Url(byte[] bytes)
		{
			return Convert.ToBase64String(bytes).TrimEnd(new char[1] { '=' }).Replace('+', '-')
				.Replace('/', '_');
		}

		private static bool TryDecodeBase64Url(string encoded, out string value)
		{
			value = string.Empty;
			if (string.IsNullOrEmpty(encoded) || encoded.Length > 512)
			{
				return false;
			}
			foreach (char c in encoded)
			{
				if (!char.IsLetterOrDigit(c) && c != '-' && c != '_')
				{
					return false;
				}
			}
			string text = encoded.Replace('-', '+').Replace('_', '/');
			int num = text.Length % 4;
			if (num == 1)
			{
				return false;
			}
			if (num > 0)
			{
				text = text.PadRight(text.Length + (4 - num), '=');
			}
			try
			{
				value = StrictUtf8.GetString(Convert.FromBase64String(text));
				return true;
			}
			catch
			{
				value = string.Empty;
				return false;
			}
		}
	}
	internal enum RosterRegistrationAction
	{
		RejectInvalid,
		IgnoreExactDuplicate,
		ReplaceStableIdentity,
		Append
	}
	internal readonly struct RosterRegistrationDecision
	{
		internal RosterRegistrationAction Action { get; }

		internal int ExistingIndex { get; }

		internal RosterRegistrationDecision(RosterRegistrationAction action, int existingIndex)
		{
			Action = action;
			ExistingIndex = existingIndex;
		}
	}
	internal static class RosterRegistrationPolicy
	{
		internal static RosterRegistrationDecision Evaluate<TTransform>(string incomingSteamId, string incomingVivoxId, TTransform incomingTransform, IReadOnlyList<string> existingSteamIds, IReadOnlyList<string> existingVivoxIds, IReadOnlyList<TTransform> existingTransforms) where TTransform : class
		{
			if (string.IsNullOrWhiteSpace(incomingSteamId) || incomingTransform == null)
			{
				return new RosterRegistrationDecision(RosterRegistrationAction.RejectInvalid, -1);
			}
			if (existingTransforms != null)
			{
				for (int i = 0; i < existingTransforms.Count; i++)
				{
					if (existingTransforms[i] == incomingTransform)
					{
						return new RosterRegistrationDecision(RosterRegistrationAction.IgnoreExactDuplicate, i);
					}
				}
			}
			int num = existingSteamIds?.Count ?? 0;
			for (int j = 0; j < num; j++)
			{
				if (string.Equals(existingSteamIds[j], incomingSteamId, StringComparison.Ordinal))
				{
					return new RosterRegistrationDecision(RosterRegistrationAction.ReplaceStableIdentity, j);
				}
			}
			int num2 = existingVivoxIds?.Count ?? 0;
			if (!string.IsNullOrWhiteSpace(incomingVivoxId))
			{
				for (int k = 0; k < num2; k++)
				{
					if (string.Equals(existingVivoxIds[k], incomingVivoxId, StringComparison.Ordinal))
					{
						return new RosterRegistrationDecision(RosterRegistrationAction.ReplaceStableIdentity, k);
					}
				}
			}
			return new RosterRegistrationDecision(RosterRegistrationAction.Append, -1);
		}
	}
	internal sealed class ScopedSenderEvidenceContext
	{
		internal bool HasSenderBinding { get; set; }

		internal bool UniqueCurrentAgreement { get; set; }

		internal bool FreshAtClick { get; set; }

		internal bool ExactTupleMatches { get; set; }

		internal bool PrivilegedObserver { get; set; }

		internal string SteamId { get; set; } = string.Empty;

		internal string PlayerId { get; set; } = string.Empty;

		internal int NativeRowIndex { get; set; } = -1;

		internal string SessionRowCorrelator { get; set; } = string.Empty;
	}
	internal static class ScopedSenderEvidencePolicy
	{
		private const int MaximumEvidenceCharacters = 1024;

		internal static bool TryBuild(ScopedSenderEvidenceContext context, out string evidence, out string error)
		{
			evidence = string.Empty;
			error = string.Empty;
			if (context == null || !context.HasSenderBinding || !context.UniqueCurrentAgreement || !context.FreshAtClick || !context.ExactTupleMatches)
			{
				error = "Exact identity evidence stayed locked because the current Steam/PurrNet/native-row tuple did not agree uniquely.";
				return false;
			}
			if (!IsSteamId64(context.SteamId) || !IsBoundedField(context.PlayerId, 128) || context.NativeRowIndex < 0 || !IsCorrelator(context.SessionRowCorrelator))
			{
				error = "Exact identity evidence stayed locked because one captured tuple field was malformed.";
				return false;
			}
			StringBuilder stringBuilder = new StringBuilder(320);
			stringBuilder.AppendLine("BlueSage exact identity evidence - EVIDENCE ONLY");
			stringBuilder.AppendLine("Local clipboard only. Revalidate the current native row before any action.");
			stringBuilder.Append("Native row index (zero-based): ").Append(context.NativeRowIndex).AppendLine();
			stringBuilder.Append("Session row correlator: ").Append(context.SessionRowCorrelator).AppendLine();
			stringBuilder.Append("SteamID64: ").Append(context.SteamId).AppendLine();
			if (context.PrivilegedObserver)
			{
				stringBuilder.Append("PurrNet PlayerID: ").Append(context.PlayerId).AppendLine();
			}
			stringBuilder.Append("Agreement: unique current Steam/PurrNet/native-row/transform");
			evidence = stringBuilder.ToString().TrimEnd(Array.Empty<char>());
			if (evidence.Length > 1024)
			{
				evidence = string.Empty;
				error = "Exact identity evidence stayed locked because the bounded clipboard record was too large.";
				return false;
			}
			return true;
		}

		private static bool IsSteamId64(string value)
		{
			if (string.IsNullOrEmpty(value) || value.Length != 17)
			{
				return false;
			}
			for (int i = 0; i < value.Length; i++)
			{
				if (value[i] < '0' || value[i] > '9')
				{
					return false;
				}
			}
			return true;
		}

		private static bool IsBoundedField(string value, int maximumLength)
		{
			if (string.IsNullOrWhiteSpace(value) || value.Length > maximumLength)
			{
				return false;
			}
			for (int i = 0; i < value.Length; i++)
			{
				if (char.IsControl(value[i]))
				{
					return false;
				}
			}
			return true;
		}

		private static bool IsCorrelator(string value)
		{
			if (string.IsNullOrEmpty(value) || value.Length != "row-".Length + 12 || !value.StartsWith("row-"))
			{
				return false;
			}
			for (int i = "row-".Length; i < value.Length; i++)
			{
				char c = value[i];
				if ((c < '0' || c > '9') && (c < 'a' || c > 'f'))
				{
					return false;
				}
			}
			return true;
		}
	}
	internal static class SelfMovementPolicy
	{
		internal const float DefaultMultiplier = 1f;

		internal const float MinimumSpeedMultiplier = 0.25f;

		internal const float MaximumSpeedMultiplier = 5f;

		internal const float MinimumJumpMultiplier = 0.25f;

		internal const float MaximumJumpMultiplier = 5f;

		internal const float MinimumGravityMultiplier = 0.1f;

		internal const float MaximumGravityMultiplier = 5f;

		internal const float BaseFlySpeed = 8f;

		internal static float ClampSpeed(float value)
		{
			return Mathf.Clamp(value, 0.25f, 5f);
		}

		internal static float ClampJump(float value)
		{
			return Mathf.Clamp(value, 0.25f, 5f);
		}

		internal static float ClampGravity(float value)
		{
			return Mathf.Clamp(value, 0.1f, 5f);
		}

		internal static string FormatPosition(Vector3 position)
		{
			return string.Join(",", position.x.ToString("R", CultureInfo.InvariantCulture), position.y.ToString("R", CultureInfo.InvariantCulture), position.z.ToString("R", CultureInfo.InvariantCulture));
		}

		internal static bool TryParsePosition(string value, out Vector3 position)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			position = Vector3.zero;
			string[] array = (value ?? string.Empty).Trim().Replace(';', ',').Split(new char[2] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries);
			if (array.Length != 3 || !float.TryParse(array[0], NumberStyles.Float, CultureInfo.InvariantCulture, out var result) || !float.TryParse(array[1], NumberStyles.Float, CultureInfo.InvariantCulture, out var result2) || !float.TryParse(array[2], NumberStyles.Float, CultureInfo.InvariantCulture, out var result3))
			{
				return false;
			}
			position = new Vector3(result, result2, result3);
			if (IsFinite(result) && IsFinite(result2))
			{
				return IsFinite(result3);
			}
			return false;
		}

		private static bool IsFinite(float value)
		{
			if (!float.IsNaN(value))
			{
				return !float.IsInfinity(value);
			}
			return false;
		}
	}
	internal static class SessionAuditPolicy
	{
		internal const int MaximumAuditFieldCharacters = 8192;

		private static readonly Regex RichTextTagPattern = new Regex("<[^>]*>", RegexOptions.Compiled);

		internal static string ToPlainText(string? value)
		{
			return Limit(RichTextTagPattern.Replace(value ?? string.Empty, string.Empty).Replace("\r", " ").Replace("\n", " ")
				.Trim());
		}

		internal static string BuildChatRecord(string utc, string channel, int senderIndex, string identityState, string observerAuthority, string senderRole, string steamId64, string displayNameRaw, string rosterNameRaw, string steamPersona, string messageRaw, string lobbyId)
		{
			return "{" + Field("schema", "1") + "," + Field("utc", utc) + "," + Field("event", "chat") + "," + Field("captureStage", "rendered-ui") + "," + Field("channel", channel) + "," + NumberField("senderIndex", senderIndex) + "," + Field("identityState", identityState) + "," + Field("observerAuthority", observerAuthority) + "," + Field("senderRole", senderRole) + "," + Field("steamId64", steamId64) + "," + Field("displayNameRaw", displayNameRaw) + "," + Field("displayNamePlain", ToPlainText(displayNameRaw)) + "," + Field("rosterNameRaw", rosterNameRaw) + "," + Field("rosterNamePlain", ToPlainText(rosterNameRaw)) + "," + Field("steamPersona", steamPersona) + "," + Field("messageRaw", messageRaw) + "," + Field("messagePlain", ToPlainText(messageRaw)) + "," + Field("lobbyId", lobbyId) + "}";
		}

		internal static string BuildNotificationRecord(string utc, string textRaw, string lobbyId)
		{
			return "{" + Field("schema", "1") + "," + Field("utc", utc) + "," + Field("event", "notification") + "," + Field("textRaw", textRaw) + "," + Field("textPlain", ToPlainText(textRaw)) + "," + Field("lobbyId", lobbyId) + "}";
		}

		internal static string BuildRunMarkerRecord(string utc, string classification, string ageBucket, string markerName)
		{
			return "{" + Field("schema", "1") + "," + Field("utc", utc) + "," + Field("event", "run-marker") + "," + Field("classification", classification) + "," + Field("ageBucket", ageBucket) + "," + Field("markerName", markerName) + "}";
		}

		internal static string BuildModerationRecord(string utc, string action, string source, string outcome, string steamId64, string displayNameRaw, string steamPersona, string lobbyId, string issuerSteamId64 = "", string incidentId = "", string targetRole = "")
		{
			return "{" + Field("schema", "1") + "," + Field("utc", utc) + "," + Field("event", "moderation") + "," + Field("action", action) + "," + Field("source", source) + "," + Field("outcome", outcome) + "," + Field("steamId64", steamId64) + "," + Field("displayNameRaw", displayNameRaw) + "," + Field("displayNamePlain", ToPlainText(displayNameRaw)) + "," + Field("steamPersona", steamPersona) + "," + Field("issuerSteamId64", issuerSteamId64) + "," + Field("incidentId", incidentId) + "," + Field("targetRole", targetRole) + "," + Field("lobbyId", lobbyId) + "}";
		}

		private static string Field(string name, string? value)
		{
			return "\"" + name + "\":\"" + Escape(Limit(value ?? string.Empty)) + "\"";
		}

		private static string NumberField(string name, int value)
		{
			return "\"" + name + "\":" + value;
		}

		private static string Limit(string value)
		{
			if (value.Length > 8192)
			{
				return value.Substring(0, 8192);
			}
			return value;
		}

		private static string Escape(string value)
		{
			StringBuilder stringBuilder = new StringBuilder(value.Length + 16);
			foreach (char c in value)
			{
				switch (c)
				{
				case '"':
					stringBuilder.Append("\\\"");
					continue;
				case '\\':
					stringBuilder.Append("\\\\");
					continue;
				case '\b':
					stringBuilder.Append("\\b");
					continue;
				case '\f':
					stringBuilder.Append("\\f");
					continue;
				case '\n':
					stringBuilder.Append("\\n");
					continue;
				case '\r':
					stringBuilder.Append("\\r");
					continue;
				case '\t':
					stringBuilder.Append("\\t");
					continue;
				}
				if (c < ' ')
				{
					StringBuilder stringBuilder2 = stringBuilder.Append("\\u");
					int num = c;
					stringBuilder2.Append(num.ToString("X4"));
				}
				else
				{
					stringBuilder.Append(c);
				}
			}
			return stringBuilder.ToString();
		}
	}
	internal static class SessionRowCorrelatorPolicy
	{
		internal static bool TryCreate(string sessionScope, string steamId, string playerId, int rowIndex, out string correlator)
		{
			correlator = string.Empty;
			if (!IsBoundedField(sessionScope, 128) || !IsSteamId64(steamId) || !IsBoundedField(playerId, 128) || rowIndex < 0)
			{
				return false;
			}
			string s = sessionScope + "\n" + steamId + "\n" + playerId + "\n" + rowIndex.ToString(CultureInfo.InvariantCulture);
			byte[] bytes = Encoding.UTF8.GetBytes(s);
			ulong num = 14695981039346656037uL;
			for (int i = 0; i < bytes.Length; i++)
			{
				num ^= bytes[i];
				num *= 1099511628211L;
			}
			correlator = "row-" + num.ToString("x16", CultureInfo.InvariantCulture).Substring(0, 12);
			return true;
		}

		private static bool IsSteamId64(string value)
		{
			if (string.IsNullOrEmpty(value) || value.Length != 17)
			{
				return false;
			}
			for (int i = 0; i < value.Length; i++)
			{
				if (value[i] < '0' || value[i] > '9')
				{
					return false;
				}
			}
			return true;
		}

		private static bool IsBoundedField(string value, int maximumLength)
		{
			if (string.IsNullOrWhiteSpace(value) || value.Length > maximumLength)
			{
				return false;
			}
			for (int i = 0; i < value.Length; i++)
			{
				if (char.IsControl(value[i]))
				{
					return false;
				}
			}
			return true;
		}
	}
	internal enum SessionRunState
	{
		Unknown,
		Running,
		Clean
	}
	internal enum SessionRunClassification
	{
		None,
		Clean,
		Concurrent,
		Uncertain,
		Abnormal
	}
	internal sealed class SessionRunMarker
	{
		internal static readonly SessionRunMarker Empty = new SessionRunMarker(string.Empty, 0, 0L, 0L, 0L, SessionRunState.Unknown, string.Empty);

		internal string Version { get; }

		internal int ProcessId { get; }

		internal long StartedUtcTicks { get; }

		internal long HeartbeatUtcTicks { get; }

		internal long ClosedUtcTicks { get; }

		internal SessionRunState State { get; }

		internal string Context { get; }

		internal SessionRunMarker(string version, int processId, long startedUtcTicks, long heartbeatUtcTicks, long closedUtcTicks, SessionRunState state, string context)
		{
			Version = version ?? string.Empty;
			ProcessId = processId;
			StartedUtcTicks = startedUtcTicks;
			HeartbeatUtcTicks = heartbeatUtcTicks;
			ClosedUtcTicks = closedUtcTicks;
			State = state;
			Context = context ?? string.Empty;
		}
	}
	internal static class SessionRunMarkerPolicy
	{
		internal const int SchemaVersion = 1;

		internal const int AbnormalStaleSeconds = 15;

		internal const int HeartbeatIntervalSeconds = 5;

		internal static SessionRunMarker CreateRunning(string version, int processId, long startedUtcTicks, long heartbeatUtcTicks, string context)
		{
			return new SessionRunMarker(Bound(version, 128), processId, startedUtcTicks, heartbeatUtcTicks, 0L, SessionRunState.Running, Bound(context, 64));
		}

		internal static SessionRunMarker CreateCleanClose(SessionRunMarker current, long closedUtcTicks)
		{
			if (current == null)
			{
				throw new ArgumentNullException("current");
			}
			return new SessionRunMarker(current.Version, current.ProcessId, current.StartedUtcTicks, Math.Max(current.HeartbeatUtcTicks, closedUtcTicks), closedUtcTicks, SessionRunState.Clean, "clean-close");
		}

		internal static SessionRunMarker WithHeartbeat(SessionRunMarker current, long heartbeatUtcTicks, string context)
		{
			if (current == null)
			{
				throw new ArgumentNullException("current");
			}
			return new SessionRunMarker(current.Version, current.ProcessId, current.StartedUtcTicks, heartbeatUtcTicks, 0L, SessionRunState.Running, Bound(context, 64));
		}

		internal static SessionRunClassification ClassifyPrior(SessionRunMarker prior, long nowUtcTicks, bool processExists, bool processStartMatches)
		{
			if (prior == null)
			{
				return SessionRunClassification.None;
			}
			if (prior.State == SessionRunState.Clean)
			{
				return SessionRunClassification.Clean;
			}
			if (prior.State != SessionRunState.Running || !IsValidTicks(nowUtcTicks))
			{
				return SessionRunClassification.Uncertain;
			}
			if (processExists && processStartMatches)
			{
				return SessionRunClassification.Concurrent;
			}
			if (processExists && !processStartMatches)
			{
				return SessionRunClassification.Abnormal;
			}
			long num = nowUtcTicks - prior.HeartbeatUtcTicks;
			if (num < 0 || num < TimeSpan.FromSeconds(15.0).Ticks)
			{
				return SessionRunClassification.Uncertain;
			}
			return SessionRunClassification.Abnormal;
		}

		internal static string Serialize(SessionRunMarker marker)
		{
			if (marker == null)
			{
				return string.Empty;
			}
			return new StringBuilder(256).Append("schema=").Append(1).Append('\n')
				.Append("state=")
				.Append((marker.State == SessionRunState.Clean) ? "clean" : "running")
				.Append('\n')
				.Append("version=")
				.Append(Escape(marker.Version))
				.Append('\n')
				.Append("pid=")
				.Append(marker.ProcessId.ToString(CultureInfo.InvariantCulture))
				.Append('\n')
				.Append("startedUtcTicks=")
				.Append(marker.StartedUtcTicks.ToString(CultureInfo.InvariantCulture))
				.Append('\n')
				.Append("heartbeatUtcTicks=")
				.Append(marker.HeartbeatUtcTicks.ToString(CultureInfo.InvariantCulture))
				.Append('\n')
				.Append("closedUtcTicks=")
				.Append(marker.ClosedUtcTicks.ToString(CultureInfo.InvariantCulture))
				.Append('\n')
				.Append("context=")
				.Append(Escape(marker.Context))
				.Append('\n')
				.ToString();
		}

		internal static bool TryParse(string serialized, out SessionRunMarker marker)
		{
			marker = SessionRunMarker.Empty;
			string[] array = (serialized ?? string.Empty).Replace("\r\n", "\n").Split(new char[1] { '\n' });
			if (array.Length != 9 || array[8].Length != 0)
			{
				return false;
			}
			if (!TryValue(array[0], "schema", out string value) || value != 1.ToString(CultureInfo.InvariantCulture) || !TryValue(array[1], "state", out string value2) || !TryValue(array[2], "version", out string value3) || !TryValue(array[3], "pid", out string value4) || !TryValue(array[4], "startedUtcTicks", out string value5) || !TryValue(array[5], "heartbeatUtcTicks", out string value6) || !TryValue(array[6], "closedUtcTicks", out string value7) || !TryValue(array[7], "context", out string value8) || !int.TryParse(value4, NumberStyles.None, CultureInfo.InvariantCulture, out var result) || !long.TryParse(value5, NumberStyles.None, CultureInfo.InvariantCulture, out var result2) || !long.TryParse(value6, NumberStyles.None, CultureInfo.InvariantCulture, out var result3) || !long.TryParse(value7, NumberStyles.None, CultureInfo.InvariantCulture, out var result4) || !TryUnescape(value3, out value3) || !TryUnescape(value8, out value8))
			{
				return false;
			}
			SessionRunState sessionRunState = ((value2 == "running") ? SessionRunState.Running : ((value2 == "clean") ? SessionRunState.Clean : SessionRunState.Unknown));
			if (sessionRunState == SessionRunState.Unknown || result <= 0 || value3.Length == 0 || value3.Length > 128 || value8.Length > 64 || !IsValidTicks(result2) || !IsValidTicks(result3) || result3 < result2 || (sessionRunState == SessionRunState.Running && result4 != 0L) || (sessionRunState == SessionRunState.Clean && (!IsValidTicks(result4) || result4 < result2)))
			{
				return false;
			}
			marker = new SessionRunMarker(value3, result, result2, result3, result4, sessionRunState, value8);
			return true;
		}

		private static bool TryValue(string line, string name, out string value)
		{
			string text = name + "=";
			if (!line.StartsWith(text, StringComparison.Ordinal))
			{
				value = string.Empty;
				return false;
			}
			value = line.Substring(text.Length);
			return true;
		}

		private static bool IsValidTicks(long ticks)
		{
			if (ticks >= 621355968000000000L)
			{
				DateTime maxValue = DateTime.MaxValue;
				return ticks <= maxValue.Ticks;
			}
			return false;
		}

		private static string Bound(string value, int maximum)
		{
			string text = (value ?? string.Empty).Replace("\r", " ").Replace("\n", " ").Replace("=", "-")
				.Trim();
			if (text.Length > maximum)
			{
				return text.Substring(0, maximum);
			}
			return text;
		}

		private static string Escape(string value)
		{
			return (value ?? string.Empty).Replace("%", "%25").Replace("\n", "%0A").Replace("\r", "%0D")
				.Replace("=", "%3D");
		}

		private static bool TryUnescape(string value, out string result)
		{
			result = (value ?? string.Empty).Replace("%3D", "=").Replace("%0D", "\r").Replace("%0A", "\n")
				.Replace("%25", "%");
			if (result.IndexOf('\r') < 0)
			{
				return result.IndexOf('\n') < 0;
			}
			return false;
		}
	}
	internal struct SharedWindowPairLayout
	{
		public WindowFitResult QolMenu { get; }

		public WindowFitResult StyleHelper { get; }

		public SharedWindowPairLayout(WindowFitResult qolMenu, WindowFitResult styleHelper)
		{
			QolMenu = qolMenu;
			StyleHelper = styleHelper;
		}
	}
	internal static class SharedWindowLayoutPolicy
	{
		public const float PairGap = 10f;

		public const float SideBySideThreshold = 1200f;

		public static SharedWindowPairLayout CreatePair(float screenWidth, float screenHeight)
		{
			float num = 10f;
			float usableWidth = WindowFitPolicy.GetUsableWidth(screenWidth);
			float usableHeight = WindowFitPolicy.GetUsableHeight(screenHeight);
			if (usableWidth >= 1200f)
			{
				float num2 = Math.Max(1f, (usableWidth - 10f) / 2f);
				float num3 = Math.Min(720f, usableHeight);
				float y = Math.Max(num, (screenHeight - num3) / 2f);
				WindowFitResult qolMenu = new WindowFitResult(num, y, num2, num3);
				WindowFitResult styleHelper = new WindowFitResult(num + num2 + 10f, y, num2, num3);
				return new SharedWindowPairLayout(qolMenu, styleHelper);
			}
			float num4 = Math.Max(1f, (usableHeight - 10f) / 2f);
			WindowFitResult qolMenu2 = new WindowFitResult(num, num, usableWidth, num4);
			WindowFitResult styleHelper2 = new WindowFitResult(num, num + num4 + 10f, usableWidth, num4);
			return new SharedWindowPairLayout(qolMenu2, styleHelper2);
		}

		public static bool Overlaps(WindowFitResult first, WindowFitResult second)
		{
			if (first.X < second.X + second.Width && first.X + first.Width > second.X && first.Y < second.Y + second.Height)
			{
				return first.Y + first.Height > second.Y;
			}
			return false;
		}

		public static bool IsFullyVisible(WindowFitResult window, float screenWidth, float screenHeight)
		{
			float num = 10f;
			if (window.X >= num - 0.1f && window.Y >= num - 0.1f && window.X + window.Width <= screenWidth - num + 0.1f)
			{
				return window.Y + window.Height <= screenHeight - num + 0.1f;
			}
			return false;
		}
	}
	internal sealed class StatisticsPulseSnapshot
	{
		public string TotalFocusLabel { get; }

		public int TodaySessions { get; }

		public int CurrentStreak { get; }

		public int LongestStreak { get; }

		public int TaskChecks { get; }

		public string AchievementsLabel { get; }

		private StatisticsPulseSnapshot(string totalFocusLabel, int todaySessions, int currentStreak, int longestStreak, int taskChecks, string achievementsLabel)
		{
			TotalFocusLabel = totalFocusLabel;
			TodaySessions = todaySessions;
			CurrentStreak = currentStreak;
			LongestStreak = longestStreak;
			TaskChecks = taskChecks;
			AchievementsLabel = achievementsLabel;
		}

		public StatisticsPulseSnapshot WithAchievementProgress(int unlocked, int total)
		{
			return new StatisticsPulseSnapshot(TotalFocusLabel, TodaySessions, CurrentStreak, LongestStreak, TaskChecks, $"{Math.Max(0, unlocked)} / {Math.Max(0, total)}");
		}

		public static bool TryCreate(float totalFocusSeconds, int todaySessions, int currentStreak, int longestStreak, int taskChecks, int? achievementsUnlocked, int? achievementsTotal, out StatisticsPulseSnapshot? snapshot)
		{
			snapshot = null;
			if (float.IsNaN(totalFocusSeconds) || float.IsInfinity(totalFocusSeconds) || totalFocusSeconds < 0f)
			{
				return false;
			}
			int num = (int)Math.Floor(totalFocusSeconds / 60f);
			string achievementsLabel = ((achievementsUnlocked.HasValue && achievementsTotal.HasValue) ? $"{Math.Max(0, achievementsUnlocked.Value)} / {Math.Max(0, achievementsTotal.Value)}" : "Press Refresh to count");
			snapshot = new StatisticsPulseSnapshot($"{num / 60}h {num % 60:00}m", Math.Max(0, todaySessions), Math.Max(0, currentStreak), Math.Max(0, longestStreak), Math.Max(0, taskChecks), achievementsLabel);
			return true;
		}
	}
	internal static class StatisticsTypeResolutionPolicy
	{
		private static readonly string[] RequiredGlobalTypes = new string[4] { "StatisticsData", "DataManager", "AchievementManager", "Achievement" };

		public static bool IsExactGameSurface(string? assemblySimpleName, Func<string, bool>? hasGlobalType)
		{
			if (!string.Equals(assemblySimpleName, "Assembly-CSharp", StringComparison.Ordinal) || hasGlobalType == null)
			{
				return false;
			}
			try
			{
				string[] requiredGlobalTypes = RequiredGlobalTypes;
				foreach (string arg in requiredGlobalTypes)
				{
					if (!hasGlobalType(arg))
					{
						return false;
					}
				}
				return true;
			}
			catch
			{
				return false;
			}
		}
	}
	internal static class StatusSuffixPolicy
	{
		internal static string Build(string statusMessage, string statusColor, string statusBrackets)
		{
			string text = (statusMessage ?? string.Empty).Trim();
			if (string.IsNullOrWhiteSpace(text))
			{
				return string.Empty;
			}
			string text2 = statusBrackets ?? "()";
			if (text2.Length < 2)
			{
				text2 = "()";
			}
			string hex;
			return RichTextStyleBuilder.BuildColorTag(RichTextStyleBuilder.TryNormalizeHex(statusColor, out hex) ? hex : "FFD45D", text2.Substring(0, 1) + text + text2.Substring(1, 1));
		}
	}
	internal sealed class StewardAnnouncementEnvelope
	{
		internal static readonly StewardAnnouncementEnvelope Empty = new StewardAnnouncementEnvelope(string.Empty, string.Empty, 0L, string.Empty, string.Empty, string.Empty, string.Empty, string.Empty);

		internal string Version { get; }

		internal string KeyId { get; }

		internal long IssuedUtcTicks { get; }

		internal string Nonce { get; }

		internal string MessageId { get; }

		internal string LobbyToken { get; }

		internal string Text { get; }

		internal string Mac { get; }

		internal StewardAnnouncementEnvelope(string version, string keyId, long issuedUtcTicks, string nonce, string messageId, string lobbyToken, string text, string mac)
		{
			Version = version ?? string.Empty;
			KeyId = keyId ?? string.Empty;
			IssuedUtcTicks = issuedUtcTicks;
			Nonce = nonce ?? string.Empty;
			MessageId = messageId ?? string.Empty;
			LobbyToken = lobbyToken ?? string.Empty;
			Text = text ?? string.Empty;
			Mac = mac ?? string.Empty;
		}
	}
	internal sealed class StewardAnnouncementKeyRing
	{
		internal static readonly StewardAnnouncementKeyRing Empty = new StewardAnnouncementKeyRing(string.Empty, null, string.Empty, null, 0L);

		private readonly byte[]? _currentKey;

		private readonly byte[]? _previousKey;

		internal string CurrentKeyId { get; }

		internal string PreviousKeyId { get; }

		internal long PreviousValidFromUtcTicks { get; }

		internal long PreviousValidUntilUtcTicks { get; }

		internal bool HasCurrentKey
		{
			get
			{
				if (_currentKey != null)
				{
					return _currentKey.Length >= 32;
				}
				return false;
			}
		}

		internal StewardAnnouncementKeyRing(string currentKeyId, byte[]? currentKey, string previousKeyId, byte[]? previousKey, long previousValidUntilUtcTicks)
			: this(currentKeyId, currentKey, previousKeyId, previousKey, (previousValidUntilUtcTicks > TimeSpan.FromMinutes(5.0).Ticks) ? (previousValidUntilUtcTicks - TimeSpan.FromMinutes(5.0).Ticks) : 0, previousValidUntilUtcTicks)
		{
		}

		internal StewardAnnouncementKeyRing(string currentKeyId, byte[]? currentKey, string previousKeyId, byte[]? previousKey, long previousValidFromUtcTicks, long previousValidUntilUtcTicks)
		{
			CurrentKeyId = currentKeyId ?? string.Empty;
			PreviousKeyId = previousKeyId ?? string.Empty;
			PreviousValidFromUtcTicks = previousValidFromUtcTicks;
			PreviousValidUntilUtcTicks = previousValidUntilUtcTicks;
			_currentKey = CloneKey(currentKey);
			_previousKey = CloneKey(previousKey);
		}

		internal bool TryResolve(string keyId, long nowUtcTicks, out byte[] key)
		{
			key = Array.Empty<byte>();
			if (HasCurrentKey && string.Equals(keyId, CurrentKeyId, StringComparison.Ordinal))
			{
				key = (byte[])_currentKey.Clone();
				return true;
			}
			if (_previousKey != null && _previousKey.Length >= 32 && !string.IsNullOrEmpty(PreviousKeyId) && string.Equals(keyId, PreviousKeyId, StringComparison.Ordinal) && nowUtcTicks >= PreviousValidFromUtcTicks && PreviousValidUntilUtcTicks >= PreviousValidFromUtcTicks && PreviousValidUntilUtcTicks - PreviousValidFromUtcTicks <= TimeSpan.FromMinutes(5.0).Ticks && nowUtcTicks <= PreviousValidUntilUtcTicks)
			{
				key = (byte[])_previousKey.Clone();
				return true;
			}
			return false;
		}

		internal void ClearSecrets()
		{
			if (_currentKey != null)
			{
				Array.Clear(_currentKey, 0, _currentKey.Length);
			}
			if (_previousKey != null)
			{
				Array.Clear(_previousKey, 0, _previousKey.Length);
			}
		}

		private static byte[]? CloneKey(byte[]? value)
		{
			if (value != null)
			{
				return (byte[])value.Clone();
			}
			return null;
		}
	}
	internal sealed class StewardAnnouncementContext
	{
		internal bool BridgeEnabled { get; }

		internal bool IsWindows { get; }

		internal bool ShutdownStarted { get; }

		internal bool SteamOwnerMatchesLocal { get; }

		internal bool PurrNetHost { get; }

		internal bool GlobalNotificationReady { get; }

		internal string ExpectedBuildIdentity { get; }

		internal string CurrentLobbyToken { get; }

		internal long NowUtcTicks { get; }

		internal StewardAnnouncementContext(bool BridgeEnabled, bool IsWindows, bool ShutdownStarted, bool SteamOwnerMatchesLocal, bool PurrNetHost, bool GlobalNotificationReady, string ExpectedBuildIdentity, string CurrentLobbyToken, long NowUtcTicks)
		{
			this.BridgeEnabled = BridgeEnabled;
			this.IsWindows = IsWindows;
			this.ShutdownStarted = ShutdownStarted;
			this.SteamOwnerMatchesLocal = SteamOwnerMatchesLocal;
			this.PurrNetHost = PurrNetHost;
			this.GlobalNotificationReady = GlobalNotificationReady;
			this.ExpectedBuildIdentity = ExpectedBuildIdentity ?? string.Empty;
			this.CurrentLobbyToken = CurrentLobbyToken ?? string.Empty;
			this.NowUtcTicks = NowUtcTicks;
		}

		internal StewardAnnouncementContext With(bool? bridgeEnabled = null, bool? isWindows = null, bool? shutdownStarted = null, bool? steamOwnerMatchesLocal = null, bool? purrNetHost = null, bool? globalNotificationReady = null, string? expectedBuildIdentity = null, string? currentLobbyToken = null, long? nowUtcTicks = null)
		{
			return new StewardAnnouncementContext(bridgeEnabled ?? BridgeEnabled, isWindows ?? IsWindows, shutdownStarted ?? ShutdownStarted, steamOwnerMatchesLocal ?? SteamOwnerMatchesLocal, purrNetHost ?? PurrNetHost, globalNotificationReady ?? GlobalNotificationReady, expectedBuildIdentity ?? ExpectedBuildIdentity, currentLobbyToken ?? CurrentLobbyToken, nowUtcTicks ?? NowUtcTicks);
		}
	}
	internal sealed class StewardAnnouncementReplayCache
	{
		private sealed class Entry
		{
			internal string NonceFingerprint = string.Empty;

			internal string MessageFingerprint = string.Empty;

			internal long ExpiresUtcTicks;
		}

		internal const int MaximumEntries = 4096;

		internal const int RetentionMinutes = 10;

		private readonly List<Entry> _entries = new List<Entry>();

		internal int Count => _entries.Count;

		internal bool IsReplay(string nonce, string messageId, long nowUtcTicks)
		{
			Prune(nowUtcTicks);
			string nonceFingerprint = StewardAnnouncementPolicy.FingerprintValue(nonce);
			string messageFingerprint = StewardAnnouncementPolicy.FingerprintValue(messageId);
			return _entries.Any((Entry entry) => string.Equals(entry.NonceFingerprint, nonceFingerprint, StringComparison.Ordinal) || string.Equals(entry.MessageFingerprint, messageFingerprint, StringComparison.Ordinal));
		}

		internal void Remember(string nonce, string messageId, long nowUtcTicks)
		{
			Prune(nowUtcTicks);
			string nonceFingerprint = StewardAnnouncementPolicy.FingerprintValue(nonce);
			string messageFingerprint = StewardAnnouncementPolicy.FingerprintValue(messageId);
			if (!_entries.Any((Entry entry) => string.Equals(entry.NonceFingerprint, nonceFingerprint, StringComparison.Ordinal) || string.Equals(entry.MessageFingerprint, messageFingerprint, StringComparison.Ordinal)))
			{
				_entries.Add(new Entry
				{
					NonceFingerprint = nonceFingerprint,
					MessageFingerprint = messageFingerprint,
					ExpiresUtcTicks = nowUtcTicks + TimeSpan.FromMinutes(10.0).Ticks
				});
				while (_entries.Count > 4096)
				{
					_entries.RemoveAt(0);
				}
			}
		}

		internal string Export(long nowUtcTicks)
		{
			Prune(nowUtcTicks);
			StringBuilder stringBuilder = new StringBuilder(64 + _entries.Count * 150);
			stringBuilder.Append("schema=1\n");
			foreach (Entry entry in _entries)
			{
				stringBuilder.Append(entry.ExpiresUtcTicks.ToString(CultureInfo.InvariantCulture)).Append('|').Append(entry.NonceFingerprint)
					.Append('|')
					.Append(entry.MessageFingerprint)
					.Append('\n');
			}
			return stringBuilder.ToString();
		}

		internal bool Import(string serialized, long nowUtcTicks)
		{
			_entries.Clear();
			string[] array = (serialized ?? string.Empty).Replace("\r\n", "\n").Split(new char[1] { '\n' });
			if (array.Length == 0 || !string.Equals(array[0], "schema=1", StringComparison.Ordinal) || array.Length > 4098)
			{
				return false;
			}
			for (int i = 1; i < array.Length; i++)
			{
				if (array[i].Length == 0)
				{
					continue;
				}
				string[] array2 = array[i].Split(new char[1] { '|' });
				if (array2.Length != 3 || !long.TryParse(array2[0], NumberStyles.None, CultureInfo.InvariantCulture, out var result) || !StewardAnnouncementPolicy.IsLowerHex(array2[1], 64) || !StewardAnnouncementPolicy.IsLowerHex(array2[2], 64))
				{
					_entries.Clear();
					return false;
				}
				if (result > nowUtcTicks)
				{
					if (result > nowUtcTicks + TimeSpan.FromMinutes(10.0).Ticks)
					{
						_entries.Clear();
						return false;
					}
					_entries.Add(new Entry
					{
						ExpiresUtcTicks = result,
						NonceFingerprint = array2[1],
						MessageFingerprint = array2[2]
					});
				}
			}
			while (_entries.Count > 4096)
			{
				_entries.RemoveAt(0);
			}
			return true;
		}

		private void Prune(long nowUtcTicks)
		{
			_entries.RemoveAll((Entry entry) => entry.ExpiresUtcTicks <= nowUtcTicks);
		}
	}
	internal sealed class StewardAnnouncementRateLimiter
	{
		internal const int ImmediateLimit = 2;

		internal const int RollingMinuteLimit = 5;

		internal const int ImmediateWindowSeconds = 2;

		private readonly Queue<long> _acceptedUtcTicks = new Queue<long>();

		internal bool TryConsume(long nowUtcTicks)
		{
			long num = nowUtcTicks - TimeSpan.FromMinutes(1.0).Ticks;
			while (_acceptedUtcTicks.Count > 0 && _acceptedUtcTicks.Peek() <= num)
			{
				_acceptedUtcTicks.Dequeue();
			}
			if (_acceptedUtcTicks.Count >= 5)
			{
				return false;
			}
			long immediateCutoff = nowUtcTicks - TimeSpan.FromSeconds(2.0).Ticks;
			if (_acceptedUtcTicks.Count((long accepted) => accepted > immediateCutoff) >= 2)
			{
				return false;
			}
			_acceptedUtcTicks.Enqueue(nowUtcTicks);
			return true;
		}
	}
	internal static class StewardAnnouncementPolicy
	{
		internal const string PipeName = "BlueSage.OnTogether.Steward.v1";

		internal const int MaximumPayloadBytes = 2048;

		internal const int MaximumAnnouncementCharacters = 320;

		internal const int MinimumKeyBytes = 32;

		internal const int MaximumClockSkewSeconds = 30;

		internal const int PreviousKeyGraceMinutes = 5;

		private const string TimestampFormat = "yyyy-MM-dd'T'HH:mm:ss'Z'";

		private static readonly UTF8Encoding StrictUtf8 = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true);

		internal static bool TryBuildSignedPayload(string version, string keyId, long issuedUtcTicks, string nonce, string messageId, string lobbyToken, string text, byte[] key, out byte[] payload, out string error)
		{
			payload = Array.Empty<byte>();
			error = string.Empty;
			StewardAnnouncementEnvelope stewardAnnouncementEnvelope = new StewardAnnouncementEnvelope(version, keyId, issuedUtcTicks, nonce, messageId, lobbyToken, text, string.Empty);
			if (!ValidateFields(stewardAnnouncementEnvelope, requireMac: false, out error) || key == null || key.Length < 32)
			{
				if (error.Length == 0)
				{
					error = "Signing key is missing or shorter than 32 bytes.";
				}
				return false;
			}
			string mac = ComputeMac(StrictUtf8.GetBytes(Serialize(stewardAnnouncementEnvelope, includeMac: false)), key);
			payload = StrictUtf8.GetBytes(Serialize(new StewardAnnouncementEnvelope(stewardAnnouncementEnvelope.Version, stewardAnnouncementEnvelope.KeyId, stewardAnnouncementEnvelope.IssuedUtcTicks, stewardAnnouncementEnvelope.Nonce, stewardAnnouncementEnvelope.MessageId, stewardAnnouncementEnvelope.LobbyToken, stewardAnnouncementEnvelope.Text, mac), includeMac: true));
			if (payload.Length > 2048)
			{
				payload = Array.Empty<byte>();
				error = "Announcement payload exceeds 2,048 UTF-8 bytes.";
				return false;
			}
			return true;
		}

		internal static bool TryParse(byte[] payload, out StewardAnnouncementEnvelope envelope, out string error)
		{
			envelope = StewardAnnouncementEnvelope.Empty;
			error = string.Empty;
			if (payload == null || payload.Length == 0 || payload.Length > 2048)
			{
				error = "Announcement payload length is outside the accepted range.";
				return false;
			}
			string text;
			try
			{
				text = StrictUtf8.GetString(payload);
			}
			catch
			{
				error = "Announcement payload is not strict UTF-8.";
				return false;
			}
			int offset = 0;
			if (!Take(text, ref offset, "{\"version\":") || !ReadJsonString(text, ref offset, out string value) || !Take(text, ref offset, ",\"keyId\":") || !ReadJsonString(text, ref offset, out string value2) || !Take(text, ref offset, ",\"issuedUtc\":") || !ReadJsonString(text, ref offset, out string value3) || !Take(text, ref offset, ",\"nonce\":") || !ReadJsonString(text, ref offset, out string value4) || !Take(text, ref offset, ",\"messageId\":") || !ReadJsonString(text, ref offset, out string value5) || !Take(text, ref offset, ",\"lobbyToken\":") || !ReadJsonString(text, ref offset, out string value6) || !Take(text, ref offset, ",\"text\":") || !ReadJsonString(text, ref offset, out string value7) || !Take(text, ref offset, ",\"mac\":") || !ReadJsonString(text, ref offset, out string value8) || !Take(text, ref offset, "}") || offset != text.Length || !DateTime.TryParseExact(value3, "yyyy-MM-dd'T'HH:mm:ss'Z'", CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeUniversal, out var result))
			{
				error = "Announcement JSON is not the exact canonical fixed-field schema.";
				return false;
			}
			envelope = new StewardAnnouncementEnvelope(value, value2, result.Ticks, value4, value5, value6, value7, value8);
			if (!ValidateFields(envelope, requireMac: true, out error) || !string.Equals(text, Serialize(envelope, includeMac: true), StringComparison.Ordinal))
			{
				envelope = StewardAnnouncementEnvelope.Empty;
				if (error.Length == 0)
				{
					error = "Announcement JSON is not canonical.";
				}
				return false;
			}
			return true;
		}

		internal static bool TryAuthenticate(byte[] payload, string expectedBuildIdentity, long nowUtcTicks, StewardAnnouncementKeyRing keys, out StewardAnnouncementEnvelope envelope, out string error)
		{
			if (!TryParse(payload, out envelope, out error))
			{
				return false;
			}
			if (!string.Equals(envelope.Version, expectedBuildIdentity, StringComparison.Ordinal))
			{
				error = "Announcement build identity does not match this receiver.";
				envelope = StewardAnnouncementEnvelope.Empty;
				return false;
			}
			if (Math.Abs(nowUtcTicks - envelope.IssuedUtcTicks) > TimeSpan.FromSeconds(30.0).Ticks)
			{
				error = "Announcement timestamp is outside the 30-second clock window.";
				envelope = StewardAnnouncementEnvelope.Empty;
				return false;
			}
			if (keys == null || !keys.TryResolve(envelope.KeyId, nowUtcTicks, out byte[] key))
			{
				error = "Announcement key is unavailable, unknown, or outside its rotation grace.";
				envelope = StewardAnnouncementEnvelope.Empty;
				return false;
			}
			byte[] expected = HexToBytes(ComputeMac(StrictUtf8.GetBytes(Serialize(envelope, includeMac: false)), key));
			byte[] supplied = HexToBytes(envelope.Mac);
			if (!FixedTimeEquals(expected, supplied))
			{
				error = "Announcement authentication failed.";
				envelope = StewardAnnouncementEnvelope.Empty;
				return false;
			}
			return true;
		}

		internal static bool TryAuthorize(StewardAnnouncementEnvelope envelope, StewardAnnouncementContext context, StewardAnnouncementReplayCache replay, StewardAnnouncementRateLimiter rate, out string safeText, out string error)
		{
			safeText = string.Empty;
			error = string.Empty;
			if (envelope == null || context == null || replay == null || rate == null)
			{
				error = "Announcement authorization state is unavailable.";
				return false;
			}
			if (!context.BridgeEnabled || !context.IsWindows || context.ShutdownStarted)
			{
				error = "Announcement bridge is disabled, unsupported, or shutting down.";
				return false;
			}
			if (!context.SteamOwnerMatchesLocal || !context.PurrNetHost || !context.GlobalNotificationReady)
			{
				error = "Announcement destination is not the exact current Host-owned Global notification surface.";
				return false;
			}
			if (!string.Equals(envelope.Version, context.ExpectedBuildIdentity, StringComparison.Ordinal) || !string.Equals(envelope.LobbyToken, context.CurrentLobbyToken, StringComparison.Ordinal) || string.IsNullOrEmpty(context.CurrentLobbyToken))
			{
				error = "Announcement build or lobby identity is stale or split.";
				return false;
			}
			if (replay.IsReplay(envelope.Nonce, envelope.MessageId, context.NowUtcTicks))
			{
				error = "Announcement nonce or message was already accepted.";
				return false;
			}
			if (!rate.TryConsume(context.NowUtcTicks))
			{
				error = "Announcement rate limit is active.";
				return false;
			}
			safeText = SanitizeAnnouncement(envelope.Text);
			if (safeText.Length == 0)
			{
				error = "Announcement text is empty after safety filtering.";
				return false;
			}
			replay.Remember(envelope.Nonce, envelope.MessageId, context.NowUtcTicks);
			return true;
		}

		internal static string FingerprintLobby(string rawLobbyIdentity, string buildIdentity)
		{
			return FingerprintValue((buildIdentity ?? string.Empty) + "\n" + (rawLobbyIdentity ?? string.Empty)).Substring(0, 32);
		}

		internal static string FingerprintValue(string value)
		{
			using SHA256 sHA = SHA256.Create();
			return ToLowerHex(sHA.ComputeHash(StrictUtf8.GetBytes(value ?? string.Empty)));
		}

		internal static bool IsLowerHex(string value, int length)
		{
			if (value == null || value.Length != length)
			{
				return false;
			}
			foreach (char c in value)
			{
				if ((c < '0' || c > '9') && (c < 'a' || c > 'f'))
				{
					return false;
				}
			}
			return true;
		}

		private static string SanitizeAnnouncement(string value)
		{
			StringBuilder stringBuilder = new StringBuilder(Math.Min((value ?? string.Empty).Length, 320));
			bool flag = false;
			string text = value ?? string.Empty;
			foreach (char c in text)
			{
				if (char.IsControl(c) || char.IsWhiteSpace(c))
				{
					if (stringBuilder.Length > 0 && !flag)
					{
						stringBuilder.Append(' ');
					}
					flag = true;
					continue;
				}
				flag = false;
				switch (c)
				{
				case '&':
					stringBuilder.Append("&amp;");
					break;
				case '<':
					stringBuilder.Append("&lt;");
					break;
				case '>':
					stringBuilder.Append("&gt;");
					break;
				default:
					stringBuilder.Append(c);
					break;
				}
				if (stringBuilder.Length >= 320)
				{
					break;
				}
			}
			return stringBuilder.ToString().Trim();
		}

		private static bool ValidateFields(StewardAnnouncementEnvelope envelope, bool requireMac, out string error)
		{
			error = string.Empty;
			if (Bounded(envelope.Version, 1, 128) && BoundedAsciiToken(envelope.KeyId, 1, 64) && BoundedAsciiToken(envelope.Nonce, 12, 128) && Bounded(envelope.MessageId, 1, 128) && BoundedAsciiToken(envelope.LobbyToken, 1, 128) && Bounded(envelope.Text, 1, 512) && envelope.IssuedUtcTicks >= 621355968000000000L)
			{
				long issuedUtcTicks = envelope.IssuedUtcTicks;
				DateTime maxValue = DateTime.MaxValue;
				if (issuedUtcTicks <= maxValue.Ticks && !HasInvalidUnicode(envelope.Version) && !HasInvalidUnicode(envelope.MessageId) && !HasInvalidUnicode(envelope.Text))
				{
					if (requireMac && !IsLowerHex(envelope.Mac, 64))
					{
						error = "Announcement MAC is not canonical lowercase SHA-256 hex.";
						return false;
					}
					return true;
				}
			}
			error = "Announcement contains an invalid or out-of-range fixed field.";
			return false;
		}

		private static bool Bounded(string value, int minimum, int maximum)
		{
			if (value != null && value.Length >= minimum)
			{
				return value.Length <= maximum;
			}
			return false;
		}

		private static bool BoundedAsciiToken(string value, int minimum, int maximum)
		{
			if (!Bounded(value, minimum, maximum))
			{
				return false;
			}
			foreach (char c in value)
			{
				if ((c < 'a' || c > 'z') && (c < 'A' || c > 'Z') && (c < '0' || c > '9') && c != '-' && c != '_' && c != '.')
				{
					return false;
				}
			}
			return true;
		}

		private static bool HasInvalidUnicode(string value)
		{
			string text = value ?? string.Empty;
			for (int i = 0; i < text.Length; i++)
			{
				char c = text[i];
				if (char.IsSurrogate(c))
				{
					if (!char.IsHighSurrogate(c) || i + 1 >= text.Length || !char.IsLowSurrogate(text[i + 1]))
					{
						return true;
					}
					i++;
				}
			}
			return false;
		}

		private static string Serialize(StewardAnnouncementEnvelope envelope, bool includeMac)
		{
			string value = new DateTime(envelope.IssuedUtcTicks, DateTimeKind.Utc).ToString("yyyy-MM-dd'T'HH:mm:ss'Z'", CultureInfo.InvariantCulture);
			StringBuilder stringBuilder = new StringBuilder(512).Append("{\"version\":").Append(JsonString(envelope.Version)).Append(",\"keyId\":")
				.Append(JsonString(envelope.KeyId))
				.Append(",\"issuedUtc\":")
				.Append(JsonString(value))
				.Append(",\"nonce\":")
				.Append(JsonString(envelope.Nonce))
				.Append(",\"messageId\":")
				.Append(JsonString(envelope.MessageId))
				.Append(",\"lobbyToken\":")
				.Append(JsonString(envelope.LobbyToken))
				.Append(",\"text\":")
				.Append(JsonString(envelope.Text));
			if (includeMac)
			{
				stringBuilder.Append(",\"mac\":").Append(JsonString(envelope.Mac));
			}
			return stringBuilder.Append('}').ToString();
		}

		private static string JsonString(string value)
		{
			StringBuilder stringBuilder = new StringBuilder((value ?? string.Empty).Length + 2).Append('"');
			string text = value ?? string.Empty;
			foreach (char c in text)
			{
				switch (c)
				{
				case '"':
					stringBuilder.Append("\\\"");
					continue;
				case '\\':
					stringBuilder.Append("\\\\");
					continue;
				case '\b':
					stringBuilder.Append("\\b");
					continue;
				case '\f':
					stringBuilder.Append("\\f");
					continue;
				case '\n':
					stringBuilder.Append("\\n");
					continue;
				case '\r':
					stringBuilder.Append("\\r");
					continue;
				case '\t':
					stringBuilder.Append("\\t");
					continue;
				}
				if (c < ' ')
				{
					StringBuilder stringBuilder2 = stringBuilder.Append("\\u");
					int num = c;
					stringBuilder2.Append(num.ToString("x4", CultureInfo.InvariantCulture));
				}
				else
				{
					stringBuilder.Append(c);
				}
			}
			return stringBuilder.Append('"').ToString();
		}

		private static bool Take(string text, ref int offset, string expected)
		{
			if (offset + expected.Length > text.Length || !string.Equals(text.Substring(offset, expected.Length), expected, StringComparison.Ordinal))
			{
				return false;
			}
			offset += expected.Length;
			return true;
		}

		private static bool ReadJsonString(string text, ref int offset, out string value)
		{
			value = string.Empty;
			if (offset >= text.Length || text[offset] != '"')
			{
				return false;
			}
			offset++;
			StringBuilder stringBuilder = new StringBuilder();
			while (offset < text.Length)
			{
				char c = text[offset++];
				if (c == '"')
				{
					value = stringBuilder.ToString();
					return !HasInvalidUnicode(value);
				}
				if (c < ' ')
				{
					return false;
				}
				if (c != '\\')
				{
					stringBuilder.Append(c);
					continue;
				}
				if (offset >= text.Length)
				{
					return false;
				}
				switch (text[offset++])
				{
				case '"':
					stringBuilder.Append('"');
					break;
				case '\\':
					stringBuilder.Append('\\');
					break;
				case '/':
					stringBuilder.Append('/');
					break;
				case 'b':
					stringBuilder.Append('\b');
					break;
				case 'f':
					stringBuilder.Append('\f');
					break;
				case 'n':
					stringBuilder.Append('\n');
					break;
				case 'r':
					stringBuilder.Append('\r');
					break;
				case 't':
					stringBuilder.Append('\t');
					break;
				case 'u':
				{
					if (offset + 4 > text.Length || !ushort.TryParse(text.Substring(offset, 4), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var result))
					{
						return false;
					}
					stringBuilder.Append((char)result);
					offset += 4;
					break;
				}
				default:
					return false;
				}
			}
			return false;
		}

		private static string ComputeMac(byte[] bytes, byte[] key)
		{
			using HMACSHA256 hMACSHA = new HMACSHA256(key);
			return ToLowerHex(hMACSHA.ComputeHash(bytes));
		}

		private static bool FixedTimeEquals(byte[] expected, byte[] supplied)
		{
			if (expected == null || supplied == null)
			{
				return false;
			}
			int num = expected.Length ^ supplied.Length;
			int num2 = Math.Max(expected.Length, supplied.Length);
			for (int i = 0; i < num2; i++)
			{
				byte b = (byte)((i < expected.Length) ? expected[i] : 0);
				byte b2 = (byte)((i < supplied.Length) ? supplied[i] : 0);
				num |= b ^ b2;
			}
			return num == 0;
		}

		private static string ToLowerHex(byte[] bytes)
		{
			StringBuilder stringBuilder = new StringBuilder(bytes.Length * 2);
			foreach (byte b in bytes)
			{
				stringBuilder.Append(b.ToString("x2", CultureInfo.InvariantCulture));
			}
			return stringBuilder.ToString();
		}

		private static byte[] HexToBytes(string value)
		{
			if (!IsLowerHex(value, 64))
			{
				return Array.Empty<byte>();
			}
			byte[] array = new byte[value.Length / 2];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = byte.Parse(value.Substring(i * 2, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture);
			}
			return array;
		}
	}
	internal sealed class DetectedDisplayNameState
	{
		public string BaseName { get; set; } = string.Empty;

		public string StatusMessage { get; set; } = string.Empty;

		public string StatusColor { get; set; } = "FFD45D";

		public bool SpoonsEnabled { get; set; }

		public int SpoonCount { get; set; } = 5;

		public string SpoonLabel { get; set; } = "sp";

		public bool RepairedLegacyMarkup { get; set; }

		public bool UsedPlainTextFallback { get; set; }

		public string DriftSummary { get; set; } = string.Empty;
	}
	internal static class StyleHelperNamePolicy
	{
		private static readonly Regex TrailingColorWrapperPattern = new Regex("^(?<base>.*)\\s(?:<\\s*#(?<short>[0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})\\s*>|<\\s*color\\s*=\\s*#?(?<long>[0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})\\s*>)(?<text>.*)</\\s*color\\s*>\\s*$", RegexOptions.IgnoreCase | RegexOptions.Compiled | RegexOptions.Singleline);

		private static readonly Regex SpoonTextPattern = new Regex("^\\[(?<count>[0-5])/5(?<label>[A-Za-z0-9_-]{1,12})\\]$", RegexOptions.Compiled);

		public static string ToPlainBaseNameForDetectCurrent(string liveDisplayName, string staleSavedBaseName, string knownStatusSuffix = "", string knownSpoonSuffix = "")
		{
			string text = RichTextStyleBuilder.ToPlainStyleEditorText(StripKnownSuffixesPreservingRichText(liveDisplayName, knownStatusSuffix, knownSpoonSuffix));
			if (!string.IsNullOrWhiteSpace(text))
			{
				return text.Trim();
			}
			return RichTextStyleBuilder.ToPlainStyleEditorText(staleSavedBaseName).Trim();
		}

		public static string ToStyledBaseNameForDetectCurrent(string liveDisplayName, string staleSavedBaseName, string knownStatusSuffix = "", string knownSpoonSuffix = "")
		{
			string value = StripKnownSuffixesPreservingRichText(liveDisplayName, knownStatusSuffix, knownSpoonSuffix);
			value = RichTextDraftPolicy.RepairLegacy(value).Value;
			if (!string.IsNullOrWhiteSpace(RichTextStyleBuilder.ToPlainStyleEditorText(value)))
			{
				return value;
			}
			return RichTextDraftPolicy.RepairLegacy(staleSavedBaseName).Value;
		}

		public static DetectedDisplayNameState DetectCurrentState(string liveDisplayName, string savedBaseName, string savedStatusMessage, string savedStatusColor, string savedStatusBrackets, bool savedSpoonsEnabled, int savedSpoonCount, string savedSpoonLabel, string knownStatusSuffix, string knownSpoonSuffix)
		{
			string text = (liveDisplayName ?? string.Empty).Trim();
			string text2 = (savedBaseName ?? string.Empty).Trim();
			string text3 = NormalizeHex(savedStatusColor, "FFD45D");
			string text4 = NormalizeSpoonLabel(savedSpoonLabel);
			bool flag = !string.IsNullOrWhiteSpace(text);
			string value = (flag ? text : text2);
			bool flag2 = false;
			int num = ClampSpoonCount(savedSpoonCount);
			string text5 = text4;
			if (flag && TryRemoveTrailingSpoons(ref value, out var count, out var label))
			{
				flag2 = true;
				num = count;
				text5 = label;
			}
			bool flag3 = false;
			string text6 = string.Empty;
			string text7 = text3;
			if (flag && TryRemoveTrailingStatus(ref value, text2, savedStatusMessage, text3, savedStatusBrackets, out var statusMessage, out var statusColor))
			{
				flag3 = true;
				text6 = statusMessage;
				text7 = statusColor;
			}
			string a;
			do
			{
				a = value;
				value = StripKnownSuffixesPreservingRichText(value, knownStatusSuffix, knownSpoonSuffix);
				TryRemoveTrailingSpoons(ref value, out var _, out var label2);
				TryRemoveTrailingStatus(ref value, text2, savedStatusMessage, text3, savedStatusBrackets, out label2, out var _);
			}
			while (!string.Equals(a, value, StringComparison.Ordinal));
			RichTextRepairResult richTextRepairResult = RichTextDraftPolicy.RepairLegacy(value);
			string value2 = richTextRepairResult.Value;
			if (string.IsNullOrWhiteSpace(RichTextStyleBuilder.ToPlainStyleEditorText(value2)))
			{
				RichTextRepairResult richTextRepairResult2 = RichTextDraftPolicy.RepairLegacy(text2);
				value2 = richTextRepairResult2.Value;
				richTextRepairResult = richTextRepairResult2;
			}
			List<string> list = new List<string>();
			if (flag && !string.Equals(value2, text2, StringComparison.Ordinal))
			{
				list.Add("live base differed from saved state");
			}
			string text8 = ((!flag) ? (savedStatusMessage ?? string.Empty).Trim() : (flag3 ? text6 : string.Empty));
			string statusColor3 = (flag3 ? text7 : text3);
			if (flag && !string.Equals(text8, (savedStatusMessage ?? string.Empty).Trim(), StringComparison.Ordinal))
			{
				list.Add("live status differed from saved state");
			}
			bool flag4 = (flag ? flag2 : savedSpoonsEnabled);
			int num2 = (flag2 ? num : ClampSpoonCount(savedSpoonCount));
			string text9 = (flag2 ? text5 : text4);
			if (flag && (flag4 != savedSpoonsEnabled || (flag4 && (num2 != ClampSpoonCount(savedSpoonCount) || !string.Equals(text9, text4, StringComparison.Ordinal)))))
			{
				list.Add("live Spoons differed from saved state");
			}
			if (richTextRepairResult.Changed)
			{
				list.Add(richTextRepairResult.UsedPlainTextFallback ? "legacy rich text fell back to visible text" : "legacy rich text was balanced");
			}
			return new DetectedDisplayNameState
			{
				BaseName = value2,
				StatusMessage = text8,
				StatusColor = statusColor3,
				SpoonsEnabled = flag4,
				SpoonCount = num2,
				SpoonLabel = text9,
				RepairedLegacyMarkup = richTextRepairResult.Changed,
				UsedPlainTextFallback = richTextRepairResult.UsedPlainTextFallback,
				DriftSummary = ((list.Count == 0) ? "Live and saved style state agree." : ("Reconciled: " + string.Join("; ", list) + "."))
			};
		}

		internal static string StripKnownSuffixesPreservingRichText(string displayName, string knownStatusSuffix, string knownSpoonSuffix)
		{
			string text = (displayName ?? string.Empty).Trim();
			string a;
			do
			{
				a = text;
				text = RemoveExactTrailingSuffix(text, knownSpoonSuffix);
				text = RemoveExactTrailingSuffix(text, knownStatusSuffix);
			}
			while (!string.Equals(a, text, StringComparison.Ordinal));
			return text.Trim();
		}

		private static string RemoveExactTrailingSuffix(string value, string suffix)
		{
			string text = (suffix ?? string.Empty).Trim();
			if (string.IsNullOrWhiteSpace(text))
			{
				return value;
			}
			string text2 = " " + text;
			if (!value.EndsWith(text2, StringComparison.Ordinal))
			{
				return value;
			}
			return value.Substring(0, value.Length - text2.Length).TrimEnd(Array.Empty<char>());
		}

		private static bool TryRemoveTrailingSpoons(ref string value, out int count, out string label)
		{
			count = 5;
			label = "sp";
			Match match = TrailingColorWrapperPattern.Match(value ?? string.Empty);
			if (!match.Success || !string.Equals(GetWrapperHex(match), "70FFBD", StringComparison.OrdinalIgnoreCase))
			{
				return false;
			}
			Match match2 = SpoonTextPattern.Match(match.Groups["text"].Value);
			if (!match2.Success || !int.TryParse(match2.Groups["count"].Value, out count))
			{
				return false;
			}
			label = NormalizeSpoonLabel(match2.Groups["label"].Value);
			value = match.Groups["base"].Value.TrimEnd(Array.Empty<char>());
			return true;
		}

		private static bool TryRemoveTrailingStatus(ref string value, string savedBaseName, string savedStatusMessage, string savedStatusColor, string savedStatusBrackets, out string statusMessage, out string statusColor)
		{
			statusMessage = string.Empty;
			statusColor = NormalizeHex(savedStatusColor, "FFD45D");
			Match match = TrailingColorWrapperPattern.Match(value ?? string.Empty);
			if (!match.Success)
			{
				return false;
			}
			if (!string.Equals(NormalizeHex(GetWrapperHex(match), string.Empty), statusColor, StringComparison.OrdinalIgnoreCase))
			{
				return false;
			}
			string obj = ((string.IsNullOrEmpty(savedStatusBrackets) || savedStatusBrackets.Length < 2) ? "()" : savedStatusBrackets);
			string value2 = match.Groups["text"].Value;
			string text = obj.Substring(0, 1);
			string text2 = obj.Substring(1, 1);
			if (!value2.StartsWith(text, StringComparison.Ordinal) || !value2.EndsWith(text2, StringComparison.Ordinal) || value2.Length < text.Length + text2.Length)
			{
				return false;
			}
			statusMessage = value2.Substring(text.Length, value2.Length - text.Length - text2.Length);
			if (string.IsNullOrWhiteSpace(savedStatusMessage) && !CanReachSavedBaseByRemovingMatchingStatusWrappers(match.Groups["base"].Value, savedBaseName, statusColor, text, text2))
			{
				statusMessage = string.Empty;
				return false;
			}
			value = match.Groups["base"].Value.TrimEnd(Array.Empty<char>());
			return true;
		}

		private static bool CanReachSavedBaseByRemovingMatchingStatusWrappers(string candidateBase, string savedBaseName, string statusColor, string prefix, string suffix)
		{
			string value = RichTextDraftPolicy.RepairLegacy(savedBaseName).Value;
			if (string.IsNullOrWhiteSpace(value))
			{
				return false;
			}
			string text = (candidateBase ?? string.Empty).TrimEnd(Array.Empty<char>());
			while (!string.IsNullOrWhiteSpace(text))
			{
				if (string.Equals(RichTextDraftPolicy.RepairLegacy(text).Value, value, StringComparison.Ordinal))
				{
					return true;
				}
				Match match = TrailingColorWrapperPattern.Match(text);
				if (!match.Success || !string.Equals(NormalizeHex(GetWrapperHex(match), string.Empty), statusColor, StringComparison.OrdinalIgnoreCase))
				{
					return false;
				}
				string value2 = match.Groups["text"].Value;
				if (!value2.StartsWith(prefix, StringComparison.Ordinal) || !value2.EndsWith(suffix, StringComparison.Ordinal) || value2.Length < prefix.Length + suffix.Length)
				{
					return false;
				}
				text = match.Groups["base"].Value.TrimEnd(Array.Empty<char>());
			}
			return false;
		}

		private static string GetWrapperHex(Match wrapper)
		{
			if (!wrapper.Groups["short"].Success)
			{
				return wrapper.Groups["long"].Value;
			}
			return wrapper.Groups["short"].Value;
		}

		private static string NormalizeHex(string value, string fallback)
		{
			string text = (value ?? string.Empty).Trim().TrimStart(new char[1] { '#' });
			if (text.Length == 3)
			{
				text = string.Concat(text[0], text[0], text[1], text[1], text[2], text[2]);
			}
			if (text.Length != 6 || !Regex.IsMatch(text, "^[0-9A-Fa-f]{6}$"))
			{
				return fallback;
			}
			return text.ToUpperInvariant();
		}

		private static int ClampSpoonCount(int value)
		{
			if (value >= 0)
			{
				if (value <= 5)
				{
					return value;
				}
				return 5;
			}
			return 0;
		}

		private static string NormalizeSpoonLabel(string value)
		{
			string text = Regex.Replace(value ?? string.Empty, "[^A-Za-z0-9_-]", string.Empty);
			if (text.Length > 12)
			{
				text = text.Substring(0, 12);
			}
			if (!string.IsNullOrWhiteSpace(text))
			{
				return text;
			}
			return "sp";
		}
	}
	internal sealed class SupporterTransaction
	{
		public string DateTimeUtc { get; }

		public string From { get; }

		public string Message { get; }

		public string Received { get; }

		public SupporterTransaction(string? dateTimeUtc, string? from, string? message, string? received)
		{
			DateTimeUtc = dateTimeUtc ?? string.Empty;
			From = from ?? string.Empty;
			Message = message ?? string.Empty;
			Received = received ?? string.Empty;
		}
	}
	internal sealed class SupporterIdentityRollup
	{
		public string Name { get; }

		public decimal TotalReceived { get; }

		public SupporterTransaction[] Transactions { get; }

		public int MessageCount { get; }

		public SupporterIdentityRollup(string name, decimal totalReceived, SupporterTransaction[] transactions, int messageCount)
		{
			Name = name;
			TotalReceived = totalReceived;
			Transactions = transactions;
			MessageCount = messageCount;
		}
	}
	internal static class SupporterLedgerPolicy
	{
		private sealed class RollupBuilder
		{
			private readonly List<SupporterTransaction> _transactions = new List<SupporterTransaction>();

			private decimal _totalReceived;

			private int _messageCount;

			public string Name { get; }

			public RollupBuilder(string name)
			{
				Name = name;
			}

			public void Add(SupporterTransaction transaction)
			{
				_transactions.Add(transaction);
				_totalReceived += ParseReceived(transaction.Received);
				if (!string.IsNullOrEmpty(transaction.Message))
				{
					_messageCount++;
				}
			}

			public SupporterIdentityRollup Build()
			{
				return new SupporterIdentityRollup(Name, _totalReceived, _transactions.ToArray(), _messageCount);
			}
		}

		public const string EmptyMessageLabel = "No public message was included.";

		public static SupporterIdentityRollup[] RollUp(SupporterTransaction[]? transactions)
		{
			if (transactions == null || transactions.Length == 0)
			{
				return new SupporterIdentityRollup[0];
			}
			List<RollupBuilder> list = new List<RollupBuilder>();
			Dictionary<string, RollupBuilder> dictionary = new Dictionary<string, RollupBuilder>(StringComparer.OrdinalIgnoreCase);
			foreach (SupporterTransaction supporterTransaction in transactions)
			{
				if (supporterTransaction != null)
				{
					string text = supporterTransaction.From ?? string.Empty;
					if (!dictionary.TryGetValue(text, out var value))
					{
						value = new RollupBuilder(text);
						dictionary.Add(text, value);
						list.Add(value);
					}
					value.Add(supporterTransaction);
				}
			}
			SupporterIdentityRollup[] array = new SupporterIdentityRollup[list.Count];
			for (int j = 0; j < list.Count; j++)
			{
				array[j] = list[j].Build();
			}
			return array;
		}

		public static int CountNonEmptyMessages(SupporterTransaction[]? transactions)
		{
			if (transactions == null)
			{
				return 0;
			}
			int num = 0;
			foreach (SupporterTransaction supporterTransaction in transactions)
			{
				if (supporterTransaction != null && !string.IsNullOrEmpty(supporterTransaction.Message))
				{
					num++;
				}
			}
			return num;
		}

		public static SupporterTransaction[] GetPublicMessages(SupporterIdentityRollup? supporter)
		{
			if (supporter == null || supporter.Transactions.Length == 0)
			{
				return new SupporterTransaction[0];
			}
			List<SupporterTransaction> list = new List<SupporterTransaction>();
			SupporterTransaction[] transactions = supporter.Transactions;
			foreach (SupporterTransaction supporterTransaction in transactions)
			{
				if (supporterTransaction != null && !string.IsNullOrWhiteSpace(supporterTransaction.Message))
				{
					list.Add(supporterTransaction);
				}
			}
			return list.ToArray();
		}

		public static decimal GetTotalReceived(SupporterTransaction[]? transactions)
		{
			if (transactions == null)
			{
				return 0m;
			}
			decimal result = default(decimal);
			foreach (SupporterTransaction supporterTransaction in transactions)
			{
				if (supporterTransaction != null)
				{
					result += ParseReceived(supporterTransaction.Received);
				}
			}
			return result;
		}

		public static string FormatReceived(decimal amount)
		{
			return "$" + amount.ToString("0.00", CultureInfo.InvariantCulture);
		}

		public static string FormatDateLabel(string? dateTimeUtc)
		{
			if (!string.IsNullOrWhiteSpace(dateTimeUtc))
			{
				return SanitizeForDisplay(dateTimeUtc);
			}
			return "Date not recorded";
		}

		public static string BuildTransactionHeading(SupporterTransaction? transaction)
		{
			if (transaction == null)
			{
				throw new ArgumentNullException("transaction");
			}
			return "♥ " + FormatDateLabel(transaction.DateTimeUtc) + " • " + SanitizeForDisplay(transaction.From) + " • " + FormatReceived(ParseReceived(transaction.Received));
		}

		public static string GetDisplayMessage(string? message)
		{
			if (!string.IsNullOrEmpty(message))
			{
				return SanitizeForDisplay(message);
			}
			return "No public message was included.";
		}

		public static string SanitizeForDisplay(string? value)
		{
			string text = value ?? string.Empty;
			if (text.Length == 0)
			{
				return string.Empty;
			}
			StringBuilder stringBuilder = new StringBuilder(text.Length);
			for (int i = 0; i < text.Length; i++)
			{
				char c = text[i];
				if (!char.IsControl(c))
				{
					stringBuilder.Append(c);
					if (c == '<' && i + 1 < text.Length && CouldStartRichTextTag(text[i + 1]))
					{
						stringBuilder.Append('\u200b');
					}
				}
			}
			return stringBuilder.ToString();
		}

		private static bool CouldStartRichTextTag(char character)
		{
			if (!char.IsLetter(character) && character != '/' && character != '#' && character != '!')
			{
				return character == '?';
			}
			return true;
		}

		private static decimal ParseReceived(string received)
		{
			if (decimal.TryParse(received, NumberStyles.AllowLeadingSign | NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out var result))
			{
				return result;
			}
			throw new FormatException("Supporter received amount is not a canonical decimal value.");
		}
	}
	internal readonly struct SweepMenuActionState
	{
		internal bool Enabled { get; }

		internal string Label { get; }

		internal string Tooltip { get; }

		internal SweepMenuActionState(bool enabled, string label, string tooltip)
		{
			Enabled = enabled;
			Label = label;
			Tooltip = tooltip;
		}
	}
	internal static class SweepMenuActionPolicy
	{
		internal static SweepMenuActionState Resolve(bool manualSweepAllowed)
		{
			if (!manualSweepAllowed)
			{
				return new SweepMenuActionState(enabled: false, "BlueSage Cleanup: Standby", "A compatibility guard currently blocks manual cleanup. Automatic Cleanup and the game's native cleanup settings are unchanged.");
			}
			return new SweepMenuActionState(enabled: true, "Run Cleanup Now", "Runs one local unused-asset cleanup now, even when Automatic Cleanup is off. It never deletes files, profiles, or mods and does not change the game's timer.");
		}

		internal static string BuildCompletionMessage(bool started)
		{
			if (!started)
			{
				return "Asset cleanup did not start because compatibility blocked cleanup or another cleanup is already in progress.";
			}
			return "Asset cleanup started.";
		}
	}
	internal sealed class SweepOperationGate
	{
		private int _lastSequence;

		internal bool IsRunning { get; private set; }

		internal int ActiveSequence { get; private set; }

		internal string ActiveReason { get; private set; } = string.Empty;

		internal bool TryStart(string reason, out int sequence)
		{
			if (IsRunning)
			{
				sequence = ActiveSequence;
				return false;
			}
			_lastSequence++;
			ActiveSequence = _lastSequence;
			ActiveReason = (string.IsNullOrWhiteSpace(reason) ? "unspecified" : reason.Trim());
			IsRunning = true;
			sequence = ActiveSequence;
			return true;
		}

		internal void Complete(int sequence)
		{
			if (IsRunning && sequence == ActiveSequence)
			{
				IsRunning = false;
				ActiveReason = string.Empty;
			}
		}
	}
	internal sealed class SweepResourceCategoryTotal
	{
		public string Category { get; }

		public int Count { get; }

		public long RuntimeBytes { get; }

		public SweepResourceCategoryTotal(string category, int count, long runtimeBytes)
		{
			Category = category ?? string.Empty;
			Count = count;
			RuntimeBytes = runtimeBytes;
		}
	}
	internal sealed class SweepResourceAssetFact
	{
		public int InstanceId { get; }

		public string Category { get; }

		public long RuntimeBytes { get; }

		public SweepResourceAssetFact(int instanceId, string category, long runtimeBytes)
		{
			InstanceId = instanceId;
			Category = category ?? string.Empty;
			RuntimeBytes = runtimeBytes;
		}
	}
	internal sealed class SweepResourceSnapshot
	{
		public bool Captured { get; set; }

		public string Status { get; set; } = "not-captured";

		public int SceneObjectCount { get; set; }

		public IReadOnlyList<SweepResourceCategoryTotal> Categories { get; set; } = Array.Empty<SweepResourceCategoryTotal>();

		public IReadOnlyList<SweepResourceAssetFact> Assets { get; set; } = Array.Empty<SweepResourceAssetFact>();

		public bool DetailTruncated { get; set; }

		public static SweepResourceSnapshot Unavailable(string exceptionType)
		{
			string text = (string.IsNullOrWhiteSpace(exceptionType) ? "Unknown" : exceptionType.Trim());
			return new SweepResourceSnapshot
			{
				Captured = false,
				Status = "unavailable:" + text
			};
		}
	}
	internal static class SweepResourceEvidenceFormatter
	{
		private const int MaximumReportedReclaimedAssets = 5;

		public static string Format(SweepResourceSnapshot? before, SweepResourceSnapshot? after)
		{
			if (before == null || !before.Captured)
			{
				return "resourceStatus=" + NormalizeUnavailableStatus(before?.Status);
			}
			if (after == null || !after.Captured)
			{
				return "resourceStatus=" + NormalizeUnavailableStatus(after?.Status);
			}
			Dictionary<string, SweepResourceCategoryTotal> beforeByCategory = ToCategoryMap(before.Categories);
			Dictionary<string, SweepResourceCategoryTotal> afterByCategory = ToCategoryMap(after.Categories);
			string[] array = beforeByCategory.Keys.Concat(afterByCategory.Keys).Distinct<string>(StringComparer.Ordinal).OrderBy(CategorySortOrder)
				.ThenBy<string, string>((string result) => result, StringComparer.Ordinal)
				.ToArray();
			string text = ((array.Length == 0) ? "none" : string.Join("|", array.Select((string category) => FormatCategory(category, GetTotal(beforeByCategory, category), GetTotal(afterByCategory, category)))));
			string text2 = "none";
			long num = 0L;
			string[] array2 = array;
			foreach (string text3 in array2)
			{
				long num3 = GetTotal(beforeByCategory, text3).RuntimeBytes - GetTotal(afterByCategory, text3).RuntimeBytes;
				if (num3 > num)
				{
					num = num3;
					text2 = text3 + "/" + FormatMiB(num3) + "MiB";
				}
			}
			HashSet<int> survivingIds = new HashSet<int>((after.Assets ?? Array.Empty<SweepResourceAssetFact>()).Select((SweepResourceAssetFact asset) => asset.InstanceId));
			SweepResourceAssetFact[] array3 = (from asset in before.Assets ?? Array.Empty<SweepResourceAssetFact>()
				where asset != null && !survivingIds.Contains(asset.InstanceId)
				orderby asset.RuntimeBytes descending
				select asset).ThenBy<SweepResourceAssetFact, string>((SweepResourceAssetFact asset) => asset.Category, StringComparer.Ordinal).ThenBy((SweepResourceAssetFact asset) => asset.InstanceId).Take(5)
				.ToArray();
			string text4 = ((array3.Length == 0) ? "none" : string.Join("|", array3.Select((SweepResourceAssetFact asset) => SanitizeToken(asset.Category, 24) + ":" + FormatMiB(asset.RuntimeBytes) + "MiB")));
			int value = after.SceneObjectCount - before.SceneObjectCount;
			return "resourceStatus=ok; sceneObjects=" + before.SceneObjectCount + "->" + after.SceneObjectCount + "(" + FormatSignedInt(value) + "); resources=" + text + "; dominantReclaimed=" + text2 + "; largestReclaimed=" + text4 + "; detailTruncated=" + ((before.DetailTruncated || after.DetailTruncated) ? "true" : "false");
		}

		private static Dictionary<string, SweepResourceCategoryTotal> ToCategoryMap(IReadOnlyList<SweepResourceCategoryTotal> totals)
		{
			Dictionary<string, SweepResourceCategoryTotal> dictionary = new Dictionary<string, SweepResourceCategoryTotal>(StringComparer.Ordinal);
			if (totals == null)
			{
				return dictionary;
			}
			foreach (SweepResourceCategoryTotal total in totals)
			{
				if (total != null && !string.IsNullOrWhiteSpace(total.Category))
				{
					dictionary[total.Category] = total;
				}
			}
			return dictionary;
		}

		private static SweepResourceCategoryTotal GetTotal(Dictionary<string, SweepResourceCategoryTotal> totals, string category)
		{
			if (totals.TryGetValue(category, out SweepResourceCategoryTotal value) && value != null)
			{
				return value;
			}
			return new SweepResourceCategoryTotal(category, 0, 0L);
		}

		private static string FormatCategory(string category, SweepResourceCategoryTotal before, SweepResourceCategoryTotal after)
		{
			return SanitizeToken(category, 24) + "=" + before.Count + "/" + FormatMiB(before.RuntimeBytes) + "MiB->" + after.Count + "/" + FormatMiB(after.RuntimeBytes) + "MiB(delta=" + FormatSignedInt(after.Count - before.Count) + "/" + FormatSignedMiB(after.RuntimeBytes - before.RuntimeBytes) + "MiB)";
		}

		private static string NormalizeUnavailableStatus(string? status)
		{
			if (string.IsNullOrWhiteSpace(status))
			{
				return "unavailable:Unknown";
			}
			string value = (status.StartsWith("unavailable:", StringComparison.Ordinal) ? status.Substring("unavailable:".Length) : status);
			return "unavailable:" + SanitizeToken(value, 80);
		}

		private static string SanitizeToken(string value, int maximumCharacters)
		{
			if (string.IsNullOrWhiteSpace(value))
			{
				return "(unnamed)";
			}
			StringBuilder stringBuilder = new StringBuilder(Math.Min(value.Length, maximumCharacters));
			string text = value.Trim();
			foreach (char c in text)
			{
				if (stringBuilder.Length >= maximumCharacters)
				{
					break;
				}
				if (char.IsControl(c))
				{
					if (stringBuilder.Length > 0 && stringBuilder[stringBuilder.Length - 1] != ' ')
					{
						stringBuilder.Append(' ');
					}
				}
				else
				{
					stringBuilder.Append((c == ';' || c == '|' || c == ':') ? '_' : c);
				}
			}
			string text2 = stringBuilder.ToString().Trim();
			if (text2.Length != 0)
			{
				return text2;
			}
			return "(unnamed)";
		}

		private static int CategorySortOrder(string category)
		{
			return category switch
			{
				"Texture2D" => 0, 
				"RenderTexture" => 1, 
				"Material" => 2, 
				"Mesh" => 3, 
				"AudioClip" => 4, 
				_ => 100, 
			};
		}

		private static string FormatSignedInt(int value)
		{
			if (value < 0)
			{
				return value.ToString(CultureInfo.InvariantCulture);
			}
			return "+" + value;
		}

		private static string FormatSignedMiB(long bytes)
		{
			double num = (double)bytes / 1048576.0;
			if (!(num >= 0.0))
			{
				return num.ToString("0.0", CultureInfo.InvariantCulture);
			}
			return "+" + num.ToString("0.0", CultureInfo.InvariantCulture);
		}

		private static string FormatMiB(long bytes)
		{
			return ((double)bytes / 1048576.0).ToString("0.0", CultureInfo.InvariantCulture);
		}
	}
	internal sealed class SweepSchedulePolicy
	{
		internal bool IsInitialized { get; private set; }

		internal double AnchorSeconds { get; private set; }

		internal double DueSeconds { get; private set; }

		internal int ConfiguredIntervalMinutes { get; private set; }

		internal void Start(double nowSeconds, int configuredMinutes)
		{
			int num = SweepSettingsPolicy.ClampIntervalMinutes(configuredMinutes);
			IsInitialized = true;
			AnchorSeconds = NormalizeNow(nowSeconds);
			DueSeconds = AnchorSeconds + (double)num * 60.0;
			ConfiguredIntervalMinutes = num;
		}

		internal void ReconcileInterval(double nowSeconds, int configuredMinutes)
		{
			int num = SweepSettingsPolicy.ClampIntervalMinutes(configuredMinutes);
			if (!IsInitialized)
			{
				Start(nowSeconds, num);
				return;
			}
			if (num < ConfiguredIntervalMinutes)
			{
				double val = AnchorSeconds + (double)num * 60.0;
				DueSeconds = Math.Min(DueSeconds, val);
			}
			ConfiguredIntervalMinutes = num;
		}

		internal bool IsDue(double nowSeconds)
		{
			if (IsInitialized)
			{
				return NormalizeNow(nowSeconds) >= DueSeconds;
			}
			return false;
		}

		internal void MarkAutomaticAttemptFinished(double nowSeconds, int configuredMinutes)
		{
			Start(nowSeconds, configuredMinutes);
		}

		internal void Reset()
		{
			IsInitialized = false;
			AnchorSeconds = 0.0;
			DueSeconds = 0.0;
			ConfiguredIntervalMinutes = 0;
		}

		private static double NormalizeNow(double nowSeconds)
		{
			if (!double.IsNaN(nowSeconds) && !double.IsInfinity(nowSeconds) && !(nowSeconds < 0.0))
			{
				return nowSeconds;
			}
			return 0.0;
		}
	}
	internal readonly struct SweepSessionSnapshot
	{
		internal bool Captured { get; }

		internal string Status { get; }

		internal long ProcessWorkingSetBytes { get; }

		internal long ProcessPrivateBytes { get; }

		internal int ProcessHandleCount { get; }

		internal int ProcessThreadCount { get; }

		internal int NativeRows { get; }

		internal int SteamMembers { get; }

		internal bool VoiceManagerPresent { get; }

		internal bool VoiceLobbyOff { get; }

		internal bool VoiceJoined { get; }

		internal int QueuedVoiceParticipants { get; }

		internal SweepSessionSnapshot(bool captured, string status, long processWorkingSetBytes, long processPrivateBytes, int processHandleCount, int processThreadCount, int nativeRows, int steamMembers, bool voiceManagerPresent, bool voiceLobbyOff, bool voiceJoined, int queuedVoiceParticipants)
		{
			Captured = captured;
			Status = status ?? string.Empty;
			ProcessWorkingSetBytes = processWorkingSetBytes;
			ProcessPrivateBytes = processPrivateBytes;
			ProcessHandleCount = processHandleCount;
			ProcessThreadCount = processThreadCount;
			NativeRows = nativeRows;
			SteamMembers = steamMembers;
			VoiceManagerPresent = voiceManagerPresent;
			VoiceLobbyOff = voiceLobbyOff;
			VoiceJoined = voiceJoined;
			QueuedVoiceParticipants = queuedVoiceParticipants;
		}

		internal static SweepSessionSnapshot Unavailable(string status)
		{
			return new SweepSessionSnapshot(captured: false, status, 0L, 0L, -1, -1, -1, -1, voiceManagerPresent: false, voiceLobbyOff: false, voiceJoined: false, -1);
		}
	}
	internal static class SweepSessionEvidenceFormatter
	{
		private const double BytesPerMiB = 1048576.0;

		internal static string Format(SweepSessionSnapshot before, SweepSessionSnapshot after)
		{
			if (!before.Captured || !after.Captured)
			{
				string value = ((!before.Captured) ? before.Status : after.Status);
				return "sessionEvidence=unavailable:" + SanitizeUnavailable(value);
			}
			return string.Join("; ", "processPrivateBeforeMiB=" + ToMiB(before.ProcessPrivateBytes), "processPrivateAfterMiB=" + ToMiB(after.ProcessPrivateBytes), "processPrivateDeltaMiB=" + ToSignedMiB(after.ProcessPrivateBytes - before.ProcessPrivateBytes), "workingSetBeforeMiB=" + ToMiB(before.ProcessWorkingSetBytes), "workingSetAfterMiB=" + ToMiB(after.ProcessWorkingSetBytes), "workingSetDeltaMiB=" + ToSignedMiB(after.ProcessWorkingSetBytes - before.ProcessWorkingSetBytes), "handles=" + before.ProcessHandleCount.ToString(CultureInfo.InvariantCulture) + "->" + after.ProcessHandleCount.ToString(CultureInfo.InvariantCulture), "threads=" + before.ProcessThreadCount.ToString(CultureInfo.InvariantCulture) + "->" + after.ProcessThreadCount.ToString(CultureInfo.InvariantCulture), "nativeRows=" + after.NativeRows.ToString(CultureInfo.InvariantCulture), "steamMembers=" + after.SteamMembers.ToString(CultureInfo.InvariantCulture), "nativeSteamDelta=" + DifferenceOrUnknown(after.NativeRows, after.SteamMembers), "voiceManager=" + Bool(after.VoiceManagerPresent), "voiceLobbyOff=" + Bool(after.VoiceLobbyOff), "voiceJoined=" + Bool(after.VoiceJoined), "voiceQueued=" + after.QueuedVoiceParticipants.ToString(CultureInfo.InvariantCulture));
		}

		private static string ToMiB(long bytes)
		{
			return ((double)bytes / 1048576.0).ToString("0.0", CultureInfo.InvariantCulture);
		}

		private static string ToSignedMiB(long bytes)
		{
			return ((double)bytes / 1048576.0).ToString("+0.0;-0.0;0.0", CultureInfo.InvariantCulture);
		}

		private static string DifferenceOrUnknown(int left, int right)
		{
			if (left >= 0 && right >= 0)
			{
				return (left - right).ToString(CultureInfo.InvariantCulture);
			}
			return "unknown";
		}

		private static string Bool(bool value)
		{
			if (!value)
			{
				return "false";
			}
			return "true";
		}

		private static string SanitizeUnavailable(string value)
		{
			if (string.IsNullOrWhiteSpace(value))
			{
				return "unavailable";
			}
			string text = value.Trim();
			if (text.StartsWith("unavailable:", StringComparison.Ordinal))
			{
				text = text.Substring("unavailable:".Length);
			}
			text = text.Replace(";", ",").Replace("\r", " ").Replace("\n", " ");
			if (text.Length > 96)
			{
				return text.Substring(0, 96);
			}
			return text;
		}
	}
	internal static class SweepSettingsPolicy
	{
		public const int MinimumIntervalMinutes = 5;

		public const int DefaultIntervalMinutes = 10;

		public const int MaximumIntervalMinutes = 180;

		private const int LegacyFifteenMinuteDefault = 15;

		public static int ClampIntervalMinutes(int configuredMinutes)
		{
			if (configuredMinutes < 5)
			{
				return 5;
			}
			if (configuredMinutes > 180)
			{
				return 180;
			}
			return configuredMinutes;
		}

		public static int MigrateLegacyDefaultIntervalMinutes(int configuredMinutes, bool alreadyMigrated)
		{
			if (!alreadyMigrated && (configuredMinutes == 30 || configuredMinutes == 60))
			{
				return 15;
			}
			return ClampIntervalMinutes(configuredMinutes);
		}

		public static int MigrateTenMinuteSafetyInterval(int configuredMinutes, bool alreadyMigrated)
		{
			if (!alreadyMigrated)
			{
				return 10;
			}
			return ClampIntervalMinutes(configuredMinutes);
		}

		public static bool MigrateAutomaticCleanupOptIn(bool configuredEnabled, bool alreadyMigrated)
		{
			return configuredEnabled;
		}
	}
	internal static class TickManagerPingPolicy
	{
		public static int? FromRttSeconds(double rttSeconds)
		{
			if (rttSeconds <= 0.0 || rttSeconds > 60.0 || double.IsNaN(rttSeconds) || double.IsInfinity(rttSeconds))
			{
				return null;
			}
			return (int)Math.Round(rttSeconds * 1000.0, MidpointRounding.AwayFromZero);
		}
	}
	internal static class TimestampFormatter
	{
		private static readonly Regex HexColorRegex = new Regex("^[0-9A-Fa-f]{6}$", RegexOptions.Compiled);

		public static string BuildPrefix(DateTime now, bool use24HourTime, int sizePercent, string colorHex)
		{
			int num = Clamp(sizePercent, 40, 100);
			string arg = SanitizeColor(colorHex);
			string arg2 = now.ToString(use24HourTime ? "HH:mm" : "h:mm tt");
			return $"<size={num}%><color=#{arg}>{arg2}</color></size> ";
		}

		private static string SanitizeColor(string colorHex)
		{
			string text = (colorHex ?? string.Empty).Trim().TrimStart(new char[1] { '#' });
			if (!HexColorRegex.IsMatch(text))
			{
				return "F5EDE1";
			}
			return text.ToUpperInvariant();
		}

		private static int Clamp(int value, int min, int max)
		{
			if (value < min)
			{
				return min;
			}
			if (value > max)
			{
				return max;
			}
			return value;
		}
	}
	internal static class UnifiedHelperPolicy
	{
		internal static string MergeForOwner(string ownerSteamId, string canonicalDelegates, string canonicalOwnerSteamId, string legacyLobbyDelegates, string legacyLobbyOwnerSteamId, string legacyModerationDelegates, string legacyModerationOwnerSteamId)
		{
			if (!IsSteamId(ownerSteamId))
			{
				return string.Empty;
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			AddScoped(hashSet, ownerSteamId, canonicalDelegates, canonicalOwnerSteamId);
			AddScoped(hashSet, ownerSteamId, legacyLobbyDelegates, legacyLobbyOwnerSteamId);
			AddScoped(hashSet, ownerSteamId, legacyModerationDelegates, legacyModerationOwnerSteamId);
			hashSet.Remove(ownerSteamId);
			return LobbyPingAuthorizationPolicy.SerializeDelegates(hashSet);
		}

		private static void AddScoped(HashSet<string> target, string ownerSteamId, string values, string scopedOwnerSteamId)
		{
			if (string.Equals(ownerSteamId, scopedOwnerSteamId, StringComparison.Ordinal))
			{
				string[] array = LobbyPingAuthorizationPolicy.ParseDelegates(values);
				foreach (string item in array)
				{
					target.Add(item);
				}
			}
		}

		private static bool IsSteamId(string value)
		{
			if (ulong.TryParse(value, out var result))
			{
				return result != 0;
			}
			return false;
		}
	}
	internal static class UnlimitedConsumablesPolicy
	{
		private static readonly HashSet<string> ConsumableItemNames = new HashSet<string>(StringComparer.Ordinal)
		{
			"CottonCandyPink", "LemonZestYellow", "BlueBerrySplashBlue", "GrapePopPurple", "SourAppleGreen", "ColaTurbo", "OrangeBlast", "LimeShock", "Boba1", "IceCream",
			"CottonCandy", "RainbowPopcorn", "Apple", "CottonGreen", "CottonPurple", "CottonLemon", "CottonBlue", "Water", "Boba2", "Boba3",
			"Chalk0", "Chalk1", "Chalk2", "Chalk3", "Chalk4"
		};

		internal static bool IsUnlimitedConsumable(string itemTypeName)
		{
			if (!string.IsNullOrWhiteSpace(itemTypeName))
			{
				return ConsumableItemNames.Contains(itemTypeName.Trim());
			}
			return false;
		}
	}
	internal static class VoicePositionRatePolicy
	{
		internal const float DefaultMinimumIntervalSeconds = 0.25f;

		internal static bool ShouldForward(float now, float lastForwardedAt, string channel, string lastChannel, float minimumIntervalSeconds = 0.25f)
		{
			if (lastForwardedAt < 0f || now < lastForwardedAt)
			{
				return true;
			}
			if (!string.Equals(channel ?? string.Empty, lastChannel ?? string.Empty, StringComparison.Ordinal))
			{
				return true;
			}
			return now - lastForwardedAt >= Math.Max(0.05f, minimumIntervalSeconds);
		}
	}
	internal static class VoiceWelcomePolicy
	{
		internal static string Build(bool? voiceChatOn, bool? lobbyVoiceOn, bool? pushToTalk)
		{
			string text = ((pushToTalk == true) ? "Push to Talk" : ((pushToTalk == false) ? "Voice Activation" : "not ready"));
			if (voiceChatOn == false)
			{
				return "Voice chat is Off in Settings; your saved mic mode is " + text + ". Recheck Settings > Audio before enabling voice.";
			}
			if (lobbyVoiceOn == false)
			{
				return "Lobby voice is Off; your saved mic mode is " + text + ". Recheck Settings > Audio if voice is enabled later.";
			}
			if (pushToTalk == true)
			{
				return "Lobby voice is " + ((lobbyVoiceOn == true) ? "On" : "starting") + " and Push to Talk is enabled; hold your mic key to speak.";
			}
			if (pushToTalk == false)
			{
				return "VOICE WARNING: lobby voice is " + ((lobbyVoiceOn == true) ? "On" : "starting") + " and Voice Activation is enabled, so your mic may be live. Check Settings > Audio or the mic icon.";
			}
			return "Voice mode is still loading. Check Settings > Audio for Push to Talk vs Voice Activation before assuming your mic is closed.";
		}
	}
	internal struct WindowFitResult
	{
		public float X { get; }

		public float Y { get; }

		public float Width { get; }

		public float Height { get; }

		public WindowFitResult(float x, float y, float width, float height)
		{
			X = x;
			Y = y;
			Width = width;
			Height = height;
		}
	}
	internal static class WindowFitPolicy
	{
		public const float ScreenMargin = 10f;

		public const float DefaultWindowWidth = 1320f;

		public const float DefaultWindowHeight = 720f;

		public const float MinimumUsableWidth = 560f;

		public const float MinimumUsableHeight = 560f;

		public static float GetUsableWidth(float screenWidth)
		{
			return Math.Max(1f, screenWidth - 20f);
		}

		public static float GetUsableHeight(float screenHeight)
		{
			return Math.Max(1f, screenHeight - 20f);
		}

		public static WindowFitResult FitInitial(float screenWidth, float screenHeight)
		{
			float usableWidth = GetUsableWidth(screenWidth);
			float usableHeight = GetUsableHeight(screenHeight);
			float num = Math.Min(1320f, usableWidth);
			float num2 = Math.Min(720f, usableHeight);
			float x = Math.Max(10f, (screenWidth - num) / 2f);
			float y = Math.Max(10f, (screenHeight - num2) / 2f);
			return new WindowFitResult(x, y, num, num2);
		}

		public static WindowFitResult FitForOpen(bool hasOpened, float x, float y, float width, float height, float preferredMinWidth, float preferredMinHeight, float screenWidth, float screenHeight)
		{
			if (!hasOpened)
			{
				return FitInitial(screenWidth, screenHeight);
			}
			return FitToScreen(x, y, width, height, preferredMinWidth, preferredMinHeight, screenWidth, screenHeight);
		}

		public static WindowFitResult FitToScreen(float x, float y, float width, float height, float preferredMinWidth, float preferredMinHeight, float screenWidth, float screenHeight)
		{
			return FitToScreen(x, y, width, height, preferredMinWidth, preferredMinHeight, screenWidth, screenHeight, expandToMaximum: false);
		}

		public static WindowFitResult FitToScreen(float x, float y, float width, float height, float preferredMinWidth, float preferredMinHeight, float screenWidth, float screenHeight, bool expandToMaximum)
		{
			float usableWidth = GetUsableWidth(screenWidth);
			float usableHeight = GetUsableHeight(screenHeight);
			float num = usableWidth;
			float num2 = usableHeight;
			float minimum = Math.Min(preferredMinWidth, num);
			float minimum2 = Math.Min(preferredMinHeight, num2);
			float num3 = (expandToMaximum ? num : Clamp(width, minimum, num));
			float num4 = (expandToMaximum ? num2 : Clamp(height, minimum2, num2));
			float x2 = ClampToVisibleRange(x, screenWidth, num3);
			float y2 = ClampToVisibleRange(y, screenHeight, num4);
			return new WindowFitResult(x2, y2, num3, num4);
		}

		private static float ClampToVisibleRange(float origin, float screenSize, float windowSize)
		{
			float maximum = Math.Max(10f, screenSize - windowSize - 10f);
			return Clamp(origin, 10f, maximum);
		}

		private static float Clamp(float value, float minimum, float maximum)
		{
			if (value < minimum)
			{
				return minimum;
			}
			if (value > maximum)
			{
				return maximum;
			}
			return value;
		}
	}
}