using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using EntityStates;
using EntityStates.Toolbot;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using On.EntityStates.Toolbot;
using R2API;
using RoR2;
using RoR2.Projectile;
using RoR2.Skills;
using UnityEngine;
using UnityEngine.AddressableAssets;

[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.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("HIFUMultTweaks")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("HIFUMultTweaks")]
[assembly: AssemblyTitle("HIFUMultTweaks")]
[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 HIFUMultTweaks
{
	public class ConfigManager
	{
		internal static bool ConfigChanged;

		internal static bool VersionChanged;

		public static T HandleConfig<T>(ConfigEntryBase entry, ConfigFile config, string name)
		{
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected O, but got Unknown
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Expected O, but got Unknown
			MethodInfo methodInfo = (from x in typeof(ConfigFile).GetMethods()
				where x.Name == "Bind"
				select x).First();
			methodInfo = methodInfo.MakeGenericMethod(typeof(T));
			object[] parameters = new object[3]
			{
				(object)new ConfigDefinition(Regex.Replace(config.ConfigFilePath, "\\W", "") + " : " + entry.Definition.Section, name),
				entry.DefaultValue,
				(object)new ConfigDescription(entry.Description.Description, (AcceptableValueBase)null, Array.Empty<object>())
			};
			ConfigEntryBase val = (ConfigEntryBase)methodInfo.Invoke(config, parameters);
			if (Main._preVersioning)
			{
				entry.BoxedValue = entry.DefaultValue;
			}
			if (!ConfigEqual(val.DefaultValue, val.BoxedValue) && VersionChanged)
			{
				entry.BoxedValue = entry.DefaultValue;
				val.BoxedValue = val.DefaultValue;
			}
			return default(T);
		}

		private static bool ConfigEqual(object a, object b)
		{
			if (a.Equals(b))
			{
				return true;
			}
			if (float.TryParse(a.ToString(), out var result) && float.TryParse(b.ToString(), out var result2) && (double)Mathf.Abs(result - result2) < 0.0001)
			{
				return true;
			}
			return false;
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("HIFU.HIFUMultTweaks", "HIFUMultTweaks", "1.0.7")]
	public class Main : BaseUnityPlugin
	{
		public const string PluginGUID = "HIFU.HIFUMultTweaks";

		public const string PluginAuthor = "HIFU";

		public const string PluginName = "HIFUMultTweaks";

		public const string PluginVersion = "1.0.7";

		public static ConfigFile HMTConfig;

		public static ConfigFile HMTBackupConfig;

		public static ManualLogSource HMTLogger;

		public static bool _preVersioning;

		public static ConfigEntry<bool> enableAutoConfig { get; set; }

		public static ConfigEntry<string> latestVersion { get; set; }

		public void Awake()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			HMTLogger = ((BaseUnityPlugin)this).Logger;
			HMTConfig = ((BaseUnityPlugin)this).Config;
			HMTBackupConfig = new ConfigFile(Paths.ConfigPath + "\\HIFU.HIFUMultTweaks.Backup.cfg", true);
			HMTBackupConfig.Bind<string>(": DO NOT MODIFY THIS FILES CONTENTS :", ": DO NOT MODIFY THIS FILES CONTENTS :", ": DO NOT MODIFY THIS FILES CONTENTS :", ": DO NOT MODIFY THIS FILES CONTENTS :");
			enableAutoConfig = HMTConfig.Bind<bool>("Config", "Enable Auto Config Sync", true, "Disabling this would stop HIFMultTweaks from syncing config whenever a new version is found.");
			_preVersioning = !((Dictionary<ConfigDefinition, string>)AccessTools.DeclaredPropertyGetter(typeof(ConfigFile), "OrphanedEntries").Invoke(HMTConfig, null)).Keys.Any((ConfigDefinition x) => x.Key == "Latest Version");
			latestVersion = HMTConfig.Bind<string>("Config", "Latest Version", "1.0.7", "DO NOT CHANGE THIS");
			if (enableAutoConfig.Value && (_preVersioning || latestVersion.Value != "1.0.7"))
			{
				latestVersion.Value = "1.0.7";
				ConfigManager.VersionChanged = true;
				HMTLogger.LogInfo((object)"Config Autosync Enabled.");
			}
			IEnumerable<Type> enumerable = from type in Assembly.GetExecutingAssembly().GetTypes()
				where !type.IsAbstract && type.IsSubclassOf(typeof(TweakBase))
				select type;
			HMTLogger.LogInfo((object)"==+----------------==TWEAKS==----------------+==");
			foreach (Type item in enumerable)
			{
				TweakBase tweakBase = (TweakBase)Activator.CreateInstance(item);
				if (ValidateTweak(tweakBase))
				{
					tweakBase.Init();
				}
			}
			IEnumerable<Type> enumerable2 = from type in Assembly.GetExecutingAssembly().GetTypes()
				where !type.IsAbstract && type.IsSubclassOf(typeof(MiscBase))
				select type;
			HMTLogger.LogInfo((object)"==+----------------==MISC==----------------+==");
			foreach (Type item2 in enumerable2)
			{
				MiscBase miscBase = (MiscBase)Activator.CreateInstance(item2);
				if (ValidateMisc(miscBase))
				{
					miscBase.Init();
				}
			}
		}

		public bool ValidateTweak(TweakBase tb)
		{
			if (tb.isEnabled && ((BaseUnityPlugin)this).Config.Bind<bool>(tb.Name, "Enable?", true, "Vanilla is false").Value)
			{
				return true;
			}
			return false;
		}

		public bool ValidateMisc(MiscBase mb)
		{
			if (mb.isEnabled && ((BaseUnityPlugin)this).Config.Bind<bool>(mb.Name, "Enable?", true, "Vanilla is false").Value)
			{
				return true;
			}
			return false;
		}

		private void UnprocessedIsActuallyMyFavoriteBandNowSorryGuys()
		{
		}
	}
	public abstract class MiscBase
	{
		public abstract string Name { get; }

		public virtual bool isEnabled { get; } = true;


		public T ConfigOption<T>(T value, string name, string description)
		{
			ConfigEntry<T> val = Main.HMTConfig.Bind<T>(Name, name, value, description);
			ConfigManager.HandleConfig<T>((ConfigEntryBase)(object)val, Main.HMTBackupConfig, name);
			return val.Value;
		}

		public abstract void Hooks();

		public string d(float f)
		{
			return f * 100f + "%";
		}

		public virtual void Init()
		{
			Hooks();
			Main.HMTLogger.LogInfo((object)("Added " + Name));
		}
	}
	public abstract class MiscBase<T> : MiscBase where T : MiscBase<T>
	{
		public static T instance { get; set; }

		public MiscBase()
		{
			if (instance != null)
			{
				throw new InvalidOperationException("Singleton class " + typeof(T).Name + " was instantiated twice");
			}
			instance = this as T;
		}
	}
	public class BlastCanister : TweakBase<BlastCanister>
	{
		public static bool Ignite;

		public override string Name => "Secondary : Blast Canister";

		public override string SkillToken => "secondary";

		public override string DescText => "<style=cIsDamage>Stunning</style>. " + (Ignite ? "<style=cIsDamage>Ignite</style>." : "") + " Launch a canister for <style=cIsDamage>220% damage</style>. Drops <style=cIsDamage>stun</style> bomblets for <style=cIsDamage>5x44% damage</style>.";

		public override void Init()
		{
			Ignite = ConfigOption(value: true, "Ignite?", "Vanilla is false");
			base.Init();
		}

		public override void Hooks()
		{
			Changes();
		}

		private void Changes()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			if (Ignite)
			{
				GameObject val = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/Toolbot/CryoCanisterProjectile.prefab").WaitForCompletion();
				ProjectileDamage component = val.GetComponent<ProjectileDamage>();
				component.damageType = DamageTypeCombo.op_Implicit((DamageType)160);
				SkillDef val2 = Addressables.LoadAssetAsync<SkillDef>((object)"RoR2/Base/Toolbot/ToolbotBodyStunDrone.asset").WaitForCompletion();
				val2.keywordTokens = new string[2] { "KEYWORD_STUNNING", "KEYWORD_IGNITE" };
			}
		}
	}
	public class PowerMode : TweakBase<PowerMode>
	{
		public static BuffDef armorBuff;

		public static BuffDef slowBuff;

		public static float armor;

		public static int count;

		public static float speedReduc;

		private static float countdown = 1f;

		public override string Name => "Special :: Power Mode";

		public override string SkillToken => "special_alt";

		public override string DescText => "Enter a heavy stance, equipping both your <style=cIsDamage>primary attacks</style> at once. Gain <style=cIsUtility>" + 5f * armor + " decaying armor</style>, but lose <style=cIsHealth>-" + Mathf.Round((1f - 1f / (1f + speedReduc)) * 100f) + "% movement speed</style>.";

		public override void Init()
		{
			armor = ConfigOption(20f, "Armor Buff", "Vanilla is 100");
			count = ConfigOption(5, "How many armor stacks to get", "Vanilla is 1 BUT it will decay in a second with vanilla settings, as the decay is 1 stack of armor per second.");
			speedReduc = ConfigOption(0.5f, "Slow Debuff", "Decimal. Vanilla is 0.5");
			base.Init();
		}

		public override void Hooks()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			Changes();
			ToolbotDualWieldBase.OnEnter += new hook_OnEnter(ToolbotDualWieldBase_OnEnter);
			ToolbotDualWield.FixedUpdate += new hook_FixedUpdate(ToolbotDualWield_FixedUpdate);
			ToolbotDualWieldBase.OnExit += new hook_OnExit(ToolbotDualWieldBase_OnExit);
			RecalculateStatsAPI.GetStatCoefficients += new StatHookEventHandler(RecalculateStatsAPI_GetStatCoefficients);
		}

		private void Changes()
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//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_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			armorBuff = ScriptableObject.CreateInstance<BuffDef>();
			armorBuff.isDebuff = false;
			armorBuff.canStack = true;
			armorBuff.isHidden = false;
			((Object)armorBuff).name = "Power Mode Decaying Armor";
			armorBuff.buffColor = Color32.op_Implicit(new Color32((byte)214, (byte)201, (byte)58, byte.MaxValue));
			armorBuff.iconSprite = Addressables.LoadAssetAsync<BuffDef>((object)"RoR2/Base/Common/bdArmorBoost.asset").WaitForCompletion().iconSprite;
			ContentAddition.AddBuffDef(armorBuff);
			slowBuff = ScriptableObject.CreateInstance<BuffDef>();
			slowBuff.isDebuff = true;
			slowBuff.isCooldown = false;
			slowBuff.isHidden = false;
			slowBuff.buffColor = Color32.op_Implicit(new Color32((byte)234, (byte)104, (byte)107, byte.MaxValue));
			((Object)slowBuff).name = "Power Mode Slow";
			slowBuff.canStack = false;
			slowBuff.iconSprite = Addressables.LoadAssetAsync<BuffDef>((object)"RoR2/Base/SprintOutOfCombat/bdWhipBoost.asset").WaitForCompletion().iconSprite;
			ContentAddition.AddBuffDef(slowBuff);
		}

		private void ToolbotDualWieldBase_OnExit(orig_OnExit orig, ToolbotDualWieldBase self)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			if (((EntityState)self).characterBody.GetBuffCount(armorBuff) > 0)
			{
				((EntityState)self).characterBody.SetBuffCount(armorBuff.buffIndex, 0);
			}
			orig.Invoke(self);
		}

		private void ToolbotDualWield_FixedUpdate(orig_FixedUpdate orig, ToolbotDualWield self)
		{
			orig.Invoke(self);
			countdown -= Time.fixedDeltaTime;
			if (countdown <= 0f)
			{
				if (((EntityState)self).characterBody.GetBuffCount(armorBuff) > 0)
				{
					((EntityState)self).characterBody.RemoveBuff(armorBuff);
				}
				countdown = 1f;
			}
		}

		private void RecalculateStatsAPI_GetStatCoefficients(CharacterBody sender, StatHookEventArgs args)
		{
			if (Object.op_Implicit((Object)(object)sender))
			{
				if (sender.HasBuff(slowBuff))
				{
					args.moveSpeedReductionMultAdd += speedReduc;
				}
				args.armorAdd += armor * (float)sender.GetBuffCount(armorBuff);
			}
		}

		private void ToolbotDualWieldBase_OnEnter(orig_OnEnter orig, ToolbotDualWieldBase self)
		{
			self.applyBonusBuff = false;
			ToolbotDualWieldBase.penaltyBuff = slowBuff;
			for (int i = 0; i < count; i++)
			{
				((EntityState)self).characterBody.AddBuff(armorBuff);
			}
			orig.Invoke(self);
		}
	}
	public abstract class TweakBase
	{
		public abstract string Name { get; }

		public abstract string SkillToken { get; }

		public abstract string DescText { get; }

		public virtual bool isEnabled { get; } = true;


		public T ConfigOption<T>(T value, string name, string description)
		{
			ConfigEntry<T> val = Main.HMTConfig.Bind<T>(Name, name, value, description);
			ConfigManager.HandleConfig<T>((ConfigEntryBase)(object)val, Main.HMTBackupConfig, name);
			return val.Value;
		}

		public abstract void Hooks();

		public string d(float f)
		{
			return f * 100f + "%";
		}

		public virtual void Init()
		{
			Hooks();
			string text = "TOOLBOT_" + SkillToken.ToUpper() + "_DESCRIPTION";
			LanguageAPI.Add(text, DescText);
			Main.HMTLogger.LogInfo((object)("Added " + Name));
		}
	}
	public abstract class TweakBase<T> : TweakBase where T : TweakBase<T>
	{
		public static T instance { get; set; }

		public TweakBase()
		{
			if (instance != null)
			{
				throw new InvalidOperationException("Singleton class " + typeof(T).Name + " was instantiated twice");
			}
			instance = this as T;
		}
	}
}
namespace HIFUMultTweaks.Misc
{
	internal class HurtBox : MiscBase
	{
		public static float SizeMultiplier;

		public override string Name => "Misc : Hurt Box";

		public override void Init()
		{
			SizeMultiplier = ConfigOption(0.8f, "Size Multiplier", "Vanilla is 1");
			base.Init();
		}

		public override void Hooks()
		{
			Changes();
		}

		private void Changes()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/Toolbot/ToolbotBody.prefab").WaitForCompletion();
			CapsuleCollider component = ((Component)val.transform.GetChild(0).GetChild(0).GetChild(0)
				.GetChild(0)
				.Find("tempHurtBox")).GetComponent<CapsuleCollider>();
			component.radius = 3.74f * SizeMultiplier;
			component.height = 12.04f * SizeMultiplier;
		}
	}
}