using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Numerics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Json;
using System.Runtime.Versioning;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using TMPro;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
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("CBra.Taschenhaendler")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.1.2.0")]
[assembly: AssemblyInformationalVersion("1.1.2")]
[assembly: AssemblyProduct("CBra.Taschenhaendler")]
[assembly: AssemblyTitle("CBra.Taschenhaendler")]
[assembly: AssemblyVersion("1.1.2.0")]
namespace CBra.Erenshor.Taschenhaendler;

internal sealed class ExtraInventorySlotMarker : MonoBehaviour
{
}
internal sealed class InventoryScrollView : MonoBehaviour
{
	private Inventory _inventory;

	private RectTransform _viewport;

	private RectTransform _content;

	private ScrollRect _scrollRect;

	private GameObject _scrollbarObject;

	private readonly List<float> _columnOffsets = new List<float>();

	private readonly HashSet<ItemIcon> _displayedSlots = new HashSet<ItemIcon>();

	private float _rowSpacing = 70.5f;

	private float _slotVisualHeight = 52f;

	private const float ToolbarHeight = 86f;

	private RectMask2D _mask;

	internal static InventoryScrollView Create(Inventory inventory, IReadOnlyList<ItemIcon> usableSlots)
	{
		//IL_0123: Unknown result type (might be due to invalid IL or missing references)
		//IL_0129: Expected O, but got Unknown
		if ((Object)(object)inventory == (Object)null || usableSlots == null || usableSlots.Count == 0)
		{
			return null;
		}
		List<RectTransform> list = (from root in usableSlots.Select(InventoryExpansionController.GetSlotRoot)
			where (Object)(object)root != (Object)null
			select root).Distinct().ToList();
		if (list.Count == 0)
		{
			return null;
		}
		RectTransform commonParent = default(RectTransform);
		ref RectTransform reference = ref commonParent;
		Transform parent = ((Transform)list[0]).parent;
		reference = (RectTransform)(object)((parent is RectTransform) ? parent : null);
		if ((Object)(object)commonParent == (Object)null || list.Any((RectTransform root) => (Object)(object)((Transform)root).parent != (Object)(object)commonParent))
		{
			TaschenhaendlerPlugin.ModLog.LogWarning((object)"Inventar-Scrollbereich konnte nicht gebaut werden: Slot-Container haben unterschiedliche Eltern.");
			return null;
		}
		InventoryScrollView componentInChildren = ((Component)commonParent).GetComponentInChildren<InventoryScrollView>(true);
		if ((Object)(object)componentInChildren != (Object)null)
		{
			componentInChildren._inventory = inventory;
			componentInChildren.LayoutSlots();
			return componentInChildren;
		}
		GameObject val = new GameObject("Taschenhaendler_ScrollViewport", new Type[5]
		{
			typeof(RectTransform),
			typeof(Image),
			typeof(RectMask2D),
			typeof(ScrollRect),
			typeof(InventoryScrollView)
		});
		RectTransform component = val.GetComponent<RectTransform>();
		((Transform)component).SetParent((Transform)(object)commonParent, false);
		((Transform)component).SetSiblingIndex(Math.Max(0, list.Min((RectTransform root) => ((Transform)root).GetSiblingIndex())));
		InventoryScrollView component2 = val.GetComponent<InventoryScrollView>();
		component2._inventory = inventory;
		component2._viewport = component;
		component2._scrollRect = val.GetComponent<ScrollRect>();
		component2._mask = val.GetComponent<RectMask2D>();
		component2.ConfigureGeometry(list);
		component2.BuildContent(commonParent);
		component2.BuildScrollbar(commonParent);
		component2.ConfigureScrollRect();
		component2.BuildTools(commonParent);
		component2.LayoutSlots();
		return component2;
	}

	internal void LayoutSlots(bool resetScroll = false)
	{
		//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
		//IL_014f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0165: Unknown result type (might be due to invalid IL or missing references)
		//IL_017b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0217: Unknown result type (might be due to invalid IL or missing references)
		//IL_021c: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
		//IL_027a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0264: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)_inventory == (Object)null || (Object)(object)_content == (Object)null || (Object)(object)_viewport == (Object)null)
		{
			return;
		}
		List<ItemIcon> list = _inventory.StoredSlots.Where(InventoryExpansionController.IsScrollableInventorySlot).ToList();
		List<ItemIcon> displayedSlots = InventoryToolsState.GetDisplayedSlots(list, _inventory.Empty);
		_displayedSlots.Clear();
		foreach (ItemIcon item in displayedSlots)
		{
			_displayedSlots.Add(item);
		}
		int num = Math.Max(1, _columnOffsets.Count);
		int num2 = Math.Max(1, Mathf.CeilToInt((float)displayedSlots.Count / (float)num));
		Rect rect = _viewport.rect;
		float num3 = Math.Max(((Rect)(ref rect)).height, _slotVisualHeight + (float)Math.Max(0, num2 - 1) * _rowSpacing + 4f);
		_content.SetSizeWithCurrentAnchors((Axis)1, num3);
		foreach (ItemIcon item2 in list)
		{
			RectTransform slotRoot = InventoryExpansionController.GetSlotRoot(item2);
			if (!((Object)(object)slotRoot == (Object)null))
			{
				((Transform)slotRoot).SetParent((Transform)(object)_content, false);
				slotRoot.anchorMin = new Vector2(0.5f, 1f);
				slotRoot.anchorMax = new Vector2(0.5f, 1f);
				slotRoot.pivot = new Vector2(0.5f, 0.5f);
			}
		}
		for (int i = 0; i < displayedSlots.Count; i++)
		{
			RectTransform slotRoot2 = InventoryExpansionController.GetSlotRoot(displayedSlots[i]);
			if (!((Object)(object)slotRoot2 == (Object)null))
			{
				int index = i % num;
				int num4 = i / num;
				slotRoot2.anchoredPosition = new Vector2(_columnOffsets[index], 0f - (_slotVisualHeight * 0.5f + 2f + (float)num4 * _rowSpacing));
			}
		}
		rect = _viewport.rect;
		bool flag = num3 > ((Rect)(ref rect)).height + 1f;
		if ((Object)(object)_scrollbarObject != (Object)null)
		{
			_scrollbarObject.SetActive(flag);
		}
		if (resetScroll)
		{
			ScrollRect scrollRect = _scrollRect;
			if (scrollRect != null)
			{
				scrollRect.StopMovement();
			}
			_content.anchoredPosition = Vector2.zero;
		}
		else if (!flag)
		{
			_content.anchoredPosition = Vector2.zero;
		}
		Canvas.ForceUpdateCanvases();
		UpdateVisibility();
	}

	private void ConfigureGeometry(IReadOnlyList<RectTransform> roots)
	{
		//IL_0221: Unknown result type (might be due to invalid IL or missing references)
		//IL_0226: Unknown result type (might be due to invalid IL or missing references)
		//IL_0230: Unknown result type (might be due to invalid IL or missing references)
		//IL_02e7: Unknown result type (might be due to invalid IL or missing references)
		//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
		//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
		//IL_035b: Unknown result type (might be due to invalid IL or missing references)
		//IL_036c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0386: Unknown result type (might be due to invalid IL or missing references)
		//IL_03a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_03bd: Unknown result type (might be due to invalid IL or missing references)
		//IL_03e7: Unknown result type (might be due to invalid IL or missing references)
		List<float> list = (from root in roots
			select root.anchoredPosition.x into value
			orderby value
			select value).ToList();
		List<float> list2 = new List<float>();
		foreach (float x in list)
		{
			if (list2.All((float existing) => Mathf.Abs(existing - x) > 5f))
			{
				list2.Add(x);
			}
		}
		if (list2.Count == 0)
		{
			list2.AddRange(new float[3] { -67f, 0f, 67f });
		}
		float num = (list2.First() + list2.Last()) * 0.5f;
		_columnOffsets.Clear();
		foreach (float item in list2)
		{
			_columnOffsets.Add(item - num);
		}
		List<float> list3 = (from value in roots.Select((RectTransform root) => root.anchoredPosition.y).Distinct()
			orderby value descending
			select value).ToList();
		if (list3.Count > 1)
		{
			List<float> list4 = new List<float>();
			for (int num2 = 1; num2 < list3.Count; num2++)
			{
				float num3 = list3[num2 - 1] - list3[num2];
				if (num3 > 10f)
				{
					list4.Add(num3);
				}
			}
			if (list4.Count > 0)
			{
				_rowSpacing = list4.OrderBy((float value) => value).ElementAt(list4.Count / 2);
			}
		}
		RectTransform val = roots[0];
		Rect rect = val.rect;
		_slotVisualHeight = Math.Max(40f, ((Rect)(ref rect)).height * Math.Abs(((Transform)val).localScale.y));
		float num4 = roots.Min((RectTransform root) => root.anchoredPosition.x);
		float num5 = roots.Max((RectTransform root) => root.anchoredPosition.x);
		float num6 = roots.Min((RectTransform root) => root.anchoredPosition.y);
		float num7 = roots.Max((RectTransform root) => root.anchoredPosition.y);
		rect = val.rect;
		float num8 = ((Rect)(ref rect)).width * Math.Abs(((Transform)val).localScale.x);
		float num9 = num5 - num4 + num8 + 12f;
		float num10 = num7 - num6 + _slotVisualHeight + 8f;
		float num11 = Math.Max(_slotVisualHeight * 3f, num10 - 86f);
		float num12 = (num6 + num7) * 0.5f;
		_viewport.anchorMin = val.anchorMin;
		_viewport.anchorMax = val.anchorMax;
		_viewport.pivot = new Vector2(0.5f, 0.5f);
		_viewport.anchoredPosition = new Vector2((num4 + num5) * 0.5f, num12 - 43f);
		_viewport.sizeDelta = new Vector2(num9, num11);
		Image component = ((Component)_viewport).GetComponent<Image>();
		((Graphic)component).color = new Color(0f, 0f, 0f, 0.001f);
		((Graphic)component).raycastTarget = true;
	}

	private void BuildContent(RectTransform commonParent)
	{
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: Expected O, but got Unknown
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0066: 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_0090: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = new GameObject("Content", new Type[1] { typeof(RectTransform) });
		_content = val.GetComponent<RectTransform>();
		((Transform)_content).SetParent((Transform)(object)_viewport, false);
		_content.anchorMin = new Vector2(0f, 1f);
		_content.anchorMax = new Vector2(1f, 1f);
		_content.pivot = new Vector2(0.5f, 1f);
		_content.anchoredPosition = Vector2.zero;
		RectTransform content = _content;
		Rect rect = _viewport.rect;
		content.sizeDelta = new Vector2(0f, ((Rect)(ref rect)).height);
	}

	private void BuildScrollbar(RectTransform commonParent)
	{
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_003d: Expected O, but got Unknown
		//IL_0058: Unknown result type (might be due to invalid IL or missing references)
		//IL_0069: 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_008f: 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_00b5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00da: Unknown result type (might be due to invalid IL or missing references)
		//IL_0103: Unknown result type (might be due to invalid IL or missing references)
		//IL_0132: Unknown result type (might be due to invalid IL or missing references)
		//IL_0137: Unknown result type (might be due to invalid IL or missing references)
		//IL_0147: Unknown result type (might be due to invalid IL or missing references)
		//IL_0152: Unknown result type (might be due to invalid IL or missing references)
		//IL_0167: Unknown result type (might be due to invalid IL or missing references)
		//IL_017c: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
		_scrollbarObject = new GameObject("Taschenhaendler_Scrollbar", new Type[3]
		{
			typeof(RectTransform),
			typeof(Image),
			typeof(Scrollbar)
		});
		RectTransform component = _scrollbarObject.GetComponent<RectTransform>();
		((Transform)component).SetParent((Transform)(object)commonParent, false);
		component.anchorMin = _viewport.anchorMin;
		component.anchorMax = _viewport.anchorMax;
		component.pivot = new Vector2(0.5f, 0.5f);
		component.anchoredPosition = _viewport.anchoredPosition + new Vector2(_viewport.sizeDelta.x * 0.5f - 5f, 0f);
		component.sizeDelta = new Vector2(9f, _viewport.sizeDelta.y);
		((Graphic)_scrollbarObject.GetComponent<Image>()).color = new Color(0.02f, 0.02f, 0.02f, 0.7f);
		GameObject val = new GameObject("Handle", new Type[2]
		{
			typeof(RectTransform),
			typeof(Image)
		});
		RectTransform component2 = val.GetComponent<RectTransform>();
		((Transform)component2).SetParent((Transform)(object)component, false);
		component2.anchorMin = Vector2.zero;
		component2.anchorMax = Vector2.one;
		component2.offsetMin = new Vector2(1f, 1f);
		component2.offsetMax = new Vector2(-1f, -1f);
		Image component3 = val.GetComponent<Image>();
		((Graphic)component3).color = new Color(0.72f, 0.55f, 0.22f, 0.95f);
		Scrollbar component4 = _scrollbarObject.GetComponent<Scrollbar>();
		component4.handleRect = component2;
		((Selectable)component4).targetGraphic = (Graphic)(object)component3;
		component4.direction = (Direction)2;
		component4.numberOfSteps = 0;
		_scrollRect.verticalScrollbar = component4;
	}

	private void BuildTools(RectTransform commonParent)
	{
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		//IL_0069: Unknown result type (might be due to invalid IL or missing references)
		//IL_0078: Unknown result type (might be due to invalid IL or missing references)
		Vector2 anchoredPosition = default(Vector2);
		((Vector2)(ref anchoredPosition))..ctor(_viewport.anchoredPosition.x, _viewport.anchoredPosition.y + _viewport.sizeDelta.y * 0.5f + 43f);
		InventoryToolsPanel.Create(_inventory, this, commonParent, _viewport.anchorMin, _viewport.anchorMax, anchoredPosition, new Vector2(_viewport.sizeDelta.x, 82f));
	}

	private void ConfigureScrollRect()
	{
		_scrollRect.content = _content;
		_scrollRect.viewport = _viewport;
		_scrollRect.horizontal = false;
		_scrollRect.vertical = true;
		_scrollRect.movementType = (MovementType)2;
		_scrollRect.inertia = true;
		_scrollRect.decelerationRate = 0.135f;
		_scrollRect.scrollSensitivity = TaschenhaendlerPlugin.Instance.ScrollSensitivity.Value;
		_scrollRect.verticalScrollbarVisibility = (ScrollbarVisibility)0;
		((UnityEvent<Vector2>)(object)_scrollRect.onValueChanged).AddListener((UnityAction<Vector2>)delegate
		{
			UpdateVisibility();
		});
	}

	private void UpdateVisibility()
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_0079: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)_inventory == (Object)null || (Object)(object)_viewport == (Object)null)
		{
			return;
		}
		Rect worldRect = GetWorldRect(_viewport);
		foreach (ItemIcon item in _inventory.StoredSlots.Where(InventoryExpansionController.IsScrollableInventorySlot))
		{
			RectTransform slotRoot = InventoryExpansionController.GetSlotRoot(item);
			bool num = _displayedSlots.Contains(item);
			bool flag = num && (Object)(object)slotRoot != (Object)null && ((Rect)(ref worldRect)).Overlaps(GetWorldRect(slotRoot), true);
			bool flag2 = num && (flag || item.dragging);
			BoxCollider2D component = ((Component)item).GetComponent<BoxCollider2D>();
			if ((Object)(object)component != (Object)null)
			{
				((Behaviour)component).enabled = flag2;
			}
			Image component2 = ((Component)item).GetComponent<Image>();
			if ((Object)(object)component2 != (Object)null)
			{
				((Graphic)component2).raycastTarget = flag2;
			}
			if ((Object)(object)slotRoot != (Object)null)
			{
				CanvasGroup obj = ((Component)slotRoot).GetComponent<CanvasGroup>() ?? ((Component)slotRoot).gameObject.AddComponent<CanvasGroup>();
				obj.alpha = (flag2 ? 1f : 0f);
				obj.blocksRaycasts = flag2;
			}
		}
	}

	private void LateUpdate()
	{
		if (!((Object)(object)_inventory == (Object)null) && !((Object)(object)_mask == (Object)null))
		{
			bool flag = _inventory.StoredSlots.Where(InventoryExpansionController.IsScrollableInventorySlot).Any((ItemIcon slot) => slot.dragging);
			if (((Behaviour)_mask).enabled == flag)
			{
				((Behaviour)_mask).enabled = !flag;
				UpdateVisibility();
			}
		}
	}

	private static Rect GetWorldRect(RectTransform rectTransform)
	{
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		Vector3[] array = (Vector3[])(object)new Vector3[4];
		rectTransform.GetWorldCorners(array);
		return Rect.MinMaxRect(array[0].x, array[0].y, array[2].x, array[2].y);
	}
}
internal sealed class SaveIsolationState
{
	internal bool CanProceed = true;

	internal bool Prepared;

	internal List<ItemIcon> Extras;

	internal List<HiddenExpansionItemState> HiddenExpansionItems;

	internal Dictionary<Hotkeys, int> HotkeyIndices = new Dictionary<Hotkeys, int>();
}
internal sealed class HiddenExpansionItemState
{
	internal ItemIcon Slot;

	internal Item Item;

	internal int Quantity;
}
internal static class InventoryExpansionController
{
	private sealed class IOExceptionLikeException : Exception
	{
	}

	private static Inventory _inventory;

	private static ItemIcon _trashSlot;

	private static readonly List<ItemIcon> ExtraSlots = new List<ItemIcon>();

	private static InventoryScrollView _scrollView;

	private static CharacterProgress _loadedProgress;

	private static readonly HashSet<int> UnresolvedOverflowIndices = new HashSet<int>();

	private static bool _sidecarAlreadyCommittedForSave;

	private static bool _nativeSaveProbeActive;

	private static bool _nativeSaveSucceeded;

	private static bool _restoringPendingExpansionItems;

	private static bool _pendingRecoveryNoticeShown;

	internal static RectTransform GetSlotRoot(ItemIcon slot)
	{
		object obj;
		if (slot == null)
		{
			obj = null;
		}
		else
		{
			Transform transform = ((Component)slot).transform;
			obj = ((transform != null) ? transform.parent : null);
		}
		return (RectTransform)((obj is RectTransform) ? obj : null);
	}

	internal static bool IsReservedUnresolvedSlot(ItemIcon slot)
	{
		int num = ExtraSlots.IndexOf(slot);
		if (num >= 0)
		{
			return UnresolvedOverflowIndices.Contains(num);
		}
		return false;
	}

	internal static bool IsScrollableInventorySlot(ItemIcon slot)
	{
		//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)slot != (Object)null && (int)slot.ThisSlotType == 0 && !slot.TrashSlot && !slot.VendorSlot && !slot.LootSlot && !slot.BankSlot && !slot.DisplayOnly && !slot.NotInInventory)
		{
			return !slot.CosmeticOnly;
		}
		return false;
	}

	internal static void RefreshLayout()
	{
		_scrollView?.LayoutSlots();
	}

	internal static void RestorePendingExpansionItems()
	{
		if (_restoringPendingExpansionItems || (Object)(object)_inventory == (Object)null || _loadedProgress == null || (Object)(object)MerchantController.ExpansionItem == (Object)null)
		{
			return;
		}
		long num = Math.Max(0L, _loadedProgress.PurchasedCount - _loadedProgress.AppliedCount);
		long num2 = 0L;
		foreach (ItemIcon storedSlot in _inventory.StoredSlots)
		{
			if ((Object)(object)storedSlot != (Object)null && TaschenhaendlerPlugin.IsExpansion(storedSlot.MyItem))
			{
				num2 = checked(num2 + Math.Max(1L, storedSlot.Quantity));
			}
		}
		long num3 = Math.Max(0L, num - num2);
		if (num3 == 0L)
		{
			_pendingRecoveryNoticeShown = false;
			return;
		}
		_restoringPendingExpansionItems = true;
		long num4 = 0L;
		try
		{
			foreach (ItemIcon item in _inventory.StoredSlots.Where((ItemIcon entry) => (Object)(object)entry != (Object)null && TaschenhaendlerPlugin.IsExpansion(entry.MyItem)))
			{
				if (num3 <= 0)
				{
					break;
				}
				long val = int.MaxValue - Math.Max(0, item.Quantity);
				int num5 = (int)Math.Min(num3, val);
				if (num5 > 0)
				{
					item.Quantity += num5;
					num3 -= num5;
					num4 += num5;
					item.UpdateSlotImage();
				}
			}
			foreach (ItemIcon item2 in _inventory.StoredSlots.Where((ItemIcon entry) => IsUsableEmptyInventorySlot(entry)).ToList())
			{
				if (num3 <= 0)
				{
					break;
				}
				int num6 = (int)((num3 > int.MaxValue) ? int.MaxValue : num3);
				item2.MyItem = MerchantController.ExpansionItem;
				item2.Quantity = num6;
				num3 -= num6;
				num4 += num6;
				item2.UpdateSlotImage();
			}
			if (num4 > 0)
			{
				_inventory.UpdatePlayerInventory();
				TaschenhaendlerPlugin.NotifyPlayer(ModLocalization.Format("{0} bereits bezahlte Inventarerweiterung(en) wurden aus dem geschützten Kaufstand wiederhergestellt.", "{0} previously purchased inventory expansion(s) were restored from protected progress.", num4));
			}
			if (num3 > 0 && !_pendingRecoveryNoticeShown)
			{
				_pendingRecoveryNoticeShown = true;
				TaschenhaendlerPlugin.NotifyPlayer(ModLocalization.Format("Für {0} bezahlte Erweiterung(en) ist noch kein freier Inventarplatz vorhanden. Räume einen Platz frei; die Wiederherstellung wird beim nächsten Laden erneut versucht.", "There is no free inventory slot yet for {0} purchased expansion(s). Free one slot; restoration will be retried on the next load.", num3));
			}
		}
		finally
		{
			_restoringPendingExpansionItems = false;
		}
	}

	internal static bool SaveNativeAfterSidecarCommit()
	{
		_sidecarAlreadyCommittedForSave = true;
		_nativeSaveProbeActive = true;
		_nativeSaveSucceeded = false;
		try
		{
			if ((Object)(object)GameData.GM == (Object)null)
			{
				return false;
			}
			try
			{
				GameData.GM.SaveGameData(false);
			}
			catch (Exception ex)
			{
				if (!_nativeSaveSucceeded)
				{
					throw;
				}
				TaschenhaendlerPlugin.ModLog.LogWarning((object)("Der Charakterstand wurde gespeichert, aber ein nachgelagerter Erenshor-Speicherschritt meldete einen Fehler: " + ex.Message));
			}
			return _nativeSaveSucceeded;
		}
		finally
		{
			_nativeSaveProbeActive = false;
			_sidecarAlreadyCommittedForSave = false;
		}
	}

	internal static void ReportNativeSaveResult(bool succeeded)
	{
		if (_nativeSaveProbeActive)
		{
			_nativeSaveSucceeded = succeeded;
		}
	}

	internal static void Initialize(Inventory inventory)
	{
		if ((Object)(object)inventory == (Object)null || !inventory.isPlayer)
		{
			return;
		}
		if ((Object)(object)_inventory != (Object)(object)inventory)
		{
			_inventory = inventory;
			_trashSlot = ((IEnumerable<ItemIcon>)inventory.StoredSlots).FirstOrDefault((Func<ItemIcon, bool>)((ItemIcon slot) => (Object)(object)slot != (Object)null && slot.TrashSlot));
			ExtraSlots.Clear();
			ExtraSlots.AddRange(inventory.StoredSlots.Where(delegate(ItemIcon slot)
			{
				RectTransform slotRoot = GetSlotRoot(slot);
				return (Object)(object)slotRoot != (Object)null && (Object)(object)((Component)slotRoot).GetComponent<ExtraInventorySlotMarker>() != (Object)null;
			}));
			_scrollView = null;
			_loadedProgress = null;
			_pendingRecoveryNoticeShown = false;
		}
		List<ItemIcon> usableSlots = inventory.StoredSlots.Where(IsScrollableInventorySlot).ToList();
		if (_scrollView == null)
		{
			_scrollView = InventoryScrollView.Create(inventory, usableSlots);
		}
		RebuildAllSlots();
	}

	internal static bool CaptureCurrentBeforeCharacterSwitch()
	{
		if (_loadedProgress == null || (Object)(object)_inventory == (Object)null)
		{
			return true;
		}
		CaptureOverflow(_loadedProgress);
		bool num = ProgressStore.Save();
		if (!num)
		{
			TaschenhaendlerPlugin.NotifyPlayer(ModLocalization.Text("Charakterwechsel abgebrochen: Das Zusatzinventar konnte nicht gespeichert werden.", "Character switch cancelled: the extra inventory could not be saved."));
		}
		return num;
	}

	internal static void ClearLoadedCharacter()
	{
		if ((Object)(object)_inventory != (Object)null)
		{
			EnsureExtraSlotCount(0);
		}
		_loadedProgress = null;
		UnresolvedOverflowIndices.Clear();
		_pendingRecoveryNoticeShown = false;
	}

	internal static void LoadCharacter(CharacterProgress progress)
	{
		if ((Object)(object)GameData.PlayerInv == (Object)null || progress == null)
		{
			return;
		}
		Initialize(GameData.PlayerInv);
		_loadedProgress = progress;
		UnresolvedOverflowIndices.Clear();
		foreach (ItemIcon extraSlot in ExtraSlots)
		{
			if ((Object)(object)extraSlot != (Object)null)
			{
				extraSlot.assignedHotkey = null;
			}
		}
		EnsureExtraSlotCount(GetDesiredExtraSlotCount(progress));
		MerchantController.RefreshOffer();
	}

	internal static void FinishCharacterLoad(CharacterProgress progress)
	{
		if ((Object)(object)_inventory == (Object)null || progress == null)
		{
			return;
		}
		for (int i = 0; i < ExtraSlots.Count; i++)
		{
			StoredItem storedItem = ((i < progress.Overflow.Count) ? progress.Overflow[i] : null);
			ItemIcon slot = ExtraSlots[i];
			if (storedItem == null || string.IsNullOrEmpty(storedItem.Id))
			{
				SetSlot(slot, _inventory.Empty, 0);
				continue;
			}
			ItemDatabase itemDB = GameData.ItemDB;
			Item val = ((itemDB != null) ? itemDB.GetItemByID(storedItem.Id) : null);
			if ((Object)(object)val == (Object)null || (Object)(object)val == (Object)(object)_inventory.Empty)
			{
				TaschenhaendlerPlugin.ModLog.LogWarning((object)$"Zusatzslot {i} verweist auf unbekanntes Item '{storedItem.Id}'. Der Eintrag bleibt in der Sidecar-Datei erhalten.");
				UnresolvedOverflowIndices.Add(i);
				SetSlot(slot, _inventory.Empty, 0);
			}
			else
			{
				SetSlot(slot, val, Math.Max(1, storedItem.Quantity));
			}
		}
		_inventory.UpdatePlayerInventory();
		RestorePendingExpansionItems();
		_scrollView?.LayoutSlots();
	}

	internal static void FinishHotkeyLoad(CharacterProgress progress)
	{
		if (progress != null && !((Object)(object)GameData.GM?.HKManager == (Object)null))
		{
			RestoreHotkeyList(GameData.GM.HKManager.FirstHotkeys, progress.FirstExtraHotkeys);
			RestoreHotkeyList(GameData.GM.HKManager.SecondHotkeys, progress.SecondExtraHotkeys);
		}
	}

	internal static bool TryUseExpansion(ItemIcon sourceSlot)
	{
		CharacterProgress current = ProgressStore.Current;
		if ((Object)(object)_inventory == (Object)null || current == null || (Object)(object)sourceSlot == (Object)null)
		{
			TaschenhaendlerPlugin.NotifyPlayer(ModLocalization.Text("Kein aktiver Charakterfortschritt gefunden.", "No active character progress was found."));
			return false;
		}
		if (sourceSlot.VendorSlot || !_inventory.StoredSlots.Contains(sourceSlot) || !TaschenhaendlerPlugin.IsExpansion(sourceSlot.MyItem))
		{
			TaschenhaendlerPlugin.ModLog.LogWarning((object)"Benutzung eines Erweiterungsitems außerhalb des Spielerinventars wurde blockiert.");
			return false;
		}
		if (current.AppliedCount >= current.PurchasedCount)
		{
			TaschenhaendlerPlugin.NotifyPlayer(ModLocalization.Text("Dieses Erweiterungsitem gehört nicht zum gespeicherten Kaufstand und wurde nicht verbraucht.", "This expansion item is not part of the saved purchase progress and was not consumed."));
			return false;
		}
		long appliedCount = current.AppliedCount;
		long grantedSlots = current.GrantedSlots;
		Item myItem = sourceSlot.MyItem;
		int quantity = sourceSlot.Quantity;
		int count = ExtraSlots.Count;
		bool flag = false;
		try
		{
			current.AppliedCount++;
			checked
			{
				current.GrantedSlots += TaschenhaendlerPlugin.Instance.SlotsPerExpansion.Value;
				EnsureExtraSlotCount(GetDesiredExtraSlotCount(current));
			}
			if (quantity > 1)
			{
				sourceSlot.Quantity = quantity - 1;
			}
			else
			{
				sourceSlot.MyItem = _inventory.Empty;
				sourceSlot.Quantity = 0;
			}
			sourceSlot.UpdateSlotImage();
			CaptureOverflow(current);
			if (!ProgressStore.Save())
			{
				throw new IOExceptionLikeException();
			}
			flag = true;
			_inventory.UpdatePlayerInventory();
			if (!SaveNativeAfterSidecarCommit())
			{
				throw new InvalidOperationException("Erenshor hat den nativen Charakterstand nicht gespeichert.");
			}
			int value = TaschenhaendlerPlugin.Instance.SlotsPerExpansion.Value;
			TaschenhaendlerPlugin.NotifyPlayer(ModLocalization.Format("Inventar dauerhaft um {0} Plätze erweitert. Insgesamt: {1} Zusatzplätze.", "Inventory permanently expanded by {0} slots. Total: {1} extra slots.", value, current.GrantedSlots));
			return true;
		}
		catch (Exception ex)
		{
			current.AppliedCount = appliedCount;
			current.GrantedSlots = grantedSlots;
			EnsureExtraSlotCount(count);
			sourceSlot.MyItem = myItem;
			sourceSlot.Quantity = quantity;
			sourceSlot.UpdateSlotImage();
			CaptureOverflow(current);
			if (!(ex is IOExceptionLikeException))
			{
				TaschenhaendlerPlugin.ModLog.LogError((object)$"Inventarerweiterung wurde zurückgerollt: {ex}");
				TaschenhaendlerPlugin.NotifyPlayer(ModLocalization.Text("Die Inventarerweiterung ist fehlgeschlagen und wurde nicht verbraucht.", "The inventory expansion failed and was not consumed."));
			}
			if (flag)
			{
				CaptureOverflow(current);
				ProgressStore.Save();
			}
			return false;
		}
	}

	internal static SaveIsolationState PrepareVanillaSave()
	{
		SaveIsolationState saveIsolationState = new SaveIsolationState
		{
			CanProceed = true,
			Prepared = false,
			Extras = new List<ItemIcon>(),
			HiddenExpansionItems = new List<HiddenExpansionItemState>()
		};
		if ((Object)(object)_inventory == (Object)null)
		{
			return saveIsolationState;
		}
		if (ProgressStore.Current == null)
		{
			saveIsolationState.CanProceed = ExtraSlots.Count == 0;
			if (!saveIsolationState.CanProceed)
			{
				TaschenhaendlerPlugin.ModLog.LogError((object)"Vanilla-Speichern wurde abgebrochen, weil Zusatzslots ohne aktiven Charakterzustand vorhanden sind.");
			}
			return saveIsolationState;
		}
		if (!_sidecarAlreadyCommittedForSave)
		{
			CaptureOverflow(ProgressStore.Current);
			if (!ProgressStore.Save())
			{
				saveIsolationState.CanProceed = false;
				return saveIsolationState;
			}
		}
		saveIsolationState.Prepared = true;
		try
		{
			saveIsolationState.Extras.AddRange(ExtraSlots.Where((ItemIcon slot) => (Object)(object)slot != (Object)null));
			foreach (ItemIcon extra in saveIsolationState.Extras)
			{
				_inventory.StoredSlots.Remove(extra);
			}
			foreach (ItemIcon item in _inventory.StoredSlots.Where((ItemIcon entry) => (Object)(object)entry != (Object)null && TaschenhaendlerPlugin.IsExpansion(entry.MyItem)).ToList())
			{
				saveIsolationState.HiddenExpansionItems.Add(new HiddenExpansionItemState
				{
					Slot = item,
					Item = item.MyItem,
					Quantity = item.Quantity
				});
				item.MyItem = _inventory.Empty;
				item.Quantity = 0;
				item.UpdateSlotImage();
			}
			MaskUnsafeHotkeys(saveIsolationState);
			RebuildAllSlots();
			saveIsolationState.Prepared = saveIsolationState.Extras.Count > 0 || saveIsolationState.HiddenExpansionItems.Count > 0 || saveIsolationState.HotkeyIndices.Count > 0;
			return saveIsolationState;
		}
		catch (Exception arg)
		{
			saveIsolationState.CanProceed = false;
			TaschenhaendlerPlugin.ModLog.LogError((object)$"Vorbereitung des sicheren Vanilla-Speicherns ist fehlgeschlagen; Teilzustand wird wiederhergestellt: {arg}");
			try
			{
				RestoreAfterVanillaSave(saveIsolationState);
			}
			catch (Exception arg2)
			{
				TaschenhaendlerPlugin.ModLog.LogError((object)$"Wiederherstellung nach fehlgeschlagener Save-Vorbereitung ist ebenfalls fehlgeschlagen: {arg2}");
			}
			TaschenhaendlerPlugin.NotifyPlayer(ModLocalization.Text("Speichern wurde abgebrochen, weil die Zusatzslots nicht sicher isoliert werden konnten.", "Saving was cancelled because the extra slots could not be isolated safely."));
			return saveIsolationState;
		}
	}

	internal static void RestoreAfterVanillaSave(SaveIsolationState state)
	{
		if (state == null || !state.Prepared || (Object)(object)_inventory == (Object)null)
		{
			return;
		}
		int num = (((Object)(object)_trashSlot != (Object)null) ? _inventory.StoredSlots.IndexOf(_trashSlot) : _inventory.StoredSlots.Count);
		if (num < 0)
		{
			num = _inventory.StoredSlots.Count;
		}
		foreach (ItemIcon extra in state.Extras)
		{
			if ((Object)(object)extra != (Object)null && !_inventory.StoredSlots.Contains(extra))
			{
				_inventory.StoredSlots.Insert(num++, extra);
			}
		}
		foreach (HiddenExpansionItemState hiddenExpansionItem in state.HiddenExpansionItems)
		{
			if (!((Object)(object)hiddenExpansionItem?.Slot == (Object)null))
			{
				hiddenExpansionItem.Slot.MyItem = hiddenExpansionItem.Item;
				hiddenExpansionItem.Slot.Quantity = hiddenExpansionItem.Quantity;
				hiddenExpansionItem.Slot.UpdateSlotImage();
			}
		}
		RebuildAllSlots();
		foreach (KeyValuePair<Hotkeys, int> hotkeyIndex in state.HotkeyIndices)
		{
			if ((Object)(object)hotkeyIndex.Key != (Object)null)
			{
				hotkeyIndex.Key.InvSlotIndex = hotkeyIndex.Value;
			}
		}
		state.Prepared = false;
		_scrollView?.LayoutSlots();
	}

	internal static void CaptureOverflow(CharacterProgress progress)
	{
		if (progress == null || (Object)(object)_inventory == (Object)null)
		{
			return;
		}
		List<StoredItem> list = new List<StoredItem>(ExtraSlots.Count);
		for (int i = 0; i < ExtraSlots.Count; i++)
		{
			ItemIcon val = ExtraSlots[i];
			if ((Object)(object)val == (Object)null || (Object)(object)val.MyItem == (Object)null || (Object)(object)val.MyItem == (Object)(object)_inventory.Empty)
			{
				if (UnresolvedOverflowIndices.Contains(i) && i < progress.Overflow.Count && !string.IsNullOrEmpty(progress.Overflow[i]?.Id))
				{
					StoredItem storedItem = progress.Overflow[i];
					list.Add(new StoredItem
					{
						Id = storedItem.Id,
						Quantity = storedItem.Quantity
					});
				}
				else
				{
					list.Add(new StoredItem());
				}
			}
			else
			{
				UnresolvedOverflowIndices.Remove(i);
				list.Add(new StoredItem
				{
					Id = (((BaseScriptableObject)val.MyItem).Id ?? string.Empty),
					Quantity = Math.Max(1, val.Quantity)
				});
			}
		}
		progress.Overflow = list;
		CaptureExtraHotkeys(progress);
	}

	private static int GetDesiredExtraSlotCount(CharacterProgress progress)
	{
		long grantedSlots = progress.GrantedSlots;
		if (grantedSlots > int.MaxValue)
		{
			throw new InvalidOperationException("Die Anzahl der Zusatzplätze überschreitet die technische Listengrenze von Unity.");
		}
		return (int)grantedSlots;
	}

	private static void EnsureExtraSlotCount(int desired)
	{
		if ((Object)(object)_inventory == (Object)null)
		{
			throw new InvalidOperationException("Spielerinventar ist nicht initialisiert.");
		}
		while (ExtraSlots.Count > desired)
		{
			ItemIcon val = ExtraSlots[ExtraSlots.Count - 1];
			ExtraSlots.RemoveAt(ExtraSlots.Count - 1);
			_inventory.StoredSlots.Remove(val);
			RectTransform slotRoot = GetSlotRoot(val);
			if ((Object)(object)slotRoot != (Object)null)
			{
				((Component)slotRoot).gameObject.SetActive(false);
				Object.Destroy((Object)(object)((Component)slotRoot).gameObject);
			}
		}
		while (ExtraSlots.Count < desired)
		{
			AddExtraSlot();
		}
		RebuildAllSlots();
		_scrollView?.LayoutSlots();
	}

	private static void AddExtraSlot()
	{
		RectTransform slotRoot = GetSlotRoot(((IEnumerable<ItemIcon>)_inventory.StoredSlots).FirstOrDefault((Func<ItemIcon, bool>)delegate(ItemIcon slot)
		{
			if ((Object)(object)slot != (Object)null && !slot.TrashSlot)
			{
				RectTransform slotRoot2 = GetSlotRoot(slot);
				return (Object)(object)((slotRoot2 != null) ? ((Component)slotRoot2).GetComponent<ExtraInventorySlotMarker>() : null) == (Object)null;
			}
			return false;
		}));
		if ((Object)(object)slotRoot == (Object)null)
		{
			throw new InvalidOperationException("Kein normaler Inventarslot als Vorlage gefunden.");
		}
		Transform parent = ((Transform)slotRoot).parent;
		RectTransform val = (RectTransform)(object)((parent is RectTransform) ? parent : null);
		GameObject val2 = Object.Instantiate<GameObject>(((Component)slotRoot).gameObject, (Transform)(object)val, false);
		((Object)val2).name = $"Taschenhaendler_ExtraSlot_{ExtraSlots.Count + 1:D4}";
		val2.AddComponent<ExtraInventorySlotMarker>();
		ItemIcon componentInChildren = val2.GetComponentInChildren<ItemIcon>(true);
		if ((Object)(object)componentInChildren == (Object)null)
		{
			Object.Destroy((Object)(object)val2);
			throw new InvalidOperationException("Die Slot-Vorlage enthält kein ItemIcon.");
		}
		if ((Object)(object)componentInChildren.MySparkler != (Object)null)
		{
			GameObject gameObject = ((Component)componentInChildren.MySparkler).gameObject;
			componentInChildren.MySparkler = null;
			Object.Destroy((Object)(object)gameObject);
		}
		componentInChildren.TrashSlot = false;
		componentInChildren.VendorSlot = false;
		componentInChildren.LootSlot = false;
		componentInChildren.BankSlot = false;
		componentInChildren.NotInInventory = false;
		componentInChildren.dragging = false;
		componentInChildren.assignedHotkey = null;
		Traverse obj = Traverse.Create((object)componentInChildren);
		obj.Field("hotkey").SetValue((object)null);
		obj.Field("MouseHomeSlot").SetValue((object)null);
		obj.Field("SwapWith").SetValue((object)null);
		obj.Field("rButton").SetValue((object)false);
		obj.Field("lButton").SetValue((object)false);
		obj.Field("doHotkey").SetValue((object)false);
		componentInChildren.MyItem = _inventory.Empty;
		componentInChildren.Quantity = 0;
		componentInChildren.ForceInitInv();
		int num = (((Object)(object)_trashSlot != (Object)null) ? _inventory.StoredSlots.IndexOf(_trashSlot) : _inventory.StoredSlots.Count);
		if (num < 0)
		{
			num = _inventory.StoredSlots.Count;
		}
		_inventory.StoredSlots.Insert(num, componentInChildren);
		ExtraSlots.Add(componentInChildren);
	}

	private static void SetSlot(ItemIcon slot, Item item, int quantity)
	{
		slot.MyItem = item;
		slot.Quantity = quantity;
		slot.UpdateSlotImage();
	}

	private static void RebuildAllSlots()
	{
		if (!((Object)(object)_inventory == (Object)null))
		{
			_inventory.ALLSLOTS.Clear();
			_inventory.ALLSLOTS.AddRange(_inventory.EquipmentSlots.Where((ItemIcon slot) => (Object)(object)slot != (Object)null));
			_inventory.ALLSLOTS.AddRange(_inventory.StoredSlots.Where((ItemIcon slot) => (Object)(object)slot != (Object)null));
			_inventory.ALLSLOTS.AddRange(_inventory.TransmogSlots.Where((ItemIcon slot) => (Object)(object)slot != (Object)null));
			for (int num = 0; num < _inventory.ALLSLOTS.Count; num++)
			{
				_inventory.ALLSLOTS[num].ALLSLOTSINDEX = num;
			}
		}
	}

	private static void CaptureExtraHotkeys(CharacterProgress progress)
	{
		if (!((Object)(object)GameData.GM?.HKManager == (Object)null))
		{
			progress.FirstExtraHotkeys = CaptureHotkeyList(GameData.GM.HKManager.FirstHotkeys);
			progress.SecondExtraHotkeys = CaptureHotkeyList(GameData.GM.HKManager.SecondHotkeys);
		}
	}

	private static List<int> CaptureHotkeyList(List<Hotkeys> hotkeys)
	{
		List<int> list = new List<int>();
		if (hotkeys == null)
		{
			return list;
		}
		foreach (Hotkeys hotkey in hotkeys)
		{
			int item = (((Object)(object)hotkey?.AssignedItem != (Object)null) ? ExtraSlots.IndexOf(hotkey.AssignedItem) : (-1));
			list.Add(item);
		}
		return list;
	}

	private static void RestoreHotkeyList(List<Hotkeys> hotkeys, List<int> mappings)
	{
		if (hotkeys == null || mappings == null)
		{
			return;
		}
		int num = Math.Min(hotkeys.Count, mappings.Count);
		for (int i = 0; i < num; i++)
		{
			int num2 = mappings[i];
			if (num2 >= 0 && num2 < ExtraSlots.Count && !((Object)(object)hotkeys[i] == (Object)null) && !((Object)(object)ExtraSlots[num2] == (Object)null))
			{
				hotkeys[i].ClearMe();
				hotkeys[i].AssignItemFrominv(ExtraSlots[num2]);
				ExtraSlots[num2].assignedHotkey = hotkeys[i];
			}
		}
	}

	private static void MaskUnsafeHotkeys(SaveIsolationState state)
	{
		if (GameData.GM?.HKManager?.AllHotkeys == null)
		{
			return;
		}
		foreach (Hotkeys hotkey in GameData.GM.HKManager.AllHotkeys)
		{
			if ((Object)(object)hotkey != (Object)null && (Object)(object)hotkey.AssignedItem != (Object)null && (ExtraSlots.Contains(hotkey.AssignedItem) || state.HiddenExpansionItems.Any((HiddenExpansionItemState hidden) => hidden != null && (Object)(object)hidden.Slot == (Object)(object)hotkey.AssignedItem)))
			{
				state.HotkeyIndices[hotkey] = hotkey.InvSlotIndex;
				hotkey.InvSlotIndex = -1;
			}
		}
	}

	private static bool IsUsableEmptyInventorySlot(ItemIcon slot)
	{
		if (IsScrollableInventorySlot(slot) && (Object)(object)slot.MyItem == (Object)(object)_inventory.Empty)
		{
			return !IsReservedUnresolvedSlot(slot);
		}
		return false;
	}
}
[HarmonyPatch(typeof(CharSelectManager), "LoadHotkeys")]
internal static class ExtraHotkeyLoadPatch
{
	[HarmonyPostfix]
	private static void Postfix()
	{
		InventoryExpansionController.FinishHotkeyLoad(ProgressStore.Current);
	}
}
[HarmonyPatch(typeof(Inventory), "Start")]
internal static class InventoryStartPatch
{
	[HarmonyPostfix]
	[HarmonyPriority(0)]
	private static void Postfix(Inventory __instance)
	{
		try
		{
			InventoryExpansionController.Initialize(__instance);
		}
		catch (Exception arg)
		{
			TaschenhaendlerPlugin.ModLog.LogError((object)$"Inventarinitialisierung fehlgeschlagen: {arg}");
		}
	}
}
[HarmonyPatch(typeof(CharSelectManager), "LoadEquipment")]
internal static class CharacterLoadPatch
{
	[HarmonyPrefix]
	private static void Prefix()
	{
		InventoryExpansionController.LoadCharacter(ProgressStore.SelectCurrentCharacter());
	}

	[HarmonyPostfix]
	private static void Postfix()
	{
		InventoryExpansionController.FinishCharacterLoad(ProgressStore.Current);
	}
}
[HarmonyPatch(typeof(CharSelectManager), "SelectSlot")]
internal static class CharacterSelectionPatch
{
	[HarmonyPrefix]
	private static bool Prefix()
	{
		return InventoryExpansionController.CaptureCurrentBeforeCharacterSwitch();
	}

	[HarmonyPostfix]
	private static void Postfix()
	{
		if (GameData.CurrentCharacterSlot != null && string.IsNullOrEmpty(GameData.CurrentCharacterSlot.CharName))
		{
			InventoryExpansionController.ClearLoadedCharacter();
			ProgressStore.ClearCurrent();
		}
	}
}
[HarmonyPatch(typeof(CharSelectManager), "SelectBackupSlot")]
internal static class BackupCharacterSelectionPatch
{
	[HarmonyPrefix]
	private static bool Prefix()
	{
		return InventoryExpansionController.CaptureCurrentBeforeCharacterSwitch();
	}
}
[HarmonyPatch(typeof(ItemIcon), "UseConsumable")]
internal static class UseExpansionPatch
{
	[HarmonyPrefix]
	private static bool Prefix(ItemIcon __instance)
	{
		if (!TaschenhaendlerPlugin.IsExpansion(__instance?.MyItem))
		{
			return true;
		}
		InventoryExpansionController.TryUseExpansion(__instance);
		return false;
	}
}
[HarmonyPatch(typeof(GameManager), "SaveGameData")]
internal static class SafeInventorySavePatch
{
	[HarmonyPrefix]
	private static bool Prefix(out SaveIsolationState __state)
	{
		__state = InventoryExpansionController.PrepareVanillaSave();
		return __state.CanProceed;
	}

	[HarmonyPostfix]
	private static void Postfix(SaveIsolationState __state)
	{
		InventoryExpansionController.RestoreAfterVanillaSave(__state);
	}

	[HarmonyFinalizer]
	private static Exception Finalizer(Exception __exception, SaveIsolationState __state)
	{
		InventoryExpansionController.RestoreAfterVanillaSave(__state);
		return __exception;
	}
}
[HarmonyPatch(typeof(GameData), "SaveData")]
internal static class NativeCharacterSaveResultPatch
{
	[HarmonyPostfix]
	private static void Postfix(bool __result)
	{
		InventoryExpansionController.ReportNativeSaveResult(__result);
	}
}
internal sealed class DeletedCharacterKey
{
	internal int SlotIndex;

	internal string Name;
}
[HarmonyPatch(typeof(CharSelectManager), "EraseCharacter")]
internal static class CharacterErasePatch
{
	[HarmonyPrefix]
	private static void Prefix(CharSelectManager __instance, out DeletedCharacterKey __state)
	{
		__state = null;
		SaveGameData val = GameData.CurrentCharacterSlot;
		if (val == null)
		{
			int value = Traverse.Create((object)__instance).Field("curIndex").GetValue<int>();
			if (GameData.SaveSlots != null && value >= 0 && value < GameData.SaveSlots.Count)
			{
				val = GameData.SaveSlots[value];
			}
		}
		if (val != null)
		{
			__state = new DeletedCharacterKey
			{
				SlotIndex = val.index,
				Name = (val.CharName ?? string.Empty)
			};
		}
	}

	[HarmonyPostfix]
	private static void Postfix(DeletedCharacterKey __state)
	{
		if (__state != null)
		{
			InventoryExpansionController.ClearLoadedCharacter();
			ProgressStore.Remove(__state.SlotIndex, __state.Name);
		}
	}
}
internal enum InventoryFilterMode
{
	All,
	Weapons,
	ArmorAndJewelry,
	Consumables,
	Crafting,
	QuestAndBooks,
	Rare,
	Other
}
internal enum InventorySortMode
{
	Name,
	Type,
	Level,
	Value,
	Quantity
}
internal static class InventoryToolsState
{
	private static readonly string[] StableSortModes = new string[5] { "Name", "Type", "Level", "Value", "Quantity" };

	private static string _searchText = string.Empty;

	private static InventoryFilterMode _filter = InventoryFilterMode.All;

	internal static string SearchText => _searchText;

	internal static InventoryFilterMode Filter => _filter;

	internal static InventorySortMode PendingSortMode
	{
		get
		{
			if (!TryParseSortMode(TaschenhaendlerPlugin.Instance?.PreferredSortMode?.Value, out var mode))
			{
				return InventorySortMode.Type;
			}
			return mode;
		}
	}

	internal static bool PendingDescending => TaschenhaendlerPlugin.Instance?.SortDescending?.Value == true;

	internal static IReadOnlyList<string> FilterLabels
	{
		get
		{
			if (ModLocalization.IsGerman)
			{
				return new string[8] { "Alle", "Waffen", "Rüst./Schm.", "Verbrauch", "Handwerk", "Quest/Buch", "Selten", "Sonstiges" };
			}
			return new string[8] { "All", "Weapons", "Armor/Jewel.", "Consume", "Crafting", "Quest/Book", "Rare", "Other" };
		}
	}

	internal static IReadOnlyList<string> SortLabels
	{
		get
		{
			if (ModLocalization.IsGerman)
			{
				return new string[5] { "Name", "Typ", "Stufe", "Wert", "Menge" };
			}
			return new string[5] { "Name", "Type", "Level", "Value", "Quantity" };
		}
	}

	internal static void SetSearch(string value)
	{
		_searchText = value?.Trim() ?? string.Empty;
	}

	internal static void SetFilter(int index)
	{
		_filter = (InventoryFilterMode)Mathf.Clamp(index, 0, Enum.GetValues(typeof(InventoryFilterMode)).Length - 1);
	}

	internal static void SetPendingSortMode(int index)
	{
		index = Mathf.Clamp(index, 0, StableSortModes.Length - 1);
		if (TaschenhaendlerPlugin.Instance?.PreferredSortMode != null)
		{
			TaschenhaendlerPlugin.Instance.PreferredSortMode.Value = StableSortModes[index];
		}
	}

	internal static void TogglePendingDirection()
	{
		if (TaschenhaendlerPlugin.Instance?.SortDescending != null)
		{
			TaschenhaendlerPlugin.Instance.SortDescending.Value = !TaschenhaendlerPlugin.Instance.SortDescending.Value;
		}
	}

	internal static bool TryParseSortMode(string value, out InventorySortMode mode)
	{
		for (int i = 0; i < StableSortModes.Length; i++)
		{
			if (string.Equals(value, StableSortModes[i], StringComparison.OrdinalIgnoreCase))
			{
				mode = (InventorySortMode)i;
				return true;
			}
		}
		mode = InventorySortMode.Type;
		return false;
	}

	internal static List<ItemIcon> GetDisplayedSlots(IEnumerable<ItemIcon> source, Item empty)
	{
		return (from slot in source
			where (Object)(object)slot != (Object)null && !slot.TrashSlot
			where Matches(slot, empty)
			select slot).ToList();
	}

	private static bool Matches(ItemIcon slot, Item empty)
	{
		Item val = slot?.MyItem;
		if ((Object)(object)val == (Object)null || (Object)(object)val == (Object)(object)empty)
		{
			if (_filter == InventoryFilterMode.All)
			{
				return string.IsNullOrEmpty(_searchText);
			}
			return false;
		}
		if (!string.IsNullOrEmpty(_searchText))
		{
			bool num = (val.ItemName ?? string.Empty).IndexOf(_searchText, StringComparison.CurrentCultureIgnoreCase) >= 0;
			bool flag = (val.Lore ?? string.Empty).IndexOf(_searchText, StringComparison.CurrentCultureIgnoreCase) >= 0;
			if (!num && !flag)
			{
				return false;
			}
		}
		if (_filter != InventoryFilterMode.All && GetFilterCategory(val) != _filter)
		{
			if (_filter == InventoryFilterMode.Rare)
			{
				if (!val.RareItem && !val.Relic)
				{
					return val.Unique;
				}
				return true;
			}
			return false;
		}
		return true;
	}

	private static InventoryFilterMode GetFilterCategory(Item item)
	{
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Invalid comparison between Unknown and I4
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_001d: Invalid comparison between Unknown and I4
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Invalid comparison between Unknown and I4
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)item == (Object)null)
		{
			return InventoryFilterMode.Other;
		}
		if ((int)item.RequiredSlot == 13 || (int)item.RequiredSlot == 14 || (int)item.RequiredSlot == 15 || item.WeaponDmg != 0 || (int)item.ThisWeaponType != 0 || item.IsBow || item.IsWand)
		{
			return InventoryFilterMode.Weapons;
		}
		if ((int)item.RequiredSlot != 0)
		{
			return InventoryFilterMode.ArmorAndJewelry;
		}
		if ((Object)(object)item.AssignQuestOnRead != (Object)null || (Object)(object)item.CompleteOnRead != (Object)null || !string.IsNullOrWhiteSpace(item.BookTitle) || (Object)(object)item.TeachSpell != (Object)null || (Object)(object)item.TeachSkill != (Object)null)
		{
			return InventoryFilterMode.QuestAndBooks;
		}
		if ((Object)(object)item.ItemEffectOnClick != (Object)null || (Object)(object)item.ItemSkillUse != (Object)null || item.Disposable)
		{
			return InventoryFilterMode.Consumables;
		}
		if (item.Template || item.FuelSource || item.Mining > 0 || item.FurnitureSet)
		{
			return InventoryFilterMode.Crafting;
		}
		return InventoryFilterMode.Other;
	}
}
internal sealed class InventoryToolsPanel : MonoBehaviour
{
	private static readonly HashSet<InventoryToolsPanel> LivePanels = new HashSet<InventoryToolsPanel>();

	private Inventory _inventory;

	private InventoryScrollView _scrollView;

	private TMP_InputField _search;

	private TextMeshProUGUI _searchPlaceholder;

	private InventoryChoiceDropdown _language;

	private InventoryChoiceDropdown _filter;

	private InventoryChoiceDropdown _sortMode;

	private Button _directionButton;

	private TextMeshProUGUI _directionText;

	private Button _sortButton;

	private TextMeshProUGUI _sortButtonText;

	private TMP_FontAsset _font;

	private float _autoSortGuard;

	internal static InventoryToolsPanel Create(Inventory inventory, InventoryScrollView scrollView, RectTransform parent, Vector2 anchorMin, Vector2 anchorMax, Vector2 anchoredPosition, Vector2 size)
	{
		//IL_0066: Unknown result type (might be due to invalid IL or missing references)
		//IL_006b: Unknown result type (might be due to invalid IL or missing references)
		//IL_007b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0082: Unknown result type (might be due to invalid IL or missing references)
		//IL_0094: 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_00a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ed: 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_0141: Unknown result type (might be due to invalid IL or missing references)
		InventoryToolsPanel componentInChildren = ((Component)parent).GetComponentInChildren<InventoryToolsPanel>(true);
		if ((Object)(object)componentInChildren != (Object)null)
		{
			componentInChildren._inventory = inventory;
			componentInChildren._scrollView = scrollView;
			componentInChildren.RefreshLocalization();
			return componentInChildren;
		}
		GameObject val = new GameObject("CBra_InventoryTools", new Type[4]
		{
			typeof(RectTransform),
			typeof(Image),
			typeof(Outline),
			typeof(InventoryToolsPanel)
		});
		RectTransform component = val.GetComponent<RectTransform>();
		((Transform)component).SetParent((Transform)(object)parent, false);
		component.anchorMin = anchorMin;
		component.anchorMax = anchorMax;
		component.pivot = new Vector2(0.5f, 0.5f);
		component.anchoredPosition = anchoredPosition;
		component.sizeDelta = size;
		((Graphic)val.GetComponent<Image>()).color = new Color(0.035f, 0.12f, 0.16f, 0.94f);
		Outline component2 = val.GetComponent<Outline>();
		((Shadow)component2).effectColor = new Color(0.35f, 0.75f, 0.78f, 0.9f);
		((Shadow)component2).effectDistance = new Vector2(1f, -1f);
		InventoryToolsPanel component3 = val.GetComponent<InventoryToolsPanel>();
		component3._inventory = inventory;
		component3._scrollView = scrollView;
		component3._font = (((Object)(object)inventory.GoldTXT != (Object)null) ? ((TMP_Text)inventory.GoldTXT).font : null);
		component3.Build(size);
		component3.RefreshLocalization();
		((Transform)component).SetAsLastSibling();
		component3.DisableExternalAutoSortButtons();
		return component3;
	}

	internal static void RefreshAllLocalization()
	{
		InventoryToolsPanel[] array = LivePanels.Where((InventoryToolsPanel panel) => (Object)(object)panel != (Object)null).ToArray();
		for (int num = 0; num < array.Length; num++)
		{
			array[num].RefreshLocalization();
		}
	}

	private void OnEnable()
	{
		LivePanels.Add(this);
	}

	private void OnDisable()
	{
		if ((Object)(object)_search != (Object)null && _search.isFocused)
		{
			GameData.PlayerTyping = false;
		}
	}

	private void OnDestroy()
	{
		LivePanels.Remove(this);
		if ((Object)(object)_search != (Object)null && _search.isFocused)
		{
			GameData.PlayerTyping = false;
		}
	}

	private void Update()
	{
		_autoSortGuard -= Time.unscaledDeltaTime;
		if (_autoSortGuard <= 0f)
		{
			_autoSortGuard = 2f;
			DisableExternalAutoSortButtons();
		}
	}

	private void Build(Vector2 size)
	{
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_007c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0087: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0113: 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_0155: Unknown result type (might be due to invalid IL or missing references)
		//IL_0161: Unknown result type (might be due to invalid IL or missing references)
		//IL_0188: Unknown result type (might be due to invalid IL or missing references)
		//IL_0192: Expected O, but got Unknown
		//IL_01af: Unknown result type (might be due to invalid IL or missing references)
		//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ec: Expected O, but got Unknown
		Transform transform = ((Component)this).transform;
		RectTransform parent = (RectTransform)(object)((transform is RectTransform) ? transform : null);
		float num = Math.Max(1f, size.x - 8f);
		_search = CreateSearch(parent, new Vector2(0f, 31f), new Vector2(num, 23f));
		float num2 = Math.Min(82f, num * 0.43f);
		float num3 = num - num2 - 4f;
		_language = InventoryChoiceDropdown.Create(parent, "CBra_LanguageDropdown", new Vector2((0f - (num - num2)) * 0.5f, 3f), new Vector2(num2, 23f), _font);
		_filter = InventoryChoiceDropdown.Create(parent, "CBra_FilterDropdown", new Vector2((num - num3) * 0.5f, 3f), new Vector2(num3, 23f), _font);
		float num4 = 28f;
		float num5 = 52f;
		float num6 = 6f;
		float num7 = num - num4 - num5 - num6;
		float num8 = (0f - num) * 0.5f;
		_sortMode = InventoryChoiceDropdown.Create(parent, "CBra_SortModeDropdown", new Vector2(num8 + num7 * 0.5f, -25f), new Vector2(num7, 23f), _font);
		_directionButton = CreateButton(parent, "CBra_SortDirection", new Vector2(num8 + num7 + 3f + num4 * 0.5f, -25f), new Vector2(num4, 23f), out _directionText);
		((UnityEvent)_directionButton.onClick).AddListener((UnityAction)delegate
		{
			InventoryToolsState.TogglePendingDirection();
			RefreshLocalization();
		});
		_sortButton = CreateButton(parent, "CBra_SortButton", new Vector2(num * 0.5f - num5 * 0.5f, -25f), new Vector2(num5, 23f), out _sortButtonText);
		((UnityEvent)_sortButton.onClick).AddListener(new UnityAction(SortNow));
		_language.SetSelectionHandler(delegate(int index)
		{
			ModLocalization.SetModeByIndex(index);
		});
		_filter.SetSelectionHandler(delegate(int index)
		{
			InventoryToolsState.SetFilter(index);
			_scrollView?.LayoutSlots(resetScroll: true);
			RefreshLocalization();
		});
		_sortMode.SetSelectionHandler(delegate(int index)
		{
			InventoryToolsState.SetPendingSortMode(index);
			RefreshLocalization();
		});
	}

	private TMP_InputField CreateSearch(RectTransform parent, Vector2 position, Vector2 size)
	{
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Expected O, but got Unknown
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		//IL_0086: 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_00a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
		//IL_0109: 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_011e: 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_0179: Unknown result type (might be due to invalid IL or missing references)
		//IL_0184: Unknown result type (might be due to invalid IL or missing references)
		//IL_018f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0199: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0208: Unknown result type (might be due to invalid IL or missing references)
		//IL_0213: Unknown result type (might be due to invalid IL or missing references)
		//IL_021d: Expected O, but got Unknown
		//IL_021e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0228: Expected O, but got Unknown
		//IL_0229: Unknown result type (might be due to invalid IL or missing references)
		//IL_0233: Expected O, but got Unknown
		GameObject val = new GameObject("CBra_InventorySearch", new Type[2]
		{
			typeof(RectTransform),
			typeof(Image)
		});
		RectTransform component = val.GetComponent<RectTransform>();
		ConfigureRect(component, parent, position, size);
		Image component2 = val.GetComponent<Image>();
		((Graphic)component2).color = new Color(0.015f, 0.035f, 0.045f, 0.96f);
		RectTransform component3 = new GameObject("Text Area", new Type[2]
		{
			typeof(RectTransform),
			typeof(RectMask2D)
		}).GetComponent<RectTransform>();
		((Transform)component3).SetParent((Transform)(object)component, false);
		component3.anchorMin = Vector2.zero;
		component3.anchorMax = Vector2.one;
		component3.offsetMin = new Vector2(7f, 1f);
		component3.offsetMax = new Vector2(-7f, -1f);
		TextMeshProUGUI val2 = CreateText(component3, "Text", string.Empty, 13f, (TextAlignmentOptions)4097);
		RectTransform rectTransform = ((TMP_Text)val2).rectTransform;
		rectTransform.anchorMin = Vector2.zero;
		rectTransform.anchorMax = Vector2.one;
		rectTransform.offsetMin = Vector2.zero;
		rectTransform.offsetMax = Vector2.zero;
		_searchPlaceholder = CreateText(component3, "Placeholder", string.Empty, 13f, (TextAlignmentOptions)4097);
		((Graphic)_searchPlaceholder).color = new Color(0.72f, 0.78f, 0.8f, 0.72f);
		RectTransform rectTransform2 = ((TMP_Text)_searchPlaceholder).rectTransform;
		rectTransform2.anchorMin = Vector2.zero;
		rectTransform2.anchorMax = Vector2.one;
		rectTransform2.offsetMin = Vector2.zero;
		rectTransform2.offsetMax = Vector2.zero;
		TMP_InputField obj = val.AddComponent<TMP_InputField>();
		obj.textViewport = component3;
		obj.textComponent = (TMP_Text)(object)val2;
		obj.placeholder = (Graphic)(object)_searchPlaceholder;
		((Selectable)obj).targetGraphic = (Graphic)(object)component2;
		obj.lineType = (LineType)0;
		obj.contentType = (ContentType)0;
		obj.characterLimit = 80;
		obj.customCaretColor = true;
		obj.caretColor = Color.white;
		obj.selectionColor = new Color(0.25f, 0.7f, 0.8f, 0.45f);
		obj.onValueChanged = new OnChangeEvent();
		obj.onSelect = new SelectionEvent();
		obj.onDeselect = new SelectionEvent();
		((UnityEvent<string>)(object)obj.onValueChanged).AddListener((UnityAction<string>)delegate(string value)
		{
			InventoryToolsState.SetSearch(value);
			_scrollView?.LayoutSlots(resetScroll: true);
		});
		((UnityEvent<string>)(object)obj.onSelect).AddListener((UnityAction<string>)delegate
		{
			GameData.PlayerTyping = true;
		});
		((UnityEvent<string>)(object)obj.onDeselect).AddListener((UnityAction<string>)delegate
		{
			GameData.PlayerTyping = false;
		});
		obj.SetTextWithoutNotify(InventoryToolsState.SearchText);
		return obj;
	}

	private Button CreateButton(RectTransform parent, string name, Vector2 position, Vector2 size, out TextMeshProUGUI label)
	{
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: 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_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_0060: Unknown result type (might be due to invalid IL or missing references)
		//IL_0077: Unknown result type (might be due to invalid IL or missing references)
		//IL_007c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0093: 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_00be: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ff: 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_0128: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = new GameObject(name, new Type[3]
		{
			typeof(RectTransform),
			typeof(Image),
			typeof(Button)
		});
		RectTransform component = val.GetComponent<RectTransform>();
		ConfigureRect(component, parent, position, size);
		Image component2 = val.GetComponent<Image>();
		((Graphic)component2).color = new Color(0.08f, 0.26f, 0.31f, 0.98f);
		Button component3 = val.GetComponent<Button>();
		((Selectable)component3).targetGraphic = (Graphic)(object)component2;
		ColorBlock colors = ((Selectable)component3).colors;
		((ColorBlock)(ref colors)).highlightedColor = new Color(0.16f, 0.46f, 0.5f, 1f);
		((ColorBlock)(ref colors)).pressedColor = new Color(0.72f, 0.55f, 0.22f, 1f);
		((Selectable)component3).colors = colors;
		label = CreateText(component, "Label", string.Empty, 12f, (TextAlignmentOptions)514);
		((Graphic)label).raycastTarget = false;
		RectTransform rectTransform = ((TMP_Text)label).rectTransform;
		rectTransform.anchorMin = Vector2.zero;
		rectTransform.anchorMax = Vector2.one;
		rectTransform.offsetMin = new Vector2(2f, 0f);
		rectTransform.offsetMax = new Vector2(-2f, 0f);
		return component3;
	}

	private TextMeshProUGUI CreateText(RectTransform parent, string name, string value, float size, TextAlignmentOptions alignment)
	{
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = new GameObject(name, new Type[2]
		{
			typeof(RectTransform),
			typeof(TextMeshProUGUI)
		});
		((Transform)val.GetComponent<RectTransform>()).SetParent((Transform)(object)parent, false);
		TextMeshProUGUI component = val.GetComponent<TextMeshProUGUI>();
		((TMP_Text)component).text = value;
		((TMP_Text)component).fontSize = size;
		((TMP_Text)component).alignment = alignment;
		((Graphic)component).color = Color.white;
		((TMP_Text)component).enableWordWrapping = false;
		if ((Object)(object)_font != (Object)null)
		{
			((TMP_Text)component).font = _font;
		}
		return component;
	}

	private static void ConfigureRect(RectTransform rect, RectTransform parent, Vector2 position, Vector2 size)
	{
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_0028: 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_0048: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		((Transform)rect).SetParent((Transform)(object)parent, false);
		rect.anchorMin = new Vector2(0.5f, 0.5f);
		rect.anchorMax = new Vector2(0.5f, 0.5f);
		rect.pivot = new Vector2(0.5f, 0.5f);
		rect.anchoredPosition = position;
		rect.sizeDelta = size;
	}

	private void SortNow()
	{
		if (InventorySorter.TrySort(_inventory))
		{
			_scrollView?.LayoutSlots(resetScroll: true);
		}
		RefreshLocalization();
	}

	private void RefreshLocalization()
	{
		if ((Object)(object)_searchPlaceholder != (Object)null)
		{
			((TMP_Text)_searchPlaceholder).text = ModLocalization.Text("Suchen …", "Search …");
		}
		_language?.SetOptions(ModLocalization.Text("Spr.", "Lang."), ModLocalization.LanguageOptionLabels, ModLocalization.CurrentModeIndex);
		_filter?.SetOptions(ModLocalization.Text("Filter", "Filter"), InventoryToolsState.FilterLabels, (int)InventoryToolsState.Filter);
		_sortMode?.SetOptions(ModLocalization.Text("Sort.", "Sort"), InventoryToolsState.SortLabels, (int)InventoryToolsState.PendingSortMode);
		if ((Object)(object)_directionText != (Object)null)
		{
			((TMP_Text)_directionText).text = (InventoryToolsState.PendingDescending ? "↓" : "↑");
		}
		if ((Object)(object)_sortButtonText != (Object)null)
		{
			((TMP_Text)_sortButtonText).text = ModLocalization.Text("Sort.", "Sort");
		}
		_scrollView?.LayoutSlots();
	}

	private void DisableExternalAutoSortButtons()
	{
		Transform val = (((Object)(object)_inventory?.InvWindow != (Object)null) ? _inventory.InvWindow.transform : ((Component)this).transform.parent);
		if ((Object)(object)val == (Object)null)
		{
			return;
		}
		Transform[] componentsInChildren = ((Component)val).GetComponentsInChildren<Transform>(true);
		foreach (Transform val2 in componentsInChildren)
		{
			if ((Object)(object)val2 != (Object)null && (Object)(object)((Component)val2).gameObject != (Object)(object)((Component)this).gameObject && string.Equals(((Object)val2).name, "AutoSortButton", StringComparison.Ordinal))
			{
				((Component)val2).gameObject.SetActive(false);
			}
		}
	}
}
internal sealed class InventoryChoiceDropdown : MonoBehaviour
{
	private TextMeshProUGUI _caption;

	private RectTransform _optionsPanel;

	private TMP_FontAsset _font;

	private string _prefix = string.Empty;

	private IReadOnlyList<string> _options = Array.Empty<string>();

	private int _selected;

	private Action<int> _selectionHandler;

	internal static InventoryChoiceDropdown Create(RectTransform parent, string name, Vector2 position, Vector2 size, TMP_FontAsset font)
	{
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		//IL_005a: 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)
		//IL_0084: Unknown result type (might be due to invalid IL or missing references)
		//IL_008f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0096: Unknown result type (might be due to invalid IL or missing references)
		//IL_009c: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c2: 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_0115: 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_0153: Unknown result type (might be due to invalid IL or missing references)
		//IL_016a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0174: Expected O, but got Unknown
		GameObject val = new GameObject(name, new Type[4]
		{
			typeof(RectTransform),
			typeof(Image),
			typeof(Button),
			typeof(InventoryChoiceDropdown)
		});
		RectTransform component = val.GetComponent<RectTransform>();
		((Transform)component).SetParent((Transform)(object)parent, false);
		component.anchorMin = new Vector2(0.5f, 0.5f);
		component.anchorMax = new Vector2(0.5f, 0.5f);
		component.pivot = new Vector2(0.5f, 0.5f);
		component.anchoredPosition = position;
		component.sizeDelta = size;
		Image component2 = val.GetComponent<Image>();
		((Graphic)component2).color = new Color(0.055f, 0.18f, 0.22f, 0.98f);
		Button component3 = val.GetComponent<Button>();
		((Selectable)component3).targetGraphic = (Graphic)(object)component2;
		InventoryChoiceDropdown component4 = val.GetComponent<InventoryChoiceDropdown>();
		component4._font = font;
		component4._caption = component4.CreateText(component, "Caption", 11.5f);
		((TMP_Text)component4._caption).rectTransform.anchorMin = Vector2.zero;
		((TMP_Text)component4._caption).rectTransform.anchorMax = Vector2.one;
		((TMP_Text)component4._caption).rectTransform.offsetMin = new Vector2(3f, 0f);
		((TMP_Text)component4._caption).rectTransform.offsetMax = new Vector2(-3f, 0f);
		((UnityEvent)component3.onClick).AddListener(new UnityAction(component4.Toggle));
		return component4;
	}

	internal void SetSelectionHandler(Action<int> handler)
	{
		_selectionHandler = handler;
	}

	internal void SetOptions(string prefix, IReadOnlyList<string> options, int selected)
	{
		_prefix = prefix ?? string.Empty;
		_options = options ?? Array.Empty<string>();
		_selected = Mathf.Clamp(selected, 0, Math.Max(0, _options.Count - 1));
		if ((Object)(object)_caption != (Object)null)
		{
			string text = ((_options.Count > 0) ? _options[_selected] : string.Empty);
			((TMP_Text)_caption).text = _prefix + ": " + text + " ▼";
		}
		if ((Object)(object)_optionsPanel != (Object)null && ((Component)_optionsPanel).gameObject.activeSelf)
		{
			BuildOptions();
		}
	}

	private void Toggle()
	{
		bool flag = (Object)(object)_optionsPanel == (Object)null || !((Component)_optionsPanel).gameObject.activeSelf;
		InventoryChoiceDropdown[] componentsInChildren = ((Component)((Component)this).transform.parent).GetComponentsInChildren<InventoryChoiceDropdown>(true);
		foreach (InventoryChoiceDropdown inventoryChoiceDropdown in componentsInChildren)
		{
			if ((Object)(object)inventoryChoiceDropdown != (Object)(object)this)
			{
				inventoryChoiceDropdown.Close();
			}
		}
		if (!flag)
		{
			Close();
			return;
		}
		BuildOptions();
		((Component)_optionsPanel).gameObject.SetActive(true);
		((Component)this).transform.SetAsLastSibling();
	}

	private void Close()
	{
		if ((Object)(object)_optionsPanel != (Object)null)
		{
			((Component)_optionsPanel).gameObject.SetActive(false);
		}
	}

	private void BuildOptions()
	{
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Expected O, but got Unknown
		//IL_006a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0084: Unknown result type (might be due to invalid IL or missing references)
		//IL_009e: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b8: 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_0135: Unknown result type (might be due to invalid IL or missing references)
		//IL_019a: Unknown result type (might be due to invalid IL or missing references)
		//IL_019f: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
		//IL_020c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0222: Unknown result type (might be due to invalid IL or missing references)
		//IL_022c: Unknown result type (might be due to invalid IL or missing references)
		//IL_026e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0253: Unknown result type (might be due to invalid IL or missing references)
		//IL_02af: Unknown result type (might be due to invalid IL or missing references)
		//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
		//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
		//IL_02f2: Unknown result type (might be due to invalid IL or missing references)
		//IL_0309: Unknown result type (might be due to invalid IL or missing references)
		//IL_0313: Expected O, but got Unknown
		if ((Object)(object)_optionsPanel == (Object)null)
		{
			GameObject val = new GameObject("Options", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			_optionsPanel = val.GetComponent<RectTransform>();
			((Transform)_optionsPanel).SetParent(((Component)this).transform, false);
			_optionsPanel.anchorMin = new Vector2(0f, 0f);
			_optionsPanel.anchorMax = new Vector2(1f, 0f);
			_optionsPanel.pivot = new Vector2(0.5f, 1f);
			_optionsPanel.anchoredPosition = new Vector2(0f, -1f);
			((Graphic)val.GetComponent<Image>()).color = new Color(0.015f, 0.05f, 0.065f, 0.99f);
		}
		Transform[] array = ((IEnumerable)_optionsPanel).Cast<Transform>().ToArray();
		for (int i = 0; i < array.Length; i++)
		{
			Object.DestroyImmediate((Object)(object)((Component)array[i]).gameObject);
		}
		_optionsPanel.sizeDelta = new Vector2(0f, 22f * (float)_options.Count + 2f);
		for (int j = 0; j < _options.Count; j++)
		{
			int captured = j;
			GameObject val2 = new GameObject($"Option_{j}", new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(Button)
			});
			RectTransform component = val2.GetComponent<RectTransform>();
			((Transform)component).SetParent((Transform)(object)_optionsPanel, false);
			component.anchorMin = new Vector2(0f, 1f);
			component.anchorMax = new Vector2(1f, 1f);
			component.pivot = new Vector2(0.5f, 1f);
			component.anchoredPosition = new Vector2(0f, -1f - (float)j * 22f);
			component.sizeDelta = new Vector2(0f, 22f);
			Image component2 = val2.GetComponent<Image>();
			((Graphic)component2).color = ((j == _selected) ? new Color(0.55f, 0.4f, 0.12f, 0.98f) : new Color(0.055f, 0.18f, 0.22f, 0.98f));
			Button component3 = val2.GetComponent<Button>();
			((Selectable)component3).targetGraphic = (Graphic)(object)component2;
			TextMeshProUGUI obj = CreateText(component, "Label", 11.5f);
			((TMP_Text)obj).text = _options[j];
			((TMP_Text)obj).rectTransform.anchorMin = Vector2.zero;
			((TMP_Text)obj).rectTransform.anchorMax = Vector2.one;
			((TMP_Text)obj).rectTransform.offsetMin = new Vector2(3f, 0f);
			((TMP_Text)obj).rectTransform.offsetMax = new Vector2(-3f, 0f);
			((UnityEvent)component3.onClick).AddListener((UnityAction)delegate
			{
				_selected = captured;
				Close();
				_selectionHandler?.Invoke(captured);
			});
		}
	}

	private TextMeshProUGUI CreateText(RectTransform parent, string name, float size)
	{
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = new GameObject(name, new Type[2]
		{
			typeof(RectTransform),
			typeof(TextMeshProUGUI)
		});
		((Transform)val.GetComponent<RectTransform>()).SetParent((Transform)(object)parent, false);
		TextMeshProUGUI component = val.GetComponent<TextMeshProUGUI>();
		((TMP_Text)component).alignment = (TextAlignmentOptions)514;
		((TMP_Text)component).fontSize = size;
		((Graphic)component).color = Color.white;
		((TMP_Text)component).enableWordWrapping = false;
		((Graphic)component).raycastTarget = false;
		if ((Object)(object)_font != (Object)null)
		{
			((TMP_Text)component).font = _font;
		}
		return component;
	}
}
internal static class InventorySorter
{
	private sealed class SlotSnapshot
	{
		internal readonly ItemIcon Slot;

		internal readonly Item Item;

		internal readonly int Quantity;

		internal readonly int OriginalIndex;

		internal SlotSnapshot(ItemIcon slot, Item item, int quantity, int originalIndex)
		{
			Slot = slot;
			Item = item;
			Quantity = quantity;
			OriginalIndex = originalIndex;
		}
	}

	private sealed class HotkeySnapshot
	{
		internal readonly Hotkeys Hotkey;

		internal readonly ItemIcon OriginalSlot;

		internal readonly int OriginalInvSlotIndex;

		internal HotkeySnapshot(Hotkeys hotkey, ItemIcon originalSlot, int originalInvSlotIndex)
		{
			Hotkey = hotkey;
			OriginalSlot = originalSlot;
			OriginalInvSlotIndex = originalInvSlotIndex;
		}
	}

	private sealed class SortEntry
	{
		internal readonly Item Item;

		internal readonly int Quantity;

		internal readonly int OriginalIndex;

		internal readonly List<Hotkeys> Hotkeys;

		internal SortEntry(Item item, int quantity, int originalIndex, List<Hotkeys> hotkeys)
		{
			Item = item;
			Quantity = quantity;
			OriginalIndex = originalIndex;
			Hotkeys = hotkeys;
		}
	}

	private sealed class StackGroup
	{
		internal readonly Item Item;

		internal readonly int OriginalIndex;

		internal readonly List<Hotkeys> Hotkeys = new List<Hotkeys>();

		internal long Total;

		internal StackGroup(Item item, int originalIndex)
		{
			Item = item;
			OriginalIndex = originalIndex;
		}
	}

	private readonly struct ComparisonSlot
	{
		internal readonly Item Item;

		internal readonly int Quantity;

		internal ComparisonSlot(Item item, int quantity)
		{
			Item = item;
			Quantity = quantity;
		}
	}

	private sealed class ReferenceComparer<T> : IEqualityComparer<T> where T : class
	{
		internal static readonly ReferenceComparer<T> Instance = new ReferenceComparer<T>();

		public bool Equals(T left, T right)
		{
			return left == right;
		}

		public int GetHashCode(T value)
		{
			return RuntimeHelpers.GetHashCode(value);
		}
	}

	internal static bool TrySort(Inventory inventory)
	{
		if (!CanSort(inventory, out var reason))
		{
			TaschenhaendlerPlugin.NotifyPlayer(reason);
			return false;
		}
		CharacterProgress current = ProgressStore.Current;
		List<ItemIcon> list = inventory.StoredSlots.Where((ItemIcon slot) => IsSortableSlot(inventory, slot)).ToList();
		List<SlotSnapshot> snapshot = list.Select((ItemIcon slot, int index) => new SlotSnapshot(slot, slot.MyItem, slot.Quantity, index)).ToList();
		List<HotkeySnapshot> hotkeys = CaptureHotkeys(list);
		bool flag = false;
		try
		{
			List<SortEntry> list2 = BuildEntries(snapshot, hotkeys, inventory.Empty, TaschenhaendlerPlugin.Instance.MergeStacksOnSort.Value);
			InventorySortMode mode = InventoryToolsState.PendingSortMode;
			bool descending = InventoryToolsState.PendingDescending;
			list2.Sort((SortEntry left, SortEntry right) => CompareEntries(left, right, mode, descending));
			foreach (ItemIcon item in list)
			{
				item.MyItem = inventory.Empty;
				item.Quantity = 0;
				item.assignedHotkey = null;
			}
			for (int num = 0; num < list2.Count; num++)
			{
				SortEntry sortEntry = list2[num];
				ItemIcon val = list[num];
				val.MyItem = sortEntry.Item;
				val.Quantity = sortEntry.Quantity;
				foreach (Hotkeys hotkey in sortEntry.Hotkeys)
				{
					if (!((Object)(object)hotkey == (Object)null))
					{
						hotkey.AssignItemFrominv(val);
						hotkey.UpdateImg();
						val.assignedHotkey = hotkey;
					}
				}
			}
			foreach (ItemIcon item2 in list)
			{
				item2.UpdateSlotImage();
			}
			inventory.UpdatePlayerInventory();
			InventoryExpansionController.CaptureOverflow(current);
			if (!ProgressStore.Save())
			{
				throw new InvalidOperationException("Sidecar save failed");
			}
			flag = true;
			if (!InventoryExpansionController.SaveNativeAfterSidecarCommit())
			{
				throw new InvalidOperationException("Native character save failed");
			}
			TaschenhaendlerPlugin.NotifyPlayer(ModLocalization.Text("Inventar sortiert; Hotkeys und Zusatzplätze wurden beibehalten.", "Inventory sorted; hotkeys and extra slots were preserved."));
			return true;
		}
		catch (Exception arg)
		{
			RestoreSnapshot(inventory, snapshot, hotkeys);
			InventoryExpansionController.CaptureOverflow(current);
			if (flag)
			{
				ProgressStore.Save();
			}
			TaschenhaendlerPlugin.ModLog.LogError((object)$"Inventarsortierung wurde zurückgerollt: {arg}");
			TaschenhaendlerPlugin.NotifyPlayer(ModLocalization.Text("Sortierung fehlgeschlagen; das Inventar wurde vollständig zurückgesetzt.", "Sorting failed; the inventory was fully restored."));
			return false;
		}
	}

	internal static int CompareItemSlots(ItemIcon left, ItemIcon right, InventorySortMode mode)
	{
		Item myItem = left.MyItem;
		Item myItem2 = right.MyItem;
		return mode switch
		{
			InventorySortMode.Name => CultureInfo.InvariantCulture.CompareInfo.Compare(myItem.ItemName ?? string.Empty, myItem2.ItemName ?? string.Empty, CompareOptions.IgnoreCase), 
			InventorySortMode.Type => CompareType(myItem, myItem2), 
			InventorySortMode.Level => myItem.ItemLevel.CompareTo(myItem2.ItemLevel), 
			InventorySortMode.Value => myItem.ItemValue.CompareTo(myItem2.ItemValue), 
			InventorySortMode.Quantity => GetQuantityKey(left).CompareTo(GetQuantityKey(right)), 
			_ => 0, 
		};
	}

	private static bool CanSort(Inventory inventory, out string reason)
	{
		if ((Object)(object)inventory == (Object)null || !inventory.isPlayer || (Object)(object)inventory.InvWindow == (Object)null || !inventory.InvWindow.activeSelf)
		{
			reason = ModLocalization.Text("Öffne zuerst dein Inventar.", "Open your inventory first.");
			return false;
		}
		if (ProgressStore.Current == null)
		{
			reason = ModLocalization.Text("Kein aktiver Charakterfortschritt gefunden.", "No active character progress was found.");
			return false;
		}
		if (GameData.InCharSelect || GameData.VendorWindowOpen || GameData.AuctionWindowOpen || GameData.Trading)
		{
			reason = ModLocalization.Text("Während eines anderen Inventarvorgangs kann nicht sortiert werden.", "Sorting is unavailable during another inventory transaction.");
			return false;
		}
		if ((Object)(object)GameData.ItemOnCursor != (Object)null && (Object)(object)GameData.ItemOnCursor != (Object)(object)inventory.Empty)
		{
			reason = ModLocalization.Text("Lege zuerst das Item am Mauszeiger ab.", "Place the item on your cursor first.");
			return false;
		}
		if (inventory.StoredSlots.Any((ItemIcon slot) => (Object)(object)slot != (Object)null && slot.dragging))
		{
			reason = ModLocalization.Text("Beende zuerst das Ziehen eines Items.", "Finish dragging the item first.");
			return false;
		}
		reason = string.Empty;
		return true;
	}

	private static bool IsSortableSlot(Inventory inventory, ItemIcon slot)
	{
		//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)slot != (Object)null && (int)slot.ThisSlotType == 0 && !slot.TrashSlot && !slot.VendorSlot && !slot.LootSlot && !slot.BankSlot && !slot.DisplayOnly && !slot.NotInInventory && !slot.CosmeticOnly && !slot.NoStackables && (inventory.CosmeticSlots == null || !inventory.CosmeticSlots.Contains(slot)))
		{
			return !InventoryExpansionController.IsReservedUnresolvedSlot(slot);
		}
		return false;
	}

	private static List<HotkeySnapshot> CaptureHotkeys(List<ItemIcon> targets)
	{
		List<HotkeySnapshot> list = new List<HotkeySnapshot>();
		if (GameData.GM?.HKManager?.AllHotkeys == null)
		{
			return list;
		}
		HashSet<ItemIcon> hashSet = new HashSet<ItemIcon>(targets);
		foreach (Hotkeys allHotkey in GameData.GM.HKManager.AllHotkeys)
		{
			if ((Object)(object)allHotkey?.AssignedItem != (Object)null && hashSet.Contains(allHotkey.AssignedItem))
			{
				list.Add(new HotkeySnapshot(allHotkey, allHotkey.AssignedItem, allHotkey.InvSlotIndex));
			}
		}
		return list;
	}

	private static List<SortEntry> BuildEntries(List<SlotSnapshot> snapshot, List<HotkeySnapshot> hotkeys, Item empty, bool mergeStacks)
	{
		List<SortEntry> list = new List<SortEntry>();
		Dictionary<ItemIcon, List<Hotkeys>> dictionary = (from binding in hotkeys
			group binding by binding.OriginalSlot).ToDictionary((IGrouping<ItemIcon, HotkeySnapshot> group) => group.Key, (IGrouping<ItemIcon, HotkeySnapshot> group) => group.Select((HotkeySnapshot binding) => binding.Hotkey).ToList());
		Dictionary<Item, StackGroup> dictionary2 = new Dictionary<Item, StackGroup>(ReferenceComparer<Item>.Instance);
		Dictionary<Item, int> dictionary3 = new Dictionary<Item, int>(ReferenceComparer<Item>.Instance);
		foreach (SlotSnapshot item in snapshot)
		{
			if (!((Object)(object)item.Item == (Object)null) && !((Object)(object)item.Item == (Object)(object)empty) && item.Item.Stackable)
			{
				List<Hotkeys> value;
				int num = (dictionary.TryGetValue(item.Slot, out value) ? value.Count : 0);
				dictionary3.TryGetValue(item.Item, out var value2);
				dictionary3[item.Item] = value2 + num;
			}
		}
		foreach (SlotSnapshot item2 in snapshot)
		{
			if ((Object)(object)item2.Item == (Object)null || (Object)(object)item2.Item == (Object)(object)empty)
			{
				continue;
			}
			List<Hotkeys> value3;
			List<Hotkeys> list2 = (dictionary.TryGetValue(item2.Slot, out value3) ? value3 : new List<Hotkeys>());
			int value4;
			bool flag = !dictionary3.TryGetValue(item2.Item, out value4) || value4 <= 1;
			if (mergeStacks && item2.Item.Stackable && flag)
			{
				if (!dictionary2.TryGetValue(item2.Item, out var value5))
				{
					value5 = new StackGroup(item2.Item, item2.OriginalIndex);
					dictionary2.Add(item2.Item, value5);
				}
				value5.Total += Math.Max(1L, item2.Quantity);
				value5.Hotkeys.AddRange(list2);
			}
			else
			{
				list.Add(new SortEntry(item2.Item, item2.Quantity, item2.OriginalIndex, list2));
			}
		}
		foreach (StackGroup value6 in dictionary2.Values)
		{
			long num2 = value6.Total;
			bool flag2 = true;
			while (num2 > 0)
			{
				int num3 = (int)((num2 > int.MaxValue) ? int.MaxValue : num2);
				list.Add(new SortEntry(value6.Item, num3, value6.OriginalIndex, flag2 ? value6.Hotkeys : new List<Hotkeys>()));
				num2 -= num3;
				flag2 = false;
			}
		}
		return list;
	}

	private static int CompareEntries(SortEntry left, SortEntry right, InventorySortMode mode, bool descending)
	{
		ComparisonSlot left2 = new ComparisonSlot(left.Item, left.Quantity);
		ComparisonSlot right2 = new ComparisonSlot(right.Item, right.Quantity);
		int num = CompareValues(left2, right2, mode);
		if (descending)
		{
			num = -num;
		}
		if (num != 0)
		{
			return num;
		}
		int num2 = CultureInfo.InvariantCulture.CompareInfo.Compare(left.Item.ItemName ?? string.Empty, right.Item.ItemName ?? string.Empty, CompareOptions.IgnoreCase);
		if (num2 != 0)
		{
			return num2;
		}
		int num3 = string.Compare(((BaseScriptableObject)left.Item).Id, ((BaseScriptableObject)right.Item).Id, StringComparison.Ordinal);
		if (num3 == 0)
		{
			return left.OriginalIndex.CompareTo(right.OriginalIndex);
		}
		return num3;
	}

	private static int CompareValues(ComparisonSlot left, ComparisonSlot right, InventorySortMode mode)
	{
		return mode switch
		{
			InventorySortMode.Name => CultureInfo.InvariantCulture.CompareInfo.Compare(left.Item.ItemName ?? string.Empty, right.Item.ItemName ?? string.Empty, CompareOptions.IgnoreCase), 
			InventorySortMode.Type => CompareType(left.Item, right.Item), 
			InventorySortMode.Level => left.Item.ItemLevel.CompareTo(right.Item.ItemLevel), 
			InventorySortMode.Value => left.Item.ItemValue.CompareTo(right.Item.ItemValue), 
			InventorySortMode.Quantity => ((!left.Item.Stackable) ? 1 : left.Quantity).CompareTo((!right.Item.Stackable) ? 1 : right.Quantity), 
			_ => 0, 
		};
	}

	private static int CompareType(Item left, Item right)
	{
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Expected I4, but got Unknown
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Expected I4, but got Unknown
		int num = GetTypeRank(left).CompareTo(GetTypeRank(right));
		if (num == 0)
		{
			return ((int)left.RequiredSlot).CompareTo((int)right.RequiredSlot);
		}
		return num;
	}

	private static int GetTypeRank(Item item)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Invalid comparison between Unknown and I4
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Invalid comparison between Unknown and I4
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Invalid comparison between Unknown and I4
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		if ((int)item.RequiredSlot == 13 || (int)item.RequiredSlot == 14 || (int)item.RequiredSlot == 15 || item.WeaponDmg != 0 || (int)item.ThisWeaponType != 0)
		{
			return 0;
		}
		if ((int)item.RequiredSlot != 0)
		{
			return 1;
		}
		if ((Object)(object)item.ItemEffectOnClick != (Object)null || (Object)(object)item.ItemSkillUse != (Object)null || item.Disposable)
		{
			return 2;
		}
		if (item.Template || item.FuelSource || item.Mining > 0 || item.FurnitureSet)
		{
			return 3;
		}
		if ((Object)(object)item.AssignQuestOnRead != (Object)null || (Object)(object)item.CompleteOnRead != (Object)null || !string.IsNullOrWhiteSpace(item.BookTitle))
		{
			return 4;
		}
		return 5;
	}

	private static int GetQuantityKey(ItemIcon slot)
	{
		if (!((Object)(object)slot.MyItem != (Object)null) || !slot.MyItem.Stackable)
		{
			return 1;
		}
		return slot.Quantity;
	}

	private static void RestoreSnapshot(Inventory inventory, List<SlotSnapshot> snapshot, List<HotkeySnapshot> hotkeys)
	{
		foreach (SlotSnapshot item in snapshot)
		{
			item.Slot.MyItem = item.Item;
			item.Slot.Quantity = item.Quantity;
			item.Slot.assignedHotkey = null;
			item.Slot.UpdateSlotImage();
		}
		foreach (HotkeySnapshot hotkey in hotkeys)
		{
			if (!((Object)(object)hotkey.Hotkey == (Object)null) && !((Object)(object)hotkey.OriginalSlot == (Object)null))
			{
				hotkey.Hotkey.AssignItemFrominv(hotkey.OriginalSlot);
				hotkey.Hotkey.InvSlotIndex = hotkey.OriginalInvSlotIndex;
				hotkey.Hotkey.UpdateImg();
				hotkey.OriginalSlot.assignedHotkey = hotkey.Hotkey;
			}
		}
		inventory.UpdatePlayerInventory();
	}
}
[HarmonyPatch(typeof(Inventory), "UpdatePlayerInventory")]
internal static class InventoryToolsRefreshPatch
{
	[HarmonyPostfix]
	[HarmonyPriority(0)]
	private static void Postfix(Inventory __instance)
	{
		if ((Object)(object)__instance != (Object)null && __instance.isPlayer)
		{
			InventoryExpansionController.RefreshLayout();
		}
	}
}
internal enum ModLanguageMode
{
	Auto,
	German,
	English
}
internal static class ModLocalization
{
	private static readonly string[] StableModes = new string[3] { "Auto", "German", "English" };

	internal static bool IsGerman
	{
		get
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			switch (CurrentMode)
			{
			case ModLanguageMode.Auto:
				if ((int)Application.systemLanguage != 15)
				{
					return string.Equals(CultureInfo.CurrentUICulture.TwoLetterISOLanguageName, "de", StringComparison.OrdinalIgnoreCase);
				}
				return true;
			default:
				return false;
			case ModLanguageMode.German:
				return true;
			}
		}
	}

	internal static ModLanguageMode CurrentMode
	{
		get
		{
			if (!TryParseMode(TaschenhaendlerPlugin.Instance?.LanguageMode?.Value, out var mode))
			{
				return ModLanguageMode.Auto;
			}
			return mode;
		}
	}

	internal static int CurrentModeIndex => (int)CurrentMode;

	internal static IReadOnlyList<string> LanguageOptionLabels
	{
		get
		{
			if (IsGerman)
			{
				return new string[3] { "Auto", "Deutsch", "Englisch" };
			}
			return new string[3] { "Auto", "German", "English" };
		}
	}

	internal static string MerchantRole => Text("Taschen-Händlerin", "Bag Merchant");

	internal static string MessagePrefix => Text("Taschen-Händlerin", "Bag Merchant");

	internal static string Text(string german, string english)
	{
		if (!IsGerman)
		{
			return english;
		}
		return german;
	}

	internal static string Format(string german, string english, params object[] arguments)
	{
		return string.Format(Text(german, english), arguments);
	}

	internal static void SetModeByIndex(int index)
	{
		index = Mathf.Clamp(index, 0, StableModes.Length - 1);
		if (TaschenhaendlerPlugin.Instance?.LanguageMode != null)
		{
			TaschenhaendlerPlugin.Instance.LanguageMode.Value = StableModes[index];
		}
	}

	internal static bool TryParseMode(string value, out ModLanguageMode mode)
	{
		if (string.Equals(value, "German", StringComparison.OrdinalIgnoreCase) || string.Equals(value, "Deutsch", StringComparison.OrdinalIgnoreCase) || string.Equals(value, "de", StringComparison.OrdinalIgnoreCase))
		{
			mode = ModLanguageMode.German;
			return true;
		}
		if (string.Equals(value, "English", StringComparison.OrdinalIgnoreCase) || string.Equals(value, "Englisch", StringComparison.OrdinalIgnoreCase) || string.Equals(value, "en", StringComparison.OrdinalIgnoreCase))
		{
			mode = ModLanguageMode.English;
			return true;
		}
		if (string.IsNullOrWhiteSpace(value) || string.Equals(value, "Auto", StringComparison.OrdinalIgnoreCase) || string.Equals(value, "Automatic", StringComparison.OrdinalIgnoreCase) || string.Equals(value, "Automatisch", StringComparison.OrdinalIgnoreCase))
		{
			mode = ModLanguageMode.Auto;
			return true;
		}
		mode = ModLanguageMode.Auto;
		return false;
	}
}
internal sealed class BagVendorMarker : MonoBehaviour
{
	internal string SceneName;

	internal Vector3 AnchorPosition;

	internal int SourceVendorInstanceId;

	internal int NameIndex;

	private IEnumerator Start()
	{
		yield return null;
		MerchantController.RefreshVendorPresentation(this);
	}
}
internal static class MerchantController
{
	private sealed class ProgressWriteException : Exception
	{
	}

	private static readonly string[] GermanVendorNames = new string[12]
	{
		"Mara – Taschen-Händlerin", "Borin – Gepäckmeister", "Lina – Hüterin der Taschen", "Taro – Taschen-Händler", "Selma – Reiseausstatterin", "Oren – Gepäckhändler", "Nira – Taschen-Händlerin", "Fenn – Meister der Beutel", "Kara – Reisehändlerin", "Jorin – Taschen-Händler",
		"Alva – Gepäckmeisterin", "Rumo – Reiseausstatter"
	};

	private static readonly string[] EnglishVendorNames = new string[12]
	{
		"Mara – Bag Merchant", "Borin – Luggage Master", "Lina – Keeper of Bags", "Taro – Bag Merchant", "Selma – Travel Outfitter", "Oren – Luggage Merchant", "Nira – Bag Merchant", "Fenn – Master of Pouches", "Kara – Travel Merchant", "Jorin – Bag Merchant",
		"Alva – Luggage Expert", "Rumo – Travel Outfitter"
	};

	private static TaschenhaendlerPlugin _plugin;

	private static readonly HashSet<int> PendingSources = new HashSet<int>();

	internal static Item ExpansionItem { get; private set; }

	internal static void Initialize(TaschenhaendlerPlugin plugin)
	{
		_plugin = plugin;
		PendingSources.Clear();
	}

	internal static void Shutdown()
	{
		PendingSources.Clear();
		_plugin = null;
	}

	internal static void OnSceneLoaded(Scene scene)
	{
		PendingSources.Clear();
	}

	internal static void OnSceneUnloaded(Scene scene)
	{
		PendingSources.Clear();
	}

	internal static void RegisterExpansionItem(ItemDatabase database)
	{
		//IL_0153: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)database == (Object)null)
		{
			return;
		}
		try
		{
			Dictionary<string, Item> dictionary = Traverse.Create((object)database).Field("itemDict").GetValue<Dictionary<string, Item>>();
			if (dictionary != null && dictionary.TryGetValue("CBRA_TASCHENHAENDLER_INVENTARERWEITERUNG_V1", out var value) && (Object)(object)value != (Object)null)
			{
				ExpansionItem = value;
				RefreshOffer();
				RebindExistingExpansionItems();
				InventoryExpansionController.RestorePendingExpansionItems();
				return;
			}
			Item value2 = null;
			dictionary?.TryGetValue("315843", out value2);
			value2 = value2 ?? database.ItemDB?.FirstOrDefault((Func<Item, bool>)((Item val2) => (Object)(object)val2 != (Object)null && (Object)(object)val2.ItemIcon != (Object)null));
			value2 = value2 ?? database.ItemDBList?.FirstOrDefault((Func<Item, bool>)((Item val2) => (Object)(object)val2 != (Object)null && (Object)(object)val2.ItemIcon != (Object)null));
			if ((Object)(object)value2 == (Object)null)
			{
				TaschenhaendlerPlugin.ModLog.LogError((object)"Inventarerweiterungsitem konnte nicht erzeugt werden: Keine Item-Vorlage gefunden.");
				return;
			}
			Item item = Object.Instantiate<Item>(value2);
			((Object)item).name = "CBra Inventory Expansion";
			((BaseScriptableObject)item).Id = "CBRA_TASCHENHAENDLER_INVENTARERWEITERUNG_V1";
			item.ItemName = ModLocalization.Text("Inventarerweiterung (+10 Plätze)", "Inventory Expansion (+10 slots)");
			item.ItemLevel = 1;
			item.RequiredSlot = (SlotType)0;
			item.Classes = new List<Class>
			{
				GameData.ClassDB?.Paladin,
				GameData.ClassDB?.Arcanist,
				GameData.ClassDB?.Duelist,
				GameData.ClassDB?.Druid,
				GameData.ClassDB?.Stormcaller,
				GameData.ClassDB?.Reaver
			}.Where((Class characterClass) => (Object)(object)characterClass != (Object)null).Distinct().ToList();
			item.Stackable = true;
			item.Disposable = true;
			item.Unique = false;
			item.PlayerCannotSell = true;
			item.NoTradeNoDestroy = true;
			item.SimPlayersCantGet = true;
			item.MustBeEquippedToClick = false;
			item.TeachSpell = null;
			item.TeachSkill = null;
			item.ItemSkillUse = null;
			item.AssignQuestOnRead = null;
			item.CompleteOnRead = null;
			item.WeaponProcOnHit = null;
			item.Aura = null;
			item.WornEffect = null;
			item.BookTitle = string.Empty;
			Spell val = ScriptableObject.CreateInstance<Spell>();
			((Object)val).name = "CBra Inventory Expansion Click Gate";
			((BaseScriptableObject)val).Id = "CBRA_TASCHENHAENDLER_CLICK_GATE_V1";
			val.SpellName = ModLocalization.Text("Inventar erweitern", "Expand inventory");
			val.SpellDesc = ModLocalization.Text("Verbraucht die Erweiterung und fügt dem Inventar dauerhaft weitere Plätze hinzu.", "Consumes the expansion and permanently adds more inventory slots.");
			((Object)val).hideFlags = (HideFlags)61;
			item.ItemEffectOnClick = val;
			((Object)item).hideFlags = (HideFlags)61;
			ExpansionItem = item;
			if (dictionary == null)
			{
				dictionary = new Dictionary<string, Item>(StringComparer.Ordinal);
				Traverse.Create((object)database).Field("itemDict").SetValue((object)dictionary);
			}
			dictionary[((BaseScriptableObject)item).Id] = item;
			if (database.ItemDBList == null)
			{
				database.ItemDBList = new List<Item>();
			}
			if (!database.ItemDBList.Any((Item entry) => (Object)(object)entry != (Object)null && ((BaseScriptableObject)entry).Id == ((BaseScriptableObject)item).Id))
			{
				database.ItemDBList.Add(item);
			}
			List<Item> list = database.ItemDB?.Where((Item entry) => (Object)(object)entry != (Object)null).ToList() ?? new List<Item>();
			if (!list.Any((Item entry) => ((BaseScriptableObject)entry).Id == ((BaseScriptableObject)item).Id))
			{
				list.Add(item);
				database.ItemDB = list.ToArray();
			}
			RefreshOffer();
			RebindExistingExpansionItems();
			InventoryExpansionController.RestorePendingExpansionItems();
			VendorInventory[] array = Object.FindObjectsOfType<VendorInventory>();
			for (int num = 0; num < array.Length; num++)
			{
				OnVendorStarted(array[num]);
			}
			TaschenhaendlerPlugin.ModLog.LogInfo((object)"Inventarerweiterungsitem registriert.");
		}
		catch (Exception arg)
		{
			TaschenhaendlerPlugin.ModLog.LogError((object)$"Inventarerweiterungsitem konnte nicht registriert werden: {arg}");
		}
	}

	internal static void OnVendorStarted(VendorInventory source)
	{
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)_plugin == (Object)null || !IsAdventurerMerchant(source))
		{
			return;
		}
		Scene scene = ((Component)source).gameObject.scene;
		if (!((Scene)(ref scene)).IsValid() || !IsGameplayScene(((Scene)(ref scene)).name))
		{
			return;
		}
		NPC component = ((Component)source).GetComponent<NPC>();
		if (!((Object)(object)component == (Object)null) && !component.SummonedByPlayer && !((Object)source).name.StartsWith("Summoned:", StringComparison.OrdinalIgnoreCase))
		{
			int instanceID = ((Object)source).GetInstanceID();
			if (PendingSources.Add(instanceID))
			{
				((MonoBehaviour)_plugin).StartCoroutine(EnsureVendorAfterDelay(source, instanceID));
			}
		}
	}

	internal static void RefreshLocalization()
	{
		BagVendorMarker[] array = Object.FindObjectsOfType<BagVendorMarker>();
		for (int i = 0; i < array.Length; i++)
		{
			RefreshVendorPresentation(array[i]);
		}
		VendorWindow vendorWindow = GameData.VendorWindow;
		if ((Object)(object)vendorWindow != (Object)null && (Object)(object)vendorWindow.WindowParent != (Object)null && vendorWindow.WindowParent.activeSelf)
		{
			VendorInventory value = Traverse.Create((object)vendorWindow).Field("parent").GetValue<VendorInventory>();
			if ((Object)(object)value != (Object)null && (Object)(object)((Component)value).GetComponent<BagVendorMarker>() != (Object)null && (Object)(object)vendorWindow.LootSource != (Object)null)
			{
				((TMP_Text)vendorWindow.LootSource).text = ModLocalization.Format("Geschäfte mit {0}", "Doing business with {0}", ((Object)((Component)value).transform).name);
			}
		}
	}

	internal static void RefreshVendorPresentation(BagVendorMarker marker)
	{
		if ((Object)(object)marker == (Object)null)
		{
			return;
		}
		NPC component = ((Component)marker).GetComponent<NPC>();
		string vendorName = GetVendorName(marker.NameIndex);
		((Object)((Component)marker).gameObject).name = vendorName;
		if ((Object)(object)component != (Object)null)
		{
			component.NPCName = vendorName;
			Stats component2 = ((Component)marker).GetComponent<Stats>();
			if ((Object)(object)component2 != (Object)null)
			{
				component2.MyName = vendorName;
			}
		}
		VendorInventory component3 = ((Component)marker).GetComponent<VendorInventory>();
		if ((Object)(object)component3 != (Object)null)
		{
			component3.VendorDesc = ModLocalization.MerchantRole;
		}
		NPCDialog[] components = ((Component)marker).GetComponents<NPCDialog>();
		foreach (NPCDialog val in components)
		{
			if ((Object)(object)val != (Object)null)
			{
				val.Dialog = ModLocalization.Text("Grüße! Meine Inventarerweiterungen gelten bei jeder Taschen-Händlerin. Rechtsklick auf das gekaufte Item fügt dauerhaft weitere Plätze hinzu.", "Greetings! My inventory expansions are synchronized across every Bag Merchant. Right-click the purchased item to permanently add more slots.");
			}
		}
		RefreshVendorPresentation(component);
	}

	internal static void RefreshVendorPresentation(NPC npc)
	{
		if (!((Object)(object)npc == (Object)null) && !((Object)(object)((Component)npc).GetComponent<BagVendorMarker>() == (Object)null) && !((Object)(object)npc.NamePlateTxt == (Object)null))
		{
			((TMP_Text)npc.NamePlateTxt).text = npc.NPCName + "\n<" + ModLocalization.MerchantRole + ">";
		}
	}

	internal static void RefreshOffer()
	{
		if ((Object)(object)ExpansionItem == (Object)null)
		{
			return;
		}
		CharacterProgress current = ProgressStore.Current;
		BigInteger currentTotal = PriceMath.GetCurrentTotal(current);
		BigInteger paid = PriceMath.GetPaid(current);
		BigInteger bigInteger = BigInteger.Max(BigInteger.Zero, currentTotal - paid);
		int installment = PriceMath.GetInstallment(current);
		int num = (((Object)(object)_plugin != (Object)null) ? _plugin.SlotsPerExpansion.Value : 10);
		long oneBasedTier = ((current == null) ? 1 : (current.PurchasedCount + 1));
		ExpansionItem.ItemName = ModLocalization.Format("Inventarerweiterung (+{0} Plätze)", "Inventory Expansion (+{0} slots)", num);
		ExpansionItem.ItemValue = installment;
		string text = ((bigInteger > 2147483647L) ? ModLocalization.Format("Aktuelle Teilzahlung: {0} Gold", "Current installment: {0} gold", PriceMath.Format(new BigInteger(installment))) : ModLocalization.Format("Zu zahlen: {0} Gold", "Amount due: {0} gold", PriceMath.Format(bigInteger)));
		string text2 = ((paid > 0L) ? ModLocalization.Format("\nBereits bezahlt: {0} Gold", "\nAlready paid: {0} gold", PriceMath.Format(paid)) : string.Empty);
		ExpansionItem.Lore = ModLocalization.Format("Erweiterung {0}. Rechtsklick fügt diesem Charakter dauerhaft {1} Inventarplätze hinzu.\nGesamtpreis dieser Stufe: {2} Gold{3}\n{4}\nDer Kaufstand ist bei allen Taschen-Händlerinnen synchron.", "Expansion {0}. Right-click to permanently add {1} inventory slots to this character.\nTotal price for this tier: {2} gold{3}\n{4}\nPurchase progress is synchronized across all Bag Merchants.", TierName(oneBasedTier), num, PriceMath.Format(currentTotal), text2, text);
		if ((Object)(object)ExpansionItem.ItemEffectOnClick != (Object)null)
		{
			ExpansionItem.ItemEffectOnClick.SpellName = ModLocalization.Text("Inventar erweitern", "Expand inventory");
			ExpansionItem.ItemEffectOnClick.SpellDesc = ModLocalization.Text("Verbraucht die Erweiterung und fügt dem Inventar dauerhaft weitere Plätze hinzu.", "Consumes the expansion and permanently adds more inventory slots.");
		}
		BagVendorMarker[] array = Object.FindObjectsOfType<BagVendorMarker>();
		foreach (BagVendorMarker bagVendorMarker in array)
		{
			VendorInventory val = (((Object)(object)bagVendorMarker != (Object)null) ? ((Component)bagVendorMarker).GetComponent<VendorInventory>() : null);
			if ((Object)(object)val != (Object)null)
			{
				val.ItemsForSale = new List<Item> { ExpansionItem };
				val.QuestRewardsForSale = new List<Quest>();
			}
		}
		ItemIcon slotActiveForVendor = GameData.SlotActiveForVendor;
		if ((Object)(object)slotActiveForVendor != (Object)null && slotActiveForVendor.VendorSlot && TaschenhaendlerPlugin.IsExpansion(slotActiveForVendor.MyItem))
		{
			GameData.ActivateSlotForVendor(slotActiveForVendor);
		}
	}

	internal static bool HandlePurchase()
	{
		ItemIcon slotActiveForVendor = GameData.SlotActiveForVendor;
		if ((Object)(object)slotActiveForVendor == (Object)null || !slotActiveForVendor.VendorSlot || !TaschenhaendlerPlugin.IsExpansion(slotActiveForVendor.MyItem))
		{
			return false;
		}
		Inventory playerInv = GameData.PlayerInv;
		CharacterProgress characterProgress = ProgressStore.Current ?? ProgressStore.SelectCurrentCharacter();
		if ((Object)(object)playerInv == (Object)null || characterProgress == null)
		{
			TaschenhaendlerPlugin.NotifyPlayer(ModLocalization.Text("Der Charakterfortschritt ist noch nicht bereit.", "Character progress is not ready yet."));
			return true;
		}
		BigInteger currentTotal = PriceMath.GetCurrentTotal(characterProgress);
		BigInteger paid = PriceMath.GetPaid(characterProgress);
		BigInteger.Max(BigInteger.Zero, currentTotal - paid);
		int installment = PriceMath.GetInstallment(characterProgress);
		if (playerInv.Gold < installment)
		{
			TaschenhaendlerPlugin.NotifyPlayer(ModLocalization.Format("Dafür werden {0} Gold benötigt.", "You need {0} gold for this payment.", PriceMath.Format(new BigInteger(installment))));
			return true;
		}
		bool flag = paid + installment >= currentTotal;
		bool flag2 = false;
		if (flag)
		{
			flag2 = playerInv.AddItemToInv(ExpansionItem);
			if (!flag2)
			{
				TaschenhaendlerPlugin.NotifyPlayer(ModLocalization.Text("Das Inventar ist voll. Es wurde kein Gold abgezogen.", "Your inventory is full. No gold was deducted."));
				return true;
			}
		}
		int gold = playerInv.Gold;
		long purchasedCount = characterProgress.PurchasedCount;
		string nextPrice = characterProgress.NextPrice;
		string priceNumerator = characterProgress.PriceNumerator;
		string priceDenominator = characterProgress.PriceDenominator;
		string paidTowardNext = characterProgress.PaidTowardNext;
		bool flag3 = false;
		try
		{
			playerInv.Gold -= installment;
			checked
			{
				if (flag)
				{
					characterProgress.PurchasedCount++;
					PriceMath.Advance(characterProgress);
				}
				else
				{
					characterProgress.PaidTowardNext = (paid + installment).ToString(CultureInfo.InvariantCulture);
				}
				InventoryExpansionController.CaptureOverflow(characterProgress);
				if (!ProgressStore.Save())
				{
					throw new ProgressWriteException();
				}
				flag3 = true;
				RefreshGold(playerInv);
				RefreshOffer();
				if (!InventoryExpansionController.SaveNativeAfterSidecarCommit())
				{
					throw new InvalidOperationException("Erenshor hat den nativen Charakterstand nicht gespeichert.");
				}
			}
			if (flag)
			{
				TaschenhaendlerPlugin.NotifyPlayer(ModLocalization.Format("Erweiterung {0} gekauft. Alle Taschen-Händlerinnen bieten jetzt {1} an.", "Expansion {0} purchased. All Bag Merchants now offer {1}.", TierName(characterProgress.PurchasedCount), TierName(characterProgress.PurchasedCount + 1)));
			}
			else
			{
				BigInteger paid2 = PriceMath.GetPaid(characterProgress);
				BigInteger value = BigInteger.Max(BigInteger.Zero, currentTotal - paid2);
				TaschenhaendlerPlugin.NotifyPlayer(ModLocalization.Format("Teilzahlung verbucht. Für diese Erweiterung fehlen noch {0} Gold; der Stand gilt bei allen Taschen-Händlerinnen.", "Installment recorded. {0} gold remains for this expansion; the balance is shared by every Bag Merchant.", PriceMath.Format(value)));
			}
		}
		catch (Exception ex)
		{
			playerInv.Gold = gold;
			characterProgress.PurchasedCount = purchasedCount;
			characterProgress.NextPrice = nextPrice;
			characterProgress.PriceNumerator = priceNumerator;
			characterProgress.PriceDenominator = priceDenominator;
			characterProgress.PaidTowardNext = paidTowardNext;
			if (flag2)
			{
				RemoveOneExpansion(playerInv);
			}
			RefreshGold(playerInv);
			RefreshOffer();
			if (!(ex is ProgressWriteException))
			{
				TaschenhaendlerPlugin.ModLog.LogError((object)$"Kauf wurde zurückgerollt: {ex}");
				TaschenhaendlerPlugin.NotifyPlayer(ModLocalization.Text("Der Kauf ist fehlgeschlagen; Gold und Item wurden zurückgesetzt.", "The purchase failed; gold and item were restored."));
			}
			if (flag3)
			{
				InventoryExpansionController.CaptureOverflow(characterProgress);
				ProgressStore.Save();
			}
		}
		return true;
	}

	private static IEnumerator EnsureVendorAfterDelay(VendorInventory source, int sourceId)
	{
		yield return null;
		yield return (object)new WaitForSeconds(0.75f);
		PendingSources.Remove(sourceId);
		if (!((Object)(object)source == (Object)null) && !((Object)(object)ExpansionItem == (Object)null) && ((Component)source).gameObject.activeInHierarchy && IsAdventurerMerchant(source) && !((Object)(object)Object.FindObjectsOfType<BagVendorMarker>().FirstOrDefault((BagVendorMarker marker) => (Object)(object)marker != (Object)null && marker.SourceVendorInstanceId == sourceId) != (Object)null))
		{
			SpawnBagVendor(source);
		}
	}

	private static void SpawnBagVendor(VendorInventory source)
	{
		//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_0046: Unknown result type (might be due to invalid IL or missing references)
		//IL_0058: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0118: 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_0155: Unknown result type (might be due to invalid IL or missing references)
		//IL_016f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0174: Unknown result type (might be due to invalid IL or missing references)
		//IL_0184: Unknown result type (might be due to invalid IL or missing references)
		//IL_0185: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
		//IL_0311: Unknown result type (might be due to invalid IL or missing references)
		//IL_0319: Unknown result type (might be due to invalid IL or missing references)
		//IL_0321: Unknown result type (might be due to invalid IL or missing references)
		//IL_0592: Unknown result type (might be due to invalid IL or missing references)
		//IL_05dd: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = null;
		NPC val2 = null;
		try
		{
			Vector3 position = ((Component)source).transform.position;
			Vector3 val3 = position + ((Component)source).transform.right * 2.8f + ((Component)source).transform.forward * 0.8f;
			NavMeshHit val4 = default(NavMeshHit);
			if (NavMesh.SamplePosition(val3, ref val4, 5f, -1))
			{
				val3 = ((NavMeshHit)(ref val4)).position;
			}
			NPC component = ((Component)source).GetComponent<NPC>();
			Traverse val5 = (((Object)(object)component != (Object)null) ? Traverse.Create((object)component) : null);
			int[] childIndexPath = GetChildIndexPath(((Component)source).transform, component?.NamePlate);
			Transform transform = ((Component)source).transform;
			object target;
			if (val5 == null)
			{
				target = null;
			}
			else
			{
				SpriteRenderer value = val5.Field("MapArrow").GetValue<SpriteRenderer>();
				target = ((value != null) ? ((Component)value).transform : null);
			}
			int[] childIndexPath2 = GetChildIndexPath(transform, (Transform)target);
			Transform transform2 = ((Component)source).transform;
			object target2;
			if (val5 == null)
			{
				target2 = null;
			}
			else
			{
				GameObject value2 = val5.Field("QuestMarker").GetValue<GameObject>();
				target2 = ((value2 != null) ? value2.transform : null);
			}
			int[] childIndexPath3 = GetChildIndexPath(transform2, (Transform)target2);
			bool activeSelf = ((Component)source).gameObject.activeSelf;
			try
			{
				((Component)source).gameObject.SetActive(false);
				val = Object.Instantiate<GameObject>(((Component)source).gameObject, val3, ((Component)source).transform.rotation);
			}
			finally
			{
				((Component)source).gameObject.SetActive(activeSelf);
			}
			if ((Object)(object)val == (Object)null)
			{
				throw new InvalidOperationException("Der Händlerklon konnte nicht erzeugt werden.");
			}
			SceneManager.MoveGameObjectToScene(val, ((Component)source).gameObject.scene);
			BagVendorMarker bagVendorMarker = val.AddComponent<BagVendorMarker>();
			Scene scene = ((Component)source).gameObject.scene;
			bagVendorMarker.SceneName = ((Scene)(ref scene)).name;
			bagVendorMarker.AnchorPosition = position;
			bagVendorMarker.SourceVendorInstanceId = ((Object)source).GetInstanceID();
			bagVendorMarker.NameIndex = SelectVendorNameIndex(bagVendorMarker.SceneName, position);
			string text = (((Object)val).name = GetVendorName(bagVendorMarker.NameIndex));
			val2 = val.GetComponent<NPC>();
			Character component2 = val.GetComponent<Character>();
			VendorInventory component3 = val.GetComponent<VendorInventory>();
			NPCDialogManager component4 = val.GetComponent<NPCDialogManager>();
			if ((Object)(object)val2 == (Object)null || (Object)(object)component2 == (Object)null || (Object)(object)component3 == (Object)null || (Object)(object)component4 == (Object)null)
			{
				Object.Destroy((Object)(object)val);
				TaschenhaendlerPlugin.ModLog.LogWarning((object)("Händler '" + ((Object)source).name + "' konnte nicht als Taschen-Händler geklont werden: Komponenten fehlen."));
				return;
			}
			val2.NPCName = text;
			val2.NeverAggro = true;
			val2.Mobile = false;
			val2.noClick = false;
			val2.SummonedByPlayer = false;
			val2.AggroRegardlessOfLevel = false;
			val2.AggroRegardlessofLOS = false;
			val2.CurrentAggroTarget = null;
			val2.PastAggroTarget = null;
			val2.AggroTable = new List<AggroSlot>();
			Traverse val6 = Traverse.Create((object)val2);
			val6.Field("wander").SetValue((object)0f);
			val6.Field("MySpawnPoint").SetValue((object)null);
			val6.Field("HomePos").SetValue((object)val3);
			val6.Field("PatrolPath").SetValue((object)new List<Transform>());
			val6.Field("Myself").SetValue((object)component2);
			component2.isVendor = true;
			component2.Invulnerable = true;
			component2.MyWorldFaction = null;
			component2.MyFaction = (Faction)1;
			component2.BaseFaction = (Faction)1;
			component2.TempFaction = (Faction)1;
			component2.AggressiveTowards = new List<Faction>();
			component3.ItemsForSale = new List<Item> { ExpansionItem };
			component3.QuestRewardsForSale = new List<Quest>();
			component3.VendorDesc = ModLocalization.MerchantRole;
			QuestManager component5 = val.GetComponent<QuestManager>();
			if ((Object)(object)component5 != (Object)null)
			{
				component5.NPCQuests = new List<Quest>();
			}
			Transform[] array = ((IEnumerable<Transform>)(object)new Transform[3]
			{
				ResolveClonedRuntimeChild(val.transform, childIndexPath),
				ResolveClonedRuntimeChild(val.transform, childIndexPath2),
				ResolveClonedRuntimeChild(val.transform, childIndexPath3)
			}).Where((Transform display) => (Object)(object)display != (Object)null).Distinct().ToArray();
			for (int num = 0; num < array.Length; num++)
			{
				Object.DestroyImmediate((Object)(object)((Component)array[num]).gameObject);
			}
			val2.NamePlate = null;
			val6.Field("MapArrow").SetValue((object)null);
			val6.Field("QuestMarker").SetValue((object)null);
			val6.Field("MarkerUp").SetValue((object)false);
			NPCDialog[] components = val.GetComponents<NPCDialog>();
			for (int num = 0; num < components.Length; num++)
			{
				Object.DestroyImmediate((Object)(object)components[num]);
			}
			NPCDialog val7 = val.AddComponent<NPCDialog>();
			val7.Dialog = ModLocalization.Text("Grüße! Meine Inventarerweiterungen gelten bei jeder Taschen-Händlerin. Rechtsklick auf das gekaufte Item fügt dauerhaft weitere Plätze hinzu.", "Greetings! My inventory expansions are synchronized across every Bag Merchant. Right-click the purchased item to permanently add more slots.");
			val7.KeywordToActivate = new List<string>();
			val7.GiveItem = null;
			val7.QuestToAssign = null;
			val7.QuestToComplete = null;
			val7.RequireQuestComplete = null;
			val7.Spawn = null;
			val7.KillMeOnSay = false;
			component4.MyDialogOptions = (NPCDialog[])(object)new NPCDialog[1] { val7 };
			component4.SpecificClass = new List<Class>();
			Traverse.Create((object)component4).Field("Keywords").SetValue((object)new List<string>());
			component4.EngageWithSims = false;
			component4.Rejection = string.Empty;
			PointOfInterest[] componentsInChildren = val.GetComponentsInChildren<PointOfInterest>(true);
			foreach (PointOfInterest val8 in componentsInChildren)
			{
				if ((Object)(object)((Component)val8).gameObject == (Object)(object)val)
				{
					Object.DestroyImmediate((Object)(object)val8);
				}
				else
				{
					Object.DestroyImmediate((Object)(object)((Component)val8).gameObject);
				}
			}
			Traverse.Create((object)component4).Field("myPOI").SetValue((object)null);
			val6.Field("MyDialog").SetValue((object)component4);
			val.transform.position = val3;
			val.SetActive(true);
			if (NPCTable.LiveNPCs != null && !NPCTable.LiveNPCs.Contains(val2))
			{
				NPCTable.LiveNPCs.Add(val2);
			}
			RefreshVendorPresentation(bagVendorMarker);
			RefreshOffer();
			TaschenhaendlerPlugin.ModLog.LogInfo((object)$"Taschen-Händler '{text}' in {bagVendorMarker.SceneName} bei {val3} erzeugt.");
		}
		catch (Exception arg)
		{
			if ((Object)(object)val2 != (Object)null && NPCTable.LiveNPCs != null)
			{
				NPCTable.LiveNPCs.Remove(val2);
			}
			if ((Object)(object)val != (Object)null)
			{
				Object.Destroy((Object)(object)val);
			}
			TaschenhaendlerPlugin.ModLog.LogError((object)$"Taschen-Händler konnte bei '{((source != null) ? ((Object)source).name : null)}' nicht erzeugt werden: {arg}");
		}
	}

	private static int[] GetChildIndexPath(Transform root, Transform target)
	{
		if ((Object)(object)root == (Object)null || (Object)(object)target == (Object)null || (Object)(object)target == (Object)(object)root || !target.IsChildOf(root))
		{
			return null;
		}
		List<int> list = new List<int>();
		Transform val = target;
		while ((Object)(object)val != (Object)null && (Object)(object)val != (Object)(object)root)
		{
			list.Add(val.GetSiblingIndex());
			val = val.parent;
		}
		if ((Object)(object)val != (Object)(object)root)
		{
			return null;
		}
		list.Reverse();
		return list.ToArray();
	}

	private static Transform ResolveClonedRuntimeChild(Transform cloneRoot, int[] childIndexPath)
	{
		if ((Object)(object)cloneRoot == (Object)null || childIndexPath == null || childIndexPath.Length == 0)
		{
			return null;
		}
		Transform val = cloneRoot;
		foreach (int num in childIndexPath)
		{
			if (num < 0 || num >= val.childCount)
			{
				return null;
			}
			val = val.GetChild(num);
		}
		if ((Object)(object)val != (Object)null && (Object)(object)val != (Object)(object)cloneRoot && val.IsChildOf(cloneRoot))
		{
			return val;
		}
		return null;
	}

	private static void RefreshGold(Inventory inventory)
	{
		if ((Object)(object)inventory.GoldTXT != (Object)null)
		{
			((TMP_Text)inventory.GoldTXT).text = inventory.Gold.ToString(CultureInfo.InvariantCulture);
		}
		inventory.UpdatePlayerInventory();
	}

	private static void RemoveOneExpansion(Inventory inventory)
	{
		ItemIcon val = ((IEnumerable<ItemIcon>)inventory.StoredSlots).LastOrDefault((Func<ItemIcon, bool>)((ItemIcon entry) => (Object)(object)entry != (Object)null && TaschenhaendlerPlugin.IsExpansion(entry.MyItem)));
		if (!((Object)(object)val == (Object)null))
		{
			if (val.Quantity > 1)
			{
				val.Quantity--;
			}
			else
			{
				val.MyItem = inventory.Empty;
				val.Quantity = 0;
			}
			val.UpdateSlotImage();
		}
	}

	private static void RebindExistingExpansionItems()
	{
		Inventory playerInv = GameData.PlayerInv;
		if ((Object)(object)playerInv == (Object)null || (Object)(object)ExpansionItem == (Object)null)
		{
			return;
		}
		foreach (ItemIcon storedSlot in playerInv.StoredSlots)
		{
			if ((Object)(object)storedSlot != (Object)null && TaschenhaendlerPlugin.IsExpansion(storedSlot.MyItem))
			{
				storedSlot.MyItem = ExpansionItem;
				storedSlot.UpdateSlotImage();
			}
		}
	}

	private static bool IsAdventurerMerchant(VendorInventory source)
	{
		if ((Object)(object)source == (Object)null || (Object)(object)((Component)source).GetComponent<BagVendorMarker>() != (Object)null)
		{
			return false;
		}
		return string.Equals(source.VendorDesc?.Trim(), "Adventurer", StringComparison.OrdinalIgnoreCase);
	}

	private static int SelectVendorNameIndex(string scene, Vector3 position)
	{
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		int num = 17;
		string text = scene ?? string.Empty;
		foreach (char c in text)
		{
			num = num * 31 + c;
		}
		num = num * 31 + Mathf.RoundToInt(position.x / 10f);
		num = num * 31 + Mathf.RoundToInt(position.z / 10f);
		return (num & 0x7FFFFFFF) % GermanVendorNames.Length;
	}

	private static string GetVendorName(int index)
	{
		string[] array = (ModLocalization.IsGerman ? GermanVendorNames : EnglishVendorNames);
		if (index < 0 || index >= array.Length)
		{
			index = 0;
		}
		return array[index];
	}

	private static string TierName(long oneBasedTier)
	{
		if (oneBasedTier < 1)
		{
			oneBasedTier = 1L;
		}
		string text = string.Empty;
		long num = oneBasedTier;
		while (num > 0 && text.Length < 12)
		{
			num--;
			text = (char)(65 + num % 26) + text;
			num /= 26;
		}
		if (num <= 0)
		{
			return text;
		}
		return $"#{oneBasedTier}";
	}

	private static bool IsGameplayScene(string sceneName)
	{
		if (string.IsNullOrWhiteSpace(sceneName))
		{
			return false;
		}
		string text = sceneName.ToLowerInvariant();
		if (!text.Contains("menu") && !text.Contains("loadscene") && !text.Contains("hidden"))
		{
			return !text.Contains("characterselect");
		}
		return false;
	}
}
[HarmonyPatch(typeof(ItemDatabase), "Start")]
internal static class ItemDatabaseStartPatch
{
	[HarmonyPostfix]
	[HarmonyPriority(0)]
	private static void Postfix(ItemDatabase __instance)
	{
		MerchantController.RegisterExpansionItem(__instance);
	}
}
[HarmonyPatch(typeof(VendorInventory), "Start")]
internal static class VendorInventoryStartPatch
{
	[HarmonyPostfix]
	private static void Postfix(VendorInventory __instance)
	{
		MerchantController.OnVendorStarted(__instance);
	}
}
[HarmonyPatch(typeof(VendorWindow), "Transaction")]
internal static class VendorTransactionPatch
{
	[HarmonyPrefix]
	private static bool Prefix()
	{
		return !MerchantController.HandlePurchase();
	}
}
[HarmonyPatch(typeof(NPC), "Start")]
internal static class BagVendorNamePlateStartPatch
{
	[HarmonyPostfix]
	[HarmonyPriority(0)]
	private static void Postfix(NPC __instance)
	{
		MerchantController.RefreshVendorPresentation(__instance);
	}
}
[HarmonyPatch(typeof(NPC), "UpdateNamePlate")]
internal static class BagVendorNamePlateUpdatePatch
{
	[HarmonyPostfix]
	[HarmonyPriority(0)]
	private static void Postfix(NPC __instance)
	{
		MerchantController.RefreshVendorPresentation(__instance);
	}
}
[HarmonyPatch(typeof(VendorWindow), "LoadWindow")]
internal static class BagVendorWindowLocalizationPatch
{
	[HarmonyPostfix]
	private static void Postfix(VendorWindow __instance, VendorInventory _incoming)
	{
		if (!((Object)(object)__instance?.LootSource == (Object)null) && !((Object)(object)_incoming == (Object)null) && !((Object)(object)((Component)_incoming).GetComponent<BagVendorMarker>() == (Object)null))
		{
			((TMP_Text)__instance.LootSource).text = ModLocalization.Format("Geschäfte mit {0}", "Doing business with {0}", ((Object)((Component)_incoming).transform).name);
		}
	}
}
[HarmonyPatch(typeof(GameData), "ActivateSlotForVendor")]
internal static class BagVendorSelectionLocalizationPatch
{
	[HarmonyPrefix]
	private static bool Prefix(ItemIcon _newActive)
	{
		//IL_007c: 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_0105: Expected O, but got Unknown
		if ((Object)(object)_newActive == (Object)null || !_newActive.VendorSlot || !TaschenhaendlerPlugin.IsExpansion(_newActive.MyItem))
		{
			return true;
		}
		GameData.DeactivateSlotForVendor();
		if ((Object)(object)_newActive.MyItem == (Object)(object)GameData.PlayerInv?.Empty)
		{
			return false;
		}
		GameData.SlotActiveForVendor = _newActive;
		Image val = (((Object)(object)((Component)_newActive).transform.parent != (Object)null) ? ((Component)((Component)_newActive).transform.parent).GetComponent<Image>() : null);
		if ((Object)(object)val != (Object)null)
		{
			((Graphic)val).color = Color.yellow;
		}
		GameData.CurSellVal = Mathf.RoundToInt((float)_newActive.MyItem.ItemValue);
		string text = (((Object)(object)GameData.VendorWindow != (Object)null) ? GameData.VendorWindow.GetVendor() : ModLocalization.MerchantRole);
		string text2 = ModLocalization.Format("{0} sagt: Das kostet {1} Gold für {2}.", "{0} says: That'll be {1} gold for {2}.", text, PriceMath.Format(new BigInteger(GameData.CurSellVal)), _newActive.MyItem.ItemName);
		UpdateSocialLog.LogAdd(new ChatLogLine(text2, (LogType)1, ""));
		UpdateSocialLog.LocalLogAdd(text2, "white");
		if ((Object)(object)GameData.VendorWindow?.ButtonContext != (Object)null)
		{
			((TMP_Text)GameData.VendorWindow.ButtonContext).text = ModLocalization.Text("Kaufen", "Purchase");
		}
		return false;
	}
}
[BepInPlugin("CBra.Erenshor.Taschenhaendler", "Taschenhaendler", "1.1.2")]
public sealed class TaschenhaendlerPlugin : BaseUnityPlugin
{
	public const string PluginGuid = "CBra.Erenshor.Taschenhaendler";

	public const string PluginName = "Taschenhaendler";

	public const string PluginVersion = "1.1.2";

	public const string ExpansionItemId = "CBRA_TASCHENHAENDLER_INVENTARERWEITERUNG_V1";

	private Harmony _harmony;

	internal static TaschenhaendlerPlugin Instance { get; private set; }

	internal static ManualLogSource ModLog { get; private set; }

	internal ConfigEntry<int> StartPrice { get; private set; }

	internal ConfigEntry<string> PriceMultiplier { get; private set; }

	internal ConfigEntry<int> SlotsPerExpansion { get; private set; }

	internal ConfigEntry<float> ScrollSensitivity { get; private set; }

	internal ConfigEntry<string> LanguageMode { get; private set; }

	internal ConfigEntry<string> PreferredSortMode { get; private set; }

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

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

	private void Awake()
	{
		//IL_015c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0166: Expected O, but got Unknown
		Instance = this;
		ModLog = ((BaseUnityPlugin)this).Logger;
		StartPrice = ((BaseUnityPlugin)this).Config.Bind<int>("Preise", "StartPrice", 5000, "DE: Goldpreis der ersten Erweiterung. Beispiel: 5000 bedeutet, dass Stufe A 5.000 Gold kostet. | EN: Gold price of the first expansion. Example: 5000 makes tier A cost 5,000 gold.");
		PriceMultiplier = ((BaseUnityPlugin)this).Config.Bind<string>("Preise", "PriceMultiplier", "1.5", "DE: Faktor für die nächste vollständige Preisstufe. Beispiel: 1.5 macht aus 5.000 anschließend 7.500 Gold. Punkt oder Komma sind erlaubt. | EN: Multiplier for the next full price tier. Example: 1.5 changes 5,000 into 7,500 gold. A dot or comma is accepted.");
		SlotsPerExpansion = ((BaseUnityPlugin)this).Config.Bind<int>("Inventar", "SlotsPerExpansion", 10, "DE: Neue Plätze pro benutztem Erweiterungsitem. Beispiel: 10 ergibt nach zwei Benutzungen 20 zusätzliche Plätze. | EN: New slots granted by each used expansion item. Example: 10 grants 20 extra slots after two uses.");
		ScrollSensitivity = ((BaseUnityPlugin)this).Config.Bind<float>("Inventar", "ScrollSensitivity", 25f, "DE: Scrollgeschwindigkeit der Inventarliste. Beispiel: 40 scrollt schneller als 25. | EN: Inventory-list scroll speed. Example: 40 scrolls faster than 25.");
		PreferredSortMode = ((BaseUnityPlugin)this).Config.Bind<string>("Inventarwerkzeuge", "PreferredSortMode", "Type", "DE: Im Auswahlfeld vorgewählte Sortierart; ausgeführt wird erst per Sortierknopf. Beispiel: Value sortiert nach Goldwert. | EN: Sort mode preselected in the dropdown; sorting runs only after clicking the button. Example: Value sorts by gold value. Allowed: Name, Type, Level, Value, Quantity.");
		SortDescending = ((BaseUnityPlugin)this).Config.Bind<bool>("Inventarwerkzeuge", "SortDescending", false, "DE: Richtung des nächsten Sortierklicks. Beispiel: false sortiert A–Z oder klein–groß; true kehrt die Reihenfolge um. | EN: Direction of the next sort click. Example: false sorts A–Z or low–high; true reverses the order.");
		MergeStacksOnSort = ((BaseUnityPlugin)this).Config.Bind<bool>("Inventarwerkzeuge", "MergeStacksOnSort", true, "DE: Fasst beim Sortieren gleiche stapelbare Items zusammen. Beispiel: true macht aus Stapeln mit 3 und 4 Stück einen Stapel mit 7; Hotkeys werden erhalten. | EN: Merges identical stackable items while sorting. Example: true combines stacks of 3 and 4 into one stack of 7 while preserving hotkeys.");
		LanguageMode = ((BaseUnityPlugin)this).Config.Bind<string>("Sprache / Language", "Language", "Auto", "DE: Sprache aller Mod-Texte. Beispiel: English erzwingt Englisch; Auto folgt der Windows-/Unity-Sprache. | EN: Language of all mod-owned text. Example: German forces German; Auto follows the Windows/Unity language. Allowed: Auto, German, English.");
		ValidateConfig();
		LanguageMode.SettingChanged += delegate
		{
			RefreshLocalizedContent();
		};
		ProgressStore.Initialize();
		MerchantController.Initialize(this);
		_harmony = new Harmony("CBra.Erenshor.Taschenhaendler");
		_harmony.PatchAll(typeof(TaschenhaendlerPlugin).Assembly);
		SceneManager.sceneLoaded += OnSceneLoaded;
		SceneManager.sceneUnloaded += OnSceneUnloaded;
		((BaseUnityPlugin)this).Logger.LogInfo((object)"Taschenhaendler 1.1.2 geladen.");
	}

	private void OnDestroy()
	{
		SceneManager.sceneLoaded -= OnSceneLoaded;
		SceneManager.sceneUnloaded -= OnSceneUnloaded;
		Harmony harmony = _harmony;
		if (harmony != null)
		{
			harmony.UnpatchSelf();
		}
		MerchantController.Shutdown();
		Instance = null;
	}

	private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		MerchantController.OnSceneLoaded(scene);
		((MonoBehaviour)this).StartCoroutine(RefreshAfterSceneLoad());
	}

	private void OnSceneUnloaded(Scene scene)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		MerchantController.OnSceneUnloaded(scene);
	}

	private IEnumerator RefreshAfterSceneLoad()
	{
		yield return null;
		yield return null;
		MerchantController.RefreshOffer();
	}

	private void ValidateConfig()
	{
		if (StartPrice.Value < 1)
		{
			((BaseUnityPlugin)this).Logger.LogWarning((object)"StartPrice war kleiner als 1 und wurde für diese Sitzung auf 5000 gesetzt.");
			StartPrice.Value = 5000;
		}
		if (SlotsPerExpansion.Value < 1)
		{
			((BaseUnityPlugin)this).Logger.LogWarning((object)"SlotsPerExpansion war kleiner als 1 und wurde für diese Sitzung auf 10 gesetzt.");
			SlotsPerExpansion.Value = 10;
		}
		if (ScrollSensitivity.Value <= 0f)
		{
			((BaseUnityPlugin)this).Logger.LogWarning((object)"ScrollSensitivity war nicht größer als 0 und wurde für diese Sitzung auf 25 gesetzt.");
			ScrollSensitivity.Value = 25f;
		}
		if (!PriceMath.TryGetMultiplier(out var numerator, out var denominator) || numerator <= denominator)
		{
			((BaseUnityPlugin)this).Logger.LogWarning((object)"PriceMultiplier war ungültig oder nicht größer als 1 und wurde für diese Sitzung auf 1.5 gesetzt.");
			PriceMultiplier.Value = "1.5";
		}
		if (!ModLocalization.TryParseMode(LanguageMode.Value, out var _))
		{
			((BaseUnityPlugin)this).Logger.LogWarning((object)"Language war ungültig und wurde für diese Sitzung auf Auto gesetzt.");
			LanguageMode.Value = "Auto";
		}
		if (!InventoryToolsState.TryParseSortMode(PreferredSortMode.Value, out var _))
		{
			((BaseUnityPlugin)this).Logger.LogWarning((object)"PreferredSortMode war ungültig und wurde für diese Sitzung auf Type gesetzt.");
			PreferredSortMode.Value = "Type";
		}
	}

	private void RefreshLocalizedContent()
	{
		MerchantController.RefreshLocalization();
		InventoryToolsPanel.RefreshAllLocalization();
		MerchantController.RefreshOffer();
	}

	internal static void NotifyPlayer(string message)
	{
		try
		{
			UpdateSocialLog.LogAdd("[" + ModLocalization.MessagePrefix + "] " + message);
		}
		catch (Exception ex)
		{
			ManualLogSource modLog = ModLog;
			if (modLog != null)
			{
				modLog.LogDebug((object)("Spielnachricht konnte nicht geschrieben werden: " + ex.Message));
			}
		}
	}

	internal static bool IsExpansion(Item item)
	{
		if ((Object)(object)item != (Object)null)
		{
			return string.Equals(((BaseScriptableObject)item).Id, "CBRA_TASCHENHAENDLER_INVENTARERWEITERUNG_V1", StringComparison.Ordinal);
		}
		return false;
	}
}
internal static class PriceMath
{
	internal static BigInteger GetCurrentTotal(CharacterProgress progress)
	{
		if (progress == null)
		{
			return new BigInteger(Math.Max(1, TaschenhaendlerPlugin.Instance.StartPrice.Value));
		}
		GetPriceFraction(progress, out var numerator, out var denominator);
		BigInteger result = DivideCeiling(numerator, denominator);
		progress.NextPrice = result.ToString(CultureInfo.InvariantCulture);
		return result;
	}

	internal static BigInteger GetPaid(CharacterProgress progress)
	{
		if (progress == null || !BigInteger.TryParse(progress.PaidTowardNext, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) || result < 0L)
		{
			return BigInteger.Zero;
		}
		return result;
	}

	internal static BigInteger GetRemaining(CharacterProgress progress)
	{
		return BigInteger.Max(BigInteger.Zero, GetCurrentTotal(progress) - GetPaid(progress));
	}

	internal static int GetInstallment(CharacterProgress progress)
	{
		BigInteger remaining = GetRemaining(progress);
		if (remaining <= 0L)
		{
			return 1;
		}
		if (!(remaining > 2147483647L))
		{
			return (int)remaining;
		}
		return int.MaxValue;
	}

	internal static void Advance(CharacterProgress progress)
	{
		BigInteger currentTotal = GetCurrentTotal(progress);
		GetPriceFraction(progress, out var numerator, out var denominator);
		if (!TryGetMultiplier(out var numerator2, out var denominator2))
		{
			numerator2 = 3;
			denominator2 = 2;
		}
		numerator *= numerator2;
		denominator *= denominator2;
		BigInteger bigInteger = BigInteger.GreatestCommonDivisor(numerator, denominator);
		numerator /= bigInteger;
		denominator /= bigInteger;
		BigInteger bigInteger2 = DivideCeiling(numerator, denominator);
		if (bigInteger2 <= currentTotal)
		{
			bigInteger2 = currentTotal + 1;
			numerator = bigInteger2;
			denominator = BigInteger.One;
		}
		progress.PriceNumerator = numerator.ToString(CultureInfo.InvariantCulture);
		progress.PriceDenominator = denominator.ToString(CultureInfo.InvariantCulture);
		progress.NextPrice = bigInteger2.ToString(CultureInfo.InvariantCulture);
		progress.PaidTowardNext = "0";
	}

	internal static bool TryGetMultiplier(out BigInteger numerator, out BigInteger denominator)
	{
		numerator = 3;
		denominator = 2;
		string text = TaschenhaendlerPlugin.Instance?.PriceMultiplier?.Value;
		if (string.IsNullOrWhiteSpace(text))
		{
			return false;
		}
		text = text.Trim().Replace(',', '.');
		int num = text.IndexOf('.');
		string value = ((num >= 0) ? text.Remove(num, 1) : text);
		int exponent = ((num >= 0) ? (text.Length - num - 1) : 0);
		if (!BigInteger.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out numerator) || numerator <= 0L)
		{
			return false;
		}
		denominator = BigInteger.Pow(10, exponent);
		BigInteger bigInteger = BigInteger.GreatestCommonDivisor(numerator, denominator);
		numerator /= bigInteger;
		denominator /= bigInteger;
		return denominator > 0L;
	}

	internal static string Format(BigInteger value)
	{
		string text = value.ToString(CultureInfo.InvariantCulture);
		bool flag = text.StartsWith("-", StringComparison.Ordinal);
		string text2 = (flag ? text.Substring(1) : text);
		List<string> list = new List<string>();
		for (int num = text2.Length; num > 0; num -= 3)
		{
			int num2 = Math.Max(0, num - 3);
			list.Add(text2.Substring(num2, num - num2));
		}
		list.Reverse();
		return (flag ? "-" : string.Empty) + string.Join(ModLocalization.IsGerman ? "." : ",", list);
	}

	private static BigInteger DivideCeiling(BigInteger numerator, BigInteger denominator)
	{
		return (numerator + denominator - 1) / denominator;
	}

	private static void GetPriceFraction(CharacterProgress progress, out BigInteger numerator, out BigInteger denominator)
	{
		bool num = BigInteger.TryParse(progress.PriceNumerator, NumberStyles.Integer, CultureInfo.InvariantCulture, out numerator) && numerator > 0L;
		bool flag = BigInteger.TryParse(progress.PriceDenominator, NumberStyles.Integer, CultureInfo.InvariantCulture, out denominator) && denominator > 0L;
		if (!num || !flag)
		{
			if (!BigInteger.TryParse(progress.NextPrice, NumberStyles.Integer, CultureInfo.InvariantCulture, out numerator) || numerator < 1L)
			{
				numerator = new BigInteger(Math.Max(1, TaschenhaendlerPlugin.Instance.StartPrice.Value));
			}
			denominator = BigInteger.One;
			progress.PriceNumerator = numerator.ToString(CultureInfo.InvariantCulture);
			progress.PriceDenominator = "1";
		}
	}
}
[Serializable]
[DataContract]
public sealed class ProgressDatabase
{
	[DataMember(IsRequired = true, Order = 1)]
	public int Version = 2;

	[DataMember(IsRequired = true, Order = 2)]
	public long Revision;

	[DataMember(IsRequired = true, Order = 3)]
	public List<CharacterProgress> Characters = new List<CharacterProgress>();
}
[DataContract]
public sealed class LegacyProgressDatabase
{
	[DataMember(Order = 1)]
	public int Version = 1;

	[DataMember(Order = 2)]
	public long Revision;

	[DataMember(Order = 3)]
	public List<CharacterProgress> Characters = new List<CharacterProgress>();
}
[Serializable]
[DataContract]
public sealed class CharacterProgress
{
	[DataMember(Order = 1)]
	public int SlotIndex;

	[DataMember(Order = 2)]
	public string CharacterName = string.Empty;

	[DataMember(Order = 3)]
	public string CharacterClass = string.Empty;

	[DataMember(Order = 4)]
	public long PurchasedCount;

	[DataMember(Order = 5)]
	public long AppliedCount;

	[DataMember(Order = 6)]
	public long GrantedSlots;

	[DataMember(Order = 7)]
	public string PriceNumerator = string.Empty;

	[DataMember(Order = 8)]
	public string PriceDenominator = "1";

	[DataMember(Order = 9)]
	public string NextPrice = string.Empty;

	[DataMember(Order = 10)]
	public string PaidTowardNext = "0";

	[DataMember(Order = 11)]
	public List<StoredItem> Overflow = new List<StoredItem>();

	[DataMember(Order = 12)]
	public List<int> FirstExtraHotkeys = new List<int>();

	[DataMember(Order = 13)]
	public List<int> SecondExtraHotkeys = new List<int>();
}
[Serializable]
[DataContract]
public sealed class StoredItem
{
	[DataMember(Order = 1)]
	public string Id = string.Empty;

	[DataMember(Order = 2)]
	public int Quantity;
}
internal static class ProgressStore
{
	private sealed class DatabaseCandidate
	{
		internal readonly string Path;

		internal readonly ProgressDatabase Database;

		internal readonly long TimestampUtcTicks;

		internal DatabaseCandidate(string path, ProgressDatabase database, long timestampUtcTicks)
		{
			Path = path;
			Database = database;
			TimestampUtcTicks = timestampUtcTicks;
		}
	}

	private sealed class ProgressSelection
	{
		internal readonly CharacterProgress Progress;

		internal readonly long TimestampUtcTicks;

		internal ProgressSelection(CharacterProgress progress, long timestampUtcTicks)
		{
			Progress = progress;
			TimestampUtcTicks = timestampUtcTicks;
		}
	}

	private const string FileName = "CBra.Taschenhaendler.Progress.json";

	private static readonly DataContractJsonSerializerSettings SerializerSettings = new DataContractJsonSerializerSettings
	{
		MaxItemsInObjectGraph = int.MaxValue,
		UseSimpleDictionaryFormat = true
	};

	private static ProgressDatabase _database;

	private static bool _loaded;

	private static bool _storageFault;

	private static bool _storageFaultNoticeShown;

	internal static CharacterProgress Current { get; private set; }

	internal static string FilePath => Path.Combine(Paths.ConfigPath, "CBra.Taschenhaendler.Progress.json");

	internal static string ProtectedMirrorPath => Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "CBra", "Erenshor", "Taschenhaendler", "CBra.Taschenhaendler.Progress.json");

	private static string LegacyFilePath => Path.Combine(Application.persistentDataPath, "ESSaveData", "CBra.Taschenhaendler.Progress.json");

	internal static void Initialize()
	{
		_loaded = false;
		_database = null;
		_storageFault = false;
		_storageFaultNoticeShown = false;
		Current = null;
	}

	internal static CharacterProgress SelectCurrentCharacter()
	{
		EnsureLoaded();
		if (_storageFault)
		{
			Current = null;
			NotifyStorageFault();
			return null;
		}
		SaveGameData slot = GameData.CurrentCharacterSlot;
		if (slot == null)
		{
			Current = null;
			return null;
		}
		string name = NormalizeName(slot.CharName);
		string charClass = NormalizeName(slot.CharClass);
		CharacterProgress characterProgress = _database.Characters.FirstOrDefault((CharacterProgress entry) => entry.SlotIndex == slot.index && string.Equals(NormalizeName(entry.CharacterName), name, StringComparison.OrdinalIgnoreCase) && ClassesMatch(entry.CharacterClass, charClass));
		if (characterProgress == null)
		{
			characterProgress = _database.Characters.FirstOrDefault((CharacterProgress entry) => !string.IsNullOrEmpty(name) && string.Equals(NormalizeName(entry.CharacterName), name, StringComparison.OrdinalIgnoreCase) && ClassesMatch(entry.CharacterClass, charClass));
		}
		if (characterProgress == null)
		{
			if (_database.Characters.RemoveAll((CharacterProgress entry) => entry != null && !string.IsNullOrEmpty(name) && string.Equals(NormalizeName(entry.CharacterName), name, StringComparison.OrdinalIgnoreCase)) > 0)
			{
				TaschenhaendlerPlugin.ModLog.LogWarning((object)("Alter Taschenfortschritt für '" + name + "' gehörte zu einer anderen Charakterklasse und wurde nicht auf den neu erkannten Charakter übertragen."));
			}
			characterProgress = new CharacterProgress
			{
				SlotIndex = slot.index,
				CharacterName = name,
				CharacterClass = charClass,
				PriceNumerator = Math.Max(1, TaschenhaendlerPlugin.Instance.StartPrice.Value).ToString(CultureInfo.InvariantCulture),
				PriceDenominator = "1",
				NextPrice = Math.Max(1, TaschenhaendlerPlugin.Instance.StartPrice.Value).ToString(CultureInfo.InvariantCulture),
				PaidTowardNext = "0"
			};
			_database.Characters.Add(characterProgress);
		}
		else
		{
			characterProgress.SlotIndex = slot.index;
			characterProgress.CharacterName = name;
			characterProgress.CharacterClass = charClass;
			Normalize(characterProgress);
		}
		Current = characterProgress;
		Save();
		return characterProgress;
	}

	internal static void ClearCurrent()
	{
		Current = null;
	}

	internal static bool Save()
	{
		EnsureLoaded();
		if (_storageFault)
		{
			NotifyStorageFault();
			return false;
		}
		NormalizeAll();
		_database.Version = 2;
		if (_database.Revision >= long.MaxValue)
		{
			TaschenhaendlerPlugin.ModLog.LogError((object)"Die Fortschrittsrevision hat die technische 64-Bit-Grenze erreicht; Speichern wurde sicherheitshalber blockiert.");
			return false;
		}
		long revision = _database.Revision;
		_database.Revision = Math.Max(0L, revision) + 1;
		if (!TrySerializeAndValidate(out var json, out var error))
		{
			_database.Revision = revision;
			TaschenhaendlerPlugin.ModLog.LogError((object)$"Fortschritts-Serialisierung hat die Rundlaufprüfung nicht bestanden: {error}");
			TaschenhaendlerPlugin.NotifyPlayer(ModLocalization.Text("Der Erweiterungsfortschritt konnte nicht verlustfrei serialisiert werden. Die Aktion wurde abgebrochen.", "Expansion progress could not be serialized without data loss. The action was cancelled."));
			return false;
		}
		Exception error2;
		bool flag = TryWriteDatabase(FilePath, json, out error2);
		Exception error3;
		bool flag2 = TryWriteDatabase(ProtectedMirrorPath, json, out error3);
		if (flag || flag2)
		{
			if (!flag)
			{
				TaschenhaendlerPlugin.ModLog.LogWarning((object)$"Primäre Fortschrittsdatei konnte nicht gespeichert werden; geschützte Spiegelung ist aktuell: {error2}");
			}
			if (!flag2)
			{
				TaschenhaendlerPlugin.ModLog.LogWarning((object)$"Geschützte Fortschrittsspiegelung konnte nicht gespeichert werden; Primärdatei ist aktuell: {error3}");
			}
			return true;
		}
		TaschenhaendlerPlugin.ModLog.LogError((object)$"Fortschritt konnte an keinem der beiden Speicherorte geschrieben werden. Primär: {error2}; Spiegelung: {error3}");
		_database.Revision = revision;
		TaschenhaendlerPlugin.NotifyPlayer(ModLocalization.Text("Der Erweiterungsfortschritt konnte nicht gespeichert werden. Die Aktion wurde abgebrochen.", "The expansion progress could not be saved. The action was cancelled."));
		return false;
	}

	internal static void Remove(int slotIndex, string characterName)
	{
		EnsureLoaded();
		if (_storageFault)
		{
			NotifyStorageFault();
			return;
		}
		string normalizedName = NormalizeName(characterName);
		_database.Characters.RemoveAll((CharacterProgress entry) => entry != null && ((entry.SlotIndex == slotIndex && string.Equals(NormalizeName(entry.CharacterName), normalizedName, StringComparison.OrdinalIgnoreCase)) || (!string.IsNullOrEmpty(normalizedName) && string.Equals(NormalizeName(entry.CharacterName), normalizedName, StringComparison.OrdinalIgnoreCase))));
		if (Current != null && (Current.SlotIndex == slotIndex || (!string.IsNullOrEmpty(normalizedName) && string.Equals(NormalizeName(Current.CharacterName), normalizedName, StringComparison.OrdinalIgnoreCase))))
		{
			Current = null;
		}
		Save();
	}

	private static void EnsureLoaded()
	{
		if (_loaded)
		{
			return;
		}
		_loaded = true;
		_database = new ProgressDatabase();
		List<DatabaseCandidate> list = new List<DatabaseCandidate>();
		bool flag = HasAnyDatabaseFile(FilePath) || HasAnyDatabaseFile(ProtectedMirrorPath);
		LoadCandidateWithFallback(FilePath, "Primärdatei", legacyTolerant: false, list);
		LoadCandidateWithFallback(ProtectedMirrorPath, "geschützte Spiegelung", legacyTolerant: false, list);
		if (list.Count == 0)
		{
			if (flag)
			{
				SetStorageFault("Mindestens eine geschützte Fortschrittsdatei ist vorhanden, aber keine davon ist gültig. Alte Daten werden nicht automatisch überschrieben.");
				return;
			}
			bool flag2 = HasAnyDatabaseFile(LegacyFilePath);
			LoadCandidateWithFallback(LegacyFilePath, "alte ESSaveData-Datei", legacyTolerant: true, list);
			if (list.Count == 0 && flag2)
			{
				SetStorageFault("Die alte Fortschrittsdatei ist vorhanden, aber nicht lesbar. Sie wird nicht automatisch überschrieben.");
				return;
			}
		}
		if (list.Count != 0)
		{
			_database = MergeCandidates(list);
			NormalizeAll();
			TaschenhaendlerPlugin.ModLog.LogInfo((object)$"Taschenfortschritt aus {list.Count} gültigen Speicherquelle(n) geladen; {_database.Characters.Count} Charakter(e), Revision {_database.Revision}.");
		}
	}

	private static bool HasAnyDatabaseFile(string path)
	{
		if (!string.IsNullOrWhiteSpace(path))
		{
			if (!File.Exists(path) && !File.Exists(path + ".tmp"))
			{
				return File.Exists(path + ".bak");
			}
			return true;
		}
		return false;
	}

	private static void SetStorageFault(string reason)
	{
		_storageFault = true;
		Current = null;
		TaschenhaendlerPlugin.ModLog.LogError((object)("Geschützter Fortschritt wurde gesperrt: " + reason));
		NotifyStorageFault();
	}

	private static void NotifyStorageFault()
	{
		if (!_storageFaultNoticeShown)
		{
			_storageFaultNoticeShown = true;
			TaschenhaendlerPlugin.NotifyPlayer(ModLocalization.Text("Die Fortschrittsdatei ist beschädigt oder unvollständig. Käufe und Erweiterungen bleiben gesperrt, damit keine vorhandenen Daten überschrieben werden. Bitte sichere die Dateien und prüfe das BepInEx-Log.", "The progress file is damaged or incomplete. Purchases and expansions remain locked so existing data is not overwritten. Back up the files and check the BepInEx log."));
		}
	}

	private static bool TryReadDatabase(string path, bool legacyTolerant, out ProgressDatabase database, out Exception error)
	{
		database = null;
		error = null;
		if (!File.Exists(path))
		{
			error = new FileNotFoundException("Datei nicht gefunden.", path);
			return false;
		}
		try
		{
			string text = File.ReadAllText(path);
			database = DeserializeDatabase(text, legacyTolerant);
			if (database == null)
			{
				throw new InvalidDataException("JSON enthält keine Fortschrittsdaten.");
			}
			if (database.Version < 1 || database.Version > 2)
			{
				throw new InvalidDataException($"Nicht unterstützte Fortschrittsversion {database.Version}.");
			}
			if (!legacyTolerant && database.Version != 2)
			{
				throw new InvalidDataException($"Geschützter Speicherort enthält die alte Version {database.Version} statt Version 2.");
			}
			if (database.Revision < 0)
			{
				throw new InvalidDataException("Die Fortschrittsrevision ist negativ.");
			}
			if (!legacyTolerant && (text.IndexOf("\"Version\"", StringComparison.Ordinal) < 0 || text.IndexOf("\"Revision\"", StringComparison.Ordinal) < 0 || text.IndexOf("\"Characters\"", StringComparison.Ordinal) < 0))
			{
				throw new InvalidDataException("Version, Revision oder Charakterliste fehlt in einer Version-2-Datei.");
			}
			if (legacyTolerant)
			{
				ProgressDatabase progressDatabase = database;
				if (progressDatabase.Characters == null)
				{
					progressDatabase.Characters = new List<CharacterProgress>();
				}
			}
			else
			{
				ValidateDatabase(database);
			}
			return true;
		}
		catch (Exception ex)
		{
			database = null;
			error = ex;
			return false;
		}
	}

	private static void NormalizeAll()
	{
		if (_database == null)
		{
			_database = new ProgressDatabase();
		}
		ProgressDatabase database = _database;
		if (database.Characters == null)
		{
			database.Characters = new List<CharacterProgress>();
		}
		_database.Characters.RemoveAll((CharacterProgress progress) => progress == null);
		foreach (CharacterProgress character in _database.Characters)
		{
			Normalize(character);
		}
	}

	private static void Normalize(CharacterProgress progress)
	{
		CharacterProgress characterProgress = progress;
		if (characterProgress.CharacterName == null)
		{
			characterProgress.CharacterName = string.Empty;
		}
		characterProgress = progress;
		if (characterProgress.CharacterClass == null)
		{
			characterProgress.CharacterClass = string.Empty;
		}
		characterProgress = progress;
		if (characterProgress.NextPrice == null)
		{
			characterProgress.NextPrice = string.Empty;
		}
		characterProgress = progress;
		if (characterProgress.PriceNumerator == null)
		{
			characterProgress.PriceNumerator = string.Empty;
		}
		characterProgress = progress;
		if (characterProgress.PriceDenominator == null)
		{
			characterProgress.PriceDenominator = "1";
		}
		characterProgress = progress;
		if (characterProgress.PaidTowardNext == null)
		{
			characterProgress.PaidTowardNext = "0";
		}
		characterProgress = progress;
		if (characterProgress.Overflow == null)
		{
			characterProgress.Overflow = new List<StoredItem>();
		}
		characterProgress = progress;
		if (characterProgress.FirstExtraHotkeys == null)
		{
			characterProgress.FirstExtraHotkeys = new List<int>();
		}
		characterProgress = progress;
		if (characterProgress.SecondExtraHotkeys == null)
		{
			characterProgress.SecondExtraHotkeys = new List<int>();
		}
		for (int i = 0; i < progress.Overflow.Count; i++)
		{
			StoredItem storedItem = progress.Overflow[i];
			if (storedItem == null)
			{
				progress.Overflow[i] = new StoredItem();
				continue;
			}
			StoredItem storedItem2 = storedItem;
			if (storedItem2.Id == null)
			{
				storedItem2.Id = string.Empty;
			}
			if (string.IsNullOrEmpty(storedItem.Id))
			{
				storedItem.Quantity = 0;
			}
			else if (storedItem.Quantity < 1)
			{
				storedItem.Quantity = 1;
			}
		}
		if (progress.PurchasedCount < 0)
		{
			progress.PurchasedCount = 0L;
		}
		if (progress.AppliedCount < 0)
		{
			progress.AppliedCount = 0L;
		}
		if (progress.AppliedCount > progress.PurchasedCount)
		{
			progress.AppliedCount = progress.PurchasedCount;
		}
		if (progress.GrantedSlots < 0)
		{
			progress.GrantedSlots = 0L;
		}
		if (progress.GrantedSlots == 0L && progress.AppliedCount > 0)
		{
			long num = Math.Max(1, TaschenhaendlerPlugin.Instance?.SlotsPerExpansion?.Value ?? 10);
			long val = ((progress.AppliedCount > long.MaxValue / num) ? long.MaxValue : (progress.AppliedCount * num));
			progress.GrantedSlots = Math.Max(val, progress.Overflow.Count);
		}
		else if (progress.Overflow.Count > progress.GrantedSlots)
		{
			progress.GrantedSlots = progress.Overflow.Count;
		}
		NormalizePrice(progress);
		NormalizeHotkeyList(progress.FirstExtraHotkeys, progress.GrantedSlots);
		NormalizeHotkeyList(progress.SecondExtraHotkeys, progress.GrantedSlots);
	}

	private static void NormalizePrice(CharacterProgress progress)
	{
		int num = Math.Max(1, TaschenhaendlerPlugin.Instance?.StartPrice?.Value ?? 5000);
		BigInteger result;
		bool num2 = BigInteger.TryParse(progress.PriceNumerator, NumberStyles.Integer, CultureInfo.InvariantCulture, out result) && result > 0L;
		BigInteger result2;
		bool flag = BigInteger.TryParse(progress.PriceDenominator, NumberStyles.Integer, CultureInfo.InvariantCulture, out result2) && result2 > 0L;
		if (!num2 || !flag)
		{
			if (!BigInteger.TryParse(progress.NextPrice, NumberStyles.Integer, CultureInfo.InvariantCulture, out result) || result < 1L)
			{
				result = num;
			}
			result2 = BigInteger.One;
		}
		BigInteger bigInteger = BigInteger.GreatestCommonDivisor(result, result2);
		result /= bigInteger;
		result2 /= bigInteger;
		BigInteger bigInteger2 = (result + result2 - 1) / result2;
		progress.PriceNumerator = result.ToString(CultureInfo.InvariantCulture);
		progress.PriceDenominator = result2.ToString(CultureInfo.InvariantCulture);
		progress.NextPrice = bigInteger2.ToString(CultureInfo.InvariantCulture);
		if (!BigInteger.TryParse(progress.PaidTowardNext, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result3) || result3 < 0L)
		{
			result3 = BigInteger.Zero;
		}
		if (result3 > bigInteger2)
		{
			result3 = bigInteger2;
		}
		progress.PaidTowardNext = result3.ToString(CultureInfo.InvariantCulture);
	}

	private static void NormalizeHotkeyList(List<int> mappings, long grantedSlots)
	{
		for (int i = 0; i < mappings.Count; i++)
		{
			int num = mappings[i];
			if (num < -1 || num >= grantedSlots)
			{
				mappings[i] = -1;
			}
		}
	}

	private static void LoadCandidateWithFallback(string path, string label, bool legacyTolerant, List<DatabaseCandidate> candidates)
	{
		if (string.IsNullOrWhiteSpace(path))
		{
			return;
		}
		Exception error;
		bool flag = TryAddCandidate(path, legacyTolerant, candidates, out error);
		if (!flag && File.Exists(path))
		{
			TaschenhaendlerPlugin.ModLog.LogWarning((object)(label + " ist nicht lesbar: " + error?.Message));
			PreserveCorruptFile(path);
		}
		string path2 = path + ".tmp";
		if (TryAddCandidate(path2, legacyTolerant, candidates, out var error2))
		{
			TaschenhaendlerPlugin.ModLog.LogWarning((object)("Für " + label + " wurde eine vollständige .tmp-Datei als Absturzsicherung gefunden."));
		}
		else if (File.Exists(path2))
		{
			TaschenhaendlerPlugin.ModLog.LogWarning((object)("Die .tmp-Absturzsicherung von " + label + " ist nicht lesbar: " + error2?.Message));
		}
		string path3 = path + ".bak";
		if (TryAddCandidate(path3, legacyTolerant, candidates, out var error3))
		{
			if (!flag)
			{
				TaschenhaendlerPlugin.ModLog.LogWarning((object)(label + " wurde aus ihrer .bak-Sicherung wiederhergestellt."));
			}
		}
		else if (File.Exists(path3))
		{
			TaschenhaendlerPlugin.ModLog.LogWarning((object)("Auch die Sicherung von " + label + " ist nicht lesbar: " + error3?.Message));
		}
	}

	private static bool TryAddCandidate(string path, bool legacyTolerant, List<DatabaseCandidate> candidates, out Exception error)
	{
		if (!TryReadDatabase(path, legacyTolerant, out var database, out error))
		{
			return false;
		}
		candidates.Add(new DatabaseCandidate(path, database, File.GetLastWriteTimeUtc(path).Ticks));
		return true;
	}

	private static ProgressDatabase MergeCandidates(IEnumerable<DatabaseCandidate> candidates)
	{
		ProgressDatabase progressDatabase = new ProgressDatabase();
		Dictionary<string, ProgressSelection> dictionary = new Dictionary<string, ProgressSelection>(StringComparer.OrdinalIgnoreCase);
		List<DatabaseCandidate> source = candidates.ToList();
		long highestRevision = source.Max((DatabaseCandidate entry) => Math.Max(0L, entry.Database.Revision));
		foreach (DatabaseCandidate item in from entry in source
			where Math.Max(0L, entry.Database.Revision) == highestRevision
			orderby entry.TimestampUtcTicks
			select entry)
		{
			progressDatabase.Revision = Math.Max(progressDatabase.Revision, Math.Max(0L, item.Database.Revision));
			ProgressDatabase database = item.Database;
			if (database.Characters == null)
			{
				database.Characters = new List<CharacterProgress>();
			}
			foreach (CharacterProgress item2 in item.Database.Characters.Where((CharacterProgress entry) => entry != null))
			{
				Normalize(item2);
				string text = NormalizeName(item2.CharacterName);
				string key = ((!string.IsNullOrEmpty(text)) ? ("name:" + text) : ("slot:" + item2.SlotIndex.ToString(CultureInfo.InvariantCulture)));
				if (!dictionary.TryGetValue(key, out var value) || CompareProgress(item2, value.Progress) > 0 || (CompareProgress(item2, value.Progress) == 0 && item.TimestampUtcTicks >= value.TimestampUtcTicks))
				{
					dictionary[key] = new ProgressSelection(item2, item.TimestampUtcTicks);
				}
			}
		}
		progressDatabase.Characters = dictionary.Values.Select((ProgressSelection entry) => entry.Progress).ToList();
		return progressDatabase;
	}

	private static int CompareProgress(CharacterProgress left, CharacterProgress right)
	{
		int num = left.PurchasedCount.CompareTo(right.PurchasedCount);
		if (num != 0)
		{
			return num;
		}
		num = left.AppliedCount.CompareTo(right.AppliedCount);
		if (num != 0)
		{
			return num;
		}
		num = left.GrantedSlots.CompareTo(right.GrantedSlots);
		if (num != 0)
		{
			return num;
		}
		num = ParseNonNegative(left.PaidTowardNext).CompareTo(ParseNonNegative(right.PaidTowardNext));
		if (num != 0)
		{
			return num;
		}
		return (left.Overflow?.Count ?? 0).CompareTo(right.Overflow?.Count ?? 0);
	}

	private static BigInteger ParseNonNegative(string value)
	{
		if (!BigInteger.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) || !(result >= 0L))
		{
			return BigInteger.Zero;
		}
		return result;
	}

	private static string NormalizeName(string value)
	{
		return (value ?? string.Empty).Trim();
	}

	private static bool ClassesMatch(string storedClass, string currentClass)
	{
		string text = NormalizeName(storedClass);
		string text2 = NormalizeName(currentClass);
		if (!string.IsNullOrEmpty(text) && !string.IsNullOrEmpty(text2))
		{
			return string.Equals(text, text2, StringComparison.OrdinalIgnoreCase);
		}
		return true;
	}

	private static DataContractJsonSerializer CreateSerializer()
	{
		return new DataContractJsonSerializer(typeof(ProgressDatabase), SerializerSettings);
	}

	private static DataContractJsonSerializer CreateLegacySerializer()
	{
		return new DataContractJsonSerializer(typeof(LegacyProgressDatabase), SerializerSettings);
	}

	private static string SerializeDatabase(ProgressDatabase database)
	{
		using MemoryStream memoryStream = new MemoryStream();
		CreateSerializer().WriteObject(memoryStream, database);
		return Encoding.UTF8.GetString(memoryStream.ToArray());
	}

	private static ProgressDatabase DeserializeDatabase(string json, bool legacyTolerant)
	{
		try
		{
			using MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(json ?? string.Empty), writable: false);
			return (ProgressDatabase)CreateSerializer().ReadObject(stream);
		}
		catch (Exception ex)
		{
			if (!legacyTolerant)
			{
				throw;
			}
			try
			{
				using MemoryStream stream2 = new MemoryStream(Encoding.UTF8.GetBytes(json ?? string.Empty), writable: false);
				LegacyProgressDatabase legacyProgressDatabase = (LegacyProgressDatabase)CreateLegacySerializer().ReadObject(stream2);
				if (legacyProgressDatabase == null)
				{
					throw new InvalidDataException("Verwalteter Legacy-Leser lieferte keine Fortschrittsdaten.");
				}
				return new ProgressDatabase
				{
					Version = legacyProgressDatabase.Version,
					Revision = legacyProgressDatabase.Revision,
					Characters = (legacyProgressDatabase.Characters ?? new List<CharacterProgress>())
				};
			}
			catch (Exception ex2)
			{
				try
				{
					return JsonUtility.FromJson<ProgressDatabase>(json) ?? throw new InvalidDataException("Unity-Legacyleser lieferte keine Fortschrittsdaten.");
				}
				catch (Exception ex3)
				{
					throw new InvalidDataException("Fortschritts-JSON konnte weder im geschützten noch in den alten Formaten gelesen werden.", new AggregateException(ex, ex2, ex3));
				}
			}
		}
	}

	private static void ValidateDatabase(ProgressDatabase database)
	{
		if (database == null || database.Version != 2 || database.Revision < 0 || database.Characters == null)
		{
			throw new InvalidDataException("Version-2-Umschlag ist unvollständig oder ungültig.");
		}
		HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
		foreach (CharacterProgress character in database.Characters)
		{
			if (character == null)
			{
				throw new InvalidDataException("Die Charakterliste enthält einen leeren Eintrag.");
			}
			string text = NormalizeName(character.CharacterName);
			if (string.IsNullOrEmpty(text) || !hashSet.Add(text))
			{
				throw new InvalidDataException("Ein Charaktername fehlt oder ist doppelt vorhanden.");
			}
			if (character.PurchasedCount < 0 || character.AppliedCount < 0 || character.AppliedCount > character.PurchasedCount || character.GrantedSlots < 0)
			{
				throw new InvalidDataException("Ungültige Zähler für '" + text + "'.");
			}
			if (character.Overflow == null || character.FirstExtraHotkeys == null || character.SecondExtraHotkeys == null)
			{
				throw new InvalidDataException("Zusatzslot- oder Hotkeylisten für '" + text + "' fehlen.");
			}
			if (character.Overflow.Count > character.GrantedSlots)
			{
				throw new InvalidDataException("Mehr gespeicherte Zusatzslots als gewährte Plätze für '" + text + "'.");
			}
			RequirePositiveInteger(character.PriceNumerator, "Preis-Zähler für '" + text + "'");
			RequirePositiveInteger(character.PriceDenominator, "Preis-Nenner für '" + text + "'");
			RequirePositiveInteger(character.NextPrice, "nächster Preis für '" + text + "'");
			RequireNonNegativeInteger(character.PaidTowardNext, "Teilzahlung für '" + text + "'");
			foreach (StoredItem item in character.Overflow)
			{
				if (item == null || item.Id == null || (string.IsNullOrEmpty(item.Id) && item.Quantity != 0) || (!string.IsNullOrEmpty(item.Id) && item.Quantity < 1))
				{
					throw new InvalidDataException("Ungültiger Zusatzslot-Inhalt für '" + text + "'.");
				}
			}
			ValidateHotkeys(character.FirstExtraHotkeys, character.GrantedSlots, text);
			ValidateHotkeys(character.SecondExtraHotkeys, character.GrantedSlots, text);
		}
	}

	private static void RequirePositiveInteger(string value, string label)
	{
		if (!BigInteger.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) || result <= 0L)
		{
			throw new InvalidDataException(label + " ist keine positive Ganzzahl.");
		}
	}

	private static void RequireNonNegativeInteger(string value, string label)
	{
		if (!BigInteger.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) || result < 0L)
		{
			throw new InvalidDataException(label + " ist keine nichtnegative Ganzzahl.");
		}
	}

	private static void ValidateHotkeys(List<int> mappings, long grantedSlots, string characterName)
	{
		foreach (int mapping in mappings)
		{
			if (mapping < -1 || mapping >= grantedSlots)
			{
				throw new InvalidDataException("Ungültige Zusatzslot-Hotkeyzuordnung für '" + characterName + "'.");
			}
		}
	}

	private static bool TryWriteDatabase(string path, string json, out Exception error)
	{
		error = null;
		string text = path + ".tmp";
		try
		{
			string directoryName = Path.GetDirectoryName(path);
			if (!string.IsNullOrEmpty(directoryName))
			{
				Directory.CreateDirectory(directoryName);
			}
			byte[] bytes = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false).GetBytes(json);
			using (FileStream fileStream = new FileStream(text, FileMode.Create, FileAccess.Write, FileShare.None))
			{
				fileStream.Write(bytes, 0, bytes.Length);
				fileStream.Flush(flushToDisk: true);
			}
			if (File.Exists(path))
			{
				string text2 = path + ".bak";
				try
				{
					File.Replace(text, path, text2, ignoreMetadataErrors: true);
				}
				catch (PlatformNotSupportedException)
				{
					File.Copy(path, text2, overwrite: true);
					File.Copy(text, path, overwrite: true);
					File.Delete(text);
				}
			}
			else
			{
				File.Move(text, path);
			}
			return true;
		}
		catch (Exception ex2)
		{
			error = ex2;
			try
			{
				if (File.Exists(text))
				{
					File.Delete(text);
				}
			}
			catch
			{
			}
			return false;
		}
	}

	private static bool TrySerializeAndValidate(out string json, out Exception error)
	{
		json = null;
		error = null;
		try
		{
			ValidateDatabase(_database);
			json = SerializeDatabase(_database);
			ProgressDatabase progressDatabase = DeserializeDatabase(json, legacyTolerant: false);
			ValidateDatabase(progressDatabase);
			if (progressDatabase.Version != _database.Version || progressDatabase.Revision != _database.Revision)
			{
				throw new InvalidDataException("Version oder Revision ging beim JSON-Rundlauf verloren.");
			}
			ProgressDatabase progressDatabase2 = progressDatabase;
			if (progressDatabase2.Characters == null)
			{
				progressDatabase2.Characters = new List<CharacterProgress>();
			}
			if (progressDatabase.Characters.Count != _database.Characters.Count)
			{
				throw new InvalidDataException($"Charakteranzahl änderte sich beim JSON-Rundlauf von {_database.Characters.Count} auf {progressDatabase.Characters.Count}.");
			}
			foreach (CharacterProgress original in _database.Characters)
			{
				CharacterProgress characterProgress = progressDatabase.Characters.FirstOrDefault((CharacterProgress candidate) => candidate != null && candidate.SlotIndex == original.SlotIndex && string.Equals(NormalizeName(candidate.CharacterName), NormalizeName(original.CharacterName), StringComparison.OrdinalIgnoreCase));
				if (characterProgress == null || characterProgress.PurchasedCount != original.PurchasedCount || !string.Equals(characterProgress.CharacterName, original.CharacterName, StringComparison.Ordinal) || !string.Equals(characterProgress.CharacterClass, original.CharacterClass, StringComparison.Ordinal) || characterProgress.AppliedCount != original.AppliedCount || characterProgress.GrantedSlots != original.GrantedSlots || !string.Equals(characterProgress.PriceNumerator, original.PriceNumerator, StringComparison.Ordinal) || !string.Equals(characterProgress.PriceDenominator, original.PriceDenominator, StringComparison.Ordinal) || !string.Equals(characterProgress.NextPrice, original.NextPrice, StringComparison.Ordinal) || !string.Equals(characterProgress.PaidTowardNext, original.PaidTowardNext, StringComparison.Ordinal) || !StoredItemsEqual(characterProgress.Overflow, original.Overflow) || !IntListsEqual(characterProgress.FirstExtraHotkeys, original.FirstExtraHotkeys) || !IntListsEqual(characterProgress.SecondExtraHotkeys, original.SecondExtraHotkeys))
				{
					throw new InvalidDataException("Fortschrittsdaten für '" + original.CharacterName + "' gingen beim JSON-Rundlauf verloren.");
				}
			}
			return true;
		}
		catch (Exception ex)
		{
			error = ex;
			json = null;
			return false;
		}
	}

	private static bool StoredItemsEqual(IReadOnlyList<StoredItem> left, IReadOnlyList<StoredItem> right)
	{
		if (left == null || right == null || left.Count != right.Count)
		{
			return false;
		}
		for (int i = 0; i < left.Count; i++)
		{
			StoredItem storedItem = left[i];
			StoredItem storedItem2 = right[i];
			if (storedItem == null || storedItem2 == null || storedItem.Quantity != storedItem2.Quantity || !string.Equals(storedItem.Id, storedItem2.Id, StringComparison.Ordinal))
			{
				return false;
			}
		}
		return true;
	}

	private static bool IntListsEqual(IReadOnlyList<int> left, IReadOnlyList<int> right)
	{
		if (left == null || right == null || left.Count != right.Count)
		{
			return false;
		}
		for (int i = 0; i < left.Count; i++)
		{
			if (left[i] != right[i])
			{
				return false;
			}
		}
		return true;
	}

	private static void PreserveCorruptFile(string path)
	{
		try
		{
			string destFileName = path + ".corrupt-" + DateTime.Now.ToString("yyyyMMdd-HHmmss", CultureInfo.InvariantCulture);
			File.Copy(path, destFileName, overwrite: false);
		}
		catch (Exception ex)
		{
			TaschenhaendlerPlugin.ModLog.LogWarning((object)("Beschädigte Datei konnte nicht zusätzlich kopiert werden: " + ex.Message));
		}
	}
}