using System;

namespace ExitGames.Client.Photon
{
	// Token: 0x02000019 RID: 25
	internal class NCommand : IComparable<NCommand>
	{
		// Token: 0x17000060 RID: 96
		// (get) Token: 0x06000176 RID: 374 RVA: 0x0000DA44 File Offset: 0x0000BC44
		protected internal int SizeOfPayload
		{
			get
			{
				return (this.Payload != null) ? this.Payload.Length : 0;
			}
		}

		// Token: 0x06000177 RID: 375 RVA: 0x0000DA6C File Offset: 0x0000BC6C
		internal NCommand(EnetPeer peer, byte commandType, byte[] payload, byte channel)
		{
			this.commandType = commandType;
			this.commandFlags = 1;
			this.commandChannelID = channel;
			this.Payload = payload;
			this.Size = 12;
			switch (this.commandType)
			{
			case 2:
			{
				this.Size = 44;
				this.Payload = new byte[32];
				this.Payload[0] = 0;
				this.Payload[1] = 0;
				int num = 2;
				Protocol.Serialize((short)peer.mtu, this.Payload, ref num);
				this.Payload[4] = 0;
				this.Payload[5] = 0;
				this.Payload[6] = 128;
				this.Payload[7] = 0;
				this.Payload[11] = peer.ChannelCount;
				this.Payload[15] = 0;
				this.Payload[19] = 0;
				this.Payload[22] = 19;
				this.Payload[23] = 136;
				this.Payload[27] = 2;
				this.Payload[31] = 2;
				break;
			}
			case 4:
			{
				this.Size = 12;
				bool flag = peer.peerConnectionState != PeerBase.ConnectionStateValue.Connected;
				if (flag)
				{
					this.commandFlags = 2;
					bool flag2 = peer.peerConnectionState == PeerBase.ConnectionStateValue.Zombie;
					if (flag2)
					{
						this.reservedByte = 2;
					}
				}
				break;
			}
			case 6:
				this.Size = 12 + payload.Length;
				break;
			case 7:
				this.Size = 16 + payload.Length;
				this.commandFlags = 0;
				break;
			case 8:
				this.Size = 32 + payload.Length;
				break;
			}
		}

		// Token: 0x06000178 RID: 376 RVA: 0x0000DC00 File Offset: 0x0000BE00
		internal static void CreateAck(byte[] buffer, int offset, NCommand commandToAck, int sentTime)
		{
			buffer[offset++] = 1;
			buffer[offset++] = commandToAck.commandChannelID;
			buffer[offset++] = 0;
			buffer[offset++] = commandToAck.reservedByte;
			Protocol.Serialize(20, buffer, ref offset);
			Protocol.Serialize(commandToAck.reliableSequenceNumber, buffer, ref offset);
			Protocol.Serialize(commandToAck.reliableSequenceNumber, buffer, ref offset);
			Protocol.Serialize(sentTime, buffer, ref offset);
		}

		// Token: 0x06000179 RID: 377 RVA: 0x0000DC70 File Offset: 0x0000BE70
		internal NCommand(EnetPeer peer, byte[] inBuff, ref int readingOffset)
		{
			int num = readingOffset;
			readingOffset = num + 1;
			this.commandType = inBuff[num];
			num = readingOffset;
			readingOffset = num + 1;
			this.commandChannelID = inBuff[num];
			num = readingOffset;
			readingOffset = num + 1;
			this.commandFlags = inBuff[num];
			num = readingOffset;
			readingOffset = num + 1;
			this.reservedByte = inBuff[num];
			Protocol.Deserialize(out this.Size, inBuff, ref readingOffset);
			Protocol.Deserialize(out this.reliableSequenceNumber, inBuff, ref readingOffset);
			peer.bytesIn += (long)this.Size;
			switch (this.commandType)
			{
			case 1:
				Protocol.Deserialize(out this.ackReceivedReliableSequenceNumber, inBuff, ref readingOffset);
				Protocol.Deserialize(out this.ackReceivedSentTime, inBuff, ref readingOffset);
				break;
			case 3:
			{
				short num2;
				Protocol.Deserialize(out num2, inBuff, ref readingOffset);
				readingOffset += 30;
				bool flag = peer.peerID == -1 || peer.peerID == -2;
				if (flag)
				{
					peer.peerID = num2;
				}
				break;
			}
			case 6:
				this.Payload = new byte[this.Size - 12];
				break;
			case 7:
				Protocol.Deserialize(out this.unreliableSequenceNumber, inBuff, ref readingOffset);
				this.Payload = new byte[this.Size - 16];
				break;
			case 8:
				Protocol.Deserialize(out this.startSequenceNumber, inBuff, ref readingOffset);
				Protocol.Deserialize(out this.fragmentCount, inBuff, ref readingOffset);
				Protocol.Deserialize(out this.fragmentNumber, inBuff, ref readingOffset);
				Protocol.Deserialize(out this.totalLength, inBuff, ref readingOffset);
				Protocol.Deserialize(out this.fragmentOffset, inBuff, ref readingOffset);
				this.Payload = new byte[this.Size - 32];
				this.fragmentsRemaining = this.fragmentCount;
				break;
			}
			bool flag2 = this.Payload != null;
			if (flag2)
			{
				Buffer.BlockCopy(inBuff, readingOffset, this.Payload, 0, this.Payload.Length);
				readingOffset += this.Payload.Length;
			}
		}

		// Token: 0x0600017A RID: 378 RVA: 0x0000DE6C File Offset: 0x0000C06C
		internal void SerializeHeader(byte[] buffer, ref int bufferIndex)
		{
			bool flag = this.commandHeader != null;
			if (!flag)
			{
				this.SizeOfHeader = 12;
				bool flag2 = this.commandType == 7;
				if (flag2)
				{
					this.SizeOfHeader = 16;
				}
				else
				{
					bool flag3 = this.commandType == 8;
					if (flag3)
					{
						this.SizeOfHeader = 32;
					}
				}
				int num = bufferIndex;
				bufferIndex = num + 1;
				buffer[num] = this.commandType;
				num = bufferIndex;
				bufferIndex = num + 1;
				buffer[num] = this.commandChannelID;
				num = bufferIndex;
				bufferIndex = num + 1;
				buffer[num] = this.commandFlags;
				num = bufferIndex;
				bufferIndex = num + 1;
				buffer[num] = this.reservedByte;
				Protocol.Serialize(this.Size, buffer, ref bufferIndex);
				Protocol.Serialize(this.reliableSequenceNumber, buffer, ref bufferIndex);
				bool flag4 = this.commandType == 7;
				if (flag4)
				{
					Protocol.Serialize(this.unreliableSequenceNumber, buffer, ref bufferIndex);
				}
				else
				{
					bool flag5 = this.commandType == 8;
					if (flag5)
					{
						Protocol.Serialize(this.startSequenceNumber, buffer, ref bufferIndex);
						Protocol.Serialize(this.fragmentCount, buffer, ref bufferIndex);
						Protocol.Serialize(this.fragmentNumber, buffer, ref bufferIndex);
						Protocol.Serialize(this.totalLength, buffer, ref bufferIndex);
						Protocol.Serialize(this.fragmentOffset, buffer, ref bufferIndex);
					}
				}
			}
		}

		// Token: 0x0600017B RID: 379 RVA: 0x0000DFA0 File Offset: 0x0000C1A0
		internal byte[] Serialize()
		{
			return this.Payload;
		}

		// Token: 0x0600017C RID: 380 RVA: 0x0000DFB8 File Offset: 0x0000C1B8
		public int CompareTo(NCommand other)
		{
			bool flag = (this.commandFlags & 1) > 0;
			int num;
			if (flag)
			{
				num = this.reliableSequenceNumber - other.reliableSequenceNumber;
			}
			else
			{
				num = this.unreliableSequenceNumber - other.unreliableSequenceNumber;
			}
			return num;
		}

		// Token: 0x0600017D RID: 381 RVA: 0x0000DFF8 File Offset: 0x0000C1F8
		public override string ToString()
		{
			bool flag = this.commandType == 1;
			string text;
			if (flag)
			{
				text = string.Format("CMD({1} ack for c#:{0} s#/time {2}/{3})", new object[] { this.commandChannelID, this.commandType, this.ackReceivedReliableSequenceNumber, this.ackReceivedSentTime });
			}
			else
			{
				text = string.Format("CMD({1} c#:{0} r/u: {2}/{3} st/r#/rt:{4}/{5}/{6})", new object[] { this.commandChannelID, this.commandType, this.reliableSequenceNumber, this.unreliableSequenceNumber, this.commandSentTime, this.commandSentCount, this.timeoutTime });
			}
			return text;
		}

		// Token: 0x040000CD RID: 205
		internal byte commandFlags;

		// Token: 0x040000CE RID: 206
		internal const int FLAG_RELIABLE = 1;

		// Token: 0x040000CF RID: 207
		internal const int FLAG_UNSEQUENCED = 2;

		// Token: 0x040000D0 RID: 208
		internal const byte FV_UNRELIABLE = 0;

		// Token: 0x040000D1 RID: 209
		internal const byte FV_RELIABLE = 1;

		// Token: 0x040000D2 RID: 210
		internal const byte FV_UNRELIBALE_UNSEQUENCED = 2;

		// Token: 0x040000D3 RID: 211
		internal byte commandType;

		// Token: 0x040000D4 RID: 212
		internal const byte CT_NONE = 0;

		// Token: 0x040000D5 RID: 213
		internal const byte CT_ACK = 1;

		// Token: 0x040000D6 RID: 214
		internal const byte CT_CONNECT = 2;

		// Token: 0x040000D7 RID: 215
		internal const byte CT_VERIFYCONNECT = 3;

		// Token: 0x040000D8 RID: 216
		internal const byte CT_DISCONNECT = 4;

		// Token: 0x040000D9 RID: 217
		internal const byte CT_PING = 5;

		// Token: 0x040000DA RID: 218
		internal const byte CT_SENDRELIABLE = 6;

		// Token: 0x040000DB RID: 219
		internal const byte CT_SENDUNRELIABLE = 7;

		// Token: 0x040000DC RID: 220
		internal const byte CT_SENDFRAGMENT = 8;

		// Token: 0x040000DD RID: 221
		internal const byte CT_EG_SERVERTIME = 12;

		// Token: 0x040000DE RID: 222
		internal byte commandChannelID;

		// Token: 0x040000DF RID: 223
		internal int reliableSequenceNumber;

		// Token: 0x040000E0 RID: 224
		internal int unreliableSequenceNumber;

		// Token: 0x040000E1 RID: 225
		internal int unsequencedGroupNumber;

		// Token: 0x040000E2 RID: 226
		internal byte reservedByte = 4;

		// Token: 0x040000E3 RID: 227
		internal int startSequenceNumber;

		// Token: 0x040000E4 RID: 228
		internal int fragmentCount;

		// Token: 0x040000E5 RID: 229
		internal int fragmentNumber;

		// Token: 0x040000E6 RID: 230
		internal int totalLength;

		// Token: 0x040000E7 RID: 231
		internal int fragmentOffset;

		// Token: 0x040000E8 RID: 232
		internal int fragmentsRemaining;

		// Token: 0x040000E9 RID: 233
		internal int commandSentTime;

		// Token: 0x040000EA RID: 234
		internal byte commandSentCount;

		// Token: 0x040000EB RID: 235
		internal int roundTripTimeout;

		// Token: 0x040000EC RID: 236
		internal int timeoutTime;

		// Token: 0x040000ED RID: 237
		internal int ackReceivedReliableSequenceNumber;

		// Token: 0x040000EE RID: 238
		internal int ackReceivedSentTime;

		// Token: 0x040000EF RID: 239
		internal const int HEADER_UDP_PACK_LENGTH = 12;

		// Token: 0x040000F0 RID: 240
		internal const int CmdSizeMinimum = 12;

		// Token: 0x040000F1 RID: 241
		internal const int CmdSizeAck = 20;

		// Token: 0x040000F2 RID: 242
		internal const int CmdSizeConnect = 44;

		// Token: 0x040000F3 RID: 243
		internal const int CmdSizeVerifyConnect = 44;

		// Token: 0x040000F4 RID: 244
		internal const int CmdSizeDisconnect = 12;

		// Token: 0x040000F5 RID: 245
		internal const int CmdSizePing = 12;

		// Token: 0x040000F6 RID: 246
		internal const int CmdSizeReliableHeader = 12;

		// Token: 0x040000F7 RID: 247
		internal const int CmdSizeUnreliableHeader = 16;

		// Token: 0x040000F8 RID: 248
		internal const int CmdSizeFragmentHeader = 32;

		// Token: 0x040000F9 RID: 249
		internal const int CmdSizeMaxHeader = 36;

		// Token: 0x040000FA RID: 250
		internal int Size;

		// Token: 0x040000FB RID: 251
		private byte[] commandHeader;

		// Token: 0x040000FC RID: 252
		internal int SizeOfHeader;

		// Token: 0x040000FD RID: 253
		internal byte[] Payload;
	}
}