using System;
using System.IO;
using BestHTTP.WebSocket.Extensions;

namespace BestHTTP.WebSocket.Frames
{
	// Token: 0x02000220 RID: 544
	public sealed class OPAEMMDPOHJ
	{
		// Token: 0x06006749 RID: 26441 RVA: 0x00218970 File Offset: 0x00216B70
		private void PMGHGJJFJNA(byte NOBAPCOKFIL)
		{
			this.<MCHGIFICPJG>k__BackingField = NOBAPCOKFIL;
		}

		// Token: 0x0600674A RID: 26442 RVA: 0x0021897C File Offset: 0x00216B7C
		public byte[] GNLDKCDPKDM()
		{
			return this.<IEJGKMNCNDN>k__BackingField;
		}

		// Token: 0x170002A8 RID: 680
		// (get) Token: 0x0600674B RID: 26443 RVA: 0x00218984 File Offset: 0x00216B84
		// (set) Token: 0x06006756 RID: 26454 RVA: 0x00218A08 File Offset: 0x00216C08
		public bool MDMDGHKFJLD { get; private set; }

		// Token: 0x0600674C RID: 26444 RVA: 0x0021898C File Offset: 0x00216B8C
		public bool CFEECKHGEAM()
		{
			return this.<JCKMPLKIJDP>k__BackingField;
		}

		// Token: 0x0600674D RID: 26445 RVA: 0x00218994 File Offset: 0x00216B94
		public bool ANFHADDLBLO()
		{
			return this.<JCKMPLKIJDP>k__BackingField;
		}

		// Token: 0x170002A7 RID: 679
		// (get) Token: 0x0600675F RID: 26463 RVA: 0x00218C60 File Offset: 0x00216E60
		// (set) Token: 0x0600674E RID: 26446 RVA: 0x0021899C File Offset: 0x00216B9C
		public byte[] LCHAEFBPFIH { get; private set; }

		// Token: 0x170002A6 RID: 678
		// (get) Token: 0x0600675D RID: 26461 RVA: 0x00218B68 File Offset: 0x00216D68
		// (set) Token: 0x0600674F RID: 26447 RVA: 0x002189A8 File Offset: 0x00216BA8
		public byte PMLLKNFHFPF { get; private set; }

		// Token: 0x170002A4 RID: 676
		// (get) Token: 0x06006752 RID: 26450 RVA: 0x002189C8 File Offset: 0x00216BC8
		// (set) Token: 0x06006750 RID: 26448 RVA: 0x002189B4 File Offset: 0x00216BB4
		public CLIGHMMAICB EEAOGJHMFII { get; private set; }

		// Token: 0x06006751 RID: 26449 RVA: 0x002189C0 File Offset: 0x00216BC0
		public bool NBKIMLIIGNM()
		{
			return this.<JCKMPLKIJDP>k__BackingField;
		}

		// Token: 0x170002A5 RID: 677
		// (get) Token: 0x06006753 RID: 26451 RVA: 0x002189D0 File Offset: 0x00216BD0
		// (set) Token: 0x06006755 RID: 26453 RVA: 0x002189FC File Offset: 0x00216BFC
		public bool EALMNCGBBLJ { get; private set; }

		// Token: 0x06006754 RID: 26452 RVA: 0x002189D8 File Offset: 0x00216BD8
		public OPAEMMDPOHJ(IJADBHMBMPG MAMLCABFOLP, CLIGHMMAICB ANNBGHOPFBN, byte[] AOAILGGFDHJ, bool LFJIIJFGHAG, bool MBLFMKMPLMD)
			: this(MAMLCABFOLP, ANNBGHOPFBN, AOAILGGFDHJ, 0UL, (ulong)((AOAILGGFDHJ == null) ? 0L : ((long)AOAILGGFDHJ.Length)), LFJIIJFGHAG, MBLFMKMPLMD)
		{
		}

		// Token: 0x06006757 RID: 26455 RVA: 0x00218A14 File Offset: 0x00216C14
		private void LBADLMMCDEI(byte[] NOBAPCOKFIL)
		{
			this.<IEJGKMNCNDN>k__BackingField = NOBAPCOKFIL;
		}

		// Token: 0x06006758 RID: 26456 RVA: 0x00218A20 File Offset: 0x00216C20
		public OPAEMMDPOHJ[] EFMNNFBKEAP(ushort IIELOBIGLLC)
		{
			if (this.AJHONMPDLAO() == null)
			{
				return null;
			}
			if (this.EEAOGJHMFII != (CLIGHMMAICB)5 && this.EEAOGJHMFII != CLIGHMMAICB.Continuation)
			{
				return null;
			}
			if (this.LCHAEFBPFIH.Length <= (int)IIELOBIGLLC)
			{
				return null;
			}
			this.EALMNCGBBLJ = true;
			this.PMLLKNFHFPF &= 112;
			int num = this.LCHAEFBPFIH.Length / (int)IIELOBIGLLC + ((this.GNLDKCDPKDM().Length % (int)IIELOBIGLLC != 0) ? 1 : (-1));
			OPAEMMDPOHJ[] array = new OPAEMMDPOHJ[num];
			ulong num3;
			for (ulong num2 = (ulong)IIELOBIGLLC; num2 < (ulong)((long)this.GNLDKCDPKDM().Length); num2 += num3)
			{
				num3 = Math.Min((ulong)IIELOBIGLLC, (ulong)((long)this.AJHONMPDLAO().Length - (long)num2));
				OPAEMMDPOHJ[] array2 = array;
				int num4 = array.Length;
				int num5 = num;
				num = num5 - 0;
				array2[num4 - num5] = new OPAEMMDPOHJ(null, CLIGHMMAICB.Continuation, this.LCHAEFBPFIH, num2, num3, num2 + num3 < (ulong)((long)this.GNLDKCDPKDM().Length), true);
			}
			byte[] array3 = new byte[(int)IIELOBIGLLC];
			Array.Copy(this.AJHONMPDLAO(), 1, array3, 1, (int)IIELOBIGLLC);
			this.CBHEGNHLKEP(array3);
			return array;
		}

		// Token: 0x06006759 RID: 26457 RVA: 0x00218B20 File Offset: 0x00216D20
		public OPAEMMDPOHJ(IJADBHMBMPG MAMLCABFOLP, CLIGHMMAICB ANNBGHOPFBN, byte[] AOAILGGFDHJ, bool MBLFMKMPLMD)
			: this(MAMLCABFOLP, ANNBGHOPFBN, AOAILGGFDHJ, 0UL, (ulong)((AOAILGGFDHJ == null) ? 0L : ((long)AOAILGGFDHJ.Length)), true, MBLFMKMPLMD)
		{
		}

		// Token: 0x0600675A RID: 26458 RVA: 0x00218B44 File Offset: 0x00216D44
		public OPAEMMDPOHJ(IJADBHMBMPG MAMLCABFOLP, CLIGHMMAICB ANNBGHOPFBN, byte[] AOAILGGFDHJ)
			: this(MAMLCABFOLP, ANNBGHOPFBN, AOAILGGFDHJ, true)
		{
		}

		// Token: 0x0600675B RID: 26459 RVA: 0x00218B50 File Offset: 0x00216D50
		public bool KJOFDIICLBG()
		{
			return this.<JCKMPLKIJDP>k__BackingField;
		}

		// Token: 0x0600675E RID: 26462 RVA: 0x00218B70 File Offset: 0x00216D70
		public OPAEMMDPOHJ(IJADBHMBMPG MAMLCABFOLP, CLIGHMMAICB ANNBGHOPFBN, byte[] AOAILGGFDHJ, ulong IFJEHHMHOOM, ulong MFFGOHPHNFL, bool LFJIIJFGHAG, bool MBLFMKMPLMD)
		{
			this.EEAOGJHMFII = ANNBGHOPFBN;
			this.EALMNCGBBLJ = LFJIIJFGHAG;
			this.MDMDGHKFJLD = MBLFMKMPLMD;
			if (AOAILGGFDHJ != null)
			{
				this.LCHAEFBPFIH = new byte[MFFGOHPHNFL];
				Array.Copy(AOAILGGFDHJ, (int)IFJEHHMHOOM, this.LCHAEFBPFIH, 0, (int)MFFGOHPHNFL);
			}
			else
			{
				AOAILGGFDHJ = OPAEMMDPOHJ.AJOFPOKFJFP;
			}
			byte b = ((!this.EALMNCGBBLJ) ? 0 : 128);
			this.PMLLKNFHFPF = b | (byte)this.EEAOGJHMFII;
			if (this.MDMDGHKFJLD && MAMLCABFOLP != null && MAMLCABFOLP.AGODJKPLNGO != null)
			{
				for (int i = 0; i < MAMLCABFOLP.AGODJKPLNGO.Length; i++)
				{
					EFMJKIGBGGK efmjkigbggk = MAMLCABFOLP.AGODJKPLNGO[i];
					if (efmjkigbggk != null)
					{
						this.PMLLKNFHFPF |= efmjkigbggk.PCGCOOLONAK(this, this.PMLLKNFHFPF);
						this.LCHAEFBPFIH = efmjkigbggk.LBACPJMCEKK(this);
					}
				}
			}
		}

		// Token: 0x06006760 RID: 26464 RVA: 0x00218C68 File Offset: 0x00216E68
		public byte[] CPIBGJLHLBL()
		{
			if (this.LCHAEFBPFIH == null)
			{
				this.LCHAEFBPFIH = OPAEMMDPOHJ.AJOFPOKFJFP;
			}
			byte[] array;
			using (MemoryStream memoryStream = new MemoryStream(this.LCHAEFBPFIH.Length + 9))
			{
				memoryStream.WriteByte(this.PMLLKNFHFPF);
				if (this.LCHAEFBPFIH.Length < 126)
				{
					memoryStream.WriteByte(128 | (byte)this.LCHAEFBPFIH.Length);
				}
				else if (this.LCHAEFBPFIH.Length < 65535)
				{
					memoryStream.WriteByte(254);
					byte[] bytes = BitConverter.GetBytes((ushort)this.LCHAEFBPFIH.Length);
					if (BitConverter.IsLittleEndian)
					{
						Array.Reverse(bytes, 0, bytes.Length);
					}
					memoryStream.Write(bytes, 0, bytes.Length);
				}
				else
				{
					memoryStream.WriteByte(byte.MaxValue);
					byte[] bytes2 = BitConverter.GetBytes((ulong)((long)this.LCHAEFBPFIH.Length));
					if (BitConverter.IsLittleEndian)
					{
						Array.Reverse(bytes2, 0, bytes2.Length);
					}
					memoryStream.Write(bytes2, 0, bytes2.Length);
				}
				byte[] bytes3 = BitConverter.GetBytes(this.GetHashCode());
				memoryStream.Write(bytes3, 0, bytes3.Length);
				for (int i = 0; i < this.LCHAEFBPFIH.Length; i++)
				{
					memoryStream.WriteByte(this.LCHAEFBPFIH[i] ^ bytes3[i % 4]);
				}
				array = memoryStream.ToArray();
			}
			return array;
		}

		// Token: 0x06006761 RID: 26465 RVA: 0x00218DE0 File Offset: 0x00216FE0
		public bool CNJJLPNGBJE()
		{
			return this.<JCKMPLKIJDP>k__BackingField;
		}

		// Token: 0x06006762 RID: 26466 RVA: 0x00218DE8 File Offset: 0x00216FE8
		public bool ECBHKFHJBPK()
		{
			return this.<BNEMCBNIDJF>k__BackingField;
		}

		// Token: 0x06006763 RID: 26467 RVA: 0x00218DF0 File Offset: 0x00216FF0
		public byte ELMOBLBPGBO()
		{
			return this.<MCHGIFICPJG>k__BackingField;
		}

		// Token: 0x06006764 RID: 26468 RVA: 0x00218DF8 File Offset: 0x00216FF8
		public OPAEMMDPOHJ[] LIDAPBKACDI(ushort IIELOBIGLLC)
		{
			if (this.LCHAEFBPFIH == null)
			{
				return null;
			}
			if (this.EEAOGJHMFII != CLIGHMMAICB.Binary && this.EEAOGJHMFII != CLIGHMMAICB.Text)
			{
				return null;
			}
			if (this.LCHAEFBPFIH.Length <= (int)IIELOBIGLLC)
			{
				return null;
			}
			this.EALMNCGBBLJ = false;
			this.PMLLKNFHFPF &= 127;
			int num = this.LCHAEFBPFIH.Length / (int)IIELOBIGLLC + ((this.LCHAEFBPFIH.Length % (int)IIELOBIGLLC != 0) ? 0 : (-1));
			OPAEMMDPOHJ[] array = new OPAEMMDPOHJ[num];
			ulong num3;
			for (ulong num2 = (ulong)IIELOBIGLLC; num2 < (ulong)((long)this.LCHAEFBPFIH.Length); num2 += num3)
			{
				num3 = Math.Min((ulong)IIELOBIGLLC, (ulong)((long)this.LCHAEFBPFIH.Length - (long)num2));
				array[array.Length - num--] = new OPAEMMDPOHJ(null, CLIGHMMAICB.Continuation, this.LCHAEFBPFIH, num2, num3, num2 + num3 >= (ulong)((long)this.LCHAEFBPFIH.Length), false);
			}
			byte[] array2 = new byte[(int)IIELOBIGLLC];
			Array.Copy(this.LCHAEFBPFIH, 0, array2, 0, (int)IIELOBIGLLC);
			this.LCHAEFBPFIH = array2;
			return array;
		}

		// Token: 0x06006765 RID: 26469 RVA: 0x00218EF8 File Offset: 0x002170F8
		private void CBHEGNHLKEP(byte[] NOBAPCOKFIL)
		{
			this.<IEJGKMNCNDN>k__BackingField = NOBAPCOKFIL;
		}

		// Token: 0x06006766 RID: 26470 RVA: 0x00218F04 File Offset: 0x00217104
		public bool FIALBPKGDPC()
		{
			return this.<BNEMCBNIDJF>k__BackingField;
		}

		// Token: 0x06006767 RID: 26471 RVA: 0x00218F0C File Offset: 0x0021710C
		public byte[] AJHONMPDLAO()
		{
			return this.<IEJGKMNCNDN>k__BackingField;
		}

		// Token: 0x06006768 RID: 26472 RVA: 0x00218F14 File Offset: 0x00217114
		public byte[] CDGCJDDKFPH()
		{
			if (this.LCHAEFBPFIH == null)
			{
				this.CBHEGNHLKEP(OPAEMMDPOHJ.AJOFPOKFJFP);
			}
			byte[] array;
			using (MemoryStream memoryStream = new MemoryStream(this.GNLDKCDPKDM().Length + -100))
			{
				memoryStream.WriteByte(this.ELMOBLBPGBO());
				if (this.GNLDKCDPKDM().Length < -36)
				{
					memoryStream.WriteByte(168 | (byte)this.AJHONMPDLAO().Length);
				}
				else if (this.LCHAEFBPFIH.Length < 1)
				{
					memoryStream.WriteByte((byte)(-193));
					byte[] bytes = BitConverter.GetBytes((ushort)this.GNLDKCDPKDM().Length);
					if (BitConverter.IsLittleEndian)
					{
						Array.Reverse(bytes, 0, bytes.Length);
					}
					memoryStream.Write(bytes, 1, bytes.Length);
				}
				else
				{
					memoryStream.WriteByte(134);
					byte[] bytes2 = BitConverter.GetBytes((ulong)((long)this.AJHONMPDLAO().Length));
					if (BitConverter.IsLittleEndian)
					{
						Array.Reverse(bytes2, 1, bytes2.Length);
					}
					memoryStream.Write(bytes2, 1, bytes2.Length);
				}
				byte[] bytes3 = BitConverter.GetBytes(this.GetHashCode());
				memoryStream.Write(bytes3, 0, bytes3.Length);
				for (int i = 0; i < this.GNLDKCDPKDM().Length; i += 0)
				{
					memoryStream.WriteByte(this.AJHONMPDLAO()[i] ^ bytes3[i % 6]);
				}
				array = memoryStream.ToArray();
			}
			return array;
		}

		// Token: 0x06006769 RID: 26473 RVA: 0x0021908C File Offset: 0x0021728C
		public bool JNHPKLBECJJ()
		{
			return this.<JCKMPLKIJDP>k__BackingField;
		}

		// Token: 0x0600676A RID: 26474 RVA: 0x00219094 File Offset: 0x00217294
		private void NCDEEENCHFJ(bool NOBAPCOKFIL)
		{
			this.<BNEMCBNIDJF>k__BackingField = NOBAPCOKFIL;
		}

		// Token: 0x04000DD4 RID: 3540
		public static readonly byte[] AJOFPOKFJFP = new byte[0];
	}
}