using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GoldScrapConfig.Patches;
using GoldScrapConfig.Store;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("GoldScrapConfig")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.1.0.0")]
[assembly: AssemblyInformationalVersion("0.1.0")]
[assembly: AssemblyProduct("GoldScrapConfig")]
[assembly: AssemblyTitle("GoldScrapConfig")]
[assembly: AssemblyVersion("0.1.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace GoldScrapConfig
{
	[BepInPlugin("mine9289.GoldScrapConfig", "GoldScrapConfig", "0.1.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		internal static ManualLogSource Log;

		internal static ConfigEntry<float> OreBonusCapMultiplier;

		internal static ConfigEntry<float> CrownPercentMultiplier;

		private Harmony harmony;

		private void Awake()
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			OreBonusCapMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Ore", "Ore Bonus multiplier", 1f, "Ore bonus cap ×. 1 = vanilla.");
			CrownPercentMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Crown", "Crown multiplier", 1f, "Crown value % ×. 1 = vanilla.");
			StorePricePatch.RegisterPerItemPrices(((BaseUnityPlugin)this).Config);
			harmony = new Harmony("mine9289.GoldScrapConfig");
			harmony.PatchAll(typeof(Plugin).Assembly);
			Log.LogInfo((object)("GoldScrapConfig 0.1.0 ore×" + OreBonusCapMultiplier.Value + " crown×" + CrownPercentMultiplier.Value + " " + ((BaseUnityPlugin)this).Config.ConfigFilePath));
		}
	}
	internal static class PluginInfo
	{
		public const string PLUGIN_GUID = "mine9289.GoldScrapConfig";

		public const string PLUGIN_NAME = "GoldScrapConfig";

		public const string PLUGIN_VERSION = "0.1.0";
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "GoldScrapConfig";

		public const string PLUGIN_NAME = "GoldScrapConfig";

		public const string PLUGIN_VERSION = "0.1.0";
	}
}
namespace GoldScrapConfig.Store
{
	internal static class GoldStoreDefaults
	{
		internal const string NoPriceOverrideFolder = "GoldenTicket";

		internal static readonly Dictionary<string, int> StoreDefaultPriceByFolder = new Dictionary<string, int>(StringComparer.Ordinal)
		{
			["BronzeSuit"] = 2500,
			["CatOGold"] = 777,
			["CreditsCard"] = -1,
			["GoldCrown"] = 5000,
			["GoldfatherClock"] = 612,
			["GoldMedal"] = 3333,
			["GoldNugget"] = 100,
			["GoldOre"] = 500,
			["GoldSuit"] = 10000,
			["GoldenGlove"] = 800,
			["GoldenHourglass"] = 133,
			["GoldenPickaxe"] = 75,
			["GoldenThrone"] = 25000,
			["GoldToilet"] = 450,
			["GoldTrophy"] = 2000,
			["GroovyGold"] = 150,
			["SafeBox"] = 1000,
			["SilverSuit"] = 5000
		};

		internal static int DefaultPriceOrMinusOne(string folderName)
		{
			if (!StoreDefaultPriceByFolder.TryGetValue(folderName, out var value))
			{
				return -1;
			}
			return value;
		}
	}
	internal static class GoldStoreItemIds
	{
		internal static readonly string[] All = new string[19]
		{
			"BronzeSuit", "CatOGold", "CreditsCard", "GoldCrown", "GoldfatherClock", "GoldMedal", "GoldNugget", "GoldOre", "GoldSuit", "GoldenGlove",
			"GoldenHourglass", "GoldenPickaxe", "GoldenThrone", "GoldenTicket", "GoldToilet", "GoldTrophy", "GroovyGold", "SafeBox", "SilverSuit"
		};
	}
	internal static class StorePriceApply
	{
		internal static void ApplyCreditsToItem(object itemData, int credits)
		{
			if (credits < 0 || itemData == null)
			{
				return;
			}
			Traverse obj = Traverse.Create(itemData);
			obj.Field("localStorePrice").SetValue((object)credits);
			object value = obj.Field("itemProperties").GetValue();
			if (value != null && !IsUnityNull(value))
			{
				Traverse.Create(value).Field("creditsWorth").SetValue((object)credits);
			}
			if (!(obj.Field("storeTerminalNodes").GetValue() is Array array))
			{
				return;
			}
			foreach (object item in array)
			{
				if (item != null && !IsUnityNull(item))
				{
					Traverse.Create(item).Field("itemCost").SetValue((object)credits);
				}
			}
		}

		private static bool IsUnityNull(object o)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			return (Object)o == (Object)null;
		}
	}
}
namespace GoldScrapConfig.Patches
{
	[HarmonyPatch]
	internal static class StorePricePatch
	{
		private static readonly Dictionary<string, ConfigEntry<int>> PriceEntries = new Dictionary<string, ConfigEntry<int>>();

		private static MethodBase? TargetMethod()
		{
			return HarmonyTargetHelpers.GoldScrapConfigs_SetCustomGoldStorePrices();
		}

		private static bool Prepare()
		{
			return TargetMethod() != null;
		}

		internal static void RegisterPerItemPrices(ConfigFile cfg)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			PriceEntries.Clear();
			string[] all = GoldStoreItemIds.All;
			foreach (string text in all)
			{
				if (!string.Equals(text, "GoldenTicket", StringComparison.Ordinal))
				{
					int num = GoldStoreDefaults.DefaultPriceOrMinusOne(text);
					PriceEntries[text] = cfg.Bind<int>("Store.Prices", text, num, new ConfigDescription("-1: LCGold default", (AcceptableValueBase)null, Array.Empty<object>()));
				}
			}
		}

		private static void Postfix()
		{
			if (!(StoreFieldCache.AllGoldStoreItemData?.GetValue(null) is Array array))
			{
				return;
			}
			foreach (object item in array)
			{
				if (item != null)
				{
					string value = Traverse.Create(item).Field<string>("folderName").Value;
					if (!string.IsNullOrEmpty(value) && !string.Equals(value, "GoldenTicket", StringComparison.Ordinal) && PriceEntries.TryGetValue(value, out ConfigEntry<int> value2) && value2.Value >= 0)
					{
						StorePriceApply.ApplyCreditsToItem(item, value2.Value);
					}
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class GoldOreFieldsPatch
	{
		private static MethodBase? TargetMethod()
		{
			return HarmonyTargetHelpers.GoldNuggetScript_Start();
		}

		private static bool Prepare()
		{
			return TargetMethod() != null;
		}

		private static void Prefix(object __instance)
		{
			Traverse val = Traverse.Create(__instance);
			if (HarmonyTargetHelpers.IsGoldOreItem(val.Field("itemType").GetValue()))
			{
				float value = Plugin.OreBonusCapMultiplier.Value;
				if (value > 0f && !Mathf.Approximately(value, 1f))
				{
					int value2 = val.Field<int>("oreBonusPerQuotaMaxIncrease").Value;
					val.Field("oreBonusPerQuotaMaxIncrease").SetValue((object)Mathf.Max(1, Mathf.RoundToInt((float)value2 * value)));
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class CrownFieldsPatch
	{
		private static MethodBase? TargetMethod()
		{
			return HarmonyTargetHelpers.CrownScript_Start();
		}

		private static bool Prepare()
		{
			return TargetMethod() != null;
		}

		private static void Prefix(object __instance)
		{
			Traverse val = Traverse.Create(__instance);
			float value = Plugin.CrownPercentMultiplier.Value;
			if (value > 0f && !Mathf.Approximately(value, 1f))
			{
				int value2 = val.Field<int>("itemValuePercentage").Value;
				val.Field("itemValuePercentage").SetValue((object)Mathf.Max(0, Mathf.RoundToInt((float)value2 * value)));
			}
		}
	}
	internal static class HarmonyTargetHelpers
	{
		private static readonly Lazy<MethodBase?> SetCustomGoldStorePrices = new Lazy<MethodBase>(delegate
		{
			Type type3 = AccessTools.TypeByName("GoldScrapConfigs");
			return (!(type3 == null)) ? AccessTools.Method(type3, "SetCustomGoldStorePrices", new Type[1] { typeof(float) }, (Type[])null) : null;
		});

		private static readonly Lazy<MethodBase?> GoldNuggetStart = new Lazy<MethodBase>(delegate
		{
			Type type2 = AccessTools.TypeByName("GoldNuggetScript");
			return (!(type2 == null)) ? AccessTools.Method(type2, "Start", (Type[])null, (Type[])null) : null;
		});

		private static readonly Lazy<MethodBase?> CrownStart = new Lazy<MethodBase>(delegate
		{
			Type type = AccessTools.TypeByName("CrownScript");
			return (!(type == null)) ? AccessTools.Method(type, "Start", (Type[])null, (Type[])null) : null;
		});

		private static readonly Dictionary<Type, object> GoldOreValueByEnumType = new Dictionary<Type, object>();

		internal static MethodBase? GoldScrapConfigs_SetCustomGoldStorePrices()
		{
			return SetCustomGoldStorePrices.Value;
		}

		internal static MethodBase? GoldNuggetScript_Start()
		{
			return GoldNuggetStart.Value;
		}

		internal static MethodBase? CrownScript_Start()
		{
			return CrownStart.Value;
		}

		internal static bool IsGoldOreItem(object? itemType)
		{
			if (itemType == null)
			{
				return false;
			}
			Type type = itemType.GetType();
			lock (GoldOreValueByEnumType)
			{
				if (!GoldOreValueByEnumType.TryGetValue(type, out object value))
				{
					try
					{
						value = Enum.Parse(type, "GoldOre");
					}
					catch (ArgumentException)
					{
						return false;
					}
					GoldOreValueByEnumType[type] = value;
				}
				return value.Equals(itemType);
			}
		}
	}
	internal static class StoreFieldCache
	{
		private static readonly FieldInfo? AllItems = MakeField();

		internal static FieldInfo? AllGoldStoreItemData => AllItems;

		private static FieldInfo? MakeField()
		{
			Type type = AccessTools.TypeByName("StoreAndTerminal");
			if (!(type == null))
			{
				return AccessTools.Field(type, "allGoldStoreItemData");
			}
			return null;
		}
	}
}