using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using AdjustableUpgrades.Configuration;
using AdjustableUpgrades.Core;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("AdjustableUpgrades")]
[assembly: AssemblyDescription("A REPO mod that lets players adjust their upgrade levels within their purchased cap.")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("AdjustableUpgrades")]
[assembly: AssemblyCopyright("")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("a1b2c3d4-e5f6-7890-abcd-ef1234567890")]
[assembly: AssemblyFileVersion("1.0.3.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.3.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace AdjustableUpgrades
{
	[BepInPlugin("Hazuki.REPO.AdjustableUpgrades", "Adjustable Upgrades", "1.0.3")]
	public class Plugin : BaseUnityPlugin
	{
		private const string MOD_GUID = "Hazuki.REPO.AdjustableUpgrades";

		private const string MOD_NAME = "Adjustable Upgrades";

		private const string MOD_VERSION = "1.0.3";

		private readonly Harmony harmony = new Harmony("Hazuki.REPO.AdjustableUpgrades");

		internal static ManualLogSource Log;

		internal static Plugin Instance;

		private bool isUIVisible;

		private Rect windowRect = new Rect(20f, 20f, 420f, 500f);

		private Vector2 scrollPosition = Vector2.zero;

		private GUIStyle headerStyle;

		private GUIStyle labelStyle;

		private GUIStyle buttonStyle;

		private GUIStyle boxStyle;

		private GUIStyle windowStyle;

		private bool stylesInitialized;

		private CursorLockMode previousLockState;

		private bool previousCursorVisible;

		private const int WINDOW_ID = 98712;

		private void Awake()
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Instance != (Object)null))
			{
				Instance = this;
				Log = ((BaseUnityPlugin)this).Logger;
				((Component)this).gameObject.transform.parent = null;
				((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
				UpgradeCapManager.SetSavePath(Paths.ConfigPath);
				ModConfig.Init(((BaseUnityPlugin)this).Config);
				harmony.PatchAll();
				Log.LogInfo((object)"Adjustable Upgrades v1.0.3 loaded!");
				Log.LogInfo((object)$"Press '{ModConfig.ToggleUIKey.Value}' to toggle upgrade adjustment UI.");
			}
		}

		private void Update()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			if (!Input.GetKeyDown(ModConfig.ToggleUIKey.Value))
			{
				return;
			}
			isUIVisible = !isUIVisible;
			Log.LogInfo((object)$"Upgrade Adjust UI toggled: {isUIVisible}");
			if (isUIVisible)
			{
				previousLockState = Cursor.lockState;
				previousCursorVisible = Cursor.visible;
				Cursor.lockState = (CursorLockMode)0;
				Cursor.visible = true;
				if (UpgradeCapManager.GetAllCaps().Count == 0)
				{
					Log.LogInfo((object)"Caps empty, reinitializing...");
					UpgradeCapManager.InitCapsFromCurrentStats();
				}
			}
			else
			{
				Cursor.lockState = previousLockState;
				Cursor.visible = previousCursorVisible;
			}
		}

		private void OnGUI()
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			//IL_004a: 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)
			if (isUIVisible)
			{
				if ((int)Cursor.lockState != 0)
				{
					Cursor.lockState = (CursorLockMode)0;
					Cursor.visible = true;
				}
				InitStyles();
				windowRect = GUILayout.Window(98712, windowRect, new WindowFunction(DrawWindow), "Adjustable Upgrades", windowStyle, Array.Empty<GUILayoutOption>());
			}
		}

		private void OnDestroy()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			harmony.UnpatchSelf();
			if (isUIVisible)
			{
				Cursor.lockState = previousLockState;
				Cursor.visible = previousCursorVisible;
			}
		}

		private void InitStyles()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_0038: 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_0070: Expected O, but got Unknown
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Expected O, but got Unknown
			//IL_00e6: 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
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Expected O, but got Unknown
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			if (!stylesInitialized)
			{
				windowStyle = new GUIStyle(GUI.skin.window);
				windowStyle.normal.textColor = new Color(0.9f, 0.85f, 0.6f);
				windowStyle.fontSize = 16;
				windowStyle.fontStyle = (FontStyle)1;
				headerStyle = new GUIStyle(GUI.skin.label);
				headerStyle.fontSize = 14;
				headerStyle.fontStyle = (FontStyle)1;
				headerStyle.normal.textColor = new Color(1f, 0.9f, 0.5f);
				headerStyle.alignment = (TextAnchor)4;
				labelStyle = new GUIStyle(GUI.skin.label);
				labelStyle.fontSize = 13;
				labelStyle.normal.textColor = Color.white;
				buttonStyle = new GUIStyle(GUI.skin.button);
				buttonStyle.fontSize = 13;
				buttonStyle.fontStyle = (FontStyle)1;
				boxStyle = new GUIStyle(GUI.skin.box);
				boxStyle.normal.textColor = Color.white;
				boxStyle.fontSize = 12;
				stylesInitialized = true;
			}
		}

		private void DrawWindow(int windowID)
		{
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_039e: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a3: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<string, int> allCaps = UpgradeCapManager.GetAllCaps();
			if (allCaps.Count == 0)
			{
				GUILayout.Space(10f);
				GUILayout.Label("No upgrades detected yet.", headerStyle, Array.Empty<GUILayoutOption>());
				GUILayout.Label("Enter a level first, then try again.", labelStyle, Array.Empty<GUILayoutOption>());
				GUILayout.Space(5f);
				if (GUILayout.Button("Refresh", buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) }))
				{
					UpgradeCapManager.InitCapsFromCurrentStats();
				}
				GUILayout.Space(10f);
				GUI.DragWindow();
				return;
			}
			GUILayout.Space(5f);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (GUILayout.Button("MAX ALL", buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) }))
			{
				UpgradeCapManager.MaxAll();
			}
			if (GUILayout.Button("CLEAR ALL", buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) }))
			{
				UpgradeCapManager.ClearAll();
			}
			if (ModConfig.EnableRandomizeButton.Value && GUILayout.Button("RANDOM", buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) }))
			{
				UpgradeCapManager.RandomizeAll();
			}
			GUILayout.EndHorizontal();
			GUILayout.Space(5f);
			List<string> list = (from k in allCaps.Keys
				where UpgradeCapManager.VanillaKeys.Contains(k)
				orderby k
				select k).ToList();
			List<string> list2 = (from k in allCaps.Keys
				where UpgradeCapManager.ModdedKeys.Contains(k)
				orderby k
				select k).ToList();
			scrollPosition = GUILayout.BeginScrollView(scrollPosition, Array.Empty<GUILayoutOption>());
			if (list.Count > 0)
			{
				GUILayout.Label("--- Vanilla Upgrades ---", headerStyle, Array.Empty<GUILayoutOption>());
				GUILayout.Space(3f);
				foreach (string item in list)
				{
					DrawUpgradeRow(item, allCaps[item]);
				}
			}
			if (list2.Count > 0)
			{
				GUILayout.Space(8f);
				GUILayout.Label("--- Modded Upgrades ---", headerStyle, Array.Empty<GUILayoutOption>());
				GUILayout.Space(3f);
				foreach (string item2 in list2)
				{
					DrawUpgradeRow(item2, allCaps[item2]);
				}
			}
			List<string> list3 = (from k in allCaps.Keys
				where !UpgradeCapManager.VanillaKeys.Contains(k) && !UpgradeCapManager.ModdedKeys.Contains(k)
				orderby k
				select k).ToList();
			if (list3.Count > 0)
			{
				GUILayout.Space(8f);
				GUILayout.Label("--- Other Upgrades ---", headerStyle, Array.Empty<GUILayoutOption>());
				GUILayout.Space(3f);
				foreach (string item3 in list3)
				{
					DrawUpgradeRow(item3, allCaps[item3]);
				}
			}
			GUILayout.EndScrollView();
			GUILayout.Space(5f);
			KeyCode value = ModConfig.ToggleUIKey.Value;
			GUILayout.Label("Press " + ((object)(KeyCode)(ref value)).ToString() + " to close", labelStyle, Array.Empty<GUILayoutOption>());
			GUI.DragWindow();
		}

		private void DrawUpgradeRow(string key, int cap)
		{
			int currentLevel = UpgradeCapManager.GetCurrentLevel(key);
			object obj = UpgradeCapManager.GetDisplayName(key);
			GUILayout.BeginHorizontal(boxStyle, Array.Empty<GUILayoutOption>());
			if (obj == null)
			{
				obj = "";
			}
			GUILayout.Label((string)obj, labelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(150f) });
			GUILayout.Label($"Lv.{currentLevel} / {cap}", labelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(70f) });
			GUI.enabled = currentLevel > 0;
			if (GUILayout.Button("-", buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(30f),
				GUILayout.Height(25f)
			}))
			{
				UpgradeCapManager.SetLevel(key, currentLevel - 1);
			}
			GUI.enabled = true;
			int num = Mathf.RoundToInt(GUILayout.HorizontalSlider((float)currentLevel, 0f, (float)cap, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(80f) }));
			if (num != currentLevel)
			{
				UpgradeCapManager.SetLevel(key, num);
			}
			GUI.enabled = currentLevel < cap;
			if (GUILayout.Button("+", buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(30f),
				GUILayout.Height(25f)
			}))
			{
				UpgradeCapManager.SetLevel(key, currentLevel + 1);
			}
			GUI.enabled = true;
			GUILayout.EndHorizontal();
		}
	}
}
namespace AdjustableUpgrades.Patches
{
	[HarmonyPatch(typeof(StatsManager), "Start")]
	public class StatsManagerInitPatch
	{
		[HarmonyPostfix]
		public static void Postfix(StatsManager __instance)
		{
			UpgradeCapManager.InitCapsFromCurrentStats();
		}
	}
	[HarmonyPatch(typeof(ItemUpgrade), "PlayerUpgrade")]
	public class UpgradePurchasePatch
	{
		public struct UpgradeSnapshot
		{
			public string SteamID;

			public Dictionary<string, int> PreLevels;
		}

		[HarmonyPrefix]
		public static void Prefix(ItemUpgrade __instance, out UpgradeSnapshot __state)
		{
			__state = default(UpgradeSnapshot);
			object? value = AccessTools.Field(typeof(ItemUpgrade), "itemToggle").GetValue(__instance);
			ItemToggle val = (ItemToggle)((value is ItemToggle) ? value : null);
			if ((Object)(object)val == (Object)null || !val.toggleState)
			{
				return;
			}
			PlayerAvatar val2 = SemiFunc.PlayerAvatarGetFromPhotonID((int)AccessTools.Field(typeof(ItemToggle), "playerTogglePhotonID").GetValue(val));
			if ((Object)(object)val2 == (Object)null)
			{
				return;
			}
			string text = (string)AccessTools.Field(typeof(PlayerAvatar), "steamID").GetValue(val2);
			if (!((Object)(object)val2.photonView != (Object)null) || !val2.photonView.IsMine)
			{
				return;
			}
			Dictionary<string, int> dictionary = new Dictionary<string, int>();
			if ((Object)(object)StatsManager.instance != (Object)null)
			{
				foreach (KeyValuePair<string, Dictionary<string, int>> dictionaryOfDictionary in StatsManager.instance.dictionaryOfDictionaries)
				{
					if (dictionaryOfDictionary.Key.StartsWith("playerUpgrade"))
					{
						int value2 = (dictionaryOfDictionary.Value.ContainsKey(text) ? dictionaryOfDictionary.Value[text] : 0);
						dictionary[dictionaryOfDictionary.Key] = value2;
					}
				}
			}
			__state = new UpgradeSnapshot
			{
				SteamID = text,
				PreLevels = dictionary
			};
		}

		[HarmonyPostfix]
		public static void Postfix(ItemUpgrade __instance, UpgradeSnapshot __state)
		{
			if (string.IsNullOrEmpty(__state.SteamID) || __state.PreLevels == null || (Object)(object)StatsManager.instance == (Object)null)
			{
				return;
			}
			foreach (KeyValuePair<string, Dictionary<string, int>> dictionaryOfDictionary in StatsManager.instance.dictionaryOfDictionaries)
			{
				if (dictionaryOfDictionary.Key.StartsWith("playerUpgrade"))
				{
					int num = (dictionaryOfDictionary.Value.ContainsKey(__state.SteamID) ? dictionaryOfDictionary.Value[__state.SteamID] : 0);
					int num2 = (__state.PreLevels.ContainsKey(dictionaryOfDictionary.Key) ? __state.PreLevels[dictionaryOfDictionary.Key] : 0);
					if (num > num2)
					{
						int num3 = num - num2;
						UpgradeCapManager.IncreaseCap(dictionaryOfDictionary.Key, num3);
						Plugin.Log.LogInfo((object)$"Upgrade purchased: {dictionaryOfDictionary.Key} cap increased by {num3}");
					}
				}
			}
		}
	}
}
namespace AdjustableUpgrades.Core
{
	public static class UpgradeCapManager
	{
		private static readonly Dictionary<string, int> upgradeCaps = new Dictionary<string, int>();

		public static readonly HashSet<string> VanillaKeys = new HashSet<string>();

		public static readonly HashSet<string> ModdedKeys = new HashSet<string>();

		private static readonly object capLock = new object();

		private static readonly Random random = new Random();

		private static string capsFilePath;

		public static void SetSavePath(string configDir)
		{
			capsFilePath = Path.Combine(configDir, "AdjustableUpgrades_caps.txt");
		}

		public static void InitCapsFromCurrentStats()
		{
			lock (capLock)
			{
				upgradeCaps.Clear();
				VanillaKeys.Clear();
				ModdedKeys.Clear();
				if ((Object)(object)StatsManager.instance == (Object)null)
				{
					return;
				}
				Dictionary<string, int> dictionary = LoadCapsFromFile();
				HashSet<string> hashSet = (from f in typeof(StatsManager).GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
					select f.Name).ToHashSet();
				string localSteamID = GetLocalSteamID();
				if (string.IsNullOrEmpty(localSteamID))
				{
					return;
				}
				foreach (KeyValuePair<string, Dictionary<string, int>> dictionaryOfDictionary in StatsManager.instance.dictionaryOfDictionaries)
				{
					if (dictionaryOfDictionary.Key.StartsWith("playerUpgrade"))
					{
						if (hashSet.Contains(dictionaryOfDictionary.Key))
						{
							VanillaKeys.Add(dictionaryOfDictionary.Key);
						}
						else
						{
							ModdedKeys.Add(dictionaryOfDictionary.Key);
						}
						int val = (dictionaryOfDictionary.Value.ContainsKey(localSteamID) ? dictionaryOfDictionary.Value[localSteamID] : 0);
						int val2 = (dictionary.ContainsKey(dictionaryOfDictionary.Key) ? dictionary[dictionaryOfDictionary.Key] : 0);
						upgradeCaps[dictionaryOfDictionary.Key] = Math.Max(val2, val);
					}
				}
				Plugin.Log.LogInfo((object)$"UpgradeCapManager initialized: {VanillaKeys.Count} vanilla, {ModdedKeys.Count} modded. Caps loaded (saved caps applied).");
				RestoreLevelsToCaps(localSteamID);
				SaveCapsToFile();
			}
		}

		private static void RestoreLevelsToCaps(string localSteamID)
		{
			if ((Object)(object)PunManager.instance == (Object)null)
			{
				return;
			}
			PhotonView component = ((Component)PunManager.instance).GetComponent<PhotonView>();
			if ((Object)(object)component == (Object)null)
			{
				return;
			}
			foreach (KeyValuePair<string, int> upgradeCap in upgradeCaps)
			{
				string key = upgradeCap.Key;
				int value = upgradeCap.Value;
				int num = 0;
				if (StatsManager.instance.dictionaryOfDictionaries.TryGetValue(key, out var value2))
				{
					num = (value2.ContainsKey(localSteamID) ? value2[localSteamID] : 0);
				}
				if (num < value)
				{
					if (VanillaKeys.Contains(key))
					{
						string text = key.Substring("playerUpgrade".Length);
						int num2 = value - num;
						component.RPC("TesterUpgradeCommandRPC", (RpcTarget)0, new object[3] { localSteamID, text, num2 });
					}
					else
					{
						component.RPC("UpdateStatRPC", (RpcTarget)0, new object[3] { key, localSteamID, value });
					}
					Plugin.Log.LogInfo((object)$"Restored {key}: {num} -> {value}");
				}
			}
		}

		public static void IncreaseCap(string key, int amount = 1)
		{
			lock (capLock)
			{
				if (!upgradeCaps.ContainsKey(key))
				{
					upgradeCaps[key] = 0;
				}
				upgradeCaps[key] += amount;
				Plugin.Log.LogInfo((object)$"Cap increased: {key} -> {upgradeCaps[key]}");
				SaveCapsToFile();
			}
		}

		public static int GetCap(string key)
		{
			lock (capLock)
			{
				return upgradeCaps.ContainsKey(key) ? upgradeCaps[key] : 0;
			}
		}

		public static int GetCurrentLevel(string key)
		{
			if ((Object)(object)StatsManager.instance == (Object)null)
			{
				return 0;
			}
			string localSteamID = GetLocalSteamID();
			if (string.IsNullOrEmpty(localSteamID))
			{
				return 0;
			}
			if (StatsManager.instance.dictionaryOfDictionaries.TryGetValue(key, out var value))
			{
				if (!value.ContainsKey(localSteamID))
				{
					return 0;
				}
				return value[localSteamID];
			}
			return 0;
		}

		public static void SetLevel(string key, int targetLevel)
		{
			int cap = GetCap(key);
			int num = Math.Max(0, Math.Min(targetLevel, cap));
			int currentLevel = GetCurrentLevel(key);
			if (num == currentLevel)
			{
				return;
			}
			string localSteamID = GetLocalSteamID();
			if (!string.IsNullOrEmpty(localSteamID) && !((Object)(object)PunManager.instance == (Object)null))
			{
				PhotonView component = ((Component)PunManager.instance).GetComponent<PhotonView>();
				if ((Object)(object)component == (Object)null)
				{
					Plugin.Log.LogWarning((object)"SetLevel: PunManager PhotonView not found.");
				}
				else if (VanillaKeys.Contains(key))
				{
					string text = key.Substring("playerUpgrade".Length);
					int num2 = num - currentLevel;
					component.RPC("TesterUpgradeCommandRPC", (RpcTarget)0, new object[3] { localSteamID, text, num2 });
					Plugin.Log.LogInfo((object)$"SetLevel (vanilla): {key} {currentLevel} -> {num} (delta: {num2})");
				}
				else
				{
					component.RPC("UpdateStatRPC", (RpcTarget)0, new object[3] { key, localSteamID, num });
					Plugin.Log.LogInfo((object)$"SetLevel (modded): {key} {currentLevel} -> {num}");
				}
			}
		}

		public static void RandomizeAll()
		{
			lock (capLock)
			{
				foreach (string item in upgradeCaps.Keys.ToList())
				{
					int num = upgradeCaps[item];
					if (num > 0)
					{
						int targetLevel = random.Next(0, num + 1);
						SetLevel(item, targetLevel);
					}
				}
			}
			Plugin.Log.LogInfo((object)"All upgrade levels randomized.");
		}

		public static void MaxAll()
		{
			lock (capLock)
			{
				foreach (KeyValuePair<string, int> upgradeCap in upgradeCaps)
				{
					SetLevel(upgradeCap.Key, upgradeCap.Value);
				}
			}
			Plugin.Log.LogInfo((object)"All upgrade levels set to max.");
		}

		public static void ClearAll()
		{
			lock (capLock)
			{
				foreach (string item in upgradeCaps.Keys.ToList())
				{
					SetLevel(item, 0);
				}
			}
			Plugin.Log.LogInfo((object)"All upgrade levels cleared to 0.");
		}

		public static Dictionary<string, int> GetAllCaps()
		{
			lock (capLock)
			{
				return new Dictionary<string, int>(upgradeCaps);
			}
		}

		public static string GetDisplayName(string key)
		{
			if (key.StartsWith("playerUpgrade"))
			{
				return key.Substring("playerUpgrade".Length);
			}
			if (key.StartsWith("player"))
			{
				return key.Substring("player".Length);
			}
			return key;
		}

		private static void SaveCapsToFile()
		{
			if (string.IsNullOrEmpty(capsFilePath))
			{
				return;
			}
			try
			{
				List<string> list = new List<string>();
				foreach (KeyValuePair<string, int> upgradeCap in upgradeCaps)
				{
					list.Add($"{upgradeCap.Key}={upgradeCap.Value}");
				}
				File.WriteAllLines(capsFilePath, list);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Failed to save caps: " + ex.Message));
			}
		}

		private static Dictionary<string, int> LoadCapsFromFile()
		{
			Dictionary<string, int> dictionary = new Dictionary<string, int>();
			if (string.IsNullOrEmpty(capsFilePath))
			{
				return dictionary;
			}
			if (!File.Exists(capsFilePath))
			{
				return dictionary;
			}
			try
			{
				string[] array = File.ReadAllLines(capsFilePath);
				for (int i = 0; i < array.Length; i++)
				{
					string text = array[i].Trim();
					if (string.IsNullOrEmpty(text))
					{
						continue;
					}
					int num = text.IndexOf('=');
					if (num > 0)
					{
						string key = text.Substring(0, num);
						if (int.TryParse(text.Substring(num + 1), out var result))
						{
							dictionary[key] = result;
						}
					}
				}
				Plugin.Log.LogInfo((object)$"Loaded {dictionary.Count} saved caps from file.");
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Failed to load caps: " + ex.Message));
			}
			return dictionary;
		}

		private static string GetLocalSteamID()
		{
			if (SemiFunc.PlayerGetAll() == null)
			{
				return null;
			}
			foreach (PlayerAvatar item in SemiFunc.PlayerGetAll())
			{
				if (!((Object)(object)item == (Object)null) && (Object)(object)item.photonView != (Object)null && item.photonView.IsMine)
				{
					return SemiFunc.PlayerGetSteamID(item);
				}
			}
			PlayerAvatar val = SemiFunc.PlayerGetAll().FirstOrDefault();
			if (!((Object)(object)val != (Object)null))
			{
				return null;
			}
			return SemiFunc.PlayerGetSteamID(val);
		}
	}
}
namespace AdjustableUpgrades.Configuration
{
	internal static class ModConfig
	{
		public static ConfigEntry<KeyCode> ToggleUIKey;

		public static ConfigEntry<bool> EnableRandomizeButton;

		public static void Init(ConfigFile config)
		{
			ToggleUIKey = config.Bind<KeyCode>("UI Settings", "ToggleUIKey", (KeyCode)283, "Key to toggle the upgrade adjustment UI");
			EnableRandomizeButton = config.Bind<bool>("UI Settings", "EnableRandomizeButton", true, "Show the 'Randomize All' button in the UI");
		}
	}
}