using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using UnityEngine.Networking.Types;

namespace UnityEngine.Networking
{
	// Token: 0x0200005A RID: 90
	public class NetworkServerSimple
	{
		// Token: 0x0600043E RID: 1086 RVA: 0x0001897C File Offset: 0x00016B7C
		public NetworkServerSimple()
		{
			this.m_ConnectionsReadOnly = new ReadOnlyCollection<NetworkConnection>(this.m_Connections);
		}

		// Token: 0x170000AF RID: 175
		// (get) Token: 0x0600043F RID: 1087 RVA: 0x000189EC File Offset: 0x00016BEC
		// (set) Token: 0x06000440 RID: 1088 RVA: 0x00018A07 File Offset: 0x00016C07
		public int listenPort
		{
			get
			{
				return this.m_ListenPort;
			}
			set
			{
				this.m_ListenPort = value;
			}
		}

		// Token: 0x170000B0 RID: 176
		// (get) Token: 0x06000441 RID: 1089 RVA: 0x00018A14 File Offset: 0x00016C14
		// (set) Token: 0x06000442 RID: 1090 RVA: 0x00018A2F File Offset: 0x00016C2F
		public int serverHostId
		{
			get
			{
				return this.m_ServerHostId;
			}
			set
			{
				this.m_ServerHostId = value;
			}
		}

		// Token: 0x170000B1 RID: 177
		// (get) Token: 0x06000443 RID: 1091 RVA: 0x00018A3C File Offset: 0x00016C3C
		public HostTopology hostTopology
		{
			get
			{
				return this.m_HostTopology;
			}
		}

		// Token: 0x170000B2 RID: 178
		// (get) Token: 0x06000444 RID: 1092 RVA: 0x00018A58 File Offset: 0x00016C58
		// (set) Token: 0x06000445 RID: 1093 RVA: 0x00018A73 File Offset: 0x00016C73
		public bool useWebSockets
		{
			get
			{
				return this.m_UseWebSockets;
			}
			set
			{
				this.m_UseWebSockets = value;
			}
		}

		// Token: 0x170000B3 RID: 179
		// (get) Token: 0x06000446 RID: 1094 RVA: 0x00018A80 File Offset: 0x00016C80
		public ReadOnlyCollection<NetworkConnection> connections
		{
			get
			{
				return this.m_ConnectionsReadOnly;
			}
		}

		// Token: 0x170000B4 RID: 180
		// (get) Token: 0x06000447 RID: 1095 RVA: 0x00018A9C File Offset: 0x00016C9C
		public Dictionary<short, NetworkMessageDelegate> handlers
		{
			get
			{
				return this.m_MessageHandlers.GetHandlers();
			}
		}

		// Token: 0x170000B5 RID: 181
		// (get) Token: 0x06000448 RID: 1096 RVA: 0x00018ABC File Offset: 0x00016CBC
		public byte[] messageBuffer
		{
			get
			{
				return this.m_MsgBuffer;
			}
		}

		// Token: 0x170000B6 RID: 182
		// (get) Token: 0x06000449 RID: 1097 RVA: 0x00018AD8 File Offset: 0x00016CD8
		public NetworkReader messageReader
		{
			get
			{
				return this.m_MsgReader;
			}
		}

		// Token: 0x170000B7 RID: 183
		// (get) Token: 0x0600044A RID: 1098 RVA: 0x00018AF4 File Offset: 0x00016CF4
		public Type networkConnectionClass
		{
			get
			{
				return this.m_NetworkConnectionClass;
			}
		}

		// Token: 0x0600044B RID: 1099 RVA: 0x00018B0F File Offset: 0x00016D0F
		public void SetNetworkConnectionClass<T>() where T : NetworkConnection
		{
			this.m_NetworkConnectionClass = typeof(T);
		}

		// Token: 0x0600044C RID: 1100 RVA: 0x00018B24 File Offset: 0x00016D24
		public virtual void Initialize()
		{
			if (!this.m_Initialized)
			{
				this.m_Initialized = true;
				NetworkTransport.Init();
				this.m_MsgBuffer = new byte[65535];
				this.m_MsgReader = new NetworkReader(this.m_MsgBuffer);
				if (this.m_HostTopology == null)
				{
					ConnectionConfig connectionConfig = new ConnectionConfig();
					connectionConfig.AddChannel(QosType.ReliableSequenced);
					connectionConfig.AddChannel(QosType.Unreliable);
					this.m_HostTopology = new HostTopology(connectionConfig, 8);
				}
				if (LogFilter.logDebug)
				{
					Debug.Log("NetworkServerSimple initialize.");
				}
			}
		}

		// Token: 0x0600044D RID: 1101 RVA: 0x00018BB8 File Offset: 0x00016DB8
		public bool Configure(ConnectionConfig config, int maxConnections)
		{
			HostTopology hostTopology = new HostTopology(config, maxConnections);
			return this.Configure(hostTopology);
		}

		// Token: 0x0600044E RID: 1102 RVA: 0x00018BDC File Offset: 0x00016DDC
		public bool Configure(HostTopology topology)
		{
			this.m_HostTopology = topology;
			return true;
		}

		// Token: 0x0600044F RID: 1103 RVA: 0x00018BFC File Offset: 0x00016DFC
		public bool Listen(string ipAddress, int serverListenPort)
		{
			this.Initialize();
			this.m_ListenPort = serverListenPort;
			if (this.m_UseWebSockets)
			{
				this.m_ServerHostId = NetworkTransport.AddWebsocketHost(this.m_HostTopology, serverListenPort, ipAddress);
			}
			else
			{
				this.m_ServerHostId = NetworkTransport.AddHost(this.m_HostTopology, serverListenPort, ipAddress);
			}
			bool flag;
			if (this.m_ServerHostId == -1)
			{
				flag = false;
			}
			else
			{
				if (LogFilter.logDebug)
				{
					Debug.Log(string.Concat(new object[] { "NetworkServerSimple listen: ", ipAddress, ":", this.m_ListenPort }));
				}
				flag = true;
			}
			return flag;
		}

		// Token: 0x06000450 RID: 1104 RVA: 0x00018CAC File Offset: 0x00016EAC
		public bool Listen(int serverListenPort)
		{
			return this.Listen(serverListenPort, this.m_HostTopology);
		}

		// Token: 0x06000451 RID: 1105 RVA: 0x00018CD0 File Offset: 0x00016ED0
		public bool Listen(int serverListenPort, HostTopology topology)
		{
			this.m_HostTopology = topology;
			this.Initialize();
			this.m_ListenPort = serverListenPort;
			if (this.m_UseWebSockets)
			{
				this.m_ServerHostId = NetworkTransport.AddWebsocketHost(this.m_HostTopology, serverListenPort);
			}
			else
			{
				this.m_ServerHostId = NetworkTransport.AddHost(this.m_HostTopology, serverListenPort);
			}
			bool flag;
			if (this.m_ServerHostId == -1)
			{
				flag = false;
			}
			else
			{
				if (LogFilter.logDebug)
				{
					Debug.Log("NetworkServerSimple listen " + this.m_ListenPort);
				}
				flag = true;
			}
			return flag;
		}

		// Token: 0x06000452 RID: 1106 RVA: 0x00018D6C File Offset: 0x00016F6C
		public void ListenRelay(string relayIp, int relayPort, NetworkID netGuid, SourceID sourceId, NodeID nodeId)
		{
			this.Initialize();
			this.m_ServerHostId = NetworkTransport.AddHost(this.m_HostTopology, this.listenPort);
			if (LogFilter.logDebug)
			{
				Debug.Log("Server Host Slot Id: " + this.m_ServerHostId);
			}
			this.Update();
			byte b;
			NetworkTransport.ConnectAsNetworkHost(this.m_ServerHostId, relayIp, relayPort, netGuid, sourceId, nodeId, out b);
			this.m_RelaySlotId = 0;
			if (LogFilter.logDebug)
			{
				Debug.Log("Relay Slot Id: " + this.m_RelaySlotId);
			}
		}

		// Token: 0x06000453 RID: 1107 RVA: 0x00018E04 File Offset: 0x00017004
		public void Stop()
		{
			if (LogFilter.logDebug)
			{
				Debug.Log("NetworkServerSimple stop ");
			}
			NetworkTransport.RemoveHost(this.m_ServerHostId);
			this.m_ServerHostId = -1;
		}

		// Token: 0x06000454 RID: 1108 RVA: 0x00018E30 File Offset: 0x00017030
		internal void RegisterHandlerSafe(short msgType, NetworkMessageDelegate handler)
		{
			this.m_MessageHandlers.RegisterHandlerSafe(msgType, handler);
		}

		// Token: 0x06000455 RID: 1109 RVA: 0x00018E40 File Offset: 0x00017040
		public void RegisterHandler(short msgType, NetworkMessageDelegate handler)
		{
			this.m_MessageHandlers.RegisterHandler(msgType, handler);
		}

		// Token: 0x06000456 RID: 1110 RVA: 0x00018E50 File Offset: 0x00017050
		public void UnregisterHandler(short msgType)
		{
			this.m_MessageHandlers.UnregisterHandler(msgType);
		}

		// Token: 0x06000457 RID: 1111 RVA: 0x00018E5F File Offset: 0x0001705F
		public void ClearHandlers()
		{
			this.m_MessageHandlers.ClearMessageHandlers();
		}

		// Token: 0x06000458 RID: 1112 RVA: 0x00018E70 File Offset: 0x00017070
		public void UpdateConnections()
		{
			for (int i = 0; i < this.m_Connections.Count; i++)
			{
				NetworkConnection networkConnection = this.m_Connections[i];
				if (networkConnection != null)
				{
					networkConnection.FlushChannels();
				}
			}
		}

		// Token: 0x06000459 RID: 1113 RVA: 0x00018EB8 File Offset: 0x000170B8
		public void Update()
		{
			if (this.m_ServerHostId != -1)
			{
				NetworkEventType networkEventType;
				if (this.m_RelaySlotId != -1)
				{
					byte b;
					networkEventType = NetworkTransport.ReceiveRelayEventFromHost(this.m_ServerHostId, out b);
					if (networkEventType != NetworkEventType.Nothing)
					{
						if (LogFilter.logDebug)
						{
							Debug.Log("NetGroup event:" + networkEventType);
						}
					}
					if (networkEventType == NetworkEventType.ConnectEvent)
					{
						if (LogFilter.logDebug)
						{
							Debug.Log("NetGroup server connected");
						}
					}
					if (networkEventType == NetworkEventType.DisconnectEvent)
					{
						if (LogFilter.logDebug)
						{
							Debug.Log("NetGroup server disconnected");
						}
					}
				}
				do
				{
					byte b;
					int num;
					int num2;
					int num3;
					networkEventType = NetworkTransport.ReceiveFromHost(this.m_ServerHostId, out num, out num2, this.m_MsgBuffer, this.m_MsgBuffer.Length, out num3, out b);
					if (networkEventType != NetworkEventType.Nothing)
					{
						if (LogFilter.logDev)
						{
							Debug.Log(string.Concat(new object[] { "Server event: host=", this.m_ServerHostId, " event=", networkEventType, " error=", b }));
						}
					}
					switch (networkEventType)
					{
					case NetworkEventType.DataEvent:
						this.HandleData(num, num2, num3, b);
						break;
					case NetworkEventType.ConnectEvent:
						this.HandleConnect(num, b);
						break;
					case NetworkEventType.DisconnectEvent:
						this.HandleDisconnect(num, b);
						break;
					case NetworkEventType.Nothing:
						break;
					default:
						if (LogFilter.logError)
						{
							Debug.LogError("Unknown network message type received: " + networkEventType);
						}
						break;
					}
				}
				while (networkEventType != NetworkEventType.Nothing);
				this.UpdateConnections();
			}
		}

		// Token: 0x0600045A RID: 1114 RVA: 0x0001906C File Offset: 0x0001726C
		public NetworkConnection FindConnection(int connectionId)
		{
			NetworkConnection networkConnection;
			if (connectionId < 0 || connectionId >= this.m_Connections.Count)
			{
				networkConnection = null;
			}
			else
			{
				networkConnection = this.m_Connections[connectionId];
			}
			return networkConnection;
		}

		// Token: 0x0600045B RID: 1115 RVA: 0x000190AC File Offset: 0x000172AC
		public bool SetConnectionAtIndex(NetworkConnection conn)
		{
			while (this.m_Connections.Count <= conn.connectionId)
			{
				this.m_Connections.Add(null);
			}
			bool flag;
			if (this.m_Connections[conn.connectionId] != null)
			{
				flag = false;
			}
			else
			{
				this.m_Connections[conn.connectionId] = conn;
				conn.SetHandlers(this.m_MessageHandlers);
				flag = true;
			}
			return flag;
		}

		// Token: 0x0600045C RID: 1116 RVA: 0x00019128 File Offset: 0x00017328
		public bool RemoveConnectionAtIndex(int connectionId)
		{
			bool flag;
			if (connectionId < 0 || connectionId >= this.m_Connections.Count)
			{
				flag = false;
			}
			else
			{
				this.m_Connections[connectionId] = null;
				flag = true;
			}
			return flag;
		}

		// Token: 0x0600045D RID: 1117 RVA: 0x0001916C File Offset: 0x0001736C
		private void HandleConnect(int connectionId, byte error)
		{
			if (LogFilter.logDebug)
			{
				Debug.Log("NetworkServerSimple accepted client:" + connectionId);
			}
			if (error != 0)
			{
				this.OnConnectError(connectionId, error);
			}
			else
			{
				string text;
				int num;
				NetworkID networkID;
				NodeID nodeID;
				byte b;
				NetworkTransport.GetConnectionInfo(this.m_ServerHostId, connectionId, out text, out num, out networkID, out nodeID, out b);
				NetworkConnection networkConnection = (NetworkConnection)Activator.CreateInstance(this.m_NetworkConnectionClass);
				networkConnection.SetHandlers(this.m_MessageHandlers);
				networkConnection.Initialize(text, this.m_ServerHostId, connectionId, this.m_HostTopology);
				networkConnection.lastError = (NetworkError)b;
				while (this.m_Connections.Count <= connectionId)
				{
					this.m_Connections.Add(null);
				}
				this.m_Connections[connectionId] = networkConnection;
				this.OnConnected(networkConnection);
			}
		}

		// Token: 0x0600045E RID: 1118 RVA: 0x0001923C File Offset: 0x0001743C
		private void HandleDisconnect(int connectionId, byte error)
		{
			if (LogFilter.logDebug)
			{
				Debug.Log("NetworkServerSimple disconnect client:" + connectionId);
			}
			NetworkConnection networkConnection = this.FindConnection(connectionId);
			if (networkConnection != null)
			{
				networkConnection.lastError = (NetworkError)error;
				if (error != 0)
				{
					if (error != 6)
					{
						this.m_Connections[connectionId] = null;
						if (LogFilter.logError)
						{
							Debug.LogError(string.Concat(new object[]
							{
								"Server client disconnect error, connectionId: ",
								connectionId,
								" error: ",
								(NetworkError)error
							}));
						}
						this.OnDisconnectError(networkConnection, error);
						return;
					}
				}
				networkConnection.Disconnect();
				this.m_Connections[connectionId] = null;
				if (LogFilter.logDebug)
				{
					Debug.Log("Server lost client:" + connectionId);
				}
				this.OnDisconnected(networkConnection);
			}
		}

		// Token: 0x0600045F RID: 1119 RVA: 0x0001932C File Offset: 0x0001752C
		private void HandleData(int connectionId, int channelId, int receivedSize, byte error)
		{
			NetworkConnection networkConnection = this.FindConnection(connectionId);
			if (networkConnection == null)
			{
				if (LogFilter.logError)
				{
					Debug.LogError("HandleData Unknown connectionId:" + connectionId);
				}
			}
			else
			{
				networkConnection.lastError = (NetworkError)error;
				if (error != 0)
				{
					this.OnDataError(networkConnection, error);
				}
				else
				{
					this.m_MsgReader.SeekZero();
					this.OnData(networkConnection, receivedSize, channelId);
				}
			}
		}

		// Token: 0x06000460 RID: 1120 RVA: 0x000193A4 File Offset: 0x000175A4
		public void SendBytesTo(int connectionId, byte[] bytes, int numBytes, int channelId)
		{
			NetworkConnection networkConnection = this.FindConnection(connectionId);
			if (networkConnection != null)
			{
				networkConnection.SendBytes(bytes, numBytes, channelId);
			}
		}

		// Token: 0x06000461 RID: 1121 RVA: 0x000193D4 File Offset: 0x000175D4
		public void SendWriterTo(int connectionId, NetworkWriter writer, int channelId)
		{
			NetworkConnection networkConnection = this.FindConnection(connectionId);
			if (networkConnection != null)
			{
				networkConnection.SendWriter(writer, channelId);
			}
		}

		// Token: 0x06000462 RID: 1122 RVA: 0x00019400 File Offset: 0x00017600
		public void Disconnect(int connectionId)
		{
			NetworkConnection networkConnection = this.FindConnection(connectionId);
			if (networkConnection != null)
			{
				networkConnection.Disconnect();
				this.m_Connections[connectionId] = null;
			}
		}

		// Token: 0x06000463 RID: 1123 RVA: 0x00019438 File Offset: 0x00017638
		public void DisconnectAllConnections()
		{
			for (int i = 0; i < this.m_Connections.Count; i++)
			{
				NetworkConnection networkConnection = this.m_Connections[i];
				if (networkConnection != null)
				{
					networkConnection.Disconnect();
					networkConnection.Dispose();
				}
			}
		}

		// Token: 0x06000464 RID: 1124 RVA: 0x00019485 File Offset: 0x00017685
		public virtual void OnConnectError(int connectionId, byte error)
		{
			Debug.LogError("OnConnectError error:" + error);
		}

		// Token: 0x06000465 RID: 1125 RVA: 0x0001949D File Offset: 0x0001769D
		public virtual void OnDataError(NetworkConnection conn, byte error)
		{
			Debug.LogError("OnDataError error:" + error);
		}

		// Token: 0x06000466 RID: 1126 RVA: 0x000194B5 File Offset: 0x000176B5
		public virtual void OnDisconnectError(NetworkConnection conn, byte error)
		{
			Debug.LogError("OnDisconnectError error:" + error);
		}

		// Token: 0x06000467 RID: 1127 RVA: 0x000194CD File Offset: 0x000176CD
		public virtual void OnConnected(NetworkConnection conn)
		{
			conn.InvokeHandlerNoData(32);
		}

		// Token: 0x06000468 RID: 1128 RVA: 0x000194D9 File Offset: 0x000176D9
		public virtual void OnDisconnected(NetworkConnection conn)
		{
			conn.InvokeHandlerNoData(33);
		}

		// Token: 0x06000469 RID: 1129 RVA: 0x000194E5 File Offset: 0x000176E5
		public virtual void OnData(NetworkConnection conn, int receivedSize, int channelId)
		{
			conn.TransportReceive(this.m_MsgBuffer, receivedSize, channelId);
		}

		// Token: 0x040001D2 RID: 466
		private bool m_Initialized = false;

		// Token: 0x040001D3 RID: 467
		private int m_ListenPort;

		// Token: 0x040001D4 RID: 468
		private int m_ServerHostId = -1;

		// Token: 0x040001D5 RID: 469
		private int m_RelaySlotId = -1;

		// Token: 0x040001D6 RID: 470
		private bool m_UseWebSockets;

		// Token: 0x040001D7 RID: 471
		private byte[] m_MsgBuffer = null;

		// Token: 0x040001D8 RID: 472
		private NetworkReader m_MsgReader = null;

		// Token: 0x040001D9 RID: 473
		private Type m_NetworkConnectionClass = typeof(NetworkConnection);

		// Token: 0x040001DA RID: 474
		private HostTopology m_HostTopology;

		// Token: 0x040001DB RID: 475
		private List<NetworkConnection> m_Connections = new List<NetworkConnection>();

		// Token: 0x040001DC RID: 476
		private ReadOnlyCollection<NetworkConnection> m_ConnectionsReadOnly;

		// Token: 0x040001DD RID: 477
		private NetworkMessageHandlers m_MessageHandlers = new NetworkMessageHandlers();
	}
}