using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using BigBag.Configuration;
using BigBag.Localization;
using HarmonyLib;
using Il2CppSystem.Collections.Generic;
using UnityEngine;
using UnityEngine.Localization.Settings;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("BigBag")]
[assembly: AssemblyDescription("Big Bag mod for Island Market Simulator by Ice Box Studio")]
[assembly: AssemblyCompany("Ice Box Studio")]
[assembly: AssemblyProduct("BigBag")]
[assembly: AssemblyCopyright("Copyright © 2026 Ice Box Studio All rights reserved.")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("5DC5CB15-271F-47F8-9755-B2A5A9738743")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace BigBag
{
	[BepInPlugin("IceBoxStudio.IslandMarketSimulator.BigBag", "BigBag", "1.0.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class BigBag : BasePlugin
	{
		public static BigBag _Instance;

		private Harmony _harmony;

		private bool patchesApplied;

		private const string ModConfigManagerApiTypeName = "ModConfigManager.Api.ModConfigManagerAPI";

		private const string ModConfigManagerRegisterMethodName = "RegisterPluginInfo";

		public static BigBag Instance => _Instance;

		internal static ManualLogSource Logger { get; private set; }

		public override void Load()
		{
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Expected O, but got Unknown
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Expected O, but got Unknown
			_Instance = this;
			Logger = ((BasePlugin)this).Log;
			bool flag = default(bool);
			try
			{
				Logger.LogInfo((object)"=============================================");
				ManualLogSource logger = Logger;
				BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(1, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("BigBag");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(LocalizationManager.Instance.GetLocalizedText("plugin.initializing"));
				}
				logger.LogInfo(val);
				ManualLogSource logger2 = Logger;
				val = new BepInExInfoLogInterpolatedStringHandler(54, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(LocalizationManager.Instance.GetLocalizedText("plugin.author_prefix"));
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Ice Box Studio(https://steamcommunity.com/id/ibox666/)");
				}
				logger2.LogInfo(val);
				ConfigManager.Initialize(((BasePlugin)this).Config);
				RegisterToModConfigManager();
				ApplyPatches();
				ManualLogSource logger3 = Logger;
				val = new BepInExInfoLogInterpolatedStringHandler(1, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("BigBag");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(LocalizationManager.Instance.GetLocalizedText("plugin.initialized"));
				}
				logger3.LogInfo(val);
				Logger.LogInfo((object)"=============================================");
			}
			catch (Exception ex)
			{
				ManualLogSource logger4 = Logger;
				BepInExErrorLogInterpolatedStringHandler val2 = new BepInExErrorLogInterpolatedStringHandler(9, 3, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>("BigBag");
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" 初始化错误: ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(ex.Message);
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("\n");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(ex.StackTrace);
				}
				logger4.LogError(val2);
			}
		}

		private void ApplyPatches()
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			if (!patchesApplied)
			{
				try
				{
					_harmony = new Harmony("IceBoxStudio.IslandMarketSimulator.BigBag");
					_harmony.PatchAll();
					patchesApplied = true;
					return;
				}
				catch (Exception ex)
				{
					ManualLogSource logger = Logger;
					bool flag = default(bool);
					BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(10, 3, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("BigBag");
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" 应用补丁错误: ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\n");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.StackTrace);
					}
					logger.LogError(val);
					return;
				}
			}
			Logger.LogInfo((object)LocalizationManager.Instance.GetLocalizedText("plugin.patches_skipped"));
		}

		private void RegisterToModConfigManager()
		{
			Type type = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault((Assembly assembly) => assembly.GetType("ModConfigManager.Api.ModConfigManagerAPI") != null)?.GetType("ModConfigManager.Api.ModConfigManagerAPI");
			if (!(type == null))
			{
				MethodInfo method = type.GetMethod("RegisterPluginInfo", BindingFlags.Static | BindingFlags.Public);
				if (!(method == null))
				{
					method.Invoke(null, new object[5]
					{
						"IceBoxStudio.IslandMarketSimulator.BigBag",
						LocalizationManager.Instance.GetLocalizedText("plugin.name"),
						"1.0.0",
						"Ice Box Studio",
						LocalizationManager.Instance.GetLocalizedText("plugin.description")
					});
				}
			}
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "IceBoxStudio.IslandMarketSimulator.BigBag";

		public const string PLUGIN_NAME = "BigBag";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace BigBag.Patches
{
	internal static class HeldItemPanelsPatch
	{
		private const int RaiseThreshold = 8;

		private static ItemManager _cachedManager = null;

		private static RectTransform _cachedHeldPanelRect = null;

		private static Vector2 _cachedHeldPanelBasePos = Vector2.zero;

		private static RectTransform _cachedEventPanelRect = null;

		private static Vector2 _cachedEventPanelBasePos = Vector2.zero;

		internal static void Apply(ItemManager itemManager)
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: 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_0094: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)itemManager == (Object)null)
			{
				return;
			}
			if (itemManager.availableSlots <= 8)
			{
				RestoreBasePositions(itemManager);
				return;
			}
			EnsureCache(itemManager);
			float num = Mathf.Abs(itemManager.indicatorMoveValue);
			if (num < 1f)
			{
				num = 125f;
			}
			int num2 = CalculateBagRows(itemManager);
			float num3 = num * (float)num2;
			if ((Object)(object)_cachedHeldPanelRect != (Object)null)
			{
				_cachedHeldPanelRect.anchoredPosition = _cachedHeldPanelBasePos + new Vector2(0f, num3);
			}
			if ((Object)(object)_cachedEventPanelRect != (Object)null)
			{
				_cachedEventPanelRect.anchoredPosition = _cachedEventPanelBasePos + new Vector2(0f, num3);
			}
		}

		private static void RestoreBasePositions(ItemManager itemManager)
		{
			//IL_0020: 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)
			if (!((Object)(object)_cachedManager != (Object)(object)itemManager))
			{
				if ((Object)(object)_cachedHeldPanelRect != (Object)null)
				{
					_cachedHeldPanelRect.anchoredPosition = _cachedHeldPanelBasePos;
				}
				if ((Object)(object)_cachedEventPanelRect != (Object)null)
				{
					_cachedEventPanelRect.anchoredPosition = _cachedEventPanelBasePos;
				}
			}
		}

		private static void EnsureCache(ItemManager itemManager)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: 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_00aa: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_cachedManager == (Object)(object)itemManager && (Object)(object)_cachedHeldPanelRect != (Object)null && (Object)(object)_cachedEventPanelRect != (Object)null)
			{
				return;
			}
			Transform val = FindCanvasRoot(itemManager);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			_cachedManager = itemManager;
			Transform val2 = FindChildByPrefix(val, "HeldItemPanels");
			if ((Object)(object)val2 != (Object)null)
			{
				RectTransform component = ((Component)val2).GetComponent<RectTransform>();
				if ((Object)(object)component != (Object)null)
				{
					_cachedHeldPanelRect = component;
					_cachedHeldPanelBasePos = component.anchoredPosition;
				}
			}
			Transform val3 = FindChildByPrefix(val, "ActiveEventPanel");
			if ((Object)(object)val3 != (Object)null)
			{
				RectTransform component2 = ((Component)val3).GetComponent<RectTransform>();
				if ((Object)(object)component2 != (Object)null)
				{
					_cachedEventPanelRect = component2;
					_cachedEventPanelBasePos = component2.anchoredPosition;
				}
			}
		}

		private static Transform FindCanvasRoot(ItemManager itemManager)
		{
			Transform val = null;
			if (itemManager.bagSlotImages != null && itemManager.bagSlotImages.Count > 0 && (Object)(object)itemManager.bagSlotImages[0] != (Object)null)
			{
				val = itemManager.bagSlotImages[0].transform;
			}
			else if ((Object)(object)itemManager.itemIndicatorImage != (Object)null)
			{
				val = ((Component)itemManager.itemIndicatorImage).transform;
			}
			else if ((Object)(object)itemManager.baseItemImage != (Object)null)
			{
				val = ((Component)itemManager.baseItemImage).transform;
			}
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			Transform val2 = val;
			while ((Object)(object)val2 != (Object)null)
			{
				if ((Object)(object)((Component)val2).GetComponent<Canvas>() != (Object)null)
				{
					return val2;
				}
				val2 = val2.parent;
			}
			val2 = val;
			while ((Object)(object)val2.parent != (Object)null)
			{
				val2 = val2.parent;
			}
			return val2;
		}

		private static Transform FindChildByPrefix(Transform parent, string prefix)
		{
			for (int i = 0; i < parent.childCount; i++)
			{
				Transform child = parent.GetChild(i);
				if ((Object)(object)child != (Object)null && !string.IsNullOrEmpty(((Object)child).name) && ((Object)child).name.StartsWith(prefix))
				{
					return child;
				}
			}
			return null;
		}

		private static int CalculateBagRows(ItemManager itemManager)
		{
			int num = Mathf.Max(0, itemManager.availableSlots - 1);
			int valueOrDefault = (ConfigManager.Instance?.SlotsPerRow?.Value).GetValueOrDefault(5);
			valueOrDefault = Mathf.Max(2, valueOrDefault);
			int num2 = valueOrDefault - 1;
			if (num <= num2)
			{
				return 1;
			}
			int num3 = Mathf.CeilToInt((float)(num - num2) / (float)valueOrDefault);
			return 1 + Mathf.Max(0, num3);
		}
	}
	[HarmonyPatch(typeof(ItemManager), "InitItemManager")]
	internal static class HeldItemPanelsInitPatch
	{
		[HarmonyPostfix]
		private static void Postfix(ItemManager __instance)
		{
			HeldItemPanelsPatch.Apply(__instance);
		}
	}
	[HarmonyPatch(typeof(ItemManager), "HandleBagSlots")]
	internal static class HeldItemPanelsHandleBagSlotsPatch
	{
		[HarmonyPostfix]
		private static void Postfix(ItemManager __instance)
		{
			HeldItemPanelsPatch.Apply(__instance);
		}
	}
	[HarmonyPatch(typeof(ItemManager), "SwitchSlot")]
	internal static class HeldItemPanelsSwitchSlotPatch
	{
		[HarmonyPostfix]
		private static void Postfix(ItemManager __instance)
		{
			HeldItemPanelsPatch.Apply(__instance);
		}
	}
	[HarmonyPatch(typeof(ItemManager), "Update")]
	internal static class HeldItemPanelsUpdatePatch
	{
		[HarmonyPostfix]
		private static void Postfix(ItemManager __instance)
		{
			HeldItemPanelsPatch.Apply(__instance);
		}
	}
	internal static class BagPatch
	{
		private static ItemManager _indMgr;

		private static float _indBaseY;

		private static ItemManager _colorMgr;

		private static Color _indBaseColor;

		internal static int ResolveCapacity(int orig)
		{
			ConfigManager instance = ConfigManager.Instance;
			if (instance == null)
			{
				return orig;
			}
			int value;
			switch (orig)
			{
			case 3:
				value = instance.SmallBagCapacity.Value;
				break;
			case 4:
				value = instance.MediumBagCapacity.Value;
				break;
			case 5:
				value = instance.LargeBagCapacity.Value;
				break;
			default:
				return orig;
			}
			return Mathf.Max(0, value - 1);
		}

		internal static void EnsureSlots(ItemManager mgr, int count)
		{
			//IL_0055: 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_012b: 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_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: 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_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: 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_0098: 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_00a0: 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)
			if ((Object)(object)mgr == (Object)null || mgr.bagSlotImages == null || count <= 0 || mgr.bagSlotImages.Count == 0)
			{
				return;
			}
			GameObject val = mgr.bagSlotImages[0];
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			Transform parent = val.transform.parent;
			RectTransform component = val.GetComponent<RectTransform>();
			Vector2 spacing = GetSpacing(mgr, mgr.indicatorMoveValue);
			if ((Object)(object)component != (Object)null)
			{
				for (int i = 1; i < mgr.bagSlotImages.Count; i++)
				{
					GameObject val2 = mgr.bagSlotImages[i];
					if (!((Object)(object)val2 == (Object)null))
					{
						RectTransform component2 = val2.GetComponent<RectTransform>();
						if ((Object)(object)component2 != (Object)null)
						{
							component2.anchoredPosition = component.anchoredPosition + SlotOffset(i, spacing);
						}
					}
				}
			}
			for (int j = mgr.bagSlotImages.Count; j < count; j++)
			{
				GameObject val3 = Object.Instantiate<GameObject>(val, parent);
				((Object)val3).name = "BagSlot_Expanded_" + j;
				val3.SetActive(false);
				mgr.bagSlotImages.Add(val3);
				RectTransform component3 = val3.GetComponent<RectTransform>();
				if ((Object)(object)component3 != (Object)null && (Object)(object)component != (Object)null)
				{
					component3.anchoredPosition = component.anchoredPosition + SlotOffset(j, spacing);
					component3.anchorMin = component.anchorMin;
					component3.anchorMax = component.anchorMax;
					component3.pivot = component.pivot;
					component3.sizeDelta = component.sizeDelta;
					((Transform)component3).localScale = ((Transform)component).localScale;
				}
			}
		}

		internal static void ResizeBagData(ItemManager mgr, int targetCount)
		{
			if (!((Object)(object)mgr == (Object)null))
			{
				if (targetCount < 0)
				{
					targetCount = 0;
				}
				List<GameObject> val = mgr.bagSlots ?? new List<GameObject>();
				List<GameObject> val2 = new List<GameObject>(targetCount);
				for (int i = 0; i < targetCount; i++)
				{
					val2.Add((i < val.Count) ? val[i] : null);
				}
				mgr.bagSlots = val2;
				mgr.availableSlots = targetCount + 1;
				if (mgr.currentSlotIndex >= mgr.availableSlots)
				{
					mgr.currentSlotIndex = mgr.availableSlots - 1;
				}
				if (mgr.currentSlotIndex < 0)
				{
					mgr.currentSlotIndex = 0;
				}
			}
		}

		internal static void RefreshSlots(ItemManager mgr, int activeCount)
		{
			if ((Object)(object)mgr == (Object)null || mgr.bagSlotImages == null)
			{
				return;
			}
			for (int i = 0; i < mgr.bagSlotImages.Count; i++)
			{
				GameObject val = mgr.bagSlotImages[i];
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				bool flag = i < activeCount;
				val.SetActive(flag);
				Image component = val.GetComponent<Image>();
				if (!((Object)(object)component == (Object)null))
				{
					if (!flag)
					{
						component.sprite = mgr.defaultSprite;
						continue;
					}
					GameObject val2 = ((i < mgr.bagSlots.Count) ? mgr.bagSlots[i] : null);
					BaseItem val3 = (((Object)(object)val2 != (Object)null) ? val2.GetComponent<BaseItem>() : null);
					component.sprite = (((Object)(object)val3 != (Object)null && (Object)(object)val3.itemData != (Object)null) ? val3.itemData.iconSprite : mgr.defaultSprite);
				}
			}
		}

		internal static void SyncHeldItem(ItemManager mgr)
		{
			if (!((Object)(object)mgr == (Object)null))
			{
				if (mgr.currentSlotIndex == 0)
				{
					mgr.heldItem = mgr.baseSlotItem;
					return;
				}
				int num = mgr.currentSlotIndex - 1;
				mgr.heldItem = ((num >= 0 && num < mgr.bagSlots.Count) ? mgr.bagSlots[num] : null);
			}
		}

		internal static void RefreshIndicator(ItemManager mgr)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)mgr == (Object)null) && !((Object)(object)mgr.itemIndicatorImage == (Object)null))
			{
				ApplyColor(mgr);
				RectTransform rectTransform = ((Graphic)mgr.itemIndicatorImage).rectTransform;
				if ((Object)(object)_indMgr != (Object)(object)mgr)
				{
					_indBaseY = rectTransform.anchoredPosition.y;
					_indMgr = mgr;
				}
				if (mgr.currentSlotIndex == 0)
				{
					rectTransform.anchoredPosition = new Vector2(mgr.indicatorStartXValue, _indBaseY);
					return;
				}
				(int row, int col) tuple = SlotRowCol(mgr.currentSlotIndex - 1);
				int item = tuple.row;
				int item2 = tuple.col;
				float num = mgr.indicatorMoveValue * (float)(item2 + ((item == 0) ? 1 : 0)) + mgr.indicatorStartXValue;
				float num2 = _indBaseY + Mathf.Abs(mgr.indicatorMoveValue) * (float)item;
				rectTransform.anchoredPosition = new Vector2(num, num2);
			}
		}

		internal static void ApplyColor(ItemManager mgr)
		{
			//IL_002b: 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_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: 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)
			if (!((Object)(object)mgr == (Object)null) && !((Object)(object)mgr.itemIndicatorImage == (Object)null))
			{
				if ((Object)(object)_colorMgr != (Object)(object)mgr)
				{
					_indBaseColor = ((Graphic)mgr.itemIndicatorImage).color;
					_colorMgr = mgr;
				}
				string text = ConfigManager.Instance?.BagHighlightColor?.Value;
				if (string.IsNullOrWhiteSpace(text))
				{
					((Graphic)mgr.itemIndicatorImage).color = _indBaseColor;
				}
				else
				{
					Color val = default(Color);
					((Graphic)mgr.itemIndicatorImage).color = (ColorUtility.TryParseHtmlString(text, ref val) ? val : _indBaseColor);
				}
			}
		}

		private static (int row, int col) SlotRowCol(int bagSlotIndex)
		{
			int num = Mathf.Max(2, (ConfigManager.Instance?.SlotsPerRow?.Value).GetValueOrDefault(5));
			int num2 = num - 1;
			if (bagSlotIndex < num2)
			{
				return (0, bagSlotIndex);
			}
			int num3 = bagSlotIndex - num2;
			return (num3 / num + 1, num3 % num);
		}

		internal static Vector2 SlotOffset(int slotIndex, Vector2 spacing)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			(int row, int col) tuple = SlotRowCol(slotIndex);
			int item = tuple.row;
			int item2 = tuple.col;
			float num = spacing.x * (float)item2;
			if (item > 0)
			{
				num -= spacing.x;
			}
			return new Vector2(num, spacing.y * (float)item);
		}

		private static Vector2 GetSpacing(ItemManager mgr, float fallbackX)
		{
			//IL_00a7: 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_0082: Unknown result type (might be due to invalid IL or missing references)
			float num = fallbackX;
			if ((Object)(object)mgr != (Object)null && mgr.bagSlotImages != null && mgr.bagSlotImages.Count > 1)
			{
				GameObject val = mgr.bagSlotImages[0];
				GameObject val2 = mgr.bagSlotImages[1];
				if ((Object)(object)val != (Object)null && (Object)(object)val2 != (Object)null)
				{
					RectTransform component = val.GetComponent<RectTransform>();
					RectTransform component2 = val2.GetComponent<RectTransform>();
					if ((Object)(object)component != (Object)null && (Object)(object)component2 != (Object)null)
					{
						float num2 = component2.anchoredPosition.x - component.anchoredPosition.x;
						if (Mathf.Abs(num2) > 0.01f)
						{
							num = num2;
						}
					}
				}
			}
			return new Vector2(num, Mathf.Abs(num));
		}
	}
	[HarmonyPatch(typeof(ItemManager), "InitItemManager")]
	internal static class ItemManagerInitPatch
	{
		[HarmonyPostfix]
		private static void Postfix(ItemManager __instance)
		{
			BagPatch.RefreshIndicator(__instance);
		}
	}
	[HarmonyPatch(typeof(ItemManager), "HandleBagSlots")]
	internal static class ItemManagerHandleBagSlotsPatch
	{
		[HarmonyPrefix]
		private static void Prefix(ItemManager __instance, ref int count)
		{
			count = BagPatch.ResolveCapacity(count);
			BagPatch.EnsureSlots(__instance, count);
		}
	}
	[HarmonyPatch(typeof(TestSave), "LoadItemManager")]
	internal static class TestSaveLoadItemManagerPatch
	{
		[HarmonyPostfix]
		private static void Postfix(TestSave __instance)
		{
			GameObject val = ((__instance != null) ? __instance.player : null);
			if (!((Object)(object)val == (Object)null))
			{
				PlayerSaveHelper component = val.GetComponent<PlayerSaveHelper>();
				ItemManager val2 = (((Object)(object)component != (Object)null) ? component.itemManager : null);
				if (!((Object)(object)val2 == (Object)null) && !((Object)(object)val2.currentBag == (Object)null))
				{
					int num = BagPatch.ResolveCapacity(val2.currentBag.slotCapacity);
					BagPatch.EnsureSlots(val2, num);
					BagPatch.ResizeBagData(val2, num);
					BagPatch.RefreshSlots(val2, num);
					BagPatch.SyncHeldItem(val2);
					BagPatch.RefreshIndicator(val2);
				}
			}
		}
	}
	[HarmonyPatch(typeof(ItemManager), "SwitchSlot")]
	internal static class ItemManagerSwitchSlotPatch
	{
		[HarmonyPostfix]
		private static void Postfix(ItemManager __instance)
		{
			BagPatch.RefreshIndicator(__instance);
		}
	}
	[HarmonyPatch(typeof(ItemManager), "Update")]
	internal static class ItemManagerUpdatePatch
	{
		[HarmonyPostfix]
		private static void Postfix(ItemManager __instance)
		{
			BagPatch.ApplyColor(__instance);
		}
	}
}
namespace BigBag.Localization
{
	public static class LocalizationHelper
	{
		public static Dictionary<string, string> GetDefaultTranslations(string language)
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			switch (language)
			{
			case "zh":
				dictionary.Add("plugin.initializing", "开始初始化...");
				dictionary.Add("plugin.author_prefix", "作者：");
				dictionary.Add("plugin.initialized", "初始化成功！");
				dictionary.Add("plugin.patches_skipped", "补丁已应用，跳过...");
				dictionary.Add("plugin.name", "大背包");
				dictionary.Add("plugin.description", "增加三种背包的背包容量并支持调整选择框颜色。");
				dictionary.Add("config.small_bag_capacity", "小型背包增加的格子数量\n24格为一行");
				dictionary.Add("config.medium_bag_capacity", "中型背包增加的格子数量\n24格为一行");
				dictionary.Add("config.large_bag_capacity", "大型背包增加的格子数量\n24格为一行");
				dictionary.Add("config.slots_per_row", "每行最大槽位数量\n24格为一行");
				dictionary.Add("config.bag_highlight_color", "背包高亮框颜色（留空使用游戏默认颜色，支持 #RRGGBB 或 #RRGGBBAA）");
				break;
			case "zh-TW":
				dictionary.Add("plugin.initializing", "開始初始化...");
				dictionary.Add("plugin.author_prefix", "作者：");
				dictionary.Add("plugin.initialized", "初始化成功！");
				dictionary.Add("plugin.patches_skipped", "補丁已套用，跳過...");
				dictionary.Add("plugin.name", "大背包");
				dictionary.Add("plugin.description", "增加三種背包的背包容量並支援調整選擇框顏色。");
				dictionary.Add("config.small_bag_capacity", "小型背包增加的格子數量\n24格為一行");
				dictionary.Add("config.medium_bag_capacity", "中型背包增加的格子數量\n24格為一行");
				dictionary.Add("config.large_bag_capacity", "大型背包增加的格子數量\n24格為一行");
				dictionary.Add("config.slots_per_row", "每行最大槽位數量\n24格為一行");
				dictionary.Add("config.bag_highlight_color", "背包高亮框顏色（留空使用遊戲預設顏色，支援 #RRGGBB 或 #RRGGBBAA）");
				break;
			case "en":
				dictionary.Add("plugin.initializing", "Initializing...");
				dictionary.Add("plugin.author_prefix", "Author: ");
				dictionary.Add("plugin.initialized", "Initialized successfully!");
				dictionary.Add("plugin.patches_skipped", "Patches already applied, skipping...");
				dictionary.Add("plugin.name", "Big Bag");
				dictionary.Add("plugin.description", "Increases the capacity of three bag types and supports adjusting the selection frame color.");
				dictionary.Add("config.small_bag_capacity", "Slots added by Small Bag\n24 slots per row");
				dictionary.Add("config.medium_bag_capacity", "Slots added by Medium Bag\n24 slots per row");
				dictionary.Add("config.large_bag_capacity", "Slots added by Large Bag\n24 slots per row");
				dictionary.Add("config.slots_per_row", "Max slots per row\n24 slots per row");
				dictionary.Add("config.bag_highlight_color", "Bag highlight color (leave empty to use the game default, supports #RRGGBB or #RRGGBBAA)");
				break;
			case "ja":
				dictionary.Add("plugin.initializing", "初期化中...");
				dictionary.Add("plugin.author_prefix", "作者: ");
				dictionary.Add("plugin.initialized", "初期化に成功しました！");
				dictionary.Add("plugin.patches_skipped", "パッチは適用済みです。スキップします...");
				dictionary.Add("plugin.name", "ビッグバッグ");
				dictionary.Add("plugin.description", "3種類のバッグ容量を増やし、選択枠の色も調整できます。");
				dictionary.Add("config.small_bag_capacity", "小型バッグで増えるスロット数\n24スロットで1行");
				dictionary.Add("config.medium_bag_capacity", "中型バッグで増えるスロット数\n24スロットで1行");
				dictionary.Add("config.large_bag_capacity", "大型バッグで増えるスロット数\n24スロットで1行");
				dictionary.Add("config.slots_per_row", "1行あたりの最大スロット数\n24スロットで1行");
				dictionary.Add("config.bag_highlight_color", "バッグのハイライト枠色（空欄でゲーム既定色、#RRGGBB または #RRGGBBAA 対応）");
				break;
			}
			return dictionary;
		}
	}
	public class LocalizationManager
	{
		private static LocalizationManager _instance;

		private readonly Dictionary<string, Dictionary<string, string>> _localizations = new Dictionary<string, Dictionary<string, string>>();

		private string _currentLocale = "zh";

		public static readonly string[] SupportedLanguages = new string[16]
		{
			"en", "tr", "fr", "es", "zh", "zh-TW", "de", "el", "pt-BR", "it",
			"ja", "pl", "pt-PT", "ru", "ko", "th"
		};

		public static LocalizationManager Instance => _instance ?? (_instance = new LocalizationManager());

		private LocalizationManager()
		{
			Initialize();
		}

		public void Initialize()
		{
			RefreshCurrentLocale();
			string[] supportedLanguages = SupportedLanguages;
			foreach (string text in supportedLanguages)
			{
				Dictionary<string, string> defaultTranslations = LocalizationHelper.GetDefaultTranslations(text);
				if (defaultTranslations != null && defaultTranslations.Count > 0)
				{
					_localizations[text] = defaultTranslations;
				}
			}
		}

		private void RefreshCurrentLocale()
		{
			if (PlayerPrefs.HasKey("Lang"))
			{
				int @int = PlayerPrefs.GetInt("Lang");
				ILocalesProvider availableLocales = LocalizationSettings.AvailableLocales;
				if (availableLocales != null && availableLocales.Locales != null && @int >= 0 && @int < availableLocales.Locales.Count)
				{
					string code = availableLocales.Locales[@int].Identifier.Code;
					_currentLocale = (_localizations.ContainsKey(code) ? code : "en");
				}
			}
		}

		public string GetLocalizedText(string key, params object[] args)
		{
			RefreshCurrentLocale();
			if (string.IsNullOrEmpty(_currentLocale) || !_localizations.ContainsKey(_currentLocale))
			{
				_currentLocale = "en";
			}
			if (_localizations.ContainsKey(_currentLocale) && _localizations[_currentLocale].TryGetValue(key, out var value))
			{
				if (args.Length == 0)
				{
					return value;
				}
				return string.Format(value, args);
			}
			if (_currentLocale != "en" && _localizations.ContainsKey("en") && _localizations["en"].TryGetValue(key, out var value2))
			{
				if (args.Length == 0)
				{
					return value2;
				}
				return string.Format(value2, args);
			}
			if (_localizations.ContainsKey("zh") && _localizations["zh"].TryGetValue(key, out var value3))
			{
				if (args.Length == 0)
				{
					return value3;
				}
				return string.Format(value3, args);
			}
			return key;
		}
	}
}
namespace BigBag.Configuration
{
	public class ConfigManager
	{
		private static ConfigManager _instance;

		private readonly ConfigFile _configFile;

		private readonly Dictionary<string, ConfigEntry<bool>> _boolConfigs = new Dictionary<string, ConfigEntry<bool>>();

		private readonly Dictionary<string, ConfigEntry<string>> _stringConfigs = new Dictionary<string, ConfigEntry<string>>();

		private readonly Dictionary<string, ConfigEntry<int>> _intConfigs = new Dictionary<string, ConfigEntry<int>>();

		private readonly Dictionary<string, ConfigEntry<float>> _floatConfigs = new Dictionary<string, ConfigEntry<float>>();

		private readonly Dictionary<string, ConfigEntry<KeyCode>> _keyCodeConfigs = new Dictionary<string, ConfigEntry<KeyCode>>();

		public static ConfigManager Instance => _instance;

		public ConfigEntry<int> SmallBagCapacity { get; private set; }

		public ConfigEntry<int> MediumBagCapacity { get; private set; }

		public ConfigEntry<int> LargeBagCapacity { get; private set; }

		public ConfigEntry<int> SlotsPerRow { get; private set; }

		public ConfigEntry<string> BagHighlightColor { get; private set; }

		private ConfigManager(ConfigFile configFile)
		{
			_configFile = configFile;
			InitializeDefaultConfigs();
		}

		public static void Initialize(ConfigFile configFile)
		{
			if (_instance == null)
			{
				_instance = new ConfigManager(configFile);
			}
		}

		private void InitializeDefaultConfigs()
		{
			SmallBagCapacity = RegisterIntMax("背包扩容 - Bag Capacity", "SmallBagCapacity", GetLocalizedDescription("config.small_bag_capacity"), 4, 1, 240);
			MediumBagCapacity = RegisterIntMax("背包扩容 - Bag Capacity", "MediumBagCapacity", GetLocalizedDescription("config.medium_bag_capacity"), 5, 1, 240);
			LargeBagCapacity = RegisterIntMax("背包扩容 - Bag Capacity", "LargeBagCapacity", GetLocalizedDescription("config.large_bag_capacity"), 6, 1, 240);
			SlotsPerRow = RegisterIntMax("背包扩容 - Bag Capacity", "SlotsPerRow", GetLocalizedDescription("config.slots_per_row"), 24, 1, 24);
			BagHighlightColor = RegisterString("背包高亮 - Bag Highlight", "BagHighlightColor", GetLocalizedDescription("config.bag_highlight_color"), "");
		}

		private string GetLocalizedDescription(string key)
		{
			return LocalizationManager.Instance?.GetLocalizedText(key) ?? key;
		}

		public ConfigEntry<bool> RegisterBool(string section, string key, string description, bool defaultValue)
		{
			ConfigEntry<bool> val = _configFile.Bind<bool>(section, key, defaultValue, description);
			_boolConfigs[key] = val;
			return val;
		}

		public ConfigEntry<string> RegisterString(string section, string key, string description, string defaultValue)
		{
			ConfigEntry<string> val = _configFile.Bind<string>(section, key, defaultValue, description);
			_stringConfigs[key] = val;
			return val;
		}

		public ConfigEntry<KeyCode> RegisterKeyCode(string section, string key, string description, KeyCode defaultValue)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			ConfigEntry<KeyCode> val = _configFile.Bind<KeyCode>(section, key, defaultValue, description);
			_keyCodeConfigs[key] = val;
			return val;
		}

		public ConfigEntry<int> RegisterInt(string section, string key, string description, int defaultValue)
		{
			ConfigEntry<int> val = _configFile.Bind<int>(section, key, defaultValue, description);
			_intConfigs[key] = val;
			return val;
		}

		public ConfigEntry<int> RegisterIntMax(string section, string key, string description, int defaultValue, int minValue, int maxValue)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			ConfigEntry<int> val = _configFile.Bind<int>(section, key, defaultValue, new ConfigDescription(description, (AcceptableValueBase)(object)new AcceptableValueRange<int>(minValue, maxValue), Array.Empty<object>()));
			_intConfigs[key] = val;
			return val;
		}

		public ConfigEntry<float> RegisterFloat(string section, string key, string description, float defaultValue)
		{
			ConfigEntry<float> val = _configFile.Bind<float>(section, key, defaultValue, description);
			_floatConfigs[key] = val;
			return val;
		}

		public ConfigEntry<float> RegisterFloatMax(string section, string key, string description, float defaultValue, float minValue, float maxValue)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			ConfigEntry<float> val = _configFile.Bind<float>(section, key, defaultValue, new ConfigDescription(description, (AcceptableValueBase)(object)new AcceptableValueRange<float>(minValue, maxValue), Array.Empty<object>()));
			_floatConfigs[key] = val;
			return val;
		}
	}
}