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 UnityEngine;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("UCHCustomNames")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("UCHCustomNames")]
[assembly: AssemblyCopyright("Copyright ©  2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("0d1b656b-fd01-4b18-8792-d987bfceba21")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
[BepInPlugin("com.customnames.uch", "UCH Custom Names", "1.0")]
public class CustomNames : BaseUnityPlugin
{
	private class LocalPlayerInfo
	{
		public int playerNumber;

		public string currentName;

		public string newName;

		public LobbyPlayer lobbyPlayer;

		public bool isInLobby;
	}

	private static CustomNames instance;

	private bool menuVisible;

	private Vector2 scrollPos = Vector2.zero;

	private Rect menuRect = new Rect((float)(Screen.width / 2 - 200), (float)(Screen.height / 2 - 250), 400f, 500f);

	private List<LocalPlayerInfo> localPlayers = new List<LocalPlayerInfo>();

	private int selectedPlayer;

	private string newName = "";

	private GUIStyle titleStyle;

	private GUIStyle labelStyle;

	private GUIStyle buttonStyle;

	private GUIStyle boxStyle;

	private bool stylesInitialized;

	private HashSet<int> autoAppliedPlayers = new HashSet<int>();

	private Texture2D cursorTexture;

	private Vector2 cursorHotspot = new Vector2(16f, 16f);

	private static void LogInfo(string message)
	{
		if ((Object)(object)instance != (Object)null)
		{
			((BaseUnityPlugin)instance).Logger.LogInfo((object)message);
		}
		else
		{
			Debug.Log((object)("[UCH Custom Names] " + message));
		}
	}

	private static void LogWarning(string message)
	{
		if ((Object)(object)instance != (Object)null)
		{
			((BaseUnityPlugin)instance).Logger.LogWarning((object)message);
		}
		else
		{
			Debug.LogWarning((object)("[UCH Custom Names] " + message));
		}
	}

	private static void LogError(string message)
	{
		if ((Object)(object)instance != (Object)null)
		{
			((BaseUnityPlugin)instance).Logger.LogError((object)message);
		}
		else
		{
			Debug.LogError((object)("[UCH Custom Names] " + message));
		}
	}

	private void Awake()
	{
		instance = this;
		LogInfo("========================================");
		LogInfo("UCH Custom Names - Mod Loaded!");
		LogInfo("Game version: " + Application.version);
		LogInfo("Unity version: " + Application.unityVersion);
		LogInfo("========================================");
		SceneManager.sceneLoaded += OnSceneLoaded;
		CreateStyles();
		CreateCursorTexture();
		LogInfo("Mod initialization complete. Press F5 to toggle menu.");
	}

	private void CreateCursorTexture()
	{
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Expected O, but got Unknown
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: 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_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_004d: 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_011e: 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_0130: Unknown result type (might be due to invalid IL or missing references)
		int num = 32;
		cursorTexture = new Texture2D(num, num, (TextureFormat)5, false);
		Color val = default(Color);
		((Color)(ref val))..ctor(0f, 0f, 0f, 0f);
		Color white = Color.white;
		Color black = Color.black;
		for (int i = 0; i < num; i++)
		{
			for (int j = 0; j < num; j++)
			{
				cursorTexture.SetPixel(i, j, val);
			}
		}
		int num2 = num / 2;
		int num3 = 2;
		for (int k = 0; k < num; k++)
		{
			for (int l = -num3; l <= num3; l++)
			{
				int num4 = num2 + l;
				if (num4 >= 0 && num4 < num)
				{
					if (l == -num3 || l == num3 || k == 0 || k == num - 1)
					{
						cursorTexture.SetPixel(k, num4, black);
					}
					else
					{
						cursorTexture.SetPixel(k, num4, white);
					}
				}
			}
		}
		for (int m = 0; m < num; m++)
		{
			for (int n = -num3; n <= num3; n++)
			{
				int num5 = num2 + n;
				if (num5 >= 0 && num5 < num)
				{
					if (n == -num3 || n == num3 || m == 0 || m == num - 1)
					{
						cursorTexture.SetPixel(num5, m, black);
					}
					else
					{
						cursorTexture.SetPixel(num5, m, white);
					}
				}
			}
		}
		cursorTexture.Apply();
	}

	private void CreateStyles()
	{
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: 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_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: Expected O, but got Unknown
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		//IL_0055: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: 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_0072: Expected O, but got Unknown
		//IL_007d: 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_008a: 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_0099: Expected O, but got Unknown
		//IL_0099: 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_00aa: Expected O, but got Unknown
		//IL_00af: Expected O, but got Unknown
		//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bf: 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: Expected O, but got Unknown
		//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00db: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e5: Expected O, but got Unknown
		//IL_00ea: Expected O, but got Unknown
		try
		{
			LogInfo("Creating GUI styles...");
			GUIStyle val = new GUIStyle(GUI.skin.label)
			{
				fontSize = 24,
				fontStyle = (FontStyle)1,
				alignment = (TextAnchor)4
			};
			val.normal.textColor = Color.white;
			titleStyle = val;
			GUIStyle val2 = new GUIStyle(GUI.skin.label)
			{
				fontSize = 14
			};
			val2.normal.textColor = Color.white;
			labelStyle = val2;
			buttonStyle = new GUIStyle(GUI.skin.button)
			{
				fontSize = 14,
				margin = new RectOffset(5, 5, 5, 5),
				padding = new RectOffset(10, 10, 5, 5)
			};
			boxStyle = new GUIStyle(GUI.skin.box)
			{
				margin = new RectOffset(10, 10, 10, 10),
				padding = new RectOffset(10, 10, 10, 10)
			};
			stylesInitialized = true;
			LogInfo("GUI styles created successfully.");
		}
		catch (Exception ex)
		{
			LogError("Error creating GUI styles: " + ex.Message);
		}
	}

	private void OnDestroy()
	{
		SceneManager.sceneLoaded -= OnSceneLoaded;
		LogInfo("Mod destroyed.");
	}

	private void Update()
	{
		//IL_0254: Unknown result type (might be due to invalid IL or missing references)
		if (Input.GetKeyDown((KeyCode)286))
		{
			LogInfo("F5 key pressed!");
			menuVisible = !menuVisible;
			LogInfo($"Menu visible: {menuVisible}");
			if (menuVisible)
			{
				RefreshLocalPlayers();
				LogInfo($"Players found after refresh: {localPlayers.Count}");
				if (localPlayers.Count > 0)
				{
					newName = localPlayers[selectedPlayer].newName;
					LogInfo($"Selected player: {selectedPlayer}, Name: {newName}");
				}
			}
		}
		if (menuVisible && localPlayers.Count > 0)
		{
			if (Input.GetKeyDown((KeyCode)273))
			{
				selectedPlayer = Mathf.Max(0, selectedPlayer - 1);
				if (selectedPlayer < localPlayers.Count)
				{
					newName = localPlayers[selectedPlayer].newName;
					LogInfo($"Up arrow - Selected player: {selectedPlayer}");
				}
			}
			else if (Input.GetKeyDown((KeyCode)274))
			{
				selectedPlayer = Mathf.Min(localPlayers.Count - 1, selectedPlayer + 1);
				if (selectedPlayer < localPlayers.Count)
				{
					newName = localPlayers[selectedPlayer].newName;
					LogInfo($"Down arrow - Selected player: {selectedPlayer}");
				}
			}
		}
		if (IsInLobby())
		{
			LobbyPlayer[] array = Object.FindObjectsOfType<LobbyPlayer>();
			foreach (LobbyPlayer val in array)
			{
				if (!((Object)(object)val != (Object)null) || !val.IsLocalPlayer)
				{
					continue;
				}
				int networkNumber = val.networkNumber;
				if (autoAppliedPlayers.Contains(networkNumber))
				{
					continue;
				}
				string savedName = GetSavedName(networkNumber);
				if (val.playerName != savedName)
				{
					LogInfo($"AUTO-APPLY: Player {networkNumber} has name '{val.playerName}', applying saved name '{savedName}'");
					try
					{
						val.CallCmdSetPlayerInfo(savedName, val.NetworkSkillMean, val.NetworkSkillStdDev, val.NetworkIsHost, val.NetworkGSID, val.Networkplatform);
						LogInfo($"SUCCESS: Auto-applied name '{savedName}' to Player {networkNumber}");
					}
					catch (Exception ex)
					{
						LogError($"Error auto-applying name to Player {networkNumber}: {ex.Message}");
					}
				}
				else
				{
					LogInfo($"AUTO-APPLY: Player {networkNumber} already has correct name '{savedName}'");
				}
				autoAppliedPlayers.Add(networkNumber);
			}
		}
		else if (autoAppliedPlayers.Count > 0)
		{
			autoAppliedPlayers.Clear();
			LogInfo("Left lobby, cleared auto-apply tracking.");
		}
	}

	private void OnGUI()
	{
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: 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_0096: 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_00c5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
		//IL_010b: Expected O, but got Unknown
		//IL_0106: Unknown result type (might be due to invalid IL or missing references)
		//IL_010b: Unknown result type (might be due to invalid IL or missing references)
		if (menuVisible)
		{
			Vector3 mousePosition = Input.mousePosition;
			float num = (float)Screen.height - mousePosition.y;
			GUI.DrawTexture(new Rect(mousePosition.x - cursorHotspot.x, num - cursorHotspot.y, 32f, 32f), (Texture)(object)cursorTexture);
		}
		if (!menuVisible)
		{
			return;
		}
		try
		{
			if (Time.frameCount % 60 == 0)
			{
				LogInfo($"OnGUI - Menu is visible. Frame: {Time.frameCount}");
			}
			GUI.color = new Color(0f, 0f, 0f, 0.7f);
			GUI.DrawTexture(new Rect(0f, 0f, (float)Screen.width, (float)Screen.height), (Texture)(object)Texture2D.whiteTexture);
			GUI.color = Color.white;
			if (!stylesInitialized)
			{
				LogWarning("Styles not initialized, recreating...");
				CreateStyles();
			}
			menuRect = GUI.Window(1, menuRect, new WindowFunction(DrawMenu), "", boxStyle);
		}
		catch (Exception ex)
		{
			LogError("Error in OnGUI: " + ex.Message + "\n" + ex.StackTrace);
			menuVisible = false;
			LogInfo("Menu disabled due to error.");
		}
	}

	private void DrawMenu(int windowID)
	{
		//IL_003a: 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_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
		//IL_0154: Unknown result type (might be due to invalid IL or missing references)
		//IL_014d: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f2: 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_021f: Unknown result type (might be due to invalid IL or missing references)
		//IL_024b: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
			GUILayout.Label("CUSTOM NAMES", titleStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Space(5f);
			bool flag = IsInLobby();
			GUI.color = (flag ? Color.green : Color.yellow);
			GUILayout.Label("Status: " + (flag ? "IN LOBBY ✅" : "NOT IN LOBBY ⚠\ufe0f"), labelStyle, Array.Empty<GUILayoutOption>());
			GUI.color = Color.white;
			GUILayout.Label($"Players: {localPlayers.Count}", labelStyle, Array.Empty<GUILayoutOption>());
			Scene activeScene = SceneManager.GetActiveScene();
			string name = ((Scene)(ref activeScene)).name;
			GUILayout.Label("Scene: " + name, labelStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Space(5f);
			scrollPos = GUILayout.BeginScrollView(scrollPos, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(150f) });
			if (localPlayers.Count == 0)
			{
				GUILayout.Label("No players found. Join a game or press REFRESH.", labelStyle, Array.Empty<GUILayoutOption>());
			}
			else
			{
				for (int i = 0; i < localPlayers.Count; i++)
				{
					LocalPlayerInfo localPlayerInfo = localPlayers[i];
					bool flag2 = i == selectedPlayer;
					GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
					GUI.color = (flag2 ? Color.cyan : Color.white);
					if (GUILayout.Button($"P{localPlayerInfo.playerNumber}", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(40f) }))
					{
						selectedPlayer = i;
						newName = localPlayerInfo.newName;
						LogInfo($"Selected player {i}: P{localPlayerInfo.playerNumber} - {localPlayerInfo.currentName}");
					}
					GUI.color = Color.white;
					string obj = (localPlayerInfo.isInLobby ? "●" : "○");
					GUI.color = (localPlayerInfo.isInLobby ? Color.green : Color.gray);
					GUILayout.Label(obj, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(20f) });
					GUI.color = (flag2 ? Color.cyan : Color.white);
					GUILayout.Label(localPlayerInfo.currentName, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
					GUI.color = Color.white;
					GUILayout.EndHorizontal();
				}
			}
			GUILayout.EndScrollView();
			GUILayout.Space(10f);
			if (selectedPlayer < localPlayers.Count && localPlayers.Count > 0)
			{
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				GUILayout.Label("New Name:", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(80f) });
				newName = GUILayout.TextField(newName, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
				GUILayout.EndHorizontal();
				GUILayout.Space(5f);
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				if (GUILayout.Button("APPLY", buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) }))
				{
					LogInfo("APPLY button clicked");
					ApplySelectedName();
				}
				if (GUILayout.Button("SAVE", buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) }))
				{
					LogInfo("SAVE button clicked");
					SaveCurrentName();
				}
				if (GUILayout.Button("RESET ALL", buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) }))
				{
					LogInfo("RESET ALL button clicked");
					ResetAllNames();
				}
				if (GUILayout.Button("REFRESH", buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) }))
				{
					LogInfo("REFRESH button clicked");
					RefreshLocalPlayers();
				}
				GUILayout.EndHorizontal();
			}
			GUILayout.FlexibleSpace();
			if (GUILayout.Button("CLOSE (F5)", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) }))
			{
				LogInfo("CLOSE button clicked");
				menuVisible = false;
			}
			GUILayout.EndVertical();
			GUI.DragWindow();
		}
		catch (Exception ex)
		{
			LogError("Error in DrawMenu: " + ex.Message + "\n" + ex.StackTrace);
		}
	}

	private string GetSavedName(int playerNumber)
	{
		return PlayerPrefs.GetString("UCH_Name_" + playerNumber, $"Player {playerNumber}");
	}

	private void SetSavedName(int playerNumber, string name)
	{
		LogInfo($"SetSavedName({playerNumber}) = '{name}'");
		PlayerPrefs.SetString("UCH_Name_" + playerNumber, name);
		PlayerPrefs.Save();
		LogInfo("PlayerPrefs saved.");
	}

	private void RefreshLocalPlayers()
	{
		LogInfo("=== REFRESH LOCAL PLAYERS ===");
		localPlayers.Clear();
		try
		{
			LobbyPlayer[] array = Object.FindObjectsOfType<LobbyPlayer>();
			LogInfo($"Total LobbyPlayer found: {array.Length}");
			List<LobbyPlayer> list = (from p in array
				where (Object)(object)p != (Object)null && p.IsLocalPlayer
				orderby p.networkNumber
				select p).ToList();
			LogInfo($"Local players found: {list.Count}");
			foreach (LobbyPlayer item in list)
			{
				LogInfo($"  - Player {item.networkNumber}: '{item.playerName}' (IsLocalPlayer: {item.IsLocalPlayer})");
				LocalPlayerInfo localPlayerInfo = new LocalPlayerInfo
				{
					playerNumber = item.networkNumber,
					currentName = item.playerName,
					newName = GetSavedName(item.networkNumber),
					lobbyPlayer = item,
					isInLobby = IsInLobby()
				};
				localPlayers.Add(localPlayerInfo);
				LogInfo($"    Added to list: P{localPlayerInfo.playerNumber} - '{localPlayerInfo.currentName}' -> new: '{localPlayerInfo.newName}'");
			}
			if (localPlayers.Count == 0)
			{
				LogInfo("No local players found. Checking saved names...");
				for (int num = 1; num <= 10; num++)
				{
					string savedName = GetSavedName(num);
					if (savedName != $"Player {num}")
					{
						LogInfo($"  Saved player {num}: '{savedName}'");
						localPlayers.Add(new LocalPlayerInfo
						{
							playerNumber = num,
							currentName = savedName,
							newName = savedName,
							lobbyPlayer = null,
							isInLobby = false
						});
					}
				}
				if (localPlayers.Count == 0)
				{
					LogInfo("No saved names found. Creating default player.");
					localPlayers.Add(new LocalPlayerInfo
					{
						playerNumber = 1,
						currentName = "Player 1",
						newName = "Player 1",
						lobbyPlayer = null,
						isInLobby = false
					});
				}
			}
			if (selectedPlayer >= localPlayers.Count)
			{
				selectedPlayer = 0;
			}
			if (localPlayers.Count > 0)
			{
				newName = localPlayers[selectedPlayer].newName;
			}
			LogInfo($"Refresh complete. Total players in list: {localPlayers.Count}");
			LogInfo("=====================================");
		}
		catch (Exception ex)
		{
			LogError("Error in RefreshLocalPlayers: " + ex.Message + "\n" + ex.StackTrace);
		}
	}

	private void ApplySelectedName()
	{
		//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
		LogInfo("=== APPLY SELECTED NAME ===");
		if (selectedPlayer >= localPlayers.Count)
		{
			LogWarning($"Selected player {selectedPlayer} out of range (count: {localPlayers.Count})");
			return;
		}
		LocalPlayerInfo localPlayerInfo = localPlayers[selectedPlayer];
		LogInfo($"Applying name to Player {localPlayerInfo.playerNumber}: '{newName}'");
		if (string.IsNullOrEmpty(newName))
		{
			LogWarning("Name is empty, ignoring.");
			return;
		}
		if (localPlayerInfo.isInLobby && (Object)(object)localPlayerInfo.lobbyPlayer != (Object)null)
		{
			LogInfo("Player is in lobby, updating via network...");
			try
			{
				localPlayerInfo.lobbyPlayer.CallCmdSetPlayerInfo(newName, localPlayerInfo.lobbyPlayer.NetworkSkillMean, localPlayerInfo.lobbyPlayer.NetworkSkillStdDev, localPlayerInfo.lobbyPlayer.NetworkIsHost, localPlayerInfo.lobbyPlayer.NetworkGSID, localPlayerInfo.lobbyPlayer.Networkplatform);
				localPlayerInfo.currentName = newName;
				localPlayerInfo.newName = newName;
				SetSavedName(localPlayerInfo.playerNumber, newName);
				autoAppliedPlayers.Add(localPlayerInfo.playerNumber);
				LogInfo($"SUCCESS: Name updated for Player {localPlayerInfo.playerNumber}: {newName}");
			}
			catch (Exception ex)
			{
				LogError("Error updating name via network: " + ex.Message);
			}
		}
		else
		{
			LogInfo("Player is offline or not in lobby, saving locally.");
			SetSavedName(localPlayerInfo.playerNumber, newName);
			localPlayerInfo.currentName = newName;
			localPlayerInfo.newName = newName;
			LogInfo($"SUCCESS: Name saved for offline Player {localPlayerInfo.playerNumber}: {newName}");
		}
		RefreshLocalPlayers();
		LogInfo("=================================");
	}

	private void SaveCurrentName()
	{
		LogInfo("=== SAVE CURRENT NAME ===");
		if (selectedPlayer >= localPlayers.Count)
		{
			LogWarning($"Selected player {selectedPlayer} out of range (count: {localPlayers.Count})");
			return;
		}
		LocalPlayerInfo localPlayerInfo = localPlayers[selectedPlayer];
		LogInfo($"Saving name for Player {localPlayerInfo.playerNumber}: '{newName}'");
		if (string.IsNullOrEmpty(newName))
		{
			LogWarning("Name is empty, ignoring.");
			return;
		}
		SetSavedName(localPlayerInfo.playerNumber, newName);
		localPlayerInfo.currentName = newName;
		localPlayerInfo.newName = newName;
		LogInfo("SUCCESS: Name saved: " + newName);
		RefreshLocalPlayers();
		LogInfo("=================================");
	}

	private void ResetAllNames()
	{
		//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
		LogInfo("=== RESET ALL NAMES ===");
		foreach (LocalPlayerInfo localPlayer in localPlayers)
		{
			string text = $"Player {localPlayer.playerNumber}";
			LogInfo($"Resetting Player {localPlayer.playerNumber}: '{localPlayer.currentName}' -> '{text}'");
			SetSavedName(localPlayer.playerNumber, text);
			localPlayer.currentName = text;
			localPlayer.newName = text;
			autoAppliedPlayers.Remove(localPlayer.playerNumber);
			if (localPlayer.isInLobby && (Object)(object)localPlayer.lobbyPlayer != (Object)null)
			{
				try
				{
					LogInfo($"  Updating Player {localPlayer.playerNumber} via network...");
					localPlayer.lobbyPlayer.CallCmdSetPlayerInfo(text, localPlayer.lobbyPlayer.NetworkSkillMean, localPlayer.lobbyPlayer.NetworkSkillStdDev, localPlayer.lobbyPlayer.NetworkIsHost, localPlayer.lobbyPlayer.NetworkGSID, localPlayer.lobbyPlayer.Networkplatform);
				}
				catch (Exception ex)
				{
					LogError($"  Error updating Player {localPlayer.playerNumber}: {ex.Message}");
				}
			}
		}
		RefreshLocalPlayers();
		LogInfo("All names reset to default.");
		LogInfo("=================================");
	}

	private bool IsInLobby()
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			Scene activeScene = SceneManager.GetActiveScene();
			bool num = ((Scene)(ref activeScene)).name == "TreeHouseLobby";
			bool flag = (Object)(object)LobbyManager.instance != (Object)null;
			bool flag2 = flag && LobbyManager.instance.IsInOnlineGame;
			return num && flag && flag2;
		}
		catch
		{
			return false;
		}
	}

	private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
	{
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		LogInfo("=== SCENE LOADED ===");
		LogInfo($"Scene: '{((Scene)(ref scene)).name}' (buildIndex: {((Scene)(ref scene)).buildIndex})");
		LogInfo($"Load mode: {mode}");
		if (((Scene)(ref scene)).name == "TreeHouseLobby")
		{
			LogInfo("Entered lobby! Refreshing players...");
			autoAppliedPlayers.Clear();
			RefreshLocalPlayers();
		}
		else
		{
			LogInfo("Scene '" + ((Scene)(ref scene)).name + "' is not the lobby. No action taken.");
		}
		LogInfo("====================");
	}

	public static void ChangePlayerName(int playerNumber, string newName)
	{
		//IL_0092: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)instance == (Object)null)
		{
			LogWarning("Instance is null, cannot change name.");
			return;
		}
		LogInfo($"Static call: ChangePlayerName({playerNumber}, '{newName}')");
		LobbyPlayer[] array = Object.FindObjectsOfType<LobbyPlayer>();
		foreach (LobbyPlayer val in array)
		{
			if (!((Object)(object)val != (Object)null) || !val.IsLocalPlayer || val.networkNumber != playerNumber)
			{
				continue;
			}
			LogInfo($"Found local player {playerNumber}, applying name...");
			try
			{
				val.CallCmdSetPlayerInfo(newName, val.NetworkSkillMean, val.NetworkSkillStdDev, val.NetworkIsHost, val.NetworkGSID, val.Networkplatform);
				if ((Object)(object)instance != (Object)null)
				{
					instance.SetSavedName(playerNumber, newName);
					instance.autoAppliedPlayers.Add(playerNumber);
				}
				LogInfo("Name changed successfully to: " + newName);
				break;
			}
			catch (Exception ex)
			{
				LogError("Error in static ChangePlayerName: " + ex.Message);
				break;
			}
		}
	}
}