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 HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("OnePunch")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("OnePunch")]
[assembly: AssemblyTitle("OnePunch")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
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 OnePunch
{
	[BepInPlugin("GeeEm.WrestlingEmpire.OnePunch", "OnePunch", "1.1.2")]
	[HarmonyPatch]
	public class Plugin : BaseUnityPlugin
	{
		[HarmonyPatch(typeof(DFOGOCNBECG))]
		public static class DFOGOCNBECG_Patch
		{
			[HarmonyPatch("DIIMPIPKAFK")]
			[HarmonyPrefix]
			private static void DIIMPIPKAFK_Prefix(DFOGOCNBECG __instance, DFOGOCNBECG ELPIOHCPOIJ, int DODBHICKEPB, float CLNCAKDCODN, float FJDILPBOGEJ)
			{
				if (__instance.EMDMDLNJFKP.id == Characters.wrestler)
				{
					if (NoHealthAndStun.Value)
					{
						DamageStun(ELPIOHCPOIJ);
					}
					if (Dizzyness.Value)
					{
						DizzyTarget(ELPIOHCPOIJ);
					}
					if (InjureTarget.Value)
					{
						Injure(ELPIOHCPOIJ);
					}
					if (KOTarget.Value)
					{
						KnockOut(ELPIOHCPOIJ);
					}
				}
			}

			[HarmonyPatch("MHNNBEOCPGA")]
			[HarmonyPrefix]
			private static void MHNNBEOCPGA_Prefix(DFOGOCNBECG __instance, int MKCPMOJGBEM, float FPLEMEKHJLD, float FJDILPBOGEJ)
			{
				if (__instance.EMDMDLNJFKP.id == Characters.wrestler && (__instance.DPHHFKLDOOG > 0 || __instance.ELPIOHCPOIJ.NLDPMDNKGIC == 643 || __instance.ELPIOHCPOIJ.NLDPMDNKGIC == 644))
				{
					if (NoHealthAndStun.Value)
					{
						DamageStun(__instance.ELPIOHCPOIJ);
					}
					if (Dizzyness.Value)
					{
						DizzyTarget(__instance.ELPIOHCPOIJ);
					}
					if (InjureTarget.Value)
					{
						Injure(__instance.ELPIOHCPOIJ);
					}
					if (KOTarget.Value)
					{
						KnockOut(__instance.ELPIOHCPOIJ);
					}
				}
			}

			[HarmonyPatch("LKGOPCPNDNK")]
			[HarmonyPrefix]
			private static void LKGOPCPNDNK_Prefix(DFOGOCNBECG __instance, DFOGOCNBECG __0, int __1, float __2)
			{
				if (__instance.EMDMDLNJFKP.id == Characters.wrestler)
				{
					if (NoHealthAndStun.Value)
					{
						DamageStun(__0);
					}
					if (Dizzyness.Value)
					{
						DizzyTarget(__0);
					}
					if (InjureTarget.Value)
					{
						Injure(__0);
					}
					if (KOTarget.Value)
					{
						KnockOut(__0);
					}
				}
			}

			[HarmonyPatch("PFGONEIPHLJ")]
			[HarmonyPrefix]
			private static void PFGONEIPHLJ_Prefix(DFOGOCNBECG __instance, float KCMMOFECACH, float HAFBGEAMBMI, float JHCBBFEIKHL, int HNMOIBIFJID, float CLNCAKDCODN, float FJDILPBOGEJ)
			{
				if (__instance.EMDMDLNJFKP.id != Characters.wrestler)
				{
					return;
				}
				HAFBGEAMBMI *= __instance.JNLAJNFCDHA;
				KCMMOFECACH *= __instance.JNLAJNFCDHA;
				float nJDGEELLAKG = __instance.NJDGEELLAKG;
				float bMFDFFLPBOJ = __instance.BMFDFFLPBOJ;
				float num = HAFBGEAMBMI;
				if (num < KCMMOFECACH / 2f)
				{
					num = KCMMOFECACH / 2f;
				}
				nJDGEELLAKG += NAEEIFNFBBO.PDOBPEFCMCK(__instance.PJJFOALHEPF, num);
				bMFDFFLPBOJ += NAEEIFNFBBO.GPMMBFPCFFL(__instance.PJJFOALHEPF, num);
				CLNCAKDCODN *= 0.5f + __instance.HNFHLLJOFKI[2] / 200f;
				int num2 = 0;
				int num3 = 0;
				int num4 = 0;
				float num5 = 9999f;
				for (int i = 1; i <= NJBJIIIACEP.NBBBLJDBLNM; i++)
				{
					DFOGOCNBECG val = NJBJIIIACEP.OAAMGFLINOB[i];
					if (i == __instance.PLFGKLGCOMD || !(val.AHBNKMMMGFI > 0f) || __instance.KPEFINJBJLJ[i] != 0 || LIPNHOMGGHF.FAKHAFKOBPB == 60)
					{
						continue;
					}
					int num6 = val.KFHGMKAKGDC();
					if ((HNMOIBIFJID <= 0 || num6 <= 0) && num6 < 3)
					{
						continue;
					}
					float num7 = (val.DFINJNKKMFL(1) + val.DFINJNKKMFL(3)) / 2f;
					num7 += 4f * (__instance.JNLAJNFCDHA * val.JNLAJNFCDHA);
					if (i == __instance.NNMDEFLLNBF)
					{
					}
					if (!(JHCBBFEIKHL > val.FNNBCDPJBIO - 3f) || !(JHCBBFEIKHL <= num7))
					{
						continue;
					}
					int num8 = val.MDOAGGHHHDC(nJDGEELLAKG, bMFDFFLPBOJ, KCMMOFECACH);
					if (num8 == 0)
					{
						num8 = val.MDOAGGHHHDC((__instance.NJDGEELLAKG + nJDGEELLAKG) / 2f, (__instance.BMFDFFLPBOJ + bMFDFFLPBOJ) / 2f, KCMMOFECACH / 2f);
					}
					if (__instance.GDIEPKEPCAJ() == 0 && num6 >= 3 && val.ECCLLOHOJDO(10) > 0 && __instance.KDDHPODFDHB != -1)
					{
						num8 = 0;
					}
					if (val.DFINJNKKMFL(1) > val.FNNBCDPJBIO + 10f * val.JNLAJNFCDHA)
					{
						num8 = 0;
					}
					if (num8 > 0 && __instance.GDIEPKEPCAJ() > 0)
					{
						if (__instance.GEPLNBJEDLH[9] < 0 && __instance.GEPLNBJEDLH[12] < 0)
						{
							num8 = 0;
						}
						if (GIMNNPMAKNJ.JIHKMLJICDO(__instance.NJDGEELLAKG, __instance.BMFDFFLPBOJ, 0f) != GIMNNPMAKNJ.JIHKMLJICDO(val.NJDGEELLAKG, val.BMFDFFLPBOJ, 0f))
						{
							num8 = 0;
						}
						if (Mathf.Abs(__instance.EKOHAKPAOGN - val.EKOHAKPAOGN) > 2f || Mathf.Abs(__instance.FNNBCDPJBIO - val.FNNBCDPJBIO) > 2f || __instance.NELODEMHJHN != val.NELODEMHJHN)
						{
							num8 = 0;
						}
						if (__instance.KPEFINJBJLJ[0] != 0)
						{
							num8 = 0;
						}
						if ((__instance.NEMJMNEGAAH(i) > 0 || val.FIEMGOLBHIO == 3) && __instance.NNMDEFLLNBF > 0 && __instance.NNMDEFLLNBF != i && __instance.JKIPPBBKNOC != i)
						{
							num8 = 0;
						}
					}
					if (val.CJAFIDDNBOC() > 0)
					{
						num8 = 0;
					}
					if (GIMNNPMAKNJ.DMPAOJMIAHN(__instance.NJDGEELLAKG, __instance.DFINJNKKMFL(1), __instance.BMFDFFLPBOJ, val.NJDGEELLAKG, val.DFINJNKKMFL(1), val.BMFDFFLPBOJ) > 0)
					{
						num8 = 0;
					}
					if (num8 > 0)
					{
						float num9 = NAEEIFNFBBO.FHPCDHIGILG(nJDGEELLAKG, bMFDFFLPBOJ, val.NJDGEELLAKG, val.BMFDFFLPBOJ);
						if (num6 <= 2)
						{
							num9 *= 4f;
						}
						if (__instance.GDIEPKEPCAJ() > 0 && val.MKKDHANKPEN > 0)
						{
							num9 *= 2f;
						}
						if ((__instance.NEMJMNEGAAH(i) > 0 || val.FIEMGOLBHIO == 3) && __instance.NNMDEFLLNBF != i && __instance.JKIPPBBKNOC != i)
						{
							num9 *= 10f;
						}
						if (num9 < num5)
						{
							num3 = 1;
							num2 = i;
							num4 = num8;
							num5 = num9;
						}
					}
				}
				if (__instance.KPEFINJBJLJ[0] == 0 && __instance.GPKBOEBABNI[0] == 0 && __instance.GDIEPKEPCAJ() == 0)
				{
					for (int j = 1; j <= HAPFAOIMGOL.HOEGNFNHMOA; j++)
					{
						GGKBLABCJFN val2 = HAPFAOIMGOL.OMOGPIJGMKO[j];
						if (val2.LOBDMDPMFLK < 0 || (val2.LOBDMDPMFLK > 0 && HNMOIBIFJID >= 2))
						{
							float num10 = NAEEIFNFBBO.FHPCDHIGILG(__instance.NJDGEELLAKG, __instance.BMFDFFLPBOJ, val2.NJDGEELLAKG, val2.BMFDFFLPBOJ);
							if (val2.GBLDMIAPNEP(nJDGEELLAKG, JHCBBFEIKHL, bMFDFFLPBOJ, 0f) > 0 && j != __instance.NELODEMHJHN && num10 < num5)
							{
								num3 = 2;
								num2 = j;
								num5 = num10;
							}
						}
					}
				}
				if (num3 == 1 && num2 > 0)
				{
					int num11 = num2;
					DFOGOCNBECG instance = NJBJIIIACEP.OAAMGFLINOB[num11];
					if (NoHealthAndStun.Value)
					{
						DamageStun(instance);
					}
					if (Dizzyness.Value)
					{
						DizzyTarget(instance);
					}
					if (InjureTarget.Value)
					{
						Injure(instance);
					}
					if (KOTarget.Value)
					{
						KnockOut(instance);
					}
				}
			}
		}

		public const string PluginGuid = "GeeEm.WrestlingEmpire.OnePunch";

		public const string PluginName = "OnePunch";

		public const string PluginVer = "1.1.2";

		internal static ManualLogSource Log;

		internal static readonly Harmony Harmony = new Harmony("GeeEm.WrestlingEmpire.OnePunch");

		internal static string PluginPath;

		public static ConfigEntry<bool> NoHealthAndStun;

		public static ConfigEntry<bool> Dizzyness;

		public static ConfigEntry<bool> InjureTarget;

		public static ConfigEntry<bool> KOTarget;

		private void Awake()
		{
			Log = ((BaseUnityPlugin)this).Logger;
			PluginPath = Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location);
			NoHealthAndStun = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "No Health", true, "Punches will remove all health and stun the target");
			Dizzyness = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Dizzyness", true, "Punches will apply dizzyness to the target");
			InjureTarget = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Injure", false, "Punches will injure the target");
			KOTarget = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Knock out", false, "Punches will DQ and knock out the target");
		}

		private void OnEnable()
		{
			Harmony.PatchAll();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Loaded OnePunch!");
		}

		private void OnDisable()
		{
			Harmony.UnpatchSelf();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Unloaded OnePunch!");
		}

		public static void Injure(DFOGOCNBECG instance)
		{
			instance.PGJEOKAEPCL = Random.Range(1, 31);
			if (FFCEGMEAIBP.LOBDMDPMFLK == 0 && instance.EMDMDLNJFKP.injuryTime < 2)
			{
				instance.EMDMDLNJFKP.injuryTime = 2;
			}
			CHLPMKEGJBJ.BPLLANFDDDP(instance.GPGOFIFBCLP, CHLPMKEGJBJ.KEMDEGPNJAD[NAEEIFNFBBO.PMEEFNOLAGF(1, 2, 0)], -0.1f, 1f);
			instance.KMGCIKMAJCJ(NAEEIFNFBBO.PMEEFNOLAGF(2, 3, 0), 1f);
			if (FFCEGMEAIBP.FEAOFHKANPP == 16)
			{
				CHLPMKEGJBJ.KIKKPCJGDLM(0, NAEEIFNFBBO.CFPJBJFFJFH(3, 20), 1f);
				FFCEGMEAIBP.MBJFIEPNHPP *= 0.8f;
			}
			else
			{
				CHLPMKEGJBJ.KIKKPCJGDLM(0, -1, 1f);
				CHLPMKEGJBJ.KIKKPCJGDLM(0, NAEEIFNFBBO.PMEEFNOLAGF(16, 20, 0), 0f);
				FFCEGMEAIBP.MBJFIEPNHPP += instance.HNFHLLJOFKI[1] * (instance.HNFHLLJOFKI[1] / 10f) * instance.DFKNBACDFGM(0);
				if (FFCEGMEAIBP.NHMKFGOLHJA == 16)
				{
					FFCEGMEAIBP.MBJFIEPNHPP += instance.HNFHLLJOFKI[1] * (instance.HNFHLLJOFKI[1] / 10f) * instance.DFKNBACDFGM(0);
				}
			}
			FFCEGMEAIBP.IJOIMLGJION += 250f * instance.DFKNBACDFGM(0);
			instance.HLGALFAGDGC /= 2f;
			instance.BBBGPIILOBB /= 2f;
			if (FFCEGMEAIBP.LOBDMDPMFLK != 0)
			{
				for (int i = 1; i <= NJBJIIIACEP.NBBBLJDBLNM; i++)
				{
					if (NJBJIIIACEP.OAAMGFLINOB[i].FIEMGOLBHIO == 3 || NJBJIIIACEP.OAAMGFLINOB[i].FIEMGOLBHIO == 0)
					{
						NJBJIIIACEP.OAAMGFLINOB[i].PFHOHKJMLLN = 48;
					}
				}
			}
			Characters.LPGPAKHJMMA(NJBJIIIACEP.OAAMGFLINOB[instance.JNNBBJKLEFK].GOOKPABIPBC, instance.GOOKPABIPBC);
			NJBJIIIACEP.PKGACKAGENN(instance.JNNBBJKLEFK, instance.PLFGKLGCOMD, 1);
		}

		public static void KnockOut(DFOGOCNBECG instance)
		{
			instance.DMEDPMIPBAO = 1;
			if (FFCEGMEAIBP.LOBDMDPMFLK > 0 && instance.FIEMGOLBHIO == 1 && instance.MGPDGDCIBGC == 0f)
			{
				FFCEGMEAIBP.NCAAOLGAGCG(instance.JNNBBJKLEFK, instance.PLFGKLGCOMD);
			}
			instance.MGPDGDCIBGC = 1f;
			FFCEGMEAIBP.JPBHIEOKODO = FFCEGMEAIBP.BCENJCEONEB(1);
			if (FFCEGMEAIBP.JPBHIEOKODO == 0)
			{
				FFCEGMEAIBP.CADLONHABMC = 0;
				if (FFCEGMEAIBP.GDKCEGBINCM >= 1 && FFCEGMEAIBP.GDKCEGBINCM <= 2)
				{
					FFCEGMEAIBP.GDKCEGBINCM = 0;
				}
			}
		}

		public static void DamageStun(DFOGOCNBECG instance)
		{
			instance.HLGALFAGDGC = 0f;
			instance.OIHGGHEDIFF = 0f;
			instance.OKPAGLBJIOH = float.MaxValue;
		}

		public static void DizzyTarget(DFOGOCNBECG instance)
		{
			instance.FLOPBFFLLDE = float.MinValue;
		}
	}
}