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.Configuration;
using BepInEx.Logging;
using Microsoft.CodeAnalysis;
using On.RoR2;
using R2API.Utils;
using RoR2;
using RoR2.Projectile;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("ConfigEgocentrism")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("ConfigEgocentrism")]
[assembly: AssemblyTitle("ConfigEgocentrism")]
[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 ConfigEgocentrism
{
	[BepInPlugin("Judgy.ConfigEgocentrism", "ConfigEgocentrism", "1.2.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class ConfigEgocentrismPlugin : BaseUnityPlugin
	{
		public const string PluginGUID = "Judgy.ConfigEgocentrism";

		public const string PluginAuthor = "Judgy";

		public const string PluginName = "ConfigEgocentrism";

		public const string PluginVersion = "1.2.1";

		private List<ItemTier> TransformInvalidItemTiers;

		private static ConfigEntry<bool> ConfigProjectilesEnabled { get; set; }

		private static ConfigEntry<float> ConfigProjectilesIntervalBase { get; set; }

		private static ConfigEntry<float> ConfigProjectilesIntervalStackMult { get; set; }

		private static ConfigEntry<float> ConfigProjectilesIntervalStackExponent { get; set; }

		private static ConfigEntry<float> ConfigProjectilesDamageBase { get; set; }

		private static ConfigEntry<float> ConfigProjectilesDamageStackMult { get; set; }

		private static ConfigEntry<float> ConfigProjectilesDamageStackExponent { get; set; }

		private static ConfigEntry<float> ConfigProjectilesMaxAmountBase { get; set; }

		private static ConfigEntry<float> ConfigProjectilesMaxAmountStackMult { get; set; }

		private static ConfigEntry<float> ConfigProjectilesMaxAmountStackExponent { get; set; }

		private static ConfigEntry<string> ConfigProjectilesMaxAmountRoundingMode { get; set; }

		private static ConfigEntry<float> ConfigProjectilesRangeBase { get; set; }

		private static ConfigEntry<float> ConfigProjectilesRangeStackMult { get; set; }

		private static ConfigEntry<float> ConfigProjectilesRangeStackExponent { get; set; }

		private static ConfigEntry<bool> ConfigTransformEnabled { get; set; }

		private static ConfigEntry<float> ConfigTransformIntervalBase { get; set; }

		private static ConfigEntry<float> ConfigTransformIntervalStackMult { get; set; }

		private static ConfigEntry<float> ConfigTransformIntervalStackExponent { get; set; }

		private static ConfigEntry<float> ConfigTransformAmountBase { get; set; }

		private static ConfigEntry<float> ConfigTransformAmountStackMult { get; set; }

		private static ConfigEntry<float> ConfigTransformAmountStackExponent { get; set; }

		private static ConfigEntry<string> ConfigTransformAmountRoundingMode { get; set; }

		private static ConfigEntry<string> ConfigTransformItemFilter { get; set; }

		private static ConfigEntry<string> ConfigPluginVersion { get; set; }

		public void Awake()
		{
			Log.Init(((BaseUnityPlugin)this).Logger);
			CreateConfig();
			BuildItemFilters();
			SetupHooks();
			Log.LogInfo("Awake done.");
		}

		private void CreateConfig()
		{
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Expected O, but got Unknown
			//IL_0351: Unknown result type (might be due to invalid IL or missing references)
			//IL_035b: Expected O, but got Unknown
			ConfigProjectilesEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("Feature Toggle", "Projectiles Enabled", true, "Enables the generation of projectiles.");
			ConfigTransformEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("Feature Toggle", "Transform Enabled", true, "Enables the transformation of other items.");
			ConfigProjectilesIntervalBase = ((BaseUnityPlugin)this).Config.Bind<float>("Projectiles Interval", "Interval Base", 3f, "Sets the base interval between each generation of projectiles (in seconds).\nFormula: _Base_ / (Stack * StackMult)^StackExponent");
			ConfigProjectilesIntervalStackMult = ((BaseUnityPlugin)this).Config.Bind<float>("Projectiles Interval", "Interval Stack Multiplier", 1f, "Sets the stack multiplier in projectiles interval formula.\nOnly accepts positive values or 0.0. Default value used if input is negative.\nFormula: Base / (Stack * _StackMult_)^StackExponent");
			ConfigProjectilesIntervalStackExponent = ((BaseUnityPlugin)this).Config.Bind<float>("Projectiles Interval", "Interval Stack Exponent", 1f, "Sets the stack exponent in projectiles interval formula.\nOnly accepts positive values or 0.0. Default value used if input is negative.\nFormula: Base / (Stack * StackMult)^_StackExponent_");
			ConfigProjectilesDamageBase = ((BaseUnityPlugin)this).Config.Bind<float>("Projectiles Damage", "Damage Base", 3.6f, "Sets the base damage multiplier of projectiles.\nFormula: _Base_ + (Stack * StackMult)^StackExponent");
			ConfigProjectilesDamageStackMult = ((BaseUnityPlugin)this).Config.Bind<float>("Projectiles Damage", "Damage Stack Multiplier", 0f, "Sets the stack multiplier in projectiles damage formula.\nFormula: Base + (Stack * _StackMult_)^StackExponent");
			ConfigProjectilesDamageStackExponent = ((BaseUnityPlugin)this).Config.Bind<float>("Projectiles Damage", "Damage Stack Exponent", 1f, "Sets the stack exponent in projectiles damage formula.\nFormula: Base + (Stack * StackMult)^_StackExponent_");
			ConfigProjectilesMaxAmountBase = ((BaseUnityPlugin)this).Config.Bind<float>("Projectiles Max Amount", "Max Amount Base", 2f, "Sets the base max amount of projectiles.\nFormula: _Base_ + (Stack * StackMult)^StackExponent");
			ConfigProjectilesMaxAmountStackMult = ((BaseUnityPlugin)this).Config.Bind<float>("Projectiles Max Amount", "Max Amount Stack Multiplier", 1f, "Sets the stack multiplier in projectiles max amount formula.\nFormula: Base + (Stack * _StackMult_)^StackExponent");
			ConfigProjectilesMaxAmountStackExponent = ((BaseUnityPlugin)this).Config.Bind<float>("Projectiles Max Amount", "Max Amount Stack Exponent", 1f, "Sets the stack multiplier in projectiles max amount formula.\nFormula: Base + (Stack * StackMult)^_StackExponent_");
			ConfigProjectilesMaxAmountRoundingMode = ((BaseUnityPlugin)this).Config.Bind<string>("Projectiles Max Amount", "Max Amount Rounding Mode", Utils.RoundingMode.AlwaysDown.ToString(), new ConfigDescription("Sets the rounding mode when calculating projectiles max amount.", (AcceptableValueBase)(object)new AcceptableValueList<string>(Enum.GetNames(typeof(Utils.RoundingMode))), Array.Empty<object>()));
			ConfigProjectilesRangeBase = ((BaseUnityPlugin)this).Config.Bind<float>("Projectiles Range", "Range Base", 15f, "Sets the base targeting range of projectiles.\nFormula: _Base_ + (Stack * StackMult)^StackExponent");
			ConfigProjectilesRangeStackMult = ((BaseUnityPlugin)this).Config.Bind<float>("Projectiles Range", "Range Stack Mutliplier", 0f, "Sets the stack multiplier in projectiles range formula.\nFormula: Base + (Stack * _StackMult_)^StackExponent");
			ConfigProjectilesRangeStackExponent = ((BaseUnityPlugin)this).Config.Bind<float>("Projectiles Range", "Range Stack Exponent", 1f, "Sets the stack exponent in projectiles range formula.\nFormula: Base + (Stack * StackMult)^_StackExponent_");
			ConfigTransformIntervalBase = ((BaseUnityPlugin)this).Config.Bind<float>("Transform Interval", "Interval Base", 60f, "Sets the base interval between each item transform (in seconds).\nFormula: _Base_ / (Stack * StackMult)^StackExponent");
			ConfigTransformIntervalStackMult = ((BaseUnityPlugin)this).Config.Bind<float>("Transform Interval", "Interval Stack Multiplier", 0f, "Sets the stack multiplier in item transform interval formula.\nOnly accepts positive values or 0.0. Default value used if input is negative.\nFormula: Base / (Stack * _StackMult_)^StackExponent");
			ConfigTransformIntervalStackExponent = ((BaseUnityPlugin)this).Config.Bind<float>("Transform Interval", "Interval Stack Exponent", 0f, "Sets the stack exponent in item transform interval formula.\nOnly accepts positive values or 0.0. Default value used if input is negative.\nFormula: Base / (Stack * StackMult)^_StackExponent_");
			ConfigTransformAmountBase = ((BaseUnityPlugin)this).Config.Bind<float>("Transform Item Amount", "Transform Amount Base", 1f, "Sets the base number of items transformed at each iteration.\nFormula: _Base_ + (Stack * StackMult)^StackExponent");
			ConfigTransformAmountStackMult = ((BaseUnityPlugin)this).Config.Bind<float>("Transform Item Amount", "Transform Amount Stack Multiplier", 0f, "Sets the stack multiplier in transform item amount formula.\nFormula: Base + (Stack * _StackMult_)^StackExponent");
			ConfigTransformAmountStackExponent = ((BaseUnityPlugin)this).Config.Bind<float>("Transform Item Amount", "Transform Amount Stack Exponent", 1f, "Sets the stack exponent in transform item amount formula.\nFormula: Base + (Stack * StackMult)^_StackExponent_");
			ConfigTransformAmountRoundingMode = ((BaseUnityPlugin)this).Config.Bind<string>("Transform Item Amount", "Transform Amount Rounding Mode", Utils.RoundingMode.AlwaysDown.ToString(), new ConfigDescription("Sets the rounding mode when calculating item transform amount.", (AcceptableValueBase)(object)new AcceptableValueList<string>(Enum.GetNames(typeof(Utils.RoundingMode))), Array.Empty<object>()));
			ConfigTransformItemFilter = ((BaseUnityPlugin)this).Config.Bind<string>("Transform Item Filter", "Filter", "untiered", "Filters Item Tiers to NOT transform. Avoid removing `untiered` from that list to not lose character passives, artifacts and other hidden stuff.\r\nFormat : tier1,tier2,tier3\r\nValid Tiers: untiered,white,green,red,blue,yellow,voidwhite,voidgreen,voidred,voidyellow");
			ConfigTransformItemFilter.SettingChanged += RebuildItemFiltersEvent;
			ConfigPluginVersion = ((BaseUnityPlugin)this).Config.Bind<string>("zMiscellaneous", "Plugin Version", "0.0.0", "Plugin Version, used for cleaning old configs entries.\nAvoid editing this unless you want duplicate config entries.");
			if (ConfigPluginVersion.Value == (string)((ConfigEntryBase)ConfigPluginVersion).DefaultValue)
			{
				ConfigCleanup();
			}
			ConfigPluginVersion.Value = "1.2.1";
		}

		private void ConfigCleanup()
		{
			Log.LogWarning("Old Config data cleaned up. This should only get triggered once ever.");
			Reflection.GetPropertyValue<Dictionary<ConfigDefinition, string>>((object)((BaseUnityPlugin)this).Config, "OrphanedEntries").Clear();
			((BaseUnityPlugin)this).Config.Save();
		}

		private void RebuildItemFiltersEvent(object s, EventArgs e)
		{
			BuildItemFilters();
		}

		private void BuildItemFilters()
		{
			TransformInvalidItemTiers = new List<ItemTier>();
			string[] array = ConfigTransformItemFilter.Value.Split(new char[1] { ',' });
			foreach (string text in array)
			{
				if (!string.IsNullOrWhiteSpace(text))
				{
					if (Enum.TryParse<Utils.ItemTierLookup>(text.Trim().ToLower(), out var result))
					{
						TransformInvalidItemTiers.Add((ItemTier)result);
					}
					else
					{
						Log.LogDebug("TransformItemFilter: Invalid tier input `" + text + "`");
					}
				}
			}
			Log.LogInfo($"TransformItemFilter: Filter List built ({TransformInvalidItemTiers.Count} filters)");
		}

		private void SetupHooks()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			LunarSunBehavior.FixedUpdate += (hook_FixedUpdate)delegate(orig_FixedUpdate orig, LunarSunBehavior self)
			{
				//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ef: 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_011a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0121: Unknown result type (might be due to invalid IL or missing references)
				//IL_0126: Unknown result type (might be due to invalid IL or missing references)
				//IL_012b: Unknown result type (might be due to invalid IL or missing references)
				//IL_012d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0134: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_01de: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_0231: Unknown result type (might be due to invalid IL or missing references)
				//IL_0234: Invalid comparison between Unknown and I4
				//IL_0206: Unknown result type (might be due to invalid IL or missing references)
				//IL_023c: Unknown result type (might be due to invalid IL or missing references)
				//IL_025b: 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_0212: Unknown result type (might be due to invalid IL or missing references)
				//IL_0214: Unknown result type (might be due to invalid IL or missing references)
				CharacterBody fieldValue = Reflection.GetFieldValue<CharacterBody>((object)self, "body");
				GameObject fieldValue2 = Reflection.GetFieldValue<GameObject>((object)self, "projectilePrefab");
				int fieldValue3 = Reflection.GetFieldValue<int>((object)self, "stack");
				float num = Reflection.GetFieldValue<float>((object)self, "projectileTimer");
				float num2 = Reflection.GetFieldValue<float>((object)self, "transformTimer");
				Xoroshiro128Plus fieldValue4 = Reflection.GetFieldValue<Xoroshiro128Plus>((object)self, "transformRng");
				if (ConfigProjectilesEnabled.Value)
				{
					num += Time.fixedDeltaTime;
					float projectilesInterval = GetProjectilesInterval(fieldValue3);
					int num3 = (int)(num / projectilesInterval);
					for (int i = 0; i < num3; i++)
					{
						if (!fieldValue.master.IsDeployableLimited((DeployableSlot)16))
						{
							num -= num;
							ProjectileSphereTargetFinder component = fieldValue2.GetComponent<ProjectileSphereTargetFinder>();
							if (Object.op_Implicit((Object)(object)component))
							{
								component.lookRange = GetProjectilesRange(fieldValue3);
							}
							else
							{
								Log.LogError("LunarSunBehavior: Unable to modify projectile Range (ProjectileSphereTargetFinder component not found)");
							}
							FireProjectileInfo val = default(FireProjectileInfo);
							val.projectilePrefab = fieldValue2;
							val.crit = fieldValue.RollCrit();
							val.damage = fieldValue.damage * GetProjectilesDamage(fieldValue3);
							val.damageColorIndex = (DamageColorIndex)3;
							val.force = 0f;
							val.owner = ((Component)self).gameObject;
							val.position = fieldValue.transform.position;
							val.rotation = Quaternion.identity;
							FireProjectileInfo val2 = val;
							ProjectileManager.instance.FireProjectile(val2);
						}
						else
						{
							num = 0f;
						}
					}
				}
				if (ConfigTransformEnabled.Value)
				{
					num2 += Time.fixedDeltaTime;
					if (num2 > GetTransformInterval(fieldValue3))
					{
						num2 = 0f;
						if (Object.op_Implicit((Object)(object)fieldValue.master) && Object.op_Implicit((Object)(object)fieldValue.inventory))
						{
							int transformAmount = GetTransformAmount(fieldValue3);
							for (int j = 0; j < transformAmount; j++)
							{
								List<ItemIndex> list = new List<ItemIndex>(fieldValue.inventory.itemAcquisitionOrder);
								ItemIndex val3 = (ItemIndex)(-1);
								Util.ShuffleList<ItemIndex>(list, fieldValue4);
								foreach (ItemIndex item in list)
								{
									if (item != Items.LunarSun.itemIndex)
									{
										ItemDef itemDef = ItemCatalog.GetItemDef(item);
										if (Object.op_Implicit((Object)(object)itemDef) && !TransformInvalidItemTiers.Contains(itemDef.tier))
										{
											val3 = item;
											break;
										}
									}
								}
								if ((int)val3 != -1)
								{
									fieldValue.inventory.RemoveItem(val3, 1);
									fieldValue.inventory.GiveItem(Items.LunarSun, 1);
									CharacterMasterNotificationQueue.PushItemTransformNotification(fieldValue.master, val3, Items.LunarSun.itemIndex, (TransformationType)4);
								}
							}
						}
					}
				}
				Reflection.SetFieldValue<float>((object)self, "projectileTimer", num);
				Reflection.SetFieldValue<float>((object)self, "transformTimer", num2);
			};
			LunarSunBehavior.GetMaxProjectiles += (hook_GetMaxProjectiles)((orig_GetMaxProjectiles orig, Inventory inventory) => GetProjectilesMaxAmount(inventory.GetItemCount(Items.LunarSun)));
		}

		private float GetProjectilesInterval(int stack)
		{
			float value = ConfigProjectilesIntervalBase.Value;
			float positiveConfigFloat = Utils.GetPositiveConfigFloat(ConfigProjectilesIntervalStackMult);
			float positiveConfigFloat2 = Utils.GetPositiveConfigFloat(ConfigProjectilesIntervalStackExponent);
			return Utils.GetDividingFormulaValue(value, stack, positiveConfigFloat, positiveConfigFloat2);
		}

		private float GetProjectilesDamage(int stack)
		{
			float value = ConfigProjectilesDamageBase.Value;
			float value2 = ConfigProjectilesDamageStackMult.Value;
			float value3 = ConfigProjectilesDamageStackExponent.Value;
			return Utils.GetAdditionalFormulaValue(value, stack, value2, value3);
		}

		private int GetProjectilesMaxAmount(int stack)
		{
			float value = ConfigProjectilesMaxAmountBase.Value;
			float value2 = ConfigProjectilesMaxAmountStackMult.Value;
			float value3 = ConfigProjectilesMaxAmountStackExponent.Value;
			return Utils.Round(Utils.GetAdditionalFormulaValue(value, stack, value2, value3), ConfigProjectilesMaxAmountRoundingMode.Value);
		}

		private float GetProjectilesRange(int stack)
		{
			float value = ConfigProjectilesRangeBase.Value;
			float value2 = ConfigProjectilesRangeStackMult.Value;
			float value3 = ConfigProjectilesRangeStackExponent.Value;
			return Utils.GetAdditionalFormulaValue(value, stack, value2, value3);
		}

		private float GetTransformInterval(int stack)
		{
			float value = ConfigTransformIntervalBase.Value;
			float positiveConfigFloat = Utils.GetPositiveConfigFloat(ConfigTransformIntervalStackMult);
			float positiveConfigFloat2 = Utils.GetPositiveConfigFloat(ConfigTransformIntervalStackExponent);
			return Utils.GetDividingFormulaValue(value, stack, positiveConfigFloat, positiveConfigFloat2);
		}

		private int GetTransformAmount(int stack)
		{
			float value = ConfigTransformAmountBase.Value;
			float value2 = ConfigTransformAmountStackMult.Value;
			float value3 = ConfigTransformAmountStackExponent.Value;
			return Utils.Round(Utils.GetAdditionalFormulaValue(value, stack, value2, value3), ConfigTransformAmountRoundingMode.Value);
		}
	}
	internal static class Log
	{
		internal static ManualLogSource _logSource;

		internal static void Init(ManualLogSource logSource)
		{
			_logSource = logSource;
		}

		internal static void LogDebug(object data)
		{
			_logSource.LogDebug(data);
		}

		internal static void LogError(object data)
		{
			_logSource.LogError(data);
		}

		internal static void LogFatal(object data)
		{
			_logSource.LogFatal(data);
		}

		internal static void LogInfo(object data)
		{
			_logSource.LogInfo(data);
		}

		internal static void LogMessage(object data)
		{
			_logSource.LogMessage(data);
		}

		internal static void LogWarning(object data)
		{
			_logSource.LogWarning(data);
		}
	}
	public static class Utils
	{
		public enum ItemTierLookup
		{
			white,
			green,
			red,
			blue,
			yellow,
			untiered,
			voidwhite,
			voidgreen,
			voidred,
			voidyellow
		}

		public enum RoundingMode
		{
			AlwaysDown,
			AlwaysUp,
			Closest
		}

		public static int Round(float f, string roundingModeStr, int defaultVal = 0)
		{
			RoundingMode roundingMode = RoundingMode.AlwaysDown;
			if (Enum.TryParse<RoundingMode>(roundingModeStr, out var result))
			{
				roundingMode = result;
			}
			switch (roundingMode)
			{
			case RoundingMode.AlwaysDown:
				return Mathf.FloorToInt(f);
			case RoundingMode.AlwaysUp:
				return Mathf.CeilToInt(f);
			case RoundingMode.Closest:
				return Mathf.RoundToInt(f);
			default:
				Log.LogError("Rounding mode \"" + roundingModeStr + "\" not implemented. Returning default value (" + defaultVal + ")");
				return defaultVal;
			}
		}

		public static float GetPositiveConfigFloat(ConfigEntry<float> config)
		{
			if (config.Value >= 0f)
			{
				return config.Value;
			}
			return (float)((ConfigEntryBase)config).DefaultValue;
		}

		public static float GetAdditionalFormulaValue(float baseVal, int stack, float stackMult, float stackExponent)
		{
			return baseVal + Mathf.Pow((float)stack * stackMult, stackExponent);
		}

		public static float GetDividingFormulaValue(float baseVal, int stack, float stackMult, float stackExponent)
		{
			float num = Mathf.Pow((float)stack * stackMult, stackExponent);
			if (num <= 0f)
			{
				num = 1f;
			}
			return baseVal / num;
		}
	}
}