using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using HarmonyLib;
using Jotunn.Managers;
using Jotunn.Utils;
using UnityEngine;
using VNEI.Logic;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("MagneticWishbone")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Riintouge")]
[assembly: AssemblyProduct("MagneticWishbone")]
[assembly: AssemblyCopyright("Copyright © 2024")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("4533b312-0061-4916-b569-170707a29c8f")]
[assembly: AssemblyFileVersion("1.1.1.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.1.1.0")]
namespace MagneticWishbone;

public class Common
{
	public const string WishbonePrefabName = "Wishbone";

	public const string WishboneUnlocalizedName = "$item_wishbone";

	public const string NoneCraftingStationName = "NoneCraftingStation";

	public const float DefaultMaxAutoPickupDistance = 2f;

	public const float DefaultMaxInteractDistance = 5f;

	public const float MaxAutoPickupDistance = 50f;

	public static InvalidatableLazy<CraftingStation> NoneCraftingStation = new InvalidatableLazy<CraftingStation>(delegate
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		CraftingStation obj = new GameObject().AddComponent<CraftingStation>();
		((Object)obj).name = "NoneCraftingStation";
		obj.m_name = "NoneCraftingStation";
		obj.m_discoverRange = 0f;
		return obj;
	});

	public static CraftingStation FindCraftingStationByUnlocalizedName(string unlocalizedName)
	{
		if (!Utility.IsNullOrWhiteSpace(unlocalizedName))
		{
			foreach (CraftingStation item in Traverse.Create(typeof(CraftingStation)).Field("m_allStations").GetValue() as List<CraftingStation>)
			{
				if (item.m_name.Equals(unlocalizedName))
				{
					return item;
				}
			}
		}
		return NoneCraftingStation.Value;
	}
}
public abstract class CustomRecipe : Recipe
{
	public virtual bool IsCraftable()
	{
		return IsCraftableAt(GetCustomRequiredStation(1));
	}

	public abstract bool IsCraftableAt(CraftingStation station);

	public virtual bool IsUpgradable(int currentQuality)
	{
		return IsUpgradableAt(currentQuality, GetCustomRequiredStation(currentQuality));
	}

	public abstract bool IsUpgradableAt(int currentQuality, CraftingStation station);

	public virtual bool AppliesTo(ItemDrop itemDrop)
	{
		return AppliesTo(itemDrop.m_itemData);
	}

	public virtual bool AppliesTo(ItemData itemData)
	{
		return AppliesTo(itemData.m_shared.m_name);
	}

	public virtual bool AppliesTo(string unlocalizedItemNameOrPrefabName)
	{
		if (!base.m_item.m_itemData.m_shared.m_name.Equals(unlocalizedItemNameOrPrefabName))
		{
			return ((Object)base.m_item).name.Equals(unlocalizedItemNameOrPrefabName);
		}
		return true;
	}

	public virtual bool RegisterWithVNEI()
	{
		if (Chainloader.PluginInfos.ContainsKey("com.maxsch.valheim.vnei"))
		{
			RegisterWithVNEICore();
			return true;
		}
		return false;
	}

	protected virtual void RegisterWithVNEICore()
	{
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Expected O, but got Unknown
		for (int i = 1; i <= base.m_item.m_itemData.m_shared.m_maxQuality; i++)
		{
			if ((i == 1) ? IsCraftable() : IsUpgradable(i - 1))
			{
				Indexing.AddRecipeToItems((RecipeInfo)RegisterWithVNEICore(i));
			}
		}
	}

	protected virtual object RegisterWithVNEICore(int quality)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Expected O, but got Unknown
		RecipeInfo val = new RecipeInfo((Recipe)(object)this, quality);
		val.AddStation(GetCustomRequiredStation(quality).m_name, GetCustomRequiredStationLevel(quality));
		return (object)val;
	}

	public virtual int GetCustomAmount(int quality, out int need, out ItemData singleReqItem)
	{
		return ((Recipe)this).GetAmount(quality, ref need, ref singleReqItem, 1);
	}

	public virtual CraftingStation GetCustomRequiredStation(int quality)
	{
		return ((Recipe)this).GetRequiredStation(quality);
	}

	public virtual int GetCustomRequiredStationLevel(int quality)
	{
		return ((Recipe)this).GetRequiredStationLevel(quality);
	}

	public static Tuple<string, int> ParseItemCountPair(string rawPair)
	{
		if (rawPair == null)
		{
			throw new ArgumentNullException("rawPair");
		}
		int result = 0;
		string[] array = rawPair.Split(new char[1] { ',' });
		if (array.Length < 2)
		{
			throw new ArgumentException("Item count does not name an item!");
		}
		if (array.Length > 2)
		{
			throw new ArgumentException("Item count lists more than an item and a count!");
		}
		if (Utility.IsNullOrWhiteSpace(array[0]))
		{
			throw new ArgumentException("Item name is null or whitespace!");
		}
		if (Utility.IsNullOrWhiteSpace(array[1]))
		{
			throw new ArgumentException("Count is null or whitespace!");
		}
		if (!int.TryParse(array[1], out result))
		{
			throw new NullReferenceException("Cannot parse \"" + array[1] + "\" as an integer!");
		}
		return new Tuple<string, int>(array[0], result);
	}

	public static Dictionary<string, int> ParseRequirementString(string requirementsString)
	{
		if (requirementsString == null)
		{
			return null;
		}
		Dictionary<string, int> dictionary = new Dictionary<string, int>();
		if (Utility.IsNullOrWhiteSpace(requirementsString))
		{
			return dictionary;
		}
		try
		{
			string[] array = requirementsString.Split(new char[1] { ';' });
			for (int i = 0; i < array.Length; i++)
			{
				Tuple<string, int> tuple = ParseItemCountPair(array[i]);
				if (tuple.Item2 > 0)
				{
					if (dictionary.ContainsKey(tuple.Item1))
					{
						dictionary[tuple.Item1] += tuple.Item2;
					}
					else
					{
						dictionary.Add(tuple.Item1, tuple.Item2);
					}
				}
			}
			return dictionary;
		}
		catch (Exception value)
		{
			Console.WriteLine(value);
			return null;
		}
	}

	public static List<T> CreateRequirements<T>(string requirementsString) where T : CustomRequirement, new()
	{
		Dictionary<string, int> dictionary = ParseRequirementString(requirementsString);
		if (dictionary == null)
		{
			return null;
		}
		List<T> list = new List<T>();
		foreach (string key in dictionary.Keys)
		{
			list.Add(new T
			{
				m_resItem = ObjectDB.instance.GetItemPrefab(key).GetComponent<ItemDrop>(),
				m_amount = dictionary[key],
				m_extraAmountOnlyOneIngredient = 0,
				m_amountPerLevel = 0,
				m_recover = true
			});
		}
		return list;
	}
}
public class CustomRequirement : Requirement
{
	public int m_applicableLevel;

	public virtual int GetCustomAmount(int qualityLevel)
	{
		if (m_applicableLevel == 0)
		{
			return ((Requirement)this).GetAmount(qualityLevel);
		}
		if (m_applicableLevel != qualityLevel)
		{
			return 0;
		}
		return base.m_amount;
	}
}
[BepInPlugin("com.riintouge.magneticwishbone", "Magnetic Wishbone", "1.1.1")]
[BepInProcess("valheim.exe")]
public class MagneticWishbone : BaseUnityPlugin
{
	[HarmonyPatch(typeof(Humanoid))]
	private class HumanoidPatch
	{
		internal static float MaxMagneticRange(Player player)
		{
			float num = 2f;
			if (!IsEnabled.Value)
			{
				return num;
			}
			foreach (ItemData equippedItem in ((Humanoid)player).GetInventory().GetEquippedItems())
			{
				if (equippedItem.m_shared.m_name.Equals("$item_wishbone"))
				{
					int num2 = Mathf.Min(equippedItem.m_quality, MaxAllowedQuality());
					if (num2 >= 2)
					{
						num = Mathf.Max(num, Tier2PickupRadius.Value);
					}
					if (num2 >= 3)
					{
						num = Mathf.Max(num, Tier3PickupRadius.Value);
					}
					if (num2 >= 4)
					{
						num = Mathf.Max(num, Tier4PickupRadius.Value);
					}
				}
			}
			return num;
		}

		[HarmonyPatch("EquipItem")]
		[HarmonyPostfix]
		private static void EquipItemPostfix(ref bool __result, ref Humanoid __instance, ref ItemData item, ref bool triggerEquipEffects)
		{
			if (__result && item != null && item.m_equipped && item.m_shared.m_name.Equals("$item_wishbone"))
			{
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer != (Object)null && (Object)(object)localPlayer == (Object)(object)__instance)
				{
					localPlayer.m_autoPickupRange = MaxMagneticRange(localPlayer);
				}
			}
		}

		[HarmonyPatch("UnequipItem")]
		[HarmonyPostfix]
		private static void UnequipItemPostfix(ref Humanoid __instance, ref ItemData item, ref bool triggerEquipEffects)
		{
			if (item != null && !item.m_equipped && item.m_shared.m_name.Equals("$item_wishbone"))
			{
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer != (Object)null && (Object)(object)localPlayer == (Object)(object)__instance)
				{
					localPlayer.m_autoPickupRange = MaxMagneticRange(localPlayer);
				}
			}
		}
	}

	[HarmonyPatch(typeof(InventoryGui))]
	private class InventoryGuiPatch
	{
		[HarmonyPatch("AddRecipeToList")]
		[HarmonyPrefix]
		private static bool AddRecipeToListPrefix(ref InventoryGui __instance, ref Player player, ref Recipe recipe, ref ItemData item, ref bool canCraft)
		{
			if (IsEnabled.Value && !canCraft && recipe is CustomRecipe)
			{
				CustomRecipe customRecipe = (CustomRecipe)(object)recipe;
				CraftingStation currentCraftingStation = player.GetCurrentCraftingStation();
				if ((__instance.InCraftTab() && !customRecipe.IsCraftableAt(currentCraftingStation)) || (!__instance.InCraftTab() && !customRecipe.IsUpgradableAt(item.m_quality, currentCraftingStation)))
				{
					return false;
				}
			}
			return true;
		}

		[HarmonyPatch("UpdateRecipeList")]
		[HarmonyPrefix]
		private static void UpdateRecipeListPrefix(ref InventoryGui __instance, ref List<Recipe> recipes)
		{
			Player localPlayer = Player.m_localPlayer;
			if (!IsEnabled.Value || (Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			MagneticWishboneRecipe[] source = new MagneticWishboneRecipe[1] { MagneticWishboneRecipe.Instance.Value };
			List<ItemData> list = (from x in ((Humanoid)localPlayer).GetInventory().GetAllItems()
				where x != null
				select x).ToList();
			CraftingStation currentCraftingStation = localPlayer.GetCurrentCraftingStation();
			foreach (CustomRecipe item in source.Where((CustomRecipe x) => ((Recipe)x).m_enabled))
			{
				if (__instance.InCraftTab())
				{
					if (item.IsCraftableAt(currentCraftingStation))
					{
						recipes.Add((Recipe)(object)item);
					}
					continue;
				}
				foreach (ItemData item2 in list)
				{
					if (item.AppliesTo(item2) && item.IsUpgradableAt(item2.m_quality, currentCraftingStation))
					{
						recipes.Add((Recipe)(object)item);
						break;
					}
				}
			}
		}
	}

	internal class MagneticWishboneRecipe : CustomRecipe
	{
		public static InvalidatableLazy<MagneticWishboneRecipe> Instance = new InvalidatableLazy<MagneticWishboneRecipe>(() => (MagneticWishboneRecipe)(object)ScriptableObject.CreateInstance(typeof(MagneticWishboneRecipe)));

		protected MagneticWishboneRecipe()
		{
			((Recipe)this).m_item = ObjectDB.instance.GetItemPrefab("Wishbone").GetComponent<ItemDrop>();
			((Recipe)this).m_amount = 1;
			((Recipe)this).m_enabled = true;
			((Recipe)this).m_qualityResultAmountMultiplier = 1f;
			((Recipe)this).m_craftingStation = Common.NoneCraftingStation.Value;
			((Recipe)this).m_repairStation = Common.NoneCraftingStation.Value;
			((Recipe)this).m_minStationLevel = 1;
			((Recipe)this).m_requireOnlyOneIngredient = false;
			try
			{
				List<Requirement> list = new List<Requirement>();
				if (AllowTier4.Value || AllowTier3.Value || AllowTier2.Value)
				{
					List<CustomRequirement> list2 = CustomRecipe.CreateRequirements<CustomRequirement>(Tier2Ingredients.Value);
					list2.ForEach(delegate(CustomRequirement x)
					{
						x.m_applicableLevel = 2;
					});
					list.AddRange((IEnumerable<Requirement>)list2);
				}
				if (AllowTier4.Value || AllowTier3.Value)
				{
					List<CustomRequirement> list3 = CustomRecipe.CreateRequirements<CustomRequirement>(Tier3Ingredients.Value);
					list3.ForEach(delegate(CustomRequirement x)
					{
						x.m_applicableLevel = 3;
					});
					list.AddRange((IEnumerable<Requirement>)list3);
				}
				if (AllowTier4.Value)
				{
					List<CustomRequirement> list4 = CustomRecipe.CreateRequirements<CustomRequirement>(Tier4Ingredients.Value);
					list4.ForEach(delegate(CustomRequirement x)
					{
						x.m_applicableLevel = 4;
					});
					list.AddRange((IEnumerable<Requirement>)list4);
				}
				((Recipe)this).m_resources = list.ToArray();
			}
			catch (Exception value)
			{
				((Recipe)this).m_enabled = false;
				Console.WriteLine(value);
			}
			RegisterWithVNEI();
		}

		public override bool IsCraftable()
		{
			return false;
		}

		public override bool IsCraftableAt(CraftingStation station)
		{
			return false;
		}

		public override bool IsUpgradable(int currentQuality)
		{
			return currentQuality < MaxAllowedQuality();
		}

		public override bool IsUpgradableAt(int currentQuality, CraftingStation station)
		{
			CraftingStation customRequiredStation = GetCustomRequiredStation(currentQuality + 1);
			if ((station == null || station.m_name == null) && (customRequiredStation == null || customRequiredStation.m_name == null))
			{
				return true;
			}
			if (station == null || station.m_name == null || customRequiredStation == null || customRequiredStation.m_name == null)
			{
				return false;
			}
			if (!customRequiredStation.m_name.Equals(station.m_name))
			{
				return false;
			}
			if (GetCustomRequiredStationLevel(currentQuality + 1) > station.GetLevel(true))
			{
				return false;
			}
			return true;
		}

		public override CraftingStation GetCustomRequiredStation(int quality)
		{
			switch (quality)
			{
			case 2:
				if (!AllowTier2.Value)
				{
					return Common.NoneCraftingStation.Value;
				}
				return Common.FindCraftingStationByUnlocalizedName(Tier2CraftingStation.Value.Split(new char[1] { ',' })[0]);
			case 3:
				if (!AllowTier3.Value)
				{
					return Common.NoneCraftingStation.Value;
				}
				return Common.FindCraftingStationByUnlocalizedName(Tier3CraftingStation.Value.Split(new char[1] { ',' })[0]);
			case 4:
				if (!AllowTier4.Value)
				{
					return Common.NoneCraftingStation.Value;
				}
				return Common.FindCraftingStationByUnlocalizedName(Tier4CraftingStation.Value.Split(new char[1] { ',' })[0]);
			default:
				return Common.NoneCraftingStation.Value;
			}
		}

		public override int GetCustomRequiredStationLevel(int quality)
		{
			try
			{
				switch (quality)
				{
				case 2:
					return AllowTier2.Value ? int.Parse(Tier2CraftingStation.Value.Split(new char[1] { ',' })[1]) : 999;
				case 3:
					return AllowTier3.Value ? int.Parse(Tier3CraftingStation.Value.Split(new char[1] { ',' })[1]) : 999;
				case 4:
					return AllowTier4.Value ? int.Parse(Tier4CraftingStation.Value.Split(new char[1] { ',' })[1]) : 999;
				}
			}
			catch (Exception)
			{
			}
			return 999;
		}
	}

	[HarmonyPatch(typeof(ObjectDB))]
	private class ObjectDBPatch
	{
		public static void UpdateWishboneMaxQuality()
		{
			ObjectDB instance = ObjectDB.instance;
			object obj;
			if (instance == null)
			{
				obj = null;
			}
			else
			{
				GameObject itemPrefab = instance.GetItemPrefab("Wishbone");
				obj = ((itemPrefab == null) ? null : itemPrefab.GetComponent<ItemDrop>()?.m_itemData?.m_shared);
			}
			SharedData val = (SharedData)obj;
			if (val != null)
			{
				val.m_maxQuality = MaxAllowedQuality();
			}
		}

		[HarmonyPatch("Awake")]
		[HarmonyPrefix]
		private static void AwakePrefix()
		{
			MagneticWishboneRecipe.Instance.Value = null;
		}

		[HarmonyPatch("UpdateRegisters")]
		[HarmonyPostfix]
		private static void UpdateRegistersPostfix()
		{
			UpdateWishboneMaxQuality();
		}
	}

	[HarmonyPatch(typeof(Requirement))]
	private class PieceRequirementPatch
	{
		[HarmonyPatch("GetAmount")]
		[HarmonyPrefix]
		private static bool GetAmountPrefix(ref int __result, ref Requirement __instance, ref int qualityLevel)
		{
			if (__instance is CustomRequirement)
			{
				__result = ((CustomRequirement)(object)__instance).GetCustomAmount(qualityLevel);
				return false;
			}
			return true;
		}
	}

	[HarmonyPatch(typeof(Recipe))]
	private class RecipePatch
	{
		[HarmonyPatch("GetRequiredStation")]
		[HarmonyPrefix]
		private static bool GetRequiredStationPrefix(ref CraftingStation __result, ref Recipe __instance, ref int quality)
		{
			if (__instance is CustomRecipe)
			{
				__result = ((CustomRecipe)(object)__instance).GetCustomRequiredStation(quality);
				return false;
			}
			return true;
		}

		[HarmonyPatch("GetRequiredStationLevel")]
		[HarmonyPrefix]
		private static bool GetRequiredStationLevelPrefix(ref int __result, ref Recipe __instance, ref int quality)
		{
			if (__instance is CustomRecipe)
			{
				__result = ((CustomRecipe)(object)__instance).GetCustomRequiredStationLevel(quality);
				return false;
			}
			return true;
		}
	}

	public static ConfigEntry<bool> IsEnabled;

	public static ConfigEntry<bool> AllowTier2;

	public static ConfigEntry<string> Tier2CraftingStation;

	public static ConfigEntry<string> Tier2Ingredients;

	public static ConfigEntry<float> Tier2PickupRadius;

	public static ConfigEntry<bool> AllowTier3;

	public static ConfigEntry<string> Tier3CraftingStation;

	public static ConfigEntry<string> Tier3Ingredients;

	public static ConfigEntry<float> Tier3PickupRadius;

	public static ConfigEntry<bool> AllowTier4;

	public static ConfigEntry<string> Tier4CraftingStation;

	public static ConfigEntry<string> Tier4Ingredients;

	public static ConfigEntry<float> Tier4PickupRadius;

	private readonly Harmony Harmony = new Harmony("com.riintouge.magneticwishbone");

	private readonly ConfigurationManagerAttributes AdminOnlyAttribute = new ConfigurationManagerAttributes
	{
		IsAdminOnly = true
	};

	private void Awake()
	{
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Expected O, but got Unknown
		//IL_005b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0065: Expected O, but got Unknown
		//IL_0094: Unknown result type (might be due to invalid IL or missing references)
		//IL_009e: Expected O, but got Unknown
		//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d7: Expected O, but got Unknown
		//IL_0114: Unknown result type (might be due to invalid IL or missing references)
		//IL_011e: Expected O, but got Unknown
		//IL_0149: Unknown result type (might be due to invalid IL or missing references)
		//IL_0153: Expected O, but got Unknown
		//IL_0182: Unknown result type (might be due to invalid IL or missing references)
		//IL_018c: Expected O, but got Unknown
		//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c5: Expected O, but got Unknown
		//IL_0202: Unknown result type (might be due to invalid IL or missing references)
		//IL_020c: Expected O, but got Unknown
		//IL_0237: Unknown result type (might be due to invalid IL or missing references)
		//IL_0241: Expected O, but got Unknown
		//IL_0270: Unknown result type (might be due to invalid IL or missing references)
		//IL_027a: Expected O, but got Unknown
		//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_02b3: Expected O, but got Unknown
		//IL_02f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_02fa: Expected O, but got Unknown
		IsEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("0 - Core", "Enable", true, new ConfigDescription("Whether this plugin has any effect when loaded.", (AcceptableValueBase)null, new object[1] { AdminOnlyAttribute }));
		AllowTier2 = ((BaseUnityPlugin)this).Config.Bind<bool>("2 - Basic", "AllowTier2", true, new ConfigDescription("Whether the Wishbone can be upgraded to quality level 2, and functions as such.", (AcceptableValueBase)null, new object[1] { AdminOnlyAttribute }));
		Tier2CraftingStation = ((BaseUnityPlugin)this).Config.Bind<string>("2 - Basic", "Tier2CraftingStation", "$piece_forge,1", new ConfigDescription("A string of the form \"UnlocalizedName,StationLevel\".", (AcceptableValueBase)null, new object[1] { AdminOnlyAttribute }));
		Tier2Ingredients = ((BaseUnityPlugin)this).Config.Bind<string>("2 - Basic", "Tier2Ingredients", "IronScrap,20;Root,5", new ConfigDescription("A string of the form \"ItemName1,Amount;...;ItemNameN,Amount\".", (AcceptableValueBase)null, new object[1] { AdminOnlyAttribute }));
		Tier2PickupRadius = ((BaseUnityPlugin)this).Config.Bind<float>("2 - Basic", "Tier2PickupRadius", 5f, new ConfigDescription("The auto-pickup range of the player, in meters, when a once-upgraded Wishbone is equipped.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(2f, 50f), new object[1] { AdminOnlyAttribute }));
		AllowTier3 = ((BaseUnityPlugin)this).Config.Bind<bool>("3 - Improved", "AllowTier3", true, new ConfigDescription("Whether the Wishbone can be upgraded to quality level 3, and functions as such.", (AcceptableValueBase)null, new object[1] { AdminOnlyAttribute }));
		Tier3CraftingStation = ((BaseUnityPlugin)this).Config.Bind<string>("3 - Improved", "Tier3CraftingStation", "$piece_artisanstation,1", new ConfigDescription("A string of the form \"UnlocalizedName,StationLevel\".", (AcceptableValueBase)null, new object[1] { AdminOnlyAttribute }));
		Tier3Ingredients = ((BaseUnityPlugin)this).Config.Bind<string>("3 - Improved", "Tier3Ingredients", "MechanicalSpring,1;Thunderstone,1;Resin,5", new ConfigDescription("A string of the form \"ItemName1,Amount;...;ItemNameN,Amount\".", (AcceptableValueBase)null, new object[1] { AdminOnlyAttribute }));
		Tier3PickupRadius = ((BaseUnityPlugin)this).Config.Bind<float>("3 - Improved", "Tier3PickupRadius", 10f, new ConfigDescription("The auto-pickup range of the player, in meters, when a twice-upgraded Wishbone is equipped.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(2f, 50f), new object[1] { AdminOnlyAttribute }));
		AllowTier4 = ((BaseUnityPlugin)this).Config.Bind<bool>("4 - Advanced", "AllowTier4", false, new ConfigDescription("Whether the Wishbone can be upgraded to quality level 4, and functions as such.", (AcceptableValueBase)null, new object[1] { AdminOnlyAttribute }));
		Tier4CraftingStation = ((BaseUnityPlugin)this).Config.Bind<string>("4 - Advanced", "Tier4CraftingStation", "$piece_magetable,4", new ConfigDescription("A string of the form \"UnlocalizedName,StationLevel\".", (AcceptableValueBase)null, new object[1] { AdminOnlyAttribute }));
		Tier4Ingredients = ((BaseUnityPlugin)this).Config.Bind<string>("4 - Advanced", "Tier4Ingredients", "DarkCore,1;Wisp,1;SilverNecklace,1;LinenThread,5", new ConfigDescription("A string of the form \"ItemName1,Amount;...;ItemNameN,Amount\".", (AcceptableValueBase)null, new object[1] { AdminOnlyAttribute }));
		Tier4PickupRadius = ((BaseUnityPlugin)this).Config.Bind<float>("4 - Advanced", "Tier4PickupRadius", 15f, new ConfigDescription("The auto-pickup range of the player, in meters, when a thrice-upgraded Wishbone is equipped.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(2f, 50f), new object[1] { AdminOnlyAttribute }));
		Harmony.PatchAll();
		((BaseUnityPlugin)this).Config.SettingChanged += Config_SettingChanged;
		SynchronizationManager.OnConfigurationSynchronized += SynchronizationManager_OnConfigurationSynchronized;
	}

	private void Config_SettingChanged(object sender, SettingChangedEventArgs e)
	{
		if (e.ChangedSetting == IsEnabled)
		{
			((Recipe)MagneticWishboneRecipe.Instance.Value).m_enabled = IsEnabled.Value;
		}
		else if (e.ChangedSetting == AllowTier2)
		{
			if (!AllowTier2.Value)
			{
				AllowTier3.Value = false;
			}
			ObjectDBPatch.UpdateWishboneMaxQuality();
			MagneticWishboneRecipe.Instance.Value = null;
		}
		else if (e.ChangedSetting == AllowTier3)
		{
			if (AllowTier3.Value)
			{
				AllowTier2.Value = true;
			}
			else
			{
				AllowTier4.Value = false;
			}
			ObjectDBPatch.UpdateWishboneMaxQuality();
			MagneticWishboneRecipe.Instance.Value = null;
		}
		else if (e.ChangedSetting == AllowTier4)
		{
			if (AllowTier4.Value)
			{
				AllowTier3.Value = true;
			}
			ObjectDBPatch.UpdateWishboneMaxQuality();
			MagneticWishboneRecipe.Instance.Value = null;
		}
		else if (e.ChangedSetting == Tier2Ingredients || e.ChangedSetting == Tier3Ingredients || e.ChangedSetting == Tier4Ingredients)
		{
			MagneticWishboneRecipe.Instance.Value = null;
		}
		else if (e.ChangedSetting == Tier2PickupRadius || e.ChangedSetting == Tier3PickupRadius || e.ChangedSetting == Tier4PickupRadius)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null)
			{
				localPlayer.m_autoPickupRange = HumanoidPatch.MaxMagneticRange(localPlayer);
			}
		}
	}

	private void SynchronizationManager_OnConfigurationSynchronized(object sender, ConfigurationSynchronizationEventArgs e)
	{
		ObjectDBPatch.UpdateWishboneMaxQuality();
		MagneticWishboneRecipe.Instance.Value = null;
	}

	public static int MaxAllowedQuality()
	{
		if (!AllowTier4.Value)
		{
			if (!AllowTier3.Value)
			{
				if (!AllowTier2.Value)
				{
					return 1;
				}
				return 2;
			}
			return 3;
		}
		return 4;
	}
}
public class InvalidatableLazy<T>
{
	private Func<T> producer;

	private T value;

	public T Value
	{
		get
		{
			lock (producer)
			{
				if (value == null)
				{
					value = producer();
				}
				return value;
			}
		}
		set
		{
			lock (producer)
			{
				if (value != null)
				{
					throw new ArgumentException("value");
				}
				this.value = default(T);
			}
		}
	}

	public InvalidatableLazy(Func<T> producer)
	{
		if (producer == null)
		{
			throw new ArgumentNullException("producer");
		}
		this.producer = producer;
	}
}