using System;
using System.IO;
using System.Runtime.InteropServices;
using System.Text;

namespace System.Net
{
	// Token: 0x02000251 RID: 593
	internal class ResponseStream : Stream
	{
		// Token: 0x06001505 RID: 5381 RVA: 0x000433AC File Offset: 0x000415AC
		internal ResponseStream(Stream stream, HttpListenerResponse response, bool ignore_errors)
		{
			this.response = response;
			this.ignore_errors = ignore_errors;
			this.stream = stream;
		}

		// Token: 0x170006DC RID: 1756
		// (get) Token: 0x06001507 RID: 5383 RVA: 0x000433E4 File Offset: 0x000415E4
		public override bool CanRead
		{
			get
			{
				return false;
			}
		}

		// Token: 0x170006DD RID: 1757
		// (get) Token: 0x06001508 RID: 5384 RVA: 0x000433E8 File Offset: 0x000415E8
		public override bool CanSeek
		{
			get
			{
				return false;
			}
		}

		// Token: 0x170006DE RID: 1758
		// (get) Token: 0x06001509 RID: 5385 RVA: 0x000433EC File Offset: 0x000415EC
		public override bool CanWrite
		{
			get
			{
				return true;
			}
		}

		// Token: 0x170006DF RID: 1759
		// (get) Token: 0x0600150A RID: 5386 RVA: 0x000433F0 File Offset: 0x000415F0
		public override long Length
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		// Token: 0x170006E0 RID: 1760
		// (get) Token: 0x0600150B RID: 5387 RVA: 0x000433F8 File Offset: 0x000415F8
		// (set) Token: 0x0600150C RID: 5388 RVA: 0x00043400 File Offset: 0x00041600
		public override long Position
		{
			get
			{
				throw new NotSupportedException();
			}
			set
			{
				throw new NotSupportedException();
			}
		}

		// Token: 0x0600150D RID: 5389 RVA: 0x00043408 File Offset: 0x00041608
		public override void Close()
		{
			if (!this.disposed)
			{
				this.disposed = true;
				MemoryStream headers = this.GetHeaders(true);
				bool sendChunked = this.response.SendChunked;
				if (headers != null)
				{
					long position = headers.Position;
					if (sendChunked && !this.trailer_sent)
					{
						byte[] array = ResponseStream.GetChunkSizeBytes(0, true);
						headers.Position = headers.Length;
						headers.Write(array, 0, array.Length);
					}
					this.InternalWrite(headers.GetBuffer(), (int)position, (int)(headers.Length - position));
					this.trailer_sent = true;
				}
				else if (sendChunked && !this.trailer_sent)
				{
					byte[] array = ResponseStream.GetChunkSizeBytes(0, true);
					this.InternalWrite(array, 0, array.Length);
					this.trailer_sent = true;
				}
				this.response.Close();
			}
		}

		// Token: 0x0600150E RID: 5390 RVA: 0x000434D4 File Offset: 0x000416D4
		private MemoryStream GetHeaders(bool closing)
		{
			if (this.response.HeadersSent)
			{
				return null;
			}
			MemoryStream memoryStream = new MemoryStream();
			this.response.SendHeaders(closing, memoryStream);
			return memoryStream;
		}

		// Token: 0x0600150F RID: 5391 RVA: 0x00043508 File Offset: 0x00041708
		public override void Flush()
		{
		}

		// Token: 0x06001510 RID: 5392 RVA: 0x0004350C File Offset: 0x0004170C
		private static byte[] GetChunkSizeBytes(int size, bool final)
		{
			string text = string.Format("{0:x}\r\n{1}", size, (!final) ? string.Empty : "\r\n");
			return Encoding.ASCII.GetBytes(text);
		}

		// Token: 0x06001511 RID: 5393 RVA: 0x0004354C File Offset: 0x0004174C
		internal void InternalWrite(byte[] buffer, int offset, int count)
		{
			if (this.ignore_errors)
			{
				try
				{
					this.stream.Write(buffer, offset, count);
				}
				catch
				{
				}
			}
			else
			{
				this.stream.Write(buffer, offset, count);
			}
		}

		// Token: 0x06001512 RID: 5394 RVA: 0x000435AC File Offset: 0x000417AC
		public override void Write(byte[] buffer, int offset, int count)
		{
			if (this.disposed)
			{
				throw new ObjectDisposedException(base.GetType().ToString());
			}
			MemoryStream headers = this.GetHeaders(false);
			bool sendChunked = this.response.SendChunked;
			if (headers != null)
			{
				long position = headers.Position;
				headers.Position = headers.Length;
				if (sendChunked)
				{
					byte[] array = ResponseStream.GetChunkSizeBytes(count, false);
					headers.Write(array, 0, array.Length);
				}
				int num = Math.Min(count, 16384 - (int)headers.Position + (int)position);
				headers.Write(buffer, offset, num);
				count -= num;
				offset += num;
				this.InternalWrite(headers.GetBuffer(), (int)position, (int)(headers.Length - position));
				headers.SetLength(0L);
				headers.Capacity = 0;
			}
			else if (sendChunked)
			{
				byte[] array = ResponseStream.GetChunkSizeBytes(count, false);
				this.InternalWrite(array, 0, array.Length);
			}
			if (count > 0)
			{
				this.InternalWrite(buffer, offset, count);
			}
			if (sendChunked)
			{
				this.InternalWrite(ResponseStream.crlf, 0, 2);
			}
		}

		// Token: 0x06001513 RID: 5395 RVA: 0x000436B4 File Offset: 0x000418B4
		public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback cback, object state)
		{
			if (this.disposed)
			{
				throw new ObjectDisposedException(base.GetType().ToString());
			}
			MemoryStream headers = this.GetHeaders(false);
			bool sendChunked = this.response.SendChunked;
			if (headers != null)
			{
				long position = headers.Position;
				headers.Position = headers.Length;
				if (sendChunked)
				{
					byte[] array = ResponseStream.GetChunkSizeBytes(count, false);
					headers.Write(array, 0, array.Length);
				}
				headers.Write(buffer, offset, count);
				buffer = headers.GetBuffer();
				offset = (int)position;
				count = (int)(headers.Position - position);
			}
			else if (sendChunked)
			{
				byte[] array = ResponseStream.GetChunkSizeBytes(count, false);
				this.InternalWrite(array, 0, array.Length);
			}
			return this.stream.BeginWrite(buffer, offset, count, cback, state);
		}

		// Token: 0x06001514 RID: 5396 RVA: 0x00043778 File Offset: 0x00041978
		public override void EndWrite(IAsyncResult ares)
		{
			if (this.disposed)
			{
				throw new ObjectDisposedException(base.GetType().ToString());
			}
			if (this.ignore_errors)
			{
				try
				{
					this.stream.EndWrite(ares);
					if (this.response.SendChunked)
					{
						this.stream.Write(ResponseStream.crlf, 0, 2);
					}
				}
				catch
				{
				}
			}
			else
			{
				this.stream.EndWrite(ares);
				if (this.response.SendChunked)
				{
					this.stream.Write(ResponseStream.crlf, 0, 2);
				}
			}
		}

		// Token: 0x06001515 RID: 5397 RVA: 0x00043834 File Offset: 0x00041A34
		public override int Read([In] [Out] byte[] buffer, int offset, int count)
		{
			throw new NotSupportedException();
		}

		// Token: 0x06001516 RID: 5398 RVA: 0x0004383C File Offset: 0x00041A3C
		public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback cback, object state)
		{
			throw new NotSupportedException();
		}

		// Token: 0x06001517 RID: 5399 RVA: 0x00043844 File Offset: 0x00041A44
		public override int EndRead(IAsyncResult ares)
		{
			throw new NotSupportedException();
		}

		// Token: 0x06001518 RID: 5400 RVA: 0x0004384C File Offset: 0x00041A4C
		public override long Seek(long offset, SeekOrigin origin)
		{
			throw new NotSupportedException();
		}

		// Token: 0x06001519 RID: 5401 RVA: 0x00043854 File Offset: 0x00041A54
		public override void SetLength(long value)
		{
			throw new NotSupportedException();
		}

		// Token: 0x040011A5 RID: 4517
		private HttpListenerResponse response;

		// Token: 0x040011A6 RID: 4518
		private bool ignore_errors;

		// Token: 0x040011A7 RID: 4519
		private bool disposed;

		// Token: 0x040011A8 RID: 4520
		private bool trailer_sent;

		// Token: 0x040011A9 RID: 4521
		private Stream stream;

		// Token: 0x040011AA RID: 4522
		private static byte[] crlf = new byte[] { 13, 10 };
	}
}