using System;

namespace ICSharpCode.SharpZipLib.Zip.Compression
{
	// Token: 0x0200003F RID: 63
	public class Deflater
	{
		// Token: 0x06000278 RID: 632 RVA: 0x0000CE3A File Offset: 0x0000BE3A
		public Deflater()
			: this(-1, false)
		{
		}

		// Token: 0x06000279 RID: 633 RVA: 0x0000CE44 File Offset: 0x0000BE44
		public Deflater(int level)
			: this(level, false)
		{
		}

		// Token: 0x0600027A RID: 634 RVA: 0x0000CE50 File Offset: 0x0000BE50
		public Deflater(int level, bool noZlibHeaderOrFooter)
		{
			if (level == -1)
			{
				level = 6;
			}
			else if (level < 0 || level > 9)
			{
				throw new ArgumentOutOfRangeException("level");
			}
			this.pending = new DeflaterPending();
			this.engine = new DeflaterEngine(this.pending);
			this.noZlibHeaderOrFooter = noZlibHeaderOrFooter;
			this.SetStrategy(DeflateStrategy.Default);
			this.SetLevel(level);
			this.Reset();
		}

		// Token: 0x0600027B RID: 635 RVA: 0x0000CEB7 File Offset: 0x0000BEB7
		public void Reset()
		{
			this.state = (this.noZlibHeaderOrFooter ? 16 : 0);
			this.totalOut = 0L;
			this.pending.Reset();
			this.engine.Reset();
		}

		// Token: 0x1700008C RID: 140
		// (get) Token: 0x0600027C RID: 636 RVA: 0x0000CEEA File Offset: 0x0000BEEA
		public int Adler
		{
			get
			{
				return this.engine.Adler;
			}
		}

		// Token: 0x1700008D RID: 141
		// (get) Token: 0x0600027D RID: 637 RVA: 0x0000CEF7 File Offset: 0x0000BEF7
		public long TotalIn
		{
			get
			{
				return this.engine.TotalIn;
			}
		}

		// Token: 0x1700008E RID: 142
		// (get) Token: 0x0600027E RID: 638 RVA: 0x0000CF04 File Offset: 0x0000BF04
		public long TotalOut
		{
			get
			{
				return this.totalOut;
			}
		}

		// Token: 0x0600027F RID: 639 RVA: 0x0000CF0C File Offset: 0x0000BF0C
		public void Flush()
		{
			this.state |= 4;
		}

		// Token: 0x06000280 RID: 640 RVA: 0x0000CF1C File Offset: 0x0000BF1C
		public void Finish()
		{
			this.state |= 12;
		}

		// Token: 0x1700008F RID: 143
		// (get) Token: 0x06000281 RID: 641 RVA: 0x0000CF2D File Offset: 0x0000BF2D
		public bool IsFinished
		{
			get
			{
				return this.state == 30 && this.pending.IsFlushed;
			}
		}

		// Token: 0x17000090 RID: 144
		// (get) Token: 0x06000282 RID: 642 RVA: 0x0000CF46 File Offset: 0x0000BF46
		public bool IsNeedingInput
		{
			get
			{
				return this.engine.NeedsInput();
			}
		}

		// Token: 0x06000283 RID: 643 RVA: 0x0000CF53 File Offset: 0x0000BF53
		public void SetInput(byte[] input)
		{
			this.SetInput(input, 0, input.Length);
		}

		// Token: 0x06000284 RID: 644 RVA: 0x0000CF60 File Offset: 0x0000BF60
		public void SetInput(byte[] input, int offset, int count)
		{
			if ((this.state & 8) != 0)
			{
				throw new InvalidOperationException("Finish() already called");
			}
			this.engine.SetInput(input, offset, count);
		}

		// Token: 0x06000285 RID: 645 RVA: 0x0000CF85 File Offset: 0x0000BF85
		public void SetLevel(int level)
		{
			if (level == -1)
			{
				level = 6;
			}
			else if (level < 0 || level > 9)
			{
				throw new ArgumentOutOfRangeException("level");
			}
			if (this.level != level)
			{
				this.level = level;
				this.engine.SetLevel(level);
			}
		}

		// Token: 0x06000286 RID: 646 RVA: 0x0000CFC0 File Offset: 0x0000BFC0
		public int GetLevel()
		{
			return this.level;
		}

		// Token: 0x06000287 RID: 647 RVA: 0x0000CFC8 File Offset: 0x0000BFC8
		public void SetStrategy(DeflateStrategy strategy)
		{
			this.engine.Strategy = strategy;
		}

		// Token: 0x06000288 RID: 648 RVA: 0x0000CFD6 File Offset: 0x0000BFD6
		public int Deflate(byte[] output)
		{
			return this.Deflate(output, 0, output.Length);
		}

		// Token: 0x06000289 RID: 649 RVA: 0x0000CFE4 File Offset: 0x0000BFE4
		public int Deflate(byte[] output, int offset, int length)
		{
			int num = length;
			if (this.state == 127)
			{
				throw new InvalidOperationException("Deflater closed");
			}
			if (this.state < 16)
			{
				int num2 = 30720;
				int num3 = this.level - 1 >> 1;
				if (num3 < 0 || num3 > 3)
				{
					num3 = 3;
				}
				num2 |= num3 << 6;
				if ((this.state & 1) != 0)
				{
					num2 |= 32;
				}
				num2 += 31 - num2 % 31;
				this.pending.WriteShortMSB(num2);
				if ((this.state & 1) != 0)
				{
					int adler = this.engine.Adler;
					this.engine.ResetAdler();
					this.pending.WriteShortMSB(adler >> 16);
					this.pending.WriteShortMSB(adler & 65535);
				}
				this.state = 16 | (this.state & 12);
			}
			for (;;)
			{
				int num4 = this.pending.Flush(output, offset, length);
				offset += num4;
				this.totalOut += (long)num4;
				length -= num4;
				if (length == 0 || this.state == 30)
				{
					goto IL_1DE;
				}
				if (!this.engine.Deflate((this.state & 4) != 0, (this.state & 8) != 0))
				{
					if (this.state == 16)
					{
						break;
					}
					if (this.state == 20)
					{
						if (this.level != 0)
						{
							for (int i = 8 + (-this.pending.BitCount & 7); i > 0; i -= 10)
							{
								this.pending.WriteBits(2, 10);
							}
						}
						this.state = 16;
					}
					else if (this.state == 28)
					{
						this.pending.AlignToByte();
						if (!this.noZlibHeaderOrFooter)
						{
							int adler2 = this.engine.Adler;
							this.pending.WriteShortMSB(adler2 >> 16);
							this.pending.WriteShortMSB(adler2 & 65535);
						}
						this.state = 30;
					}
				}
			}
			return num - length;
			IL_1DE:
			return num - length;
		}

		// Token: 0x0600028A RID: 650 RVA: 0x0000D1D2 File Offset: 0x0000C1D2
		public void SetDictionary(byte[] dictionary)
		{
			this.SetDictionary(dictionary, 0, dictionary.Length);
		}

		// Token: 0x0600028B RID: 651 RVA: 0x0000D1DF File Offset: 0x0000C1DF
		public void SetDictionary(byte[] dictionary, int index, int count)
		{
			if (this.state != 0)
			{
				throw new InvalidOperationException();
			}
			this.state = 1;
			this.engine.SetDictionary(dictionary, index, count);
		}

		// Token: 0x0400015A RID: 346
		public const int BEST_COMPRESSION = 9;

		// Token: 0x0400015B RID: 347
		public const int BEST_SPEED = 1;

		// Token: 0x0400015C RID: 348
		public const int DEFAULT_COMPRESSION = -1;

		// Token: 0x0400015D RID: 349
		public const int NO_COMPRESSION = 0;

		// Token: 0x0400015E RID: 350
		public const int DEFLATED = 8;

		// Token: 0x0400015F RID: 351
		private const int IS_SETDICT = 1;

		// Token: 0x04000160 RID: 352
		private const int IS_FLUSHING = 4;

		// Token: 0x04000161 RID: 353
		private const int IS_FINISHING = 8;

		// Token: 0x04000162 RID: 354
		private const int INIT_STATE = 0;

		// Token: 0x04000163 RID: 355
		private const int SETDICT_STATE = 1;

		// Token: 0x04000164 RID: 356
		private const int BUSY_STATE = 16;

		// Token: 0x04000165 RID: 357
		private const int FLUSHING_STATE = 20;

		// Token: 0x04000166 RID: 358
		private const int FINISHING_STATE = 28;

		// Token: 0x04000167 RID: 359
		private const int FINISHED_STATE = 30;

		// Token: 0x04000168 RID: 360
		private const int CLOSED_STATE = 127;

		// Token: 0x04000169 RID: 361
		private int level;

		// Token: 0x0400016A RID: 362
		private bool noZlibHeaderOrFooter;

		// Token: 0x0400016B RID: 363
		private int state;

		// Token: 0x0400016C RID: 364
		private long totalOut;

		// Token: 0x0400016D RID: 365
		private DeflaterPending pending;

		// Token: 0x0400016E RID: 366
		private DeflaterEngine engine;
	}
}