using System;
using System.Collections.Generic;
using System.Text;

namespace UnityEngine.Networking
{
	// Token: 0x0200003F RID: 63
	public class NetworkConnection : IDisposable
	{
		// Token: 0x0600019E RID: 414 RVA: 0x00006BEC File Offset: 0x00004DEC
		public NetworkConnection()
		{
			this.m_Writer = new NetworkWriter();
		}

		// Token: 0x17000039 RID: 57
		// (get) Token: 0x0600019F RID: 415 RVA: 0x00006C58 File Offset: 0x00004E58
		internal HashSet<NetworkIdentity> visList
		{
			get
			{
				return this.m_VisList;
			}
		}

		// Token: 0x1700003A RID: 58
		// (get) Token: 0x060001A0 RID: 416 RVA: 0x00006C74 File Offset: 0x00004E74
		public List<PlayerController> playerControllers
		{
			get
			{
				return this.m_PlayerControllers;
			}
		}

		// Token: 0x1700003B RID: 59
		// (get) Token: 0x060001A1 RID: 417 RVA: 0x00006C90 File Offset: 0x00004E90
		public HashSet<NetworkInstanceId> clientOwnedObjects
		{
			get
			{
				return this.m_ClientOwnedObjects;
			}
		}

		// Token: 0x1700003C RID: 60
		// (get) Token: 0x060001A2 RID: 418 RVA: 0x00006CAC File Offset: 0x00004EAC
		public bool isConnected
		{
			get
			{
				return this.hostId != -1;
			}
		}

		// Token: 0x1700003D RID: 61
		// (get) Token: 0x060001A3 RID: 419 RVA: 0x00006CD0 File Offset: 0x00004ED0
		// (set) Token: 0x060001A4 RID: 420 RVA: 0x00006CEB File Offset: 0x00004EEB
		public NetworkError lastError
		{
			get
			{
				return this.error;
			}
			internal set
			{
				this.error = value;
			}
		}

		// Token: 0x1700003E RID: 62
		// (get) Token: 0x060001A5 RID: 421 RVA: 0x00006CF8 File Offset: 0x00004EF8
		internal Dictionary<short, NetworkConnection.PacketStat> packetStats
		{
			get
			{
				return this.m_PacketStats;
			}
		}

		// Token: 0x060001A6 RID: 422 RVA: 0x00006D14 File Offset: 0x00004F14
		public virtual void Initialize(string networkAddress, int networkHostId, int networkConnectionId, HostTopology hostTopology)
		{
			this.m_Writer = new NetworkWriter();
			this.address = networkAddress;
			this.hostId = networkHostId;
			this.connectionId = networkConnectionId;
			int channelCount = hostTopology.DefaultConfig.ChannelCount;
			int packetSize = (int)hostTopology.DefaultConfig.PacketSize;
			if (hostTopology.DefaultConfig.UsePlatformSpecificProtocols && Application.platform != RuntimePlatform.PS4 && Application.platform != RuntimePlatform.PSP2)
			{
				throw new ArgumentOutOfRangeException("Platform specific protocols are not supported on this platform");
			}
			this.m_Channels = new ChannelBuffer[channelCount];
			for (int i = 0; i < channelCount; i++)
			{
				ChannelQOS channelQOS = hostTopology.DefaultConfig.Channels[i];
				int num = packetSize;
				if (channelQOS.QOS == QosType.ReliableFragmented || channelQOS.QOS == QosType.UnreliableFragmented)
				{
					num = (int)(hostTopology.DefaultConfig.FragmentSize * 128);
				}
				this.m_Channels[i] = new ChannelBuffer(this, num, (byte)i, NetworkConnection.IsReliableQoS(channelQOS.QOS), NetworkConnection.IsSequencedQoS(channelQOS.QOS));
			}
		}

		// Token: 0x060001A7 RID: 423 RVA: 0x00006E1C File Offset: 0x0000501C
		~NetworkConnection()
		{
			this.Dispose(false);
		}

		// Token: 0x060001A8 RID: 424 RVA: 0x00006E50 File Offset: 0x00005050
		public void Dispose()
		{
			this.Dispose(true);
			GC.SuppressFinalize(this);
		}

		// Token: 0x060001A9 RID: 425 RVA: 0x00006E60 File Offset: 0x00005060
		protected virtual void Dispose(bool disposing)
		{
			if (!this.m_Disposed && this.m_Channels != null)
			{
				for (int i = 0; i < this.m_Channels.Length; i++)
				{
					this.m_Channels[i].Dispose();
				}
			}
			this.m_Channels = null;
			if (this.m_ClientOwnedObjects != null)
			{
				foreach (NetworkInstanceId networkInstanceId in this.m_ClientOwnedObjects)
				{
					GameObject gameObject = NetworkServer.FindLocalObject(networkInstanceId);
					if (gameObject != null)
					{
						gameObject.GetComponent<NetworkIdentity>().ClearClientOwner();
					}
				}
			}
			this.m_ClientOwnedObjects = null;
			this.m_Disposed = true;
		}

		// Token: 0x060001AA RID: 426 RVA: 0x00006F3C File Offset: 0x0000513C
		private static bool IsSequencedQoS(QosType qos)
		{
			return qos == QosType.ReliableSequenced || qos == QosType.UnreliableSequenced;
		}

		// Token: 0x060001AB RID: 427 RVA: 0x00006F60 File Offset: 0x00005160
		private static bool IsReliableQoS(QosType qos)
		{
			return qos == QosType.Reliable || qos == QosType.ReliableFragmented || qos == QosType.ReliableSequenced || qos == QosType.ReliableStateUpdate;
		}

		// Token: 0x060001AC RID: 428 RVA: 0x00006F94 File Offset: 0x00005194
		public bool SetChannelOption(int channelId, ChannelOption option, int value)
		{
			return this.m_Channels != null && channelId >= 0 && channelId < this.m_Channels.Length && this.m_Channels[channelId].SetOption(option, value);
		}

		// Token: 0x060001AD RID: 429 RVA: 0x00006FE8 File Offset: 0x000051E8
		public void Disconnect()
		{
			this.address = "";
			this.isReady = false;
			ClientScene.HandleClientDisconnect(this);
			if (this.hostId != -1)
			{
				byte b;
				NetworkTransport.Disconnect(this.hostId, this.connectionId, out b);
				this.RemoveObservers();
			}
		}

		// Token: 0x060001AE RID: 430 RVA: 0x0000703A File Offset: 0x0000523A
		internal void SetHandlers(NetworkMessageHandlers handlers)
		{
			this.m_MessageHandlers = handlers;
			this.m_MessageHandlersDict = handlers.GetHandlers();
		}

		// Token: 0x060001AF RID: 431 RVA: 0x00007050 File Offset: 0x00005250
		public bool CheckHandler(short msgType)
		{
			return this.m_MessageHandlersDict.ContainsKey(msgType);
		}

		// Token: 0x060001B0 RID: 432 RVA: 0x00007074 File Offset: 0x00005274
		public bool InvokeHandlerNoData(short msgType)
		{
			return this.InvokeHandler(msgType, null, 0);
		}

		// Token: 0x060001B1 RID: 433 RVA: 0x00007094 File Offset: 0x00005294
		public bool InvokeHandler(short msgType, NetworkReader reader, int channelId)
		{
			bool flag;
			if (this.m_MessageHandlersDict.ContainsKey(msgType))
			{
				this.m_MessageInfo.msgType = msgType;
				this.m_MessageInfo.conn = this;
				this.m_MessageInfo.reader = reader;
				this.m_MessageInfo.channelId = channelId;
				NetworkMessageDelegate networkMessageDelegate = this.m_MessageHandlersDict[msgType];
				if (networkMessageDelegate == null)
				{
					if (LogFilter.logError)
					{
						Debug.LogError("NetworkConnection InvokeHandler no handler for " + msgType);
					}
					flag = false;
				}
				else
				{
					networkMessageDelegate(this.m_MessageInfo);
					flag = true;
				}
			}
			else
			{
				flag = false;
			}
			return flag;
		}

		// Token: 0x060001B2 RID: 434 RVA: 0x0000713C File Offset: 0x0000533C
		public bool InvokeHandler(NetworkMessage netMsg)
		{
			bool flag;
			if (this.m_MessageHandlersDict.ContainsKey(netMsg.msgType))
			{
				NetworkMessageDelegate networkMessageDelegate = this.m_MessageHandlersDict[netMsg.msgType];
				networkMessageDelegate(netMsg);
				flag = true;
			}
			else
			{
				flag = false;
			}
			return flag;
		}

		// Token: 0x060001B3 RID: 435 RVA: 0x0000718C File Offset: 0x0000538C
		internal void HandleFragment(NetworkReader reader, int channelId)
		{
			if (channelId >= 0 && channelId < this.m_Channels.Length)
			{
				ChannelBuffer channelBuffer = this.m_Channels[channelId];
				if (channelBuffer.HandleFragment(reader))
				{
					NetworkReader networkReader = new NetworkReader(channelBuffer.fragmentBuffer.AsArraySegment().Array);
					networkReader.ReadInt16();
					short num = networkReader.ReadInt16();
					this.InvokeHandler(num, networkReader, channelId);
				}
			}
		}

		// Token: 0x060001B4 RID: 436 RVA: 0x000071FD File Offset: 0x000053FD
		public void RegisterHandler(short msgType, NetworkMessageDelegate handler)
		{
			this.m_MessageHandlers.RegisterHandler(msgType, handler);
		}

		// Token: 0x060001B5 RID: 437 RVA: 0x0000720D File Offset: 0x0000540D
		public void UnregisterHandler(short msgType)
		{
			this.m_MessageHandlers.UnregisterHandler(msgType);
		}

		// Token: 0x060001B6 RID: 438 RVA: 0x0000721C File Offset: 0x0000541C
		internal void SetPlayerController(PlayerController player)
		{
			while ((int)player.playerControllerId >= this.m_PlayerControllers.Count)
			{
				this.m_PlayerControllers.Add(new PlayerController());
			}
			this.m_PlayerControllers[(int)player.playerControllerId] = player;
		}

		// Token: 0x060001B7 RID: 439 RVA: 0x0000726C File Offset: 0x0000546C
		internal void RemovePlayerController(short playerControllerId)
		{
			for (int i = this.m_PlayerControllers.Count; i >= 0; i--)
			{
				if ((int)playerControllerId == i && playerControllerId == this.m_PlayerControllers[i].playerControllerId)
				{
					this.m_PlayerControllers[i] = new PlayerController();
					return;
				}
			}
			if (LogFilter.logError)
			{
				Debug.LogError("RemovePlayer player at playerControllerId " + playerControllerId + " not found");
				return;
			}
		}

		// Token: 0x060001B8 RID: 440 RVA: 0x000072F4 File Offset: 0x000054F4
		internal bool GetPlayerController(short playerControllerId, out PlayerController playerController)
		{
			playerController = null;
			bool flag;
			if (this.playerControllers.Count > 0)
			{
				for (int i = 0; i < this.playerControllers.Count; i++)
				{
					if (this.playerControllers[i].IsValid && this.playerControllers[i].playerControllerId == playerControllerId)
					{
						playerController = this.playerControllers[i];
						return true;
					}
				}
				flag = false;
			}
			else
			{
				flag = false;
			}
			return flag;
		}

		// Token: 0x060001B9 RID: 441 RVA: 0x00007388 File Offset: 0x00005588
		public void FlushChannels()
		{
			if (this.m_Channels != null)
			{
				for (int i = 0; i < this.m_Channels.Length; i++)
				{
					this.m_Channels[i].CheckInternalBuffer();
				}
			}
		}

		// Token: 0x060001BA RID: 442 RVA: 0x000073D0 File Offset: 0x000055D0
		public void SetMaxDelay(float seconds)
		{
			if (this.m_Channels != null)
			{
				for (int i = 0; i < this.m_Channels.Length; i++)
				{
					this.m_Channels[i].maxDelay = seconds;
				}
			}
		}

		// Token: 0x060001BB RID: 443 RVA: 0x00007418 File Offset: 0x00005618
		public virtual bool Send(short msgType, MessageBase msg)
		{
			return this.SendByChannel(msgType, msg, 0);
		}

		// Token: 0x060001BC RID: 444 RVA: 0x00007438 File Offset: 0x00005638
		public virtual bool SendUnreliable(short msgType, MessageBase msg)
		{
			return this.SendByChannel(msgType, msg, 1);
		}

		// Token: 0x060001BD RID: 445 RVA: 0x00007458 File Offset: 0x00005658
		public virtual bool SendByChannel(short msgType, MessageBase msg, int channelId)
		{
			this.m_Writer.StartMessage(msgType);
			msg.Serialize(this.m_Writer);
			this.m_Writer.FinishMessage();
			return this.SendWriter(this.m_Writer, channelId);
		}

		// Token: 0x060001BE RID: 446 RVA: 0x000074A0 File Offset: 0x000056A0
		public virtual bool SendBytes(byte[] bytes, int numBytes, int channelId)
		{
			if (this.logNetworkMessages)
			{
				this.LogSend(bytes);
			}
			return this.CheckChannel(channelId) && this.m_Channels[channelId].SendBytes(bytes, numBytes);
		}

		// Token: 0x060001BF RID: 447 RVA: 0x000074E8 File Offset: 0x000056E8
		public virtual bool SendWriter(NetworkWriter writer, int channelId)
		{
			if (this.logNetworkMessages)
			{
				this.LogSend(writer.ToArray());
			}
			return this.CheckChannel(channelId) && this.m_Channels[channelId].SendWriter(writer);
		}

		// Token: 0x060001C0 RID: 448 RVA: 0x00007534 File Offset: 0x00005734
		private void LogSend(byte[] bytes)
		{
			NetworkReader networkReader = new NetworkReader(bytes);
			ushort num = networkReader.ReadUInt16();
			ushort num2 = networkReader.ReadUInt16();
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 4; i < (int)(4 + num); i++)
			{
				stringBuilder.AppendFormat("{0:X2}", bytes[i]);
				if (i > 150)
				{
					break;
				}
			}
			Debug.Log(string.Concat(new object[] { "ConnectionSend con:", this.connectionId, " bytes:", num, " msgId:", num2, " ", stringBuilder }));
		}

		// Token: 0x060001C1 RID: 449 RVA: 0x000075F4 File Offset: 0x000057F4
		private bool CheckChannel(int channelId)
		{
			bool flag;
			if (this.m_Channels == null)
			{
				if (LogFilter.logWarn)
				{
					Debug.LogWarning("Channels not initialized sending on id '" + channelId);
				}
				flag = false;
			}
			else if (channelId < 0 || channelId >= this.m_Channels.Length)
			{
				if (LogFilter.logError)
				{
					Debug.LogError(string.Concat(new object[]
					{
						"Invalid channel when sending buffered data, '",
						channelId,
						"'. Current channel count is ",
						this.m_Channels.Length
					}));
				}
				flag = false;
			}
			else
			{
				flag = true;
			}
			return flag;
		}

		// Token: 0x060001C2 RID: 450 RVA: 0x000076A0 File Offset: 0x000058A0
		public void ResetStats()
		{
		}

		// Token: 0x060001C3 RID: 451 RVA: 0x000076A4 File Offset: 0x000058A4
		protected void HandleBytes(byte[] buffer, int receivedSize, int channelId)
		{
			NetworkReader networkReader = new NetworkReader(buffer);
			this.HandleReader(networkReader, receivedSize, channelId);
		}

		// Token: 0x060001C4 RID: 452 RVA: 0x000076C4 File Offset: 0x000058C4
		protected void HandleReader(NetworkReader reader, int receivedSize, int channelId)
		{
			while ((ulong)reader.Position < (ulong)((long)receivedSize))
			{
				ushort num = reader.ReadUInt16();
				short num2 = reader.ReadInt16();
				byte[] array = reader.ReadBytes((int)num);
				NetworkReader networkReader = new NetworkReader(array);
				if (this.logNetworkMessages)
				{
					StringBuilder stringBuilder = new StringBuilder();
					for (int i = 0; i < (int)num; i++)
					{
						stringBuilder.AppendFormat("{0:X2}", array[i]);
						if (i > 150)
						{
							break;
						}
					}
					Debug.Log(string.Concat(new object[] { "ConnectionRecv con:", this.connectionId, " bytes:", num, " msgId:", num2, " ", stringBuilder }));
				}
				NetworkMessageDelegate networkMessageDelegate = null;
				if (this.m_MessageHandlersDict.ContainsKey(num2))
				{
					networkMessageDelegate = this.m_MessageHandlersDict[num2];
				}
				if (networkMessageDelegate == null)
				{
					if (LogFilter.logError)
					{
						Debug.LogError(string.Concat(new object[] { "Unknown message ID ", num2, " connId:", this.connectionId }));
					}
					break;
				}
				this.m_NetMsg.msgType = num2;
				this.m_NetMsg.reader = networkReader;
				this.m_NetMsg.conn = this;
				this.m_NetMsg.channelId = channelId;
				networkMessageDelegate(this.m_NetMsg);
				this.lastMessageTime = Time.time;
			}
		}

		// Token: 0x060001C5 RID: 453 RVA: 0x00007870 File Offset: 0x00005A70
		public virtual void GetStatsOut(out int numMsgs, out int numBufferedMsgs, out int numBytes, out int lastBufferedPerSecond)
		{
			numMsgs = 0;
			numBufferedMsgs = 0;
			numBytes = 0;
			lastBufferedPerSecond = 0;
			for (int i = 0; i < this.m_Channels.Length; i++)
			{
				ChannelBuffer channelBuffer = this.m_Channels[i];
				numMsgs += channelBuffer.numMsgsOut;
				numBufferedMsgs += channelBuffer.numBufferedMsgsOut;
				numBytes += channelBuffer.numBytesOut;
				lastBufferedPerSecond += channelBuffer.lastBufferedPerSecond;
			}
		}

		// Token: 0x060001C6 RID: 454 RVA: 0x000078E0 File Offset: 0x00005AE0
		public virtual void GetStatsIn(out int numMsgs, out int numBytes)
		{
			numMsgs = 0;
			numBytes = 0;
			for (int i = 0; i < this.m_Channels.Length; i++)
			{
				ChannelBuffer channelBuffer = this.m_Channels[i];
				numMsgs += channelBuffer.numMsgsIn;
				numBytes += channelBuffer.numBytesIn;
			}
		}

		// Token: 0x060001C7 RID: 455 RVA: 0x00007930 File Offset: 0x00005B30
		public override string ToString()
		{
			return string.Format("hostId: {0} connectionId: {1} isReady: {2} channel count: {3}", new object[]
			{
				this.hostId,
				this.connectionId,
				this.isReady,
				(this.m_Channels == null) ? 0 : this.m_Channels.Length
			});
		}

		// Token: 0x060001C8 RID: 456 RVA: 0x000079A0 File Offset: 0x00005BA0
		internal void AddToVisList(NetworkIdentity uv)
		{
			this.m_VisList.Add(uv);
			NetworkServer.ShowForConnection(uv, this);
		}

		// Token: 0x060001C9 RID: 457 RVA: 0x000079B7 File Offset: 0x00005BB7
		internal void RemoveFromVisList(NetworkIdentity uv, bool isDestroyed)
		{
			this.m_VisList.Remove(uv);
			if (!isDestroyed)
			{
				NetworkServer.HideForConnection(uv, this);
			}
		}

		// Token: 0x060001CA RID: 458 RVA: 0x000079D8 File Offset: 0x00005BD8
		internal void RemoveObservers()
		{
			foreach (NetworkIdentity networkIdentity in this.m_VisList)
			{
				networkIdentity.RemoveObserverInternal(this);
			}
			this.m_VisList.Clear();
		}

		// Token: 0x060001CB RID: 459 RVA: 0x00007A44 File Offset: 0x00005C44
		public virtual void TransportReceive(byte[] bytes, int numBytes, int channelId)
		{
			this.HandleBytes(bytes, numBytes, channelId);
		}

		// Token: 0x060001CC RID: 460 RVA: 0x00007A50 File Offset: 0x00005C50
		[Obsolete("TransportRecieve has been deprecated. Use TransportReceive instead (UnityUpgradable) -> TransportReceive(*)", false)]
		public virtual void TransportRecieve(byte[] bytes, int numBytes, int channelId)
		{
			this.TransportReceive(bytes, numBytes, channelId);
		}

		// Token: 0x060001CD RID: 461 RVA: 0x00007A5C File Offset: 0x00005C5C
		public virtual bool TransportSend(byte[] bytes, int numBytes, int channelId, out byte error)
		{
			return NetworkTransport.Send(this.hostId, this.connectionId, channelId, bytes, numBytes, out error);
		}

		// Token: 0x060001CE RID: 462 RVA: 0x00007A87 File Offset: 0x00005C87
		internal void AddOwnedObject(NetworkIdentity obj)
		{
			if (this.m_ClientOwnedObjects == null)
			{
				this.m_ClientOwnedObjects = new HashSet<NetworkInstanceId>();
			}
			this.m_ClientOwnedObjects.Add(obj.netId);
		}

		// Token: 0x060001CF RID: 463 RVA: 0x00007AB4 File Offset: 0x00005CB4
		internal void RemoveOwnedObject(NetworkIdentity obj)
		{
			if (this.m_ClientOwnedObjects != null)
			{
				this.m_ClientOwnedObjects.Remove(obj.netId);
			}
		}

		// Token: 0x060001D0 RID: 464 RVA: 0x00007ADA File Offset: 0x00005CDA
		internal static void OnFragment(NetworkMessage netMsg)
		{
			netMsg.conn.HandleFragment(netMsg.reader, netMsg.channelId);
		}

		// Token: 0x040000EF RID: 239
		private ChannelBuffer[] m_Channels;

		// Token: 0x040000F0 RID: 240
		private List<PlayerController> m_PlayerControllers = new List<PlayerController>();

		// Token: 0x040000F1 RID: 241
		private NetworkMessage m_NetMsg = new NetworkMessage();

		// Token: 0x040000F2 RID: 242
		private HashSet<NetworkIdentity> m_VisList = new HashSet<NetworkIdentity>();

		// Token: 0x040000F3 RID: 243
		private NetworkWriter m_Writer;

		// Token: 0x040000F4 RID: 244
		private Dictionary<short, NetworkMessageDelegate> m_MessageHandlersDict;

		// Token: 0x040000F5 RID: 245
		private NetworkMessageHandlers m_MessageHandlers;

		// Token: 0x040000F6 RID: 246
		private HashSet<NetworkInstanceId> m_ClientOwnedObjects;

		// Token: 0x040000F7 RID: 247
		private NetworkMessage m_MessageInfo = new NetworkMessage();

		// Token: 0x040000F8 RID: 248
		private const int k_MaxMessageLogSize = 150;

		// Token: 0x040000F9 RID: 249
		private NetworkError error;

		// Token: 0x040000FA RID: 250
		public int hostId = -1;

		// Token: 0x040000FB RID: 251
		public int connectionId = -1;

		// Token: 0x040000FC RID: 252
		public bool isReady;

		// Token: 0x040000FD RID: 253
		public string address;

		// Token: 0x040000FE RID: 254
		public float lastMessageTime;

		// Token: 0x040000FF RID: 255
		public bool logNetworkMessages = false;

		// Token: 0x04000100 RID: 256
		private Dictionary<short, NetworkConnection.PacketStat> m_PacketStats = new Dictionary<short, NetworkConnection.PacketStat>();

		// Token: 0x04000101 RID: 257
		private bool m_Disposed;

		// Token: 0x02000040 RID: 64
		public class PacketStat
		{
			// Token: 0x060001D1 RID: 465 RVA: 0x00007AF4 File Offset: 0x00005CF4
			public PacketStat()
			{
				this.msgType = 0;
				this.count = 0;
				this.bytes = 0;
			}

			// Token: 0x060001D2 RID: 466 RVA: 0x00007B12 File Offset: 0x00005D12
			public PacketStat(NetworkConnection.PacketStat s)
			{
				this.msgType = s.msgType;
				this.count = s.count;
				this.bytes = s.bytes;
			}

			// Token: 0x060001D3 RID: 467 RVA: 0x00007B40 File Offset: 0x00005D40
			public override string ToString()
			{
				return string.Concat(new object[]
				{
					MsgType.MsgTypeToString(this.msgType),
					": count=",
					this.count,
					" bytes=",
					this.bytes
				});
			}

			// Token: 0x04000102 RID: 258
			public short msgType;

			// Token: 0x04000103 RID: 259
			public int count;

			// Token: 0x04000104 RID: 260
			public int bytes;
		}
	}
}