using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using PerfectRandom.Sulfur.Core;
using PerfectRandom.Sulfur.Core.CharacterStats;
using PerfectRandom.Sulfur.Core.Items;
using PerfectRandom.Sulfur.Core.Stats;
using PerfectRandom.Sulfur.Core.UI.ItemDescription;
using PerfectRandom.Sulfur.Core.Weapons;
using TMPro;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("PerfectOils")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("PerfectOils")]
[assembly: AssemblyCopyright("Copyright ©  2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("fca0f276-8db3-47a4-b077-acfc5373e719")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace PerfectOils
{
	internal sealed class OilTraitService
	{
		internal sealed class OilDefinitionInfo
		{
			internal readonly EnchantmentDefinition Definition;

			internal readonly bool HasMoreBulletDrop;

			internal OilDefinitionInfo(EnchantmentDefinition definition)
			{
				Definition = definition;
				HasMoreBulletDrop = NegativeTraitPolicy.HasMoreBulletDropTrait(((Object)(object)definition == (Object)null) ? null : definition.modifiersApplied);
			}
		}

		private struct ModifierSignature
		{
			internal readonly ItemAttributes Attribute;

			internal readonly StatModType ModType;

			internal readonly float Value;

			internal readonly NegativeOilTrait Traits;

			internal ModifierSignature(ItemModifierContainer modifier, NegativeOilTrait traits)
			{
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				Attribute = modifier.attribute;
				ModType = modifier.modType;
				Value = modifier.value;
				Traits = traits;
			}

			internal bool Matches(ItemAttributes attribute, StatModifier modifier)
			{
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				return modifier != null && Attribute == attribute && ModType == modifier.Type && Math.Abs(Value - modifier.Value) <= 1E-06f;
			}
		}

		private readonly ManualLogSource _log;

		private readonly TraitConfiguration _settings;

		private readonly Dictionary<uint, List<ModifierSignature>> _classifiedBySourceId = new Dictionary<uint, List<ModifierSignature>>();

		private readonly Dictionary<ItemDefinition, OilDefinitionInfo> _oilInfoByItem = new Dictionary<ItemDefinition, OilDefinitionInfo>();

		private readonly Dictionary<EnchantmentDefinition, OilDefinitionInfo> _oilInfoByDefinition = new Dictionary<EnchantmentDefinition, OilDefinitionInfo>();

		private readonly Dictionary<EnchantmentDefinition, bool> _originalDurabilityFlags = new Dictionary<EnchantmentDefinition, bool>();

		private bool _initialized;

		private bool _loggedFirstRuntimeSuppression;

		private bool _warnedUnavailableDatabase;

		private bool _warnedEmptyDatabase;

		private bool _warnedNoOilDefinitions;

		internal bool IsInitialized => _initialized;

		internal OilTraitService(ManualLogSource log, TraitConfiguration settings)
		{
			_log = log;
			_settings = settings;
		}

		internal bool Initialize(AsyncAssetLoading assets, bool detailedLogging)
		{
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Invalid comparison between Unknown and I4
			if (_initialized)
			{
				return true;
			}
			if ((Object)(object)assets == (Object)null || (Object)(object)assets.itemDatabase == (Object)null || (Object)(object)assets.enchantmentDatabase == (Object)null)
			{
				if (!_warnedUnavailableDatabase)
				{
					_log.LogWarning((object)"[PerfectOils] Asset loading completed, but an oil database was unavailable; initialization will be retried.");
					_warnedUnavailableDatabase = true;
				}
				return false;
			}
			List<ItemDefinition> rawList = assets.itemDatabase.GetRawList();
			if (rawList == null)
			{
				if (!_warnedUnavailableDatabase)
				{
					_log.LogWarning((object)"[PerfectOils] Item database returned no raw item list; initialization will be retried.");
					_warnedUnavailableDatabase = true;
				}
				return false;
			}
			if (rawList.Count == 0)
			{
				if (!_warnedEmptyDatabase)
				{
					_log.LogWarning((object)"[PerfectOils] Item database is present but still empty; initialization will be retried.");
					_warnedEmptyDatabase = true;
				}
				return false;
			}
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			int num4 = 0;
			int num5 = 0;
			int num6 = 0;
			int num7 = 0;
			int num8 = 0;
			int num9 = 0;
			for (int i = 0; i < rawList.Count; i++)
			{
				ItemDefinition val = rawList[i];
				if (!IsOilItem(val))
				{
					continue;
				}
				num++;
				EnchantmentDefinition val2;
				try
				{
					val2 = assets.enchantmentDatabase[val.appliesEnchantment];
				}
				catch (Exception ex)
				{
					_log.LogWarning((object)("[PerfectOils] Could not resolve enchantment for oil '" + SafeOilName(val) + "': " + ex.Message));
					continue;
				}
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				if (!_oilInfoByDefinition.TryGetValue(val2, out var value))
				{
					value = new OilDefinitionInfo(val2);
					_oilInfoByDefinition.Add(val2, value);
					num2++;
					uint key = GlobalId.op_Implicit(((EnchantmentId)(ref val2.id)).AsGlobalId());
					List<ModifierSignature> list = new List<ModifierSignature>();
					List<ItemModifierContainer> modifiersApplied = val2.modifiersApplied;
					if (modifiersApplied != null)
					{
						for (int j = 0; j < modifiersApplied.Count; j++)
						{
							ItemModifierContainer val3 = modifiersApplied[j];
							NegativeOilTrait negativeOilTrait = NegativeTraitPolicy.Classify(val3, value.HasMoreBulletDrop);
							if (negativeOilTrait == NegativeOilTrait.None)
							{
								continue;
							}
							list.Add(new ModifierSignature(val3, negativeOilTrait));
							num3++;
							if ((negativeOilTrait & NegativeOilTrait.NegativeBulletSpeed) != NegativeOilTrait.None)
							{
								num5++;
							}
							if ((negativeOilTrait & NegativeOilTrait.NegativeDamage) != NegativeOilTrait.None)
							{
								if ((int)val3.modType == 100)
								{
									num6++;
								}
								else
								{
									num7++;
								}
							}
							if ((negativeOilTrait & NegativeOilTrait.NegativeBulletSize) != NegativeOilTrait.None)
							{
								num8++;
							}
							if ((negativeOilTrait & NegativeOilTrait.NegativeRpm) != NegativeOilTrait.None)
							{
								num9++;
							}
							if (_settings.ShouldRemove(negativeOilTrait))
							{
								num4++;
							}
							if (detailedLogging)
							{
								_log.LogInfo((object)("[PerfectOils] Classified " + NegativeTraitPolicy.Describe(negativeOilTrait) + " from '" + SafeDefinitionName(val2, val) + "' [active=" + _settings.ShouldRemove(negativeOilTrait) + ", attribute=" + ((object)Unsafe.As<ItemAttributes, ItemAttributes>(ref val3.attribute)/*cast due to .constrained prefix*/).ToString() + ", type=" + ((object)Unsafe.As<StatModType, StatModType>(ref val3.modType)/*cast due to .constrained prefix*/).ToString() + ", value=" + val3.value + "]."));
							}
						}
					}
					if (list.Count > 0)
					{
						_classifiedBySourceId[key] = list;
					}
					_originalDurabilityFlags[val2] = val2.CostsDurability;
				}
				_oilInfoByItem[val] = value;
			}
			if (num == 0 || num2 == 0)
			{
				if (!_warnedNoOilDefinitions)
				{
					_log.LogWarning((object)("[PerfectOils] Scanned " + rawList.Count + " item definitions but found no runtime enchantment oils; initialization will be retried."));
					_warnedNoOilDefinitions = true;
				}
				return false;
			}
			_initialized = true;
			_log.LogInfo((object)("[PerfectOils] Scanned " + rawList.Count + " item definitions. Indexed " + num + " oil items across " + num2 + " unique enchantments; " + num3 + " known negative modifiers were classified, and " + num4 + " are currently enabled for suppression by config. Signed-value traits: bulletSpeed=" + num5 + ", damageFlat=" + num6 + ", damagePercent=" + num7 + ", bulletSize=" + num8 + ", rpm=" + num9 + "."));
			return true;
		}

		internal unsafe bool ShouldSuppress(ItemAttributes attribute, StatModifier modifier)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			if (!_initialized || modifier == null)
			{
				return false;
			}
			if (!_classifiedBySourceId.TryGetValue(modifier.SourceId, out var value))
			{
				return false;
			}
			for (int i = 0; i < value.Count; i++)
			{
				ModifierSignature modifierSignature = value[i];
				if (modifierSignature.Matches(attribute, modifier) && _settings.ShouldRemove(modifierSignature.Traits))
				{
					if (!_loggedFirstRuntimeSuppression)
					{
						_loggedFirstRuntimeSuppression = true;
						ManualLogSource log = _log;
						string[] obj = new string[7]
						{
							"[PerfectOils] Runtime suppression is active; the first configured oil modifier was blocked [trait=",
							NegativeTraitPolicy.Describe(modifierSignature.Traits),
							", attribute=",
							((object)(*(ItemAttributes*)(&attribute))/*cast due to .constrained prefix*/).ToString(),
							", sourceId=",
							null,
							null
						};
						uint sourceId = modifier.SourceId;
						obj[5] = sourceId.ToString();
						obj[6] = "].";
						log.LogInfo((object)string.Concat(obj));
					}
					return true;
				}
			}
			return false;
		}

		internal bool TryGetOilInfo(InventoryItem item, out OilDefinitionInfo info)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			info = null;
			if (!_initialized || (Object)(object)item == (Object)null || (Object)(object)item.itemDefinition == (Object)null)
			{
				return false;
			}
			ItemDefinition itemDefinition = item.itemDefinition;
			if (_oilInfoByItem.TryGetValue(itemDefinition, out info))
			{
				return true;
			}
			if (!((EnchantmentId)(ref itemDefinition.appliesEnchantment)).IsValid)
			{
				return false;
			}
			try
			{
				EnchantmentDefinition asset = AssetAccess.GetAsset(itemDefinition.appliesEnchantment);
				return (Object)(object)asset != (Object)null && _oilInfoByDefinition.TryGetValue(asset, out info);
			}
			catch
			{
				info = null;
				return false;
			}
		}

		internal void RefreshDurabilityFlags(bool pluginEnabled)
		{
			bool flag = pluginEnabled && _settings.RemoveExtraDurabilityCost.Value;
			foreach (KeyValuePair<EnchantmentDefinition, bool> originalDurabilityFlag in _originalDurabilityFlags)
			{
				if ((Object)(object)originalDurabilityFlag.Key != (Object)null)
				{
					originalDurabilityFlag.Key.CostsDurability = !flag && originalDurabilityFlag.Value;
				}
			}
		}

		internal void RestoreOriginalDefinitions()
		{
			foreach (KeyValuePair<EnchantmentDefinition, bool> originalDurabilityFlag in _originalDurabilityFlags)
			{
				if ((Object)(object)originalDurabilityFlag.Key != (Object)null)
				{
					originalDurabilityFlag.Key.CostsDurability = originalDurabilityFlag.Value;
				}
			}
			_classifiedBySourceId.Clear();
			_oilInfoByItem.Clear();
			_oilInfoByDefinition.Clear();
			_originalDurabilityFlags.Clear();
			_initialized = false;
			_loggedFirstRuntimeSuppression = false;
			_warnedUnavailableDatabase = false;
			_warnedEmptyDatabase = false;
			_warnedNoOilDefinitions = false;
		}

		private static bool IsOilItem(ItemDefinition itemDefinition)
		{
			return (Object)(object)itemDefinition != (Object)null && itemDefinition.IsEnchantment && ((EnchantmentId)(ref itemDefinition.appliesEnchantment)).IsValid;
		}

		private static string SafeOilName(ItemDefinition oilItem)
		{
			if ((Object)(object)oilItem == (Object)null)
			{
				return "<null oil>";
			}
			if (!string.IsNullOrEmpty(oilItem.displayName))
			{
				return oilItem.displayName;
			}
			return ((object)Unsafe.As<ItemId, ItemId>(ref oilItem.id)/*cast due to .constrained prefix*/).ToString();
		}

		private static string SafeDefinitionName(EnchantmentDefinition definition, ItemDefinition oilItem)
		{
			if ((Object)(object)definition != (Object)null && !string.IsNullOrEmpty(definition.enchantmentName))
			{
				return definition.enchantmentName;
			}
			return SafeOilName(oilItem);
		}
	}
	[Flags]
	internal enum NegativeOilTrait
	{
		None = 0,
		DisableAiming = 1,
		MoreBulletDrop = 2,
		MoreDrag = 4,
		ExtraAmmoConsumeChance = 8,
		DecreaseAccuracyWhenMoving = 0x10,
		DecreaseMoveSpeed = 0x20,
		DecreaseJumpPower = 0x40,
		DecreaseLootChanceMultiplier = 0x80,
		DisableMoneyDrops = 0x100,
		DisableOrganDrops = 0x200,
		NegativeBulletSpeed = 0x400,
		NegativeDamage = 0x800,
		NegativeBulletSize = 0x1000,
		NegativeRpm = 0x2000,
		ExtraDurabilityCost = 0x4000
	}
	internal static class NegativeTraitPolicy
	{
		private const float Epsilon = 1E-06f;

		internal static bool HasMoreBulletDropTrait(IList<ItemModifierContainer> modifiers)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Invalid comparison between Unknown and I4
			if (modifiers == null)
			{
				return false;
			}
			for (int i = 0; i < modifiers.Count; i++)
			{
				ItemModifierContainer val = modifiers[i];
				if (val != null && (int)val.attribute == 102 && IncreasesAttribute(val))
				{
					return true;
				}
			}
			return false;
		}

		internal static NegativeOilTrait Classify(ItemModifierContainer modifier, bool oilHasMoreBulletDrop)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Invalid comparison between Unknown and I4
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Invalid comparison between Unknown and I4
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected I4, but got Unknown
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Expected I4, but got Unknown
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Invalid comparison between Unknown and I4
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Invalid comparison between Unknown and I4
			if (modifier == null)
			{
				return NegativeOilTrait.None;
			}
			ItemAttributes attribute = modifier.attribute;
			ItemAttributes val = attribute;
			if ((int)val <= 52)
			{
				switch (val - 1)
				{
				default:
					if ((int)val != 41)
					{
						if ((int)val != 52)
						{
							break;
						}
						return DecreasesAttribute(modifier) ? NegativeOilTrait.NegativeBulletSize : NegativeOilTrait.None;
					}
					return (oilHasMoreBulletDrop && IncreasesAttribute(modifier)) ? NegativeOilTrait.MoreBulletDrop : NegativeOilTrait.None;
				case 7:
					return IncreasesAttribute(modifier) ? NegativeOilTrait.DisableAiming : NegativeOilTrait.None;
				case 2:
					return IncreasesAttribute(modifier) ? NegativeOilTrait.ExtraAmmoConsumeChance : NegativeOilTrait.None;
				case 0:
					return DecreasesAttribute(modifier) ? NegativeOilTrait.DecreaseAccuracyWhenMoving : NegativeOilTrait.None;
				case 16:
					return DecreasesAttribute(modifier) ? NegativeOilTrait.DecreaseMoveSpeed : NegativeOilTrait.None;
				case 14:
					return DecreasesAttribute(modifier) ? NegativeOilTrait.DecreaseJumpPower : NegativeOilTrait.None;
				case 15:
					return DecreasesAttribute(modifier) ? NegativeOilTrait.DecreaseLootChanceMultiplier : NegativeOilTrait.None;
				case 8:
					return IncreasesAttribute(modifier) ? NegativeOilTrait.DisableMoneyDrops : NegativeOilTrait.None;
				case 9:
					return IncreasesAttribute(modifier) ? NegativeOilTrait.DisableOrganDrops : NegativeOilTrait.None;
				case 5:
				case 6:
					return DecreasesAttribute(modifier) ? NegativeOilTrait.NegativeDamage : NegativeOilTrait.None;
				case 1:
				case 3:
				case 4:
				case 10:
				case 11:
				case 12:
				case 13:
					break;
				}
			}
			else
			{
				if ((int)val == 56)
				{
					return DecreasesAttribute(modifier) ? NegativeOilTrait.NegativeRpm : NegativeOilTrait.None;
				}
				switch (val - 61)
				{
				default:
					if ((int)val != 102)
					{
						break;
					}
					return IncreasesAttribute(modifier) ? NegativeOilTrait.MoreBulletDrop : NegativeOilTrait.None;
				case 4:
					return IncreasesAttribute(modifier) ? NegativeOilTrait.MoreDrag : NegativeOilTrait.None;
				case 0:
					if (!DecreasesAttribute(modifier))
					{
						return NegativeOilTrait.None;
					}
					return (NegativeOilTrait)(0x400 | (oilHasMoreBulletDrop ? 2 : 0));
				case 2:
					return IncreasesAttribute(modifier) ? NegativeOilTrait.ExtraDurabilityCost : NegativeOilTrait.None;
				case 1:
				case 3:
					break;
				}
			}
			return NegativeOilTrait.None;
		}

		internal static string Describe(NegativeOilTrait traits)
		{
			if (traits == NegativeOilTrait.None)
			{
				return "None";
			}
			List<string> list = new List<string>();
			AddName(list, traits, NegativeOilTrait.DisableAiming, "Disable Aiming");
			AddName(list, traits, NegativeOilTrait.MoreBulletDrop, "More Bullet Drop");
			AddName(list, traits, NegativeOilTrait.MoreDrag, "More Drag");
			AddName(list, traits, NegativeOilTrait.ExtraAmmoConsumeChance, "Extra Ammo Consume Chance");
			AddName(list, traits, NegativeOilTrait.DecreaseAccuracyWhenMoving, "Decrease Accuracy When Moving");
			AddName(list, traits, NegativeOilTrait.DecreaseMoveSpeed, "Decrease Move Speed");
			AddName(list, traits, NegativeOilTrait.DecreaseJumpPower, "Decrease Jump Power");
			AddName(list, traits, NegativeOilTrait.DecreaseLootChanceMultiplier, "Decrease Loot Chance Multiplier");
			AddName(list, traits, NegativeOilTrait.DisableMoneyDrops, "Disable Money Drops");
			AddName(list, traits, NegativeOilTrait.DisableOrganDrops, "Disable Organ Drops");
			AddName(list, traits, NegativeOilTrait.NegativeBulletSpeed, "Negative Bullet Speed");
			AddName(list, traits, NegativeOilTrait.NegativeDamage, "Negative Damage");
			AddName(list, traits, NegativeOilTrait.NegativeBulletSize, "Negative Bullet Size");
			AddName(list, traits, NegativeOilTrait.NegativeRpm, "Negative RPM");
			AddName(list, traits, NegativeOilTrait.ExtraDurabilityCost, "Extra Oil Durability Cost");
			return string.Join(" + ", list.ToArray());
		}

		private static bool IncreasesAttribute(ItemModifierContainer modifier)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return IsSupportedModType(modifier.modType) && modifier.value > 1E-06f;
		}

		private static bool DecreasesAttribute(ItemModifierContainer modifier)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return IsSupportedModType(modifier.modType) && modifier.value < -1E-06f;
		}

		private static bool IsSupportedModType(StatModType modType)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Invalid comparison between Unknown and I4
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Invalid comparison between Unknown and I4
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			return (int)modType == 100 || (int)modType == 200 || (int)modType == 300;
		}

		private static void AddName(List<string> names, NegativeOilTrait traits, NegativeOilTrait flag, string name)
		{
			if ((traits & flag) != NegativeOilTrait.None)
			{
				names.Add(name);
			}
		}
	}
	[BepInPlugin("com.ryuka.sulfur.perfectoils", "Perfect Oils", "1.3.0")]
	public sealed class Plugin : BaseUnityPlugin
	{
		public const string PluginGuid = "com.ryuka.sulfur.perfectoils";

		public const string PluginName = "Perfect Oils";

		public const string PluginVersion = "1.3.0";

		private const float InitializationRetryInterval = 1f;

		private Harmony _harmony;

		private AsyncAssetLoading _assetLoader;

		private float _nextInitializationAttempt;

		internal static Plugin Instance { get; private set; }

		internal static ManualLogSource Log { get; private set; }

		internal ConfigEntry<bool> Enabled { get; private set; }

		internal ConfigEntry<bool> ShowRemovedTraitsWithStrikethrough { get; private set; }

		internal ConfigEntry<bool> DetailedLogging { get; private set; }

		internal TraitConfiguration TraitSettings { get; private set; }

		internal OilTraitService OilTraits { get; private set; }

		internal TooltipStrikeRenderer TooltipRenderer { get; private set; }

		private void Awake()
		{
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Expected O, but got Unknown
			Instance = this;
			Log = ((BaseUnityPlugin)this).Logger;
			Enabled = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Enabled", true, "Enable Perfect Oils. Individual undesirable traits can be selected in the Traits section.");
			ShowRemovedTraitsWithStrikethrough = ((BaseUnityPlugin)this).Config.Bind<bool>("Display", "ShowRemovedTraitsWithStrikethrough", true, "Keep the original undesirable-trait text in oil tooltips and draw a strikethrough over lines currently disabled by this mod.");
			DetailedLogging = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "DetailedLogging", false, "Log each classified oil modifier and tooltip line. Keep disabled during normal play.");
			TraitSettings = new TraitConfiguration(((BaseUnityPlugin)this).Config);
			OilTraits = new OilTraitService(((BaseUnityPlugin)this).Logger, TraitSettings);
			TooltipRenderer = new TooltipStrikeRenderer(OilTraits, TraitSettings, ((BaseUnityPlugin)this).Logger);
			Enabled.SettingChanged += OnDurabilitySettingChanged;
			TraitSettings.RemoveExtraDurabilityCost.SettingChanged += OnDurabilitySettingChanged;
			_harmony = new Harmony("com.ryuka.sulfur.perfectoils");
			_harmony.PatchAll(typeof(Plugin).Assembly);
			((BaseUnityPlugin)this).Logger.LogInfo((object)"[PerfectOils] Patches applied. Waiting for the SULFUR asset databases.");
		}

		private void Update()
		{
			if (OilTraits != null && !OilTraits.IsInitialized && !(Time.unscaledTime < _nextInitializationAttempt))
			{
				if ((Object)(object)_assetLoader == (Object)null)
				{
					_assetLoader = Object.FindFirstObjectByType<AsyncAssetLoading>();
				}
				if ((Object)(object)_assetLoader == (Object)null || !_assetLoader.loadingDone)
				{
					_nextInitializationAttempt = Time.unscaledTime + 1f;
				}
				else
				{
					TryInitializeOilTraits(_assetLoader);
				}
			}
		}

		internal void NotifyAssetsReady(AsyncAssetLoading assetLoader)
		{
			if (!((Object)(object)assetLoader == (Object)null))
			{
				_assetLoader = assetLoader;
				TryInitializeOilTraits(assetLoader);
			}
		}

		private void TryInitializeOilTraits(AsyncAssetLoading assetLoader)
		{
			if (OilTraits != null && !OilTraits.IsInitialized)
			{
				if (!OilTraits.Initialize(assetLoader, DetailedLogging.Value))
				{
					_nextInitializationAttempt = Time.unscaledTime + 1f;
				}
				else
				{
					OilTraits.RefreshDurabilityFlags(Enabled.Value);
				}
			}
		}

		private void OnDurabilitySettingChanged(object sender, EventArgs eventArgs)
		{
			if (OilTraits != null && OilTraits.IsInitialized)
			{
				OilTraits.RefreshDurabilityFlags(Enabled.Value);
			}
		}

		private void OnDestroy()
		{
			Enabled.SettingChanged -= OnDurabilitySettingChanged;
			if (TraitSettings != null)
			{
				TraitSettings.RemoveExtraDurabilityCost.SettingChanged -= OnDurabilitySettingChanged;
			}
			if (OilTraits != null)
			{
				OilTraits.RestoreOriginalDefinitions();
			}
			if (_harmony != null)
			{
				_harmony.UnpatchSelf();
			}
			if (Instance == this)
			{
				Instance = null;
				Log = null;
			}
		}
	}
	internal sealed class TooltipStrikeRenderer
	{
		private enum LineKind
		{
			Attribute,
			Description
		}

		private sealed class LineSpec
		{
			internal readonly LineKind Kind;

			internal readonly string Key;

			internal readonly string Value;

			internal readonly bool IsRemoved;

			internal LineSpec(LineKind kind, string key, string value, bool isRemoved)
			{
				Kind = kind;
				Key = key ?? string.Empty;
				Value = value ?? string.Empty;
				IsRemoved = isRemoved;
			}
		}

		private sealed class RenderedLine
		{
			internal readonly LineKind Kind;

			internal readonly int SiblingIndex;

			internal readonly string Key;

			internal readonly string Value;

			internal readonly TMP_Text[] TextComponents;

			internal RenderedLine(LineKind kind, int siblingIndex, string key, string value, TMP_Text[] textComponents)
			{
				Kind = kind;
				SiblingIndex = siblingIndex;
				Key = key ?? string.Empty;
				Value = value ?? string.Empty;
				TextComponents = textComponents;
			}
		}

		private static class LocalizationBridge
		{
			private static readonly MethodInfo TryGetTranslationMethod = FindTryGetTranslation();

			internal static string GetTranslationOrFallback(string term, string fallback)
			{
				if (TryGetTranslationMethod != null)
				{
					try
					{
						object[] array = new object[9] { term, null, true, 0, true, false, null, null, true };
						bool flag = (bool)TryGetTranslationMethod.Invoke(null, array);
						string text = array[1] as string;
						if (flag && !string.IsNullOrEmpty(text))
						{
							return text;
						}
					}
					catch
					{
					}
				}
				return fallback ?? string.Empty;
			}

			private static MethodInfo FindTryGetTranslation()
			{
				Type type = AccessTools.TypeByName("I2.Loc.LocalizationManager");
				if (type == null)
				{
					return null;
				}
				MethodInfo[] methods = type.GetMethods(BindingFlags.Static | BindingFlags.Public);
				foreach (MethodInfo methodInfo in methods)
				{
					if (!(methodInfo.Name != "TryGetTranslation"))
					{
						ParameterInfo[] parameters = methodInfo.GetParameters();
						if (parameters.Length == 9 && parameters[0].ParameterType == typeof(string) && parameters[1].ParameterType == typeof(string).MakeByRefType())
						{
							return methodInfo;
						}
					}
				}
				return null;
			}
		}

		private static readonly FieldInfo AttributesInUseField = AccessTools.Field(typeof(ItemDescription), "attributesInUse");

		private static readonly FieldInfo DescriptionTextInUseField = AccessTools.Field(typeof(ItemDescription), "descriptionTextInUse");

		private static readonly FieldInfo KeyTextField = AccessTools.Field(typeof(ItemDescriptionAttribute), "keyText");

		private static readonly FieldInfo ValueTextField = AccessTools.Field(typeof(ItemDescriptionAttribute), "valueText");

		private static readonly FieldInfo ModifierTextField = AccessTools.Field(typeof(ItemDescriptionAttribute), "modifierText");

		private static readonly MethodInfo FormatModifierValueMethod = AccessTools.Method(typeof(ItemDescription), "GetValueAsStringDependingOnModType", new Type[2]
		{
			typeof(ItemModifierContainer),
			typeof(ItemAttribute)
		}, (Type[])null);

		private readonly OilTraitService _oilTraits;

		private readonly TraitConfiguration _settings;

		private readonly ManualLogSource _log;

		private bool _loggedFirstStrikethrough;

		internal TooltipStrikeRenderer(OilTraitService oilTraits, TraitConfiguration settings, ManualLogSource log)
		{
			_oilTraits = oilTraits;
			_settings = settings;
			_log = log;
		}

		internal void Apply(ItemDescription description, InventoryItem item, bool detailedLogging)
		{
			if ((Object)(object)description == (Object)null || (Object)(object)item == (Object)null || !_oilTraits.TryGetOilInfo(item, out var info) || info == null || (Object)(object)info.Definition == (Object)null || info.Definition.modifiersApplied == null)
			{
				return;
			}
			List<LineSpec> list = BuildLineSpecs(description, info);
			if (list.Count == 0)
			{
				return;
			}
			List<RenderedLine> list2 = CollectRenderedLines(description);
			if (list2.Count == 0)
			{
				return;
			}
			List<int> list3 = FindBestOrderedMatch(list2, list);
			if (list3 == null)
			{
				list3 = FindRemovedLinesFallback(list2, list);
				if (detailedLogging)
				{
					_log.LogWarning((object)("[PerfectOils] Could not match the complete oil modifier block for '" + SafeItemName(item) + "'; used exact removed-line fallback matching."));
				}
			}
			if (list3 == null)
			{
				return;
			}
			int num = 0;
			for (int i = 0; i < list.Count && i < list3.Count; i++)
			{
				if (list[i].IsRemoved && list3[i] >= 0)
				{
					ApplyStrikethrough(list2[list3[i]]);
					num++;
				}
			}
			if (num > 0 && !_loggedFirstStrikethrough)
			{
				_loggedFirstStrikethrough = true;
				_log.LogInfo((object)"[PerfectOils] Tooltip integration is active; removed oil traits are being shown with strikethrough.");
			}
			if (detailedLogging && num > 0)
			{
				_log.LogInfo((object)("[PerfectOils] Marked " + num + " removed trait line(s) in the tooltip for '" + SafeItemName(item) + "'."));
			}
		}

		private List<LineSpec> BuildLineSpecs(ItemDescription description, OilTraitService.OilDefinitionInfo info)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Invalid comparison between Unknown and I4
			//IL_0041: 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_00c8: Unknown result type (might be due to invalid IL or missing references)
			List<LineSpec> list = new List<LineSpec>();
			List<ItemModifierContainer> modifiersApplied = info.Definition.modifiersApplied;
			for (int i = 0; i < modifiersApplied.Count; i++)
			{
				ItemModifierContainer val = modifiersApplied[i];
				if (val == null || (int)val.attribute == 0)
				{
					continue;
				}
				ItemAttribute asset;
				try
				{
					asset = AssetAccess.GetAsset(val.attribute);
				}
				catch
				{
					continue;
				}
				if ((Object)(object)asset == (Object)null || !asset.showInItemDescription)
				{
					continue;
				}
				NegativeOilTrait traits = NegativeTraitPolicy.Classify(val, info.HasMoreBulletDrop);
				bool isRemoved = _settings.ShouldRemove(traits);
				if (asset.simplifiedModAmount)
				{
					bool flag = val.value > 0f;
					string term = string.Format(flag ? "ItemAttributes/{0}_simplifiedIncrease" : "ItemAttributes/{0}_simplifiedDecrease", val.attribute);
					string fallback = (flag ? asset.simplifiedIncreaseString : asset.simplifiedDecreaseString);
					string translationOrFallback = LocalizationBridge.GetTranslationOrFallback(term, fallback);
					if (!string.IsNullOrEmpty(translationOrFallback))
					{
						list.Add(new LineSpec(LineKind.Description, translationOrFallback, string.Empty, isRemoved));
					}
					continue;
				}
				string term2 = $"ItemAttributes/{val.attribute}_itemDescription";
				string translationOrFallback2 = LocalizationBridge.GetTranslationOrFallback(term2, asset.itemDescriptionName);
				if (asset.isBooleanAttribute)
				{
					if (!string.IsNullOrEmpty(translationOrFallback2))
					{
						list.Add(new LineSpec(LineKind.Description, translationOrFallback2, string.Empty, isRemoved));
					}
				}
				else
				{
					string value = FormatModifierValue(description, val, asset);
					string key = translationOrFallback2 + (string.IsNullOrEmpty(value) ? string.Empty : ":");
					list.Add(new LineSpec(LineKind.Attribute, key, value, isRemoved));
				}
			}
			return list;
		}

		private static string FormatModifierValue(ItemDescription description, ItemModifierContainer modifier, ItemAttribute attribute)
		{
			if (FormatModifierValueMethod == null)
			{
				return modifier.GetValueString();
			}
			try
			{
				return ((string)FormatModifierValueMethod.Invoke(description, new object[2] { modifier, attribute })) ?? string.Empty;
			}
			catch
			{
				return modifier.GetValueString() ?? string.Empty;
			}
		}

		private static List<RenderedLine> CollectRenderedLines(ItemDescription description)
		{
			List<RenderedLine> list = new List<RenderedLine>();
			List<ItemDescriptionAttribute> list2 = ((AttributesInUseField == null) ? null : (AttributesInUseField.GetValue(description) as List<ItemDescriptionAttribute>));
			if (list2 != null)
			{
				for (int i = 0; i < list2.Count; i++)
				{
					ItemDescriptionAttribute val = list2[i];
					if (!((Object)(object)val == (Object)null))
					{
						TMP_Text textField = GetTextField(KeyTextField, val);
						TMP_Text textField2 = GetTextField(ValueTextField, val);
						TMP_Text textField3 = GetTextField(ModifierTextField, val);
						list.Add(new RenderedLine(LineKind.Attribute, ((Component)val).transform.GetSiblingIndex(), GetComparableText(textField), GetComparableText(textField2), (TMP_Text[])(object)new TMP_Text[3] { textField, textField2, textField3 }));
					}
				}
			}
			List<ItemDescriptionText> list3 = ((DescriptionTextInUseField == null) ? null : (DescriptionTextInUseField.GetValue(description) as List<ItemDescriptionText>));
			if (list3 != null)
			{
				for (int j = 0; j < list3.Count; j++)
				{
					ItemDescriptionText val2 = list3[j];
					if (!((Object)(object)val2 == (Object)null) && !((Object)(object)val2.textComp == (Object)null))
					{
						int siblingIndex = ((Component)val2).transform.GetSiblingIndex();
						string comparableText = GetComparableText((TMP_Text)(object)val2.textComp);
						string empty = string.Empty;
						TMP_Text[] textComponents = (TMP_Text[])(object)new TextMeshProUGUI[1] { val2.textComp };
						list.Add(new RenderedLine(LineKind.Description, siblingIndex, comparableText, empty, textComponents));
					}
				}
			}
			list.Sort(delegate(RenderedLine left, RenderedLine right)
			{
				int siblingIndex2 = left.SiblingIndex;
				return siblingIndex2.CompareTo(right.SiblingIndex);
			});
			return list;
		}

		private static TMP_Text GetTextField(FieldInfo field, object instance)
		{
			return (TMP_Text)((field == null) ? null : /*isinst with value type is only supported in some contexts*/);
		}

		private static string GetComparableText(TMP_Text text)
		{
			return ((Object)(object)text == (Object)null) ? string.Empty : RemoveOwnStrikeTags(text.text ?? string.Empty);
		}

		private static List<int> FindBestOrderedMatch(List<RenderedLine> lines, List<LineSpec> specs)
		{
			List<int> result = null;
			int num = int.MaxValue;
			for (int i = 0; i < lines.Count; i++)
			{
				if (!Matches(lines[i], specs[0]))
				{
					continue;
				}
				List<int> list = new List<int>(specs.Count) { i };
				int num2 = i + 1;
				bool flag = true;
				for (int j = 1; j < specs.Count; j++)
				{
					int num3 = -1;
					for (int k = num2; k < lines.Count; k++)
					{
						if (Matches(lines[k], specs[j]))
						{
							num3 = k;
							break;
						}
					}
					if (num3 < 0)
					{
						flag = false;
						break;
					}
					list.Add(num3);
					num2 = num3 + 1;
				}
				if (flag)
				{
					int num4 = list[list.Count - 1] - list[0];
					if (num4 < num)
					{
						result = list;
						num = num4;
					}
				}
			}
			return result;
		}

		private static List<int> FindRemovedLinesFallback(List<RenderedLine> lines, List<LineSpec> specs)
		{
			List<int> list = new List<int>(specs.Count);
			HashSet<int> hashSet = new HashSet<int>();
			bool flag = false;
			for (int i = 0; i < specs.Count; i++)
			{
				if (!specs[i].IsRemoved)
				{
					list.Add(-1);
					continue;
				}
				int item = -1;
				for (int j = 0; j < lines.Count; j++)
				{
					if (!hashSet.Contains(j) && Matches(lines[j], specs[i]))
					{
						item = j;
						hashSet.Add(j);
						flag = true;
						break;
					}
				}
				list.Add(item);
			}
			return flag ? list : null;
		}

		private static bool Matches(RenderedLine line, LineSpec spec)
		{
			return line.Kind == spec.Kind && string.Equals(line.Key, spec.Key, StringComparison.Ordinal) && string.Equals(line.Value, spec.Value, StringComparison.Ordinal);
		}

		private static void ApplyStrikethrough(RenderedLine line)
		{
			for (int i = 0; i < line.TextComponents.Length; i++)
			{
				TMP_Text val = line.TextComponents[i];
				if (!((Object)(object)val == (Object)null) && !string.IsNullOrEmpty(val.text))
				{
					string text = RemoveOwnStrikeTags(val.text);
					val.text = "<s>" + text + "</s>";
				}
			}
		}

		private static string RemoveOwnStrikeTags(string text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return string.Empty;
			}
			if (text.StartsWith("<s>", StringComparison.Ordinal) && text.EndsWith("</s>", StringComparison.Ordinal))
			{
				return text.Substring("<s>".Length, text.Length - "<s>".Length - "</s>".Length);
			}
			return text;
		}

		private static string SafeItemName(InventoryItem item)
		{
			if ((Object)(object)item == (Object)null || (Object)(object)item.itemDefinition == (Object)null)
			{
				return "<unknown oil>";
			}
			return string.IsNullOrEmpty(item.itemDefinition.displayName) ? ((object)item.itemDefinition).ToString() : item.itemDefinition.displayName;
		}
	}
	internal sealed class TraitConfiguration
	{
		internal ConfigEntry<bool> RemoveDisableAiming { get; private set; }

		internal ConfigEntry<bool> RemoveMoreBulletDrop { get; private set; }

		internal ConfigEntry<bool> RemoveMoreDrag { get; private set; }

		internal ConfigEntry<bool> RemoveExtraAmmoConsumeChance { get; private set; }

		internal ConfigEntry<bool> RemoveDecreaseAccuracyWhenMoving { get; private set; }

		internal ConfigEntry<bool> RemoveDecreaseMoveSpeed { get; private set; }

		internal ConfigEntry<bool> RemoveDecreaseJumpPower { get; private set; }

		internal ConfigEntry<bool> RemoveDecreaseLootChanceMultiplier { get; private set; }

		internal ConfigEntry<bool> RemoveDisableMoneyDrops { get; private set; }

		internal ConfigEntry<bool> RemoveDisableOrganDrops { get; private set; }

		internal ConfigEntry<bool> RemoveNegativeBulletSpeed { get; private set; }

		internal ConfigEntry<bool> RemoveNegativeDamage { get; private set; }

		internal ConfigEntry<bool> RemoveNegativeBulletSize { get; private set; }

		internal ConfigEntry<bool> RemoveNegativeRpm { get; private set; }

		internal ConfigEntry<bool> RemoveExtraDurabilityCost { get; private set; }

		internal TraitConfiguration(ConfigFile config)
		{
			RemoveDisableAiming = config.Bind<bool>("Traits", "RemoveDisableAiming", true, "Remove oil modifiers that disable aiming down sights.");
			RemoveMoreBulletDrop = config.Bind<bool>("Traits", "RemoveMoreBulletDrop", false, "Remove increased projectile gravity and its same-oil speed/mass companion penalties.");
			RemoveMoreDrag = config.Bind<bool>("Traits", "RemoveMoreDrag", false, "Remove oil modifiers that increase projectile drag.");
			RemoveExtraAmmoConsumeChance = config.Bind<bool>("Traits", "RemoveExtraAmmoConsumeChance", true, "Remove oil modifiers that add a chance to consume extra ammunition.");
			RemoveDecreaseAccuracyWhenMoving = config.Bind<bool>("Traits", "RemoveDecreaseAccuracyWhenMoving", true, "Remove oil modifiers that reduce accuracy while moving.");
			RemoveDecreaseMoveSpeed = config.Bind<bool>("Traits", "RemoveDecreaseMoveSpeed", true, "Remove oil modifiers that reduce movement speed while holding the weapon.");
			RemoveDecreaseJumpPower = config.Bind<bool>("Traits", "RemoveDecreaseJumpPower", true, "Remove oil modifiers that reduce jump power while holding the weapon.");
			RemoveDecreaseLootChanceMultiplier = config.Bind<bool>("Traits", "RemoveDecreaseLootChanceMultiplier", true, "Remove oil modifiers that reduce the loot chance multiplier.");
			RemoveDisableMoneyDrops = config.Bind<bool>("Traits", "RemoveDisableMoneyDrops", true, "Remove oil modifiers that disable Sulf/money drops.");
			RemoveDisableOrganDrops = config.Bind<bool>("Traits", "RemoveDisableOrganDrops", true, "Remove oil modifiers that disable organ drops.");
			RemoveNegativeBulletSpeed = config.Bind<bool>("Traits", "RemoveNegativeBulletSpeed", false, "Remove ProjectileTimeScale modifiers only when they reduce bullet speed. Positive bullet-speed modifiers remain active.");
			RemoveNegativeDamage = config.Bind<bool>("Traits", "RemoveNegativeDamage", false, "Remove flat or percentage damage modifiers only when their signed value is negative. Positive damage modifiers remain active.");
			RemoveNegativeBulletSize = config.Bind<bool>("Traits", "RemoveNegativeBulletSize", false, "Remove ProjectileScale modifiers only when they reduce bullet size. Positive bullet-size modifiers remain active.");
			RemoveNegativeRpm = config.Bind<bool>("Traits", "RemoveNegativeRpm", false, "Remove RPM modifiers only when their signed value is negative. Positive fire-rate modifiers remain active.");
			RemoveExtraDurabilityCost = config.Bind<bool>("General", "RemoveExtraDurabilityCost", false, "Remove oil-specific extra durability consumption. This setting is independent from the other undesirable traits.");
		}

		internal bool ShouldRemove(NegativeOilTrait traits)
		{
			return IsEnabled(traits, NegativeOilTrait.DisableAiming, RemoveDisableAiming) || IsEnabled(traits, NegativeOilTrait.MoreBulletDrop, RemoveMoreBulletDrop) || IsEnabled(traits, NegativeOilTrait.MoreDrag, RemoveMoreDrag) || IsEnabled(traits, NegativeOilTrait.ExtraAmmoConsumeChance, RemoveExtraAmmoConsumeChance) || IsEnabled(traits, NegativeOilTrait.DecreaseAccuracyWhenMoving, RemoveDecreaseAccuracyWhenMoving) || IsEnabled(traits, NegativeOilTrait.DecreaseMoveSpeed, RemoveDecreaseMoveSpeed) || IsEnabled(traits, NegativeOilTrait.DecreaseJumpPower, RemoveDecreaseJumpPower) || IsEnabled(traits, NegativeOilTrait.DecreaseLootChanceMultiplier, RemoveDecreaseLootChanceMultiplier) || IsEnabled(traits, NegativeOilTrait.DisableMoneyDrops, RemoveDisableMoneyDrops) || IsEnabled(traits, NegativeOilTrait.DisableOrganDrops, RemoveDisableOrganDrops) || IsEnabled(traits, NegativeOilTrait.NegativeBulletSpeed, RemoveNegativeBulletSpeed) || IsEnabled(traits, NegativeOilTrait.NegativeDamage, RemoveNegativeDamage) || IsEnabled(traits, NegativeOilTrait.NegativeBulletSize, RemoveNegativeBulletSize) || IsEnabled(traits, NegativeOilTrait.NegativeRpm, RemoveNegativeRpm) || IsEnabled(traits, NegativeOilTrait.ExtraDurabilityCost, RemoveExtraDurabilityCost);
		}

		private static bool IsEnabled(NegativeOilTrait traits, NegativeOilTrait flag, ConfigEntry<bool> setting)
		{
			return (traits & flag) != NegativeOilTrait.None && setting.Value;
		}
	}
}
namespace PerfectOils.Patches
{
	[HarmonyPatch(typeof(AsyncAssetLoading), "set_loadingDone")]
	internal static class AssetLoadingPatches
	{
		[HarmonyPostfix]
		private static void AfterLoadingDoneSet(AsyncAssetLoading __instance, bool value)
		{
			Plugin instance = Plugin.Instance;
			if (value && !((Object)(object)instance == (Object)null))
			{
				instance.NotifyAssetsReady(__instance);
			}
		}
	}
	[HarmonyPatch]
	internal static class ItemDescriptionPatches
	{
		private static MethodBase TargetMethod()
		{
			return AccessTools.Method(typeof(ItemDescription), "Setup", new Type[1] { typeof(InventoryItem) }, (Type[])null);
		}

		[HarmonyPostfix]
		private static void AfterSetup(ItemDescription __instance, InventoryItem __0)
		{
			Plugin instance = Plugin.Instance;
			if (!((Object)(object)instance == (Object)null) && instance.Enabled.Value && instance.ShowRemovedTraitsWithStrikethrough.Value && instance.TooltipRenderer != null)
			{
				instance.TooltipRenderer.Apply(__instance, __0, instance.DetailedLogging.Value);
			}
		}
	}
	[HarmonyPatch]
	internal static class ItemStatsPatches
	{
		private static MethodBase TargetMethod()
		{
			return AccessTools.Method(typeof(ItemStats), "AddModifier", new Type[2]
			{
				typeof(ItemAttributes),
				typeof(StatModifier)
			}, (Type[])null);
		}

		[HarmonyPrefix]
		private static bool BeforeAddModifier(ItemAttributes __0, StatModifier __1)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			Plugin instance = Plugin.Instance;
			if ((Object)(object)instance == (Object)null || !instance.Enabled.Value || instance.OilTraits == null)
			{
				return true;
			}
			return !instance.OilTraits.ShouldSuppress(__0, __1);
		}
	}
	[HarmonyPatch(typeof(Weapon), "SyncEnchantments")]
	internal static class WeaponPatches
	{
		[HarmonyPrefix]
		private static void ResetCachedAimingState(ref bool ___aimingDisabled)
		{
			___aimingDisabled = false;
		}
	}
}