using System;
using System.Collections;
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.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using EntityStates;
using HG.Coroutines;
using HG.Reflection;
using Microsoft.CodeAnalysis;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using MonoMod.RuntimeDetour;
using MonoMod.Utils;
using On.RoR2;
using RiskOfOptions;
using RiskOfOptions.Options;
using RoR2;
using RoR2.ContentManagement;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: OptIn]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("EntityStatesConfigurator")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("EntityStatesConfigurator")]
[assembly: AssemblyTitle("EntityStatesConfigurator")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
[module: UnverifiableCode]
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 EntityStatesConfigurator
{
	[Serializable]
	[BepInPlugin("com.brynzananas.entitystatesconfigurator", "Entity States Configurator", "1.0.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class EntityStatesConfiguratorPlugin : BaseUnityPlugin
	{
		private class DisplayClass<T>
		{
			public string name;

			private bool isFloat;

			public DisplayClass(ILContext iLContext, MethodInfo methodInfo, string name)
			{
				this.name = name;
				isFloat = typeof(T) == typeof(float);
				try
				{
					Handle<T>(iLContext, methodInfo);
				}
				catch
				{
				}
			}

			private void Handle<T>(ILContext iLContext, MethodInfo methodInfo)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_009a: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a4: Expected O, but got Unknown
				//IL_009f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a6: Expected O, but got Unknown
				ILCursor val = new ILCursor(iLContext);
				if (val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[2]
				{
					(Instruction x) => ILPatternMatchingExt.MatchCall<EntityState>(x, "get_characterBody"),
					(Instruction x) => ILPatternMatchingExt.MatchCallvirt<CharacterBody>(x, "get_" + name)
				}))
				{
					Type declaringType = methodInfo.DeclaringType;
					if (isFloat)
					{
						ConfigEntry<float> val2 = CreateConfig(declaringType, name, 1f, "", enableRiskOfOptions: true);
					}
					else
					{
						ConfigEntry<int> val3 = CreateConfig(declaringType, name, 1, "", enableRiskOfOptions: true);
					}
					try
					{
						ILHook val4 = new ILHook((MethodBase)methodInfo, new Manipulator(Handle2));
					}
					catch
					{
					}
				}
			}

			private void Handle2(ILContext iLContext)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				ILCursor val = new ILCursor(iLContext);
				while (val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[2]
				{
					(Instruction x) => ILPatternMatchingExt.MatchCall<EntityState>(x, "get_characterBody"),
					(Instruction x) => ILPatternMatchingExt.MatchCallvirt<CharacterBody>(x, "get_" + name)
				}))
				{
					val.Emit(OpCodes.Ldarg_0);
					if (isFloat)
					{
						val.EmitDelegate<Func<float, EntityState, float>>((Func<float, EntityState, float>)HandleFloat);
					}
					else
					{
						val.EmitDelegate<Func<int, EntityState, int>>((Func<int, EntityState, int>)HandleInt);
					}
				}
			}

			private float HandleFloat(float value, EntityState entityState)
			{
				Type type = ((object)entityState).GetType();
				if (debug)
				{
					Log.LogMessage((object)("Called " + value + " " + name + " from " + type.Namespace + type.Name));
				}
				if (keyValuePairs.TryGetValue(type, out var value2) && value2.TryGetValue(name, out var value3))
				{
					ConfigEntry<float> val = value3 as ConfigEntry<float>;
					value *= val.Value;
				}
				return value;
			}

			private int HandleInt(int value, EntityState entityState)
			{
				Type type = ((object)entityState).GetType();
				if (keyValuePairs.TryGetValue(type, out var value2) && value2.TryGetValue(name, out var value3))
				{
					ConfigEntry<int> val = value3 as ConfigEntry<int>;
					value *= val.Value;
				}
				return value;
			}
		}

		private class DisplayClassStat
		{
			public string name;

			public string name2;

			public DisplayClassStat(ILContext iLContext, MethodInfo methodInfo, string name, string name2)
			{
				this.name = name;
				this.name2 = name2;
				try
				{
					Handle(iLContext, methodInfo);
				}
				catch
				{
				}
			}

			private void Handle(ILContext iLContext, MethodInfo methodInfo)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_0073: Unknown result type (might be due to invalid IL or missing references)
				//IL_007d: Expected O, but got Unknown
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: Expected O, but got Unknown
				ILCursor val = new ILCursor(iLContext);
				if (val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[2]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
					(Instruction x) => ILPatternMatchingExt.MatchLdfld<BaseState>(x, name)
				}))
				{
					Type declaringType = methodInfo.DeclaringType;
					ConfigEntry<float> val2 = CreateConfig(declaringType, name2, 1f, "", enableRiskOfOptions: true);
					try
					{
						ILHook val3 = new ILHook((MethodBase)methodInfo, new Manipulator(Handle2));
					}
					catch
					{
					}
				}
			}

			private void Handle2(ILContext iLContext)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				ILCursor val = new ILCursor(iLContext);
				while (val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[2]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
					(Instruction x) => ILPatternMatchingExt.MatchLdfld<BaseState>(x, name)
				}))
				{
					val.Emit(OpCodes.Ldarg_0);
					val.EmitDelegate<Func<float, EntityState, float>>((Func<float, EntityState, float>)Handle3);
				}
			}

			private float Handle3(float value, EntityState entityState)
			{
				Type type = ((object)entityState).GetType();
				if (debug)
				{
					Log.LogMessage((object)("Called " + value + " " + name + " from " + type.Namespace + type.Name));
				}
				if (keyValuePairs.TryGetValue(type, out var value2) && value2.TryGetValue(name, out var value3))
				{
					ConfigEntry<float> val = value3 as ConfigEntry<float>;
					value *= val.Value;
				}
				return value;
			}
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static hook_SetState <0>__EntityStateMachine_SetState;
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass25_0
		{
			public ParallelCoroutine loadCoroutine;

			public Stopwatch stopwatch;
		}

		[CompilerGenerated]
		private sealed class <Thread>d__26 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			private Type[] <>s__1;

			private int <>s__2;

			private Type <type2>5__3;

			private MethodInfo[] <methodInfos>5__4;

			private MethodInfo[] <>s__5;

			private int <>s__6;

			private MethodInfo <methodInfo>5__7;

			private DynamicMethodDefinition <dmd>5__8;

			private ILContext <il>5__9;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <Thread>d__26(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>s__1 = null;
				<type2>5__3 = null;
				<methodInfos>5__4 = null;
				<>s__5 = null;
				<methodInfo>5__7 = null;
				<dmd>5__8 = null;
				<il>5__9 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0112: Unknown result type (might be due to invalid IL or missing references)
				//IL_011c: Expected O, but got Unknown
				//IL_0128: Unknown result type (might be due to invalid IL or missing references)
				//IL_0132: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>s__1 = ContentManager.entityStateTypes;
					for (<>s__2 = 0; <>s__2 < <>s__1.Length; <>s__2++)
					{
						<type2>5__3 = <>s__1[<>s__2];
						<methodInfos>5__4 = <type2>5__3.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.GetProperty | BindingFlags.SetProperty);
						try
						{
							<>s__5 = <methodInfos>5__4;
							for (<>s__6 = 0; <>s__6 < <>s__5.Length; <>s__6++)
							{
								<methodInfo>5__7 = <>s__5[<>s__6];
								if (!<methodInfo>5__7.ContainsGenericParameters && !<methodInfo>5__7.IsGenericMethod && !<methodInfo>5__7.IsConstructedGenericMethod && !<methodInfo>5__7.IsGenericMethodDefinition && !methodInfos.Contains(<methodInfo>5__7))
								{
									methodInfos.Add(<methodInfo>5__7);
									if (<methodInfo>5__7.GetMethodBody() != null)
									{
										<dmd>5__8 = new DynamicMethodDefinition((MethodBase)<methodInfo>5__7);
										<il>5__9 = new ILContext(<dmd>5__8.Definition);
										new DisplayClass<float>(<il>5__9, <methodInfo>5__7, "maxHealth");
										new DisplayClass<float>(<il>5__9, <methodInfo>5__7, "maxBarrier");
										new DisplayClass<float>(<il>5__9, <methodInfo>5__7, "regen");
										new DisplayClass<float>(<il>5__9, <methodInfo>5__7, "maxShield");
										new DisplayClass<float>(<il>5__9, <methodInfo>5__7, "moveSpeed");
										new DisplayClassStat(<il>5__9, <methodInfo>5__7, "moveSpeedStat", "moveSpeed");
										new DisplayClass<float>(<il>5__9, <methodInfo>5__7, "acceleration");
										new DisplayClass<float>(<il>5__9, <methodInfo>5__7, "jumpPower");
										new DisplayClass<int>(<il>5__9, <methodInfo>5__7, "maxJumpCount");
										new DisplayClass<float>(<il>5__9, <methodInfo>5__7, "maxJumpHeight");
										new DisplayClass<float>(<il>5__9, <methodInfo>5__7, "damage");
										new DisplayClassStat(<il>5__9, <methodInfo>5__7, "damageStat", "damage");
										new DisplayClass<float>(<il>5__9, <methodInfo>5__7, "attackSpeed");
										new DisplayClassStat(<il>5__9, <methodInfo>5__7, "attackSpeedStat", "attackSpeed");
										new DisplayClass<float>(<il>5__9, <methodInfo>5__7, "crit");
										new DisplayClassStat(<il>5__9, <methodInfo>5__7, "critStat", "crit");
										new DisplayClass<float>(<il>5__9, <methodInfo>5__7, "critMultiplier");
										new DisplayClass<float>(<il>5__9, <methodInfo>5__7, "bleedChance");
										new DisplayClass<float>(<il>5__9, <methodInfo>5__7, "armor");
										new DisplayClass<float>(<il>5__9, <methodInfo>5__7, "critHeal");
										<dmd>5__8 = null;
										<il>5__9 = null;
										<methodInfo>5__7 = null;
									}
								}
							}
							<>s__5 = null;
						}
						catch
						{
						}
						<methodInfos>5__4 = null;
						<type2>5__3 = null;
					}
					<>s__1 = null;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public const string ModGuid = "com.brynzananas.entitystatesconfigurator";

		public const string ModName = "Entity States Configurator";

		public const string ModVer = "1.0.0";

		public static HashSet<MethodInfo> methodInfos = new HashSet<MethodInfo>();

		public static Dictionary<Type, string> names = new Dictionary<Type, string>();

		public static Dictionary<Type, Dictionary<string, ConfigEntryBase>> keyValuePairs = new Dictionary<Type, Dictionary<string, ConfigEntryBase>>();

		private static bool _debug;

		private static char[] forbiddenCharacters = new char[6] { '\n', '\t', '"', '\'', '[', ']' };

		public static ManualLogSource Log { get; private set; }

		public static ConfigFile configFile { get; private set; }

		public static bool riskOfOptionsEnabled { get; private set; }

		public static bool debug
		{
			get
			{
				return _debug;
			}
			set
			{
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_0055: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Expected O, but got Unknown
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Expected O, but got Unknown
				if (value == _debug)
				{
					return;
				}
				_debug = value;
				if (value)
				{
					object obj = <>O.<0>__EntityStateMachine_SetState;
					if (obj == null)
					{
						hook_SetState val = EntityStateMachine_SetState;
						<>O.<0>__EntityStateMachine_SetState = val;
						obj = (object)val;
					}
					EntityStateMachine.SetState += (hook_SetState)obj;
				}
				else
				{
					object obj2 = <>O.<0>__EntityStateMachine_SetState;
					if (obj2 == null)
					{
						hook_SetState val2 = EntityStateMachine_SetState;
						<>O.<0>__EntityStateMachine_SetState = val2;
						obj2 = (object)val2;
					}
					EntityStateMachine.SetState -= (hook_SetState)obj2;
				}
			}
		}

		private static void EntityStateMachine_SetState(orig_SetState orig, EntityStateMachine self, EntityState newState)
		{
			orig.Invoke(self, newState);
			Log.LogMessage((object)("Set state for " + ((object)self)?.ToString() + " to " + (object)newState));
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		public static void CCDebug(ConCommandArgs args)
		{
			debug = ((ConCommandArgs)(ref args)).GetArgBool(0);
			if (debug)
			{
				Log.LogMessage((object)"Enabled debug");
			}
			else
			{
				Log.LogMessage((object)"Disabled debug");
			}
		}

		public void Awake()
		{
			Log = ((BaseUnityPlugin)this).Logger;
			configFile = ((BaseUnityPlugin)this).Config;
			riskOfOptionsEnabled = Chainloader.PluginInfos.ContainsKey("com.rune580.riskofoptions");
			RoR2Application.onLoadFinished = (Action)Delegate.Combine(RoR2Application.onLoadFinished, new Action(OnLoadFinished));
		}

		private void OnLoadFinished()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			<>c__DisplayClass25_0 CS$<>8__locals0 = new <>c__DisplayClass25_0();
			configFile.SaveOnConfigSet = false;
			Log.LogMessage((object)"Begin configuring entity states");
			CS$<>8__locals0.stopwatch = Stopwatch.StartNew();
			CS$<>8__locals0.loadCoroutine = new ParallelCoroutine();
			CS$<>8__locals0.loadCoroutine.Add(Thread());
			((MonoBehaviour)RoR2Application.instance).StartCoroutine(runLoadCoroutine());
			[IteratorStateMachine(typeof(<>c__DisplayClass25_0.<<OnLoadFinished>g__runLoadCoroutine|0>d))]
			IEnumerator runLoadCoroutine()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <>c__DisplayClass25_0.<<OnLoadFinished>g__runLoadCoroutine|0>d(0)
				{
					<>4__this = CS$<>8__locals0
				};
			}
		}

		[IteratorStateMachine(typeof(<Thread>d__26))]
		private static IEnumerator Thread()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Thread>d__26(0);
		}

		private static string HandleString(string @string, Type type)
		{
			if (Utility.IsNullOrWhiteSpace(@string))
			{
				return @string;
			}
			char[] array = forbiddenCharacters;
			foreach (char c in array)
			{
				while (@string.Contains(c))
				{
					@string = @string.Replace(c, ' ');
				}
			}
			@string.Trim();
			int j;
			for (j = 0; names.ContainsValue(@string + ((j == 0) ? "" : ((object)j))); j++)
			{
			}
			@string += ((j == 0) ? "" : ((object)j));
			names.Add(type, @string);
			return @string;
		}

		private static ConfigEntry<T> CreateConfig<T>(Type type, string key, T defaultValue, string description, bool enableRiskOfOptions)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			string text = (names.ContainsKey(type) ? names[type] : HandleString(type.Namespace + "." + type.Name, type));
			if (Utility.IsNullOrWhiteSpace(text))
			{
				return null;
			}
			ConfigDefinition val = new ConfigDefinition(text, key);
			if (keyValuePairs.TryGetValue(type, out var value) && value.TryGetValue(key, out var value2))
			{
				return value2 as ConfigEntry<T>;
			}
			ConfigDescription val2 = new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>());
			ConfigEntry<T> val3 = configFile.Bind<T>(val, defaultValue, val2);
			if (keyValuePairs.ContainsKey(type))
			{
				Dictionary<string, ConfigEntryBase> dictionary = keyValuePairs[type];
				dictionary.Add(key, (ConfigEntryBase)(object)val3);
			}
			else
			{
				Dictionary<string, ConfigEntryBase> dictionary2 = new Dictionary<string, ConfigEntryBase>();
				dictionary2.Add(key, (ConfigEntryBase)(object)val3);
				keyValuePairs.Add(type, dictionary2);
			}
			if (enableRiskOfOptions && riskOfOptionsEnabled)
			{
				ModCompatabilities.RiskOfOptionsCompatability.AddConfig<ConfigEntry<T>>(val3);
			}
			return val3;
		}
	}
	public static class ModCompatabilities
	{
		public static class RiskOfOptionsCompatability
		{
			public const string GUID = "com.rune580.riskofoptions";

			public static void AddConfig<T>(T config) where T : ConfigEntryBase
			{
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Expected O, but got Unknown
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Expected O, but got Unknown
				//IL_0073: Unknown result type (might be due to invalid IL or missing references)
				//IL_007d: Expected O, but got Unknown
				//IL_009d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a7: Expected O, but got Unknown
				if (config is ConfigEntry<float>)
				{
					ModSettingsManager.AddOption((BaseOption)new FloatFieldOption(config as ConfigEntry<float>));
				}
				if (config is ConfigEntry<bool>)
				{
					ModSettingsManager.AddOption((BaseOption)new CheckBoxOption(config as ConfigEntry<bool>));
				}
				if (config is ConfigEntry<int>)
				{
					ModSettingsManager.AddOption((BaseOption)new IntFieldOption(config as ConfigEntry<int>));
				}
				if (config is ConfigEntry<string>)
				{
					ModSettingsManager.AddOption((BaseOption)new StringInputFieldOption(config as ConfigEntry<string>));
				}
			}
		}
	}
}