using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Mirror;
using Mirror.RemoteCalls;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Mirror")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("com.github.darmuh.MirrorPlumber")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.3.0.0")]
[assembly: AssemblyInformationalVersion("0.3.0+ab4e1d8b9bf34f25fe00ce640b24bed33bf755d1")]
[assembly: AssemblyProduct("com.github.darmuh.MirrorPlumber")]
[assembly: AssemblyTitle("MirrorPlumber")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.3.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.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]
	[Microsoft.CodeAnalysis.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]
	[Microsoft.CodeAnalysis.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 BepInEx
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class BepInAutoPluginAttribute : Attribute
	{
		public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace BepInEx.Preloader.Core.Patching
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class PatcherAutoPluginAttribute : Attribute
	{
		public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace MirrorPlumber
{
	public class BehaviourAdder
	{
		private static readonly List<KeyValuePair<BehaviourAdder, uint>> PrefabAddons = new List<KeyValuePair<BehaviourAdder, uint>>();

		private static readonly List<BehaviourAdder> PlayerPrefabAddons = new List<BehaviourAdder>();

		private bool IsPlayerPrefab;

		private Type? NewBehaviour;

		internal static bool Frozen = false;

		public void AddToPlayerPrefab<T>() where T : NetworkBehaviour
		{
			IsPlayerPrefab = true;
			NewBehaviour = typeof(T);
			PlayerPrefabAddons.Add(this);
		}

		public void AddToPrefab<T>(uint assetId) where T : NetworkBehaviour
		{
			NewBehaviour = typeof(T);
			PrefabAddons.Add(new KeyValuePair<BehaviourAdder, uint>(this, assetId));
		}

		internal static void FreezeEvent(NetworkManager networkManager)
		{
			if (Frozen)
			{
				return;
			}
			Plugin.Log.LogDebug((object)">>>BehaviourAdder Freeze Event<<<");
			if ((Object)(object)networkManager.playerPrefab.GetComponent<NetworkIdentity>() == (Object)null)
			{
				Plugin.Log.LogWarning((object)"Player Prefab does not have a NetworkIdentity!!\r\nOur added NetworkBehaviors will not work and have not been added\r\nFreeze event canceled.");
				return;
			}
			int num = 0;
			int num2 = 0;
			foreach (BehaviourAdder playerPrefabAddon in PlayerPrefabAddons)
			{
				if (!(playerPrefabAddon.NewBehaviour == null) && playerPrefabAddon.IsPlayerPrefab)
				{
					Type newBehaviour = playerPrefabAddon.NewBehaviour;
					if (!((Object)(object)networkManager.playerPrefab.GetComponent(newBehaviour) != (Object)null))
					{
						networkManager.playerPrefab.AddComponent(newBehaviour);
						num++;
					}
				}
			}
			if (PrefabAddons.Count != 0)
			{
				Dictionary<uint, NetworkIdentity> netIdentities = GetNetIdentities(networkManager);
				foreach (KeyValuePair<BehaviourAdder, uint> prefabAddon in PrefabAddons)
				{
					if (!prefabAddon.Key.IsPlayerPrefab && !(prefabAddon.Key.NewBehaviour == null) && netIdentities.TryGetValue(prefabAddon.Value, out var value))
					{
						Type newBehaviour2 = prefabAddon.Key.NewBehaviour;
						if (!((Object)(object)((Component)value).GetComponent(newBehaviour2) != (Object)null))
						{
							((Component)value).gameObject.AddComponent(newBehaviour2);
							Plugin.Log.LogInfo((object)$"Added {newBehaviour2.Name} component to {prefabAddon.Value} Network Prefab!");
							num2++;
						}
					}
				}
			}
			Frozen = true;
			Plugin.Log.LogDebug((object)$"Added [ {num} ] NetworkBehaviours to the PlayerPrefab.");
			Plugin.Log.LogDebug((object)$"Added [ {num2} ] NetworkBehaviours to Network Objects in the SpawnPrefabs list.");
		}

		private static Dictionary<uint, NetworkIdentity> GetNetIdentities(NetworkManager networkManager)
		{
			Dictionary<uint, NetworkIdentity> dictionary = new Dictionary<uint, NetworkIdentity>();
			foreach (GameObject spawnPrefab in networkManager.spawnPrefabs)
			{
				NetworkIdentity component = spawnPrefab.GetComponent<NetworkIdentity>();
				if ((Object)(object)component != (Object)null)
				{
					dictionary.Add(component.assetId, component);
				}
			}
			return dictionary;
		}
	}
	public static class GameObjectExtensions
	{
		internal static List<GameObject> RegisteredPrefabs = new List<GameObject>();

		public static bool TryRegisterPrefab(this GameObject prefab, out uint assetId)
		{
			prefab.TryGetAssetId(out assetId);
			if ((Object)(object)prefab == (Object)null)
			{
				return false;
			}
			if (!Object.op_Implicit((Object)(object)prefab.GetComponent<NetworkIdentity>()))
			{
				return false;
			}
			RegisteredPrefabs.Add(prefab);
			Plugin.Log.LogDebug((object)(((Object)prefab).name + " will be registered with Mirror at NetworkClient.Initialize!"));
			return true;
		}

		public static bool TryRegisterPrefab(this GameObject prefab)
		{
			if ((Object)(object)prefab == (Object)null)
			{
				return false;
			}
			if (!Object.op_Implicit((Object)(object)prefab.GetComponent<NetworkIdentity>()))
			{
				return false;
			}
			RegisteredPrefabs.Add(prefab);
			Plugin.Log.LogDebug((object)(((Object)prefab).name + " will be registered with Mirror at NetworkClient.Initialize!"));
			return true;
		}

		public static bool TryGetAssetId(this GameObject prefab, out uint assetId)
		{
			assetId = 0u;
			if ((Object)(object)prefab == (Object)null)
			{
				return false;
			}
			if (!Object.op_Implicit((Object)(object)prefab.GetComponent<NetworkIdentity>()))
			{
				return false;
			}
			assetId = prefab.GetComponent<NetworkIdentity>().assetId;
			return true;
		}

		public static bool TryUntrackPrefab(this GameObject prefab)
		{
			if ((Object)(object)prefab == (Object)null)
			{
				return false;
			}
			if (!Object.op_Implicit((Object)(object)prefab.GetComponent<NetworkIdentity>()))
			{
				return false;
			}
			bool flag = RegisteredPrefabs.Remove(prefab);
			Plugin.Log.LogDebug((object)$"{((Object)prefab).name} has been removed from MirrorPlumber's RegisteredPrefabs list [{flag}]");
			return flag;
		}

		public static bool TrySpawnOnServer(this GameObject prefab)
		{
			if (!NetworkServer.active)
			{
				Plugin.Log.LogWarning((object)("Unable to spawn " + ((Object)prefab).name + " on the server as we are not the server client!"));
				return false;
			}
			if (!NetworkClient.prefabs.ContainsValue(prefab))
			{
				Plugin.Log.LogError((object)("Unable to spawn " + ((Object)prefab).name + " on the server! It does not exist in the prefabs list!"));
				return false;
			}
			GameObject val = Object.Instantiate<GameObject>(prefab);
			NetworkServer.Spawn(val, (NetworkConnectionToClient)null);
			return true;
		}
	}
	[BepInPlugin("com.github.darmuh.MirrorPlumber", "MirrorPlumber", "0.3.0")]
	internal class Plugin : BaseUnityPlugin
	{
		[HarmonyPatch(typeof(NetworkManager), "Awake")]
		public class NetworkManagerAwake
		{
			public static void Prefix(NetworkManager __instance)
			{
				Log.LogDebug((object)"NetworkManager Awake Prefix");
				BehaviourAdder.FreezeEvent(__instance);
			}
		}

		[HarmonyPatch(typeof(NetworkClient), "Initialize")]
		public class Initialize
		{
			public static void Prefix()
			{
				Log.LogDebug((object)"NetworkClient Initialize Prefix");
				foreach (GameObject registeredPrefab in GameObjectExtensions.RegisteredPrefabs)
				{
					if (!NetworkClient.prefabs.ContainsValue(registeredPrefab))
					{
						Log.LogMessage((object)"registering prefab");
						NetworkClient.RegisterPrefab(registeredPrefab);
					}
				}
			}
		}

		public const string Id = "com.github.darmuh.MirrorPlumber";

		internal static ManualLogSource Log { get; private set; }

		public static string Name => "MirrorPlumber";

		public static string Version => "0.3.0";

		private void Awake()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			Harmony val = new Harmony("com.github.darmuh.MirrorPlumber");
			val.PatchAll();
			Log.LogInfo((object)("Plugin " + Name + " is loaded and ready to go!"));
		}
	}
	public delegate void NetworkEvent();
	public delegate void NetworkEvent<T>(T param);
	public delegate void NetworkEvent<T1, T2>(T1 param1, T2 param2);
	public abstract class PlumberBase
	{
		public enum NetType
		{
			Command,
			ClientRpc,
			TargetRpc
		}

		internal Type? type;

		internal bool IsRegistered;

		internal string? _fullName { get; private set; }

		internal ushort _hash { get; private set; }

		internal bool _requiresAuth { get; private set; }

		internal bool _includeOwner { get; private set; }

		internal RemoteCallType _callType { get; private set; }

		internal NetType _netType { get; private set; }

		public void Create(Type netBehaviour, string methodName, NetType netType, bool requiresAuthority = false)
		{
			if (!IsRegistered)
			{
				type = netBehaviour;
				_fullName = GetFullName(type, methodName);
				_hash = GetHash(_fullName);
				_requiresAuth = requiresAuthority;
				_netType = netType;
				Register();
			}
		}

		internal void Register()
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			Plugin.Log.LogDebug((object)("Registering " + _fullName + " with mirror"));
			if (_netType == NetType.Command)
			{
				_callType = (RemoteCallType)0;
			}
			else
			{
				_callType = (RemoteCallType)1;
			}
			if (_netType == NetType.Command)
			{
				RemoteProcedureCalls.RegisterDelegate(type, _fullName, _callType, new RemoteCallDelegate(StandardCommand), _requiresAuth);
			}
			else
			{
				RemoteProcedureCalls.RegisterDelegate(type, _fullName, _callType, new RemoteCallDelegate(StandardRPC), _requiresAuth);
			}
			IsRegistered = true;
		}

		internal abstract void StandardCommand(NetworkBehaviour obj, NetworkReader reader, NetworkConnectionToClient senderConnection);

		internal abstract void StandardRPC(NetworkBehaviour obj, NetworkReader reader, NetworkConnectionToClient senderConnection);

		internal void SendToMirror<T>(T instance, NetworkWriterPooled writer, NetworkConnection target = null) where T : NetworkBehaviour
		{
			if ((Object)(object)instance == (Object)null)
			{
				Plugin.Log.LogError((object)$"{typeof(T)} instance is Null!");
				return;
			}
			if (_netType == NetType.Command)
			{
				((NetworkBehaviour)instance).SendCommandInternal(_fullName, (int)_hash, (NetworkWriter)(object)writer, 0, _requiresAuth);
			}
			else if (_netType == NetType.ClientRpc)
			{
				((NetworkBehaviour)instance).SendRPCInternal(_fullName, (int)_hash, (NetworkWriter)(object)writer, 0, _includeOwner);
			}
			else
			{
				if (_netType != NetType.TargetRpc || target == null)
				{
					Plugin.Log.LogWarning((object)(_fullName + ": TargetRpc Invoke missing target parameter!"));
					return;
				}
				((NetworkBehaviour)instance).SendTargetRPCInternal(target, _fullName, (int)_hash, (NetworkWriter)(object)writer, 0);
			}
			NetworkWriterPool.Return(writer);
		}

		internal static string GetFullName(Type type, string methodName)
		{
			return $"{type?.GetMethod(methodName)?.ReturnType} {type?.Namespace}::{methodName}";
		}

		internal static ushort GetHash(string fullName)
		{
			return (ushort)((uint)Extensions.GetStableHashCode(fullName) & 0xFFFFu);
		}

		public void SetRpcIncludeOwner(bool includeOwner)
		{
			_includeOwner = includeOwner;
		}
	}
	public class Plumber : PlumberBase
	{
		private event NetworkEvent NetworkedEvent;

		public void AddListener(NetworkEvent listener)
		{
			NetworkedEvent += listener;
		}

		public void SetListener(NetworkEvent listener)
		{
			this.NetworkedEvent = null;
			NetworkedEvent += listener;
		}

		public void ClearListeners()
		{
			this.NetworkedEvent = null;
		}

		public void Invoke<TSource>(TSource instance, NetworkConnection target = null) where TSource : NetworkBehaviour
		{
			NetworkWriterPooled writer = NetworkWriterPool.Get();
			SendToMirror(instance, writer, target);
		}

		internal override void StandardRPC(NetworkBehaviour obj, NetworkReader reader, NetworkConnectionToClient senderConnection)
		{
			if (!NetworkClient.active)
			{
				Plugin.Log.LogError((object)(base._fullName + " called on inactive client."));
			}
			else
			{
				this.NetworkedEvent?.Invoke();
			}
		}

		internal override void StandardCommand(NetworkBehaviour obj, NetworkReader reader, NetworkConnectionToClient senderConnection)
		{
			if (!NetworkServer.active)
			{
				Plugin.Log.LogError((object)("Attempted to call " + base._fullName + " when NetworkServer is not active."));
			}
			else
			{
				this.NetworkedEvent?.Invoke();
			}
		}
	}
	public class Plumber<TParam> : PlumberBase
	{
		private event NetworkEvent<TParam> NetworkedEvent;

		public void AddListener(NetworkEvent<TParam> listener)
		{
			NetworkedEvent += listener;
		}

		public void SetListener(NetworkEvent<TParam> listener)
		{
			this.NetworkedEvent = null;
			NetworkedEvent += listener;
		}

		public void ClearListeners()
		{
			this.NetworkedEvent = null;
		}

		public void Invoke<TSource>(TSource instance, TParam param, NetworkConnection target = null) where TSource : NetworkBehaviour
		{
			NetworkWriterPooled val = NetworkWriterPool.Get();
			if (param == null)
			{
				Plugin.Log.LogError((object)"Given Parameter is null! Mirror cannot read/write NULL values!");
				return;
			}
			((NetworkWriter)val).Write<TParam>(param);
			SendToMirror(instance, val, target);
		}

		internal override void StandardRPC(NetworkBehaviour obj, NetworkReader reader, NetworkConnectionToClient senderConnection)
		{
			if (!NetworkClient.active)
			{
				Plugin.Log.LogError((object)(base._fullName + " called on inactive client."));
			}
			else
			{
				this.NetworkedEvent?.Invoke(reader.Read<TParam>());
			}
		}

		internal override void StandardCommand(NetworkBehaviour obj, NetworkReader reader, NetworkConnectionToClient senderConnection)
		{
			if (!NetworkServer.active)
			{
				Plugin.Log.LogError((object)("Attempted to call " + base._fullName + " when NetworkServer is not active."));
			}
			else
			{
				this.NetworkedEvent?.Invoke(reader.Read<TParam>());
			}
		}
	}
	public class Plumber<TParam1, TParam2> : PlumberBase
	{
		private event NetworkEvent<TParam1, TParam2> NetworkedEvent;

		public void AddListener(NetworkEvent<TParam1, TParam2> listener)
		{
			NetworkedEvent += listener;
		}

		public void SetListener(NetworkEvent<TParam1, TParam2> listener)
		{
			this.NetworkedEvent = null;
			NetworkedEvent += listener;
		}

		public void ClearListeners()
		{
			this.NetworkedEvent = null;
		}

		public void Invoke<TSource>(TSource instance, TParam1 param1, TParam2 param2, NetworkConnection target = null) where TSource : NetworkBehaviour
		{
			NetworkWriterPooled val = NetworkWriterPool.Get();
			if (param1 == null)
			{
				Plugin.Log.LogError((object)"Parameter 1 is null! Mirror cannot read/write NULL values!");
				return;
			}
			if (param2 == null)
			{
				Plugin.Log.LogError((object)"Parameter 2 is null! Mirror cannot read/write NULL values!");
				return;
			}
			((NetworkWriter)val).Write<TParam1>(param1);
			((NetworkWriter)val).Write<TParam2>(param2);
			SendToMirror(instance, val, target);
		}

		internal override void StandardRPC(NetworkBehaviour obj, NetworkReader reader, NetworkConnectionToClient senderConnection)
		{
			if (!NetworkClient.active)
			{
				Plugin.Log.LogError((object)(base._fullName + " called on inactive client."));
			}
			else
			{
				this.NetworkedEvent?.Invoke(reader.Read<TParam1>(), reader.Read<TParam2>());
			}
		}

		internal override void StandardCommand(NetworkBehaviour obj, NetworkReader reader, NetworkConnectionToClient senderConnection)
		{
			if (!NetworkServer.active)
			{
				Plugin.Log.LogError((object)("Attempted to call " + base._fullName + " when NetworkServer is not active."));
			}
			else
			{
				this.NetworkedEvent?.Invoke(reader.Read<TParam1>(), reader.Read<TParam2>());
			}
		}
	}
	public class PlumbVar<TSource, TValue> where TSource : NetworkBehaviour
	{
		private TSource? SourceInstance;

		private static readonly Plumber<TValue> CommandUpdateValue = new Plumber<TValue>();

		private static readonly Plumber<TValue> ClientRpcUpdateValue = new Plumber<TValue>();

		private readonly TValue initVal;

		private TValue _value;

		public TValue Value
		{
			get
			{
				return _value;
			}
			set
			{
				_value = value;
				if ((Object)(object)SourceInstance != (Object)null)
				{
					if (((NetworkBehaviour)SourceInstance).isServer)
					{
						ClientRpcUpdateValue?.Invoke(SourceInstance, value);
					}
					else
					{
						CommandUpdateValue?.Invoke(SourceInstance, value);
					}
				}
			}
		}

		public PlumbVar(TValue initialValue)
		{
			initVal = initialValue;
			_value = initialValue;
			base..ctor();
		}

		public void Create(TSource NetBehaviourInstance)
		{
			_value = initVal;
			SourceInstance = NetBehaviourInstance;
			CommandUpdateValue.Create(typeof(TSource), typeof(TSource).Name + " TValue PlumbVar Command", PlumberBase.NetType.Command);
			CommandUpdateValue.SetListener(UpdateValue);
			ClientRpcUpdateValue.Create(typeof(TSource), typeof(TSource).Name + " TValue PlumbVar ClientRpc", PlumberBase.NetType.ClientRpc);
			ClientRpcUpdateValue.SetListener(UpdateValue);
		}

		private void UpdateValue(TValue value)
		{
			_value = value;
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}