// LzmaDecoder.cs

using System;

namespace SevenZip.Compression.LZMA

{

	using RangeCoder;

	public class Decoder : ICoder, ISetDecoderProperties // ,System.IO.Stream

	{

		class LenDecoder

		{

			BitDecoder m_Choice = new BitDecoder();

			BitDecoder m_Choice2 = new BitDecoder();

			BitTreeDecoder[] m_LowCoder = new BitTreeDecoder[Base.kNumPosStatesMax];

			BitTreeDecoder[] m_MidCoder = new BitTreeDecoder[Base.kNumPosStatesMax];

			BitTreeDecoder m_HighCoder = new BitTreeDecoder(Base.kNumHighLenBits);

			uint m_NumPosStates = 0;

			public void Create(uint numPosStates)

			{

				for (uint posState = m_NumPosStates; posState < numPosStates; posState++)

				{

					m_LowCoder[posState] = new BitTreeDecoder(Base.kNumLowLenBits);

					m_MidCoder[posState] = new BitTreeDecoder(Base.kNumMidLenBits);

				}

				m_NumPosStates = numPosStates;

			}

			public void Init()

			{

				m_Choice.Init();

				for (uint posState = 0; posState < m_NumPosStates; posState++)

				{

					m_LowCoder[posState].Init();

					m_MidCoder[posState].Init();

				}

				m_Choice2.Init();

				m_HighCoder.Init();

			}

			public uint Decode(RangeCoder.Decoder rangeDecoder, uint posState)

			{

				if (m_Choice.Decode(rangeDecoder) == 0)

					return m_LowCoder[posState].Decode(rangeDecoder);

				else

				{

					uint symbol = Base.kNumLowLenSymbols;

					if (m_Choice2.Decode(rangeDecoder) == 0)

						symbol += m_MidCoder[posState].Decode(rangeDecoder);

					else

					{

						symbol += Base.kNumMidLenSymbols;

						symbol += m_HighCoder.Decode(rangeDecoder);

					}

					return symbol;

				}

			}

		}

		class LiteralDecoder

		{

			struct Decoder2

			{

				BitDecoder[] m_Decoders;

				public void Create() { m_Decoders = new BitDecoder[0x300]; }

				public void Init() { for (int i = 0; i < 0x300; i++) m_Decoders[i].Init(); }

				public byte DecodeNormal(RangeCoder.Decoder rangeDecoder)

				{

					uint symbol = 1;

					do

						symbol = (symbol << 1) | m_Decoders[symbol].Decode(rangeDecoder);

					while (symbol < 0x100);

					return (byte)symbol;

				}

				public byte DecodeWithMatchByte(RangeCoder.Decoder rangeDecoder, byte matchByte)

				{

					uint symbol = 1;

					do

					{

						uint matchBit = (uint)(matchByte >> 7) & 1;

						matchByte <<= 1;

						uint bit = m_Decoders[((1 + matchBit) << 8) + symbol].Decode(rangeDecoder);

						symbol = (symbol << 1) | bit;

						if (matchBit != bit)

						{

							while (symbol < 0x100)

								symbol = (symbol << 1) | m_Decoders[symbol].Decode(rangeDecoder);

							break;

						}

					}

					while (symbol < 0x100);

					return (byte)symbol;

				}

			}

			Decoder2[] m_Coders;

			int m_NumPrevBits;

			int m_NumPosBits;

			uint m_PosMask;

			public void Create(int numPosBits, int numPrevBits)

			{

				if (m_Coders != null && m_NumPrevBits == numPrevBits &&

					m_NumPosBits == numPosBits)

					return;

				m_NumPosBits = numPosBits;

				m_PosMask = ((uint)1 << numPosBits) - 1;

				m_NumPrevBits = numPrevBits;

				uint numStates = (uint)1 << (m_NumPrevBits + m_NumPosBits);

				m_Coders = new Decoder2[numStates];

				for (uint i = 0; i < numStates; i++)

					m_Coders[i].Create();

			}

			public void Init()

			{

				uint numStates = (uint)1 << (m_NumPrevBits + m_NumPosBits);

				for (uint i = 0; i < numStates; i++)

					m_Coders[i].Init();

			}

			uint GetState(uint pos, byte prevByte)

			{ return ((pos & m_PosMask) << m_NumPrevBits) + (uint)(prevByte >> (8 - m_NumPrevBits)); }

			public byte DecodeNormal(RangeCoder.Decoder rangeDecoder, uint pos, byte prevByte)

			{ return m_Coders[GetState(pos, prevByte)].DecodeNormal(rangeDecoder); }

			public byte DecodeWithMatchByte(RangeCoder.Decoder rangeDecoder, uint pos, byte prevByte, byte matchByte)

			{ return m_Coders[GetState(pos, prevByte)].DecodeWithMatchByte(rangeDecoder, matchByte); }

		};

		LZ.OutWindow m_OutWindow = new LZ.OutWindow();

		RangeCoder.Decoder m_RangeDecoder = new RangeCoder.Decoder();

		BitDecoder[] m_IsMatchDecoders = new BitDecoder[Base.kNumStates << Base.kNumPosStatesBitsMax];

		BitDecoder[] m_IsRepDecoders = new BitDecoder[Base.kNumStates];

		BitDecoder[] m_IsRepG0Decoders = new BitDecoder[Base.kNumStates];

		BitDecoder[] m_IsRepG1Decoders = new BitDecoder[Base.kNumStates];

		BitDecoder[] m_IsRepG2Decoders = new BitDecoder[Base.kNumStates];

		BitDecoder[] m_IsRep0LongDecoders = new BitDecoder[Base.kNumStates << Base.kNumPosStatesBitsMax];

		BitTreeDecoder[] m_PosSlotDecoder = new BitTreeDecoder[Base.kNumLenToPosStates];

		BitDecoder[] m_PosDecoders = new BitDecoder[Base.kNumFullDistances - Base.kEndPosModelIndex];

		BitTreeDecoder m_PosAlignDecoder = new BitTreeDecoder(Base.kNumAlignBits);

		LenDecoder m_LenDecoder = new LenDecoder();

		LenDecoder m_RepLenDecoder = new LenDecoder();

		LiteralDecoder m_LiteralDecoder = new LiteralDecoder();

		uint m_DictionarySize;

		uint m_DictionarySizeCheck;

		uint m_PosStateMask;

		public Decoder()

		{

			m_DictionarySize = 0xFFFFFFFF;

			for (int i = 0; i < Base.kNumLenToPosStates; i++)

				m_PosSlotDecoder[i] = new BitTreeDecoder(Base.kNumPosSlotBits);

		}

		void SetDictionarySize(uint dictionarySize)

		{

			if (m_DictionarySize != dictionarySize)

			{

				m_DictionarySize = dictionarySize;

				m_DictionarySizeCheck = Math.Max(m_DictionarySize, 1);

				uint blockSize = Math.Max(m_DictionarySizeCheck, (1 << 12));

				m_OutWindow.Create(blockSize);

			}

		}

		void SetLiteralProperties(int lp, int lc)

		{

			if (lp > 8)

				throw new InvalidParamException();

			if (lc > 8)

				throw new InvalidParamException();

			m_LiteralDecoder.Create(lp, lc);

		}

		void SetPosBitsProperties(int pb)

		{

			if (pb > Base.kNumPosStatesBitsMax)

				throw new InvalidParamException();

			uint numPosStates = (uint)1 << pb;

			m_LenDecoder.Create(numPosStates);

			m_RepLenDecoder.Create(numPosStates);

			m_PosStateMask = numPosStates - 1;

		}

		bool _solid = false;

		void Init(System.IO.Stream inStream, System.IO.Stream outStream)

		{

			m_RangeDecoder.Init(inStream);

			m_OutWindow.Init(outStream, _solid);

			uint i;

			for (i = 0; i < Base.kNumStates; i++)

			{

				for (uint j = 0; j <= m_PosStateMask; j++)

				{

					uint index = (i << Base.kNumPosStatesBitsMax) + j;

					m_IsMatchDecoders[index].Init();

					m_IsRep0LongDecoders[index].Init();

				}

				m_IsRepDecoders[i].Init();

				m_IsRepG0Decoders[i].Init();

				m_IsRepG1Decoders[i].Init();

				m_IsRepG2Decoders[i].Init();

			}

			m_LiteralDecoder.Init();

			for (i = 0; i < Base.kNumLenToPosStates; i++)

				m_PosSlotDecoder[i].Init();

			// m_PosSpecDecoder.Init();

			for (i = 0; i < Base.kNumFullDistances - Base.kEndPosModelIndex; i++)

				m_PosDecoders[i].Init();

			m_LenDecoder.Init();

			m_RepLenDecoder.Init();

			m_PosAlignDecoder.Init();

		}

		public void Code(System.IO.Stream inStream, System.IO.Stream outStream,

			Int64 inSize, Int64 outSize, ICodeProgress progress)

		{

			Init(inStream, outStream);

			Base.State state = new Base.State();

			state.Init();

			uint rep0 = 0, rep1 = 0, rep2 = 0, rep3 = 0;

			UInt64 nowPos64 = 0;

			UInt64 outSize64 = (UInt64)outSize;

			if (nowPos64 < outSize64)

			{

				if (m_IsMatchDecoders[state.Index << Base.kNumPosStatesBitsMax].Decode(m_RangeDecoder) != 0)

					throw new DataErrorException();

				state.UpdateChar();

				byte b = m_LiteralDecoder.DecodeNormal(m_RangeDecoder, 0, 0);

				m_OutWindow.PutByte(b);

				nowPos64++;

			}

			while (nowPos64 < outSize64)

			{

				// UInt64 next = Math.Min(nowPos64 + (1 << 18), outSize64);

					// while(nowPos64 < next)

				{

					uint posState = (uint)nowPos64 & m_PosStateMask;

					if (m_IsMatchDecoders[(state.Index << Base.kNumPosStatesBitsMax) + posState].Decode(m_RangeDecoder) == 0)

					{

						byte b;

						byte prevByte = m_OutWindow.GetByte(0);

						if (!state.IsCharState())

							b = m_LiteralDecoder.DecodeWithMatchByte(m_RangeDecoder,

								(uint)nowPos64, prevByte, m_OutWindow.GetByte(rep0));

						else

							b = m_LiteralDecoder.DecodeNormal(m_RangeDecoder, (uint)nowPos64, prevByte);

						m_OutWindow.PutByte(b);

						state.UpdateChar();

						nowPos64++;

					}

					else

					{

						uint len;

						if (m_IsRepDecoders[state.Index].Decode(m_RangeDecoder) == 1)

						{

							if (m_IsRepG0Decoders[state.Index].Decode(m_RangeDecoder) == 0)

							{

								if (m_IsRep0LongDecoders[(state.Index << Base.kNumPosStatesBitsMax) + posState].Decode(m_RangeDecoder) == 0)

								{

									state.UpdateShortRep();

									m_OutWindow.PutByte(m_OutWindow.GetByte(rep0));

									nowPos64++;

									continue;

								}

							}

							else

							{

								UInt32 distance;

								if (m_IsRepG1Decoders[state.Index].Decode(m_RangeDecoder) == 0)

								{

									distance = rep1;

								}

								else

								{

									if (m_IsRepG2Decoders[state.Index].Decode(m_RangeDecoder) == 0)

										distance = rep2;

									else

									{

										distance = rep3;

										rep3 = rep2;

									}

									rep2 = rep1;

								}

								rep1 = rep0;

								rep0 = distance;

							}

							len = m_RepLenDecoder.Decode(m_RangeDecoder, posState) + Base.kMatchMinLen;

							state.UpdateRep();

						}

						else

						{

							rep3 = rep2;

							rep2 = rep1;

							rep1 = rep0;

							len = Base.kMatchMinLen + m_LenDecoder.Decode(m_RangeDecoder, posState);

							state.UpdateMatch();

							uint posSlot = m_PosSlotDecoder[Base.GetLenToPosState(len)].Decode(m_RangeDecoder);

							if (posSlot >= Base.kStartPosModelIndex)

							{

								int numDirectBits = (int)((posSlot >> 1) - 1);

								rep0 = ((2 | (posSlot & 1)) << numDirectBits);

								if (posSlot < Base.kEndPosModelIndex)

									rep0 += BitTreeDecoder.ReverseDecode(m_PosDecoders,

											rep0 - posSlot - 1, m_RangeDecoder, numDirectBits);

								else

								{

									rep0 += (m_RangeDecoder.DecodeDirectBits(

										numDirectBits - Base.kNumAlignBits) << Base.kNumAlignBits);

									rep0 += m_PosAlignDecoder.ReverseDecode(m_RangeDecoder);

								}

							}

							else

								rep0 = posSlot;

						}

						if (rep0 >= m_OutWindow.TrainSize + nowPos64 || rep0 >= m_DictionarySizeCheck)

						{

							if (rep0 == 0xFFFFFFFF)

								break;

							throw new DataErrorException();

						}

						m_OutWindow.CopyBlock(rep0, len);

						nowPos64 += len;

					}

				}

			}

			m_OutWindow.Flush();

			m_OutWindow.ReleaseStream();

			m_RangeDecoder.ReleaseStream();

		}

		public void SetDecoderProperties(byte[] properties)

		{

			if (properties.Length < 5)

				throw new InvalidParamException();

			int lc = properties[0] % 9;

			int remainder = properties[0] / 9;

			int lp = remainder % 5;

			int pb = remainder / 5;

			if (pb > Base.kNumPosStatesBitsMax)

				throw new InvalidParamException();

			UInt32 dictionarySize = 0;

			for (int i = 0; i < 4; i++)

				dictionarySize += ((UInt32)(properties[1 + i])) << (i * 8);

			SetDictionarySize(dictionarySize);

			SetLiteralProperties(lp, lc);

			SetPosBitsProperties(pb);

		}

		public bool Train(System.IO.Stream stream)

		{

			_solid = true;

			return m_OutWindow.Train(stream);

		}

		/*

		public override bool CanRead { get { return true; }}

		public override bool CanWrite { get { return true; }}

		public override bool CanSeek { get { return true; }}

		public override long Length { get { return 0; }}

		public override long Position

		{

			get { return 0;	}

			set { }

		}

		public override void Flush() { }

		public override int Read(byte[] buffer, int offset, int count) 

		{

			return 0;

		}

		public override void Write(byte[] buffer, int offset, int count)

		{

		}

		public override long Seek(long offset, System.IO.SeekOrigin origin)

		{

			return 0;

		}

		public override void SetLength(long value) {}

		*/

	}

}