using System;
using System.Collections;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using KillItWithShovel.Patches;
using Unity.Collections;
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: AssemblyTitle("DisableTurretOnHit")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("DisableTurretOnHit")]
[assembly: AssemblyCopyright("Copyright ©  2024")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("7396d5a1-8737-4657-8c55-4f5741428920")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace KillItWithShovel
{
	[Serializable]
	public class Config : SyncedInstance<Config>
	{
		public static ConfigEntry<bool> configEnterBerserkMode;

		public bool bMode;

		public static ConfigEntry<bool> configWakenAfterWeapon;

		public bool bWakenAfterWeapon;

		public static ConfigEntry<float> configDisableDuration;

		public float dDuration;

		public static ConfigEntry<float> configDisableChance;

		public float dChance;

		public static ConfigEntry<int> configGuaranteedBMode;

		public int BGuarantee;

		public static ConfigEntry<bool> configIncreaseGBMOnFailure;

		public bool GBMUpOnFailure;

		public Config(ConfigFile cfg)
		{
			InitInstance(this);
			configEnterBerserkMode = cfg.Bind<bool>("General", "Berserk Mode when being waked", true, "Turret will enter berserker mode if rudely woken by weapons.");
			configWakenAfterWeapon = cfg.Bind<bool>("General", "Can be Waked only after deactivating to a weapon", true, "Turrets can be waken from deactivation only when they were deactivated by other weapon previously (not ship terminal).");
			configDisableDuration = cfg.Bind<float>("General", "Disable Duration", 5f, "For how many seconds the turret will be deactivated on successful hit.");
			configDisableChance = cfg.Bind<float>("General", "Deactivate Chance", 1f, "Chance that the turret will deactivate on a successful hit (0 to 1).\n-\nHow this works: 0.5 means 50% that turret will deactivate (same 50% that it fails to deactivate), it could be 0 (0%, turret will never deactivate), 1 (100%, turret always deactivates), and any other value like for example 0.34 (34%)");
			configGuaranteedBMode = cfg.Bind<int>("General", "Guaranteed Berserk Mode", -1, "How many hits will trigger guaranteed berserk mode (-1 to disable this feature).\n-\nHow this works: every time you hit turret 0 value goes up, and when you hit it while value is equal to this config value, guaranteed berserk mode starts and value resets to 0. That's why -1 disables this function beacuse no matter how much you hit it will never be equal to negative number.");
			configIncreaseGBMOnFailure = cfg.Bind<bool>("General", "Increase Guaranteed Berserk Mode Value on failure to deactivate the turret", false, "The guaranteed berserk mode counter will increase if player fails to deactivate turret with a shovel and turret enters Berserk mode.");
		}

		public static void BuildServerConfigSync()
		{
			SyncedInstance<Config>.Default.bMode = configEnterBerserkMode.Value;
			SyncedInstance<Config>.Default.bWakenAfterWeapon = configWakenAfterWeapon.Value;
			SyncedInstance<Config>.Default.dDuration = configDisableDuration.Value;
			SyncedInstance<Config>.Default.dChance = configDisableChance.Value;
			SyncedInstance<Config>.Default.BGuarantee = configGuaranteedBMode.Value;
			SyncedInstance<Config>.Default.GBMUpOnFailure = configIncreaseGBMOnFailure.Value;
			SyncedInstance<Config>.Instance.bMode = SyncedInstance<Config>.Default.bMode;
			SyncedInstance<Config>.Instance.bWakenAfterWeapon = SyncedInstance<Config>.Default.bWakenAfterWeapon;
			SyncedInstance<Config>.Instance.dDuration = SyncedInstance<Config>.Default.dDuration;
			SyncedInstance<Config>.Instance.dChance = SyncedInstance<Config>.Default.dChance;
			SyncedInstance<Config>.Instance.BGuarantee = SyncedInstance<Config>.Default.BGuarantee;
			SyncedInstance<Config>.Instance.GBMUpOnFailure = SyncedInstance<Config>.Default.GBMUpOnFailure;
		}

		public static void RequestSync()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			if (!SyncedInstance<Config>.IsClient)
			{
				return;
			}
			FastBufferWriter val = default(FastBufferWriter);
			((FastBufferWriter)(ref val))..ctor(SyncedInstance<Config>.IntSize, (Allocator)2, -1);
			try
			{
				SyncedInstance<Config>.MessageManager.SendNamedMessage("DisableTurretOnHit_OnRequestConfigSync", 0uL, val, (NetworkDelivery)2);
			}
			finally
			{
				((FastBufferWriter)(ref val)).Dispose();
			}
		}

		public static void OnRequestSync(ulong clientId, FastBufferReader _)
		{
			//IL_0053: 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_0077: Unknown result type (might be due to invalid IL or missing references)
			if (!SyncedInstance<Config>.IsHost)
			{
				return;
			}
			SyncedInstance<Config>.mls2.LogInfo((object)$"Config sync request received from client: {clientId}");
			byte[] array = SyncedInstance<Config>.SerializeToBytes(SyncedInstance<Config>.Instance);
			int num = array.Length;
			FastBufferWriter val = default(FastBufferWriter);
			((FastBufferWriter)(ref val))..ctor(num + SyncedInstance<Config>.IntSize, (Allocator)2, -1);
			try
			{
				((FastBufferWriter)(ref val)).WriteValueSafe<int>(ref num, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteBytesSafe(array, -1, 0);
				SyncedInstance<Config>.MessageManager.SendNamedMessage("DisableTurretOnHit_OnReceiveConfigSync", clientId, val, (NetworkDelivery)2);
			}
			catch (Exception arg)
			{
				SyncedInstance<Config>.mls2.LogError((object)$"Error occurred syncing config with client: {clientId}\n{arg}");
			}
			finally
			{
				((FastBufferWriter)(ref val)).Dispose();
			}
		}

		public static void OnReceiveSync(ulong _, FastBufferReader reader)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			if (!((FastBufferReader)(ref reader)).TryBeginRead(SyncedInstance<Config>.IntSize))
			{
				SyncedInstance<Config>.mls2.LogError((object)"Config sync error: Could not begin reading buffer.");
				return;
			}
			int num = default(int);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num, default(ForPrimitives));
			if (!((FastBufferReader)(ref reader)).TryBeginRead(num))
			{
				SyncedInstance<Config>.mls2.LogError((object)"Config sync error: Host could not sync.");
				return;
			}
			byte[] data = new byte[num];
			((FastBufferReader)(ref reader)).ReadBytesSafe(ref data, num, 0);
			SyncedInstance<Config>.SyncInstance(data);
			SyncedInstance<Config>.mls2.LogInfo((object)"Successfully synced config with host.");
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlayerControllerB), "ConnectClientToPlayerObject")]
		public static void InitializeLocalPlayer()
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			if (SyncedInstance<Config>.IsHost)
			{
				BuildServerConfigSync();
				SyncedInstance<Config>.MessageManager.RegisterNamedMessageHandler("DisableTurretOnHit_OnRequestConfigSync", new HandleNamedMessageDelegate(OnRequestSync));
				SyncedInstance<Config>.Synced = true;
			}
			else
			{
				SyncedInstance<Config>.Synced = false;
				SyncedInstance<Config>.MessageManager.RegisterNamedMessageHandler("DisableTurretOnHit_OnReceiveConfigSync", new HandleNamedMessageDelegate(OnReceiveSync));
				RequestSync();
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(GameNetworkManager), "StartDisconnect")]
		public static void PlayerLeave()
		{
			SyncedInstance<Config>.RevertSync();
		}
	}
	[BepInPlugin("Great_Ramil.DisableTurretOnHit", "DisableTurretOnHit", "1.0.0")]
	public class Plugin : BaseUnityPlugin
	{
		private const string modGUID = "Great_Ramil.DisableTurretOnHit";

		private const string modName = "DisableTurretOnHit";

		private const string modVersion = "1.0.0";

		private readonly Harmony harmony = new Harmony("Great_Ramil.DisableTurretOnHit");

		public static Plugin Instance;

		internal ManualLogSource mls;

		public static Config MyConfig { get; internal set; }

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Plugin Great_Ramil.DisableTurretOnHit is loaded!");
			mls = Logger.CreateLogSource("Great_Ramil.DisableTurretOnHit");
			harmony.PatchAll(typeof(Plugin));
			harmony.PatchAll(typeof(TurretPatch));
			harmony.PatchAll(typeof(Config));
			MyConfig = new Config(((BaseUnityPlugin)this).Config);
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "Great_Ramil.DisableTurretOnHit";

		public const string PLUGIN_NAME = "DisableTurretOnHit";

		public const string PLUGIN_VERSION = "2.0.0";
	}
	[Serializable]
	public class SyncedInstance<T>
	{
		public static ManualLogSource mls2 = Logger.CreateLogSource("Great_Ramil.DisableTurretOnHit");

		[NonSerialized]
		protected static int IntSize = 4;

		internal static CustomMessagingManager MessageManager => NetworkManager.Singleton.CustomMessagingManager;

		internal static bool IsClient => NetworkManager.Singleton.IsClient;

		internal static bool IsHost => NetworkManager.Singleton.IsHost;

		public static T Default { get; private set; }

		public static T Instance { get; private set; }

		public static bool Synced { get; internal set; }

		protected void InitInstance(T instance)
		{
			Default = instance;
			Instance = instance;
			IntSize = 4;
		}

		internal static void SyncInstance(byte[] data)
		{
			Instance = DeserializeFromBytes(data);
			Synced = true;
		}

		internal static void RevertSync()
		{
			Instance = Default;
			Synced = false;
		}

		public static byte[] SerializeToBytes(T val)
		{
			BinaryFormatter binaryFormatter = new BinaryFormatter();
			using MemoryStream memoryStream = new MemoryStream();
			try
			{
				binaryFormatter.Serialize(memoryStream, val);
				return memoryStream.ToArray();
			}
			catch (Exception arg)
			{
				mls2.LogError((object)$"Error serializing instance: {arg}");
				return null;
			}
		}

		public static T DeserializeFromBytes(byte[] data)
		{
			BinaryFormatter binaryFormatter = new BinaryFormatter();
			T result;
			using (MemoryStream serializationStream = new MemoryStream(data))
			{
				try
				{
					result = (T)binaryFormatter.Deserialize(serializationStream);
					return result;
				}
				catch (Exception arg)
				{
					mls2.LogError((object)$"Error deserializing instance: {arg}");
					result = default(T);
				}
			}
			return result;
		}
	}
}
namespace KillItWithShovel.Patches
{
	[HarmonyPatch(typeof(EnemyAI))]
	internal class EnemyAIPatch
	{
		[HarmonyPatch(typeof(EnemyAI), "HitEnemy")]
		[HarmonyPrefix]
		public static bool HitPushBackPatch(ref int force, ref PlayerControllerB playerWhoHit, ref EnemyAI __instance)
		{
			string enemyName = __instance.enemyType.enemyName;
			string text = enemyName;
			if (text == "SpringManAI" || text == "JesterAI")
			{
				PushBackHit(ref force, ref playerWhoHit, ref __instance);
			}
			return true;
		}

		private static void PushBackHit(ref int force, ref PlayerControllerB playerWhoHit, ref EnemyAI __instance)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: 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_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_007b: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ((Component)__instance).gameObject.transform.position;
			Vector3 position2 = ((Component)playerWhoHit).gameObject.transform.position;
			float num = position2.y - position.y;
			if (num > 40f)
			{
				__instance.KillEnemy(false);
				return;
			}
			Vector3 val = Vector3.Normalize((position2 - position) * (float)force);
			Transform transform = ((Component)__instance).gameObject.transform;
			transform.position += val;
		}
	}
	[HarmonyPatch(typeof(Turret))]
	internal class TurretPatch
	{
		public class TurretHitPatchMB : MonoBehaviour
		{
		}

		public class TurretHitStatus : MonoBehaviour
		{
			public int hitCount = 0;

			public bool wasDeactivatedByWeapon = false;
		}

		private static readonly ManualLogSource logger = Logger.CreateLogSource("KillItWithShovel");

		private static TurretHitPatchMB turretHitPatchMB;

		[HarmonyPatch(typeof(Turret), "IHittable.Hit")]
		[HarmonyPrefix]
		public static bool HitDisablePatch(ref TurretMode ___turretMode, ref Turret __instance)
		{
			if ((Object)(object)turretHitPatchMB == (Object)null)
			{
				turretHitPatchMB = ((Component)__instance).gameObject.AddComponent<TurretHitPatchMB>();
			}
			TurretHitStatus turretHitStatus = ((Component)__instance).gameObject.GetComponent<TurretHitStatus>();
			if ((Object)(object)turretHitStatus == (Object)null)
			{
				turretHitStatus = ((Component)__instance).gameObject.AddComponent<TurretHitStatus>();
			}
			int num = turretHitStatus.hitCount;
			bool wasDeactivatedByWeapon = turretHitStatus.wasDeactivatedByWeapon;
			bool turretActive = __instance.turretActive;
			bool flag = false;
			if ((int)___turretMode == 3)
			{
				flag = true;
			}
			bool result = true;
			if (!flag)
			{
				if (turretActive)
				{
					bool flag2 = Random.value <= SyncedInstance<Config>.Instance.dChance;
					if (SyncedInstance<Config>.Instance.dChance == 0f)
					{
						flag2 = false;
					}
					if (num >= SyncedInstance<Config>.Instance.BGuarantee && SyncedInstance<Config>.Instance.BGuarantee >= 0)
					{
						num = 0;
						result = true;
					}
					else if (flag2)
					{
						num++;
						((MonoBehaviour)turretHitPatchMB).StartCoroutine(TurnOffAndOnTurret(__instance, SyncedInstance<Config>.Instance.dDuration));
						result = false;
					}
					else
					{
						if (SyncedInstance<Config>.Instance.GBMUpOnFailure)
						{
							num++;
						}
						result = true;
					}
				}
				else
				{
					bool bMode = SyncedInstance<Config>.Instance.bMode;
					bool bWakenAfterWeapon = SyncedInstance<Config>.Instance.bWakenAfterWeapon;
					if (bMode && ((bWakenAfterWeapon && wasDeactivatedByWeapon) || !bWakenAfterWeapon))
					{
						__instance.ToggleTurretEnabled(true);
						result = true;
					}
					else
					{
						result = false;
					}
				}
			}
			((Component)__instance).gameObject.GetComponent<TurretHitStatus>().hitCount = num;
			return result;
		}

		public static IEnumerator TurnOffAndOnTurret(Turret _turret, float duration)
		{
			((Component)_turret).gameObject.GetComponent<TurretHitStatus>().wasDeactivatedByWeapon = true;
			_turret.ToggleTurretEnabled(false);
			yield return (object)new WaitForSeconds(duration);
			((Component)_turret).gameObject.GetComponent<TurretHitStatus>().wasDeactivatedByWeapon = false;
			_turret.ToggleTurretEnabled(true);
		}
	}
}