using System;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using CSync.Extensions;
using CSync.Lib;
using CessilCellsCeaChells.CeaChore;
using IL;
using Microsoft.CodeAnalysis;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using MonoMod.RuntimeDetour;
using On;
using PredictableEggs.NetcodePatcher;
using Unity.Netcode;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: RequiresMethod(typeof(StunGrenadeItem), "Awake", typeof(void), new Type[] { })]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("PredictableEggs")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("A mod for Lethal Company")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+1e6e75db2673090a5f440c6cb2b31a57f0051f4f")]
[assembly: AssemblyProduct("PredictableEggs")]
[assembly: AssemblyTitle("PredictableEggs")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
internal class <Module>
{
	static <Module>()
	{
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[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 PredictableEggs
{
	public static class Assets
	{
		public static AudioClip EggReadyToExplode { get; private set; }

		public static void Load()
		{
			string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
			AssetBundle val = AssetBundle.LoadFromFile(Path.Combine(directoryName, "predictableeggs.bundle"));
			EggReadyToExplode = val.LoadAsset<AudioClip>("EggReadyToExplode");
		}
	}
	public class Config : SyncedConfig2<Config>
	{
		[SyncedEntryField]
		public SyncedEntry<float> EggExplodeChance;

		[SyncedEntryField]
		public SyncedEntry<bool> WarningSound;

		[SyncedEntryField]
		public SyncedEntry<bool> DontExplodeOnDrop;

		[SyncedEntryField]
		public SyncedEntry<bool> DetermineOnPickUp;

		[SyncedEntryField]
		public SyncedEntry<int> EnemyDamage;

		public Config(ConfigFile cfg)
			: base("moe.sylvi.PredictableEggs")
		{
			EggExplodeChance = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, "General", "EggExplodeChance", 16f, "Percentage chance for the egg to explode, determined when the egg is selected in the inventory. (Vanilla value is 16%)");
			WarningSound = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, "General", "WarningSound", true, "Plays a unique sound (fizzling) if the egg will explode on its next throw.");
			DontExplodeOnDrop = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, "General", "DontExplodeOnDrop", false, "Prevents eggs from exploding when dropped, as opposed to being thrown.");
			DetermineOnPickUp = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, "General", "DetermineOnPickUp", false, "Decides whether eggs will explode only on pickup, as opposed to any time it's selected.");
			EnemyDamage = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, "General", "EnemyDamage", 6, "The amount of damage egg explosions should deal to enemies. (Vanilla value is 6)");
			ConfigManager.Register<Config>((SyncedConfig2<Config>)this);
		}
	}
	public static class Patches
	{
		private delegate void StunGrenadeItem_orig_Awake(StunGrenadeItem self);

		[CompilerGenerated]
		private static class <>O
		{
			public static hook_EquipItem <0>__StunGrenadeItem_EquipItem;

			public static hook_DiscardItem <1>__StunGrenadeItem_DiscardItem;

			public static hook_ItemActivate <2>__StunGrenadeItem_ItemActivate;

			public static hook_OnHitGround <3>__StunGrenadeItem_OnHitGround;

			public static hook_ExplodeStunGrenade <4>__StunGrenadeItem_ExplodeStunGrenade;

			public static Manipulator <5>__Landmine_SpawnExplosion;

			public static Func<int, int> <6>__ApplyOverrideLandmineEnemyDamage;
		}

		public static bool OverrideLandmineEnemyDamage;

		public static void Initialize()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Expected O, but got Unknown
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Expected O, but got Unknown
			object obj = <>O.<0>__StunGrenadeItem_EquipItem;
			if (obj == null)
			{
				hook_EquipItem val = StunGrenadeItem_EquipItem;
				<>O.<0>__StunGrenadeItem_EquipItem = val;
				obj = (object)val;
			}
			StunGrenadeItem.EquipItem += (hook_EquipItem)obj;
			object obj2 = <>O.<1>__StunGrenadeItem_DiscardItem;
			if (obj2 == null)
			{
				hook_DiscardItem val2 = StunGrenadeItem_DiscardItem;
				<>O.<1>__StunGrenadeItem_DiscardItem = val2;
				obj2 = (object)val2;
			}
			StunGrenadeItem.DiscardItem += (hook_DiscardItem)obj2;
			object obj3 = <>O.<2>__StunGrenadeItem_ItemActivate;
			if (obj3 == null)
			{
				hook_ItemActivate val3 = StunGrenadeItem_ItemActivate;
				<>O.<2>__StunGrenadeItem_ItemActivate = val3;
				obj3 = (object)val3;
			}
			StunGrenadeItem.ItemActivate += (hook_ItemActivate)obj3;
			object obj4 = <>O.<3>__StunGrenadeItem_OnHitGround;
			if (obj4 == null)
			{
				hook_OnHitGround val4 = StunGrenadeItem_OnHitGround;
				<>O.<3>__StunGrenadeItem_OnHitGround = val4;
				obj4 = (object)val4;
			}
			StunGrenadeItem.OnHitGround += (hook_OnHitGround)obj4;
			object obj5 = <>O.<4>__StunGrenadeItem_ExplodeStunGrenade;
			if (obj5 == null)
			{
				hook_ExplodeStunGrenade val5 = StunGrenadeItem_ExplodeStunGrenade;
				<>O.<4>__StunGrenadeItem_ExplodeStunGrenade = val5;
				obj5 = (object)val5;
			}
			StunGrenadeItem.ExplodeStunGrenade += (hook_ExplodeStunGrenade)obj5;
			object obj6 = <>O.<5>__Landmine_SpawnExplosion;
			if (obj6 == null)
			{
				Manipulator val6 = Landmine_SpawnExplosion;
				<>O.<5>__Landmine_SpawnExplosion = val6;
				obj6 = (object)val6;
			}
			Landmine.SpawnExplosion += (Manipulator)obj6;
			new Hook((MethodBase)typeof(StunGrenadeItem).GetMethod("Awake", BindingFlags.Instance | BindingFlags.Public), typeof(Patches).GetMethod("StunGrenadeItem_Awake", BindingFlags.Static | BindingFlags.NonPublic)).Apply();
		}

		private static void Landmine_SpawnExplosion(ILContext il)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			ILCursor val = new ILCursor(il);
			if (!val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[1]
			{
				(Instruction instr) => ILPatternMatchingExt.MatchLdcI4(instr, 6)
			}))
			{
				Plugin.Logger.LogError((object)"Failed IL hook for Landmine.SpawnExplosion @ HitEnemyOnLocalClient for 6 damage");
			}
			else
			{
				val.EmitDelegate<Func<int, int>>((Func<int, int>)ApplyOverrideLandmineEnemyDamage);
			}
		}

		private static int ApplyOverrideLandmineEnemyDamage(int orig)
		{
			return OverrideLandmineEnemyDamage ? Plugin.Config.EnemyDamage.Value : orig;
		}

		private static void StunGrenadeItem_ExplodeStunGrenade(orig_ExplodeStunGrenade orig, StunGrenadeItem self, bool destroy)
		{
			if (self.chanceToExplode >= 100f)
			{
				orig.Invoke(self, destroy);
				return;
			}
			OverrideLandmineEnemyDamage = true;
			orig.Invoke(self, destroy);
			OverrideLandmineEnemyDamage = false;
		}

		private static void StunGrenadeItem_OnHitGround(orig_OnHitGround orig, StunGrenadeItem self)
		{
			Plugin.Logger.LogInfo((object)$"Hit ground! Will explode: {self.explodeOnThrow}");
			orig.Invoke(self);
		}

		private static void StunGrenadeItem_ItemActivate(orig_ItemActivate orig, StunGrenadeItem self, bool used, bool buttonDown)
		{
			if (!self.inPullingPinAnimation && self.pinPulled && ((NetworkBehaviour)self).IsOwner)
			{
				PredictableEggComponent component = ((Component)self).gameObject.GetComponent<PredictableEggComponent>();
				component.WasThrown = true;
			}
			orig.Invoke(self, used, buttonDown);
		}

		private static void StunGrenadeItem_EquipItem(orig_EquipItem orig, StunGrenadeItem self)
		{
			if (self.chanceToExplode >= 100f)
			{
				orig.Invoke(self);
				return;
			}
			bool isPocketed = ((GrabbableObject)self).isPocketed;
			float chanceToExplode = self.chanceToExplode;
			self.chanceToExplode = 100f;
			orig.Invoke(self);
			self.chanceToExplode = chanceToExplode;
			PredictableEggComponent component = ((Component)self).gameObject.GetComponent<PredictableEggComponent>();
			component.SetExplosiveOnEquip(isPocketed);
			component.WasThrown = false;
			self.gotExplodeOnThrowRPC = true;
		}

		private static void StunGrenadeItem_DiscardItem(orig_DiscardItem orig, StunGrenadeItem self)
		{
			if (SyncedEntry<bool>.op_Implicit(Plugin.Config.DontExplodeOnDrop) && (((NetworkBehaviour)self).IsOwner || ((GrabbableObject)self).wasOwnerLastFrame) && (Object)(object)((GrabbableObject)self).playerHeldBy != (Object)null && !((GrabbableObject)self).playerHeldBy.isPlayerDead && self.chanceToExplode < 100f)
			{
				PredictableEggComponent component = ((Component)self).gameObject.GetComponent<PredictableEggComponent>();
				if (!component.WasThrown)
				{
					Plugin.Logger.LogInfo((object)"Dropping safely!");
					self.explodeOnThrow = false;
					component.SetExplodeOnThrowDirectServerRpc(explode: false);
				}
			}
			orig.Invoke(self);
		}

		private static void StunGrenadeItem_Awake(StunGrenadeItem_orig_Awake orig, StunGrenadeItem self)
		{
			orig(self);
			if (!Object.op_Implicit((Object)(object)((Component)self).gameObject.GetComponent<PredictableEggComponent>()))
			{
				((Component)self).gameObject.AddComponent<PredictableEggComponent>();
			}
		}
	}
	[BepInPlugin("moe.sylvi.PredictableEggs", "PredictableEggs", "1.1.0")]
	[BepInDependency("com.sigurd.csync", "5.0.1")]
	public class Plugin : BaseUnityPlugin
	{
		public static Config Config { get; private set; }

		public static ManualLogSource Logger { get; private set; }

		private void Awake()
		{
			Config = new Config(((BaseUnityPlugin)this).Config);
			Logger = ((BaseUnityPlugin)this).Logger;
			Assets.Load();
			Patches.Initialize();
			InitNetcodePatcher();
			Logger.LogInfo((object)"Plugin moe.sylvi.PredictableEggs is loaded!");
		}

		private void InitNetcodePatcher()
		{
			Type[] types = Assembly.GetExecutingAssembly().GetTypes();
			Type[] array = types;
			foreach (Type type in array)
			{
				MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
				MethodInfo[] array2 = methods;
				foreach (MethodInfo methodInfo in array2)
				{
					object[] customAttributes = methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false);
					if (customAttributes.Length != 0)
					{
						methodInfo.Invoke(null, null);
					}
				}
			}
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "moe.sylvi.PredictableEggs";

		public const string PLUGIN_NAME = "PredictableEggs";

		public const string PLUGIN_VERSION = "1.1.0";
	}
	public class PredictableEggComponent : NetworkBehaviour
	{
		public bool WasThrown = false;

		private StunGrenadeItem eggItem;

		private void Awake()
		{
			eggItem = ((Component)this).gameObject.GetComponent<StunGrenadeItem>();
		}

		public void SetExplosiveOnEquip(bool wasPocketed)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			if (((NetworkBehaviour)this).IsOwner)
			{
				Random random = new Random(StartOfRound.Instance.randomMapSeed + 10 + (int)((Component)this).transform.position.x + (int)((Component)this).transform.position.z);
				bool flag = random.NextDouble() * 100.0 < (double)Plugin.Config.EggExplodeChance.Value;
				if (wasPocketed && Plugin.Config.DetermineOnPickUp.Value)
				{
					flag = eggItem.explodeOnThrow;
				}
				if (flag && Plugin.Config.WarningSound.Value)
				{
					((Component)this).gameObject.GetComponent<AudioSource>().PlayOneShot(Assets.EggReadyToExplode, 1f);
				}
				Plugin.Logger.LogInfo((object)$"Egg explosion prediction: {flag}");
				eggItem.explodeOnThrow = flag;
				SetExplodeOnThrowDirectServerRpc(flag);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SetExplodeOnThrowDirectServerRpc(bool explode)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1866835474u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref explode, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1866835474u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					SetExplodeOnThrowDirectClientRpc(explode);
				}
			}
		}

		[ClientRpc]
		public void SetExplodeOnThrowDirectClientRpc(bool explode)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1435201353u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref explode, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1435201353u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && !((NetworkBehaviour)this).IsOwner)
				{
					Plugin.Logger.LogInfo((object)$"Egg explosion prediction: {explode}");
					eggItem.gotExplodeOnThrowRPC = true;
					eggItem.explodeOnThrow = explode;
				}
			}
		}

		protected override void __initializeVariables()
		{
			((NetworkBehaviour)this).__initializeVariables();
		}

		[RuntimeInitializeOnLoadMethod]
		internal static void InitializeRPCS_PredictableEggComponent()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			NetworkManager.__rpc_func_table.Add(1866835474u, new RpcReceiveHandler(__rpc_handler_1866835474));
			NetworkManager.__rpc_func_table.Add(1435201353u, new RpcReceiveHandler(__rpc_handler_1435201353));
		}

		private static void __rpc_handler_1866835474(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool explodeOnThrowDirectServerRpc = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref explodeOnThrowDirectServerRpc, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((PredictableEggComponent)(object)target).SetExplodeOnThrowDirectServerRpc(explodeOnThrowDirectServerRpc);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1435201353(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool explodeOnThrowDirectClientRpc = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref explodeOnThrowDirectClientRpc, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((PredictableEggComponent)(object)target).SetExplodeOnThrowDirectClientRpc(explodeOnThrowDirectClientRpc);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected internal override string __getTypeName()
		{
			return "PredictableEggComponent";
		}
	}
}
namespace PredictableEggs.NetcodePatcher
{
	[AttributeUsage(AttributeTargets.Module)]
	internal class NetcodePatchedAssemblyAttribute : Attribute
	{
	}
}