package SevenZip;

import java.io.ByteArrayOutputStream;

import java.io.ByteArrayInputStream;

import java.io.IOException;

public class LzmaBench

{

	static final int kAdditionalSize = (1 << 21);

	static final int kCompressedAdditionalSize = (1 << 10);

	static class CRandomGenerator

	{

		int A1;

		int A2;

		public CRandomGenerator() { Init(); }

		public void Init() { A1 = 362436069; A2 = 521288629; }

		public int GetRnd()

		{

			return

				((A1 = 36969 * (A1 & 0xffff) + (A1 >>> 16)) << 16) ^

				((A2 = 18000 * (A2 & 0xffff) + (A2 >>> 16)));

		}

	};

	static class CBitRandomGenerator

	{

		CRandomGenerator RG = new CRandomGenerator();

		int Value;

		int NumBits;

		public void Init()

		{

			Value = 0;

			NumBits = 0;

		}

		public int GetRnd(int numBits)

		{

			int result;

			if (NumBits > numBits)

			{

				result = Value & ((1 << numBits) - 1);

				Value >>>= numBits;

				NumBits -= numBits;

				return result;

			}

			numBits -= NumBits;

			result = (Value << numBits);

			Value = RG.GetRnd();

			result |= Value & (((int)1 << numBits) - 1);

			Value >>>= numBits;

			NumBits = 32 - numBits;

			return result;

		}

	};

	static class CBenchRandomGenerator

	{

		CBitRandomGenerator RG = new CBitRandomGenerator();

		int Pos;

		int Rep0;

		public int BufferSize;

		public byte[] Buffer = null;

		public CBenchRandomGenerator() { }

		public void Set(int bufferSize)

		{

			Buffer = new byte[bufferSize];

			Pos = 0;

			BufferSize = bufferSize;

		}

		int GetRndBit() { return RG.GetRnd(1); }

		int GetLogRandBits(int numBits)

		{

			int len = RG.GetRnd(numBits);

			return RG.GetRnd((int)len);

		}

		int GetOffset()

		{

			if (GetRndBit() == 0)

				return GetLogRandBits(4);

			return (GetLogRandBits(4) << 10) | RG.GetRnd(10);

		}

		int GetLen1() { return RG.GetRnd(1 + (int)RG.GetRnd(2)); }

		int GetLen2() { return RG.GetRnd(2 + (int)RG.GetRnd(2)); }

		public void Generate()

		{

			RG.Init();

			Rep0 = 1;

			while (Pos < BufferSize)

			{

				if (GetRndBit() == 0 || Pos < 1)

					Buffer[Pos++] = (byte)(RG.GetRnd(8));

				else

				{

					int len;

					if (RG.GetRnd(3) == 0)

						len = 1 + GetLen1();

					else

					{

						do

							Rep0 = GetOffset();

						while (Rep0 >= Pos);

						Rep0++;

						len = 2 + GetLen2();

					}

					for (int i = 0; i < len && Pos < BufferSize; i++, Pos++)

						Buffer[Pos] = Buffer[Pos - Rep0];

				}

			}

		}

	};

	static class CrcOutStream extends java.io.OutputStream

	{

		public CRC CRC = new CRC();

		public void Init()

		{ 

			CRC.Init(); 

		}

		public int GetDigest()

		{ 

			return CRC.GetDigest(); 

		}

		public void write(byte[] b)

		{

			CRC.Update(b);

		}

		public void write(byte[] b, int off, int len)

		{

			CRC.Update(b, off, len);

		}

		public void write(int b)

		{

			CRC.UpdateByte(b);

		}

	};

	static class MyOutputStream extends java.io.OutputStream

	{

		byte[] _buffer;

		int _size;

		int _pos;

		public MyOutputStream(byte[] buffer)

		{

			_buffer = buffer;

			_size = _buffer.length;

		}

		public void reset()

		{ 

			_pos = 0; 

		}

		public void write(int b) throws IOException

		{

			if (_pos >= _size)

				throw new IOException("Error");

			_buffer[_pos++] = (byte)b;

		}

		public int size()

		{

			return _pos;

		}

	};

	static class MyInputStream extends java.io.InputStream

	{

		byte[] _buffer;

		int _size;

		int _pos;

		public MyInputStream(byte[] buffer, int size)

		{

			_buffer = buffer;

			_size = size;

		}

		public void reset()

		{ 

			_pos = 0; 

		}

		public int read()

		{

			if (_pos >= _size)

				return -1;

			return _buffer[_pos++] & 0xFF;

		}

	};

	static class CProgressInfo implements ICodeProgress

	{

		public long ApprovedStart;

		public long InSize;

		public long Time;

		public void Init()

		{ InSize = 0; }

		public void SetProgress(long inSize, long outSize)

		{

			if (inSize >= ApprovedStart && InSize == 0)

			{

				Time = System.currentTimeMillis();

				InSize = inSize;

			}

		}

	}

	static final int kSubBits = 8;

	static int GetLogSize(int size)

	{

		for (int i = kSubBits; i < 32; i++)

			for (int j = 0; j < (1 << kSubBits); j++)

				if (size <= ((1) << i) + (j << (i - kSubBits)))

					return (i << kSubBits) + j;

		return (32 << kSubBits);

	}

	static long MyMultDiv64(long value, long elapsedTime)

	{

		long freq = 1000; // ms

		long elTime = elapsedTime;

		while (freq > 1000000)

		{

			freq >>>= 1;

			elTime >>>= 1;

		}

		if (elTime == 0)

			elTime = 1;

		return value * freq / elTime;

	}

	static long GetCompressRating(int dictionarySize, long elapsedTime, long size)

	{

		long t = GetLogSize(dictionarySize) - (18 << kSubBits);

		long numCommandsForOne = 1060 + ((t * t * 10) >> (2 * kSubBits));

		long numCommands = (long)(size) * numCommandsForOne;

		return MyMultDiv64(numCommands, elapsedTime);

	}

	static long GetDecompressRating(long elapsedTime, long outSize, long inSize)

	{

		long numCommands = inSize * 220 + outSize * 20;

		return MyMultDiv64(numCommands, elapsedTime);

	}

	static long GetTotalRating(

			int dictionarySize,

			long elapsedTimeEn, long sizeEn,

			long elapsedTimeDe,

			long inSizeDe, long outSizeDe)

	{

		return (GetCompressRating(dictionarySize, elapsedTimeEn, sizeEn) +

				GetDecompressRating(elapsedTimeDe, inSizeDe, outSizeDe)) / 2;

	}

	static void PrintValue(long v)

	{

		String s = "";

		s += v;

		for (int i = 0; i + s.length() < 6; i++)

			System.out.print(" ");

		System.out.print(s);

	}

	static void PrintRating(long rating)

	{

		PrintValue(rating / 1000000);

		System.out.print(" MIPS");

	}

	static void PrintResults(

			int dictionarySize,

			long elapsedTime,

			long size,

			boolean decompressMode, long secondSize)

	{

		long speed = MyMultDiv64(size, elapsedTime);

		PrintValue(speed / 1024);

		System.out.print(" KB/s  ");

		long rating;

		if (decompressMode)

			rating = GetDecompressRating(elapsedTime, size, secondSize);

		else

			rating = GetCompressRating(dictionarySize, elapsedTime, size);

		PrintRating(rating);

	}

	static public int LzmaBenchmark(int numIterations, int dictionarySize) throws Exception

	{

		if (numIterations <= 0)

			return 0;

		if (dictionarySize < (1 << 18))

		{

			System.out.println("\nError: dictionary size for benchmark must be >= 18 (256 KB)");

			return 1;

		}

		System.out.print("\n       Compressing                Decompressing\n\n");

		SevenZip.Compression.LZMA.Encoder encoder = new SevenZip.Compression.LZMA.Encoder();

		SevenZip.Compression.LZMA.Decoder decoder = new SevenZip.Compression.LZMA.Decoder();

		if (!encoder.SetDictionarySize(dictionarySize))

			throw new Exception("Incorrect dictionary size");

		int kBufferSize = dictionarySize + kAdditionalSize;

		int kCompressedBufferSize = (kBufferSize / 2) + kCompressedAdditionalSize;

		ByteArrayOutputStream propStream = new ByteArrayOutputStream();

		encoder.WriteCoderProperties(propStream);

		byte[] propArray = propStream.toByteArray();

		decoder.SetDecoderProperties(propArray);

		CBenchRandomGenerator rg = new CBenchRandomGenerator();

		rg.Set(kBufferSize);

		rg.Generate();

		CRC crc = new CRC();

		crc.Init();

		crc.Update(rg.Buffer, 0, rg.BufferSize);

		CProgressInfo progressInfo = new CProgressInfo();

		progressInfo.ApprovedStart = dictionarySize;

		long totalBenchSize = 0;

		long totalEncodeTime = 0;

		long totalDecodeTime = 0;

		long totalCompressedSize = 0;

		MyInputStream inStream = new MyInputStream(rg.Buffer, rg.BufferSize);

		byte[] compressedBuffer = new byte[kCompressedBufferSize];

		MyOutputStream compressedStream = new MyOutputStream(compressedBuffer);

		CrcOutStream crcOutStream = new CrcOutStream();

		MyInputStream inputCompressedStream = null;

		int compressedSize = 0;

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

		{

			progressInfo.Init();

			inStream.reset();

			compressedStream.reset();

			encoder.Code(inStream, compressedStream, -1, -1, progressInfo);

			long encodeTime = System.currentTimeMillis() - progressInfo.Time;

			if (i == 0)

			{

				compressedSize = compressedStream.size();

				inputCompressedStream = new MyInputStream(compressedBuffer, compressedSize);

			}

			else if (compressedSize != compressedStream.size())

				throw (new Exception("Encoding error"));

			if (progressInfo.InSize == 0)

				throw (new Exception("Internal ERROR 1282"));

			long decodeTime = 0;

			for (int j = 0; j < 2; j++)

			{

				inputCompressedStream.reset();

				crcOutStream.Init();

				long outSize = kBufferSize;

				long startTime = System.currentTimeMillis();

				if (!decoder.Code(inputCompressedStream, crcOutStream, outSize))

					throw (new Exception("Decoding Error"));;

				decodeTime = System.currentTimeMillis() - startTime;

				if (crcOutStream.GetDigest() != crc.GetDigest())

					throw (new Exception("CRC Error"));

			}

			long benchSize = kBufferSize - (long)progressInfo.InSize;

			PrintResults(dictionarySize, encodeTime, benchSize, false, 0);

			System.out.print("     ");

			PrintResults(dictionarySize, decodeTime, kBufferSize, true, compressedSize);

			System.out.println();

			totalBenchSize += benchSize;

			totalEncodeTime += encodeTime;

			totalDecodeTime += decodeTime;

			totalCompressedSize += compressedSize;

		}

		System.out.println("---------------------------------------------------");

		PrintResults(dictionarySize, totalEncodeTime, totalBenchSize, false, 0);

		System.out.print("     ");

		PrintResults(dictionarySize, totalDecodeTime,

				kBufferSize * (long)numIterations, true, totalCompressedSize);

		System.out.println("    Average");

		return 0;

	}

}