using System;
using System.IO;

namespace ICSharpCode.SharpZipLib.Tar
{
	// Token: 0x0200003B RID: 59
	public class TarOutputStream : Stream
	{
		// Token: 0x06000238 RID: 568 RVA: 0x0000BEBE File Offset: 0x0000AEBE
		public TarOutputStream(Stream outputStream)
			: this(outputStream, 20)
		{
		}

		// Token: 0x06000239 RID: 569 RVA: 0x0000BECC File Offset: 0x0000AECC
		public TarOutputStream(Stream outputStream, int blockFactor)
		{
			if (outputStream == null)
			{
				throw new ArgumentNullException("outputStream");
			}
			this.outputStream = outputStream;
			this.buffer = TarBuffer.CreateOutputTarBuffer(outputStream, blockFactor);
			this.assemblyBuffer = new byte[512];
			this.blockBuffer = new byte[512];
		}

		// Token: 0x1700007B RID: 123
		// (get) Token: 0x0600023A RID: 570 RVA: 0x0000BF21 File Offset: 0x0000AF21
		// (set) Token: 0x0600023B RID: 571 RVA: 0x0000BF2E File Offset: 0x0000AF2E
		public bool IsStreamOwner
		{
			get
			{
				return this.buffer.IsStreamOwner;
			}
			set
			{
				this.buffer.IsStreamOwner = value;
			}
		}

		// Token: 0x1700007C RID: 124
		// (get) Token: 0x0600023C RID: 572 RVA: 0x0000BF3C File Offset: 0x0000AF3C
		public override bool CanRead
		{
			get
			{
				return this.outputStream.CanRead;
			}
		}

		// Token: 0x1700007D RID: 125
		// (get) Token: 0x0600023D RID: 573 RVA: 0x0000BF49 File Offset: 0x0000AF49
		public override bool CanSeek
		{
			get
			{
				return this.outputStream.CanSeek;
			}
		}

		// Token: 0x1700007E RID: 126
		// (get) Token: 0x0600023E RID: 574 RVA: 0x0000BF56 File Offset: 0x0000AF56
		public override bool CanWrite
		{
			get
			{
				return this.outputStream.CanWrite;
			}
		}

		// Token: 0x1700007F RID: 127
		// (get) Token: 0x0600023F RID: 575 RVA: 0x0000BF63 File Offset: 0x0000AF63
		public override long Length
		{
			get
			{
				return this.outputStream.Length;
			}
		}

		// Token: 0x17000080 RID: 128
		// (get) Token: 0x06000240 RID: 576 RVA: 0x0000BF70 File Offset: 0x0000AF70
		// (set) Token: 0x06000241 RID: 577 RVA: 0x0000BF7D File Offset: 0x0000AF7D
		public override long Position
		{
			get
			{
				return this.outputStream.Position;
			}
			set
			{
				this.outputStream.Position = value;
			}
		}

		// Token: 0x06000242 RID: 578 RVA: 0x0000BF8B File Offset: 0x0000AF8B
		public override long Seek(long offset, SeekOrigin origin)
		{
			return this.outputStream.Seek(offset, origin);
		}

		// Token: 0x06000243 RID: 579 RVA: 0x0000BF9A File Offset: 0x0000AF9A
		public override void SetLength(long value)
		{
			this.outputStream.SetLength(value);
		}

		// Token: 0x06000244 RID: 580 RVA: 0x0000BFA8 File Offset: 0x0000AFA8
		public override int ReadByte()
		{
			return this.outputStream.ReadByte();
		}

		// Token: 0x06000245 RID: 581 RVA: 0x0000BFB5 File Offset: 0x0000AFB5
		public override int Read(byte[] buffer, int offset, int count)
		{
			return this.outputStream.Read(buffer, offset, count);
		}

		// Token: 0x06000246 RID: 582 RVA: 0x0000BFC5 File Offset: 0x0000AFC5
		public override void Flush()
		{
			this.outputStream.Flush();
		}

		// Token: 0x06000247 RID: 583 RVA: 0x0000BFD2 File Offset: 0x0000AFD2
		public void Finish()
		{
			if (this.IsEntryOpen)
			{
				this.CloseEntry();
			}
			this.WriteEofBlock();
		}

		// Token: 0x06000248 RID: 584 RVA: 0x0000BFE8 File Offset: 0x0000AFE8
		public override void Close()
		{
			if (!this.isClosed)
			{
				this.isClosed = true;
				this.Finish();
				this.buffer.Close();
			}
		}

		// Token: 0x17000081 RID: 129
		// (get) Token: 0x06000249 RID: 585 RVA: 0x0000C00A File Offset: 0x0000B00A
		public int RecordSize
		{
			get
			{
				return this.buffer.RecordSize;
			}
		}

		// Token: 0x0600024A RID: 586 RVA: 0x0000C017 File Offset: 0x0000B017
		[Obsolete("Use RecordSize property instead")]
		public int GetRecordSize()
		{
			return this.buffer.RecordSize;
		}

		// Token: 0x17000082 RID: 130
		// (get) Token: 0x0600024B RID: 587 RVA: 0x0000C024 File Offset: 0x0000B024
		private bool IsEntryOpen
		{
			get
			{
				return this.currBytes < this.currSize;
			}
		}

		// Token: 0x0600024C RID: 588 RVA: 0x0000C034 File Offset: 0x0000B034
		public void PutNextEntry(TarEntry entry)
		{
			if (entry == null)
			{
				throw new ArgumentNullException("entry");
			}
			if (entry.TarHeader.Name.Length >= 100)
			{
				TarHeader tarHeader = new TarHeader();
				tarHeader.TypeFlag = 76;
				tarHeader.Name += "././@LongLink";
				tarHeader.UserId = 0;
				tarHeader.GroupId = 0;
				tarHeader.GroupName = "";
				tarHeader.UserName = "";
				tarHeader.LinkName = "";
				tarHeader.Size = (long)entry.TarHeader.Name.Length;
				tarHeader.WriteHeader(this.blockBuffer);
				this.buffer.WriteBlock(this.blockBuffer);
				int i = 0;
				while (i < entry.TarHeader.Name.Length)
				{
					Array.Clear(this.blockBuffer, 0, this.blockBuffer.Length);
					TarHeader.GetAsciiBytes(entry.TarHeader.Name, i, this.blockBuffer, 0, 512);
					i += 512;
					this.buffer.WriteBlock(this.blockBuffer);
				}
			}
			entry.WriteEntryHeader(this.blockBuffer);
			this.buffer.WriteBlock(this.blockBuffer);
			this.currBytes = 0L;
			this.currSize = (entry.IsDirectory ? 0L : entry.Size);
		}

		// Token: 0x0600024D RID: 589 RVA: 0x0000C18C File Offset: 0x0000B18C
		public void CloseEntry()
		{
			if (this.assemblyBufferLength > 0)
			{
				Array.Clear(this.assemblyBuffer, this.assemblyBufferLength, this.assemblyBuffer.Length - this.assemblyBufferLength);
				this.buffer.WriteBlock(this.assemblyBuffer);
				this.currBytes += (long)this.assemblyBufferLength;
				this.assemblyBufferLength = 0;
			}
			if (this.currBytes < this.currSize)
			{
				string text = string.Format("Entry closed at '{0}' before the '{1}' bytes specified in the header were written", this.currBytes, this.currSize);
				throw new TarException(text);
			}
		}

		// Token: 0x0600024E RID: 590 RVA: 0x0000C224 File Offset: 0x0000B224
		public override void WriteByte(byte value)
		{
			this.Write(new byte[] { value }, 0, 1);
		}

		// Token: 0x0600024F RID: 591 RVA: 0x0000C248 File Offset: 0x0000B248
		public override void Write(byte[] buffer, int offset, int count)
		{
			if (buffer == null)
			{
				throw new ArgumentNullException("buffer");
			}
			if (offset < 0)
			{
				throw new ArgumentOutOfRangeException("offset", "Cannot be negative");
			}
			if (buffer.Length - offset < count)
			{
				throw new ArgumentException("offset and count combination is invalid");
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", "Cannot be negative");
			}
			if (this.currBytes + (long)count > this.currSize)
			{
				string text = string.Format("request to write '{0}' bytes exceeds size in header of '{1}' bytes", count, this.currSize);
				throw new ArgumentOutOfRangeException("count", text);
			}
			if (this.assemblyBufferLength > 0)
			{
				if (this.assemblyBufferLength + count >= this.blockBuffer.Length)
				{
					int num = this.blockBuffer.Length - this.assemblyBufferLength;
					Array.Copy(this.assemblyBuffer, 0, this.blockBuffer, 0, this.assemblyBufferLength);
					Array.Copy(buffer, offset, this.blockBuffer, this.assemblyBufferLength, num);
					this.buffer.WriteBlock(this.blockBuffer);
					this.currBytes += (long)this.blockBuffer.Length;
					offset += num;
					count -= num;
					this.assemblyBufferLength = 0;
				}
				else
				{
					Array.Copy(buffer, offset, this.assemblyBuffer, this.assemblyBufferLength, count);
					offset += count;
					this.assemblyBufferLength += count;
					count -= count;
				}
			}
			while (count > 0)
			{
				if (count < this.blockBuffer.Length)
				{
					Array.Copy(buffer, offset, this.assemblyBuffer, this.assemblyBufferLength, count);
					this.assemblyBufferLength += count;
					return;
				}
				this.buffer.WriteBlock(buffer, offset);
				int num2 = this.blockBuffer.Length;
				this.currBytes += (long)num2;
				count -= num2;
				offset += num2;
			}
		}

		// Token: 0x06000250 RID: 592 RVA: 0x0000C3FE File Offset: 0x0000B3FE
		private void WriteEofBlock()
		{
			Array.Clear(this.blockBuffer, 0, this.blockBuffer.Length);
			this.buffer.WriteBlock(this.blockBuffer);
		}

		// Token: 0x04000140 RID: 320
		private long currBytes;

		// Token: 0x04000141 RID: 321
		private int assemblyBufferLength;

		// Token: 0x04000142 RID: 322
		private bool isClosed;

		// Token: 0x04000143 RID: 323
		protected long currSize;

		// Token: 0x04000144 RID: 324
		protected byte[] blockBuffer;

		// Token: 0x04000145 RID: 325
		protected byte[] assemblyBuffer;

		// Token: 0x04000146 RID: 326
		protected TarBuffer buffer;

		// Token: 0x04000147 RID: 327
		protected Stream outputStream;
	}
}