using System;
using System.Collections;
using System.Collections.Generic;
using GameNetcodeStuff;
using Netcode.Transports.Facepunch;
using Steamworks;
using Steamworks.Data;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.SceneManagement;

public class GameNetworkManager : MonoBehaviour
{
	public int gameVersionNum = 1;

	public int compatibleFileCutoffVersion;

	public bool AlwaysDisplayNews = true;

	public bool isDemo;

	[Space(5f)]
	public bool SendExceptionsToServer;

	[Space(5f)]
	public bool disableSteam;

	private FacepunchTransport transport;

	public HostSettings lobbyHostSettings;

	public int connectedPlayers;

	private bool hasSubscribedToConnectionCallbacks;

	public bool gameHasStarted;

	public PlayerControllerB localPlayerController;

	public int disconnectReason;

	public string username;

	public bool isDisconnecting;

	public bool firstTimeInMenu = true;

	public bool isHostingGame;

	public bool waitingForLobbyDataRefresh;

	public int playersInRefreshedLobby;

	public string steamLobbyName;

	public const string LCsaveFile1Name = "LCSaveFile1";

	public const string LCsaveFile2Name = "LCSaveFile2";

	public const string LCsaveFile3Name = "LCSaveFile3";

	public const string generalSaveDataName = "LCGeneralSaveData";

	public string currentSaveFileName = "LCSaveFile1";

	public int saveFileNum;

	public AudioClip buttonCancelSFX;

	public AudioClip buttonSelectSFX;

	public AudioClip buttonPressSFX;

	public AudioClip buttonTuneSFX;

	public bool disallowConnection;

	public string disconnectionReasonMessage;

	public bool localClientWaitingForApproval;

	public bool disapprovedClientThisFrame;

	private string previousLogErrorString;

	public static GameNetworkManager Instance { get; private set; }

	public Lobby? currentLobby { get; private set; }

	private void LogCallback(string condition, string stackTrace, LogType type)
	{
		if ((type != LogType.Exception && type != 0) || HUDManager.Instance == null || localPlayerController == null)
		{
			return;
		}
		string text = condition + stackTrace.Substring(0, Mathf.Clamp(200, 0, stackTrace.Length));
		if (string.IsNullOrEmpty(previousLogErrorString) || !(text == previousLogErrorString))
		{
			previousLogErrorString = text;
			if (!SendExceptionsToServer)
			{
				HUDManager.Instance.AddToErrorLog(text, (int)localPlayerController.playerClientId);
				return;
			}
			HUDManager.Instance.SendErrorMessageServerRpc(text, (int)localPlayerController.playerClientId);
			HUDManager.Instance.AddToErrorLog(text, (int)localPlayerController.playerClientId);
		}
	}

	private void Awake()
	{
		if (Instance == null)
		{
			Instance = this;
			StartCoroutine(waitFrameBeforeFindingUsername());
			if (compatibleFileCutoffVersion > gameVersionNum)
			{
				Debug.LogError("The compatible file cutoff version was higher than the game version number. This should not happen!!");
				compatibleFileCutoffVersion = gameVersionNum;
			}
		}
		else
		{
			UnityEngine.Object.Destroy(base.gameObject);
		}
	}

	private IEnumerator waitFrameBeforeFindingUsername()
	{
		yield return null;
		yield return null;
		if (!disableSteam)
		{
			string text = SteamClient.Name.ToString();
			if (text.Length > 18)
			{
				text.Remove(15, text.Length - 15);
				text += "...";
			}
			username = text;
		}
		else
		{
			username = "PlayerName";
		}
	}

	private void Start()
	{
		GetComponent<NetworkManager>().NetworkConfig.ProtocolVersion = (ushort)gameVersionNum;
		if ((bool)GetComponent<FacepunchTransport>())
		{
			transport = GetComponent<FacepunchTransport>();
		}
		else
		{
			Debug.Log("Facepunch transport is disabled.");
		}
		saveFileNum = ES3.Load("SelectedFile", "LCGeneralSaveData", 0);
		switch (saveFileNum)
		{
		case 0:
			currentSaveFileName = "LCSaveFile1";
			break;
		case 1:
			currentSaveFileName = "LCSaveFile2";
			break;
		case 2:
			currentSaveFileName = "LCSaveFile3";
			break;
		default:
			currentSaveFileName = "LCSaveFile1";
			break;
		}
	}

	private void OnEnable()
	{
		Application.logMessageReceived += LogCallback;
		if (!disableSteam)
		{
			Debug.Log("subcribing to steam callbacks");
			SteamMatchmaking.OnLobbyCreated += SteamMatchmaking_OnLobbyCreated;
			SteamMatchmaking.OnLobbyMemberJoined += SteamMatchmaking_OnLobbyMemberJoined;
			SteamMatchmaking.OnLobbyMemberLeave += SteamMatchmaking_OnLobbyMemberLeave;
			SteamMatchmaking.OnLobbyInvite += SteamMatchmaking_OnLobbyInvite;
			SteamMatchmaking.OnLobbyGameCreated += SteamMatchmaking_OnLobbyGameCreated;
			SteamFriends.OnGameLobbyJoinRequested += SteamFriends_OnGameLobbyJoinRequested;
		}
	}

	private void OnDisable()
	{
		Application.logMessageReceived -= LogCallback;
		if (!disableSteam)
		{
			Debug.Log("unsubscribing from steam callbacks");
			SteamMatchmaking.OnLobbyCreated -= SteamMatchmaking_OnLobbyCreated;
			SteamMatchmaking.OnLobbyMemberJoined -= SteamMatchmaking_OnLobbyMemberJoined;
			SteamMatchmaking.OnLobbyMemberLeave -= SteamMatchmaking_OnLobbyMemberLeave;
			SteamMatchmaking.OnLobbyInvite -= SteamMatchmaking_OnLobbyInvite;
			SteamMatchmaking.OnLobbyGameCreated -= SteamMatchmaking_OnLobbyGameCreated;
			SteamFriends.OnGameLobbyJoinRequested -= SteamFriends_OnGameLobbyJoinRequested;
		}
	}

	public void SetSteamFriendGrouping(string groupName, int groupSize, string steamDisplay)
	{
		_ = disableSteam;
	}

	private void Singleton_OnClientDisconnectCallback(ulong clientId)
	{
		Debug.Log("Disconnect callback called");
		Debug.Log($"Is server: {NetworkManager.Singleton.IsServer}; ishost: {NetworkManager.Singleton.IsHost}; isConnectedClient: {NetworkManager.Singleton.IsConnectedClient}");
		if (NetworkManager.Singleton == null)
		{
			Debug.Log("Network singleton is null!");
			return;
		}
		if (clientId == NetworkManager.Singleton.LocalClientId && localClientWaitingForApproval)
		{
			OnLocalClientConnectionDisapproved(clientId);
			return;
		}
		if (NetworkManager.Singleton.IsServer)
		{
			Debug.Log($"Disconnect callback called in gamenetworkmanager; disconnecting clientId: {clientId}");
			if (StartOfRound.Instance != null && !StartOfRound.Instance.ClientPlayerList.ContainsKey(clientId))
			{
				Debug.Log("A Player disconnected but they were not in clientplayerlist");
				return;
			}
			if (clientId == NetworkManager.Singleton.LocalClientId)
			{
				Debug.Log("Disconnect callback called for local client; ignoring.");
				return;
			}
			if (NetworkManager.Singleton.IsServer)
			{
				connectedPlayers--;
			}
		}
		if (StartOfRound.Instance != null)
		{
			StartOfRound.Instance.OnClientDisconnect(clientId);
		}
		Debug.Log("Disconnect callback from networkmanager in gamenetworkmanager");
	}

	private void OnLocalClientConnectionDisapproved(ulong clientId)
	{
		localClientWaitingForApproval = false;
		Debug.Log($"Local client connection denied; clientId: {clientId}; reason: {disconnectionReasonMessage.ToString()}");
		if (!string.IsNullOrEmpty(NetworkManager.Singleton.DisconnectReason))
		{
			disconnectionReasonMessage = NetworkManager.Singleton.DisconnectReason;
		}
		UnityEngine.Object.FindObjectOfType<MenuManager>().SetLoadingScreen(isLoading: false);
		LeaveCurrentSteamLobby();
		SetInstanceValuesBackToDefault();
		if (NetworkManager.Singleton.IsConnectedClient)
		{
			Debug.Log("Calling shutdown(true) on server in OnLocalClientDisapproved");
			NetworkManager.Singleton.Shutdown(discardMessageQueue: true);
		}
	}

	private void Singleton_OnClientConnectedCallback(ulong clientId)
	{
		if (!(NetworkManager.Singleton == null))
		{
			Debug.Log("Client connected callback in gamenetworkmanager");
			if (NetworkManager.Singleton.IsServer)
			{
				connectedPlayers++;
			}
			if (StartOfRound.Instance != null)
			{
				StartOfRound.Instance.OnClientConnect(clientId);
			}
		}
	}

	public void SubscribeToConnectionCallbacks()
	{
		if (!hasSubscribedToConnectionCallbacks)
		{
			NetworkManager.Singleton.OnClientConnectedCallback += Instance.Singleton_OnClientConnectedCallback;
			NetworkManager.Singleton.OnClientDisconnectCallback += Instance.Singleton_OnClientDisconnectCallback;
			hasSubscribedToConnectionCallbacks = true;
		}
	}

	public void SteamFriends_OnGameLobbyJoinRequested(Lobby lobby, SteamId id)
	{
		if (UnityEngine.Object.FindObjectOfType<MenuManager>() == null)
		{
			return;
		}
		if (!Instance.currentLobby.HasValue)
		{
			Debug.Log("JOIN REQUESTED through steam invite");
			Debug.Log($"lobby id: {lobby.Id}");
			LobbySlot.JoinLobbyAfterVerifying(lobby, lobby.Id);
			return;
		}
		Debug.Log("Attempted to join by Steam invite request, but already in a lobby.");
		MenuManager menuManager = UnityEngine.Object.FindObjectOfType<MenuManager>();
		if (menuManager != null)
		{
			menuManager.DisplayMenuNotification("You are already in a lobby!", "Back");
		}
		Instance.currentLobby.Value.Leave();
		Instance.currentLobby = null;
	}

	public bool LobbyDataIsJoinable(Lobby lobby)
	{
		string data = lobby.GetData("vers");
		if (data != Instance.gameVersionNum.ToString())
		{
			Debug.Log($"Lobby join denied! Attempted to join vers.{data} lobby id: {lobby.Id}");
			UnityEngine.Object.FindObjectOfType<MenuManager>().SetLoadingScreen(isLoading: false, RoomEnter.DoesntExist, $"The server host is playing on version {data} while you are on version {Instance.gameVersionNum}.");
			return false;
		}
		if (lobby.GetData("joinable") == "false")
		{
			Debug.Log("Lobby join denied! Host lobby is not joinable");
			UnityEngine.Object.FindObjectOfType<MenuManager>().SetLoadingScreen(isLoading: false, RoomEnter.DoesntExist, "The server host has already landed their ship, or they are still loading in.");
			return false;
		}
		if (lobby.MemberCount >= 4 || lobby.MemberCount < 1)
		{
			Debug.Log($"Lobby join denied! Too many members in lobby! {lobby.Id}");
			UnityEngine.Object.FindObjectOfType<MenuManager>().SetLoadingScreen(isLoading: false, RoomEnter.Full, "The server is full!");
			return false;
		}
		Debug.Log($"Lobby join accepted! Lobby id {lobby.Id} is OK");
		return true;
	}

	public IEnumerator TimeOutLobbyRefresh()
	{
		yield return new WaitForSeconds(7f);
		waitingForLobbyDataRefresh = false;
		UnityEngine.Object.FindObjectOfType<MenuManager>().SetLoadingScreen(isLoading: false, RoomEnter.Error, "Error! Could not get the lobby data. Are you offline?");
		SteamMatchmaking.OnLobbyDataChanged -= LobbySlot.OnLobbyDataRefresh;
	}

	private void SteamMatchmaking_OnLobbyMemberJoined(Lobby lobby, Friend friend)
	{
	}

	private void SteamMatchmaking_OnLobbyMemberLeave(Lobby lobby, Friend friend)
	{
	}

	private void SteamMatchmaking_OnLobbyGameCreated(Lobby lobby, uint arg2, ushort arg3, SteamId arg4)
	{
	}

	private void SteamMatchmaking_OnLobbyInvite(Friend friend, Lobby lobby)
	{
		Debug.Log($"You got invited by {friend.Name} to join {lobby.Id}");
	}

	private void SteamMatchmaking_OnLobbyCreated(Result result, Lobby lobby)
	{
		if (result != Result.OK)
		{
			Debug.LogError($"Lobby could not be created! {result}", this);
		}
		lobby.SetData("name", lobbyHostSettings.lobbyName.ToString());
		lobby.SetData("vers", Instance.gameVersionNum.ToString());
		if (lobbyHostSettings.isLobbyPublic)
		{
			lobby.SetPublic();
		}
		else
		{
			lobby.SetPrivate();
			lobby.SetFriendsOnly();
		}
		lobby.SetJoinable(b: false);
		Instance.currentLobby = lobby;
		steamLobbyName = lobby.GetData("name");
		Debug.Log("Lobby has been created");
	}

	public void LeaveLobbyAtGameStart()
	{
		if (!Instance.currentLobby.HasValue)
		{
			Debug.Log("Current lobby is null. (Attempted to close lobby at game start)");
		}
		else
		{
			LeaveCurrentSteamLobby();
		}
	}

	public void SetLobbyJoinable(bool joinable)
	{
		if (!Instance.currentLobby.HasValue)
		{
			Debug.Log($"Current lobby is null. (Attempted to set lobby joinable {joinable}.)");
		}
		else
		{
			Instance.currentLobby.Value.SetJoinable(joinable);
		}
	}

	public void SetCurrentLobbyNull()
	{
		currentLobby = null;
	}

	private void OnApplicationQuit()
	{
		ES3.Save("SelectedFile", saveFileNum, "LCGeneralSaveData");
		Disconnect();
	}

	public void Disconnect()
	{
		if (!isDisconnecting)
		{
			isDisconnecting = true;
			if (isHostingGame)
			{
				disallowConnection = true;
			}
			StartDisconnect();
			SaveGame();
			if (NetworkManager.Singleton == null)
			{
				Debug.Log("Server is not active; quitting to main menu");
				ResetGameValuesToDefault();
				SceneManager.LoadScene("MainMenu");
			}
			else
			{
				StartCoroutine(DisconnectProcess());
			}
		}
	}

	private IEnumerator DisconnectProcess()
	{
		Debug.Log($"Shutting down and disconnecting from server. Is host?: {NetworkManager.Singleton.IsServer}");
		NetworkManager.Singleton.Shutdown();
		yield return new WaitUntil(() => !NetworkManager.Singleton.ShutdownInProgress);
		ResetGameValuesToDefault();
		SceneManager.LoadScene("MainMenu");
	}

	private void StartDisconnect()
	{
		if (!disableSteam)
		{
			Debug.Log("Leaving current lobby");
			LeaveCurrentSteamLobby();
			steamLobbyName = SteamClient.Name;
		}
		Debug.Log("Disconnecting and setting networkobjects to destroy with owner");
		NetworkObject[] array = UnityEngine.Object.FindObjectsOfType<NetworkObject>(includeInactive: true);
		for (int i = 0; i < array.Length; i++)
		{
			array[i].DontDestroyWithOwner = false;
		}
		Terminal terminal = UnityEngine.Object.FindObjectOfType<Terminal>();
		if (terminal != null && terminal.displayingSteamKeyboard)
		{
			SteamUtils.OnGamepadTextInputDismissed -= terminal.OnGamepadTextInputDismissed_t;
		}
	}

	public void SaveGame()
	{
		SaveLocalPlayerValues();
		SaveGameValues();
	}

	private void ResetGameValuesToDefault()
	{
		ResetUnlockablesListValues();
		if (StartOfRound.Instance != null)
		{
			StartOfRound.Instance.OnLocalDisconnect();
		}
		SetInstanceValuesBackToDefault();
	}

	public void ResetUnlockablesListValues()
	{
		if (!(StartOfRound.Instance != null))
		{
			return;
		}
		Debug.Log("Resetting unlockables list!");
		List<UnlockableItem> unlockables = StartOfRound.Instance.unlockablesList.unlockables;
		for (int i = 0; i < unlockables.Count; i++)
		{
			unlockables[i].hasBeenUnlockedByPlayer = false;
			if (unlockables[i].unlockableType == 1)
			{
				unlockables[i].placedPosition = Vector3.zero;
				unlockables[i].placedRotation = Vector3.zero;
				unlockables[i].hasBeenMoved = false;
				unlockables[i].inStorage = false;
			}
		}
	}

	private void SaveLocalPlayerValues()
	{
		try
		{
			if (HUDManager.Instance != null)
			{
				if (HUDManager.Instance.setTutorialArrow)
				{
					ES3.Save("FinishedShockMinigame", PatcherTool.finishedShockMinigame, "LCGeneralSaveData");
				}
				ES3.Save("PlayerLevel", HUDManager.Instance.localPlayerLevel, "LCGeneralSaveData");
				ES3.Save("PlayerXPNum", HUDManager.Instance.localPlayerXP, "LCGeneralSaveData");
			}
		}
		catch (Exception arg)
		{
			Debug.Log($"ERROR occured while saving local player values!: {arg}");
		}
	}

	public void ResetSavedGameValues()
	{
		if (!isHostingGame)
		{
			return;
		}
		TimeOfDay timeOfDay = UnityEngine.Object.FindObjectOfType<TimeOfDay>();
		if (timeOfDay != null)
		{
			ES3.Save("GlobalTime", 100, currentSaveFileName);
			ES3.Save("QuotaFulfilled", 0, currentSaveFileName);
			ES3.Save("QuotasPassed", 0, currentSaveFileName);
			ES3.Save("ProfitQuota", timeOfDay.quotaVariables.startingQuota, currentSaveFileName);
			ES3.Save("DeadlineTime", (int)(timeOfDay.totalTime * (float)timeOfDay.quotaVariables.deadlineDaysAmount), currentSaveFileName);
			ES3.Save("GroupCredits", timeOfDay.quotaVariables.startingCredits, currentSaveFileName);
		}
		ES3.Save("CurrentPlanetID", 0, currentSaveFileName);
		StartOfRound startOfRound = UnityEngine.Object.FindObjectOfType<StartOfRound>();
		if (!(startOfRound != null))
		{
			return;
		}
		ES3.DeleteKey("UnlockedShipObjects", Instance.currentSaveFileName);
		for (int i = 0; i < startOfRound.unlockablesList.unlockables.Count; i++)
		{
			if (startOfRound.unlockablesList.unlockables[i].unlockableType == 1)
			{
				ES3.DeleteKey("ShipUnlockMoved_" + startOfRound.unlockablesList.unlockables[i].unlockableName, currentSaveFileName);
				ES3.DeleteKey("ShipUnlockStored_" + startOfRound.unlockablesList.unlockables[i].unlockableName, currentSaveFileName);
				ES3.DeleteKey("ShipUnlockPos_" + startOfRound.unlockablesList.unlockables[i].unlockableName, currentSaveFileName);
				ES3.DeleteKey("ShipUnlockRot_" + startOfRound.unlockablesList.unlockables[i].unlockableName, currentSaveFileName);
			}
		}
		ResetUnlockablesListValues();
		ES3.Save("RandomSeed", startOfRound.randomMapSeed + 1, currentSaveFileName);
		ES3.Save("Stats_DaysSpent", 0, currentSaveFileName);
		ES3.Save("Stats_Deaths", 0, currentSaveFileName);
		ES3.Save("Stats_ValueCollected", 0, currentSaveFileName);
		ES3.Save("Stats_StepsTaken", 0, currentSaveFileName);
	}

	private void SaveGameValues()
	{
		if (!isHostingGame)
		{
			return;
		}
		if (!ES3.KeyExists("FileGameVers", currentSaveFileName))
		{
			ES3.Save("FileGameVers", Instance.gameVersionNum, currentSaveFileName);
		}
		if (!StartOfRound.Instance.inShipPhase)
		{
			return;
		}
		try
		{
			TimeOfDay timeOfDay = UnityEngine.Object.FindObjectOfType<TimeOfDay>();
			if (timeOfDay != null)
			{
				ES3.Save("QuotaFulfilled", timeOfDay.quotaFulfilled, currentSaveFileName);
				ES3.Save("QuotasPassed", timeOfDay.timesFulfilledQuota, currentSaveFileName);
				ES3.Save("ProfitQuota", timeOfDay.profitQuota, currentSaveFileName);
			}
			ES3.Save("CurrentPlanetID", StartOfRound.Instance.currentLevelID, currentSaveFileName);
			Terminal terminal = UnityEngine.Object.FindObjectOfType<Terminal>();
			if (terminal != null)
			{
				ES3.Save("GroupCredits", terminal.groupCredits, currentSaveFileName);
				if (terminal.unlockedStoryLogs.Count > 0)
				{
					ES3.Save("StoryLogs", terminal.unlockedStoryLogs.ToArray(), currentSaveFileName);
				}
				if (terminal.scannedEnemyIDs.Count > 0)
				{
					ES3.Save("EnemyScans", terminal.scannedEnemyIDs.ToArray(), currentSaveFileName);
				}
			}
			StartOfRound startOfRound = UnityEngine.Object.FindObjectOfType<StartOfRound>();
			if (startOfRound != null)
			{
				List<int> list = new List<int>();
				for (int i = 0; i < startOfRound.unlockablesList.unlockables.Count; i++)
				{
					if (startOfRound.unlockablesList.unlockables[i].hasBeenUnlockedByPlayer || startOfRound.unlockablesList.unlockables[i].hasBeenMoved || startOfRound.unlockablesList.unlockables[i].inStorage)
					{
						list.Add(i);
					}
					if (startOfRound.unlockablesList.unlockables[i].IsPlaceable)
					{
						if (startOfRound.unlockablesList.unlockables[i].canBeStored)
						{
							ES3.Save("ShipUnlockStored_" + startOfRound.unlockablesList.unlockables[i].unlockableName, startOfRound.unlockablesList.unlockables[i].inStorage, currentSaveFileName);
						}
						if (startOfRound.unlockablesList.unlockables[i].hasBeenMoved)
						{
							ES3.Save("ShipUnlockMoved_" + startOfRound.unlockablesList.unlockables[i].unlockableName, startOfRound.unlockablesList.unlockables[i].hasBeenMoved, currentSaveFileName);
							ES3.Save("ShipUnlockPos_" + startOfRound.unlockablesList.unlockables[i].unlockableName, startOfRound.unlockablesList.unlockables[i].placedPosition, currentSaveFileName);
							ES3.Save("ShipUnlockRot_" + startOfRound.unlockablesList.unlockables[i].unlockableName, startOfRound.unlockablesList.unlockables[i].placedRotation, currentSaveFileName);
						}
					}
				}
				if (list.Count > 0)
				{
					ES3.Save("UnlockedShipObjects", list.ToArray(), currentSaveFileName);
				}
				ES3.Save("DeadlineTime", (int)Mathf.Clamp(timeOfDay.timeUntilDeadline, 0f, 99999f), currentSaveFileName);
				ES3.Save("RandomSeed", startOfRound.randomMapSeed, currentSaveFileName);
				ES3.Save("Stats_DaysSpent", startOfRound.gameStats.daysSpent, currentSaveFileName);
				ES3.Save("Stats_Deaths", startOfRound.gameStats.deaths, currentSaveFileName);
				ES3.Save("Stats_ValueCollected", startOfRound.gameStats.scrapValueCollected, currentSaveFileName);
				ES3.Save("Stats_StepsTaken", startOfRound.gameStats.allStepsTaken, currentSaveFileName);
			}
			SaveItemsInShip();
		}
		catch (Exception arg)
		{
			Debug.LogError($"Error while trying to save game values when disconnecting as host: {arg}");
		}
	}

	private void SaveItemsInShip()
	{
		GrabbableObject[] array = UnityEngine.Object.FindObjectsByType<GrabbableObject>(FindObjectsInactive.Exclude, FindObjectsSortMode.None);
		if (array == null || array.Length == 0)
		{
			ES3.DeleteKey("shipGrabbableItemIDs", currentSaveFileName);
			ES3.DeleteKey("shipGrabbableItemPos", currentSaveFileName);
			ES3.DeleteKey("shipScrapValues", currentSaveFileName);
			return;
		}
		List<int> list = new List<int>();
		List<Vector3> list2 = new List<Vector3>();
		List<int> list3 = new List<int>();
		for (int i = 0; i < array.Length && i <= StartOfRound.Instance.maxShipItemCapacity; i++)
		{
			if (!StartOfRound.Instance.allItemsList.itemsList.Contains(array[i].itemProperties))
			{
				continue;
			}
			if (array[i].itemProperties.spawnPrefab == null)
			{
				Debug.LogError("Item '" + array[i].itemProperties.itemName + "' has no spawn prefab set!");
			}
			else
			{
				if (array[i].itemUsedUp)
				{
					continue;
				}
				for (int j = 0; j < StartOfRound.Instance.allItemsList.itemsList.Count; j++)
				{
					if (StartOfRound.Instance.allItemsList.itemsList[j] == array[i].itemProperties)
					{
						list.Add(j);
						list2.Add(array[i].transform.position);
						break;
					}
				}
				if (array[i].itemProperties.isScrap)
				{
					list3.Add(array[i].scrapValue);
				}
			}
		}
		if (list.Count <= 0)
		{
			Debug.Log("Got no ship grabbable items to save.");
			return;
		}
		ES3.Save("shipGrabbableItemPos", list2.ToArray(), currentSaveFileName);
		ES3.Save("shipGrabbableItemIDs", list.ToArray(), currentSaveFileName);
		if (list3.Count > 0)
		{
			ES3.Save("shipScrapValues", list3.ToArray(), currentSaveFileName);
		}
	}

	private void ConvertUnsellableItemsToCredits()
	{
		if (!StartOfRound.Instance.inShipPhase)
		{
			Debug.Log("Players disconnected, but they were not in ship phase so they can't be reimbursed for their items.");
			ES3.Save("Reimburse", 0, currentSaveFileName);
			return;
		}
		int num = 0;
		GrabbableObject[] array = UnityEngine.Object.FindObjectsOfType<GrabbableObject>();
		for (int i = 0; i < array.Length; i++)
		{
			if (!array[i].itemProperties.isScrap && !array[i].itemUsedUp)
			{
				num += array[i].itemProperties.creditsWorth;
			}
		}
		Terminal terminal = UnityEngine.Object.FindObjectOfType<Terminal>();
		for (int j = 0; j < terminal.orderedItemsFromTerminal.Count; j++)
		{
			num += terminal.buyableItemsList[terminal.orderedItemsFromTerminal[j]].creditsWorth;
		}
		ES3.Save("Reimburse", num, currentSaveFileName);
	}

	private void SetInstanceValuesBackToDefault()
	{
		isDisconnecting = false;
		disallowConnection = false;
		connectedPlayers = 0;
		localPlayerController = null;
		gameHasStarted = false;
		if (SoundManager.Instance != null)
		{
			SoundManager.Instance.ResetValues();
		}
		if (hasSubscribedToConnectionCallbacks && NetworkManager.Singleton != null)
		{
			NetworkManager.Singleton.OnClientConnectedCallback -= Singleton_OnClientConnectedCallback;
			NetworkManager.Singleton.OnClientDisconnectCallback -= Singleton_OnClientDisconnectCallback;
			hasSubscribedToConnectionCallbacks = false;
		}
	}

	public void InviteFriendsUI()
	{
		SteamFriends.OpenGameInviteOverlay(Instance.currentLobby.Value.Id);
	}

	public async void StartHost()
	{
		if (!UnityEngine.Object.FindObjectOfType<MenuManager>())
		{
			Debug.Log("Menu manager script is not present in scene; unable to start host");
			return;
		}
		if (Instance.currentLobby.HasValue)
		{
			Debug.Log("Tried starting host but currentLobby is not null! This should not happen. Leaving currentLobby and setting null.");
			LeaveCurrentSteamLobby();
		}
		if (!disableSteam)
		{
			GameNetworkManager instance = Instance;
			instance.currentLobby = await SteamMatchmaking.CreateLobbyAsync(4);
		}
		UnityEngine.Object.FindObjectOfType<MenuManager>().StartHosting();
		SubscribeToConnectionCallbacks();
		isHostingGame = true;
		connectedPlayers = 1;
	}

	public async void JoinLobby(Lobby lobby, SteamId id)
	{
		Debug.Log($"lobby.id: {lobby.Id}");
		Debug.Log($"id: {id}");
		if (UnityEngine.Object.FindObjectOfType<MenuManager>() == null)
		{
			return;
		}
		if (!Instance.currentLobby.HasValue)
		{
			Instance.currentLobby = lobby;
			steamLobbyName = lobby.GetData("name");
			if (await lobby.Join() == RoomEnter.Success)
			{
				Debug.Log("Successfully joined steam lobby.");
				Debug.Log($"AA {Instance.currentLobby.Value.Id}");
				Debug.Log($"BB {id}");
				Instance.StartClient(lobby.Owner.Id);
			}
			else
			{
				Debug.Log("Failed to join steam lobby.");
				LeaveCurrentSteamLobby();
				steamLobbyName = SteamClient.Name;
				UnityEngine.Object.FindObjectOfType<MenuManager>().SetLoadingScreen(isLoading: false, RoomEnter.Error, "The host has not loaded or has already landed their ship.");
			}
		}
		else
		{
			Debug.Log("Lobby error!: Attempted to join, but we are already in a Steam lobby. We should not be in a lobby while in the menu!");
			LeaveCurrentSteamLobby();
		}
	}

	public void LeaveCurrentSteamLobby()
	{
		try
		{
			if (Instance.currentLobby.HasValue)
			{
				Instance.currentLobby.Value.Leave();
				Instance.currentLobby = null;
			}
		}
		catch (Exception arg)
		{
			Debug.Log($"Error caught while attempting to leave current lobby!: {arg}");
		}
	}

	public void SetConnectionDataBeforeConnecting()
	{
	}

	public void StartClient(SteamId id)
	{
		Debug.Log($"CC {id}");
		transport.targetSteamId = id;
		SetConnectionDataBeforeConnecting();
		if (NetworkManager.Singleton.StartClient())
		{
			Debug.Log("started client!");
			SubscribeToConnectionCallbacks();
			UnityEngine.Object.FindObjectOfType<MenuManager>().SetLoadingScreen(isLoading: true);
			return;
		}
		Debug.Log("Joined steam lobby successfully, but connection failed");
		UnityEngine.Object.FindObjectOfType<MenuManager>().SetLoadingScreen(isLoading: false);
		if (Instance.currentLobby.HasValue)
		{
			Debug.Log("Leaving steam lobby");
			Instance.currentLobby.Value.Leave();
			Instance.currentLobby = null;
			steamLobbyName = SteamClient.Name;
		}
		SetInstanceValuesBackToDefault();
	}

	private IEnumerator delayStartClient()
	{
		yield return new WaitForSeconds(1f);
		if (NetworkManager.Singleton.StartClient())
		{
			Debug.Log("started client!");
			Debug.Log($"Are we connected client: {NetworkManager.Singleton.IsConnectedClient}");
			if (NetworkManager.Singleton != null)
			{
				Debug.Log("NetworkManager is not null");
			}
			Debug.Log($"Are we connected client: {NetworkManager.Singleton.IsConnectedClient}");
			Debug.Log($"Are we host: {NetworkManager.Singleton.IsHost}");
			yield return null;
			if (NetworkManager.Singleton != null)
			{
				Debug.Log("NetworkManager is not null");
			}
			Debug.Log($"is networkmanager listening: {NetworkManager.Singleton.IsListening}");
			Debug.Log("connected host name: " + NetworkManager.Singleton.ConnectedHostname);
		}
	}
}