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 IL.RoR2.UI;
using Microsoft.CodeAnalysis;
using Mono.Cecil;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using On.RoR2;
using On.RoR2.UI;
using R2API.AutoVersionGen;
using R2API.Utils;
using RoR2;
using RoR2.UI;
using RoR2BepInExPack.Utilities;
using UnityEngine;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("R2API.Buffs")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+08d7eb19309a06aa19383edbade1e9494f9ee1c2")]
[assembly: AssemblyProduct("R2API.Buffs")]
[assembly: AssemblyTitle("R2API.Buffs")]
[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.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 System.Diagnostics.CodeAnalysis
{
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class MemberNotNullAttribute : Attribute
	{
		public string[] Members { get; }

		public MemberNotNullAttribute(string member)
		{
			Members = new string[1] { member };
		}

		public MemberNotNullAttribute(params string[] members)
		{
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class MemberNotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public string[] Members { get; }

		public MemberNotNullWhenAttribute(bool returnValue, string member)
		{
			ReturnValue = returnValue;
			Members = new string[1] { member };
		}

		public MemberNotNullWhenAttribute(bool returnValue, params string[] members)
		{
			ReturnValue = returnValue;
			Members = members;
		}
	}
}
namespace R2API
{
	[AutoVersion]
	public static class BuffsAPI
	{
		public delegate SimpleSpriteAnimation CustomSimpleSpriteAnimation(BuffIcon buffIcon);

		public enum ModdedBuffFlag
		{

		}

		public delegate void CustomStackingDisplayMethod(BuffIcon buffIcon);

		private class SingleSimpleSpriteAnimationDisplayClass
		{
			public SimpleSpriteAnimation simpleSpriteAnimation;

			public SimpleSpriteAnimation SingleCustomSimpleSpriteAnimation(BuffIcon buffIcon)
			{
				return simpleSpriteAnimation;
			}
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static Manipulator <0>__BuffIcon_UpdateIcon;

			public static hook_OnEnable <1>__BuffIcon_OnEnable;

			public static hook_SetBuffDefs <2>__BuffCatalog_SetBuffDefs;

			public static Func<BuffIcon, bool> <3>__CheckSimpleSpriteAnimation;

			public static Func<BuffIcon, Sprite> <4>__HandleSimpleSpriteAnimation;

			public static Func<BuffIcon, StackingDisplayMethod, bool> <5>__HandleCustomStackingDisplayMethods;
		}

		public const string PluginGUID = "com.bepis.r2api.buffs";

		public const string PluginName = "R2API.Buffs";

		private static bool _hooksEnabled;

		public static StackingDisplayMethod NoneStackingDisplayMethod;

		private static byte[][] _moddedBuffFlags = Array.Empty<byte[]>();

		private static CustomSimpleSpriteAnimation[] _buffDefSimpleSpriteAnimation = Array.Empty<CustomSimpleSpriteAnimation>();

		private static bool _init;

		public static int VanillaStackingDisplayMethodCount;

		private static readonly List<StackingDisplayMethod> CustomStackingDisplayMethods = new List<StackingDisplayMethod>();

		private static CustomStackingDisplayMethod[] _customStackingDisplayMethod = new CustomStackingDisplayMethod[0];

		private static Dictionary<BuffDef, byte[]> _pendingModdedBuffFlags = new Dictionary<BuffDef, byte[]>();

		private static Dictionary<BuffDef, CustomSimpleSpriteAnimation> _pendingSimpleSpriteAnimation = new Dictionary<BuffDef, CustomSimpleSpriteAnimation>();

		private static FixedConditionalWeakTable<BuffIcon, SimpleSpriteAnimator> _buffIconSimpleSpriteAnimator = new FixedConditionalWeakTable<BuffIcon, SimpleSpriteAnimator>();

		public const string PluginVersion = "1.0.0";

		public static int CustomStackingDisplayMethodCount => CustomStackingDisplayMethods.Count;

		public static int ModdedBuffFlagCount { get; private set; }

		internal static void SetHooks()
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			//IL_0087: 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)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Expected O, but got Unknown
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			if (!_hooksEnabled)
			{
				_hooksEnabled = true;
				VanillaStackingDisplayMethodCount = Enum.GetValues(typeof(StackingDisplayMethod)).Length;
				object obj = <>O.<0>__BuffIcon_UpdateIcon;
				if (obj == null)
				{
					Manipulator val = BuffIcon_UpdateIcon;
					<>O.<0>__BuffIcon_UpdateIcon = val;
					obj = (object)val;
				}
				BuffIcon.UpdateIcon += (Manipulator)obj;
				object obj2 = <>O.<1>__BuffIcon_OnEnable;
				if (obj2 == null)
				{
					hook_OnEnable val2 = BuffIcon_OnEnable;
					<>O.<1>__BuffIcon_OnEnable = val2;
					obj2 = (object)val2;
				}
				BuffIcon.OnEnable += (hook_OnEnable)obj2;
				object obj3 = <>O.<2>__BuffCatalog_SetBuffDefs;
				if (obj3 == null)
				{
					hook_SetBuffDefs val3 = BuffCatalog_SetBuffDefs;
					<>O.<2>__BuffCatalog_SetBuffDefs = val3;
					obj3 = (object)val3;
				}
				BuffCatalog.SetBuffDefs += (hook_SetBuffDefs)obj3;
				if ((int)NoneStackingDisplayMethod == 0)
				{
					NoneStackingDisplayMethod = RegisterStackingDisplayMethod(null);
				}
			}
		}

		internal static void UnsetHooks()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			if (_hooksEnabled)
			{
				_hooksEnabled = false;
				object obj = <>O.<0>__BuffIcon_UpdateIcon;
				if (obj == null)
				{
					Manipulator val = BuffIcon_UpdateIcon;
					<>O.<0>__BuffIcon_UpdateIcon = val;
					obj = (object)val;
				}
				BuffIcon.UpdateIcon -= (Manipulator)obj;
				object obj2 = <>O.<1>__BuffIcon_OnEnable;
				if (obj2 == null)
				{
					hook_OnEnable val2 = BuffIcon_OnEnable;
					<>O.<1>__BuffIcon_OnEnable = val2;
					obj2 = (object)val2;
				}
				BuffIcon.OnEnable -= (hook_OnEnable)obj2;
				object obj3 = <>O.<2>__BuffCatalog_SetBuffDefs;
				if (obj3 == null)
				{
					hook_SetBuffDefs val3 = BuffCatalog_SetBuffDefs;
					<>O.<2>__BuffCatalog_SetBuffDefs = val3;
					obj3 = (object)val3;
				}
				BuffCatalog.SetBuffDefs -= (hook_SetBuffDefs)obj3;
			}
		}

		private static void BuffIcon_OnEnable(orig_OnEnable orig, BuffIcon self)
		{
			orig.Invoke(self);
			SimpleSpriteAnimator val = default(SimpleSpriteAnimator);
			if (_buffIconSimpleSpriteAnimator.TryGetValue(self, ref val) && ((Behaviour)val).enabled)
			{
				val.Tick();
			}
		}

		private static void BuffCatalog_SetBuffDefs(orig_SetBuffDefs orig, BuffDef[] newBuffDefs)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(newBuffDefs);
			if (_init)
			{
				return;
			}
			_moddedBuffFlags = new byte[BuffCatalog.buffCount][];
			_buffDefSimpleSpriteAnimation = new CustomSimpleSpriteAnimation[BuffCatalog.buffCount];
			foreach (KeyValuePair<BuffDef, byte[]> pendingModdedBuffFlag in _pendingModdedBuffFlags)
			{
				BuffDef key = pendingModdedBuffFlag.Key;
				if (Object.op_Implicit((Object)(object)key))
				{
					byte[] value = pendingModdedBuffFlag.Value;
					if (value != null && value.Length != 0)
					{
						_moddedBuffFlags[key.buffIndex] = value;
					}
				}
			}
			_pendingModdedBuffFlags.Clear();
			_pendingModdedBuffFlags = null;
			foreach (KeyValuePair<BuffDef, CustomSimpleSpriteAnimation> item in _pendingSimpleSpriteAnimation)
			{
				BuffDef key2 = item.Key;
				if (Object.op_Implicit((Object)(object)key2))
				{
					CustomSimpleSpriteAnimation value2 = item.Value;
					if (value2 != null)
					{
						_buffDefSimpleSpriteAnimation[key2.buffIndex] = value2;
					}
				}
			}
			_pendingSimpleSpriteAnimation.Clear();
			_pendingSimpleSpriteAnimation = null;
			_init = true;
		}

		private static void BuffIcon_UpdateIcon(ILContext il)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_0282: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_041d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0429: Unknown result type (might be due to invalid IL or missing references)
			//IL_045d: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			int num = default(int);
			if (!val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[4]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
				(Instruction x) => ILPatternMatchingExt.MatchLdfld<BuffIcon>(x, "iconImage"),
				(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, ref num),
				(Instruction x) => ILPatternMatchingExt.MatchCallvirt(x, (MethodBase)Reflection.GetPropertySetter(typeof(Image), "sprite"))
			}))
			{
				BuffsPlugin.Logger.LogError((object)(((MemberReference)il.Method).Name + " IL Hook 1 failed!"));
			}
			else
			{
				Instruction next = val.Next.Next.Next.Next;
				Instruction next2 = val.Next;
				val.Emit(OpCodes.Ldarg_0);
				val.EmitDelegate<Func<BuffIcon, bool>>((Func<BuffIcon, bool>)CheckSimpleSpriteAnimation);
				val.Emit(OpCodes.Brfalse_S, next2);
				val.Emit(OpCodes.Ldarg_0);
				val.Emit(OpCodes.Ldfld, AccessTools.Field(typeof(BuffIcon), "iconImage"));
				val.Emit(OpCodes.Ldarg_0);
				val.EmitDelegate<Func<BuffIcon, Sprite>>((Func<BuffIcon, Sprite>)HandleSimpleSpriteAnimation);
				val.Emit(OpCodes.Br_S, next);
			}
			ILLabel iLLabel = null;
			if (!val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[4]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
				(Instruction x) => ILPatternMatchingExt.MatchLdfld<BuffIcon>(x, "buffDef"),
				(Instruction x) => ILPatternMatchingExt.MatchLdfld<BuffDef>(x, "canStack"),
				(Instruction x) => ILPatternMatchingExt.MatchBrfalse(x, ref iLLabel)
			}))
			{
				BuffsPlugin.Logger.LogError((object)(((MemberReference)il.Method).Name + " IL Hook 2 failed!"));
			}
			else
			{
				val.Emit(OpCodes.Ldarg_0);
				val.Emit(OpCodes.Ldfld, AccessTools.Field(typeof(BuffIcon), "stackCount"));
				val.Emit(OpCodes.Ldfld, AccessTools.Field(typeof(BuffDef), "stackingDisplayMethod"));
				val.Emit(OpCodes.Ldsfld, AccessTools.Field(typeof(BuffsAPI), "NoneStackingDisplayMethod"));
				val.Emit(OpCodes.Beq_S, (object)iLLabel);
			}
			if (!val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[4]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
				(Instruction x) => ILPatternMatchingExt.MatchLdfld<BuffIcon>(x, "stackCount"),
				(Instruction x) => ILPatternMatchingExt.MatchLdcI4(x, 1),
				(Instruction x) => ILPatternMatchingExt.MatchCallvirt(x, (MethodBase)Reflection.GetPropertySetter(typeof(Behaviour), "enabled"))
			}))
			{
				BuffsPlugin.Logger.LogError((object)(((MemberReference)il.Method).Name + " IL Hook 3 failed!"));
				return;
			}
			Instruction next3 = val.Next;
			int stackingDisplayMethodLoc = 0;
			if (!val.TryGotoPrev((MoveType)2, new Func<Instruction, bool>[4]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
				(Instruction x) => ILPatternMatchingExt.MatchLdfld<BuffIcon>(x, "buffDef"),
				(Instruction x) => ILPatternMatchingExt.MatchLdfld<BuffDef>(x, "stackingDisplayMethod"),
				(Instruction x) => ILPatternMatchingExt.MatchStloc(x, ref stackingDisplayMethodLoc)
			}))
			{
				BuffsPlugin.Logger.LogError((object)(((MemberReference)il.Method).Name + " IL Hook 4 failed!"));
				return;
			}
			val.Emit(OpCodes.Ldarg_0);
			val.Emit(OpCodes.Ldloc, stackingDisplayMethodLoc);
			val.EmitDelegate<Func<BuffIcon, StackingDisplayMethod, bool>>((Func<BuffIcon, StackingDisplayMethod, bool>)HandleCustomStackingDisplayMethods);
			val.Emit(OpCodes.Brtrue_S, next3);
		}

		public static StackingDisplayMethod RegisterStackingDisplayMethod(CustomStackingDisplayMethod customStackingDisplayMethod)
		{
			//IL_0033: 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)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			SetHooks();
			int num = VanillaStackingDisplayMethodCount + CustomStackingDisplayMethodCount;
			int num2 = _customStackingDisplayMethod.Length;
			Array.Resize(ref _customStackingDisplayMethod, _customStackingDisplayMethod.Length + 1);
			_customStackingDisplayMethod[num2] = customStackingDisplayMethod;
			StackingDisplayMethod val = (StackingDisplayMethod)num;
			CustomStackingDisplayMethods.Add(val);
			return val;
		}

		public static void SetSimpleSpriteAnimation(this BuffDef buffDef, SimpleSpriteAnimation simpleSpriteAnimation)
		{
			SetHooks();
			SingleSimpleSpriteAnimationDisplayClass singleSimpleSpriteAnimationDisplayClass = new SingleSimpleSpriteAnimationDisplayClass();
			singleSimpleSpriteAnimationDisplayClass.simpleSpriteAnimation = simpleSpriteAnimation;
			buffDef.SetCustomSimpleSpriteAnimation(singleSimpleSpriteAnimationDisplayClass.SingleCustomSimpleSpriteAnimation);
		}

		public static void SetCustomSimpleSpriteAnimation(this BuffDef buffDef, CustomSimpleSpriteAnimation customSimpleSpriteAnimation)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			SetHooks();
			if (_init)
			{
				_buffDefSimpleSpriteAnimation[buffDef.buffIndex] = customSimpleSpriteAnimation;
			}
			else if (_pendingSimpleSpriteAnimation.ContainsKey(buffDef))
			{
				_pendingSimpleSpriteAnimation[buffDef] = customSimpleSpriteAnimation;
			}
			else
			{
				_pendingSimpleSpriteAnimation.Add(buffDef, customSimpleSpriteAnimation);
			}
		}

		public static CustomSimpleSpriteAnimation GetCustomSimpleSpriteAnimation(this BuffDef buffDef)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			SetHooks();
			if (_init)
			{
				return _buffDefSimpleSpriteAnimation[buffDef.buffIndex];
			}
			if (_pendingSimpleSpriteAnimation.TryGetValue(buffDef, out CustomSimpleSpriteAnimation value))
			{
				return value;
			}
			return null;
		}

		public static ModdedBuffFlag ReserveBuffFlag()
		{
			SetHooks();
			if (ModdedBuffFlagCount >= 1152)
			{
				throw new IndexOutOfRangeException($"Reached the limit of {1152} ModdedBuffFlags. Please contact R2API developers to increase the limit");
			}
			ModdedBuffFlagCount++;
			return (ModdedBuffFlag)ModdedBuffFlagCount;
		}

		public static void AddModdedBuffFlag(this BuffDef buffDef, ModdedBuffFlag moddedBuffFlag)
		{
			AddModdedBuffFlagInternal(buffDef, moddedBuffFlag);
		}

		public static bool RemoveModdedBuffFlag(this BuffDef buffDef, ModdedBuffFlag moddedBuffFlag)
		{
			return RemoveModdedBuffFlagInternal(buffDef, moddedBuffFlag);
		}

		public static bool HasAnyModdedBodyFlag(this BuffDef buffDef)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			SetHooks();
			byte[] array;
			if (_init)
			{
				array = _moddedBuffFlags[buffDef.buffIndex];
				if (array != null)
				{
					return array.Length != 0;
				}
				return false;
			}
			if (_pendingModdedBuffFlags.TryGetValue(buffDef, out array))
			{
				if (array != null)
				{
					return array.Length != 0;
				}
				return false;
			}
			return false;
		}

		public static bool HasModdedBuffFlag(this BuffDef buffDef, ModdedBuffFlag moddedBuffFlag)
		{
			return HasModdedBuffFlagInternal(buffDef, moddedBuffFlag);
		}

		private static void AddModdedBuffFlagInternal(BuffDef buffDef, ModdedBuffFlag moddedBuffFlag)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			SetHooks();
			if (!CheckRange(moddedBuffFlag))
			{
				return;
			}
			byte[] array;
			if (_init)
			{
				array = _moddedBuffFlags[buffDef.buffIndex];
				if (array == null)
				{
					array = new byte[0];
				}
				CompressedFlagArrayUtilities.AddImmutable(ref array, (int)(moddedBuffFlag - 1));
				_moddedBuffFlags[buffDef.buffIndex] = array;
			}
			else if (_pendingModdedBuffFlags.TryGetValue(buffDef, out array))
			{
				CompressedFlagArrayUtilities.AddImmutable(ref array, (int)(moddedBuffFlag - 1));
				_pendingModdedBuffFlags[buffDef] = array;
			}
			else
			{
				array = new byte[0];
				CompressedFlagArrayUtilities.AddImmutable(ref array, (int)(moddedBuffFlag - 1));
				_pendingModdedBuffFlags.Add(buffDef, array);
			}
		}

		private static bool RemoveModdedBuffFlagInternal(BuffDef buffDef, ModdedBuffFlag moddedBuffFlag)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			SetHooks();
			if (!CheckRange(moddedBuffFlag))
			{
				return false;
			}
			byte[] array;
			if (_init)
			{
				array = _moddedBuffFlags[buffDef.buffIndex];
				if (array == null)
				{
					return false;
				}
				bool result = CompressedFlagArrayUtilities.RemoveImmutable(ref array, (int)(moddedBuffFlag - 1));
				_moddedBuffFlags[buffDef.buffIndex] = array;
				return result;
			}
			if (_pendingModdedBuffFlags.TryGetValue(buffDef, out array))
			{
				bool result2 = CompressedFlagArrayUtilities.RemoveImmutable(ref array, (int)(moddedBuffFlag - 1));
				_pendingModdedBuffFlags[buffDef] = array;
				return result2;
			}
			return false;
		}

		private static bool HasModdedBuffFlagInternal(BuffDef buffDef, ModdedBuffFlag moddedBuffFlag)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			SetHooks();
			if (!CheckRange(moddedBuffFlag))
			{
				return false;
			}
			byte[] array;
			if (_init)
			{
				array = _moddedBuffFlags[buffDef.buffIndex];
				if (array == null)
				{
					return false;
				}
				return CompressedFlagArrayUtilities.Has(array, (int)(moddedBuffFlag - 1));
			}
			if (_pendingModdedBuffFlags.TryGetValue(buffDef, out array))
			{
				return CompressedFlagArrayUtilities.Has(array, (int)(moddedBuffFlag - 1));
			}
			return false;
		}

		private static bool CheckRange(ModdedBuffFlag moddedBuffFlag)
		{
			if ((int)moddedBuffFlag > ModdedBuffFlagCount || moddedBuffFlag < (ModdedBuffFlag)1)
			{
				BuffsPlugin.Logger.LogError((object)string.Format("Parameter '{0}' with value {1} is out of range of registered types (1-{2})\n{3}", "moddedBuffFlag", moddedBuffFlag, ModdedBuffFlagCount, new StackTrace(fNeedFileInfo: true)));
				return false;
			}
			return true;
		}

		private static void DisableSimpleSpriteAnimator(BuffIcon buffIcon)
		{
			SimpleSpriteAnimator val = default(SimpleSpriteAnimator);
			if (_buffIconSimpleSpriteAnimator.TryGetValue(buffIcon, ref val) && ((Behaviour)val).enabled)
			{
				((Behaviour)val).enabled = false;
			}
		}

		private static bool CheckSimpleSpriteAnimation(BuffIcon buffIcon)
		{
			if (Object.op_Implicit((Object)(object)buffIcon.buffDef.GetCustomSimpleSpriteAnimation()?.Invoke(buffIcon)))
			{
				return true;
			}
			DisableSimpleSpriteAnimator(buffIcon);
			return false;
		}

		private static Sprite HandleSimpleSpriteAnimation(BuffIcon buffIcon)
		{
			SimpleSpriteAnimation val = buffIcon.buffDef.GetCustomSimpleSpriteAnimation()?.Invoke(buffIcon);
			if (Object.op_Implicit((Object)(object)val))
			{
				SimpleSpriteAnimator val2 = default(SimpleSpriteAnimator);
				if (!_buffIconSimpleSpriteAnimator.TryGetValue(buffIcon, ref val2))
				{
					val2 = ((Component)buffIcon).gameObject.AddComponent<SimpleSpriteAnimator>();
					val2.target = buffIcon.iconImage;
					val2.animation = val;
					val2.Tick();
					_buffIconSimpleSpriteAnimator.Add(buffIcon, val2);
				}
				else
				{
					if ((Object)(object)val2.animation != (Object)(object)val)
					{
						val2.animation = val;
						val2.Tick();
					}
					if (!((Behaviour)val2).enabled)
					{
						((Behaviour)val2).enabled = true;
					}
				}
			}
			else
			{
				DisableSimpleSpriteAnimator(buffIcon);
			}
			return buffIcon.iconImage.sprite;
		}

		private static bool HandleCustomStackingDisplayMethods(BuffIcon buffIcon, StackingDisplayMethod stackingDisplayMethod)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			if ((int)stackingDisplayMethod >= VanillaStackingDisplayMethodCount)
			{
				_customStackingDisplayMethod[stackingDisplayMethod - VanillaStackingDisplayMethodCount]?.Invoke(buffIcon);
				return true;
			}
			return false;
		}
	}
	[BepInPlugin("com.bepis.r2api.buffs", "R2API.Buffs", "1.0.0")]
	public sealed class BuffsPlugin : BaseUnityPlugin
	{
		internal static ManualLogSource Logger { get; set; }

		private void Awake()
		{
			Logger = ((BaseUnityPlugin)this).Logger;
			BuffsAPI.SetHooks();
		}

		private void OnDestroy()
		{
			BuffsAPI.UnsetHooks();
		}
	}
}
namespace R2API.AutoVersionGen
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	internal class AutoVersionAttribute : Attribute
	{
	}
}