using System;
using System.Collections;
using System.Globalization;
using System.IO;
using System.Text;

namespace System.Net
{
	// Token: 0x020001FF RID: 511
	internal class ChunkStream
	{
		// Token: 0x06001153 RID: 4435 RVA: 0x000328A8 File Offset: 0x00030AA8
		public ChunkStream(byte[] buffer, int offset, int size, WebHeaderCollection headers)
			: this(headers)
		{
			this.Write(buffer, offset, size);
		}

		// Token: 0x06001154 RID: 4436 RVA: 0x000328BC File Offset: 0x00030ABC
		public ChunkStream(WebHeaderCollection headers)
		{
			this.headers = headers;
			this.saved = new StringBuilder();
			this.chunks = new ArrayList();
			this.chunkSize = -1;
		}

		// Token: 0x06001155 RID: 4437 RVA: 0x000328F4 File Offset: 0x00030AF4
		public void ResetBuffer()
		{
			this.chunkSize = -1;
			this.chunkRead = 0;
			this.chunks.Clear();
		}

		// Token: 0x06001156 RID: 4438 RVA: 0x00032910 File Offset: 0x00030B10
		public void WriteAndReadBack(byte[] buffer, int offset, int size, ref int read)
		{
			if (offset + read > 0)
			{
				this.Write(buffer, offset, offset + read);
			}
			read = this.Read(buffer, offset, size);
		}

		// Token: 0x06001157 RID: 4439 RVA: 0x00032944 File Offset: 0x00030B44
		public int Read(byte[] buffer, int offset, int size)
		{
			return this.ReadFromChunks(buffer, offset, size);
		}

		// Token: 0x06001158 RID: 4440 RVA: 0x00032950 File Offset: 0x00030B50
		private int ReadFromChunks(byte[] buffer, int offset, int size)
		{
			int count = this.chunks.Count;
			int num = 0;
			for (int i = 0; i < count; i++)
			{
				ChunkStream.Chunk chunk = (ChunkStream.Chunk)this.chunks[i];
				if (chunk != null)
				{
					if (chunk.Offset == chunk.Bytes.Length)
					{
						this.chunks[i] = null;
					}
					else
					{
						num += chunk.Read(buffer, offset + num, size - num);
						if (num == size)
						{
							break;
						}
					}
				}
			}
			return num;
		}

		// Token: 0x06001159 RID: 4441 RVA: 0x000329DC File Offset: 0x00030BDC
		public void Write(byte[] buffer, int offset, int size)
		{
			this.InternalWrite(buffer, ref offset, size);
		}

		// Token: 0x0600115A RID: 4442 RVA: 0x000329E8 File Offset: 0x00030BE8
		private void InternalWrite(byte[] buffer, ref int offset, int size)
		{
			if (this.state == ChunkStream.State.None)
			{
				this.state = this.GetChunkSize(buffer, ref offset, size);
				if (this.state == ChunkStream.State.None)
				{
					return;
				}
				this.saved.Length = 0;
				this.sawCR = false;
				this.gotit = false;
			}
			if (this.state == ChunkStream.State.Body && offset < size)
			{
				this.state = this.ReadBody(buffer, ref offset, size);
				if (this.state == ChunkStream.State.Body)
				{
					return;
				}
			}
			if (this.state == ChunkStream.State.BodyFinished && offset < size)
			{
				this.state = this.ReadCRLF(buffer, ref offset, size);
				if (this.state == ChunkStream.State.BodyFinished)
				{
					return;
				}
				this.sawCR = false;
			}
			if (this.state == ChunkStream.State.Trailer && offset < size)
			{
				this.state = this.ReadTrailer(buffer, ref offset, size);
				if (this.state == ChunkStream.State.Trailer)
				{
					return;
				}
				this.saved.Length = 0;
				this.sawCR = false;
				this.gotit = false;
			}
			if (offset < size)
			{
				this.InternalWrite(buffer, ref offset, size);
			}
		}

		// Token: 0x170005B5 RID: 1461
		// (get) Token: 0x0600115B RID: 4443 RVA: 0x00032AF8 File Offset: 0x00030CF8
		public bool WantMore
		{
			get
			{
				return this.chunkRead != this.chunkSize || this.chunkSize != 0 || this.state != ChunkStream.State.None;
			}
		}

		// Token: 0x170005B6 RID: 1462
		// (get) Token: 0x0600115C RID: 4444 RVA: 0x00032B28 File Offset: 0x00030D28
		public int ChunkLeft
		{
			get
			{
				return this.chunkSize - this.chunkRead;
			}
		}

		// Token: 0x0600115D RID: 4445 RVA: 0x00032B38 File Offset: 0x00030D38
		private ChunkStream.State ReadBody(byte[] buffer, ref int offset, int size)
		{
			if (this.chunkSize == 0)
			{
				return ChunkStream.State.BodyFinished;
			}
			int num = size - offset;
			if (num + this.chunkRead > this.chunkSize)
			{
				num = this.chunkSize - this.chunkRead;
			}
			byte[] array = new byte[num];
			Buffer.BlockCopy(buffer, offset, array, 0, num);
			this.chunks.Add(new ChunkStream.Chunk(array));
			offset += num;
			this.chunkRead += num;
			return (this.chunkRead != this.chunkSize) ? ChunkStream.State.Body : ChunkStream.State.BodyFinished;
		}

		// Token: 0x0600115E RID: 4446 RVA: 0x00032BC8 File Offset: 0x00030DC8
		private ChunkStream.State GetChunkSize(byte[] buffer, ref int offset, int size)
		{
			char c = '\0';
			while (offset < size)
			{
				c = (char)buffer[offset++];
				if (c == '\r')
				{
					if (this.sawCR)
					{
						ChunkStream.ThrowProtocolViolation("2 CR found");
					}
					this.sawCR = true;
				}
				else
				{
					if (this.sawCR && c == '\n')
					{
						break;
					}
					if (c == ' ')
					{
						this.gotit = true;
					}
					if (!this.gotit)
					{
						this.saved.Append(c);
					}
					if (this.saved.Length > 20)
					{
						ChunkStream.ThrowProtocolViolation("chunk size too long.");
					}
				}
			}
			if (!this.sawCR || c != '\n')
			{
				if (offset < size)
				{
					ChunkStream.ThrowProtocolViolation("Missing \\n");
				}
				try
				{
					if (this.saved.Length > 0)
					{
						this.chunkSize = int.Parse(ChunkStream.RemoveChunkExtension(this.saved.ToString()), NumberStyles.HexNumber);
					}
				}
				catch (Exception)
				{
					ChunkStream.ThrowProtocolViolation("Cannot parse chunk size.");
				}
				return ChunkStream.State.None;
			}
			this.chunkRead = 0;
			try
			{
				this.chunkSize = int.Parse(ChunkStream.RemoveChunkExtension(this.saved.ToString()), NumberStyles.HexNumber);
			}
			catch (Exception)
			{
				ChunkStream.ThrowProtocolViolation("Cannot parse chunk size.");
			}
			if (this.chunkSize == 0)
			{
				this.trailerState = 2;
				return ChunkStream.State.Trailer;
			}
			return ChunkStream.State.Body;
		}

		// Token: 0x0600115F RID: 4447 RVA: 0x00032D68 File Offset: 0x00030F68
		private static string RemoveChunkExtension(string input)
		{
			int num = input.IndexOf(';');
			if (num == -1)
			{
				return input;
			}
			return input.Substring(0, num);
		}

		// Token: 0x06001160 RID: 4448 RVA: 0x00032D90 File Offset: 0x00030F90
		private ChunkStream.State ReadCRLF(byte[] buffer, ref int offset, int size)
		{
			if (!this.sawCR)
			{
				if ((ushort)buffer[offset++] != 13)
				{
					ChunkStream.ThrowProtocolViolation("Expecting \\r");
				}
				this.sawCR = true;
				if (offset == size)
				{
					return ChunkStream.State.BodyFinished;
				}
			}
			if (this.sawCR && (ushort)buffer[offset++] != 10)
			{
				ChunkStream.ThrowProtocolViolation("Expecting \\n");
			}
			return ChunkStream.State.None;
		}

		// Token: 0x06001161 RID: 4449 RVA: 0x00032E00 File Offset: 0x00031000
		private ChunkStream.State ReadTrailer(byte[] buffer, ref int offset, int size)
		{
			if (this.trailerState == 2 && (ushort)buffer[offset] == 13 && this.saved.Length == 0)
			{
				offset++;
				if (offset < size && (ushort)buffer[offset] == 10)
				{
					offset++;
					return ChunkStream.State.None;
				}
				offset--;
			}
			int num = this.trailerState;
			string text = "\r\n\r";
			while (offset < size && num < 4)
			{
				char c = (char)buffer[offset++];
				if ((num == 0 || num == 2) && c == '\r')
				{
					num++;
				}
				else if ((num == 1 || num == 3) && c == '\n')
				{
					num++;
				}
				else if (num > 0)
				{
					this.saved.Append(text.Substring(0, (this.saved.Length != 0) ? num : (num - 2)));
					num = 0;
					if (this.saved.Length > 4196)
					{
						ChunkStream.ThrowProtocolViolation("Error reading trailer (too long).");
					}
				}
			}
			if (num < 4)
			{
				this.trailerState = num;
				if (offset < size)
				{
					ChunkStream.ThrowProtocolViolation("Error reading trailer.");
				}
				return ChunkStream.State.Trailer;
			}
			StringReader stringReader = new StringReader(this.saved.ToString());
			string text2;
			while ((text2 = stringReader.ReadLine()) != null && text2 != string.Empty)
			{
				this.headers.Add(text2);
			}
			return ChunkStream.State.None;
		}

		// Token: 0x06001162 RID: 4450 RVA: 0x00032F88 File Offset: 0x00031188
		private static void ThrowProtocolViolation(string message)
		{
			WebException ex = new WebException(message, null, WebExceptionStatus.ServerProtocolViolation, null);
			throw ex;
		}

		// Token: 0x04000F5A RID: 3930
		internal WebHeaderCollection headers;

		// Token: 0x04000F5B RID: 3931
		private int chunkSize;

		// Token: 0x04000F5C RID: 3932
		private int chunkRead;

		// Token: 0x04000F5D RID: 3933
		private ChunkStream.State state;

		// Token: 0x04000F5E RID: 3934
		private StringBuilder saved;

		// Token: 0x04000F5F RID: 3935
		private bool sawCR;

		// Token: 0x04000F60 RID: 3936
		private bool gotit;

		// Token: 0x04000F61 RID: 3937
		private int trailerState;

		// Token: 0x04000F62 RID: 3938
		private ArrayList chunks;

		// Token: 0x02000200 RID: 512
		private enum State
		{
			// Token: 0x04000F64 RID: 3940
			None,
			// Token: 0x04000F65 RID: 3941
			Body,
			// Token: 0x04000F66 RID: 3942
			BodyFinished,
			// Token: 0x04000F67 RID: 3943
			Trailer
		}

		// Token: 0x02000201 RID: 513
		private class Chunk
		{
			// Token: 0x06001163 RID: 4451 RVA: 0x00032FA4 File Offset: 0x000311A4
			public Chunk(byte[] chunk)
			{
				this.Bytes = chunk;
			}

			// Token: 0x06001164 RID: 4452 RVA: 0x00032FB4 File Offset: 0x000311B4
			public int Read(byte[] buffer, int offset, int size)
			{
				int num = ((size <= this.Bytes.Length - this.Offset) ? size : (this.Bytes.Length - this.Offset));
				Buffer.BlockCopy(this.Bytes, this.Offset, buffer, offset, num);
				this.Offset += num;
				return num;
			}

			// Token: 0x04000F68 RID: 3944
			public byte[] Bytes;

			// Token: 0x04000F69 RID: 3945
			public int Offset;
		}
	}
}