using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using TMPro;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Sparroh")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.1.0")]
[assembly: AssemblyInformationalVersion("1.0.1")]
[assembly: AssemblyProduct("ProfileSwitcher")]
[assembly: AssemblyTitle("ProfileSwitcher")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
[BepInPlugin("sparroh.profileswitcher", "ProfileSwitcher", "1.0.1")]
[MycoMod(/*Could not decode attribute arguments.*/)]
public class ProfileSwitcherPlugin : BaseUnityPlugin
{
	public const string PluginGUID = "sparroh.profileswitcher";

	public const string PluginName = "ProfileSwitcher";

	public const string PluginVersion = "1.0.1";

	internal static ManualLogSource Log;

	private Harmony _harmony;

	private void Awake()
	{
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Expected O, but got Unknown
		Log = ((BaseUnityPlugin)this).Logger;
		_harmony = new Harmony("sparroh.profileswitcher");
		_harmony.PatchAll(typeof(StartMenuProfilePatches));
		Log.LogInfo((object)"ProfileSwitcher v1.0.1 loaded — profiles can be swapped from the main menu without restarting.");
	}

	private void OnDestroy()
	{
		Harmony harmony = _harmony;
		if (harmony != null)
		{
			harmony.UnpatchSelf();
		}
	}
}
internal static class ProfileReloader
{
	private static readonly FieldInfo InstanceField = AccessTools.Field(typeof(PlayerData), "_instance");

	private static readonly FieldInfo SavePathField = AccessTools.Field(typeof(PlayerData), "savePath");

	private static readonly FieldInfo BinaryFormatterField = AccessTools.Field(typeof(PlayerData), "binaryFormatter");

	private static readonly FieldInfo ProfileIndexField = AccessTools.Field(typeof(ProfileConfig), "profileIndex");

	private static readonly MethodInfo TryLoadSaveMethod = AccessTools.Method(typeof(PlayerData), "TryLoadSave", (Type[])null, (Type[])null);

	private static readonly MethodInfo OnCreatedMethod = AccessTools.Method(typeof(PlayerData), "OnCreated", (Type[])null, (Type[])null);

	private static readonly MethodInfo InitializeMethod = AccessTools.Method(typeof(PlayerData), "Initialize", (Type[])null, (Type[])null);

	private static readonly MethodInfo PlayerLevelMethod = AccessTools.Method(typeof(PlayerData), "GetPlayerLevel", Type.EmptyTypes, (Type[])null);

	private static readonly FieldInfo InWorldUpgradesField = AccessTools.Field(typeof(PlayerData), "inWorldUpgrades");

	private static readonly FieldInfo FloatingInstancesField = AccessTools.Field(typeof(PlayerData), "floatingInstances");

	private static readonly FieldInfo RecentUnchosenField = AccessTools.Field(typeof(PlayerData), "recentUnchosenUpgrades");

	private static readonly FieldInfo DamagePropertiesField = AccessTools.Field(typeof(PlayerData), "damageProperties");

	private static readonly FieldInfo KillPropertiesField = AccessTools.Field(typeof(PlayerData), "killProperties");

	private static readonly FieldInfo MissionPropertiesField = AccessTools.Field(typeof(PlayerData), "missionProperties");

	private static readonly FieldInfo FixedUpdatePropertiesField = AccessTools.Field(typeof(PlayerData), "fixedUpdateProperties");

	private static readonly FieldInfo DiePropertiesField = AccessTools.Field(typeof(PlayerData), "dieProperties");

	private static readonly FieldInfo OuroPropertiesField = AccessTools.Field(typeof(PlayerData), "ouroProperties");

	private static readonly FieldInfo ActiveDefaultDirectiveField = AccessTools.Field(typeof(PlayerData), "activeDefaultDirective");

	private static readonly FieldInfo TaskObjectiveField = AccessTools.Field(typeof(PlayerData), "taskObjective");

	private static readonly FieldInfo ProfileNameField = AccessTools.Field(typeof(PlayerData), "profile");

	private static readonly FieldInfo DataField = AccessTools.Field(typeof(PlayerData), "data");

	private static readonly FieldInfo InvalidUpgradesField = AccessTools.Field(typeof(PlayerData), "invalidUpgrades");

	private static readonly FieldInfo DiscoveredModifiersField = AccessTools.Field(typeof(PlayerData), "discoveredModifiers");

	private static readonly MethodInfo MergeUpgradeListsMethod = AccessTools.Method(typeof(PlayerData), "MergeUpgradeLists", (Type[])null, (Type[])null);

	private static readonly MethodInfo GiveMissingGunTokensMethod = AccessTools.Method(typeof(PlayerData), "GiveMissingGunTokens", (Type[])null, (Type[])null);

	private static readonly MethodInfo QueryUpgradesMethod = AccessTools.Method(typeof(PlayerData), "QueryUpgrades", (Type[])null, (Type[])null);

	private static readonly FieldInfo OnResourcesUpdatedField = AccessTools.DeclaredField(typeof(PlayerData), "OnResourcesUpdated");

	private static readonly FieldInfo OnXPAddedField = AccessTools.DeclaredField(typeof(PlayerData), "OnXPAdded");

	private static readonly FieldInfo OnUpgradeCollectedOrDestroyedField = AccessTools.DeclaredField(typeof(PlayerData), "OnUpgradeCollectedOrDestroyed");

	internal static int GetCurrentProfileIndex()
	{
		ProfileConfig instance = ProfileConfig.Instance;
		if (instance == null || ProfileIndexField == null)
		{
			return 0;
		}
		return (int)ProfileIndexField.GetValue(instance);
	}

	public static bool TrySwapProfile(int newIndex, out string error)
	{
		//IL_018d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0194: Expected O, but got Unknown
		error = null;
		if (InstanceField == null || SavePathField == null || TryLoadSaveMethod == null || InitializeMethod == null || ProfileIndexField == null)
		{
			error = "Could not access required PlayerData internals. The game may have updated.";
			return false;
		}
		ProfileConfig instance = ProfileConfig.Instance;
		if (instance == null)
		{
			error = "Profile configuration is missing.";
			return false;
		}
		int num = (int)ProfileIndexField.GetValue(instance);
		PlayerData instance2 = PlayerData.Instance;
		string text = SavePathField.GetValue(null) as string;
		try
		{
			UpdateProfileLevelMetadata(num);
			PlayerData.SaveData(false);
			SaveProfileConfig();
			instance.SetProfile(newIndex);
			SaveProfileConfig();
			string text2 = BuildSavePathForCurrentProfile();
			SavePathField.SetValue(null, text2);
			string text3 = text2 + "/PlayerData.saxon";
			object[] array = new object[2] { text3, null };
			int num2 = (int)TryLoadSaveMethod.Invoke(null, array);
			object obj = array[1];
			PlayerData val = (PlayerData)((obj is PlayerData) ? obj : null);
			if (num2 != 0 || val == null)
			{
				string path = text2 + "/Backups";
				if (Directory.Exists(path))
				{
					string[] files = Directory.GetFiles(path);
					Array.Sort(files);
					for (int num3 = files.Length - 1; num3 >= 0; num3--)
					{
						array[0] = files[num3];
						array[1] = null;
						num2 = (int)TryLoadSaveMethod.Invoke(null, array);
						object obj2 = array[1];
						val = (PlayerData)((obj2 is PlayerData) ? obj2 : null);
						if (num2 == 0 && val != null)
						{
							break;
						}
					}
				}
			}
			if (num2 != 0 || val == null)
			{
				ProfileSwitcherPlugin.Log.LogInfo((object)$"No existing save for profile {newIndex}; creating a new PlayerData instance.");
				val = new PlayerData();
				OnCreatedMethod?.Invoke(val, null);
			}
			ClearStaticRuntimeCaches();
			RemovePlayerDataEventHandlers(instance2);
			ResetProcessLifetimeCounters();
			InstanceField.SetValue(null, val);
			int gameLaunchCount = val.gameLaunchCount;
			InitializeMethod.Invoke(val, null);
			val.gameLaunchCount = gameLaunchCount;
			RebindGearAndFinalize(val);
			ProfileNameField?.SetValue(val, GetSteamBranchFolderName());
			UpdateProfileLevelMetadata(newIndex);
			SaveProfileConfig();
			return true;
		}
		catch (Exception ex)
		{
			error = ex.Message;
			ProfileSwitcherPlugin.Log.LogError((object)ex);
			try
			{
				if (instance2 != null)
				{
					InstanceField.SetValue(null, instance2);
				}
				if (text != null)
				{
					SavePathField.SetValue(null, text);
				}
				instance.SetProfile(num);
				SaveProfileConfig();
			}
			catch (Exception arg)
			{
				ProfileSwitcherPlugin.Log.LogError((object)$"Rollback after failed swap also failed: {arg}");
			}
			return false;
		}
	}

	private static void UpdateProfileLevelMetadata(int index)
	{
		try
		{
			if (index >= 1)
			{
				int level = 1;
				if (PlayerLevelMethod != null && PlayerData.Instance != null)
				{
					level = (int)PlayerLevelMethod.Invoke(null, null);
				}
				ProfileConfig.Instance.GetProfile(index).Level = level;
			}
		}
		catch (Exception ex)
		{
			ProfileSwitcherPlugin.Log.LogDebug((object)("Could not update profile level metadata: " + ex.Message));
		}
	}

	private static string GetSteamBranchFolderName()
	{
		string text = default(string);
		if (SteamManager.Initialized && Online.GetProfileName(ref text) && !string.IsNullOrEmpty(text))
		{
			return text;
		}
		return "default";
	}

	private static string BuildSavePathForCurrentProfile()
	{
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		string text = Application.persistentDataPath + "/Profiles/" + GetSteamBranchFolderName();
		string name = ProfileConfig.Instance.CurrentProfile.Name;
		if (!string.IsNullOrEmpty(name))
		{
			return text + "/" + name;
		}
		return text;
	}

	private static void SaveProfileConfig()
	{
		try
		{
			if (ProfileConfig.Instance == null || string.IsNullOrEmpty(ProfileConfig.SavePath))
			{
				return;
			}
			BinaryFormatter binaryFormatter = (BinaryFormatterField?.GetValue(null) as BinaryFormatter) ?? new BinaryFormatter();
			string directoryName = Path.GetDirectoryName(ProfileConfig.SavePath);
			if (!string.IsNullOrEmpty(directoryName))
			{
				Directory.CreateDirectory(directoryName);
			}
			using FileStream serializationStream = new FileStream(ProfileConfig.SavePath, FileMode.Create);
			binaryFormatter.Serialize(serializationStream, ProfileConfig.Instance);
		}
		catch (Exception ex)
		{
			ProfileSwitcherPlugin.Log.LogWarning((object)("Failed to save Profiles.poop: " + ex.Message));
		}
	}

	private static void ClearStaticRuntimeCaches()
	{
		ClearListField(InWorldUpgradesField);
		ClearDictionaryField(FloatingInstancesField);
		ClearListField(RecentUnchosenField);
		ClearListField(DamagePropertiesField);
		ClearListField(KillPropertiesField);
		ClearListField(MissionPropertiesField);
		ClearListField(FixedUpdatePropertiesField);
		ClearListField(DiePropertiesField);
		ClearListField(OuroPropertiesField);
		ActiveDefaultDirectiveField?.SetValue(null, null);
		TaskObjectiveField?.SetValue(null, null);
	}

	private static void RemovePlayerDataEventHandlers(PlayerData oldInstance)
	{
		if (oldInstance != null)
		{
			RemoveHandlersTargeting(OnResourcesUpdatedField, oldInstance);
			RemoveHandlersTargeting(OnXPAddedField, oldInstance);
			RemoveHandlersTargeting(OnUpgradeCollectedOrDestroyedField, oldInstance);
		}
	}

	private static void RemoveHandlersTargeting(FieldInfo eventField, object oldTarget)
	{
		if (eventField == null)
		{
			return;
		}
		try
		{
			if (!(eventField.GetValue(null) is Delegate obj) || (object)obj == null)
			{
				return;
			}
			Delegate obj2 = null;
			Delegate[] invocationList = obj.GetInvocationList();
			foreach (Delegate obj3 in invocationList)
			{
				if (obj3.Target != oldTarget)
				{
					obj2 = (((object)obj2 == null) ? obj3 : Delegate.Combine(obj2, obj3));
				}
			}
			eventField.SetValue(null, obj2);
		}
		catch (Exception ex)
		{
			ProfileSwitcherPlugin.Log.LogDebug((object)("Could not prune event field " + eventField.Name + ": " + ex.Message));
		}
	}

	private static void ResetProcessLifetimeCounters()
	{
		PlayerData.goobers = 0;
		PlayerData.hoops = 0;
		PlayerData.tempSaxitosPunchedCounter = 0;
	}

	private static void ClearListField(FieldInfo field)
	{
		if (!(field == null) && field.GetValue(null) is IList list)
		{
			list.Clear();
		}
	}

	private static void ClearDictionaryField(FieldInfo field)
	{
		if (!(field == null) && field.GetValue(null) is IDictionary dictionary)
		{
			dictionary.Clear();
		}
	}

	private static void RebindGearAndFinalize(PlayerData instance)
	{
		if ((Object)(object)Global.Instance == (Object)null)
		{
			ProfileSwitcherPlugin.Log.LogWarning((object)"Global.Instance is null during profile rebind; gear refs may be incomplete until next scene.");
			return;
		}
		for (int i = 0; i < Global.Instance.AllGear.Length; i++)
		{
			AddGear(Global.Instance.AllGear[i]);
		}
		for (int j = 0; j < Global.Instance.Characters.Length; j++)
		{
			AddGear((IUpgradable)(object)Global.Instance.Characters[j]);
		}
		AddGear((IUpgradable)(object)Global.Instance);
		RepairInvalidAndNullUpgrades(instance);
		try
		{
			MergeUpgradeListsMethod?.Invoke(instance, null);
		}
		catch (Exception ex)
		{
			ProfileSwitcherPlugin.Log.LogDebug((object)("MergeUpgradeLists: " + ex.Message));
		}
		List<int> list = null;
		foreach (KeyValuePair<int, GearData> item in instance.collectedGear)
		{
			if (item.Value.Gear == null)
			{
				if (list == null)
				{
					list = new List<int>();
				}
				list.Add(item.Key);
			}
			else
			{
				try
				{
					item.Value.DeepCleanup();
				}
				catch (Exception ex2)
				{
					ProfileSwitcherPlugin.Log.LogDebug((object)("DeepCleanup: " + ex2.Message));
				}
			}
		}
		if (list != null)
		{
			for (int k = 0; k < list.Count; k++)
			{
				instance.collectedGear.Remove(list[k]);
			}
		}
		foreach (KeyValuePair<int, GearData> item2 in instance.collectedGear)
		{
			try
			{
				IUpgradable gear = item2.Value.Gear;
				if (gear != null)
				{
					gear.InitializeOnLoad();
				}
				item2.Value.RestoreSavedUpgrades(true);
			}
			catch (Exception ex3)
			{
				ProfileSwitcherPlugin.Log.LogDebug((object)("InitializeOnLoad/RestoreSavedUpgrades: " + ex3.Message));
			}
		}
		try
		{
			if (instance.GetFlag("mxp") == 0)
			{
				instance.SetFlag("mxp", 1);
				foreach (KeyValuePair<int, GearData> item3 in instance.collectedGear)
				{
					try
					{
						item3.Value.GiveMissedXP();
					}
					catch (Exception ex4)
					{
						ProfileSwitcherPlugin.Log.LogDebug((object)("GiveMissedXP: " + ex4.Message));
					}
				}
			}
			if (instance.GetFlag("freeupgrades") <= 0 && QueryUpgradesMethod != null)
			{
				instance.SetFlag("freeupgrades", 1);
				QueryUpgradesMethod.Invoke(null, new object[1] { (Action<UpgradeInstance>)delegate(UpgradeInstance upgrade)
				{
					try
					{
						upgrade.UnlockIfFree();
					}
					catch (Exception ex7)
					{
						ProfileSwitcherPlugin.Log.LogDebug((object)("UnlockIfFree: " + ex7.Message));
					}
				} });
			}
		}
		catch (Exception ex5)
		{
			ProfileSwitcherPlugin.Log.LogDebug((object)("OnAwake one-shot fixes skipped: " + ex5.Message));
		}
		ScrubInvalidDiscoveredModifiers(instance);
		try
		{
			GiveMissingGunTokensMethod?.Invoke(null, null);
		}
		catch (Exception ex6)
		{
			ProfileSwitcherPlugin.Log.LogDebug((object)("GiveMissingGunTokens: " + ex6.Message));
		}
		void AddGear(IUpgradable val)
		{
			//IL_0091: 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_00a0: Expected O, but got Unknown
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Invalid comparison between Unknown and I4
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Invalid comparison between Unknown and I4
			if (!((Object)(object)((val != null) ? val.Info : null) == (Object)null))
			{
				if (instance.collectedGear.TryGetValue(val.Info.ID, out var value))
				{
					value.Gear = val;
					if ((int)val.Info.UnlockState >= 1 && !value.IsCollected)
					{
						value.Collect();
					}
					if ((int)val.Info.UnlockState == 2 && !value.IsUnlocked)
					{
						value.Unlock();
					}
				}
				else
				{
					instance.collectedGear.Add(val.Info.ID, new GearData(val, val.Info.UnlockState));
				}
			}
		}
	}

	private static void RepairInvalidAndNullUpgrades(PlayerData instance)
	{
		if (DataField == null || InvalidUpgradesField == null)
		{
			return;
		}
		try
		{
			IDictionary dictionary = DataField.GetValue(instance) as IDictionary;
			IList list = InvalidUpgradesField.GetValue(instance) as IList;
			if (dictionary == null || list == null)
			{
				return;
			}
			Type type = null;
			if (InvalidUpgradesField.FieldType.IsGenericType)
			{
				type = InvalidUpgradesField.FieldType.GetGenericArguments()[0];
			}
			FieldInfo fieldInfo = type?.GetField("info", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			FieldInfo fieldInfo2 = type?.GetField("gearID", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (fieldInfo == null || fieldInfo2 == null)
			{
				return;
			}
			PropertyInfo property = typeof(UpgradeInfo).GetProperty("Upgrade", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			PropertyInfo property2 = typeof(UpgradeInfo).GetProperty("SourceID", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			for (int num = list.Count - 1; num >= 0; num--)
			{
				object obj = list[num];
				if (obj == null)
				{
					list.RemoveAt(num);
				}
				else
				{
					object value = fieldInfo.GetValue(obj);
					if (value == null)
					{
						list.RemoveAt(num);
					}
					else
					{
						object? obj2 = property?.GetValue(value);
						int num2 = (int)fieldInfo2.GetValue(obj);
						if (obj2 != null && dictionary.Contains(num2) && dictionary[num2] is IList list2)
						{
							object obj3 = property2?.GetValue(value);
							bool flag = false;
							for (int i = 0; i < list2.Count; i++)
							{
								object obj4 = list2[i];
								if (obj4 != null)
								{
									object obj5 = property2?.GetValue(obj4);
									if (obj3 != null && obj5 != null && obj3.Equals(obj5))
									{
										flag = true;
										break;
									}
								}
							}
							if (!flag)
							{
								list2.Add(value);
							}
							list.RemoveAt(num);
						}
					}
				}
			}
			ArrayList arrayList = new ArrayList();
			foreach (object key in dictionary.Keys)
			{
				arrayList.Add(key);
			}
			FieldInfo field = typeof(UpgradeID).GetField("Mod", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			foreach (object item in arrayList)
			{
				if (!(dictionary[item] is IList list3))
				{
					continue;
				}
				for (int num3 = list3.Count - 1; num3 >= 0; num3--)
				{
					object obj6 = list3[num3];
					if (obj6 == null)
					{
						list3.RemoveAt(num3);
					}
					else if (property?.GetValue(obj6) == null)
					{
						object obj7 = property2?.GetValue(obj6);
						string value2 = null;
						if (obj7 != null && field != null)
						{
							value2 = field.GetValue(obj7) as string;
						}
						if (!string.IsNullOrEmpty(value2) && type != null)
						{
							for (int num4 = list.Count - 1; num4 >= 0; num4--)
							{
								object obj8 = list[num4];
								if (obj8 != null && object.Equals(fieldInfo2.GetValue(obj8), item))
								{
									object value3 = fieldInfo.GetValue(obj8);
									object obj9 = ((value3 == null) ? null : property2?.GetValue(value3));
									if (obj7 != null && obj9 != null && obj7.Equals(obj9))
									{
										list.RemoveAt(num4);
									}
								}
							}
							object obj10 = Activator.CreateInstance(type);
							fieldInfo.SetValue(obj10, obj6);
							fieldInfo2.SetValue(obj10, item);
							list.Add(obj10);
						}
						list3.RemoveAt(num3);
					}
				}
			}
		}
		catch (Exception ex)
		{
			ProfileSwitcherPlugin.Log.LogDebug((object)("RepairInvalidAndNullUpgrades: " + ex.Message));
		}
	}

	private static void ScrubInvalidDiscoveredModifiers(PlayerData instance)
	{
		if (DiscoveredModifiersField == null)
		{
			return;
		}
		try
		{
			if (!(DiscoveredModifiersField.GetValue(instance) is IDictionary { Count: not 0 } dictionary))
			{
				return;
			}
			MethodInfo method = typeof(UpgradeID).GetMethod("IsValid", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			object obj = Activator.CreateInstance(typeof(UpgradeID));
			bool flag = false;
			foreach (object key in dictionary.Keys)
			{
				if (key == null || key.Equals(obj))
				{
					flag = true;
					break;
				}
				if (method != null && !(bool)method.Invoke(key, null))
				{
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				return;
			}
			IDictionary dictionary2;
			try
			{
				Type type = AccessTools.TypeByName("UpgradeIDComparer");
				object obj2 = ((!(type != null)) ? null : AccessTools.Field(type, "Instance")?.GetValue(null));
				dictionary2 = ((obj2 != null) ? ((IDictionary)Activator.CreateInstance(dictionary.GetType(), obj2)) : ((IDictionary)Activator.CreateInstance(dictionary.GetType())));
			}
			catch
			{
				dictionary2 = (IDictionary)Activator.CreateInstance(dictionary.GetType());
			}
			foreach (DictionaryEntry item in dictionary)
			{
				if (item.Key != null && !item.Key.Equals(obj) && (!(method != null) || (bool)method.Invoke(item.Key, null)))
				{
					dictionary2.Add(item.Key, item.Value);
				}
			}
			DiscoveredModifiersField.SetValue(instance, dictionary2);
		}
		catch (Exception ex)
		{
			ProfileSwitcherPlugin.Log.LogDebug((object)("ScrubInvalidDiscoveredModifiers: " + ex.Message));
		}
	}
}
[HarmonyPatch(typeof(StartMenu))]
internal static class StartMenuProfilePatches
{
	private static readonly FieldInfo ProfileSelectField = AccessTools.Field(typeof(StartMenu), "profileSelect");

	private static readonly FieldInfo ProfileTextField = AccessTools.Field(typeof(StartMenu), "profileText");

	private static readonly FieldInfo ProfileRestartTextField = AccessTools.Field(typeof(StartMenu), "profileRestartText");

	private static readonly FieldInfo PatchNotesBlinkerField = AccessTools.Field(typeof(StartMenu), "patchNotesBlinker");

	private static bool _isSwapping;

	[HarmonyPatch("SelectProfile")]
	[HarmonyPrefix]
	private static bool SelectProfile_Prefix(StartMenu __instance, int index)
	{
		if (_isSwapping)
		{
			return false;
		}
		try
		{
			if (!CanSwapSafely(out var reason))
			{
				ProfileSwitcherPlugin.Log.LogWarning((object)("Profile swap blocked: " + reason));
				ShowInfo("Profile Swap", reason);
				ApplyVanillaSelectionUi(__instance, index, showRestartPrompt: true);
				return false;
			}
			int currentProfileIndex = ProfileReloader.GetCurrentProfileIndex();
			if (index == currentProfileIndex)
			{
				ApplyVanillaSelectionUi(__instance, index, showRestartPrompt: false);
				return false;
			}
			_isSwapping = true;
			string error;
			bool num = ProfileReloader.TrySwapProfile(index, out error);
			_isSwapping = false;
			if (!num)
			{
				ProfileSwitcherPlugin.Log.LogError((object)("Profile swap failed: " + error));
				ShowInfo("Profile Swap Failed", error ?? "Unknown error while loading the selected profile.");
				ApplyVanillaSelectionUi(__instance, ProfileReloader.GetCurrentProfileIndex(), showRestartPrompt: true);
				return false;
			}
			ApplyVanillaSelectionUi(__instance, index, showRestartPrompt: false);
			RefreshMenuAfterSwap(__instance);
			ProfileSwitcherPlugin.Log.LogInfo((object)$"Swapped to profile index {index} without restart.");
			return false;
		}
		catch (Exception arg)
		{
			_isSwapping = false;
			ProfileSwitcherPlugin.Log.LogError((object)$"Unhandled profile swap exception: {arg}");
			ShowInfo("Profile Swap Failed", "An unexpected error occurred. The game may need a restart.");
			return false;
		}
	}

	private static bool CanSwapSafely(out string reason)
	{
		if ((Object)(object)GameManager.Instance != (Object)null)
		{
			reason = "Leave the hub/mission and return to the main menu before swapping profiles.";
			return false;
		}
		if (JoinFriendsWindow.JoiningInProgress)
		{
			reason = "Cannot swap profiles while joining a lobby.";
			return false;
		}
		if ((Object)(object)StartMenu.Instance == (Object)null)
		{
			reason = "Main menu is not active.";
			return false;
		}
		reason = null;
		return true;
	}

	private static void ApplyVanillaSelectionUi(StartMenu menu, int index, bool showRestartPrompt)
	{
		ProfileConfig.Instance.SetProfile(index);
		object? obj = ProfileSelectField?.GetValue(menu);
		object? obj2 = ((obj is GameObject) ? obj : null);
		if (obj2 != null)
		{
			((GameObject)obj2).SetActive(false);
		}
		object? obj3 = ProfileRestartTextField?.GetValue(menu);
		TextMeshProUGUI val = (TextMeshProUGUI)((obj3 is TextMeshProUGUI) ? obj3 : null);
		if ((Object)(object)val != (Object)null)
		{
			((Component)val).gameObject.SetActive(showRestartPrompt);
		}
		object? obj4 = ProfileTextField?.GetValue(menu);
		TextMeshProUGUI val2 = (TextMeshProUGUI)((obj4 is TextMeshProUGUI) ? obj4 : null);
		if ((Object)(object)val2 != (Object)null)
		{
			((TMP_Text)val2).text = ((index == 0) ? "default" : ProfileConfig.Instance.GetProfile(index).Name);
			((Component)val2).gameObject.SetActive(true);
		}
	}

	private static void RefreshMenuAfterSwap(StartMenu menu)
	{
		try
		{
			object? obj = PatchNotesBlinkerField?.GetValue(menu);
			Component val = (Component)((obj is Component) ? obj : null);
			if ((Object)(object)val != (Object)null)
			{
				val.gameObject.SetActive(Global.Version != PlayerData.Instance.lastViewedPatchNotes);
			}
		}
		catch (Exception ex)
		{
			ProfileSwitcherPlugin.Log.LogDebug((object)("Patch notes blinker refresh skipped: " + ex.Message));
		}
	}

	private static void ShowInfo(string title, string body)
	{
		//IL_0048: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			if (!((Object)(object)StartMenu.Instance == (Object)null) && !((Object)(object)Global.Instance == (Object)null) && !((Object)(object)Global.Instance.InfoWindow == (Object)null))
			{
				((InfoWindow)((Window)StartMenu.Instance).WindowSystem.OpenWindowFromPrefab((Window)(object)Global.Instance.InfoWindow, false)).SetInfo(title, body);
			}
		}
		catch (Exception ex)
		{
			ProfileSwitcherPlugin.Log.LogDebug((object)("Could not show info window: " + ex.Message));
		}
	}
}
namespace ProfileSwitcher
{
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "ProfileSwitcher";

		public const string PLUGIN_NAME = "ProfileSwitcher";

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