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 System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Pigeon;
using Sparroh.UI;
using TMPro;
using UnityEngine;
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("1.1.2.0")]
[assembly: AssemblyInformationalVersion("1.1.2")]
[assembly: AssemblyProduct("UpgradeFiltering")]
[assembly: AssemblyTitle("UpgradeFiltering")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.2.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<bool> EnableStatReformat { get; private set; }

	public static void Initialize(ConfigFile configFile, ManualLogSource log)
	{
		config = configFile;
		logger = log;
		EnableStatReformat = config.Bind<bool>("General", "Enable Reformat", false, "Force Key: Value stat format");
		StatFormatHandling.enableStatReformat = EnableStatReformat.Value;
		EnableStatReformat.SettingChanged += OnStatReformatChanged;
		try
		{
			SetupFileWatcher();
		}
		catch (Exception ex)
		{
			logger.LogError((object)("Error setting up config file watcher: " + ex.Message));
		}
	}

	public static void Tick()
	{
		if (!reloadPending || Time.unscaledTime - lastReloadTime < 0.25f)
		{
			return;
		}
		reloadPending = false;
		lastReloadTime = Time.unscaledTime;
		try
		{
			config.Reload();
			StatFormatHandling.enableStatReformat = EnableStatReformat.Value;
			logger.LogInfo((object)"Config reloaded from disk.");
		}
		catch (Exception ex)
		{
			logger.LogError((object)("Error reloading config: " + ex.Message));
		}
	}

	public static void Dispose()
	{
		if (EnableStatReformat != null)
		{
			EnableStatReformat.SettingChanged -= OnStatReformatChanged;
		}
		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.upgradefiltering.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 OnStatReformatChanged(object sender, EventArgs e)
	{
		StatFormatHandling.enableStatReformat = EnableStatReformat.Value;
	}
}
public class FilterPanelUI
{
	private readonly Dictionary<Rarity, UIButton> _rarityButtons = new Dictionary<Rarity, UIButton>();

	private UIButton _favHide;

	private UIButton _favOnly;

	private UIButton _favShowAll;

	private UIScrollView _statScroll;

	private UIWindow _window;

	private bool isInitialized;

	public bool IsExpanded { get; private set; }

	public void Toggle()
	{
		if (!isInitialized)
		{
			CreateFilterPanel();
			if (!isInitialized)
			{
				return;
			}
		}
		IsExpanded = !IsExpanded;
		if (IsExpanded)
		{
			RegenerateStatFilters();
			_window.Show();
		}
		else
		{
			_window.Hide(false);
		}
	}

	public void RegenerateStatFilters()
	{
		try
		{
			if (isInitialized && _statScroll != null)
			{
				FilterState.CurrentFilters.StatIncludeList.Clear();
				FilterState.CurrentFilters.FilterStats = false;
				RebuildStatToggles();
			}
		}
		catch
		{
		}
	}

	public void RebuildFilterPanel()
	{
		try
		{
			bool isExpanded = IsExpanded;
			if (_window != null)
			{
				_window.Destroy();
				_window = null;
			}
			_rarityButtons.Clear();
			isInitialized = false;
			IsExpanded = false;
			CreateFilterPanel();
			if (isExpanded && isInitialized)
			{
				IsExpanded = true;
				_window.Show();
			}
		}
		catch
		{
		}
	}

	private void CreateFilterPanel()
	{
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
		//IL_015f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0164: 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_01e5: Unknown result type (might be due to invalid IL or missing references)
		//IL_0295: Unknown result type (might be due to invalid IL or missing references)
		//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
		if (isInitialized)
		{
			return;
		}
		try
		{
			UITheme.Initialize();
			_window = UIWindow.Create("UpgradeFilter", (Vector2?)new Vector2(280f, 480f), "Upgrade Filters", true, true, (int?)(UITheme.WindowSortingOrder + 7));
			_window.OnClose((Action)delegate
			{
				IsExpanded = false;
			});
			Transform content = _window.Content;
			UIFactory.AddVerticalLayout(((Component)content).gameObject, UITheme.S(6f), UITheme.ScaledPadding(6, 6, 6, 6), (TextAnchor)0, true, false, true, true);
			UIButton.Create(content, "Clear All Filters", (Action)ClearAllFilters, (UIButtonStyle)2, (string)null, (float?)UITheme.S(28f));
			UIText.Create(content, "RarityLbl", "Hide Rarities", UITheme.ScaledFontSmall, (Color?)UIColors.TextSecondary, (TextAlignmentOptions)513, false);
			(string, Rarity)[] array = new(string, Rarity)[5]
			{
				("Standard", (Rarity)0),
				("Rare", (Rarity)1),
				("Epic", (Rarity)2),
				("Exotic", (Rarity)3),
				("Oddity", (Rarity)4)
			};
			for (int num = 0; num < array.Length; num++)
			{
				(string, Rarity) tuple = array[num];
				Rarity rarity = tuple.Item2;
				bool flag = FilterState.CurrentFilters.HiddenRarities.Contains(rarity);
				UIButton value = UIButton.Create(content, tuple.Item1, (Action)delegate
				{
					//IL_000b: Unknown result type (might be due to invalid IL or missing references)
					//IL_0076: Unknown result type (might be due to invalid IL or missing references)
					//IL_008c: 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_0022: Unknown result type (might be due to invalid IL or missing references)
					//IL_0039: Unknown result type (might be due to invalid IL or missing references)
					//IL_0055: Unknown result type (might be due to invalid IL or missing references)
					if (FilterState.CurrentFilters.HiddenRarities.Contains(rarity))
					{
						FilterState.CurrentFilters.HiddenRarities.Remove(rarity);
						_rarityButtons[rarity].SetStyle((UIButtonStyle)0);
						UpgradeFilteringPlugin.Logger.LogInfo((object)$"Filter: show rarity {rarity}");
					}
					else
					{
						FilterState.CurrentFilters.HiddenRarities.Add(rarity);
						_rarityButtons[rarity].SetStyle((UIButtonStyle)2);
						UpgradeFilteringPlugin.Logger.LogInfo((object)$"Filter: hide rarity {rarity}");
					}
					UpgradeFilteringPlugin.Logger.LogInfo((object)("Filter: HiddenRarities=[" + string.Join(",", FilterState.CurrentFilters.HiddenRarities) + "]"));
					RefreshUpgrades();
				}, (UIButtonStyle)(flag ? 2 : 0), (string)null, (float?)UITheme.S(24f));
				_rarityButtons[rarity] = value;
			}
			UIText.Create(content, "FavLbl", "Favorites", UITheme.ScaledFontSmall, (Color?)UIColors.TextSecondary, (TextAlignmentOptions)513, false);
			_favShowAll = UIButton.Create(content, "Show All", (Action)delegate
			{
				FilterState.CurrentFilters.FavoriteSetting = FavoriteFilter.ShowAll;
				UpdateFavoriteHighlights();
				RefreshUpgrades();
			}, (UIButtonStyle)3, (string)null, (float?)UITheme.S(24f));
			_favOnly = UIButton.Create(content, "Only Favorite", (Action)delegate
			{
				FilterState.CurrentFilters.FavoriteSetting = FavoriteFilter.ShowOnlyFavorited;
				UpdateFavoriteHighlights();
				RefreshUpgrades();
			}, (UIButtonStyle)0, (string)null, (float?)UITheme.S(24f));
			_favHide = UIButton.Create(content, "Hide Favorite", (Action)delegate
			{
				FilterState.CurrentFilters.FavoriteSetting = FavoriteFilter.HideFavorited;
				UpdateFavoriteHighlights();
				RefreshUpgrades();
			}, (UIButtonStyle)0, (string)null, (float?)UITheme.S(24f));
			UIText.Create(content, "StatLbl", "Show Only With", UITheme.ScaledFontSmall, (Color?)UIColors.TextSecondary, (TextAlignmentOptions)513, false);
			_statScroll = UIScrollView.Create(content, "StatScroll", true, false);
			GameObject gameObject = _statScroll.GameObject;
			float? num2 = UITheme.S(160f);
			float? num3 = UITheme.S(120f);
			UIHelpers.EnsureLayoutElement(gameObject, (float?)null, num2, num3);
			RebuildStatToggles();
			_window.Hide(false);
			isInitialized = true;
			IsExpanded = false;
		}
		catch (Exception)
		{
			isInitialized = false;
		}
	}

	private void UpdateFavoriteHighlights()
	{
		FavoriteFilter favoriteSetting = FilterState.CurrentFilters.FavoriteSetting;
		if (_favShowAll != null)
		{
			_favShowAll.SetStyle((UIButtonStyle)((favoriteSetting == FavoriteFilter.ShowAll) ? 3 : 0));
		}
		if (_favOnly != null)
		{
			_favOnly.SetStyle((UIButtonStyle)((favoriteSetting == FavoriteFilter.ShowOnlyFavorited) ? 3 : 0));
		}
		if (_favHide != null)
		{
			_favHide.SetStyle((UIButtonStyle)((favoriteSetting == FavoriteFilter.HideFavorited) ? 3 : 0));
		}
	}

	private void ClearAllFilters()
	{
		FilterState.CurrentFilters.HiddenRarities.Clear();
		FilterState.CurrentFilters.FavoriteSetting = FavoriteFilter.ShowAll;
		FilterState.CurrentFilters.FilterStats = false;
		FilterState.CurrentFilters.StatIncludeList.Clear();
		foreach (KeyValuePair<Rarity, UIButton> rarityButton in _rarityButtons)
		{
			rarityButton.Value.SetStyle((UIButtonStyle)0);
		}
		UpdateFavoriteHighlights();
		RebuildStatToggles();
		RefreshUpgrades();
	}

	private void RebuildStatToggles()
	{
		if (_statScroll == null)
		{
			return;
		}
		UIHelpers.DestroyChildren((Transform)(object)_statScroll.Content);
		foreach (string item in from p in GetContextAwareProperties()
			orderby p
			select p)
		{
			string text = item.Replace("_", " ");
			string prop = item;
			GameObject gameObject = UIToggle.Create((Transform)(object)_statScroll.Content, text, false, (Action<bool>)delegate(bool value)
			{
				if (value)
				{
					FilterState.CurrentFilters.FilterStats = true;
					if (!FilterState.CurrentFilters.StatIncludeList.Contains(prop))
					{
						FilterState.CurrentFilters.StatIncludeList.Add(prop);
					}
				}
				else
				{
					FilterState.CurrentFilters.StatIncludeList.Remove(prop);
					if (FilterState.CurrentFilters.StatIncludeList.Count == 0)
					{
						FilterState.CurrentFilters.FilterStats = false;
					}
				}
				RefreshUpgrades();
			}, (string)null).GameObject;
			float? num = UITheme.S(22f);
			UIHelpers.EnsureLayoutElement(gameObject, (float?)null, num, (float?)null);
		}
	}

	private List<string> GetContextAwareProperties()
	{
		try
		{
			GearDetailsWindow openWindow = FilterState.GetOpenWindow();
			bool flag = false;
			if ((Object)(object)openWindow != (Object)null)
			{
				FieldInfo fieldInfo = AccessTools.Field(typeof(GearDetailsWindow), "inSkinMode");
				if (fieldInfo != null)
				{
					try
					{
						flag = (bool)fieldInfo.GetValue(openWindow);
					}
					catch
					{
					}
				}
			}
			return flag ? DiscoverSkinProperties() : GetCuratedUpgradeProperties();
		}
		catch
		{
			return GetCuratedUpgradeProperties();
		}
	}

	private static List<string> GetCuratedUpgradeProperties()
	{
		return new List<string>
		{
			"AmmoCapacity", "AutomaticFire", "BatteryCapacity", "BulletsPerShot", "BurstFire", "Carver_Blood", "Charge", "Damage", "FireInterval", "Globbler_Globblometer",
			"Health", "HealthRegenDelay", "HitForce", "MagazineSize", "MaxBounces", "MeleeDamage", "Range", "Recoil", "Reload", "Speed"
		};
	}

	private static List<string> DiscoverSkinProperties()
	{
		List<string> list = new List<string>();
		try
		{
			Type skinUpgradePropertyType = typeof(GearUpgradeUI).Assembly.GetType("SkinUpgradeProperty");
			if (skinUpgradePropertyType == null)
			{
				return list;
			}
			foreach (Type item in (from t in skinUpgradePropertyType.Assembly.GetTypes()
				where t.IsClass && !t.IsAbstract && skinUpgradePropertyType.IsAssignableFrom(t) && t.FullName != null && t.FullName.StartsWith("SkinUpgradeProperty_")
				select t).ToList())
			{
				string text = item.Name;
				if (text.StartsWith("SkinUpgradeProperty_"))
				{
					text = text.Substring("SkinUpgradeProperty_".Length);
				}
				list.Add(text);
			}
			return (from p in list.Distinct()
				orderby p
				select p).ToList();
		}
		catch
		{
			return list;
		}
	}

	private void RefreshUpgrades()
	{
		GearDetailsWindow val = PriorityPatches.ResolveWindow() ?? FilterState.GetOpenWindow();
		if ((Object)(object)val == (Object)null)
		{
			UpgradeFilteringPlugin.Logger.LogWarning((object)"Filter refresh: no GearDetailsWindow.");
			return;
		}
		UpgradeFilteringPlugin.Logger.LogInfo((object)$"Filter refresh: window={((Object)val).name}, priorityActive={PriorityPatches.PrioritySortActive}");
		try
		{
			FilterState.ApplyToWindow(val);
		}
		catch (Exception ex)
		{
			UpgradeFilteringPlugin.Logger.LogError((object)("Filter refresh failed: " + ex.Message + "\n" + ex.StackTrace));
		}
	}
}
[HarmonyPatch(typeof(GearDetailsWindow))]
public static class GearDetailsWindowPatches
{
	[HarmonyPostfix]
	[HarmonyPatch("OnOpen")]
	private static void OnOpen(GearDetailsWindow __instance)
	{
		try
		{
			FieldInfo fieldInfo = AccessTools.Field(typeof(GearDetailsWindow), "inSkinMode");
			if (fieldInfo != null)
			{
				bool flag = (bool)fieldInfo.GetValue(__instance);
				if (FilterState.PreviousSkinMode.HasValue && FilterState.PreviousSkinMode.Value != flag && FilterState.FilterPanel != null)
				{
					FilterState.FilterPanel.RegenerateStatFilters();
				}
				FilterState.PreviousSkinMode = flag;
			}
		}
		catch
		{
		}
		if (FilterState.FilterPanel == null)
		{
			FilterState.FilterPanel = new FilterPanelUI();
		}
	}

	[HarmonyPrefix]
	[HarmonyPatch("SwitchUpgradeView")]
	private static void SwitchUpgradeView_Prefix()
	{
		ListRebuildReapply.BeginViewSwitch();
	}

	[HarmonyPostfix]
	[HarmonyPatch("SwitchUpgradeView")]
	private static void SwitchUpgradeView_Postfix(GearDetailsWindow __instance)
	{
		try
		{
			ListRebuildReapply.After(__instance, "SwitchUpgradeView");
		}
		finally
		{
			ListRebuildReapply.EndViewSwitch();
		}
	}
}
[HarmonyPatch(typeof(GearDetailsWindow), "SetupUpgrades", new Type[]
{
	typeof(IUpgradable),
	typeof(bool),
	typeof(bool)
})]
public static class SetupUpgradesPatch
{
	[HarmonyPostfix]
	public static void Postfix(GearDetailsWindow __instance, bool skins)
	{
		if (!ListRebuildReapply.SuppressNestedReapply)
		{
			ListRebuildReapply.After(__instance, $"SetupUpgrades(skins={skins})");
		}
	}
}
[HarmonyPatch(typeof(GearDetailsWindow), "SortUpgrades", new Type[]
{
	typeof(SortingMethod),
	typeof(bool)
})]
public static class SortUpgradesMethodPatch
{
	private static bool? lastSkinMode;

	[HarmonyPostfix]
	public static void Postfix(GearDetailsWindow __instance, SortingMethod method, bool resetScroll)
	{
		if (ListRebuildReapply.SuppressNestedReapply || PriorityPatches.PrioritySortActive)
		{
			return;
		}
		FieldInfo fieldInfo = AccessTools.Field(typeof(GearDetailsWindow), "inSkinMode");
		bool flag = false;
		if (fieldInfo != null)
		{
			try
			{
				flag = (bool)fieldInfo.GetValue(__instance);
			}
			catch
			{
			}
		}
		bool num = lastSkinMode.HasValue && lastSkinMode.Value != flag;
		lastSkinMode = flag;
		if (num)
		{
			return;
		}
		try
		{
			FilterState.ApplyToWindow(__instance);
		}
		catch
		{
		}
	}
}
internal static class ListRebuildReapply
{
	public static bool SuppressNestedReapply { get; private set; }

	public static void After(GearDetailsWindow window, string reason)
	{
		if ((Object)(object)window == (Object)null)
		{
			return;
		}
		try
		{
			PriorityPatches.currentWindow = window;
			PriorityPatches.CancelDeferredLayout();
			List<GearUpgradeUI> upgradeUIs = FilterState.GetUpgradeUIs();
			int num = FilterState.GetUpgradeUICount(window);
			if (upgradeUIs == null)
			{
				UpgradeFilteringPlugin.Logger.LogWarning((object)("List rebuild (" + reason + "): upgradeUIs null"));
				return;
			}
			if (num <= 0 || num > upgradeUIs.Count)
			{
				num = upgradeUIs.Count;
			}
			PriorityPatches.ClearStalePoolSlots(upgradeUIs, num);
			if (!PriorityPatches.LogUniqueInstanceIds("BEFORE repair (" + reason + ")", upgradeUIs, num) && !PriorityPatches.TryRepairDuplicateUiRefs(window, upgradeUIs, num))
			{
				UpgradeFilteringPlugin.Logger.LogError((object)("List rebuild (" + reason + "): pool repair failed — reopen gear window."));
				return;
			}
			PriorityPatches.ActivateAllLiveSlots(upgradeUIs, num);
			if (PriorityPatches.PrioritySortActive)
			{
				PriorityPatches.ApplyPrioritySort(window, resetScroll: false, skipDeferred: true);
				UpgradeFilteringPlugin.Logger.LogInfo((object)$"List rebuild re-apply ({reason}): visual priority + filters, isGrid={PriorityPatches.GetIsGridView(window)}");
			}
			else if (FilterState.HasActiveFilters())
			{
				FilterState.ApplyToWindow(window);
				UpgradeFilteringPlugin.Logger.LogInfo((object)$"List rebuild re-apply ({reason}): filters only, isGrid={PriorityPatches.GetIsGridView(window)}");
			}
			else
			{
				PriorityPatches.ForceLayoutVisibleOnly(window, upgradeUIs, num);
				UpgradeFilteringPlugin.Logger.LogInfo((object)$"List rebuild re-apply ({reason}): layout only, isGrid={PriorityPatches.GetIsGridView(window)}");
			}
		}
		catch (Exception ex)
		{
			UpgradeFilteringPlugin.Logger.LogError((object)("List rebuild re-apply failed (" + reason + "): " + ex.Message + "\n" + ex.StackTrace));
		}
	}

	public static void BeginViewSwitch()
	{
		SuppressNestedReapply = true;
		PriorityPatches.CancelDeferredLayout();
	}

	public static void EndViewSwitch()
	{
		SuppressNestedReapply = false;
	}
}
public enum FavoriteFilter
{
	ShowAll,
	ShowOnlyFavorited,
	HideFavorited
}
public struct FilterSettings
{
	public List<Rarity> HiddenRarities;

	public bool FilterStats;

	public List<string> StatIncludeList;

	public FavoriteFilter FavoriteSetting;
}
public static class FilterState
{
	internal static FilterPanelUI FilterPanel;

	internal static readonly Dictionary<Rarity, int> RarityOrder = new Dictionary<Rarity, int>
	{
		{
			(Rarity)4,
			5
		},
		{
			(Rarity)3,
			4
		},
		{
			(Rarity)2,
			3
		},
		{
			(Rarity)1,
			2
		},
		{
			(Rarity)0,
			1
		},
		{
			(Rarity)(-1),
			0
		}
	};

	internal static FilterSettings CurrentFilters = new FilterSettings
	{
		HiddenRarities = new List<Rarity>(),
		FilterStats = false,
		StatIncludeList = new List<string>(),
		FavoriteSetting = FavoriteFilter.ShowAll
	};

	internal static bool? PreviousSkinMode;

	private static FieldInfo _upgradeUIsField;

	private static FieldInfo _upgradeUICountField;

	public static bool HasActiveFilters()
	{
		if (!CurrentFilters.HiddenRarities.Any() && CurrentFilters.FavoriteSetting == FavoriteFilter.ShowAll)
		{
			if (CurrentFilters.FilterStats)
			{
				return CurrentFilters.StatIncludeList.Any();
			}
			return false;
		}
		return true;
	}

	public static void ApplyVisibilityOnly(GearDetailsWindow window)
	{
		if ((Object)(object)window == (Object)null)
		{
			return;
		}
		List<GearUpgradeUI> upgradeUIs = GetUpgradeUIs();
		if (upgradeUIs == null || upgradeUIs.Count == 0)
		{
			return;
		}
		int num = GetUpgradeUICount(window);
		if (num <= 0)
		{
			num = upgradeUIs.Count;
		}
		num = Mathf.Min(num, upgradeUIs.Count);
		bool isGridView = PriorityPatches.GetIsGridView(window);
		int num2 = 0;
		int num3 = 0;
		int num4 = 0;
		for (int i = 0; i < num; i++)
		{
			GearUpgradeUI val = upgradeUIs[i];
			if ((Object)(object)val == (Object)null)
			{
				continue;
			}
			UpgradeInstance upgrade = ((HoverInfoUpgrade)val).Upgrade;
			if ((Object)(object)((upgrade != null) ? upgrade.Upgrade : null) == (Object)null)
			{
				if (((Component)val).gameObject.activeSelf)
				{
					((Component)val).gameObject.SetActive(false);
				}
				num3++;
			}
			else if (ShouldShow(val))
			{
				if (!((Component)val).gameObject.activeSelf)
				{
					((Component)val).gameObject.SetActive(true);
					try
					{
						val.SetUpgrade(((HoverInfoUpgrade)val).Upgrade, false);
					}
					catch
					{
					}
					num4++;
				}
				try
				{
					val.EnableGridView(isGridView);
				}
				catch
				{
				}
				num2++;
			}
			else
			{
				if (((Component)val).gameObject.activeSelf)
				{
					((Component)val).gameObject.SetActive(false);
				}
				num3++;
			}
		}
		UpgradeFilteringPlugin.Logger.LogInfo((object)($"Filter visibility: count={num}, visible={num2}, hidden={num3}, " + $"reenabled={num4}, fav={CurrentFilters.FavoriteSetting}"));
	}

	public static void ApplyToWindow(GearDetailsWindow window)
	{
		if ((Object)(object)window == (Object)null)
		{
			UpgradeFilteringPlugin.Logger.LogWarning((object)"ApplyToWindow: window null");
			return;
		}
		List<GearUpgradeUI> upgradeUIs = GetUpgradeUIs();
		if (upgradeUIs == null || upgradeUIs.Count == 0)
		{
			UpgradeFilteringPlugin.Logger.LogWarning((object)"ApplyToWindow: upgradeUIs empty");
			return;
		}
		int num = GetUpgradeUICount(window);
		if (num <= 0)
		{
			num = upgradeUIs.Count;
		}
		num = Mathf.Min(num, upgradeUIs.Count);
		string arg = ((CurrentFilters.HiddenRarities != null && CurrentFilters.HiddenRarities.Count > 0) ? string.Join(",", CurrentFilters.HiddenRarities) : "(none)");
		UpgradeFilteringPlugin.Logger.LogInfo((object)($"Filter apply: count={num}, hiddenRarities=[{arg}], " + $"fav={CurrentFilters.FavoriteSetting}, stats={CurrentFilters.FilterStats}/" + $"{CurrentFilters.StatIncludeList?.Count ?? 0}"));
		ApplyVisibilityOnly(window);
		if (PriorityPatches.PrioritySortActive)
		{
			List<PriorityCriteria> order = PriorityPatches.FilterOrderForAvailableMods(PriorityPatches.LoadPriorityOrder());
			PriorityPatches.ApplyVisualPriorityOrder(window, upgradeUIs, num, order);
		}
		else
		{
			PriorityPatches.ForceLayoutVisibleOnly(window, upgradeUIs, num);
		}
		try
		{
			typeof(GearDetailsWindow).GetMethod("SetUpgradeListScroll", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(float) }, null)?.Invoke(window, new object[1] { 1f });
		}
		catch
		{
		}
	}

	internal static List<GearUpgradeUI> GetUpgradeUIs()
	{
		try
		{
			if (_upgradeUIsField == null)
			{
				_upgradeUIsField = typeof(GearDetailsWindow).GetField("upgradeUIs", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			}
			if (_upgradeUIsField == null)
			{
				return null;
			}
			return _upgradeUIsField.GetValue(null) as List<GearUpgradeUI>;
		}
		catch
		{
			return null;
		}
	}

	internal static int GetUpgradeUICount(GearDetailsWindow window)
	{
		if ((Object)(object)window == (Object)null)
		{
			return 0;
		}
		try
		{
			if (_upgradeUICountField == null)
			{
				_upgradeUICountField = typeof(GearDetailsWindow).GetField("upgradeUICount", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			}
			if (_upgradeUICountField == null)
			{
				return 0;
			}
			return (int)_upgradeUICountField.GetValue(window);
		}
		catch
		{
			return 0;
		}
	}

	internal static GearDetailsWindow GetOpenWindow()
	{
		try
		{
			Menu instance = Menu.Instance;
			if ((Object)(object)((instance != null) ? instance.WindowSystem : null) != (Object)null)
			{
				Window top = Menu.Instance.WindowSystem.GetTop();
				GearDetailsWindow val = (GearDetailsWindow)(object)((top is GearDetailsWindow) ? top : null);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
		}
		catch
		{
		}
		if ((Object)(object)PriorityPatches.currentWindow != (Object)null)
		{
			try
			{
				if ((Object)(object)((Component)PriorityPatches.currentWindow).gameObject != (Object)null)
				{
					return PriorityPatches.currentWindow;
				}
			}
			catch
			{
			}
		}
		try
		{
			return Object.FindObjectOfType<GearDetailsWindow>();
		}
		catch
		{
			return null;
		}
	}

	public static bool ShouldShow(GearUpgradeUI ui)
	{
		//IL_0058: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
		//IL_0100: Unknown result type (might be due to invalid IL or missing references)
		object obj;
		if (ui == null)
		{
			obj = null;
		}
		else
		{
			UpgradeInstance upgrade = ((HoverInfoUpgrade)ui).Upgrade;
			obj = ((upgrade != null) ? upgrade.Upgrade : null);
		}
		if ((Object)obj == (Object)null)
		{
			return false;
		}
		bool flag = true;
		if (CurrentFilters.HiddenRarities != null && CurrentFilters.HiddenRarities.Count > 0)
		{
			flag &= !CurrentFilters.HiddenRarities.Contains(((HoverInfoUpgrade)ui).Upgrade.Upgrade.Rarity);
		}
		switch (CurrentFilters.FavoriteSetting)
		{
		case FavoriteFilter.ShowOnlyFavorited:
			flag &= ((HoverInfoUpgrade)ui).Upgrade.Favorite;
			break;
		case FavoriteFilter.HideFavorited:
			flag &= !((HoverInfoUpgrade)ui).Upgrade.Favorite;
			break;
		}
		if (CurrentFilters.FilterStats && CurrentFilters.StatIncludeList != null && CurrentFilters.StatIncludeList.Count > 0)
		{
			foreach (string statInclude in CurrentFilters.StatIncludeList)
			{
				bool flag2 = false;
				Enumerator properties = ((HoverInfoUpgrade)ui).Upgrade.Upgrade.GetProperties();
				while (((Enumerator)(ref properties)).MoveNext())
				{
					UpgradeProperty current2 = ((Enumerator)(ref properties)).Current;
					if (current2 != null)
					{
						string text = ((object)current2).GetType().Name;
						if (text.StartsWith("UpgradeProperty_"))
						{
							text = text.Substring("UpgradeProperty_".Length);
						}
						else if (text.StartsWith("SkinUpgradeProperty_"))
						{
							text = text.Substring("SkinUpgradeProperty_".Length);
						}
						if (text == statInclude)
						{
							flag2 = true;
							break;
						}
					}
				}
				if (!flag2)
				{
					return false;
				}
			}
		}
		return flag;
	}
}
[BepInPlugin("sparroh.upgradefiltering", "UpgradeFiltering", "1.1.2")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[MycoMod(/*Could not decode attribute arguments.*/)]
public class UpgradeFilteringPlugin : BaseUnityPlugin
{
	public const string PluginGUID = "sparroh.upgradefiltering";

	public const string PluginName = "UpgradeFiltering";

	public const string PluginVersion = "1.1.2";

	internal static ManualLogSource Logger;

	public static UpgradeFilteringPlugin Instance;

	private bool _barRegistered;

	private void Awake()
	{
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Expected O, but got Unknown
		try
		{
			Logger = ((BaseUnityPlugin)this).Logger;
			Instance = this;
			Harmony val = new Harmony("sparroh.upgradefiltering");
			try
			{
				ConfigManager.Initialize(((BaseUnityPlugin)this).Config, Logger);
			}
			catch (Exception ex)
			{
				Logger.LogError((object)("Failed to setup configuration bindings: " + ex.Message));
			}
			try
			{
				StatFormatHandling.Initialize();
			}
			catch (Exception ex2)
			{
				Logger.LogError((object)("Failed to initialize StatFormatHandling: " + ex2.Message));
			}
			try
			{
				PriorityGUI.EnsureExists();
			}
			catch (Exception ex3)
			{
				Logger.LogError((object)("Failed to initialize PriorityGUI: " + ex3.Message));
			}
			try
			{
				PriorityPatches.Patch(val);
			}
			catch (Exception ex4)
			{
				Logger.LogError((object)("Failed to apply PriorityPatches: " + ex4.Message));
			}
			Type[] array = new Type[4]
			{
				typeof(GearDetailsWindowPatches),
				typeof(SetupUpgradesPatch),
				typeof(SortUpgradesMethodPatch),
				typeof(PriorityPatches)
			};
			foreach (Type type in array)
			{
				try
				{
					val.PatchAll(type);
				}
				catch (Exception ex5)
				{
					Logger.LogError((object)("Failed to patch " + type.Name + ": " + ex5.Message));
				}
			}
			try
			{
				array = typeof(UpgradeFilteringPlugin).Assembly.GetTypes();
				foreach (Type type2 in array)
				{
					if (type2 == typeof(GearDetailsWindowPatches) || type2 == typeof(SetupUpgradesPatch) || type2 == typeof(SortUpgradesMethodPatch) || type2 == typeof(PriorityPatches) || type2 == typeof(ListRebuildReapply) || !type2.IsClass)
					{
						continue;
					}
					object[] customAttributes = type2.GetCustomAttributes(typeof(HarmonyPatch), inherit: true);
					if (customAttributes != null && customAttributes.Length != 0)
					{
						try
						{
							val.PatchAll(type2);
						}
						catch (Exception ex6)
						{
							Logger.LogError((object)("Failed to patch " + type2.Name + ": " + ex6.Message));
						}
					}
				}
			}
			catch (Exception ex7)
			{
				Logger.LogError((object)("Failed scanning assembly patches: " + ex7.Message));
			}
		}
		catch (Exception ex8)
		{
			Logger.LogError((object)("Critical error during mod initialization: " + ex8.Message + "\n" + ex8.StackTrace));
		}
		Logger.LogInfo((object)"UpgradeFiltering loaded successfully.");
	}

	private void Update()
	{
		ConfigManager.Tick();
		GearActionBar.Tick();
		if (GearActionBar.IsGearMenuOpen() && !_barRegistered)
		{
			GearActionBar.Register("filter", "Filter", 100, (Action)delegate
			{
				FilterState.FilterPanel?.Toggle();
			}, (UIButtonStyle)0);
			GearActionBar.Register("priority", "Upgr. Sort", 110, (Action)PriorityGUI.ToggleWindowStatic, (UIButtonStyle)1);
			_barRegistered = true;
		}
	}

	private void OnDestroy()
	{
		ConfigManager.Dispose();
		GearActionBar.Unregister("filter");
		GearActionBar.Unregister("priority");
		_barRegistered = false;
	}
}
[Serializable]
public class PriorityData
{
	public List<int> order;

	public PriorityData()
	{
		order = new List<int>
		{
			0, 1, 2, 3, 7, 8, 9, 10, 11, 12,
			14, 4, 5, 6
		};
	}

	public string ToJson()
	{
		return JsonUtility.ToJson((object)this);
	}

	public static PriorityData FromJson(string json)
	{
		if (string.IsNullOrEmpty(json))
		{
			return new PriorityData();
		}
		return JsonUtility.FromJson<PriorityData>(json);
	}
}
public enum PriorityCriteria
{
	Favorited,
	NotFavorited,
	Unlocked,
	Locked,
	RecentlyUsed,
	RecentlyAcquired,
	InstanceName,
	Oddity,
	Exotic,
	Epic,
	Rare,
	Standard,
	Turbocharged,
	Trashed,
	NotTurbocharged,
	NotTrashed
}
public class PriorityGUI : MonoBehaviour
{
	private static readonly PriorityCriteria[] BaseDefaultOrder = new PriorityCriteria[14]
	{
		PriorityCriteria.Favorited,
		PriorityCriteria.NotFavorited,
		PriorityCriteria.Unlocked,
		PriorityCriteria.Locked,
		PriorityCriteria.Oddity,
		PriorityCriteria.Exotic,
		PriorityCriteria.Epic,
		PriorityCriteria.Rare,
		PriorityCriteria.Standard,
		PriorityCriteria.Turbocharged,
		PriorityCriteria.NotTurbocharged,
		PriorityCriteria.RecentlyUsed,
		PriorityCriteria.RecentlyAcquired,
		PriorityCriteria.InstanceName
	};

	private static readonly PriorityCriteria[] TrashCriteria = new PriorityCriteria[2]
	{
		PriorityCriteria.Trashed,
		PriorityCriteria.NotTrashed
	};

	private UIDragList _list;

	private UIWindow _window;

	private List<PriorityCriteria> currentOrder;

	private bool showWindow;

	public static PriorityGUI Instance { get; private set; }

	private void Awake()
	{
		Instance = this;
		Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
		currentOrder = PriorityPatches.LoadPriorityOrder();
	}

	private void Update()
	{
		if (!PriorityPatches.IsWindowOpen && !GearActionBar.IsGearMenuOpen() && showWindow)
		{
			CloseWindow(reload: true);
		}
	}

	private void OnDestroy()
	{
		if ((Object)(object)Instance == (Object)(object)this)
		{
			Instance = null;
		}
	}

	private static List<PriorityCriteria> BuildDefaultOrder()
	{
		List<PriorityCriteria> list = BaseDefaultOrder.ToList();
		if (PriorityPatches.IsBatchScrappingPresent())
		{
			int num = list.IndexOf(PriorityCriteria.Locked);
			if (num < 0)
			{
				num = list.Count - 1;
			}
			list.InsertRange(num + 1, TrashCriteria);
		}
		return list;
	}

	public static void EnsureExists()
	{
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		PriorityGUI priorityGUI = Object.FindObjectOfType<PriorityGUI>();
		if ((Object)(object)priorityGUI != (Object)null)
		{
			Object.Destroy((Object)(object)((Component)priorityGUI).gameObject);
			Instance = null;
		}
		new GameObject("PriorityGUI").AddComponent<PriorityGUI>();
	}

	public static void ToggleWindowStatic()
	{
		if (!((Object)(object)Instance == (Object)null))
		{
			Instance.ToggleWindow();
		}
	}

	private void ToggleWindow()
	{
		if (showWindow)
		{
			CloseWindow(reload: true);
		}
		else
		{
			OpenWindow();
		}
	}

	private void OpenWindow()
	{
		//IL_0060: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e5: Expected O, but got Unknown
		showWindow = true;
		currentOrder = PriorityPatches.LoadPriorityOrder();
		if (currentOrder == null || currentOrder.Count == 0)
		{
			currentOrder = BuildDefaultOrder();
		}
		else
		{
			currentOrder = PriorityPatches.FilterOrderForAvailableMods(currentOrder);
		}
		if (_window == null)
		{
			_window = UIWindow.Create("SortPriority", (Vector2?)new Vector2(340f, 560f), "Sort Priority", false, true, (int?)null);
			_window.OnClose((Action)delegate
			{
				CloseWindow(reload: true);
			});
			Transform content = _window.Content;
			UIFactory.AddVerticalLayout(((Component)content).gameObject, UITheme.S(8f), UITheme.ScaledPadding(8, 8, 8, 8), (TextAnchor)0, true, false, true, true);
			UIText.Create(content, "Hint", "Higher = applied first. Put rarities above Name/Recently* or they won't matter.", UITheme.ScaledFontSmall, (Color?)UIColors.TextSecondary, (TextAlignmentOptions)513, false);
			_list = UIDragList.Create(content, "PriorityList");
			GameObject gameObject = _list.GameObject;
			float? num = UITheme.S(400f);
			float? num2 = UITheme.S(280f);
			UIHelpers.EnsureLayoutElement(gameObject, (float?)null, num, num2);
			LayoutElement component = _list.GameObject.GetComponent<LayoutElement>();
			if ((Object)(object)component != (Object)null)
			{
				component.flexibleHeight = 1f;
			}
			_list.OnReordered((Action<int, int>)delegate(int from, int to)
			{
				if (from >= 0 && to >= 0 && from < currentOrder.Count && to < currentOrder.Count)
				{
					PriorityCriteria item = currentOrder[from];
					currentOrder.RemoveAt(from);
					currentOrder.Insert(to, item);
				}
			});
			RectTransform obj = UIFactory.CreateRect("Buttons", content);
			GameObject gameObject2 = ((Component)obj).gameObject;
			num2 = UITheme.ScaledButtonHeight + UITheme.S(4f);
			UIHelpers.EnsureLayoutElement(gameObject2, (float?)null, num2, (float?)null);
			UIFactory.AddHorizontalLayout(((Component)obj).gameObject, UITheme.S(8f), new RectOffset(0, 0, 0, 0), (TextAnchor)4, false, false, true, true);
			UIButton.Create((Transform)(object)obj, "Save", (Action)delegate
			{
				PriorityPatches.SavePriorityOrder(currentOrder);
				PriorityPatches.TriggerPrioritySort(currentOrder);
				CloseWindow(reload: false);
			}, (UIButtonStyle)1, (string)null, (float?)null).SetWidth(UITheme.S(90f));
			UIButton.Create((Transform)(object)obj, "Cancel", (Action)delegate
			{
				CloseWindow(reload: true);
			}, (UIButtonStyle)0, (string)null, (float?)null).SetWidth(UITheme.S(90f));
			UIButton.Create((Transform)(object)obj, "Reset", (Action)delegate
			{
				currentOrder = BuildDefaultOrder();
				RefreshList();
			}, (UIButtonStyle)2, (string)null, (float?)null).SetWidth(UITheme.S(90f));
		}
		RefreshList();
		_window.Show();
	}

	private void RefreshList()
	{
		if (_list == null || currentOrder == null)
		{
			return;
		}
		List<string> list = new List<string>();
		foreach (PriorityCriteria item in currentOrder)
		{
			list.Add(GetCriteriaName(item));
		}
		_list.SetItems((IList<string>)list);
	}

	private void CloseWindow(bool reload)
	{
		showWindow = false;
		if (reload)
		{
			currentOrder = PriorityPatches.LoadPriorityOrder();
		}
		if (_window != null)
		{
			_window.Hide(true);
		}
	}

	private string GetCriteriaName(PriorityCriteria criteria)
	{
		return criteria switch
		{
			PriorityCriteria.Favorited => "Favorited", 
			PriorityCriteria.NotFavorited => "Not Favorited", 
			PriorityCriteria.Unlocked => "Unlocked", 
			PriorityCriteria.Locked => "Locked", 
			PriorityCriteria.RecentlyUsed => "Recently Used", 
			PriorityCriteria.RecentlyAcquired => "Recently Acquired", 
			PriorityCriteria.InstanceName => "Name (tie-break)", 
			PriorityCriteria.Oddity => "Oddity", 
			PriorityCriteria.Exotic => "Exotic", 
			PriorityCriteria.Epic => "Epic", 
			PriorityCriteria.Rare => "Rare", 
			PriorityCriteria.Standard => "Standard", 
			PriorityCriteria.Turbocharged => "Turbocharged", 
			PriorityCriteria.Trashed => "Trashed (BatchScrapping)", 
			PriorityCriteria.NotTurbocharged => "Not Turbocharged", 
			PriorityCriteria.NotTrashed => "Not Trashed (BatchScrapping)", 
			_ => "Unknown", 
		};
	}
}
public static class PriorityPatches
{
	private struct SortEntry
	{
		public GearUpgradeUI Ui;

		public int[] Keys;
	}

	private sealed class SortEntryComparer : IComparer<SortEntry>
	{
		public static readonly SortEntryComparer Instance = new SortEntryComparer();

		public int Compare(SortEntry x, SortEntry y)
		{
			int[] keys = x.Keys;
			int[] keys2 = y.Keys;
			if (keys == null && keys2 == null)
			{
				return 0;
			}
			if (keys == null)
			{
				return 1;
			}
			if (keys2 == null)
			{
				return -1;
			}
			int num = Math.Min(keys.Length, keys2.Length);
			for (int i = 0; i < num; i++)
			{
				int num2 = keys2[i].CompareTo(keys[i]);
				if (num2 != 0)
				{
					return num2;
				}
			}
			return keys.Length.CompareTo(keys2.Length);
		}
	}

	private static List<PriorityCriteria> priorityOrder;

	public static GearDetailsWindow currentWindow;

	private static bool? _batchScrappingPresent;

	private static MethodInfo _isTrashMarkedMethod;

	private static Coroutine _deferredLayoutCoroutine;

	private static bool _deferredLayoutCancelled;

	private static FieldInfo _isGridViewField;

	private static FieldInfo _upgradeListParentField;

	private static bool _layoutLookupsDone;

	public static bool PrioritySortActive { get; private set; }

	public static bool IsWindowOpen { get; private set; }

	static PriorityPatches()
	{
		priorityOrder = new List<PriorityCriteria>();
		priorityOrder = LoadPriorityOrder();
		try
		{
			string value = default(string);
			PrioritySortActive = PlayerOptions.TryGetConfig<string>("SortPriority.Order", ref value) && !string.IsNullOrEmpty(value);
		}
		catch
		{
			PrioritySortActive = false;
		}
	}

	public static bool IsBatchScrappingPresent()
	{
		if (_batchScrappingPresent.HasValue)
		{
			return _batchScrappingPresent.Value;
		}
		try
		{
			foreach (PluginInfo value in Chainloader.PluginInfos.Values)
			{
				object obj;
				if (value == null)
				{
					obj = null;
				}
				else
				{
					BepInPlugin metadata = value.Metadata;
					obj = ((metadata != null) ? metadata.GUID : null);
				}
				if ((string?)obj == "sparroh.batchscrapping")
				{
					_batchScrappingPresent = true;
					CacheTrashApi();
					return true;
				}
			}
		}
		catch
		{
		}
		try
		{
			if (AccessTools.TypeByName("ScrapHandlingMod") != null)
			{
				_batchScrappingPresent = true;
				CacheTrashApi();
				return true;
			}
		}
		catch
		{
		}
		_batchScrappingPresent = false;
		return false;
	}

	private static void CacheTrashApi()
	{
		try
		{
			Type type = AccessTools.TypeByName("ScrapHandlingMod");
			_isTrashMarkedMethod = ((type != null) ? AccessTools.Method(type, "IsTrashMarked", new Type[1] { typeof(UpgradeInstance) }, (Type[])null) : null);
		}
		catch
		{
			_isTrashMarkedMethod = null;
		}
	}

	public static bool IsTrashMarked(UpgradeInstance instance)
	{
		if (instance == null || !IsBatchScrappingPresent())
		{
			return false;
		}
		if (_isTrashMarkedMethod != null)
		{
			try
			{
				return (bool)_isTrashMarkedMethod.Invoke(null, new object[1] { instance });
			}
			catch
			{
			}
		}
		try
		{
			FieldInfo fieldInfo = AccessTools.Field(typeof(UpgradeInstance), "flags");
			if (fieldInfo == null)
			{
				return false;
			}
			return (Convert.ToByte(fieldInfo.GetValue(instance)) & 0x20) != 0;
		}
		catch
		{
			return false;
		}
	}

	[HarmonyPostfix]
	[HarmonyPatch(typeof(GearDetailsWindow), "OnOpen")]
	public static void OnOpen_Postfix(GearDetailsWindow __instance)
	{
		IsWindowOpen = true;
		currentWindow = __instance;
		if (PrioritySortActive)
		{
			try
			{
				ApplyPrioritySort(__instance, priorityOrder, resetScroll: false);
				return;
			}
			catch (Exception ex)
			{
				UpgradeFilteringPlugin.Logger.LogWarning((object)("Priority sort on open failed: " + ex.Message));
				return;
			}
		}
		try
		{
			FilterState.ApplyToWindow(__instance);
		}
		catch
		{
		}
	}

	[HarmonyPostfix]
	[HarmonyPatch(typeof(GearDetailsWindow), "OnCloseCallback")]
	public static void OnCloseCallback_Postfix()
	{
		IsWindowOpen = false;
		currentWindow = null;
	}

	public static bool SortUpgradesInt_Prefix(int i)
	{
		if (PrioritySortActive)
		{
			PrioritySortActive = false;
			UpgradeFilteringPlugin.Logger.LogInfo((object)$"Priority sort disabled (vanilla sort button {i}).");
		}
		return true;
	}

	public static bool SortUpgradesMethod_Prefix(GearDetailsWindow __instance, SortingMethod method, bool resetScroll)
	{
		if (!PrioritySortActive)
		{
			return true;
		}
		if (ListRebuildReapply.SuppressNestedReapply)
		{
			return true;
		}
		try
		{
			ApplyPrioritySort(__instance, priorityOrder, resetScroll);
			return false;
		}
		catch (Exception ex)
		{
			UpgradeFilteringPlugin.Logger.LogError((object)("Priority sort prefix failed: " + ex.Message + "\n" + ex.StackTrace));
			return true;
		}
	}

	public static bool SortUpgradesMethodPublic_Prefix(GearDetailsWindow __instance, SortingMethod method)
	{
		if (!PrioritySortActive)
		{
			return true;
		}
		if (ListRebuildReapply.SuppressNestedReapply)
		{
			return true;
		}
		try
		{
			ApplyPrioritySort(__instance, priorityOrder);
			return false;
		}
		catch (Exception ex)
		{
			UpgradeFilteringPlugin.Logger.LogError((object)("Priority sort public prefix failed: " + ex.Message));
			return true;
		}
	}

	public static void Patch(Harmony harmony)
	{
		//IL_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Expected O, but got Unknown
		//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c3: Expected O, but got Unknown
		//IL_0118: Unknown result type (might be due to invalid IL or missing references)
		//IL_0126: Expected O, but got Unknown
		MethodInfo methodInfo = AccessTools.Method(typeof(GearDetailsWindow), "SortUpgrades", new Type[1] { typeof(int) }, (Type[])null);
		if (methodInfo != null)
		{
			harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(PriorityPatches), "SortUpgradesInt_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}
		else
		{
			UpgradeFilteringPlugin.Logger.LogWarning((object)"Could not find SortUpgrades(int).");
		}
		MethodInfo methodInfo2 = AccessTools.Method(typeof(GearDetailsWindow), "SortUpgrades", new Type[2]
		{
			typeof(SortingMethod),
			typeof(bool)
		}, (Type[])null);
		if (methodInfo2 != null)
		{
			harmony.Patch((MethodBase)methodInfo2, new HarmonyMethod(typeof(PriorityPatches), "SortUpgradesMethod_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			UpgradeFilteringPlugin.Logger.LogInfo((object)"Patched SortUpgrades(SortingMethod, bool) for sticky priority.");
			return;
		}
		MethodInfo methodInfo3 = AccessTools.Method(typeof(GearDetailsWindow), "SortUpgrades", new Type[1] { typeof(SortingMethod) }, (Type[])null);
		if (methodInfo3 != null)
		{
			harmony.Patch((MethodBase)methodInfo3, new HarmonyMethod(typeof(PriorityPatches), "SortUpgradesMethodPublic_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}
		else
		{
			UpgradeFilteringPlugin.Logger.LogWarning((object)"Could not find SortUpgrades(SortingMethod) — sticky priority may not hook vanilla sorts.");
		}
	}

	public static void TriggerPrioritySort(List<PriorityCriteria> order = null)
	{
		if (order != null && order.Count > 0)
		{
			priorityOrder = new List<PriorityCriteria>(order);
		}
		else
		{
			priorityOrder = LoadPriorityOrder();
		}
		PrioritySortActive = true;
		GearDetailsWindow val = ResolveWindow();
		if ((Object)(object)val == (Object)null)
		{
			UpgradeFilteringPlugin.Logger.LogWarning((object)"Priority sort: no GearDetailsWindow found — order saved; will apply next open.");
			return;
		}
		currentWindow = val;
		ApplyPrioritySort(val, priorityOrder);
	}

	public static GearDetailsWindow ResolveWindow()
	{
		if ((Object)(object)currentWindow != (Object)null)
		{
			try
			{
				if ((Object)(object)((Component)currentWindow).gameObject != (Object)null && ((Component)currentWindow).gameObject.activeInHierarchy)
				{
					return currentWindow;
				}
			}
			catch
			{
				currentWindow = null;
			}
		}
		GearDetailsWindow openWindow = FilterState.GetOpenWindow();
		if ((Object)(object)openWindow != (Object)null)
		{
			return openWindow;
		}
		try
		{
			return Object.FindObjectOfType<GearDetailsWindow>();
		}
		catch
		{
			return null;
		}
	}

	public static void ApplyPrioritySort(GearDetailsWindow window, bool resetScroll = true, bool skipDeferred = false)
	{
		ApplyPrioritySort(window, priorityOrder ?? LoadPriorityOrder(), resetScroll, skipDeferred);
	}

	public static void CancelDeferredLayout()
	{
		_deferredLayoutCancelled = true;
		try
		{
			if (_deferredLayoutCoroutine != null && (Object)(object)PriorityGUI.Instance != (Object)null)
			{
				((MonoBehaviour)PriorityGUI.Instance).StopCoroutine(_deferredLayoutCoroutine);
				_deferredLayoutCoroutine = null;
			}
		}
		catch
		{
		}
	}

	public static void ApplyPrioritySort(GearDetailsWindow window, List<PriorityCriteria> order, bool resetScroll = true, bool skipDeferred = false)
	{
		if ((Object)(object)window == (Object)null)
		{
			return;
		}
		PrioritySortActive = true;
		if (order != null && order.Count > 0)
		{
			priorityOrder = new List<PriorityCriteria>(order);
		}
		List<PriorityCriteria> list = FilterOrderForAvailableMods(priorityOrder);
		List<GearUpgradeUI> upgradeUIs = FilterState.GetUpgradeUIs();
		if (upgradeUIs == null || upgradeUIs.Count == 0)
		{
			UpgradeFilteringPlugin.Logger.LogWarning((object)"Priority sort: upgradeUIs empty.");
			return;
		}
		int num = FilterState.GetUpgradeUICount(window);
		if (num <= 0 || num > upgradeUIs.Count)
		{
			num = upgradeUIs.Count;
		}
		UpgradeFilteringPlugin.Logger.LogInfo((object)($"Sort begin (visual-only): window={((Object)window).name}, listCount={upgradeUIs.Count}, uiCount={num}, " + "criteria=[" + string.Join(" > ", list) + "]"));
		ActivateAllLiveSlots(upgradeUIs, num);
		if (!LogUniqueInstanceIds("BEFORE visual sort", upgradeUIs, num) && !TryRepairDuplicateUiRefs(window, upgradeUIs, num))
		{
			UpgradeFilteringPlugin.Logger.LogError((object)"Pool corrupt and repair failed — skip visual reorder; reopen gear window.");
			FilterState.ApplyVisibilityOnly(window);
			return;
		}
		FilterState.ApplyVisibilityOnly(window);
		ApplyVisualPriorityOrder(window, upgradeUIs, num, list);
		LogRowSnapshot("AFTER visual priority+filter", upgradeUIs, num);
		if (resetScroll)
		{
			try
			{
				typeof(GearDetailsWindow).GetMethod("SetUpgradeListScroll", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(float) }, null)?.Invoke(window, new object[1] { 1f });
			}
			catch (Exception ex)
			{
				UpgradeFilteringPlugin.Logger.LogWarning((object)("SetUpgradeListScroll failed: " + ex.Message));
			}
		}
		try
		{
			typeof(GearDetailsWindow).GetMethod("DisableSortButtonContainer", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null)?.Invoke(window, null);
		}
		catch
		{
		}
	}

	public static void ClearStalePoolSlots(List<GearUpgradeUI> upgradeUIs, int liveCount)
	{
		if (upgradeUIs == null)
		{
			return;
		}
		liveCount = Mathf.Max(0, liveCount);
		int num = 0;
		for (int i = liveCount; i < upgradeUIs.Count; i++)
		{
			GearUpgradeUI val = upgradeUIs[i];
			if ((Object)(object)val == (Object)null)
			{
				continue;
			}
			try
			{
				if (((Component)val).gameObject.activeSelf)
				{
					((Component)val).gameObject.SetActive(false);
				}
				if (((HoverInfoUpgrade)val).Upgrade != null)
				{
					((HoverInfoUpgrade)val).Upgrade = null;
					num++;
				}
			}
			catch
			{
				try
				{
					((Component)val).gameObject.SetActive(false);
				}
				catch
				{
				}
			}
		}
		if (num > 0)
		{
			UpgradeFilteringPlugin.Logger.LogInfo((object)$"ClearStalePoolSlots: cleared Upgrade on {num} slots past liveCount={liveCount}");
		}
	}

	public static bool TryRepairDuplicateUiRefs(GearDetailsWindow window, List<GearUpgradeUI> upgradeUIs, int count)
	{
		if (upgradeUIs == null || (Object)(object)window == (Object)null || count <= 0)
		{
			return true;
		}
		count = Mathf.Min(count, upgradeUIs.Count);
		HashSet<GearUpgradeUI> hashSet = new HashSet<GearUpgradeUI>();
		List<int> list = new List<int>();
		for (int i = 0; i < count; i++)
		{
			GearUpgradeUI val = upgradeUIs[i];
			if ((Object)(object)val == (Object)null)
			{
				list.Add(i);
			}
			else if (!hashSet.Add(val))
			{
				list.Add(i);
			}
		}
		if (list.Count == 0)
		{
			return true;
		}
		UpgradeFilteringPlugin.Logger.LogWarning((object)$"Repairing {list.Count} duplicate/null GearUpgradeUI refs in live pool.");
		Queue<GearUpgradeUI> queue = new Queue<GearUpgradeUI>();
		for (int j = 0; j < upgradeUIs.Count; j++)
		{
			GearUpgradeUI val2 = upgradeUIs[j];
			if (!((Object)(object)val2 == (Object)null) && !hashSet.Contains(val2))
			{
				queue.Enqueue(val2);
			}
		}
		RectTransform val3 = null;
		try
		{
			EnsureLayoutLookups();
			object? obj = _upgradeListParentField?.GetValue(window);
			val3 = (RectTransform)((obj is RectTransform) ? obj : null);
		}
		catch
		{
		}
		FieldInfo fieldInfo = null;
		try
		{
			fieldInfo = typeof(GearDetailsWindow).GetField("upgradeUIPrefab", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		}
		catch
		{
		}
		foreach (int item in list)
		{
			GearUpgradeUI obj4 = upgradeUIs[item];
			UpgradeInstance val4 = ((obj4 != null) ? ((HoverInfoUpgrade)obj4).Upgrade : null);
			GearUpgradeUI val5 = null;
			if (queue.Count > 0)
			{
				val5 = queue.Dequeue();
			}
			else if (fieldInfo != null && (Object)(object)val3 != (Object)null)
			{
				try
				{
					object? value = fieldInfo.GetValue(window);
					GearUpgradeUI val6 = (GearUpgradeUI)((value is GearUpgradeUI) ? value : null);
					if ((Object)(object)val6 != (Object)null)
					{
						val5 = Object.Instantiate<GearUpgradeUI>(val6, (Transform)(object)val3);
						upgradeUIs.Add(val5);
					}
				}
				catch (Exception ex)
				{
					UpgradeFilteringPlugin.Logger.LogWarning((object)("Instantiate repair UI failed: " + ex.Message));
				}
			}
			if ((Object)(object)val5 == (Object)null)
			{
				UpgradeFilteringPlugin.Logger.LogError((object)$"Could not repair duplicate at index {item}");
				return false;
			}
			upgradeUIs[item] = val5;
			hashSet.Add(val5);
			try
			{
				if (val4 != null)
				{
					((Component)val5).gameObject.SetActive(true);
					val5.SetUpgrade(val4, false);
					val5.EnableGridView(GetIsGridView(window));
				}
				else
				{
					((Component)val5).gameObject.SetActive(false);
				}
			}
			catch
			{
			}
		}
		return LogUniqueInstanceIds("AFTER pool ref repair", upgradeUIs, count);
	}

	public static void ActivateAllLiveSlots(List<GearUpgradeUI> upgradeUIs, int count)
	{
		if (upgradeUIs == null)
		{
			return;
		}
		count = Mathf.Min(count, upgradeUIs.Count);
		ClearStalePoolSlots(upgradeUIs, count);
		bool isGridView = GetIsGridView(currentWindow);
		int num = 0;
		for (int i = 0; i < count; i++)
		{
			GearUpgradeUI val = upgradeUIs[i];
			object obj;
			if (val == null)
			{
				obj = null;
			}
			else
			{
				UpgradeInstance upgrade = ((HoverInfoUpgrade)val).Upgrade;
				obj = ((upgrade != null) ? upgrade.Upgrade : null);
			}
			if ((Object)obj == (Object)null)
			{
				continue;
			}
			try
			{
				if (!((Component)val).gameObject.activeSelf)
				{
					((Component)val).gameObject.SetActive(true);
					num++;
				}
				val.EnableGridView(isGridView);
			}
			catch
			{
			}
		}
		UpgradeFilteringPlugin.Logger.LogInfo((object)$"ActivateAllLiveSlots: count={count}, reactivated={num}, isGrid={isGridView}");
	}

	public static void ApplyVisualPriorityOrder(GearDetailsWindow window, List<GearUpgradeUI> upgradeUIs, int count, List<PriorityCriteria> order)
	{
		if ((Object)(object)window == (Object)null || upgradeUIs == null)
		{
			return;
		}
		count = Mathf.Min(count, upgradeUIs.Count);
		List<(GearUpgradeUI, int[])> list = new List<(GearUpgradeUI, int[])>(count);
		for (int i = 0; i < count; i++)
		{
			GearUpgradeUI val = upgradeUIs[i];
			if ((Object)(object)val == (Object)null || !((Component)val).gameObject.activeSelf)
			{
				continue;
			}
			UpgradeInstance upgrade = ((HoverInfoUpgrade)val).Upgrade;
			if ((Object)(object)((upgrade != null) ? upgrade.Upgrade : null) == (Object)null || !FilterState.ShouldShow(val))
			{
				continue;
			}
			int[] array = new int[(order?.Count ?? 0) + 2];
			int num = 0;
			if (order != null)
			{
				foreach (PriorityCriteria item4 in order)
				{
					array[num++] = ScoreCriteria(val, item4);
				}
			}
			array[num++] = ((HoverInfoUpgrade)val).Upgrade.InstanceID;
			array[num] = -i;
			list.Add((val, array));
		}
		list.Sort(delegate((GearUpgradeUI ui, int[] keys) a, (GearUpgradeUI ui, int[] keys) b)
		{
			int[] item2 = a.keys;
			int[] item3 = b.keys;
			int num5 = Math.Min(item2.Length, item3.Length);
			for (int j = 0; j < num5; j++)
			{
				int num6 = item3[j].CompareTo(item2[j]);
				if (num6 != 0)
				{
					return num6;
				}
			}
			return 0;
		});
		EnsureLayoutLookups();
		bool isGridView = GetIsGridView(window);
		RectTransform listParent = null;
		try
		{
			object? obj = _upgradeListParentField?.GetValue(window);
			listParent = (RectTransform)((obj is RectTransform) ? obj : null);
		}
		catch
		{
		}
		for (int num2 = 0; num2 < count; num2++)
		{
			try
			{
				GearUpgradeUI obj3 = upgradeUIs[num2];
				if (obj3 != null)
				{
					((Component)obj3).transform.SetAsLastSibling();
				}
			}
			catch
			{
			}
		}
		for (int num3 = 0; num3 < list.Count; num3++)
		{
			GearUpgradeUI item = list[num3].Item1;
			try
			{
				((Component)item).transform.SetSiblingIndex(num3);
				item.EnableGridView(isGridView);
				SetUpgradeAnchoredPosition(item, num3, isGridView, listParent);
			}
			catch (Exception ex)
			{
				UpgradeFilteringPlugin.Logger.LogWarning((object)("Visual order place failed: " + ex.Message));
			}
		}
		int count2 = list.Count;
		for (int num4 = 0; num4 < count; num4++)
		{
			GearUpgradeUI val2 = upgradeUIs[num4];
			if (!((Object)(object)val2 == (Object)null) && !((Component)val2).gameObject.activeSelf)
			{
				try
				{
					((Component)val2).transform.SetSiblingIndex(count2++);
				}
				catch
				{
				}
			}
		}
		try
		{
			Canvas.ForceUpdateCanvases();
		}
		catch
		{
		}
		UpgradeFilteringPlugin.Logger.LogInfo((object)$"Visual priority order: visiblePlaced={list.Count}, isGrid={isGridView}");
	}

	private static IEnumerator DeferredLayout(GearDetailsWindow window)
	{
		yield return null;
		_deferredLayoutCoroutine = null;
		if (_deferredLayoutCancelled || (Object)(object)window == (Object)null)
		{
			yield break;
		}
		try
		{
			if (FilterState.HasActiveFilters() || PrioritySortActive)
			{
				FilterState.ApplyToWindow(window);
			}
			else
			{
				List<GearUpgradeUI> upgradeUIs = FilterState.GetUpgradeUIs();
				int num = FilterState.GetUpgradeUICount(window);
				if (upgradeUIs == null)
				{
					yield break;
				}
				if (num <= 0 || num > upgradeUIs.Count)
				{
					num = upgradeUIs.Count;
				}
				ForceLayout(window, upgradeUIs, num);
			}
			UpgradeFilteringPlugin.Logger.LogInfo((object)"Deferred layout pass complete.");
		}
		catch (Exception ex)
		{
			UpgradeFilteringPlugin.Logger.LogWarning((object)("Deferred layout failed: " + ex.Message));
		}
	}

	internal static void LogRowSnapshot(string label, List<GearUpgradeUI> upgradeUIs, int count)
	{
		//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
		//IL_0163: Unknown result type (might be due to invalid IL or missing references)
		//IL_0080: Unknown result type (might be due to invalid IL or missing references)
		//IL_0085: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(label).Append(':');
			int num = 0;
			for (int i = 0; i < count; i++)
			{
				if (num >= 6)
				{
					break;
				}
				GearUpgradeUI val = upgradeUIs[i];
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				string value = "?";
				string value2 = "?";
				try
				{
					UpgradeInstance upgrade = ((HoverInfoUpgrade)val).Upgrade;
					if ((Object)(object)((upgrade != null) ? upgrade.Upgrade : null) != (Object)null)
					{
						value = ((HoverInfoUpgrade)val).Upgrade.Upgrade.Name ?? "?";
						value2 = ((object)((HoverInfoUpgrade)val).Upgrade.Upgrade.Rarity/*cast due to .constrained prefix*/).ToString();
					}
				}
				catch
				{
				}
				Transform transform = ((Component)val).transform;
				RectTransform val2 = (RectTransform)(object)((transform is RectTransform) ? transform : null);
				Vector2 val3 = (((Object)(object)val2 != (Object)null) ? val2.anchoredPosition : Vector2.zero);
				int siblingIndex = ((Component)val).transform.GetSiblingIndex();
				string value3 = (((Object)(object)((Component)val).transform.parent != (Object)null) ? ((Object)((Component)val).transform.parent).name : "null");
				stringBuilder.Append("\n  [").Append(i).Append("] ")
					.Append(value2)
					.Append(" | ")
					.Append(value)
					.Append(" | active=")
					.Append(((Component)val).gameObject.activeSelf)
					.Append(" | sib=")
					.Append(siblingIndex)
					.Append(" | pos=")
					.Append(val3)
					.Append(" | parent=")
					.Append(value3);
				num++;
			}
			UpgradeFilteringPlugin.Logger.LogInfo((object)stringBuilder.ToString());
		}
		catch (Exception ex)
		{
			UpgradeFilteringPlugin.Logger.LogWarning((object)("LogRowSnapshot failed: " + ex.Message));
		}
	}

	private static void EnsureLayoutLookups()
	{
		if (!_layoutLookupsDone)
		{
			_layoutLookupsDone = true;
			Type? typeFromHandle = typeof(GearDetailsWindow);
			_isGridViewField = typeFromHandle.GetField("isGridView", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			_upgradeListParentField = typeFromHandle.GetField("upgradeListParent", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			UpgradeFilteringPlugin.Logger.LogInfo((object)($"Layout lookups: isGridView={_isGridViewField != null}, " + $"listParent={_upgradeListParentField != null}"));
		}
	}

	internal static bool GetIsGridView(GearDetailsWindow window)
	{
		EnsureLayoutLookups();
		try
		{
			if (_isGridViewField == null)
			{
				return false;
			}
			return _isGridViewField.IsStatic ? ((bool)_isGridViewField.GetValue(null)) : ((bool)_isGridViewField.GetValue(window));
		}
		catch
		{
			return false;
		}
	}

	internal static void ForceLayout(GearDetailsWindow window, List<GearUpgradeUI> upgradeUIs, int count)
	{
		//IL_0105: Unknown result type (might be due to invalid IL or missing references)
		//IL_0288: Unknown result type (might be due to invalid IL or missing references)
		//IL_013d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0142: 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_0355: Unknown result type (might be due to invalid IL or missing references)
		//IL_035e: Unknown result type (might be due to invalid IL or missing references)
		if (upgradeUIs == null || (Object)(object)window == (Object)null)
		{
			return;
		}
		count = Mathf.Min(count, upgradeUIs.Count);
		EnsureLayoutLookups();
		bool flag = false;
		try
		{
			if (_isGridViewField != null)
			{
				flag = (_isGridViewField.IsStatic ? ((bool)_isGridViewField.GetValue(null)) : ((bool)_isGridViewField.GetValue(window)));
			}
		}
		catch (Exception ex)
		{
			UpgradeFilteringPlugin.Logger.LogWarning((object)("isGridView read failed: " + ex.Message));
		}
		RectTransform val = null;
		try
		{
			object? obj = _upgradeListParentField?.GetValue(window);
			val = (RectTransform)((obj is RectTransform) ? obj : null);
		}
		catch (Exception ex2)
		{
			UpgradeFilteringPlugin.Logger.LogWarning((object)("upgradeListParent read failed: " + ex2.Message));
		}
		string text = null;
		try
		{
			if (count > 0)
			{
				GearUpgradeUI obj2 = upgradeUIs[0];
				object obj3;
				if (obj2 == null)
				{
					obj3 = null;
				}
				else
				{
					UpgradeInstance upgrade = ((HoverInfoUpgrade)obj2).Upgrade;
					obj3 = ((upgrade != null) ? upgrade.Upgrade : null);
				}
				if ((Object)obj3 != (Object)null)
				{
					text = ((HoverInfoUpgrade)upgradeUIs[0]).Upgrade.Upgrade.Name;
				}
			}
		}
		catch
		{
		}
		Vector2 val2 = default(Vector2);
		if (count > 0 && (Object)(object)upgradeUIs[0] != (Object)null)
		{
			Transform transform = ((Component)upgradeUIs[0]).transform;
			RectTransform val3 = (RectTransform)(object)((transform is RectTransform) ? transform : null);
			if ((Object)(object)val3 != (Object)null)
			{
				val2 = val3.anchoredPosition;
			}
		}
		for (int i = 0; i < count; i++)
		{
			GearUpgradeUI val4 = upgradeUIs[i];
			if (!((Object)(object)val4 == (Object)null))
			{
				try
				{
					((Component)val4).transform.SetAsLastSibling();
				}
				catch
				{
				}
			}
		}
		int num = 0;
		for (int j = 0; j < count; j++)
		{
			GearUpgradeUI val5 = upgradeUIs[j];
			if ((Object)(object)val5 == (Object)null)
			{
				continue;
			}
			try
			{
				((Component)val5).transform.SetSiblingIndex(j);
			}
			catch (Exception ex3)
			{
				UpgradeFilteringPlugin.Logger.LogWarning((object)$"Sibling set failed @ {j}: {ex3.Message}");
			}
			if (((Component)val5).gameObject.activeSelf)
			{
				try
				{
					val5.EnableGridView(flag);
					SetUpgradeAnchoredPosition(val5, num, flag, val);
				}
				catch (Exception ex4)
				{
					UpgradeFilteringPlugin.Logger.LogWarning((object)$"Inline pos failed @ {j}: {ex4.Message}");
				}
				num++;
			}
		}
		try
		{
			Canvas.ForceUpdateCanvases();
		}
		catch
		{
		}
		string text2 = null;
		try
		{
			if (count > 0)
			{
				GearUpgradeUI obj7 = upgradeUIs[0];
				object obj8;
				if (obj7 == null)
				{
					obj8 = null;
				}
				else
				{
					UpgradeInstance upgrade2 = ((HoverInfoUpgrade)obj7).Upgrade;
					obj8 = ((upgrade2 != null) ? upgrade2.Upgrade : null);
				}
				if ((Object)obj8 != (Object)null)
				{
					text2 = ((HoverInfoUpgrade)upgradeUIs[0]).Upgrade.Upgrade.Name;
				}
			}
		}
		catch
		{
		}
		Vector2 val6 = default(Vector2);
		if (count > 0 && (Object)(object)upgradeUIs[0] != (Object)null)
		{
			Transform transform2 = ((Component)upgradeUIs[0]).transform;
			RectTransform val7 = (RectTransform)(object)((transform2 is RectTransform) ? transform2 : null);
			if ((Object)(object)val7 != (Object)null)
			{
				val6 = val7.anchoredPosition;
			}
		}
		if (text != null && text2 != null && text != text2)
		{
			UpgradeFilteringPlugin.Logger.LogError((object)("ForceLayout mutated list head! '" + text + "' -> '" + text2 + "'"));
		}
		UpgradeFilteringPlugin.Logger.LogInfo((object)(string.Format("ForceLayout done: isGrid={0}, listParent={1}, ", flag, ((Object)(object)val != (Object)null) ? ((Object)val).name : "null") + $"visiblePlaced={num}, head={text2}, firstPos {val2} -> {val6}"));
	}

	private static void SetUpgradeAnchoredPosition(GearUpgradeUI ui, int index, bool isGrid, RectTransform listParent)
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Expected O, but got Unknown
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
		//IL_0100: Unknown result type (might be due to invalid IL or missing references)
		//IL_0105: Unknown result type (might be due to invalid IL or missing references)
		//IL_010d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0114: 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_012b: Unknown result type (might be due to invalid IL or missing references)
		//IL_014b: Unknown result type (might be due to invalid IL or missing references)
		//IL_007e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_009a: Unknown result type (might be due to invalid IL or missing references)
		//IL_009f: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
		RectTransform val = (RectTransform)((Component)ui).transform;
		Rect rect = val.rect;
		float num;
		if (!(((Rect)(ref rect)).height > 1f))
		{
			num = 52f;
		}
		else
		{
			rect = val.rect;
			num = ((Rect)(ref rect)).height;
		}
		float num2 = num;
		rect = val.rect;
		float num3;
		if (!(((Rect)(ref rect)).width > 1f))
		{
			num3 = 300f;
		}
		else
		{
			rect = val.rect;
			num3 = ((Rect)(ref rect)).width;
		}
		float num4 = num3;
		if (isGrid && (Object)(object)listParent != (Object)null)
		{
			float num5 = num4 + 10f;
			rect = listParent.rect;
			float num6;
			if (!(((Rect)(ref rect)).width > 1f))
			{
				num6 = 400f;
			}
			else
			{
				rect = listParent.rect;
				num6 = ((Rect)(ref rect)).width;
			}
			int num7 = Mathf.Max(Mathf.FloorToInt((num6 - 6f) / num5), 1);
			float num8 = 3f + (float)(index % num7) * (num4 + 10f);
			float num9 = -3f - (float)(index / num7) * (num2 + 10f);
			val.anchoredPosition = new Vector2(num8, num9);
		}
		else
		{
			Vector2 offsetMin = val.offsetMin;
			Vector2 offsetMax = val.offsetMax;
			val.offsetMin = new Vector2(0f, offsetMin.y);
			val.offsetMax = new Vector2(0f, offsetMax.y);
			val.anchoredPosition = new Vector2(0f, -3f - (num2 + 4f) * (float)index);
		}
	}

	public static List<PriorityCriteria> FilterOrderForAvailableMods(List<PriorityCriteria> order)
	{
		if (order == null)
		{
			return new List<PriorityCriteria>();
		}
		List<PriorityCriteria> list = new List<PriorityCriteria>(order.Count);
		bool flag = IsBatchScrappingPresent();
		foreach (PriorityCriteria item in order)
		{
			if (flag || (item != PriorityCriteria.Trashed && item != PriorityCriteria.NotTrashed))
			{
				list.Add(item);
			}
		}
		return MigrateTotalKeysAfterRarities(list);
	}

	public static List<PriorityCriteria> MigrateTotalKeysAfterRarities(List<PriorityCriteria> order)
	{
		if (order == null || order.Count == 0)
		{
			return order ?? new List<PriorityCriteria>();
		}
		int num = -1;
		int num2 = -1;
		for (int i = 0; i < order.Count; i++)
		{
			if (IsRarity(order[i]))
			{
				if (num < 0)
				{
					num = i;
				}
				num2 = i;
			}
		}
		if (num < 0)
		{
			return order;
		}
		bool flag = false;
		for (int j = 0; j < order.Count; j++)
		{
			if (IsTotalKey(order[j]) && j < num2)
			{
				flag = true;
				break;
			}
		}
		if (!flag)
		{
			return order;
		}
		List<PriorityCriteria> list = new List<PriorityCriteria>(order.Count);
		List<PriorityCriteria> list2 = new List<PriorityCriteria>(4);
		foreach (PriorityCriteria item in order)
		{
			if (IsTotalKey(item))
			{
				list2.Add(item);
			}
			else
			{
				list.Add(item);
			}
		}
		list.AddRange(list2);
		UpgradeFilteringPlugin.Logger.LogInfo((object)"Migrated sort order: moved Name/Recently* after rarities so rarity criteria apply.");
		return list;
		static bool IsRarity(PriorityCriteria c)
		{
			if ((uint)(c - 7) <= 4u)
			{
				return true;
			}
			return false;
		}
		static bool IsTotalKey(PriorityCriteria c)
		{
			if ((uint)(c - 4) <= 2u)
			{
				return true;
			}
			return false;
		}
	}

	public static bool TryDecorateSortLiveSlice(List<GearUpgradeUI> upgradeUIs, int count, List<PriorityCriteria> order)
	{
		if (upgradeUIs == null || count <= 0)
		{
			return true;
		}
		count = Mathf.Min(count, upgradeUIs.Count);
		int num = count;
		SortEntry[] array = new SortEntry[num];
		int num2 = (order?.Count ?? 0) + 2;
		for (int i = 0; i < num; i++)
		{
			GearUpgradeUI val = upgradeUIs[i];
			int[] array2 = new int[num2];
			int num3 = 0;
			if (order != null)
			{
				foreach (PriorityCriteria item in order)
				{
					array2[num3++] = ScoreCriteria(val, item);
				}
			}
			array2[num3++] = ((((val != null) ? ((HoverInfoUpgrade)val).Upgrade : null) != null) ? ((HoverInfoUpgrade)val).Upgrade.InstanceID : int.MinValue);
			array2[num3] = -i;
			array[i] = new SortEntry
			{
				Ui = val,
				Keys = array2
			};
		}
		Array.Sort(array, SortEntryComparer.Instance);
		HashSet<int> hashSet = new HashSet<int>();
		HashSet<int> hashSet2 = new HashSet<int>();
		for (int j = 0; j < num; j++)
		{
			GearUpgradeUI obj = upgradeUIs[j];
			if (((obj != null) ? ((HoverInfoUpgrade)obj).Upgrade : null) != null)
			{
				hashSet.Add(((HoverInfoUpgrade)upgradeUIs[j]).Upgrade.InstanceID);
			}
			GearUpgradeUI ui = array[j].Ui;
			if (((ui != null) ? ((HoverInfoUpgrade)ui).Upgrade : null) != null)
			{
				hashSet2.Add(((HoverInfoUpgrade)array[j].Ui).Upgrade.InstanceID);
			}
		}
		if (hashSet.Count != hashSet2.Count || !hashSet.SetEquals(hashSet2))
		{
			UpgradeFilteringPlugin.Logger.LogError((object)$"Decorate-sort validation failed: beforeIds={hashSet.Count} afterIds={hashSet2.Count}");
			return false;
		}
		HashSet<GearUpgradeUI> hashSet3 = new HashSet<GearUpgradeUI>();
		for (int k = 0; k < num; k++)
		{
			GearUpgradeUI ui2 = array[k].Ui;
			if (!((Object)(object)ui2 == (Object)null) && !hashSet3.Add(ui2))
			{
				UpgradeFilteringPlugin.Logger.LogError((object)"Decorate-sort validation failed: duplicate GearUpgradeUI reference.");
				return false;
			}
		}
		for (int l = 0; l < num; l++)
		{
			upgradeUIs[l] = array[l].Ui;
		}
		return true;
	}

	private static int ScoreCriteria(GearUpgradeUI ui, PriorityCriteria criteria)
	{
		//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fc: Invalid comparison between Unknown and I4
		//IL_0105: Unknown result type (might be due to invalid IL or missing references)
		//IL_010b: Invalid comparison between Unknown and I4
		//IL_0114: Unknown result type (might be due to invalid IL or missing references)
		//IL_011a: Invalid comparison between Unknown and I4
		//IL_0123: Unknown result type (might be due to invalid IL or missing references)
		//IL_0129: Invalid comparison between Unknown and I4
		//IL_0132: Unknown result type (might be due to invalid IL or missing references)
		//IL_0138: Invalid comparison between Unknown and I4
		UpgradeInstance val = ((ui != null) ? ((HoverInfoUpgrade)ui).Upgrade : null);
		if ((Object)(object)((val != null) ? val.Upgrade : null) == (Object)null)
		{
			return int.MinValue;
		}
		return criteria switch
		{
			PriorityCriteria.Favorited => val.Favorite ? 1 : 0, 
			PriorityCriteria.NotFavorited => (!val.Favorite) ? 1 : 0, 
			PriorityCriteria.Unlocked => val.IsUnlocked ? 1 : 0, 
			PriorityCriteria.Locked => (!val.IsUnlocked) ? 1 : 0, 
			PriorityCriteria.Turbocharged => val.IsTurbocharged ? 1 : 0, 
			PriorityCriteria.NotTurbocharged => (!val.IsTurbocharged) ? 1 : 0, 
			PriorityCriteria.Trashed => (!IsTrashMarked(val)) ? 1 : 0, 
			PriorityCriteria.NotTrashed => (!IsTrashMarked(val)) ? 1 : 0, 
			PriorityCriteria.RecentlyAcquired => (int)Math.Max(-2147483648L, Math.Min(2147483647L, val.TimeUnlocked)), 
			PriorityCriteria.RecentlyUsed => (int)(val.TimeUnequipped * 1000f), 
			PriorityCriteria.InstanceName => 0, 
			PriorityCriteria.Oddity => ((int)val.Upgrade.Rarity == 4) ? 1 : 0, 
			PriorityCriteria.Exotic => ((int)val.Upgrade.Rarity == 3) ? 1 : 0, 
			PriorityCriteria.Epic => ((int)val.Upgrade.Rarity == 2) ? 1 : 0, 
			PriorityCriteria.Rare => ((int)val.Upgrade.Rarity == 1) ? 1 : 0, 
			PriorityCriteria.Standard => ((int)val.Upgrade.Rarity == 0) ? 1 : 0, 
			_ => 0, 
		};
	}

	public static Comparison<GearUpgradeUI> GetPriorityComparison(List<PriorityCriteria> order)
	{
		return delegate(GearUpgradeUI a, GearUpgradeUI b)
		{
			if (a == b)
			{
				return 0;
			}
			if ((Object)(object)a == (Object)null)
			{
				return 1;
			}
			if ((Object)(object)b == (Object)null)
			{
				return -1;
			}
			if (((HoverInfoUpgrade)a).Upgrade == null && ((HoverInfoUpgrade)b).Upgrade == null)
			{
				return 0;
			}
			if (((HoverInfoUpgrade)a).Upgrade == null)
			{
				return 1;
			}
			if (((HoverInfoUpgrade)b).Upgrade == null)
			{
				return -1;
			}
			if ((Object)(object)((HoverInfoUpgrade)a).Upgrade.Upgrade == (Object)null && (Object)(object)((HoverInfoUpgrade)b).Upgrade.Upgrade == (Object)null)
			{
				return 0;
			}
			if ((Object)(object)((HoverInfoUpgrade)a).Upgrade.Upgrade == (Object)null)
			{
				return 1;
			}
			if ((Object)(object)((HoverInfoUpgrade)b).Upgrade.Upgrade == (Object)null)
			{
				return -1;
			}
			if (order != null)
			{
				foreach (PriorityCriteria item in order)
				{
					int value = ScoreCriteria(a, item);
					int num = ScoreCriteria(b, item).CompareTo(value);
					if (num != 0)
					{
						return num;
					}
				}
			}
			return ((HoverInfoUpgrade)a).Upgrade.InstanceID.CompareTo(((HoverInfoUpgrade)b).Upgrade.InstanceID);
		};
	}

	public static bool LogUniqueInstanceIds(string label, List<GearUpgradeUI> upgradeUIs, int count)
	{
		try
		{
			HashSet<int> hashSet = new HashSet<int>();
			int num = 0;
			for (int i = 0; i < count; i++)
			{
				GearUpgradeUI val = upgradeUIs[i];
				if (((val != null) ? ((HoverInfoUpgrade)val).Upgrade : null) == null)
				{
					num++;
				}
				else
				{
					hashSet.Add(((HoverInfoUpgrade)val).Upgrade.InstanceID);
				}
			}
			if (hashSet.Count + num != count)
			{
				UpgradeFilteringPlugin.Logger.LogError((object)$"{label}: LIST CORRUPTION uniqueIds={hashSet.Count} nulls={num} count={count}");
				return false;
			}
			UpgradeFilteringPlugin.Logger.LogInfo((object)$"{label}: uniqueIds={hashSet.Count} nulls={num} count={count} OK");
			return true;
		}
		catch (Exception ex)
		{
			UpgradeFilteringPlugin.Logger.LogWarning((object)("LogUniqueInstanceIds failed: " + ex.Message));
			return false;
		}
	}

	public static void ForceLayoutVisibleOnly(GearDetailsWindow window, List<GearUpgradeUI> upgradeUIs, int count)
	{
		if ((Object)(object)window == (Object)null || upgradeUIs == null)
		{
			return;
		}
		count = Mathf.Min(count, upgradeUIs.Count);
		EnsureLayoutLookups();
		bool isGridView = GetIsGridView(window);
		RectTransform listParent = null;
		try
		{
			object? obj = _upgradeListParentField?.GetValue(window);
			listParent = (RectTransform)((obj is RectTransform) ? obj : null);
		}
		catch
		{
		}
		int num = 0;
		for (int i = 0; i < count; i++)
		{
			GearUpgradeUI val = upgradeUIs[i];
			if (!((Object)(object)val == (Object)null) && ((Component)val).gameObject.activeSelf)
			{
				try
				{
					((Component)val).transform.SetSiblingIndex(num);
					val.EnableGridView(isGridView);
					SetUpgradeAnchoredPosition(val, num, isGridView, listParent);
					num++;
				}
				catch
				{
				}
			}
		}
		try
		{
			Canvas.ForceUpdateCanvases();
		}
		catch
		{
		}
		UpgradeFilteringPlugin.Logger.LogInfo((object)$"ForceLayoutVisibleOnly: visiblePlaced={num}, isGrid={isGridView}");
	}

	public static int CompareByCriteria(GearUpgradeUI a, GearUpgradeUI b, PriorityCriteria criteria)
	{
		//IL_0266: Unknown result type (might be due to invalid IL or missing references)
		//IL_026c: Invalid comparison between Unknown and I4
		//IL_027c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0282: Invalid comparison between Unknown and I4
		//IL_0296: Unknown result type (might be due to invalid IL or missing references)
		//IL_029c: Invalid comparison between Unknown and I4
		//IL_02ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_02b2: Invalid comparison between Unknown and I4
		//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
		//IL_02cc: Invalid comparison between Unknown and I4
		//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_02e2: Invalid comparison between Unknown and I4
		//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
		//IL_02fc: Invalid comparison between Unknown and I4
		//IL_030c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0312: Invalid comparison between Unknown and I4
		//IL_0326: Unknown result type (might be due to invalid IL or missing references)
		//IL_032c: Invalid comparison between Unknown and I4
		//IL_033c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0342: Invalid comparison between Unknown and I4
		switch (criteria)
		{
		case PriorityCriteria.Favorited:
			return -(((HoverInfoUpgrade)a).Upgrade.Favorite ? 1 : 0).CompareTo(((HoverInfoUpgrade)b).Upgrade.Favorite ? 1 : 0);
		case PriorityCriteria.NotFavorited:
			return -((!((HoverInfoUpgrade)a).Upgrade.Favorite) ? 1 : 0).CompareTo((!((HoverInfoUpgrade)b).Upgrade.Favorite) ? 1 : 0);
		case PriorityCriteria.Unlocked:
			return -((HoverInfoUpgrade)a).Upgrade.IsUnlocked.CompareTo(((HoverInfoUpgrade)b).Upgrade.IsUnlocked);
		case PriorityCriteria.Locked:
			return -((!((HoverInfoUpgrade)a).Upgrade.IsUnlocked) ? 1 : 0).CompareTo((!((HoverInfoUpgrade)b).Upgrade.IsUnlocked) ? 1 : 0);
		case PriorityCriteria.Turbocharged:
		{
			bool isTurbocharged = ((HoverInfoUpgrade)a).Upgrade.IsTurbocharged;
			bool isTurbocharged2 = ((HoverInfoUpgrade)b).Upgrade.IsTurbocharged;
			return -(isTurbocharged ? 1 : 0).CompareTo(isTurbocharged2 ? 1 : 0);
		}
		case PriorityCriteria.Trashed:
		{
			if (!IsBatchScrappingPresent())
			{
				return 0;
			}
			bool num = IsTrashMarked(((HoverInfoUpgrade)a).Upgrade);
			bool flag = IsTrashMarked(((HoverInfoUpgrade)b).Upgrade);
			return (num ? 1 : 0).CompareTo(flag ? 1 : 0);
		}
		case PriorityCriteria.NotTurbocharged:
		{
			bool num3 = !((HoverInfoUpgrade)a).Upgrade.IsTurbocharged;
			bool flag3 = !((HoverInfoUpgrade)b).Upgrade.IsTurbocharged;
			return -(num3 ? 1 : 0).CompareTo(flag3 ? 1 : 0);
		}
		case PriorityCriteria.NotTrashed:
		{
			if (!IsBatchScrappingPresent())
			{
				return 0;
			}
			bool num2 = !IsTrashMarked(((HoverInfoUpgrade)a).Upgrade);
			bool flag2 = !IsTrashMarked(((HoverInfoUpgrade)b).Upgrade);
			return -(num2 ? 1 : 0).CompareTo(flag2 ? 1 : 0);
		}
		case PriorityCriteria.RecentlyAcquired:
			return -((HoverInfoUpgrade)a).Upgrade.TimeUnlocked.CompareTo(((HoverInfoUpgrade)b).Upgrade.TimeUnlocked);
		case PriorityCriteria.RecentlyUsed:
			return -((HoverInfoUpgrade)a).Upgrade.TimeUnequipped.CompareTo(((HoverInfoUpgrade)b).Upgrade.TimeUnequipped);
		case PriorityCriteria.InstanceName:
		{
			string text = ((HoverInfoUpgrade)a).Upgrade.Upgrade.GetInstanceName(((HoverInfoUpgrade)a).Upgrade.Seed);
			if (string.IsNullOrEmpty(text))
			{
				text = ((HoverInfoUpgrade)a).Upgrade.Upgrade.Name;
			}
			string text2 = ((HoverInfoUpgrade)b).Upgrade.Upgrade.GetInstanceName(((HoverInfoUpgrade)b).Upgrade.Seed);
			if (string.IsNullOrEmpty(text2))
			{
				text2 = ((HoverInfoUpgrade)b).Upgrade.Upgrade.Name;
			}
			return string.Compare(text, text2, StringComparison.Ordinal);
		}
		case PriorityCriteria.Oddity:
			return -(((int)((HoverInfoUpgrade)a).Upgrade.Upgrade.Rarity == 4) ? 1 : 0).CompareTo(((int)((HoverInfoUpgrade)b).Upgrade.Upgrade.Rarity == 4) ? 1 : 0);
		case PriorityCriteria.Exotic:
			return -(((int)((HoverInfoUpgrade)a).Upgrade.Upgrade.Rarity == 3) ? 1 : 0).CompareTo(((int)((HoverInfoUpgrade)b).Upgrade.Upgrade.Rarity == 3) ? 1 : 0);
		case PriorityCriteria.Epic:
			return -(((int)((HoverInfoUpgrade)a).Upgrade.Upgrade.Rarity == 2) ? 1 : 0).CompareTo(((int)((HoverInfoUpgrade)b).Upgrade.Upgrade.Rarity == 2) ? 1 : 0);
		case PriorityCriteria.Rare:
			return -(((int)((HoverInfoUpgrade)a).Upgrade.Upgrade.Rarity == 1) ? 1 : 0).CompareTo(((int)((HoverInfoUpgrade)b).Upgrade.Upgrade.Rarity == 1) ? 1 : 0);
		case PriorityCriteria.Standard:
			return -(((int)((HoverInfoUpgrade)a).Upgrade.Upgrade.Rarity == 0) ? 1 : 0).CompareTo(((int)((HoverInfoUpgrade)b).Upgrade.Upgrade.Rarity == 0) ? 1 : 0);
		default:
			return 0;
		}
	}

	public static List<PriorityCriteria> LoadPriorityOrder()
	{
		try
		{
			string json = default(string);
			if (PlayerOptions.TryGetConfig<string>("SortPriority.Order", ref json))
			{
				try
				{
					PriorityData priorityData = PriorityData.FromJson(json);
					List<PriorityCriteria> list = new List<PriorityCriteria>();
					if (priorityData?.order != null)
					{
						foreach (int item in priorityData.order)
						{
							if (Enum.IsDefined(typeof(PriorityCriteria), item))
							{
								list.Add((PriorityCriteria)item);
							}
						}
					}
					if (list.Count > 0)
					{
						return FilterOrderForAvailableMods(list);
					}
				}
				catch (Exception ex)
				{
					UpgradeFilteringPlugin.Logger.LogWarning((object)("Failed to parse priority order from config, using defaults: " + ex.Message));
				}
			}
			return FilterOrderForAvailableMods(new PriorityData().order.ConvertAll((int i) => (PriorityCriteria)i));
		}
		catch (Exception ex2)
		{
			UpgradeFilteringPlugin.Logger.LogError((object)("Critical error loading priority order: " + ex2.Message));
			return FilterOrderForAvailableMods(new PriorityData().order.ConvertAll((int i) => (PriorityCriteria)i));
		}
	}

	public static void SavePriorityOrder(List<PriorityCriteria> order)
	{
		try
		{
			if (order != null)
			{
				priorityOrder = new List<PriorityCriteria>(order);
				string text = new PriorityData
				{
					order = order.ConvertAll((PriorityCriteria c) => (int)c)
				}.ToJson();
				PlayerOptions.SetConfig<string>("SortPriority.Order", text);
				UpgradeFilteringPlugin.Logger.LogInfo((object)$"Saved priority order ({order.Count} criteria).");
			}
		}
		catch (Exception ex)
		{
			UpgradeFilteringPlugin.Logger.LogError((object)("Failed to save priority order: " + ex.Message));
		}
	}
}
public static class StatFormatHandling
{
	public static bool enableStatReformat = true;

	public static void Initialize()
	{
	}

	public static void ReformatStats(Upgrade __instance, ref string text)
	{
		if (!enableStatReformat || string.IsNullOrEmpty(text))
		{
			return;
		}
		try
		{
			string[] array = text.Split(new string[2] { "\r\n", "\n" }, StringSplitOptions.RemoveEmptyEntries);
			StringBuilder stringBuilder = new StringBuilder();
			string[] array2 = array;
			foreach (string text2 in array2)
			{
				string text3 = text2.Trim();
				if (string.IsNullOrWhiteSpace(text3))
				{
					stringBuilder.AppendLine();
					continue;
				}
				string input = Regex.Replace(text3, "<[^>]*>", "");
				if (Regex.IsMatch(input, "^[-+]?\\d"))
				{
					Match match = Regex.Match(input, "^([-+]?\\d+(?:\\.\\d+)?[%s]?)\\s*(.+)$");
					if (match.Success)
					{
						string value = match.Groups[1].Value;
						string text4 = match.Groups[2].Value.Trim();
						if (!string.IsNullOrEmpty(text4))
						{
							string value2 = text4 + ": <b>" + value + "</b>";
							stringBuilder.AppendLine(value2);
							continue;
						}
					}
				}
				stringBuilder.AppendLine(text2);
			}
			text = stringBuilder.ToString().TrimEnd();
		}
		catch (Exception)
		{
		}
	}

	public static void ReformatUIText(TextMeshProUGUI textComponent, string fieldName = "text")
	{
		if (!enableStatReformat || (Object)(object)textComponent == (Object)null)
		{
			return;
		}
		string text = ((TMP_Text)textComponent).text;
		if (string.IsNullOrEmpty(text))
		{
			return;
		}
		try
		{
			string[] array = text.Split(new string[2] { "\r\n", "\n" }, StringSplitOptions.RemoveEmptyEntries);
			StringBuilder stringBuilder = new StringBuilder();
			string[] array2 = array;
			foreach (string text2 in array2)
			{
				string text3 = text2.Trim();
				if (string.IsNullOrWhiteSpace(text3))
				{
					stringBuilder.AppendLine();
					continue;
				}
				string input = Regex.Replace(text3, "<[^>]*>", "");
				if (Regex.IsMatch(input, "^[-+]?\\d"))
				{
					Match match = Regex.Match(input, "^([-+]?\\d+(?:\\.\\d+)?[%s]?)\\s*(.+)$");
					if (match.Success)
					{
						string value = match.Groups[1].Value;
						string text4 = match.Groups[2].Value.Trim();
						if (!string.IsNullOrEmpty(text4))
						{
							string value2 = text4 + ": <b>" + value + "</b>";
							stringBuilder.AppendLine(value2);
							continue;
						}
					}
				}
				stringBuilder.AppendLine(text2);
			}
			string text5 = stringBuilder.ToString().TrimEnd();
			((TMP_Text)textComponent).text = text5;
			((TMP_Text)textComponent).ForceMeshUpdate(false, false);
		}
		catch (Exception)
		{
		}
	}
}
[HarmonyPatch(typeof(Upgrade), "GetStatList")]
public static class StatListReformatPatch
{
	private static void Postfix(Upgrade __instance, int seed, ref string __result)
	{
		StatFormatHandling.ReformatStats(__instance, ref __result);
	}
}
[HarmonyPatch(typeof(HoverInfoDisplay), "Activate")]
public static class HoverInfoDisplayReformatPatch
{
	private static void Postfix(HoverInfoDisplay __instance, HoverInfo info, bool resetPosition)
	{
		//IL_004e: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: Expected O, but got Unknown
		//IL_0082: Unknown result type (might be due to invalid IL or missing references)
		//IL_0091: Expected O, but got Unknown
		if (!StatFormatHandling.enableStatReformat || (Object)(object)info == (Object)null || ((object)info).GetType().Name == "DirectiveButton")
		{
			return;
		}
		try
		{
			FieldInfo fieldInfo = AccessTools.Field(typeof(HoverInfoDisplay), "text");
			if (fieldInfo != null)
			{
				StatFormatHandling.ReformatUIText((TextMeshProUGUI)fieldInfo.GetValue(__instance), "main text");
			}
			FieldInfo fieldInfo2 = AccessTools.Field(typeof(HoverInfoDisplay), "statsText");
			if (fieldInfo2 != null)
			{
				StatFormatHandling.ReformatUIText((TextMeshProUGUI)fieldInfo2.GetValue(__instance), "statsText");
			}
		}
		catch (Exception ex)
		{
			UpgradeFilteringPlugin.Logger.LogWarning((object)("HoverInfoDisplayReformatPatch: Failed: " + ex.Message));
		}
	}
}
[HarmonyPatch(typeof(HoverInfoDisplay), "Refresh")]
public static class HoverInfoDisplayRefreshReformatPatch
{
	private static void Postfix(HoverInfoDisplay __instance)
	{
		//IL_007a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0089: Expected O, but got Unknown
		//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bd: Expected O, but got Unknown
		FieldInfo fieldInfo = AccessTools.Field(typeof(HoverInfoDisplay), "selectedInfo");
		if (fieldInfo == null)
		{
			return;
		}
		object? value = fieldInfo.GetValue(__instance);
		HoverInfo val = (HoverInfo)((value is HoverInfo) ? value : null);
		if (!StatFormatHandling.enableStatReformat || (Object)(object)val == (Object)null || ((object)val).GetType().Name == "DirectiveButton")
		{
			return;
		}
		try
		{
			FieldInfo fieldInfo2 = AccessTools.Field(typeof(HoverInfoDisplay), "text");
			if (fieldInfo2 != null)
			{
				StatFormatHandling.ReformatUIText((TextMeshProUGUI)fieldInfo2.GetValue(__instance), "main text (refresh)");
			}
			FieldInfo fieldInfo3 = AccessTools.Field(typeof(HoverInfoDisplay), "statsText");
			if (fieldInfo3 != null)
			{
				StatFormatHandling.ReformatUIText((TextMeshProUGUI)fieldInfo3.GetValue(__instance), "statsText (refresh)");
			}
		}
		catch (Exception ex)
		{
			UpgradeFilteringPlugin.Logger.LogWarning((object)("HoverInfoDisplayRefreshReformatPatch: Failed: " + ex.Message));
		}
	}
}
namespace UpgradeFiltering
{
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "UpgradeFiltering";

		public const string PLUGIN_NAME = "UpgradeFiltering";

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