using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using HarmonyLib;
using LongChat.Config;
using LongChat.Diagnostics;
using LongChat.Models;
using LongChat.Patches;
using LongChat.Protocol;
using LongChat.Services;
using Microsoft.CodeAnalysis;
using ProjectM;
using ProjectM.Network;
using ProjectM.UI;
using TMPro;
using Unity.Entities;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("LongChat")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("LongChat")]
[assembly: AssemblyTitle("LongChat")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[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 LongChat
{
	internal static class LongChatRuntime
	{
		private static SendQueueService _sendQueue;

		private static AssemblyService _assemblyService;

		private static AssemblyService _overheadAssemblyService;

		private static LongChatConfig _config;

		private static HUDChatWindow? _chatWindow;

		private static bool _incomingReconstructionEnabled;

		private static bool _overheadReconstructionEnabled;

		private static bool _bypassSubmissionRouting;

		private static bool _renderingReconstructedMessage;

		internal static bool IncomingReconstructionEnabled => _incomingReconstructionEnabled;

		internal static int EffectiveFrameByteLimit => TransportLimits.EffectiveFrameByteLimit(_config.FrameByteLimit.Value);

		private static TimeSpan SendDelay => TimeSpan.FromMilliseconds(Math.Max(0, _config.SendDelayMilliseconds.Value));

		private static TimeSpan AcknowledgementTimeout => TimeSpan.FromMilliseconds(Math.Max(250, _config.AcknowledgementTimeoutMilliseconds.Value));

		public static void Initialize(LongChatConfig config)
		{
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Expected O, but got Unknown
			_config = config;
			_sendQueue = new SendQueueService();
			_assemblyService = new AssemblyService(Math.Max(1, config.MaximumChunksPerMessage.Value), Math.Max(1, config.MaximumActiveAssemblies.Value), Math.Max(1024, config.MaximumBufferedBytes.Value));
			_overheadAssemblyService = new AssemblyService(Math.Max(1, config.MaximumChunksPerMessage.Value), Math.Max(1, config.MaximumActiveAssemblies.Value), Math.Max(1024, config.MaximumBufferedBytes.Value));
			int num = TransportLimits.EffectiveFrameByteLimit(config.FrameByteLimit.Value);
			if (num != config.FrameByteLimit.Value)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(72, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Configured FrameByteLimit ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(config.FrameByteLimit.Value);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" is outside the supported range; using ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(num);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" bytes.");
				}
				log.LogWarning(val);
			}
		}

		public static void ConfigureIncomingReconstruction(bool enabled)
		{
			_incomingReconstructionEnabled = enabled;
			if (!enabled)
			{
				_assemblyService.Clear();
			}
		}

		public static void ConfigureOverheadReconstruction(bool enabled)
		{
			_overheadReconstructionEnabled = enabled;
			if (!enabled)
			{
				_overheadAssemblyService.Clear();
			}
		}

		public static bool IsChannelEnabled(ChatMessageType messageType)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected I4, but got Unknown
			switch ((int)messageType)
			{
			case 0:
				return _config.EnableGlobal.Value;
			case 2:
				return _config.EnableClan.Value;
			case 1:
			case 4:
				return _config.EnableLocal.Value;
			default:
				return false;
			}
		}

		public static bool IsCommand(string text)
		{
			if (_config.DisableSplittingForCommands.Value && text.Length > 0)
			{
				return _config.CommandPrefixes.Value.IndexOf(text[0]) >= 0;
			}
			return false;
		}

		public static bool HandleInputEndEdit(ClientChatSystem chatSystem, string? submittedText)
		{
			//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_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected I4, but got Unknown
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected I4, but got Unknown
			//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_008e: 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_00b1: 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_00c1: Unknown result type (might be due to invalid IL or missing references)
			if (_bypassSubmissionRouting)
			{
				return true;
			}
			string text = submittedText ?? string.Empty;
			ChatMessageType defaultMode = chatSystem._DefaultMode;
			DiagnosticLog.Stage("SUBMISSION_ROUTED", $"length={text.Length} displayMode={(int)chatSystem._ChatMode} sendType={(int)defaultMode}");
			if (!_config.Enabled.Value || string.IsNullOrEmpty(text) || !ChatSendTypeSupport.IsSupported(defaultMode) || !IsChannelEnabled(defaultMode) || !TransportLimits.ExceedsFrameLimit(text, _config.FrameByteLimit.Value))
			{
				return true;
			}
			EntityManager entityManager = ((ComponentSystemBase)chatSystem).EntityManager;
			if (IsCommand(text))
			{
				DisplayLocalWarning(entityManager, "LongChat: Commands cannot be split into multiple chat messages.");
				CompleteVanillaSubmission(chatSystem);
				return false;
			}
			if (!TrySendMultipart(chatSystem, text, defaultMode, out string error))
			{
				CompleteVanillaSubmission(chatSystem);
				DisplayLocalWarning(entityManager, error ?? "LongChat: Unable to send the message.");
				RestoreInputText(text);
			}
			return false;
		}

		private static bool TrySendMultipart(ClientChatSystem chatSystem, string text, ChatMessageType messageType, out string? error)
		{
			//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_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Expected O, but got Unknown
			//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)
			error = null;
			try
			{
				IReadOnlyList<string> readOnlyList = FrameEncoder.Encode(text, EffectiveFrameByteLimit, Math.Clamp(_config.MaximumChunksPerMessage.Value, 1, 999));
				if (!FrameParser.TryParse(readOnlyList[0], out var frame))
				{
					error = "LongChat: Unable to parse the encoded first frame.";
					return false;
				}
				OutgoingMessage message = new OutgoingMessage(((ComponentSystemBase)chatSystem).EntityManager, messageType, frame.MessageId, text, readOnlyList, delegate(string frame2)
				{
					//IL_0007: Unknown result type (might be due to invalid IL or missing references)
					SubmitInternalFrame(chatSystem, messageType, frame2);
				});
				DateTime utcNow = DateTime.UtcNow;
				if (!_sendQueue.TryEnqueue(message, Math.Max(1, _config.MaximumQueuedMessages.Value)))
				{
					error = "LongChat: The outgoing message queue is full.";
					return false;
				}
				TickSendQueue(utcNow);
				DiagnosticLog.Stage("MULTIPART_ACCEPTED", $"length={text.Length} frames={readOnlyList.Count} queue={_sendQueue.Count}");
				return true;
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(29, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Unable to send long message: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
				}
				log.LogWarning(val);
				_sendQueue.Clear();
				error = "LongChat: " + ex.Message;
				return false;
			}
		}

		public static bool HandleFinalFilteredMessage(__c__DisplayClass55_1 callback, string userNameFiltered)
		{
			//IL_012d: 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_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Expected I4, but got Unknown
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			__c__DisplayClass55_0 field_Public___c__DisplayClass55_0_ = callback.field_Public___c__DisplayClass55_0_0;
			string text = callback.filteredText ?? string.Empty;
			string userNameFiltered2 = userNameFiltered ?? string.Empty;
			string timeStamp = ((field_Public___c__DisplayClass55_0_ != null) ? field_Public___c__DisplayClass55_0_.timeStamp : null) ?? string.Empty;
			if (!_config.Enabled.Value || !_incomingReconstructionEnabled || _renderingReconstructedMessage || field_Public___c__DisplayClass55_0_ == null || !FrameParser.TryParse(text, out var frame))
			{
				return true;
			}
			DiagnosticLog.Stage("INCOMING_FRAME", $"index={frame.Index} total={frame.Total} payload={frame.Payload.Length} raw={text.Length}");
			if (field_Public___c__DisplayClass55_0_.isSelf && _sendQueue.Acknowledge(frame.MessageId, frame.Index, DateTime.UtcNow, SendDelay))
			{
				DiagnosticLog.Stage("FRAME_ACKNOWLEDGED", $"index={frame.Index} total={frame.Total} queue={_sendQueue.Count}");
			}
			string senderId = $"{field_Public___c__DisplayClass55_0_.fromUser}:{field_Public___c__DisplayClass55_0_.fromCharacterId}";
			AssemblyKey key = new AssemblyKey(senderId, (int)field_Public___c__DisplayClass55_0_.messageType, frame.MessageId);
			IncomingContext context = new IncomingContext(callback, field_Public___c__DisplayClass55_0_.messageType, userNameFiltered2, timeStamp, field_Public___c__DisplayClass55_0_.showTimeStamp, field_Public___c__DisplayClass55_0_.isSelf, field_Public___c__DisplayClass55_0_.isUserAdmin);
			AssemblyAddResult assemblyAddResult = _assemblyService.Add(key, frame, text, context, DateTime.UtcNow);
			switch (assemblyAddResult.Status)
			{
			case AssemblyAddStatus.Complete:
				callback.filteredText = assemblyAddResult.Text;
				return true;
			case AssemblyAddStatus.Pending:
			case AssemblyAddStatus.Duplicate:
				return false;
			case AssemblyAddStatus.Conflict:
				callback.filteredText = string.Join(" ", assemblyAddResult.RawFrames);
				return true;
			default:
				return true;
			}
		}

		public unsafe static bool HandleOverheadChatMessage(NetworkId networkId, ref string text)
		{
			string text2 = text ?? string.Empty;
			if (!_config.Enabled.Value || !_config.EnableOverheadReconstruction.Value || !_overheadReconstructionEnabled || !FrameParser.TryParse(text2, out var frame))
			{
				return true;
			}
			DiagnosticLog.Stage("OVERHEAD_FRAME", $"index={frame.Index} total={frame.Total} payload={frame.Payload.Length} raw={text2.Length}");
			string senderId = ((object)(*(NetworkId*)(&networkId))/*cast due to .constrained prefix*/).ToString();
			AssemblyKey key = new AssemblyKey(senderId, 0, frame.MessageId);
			AssemblyAddResult assemblyAddResult = _overheadAssemblyService.Add(key, frame, text2, null, DateTime.UtcNow);
			switch (assemblyAddResult.Status)
			{
			case AssemblyAddStatus.Complete:
				text = FormatOverheadText(assemblyAddResult.Text);
				DiagnosticLog.Stage("OVERHEAD_COMPLETE", $"length={assemblyAddResult.Text.Length} rendered={text.Length}");
				return true;
			case AssemblyAddStatus.Pending:
			case AssemblyAddStatus.Duplicate:
				return false;
			case AssemblyAddStatus.Conflict:
				text = FormatOverheadText(string.Join(" ", assemblyAddResult.RawFrames));
				DiagnosticLog.Stage("OVERHEAD_CONFLICT", $"frames={assemblyAddResult.RawFrames.Count} rendered={text.Length}");
				return true;
			default:
				return true;
			}
		}

		public static void ObserveChatWindow(HUDChatWindow? chatWindow)
		{
			if (chatWindow != null)
			{
				_chatWindow = chatWindow;
				ApplyInputLimit(chatWindow);
			}
		}

		public static void ApplyInputLimit(HUDChatWindow? chatWindow)
		{
			if (_config.Enabled.Value && ((chatWindow != null) ? chatWindow.ChatInputField : null) != null)
			{
				int num = Math.Max(1, _config.MaxInputCharacters.Value);
				int characterLimit = chatWindow.ChatInputField.characterLimit;
				chatWindow.ChatInputField.characterLimit = num;
				if (characterLimit != num)
				{
					DiagnosticLog.Stage("INPUT_LIMIT_APPLIED", $"before={characterLimit} after={num}");
				}
			}
		}

		public static void Tick()
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			if (!_config.Enabled.Value)
			{
				return;
			}
			if (_chatWindow != null && (Object)(object)_chatWindow == (Object)null)
			{
				_chatWindow = null;
			}
			else if (_chatWindow != null)
			{
				ApplyInputLimit(_chatWindow);
			}
			try
			{
				TickSendQueue(DateTime.UtcNow);
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(34, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Sending a multipart frame failed: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
				}
				log.LogWarning(val);
				OutgoingMessage outgoingMessage = _sendQueue.FailActive();
				if ((object)outgoingMessage != null)
				{
					HandleTransportFailure(outgoingMessage, "LongChat: Multipart transport failed; the original text was restored.");
				}
			}
			if (IncomingReconstructionEnabled)
			{
				foreach (ExpiredAssembly item in _assemblyService.Expire(DateTime.UtcNow, TimeSpan.FromMilliseconds(Math.Max(250, _config.AssemblyTimeoutMilliseconds.Value))))
				{
					if (item.Context is IncomingContext context)
					{
						RenderThroughFinalCallback(context, "[Incomplete multipart message] " + item.PartialText);
					}
				}
			}
			if (!_overheadReconstructionEnabled)
			{
				return;
			}
			foreach (ExpiredAssembly item2 in _overheadAssemblyService.Expire(DateTime.UtcNow, TimeSpan.FromMilliseconds(Math.Max(250, _config.AssemblyTimeoutMilliseconds.Value))))
			{
				DiagnosticLog.Stage("OVERHEAD_EXPIRED", $"partial={item2.PartialText.Length}");
			}
		}

		public static void DisplayLocalWarning(EntityManager entityManager, string warning)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			DisplayLocalMessage(entityManager, warning, (ServerChatMessageType)6);
		}

		private static void DisplayLocalMessage(EntityManager entityManager, string text, ServerChatMessageType messageType)
		{
			//IL_0000: 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_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			try
			{
				ClientSystemChatUtils.AddLocalMessage(entityManager, text, messageType);
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(33, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Unable to display local warning: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
				}
				log.LogWarning(val);
			}
		}

		public static void ClearSession(string? reason = null)
		{
			if (_sendQueue.Count > 0)
			{
				DiagnosticLog.Stage("QUEUE_CLEARED", string.Format("count={0} reason={1}", _sendQueue.Count, reason ?? "session reset"));
			}
			_sendQueue.Clear();
			_assemblyService.Clear();
			_overheadAssemblyService.Clear();
		}

		private static void SendFrame(OutgoingMessage message, string frame)
		{
			message.SubmitFrame(frame);
		}

		private static void SubmitInternalFrame(ClientChatSystem chatSystem, ChatMessageType messageType, string frame)
		{
			//IL_000a: 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_0088: 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_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected I4, but got Unknown
			FrameParser.TryParse(frame, out var frame2);
			ChatMessageType defaultMode = chatSystem._DefaultMode;
			try
			{
				_bypassSubmissionRouting = true;
				chatSystem._DefaultMode = messageType;
				DiagnosticLog.Stage("INTERNAL_FRAME_SUBMIT", $"frame={frame2.Index}/{frame2.Total} length={frame.Length} sendType={(int)messageType} queue={_sendQueue.Count}");
				chatSystem._OnInputEndEdit(frame);
			}
			finally
			{
				chatSystem._DefaultMode = defaultMode;
				_bypassSubmissionRouting = false;
			}
		}

		private static void TickSendQueue(DateTime now)
		{
			_sendQueue.Tick(now, AcknowledgementTimeout, SendFrame, delegate(OutgoingMessage message)
			{
				HandleTransportFailure(message, "LongChat: The server did not acknowledge the multipart message; the original text was restored.");
			});
		}

		private static void HandleTransportFailure(OutgoingMessage message, string warning)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			DisplayLocalWarning(message.EntityManager, warning);
			RestoreInputText(message.OriginalText);
		}

		private static void RestoreInputText(string text)
		{
			HUDChatWindow? chatWindow = _chatWindow;
			TMP_InputField val = ((chatWindow != null) ? chatWindow.ChatInputField : null);
			if (val == null)
			{
				Plugin.Log.LogWarning((object)"Unable to restore long chat text because the chat input is unavailable.");
				return;
			}
			val.text = text;
			val.MoveTextEnd(false);
			DiagnosticLog.Stage("INPUT_RESTORED", $"length={text.Length}");
		}

		private static void CompleteVanillaSubmission(ClientChatSystem chatSystem)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			try
			{
				_bypassSubmissionRouting = true;
				chatSystem._OnInputEndEdit(string.Empty);
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(41, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Unable to complete vanilla chat cleanup: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
				}
				log.LogWarning(val);
				HUDChatWindow? chatWindow = _chatWindow;
				if (chatWindow != null)
				{
					chatWindow.ClearInputText();
				}
			}
			finally
			{
				_bypassSubmissionRouting = false;
			}
		}

		private static void RenderThroughFinalCallback(IncomingContext context, string text)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			//IL_0077: 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)
			string filteredText = context.Callback.filteredText;
			try
			{
				_renderingReconstructedMessage = true;
				context.Callback.filteredText = text;
				context.Callback._FilterChatMessages_b__1(context.UserNameFiltered);
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(37, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Unable to render multipart fallback: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.GetBaseException().Message);
				}
				log.LogWarning(val);
				DisplayLocalMessage(((ComponentSystemBase)context.Callback.field_Public___c__DisplayClass55_0_0.__4__this).EntityManager, text, context.MessageType);
			}
			finally
			{
				context.Callback.filteredText = filteredText;
				_renderingReconstructedMessage = false;
			}
		}

		private static string FormatOverheadText(string text)
		{
			return OverheadTextFormatter.Wrap(OverheadTextFormatter.Limit(text, _config.MaxOverheadCharacters.Value), _config.MaxOverheadLineCharacters.Value, _config.EnableOverheadWrapping.Value);
		}
	}
	[BepInPlugin("com.yssena.longchat", "LongChat", "1.0.0")]
	public sealed class Plugin : BasePlugin
	{
		private Harmony? _harmony;

		internal static ManualLogSource Log { get; private set; }

		internal static LongChatConfig Settings { get; private set; }

		public override void Load()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Expected O, but got Unknown
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Expected O, but got Unknown
			Log = ((BasePlugin)this).Log;
			Settings = new LongChatConfig(((BasePlugin)this).Config);
			LongChatRuntime.Initialize(Settings);
			_harmony = new Harmony("com.yssena.longchat");
			PatchFeatures(_harmony);
			bool flag = default(bool);
			BepInExInfoLogInterpolatedStringHandler val;
			if (Settings.LogPatchDiscovery.Value)
			{
				foreach (MethodBase patchedMethod in _harmony.GetPatchedMethods())
				{
					ManualLogSource log = Log;
					val = new BepInExInfoLogInterpolatedStringHandler(9, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Patched ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(patchedMethod.DeclaringType?.FullName);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(".");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(patchedMethod.Name);
					}
					log.LogInfo(val);
				}
			}
			ManualLogSource log2 = Log;
			val = new BepInExInfoLogInterpolatedStringHandler(9, 2, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("LongChat");
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("1.0.0");
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" loaded.");
			}
			log2.LogInfo(val);
			DiagnosticLog.Stage("STARTUP", "version=1.0.0");
		}

		private static void PatchFeatures(Harmony harmony)
		{
			TryPatch(harmony, "chat input expansion", ResolveMethod(typeof(ClientChatSystem), "InitOrUpdateChatWindow", typeof(bool)), null, typeof(ChatInputPatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic));
			TryPatch(harmony, "long chat submission routing", ResolveMethod(typeof(ClientChatSystem), "_OnInputEndEdit", typeof(string)), typeof(ChatEndEditPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic));
			TryPatch(harmony, "chat update scheduler", ResolveMethod(typeof(ClientChatSystem), "OnUpdate"), null, typeof(ChatUpdatePatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic));
			TryPatch(harmony, "client session cleanup", ResolveMethod(typeof(ClientBootstrapSystem), "OnDestroy"), typeof(ClientSessionPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic));
			LongChatRuntime.ConfigureIncomingReconstruction(TryPatch(harmony, "final multipart reconstruction", ResolveMethod(typeof(__c__DisplayClass55_1), "_FilterChatMessages_b__1", typeof(string)), typeof(FinalChatFilterPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic)));
			LongChatRuntime.ConfigureOverheadReconstruction(TryPatch(harmony, "overhead multipart reconstruction", ResolveMethod(typeof(ClientChatSystem), "CreateLocalChatMessageSCT", typeof(NetworkIdLookupMap).MakeByRefType(), typeof(NetworkId), typeof(string)), typeof(OverheadChatPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic)));
		}

		private static MethodInfo? ResolveMethod(Type type, string name, params Type[] parameterTypes)
		{
			return type.GetMethod(name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, parameterTypes, null);
		}

		private static bool TryPatch(Harmony harmony, string feature, MethodInfo? target, MethodInfo? prefix = null, MethodInfo? postfix = null)
		{
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Expected O, but got Unknown
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			//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)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			bool flag = default(bool);
			if ((object)target == null)
			{
				ManualLogSource log = Log;
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(57, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("LongChat disabled ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(feature);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(": compatible game method was not found.");
				}
				log.LogWarning(val);
				return false;
			}
			try
			{
				harmony.Patch((MethodBase)target, ((object)prefix == null) ? ((HarmonyMethod)null) : new HarmonyMethod(prefix), ((object)postfix == null) ? ((HarmonyMethod)null) : new HarmonyMethod(postfix), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				ManualLogSource log2 = Log;
				BepInExInfoLogInterpolatedStringHandler val2 = new BepInExInfoLogInterpolatedStringHandler(18, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("LongChat enabled ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(feature);
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(".");
				}
				log2.LogInfo(val2);
				return true;
			}
			catch (Exception ex)
			{
				ManualLogSource log3 = Log;
				bool flag2 = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(20, 2, ref flag2);
				if (flag2)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("LongChat disabled ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(feature);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(": ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.GetBaseException().Message);
				}
				log3.LogWarning(val);
				return false;
			}
		}

		public override bool Unload()
		{
			LongChatRuntime.ClearSession("plugin unloaded");
			Harmony? harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
			return true;
		}
	}
	internal static class PluginInfo
	{
		public const string Guid = "com.yssena.longchat";

		public const string Name = "LongChat";

		public const string Version = "1.0.0";
	}
}
namespace LongChat.Services
{
	public enum AssemblyAddStatus
	{
		Pending,
		Complete,
		Duplicate,
		Conflict,
		Rejected
	}
	public sealed record AssemblyAddResult(AssemblyAddStatus Status, string? Text = null, IReadOnlyList<string>? RawFrames = null);
	public sealed record ExpiredAssembly(AssemblyKey Key, string PartialText, IReadOnlyList<string> RawFrames, object? Context);
	public sealed class AssemblyService
	{
		private sealed class State
		{
			public int ExpectedChunks { get; }

			public object? Context { get; }

			public Dictionary<int, string> Payloads { get; } = new Dictionary<int, string>();

			public List<string> RawFrames { get; } = new List<string>();

			public int Bytes { get; set; }

			public DateTime LastReceived { get; set; }

			public State(int expectedChunks, object? context, DateTime now)
			{
				ExpectedChunks = expectedChunks;
				Context = context;
				LastReceived = now;
			}
		}

		private readonly Dictionary<AssemblyKey, State> _assemblies = new Dictionary<AssemblyKey, State>();

		private readonly int _maximumChunks;

		private readonly int _maximumActiveAssemblies;

		private readonly int _maximumBufferedBytes;

		private int _bufferedBytes;

		public AssemblyService(int maximumChunks, int maximumActiveAssemblies, int maximumBufferedBytes)
		{
			_maximumChunks = maximumChunks;
			_maximumActiveAssemblies = maximumActiveAssemblies;
			_maximumBufferedBytes = maximumBufferedBytes;
		}

		public AssemblyAddResult Add(AssemblyKey key, ParsedFrame frame, string rawFrame, object? context, DateTime now)
		{
			if (frame.Total > _maximumChunks)
			{
				return new AssemblyAddResult(AssemblyAddStatus.Rejected);
			}
			if (!_assemblies.TryGetValue(key, out State state))
			{
				if (_assemblies.Count >= _maximumActiveAssemblies)
				{
					RemoveOldest();
				}
				state = new State(frame.Total, context, now);
				_assemblies.Add(key, state);
			}
			else if (state.ExpectedChunks != frame.Total)
			{
				string[] rawFrames = state.RawFrames.Append(rawFrame).ToArray();
				Remove(key, state);
				return new AssemblyAddResult(AssemblyAddStatus.Conflict, null, rawFrames);
			}
			if (state.Payloads.TryGetValue(frame.Index, out string value))
			{
				if (value == frame.Payload)
				{
					state.LastReceived = now;
					return new AssemblyAddResult(AssemblyAddStatus.Duplicate);
				}
				string[] rawFrames2 = state.RawFrames.Append(rawFrame).ToArray();
				Remove(key, state);
				return new AssemblyAddResult(AssemblyAddStatus.Conflict, null, rawFrames2);
			}
			int byteCount = Encoding.UTF8.GetByteCount(frame.Payload);
			while (_assemblies.Count > 0 && _bufferedBytes + byteCount > _maximumBufferedBytes)
			{
				KeyValuePair<AssemblyKey, State>? keyValuePair = ((IEnumerable<KeyValuePair<AssemblyKey, State>>)(from pair in _assemblies
					where !pair.Key.Equals(key)
					orderby pair.Value.LastReceived
					select pair)).Select((Func<KeyValuePair<AssemblyKey, State>, KeyValuePair<AssemblyKey, State>?>)((KeyValuePair<AssemblyKey, State> pair) => pair)).FirstOrDefault();
				if (!keyValuePair.HasValue)
				{
					Remove(key, state);
					return new AssemblyAddResult(AssemblyAddStatus.Rejected);
				}
				Remove(keyValuePair.Value.Key, keyValuePair.Value.Value);
			}
			if (byteCount > _maximumBufferedBytes)
			{
				return new AssemblyAddResult(AssemblyAddStatus.Rejected);
			}
			state.Payloads.Add(frame.Index, frame.Payload);
			state.RawFrames.Add(rawFrame);
			state.Bytes += byteCount;
			state.LastReceived = now;
			_bufferedBytes += byteCount;
			if (state.Payloads.Count != state.ExpectedChunks)
			{
				return new AssemblyAddResult(AssemblyAddStatus.Pending);
			}
			string text = string.Concat(from index in Enumerable.Range(1, state.ExpectedChunks)
				select state.Payloads[index]);
			Remove(key, state);
			return new AssemblyAddResult(AssemblyAddStatus.Complete, text);
		}

		public IReadOnlyList<ExpiredAssembly> Expire(DateTime now, TimeSpan timeout)
		{
			ExpiredAssembly[] array = (from pair in _assemblies
				where now - pair.Value.LastReceived >= timeout
				select new ExpiredAssembly(pair.Key, string.Concat(from chunk in pair.Value.Payloads
					orderby chunk.Key
					select chunk.Value), pair.Value.RawFrames.ToArray(), pair.Value.Context)).ToArray();
			ExpiredAssembly[] array2 = array;
			foreach (ExpiredAssembly expiredAssembly in array2)
			{
				if (_assemblies.TryGetValue(expiredAssembly.Key, out State value))
				{
					Remove(expiredAssembly.Key, value);
				}
			}
			return array;
		}

		public void Clear()
		{
			_assemblies.Clear();
			_bufferedBytes = 0;
		}

		private void RemoveOldest()
		{
			KeyValuePair<AssemblyKey, State> keyValuePair = _assemblies.OrderBy<KeyValuePair<AssemblyKey, State>, DateTime>((KeyValuePair<AssemblyKey, State> pair) => pair.Value.LastReceived).First();
			Remove(keyValuePair.Key, keyValuePair.Value);
		}

		private void Remove(AssemblyKey key, State state)
		{
			_assemblies.Remove(key);
			_bufferedBytes -= state.Bytes;
		}
	}
	internal static class ChatSendTypeSupport
	{
		public static bool IsSupported(ChatMessageType messageType)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			if ((int)messageType <= 2 || (int)messageType == 4)
			{
				return true;
			}
			return false;
		}
	}
	internal sealed class SendQueueService
	{
		private sealed class QueuedMessage
		{
			public OutgoingMessage Message { get; }

			public int NextFrame { get; set; }

			public int AwaitingIndex { get; set; }

			public DateTime SentAt { get; set; }

			public DateTime NextSendAt { get; set; }

			public QueuedMessage(OutgoingMessage message)
			{
				Message = message;
			}
		}

		private readonly Queue<QueuedMessage> _messages = new Queue<QueuedMessage>();

		private QueuedMessage? _active;

		public int Count => _messages.Count + ((_active != null) ? 1 : 0);

		public bool TryEnqueue(OutgoingMessage message, int maximumQueuedMessages)
		{
			if (Count >= maximumQueuedMessages)
			{
				return false;
			}
			_messages.Enqueue(new QueuedMessage(message));
			return true;
		}

		public void Tick(DateTime now, TimeSpan acknowledgementTimeout, Action<OutgoingMessage, string> send, Action<OutgoingMessage> timeout)
		{
			if (_active == null && _messages.Count > 0)
			{
				_active = _messages.Dequeue();
			}
			if (_active == null)
			{
				return;
			}
			if (_active.AwaitingIndex > 0)
			{
				if (now - _active.SentAt >= acknowledgementTimeout)
				{
					OutgoingMessage message = _active.Message;
					_active = null;
					timeout(message);
				}
			}
			else if (!(now < _active.NextSendAt))
			{
				string arg = _active.Message.Frames[_active.NextFrame];
				_active.AwaitingIndex = _active.NextFrame + 1;
				_active.SentAt = now;
				send(_active.Message, arg);
			}
		}

		public bool Acknowledge(string messageId, int frameIndex, DateTime now, TimeSpan delay)
		{
			if (_active == null || _active.Message.MessageId != messageId || _active.AwaitingIndex != frameIndex)
			{
				return false;
			}
			_active.NextFrame++;
			_active.AwaitingIndex = 0;
			if (_active.NextFrame >= _active.Message.Frames.Count)
			{
				_active = null;
			}
			else
			{
				_active.NextSendAt = now + delay;
			}
			return true;
		}

		public OutgoingMessage? FailActive()
		{
			OutgoingMessage result = _active?.Message;
			_active = null;
			return result;
		}

		public void Clear()
		{
			_messages.Clear();
			_active = null;
		}
	}
}
namespace LongChat.Protocol
{
	public static class FrameEncoder
	{
		public static IReadOnlyList<string> Encode(string text, int frameByteLimit, int maximumChunks, string? messageId = null)
		{
			if (text == null)
			{
				throw new ArgumentNullException("text");
			}
			if (maximumChunks < 1)
			{
				throw new ArgumentOutOfRangeException("maximumChunks");
			}
			if (messageId == null)
			{
				messageId = MessageIdGenerator.Create();
			}
			if (messageId.Length != 6 || messageId.Any(delegate(char character)
			{
				bool flag;
				switch (character)
				{
				case '0':
				case '1':
				case '2':
				case '3':
				case '4':
				case '5':
				case '6':
				case '7':
				case '8':
				case '9':
				case 'A':
				case 'B':
				case 'C':
				case 'D':
				case 'E':
				case 'F':
					flag = true;
					break;
				default:
					flag = false;
					break;
				}
				return !flag;
			}))
			{
				throw new ArgumentException("Message IDs must contain exactly six uppercase hexadecimal characters.", "messageId");
			}
			string s = FrameParser.Header(messageId, maximumChunks, maximumChunks);
			int maximumPayloadBytes = frameByteLimit - Encoding.UTF8.GetByteCount(s);
			IReadOnlyList<string> payloads = Utf8Chunker.Split(text, maximumPayloadBytes);
			if (payloads.Count > maximumChunks)
			{
				throw new InvalidOperationException($"Message requires {payloads.Count} chunks; the configured maximum is {maximumChunks}.");
			}
			string[] array = payloads.Select((string payload, int index) => FrameParser.Header(messageId, index + 1, payloads.Count) + payload).ToArray();
			if (array.Any((string frame) => Encoding.UTF8.GetByteCount(frame) > frameByteLimit))
			{
				throw new InvalidOperationException("An encoded frame exceeded the configured byte limit.");
			}
			return array;
		}
	}
	public static class FrameParser
	{
		private const string Prefix = "[[LC1|";

		public static bool TryParse(string text, out ParsedFrame frame)
		{
			frame = default(ParsedFrame);
			if (string.IsNullOrEmpty(text) || !text.StartsWith("[[LC1|", StringComparison.Ordinal))
			{
				return false;
			}
			int num = text.IndexOf("]]", "[[LC1|".Length, StringComparison.Ordinal);
			if (num < 0)
			{
				return false;
			}
			string[] array = text.AsSpan("[[LC1|".Length, num - "[[LC1|".Length).ToString().Split('|');
			if (array.Length != 3 || array[0].Length != 6 || array[0].Any((char character) => !IsUpperHex(character)) || !int.TryParse(array[1], out var result) || !int.TryParse(array[2], out var result2) || result < 1 || result2 < 1 || result > result2)
			{
				return false;
			}
			string messageId = array[0];
			int index = result;
			int total = result2;
			int num2 = num + 2;
			frame = new ParsedFrame(messageId, index, total, text.Substring(num2, text.Length - num2));
			return true;
		}

		public static string Header(string messageId, int index, int total)
		{
			return $"[[LC1|{messageId}|{index}|{total}]]";
		}

		private static bool IsUpperHex(char character)
		{
			switch (character)
			{
			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':
			case 'A':
			case 'B':
			case 'C':
			case 'D':
			case 'E':
			case 'F':
				return true;
			default:
				return false;
			}
		}
	}
	public static class MessageIdGenerator
	{
		public static string Create()
		{
			Span<byte> data = stackalloc byte[3];
			RandomNumberGenerator.Fill(data);
			return string.Concat(from value in data.ToArray()
				select value.ToString("X2"));
		}
	}
	internal static class OverheadTextFormatter
	{
		public static string Limit(string text, int maximumCharacters)
		{
			string text2 = text ?? string.Empty;
			int num = Math.Max(1, maximumCharacters);
			if (text2.Length <= num)
			{
				return text2;
			}
			if (num != 1)
			{
				return text2.Substring(0, num - 1) + "…";
			}
			return "…";
		}

		public static string Wrap(string text, int maximumLineCharacters, bool enabled)
		{
			string text2 = text ?? string.Empty;
			if (!enabled)
			{
				return text2;
			}
			int limit = Math.Max(1, maximumLineCharacters);
			string[] array = text2.Replace("\r\n", "\n", StringComparison.Ordinal).Replace('\r', '\n').Split('\n');
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = WrapParagraph(array[i], limit);
			}
			return string.Join("\n", array);
		}

		private static string WrapParagraph(string paragraph, int limit)
		{
			if (paragraph.Length <= limit)
			{
				return paragraph;
			}
			string[] array = paragraph.Split(new char[2] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
			if (array.Length == 0)
			{
				return paragraph;
			}
			StringBuilder stringBuilder = new StringBuilder(paragraph.Length + paragraph.Length / limit + 1);
			StringBuilder stringBuilder2 = new StringBuilder(limit);
			string[] array2 = array;
			foreach (string word in array2)
			{
				AppendWord(stringBuilder, stringBuilder2, word, limit);
			}
			if (stringBuilder2.Length > 0)
			{
				AppendLine(stringBuilder, stringBuilder2.ToString());
			}
			return stringBuilder.ToString();
		}

		private static void AppendWord(StringBuilder output, StringBuilder currentLine, string word, int limit)
		{
			if (word.Length > limit)
			{
				if (currentLine.Length > 0)
				{
					AppendLine(output, currentLine.ToString());
					currentLine.Clear();
				}
				int i;
				for (i = 0; word.Length - i > limit; i += limit)
				{
					AppendLine(output, word.Substring(i, limit));
				}
				if (i < word.Length)
				{
					int num = i;
					currentLine.Append(word.Substring(num, word.Length - num));
				}
			}
			else if (currentLine.Length == 0)
			{
				currentLine.Append(word);
			}
			else if (currentLine.Length + 1 + word.Length <= limit)
			{
				currentLine.Append(' ').Append(word);
			}
			else
			{
				AppendLine(output, currentLine.ToString());
				currentLine.Clear();
				currentLine.Append(word);
			}
		}

		private static void AppendLine(StringBuilder output, string line)
		{
			if (output.Length > 0)
			{
				output.Append('\n');
			}
			output.Append(line);
		}
	}
	public static class TransportLimits
	{
		public const int MinimumFrameByteLimit = 64;

		public const int MaximumFrameByteLimit = 120;

		public static int EffectiveFrameByteLimit(int configuredLimit)
		{
			return Math.Clamp(configuredLimit, 64, 120);
		}

		public static bool ExceedsFrameLimit(string? text, int configuredLimit)
		{
			return Encoding.UTF8.GetByteCount(text ?? string.Empty) > EffectiveFrameByteLimit(configuredLimit);
		}
	}
	public static class Utf8Chunker
	{
		public static IReadOnlyList<string> Split(string text, int maximumPayloadBytes)
		{
			if (text == null)
			{
				throw new ArgumentNullException("text");
			}
			if (maximumPayloadBytes < 4)
			{
				throw new ArgumentOutOfRangeException("maximumPayloadBytes");
			}
			List<string> list = new List<string>();
			int num = 0;
			while (num < text.Length)
			{
				int num2 = FindEnd(text, num, maximumPayloadBytes);
				if (num2 <= num)
				{
					throw new InvalidOperationException("The payload budget cannot contain the next Unicode scalar.");
				}
				int num3 = num;
				list.Add(text.Substring(num3, num2 - num3));
				num = num2;
			}
			return list;
		}

		private static int FindEnd(string text, int start, int maximumBytes)
		{
			int num = 0;
			int num2 = start;
			int num3 = start;
			int num4 = -1;
			int num5 = -1;
			int num6 = -1;
			int num7 = -1;
			while (num2 < text.Length)
			{
				char c = text[num2];
				int num8 = ((!char.IsHighSurrogate(c) || num2 + 1 >= text.Length || !char.IsLowSurrogate(text[num2 + 1])) ? 1 : 2);
				int num9 = ((num8 == 2) ? char.ConvertToUtf32(c, text[num2 + 1]) : c);
				int num10 = ((num9 <= 2047) ? ((num9 <= 127) ? 1 : 2) : ((num9 > 65535) ? 4 : 3));
				int num11 = num10;
				if (num + num11 > maximumBytes)
				{
					break;
				}
				num += num11;
				num2 += num8;
				num3 = num2;
				bool flag;
				switch (num9)
				{
				case 10:
					num4 = num2 - num8;
					continue;
				case 33:
				case 46:
				case 63:
				case 12290:
				case 65281:
				case 65311:
					flag = true;
					break;
				default:
					flag = false;
					break;
				}
				if (flag)
				{
					num5 = num2;
					continue;
				}
				UnicodeCategory unicodeCategory = CharUnicodeInfo.GetUnicodeCategory(text, num2 - num8);
				if ((uint)(unicodeCategory - 18) <= 6u)
				{
					num6 = num2;
				}
				else if (num8 == 1 && char.IsWhiteSpace(c))
				{
					num7 = num2 - num8;
				}
			}
			if (num3 == text.Length)
			{
				return num3;
			}
			int num12 = start + Math.Max(1, (num3 - start) / 2);
			int[] array = new int[4] { num4, num5, num6, num7 };
			foreach (int num13 in array)
			{
				if (num13 >= num12 && num13 > start)
				{
					return num13;
				}
			}
			int result = num3;
			while (num3 > start && char.IsWhiteSpace(text[num3 - 1]))
			{
				num3--;
			}
			if (num3 <= start)
			{
				return result;
			}
			return num3;
		}
	}
}
namespace LongChat.Patches
{
	internal static class ChatEndEditPatch
	{
		internal static bool Prefix(ClientChatSystem __instance, string text)
		{
			return LongChatRuntime.HandleInputEndEdit(__instance, text);
		}
	}
	internal static class ChatInputPatch
	{
		internal static void Postfix(ClientChatSystem __instance)
		{
			LongChatRuntime.ObserveChatWindow(__instance._ChatWindow);
		}
	}
	internal static class ChatUpdatePatch
	{
		internal static void Postfix()
		{
			LongChatRuntime.Tick();
		}
	}
	internal static class ClientSessionPatch
	{
		internal static void Prefix()
		{
			LongChatRuntime.ClearSession("client session ended");
		}
	}
	internal static class FinalChatFilterPatch
	{
		internal static bool Prefix(__c__DisplayClass55_1 __instance, string userNameFiltered)
		{
			DiagnosticLog.IncomingFiltered(__instance.filteredText, __instance.field_Public___c__DisplayClass55_0_0, userNameFiltered);
			return LongChatRuntime.HandleFinalFilteredMessage(__instance, userNameFiltered);
		}
	}
	internal static class OverheadChatPatch
	{
		internal static bool Prefix(ClientChatSystem __instance, ref NetworkIdLookupMap networkIdMap, NetworkId fromCharacterId, ref string filteredText)
		{
			//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)
			DiagnosticLog.OverheadRaw(filteredText, fromCharacterId);
			return LongChatRuntime.HandleOverheadChatMessage(fromCharacterId, ref filteredText);
		}
	}
}
namespace LongChat.Models
{
	public readonly record struct AssemblyKey(string SenderId, int Channel, string MessageId);
	internal sealed record IncomingContext(__c__DisplayClass55_1 Callback, ServerChatMessageType MessageType, string UserNameFiltered, string TimeStamp, bool ShowTimeStamp, bool IsLocalUser, bool IsUserAdmin)
	{
		[CompilerGenerated]
		public void Deconstruct(out __c__DisplayClass55_1 Callback, out ServerChatMessageType MessageType, out string UserNameFiltered, out string TimeStamp, out bool ShowTimeStamp, out bool IsLocalUser, out bool IsUserAdmin)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected I4, but got Unknown
			Callback = this.Callback;
			MessageType = (ServerChatMessageType)(int)this.MessageType;
			UserNameFiltered = this.UserNameFiltered;
			TimeStamp = this.TimeStamp;
			ShowTimeStamp = this.ShowTimeStamp;
			IsLocalUser = this.IsLocalUser;
			IsUserAdmin = this.IsUserAdmin;
		}
	}
	internal sealed record OutgoingMessage(EntityManager EntityManager, ChatMessageType MessageType, string MessageId, string OriginalText, IReadOnlyList<string> Frames, Action<string> SubmitFrame)
	{
		[CompilerGenerated]
		public void Deconstruct(out EntityManager EntityManager, out ChatMessageType MessageType, out string MessageId, out string OriginalText, out IReadOnlyList<string> Frames, out Action<string> SubmitFrame)
		{
			//IL_0002: 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_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected I4, but got Unknown
			EntityManager = this.EntityManager;
			MessageType = (ChatMessageType)(int)this.MessageType;
			MessageId = this.MessageId;
			OriginalText = this.OriginalText;
			Frames = this.Frames;
			SubmitFrame = this.SubmitFrame;
		}
	}
	public readonly record struct ParsedFrame(string MessageId, int Index, int Total, string Payload);
}
namespace LongChat.Diagnostics
{
	internal static class DiagnosticLog
	{
		private const string Prefix = "[LC-DIAG]";

		private const string RawPrefix = "[LC-RAW]";

		public static void Stage(string stage, string details)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			if (Plugin.Settings.LogTransportDiagnostics.Value)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(2, 3, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[LC-DIAG]");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(stage);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(details);
				}
				log.LogInfo(val);
			}
		}

		public static void IncomingFiltered(string? filteredText, __c__DisplayClass55_0? context, string? userNameFiltered)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			//IL_0090: 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_00b2: 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)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.Settings.LogIncomingRawMessages.Value)
			{
				string text = filteredText ?? string.Empty;
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(123, 12, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[LC-RAW]");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" chars=");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(text.Length);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" bytes=");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(Encoding.UTF8.GetByteCount(text));
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" ");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("type=");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>((context != null) ? ((int)context.messageType) : 0);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" fromUser=\"");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(RawLogEscaper.Escape((context != null) ? ((object)context.fromUser/*cast due to .constrained prefix*/).ToString() : null));
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\" ");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("fromCharacter=\"");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(RawLogEscaper.Escape((context != null) ? ((object)context.fromCharacterId/*cast due to .constrained prefix*/).ToString() : null));
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\" ");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("isLocalUser=");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<bool>(context != null && context.isSelf);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" userName=\"");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(RawLogEscaper.Escape(userNameFiltered));
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\" ");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("timeStamp=\"");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(RawLogEscaper.Escape((context != null) ? context.timeStamp : null));
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\" showTimeStamp=");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<bool>(context != null && context.showTimeStamp);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" ");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("isUserAdmin=");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<bool>(context != null && context.isUserAdmin);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" text=\"");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(RawLogEscaper.Escape(text));
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\"");
				}
				log.LogInfo(val);
			}
		}

		public unsafe static void OverheadRaw(string? rawText, NetworkId networkId)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			if (Plugin.Settings.LogIncomingRawMessages.Value)
			{
				string text = rawText ?? string.Empty;
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(49, 5, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("[LC-RAW]");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" overhead=true chars=");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(text.Length);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" bytes=");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(Encoding.UTF8.GetByteCount(text));
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" ");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("networkId=\"");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(RawLogEscaper.Escape(((object)(*(NetworkId*)(&networkId))/*cast due to .constrained prefix*/).ToString()));
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\" text=\"");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(RawLogEscaper.Escape(text));
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\"");
				}
				log.LogInfo(val);
			}
		}
	}
	public static class RawLogEscaper
	{
		public static string Escape(string? value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return string.Empty;
			}
			StringBuilder stringBuilder = new StringBuilder(value.Length);
			foreach (char c in value)
			{
				switch (c)
				{
				case '\\':
					stringBuilder.Append("\\\\");
					continue;
				case '"':
					stringBuilder.Append("\\\"");
					continue;
				case '\r':
					stringBuilder.Append("\\r");
					continue;
				case '\n':
					stringBuilder.Append("\\n");
					continue;
				case '\t':
					stringBuilder.Append("\\t");
					continue;
				}
				if (char.IsControl(c))
				{
					stringBuilder.Append("\\u");
					int num = c;
					stringBuilder.Append(num.ToString("X4"));
				}
				else
				{
					stringBuilder.Append(c);
				}
			}
			return stringBuilder.ToString();
		}
	}
}
namespace LongChat.Config
{
	internal sealed class LongChatConfig
	{
		public ConfigEntry<bool> Enabled { get; }

		public ConfigEntry<int> MaxInputCharacters { get; }

		public ConfigEntry<int> FrameByteLimit { get; }

		public ConfigEntry<int> SendDelayMilliseconds { get; }

		public ConfigEntry<int> AcknowledgementTimeoutMilliseconds { get; }

		public ConfigEntry<int> MaximumChunksPerMessage { get; }

		public ConfigEntry<int> MaximumQueuedMessages { get; }

		public ConfigEntry<int> AssemblyTimeoutMilliseconds { get; }

		public ConfigEntry<int> MaximumActiveAssemblies { get; }

		public ConfigEntry<int> MaximumBufferedBytes { get; }

		public ConfigEntry<bool> EnableOverheadReconstruction { get; }

		public ConfigEntry<int> MaxOverheadCharacters { get; }

		public ConfigEntry<bool> EnableOverheadWrapping { get; }

		public ConfigEntry<int> MaxOverheadLineCharacters { get; }

		public ConfigEntry<bool> EnableLocal { get; }

		public ConfigEntry<bool> EnableGlobal { get; }

		public ConfigEntry<bool> EnableClan { get; }

		public ConfigEntry<bool> DisableSplittingForCommands { get; }

		public ConfigEntry<string> CommandPrefixes { get; }

		public ConfigEntry<bool> LogTransportDiagnostics { get; }

		public ConfigEntry<bool> LogIncomingRawMessages { get; }

		public ConfigEntry<bool> LogPatchDiscovery { get; }

		public LongChatConfig(ConfigFile config)
		{
			Enabled = config.Bind<bool>("General", "Enabled", true, "Enable LongChat.");
			MaxInputCharacters = config.Bind<int>("General", "MaxInputCharacters", 4096, "Maximum characters accepted by the chat input.");
			FrameByteLimit = config.Bind<int>("Transport", "FrameByteLimit", 120, "Maximum UTF-8 bytes in each transmitted frame. Values are clamped to 64-120.");
			SendDelayMilliseconds = config.Bind<int>("Transport", "SendDelayMilliseconds", 1, "Delay between multipart frames.");
			AcknowledgementTimeoutMilliseconds = config.Bind<int>("Transport", "AcknowledgementTimeoutMilliseconds", 3000, "Time to wait for the server to echo each multipart frame.");
			MaximumChunksPerMessage = config.Bind<int>("Transport", "MaximumChunksPerMessage", 32, "Maximum frames in one long message.");
			MaximumQueuedMessages = config.Bind<int>("Transport", "MaximumQueuedMessages", 8, "Maximum long messages waiting to send.");
			AssemblyTimeoutMilliseconds = config.Bind<int>("Receiving", "AssemblyTimeoutMilliseconds", 3000, "Time before an incomplete message is displayed partially.");
			MaximumActiveAssemblies = config.Bind<int>("Receiving", "MaximumActiveAssemblies", 32, "Maximum simultaneous incoming multipart messages.");
			MaximumBufferedBytes = config.Bind<int>("Receiving", "MaximumBufferedBytes", 262144, "Maximum incoming multipart payload bytes.");
			EnableOverheadReconstruction = config.Bind<bool>("Receiving", "EnableOverheadReconstruction", true, "Suppress multipart transport frames in overhead chat bubbles and show one reconstructed bubble.");
			MaxOverheadCharacters = config.Bind<int>("Receiving", "MaxOverheadCharacters", 500, "Maximum characters shown in a reconstructed overhead chat bubble. Main chat still shows the full message.");
			EnableOverheadWrapping = config.Bind<bool>("Receiving", "EnableOverheadWrapping", true, "Insert line breaks into reconstructed overhead chat bubbles.");
			MaxOverheadLineCharacters = config.Bind<int>("Receiving", "MaxOverheadLineCharacters", 80, "Maximum characters per reconstructed overhead chat bubble line.");
			EnableLocal = config.Bind<bool>("Channels", "EnableLocal", true, "Enable Region and Local chat splitting.");
			EnableGlobal = config.Bind<bool>("Channels", "EnableGlobal", true, "Enable Global chat splitting.");
			EnableClan = config.Bind<bool>("Channels", "EnableClan", true, "Enable Clan chat splitting.");
			DisableSplittingForCommands = config.Bind<bool>("Commands", "DisableSplittingForCommands", true, "Reject oversized command messages instead of splitting them.");
			CommandPrefixes = config.Bind<string>("Commands", "CommandPrefixes", ".,/!", "Characters that identify chat commands.");
			LogTransportDiagnostics = config.Bind<bool>("Debug", "LogTransportDiagnostics", false, "Log content-free multipart routing, acknowledgement, and recovery diagnostics.");
			LogIncomingRawMessages = config.Bind<bool>("Debug", "LogIncomingRawMessages", false, "Log complete formatted incoming chat text and metadata for temporary diagnostics. This may record private chat.");
			LogPatchDiscovery = config.Bind<bool>("Debug", "LogPatchDiscovery", false, "Log resolved Harmony patch targets.");
		}
	}
}
namespace System.Runtime.CompilerServices
{
	internal static class IsExternalInit
	{
	}
}