using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using OdinSerializer;
using OdinSerializer.Utilities;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;
using UnityNetMessages.Events;
using UnityNetMessages.Logging;
using UnityNetMessages.OdinSerializer;
using UnityNetMessages.Patches;

[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("UnityNetworkMessages")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("UnityNetworkMessages")]
[assembly: AssemblyTitle("UnityNetworkMessages")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace UnityNetMessages
{
	[BepInPlugin("Saradora.UnityNetworkMessages", "Unity Network Messagin", "2.0.0")]
	public class Plugin : BaseUnityPlugin
	{
		private readonly Harmony _harmonyInstance = new Harmony("Saradora.UnityNetworkMessages");

		private void Awake()
		{
			_harmonyInstance.PatchAll();
		}
	}
	public static class UnityNetworkMessages
	{
		public const string ModGuid = "Saradora.UnityNetworkMessages";

		public const string ModVersion = "2.0.0";

		public const string ModName = "Unity Network Messagin";
	}
	public static class Hashing
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe static uint Hash32(byte* input, int length, uint seed = 0u)
		{
			uint num = seed + 374761393;
			if (length >= 16)
			{
				uint num2 = seed - 1640531535 - 2048144777;
				uint num3 = seed + 2246822519u;
				uint num4 = seed;
				uint num5 = seed - 2654435761u;
				int num6 = length >> 4;
				for (int i = 0; i < num6; i++)
				{
					uint num7 = *(uint*)input;
					uint num8 = *(uint*)(input + 4);
					uint num9 = *(uint*)(input + 8);
					uint num10 = *(uint*)(input + 12);
					uint num11 = num2 + (uint)((int)num7 * -2048144777);
					num2 = ((num11 << 13) | (num11 >> 19)) * 2654435761u;
					uint num12 = num3 + (uint)((int)num8 * -2048144777);
					num3 = ((num12 << 13) | (num12 >> 19)) * 2654435761u;
					uint num13 = num4 + (uint)((int)num9 * -2048144777);
					num4 = ((num13 << 13) | (num13 >> 19)) * 2654435761u;
					uint num14 = num5 + (uint)((int)num10 * -2048144777);
					num5 = ((num14 << 13) | (num14 >> 19)) * 2654435761u;
					input += 16;
				}
				num = ((num2 << 1) | (num2 >> 31)) + ((num3 << 7) | (num3 >> 25)) + ((num4 << 12) | (num4 >> 20)) + ((num5 << 18) | (num5 >> 14));
			}
			uint num15 = num + (uint)length;
			for (length &= 0xF; length >= 4; length -= 4)
			{
				uint num16 = num15 + (uint)((int)(*(uint*)input) * -1028477379);
				num15 = ((num16 << 17) | (num16 >> 15)) * 668265263;
				input += 4;
			}
			while (length > 0)
			{
				uint num17 = num15 + (uint)(*input * 374761393);
				num15 = ((num17 << 11) | (num17 >> 21)) * 2654435761u;
				input++;
				length--;
			}
			int num18 = (int)(num15 ^ (num15 >> 15)) * -2048144777;
			int num19 = (num18 ^ (num18 >>> 13)) * -1028477379;
			return (uint)num19 ^ ((uint)num19 >> 16);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public unsafe static uint Hash32(this byte[] buffer)
		{
			int length = buffer.Length;
			fixed (byte* input = buffer)
			{
				return Hash32(input, length);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint Hash32(this string text)
		{
			return Encoding.UTF8.GetBytes(text).Hash32();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint Hash32(this Type type)
		{
			return type.FullName.Hash32();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint Hash32<T>()
		{
			return typeof(T).Hash32();
		}
	}
}
namespace UnityNetMessages.Logging
{
	public static class Log
	{
		private static readonly Dictionary<Assembly, ManualLogSource> LOGSources = new Dictionary<Assembly, ManualLogSource>();

		public static void Print(object message)
		{
			GetLogger(Assembly.GetCallingAssembly()).LogInfo(message ?? "Null");
		}

		public static void Warning(object message)
		{
			GetLogger(Assembly.GetCallingAssembly()).LogWarning(message ?? "Null");
		}

		public static void Error(object message)
		{
			GetLogger(Assembly.GetCallingAssembly()).LogError(message ?? "Null");
		}

		public static void Exception(Exception exception)
		{
			GetLogger(Assembly.GetCallingAssembly()).LogError((object)(exception?.Message ?? "Null"));
		}

		private static ManualLogSource GetLogger(Assembly assembly)
		{
			if (LOGSources.TryGetValue(assembly, out var value))
			{
				return value;
			}
			LOGSources[assembly] = Logger.CreateLogSource(assembly.GetName().Name);
			return LOGSources[assembly];
		}
	}
}
namespace UnityNetMessages.OdinSerializer
{
	internal sealed class CachedMemoryStream : ICacheNotificationReceiver
	{
		public static int InitialCapacity = 1024;

		public static int MaxCapacity = 32768;

		private MemoryStream memoryStream;

		public MemoryStream MemoryStream
		{
			get
			{
				if (!memoryStream.CanRead)
				{
					memoryStream = new MemoryStream(InitialCapacity);
				}
				return memoryStream;
			}
		}

		public CachedMemoryStream()
		{
			memoryStream = new MemoryStream(InitialCapacity);
		}

		public void OnFreed()
		{
			memoryStream.SetLength(0L);
			memoryStream.Position = 0L;
			if (memoryStream.Capacity > MaxCapacity)
			{
				memoryStream.Capacity = MaxCapacity;
			}
		}

		public void OnClaimed()
		{
			memoryStream.SetLength(0L);
			memoryStream.Position = 0L;
		}

		public static Cache<CachedMemoryStream> Claim(int minCapacity)
		{
			Cache<CachedMemoryStream> val = Cache<CachedMemoryStream>.Claim();
			if (val.Value.MemoryStream.Capacity < minCapacity)
			{
				val.Value.MemoryStream.Capacity = minCapacity;
			}
			return val;
		}

		public static Cache<CachedMemoryStream> Claim(byte[] bytes = null)
		{
			Cache<CachedMemoryStream> val = Cache<CachedMemoryStream>.Claim();
			if (bytes != null)
			{
				val.Value.MemoryStream.Write(bytes, 0, bytes.Length);
				val.Value.MemoryStream.Position = 0L;
			}
			return val;
		}
	}
	public static class Serialization
	{
		public static T Deserialize<T>(byte[] bytes)
		{
			return (T)Deserialize(bytes, typeof(T));
		}

		public static object Deserialize(byte[] bytes, Type type)
		{
			Cache<CachedMemoryStream> val = CachedMemoryStream.Claim(bytes);
			try
			{
				Cache<BinaryDataReader> obj = Cache<BinaryDataReader>.Claim();
				BinaryDataReader value = obj.Value;
				((BaseDataReader)value).Stream = val.Value.MemoryStream;
				((BaseDataReader)value).Context = null;
				((BaseDataReader)value).PrepareNewSerializationSession();
				IDataReader val2 = (IDataReader)(object)value;
				IDisposable disposable = (IDisposable)obj;
				try
				{
					Cache<DeserializationContext> val3 = Cache<DeserializationContext>.Claim();
					try
					{
						val2.Context = Cache<DeserializationContext>.op_Implicit(val3);
						return Serializer.Get(type).ReadValueWeak(val2);
					}
					finally
					{
						((IDisposable)val3)?.Dispose();
					}
				}
				finally
				{
					disposable.Dispose();
				}
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
		}
	}
}
namespace UnityNetMessages.Patches
{
	[HarmonyPatch(typeof(NetworkManager))]
	public static class NetworkManager_Patching
	{
		private static NetworkManager _currentSingleton;

		private static CustomMessagingManager _currentMessagingManager;

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPostfix]
		private static void Singleton_SetterPostfix(NetworkManager value)
		{
			if (!((Object)(object)_currentSingleton == (Object)(object)value))
			{
				if ((Object)(object)value == (Object)null)
				{
					CustomMessagingManager_SetterPostfix(null);
				}
				NetworkMessaging.TriggerSingletonChange(value);
				_currentSingleton = value;
			}
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPostfix]
		private static void CustomMessagingManager_SetterPostfix(CustomMessagingManager value)
		{
			if (_currentMessagingManager != value)
			{
				NetworkMessaging.TriggerMessengerChange(value);
				_currentMessagingManager = value;
			}
		}
	}
	[HarmonyPatch(typeof(NetworkObject))]
	public static class NetworkObject_Patching
	{
		private static Dictionary<NetworkObject, Action<ulong>> _networkIdsEvents = new Dictionary<NetworkObject, Action<ulong>>();

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPostfix]
		private static void NetworkObjectId_SetterPostfix(ulong value, NetworkObject __instance)
		{
			if (_networkIdsEvents.ContainsKey(__instance))
			{
				_networkIdsEvents[__instance]?.Invoke(value);
			}
		}

		public static void RegisterToObjectIdChanges(this NetworkObject obj, Action<ulong> action)
		{
			if (!_networkIdsEvents.ContainsKey(obj))
			{
				_networkIdsEvents.Add(obj, action);
				return;
			}
			Dictionary<NetworkObject, Action<ulong>> networkIdsEvents = _networkIdsEvents;
			networkIdsEvents[obj] = (Action<ulong>)Delegate.Combine(networkIdsEvents[obj], action);
		}

		public static void UnregisterFromObjectIdChanges(this NetworkObject obj, Action<ulong> action)
		{
			if (_networkIdsEvents.ContainsKey(obj))
			{
				Dictionary<NetworkObject, Action<ulong>> networkIdsEvents = _networkIdsEvents;
				networkIdsEvents[obj] = (Action<ulong>)Delegate.Remove(networkIdsEvents[obj], action);
				if (_networkIdsEvents[obj] == null)
				{
					_networkIdsEvents.Remove(obj);
				}
			}
		}

		[HarmonyPatch("OnDestroy")]
		[HarmonyPrefix]
		private static void OnDestroy_Prefix(NetworkObject __instance)
		{
			if (_networkIdsEvents.ContainsKey(__instance))
			{
				_networkIdsEvents[__instance]?.Invoke(0uL);
				_networkIdsEvents.Remove(__instance);
			}
		}
	}
}
namespace UnityNetMessages.Events
{
	public class GlobalNetEvent : NetEventBase
	{
		private readonly uint _hash;

		public GlobalNetEvent(string name, bool assemblySpecific = false)
		{
			string text = name;
			if (assemblySpecific)
			{
				text = Assembly.GetCallingAssembly().GetName().Name + "+" + text;
			}
			_hash = text.Hash32();
			RegisterEvent<NetworkEvent>();
		}

		protected override uint? GetHash()
		{
			return _hash;
		}
	}
	public class GlobalNetMessage<T> : NetMessageBase<T>
	{
		private readonly uint _hash;

		public GlobalNetMessage(string name, bool assemblySpecific = false)
		{
			string text = name;
			if (assemblySpecific)
			{
				text = Assembly.GetCallingAssembly().GetName().Name + "+" + text;
			}
			_hash = text.Hash32();
			RegisterEvent<T>();
		}

		protected override uint? GetHash()
		{
			return _hash;
		}
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	internal struct NetworkEvent
	{
	}
	public class MessageHandler
	{
		private readonly List<WeakReference> _actions = new List<WeakReference>();

		public Type ReturnType { get; }

		public bool IsEmpty
		{
			get
			{
				if (_actions.Count <= 0)
				{
					return true;
				}
				foreach (WeakReference action in _actions)
				{
					if (action.IsAlive)
					{
						return false;
					}
				}
				return true;
			}
		}

		private MessageHandler(MessageReceiver action, Type returnType)
		{
			ReturnType = returnType;
			_actions.Add(new WeakReference(action));
		}

		public static MessageHandler Create<TReturnType>(MessageReceiver action)
		{
			return new MessageHandler(action, typeof(TReturnType));
		}

		public void Subscribe<TReturnType>(MessageReceiver action)
		{
			if (ReturnType != typeof(TReturnType))
			{
				throw new ArgumentException("Cannot create network event with type " + typeof(TReturnType).Name + " because an event with the same name already exists with a different type of " + ReturnType.Name + ".");
			}
			foreach (WeakReference action2 in _actions)
			{
				if (action2.Target == action)
				{
					return;
				}
			}
			_actions.Add(new WeakReference(action));
		}

		public void Unsubscribe(MessageReceiver action)
		{
			foreach (WeakReference action2 in _actions)
			{
				if (action2.IsAlive && action2.Target == action)
				{
					_actions.Remove(action2);
					break;
				}
			}
		}

		public void RaiseEvent(ulong clientId)
		{
			for (int num = _actions.Count - 1; num >= 0; num--)
			{
				WeakReference weakReference = _actions[num];
				if (!weakReference.IsAlive)
				{
					_actions.RemoveAt(num);
				}
				else
				{
					((MessageReceiver)weakReference.Target).Invoke(clientId, null);
				}
			}
		}

		public void RaiseMessage(ulong clientId, FastBufferReader buffer)
		{
			int num = ((FastBufferReader)(ref buffer)).Length - 1 - 4;
			if (num < 0)
			{
				return;
			}
			if (num == 0)
			{
				RaiseEvent(clientId);
			}
			object obj = null;
			if (!((FastBufferReader)(ref buffer)).TryBeginRead(num))
			{
				Log.Error("Couldn't read buffer");
				return;
			}
			byte[] bytes = new byte[num];
			((FastBufferReader)(ref buffer)).ReadBytes(ref bytes, num, 0);
			obj = Serialization.Deserialize(bytes, ReturnType);
			for (int num2 = _actions.Count - 1; num2 >= 0; num2--)
			{
				WeakReference weakReference = _actions[num2];
				if (!weakReference.IsAlive)
				{
					_actions.RemoveAt(num2);
				}
				else
				{
					((MessageReceiver)weakReference.Target).Invoke(clientId, obj);
				}
			}
		}
	}
	public abstract class MessageReceiver : IDisposable
	{
		private bool _disposed;

		internal void RegisterEvent<TReturnType>()
		{
			uint? hashInternal = GetHashInternal();
			if (!hashInternal.HasValue)
			{
				throw new NullReferenceException("Cannot register event as it is uninitialized.");
			}
			NetworkMessaging.RegisterEvent<TReturnType>(hashInternal.Value, this);
		}

		internal void UnregisterEvent()
		{
			uint? hashInternal = GetHashInternal();
			if (hashInternal.HasValue)
			{
				NetworkMessaging.UnregisterEvent(hashInternal.Value, this);
			}
		}

		internal void Invoke(ulong senderId, object data)
		{
			OnReceiveMessage(senderId, data);
		}

		protected abstract uint? GetHash();

		protected abstract void OnReceiveMessage(ulong senderId, object data);

		protected uint? GetHashInternal()
		{
			if (!_disposed)
			{
				return GetHash();
			}
			return null;
		}

		~MessageReceiver()
		{
			Dispose();
		}

		public void Dispose()
		{
			if (!_disposed)
			{
				_disposed = true;
				DoDispose();
			}
		}

		protected virtual void DoDispose()
		{
			UnregisterEvent();
		}
	}
	public abstract class NetEventBase : MessageReceiver
	{
		public event Action<ulong> EventReceived;

		public event Action<ulong> EventReceivedFromClient;

		public event Action EventReceivedFromServer;

		protected override void OnReceiveMessage(ulong senderId, object data)
		{
			this.EventReceived?.Invoke(senderId);
			if (senderId == NetworkMessaging.ServerClientId)
			{
				this.EventReceivedFromServer?.Invoke();
			}
			else
			{
				this.EventReceivedFromClient?.Invoke(senderId);
			}
		}

		private FastBufferWriter GetWriterAndHash(out uint outHash)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			uint? hash = GetHash();
			if (!hash.HasValue)
			{
				throw new NullReferenceException("Cannot send as it is uninitialized.");
			}
			FastBufferWriter writer = NetworkMessaging.GetWriter(EMessageType.Event, hash.Value, 0);
			outHash = hash.Value;
			return writer;
		}

		public void InvokeOnServer(NetworkDelivery delivery = 3)
		{
			//IL_0003: 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_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)
			uint outHash;
			FastBufferWriter writerAndHash = GetWriterAndHash(out outHash);
			try
			{
				NetworkMessaging.TrySendMessageToServer<NetworkEvent>(outHash, writerAndHash, delivery);
			}
			finally
			{
				((IDisposable)(FastBufferWriter)(ref writerAndHash)).Dispose();
			}
		}

		public void InvokeOnClient(ulong clientId, NetworkDelivery delivery = 3)
		{
			//IL_0003: 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_000b: 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)
			uint outHash;
			FastBufferWriter writerAndHash = GetWriterAndHash(out outHash);
			try
			{
				NetworkMessaging.TrySendMessageToClient<NetworkEvent>(outHash, clientId, writerAndHash, delivery);
			}
			finally
			{
				((IDisposable)(FastBufferWriter)(ref writerAndHash)).Dispose();
			}
		}

		public void InvokeOnAllClients(bool includeHost = false, NetworkDelivery delivery = 3)
		{
			//IL_0003: 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_000a: 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)
			uint outHash;
			FastBufferWriter writerAndHash = GetWriterAndHash(out outHash);
			try
			{
				NetworkMessaging.TrySendMessageToAllClients<NetworkEvent>(outHash, writerAndHash, includeHost, delivery);
			}
			finally
			{
				((IDisposable)(FastBufferWriter)(ref writerAndHash)).Dispose();
			}
		}
	}
	public abstract class NetMessageBase<T> : MessageReceiver
	{
		public event Action<T, ulong> MessageReceived;

		public event Action<T, ulong> MessageReceivedFromClient;

		public event Action<T> MessageReceivedFromServer;

		protected override void OnReceiveMessage(ulong senderId, object data)
		{
			if (data is T)
			{
				T val = (T)data;
				this.MessageReceived?.Invoke(val, senderId);
				if (senderId == NetworkMessaging.ServerClientId)
				{
					this.MessageReceivedFromServer?.Invoke(val);
				}
				else
				{
					this.MessageReceivedFromClient?.Invoke(val, senderId);
				}
			}
		}

		private bool TryGetWriterAndHash(T data, out uint outHash, out FastBufferWriter outWriter)
		{
			//IL_005c: 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)
			uint? hash = GetHash();
			if (!hash.HasValue)
			{
				throw new NullReferenceException("Cannot send as it is uninitialized.");
			}
			byte[] array;
			try
			{
				array = SerializationUtility.SerializeValue<T>(data, (DataFormat)0, (SerializationContext)null);
			}
			catch
			{
				Log.Exception(new Exception("Cannot serialize type " + data.GetType().Name));
				throw;
			}
			outWriter = NetworkMessaging.GetWriter(EMessageType.Data, hash.Value, array.Length);
			((FastBufferWriter)(ref outWriter)).WriteBytes(array, -1, 0);
			outHash = hash.Value;
			return true;
		}

		public void SendToServer(T data, NetworkDelivery delivery = 3)
		{
			//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_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)
			if (!TryGetWriterAndHash(data, out var outHash, out var outWriter))
			{
				return;
			}
			FastBufferWriter val = outWriter;
			try
			{
				NetworkMessaging.TrySendMessageToServer<T>(outHash, outWriter, delivery);
			}
			catch (Exception exception)
			{
				Log.Exception(exception);
			}
			finally
			{
				((IDisposable)(FastBufferWriter)(ref val)).Dispose();
			}
		}

		public void SendToClient(T data, ulong clientId, NetworkDelivery delivery = 3)
		{
			//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_0012: 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)
			if (!TryGetWriterAndHash(data, out var outHash, out var outWriter))
			{
				return;
			}
			FastBufferWriter val = outWriter;
			try
			{
				NetworkMessaging.TrySendMessageToClient<T>(outHash, clientId, outWriter, delivery);
			}
			catch (Exception exception)
			{
				Log.Exception(exception);
			}
			finally
			{
				((IDisposable)(FastBufferWriter)(ref val)).Dispose();
			}
		}

		public void SendToAllClients(T data, bool includeHost = false, NetworkDelivery delivery = 3)
		{
			//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_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)
			if (!TryGetWriterAndHash(data, out var outHash, out var outWriter))
			{
				return;
			}
			FastBufferWriter val = outWriter;
			try
			{
				NetworkMessaging.TrySendMessageToAllClients<T>(outHash, outWriter, includeHost, delivery);
			}
			catch (Exception exception)
			{
				Log.Exception(exception);
			}
			finally
			{
				((IDisposable)(FastBufferWriter)(ref val)).Dispose();
			}
		}
	}
	public enum EMessageType : byte
	{
		Event,
		Data
	}
	public static class NetworkMessaging
	{
		private static readonly Dictionary<uint, MessageHandler> _registeredMessages;

		private static CustomMessagingManager _messenger;

		private static readonly List<ulong> _clientIds;

		public static bool IsServer => NetworkManager.Singleton.IsServer;

		public static ulong ServerClientId => 0uL;

		public static IReadOnlyList<ulong> NonHostClientIds
		{
			get
			{
				IReadOnlyList<ulong> connectedClientsIds = NetworkManager.Singleton.ConnectedClientsIds;
				_clientIds.Clear();
				ulong num = 0uL;
				foreach (ulong item in connectedClientsIds)
				{
					if (item != num)
					{
						_clientIds.Add(item);
					}
				}
				return _clientIds;
			}
		}

		public static event Action<NetworkManager> SingletonChanged;

		public static event Action<CustomMessagingManager> MessagingManagerChanged;

		internal static void TriggerSingletonChange(NetworkManager singleton)
		{
			NetworkMessaging.SingletonChanged?.Invoke(singleton);
		}

		internal static void TriggerMessengerChange(CustomMessagingManager messenger)
		{
			NetworkMessaging.MessagingManagerChanged?.Invoke(messenger);
		}

		public static FastBufferWriter GetWriter(EMessageType messageType, uint hash, int size)
		{
			//IL_0019: 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_002b: 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_0075: 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)
			//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)
			FastBufferWriter result = default(FastBufferWriter);
			switch (messageType)
			{
			case EMessageType.Event:
				((FastBufferWriter)(ref result))..ctor(5, (Allocator)2, -1);
				((FastBufferWriter)(ref result)).WriteValue<EMessageType>(ref messageType, default(ForEnums));
				((FastBufferWriter)(ref result)).WriteValue<uint>(ref hash, default(ForPrimitives));
				break;
			case EMessageType.Data:
				((FastBufferWriter)(ref result))..ctor(5 + size, (Allocator)2, -1);
				((FastBufferWriter)(ref result)).WriteValue<EMessageType>(ref messageType, default(ForEnums));
				((FastBufferWriter)(ref result)).WriteValue<uint>(ref hash, default(ForPrimitives));
				break;
			default:
				((FastBufferWriter)(ref result))..ctor(1, (Allocator)2, -1);
				break;
			}
			return result;
		}

		static NetworkMessaging()
		{
			_registeredMessages = new Dictionary<uint, MessageHandler>();
			_clientIds = new List<ulong>();
			MessagingManagerChanged -= OnMessagingManagerChanged;
			MessagingManagerChanged += OnMessagingManagerChanged;
		}

		private static void OnMessagingManagerChanged(CustomMessagingManager instance)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			if (_messenger != null)
			{
				_messenger.OnUnnamedMessage -= new UnnamedMessageDelegate(OnUnnamedMessageReceived);
			}
			_messenger = instance;
			if (_messenger != null)
			{
				_messenger.OnUnnamedMessage += new UnnamedMessageDelegate(OnUnnamedMessageReceived);
			}
		}

		private static void OnUnnamedMessageReceived(ulong clientId, FastBufferReader bufferReader)
		{
			//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_003c: 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_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_0090: Unknown result type (might be due to invalid IL or missing references)
			EMessageType eMessageType = EMessageType.Event;
			if (!((FastBufferReader)(ref bufferReader)).TryBeginReadValue<EMessageType>(ref eMessageType))
			{
				return;
			}
			((FastBufferReader)(ref bufferReader)).ReadValue<EMessageType>(ref eMessageType, default(ForEnums));
			uint key = 0u;
			MessageHandler value;
			switch (eMessageType)
			{
			case EMessageType.Event:
				if (((FastBufferReader)(ref bufferReader)).TryBeginReadValue<uint>(ref key))
				{
					((FastBufferReader)(ref bufferReader)).ReadValue<uint>(ref key, default(ForPrimitives));
					if (_registeredMessages.TryGetValue(key, out value))
					{
						value.RaiseEvent(clientId);
					}
				}
				break;
			case EMessageType.Data:
				if (((FastBufferReader)(ref bufferReader)).TryBeginReadValue<uint>(ref key))
				{
					((FastBufferReader)(ref bufferReader)).ReadValue<uint>(ref key, default(ForPrimitives));
					if (_registeredMessages.TryGetValue(key, out value))
					{
						value.RaiseMessage(clientId, bufferReader);
					}
				}
				break;
			}
		}

		public static void RegisterEvent<TReturnType>(uint hash, MessageReceiver action)
		{
			if (!_registeredMessages.ContainsKey(hash))
			{
				_registeredMessages[hash] = MessageHandler.Create<TReturnType>(action);
			}
			else
			{
				_registeredMessages[hash].Subscribe<TReturnType>(action);
			}
		}

		public static void UnregisterEvent(uint hash, MessageReceiver action)
		{
			if (_registeredMessages.ContainsKey(hash))
			{
				MessageHandler messageHandler = _registeredMessages[hash];
				messageHandler.Unsubscribe(action);
				if (messageHandler.IsEmpty)
				{
					_registeredMessages.Remove(hash);
				}
			}
		}

		public static void TrySendMessageToServer<TReturnType>(uint hash, FastBufferWriter writer, NetworkDelivery delivery = 3)
		{
			//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)
			if (IsServer)
			{
				Log.Warning("Message couldn't be sent because you are the server.");
			}
			else
			{
				TrySendMessageToClientInternal<TReturnType>(hash, ServerClientId, writer, delivery);
			}
		}

		public static void TrySendMessageToClient<TReturnType>(uint hash, ulong clientId, FastBufferWriter writer, NetworkDelivery delivery = 3)
		{
			//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)
			if (!IsServer)
			{
				Log.Warning("Message couldn't be sent because you are not the server.");
			}
			else
			{
				TrySendMessageToClientInternal<TReturnType>(hash, clientId, writer, delivery);
			}
		}

		public static void TrySendMessageToAllClients<TReturnType>(uint hash, FastBufferWriter writer, bool includeHost, NetworkDelivery delivery = 3)
		{
			//IL_0035: 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_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)
			if (!IsServer)
			{
				Log.Warning("Message couldn't be sent because you are not the server.");
			}
			else if (ValidateHandler<TReturnType>(hash))
			{
				if (includeHost)
				{
					_messenger.SendUnnamedMessageToAll(writer, delivery);
				}
				else
				{
					_messenger.SendUnnamedMessage(NonHostClientIds, writer, delivery);
				}
			}
		}

		private static void TrySendMessageToClientInternal<TReturnType>(uint hash, ulong clientId, FastBufferWriter writer, NetworkDelivery delivery)
		{
			//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 (ValidateHandler<TReturnType>(hash))
			{
				_messenger.SendUnnamedMessage(clientId, writer, delivery);
			}
		}

		private static bool ValidateHandler<TReturnType>(uint hash)
		{
			if (_messenger == null)
			{
				Log.Warning("Message couldn't be sent because messenger isn't active");
				return false;
			}
			if (!_registeredMessages.TryGetValue(hash, out var value))
			{
				Log.Warning("Message couldn't be sent because it wasn't registered to the messenger");
				return false;
			}
			if (value.ReturnType != typeof(TReturnType))
			{
				Log.Error("Message couldn't be sent because the registered event with the same name has a different return type.");
				return false;
			}
			return true;
		}
	}
	public class ObjectMessageLink<TReturnType>
	{
		private readonly string _baseName;

		private readonly NetworkObject _targetObject;

		private readonly MessageReceiver _messageReceiver;

		public uint? Hash { get; private set; }

		public ObjectMessageLink(string baseName, NetworkObject obj, MessageReceiver receiver)
		{
			Hash = null;
			_baseName = baseName;
			_targetObject = obj;
			_messageReceiver = receiver;
			RegisterNetworkObject();
			_targetObject.RegisterToObjectIdChanges(OnNetworkObjectIdChanged);
		}

		private void OnNetworkObjectIdChanged(ulong value)
		{
			if (value != 0L)
			{
				RegisterNetworkObject();
			}
			else
			{
				Dispose();
			}
		}

		private void RegisterNetworkObject()
		{
			if (_targetObject.NetworkObjectId != 0L)
			{
				if (Hash.HasValue)
				{
					UnregisterNetworkObject();
				}
				Hash = $"obj{_targetObject.NetworkObjectId}+{_baseName}".Hash32();
				_messageReceiver.RegisterEvent<TReturnType>();
			}
		}

		private void UnregisterNetworkObject()
		{
			if (Hash.HasValue)
			{
				_messageReceiver.UnregisterEvent();
				Hash = null;
			}
		}

		public void Dispose()
		{
			UnregisterNetworkObject();
			if ((Object)(object)_targetObject != (Object)null)
			{
				_targetObject.UnregisterFromObjectIdChanges(OnNetworkObjectIdChanged);
			}
		}
	}
	public class ObjectNetEvent : NetEventBase
	{
		private readonly ObjectMessageLink<NetworkEvent> _objectMessageLink;

		public ObjectNetEvent(string name, NetworkObject targetObject, bool assemblySpecific = false)
		{
			if ((Object)(object)targetObject == (Object)null)
			{
				throw new NullReferenceException("Cannot create an object event without a target object.");
			}
			if (assemblySpecific)
			{
				name = Assembly.GetCallingAssembly().GetName().Name + "+" + name;
			}
			_objectMessageLink = new ObjectMessageLink<NetworkEvent>(name, targetObject, this);
		}

		protected override uint? GetHash()
		{
			return _objectMessageLink.Hash;
		}

		protected override void DoDispose()
		{
			_objectMessageLink.Dispose();
		}
	}
	public class ObjectNetMessage<T> : NetMessageBase<T>
	{
		private readonly ObjectMessageLink<T> _objectMessageLink;

		public ObjectNetMessage(string name, NetworkObject targetObject, bool assemblySpecific = false)
		{
			if ((Object)(object)targetObject == (Object)null)
			{
				throw new NullReferenceException("Cannot create an object event without a target object.");
			}
			if (assemblySpecific)
			{
				name = Assembly.GetCallingAssembly().GetName().Name + "+" + name;
			}
			_objectMessageLink = new ObjectMessageLink<T>(name, targetObject, this);
		}

		protected override uint? GetHash()
		{
			return _objectMessageLink.Hash;
		}

		protected override void DoDispose()
		{
			_objectMessageLink.Dispose();
		}
	}
}