using System;
using System.Collections.Generic;
using UnityEngine.Networking.Match;
using UnityEngine.Networking.NetworkSystem;
using UnityEngine.Networking.Types;

namespace UnityEngine.Networking
{
	// Token: 0x0200004F RID: 79
	[AddComponentMenu("Network/NetworkMigrationManager")]
	public class NetworkMigrationManager : MonoBehaviour
	{
		// Token: 0x0600033A RID: 826 RVA: 0x00012178 File Offset: 0x00010378
		private void AddPendingPlayer(GameObject obj, int connectionId, NetworkInstanceId netId, short playerControllerId)
		{
			if (!this.m_PendingPlayers.ContainsKey(connectionId))
			{
				NetworkMigrationManager.ConnectionPendingPlayers connectionPendingPlayers = default(NetworkMigrationManager.ConnectionPendingPlayers);
				connectionPendingPlayers.players = new List<NetworkMigrationManager.PendingPlayerInfo>();
				this.m_PendingPlayers[connectionId] = connectionPendingPlayers;
			}
			NetworkMigrationManager.PendingPlayerInfo pendingPlayerInfo = default(NetworkMigrationManager.PendingPlayerInfo);
			pendingPlayerInfo.netId = netId;
			pendingPlayerInfo.playerControllerId = playerControllerId;
			pendingPlayerInfo.obj = obj;
			this.m_PendingPlayers[connectionId].players.Add(pendingPlayerInfo);
		}

		// Token: 0x0600033B RID: 827 RVA: 0x000121F8 File Offset: 0x000103F8
		private GameObject FindPendingPlayer(int connectionId, NetworkInstanceId netId, short playerControllerId)
		{
			if (this.m_PendingPlayers.ContainsKey(connectionId))
			{
				for (int i = 0; i < this.m_PendingPlayers[connectionId].players.Count; i++)
				{
					NetworkMigrationManager.PendingPlayerInfo pendingPlayerInfo = this.m_PendingPlayers[connectionId].players[i];
					if (pendingPlayerInfo.netId == netId && pendingPlayerInfo.playerControllerId == playerControllerId)
					{
						return pendingPlayerInfo.obj;
					}
				}
			}
			return null;
		}

		// Token: 0x0600033C RID: 828 RVA: 0x00012296 File Offset: 0x00010496
		private void RemovePendingPlayer(int connectionId)
		{
			this.m_PendingPlayers.Remove(connectionId);
		}

		// Token: 0x1700008A RID: 138
		// (get) Token: 0x0600033D RID: 829 RVA: 0x000122A8 File Offset: 0x000104A8
		// (set) Token: 0x0600033E RID: 830 RVA: 0x000122C3 File Offset: 0x000104C3
		public bool hostMigration
		{
			get
			{
				return this.m_HostMigration;
			}
			set
			{
				this.m_HostMigration = value;
			}
		}

		// Token: 0x1700008B RID: 139
		// (get) Token: 0x0600033F RID: 831 RVA: 0x000122D0 File Offset: 0x000104D0
		// (set) Token: 0x06000340 RID: 832 RVA: 0x000122EB File Offset: 0x000104EB
		public bool showGUI
		{
			get
			{
				return this.m_ShowGUI;
			}
			set
			{
				this.m_ShowGUI = value;
			}
		}

		// Token: 0x1700008C RID: 140
		// (get) Token: 0x06000341 RID: 833 RVA: 0x000122F8 File Offset: 0x000104F8
		// (set) Token: 0x06000342 RID: 834 RVA: 0x00012313 File Offset: 0x00010513
		public int offsetX
		{
			get
			{
				return this.m_OffsetX;
			}
			set
			{
				this.m_OffsetX = value;
			}
		}

		// Token: 0x1700008D RID: 141
		// (get) Token: 0x06000343 RID: 835 RVA: 0x00012320 File Offset: 0x00010520
		// (set) Token: 0x06000344 RID: 836 RVA: 0x0001233B File Offset: 0x0001053B
		public int offsetY
		{
			get
			{
				return this.m_OffsetY;
			}
			set
			{
				this.m_OffsetY = value;
			}
		}

		// Token: 0x1700008E RID: 142
		// (get) Token: 0x06000345 RID: 837 RVA: 0x00012348 File Offset: 0x00010548
		public NetworkClient client
		{
			get
			{
				return this.m_Client;
			}
		}

		// Token: 0x1700008F RID: 143
		// (get) Token: 0x06000346 RID: 838 RVA: 0x00012364 File Offset: 0x00010564
		// (set) Token: 0x06000347 RID: 839 RVA: 0x0001237F File Offset: 0x0001057F
		public bool waitingToBecomeNewHost
		{
			get
			{
				return this.m_WaitingToBecomeNewHost;
			}
			set
			{
				this.m_WaitingToBecomeNewHost = value;
			}
		}

		// Token: 0x17000090 RID: 144
		// (get) Token: 0x06000348 RID: 840 RVA: 0x0001238C File Offset: 0x0001058C
		// (set) Token: 0x06000349 RID: 841 RVA: 0x000123A7 File Offset: 0x000105A7
		public bool waitingReconnectToNewHost
		{
			get
			{
				return this.m_WaitingReconnectToNewHost;
			}
			set
			{
				this.m_WaitingReconnectToNewHost = value;
			}
		}

		// Token: 0x17000091 RID: 145
		// (get) Token: 0x0600034A RID: 842 RVA: 0x000123B4 File Offset: 0x000105B4
		public bool disconnectedFromHost
		{
			get
			{
				return this.m_DisconnectedFromHost;
			}
		}

		// Token: 0x17000092 RID: 146
		// (get) Token: 0x0600034B RID: 843 RVA: 0x000123D0 File Offset: 0x000105D0
		public bool hostWasShutdown
		{
			get
			{
				return this.m_HostWasShutdown;
			}
		}

		// Token: 0x17000093 RID: 147
		// (get) Token: 0x0600034C RID: 844 RVA: 0x000123EC File Offset: 0x000105EC
		public MatchInfo matchInfo
		{
			get
			{
				return this.m_MatchInfo;
			}
		}

		// Token: 0x17000094 RID: 148
		// (get) Token: 0x0600034D RID: 845 RVA: 0x00012408 File Offset: 0x00010608
		public int oldServerConnectionId
		{
			get
			{
				return this.m_OldServerConnectionId;
			}
		}

		// Token: 0x17000095 RID: 149
		// (get) Token: 0x0600034E RID: 846 RVA: 0x00012424 File Offset: 0x00010624
		// (set) Token: 0x0600034F RID: 847 RVA: 0x0001243F File Offset: 0x0001063F
		public string newHostAddress
		{
			get
			{
				return this.m_NewHostAddress;
			}
			set
			{
				this.m_NewHostAddress = value;
			}
		}

		// Token: 0x17000096 RID: 150
		// (get) Token: 0x06000350 RID: 848 RVA: 0x0001244C File Offset: 0x0001064C
		public PeerInfoMessage[] peers
		{
			get
			{
				return this.m_Peers;
			}
		}

		// Token: 0x17000097 RID: 151
		// (get) Token: 0x06000351 RID: 849 RVA: 0x00012468 File Offset: 0x00010668
		public Dictionary<int, NetworkMigrationManager.ConnectionPendingPlayers> pendingPlayers
		{
			get
			{
				return this.m_PendingPlayers;
			}
		}

		// Token: 0x06000352 RID: 850 RVA: 0x00012483 File Offset: 0x00010683
		private void Start()
		{
			this.Reset(-1);
		}

		// Token: 0x06000353 RID: 851 RVA: 0x00012490 File Offset: 0x00010690
		public void Reset(int reconnectId)
		{
			this.m_OldServerConnectionId = -1;
			this.m_WaitingToBecomeNewHost = false;
			this.m_WaitingReconnectToNewHost = false;
			this.m_DisconnectedFromHost = false;
			this.m_HostWasShutdown = false;
			ClientScene.SetReconnectId(reconnectId, this.m_Peers);
			if (NetworkManager.singleton != null)
			{
				NetworkManager.singleton.SetupMigrationManager(this);
			}
		}

		// Token: 0x06000354 RID: 852 RVA: 0x000124EC File Offset: 0x000106EC
		internal void AssignAuthorityCallback(NetworkConnection conn, NetworkIdentity uv, bool authorityState)
		{
			PeerAuthorityMessage peerAuthorityMessage = new PeerAuthorityMessage();
			peerAuthorityMessage.connectionId = conn.connectionId;
			peerAuthorityMessage.netId = uv.netId;
			peerAuthorityMessage.authorityState = authorityState;
			if (LogFilter.logDebug)
			{
				Debug.Log("AssignAuthorityCallback send for netId" + uv.netId);
			}
			for (int i = 0; i < NetworkServer.connections.Count; i++)
			{
				NetworkConnection networkConnection = NetworkServer.connections[i];
				if (networkConnection != null)
				{
					networkConnection.Send(18, peerAuthorityMessage);
				}
			}
		}

		// Token: 0x06000355 RID: 853 RVA: 0x00012580 File Offset: 0x00010780
		public void Initialize(NetworkClient newClient, MatchInfo newMatchInfo)
		{
			if (LogFilter.logDev)
			{
				Debug.Log("NetworkMigrationManager initialize");
			}
			this.m_Client = newClient;
			this.m_MatchInfo = newMatchInfo;
			newClient.RegisterHandlerSafe(11, new NetworkMessageDelegate(this.OnPeerInfo));
			newClient.RegisterHandlerSafe(18, new NetworkMessageDelegate(this.OnPeerClientAuthority));
			NetworkIdentity.clientAuthorityCallback = new NetworkIdentity.ClientAuthorityCallback(this.AssignAuthorityCallback);
		}

		// Token: 0x06000356 RID: 854 RVA: 0x000125EC File Offset: 0x000107EC
		public void DisablePlayerObjects()
		{
			if (LogFilter.logDev)
			{
				Debug.Log("NetworkMigrationManager DisablePlayerObjects");
			}
			if (this.m_Peers != null)
			{
				for (int i = 0; i < this.m_Peers.Length; i++)
				{
					PeerInfoMessage peerInfoMessage = this.m_Peers[i];
					if (peerInfoMessage.playerIds != null)
					{
						for (int j = 0; j < peerInfoMessage.playerIds.Length; j++)
						{
							PeerInfoPlayer peerInfoPlayer = peerInfoMessage.playerIds[j];
							if (LogFilter.logDev)
							{
								Debug.Log(string.Concat(new object[] { "DisablePlayerObjects disable player for ", peerInfoMessage.address, " netId:", peerInfoPlayer.netId, " control:", peerInfoPlayer.playerControllerId }));
							}
							GameObject gameObject = ClientScene.FindLocalObject(peerInfoPlayer.netId);
							if (gameObject != null)
							{
								gameObject.SetActive(false);
								this.AddPendingPlayer(gameObject, peerInfoMessage.connectionId, peerInfoPlayer.netId, peerInfoPlayer.playerControllerId);
							}
							else if (LogFilter.logWarn)
							{
								Debug.LogWarning(string.Concat(new object[] { "DisablePlayerObjects didnt find player Conn:", peerInfoMessage.connectionId, " NetId:", peerInfoPlayer.netId }));
							}
						}
					}
				}
			}
		}

		// Token: 0x06000357 RID: 855 RVA: 0x0001276C File Offset: 0x0001096C
		public void SendPeerInfo()
		{
			if (this.m_HostMigration)
			{
				PeerListMessage peerListMessage = new PeerListMessage();
				List<PeerInfoMessage> list = new List<PeerInfoMessage>();
				for (int i = 0; i < NetworkServer.connections.Count; i++)
				{
					NetworkConnection networkConnection = NetworkServer.connections[i];
					if (networkConnection != null)
					{
						PeerInfoMessage peerInfoMessage = new PeerInfoMessage();
						string text;
						int num;
						NetworkID networkID;
						NodeID nodeID;
						byte b;
						NetworkTransport.GetConnectionInfo(NetworkServer.serverHostId, networkConnection.connectionId, out text, out num, out networkID, out nodeID, out b);
						peerInfoMessage.connectionId = networkConnection.connectionId;
						peerInfoMessage.port = num;
						if (i == 0)
						{
							peerInfoMessage.port = NetworkServer.listenPort;
							peerInfoMessage.isHost = true;
							peerInfoMessage.address = "<host>";
						}
						else
						{
							peerInfoMessage.address = text;
							peerInfoMessage.isHost = false;
						}
						List<PeerInfoPlayer> list2 = new List<PeerInfoPlayer>();
						for (int j = 0; j < networkConnection.playerControllers.Count; j++)
						{
							PlayerController playerController = networkConnection.playerControllers[j];
							if (playerController != null && playerController.unetView != null)
							{
								PeerInfoPlayer peerInfoPlayer;
								peerInfoPlayer.netId = playerController.unetView.netId;
								peerInfoPlayer.playerControllerId = playerController.unetView.playerControllerId;
								list2.Add(peerInfoPlayer);
							}
						}
						if (networkConnection.clientOwnedObjects != null)
						{
							foreach (NetworkInstanceId networkInstanceId in networkConnection.clientOwnedObjects)
							{
								GameObject gameObject = NetworkServer.FindLocalObject(networkInstanceId);
								if (!(gameObject == null))
								{
									NetworkIdentity component = gameObject.GetComponent<NetworkIdentity>();
									if (component.playerControllerId == -1)
									{
										PeerInfoPlayer peerInfoPlayer2;
										peerInfoPlayer2.netId = networkInstanceId;
										peerInfoPlayer2.playerControllerId = -1;
										list2.Add(peerInfoPlayer2);
									}
								}
							}
						}
						if (list2.Count > 0)
						{
							peerInfoMessage.playerIds = list2.ToArray();
						}
						list.Add(peerInfoMessage);
					}
				}
				peerListMessage.peers = list.ToArray();
				for (int k = 0; k < NetworkServer.connections.Count; k++)
				{
					NetworkConnection networkConnection2 = NetworkServer.connections[k];
					if (networkConnection2 != null)
					{
						peerListMessage.oldServerConnectionId = networkConnection2.connectionId;
						networkConnection2.Send(11, peerListMessage);
					}
				}
			}
		}

		// Token: 0x06000358 RID: 856 RVA: 0x000129EC File Offset: 0x00010BEC
		private void OnPeerClientAuthority(NetworkMessage netMsg)
		{
			PeerAuthorityMessage peerAuthorityMessage = netMsg.ReadMessage<PeerAuthorityMessage>();
			if (LogFilter.logDebug)
			{
				Debug.Log("OnPeerClientAuthority for netId:" + peerAuthorityMessage.netId);
			}
			if (this.m_Peers != null)
			{
				for (int i = 0; i < this.m_Peers.Length; i++)
				{
					PeerInfoMessage peerInfoMessage = this.m_Peers[i];
					if (peerInfoMessage.connectionId == peerAuthorityMessage.connectionId)
					{
						if (peerInfoMessage.playerIds == null)
						{
							peerInfoMessage.playerIds = new PeerInfoPlayer[0];
						}
						if (peerAuthorityMessage.authorityState)
						{
							for (int j = 0; j < peerInfoMessage.playerIds.Length; j++)
							{
								if (peerInfoMessage.playerIds[j].netId == peerAuthorityMessage.netId)
								{
									return;
								}
							}
							PeerInfoPlayer peerInfoPlayer = default(PeerInfoPlayer);
							peerInfoPlayer.netId = peerAuthorityMessage.netId;
							peerInfoPlayer.playerControllerId = -1;
							peerInfoMessage.playerIds = new List<PeerInfoPlayer>(peerInfoMessage.playerIds) { peerInfoPlayer }.ToArray();
						}
						else
						{
							for (int k = 0; k < peerInfoMessage.playerIds.Length; k++)
							{
								if (peerInfoMessage.playerIds[k].netId == peerAuthorityMessage.netId)
								{
									List<PeerInfoPlayer> list = new List<PeerInfoPlayer>(peerInfoMessage.playerIds);
									list.RemoveAt(k);
									peerInfoMessage.playerIds = list.ToArray();
									break;
								}
							}
						}
					}
				}
				GameObject gameObject = ClientScene.FindLocalObject(peerAuthorityMessage.netId);
				this.OnAuthorityUpdated(gameObject, peerAuthorityMessage.connectionId, peerAuthorityMessage.authorityState);
			}
		}

		// Token: 0x06000359 RID: 857 RVA: 0x00012BAC File Offset: 0x00010DAC
		private void OnPeerInfo(NetworkMessage netMsg)
		{
			if (LogFilter.logDebug)
			{
				Debug.Log("OnPeerInfo");
			}
			netMsg.ReadMessage<PeerListMessage>(this.m_PeerListMessage);
			this.m_Peers = this.m_PeerListMessage.peers;
			this.m_OldServerConnectionId = this.m_PeerListMessage.oldServerConnectionId;
			for (int i = 0; i < this.m_Peers.Length; i++)
			{
				if (LogFilter.logDebug)
				{
					Debug.Log(string.Concat(new object[]
					{
						"peer conn ",
						this.m_Peers[i].connectionId,
						" your conn ",
						this.m_PeerListMessage.oldServerConnectionId
					}));
				}
				if (this.m_Peers[i].connectionId == this.m_PeerListMessage.oldServerConnectionId)
				{
					this.m_Peers[i].isYou = true;
					break;
				}
			}
			this.OnPeersUpdated(this.m_PeerListMessage);
		}

		// Token: 0x0600035A RID: 858 RVA: 0x00012CAC File Offset: 0x00010EAC
		private void OnServerReconnectPlayerMessage(NetworkMessage netMsg)
		{
			ReconnectMessage reconnectMessage = netMsg.ReadMessage<ReconnectMessage>();
			if (LogFilter.logDev)
			{
				Debug.Log(string.Concat(new object[] { "OnReconnectMessage: connId=", reconnectMessage.oldConnectionId, " playerControllerId:", reconnectMessage.playerControllerId, " netId:", reconnectMessage.netId }));
			}
			GameObject gameObject = this.FindPendingPlayer(reconnectMessage.oldConnectionId, reconnectMessage.netId, reconnectMessage.playerControllerId);
			if (gameObject == null)
			{
				if (LogFilter.logError)
				{
					Debug.LogError(string.Concat(new object[] { "OnReconnectMessage connId=", reconnectMessage.oldConnectionId, " player null for netId:", reconnectMessage.netId, " msg.playerControllerId:", reconnectMessage.playerControllerId }));
				}
			}
			else if (gameObject.activeSelf)
			{
				if (LogFilter.logError)
				{
					Debug.LogError("OnReconnectMessage connId=" + reconnectMessage.oldConnectionId + " player already active?");
				}
			}
			else
			{
				if (LogFilter.logDebug)
				{
					Debug.Log("OnReconnectMessage: player=" + gameObject);
				}
				NetworkReader networkReader = null;
				if (reconnectMessage.msgSize != 0)
				{
					networkReader = new NetworkReader(reconnectMessage.msgData);
				}
				if (reconnectMessage.playerControllerId != -1)
				{
					if (networkReader == null)
					{
						this.OnServerReconnectPlayer(netMsg.conn, gameObject, reconnectMessage.oldConnectionId, reconnectMessage.playerControllerId);
					}
					else
					{
						this.OnServerReconnectPlayer(netMsg.conn, gameObject, reconnectMessage.oldConnectionId, reconnectMessage.playerControllerId, networkReader);
					}
				}
				else
				{
					this.OnServerReconnectObject(netMsg.conn, gameObject, reconnectMessage.oldConnectionId);
				}
			}
		}

		// Token: 0x0600035B RID: 859 RVA: 0x00012E88 File Offset: 0x00011088
		public bool ReconnectObjectForConnection(NetworkConnection newConnection, GameObject oldObject, int oldConnectionId)
		{
			bool flag;
			if (!NetworkServer.active)
			{
				if (LogFilter.logError)
				{
					Debug.LogError("ReconnectObjectForConnection must have active server");
				}
				flag = false;
			}
			else
			{
				if (LogFilter.logDebug)
				{
					Debug.Log(string.Concat(new object[] { "ReconnectObjectForConnection: oldConnId=", oldConnectionId, " obj=", oldObject, " conn:", newConnection }));
				}
				if (!this.m_PendingPlayers.ContainsKey(oldConnectionId))
				{
					if (LogFilter.logError)
					{
						Debug.LogError("ReconnectObjectForConnection oldConnId=" + oldConnectionId + " not found.");
					}
					flag = false;
				}
				else
				{
					oldObject.SetActive(true);
					oldObject.GetComponent<NetworkIdentity>().SetNetworkInstanceId(new NetworkInstanceId(0U));
					if (!NetworkServer.SpawnWithClientAuthority(oldObject, newConnection))
					{
						if (LogFilter.logError)
						{
							Debug.LogError("ReconnectObjectForConnection oldConnId=" + oldConnectionId + " SpawnWithClientAuthority failed.");
						}
						flag = false;
					}
					else
					{
						flag = true;
					}
				}
			}
			return flag;
		}

		// Token: 0x0600035C RID: 860 RVA: 0x00012F9C File Offset: 0x0001119C
		public bool ReconnectPlayerForConnection(NetworkConnection newConnection, GameObject oldPlayer, int oldConnectionId, short playerControllerId)
		{
			bool flag;
			if (!NetworkServer.active)
			{
				if (LogFilter.logError)
				{
					Debug.LogError("ReconnectPlayerForConnection must have active server");
				}
				flag = false;
			}
			else
			{
				if (LogFilter.logDebug)
				{
					Debug.Log(string.Concat(new object[] { "ReconnectPlayerForConnection: oldConnId=", oldConnectionId, " player=", oldPlayer, " conn:", newConnection }));
				}
				if (!this.m_PendingPlayers.ContainsKey(oldConnectionId))
				{
					if (LogFilter.logError)
					{
						Debug.LogError("ReconnectPlayerForConnection oldConnId=" + oldConnectionId + " not found.");
					}
					flag = false;
				}
				else
				{
					oldPlayer.SetActive(true);
					NetworkServer.Spawn(oldPlayer);
					if (!NetworkServer.AddPlayerForConnection(newConnection, oldPlayer, playerControllerId))
					{
						if (LogFilter.logError)
						{
							Debug.LogError("ReconnectPlayerForConnection oldConnId=" + oldConnectionId + " AddPlayerForConnection failed.");
						}
						flag = false;
					}
					else
					{
						if (NetworkServer.localClientActive)
						{
							this.SendPeerInfo();
						}
						flag = true;
					}
				}
			}
			return flag;
		}

		// Token: 0x0600035D RID: 861 RVA: 0x000130BC File Offset: 0x000112BC
		public bool LostHostOnClient(NetworkConnection conn)
		{
			if (LogFilter.logDebug)
			{
				Debug.Log("NetworkMigrationManager client OnDisconnectedFromHost");
			}
			bool flag;
			if (Application.platform == RuntimePlatform.WebGLPlayer)
			{
				if (LogFilter.logError)
				{
					Debug.LogError("LostHostOnClient: Host migration not supported on WebGL");
				}
				flag = false;
			}
			else if (this.m_Client == null)
			{
				if (LogFilter.logError)
				{
					Debug.LogError("NetworkMigrationManager LostHostOnHost client was never initialized.");
				}
				flag = false;
			}
			else if (!this.m_HostMigration)
			{
				if (LogFilter.logError)
				{
					Debug.LogError("NetworkMigrationManager LostHostOnHost migration not enabled.");
				}
				flag = false;
			}
			else
			{
				this.m_DisconnectedFromHost = true;
				this.DisablePlayerObjects();
				byte b;
				NetworkTransport.Disconnect(this.m_Client.hostId, this.m_Client.connection.connectionId, out b);
				if (this.m_OldServerConnectionId != -1)
				{
					NetworkMigrationManager.SceneChangeOption sceneChangeOption;
					this.OnClientDisconnectedFromHost(conn, out sceneChangeOption);
					flag = sceneChangeOption == NetworkMigrationManager.SceneChangeOption.StayInOnlineScene;
				}
				else
				{
					flag = false;
				}
			}
			return flag;
		}

		// Token: 0x0600035E RID: 862 RVA: 0x000131B4 File Offset: 0x000113B4
		public void LostHostOnHost()
		{
			if (LogFilter.logDebug)
			{
				Debug.Log("NetworkMigrationManager LostHostOnHost");
			}
			if (Application.platform == RuntimePlatform.WebGLPlayer)
			{
				if (LogFilter.logError)
				{
					Debug.LogError("LostHostOnHost: Host migration not supported on WebGL");
				}
			}
			else
			{
				this.OnServerHostShutdown();
				if (this.m_Peers == null)
				{
					if (LogFilter.logError)
					{
						Debug.LogError("NetworkMigrationManager LostHostOnHost no peers");
					}
				}
				else if (this.m_Peers.Length != 1)
				{
					this.m_HostWasShutdown = true;
				}
			}
		}

		// Token: 0x0600035F RID: 863 RVA: 0x00013244 File Offset: 0x00011444
		public bool BecomeNewHost(int port)
		{
			if (LogFilter.logDebug)
			{
				Debug.Log("NetworkMigrationManager BecomeNewHost " + this.m_MatchInfo);
			}
			NetworkServer.RegisterHandler(47, new NetworkMessageDelegate(this.OnServerReconnectPlayerMessage));
			NetworkClient networkClient = NetworkServer.BecomeHost(this.m_Client, port, this.m_MatchInfo, this.oldServerConnectionId, this.peers);
			bool flag;
			if (networkClient != null)
			{
				if (NetworkManager.singleton != null)
				{
					NetworkManager.singleton.RegisterServerMessages();
					NetworkManager.singleton.UseExternalClient(networkClient);
				}
				else
				{
					Debug.LogWarning("MigrationManager BecomeNewHost - No NetworkManager.");
				}
				networkClient.RegisterHandlerSafe(11, new NetworkMessageDelegate(this.OnPeerInfo));
				this.RemovePendingPlayer(this.m_OldServerConnectionId);
				this.Reset(-1);
				this.SendPeerInfo();
				flag = true;
			}
			else
			{
				if (LogFilter.logError)
				{
					Debug.LogError("NetworkServer.BecomeHost failed");
				}
				flag = false;
			}
			return flag;
		}

		// Token: 0x06000360 RID: 864 RVA: 0x00013337 File Offset: 0x00011537
		protected virtual void OnClientDisconnectedFromHost(NetworkConnection conn, out NetworkMigrationManager.SceneChangeOption sceneChange)
		{
			sceneChange = NetworkMigrationManager.SceneChangeOption.StayInOnlineScene;
		}

		// Token: 0x06000361 RID: 865 RVA: 0x0001333D File Offset: 0x0001153D
		protected virtual void OnServerHostShutdown()
		{
		}

		// Token: 0x06000362 RID: 866 RVA: 0x00013340 File Offset: 0x00011540
		protected virtual void OnServerReconnectPlayer(NetworkConnection newConnection, GameObject oldPlayer, int oldConnectionId, short playerControllerId)
		{
			this.ReconnectPlayerForConnection(newConnection, oldPlayer, oldConnectionId, playerControllerId);
		}

		// Token: 0x06000363 RID: 867 RVA: 0x0001334F File Offset: 0x0001154F
		protected virtual void OnServerReconnectPlayer(NetworkConnection newConnection, GameObject oldPlayer, int oldConnectionId, short playerControllerId, NetworkReader extraMessageReader)
		{
			this.ReconnectPlayerForConnection(newConnection, oldPlayer, oldConnectionId, playerControllerId);
		}

		// Token: 0x06000364 RID: 868 RVA: 0x0001335E File Offset: 0x0001155E
		protected virtual void OnServerReconnectObject(NetworkConnection newConnection, GameObject oldObject, int oldConnectionId)
		{
			this.ReconnectObjectForConnection(newConnection, oldObject, oldConnectionId);
		}

		// Token: 0x06000365 RID: 869 RVA: 0x0001336B File Offset: 0x0001156B
		protected virtual void OnPeersUpdated(PeerListMessage peers)
		{
			if (LogFilter.logDev)
			{
				Debug.Log("NetworkMigrationManager NumPeers " + peers.peers.Length);
			}
		}

		// Token: 0x06000366 RID: 870 RVA: 0x00013398 File Offset: 0x00011598
		protected virtual void OnAuthorityUpdated(GameObject go, int connectionId, bool authorityState)
		{
			if (LogFilter.logDev)
			{
				Debug.Log(string.Concat(new object[] { "NetworkMigrationManager OnAuthorityUpdated for ", go, " conn:", connectionId, " state:", authorityState }));
			}
		}

		// Token: 0x06000367 RID: 871 RVA: 0x000133F0 File Offset: 0x000115F0
		public virtual bool FindNewHost(out PeerInfoMessage newHostInfo, out bool youAreNewHost)
		{
			bool flag;
			if (this.m_Peers == null)
			{
				if (LogFilter.logError)
				{
					Debug.LogError("NetworkMigrationManager FindLowestHost no peers");
				}
				newHostInfo = null;
				youAreNewHost = false;
				flag = false;
			}
			else
			{
				if (LogFilter.logDev)
				{
					Debug.Log("NetworkMigrationManager FindLowestHost");
				}
				newHostInfo = new PeerInfoMessage();
				newHostInfo.connectionId = 50000;
				newHostInfo.address = "";
				newHostInfo.port = 0;
				int num = -1;
				youAreNewHost = false;
				if (this.m_Peers == null)
				{
					flag = false;
				}
				else
				{
					for (int i = 0; i < this.m_Peers.Length; i++)
					{
						PeerInfoMessage peerInfoMessage = this.m_Peers[i];
						if (peerInfoMessage.connectionId != 0)
						{
							if (!peerInfoMessage.isHost)
							{
								if (peerInfoMessage.isYou)
								{
									num = peerInfoMessage.connectionId;
								}
								if (peerInfoMessage.connectionId < newHostInfo.connectionId)
								{
									newHostInfo = peerInfoMessage;
								}
							}
						}
					}
					if (newHostInfo.connectionId == 50000)
					{
						flag = false;
					}
					else
					{
						if (newHostInfo.connectionId == num)
						{
							youAreNewHost = true;
						}
						if (LogFilter.logDev)
						{
							Debug.Log("FindNewHost new host is " + newHostInfo.address);
						}
						flag = true;
					}
				}
			}
			return flag;
		}

		// Token: 0x06000368 RID: 872 RVA: 0x00013548 File Offset: 0x00011748
		private void OnGUIHost()
		{
			int num = this.m_OffsetY;
			GUI.Label(new Rect((float)this.m_OffsetX, (float)num, 200f, 40f), "Host Was Shutdown ID(" + this.m_OldServerConnectionId + ")");
			num += 25;
			if (Application.platform == RuntimePlatform.WebGLPlayer)
			{
				GUI.Label(new Rect((float)this.m_OffsetX, (float)num, 200f, 40f), "Host Migration not supported for WebGL");
			}
			else
			{
				if (this.m_WaitingReconnectToNewHost)
				{
					if (GUI.Button(new Rect((float)this.m_OffsetX, (float)num, 200f, 20f), "Reconnect as Client"))
					{
						this.Reset(0);
						if (NetworkManager.singleton != null)
						{
							NetworkManager.singleton.networkAddress = GUI.TextField(new Rect((float)(this.m_OffsetX + 100), (float)num, 95f, 20f), NetworkManager.singleton.networkAddress);
							NetworkManager.singleton.StartClient();
						}
						else
						{
							Debug.LogWarning("MigrationManager Old Host Reconnect - No NetworkManager.");
						}
					}
					num += 25;
				}
				else
				{
					if (GUI.Button(new Rect((float)this.m_OffsetX, (float)num, 200f, 20f), "Pick New Host"))
					{
						bool flag;
						if (this.FindNewHost(out this.m_NewHostInfo, out flag))
						{
							this.m_NewHostAddress = this.m_NewHostInfo.address;
							if (flag)
							{
								Debug.LogWarning("MigrationManager FindNewHost - new host is self?");
							}
							else
							{
								this.m_WaitingReconnectToNewHost = true;
							}
						}
					}
					num += 25;
				}
				if (GUI.Button(new Rect((float)this.m_OffsetX, (float)num, 200f, 20f), "Leave Game"))
				{
					if (NetworkManager.singleton != null)
					{
						NetworkManager.singleton.SetupMigrationManager(null);
						NetworkManager.singleton.StopHost();
					}
					else
					{
						Debug.LogWarning("MigrationManager Old Host LeaveGame - No NetworkManager.");
					}
					this.Reset(-1);
				}
				num += 25;
			}
		}

		// Token: 0x06000369 RID: 873 RVA: 0x0001375C File Offset: 0x0001195C
		private void OnGUIClient()
		{
			int num = this.m_OffsetY;
			GUI.Label(new Rect((float)this.m_OffsetX, (float)num, 200f, 40f), "Lost Connection To Host ID(" + this.m_OldServerConnectionId + ")");
			num += 25;
			if (Application.platform == RuntimePlatform.WebGLPlayer)
			{
				GUI.Label(new Rect((float)this.m_OffsetX, (float)num, 200f, 40f), "Host Migration not supported for WebGL");
			}
			else
			{
				if (this.m_WaitingToBecomeNewHost)
				{
					GUI.Label(new Rect((float)this.m_OffsetX, (float)num, 200f, 40f), "You are the new host");
					num += 25;
					if (GUI.Button(new Rect((float)this.m_OffsetX, (float)num, 200f, 20f), "Start As Host"))
					{
						if (NetworkManager.singleton != null)
						{
							this.BecomeNewHost(NetworkManager.singleton.networkPort);
						}
						else
						{
							Debug.LogWarning("MigrationManager Client BecomeNewHost - No NetworkManager.");
						}
					}
					num += 25;
				}
				else if (this.m_WaitingReconnectToNewHost)
				{
					GUI.Label(new Rect((float)this.m_OffsetX, (float)num, 200f, 40f), "New host is " + this.m_NewHostAddress);
					num += 25;
					if (GUI.Button(new Rect((float)this.m_OffsetX, (float)num, 200f, 20f), "Reconnect To New Host"))
					{
						this.Reset(this.m_OldServerConnectionId);
						if (NetworkManager.singleton != null)
						{
							NetworkManager.singleton.networkAddress = this.m_NewHostAddress;
							NetworkManager.singleton.client.ReconnectToNewHost(this.m_NewHostAddress, NetworkManager.singleton.networkPort);
						}
						else
						{
							Debug.LogWarning("MigrationManager Client reconnect - No NetworkManager.");
						}
					}
					num += 25;
				}
				else
				{
					if (GUI.Button(new Rect((float)this.m_OffsetX, (float)num, 200f, 20f), "Pick New Host"))
					{
						bool flag;
						if (this.FindNewHost(out this.m_NewHostInfo, out flag))
						{
							this.m_NewHostAddress = this.m_NewHostInfo.address;
							if (flag)
							{
								this.m_WaitingToBecomeNewHost = true;
							}
							else
							{
								this.m_WaitingReconnectToNewHost = true;
							}
						}
					}
					num += 25;
				}
				if (GUI.Button(new Rect((float)this.m_OffsetX, (float)num, 200f, 20f), "Leave Game"))
				{
					if (NetworkManager.singleton != null)
					{
						NetworkManager.singleton.SetupMigrationManager(null);
						NetworkManager.singleton.StopHost();
					}
					else
					{
						Debug.LogWarning("MigrationManager Client LeaveGame - No NetworkManager.");
					}
					this.Reset(-1);
				}
				num += 25;
			}
		}

		// Token: 0x0600036A RID: 874 RVA: 0x00013A30 File Offset: 0x00011C30
		private void OnGUI()
		{
			if (this.m_ShowGUI)
			{
				if (this.m_HostWasShutdown)
				{
					this.OnGUIHost();
				}
				else if (this.m_DisconnectedFromHost && this.m_OldServerConnectionId != -1)
				{
					this.OnGUIClient();
				}
			}
		}

		// Token: 0x0400018F RID: 399
		[SerializeField]
		private bool m_HostMigration = true;

		// Token: 0x04000190 RID: 400
		[SerializeField]
		private bool m_ShowGUI = true;

		// Token: 0x04000191 RID: 401
		[SerializeField]
		private int m_OffsetX = 10;

		// Token: 0x04000192 RID: 402
		[SerializeField]
		private int m_OffsetY = 300;

		// Token: 0x04000193 RID: 403
		private NetworkClient m_Client;

		// Token: 0x04000194 RID: 404
		private bool m_WaitingToBecomeNewHost;

		// Token: 0x04000195 RID: 405
		private bool m_WaitingReconnectToNewHost;

		// Token: 0x04000196 RID: 406
		private bool m_DisconnectedFromHost;

		// Token: 0x04000197 RID: 407
		private bool m_HostWasShutdown;

		// Token: 0x04000198 RID: 408
		private MatchInfo m_MatchInfo;

		// Token: 0x04000199 RID: 409
		private int m_OldServerConnectionId = -1;

		// Token: 0x0400019A RID: 410
		private string m_NewHostAddress;

		// Token: 0x0400019B RID: 411
		private PeerInfoMessage m_NewHostInfo = new PeerInfoMessage();

		// Token: 0x0400019C RID: 412
		private PeerListMessage m_PeerListMessage = new PeerListMessage();

		// Token: 0x0400019D RID: 413
		private PeerInfoMessage[] m_Peers;

		// Token: 0x0400019E RID: 414
		private Dictionary<int, NetworkMigrationManager.ConnectionPendingPlayers> m_PendingPlayers = new Dictionary<int, NetworkMigrationManager.ConnectionPendingPlayers>();

		// Token: 0x02000050 RID: 80
		public enum SceneChangeOption
		{
			// Token: 0x040001A0 RID: 416
			StayInOnlineScene,
			// Token: 0x040001A1 RID: 417
			SwitchToOfflineScene
		}

		// Token: 0x02000051 RID: 81
		public struct PendingPlayerInfo
		{
			// Token: 0x040001A2 RID: 418
			public NetworkInstanceId netId;

			// Token: 0x040001A3 RID: 419
			public short playerControllerId;

			// Token: 0x040001A4 RID: 420
			public GameObject obj;
		}

		// Token: 0x02000052 RID: 82
		public struct ConnectionPendingPlayers
		{
			// Token: 0x040001A5 RID: 421
			public List<NetworkMigrationManager.PendingPlayerInfo> players;
		}
	}
}