using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
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 HarmonyLib;
using Microsoft.CodeAnalysis;
using Pigeon;
using Sparroh.UI;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.UI;

[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("Sparroh")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("2.1.3.0")]
[assembly: AssemblyInformationalVersion("2.1.3")]
[assembly: AssemblyProduct("BatchScrapping")]
[assembly: AssemblyTitle("BatchScrapping")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.1.3.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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;
		}
	}
}
public static class ConfigManager
{
	private const float DebounceSeconds = 0.25f;

	private static ConfigFile config;

	private static ManualLogSource logger;

	private static FileSystemWatcher configWatcher;

	private static volatile bool reloadPending;

	private static float lastReloadTime;

	public static ConfigEntry<Key> TrashMarkKey { get; private set; }

	public static ConfigEntry<bool> EnableInstantScrapping { get; private set; }

	public static ConfigEntry<bool> EnableFixedTimer { get; private set; }

	public static ConfigEntry<float> FixedTimerDuration { get; private set; }

	public static void Initialize(ConfigFile configFile, ManualLogSource log)
	{
		//IL_0092: Unknown result type (might be due to invalid IL or missing references)
		//IL_0097: Unknown result type (might be due to invalid IL or missing references)
		config = configFile;
		logger = log;
		TrashMarkKey = config.Bind<Key>("Keybinds", "Trash Mark Keybind", (Key)34, "Key to toggle trash mark on upgrades");
		EnableInstantScrapping = config.Bind<bool>("General", "Instant Scrap", false, "Enable instant scrapping without hold timer");
		EnableFixedTimer = config.Bind<bool>("General", "Fixed Scrap Time", false, "Use fixed scrap timer instead of default (ignored when Instant Scrap is on)");
		FixedTimerDuration = config.Bind<float>("General", "Scrap Duration", 1f, "Duration in seconds for fixed scrap timer");
		ScrapHandlingMod.currentTrashKey = TrashMarkKey.Value;
		TrashMarkKey.SettingChanged += OnTrashMarkKeyChanged;
		try
		{
			SetupFileWatcher();
		}
		catch (Exception ex)
		{
			logger.LogError((object)("Error setting up config file watcher: " + ex.Message));
		}
	}

	public static void Tick()
	{
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		if (!reloadPending || Time.unscaledTime - lastReloadTime < 0.25f)
		{
			return;
		}
		reloadPending = false;
		lastReloadTime = Time.unscaledTime;
		try
		{
			config.Reload();
			ScrapHandlingMod.currentTrashKey = TrashMarkKey.Value;
			logger.LogInfo((object)"Config reloaded from disk.");
		}
		catch (Exception ex)
		{
			logger.LogError((object)("Error reloading config: " + ex.Message));
		}
	}

	public static void Dispose()
	{
		if (TrashMarkKey != null)
		{
			TrashMarkKey.SettingChanged -= OnTrashMarkKeyChanged;
		}
		if (configWatcher != null)
		{
			configWatcher.EnableRaisingEvents = false;
			configWatcher.Changed -= OnConfigFileChanged;
			configWatcher.Created -= OnConfigFileChanged;
			configWatcher.Renamed -= OnConfigFileChanged;
			configWatcher.Dispose();
			configWatcher = null;
		}
	}

	private static void SetupFileWatcher()
	{
		configWatcher = new FileSystemWatcher(Paths.ConfigPath, "sparroh.batchscrapping.cfg");
		configWatcher.NotifyFilter = NotifyFilters.FileName | NotifyFilters.Size | NotifyFilters.LastWrite;
		configWatcher.Changed += OnConfigFileChanged;
		configWatcher.Created += OnConfigFileChanged;
		configWatcher.Renamed += OnConfigFileChanged;
		configWatcher.EnableRaisingEvents = true;
	}

	private static void OnConfigFileChanged(object sender, FileSystemEventArgs e)
	{
		reloadPending = true;
	}

	private static void OnTrashMarkKeyChanged(object sender, EventArgs e)
	{
		//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)
		ScrapHandlingMod.currentTrashKey = TrashMarkKey.Value;
	}
}
public static class InstantPatches
{
	private const float InstantDuration = 0.05f;

	private static Harmony _harmony;

	public static bool ShouldModifyDuration
	{
		get
		{
			if (ConfigManager.EnableInstantScrapping == null || !ConfigManager.EnableInstantScrapping.Value)
			{
				if (ConfigManager.EnableFixedTimer != null)
				{
					return ConfigManager.EnableFixedTimer.Value;
				}
				return false;
			}
			return true;
		}
	}

	public static void Initialize()
	{
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_000f: Expected O, but got Unknown
		//IL_005d: Unknown result type (might be due to invalid IL or missing references)
		//IL_006a: Expected O, but got Unknown
		try
		{
			_harmony = new Harmony("sparroh.batchscrapping.instant");
			MethodInfo methodInfo = AccessTools.Method(typeof(GearUpgradeUI), "HasUnlockAction", new Type[1] { typeof(UnlockActionParams).MakeByRefType() }, (Type[])null);
			if (methodInfo != null)
			{
				try
				{
					_harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(typeof(InstantScrapPatches), "HasUnlockActionPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
					SparrohPlugin.Logger.LogInfo((object)"Instant Scrap: patched GearUpgradeUI.HasUnlockAction");
					return;
				}
				catch (Exception ex)
				{
					SparrohPlugin.Logger.LogError((object)("Failed to patch HasUnlockAction: " + ex.Message));
					return;
				}
			}
			SparrohPlugin.Logger.LogError((object)"Instant Scrap: could not find GearUpgradeUI.HasUnlockAction(out UnlockActionParams). Instant scrap disabled.");
		}
		catch (Exception ex2)
		{
			SparrohPlugin.Logger.LogError((object)("Critical error during Instant Scrap initialization: " + ex2.Message));
		}
	}

	public static void Destroy()
	{
		Harmony harmony = _harmony;
		if (harmony != null)
		{
			harmony.UnpatchSelf();
		}
		_harmony = null;
	}

	public static float GetModifiedDuration(float original)
	{
		if (ConfigManager.EnableInstantScrapping != null && ConfigManager.EnableInstantScrapping.Value)
		{
			return 0.05f;
		}
		if (ConfigManager.EnableFixedTimer != null && ConfigManager.EnableFixedTimer.Value)
		{
			return Mathf.Max(0.05f, ConfigManager.FixedTimerDuration.Value);
		}
		return original;
	}
}
public static class InstantScrapPatches
{
	public static void HasUnlockActionPostfix(ref UnlockActionParams data)
	{
		try
		{
			if (data.OnSecondaryComplete != null && InstantPatches.ShouldModifyDuration)
			{
				data.SecondaryDuration = InstantPatches.GetModifiedDuration(data.SecondaryDuration);
			}
		}
		catch (Exception ex)
		{
			SparrohPlugin.Logger.LogError((object)("Error in HasUnlockActionPostfix: " + ex.Message));
		}
	}
}
[BepInPlugin("sparroh.batchscrapping", "BatchScrapping", "2.1.3")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[MycoMod(/*Could not decode attribute arguments.*/)]
public class SparrohPlugin : BaseUnityPlugin
{
	public const string PluginGUID = "sparroh.batchscrapping";

	public const string PluginName = "BatchScrapping";

	public const string PluginVersion = "2.1.3";

	internal static ManualLogSource Logger;

	public static SparrohPlugin Instance;

	private bool _barRegistered;

	private bool _lastUndoCan;

	private int _lastUndoCount = -1;

	private void Awake()
	{
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Expected O, but got Unknown
		//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
		//IL_0101: Expected O, but got Unknown
		//IL_0138: Unknown result type (might be due to invalid IL or missing references)
		//IL_0145: Expected O, but got Unknown
		//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ad: Expected O, but got Unknown
		//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
		//IL_0203: Expected O, but got Unknown
		//IL_038c: Unknown result type (might be due to invalid IL or missing references)
		//IL_039a: Expected O, but got Unknown
		//IL_0239: Unknown result type (might be due to invalid IL or missing references)
		//IL_024e: Unknown result type (might be due to invalid IL or missing references)
		//IL_025b: Expected O, but got Unknown
		//IL_025b: Expected O, but got Unknown
		//IL_028c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0293: Expected O, but got Unknown
		try
		{
			Logger = ((BaseUnityPlugin)this).Logger;
			Instance = this;
			Harmony val = new Harmony("sparroh.batchscrapping");
			try
			{
				ConfigManager.Initialize(((BaseUnityPlugin)this).Config, Logger);
				ScrapHandlingMod.ScrapMarkedAction = delegate
				{
					ScrapHandlingMod.TryScrapMarkedUpgrades((MonoBehaviour)(object)this);
				};
				ScrapHandlingMod.ScrapNonFavoriteAction = delegate
				{
					ScrapHandlingMod.TryScrapNonFavoriteUpgrades((MonoBehaviour)(object)this);
				};
				ScrapHandlingMod.LoadTrashSprite();
			}
			catch (Exception ex)
			{
				Logger.LogError((object)("Failed to setup configuration bindings: " + ex.Message));
			}
			try
			{
				InstantPatches.Initialize();
			}
			catch (Exception ex2)
			{
				Logger.LogError((object)("Failed to initialize Instant Scrap: " + ex2.Message));
			}
			try
			{
				val.PatchAll();
			}
			catch (Exception ex3)
			{
				Logger.LogError((object)("Failed to apply Harmony patches: " + ex3.Message));
			}
			try
			{
				MethodInfo methodInfo = AccessTools.Method(typeof(GearDetailsWindow), "Update", (Type[])null, (Type[])null);
				if (methodInfo != null)
				{
					val.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(ScrapUIPatches), "UpdatePrefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
				MethodInfo methodInfo2 = AccessTools.Method(typeof(GearUpgradeUI), "UpdateFavoriteIcon", (Type[])null, (Type[])null);
				if (methodInfo2 != null)
				{
					val.Patch((MethodBase)methodInfo2, (HarmonyMethod)null, new HarmonyMethod(typeof(ScrapUIPatches), "UpdateFavoriteIconPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
				MethodInfo methodInfo3 = AccessTools.Method(typeof(GearUpgradeUI), "OnAdditionalAction", new Type[2]
				{
					typeof(int),
					typeof(bool).MakeByRefType()
				}, (Type[])null);
				if (methodInfo3 != null)
				{
					val.Patch((MethodBase)methodInfo3, (HarmonyMethod)null, new HarmonyMethod(typeof(ScrapUIPatches), "OnAdditionalActionPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
				MethodInfo methodInfo4 = AccessTools.Method(typeof(GearUpgradeUI), "EnableGridView", new Type[1] { typeof(bool) }, (Type[])null);
				if (methodInfo4 != null)
				{
					val.Patch((MethodBase)methodInfo4, (HarmonyMethod)null, new HarmonyMethod(typeof(ScrapUIPatches), "EnableGridViewPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
				MethodInfo methodInfo5 = AccessTools.Method(typeof(GearUpgradeUI), "Dismantle", (Type[])null, (Type[])null);
				if (methodInfo5 != null)
				{
					val.Patch((MethodBase)methodInfo5, new HarmonyMethod(typeof(ScrapUndoPatches), "DismantlePrefix", (Type[])null), new HarmonyMethod(typeof(ScrapUndoPatches), "DismantlePostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
					Logger.LogInfo((object)"Patched GearUpgradeUI.Dismantle for scrap undo.");
				}
				else
				{
					Logger.LogError((object)"Could not find GearUpgradeUI.Dismantle — single-scrap undo unavailable.");
				}
				HarmonyMethod val2 = new HarmonyMethod(typeof(BatchPickupFeedbackPatches), "ShowPickupInfoPrefix", (Type[])null);
				int num = 0;
				foreach (MethodInfo declaredMethod in AccessTools.GetDeclaredMethods(typeof(GameManager)))
				{
					if (!(declaredMethod == null) && !(declaredMethod.Name != "ShowPickupInfo"))
					{
						try
						{
							val.Patch((MethodBase)declaredMethod, val2, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
							num++;
						}
						catch (Exception ex4)
						{
							Logger.LogWarning((object)$"Failed to patch ShowPickupInfo ({declaredMethod}): {ex4.Message}");
						}
					}
				}
				if (num > 0)
				{
					Logger.LogInfo((object)$"Patched {num} GameManager.ShowPickupInfo overload(s) for batch toast consolidation.");
				}
				else
				{
					Logger.LogWarning((object)"Could not find GameManager.ShowPickupInfo — batch pickup toasts may spam.");
				}
				MethodInfo methodInfo6 = AccessTools.Method(typeof(PlayerResource), "PlayPickupSound", (Type[])null, (Type[])null);
				if (methodInfo6 != null)
				{
					val.Patch((MethodBase)methodInfo6, new HarmonyMethod(typeof(BatchPickupFeedbackPatches), "PlayPickupSoundPrefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
					Logger.LogInfo((object)"Patched PlayerResource.PlayPickupSound for batch scrap.");
				}
			}
			catch (Exception ex5)
			{
				Logger.LogError((object)("Failed to apply scrap patches: " + ex5.Message));
			}
		}
		catch (Exception ex6)
		{
			Logger.LogError((object)("Critical error during mod initialization: " + ex6.Message + "\n" + ex6.StackTrace));
		}
		Logger.LogInfo((object)"BatchScrapping v2.1.3 loaded successfully.");
	}

	private void Update()
	{
		ConfigManager.Tick();
		GearActionBar.Tick();
		if (!GearActionBar.IsGearMenuOpen())
		{
			return;
		}
		if (!_barRegistered)
		{
			GearActionBar.Register("scrap_marked", "Scrap Marked", 120, (Action)delegate
			{
				UIDialog.Confirm("Scrap Marked", "Scrap all trash-marked upgrades? This can be undone.", (Action)delegate
				{
					ScrapHandlingMod.ScrapMarkedAction?.Invoke();
				}, (Action)null, "Confirm", "Cancel");
			}, (UIButtonStyle)0);
			GearActionBar.Register("scrap_nonfav", "Scrap No-Fav", 130, (Action)delegate
			{
				UIDialog.Confirm("Scrap Non-Favorite", "Scrap ALL non-favorite upgrades? This can be undone.", (Action)delegate
				{
					ScrapHandlingMod.ScrapNonFavoriteAction?.Invoke();
				}, (Action)null, "Confirm", "Cancel");
			}, (UIButtonStyle)2);
			GearActionBar.Register("undo_scrap", "Undo Scrap", 140, (Action)delegate
			{
				UndoPatches.TryUndo();
			}, (UIButtonStyle)1);
			_barRegistered = true;
			_lastUndoCan = !UndoPatches.CanUndo;
			_lastUndoCount = -1;
		}
		bool canUndo = UndoPatches.CanUndo;
		int undoCount = UndoPatches.UndoCount;
		if (canUndo != _lastUndoCan || undoCount != _lastUndoCount)
		{
			_lastUndoCan = canUndo;
			_lastUndoCount = undoCount;
			GearActionBar.SetInteractable("undo_scrap", canUndo);
			GearActionBar.SetText("undo_scrap", canUndo ? $"Undo ({undoCount})" : "Undo");
		}
	}

	private void OnDestroy()
	{
		try
		{
			ConfigManager.Dispose();
			InstantPatches.Destroy();
			UndoPatches.Clear();
			GearActionBar.Unregister("scrap_marked");
			GearActionBar.Unregister("scrap_nonfav");
			GearActionBar.Unregister("undo_scrap");
			_barRegistered = false;
		}
		catch (Exception ex)
		{
			Logger.LogError((object)("Failed to destroy BatchScrapping UI: " + ex.Message));
		}
	}
}
public static class ScrapHandlingMod
{
	private const float HOLD_DURATION = 1f;

	private const int BATCH_SIZE = 1000000;

	private const float BATCH_INTERVAL = 0f;

	private const byte FavoriteFlag = 1;

	private const byte TrashMarkFlag = 32;

	private static bool wasScrappingSkins;

	public static Key currentTrashKey;

	public static Action ScrapMarkedAction;

	public static Action ScrapNonFavoriteAction;

	public static Sprite starSprite;

	public static Sprite trashSprite;

	public static bool IsScrapping { get; private set; }

	public static bool SuppressPickupFeedback { get; private set; }

	public static void LoadTrashSprite()
	{
		//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c3: Expected O, but got Unknown
		//IL_0122: Unknown result type (might be due to invalid IL or missing references)
		//IL_0131: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)trashSprite != (Object)null)
		{
			return;
		}
		try
		{
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			string text = null;
			string[] manifestResourceNames = executingAssembly.GetManifestResourceNames();
			foreach (string text2 in manifestResourceNames)
			{
				if (text2.EndsWith("trashcan.png", StringComparison.OrdinalIgnoreCase))
				{
					text = text2;
					break;
				}
			}
			if (text == null)
			{
				SparrohPlugin.Logger.LogWarning((object)"trashcan.png embedded resource not found; trash marks will use red star.");
				return;
			}
			using Stream stream = executingAssembly.GetManifestResourceStream(text);
			if (stream == null)
			{
				SparrohPlugin.Logger.LogWarning((object)"Failed to open trashcan.png resource stream.");
				return;
			}
			byte[] array = new byte[stream.Length];
			int num;
			for (int j = 0; j < array.Length; j += num)
			{
				if ((num = stream.Read(array, j, array.Length - j)) <= 0)
				{
					break;
				}
			}
			Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
			if (!ImageConversion.LoadImage(val, array, false))
			{
				SparrohPlugin.Logger.LogWarning((object)"Failed to decode trashcan.png.");
				Object.Destroy((Object)(object)val);
				return;
			}
			((Texture)val).filterMode = (FilterMode)1;
			((Texture)val).wrapMode = (TextureWrapMode)1;
			((Object)val).name = "BatchScrapping_Trashcan";
			trashSprite = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), 100f);
			((Object)trashSprite).name = "BatchScrapping_Trashcan";
			SparrohPlugin.Logger.LogInfo((object)$"Loaded trashcan sprite ({((Texture)val).width}x{((Texture)val).height}).");
		}
		catch (Exception ex)
		{
			SparrohPlugin.Logger.LogError((object)("Failed to load trashcan sprite: " + ex.Message));
		}
	}

	public static Sprite GetTrashIconSprite()
	{
		Sprite obj;
		if (!((Object)(object)trashSprite != (Object)null))
		{
			obj = starSprite;
			if (obj == null)
			{
				return Resources.Load<Sprite>("favorite star");
			}
		}
		else
		{
			obj = trashSprite;
		}
		return obj;
	}

	public static void ApplyMarkIcon(Image favoriteIcon, UpgradeInstance upgrade)
	{
		//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
		//IL_006f: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)favoriteIcon == (Object)null || upgrade == null)
		{
			return;
		}
		if (IsFavorite(upgrade))
		{
			if ((Object)(object)starSprite == (Object)null && (Object)(object)favoriteIcon.sprite != (Object)null && (Object)(object)favoriteIcon.sprite != (Object)(object)trashSprite)
			{
				starSprite = favoriteIcon.sprite;
			}
			favoriteIcon.sprite = starSprite ?? favoriteIcon.sprite;
			((Component)favoriteIcon).gameObject.SetActive(true);
			((Graphic)favoriteIcon).color = Color.white;
		}
		else if (IsTrashMarked(upgrade))
		{
			if ((Object)(object)starSprite == (Object)null && (Object)(object)favoriteIcon.sprite != (Object)null && (Object)(object)favoriteIcon.sprite != (Object)(object)trashSprite)
			{
				starSprite = favoriteIcon.sprite;
			}
			favoriteIcon.sprite = GetTrashIconSprite();
			((Component)favoriteIcon).gameObject.SetActive(true);
			((Graphic)favoriteIcon).color = Color.red;
		}
		else
		{
			((Component)favoriteIcon).gameObject.SetActive(false);
		}
	}

	private static bool TryScrapInstance(UpgradeInstance inst)
	{
		if (inst == null)
		{
			return false;
		}
		Upgrade upgrade;
		try
		{
			upgrade = inst.Upgrade;
		}
		catch
		{
			return false;
		}
		if ((Object)(object)upgrade == (Object)null)
		{
			return false;
		}
		try
		{
			PlayerData.UnequipFromAll(inst);
		}
		catch
		{
		}
		try
		{
			if (!inst.Destroy())
			{
				return false;
			}
			upgrade.GiveDismantleResources(inst);
			return true;
		}
		catch (Exception ex)
		{
			SparrohPlugin.Logger.LogError((object)("TryScrapInstance failed: " + ex.Message));
			return false;
		}
	}

	private static IEnumerator FinishBatchScrapCoroutine(bool success, bool isSkinsMode)
	{
		try
		{
			if (success)
			{
				UndoPatches.EndBatch();
			}
			else
			{
				UndoPatches.CancelBatch();
			}
		}
		catch (Exception ex)
		{
			SparrohPlugin.Logger.LogError((object)("FinishBatchScrap EndBatch failed: " + ex.Message));
			UndoPatches.CancelBatch();
			success = false;
		}
		SuppressPickupFeedback = false;
		if (success)
		{
			try
			{
				wasScrappingSkins = isSkinsMode;
				RefreshOpenWindows();
			}
			catch (Exception ex2)
			{
				SparrohPlugin.Logger.LogError((object)("FinishBatchScrap refresh failed: " + ex2.Message));
			}
			yield return null;
			try
			{
				BatchPickupFeedbackPatches.FlushAccumulatedPickups();
			}
			catch (Exception ex3)
			{
				SparrohPlugin.Logger.LogWarning((object)("FinishBatchScrap popup flush failed: " + ex3.Message));
			}
		}
		else
		{
			BatchPickupFeedbackPatches.ClearAccumulated();
		}
		IsScrapping = false;
	}

	public static IEnumerator ScrapMarkedUpgrades()
	{
		int num = 0;
		bool flag;
		List<UpgradeInstance> list;
		bool flag2;
		try
		{
			if (IsScrapping)
			{
				SparrohPlugin.Logger.LogWarning((object)"ScrapMarkedUpgrades: Already scrapping, aborting.");
				yield break;
			}
			IsScrapping = true;
			SuppressPickupFeedback = true;
			BatchPickupFeedbackPatches.ClearAccumulated();
			SparrohPlugin.Logger.LogInfo((object)"Starting ScrapMarkedUpgrades operation.");
			GearDetailsWindow val = Object.FindObjectOfType<GearDetailsWindow>();
			if ((Object)(object)val == (Object)null)
			{
				SparrohPlugin.Logger.LogError((object)"ScrapMarkedUpgrades: GearDetailsWindow not found.");
				SuppressPickupFeedback = false;
				IsScrapping = false;
				yield break;
			}
			IUpgradable upgradablePrefab = val.UpgradablePrefab;
			if (upgradablePrefab == null)
			{
				SparrohPlugin.Logger.LogError((object)"ScrapMarkedUpgrades: UpgradablePrefab is null.");
				SuppressPickupFeedback = false;
				IsScrapping = false;
				yield break;
			}
			flag = (bool)AccessTools.Field(typeof(GearDetailsWindow), "inSkinMode").GetValue(val);
			IEnumerable<UpgradeInfo> enumerable = (flag ? PlayerData.GetAllSkins(upgradablePrefab, true) : PlayerData.GetAllUpgrades(upgradablePrefab, true));
			int num2 = 0;
			foreach (UpgradeInfo item in enumerable)
			{
				if (item?.Instances != null)
				{
					num2 += item.Instances.Count;
				}
			}
			list = new List<UpgradeInstance>(num2);
			foreach (UpgradeInfo item2 in enumerable)
			{
				if (item2?.Instances == null)
				{
					continue;
				}
				foreach (UpgradeInstance instance in item2.Instances)
				{
					if (instance != null && IsTrashMarked(instance))
					{
						list.Add(instance);
					}
				}
			}
			if (list.Count == 0)
			{
				SparrohPlugin.Logger.LogInfo((object)"ScrapMarkedUpgrades: No marked upgrades found.");
				SuppressPickupFeedback = false;
				IsScrapping = false;
				yield break;
			}
			UndoPatches.BeginBatch($"Scrap Marked ({list.Count})");
			foreach (UpgradeInstance item3 in list)
			{
				UndoPatches.AddToBatch(item3);
			}
			SparrohPlugin.Logger.LogInfo((object)$"ScrapMarkedUpgrades: Processing {list.Count} upgrades.");
			flag2 = true;
		}
		catch (Exception ex)
		{
			SparrohPlugin.Logger.LogError((object)("ScrapMarkedUpgrades: Setup failed: " + ex.Message));
			UndoPatches.CancelBatch();
			SuppressPickupFeedback = false;
			IsScrapping = false;
			yield break;
		}
		if (flag2 && list != null)
		{
			for (int i = 0; i < list.Count; i += 1000000)
			{
				int num3 = Mathf.Min(i + 1000000, list.Count);
				for (int j = i; j < num3; j++)
				{
					if (TryScrapInstance(list[j]))
					{
						num++;
					}
				}
			}
		}
		yield return FinishBatchScrapCoroutine(num > 0, flag);
	}

	public static bool IsFavorite(UpgradeInstance instance)
	{
		if (instance == null)
		{
			return false;
		}
		return ((byte)AccessTools.Field(typeof(UpgradeInstance), "flags").GetValue(instance) & 1) != 0;
	}

	public static bool IsTrashMarked(UpgradeInstance instance)
	{
		if (instance == null)
		{
			return false;
		}
		return ((byte)AccessTools.Field(typeof(UpgradeInstance), "flags").GetValue(instance) & 0x20) != 0;
	}

	public static void SetTrashMark(UpgradeInstance instance, bool marked)
	{
		if (instance != null)
		{
			FieldInfo fieldInfo = AccessTools.Field(typeof(UpgradeInstance), "flags");
			byte b = (byte)fieldInfo.GetValue(instance);
			if (marked)
			{
				b |= 0x20;
				b &= 0xFE;
			}
			else
			{
				b &= 0xDF;
			}
			fieldInfo.SetValue(instance, b);
		}
	}

	public static void SetFavorite(UpgradeInstance instance, bool favorite)
	{
		if (instance != null)
		{
			FieldInfo fieldInfo = AccessTools.Field(typeof(UpgradeInstance), "flags");
			byte b = (byte)fieldInfo.GetValue(instance);
			if (favorite)
			{
				b |= 1;
				b &= 0xDF;
			}
			else
			{
				b &= 0xFE;
			}
			fieldInfo.SetValue(instance, b);
		}
	}

	public static void TryScrapMarkedUpgrades(MonoBehaviour owner)
	{
		GearDetailsWindow val = Object.FindObjectOfType<GearDetailsWindow>();
		if ((Object)(object)val == (Object)null)
		{
			return;
		}
		IUpgradable upgradablePrefab = val.UpgradablePrefab;
		if (upgradablePrefab == null)
		{
			return;
		}
		List<UpgradeInfo> obj = (((bool)AccessTools.Field(typeof(GearDetailsWindow), "inSkinMode").GetValue(val)) ? PlayerData.GetAllSkins(upgradablePrefab, true) : PlayerData.GetAllUpgrades(upgradablePrefab, true));
		bool flag = false;
		foreach (UpgradeInfo item in obj)
		{
			if (item?.Instances != null && item.Instances.Any((UpgradeInstance inst) => inst != null && IsTrashMarked(inst)))
			{
				flag = true;
				break;
			}
		}
		if (flag)
		{
			owner.StartCoroutine(ScrapMarkedUpgrades());
		}
	}

	public static IEnumerator ScrapNonFavoriteUpgrades()
	{
		int num = 0;
		bool flag;
		List<UpgradeInstance> list;
		bool flag2;
		try
		{
			if (IsScrapping)
			{
				SparrohPlugin.Logger.LogWarning((object)"ScrapNonFavoriteUpgrades: Already scrapping, aborting.");
				yield break;
			}
			IsScrapping = true;
			SuppressPickupFeedback = true;
			BatchPickupFeedbackPatches.ClearAccumulated();
			SparrohPlugin.Logger.LogInfo((object)"Starting ScrapNonFavoriteUpgrades operation.");
			GearDetailsWindow val = Object.FindObjectOfType<GearDetailsWindow>();
			if ((Object)(object)val == (Object)null)
			{
				SparrohPlugin.Logger.LogError((object)"ScrapNonFavoriteUpgrades: GearDetailsWindow not found.");
				SuppressPickupFeedback = false;
				IsScrapping = false;
				yield break;
			}
			IUpgradable upgradablePrefab = val.UpgradablePrefab;
			if (upgradablePrefab == null)
			{
				SparrohPlugin.Logger.LogError((object)"ScrapNonFavoriteUpgrades: UpgradablePrefab is null.");
				SuppressPickupFeedback = false;
				IsScrapping = false;
				yield break;
			}
			flag = (bool)AccessTools.Field(typeof(GearDetailsWindow), "inSkinMode").GetValue(val);
			IEnumerable<UpgradeInfo> enumerable = (flag ? PlayerData.GetAllSkins(upgradablePrefab, true) : PlayerData.GetAllUpgrades(upgradablePrefab, true));
			int num2 = 0;
			foreach (UpgradeInfo item in enumerable)
			{
				if (item?.Instances != null)
				{
					num2 += item.Instances.Count;
				}
			}
			list = new List<UpgradeInstance>(num2);
			foreach (UpgradeInfo item2 in enumerable)
			{
				if (item2?.Instances == null)
				{
					continue;
				}
				foreach (UpgradeInstance instance in item2.Instances)
				{
					if (instance != null && !IsFavorite(instance))
					{
						list.Add(instance);
					}
				}
			}
			if (list.Count == 0)
			{
				SparrohPlugin.Logger.LogInfo((object)"ScrapNonFavoriteUpgrades: No non-favorite upgrades found.");
				SuppressPickupFeedback = false;
				IsScrapping = false;
				yield break;
			}
			UndoPatches.BeginBatch($"Scrap Non-Favorite ({list.Count})");
			foreach (UpgradeInstance item3 in list)
			{
				UndoPatches.AddToBatch(item3);
			}
			SparrohPlugin.Logger.LogInfo((object)$"ScrapNonFavoriteUpgrades: Processing {list.Count} upgrades.");
			flag2 = true;
		}
		catch (Exception ex)
		{
			SparrohPlugin.Logger.LogError((object)("ScrapNonFavoriteUpgrades: Setup failed: " + ex.Message));
			UndoPatches.CancelBatch();
			SuppressPickupFeedback = false;
			IsScrapping = false;
			yield break;
		}
		if (flag2 && list != null)
		{
			for (int i = 0; i < list.Count; i += 1000000)
			{
				int num3 = Mathf.Min(i + 1000000, list.Count);
				for (int j = i; j < num3; j++)
				{
					if (TryScrapInstance(list[j]))
					{
						num++;
					}
				}
			}
		}
		yield return FinishBatchScrapCoroutine(num > 0, flag);
	}

	public static void TryScrapNonFavoriteUpgrades(MonoBehaviour owner)
	{
		GearDetailsWindow val = Object.FindObjectOfType<GearDetailsWindow>();
		if ((Object)(object)val == (Object)null)
		{
			return;
		}
		IUpgradable upgradablePrefab = val.UpgradablePrefab;
		if (upgradablePrefab == null)
		{
			return;
		}
		List<UpgradeInfo> obj = (((bool)AccessTools.Field(typeof(GearDetailsWindow), "inSkinMode").GetValue(val)) ? PlayerData.GetAllSkins(upgradablePrefab, true) : PlayerData.GetAllUpgrades(upgradablePrefab, true));
		bool flag = false;
		foreach (UpgradeInfo item in obj)
		{
			if (item?.Instances != null && item.Instances.Any((UpgradeInstance inst) => inst != null && !IsFavorite(inst)))
			{
				flag = true;
				break;
			}
		}
		if (flag)
		{
			owner.StartCoroutine(ScrapNonFavoriteUpgrades());
		}
	}

	private static void RefreshOpenWindows()
	{
		if (!((Object)(object)Menu.Instance != (Object)null) || !Menu.Instance.IsOpen)
		{
			return;
		}
		Window top = Menu.Instance.WindowSystem.GetTop();
		if (!((Object)(object)top != (Object)null))
		{
			return;
		}
		top.OnOpen(Menu.Instance.WindowSystem);
		if (wasScrappingSkins)
		{
			GearDetailsWindow val = (GearDetailsWindow)(object)((top is GearDetailsWindow) ? top : null);
			if ((Object)(object)val != (Object)null)
			{
				AccessTools.Field(typeof(GearDetailsWindow), "inSkinMode").SetValue(val, true);
			}
			wasScrappingSkins = false;
		}
	}
}
public class ScrapUIPatches
{
	private static readonly HashSet<UpgradeInstance> toggledThisSession = new HashSet<UpgradeInstance>();

	private static void AddScrapButton(GearDetailsWindow window)
	{
		//IL_005b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0061: Expected O, but got Unknown
		//IL_0087: Unknown result type (might be due to invalid IL or missing references)
		//IL_009d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00db: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_0101: Unknown result type (might be due to invalid IL or missing references)
		//IL_011f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0124: Unknown result type (might be due to invalid IL or missing references)
		//IL_0128: 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_0140: Unknown result type (might be due to invalid IL or missing references)
		//IL_014a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0156: Unknown result type (might be due to invalid IL or missing references)
		//IL_015b: Unknown result type (might be due to invalid IL or missing references)
		//IL_016d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0175: Unknown result type (might be due to invalid IL or missing references)
		//IL_019b: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01cb: Expected O, but got Unknown
		//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
		//IL_0209: Unknown result type (might be due to invalid IL or missing references)
		//IL_021f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0235: Unknown result type (might be due to invalid IL or missing references)
		//IL_0243: Unknown result type (might be due to invalid IL or missing references)
		//IL_0258: Unknown result type (might be due to invalid IL or missing references)
		//IL_026a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0289: Unknown result type (might be due to invalid IL or missing references)
		//IL_028e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0292: Unknown result type (might be due to invalid IL or missing references)
		//IL_029e: Unknown result type (might be due to invalid IL or missing references)
		//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
		//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
		//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_02e0: Unknown result type (might be due to invalid IL or missing references)
		//IL_0306: Unknown result type (might be due to invalid IL or missing references)
		Transform val = ((Component)window).transform.Find("ModScrapButtonMarked");
		if ((Object)(object)val != (Object)null)
		{
			Object.DestroyImmediate((Object)(object)((Component)val).gameObject);
		}
		Transform val2 = ((Component)window).transform.Find("ModScrapButtonNonFavorite");
		if ((Object)(object)val2 != (Object)null)
		{
			Object.DestroyImmediate((Object)(object)((Component)val2).gameObject);
		}
		RectTransform component = ((Component)((Component)window).transform).GetComponent<RectTransform>();
		GameObject val3 = new GameObject("ModScrapButtonMarked");
		val3.transform.SetParent(((Component)window).transform, false);
		RectTransform val4 = val3.AddComponent<RectTransform>();
		val4.sizeDelta = new Vector2(200f, 50f);
		val4.anchorMin = new Vector2(1f, 0f);
		val4.anchorMax = new Vector2(1f, 0f);
		val4.pivot = new Vector2(1f, 0f);
		Rect rect = component.rect;
		val4.anchoredPosition = new Vector2((0f - ((Rect)(ref rect)).width) * 0.25f, 10f);
		Image obj = val3.AddComponent<Image>();
		((Graphic)obj).color = Color.gray;
		((Graphic)obj).raycastTarget = true;
		Button obj2 = val3.AddComponent<Button>();
		((Selectable)obj2).transition = (Transition)1;
		ColorBlock colors = ((Selectable)obj2).colors;
		((ColorBlock)(ref colors)).normalColor = Color.gray;
		((ColorBlock)(ref colors)).highlightedColor = Color.white;
		((ColorBlock)(ref colors)).pressedColor = Color.blue;
		((Selectable)obj2).colors = colors;
		GameObject val5 = new GameObject("Text");
		val5.transform.SetParent(val3.transform, false);
		val5.AddComponent<RectTransform>().sizeDelta = val4.sizeDelta;
		TextMeshProUGUI obj3 = val5.AddComponent<TextMeshProUGUI>();
		((TMP_Text)obj3).text = "Scrap Marked";
		((TMP_Text)obj3).alignment = (TextAlignmentOptions)514;
		((Graphic)obj3).color = Color.white;
		((TMP_Text)obj3).fontSize = 24f;
		val3.AddComponent<HoldButtonHandler>().onHoldComplete = ScrapHandlingMod.ScrapMarkedAction;
		GameObject val6 = new GameObject("ModScrapButtonNonFavorite");
		val6.transform.SetParent(((Component)window).transform, false);
		RectTransform val7 = val6.AddComponent<RectTransform>();
		val7.sizeDelta = new Vector2(250f, 50f);
		val7.anchorMin = new Vector2(1f, 0f);
		val7.anchorMax = new Vector2(1f, 0f);
		val7.pivot = new Vector2(1f, 0f);
		val7.anchoredPosition = new Vector2(val4.anchoredPosition.x + 210f, 50f);
		Image obj4 = val6.AddComponent<Image>();
		((Graphic)obj4).color = Color.red;
		((Graphic)obj4).raycastTarget = true;
		Button obj5 = val6.AddComponent<Button>();
		((Selectable)obj5).transition = (Transition)1;
		ColorBlock colors2 = ((Selectable)obj5).colors;
		((ColorBlock)(ref colors2)).normalColor = Color.red;
		((ColorBlock)(ref colors2)).highlightedColor = Color.white;
		((ColorBlock)(ref colors2)).pressedColor = Color.blue;
		((Selectable)obj5).colors = colors2;
		GameObject val8 = new GameObject("Text");
		val8.transform.SetParent(val6.transform, false);
		val8.AddComponent<RectTransform>().sizeDelta = val7.sizeDelta;
		TextMeshProUGUI obj6 = val8.AddComponent<TextMeshProUGUI>();
		((TMP_Text)obj6).text = "Scrap All Non-Favorite";
		((TMP_Text)obj6).alignment = (TextAlignmentOptions)514;
		((Graphic)obj6).color = Color.white;
		((TMP_Text)obj6).fontSize = 20f;
		val6.AddComponent<HoldButtonHandler>().onHoldComplete = ScrapHandlingMod.ScrapNonFavoriteAction;
	}

	public static void UpdateFavoriteIconPostfix(GearUpgradeUI __instance)
	{
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_0028: Expected O, but got Unknown
		if (ScrapHandlingMod.IsScrapping)
		{
			return;
		}
		Image val = (Image)AccessTools.Field(typeof(GearUpgradeUI), "favoriteIcon").GetValue(__instance);
		if ((Object)(object)val != (Object)null && ((HoverInfoUpgrade)__instance).Upgrade != null)
		{
			ScrapHandlingMod.ApplyMarkIcon(val, ((HoverInfoUpgrade)__instance).Upgrade);
			if (ScrapHandlingMod.IsTrashMarked(((HoverInfoUpgrade)__instance).Upgrade))
			{
				Canvas.ForceUpdateCanvases();
			}
		}
	}

	public static void OnAdditionalActionPostfix(GearUpgradeUI __instance, int index, ref bool refreshUI)
	{
		if (index == 0 && ((HoverInfoUpgrade)__instance).Upgrade != null)
		{
			ScrapHandlingMod.SetFavorite(((HoverInfoUpgrade)__instance).Upgrade, ((HoverInfoUpgrade)__instance).Upgrade.Favorite);
		}
	}

	public static void EnableGridViewPostfix(GearUpgradeUI __instance, bool grid)
	{
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Expected O, but got Unknown
		if (!ScrapHandlingMod.IsScrapping && ((HoverInfoUpgrade)__instance).Upgrade != null)
		{
			Image val = (Image)AccessTools.Field(typeof(GearUpgradeUI), "favoriteIcon").GetValue(__instance);
			if ((Object)(object)val != (Object)null)
			{
				ScrapHandlingMod.ApplyMarkIcon(val, ((HoverInfoUpgrade)__instance).Upgrade);
			}
		}
	}

	public static void UpdatePrefix(GearDetailsWindow __instance)
	{
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ae: Expected O, but got Unknown
		if (ScrapHandlingMod.IsScrapping || Keyboard.current == null)
		{
			return;
		}
		if (!((ButtonControl)Keyboard.current[ScrapHandlingMod.currentTrashKey]).isPressed)
		{
			if (toggledThisSession.Count > 0)
			{
				toggledThisSession.Clear();
			}
			return;
		}
		GearUpgradeUI val = null;
		if (!UIRaycaster.RaycastForComponent<GearUpgradeUI>(ref val))
		{
			return;
		}
		UpgradeInstance upgrade = ((HoverInfoUpgrade)val).Upgrade;
		if (upgrade != null && !ScrapHandlingMod.IsFavorite(upgrade) && !toggledThisSession.Contains(upgrade))
		{
			bool flag = ScrapHandlingMod.IsTrashMarked(upgrade);
			ScrapHandlingMod.SetTrashMark(upgrade, !flag);
			toggledThisSession.Add(upgrade);
			Image val2 = (Image)(AccessTools.Field(typeof(GearUpgradeUI), "favoriteIcon")?.GetValue(val));
			if ((Object)(object)val2 != (Object)null)
			{
				ScrapHandlingMod.ApplyMarkIcon(val2, upgrade);
				Canvas.ForceUpdateCanvases();
			}
		}
	}
}
public class HoldButtonHandler : MonoBehaviour, IPointerDownHandler, IEventSystemHandler, IPointerUpHandler
{
	private const float HOLD_DURATION = 1f;

	private float holdTimer;

	private bool isHolding;

	public Action onHoldComplete;

	private void Update()
	{
		if (isHolding)
		{
			holdTimer += Time.deltaTime;
			if (holdTimer >= 1f)
			{
				onHoldComplete?.Invoke();
				isHolding = false;
			}
		}
	}

	public void OnPointerDown(PointerEventData eventData)
	{
		isHolding = true;
		holdTimer = 0f;
	}

	public void OnPointerUp(PointerEventData eventData)
	{
		isHolding = false;
	}
}
public static class BatchPickupFeedbackPatches
{
	private struct AccumEntry
	{
		public object Item;

		public int Amount;

		public MethodBase Method;

		public object Instance;

		public object[] TemplateArgs;

		public int AmountArgIndex;
	}

	private static readonly Dictionary<object, AccumEntry> accumulated = new Dictionary<object, AccumEntry>();

	private static int interceptedCount;

	public static void ClearAccumulated()
	{
		accumulated.Clear();
		interceptedCount = 0;
	}

	public static bool ShowPickupInfoPrefix(object __instance, object[] __args, MethodBase __originalMethod)
	{
		if (!ScrapHandlingMod.SuppressPickupFeedback)
		{
			return true;
		}
		try
		{
			if (__args == null || __args.Length < 2 || __originalMethod == null)
			{
				return false;
			}
			object obj = null;
			int num = 0;
			int num2 = -1;
			for (int i = 0; i < __args.Length; i++)
			{
				object obj2 = __args[i];
				if (obj2 != null)
				{
					if (obj == null && (obj2 is PlayerResource || obj2 is IInventoryItem))
					{
						obj = obj2;
					}
					else if (obj2 is int num3 && num2 < 0)
					{
						num = num3;
						num2 = i;
					}
				}
			}
			if (obj == null || num2 < 0 || num <= 0)
			{
				return false;
			}
			interceptedCount++;
			object key = obj;
			PlayerResource val = (PlayerResource)((obj is PlayerResource) ? obj : null);
			if (val != null && !string.IsNullOrEmpty(val.ID))
			{
				key = val.ID;
			}
			else
			{
				IInventoryItem val2 = (IInventoryItem)((obj is IInventoryItem) ? obj : null);
				if (val2 != null && !string.IsNullOrEmpty(val2.ID))
				{
					key = val2.ID;
				}
			}
			if (accumulated.TryGetValue(key, out var value))
			{
				value.Amount += num;
				accumulated[key] = value;
			}
			else
			{
				object[] array = new object[__args.Length];
				Array.Copy(__args, array, __args.Length);
				accumulated[key] = new AccumEntry
				{
					Item = obj,
					Amount = num,
					Method = __originalMethod,
					Instance = __instance,
					TemplateArgs = array,
					AmountArgIndex = num2
				};
			}
		}
		catch (Exception ex)
		{
			SparrohPlugin.Logger.LogWarning((object)("ShowPickupInfoPrefix accumulate failed: " + ex.Message));
		}
		return false;
	}

	public static bool PlayPickupSoundPrefix()
	{
		return !ScrapHandlingMod.SuppressPickupFeedback;
	}

	public static void FlushAccumulatedPickups()
	{
		try
		{
			SparrohPlugin.Logger.LogInfo((object)$"FlushAccumulatedPickups: intercepted={interceptedCount}, unique={accumulated.Count}");
			if (accumulated.Count == 0)
			{
				SparrohPlugin.Logger.LogWarning((object)"FlushAccumulatedPickups: nothing accumulated — no resource toasts to show (grants may still have applied).");
				return;
			}
			int num = 0;
			foreach (KeyValuePair<object, AccumEntry> item in accumulated)
			{
				AccumEntry value = item.Value;
				if (value.Method == null || value.TemplateArgs == null || value.Amount <= 0)
				{
					continue;
				}
				try
				{
					object[] array = new object[value.TemplateArgs.Length];
					Array.Copy(value.TemplateArgs, array, value.TemplateArgs.Length);
					if (value.AmountArgIndex >= 0 && value.AmountArgIndex < array.Length)
					{
						array[value.AmountArgIndex] = value.Amount;
					}
					object obj = value.Instance ?? GameManager.Instance;
					if (obj != null)
					{
						goto IL_0125;
					}
					MethodBase method = value.Method;
					if (!(method is MethodInfo) || method.IsStatic)
					{
						goto IL_0125;
					}
					SparrohPlugin.Logger.LogWarning((object)"FlushAccumulatedPickups: no GameManager instance.");
					goto end_IL_0098;
					IL_0125:
					value.Method.Invoke(obj, array);
					num++;
					end_IL_0098:;
				}
				catch (Exception ex)
				{
					Exception ex2 = ((ex is TargetInvocationException { InnerException: not null } ex3) ? ex3.InnerException : ex);
					SparrohPlugin.Logger.LogWarning((object)$"FlushAccumulatedPickups: failed for key={item.Key} x{value.Amount}: {ex2.Message}");
				}
			}
			SparrohPlugin.Logger.LogInfo((object)$"FlushAccumulatedPickups: showed {num} consolidated toast(s).");
		}
		finally
		{
			ClearAccumulated();
		}
	}
}
public static class UndoPatches
{
	public sealed class UpgradeSnapshot
	{
		public IUpgradable EquippedOnGear;

		public byte EquipRotation;

		public sbyte EquipX;

		public sbyte EquipY;

		public byte Flags;

		public IUpgradable Gear;

		public bool HasBeenSeen;

		public bool IsUnlocked;

		public UpgradeID OverriddenPattern;

		public bool RemoveOnQuit;

		public int Seed;

		public Upgrade Upgrade;

		public bool WasEquipped;
	}

	public sealed class ScrapAction
	{
		public string Description;

		public Dictionary<PlayerResource, int> ResourcesGranted = new Dictionary<PlayerResource, int>();

		public List<UpgradeSnapshot> Upgrades = new List<UpgradeSnapshot>();
	}

	public const int MaxDepth = 5;

	private static readonly List<ScrapAction> undoList = new List<ScrapAction>(5);

	private static readonly FieldInfo flagsField = AccessTools.Field(typeof(UpgradeInstance), "flags");

	private static readonly PropertyInfo hasBeenSeenProp = AccessTools.Property(typeof(UpgradeInstance), "HasBeenSeen");

	private static readonly PropertyInfo seedProp = AccessTools.Property(typeof(UpgradeInstance), "Seed");

	private static readonly PropertyInfo removeOnQuitProp = AccessTools.Property(typeof(UpgradeInstance), "RemoveOnQuit");

	private static ScrapAction pendingBatch;

	private static Dictionary<PlayerResource, int> resourceBaseline;

	private static readonly Queue<ScrapAction> deferredActions = new Queue<ScrapAction>();

	private static bool flushScheduled;

	public static int UndoCount => undoList.Count;

	public static bool CanUndo => undoList.Count > 0;

	public static void Clear()
	{
		undoList.Clear();
		deferredActions.Clear();
		flushScheduled = false;
		pendingBatch = null;
		resourceBaseline = null;
	}

	public static UpgradeSnapshot CaptureUpgrade(UpgradeInstance instance)
	{
		//IL_0092: Unknown result type (might be due to invalid IL or missing references)
		//IL_0097: Unknown result type (might be due to invalid IL or missing references)
		if (instance == null)
		{
			return null;
		}
		Upgrade upgrade;
		try
		{
			upgrade = instance.Upgrade;
		}
		catch
		{
			return null;
		}
		if ((Object)(object)upgrade == (Object)null)
		{
			return null;
		}
		UpgradeSnapshot upgradeSnapshot = new UpgradeSnapshot
		{
			Gear = instance.Gear,
			Upgrade = upgrade,
			Seed = instance.Seed,
			Flags = (byte)((flagsField != null) ? ((byte)flagsField.GetValue(instance)) : 0),
			IsUnlocked = instance.IsUnlocked,
			HasBeenSeen = instance.HasBeenSeen,
			RemoveOnQuit = instance.RemoveOnQuit,
			OverriddenPattern = instance.OverriddenPattern,
			WasEquipped = false
		};
		try
		{
			IUpgradable gear = instance.Gear;
			sbyte equipX = default(sbyte);
			sbyte equipY = default(sbyte);
			byte equipRotation = default(byte);
			if (gear != null && instance.IsEquipped(gear) && instance.GetPosition(gear, ref equipX, ref equipY, ref equipRotation))
			{
				upgradeSnapshot.WasEquipped = true;
				upgradeSnapshot.EquippedOnGear = gear;
				upgradeSnapshot.EquipX = equipX;
				upgradeSnapshot.EquipY = equipY;
				upgradeSnapshot.EquipRotation = equipRotation;
			}
		}
		catch (Exception ex)
		{
			SparrohPlugin.Logger.LogWarning((object)("ScrapUndo: failed to capture equip state: " + ex.Message));
		}
		return upgradeSnapshot;
	}

	public static Dictionary<PlayerResource, int> SnapshotResources()
	{
		Dictionary<PlayerResource, int> dictionary = new Dictionary<PlayerResource, int>();
		try
		{
			if (PlayerData.Instance == null)
			{
				return dictionary;
			}
			if (Global.Instance?.PlayerResources != null)
			{
				PlayerResource[] playerResources = Global.Instance.PlayerResources;
				foreach (PlayerResource val in playerResources)
				{
					if (!((Object)(object)val == (Object)null))
					{
						dictionary[val] = PlayerData.Instance.GetResource(val);
					}
				}
			}
			TryTrack(dictionary, "strange_comp");
			TryTrack(dictionary, "oyster");
			TryTrack(dictionary, "ouroscrap");
			TryTrack(dictionary, "ourosample");
			Global instance = Global.Instance;
			if ((Object)(object)((instance != null) ? instance.ScripResource : null) != (Object)null)
			{
				dictionary[Global.Instance.ScripResource] = PlayerData.Instance.GetResource(Global.Instance.ScripResource);
			}
		}
		catch (Exception ex)
		{
			SparrohPlugin.Logger.LogWarning((object)("ScrapUndo: resource snapshot failed: " + ex.Message));
		}
		return dictionary;
	}

	private static void TryTrack(Dictionary<PlayerResource, int> dict, string name)
	{
		PlayerResource val = default(PlayerResource);
		if (PlayerResource.TryGetResource(name, ref val) && (Object)(object)val != (Object)null)
		{
			dict[val] = PlayerData.Instance.GetResource(val);
		}
	}

	public static Dictionary<PlayerResource, int> DiffResources(Dictionary<PlayerResource, int> before, Dictionary<PlayerResource, int> after)
	{
		Dictionary<PlayerResource, int> dictionary = new Dictionary<PlayerResource, int>();
		if (before == null || after == null)
		{
			return dictionary;
		}
		foreach (KeyValuePair<PlayerResource, int> item in after)
		{
			before.TryGetValue(item.Key, out var value);
			int num = item.Value - value;
			if (num > 0)
			{
				dictionary[item.Key] = num;
			}
		}
		return dictionary;
	}

	public static void PushAction(ScrapAction action)
	{
		if (action == null || action.Upgrades == null || action.Upgrades.Count == 0)
		{
			return;
		}
		try
		{
			while (undoList.Count >= 5)
			{
				undoList.RemoveAt(0);
			}
			undoList.Add(action);
			SparrohPlugin.Logger.LogInfo((object)$"ScrapUndo: recorded action ({action.Upgrades.Count} upgrade(s)). Stack depth: {undoList.Count}/{5}");
		}
		catch (Exception ex)
		{
			SparrohPlugin.Logger.LogError((object)("ScrapUndo PushAction failed: " + ex.Message));
		}
	}

	public static void PushSingle(UpgradeSnapshot snap, Dictionary<PlayerResource, int> resourcesGranted)
	{
		if (snap != null)
		{
			PushAction(new ScrapAction
			{
				Description = (((Object)(object)snap.Upgrade != (Object)null) ? snap.Upgrade.Name : "upgrade"),
				ResourcesGranted = (resourcesGranted ?? new Dictionary<PlayerResource, int>()),
				Upgrades = { snap }
			});
		}
	}

	public static void QueueSingleDeferred(UpgradeSnapshot snap, Dictionary<PlayerResource, int> resourcesBefore)
	{
		if (snap == null)
		{
			return;
		}
		try
		{
			Dictionary<PlayerResource, int> after = SnapshotResources();
			Dictionary<PlayerResource, int> resourcesGranted = DiffResources(resourcesBefore, after);
			ScrapAction scrapAction = new ScrapAction
			{
				Description = (((Object)(object)snap.Upgrade != (Object)null) ? snap.Upgrade.Name : "upgrade"),
				ResourcesGranted = resourcesGranted
			};
			scrapAction.Upgrades.Add(snap);
			deferredActions.Enqueue(scrapAction);
			ScheduleFlush();
		}
		catch (Exception ex)
		{
			SparrohPlugin.Logger.LogError((object)("ScrapUndo QueueSingleDeferred failed: " + ex.Message));
		}
	}

	private static void ScheduleFlush()
	{
		if (!flushScheduled && !((Object)(object)SparrohPlugin.Instance == (Object)null))
		{
			flushScheduled = true;
			((MonoBehaviour)SparrohPlugin.Instance).StartCoroutine(FlushDeferredNextFrame());
		}
	}

	private static IEnumerator FlushDeferredNextFrame()
	{
		yield return null;
		flushScheduled = false;
		try
		{
			while (deferredActions.Count > 0)
			{
				PushAction(deferredActions.Dequeue());
			}
		}
		catch (Exception ex)
		{
			SparrohPlugin.Logger.LogError((object)("ScrapUndo flush failed: " + ex.Message));
			deferredActions.Clear();
		}
	}

	public static void BeginBatch(string description)
	{
		pendingBatch = new ScrapAction
		{
			Description = description
		};
		resourceBaseline = SnapshotResources();
	}

	public static void AddToBatch(UpgradeInstance instance)
	{
		if (pendingBatch != null)
		{
			UpgradeSnapshot upgradeSnapshot = CaptureUpgrade(instance);
			if (upgradeSnapshot != null)
			{
				pendingBatch.Upgrades.Add(upgradeSnapshot);
			}
		}
	}

	public static Dictionary<PlayerResource, int> EndBatch()
	{
		Dictionary<PlayerResource, int> dictionary = null;
		if (pendingBatch == null)
		{
			return new Dictionary<PlayerResource, int>();
		}
		try
		{
			Dictionary<PlayerResource, int> after = SnapshotResources();
			pendingBatch.ResourcesGranted = DiffResources(resourceBaseline, after);
			dictionary = pendingBatch.ResourcesGranted;
			if (pendingBatch.Upgrades.Count > 0)
			{
				PushAction(pendingBatch);
			}
		}
		catch (Exception ex)
		{
			SparrohPlugin.Logger.LogError((object)("ScrapUndo EndBatch failed: " + ex.Message));
		}
		pendingBatch = null;
		resourceBaseline = null;
		return dictionary ?? new Dictionary<PlayerResource, int>();
	}

	public static void CancelBatch()
	{
		pendingBatch = null;
		resourceBaseline = null;
	}

	public static bool TryUndo()
	{
		if (undoList.Count == 0)
		{
			SparrohPlugin.Logger.LogInfo((object)"ScrapUndo: nothing to undo.");
			return false;
		}
		int index = undoList.Count - 1;
		ScrapAction scrapAction = undoList[index];
		undoList.RemoveAt(index);
		int num = 0;
		try
		{
			if (scrapAction?.Upgrades != null)
			{
				foreach (UpgradeSnapshot upgrade in scrapAction.Upgrades)
				{
					if (RestoreUpgrade(upgrade))
					{
						num++;
					}
				}
			}
			if (scrapAction?.ResourcesGranted != null)
			{
				foreach (KeyValuePair<PlayerResource, int> item in scrapAction.ResourcesGranted)
				{
					if (!((Object)(object)item.Key == (Object)null) && item.Value > 0)
					{
						int num2 = Mathf.Min(PlayerData.Instance.GetResource(item.Key), item.Value);
						if (num2 > 0)
						{
							PlayerData.Instance.TryRemoveResource(item.Key, num2);
						}
					}
				}
			}
			RefreshOpenWindows();
			SparrohPlugin.Logger.LogInfo((object)$"ScrapUndo: restored {num}/{(scrapAction?.Upgrades?.Count).GetValueOrDefault()} upgrade(s). Remaining stack: {undoList.Count}");
			return num > 0;
		}
		catch (Exception ex)
		{
			SparrohPlugin.Logger.LogError((object)("ScrapUndo: undo failed: " + ex.Message + "\n" + ex.StackTrace));
			return false;
		}
	}

	private static bool RestoreUpgrade(UpgradeSnapshot snap)
	{
		//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
		if (snap == null || snap.Gear == null || (Object)(object)snap.Upgrade == (Object)null)
		{
			return false;
		}
		try
		{
			UpgradeInstance val = PlayerData.CreateUpgradeInstance(snap.Gear, snap.Upgrade, false);
			if (val == null)
			{
				return false;
			}
			if (seedProp != null)
			{
				seedProp.SetValue(val, snap.Seed);
			}
			if (flagsField != null)
			{
				flagsField.SetValue(val, snap.Flags);
			}
			if (removeOnQuitProp != null)
			{
				removeOnQuitProp.SetValue(val, snap.RemoveOnQuit);
			}
			val.OverriddenPattern = snap.OverriddenPattern;
			PlayerData.CollectInstance(val, (UnlockFlags)1);
			if (snap.IsUnlocked)
			{
				val.Unlock(true);
			}
			else
			{
				val.Lock();
			}
			if (hasBeenSeenProp != null)
			{
				hasBeenSeenProp.SetValue(val, snap.HasBeenSeen);
			}
			if (flagsField != null)
			{
				flagsField.SetValue(val, snap.Flags);
			}
			if (snap.WasEquipped && snap.EquippedOnGear != null)
			{
				try
				{
					val.Equip(snap.EquippedOnGear, snap.EquipX, snap.EquipY, snap.EquipRotation, true, false);
				}
				catch (Exception ex)
				{
					SparrohPlugin.Logger.LogWarning((object)("ScrapUndo: re-equip failed: " + ex.Message));
				}
			}
			return true;
		}
		catch (Exception ex2)
		{
			SparrohPlugin.Logger.LogError((object)("ScrapUndo: restore upgrade failed: " + ex2.Message));
			return false;
		}
	}

	private static void RefreshOpenWindows()
	{
		try
		{
			if ((Object)(object)Menu.Instance != (Object)null && Menu.Instance.IsOpen)
			{
				Window top = Menu.Instance.WindowSystem.GetTop();
				if ((Object)(object)top != (Object)null)
				{
					top.OnOpen(Menu.Instance.WindowSystem);
				}
			}
		}
		catch (Exception ex)
		{
			SparrohPlugin.Logger.LogWarning((object)("ScrapUndo: window refresh failed: " + ex.Message));
		}
	}
}
public static class ScrapUndoPatches
{
	private struct Pending
	{
		public UpgradeInstance Instance;

		public UndoPatches.UpgradeSnapshot Snap;

		public Dictionary<PlayerResource, int> ResourcesBefore;
	}

	private static readonly Stack<Pending> pendingStack = new Stack<Pending>();

	public static void DismantlePrefix(GearUpgradeUI __instance)
	{
		try
		{
			if ((Object)(object)__instance == (Object)null)
			{
				return;
			}
			UpgradeInstance upgrade = ((HoverInfoUpgrade)__instance).Upgrade;
			if (upgrade != null && !upgrade.Favorite)
			{
				UndoPatches.UpgradeSnapshot upgradeSnapshot = UndoPatches.CaptureUpgrade(upgrade);
				if (upgradeSnapshot != null)
				{
					pendingStack.Push(new Pending
					{
						Instance = upgrade,
						Snap = upgradeSnapshot,
						ResourcesBefore = UndoPatches.SnapshotResources()
					});
				}
			}
		}
		catch (Exception ex)
		{
			SparrohPlugin.Logger.LogError((object)("ScrapUndo DismantlePrefix: " + ex.Message));
		}
	}

	public static void DismantlePostfix(GearUpgradeUI __instance)
	{
		try
		{
			if (pendingStack.Count == 0)
			{
				return;
			}
			Pending pending = pendingStack.Pop();
			if (pending.Instance != null && pending.Snap != null)
			{
				bool flag;
				try
				{
					flag = pending.Instance.IsDestroyed();
				}
				catch
				{
					flag = true;
				}
				if (flag)
				{
					UndoPatches.QueueSingleDeferred(pending.Snap, pending.ResourcesBefore);
				}
			}
		}
		catch (Exception ex)
		{
			SparrohPlugin.Logger.LogError((object)("ScrapUndo DismantlePostfix: " + ex.Message));
			if (pendingStack.Count > 0)
			{
				try
				{
					pendingStack.Pop();
					return;
				}
				catch
				{
					return;
				}
			}
		}
	}
}
namespace BatchScrapping
{
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "BatchScrapping";

		public const string PLUGIN_NAME = "BatchScrapping";

		public const string PLUGIN_VERSION = "2.1.3";
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}