using System;
using System.Text;

namespace UnityEngine.Networking
{
	// Token: 0x02000055 RID: 85
	public class NetworkReader
	{
		// Token: 0x06000371 RID: 881 RVA: 0x00013D8C File Offset: 0x00011F8C
		public NetworkReader()
		{
			this.m_buf = new NetBuffer();
			NetworkReader.Initialize();
		}

		// Token: 0x06000372 RID: 882 RVA: 0x00013DA5 File Offset: 0x00011FA5
		public NetworkReader(NetworkWriter writer)
		{
			this.m_buf = new NetBuffer(writer.AsArray());
			NetworkReader.Initialize();
		}

		// Token: 0x06000373 RID: 883 RVA: 0x00013DC4 File Offset: 0x00011FC4
		public NetworkReader(byte[] buffer)
		{
			this.m_buf = new NetBuffer(buffer);
			NetworkReader.Initialize();
		}

		// Token: 0x06000374 RID: 884 RVA: 0x00013DDE File Offset: 0x00011FDE
		private static void Initialize()
		{
			if (NetworkReader.s_Encoding == null)
			{
				NetworkReader.s_StringReaderBuffer = new byte[1024];
				NetworkReader.s_Encoding = new UTF8Encoding();
			}
		}

		// Token: 0x17000098 RID: 152
		// (get) Token: 0x06000375 RID: 885 RVA: 0x00013E08 File Offset: 0x00012008
		public uint Position
		{
			get
			{
				return this.m_buf.Position;
			}
		}

		// Token: 0x17000099 RID: 153
		// (get) Token: 0x06000376 RID: 886 RVA: 0x00013E28 File Offset: 0x00012028
		public int Length
		{
			get
			{
				return this.m_buf.Length;
			}
		}

		// Token: 0x06000377 RID: 887 RVA: 0x00013E48 File Offset: 0x00012048
		public void SeekZero()
		{
			this.m_buf.SeekZero();
		}

		// Token: 0x06000378 RID: 888 RVA: 0x00013E56 File Offset: 0x00012056
		internal void Replace(byte[] buffer)
		{
			this.m_buf.Replace(buffer);
		}

		// Token: 0x06000379 RID: 889 RVA: 0x00013E68 File Offset: 0x00012068
		public uint ReadPackedUInt32()
		{
			byte b = this.ReadByte();
			uint num;
			if (b < 241)
			{
				num = (uint)b;
			}
			else
			{
				byte b2 = this.ReadByte();
				if (b >= 241 && b <= 248)
				{
					num = 240U + 256U * (uint)(b - 241) + (uint)b2;
				}
				else
				{
					byte b3 = this.ReadByte();
					if (b == 249)
					{
						num = 2288U + 256U * (uint)b2 + (uint)b3;
					}
					else
					{
						byte b4 = this.ReadByte();
						if (b == 250)
						{
							num = (uint)((int)b2 + ((int)b3 << 8) + ((int)b4 << 16));
						}
						else
						{
							byte b5 = this.ReadByte();
							if (b < 251)
							{
								throw new IndexOutOfRangeException("ReadPackedUInt32() failure: " + b);
							}
							num = (uint)((int)b2 + ((int)b3 << 8) + ((int)b4 << 16) + ((int)b5 << 24));
						}
					}
				}
			}
			return num;
		}

		// Token: 0x0600037A RID: 890 RVA: 0x00013F58 File Offset: 0x00012158
		public ulong ReadPackedUInt64()
		{
			byte b = this.ReadByte();
			ulong num;
			if (b < 241)
			{
				num = (ulong)b;
			}
			else
			{
				byte b2 = this.ReadByte();
				if (b >= 241 && b <= 248)
				{
					num = 240UL + 256UL * ((ulong)b - 241UL) + (ulong)b2;
				}
				else
				{
					byte b3 = this.ReadByte();
					if (b == 249)
					{
						num = 2288UL + 256UL * (ulong)b2 + (ulong)b3;
					}
					else
					{
						byte b4 = this.ReadByte();
						if (b == 250)
						{
							num = (ulong)b2 + ((ulong)b3 << 8) + ((ulong)b4 << 16);
						}
						else
						{
							byte b5 = this.ReadByte();
							if (b == 251)
							{
								num = (ulong)b2 + ((ulong)b3 << 8) + ((ulong)b4 << 16) + ((ulong)b5 << 24);
							}
							else
							{
								byte b6 = this.ReadByte();
								if (b == 252)
								{
									num = (ulong)b2 + ((ulong)b3 << 8) + ((ulong)b4 << 16) + ((ulong)b5 << 24) + ((ulong)b6 << 32);
								}
								else
								{
									byte b7 = this.ReadByte();
									if (b == 253)
									{
										num = (ulong)b2 + ((ulong)b3 << 8) + ((ulong)b4 << 16) + ((ulong)b5 << 24) + ((ulong)b6 << 32) + ((ulong)b7 << 40);
									}
									else
									{
										byte b8 = this.ReadByte();
										if (b == 254)
										{
											num = (ulong)b2 + ((ulong)b3 << 8) + ((ulong)b4 << 16) + ((ulong)b5 << 24) + ((ulong)b6 << 32) + ((ulong)b7 << 40) + ((ulong)b8 << 48);
										}
										else
										{
											byte b9 = this.ReadByte();
											if (b != 255)
											{
												throw new IndexOutOfRangeException("ReadPackedUInt64() failure: " + b);
											}
											num = (ulong)b2 + ((ulong)b3 << 8) + ((ulong)b4 << 16) + ((ulong)b5 << 24) + ((ulong)b6 << 32) + ((ulong)b7 << 40) + ((ulong)b8 << 48) + ((ulong)b9 << 56);
										}
									}
								}
							}
						}
					}
				}
			}
			return num;
		}

		// Token: 0x0600037B RID: 891 RVA: 0x0001415C File Offset: 0x0001235C
		public NetworkInstanceId ReadNetworkId()
		{
			return new NetworkInstanceId(this.ReadPackedUInt32());
		}

		// Token: 0x0600037C RID: 892 RVA: 0x0001417C File Offset: 0x0001237C
		public NetworkSceneId ReadSceneId()
		{
			return new NetworkSceneId(this.ReadPackedUInt32());
		}

		// Token: 0x0600037D RID: 893 RVA: 0x0001419C File Offset: 0x0001239C
		public byte ReadByte()
		{
			return this.m_buf.ReadByte();
		}

		// Token: 0x0600037E RID: 894 RVA: 0x000141BC File Offset: 0x000123BC
		public sbyte ReadSByte()
		{
			return (sbyte)this.m_buf.ReadByte();
		}

		// Token: 0x0600037F RID: 895 RVA: 0x000141E0 File Offset: 0x000123E0
		public short ReadInt16()
		{
			ushort num = 0;
			num |= (ushort)this.m_buf.ReadByte();
			num |= (ushort)(this.m_buf.ReadByte() << 8);
			return (short)num;
		}

		// Token: 0x06000380 RID: 896 RVA: 0x0001421C File Offset: 0x0001241C
		public ushort ReadUInt16()
		{
			ushort num = 0;
			num |= (ushort)this.m_buf.ReadByte();
			return num | (ushort)(this.m_buf.ReadByte() << 8);
		}

		// Token: 0x06000381 RID: 897 RVA: 0x00014258 File Offset: 0x00012458
		public int ReadInt32()
		{
			uint num = 0U;
			num |= (uint)this.m_buf.ReadByte();
			num |= (uint)((uint)this.m_buf.ReadByte() << 8);
			num |= (uint)((uint)this.m_buf.ReadByte() << 16);
			return (int)(num | (uint)((uint)this.m_buf.ReadByte() << 24));
		}

		// Token: 0x06000382 RID: 898 RVA: 0x000142B0 File Offset: 0x000124B0
		public uint ReadUInt32()
		{
			uint num = 0U;
			num |= (uint)this.m_buf.ReadByte();
			num |= (uint)((uint)this.m_buf.ReadByte() << 8);
			num |= (uint)((uint)this.m_buf.ReadByte() << 16);
			return num | (uint)((uint)this.m_buf.ReadByte() << 24);
		}

		// Token: 0x06000383 RID: 899 RVA: 0x00014308 File Offset: 0x00012508
		public long ReadInt64()
		{
			ulong num = 0UL;
			ulong num2 = (ulong)this.m_buf.ReadByte();
			num |= num2;
			num2 = (ulong)this.m_buf.ReadByte() << 8;
			num |= num2;
			num2 = (ulong)this.m_buf.ReadByte() << 16;
			num |= num2;
			num2 = (ulong)this.m_buf.ReadByte() << 24;
			num |= num2;
			num2 = (ulong)this.m_buf.ReadByte() << 32;
			num |= num2;
			num2 = (ulong)this.m_buf.ReadByte() << 40;
			num |= num2;
			num2 = (ulong)this.m_buf.ReadByte() << 48;
			num |= num2;
			num2 = (ulong)this.m_buf.ReadByte() << 56;
			return (long)(num | num2);
		}

		// Token: 0x06000384 RID: 900 RVA: 0x000143C0 File Offset: 0x000125C0
		public ulong ReadUInt64()
		{
			ulong num = 0UL;
			ulong num2 = (ulong)this.m_buf.ReadByte();
			num |= num2;
			num2 = (ulong)this.m_buf.ReadByte() << 8;
			num |= num2;
			num2 = (ulong)this.m_buf.ReadByte() << 16;
			num |= num2;
			num2 = (ulong)this.m_buf.ReadByte() << 24;
			num |= num2;
			num2 = (ulong)this.m_buf.ReadByte() << 32;
			num |= num2;
			num2 = (ulong)this.m_buf.ReadByte() << 40;
			num |= num2;
			num2 = (ulong)this.m_buf.ReadByte() << 48;
			num |= num2;
			num2 = (ulong)this.m_buf.ReadByte() << 56;
			return num | num2;
		}

		// Token: 0x06000385 RID: 901 RVA: 0x00014478 File Offset: 0x00012678
		public decimal ReadDecimal()
		{
			return new decimal(new int[]
			{
				this.ReadInt32(),
				this.ReadInt32(),
				this.ReadInt32(),
				this.ReadInt32()
			});
		}

		// Token: 0x06000386 RID: 902 RVA: 0x000144C0 File Offset: 0x000126C0
		public float ReadSingle()
		{
			uint num = this.ReadUInt32();
			return FloatConversion.ToSingle(num);
		}

		// Token: 0x06000387 RID: 903 RVA: 0x000144E4 File Offset: 0x000126E4
		public double ReadDouble()
		{
			ulong num = this.ReadUInt64();
			return FloatConversion.ToDouble(num);
		}

		// Token: 0x06000388 RID: 904 RVA: 0x00014508 File Offset: 0x00012708
		public string ReadString()
		{
			ushort num = this.ReadUInt16();
			string text;
			if (num == 0)
			{
				text = "";
			}
			else
			{
				if (num >= 32768)
				{
					throw new IndexOutOfRangeException("ReadString() too long: " + num);
				}
				while ((int)num > NetworkReader.s_StringReaderBuffer.Length)
				{
					NetworkReader.s_StringReaderBuffer = new byte[NetworkReader.s_StringReaderBuffer.Length * 2];
				}
				this.m_buf.ReadBytes(NetworkReader.s_StringReaderBuffer, (uint)num);
				char[] chars = NetworkReader.s_Encoding.GetChars(NetworkReader.s_StringReaderBuffer, 0, (int)num);
				text = new string(chars);
			}
			return text;
		}

		// Token: 0x06000389 RID: 905 RVA: 0x000145A8 File Offset: 0x000127A8
		public char ReadChar()
		{
			return (char)this.m_buf.ReadByte();
		}

		// Token: 0x0600038A RID: 906 RVA: 0x000145CC File Offset: 0x000127CC
		public bool ReadBoolean()
		{
			int num = (int)this.m_buf.ReadByte();
			return num == 1;
		}

		// Token: 0x0600038B RID: 907 RVA: 0x000145F4 File Offset: 0x000127F4
		public byte[] ReadBytes(int count)
		{
			if (count < 0)
			{
				throw new IndexOutOfRangeException("NetworkReader ReadBytes " + count);
			}
			byte[] array = new byte[count];
			this.m_buf.ReadBytes(array, (uint)count);
			return array;
		}

		// Token: 0x0600038C RID: 908 RVA: 0x0001463C File Offset: 0x0001283C
		public byte[] ReadBytesAndSize()
		{
			ushort num = this.ReadUInt16();
			byte[] array;
			if (num == 0)
			{
				array = new byte[0];
			}
			else
			{
				array = this.ReadBytes((int)num);
			}
			return array;
		}

		// Token: 0x0600038D RID: 909 RVA: 0x00014674 File Offset: 0x00012874
		public Vector2 ReadVector2()
		{
			return new Vector2(this.ReadSingle(), this.ReadSingle());
		}

		// Token: 0x0600038E RID: 910 RVA: 0x0001469C File Offset: 0x0001289C
		public Vector3 ReadVector3()
		{
			return new Vector3(this.ReadSingle(), this.ReadSingle(), this.ReadSingle());
		}

		// Token: 0x0600038F RID: 911 RVA: 0x000146C8 File Offset: 0x000128C8
		public Vector4 ReadVector4()
		{
			return new Vector4(this.ReadSingle(), this.ReadSingle(), this.ReadSingle(), this.ReadSingle());
		}

		// Token: 0x06000390 RID: 912 RVA: 0x000146FC File Offset: 0x000128FC
		public Color ReadColor()
		{
			return new Color(this.ReadSingle(), this.ReadSingle(), this.ReadSingle(), this.ReadSingle());
		}

		// Token: 0x06000391 RID: 913 RVA: 0x00014730 File Offset: 0x00012930
		public Color32 ReadColor32()
		{
			return new Color32(this.ReadByte(), this.ReadByte(), this.ReadByte(), this.ReadByte());
		}

		// Token: 0x06000392 RID: 914 RVA: 0x00014764 File Offset: 0x00012964
		public Quaternion ReadQuaternion()
		{
			return new Quaternion(this.ReadSingle(), this.ReadSingle(), this.ReadSingle(), this.ReadSingle());
		}

		// Token: 0x06000393 RID: 915 RVA: 0x00014798 File Offset: 0x00012998
		public Rect ReadRect()
		{
			return new Rect(this.ReadSingle(), this.ReadSingle(), this.ReadSingle(), this.ReadSingle());
		}

		// Token: 0x06000394 RID: 916 RVA: 0x000147CC File Offset: 0x000129CC
		public Plane ReadPlane()
		{
			return new Plane(this.ReadVector3(), this.ReadSingle());
		}

		// Token: 0x06000395 RID: 917 RVA: 0x000147F4 File Offset: 0x000129F4
		public Ray ReadRay()
		{
			return new Ray(this.ReadVector3(), this.ReadVector3());
		}

		// Token: 0x06000396 RID: 918 RVA: 0x0001481C File Offset: 0x00012A1C
		public Matrix4x4 ReadMatrix4x4()
		{
			return new Matrix4x4
			{
				m00 = this.ReadSingle(),
				m01 = this.ReadSingle(),
				m02 = this.ReadSingle(),
				m03 = this.ReadSingle(),
				m10 = this.ReadSingle(),
				m11 = this.ReadSingle(),
				m12 = this.ReadSingle(),
				m13 = this.ReadSingle(),
				m20 = this.ReadSingle(),
				m21 = this.ReadSingle(),
				m22 = this.ReadSingle(),
				m23 = this.ReadSingle(),
				m30 = this.ReadSingle(),
				m31 = this.ReadSingle(),
				m32 = this.ReadSingle(),
				m33 = this.ReadSingle()
			};
		}

		// Token: 0x06000397 RID: 919 RVA: 0x0001490C File Offset: 0x00012B0C
		public NetworkHash128 ReadNetworkHash128()
		{
			NetworkHash128 networkHash;
			networkHash.i0 = this.ReadByte();
			networkHash.i1 = this.ReadByte();
			networkHash.i2 = this.ReadByte();
			networkHash.i3 = this.ReadByte();
			networkHash.i4 = this.ReadByte();
			networkHash.i5 = this.ReadByte();
			networkHash.i6 = this.ReadByte();
			networkHash.i7 = this.ReadByte();
			networkHash.i8 = this.ReadByte();
			networkHash.i9 = this.ReadByte();
			networkHash.i10 = this.ReadByte();
			networkHash.i11 = this.ReadByte();
			networkHash.i12 = this.ReadByte();
			networkHash.i13 = this.ReadByte();
			networkHash.i14 = this.ReadByte();
			networkHash.i15 = this.ReadByte();
			return networkHash;
		}

		// Token: 0x06000398 RID: 920 RVA: 0x000149F4 File Offset: 0x00012BF4
		public Transform ReadTransform()
		{
			NetworkInstanceId networkInstanceId = this.ReadNetworkId();
			Transform transform;
			if (networkInstanceId.IsEmpty())
			{
				transform = null;
			}
			else
			{
				GameObject gameObject = ClientScene.FindLocalObject(networkInstanceId);
				if (gameObject == null)
				{
					if (LogFilter.logDebug)
					{
						Debug.Log("ReadTransform netId:" + networkInstanceId);
					}
					transform = null;
				}
				else
				{
					transform = gameObject.transform;
				}
			}
			return transform;
		}

		// Token: 0x06000399 RID: 921 RVA: 0x00014A68 File Offset: 0x00012C68
		public GameObject ReadGameObject()
		{
			NetworkInstanceId networkInstanceId = this.ReadNetworkId();
			GameObject gameObject;
			if (networkInstanceId.IsEmpty())
			{
				gameObject = null;
			}
			else
			{
				GameObject gameObject2;
				if (NetworkServer.active)
				{
					gameObject2 = NetworkServer.FindLocalObject(networkInstanceId);
				}
				else
				{
					gameObject2 = ClientScene.FindLocalObject(networkInstanceId);
				}
				if (gameObject2 == null)
				{
					if (LogFilter.logDebug)
					{
						Debug.Log("ReadGameObject netId:" + networkInstanceId + "go: null");
					}
				}
				gameObject = gameObject2;
			}
			return gameObject;
		}

		// Token: 0x0600039A RID: 922 RVA: 0x00014AF0 File Offset: 0x00012CF0
		public NetworkIdentity ReadNetworkIdentity()
		{
			NetworkInstanceId networkInstanceId = this.ReadNetworkId();
			NetworkIdentity networkIdentity;
			if (networkInstanceId.IsEmpty())
			{
				networkIdentity = null;
			}
			else
			{
				GameObject gameObject;
				if (NetworkServer.active)
				{
					gameObject = NetworkServer.FindLocalObject(networkInstanceId);
				}
				else
				{
					gameObject = ClientScene.FindLocalObject(networkInstanceId);
				}
				if (gameObject == null)
				{
					if (LogFilter.logDebug)
					{
						Debug.Log("ReadNetworkIdentity netId:" + networkInstanceId + "go: null");
					}
					networkIdentity = null;
				}
				else
				{
					networkIdentity = gameObject.GetComponent<NetworkIdentity>();
				}
			}
			return networkIdentity;
		}

		// Token: 0x0600039B RID: 923 RVA: 0x00014B84 File Offset: 0x00012D84
		public override string ToString()
		{
			return this.m_buf.ToString();
		}

		// Token: 0x0600039C RID: 924 RVA: 0x00014BA4 File Offset: 0x00012DA4
		public TMsg ReadMessage<TMsg>() where TMsg : MessageBase, new()
		{
			TMsg tmsg = new TMsg();
			tmsg.Deserialize(this);
			return tmsg;
		}

		// Token: 0x040001AE RID: 430
		private NetBuffer m_buf;

		// Token: 0x040001AF RID: 431
		private const int k_MaxStringLength = 32768;

		// Token: 0x040001B0 RID: 432
		private const int k_InitialStringBufferSize = 1024;

		// Token: 0x040001B1 RID: 433
		private static byte[] s_StringReaderBuffer;

		// Token: 0x040001B2 RID: 434
		private static Encoding s_Encoding;
	}
}