/*
 * Improved version to C# LibLZF Port:
 * Copyright (c) 2010 Roman Atachiants <kelindar@gmail.com>
 *
 * Original CLZF Port:
 * Copyright (c) 2005 Oren J. Maurice <oymaurice@hazorea.org.il>
 *
 * Original LibLZF Library  Algorithm:
 * Copyright (c) 2000-2008 Marc Alexander Lehmann <schmorp@schmorp.de>
 *
 * Redistribution and use in source and binary forms, with or without modifica-
 * tion, are permitted provided that the following conditions are met:
 *
 *   1.  Redistributions of source code must retain the above copyright notice,
 *       this list of conditions and the following disclaimer.
 *
 *   2.  Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *
 *   3.  The name of the author may not be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
 * CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO
 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
 * CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
 * ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * Alternatively, the contents of this file may be used under the terms of
 * the GNU General Public License version 2 (the "GPL"), in which case the
 * provisions of the GPL are applicable instead of the above. If you wish to
 * allow the use of your version of this file only under the terms of the
 * GPL and not to allow others to use your version of this file under the
 * BSD license, indicate your decision by deleting the provisions above and
 * replace them with the notice and other provisions required by the GPL. If
 * you do not delete the provisions above, a recipient may use your version
 * of this file under either the BSD or the GPL.
 */
using System;

/* Benchmark with Alice29 Canterbury Corpus
        ---------------------------------------
        (Compression) Original CLZF C#
        Raw = 152089, Compressed = 101092
         8292,4743 ms.
        ---------------------------------------
        (Compression) My LZF C#
        Raw = 152089, Compressed = 101092
         33,0019 ms.
        ---------------------------------------
        (Compression) Zlib using SharpZipLib
        Raw = 152089, Compressed = 54388
         8389,4799 ms.
        ---------------------------------------
        (Compression) QuickLZ C#
        Raw = 152089, Compressed = 83494
         80,0046 ms.
        ---------------------------------------
        (Decompression) Original CLZF C#
        Decompressed = 152089
         16,0009 ms.
        ---------------------------------------
        (Decompression) My LZF C#
        Decompressed = 152089
         15,0009 ms.
        ---------------------------------------
        (Decompression) Zlib using SharpZipLib
        Decompressed = 152089
         3577,2046 ms.
        ---------------------------------------
        (Decompression) QuickLZ C#
        Decompressed = 152089
         21,0012 ms.
    */

#if NETFX_CORE && (UNITY_4_6 || UNITY_4_5)
using UnityEngine.Windows;
#endif

/// <summary>
/// Improved C# LZF Compressor, a very small data compression library. The compression algorithm is extremely fast.
public static class CLZF2
{
	private static readonly uint HLOG = 14;
	private static readonly uint HSIZE = (1 << 14);
	private static readonly uint MAX_LIT = (1 << 5);
	private static readonly uint MAX_OFF = (1 << 13);
	private static readonly uint MAX_REF = ((1 << 8) + (1 << 3));

	/// <summary>
	/// Hashtable, that can be allocated only once
	/// </summary>
	private static readonly long[] HashTable = new long[HSIZE];

	// Compresses inputBytes
	public static byte[] Compress(byte[] inputBytes)
	{
		// Starting guess, increase it later if needed
		int outputByteCountGuess = inputBytes.Length * 2;
		byte[] tempBuffer = new byte[outputByteCountGuess];
		int byteCount = lzf_compress (inputBytes, ref tempBuffer);

		// If byteCount is 0, then increase buffer and try again
		while (byteCount == 0)
		{
			outputByteCountGuess *=2;
			tempBuffer = new byte[outputByteCountGuess];
			byteCount = lzf_compress (inputBytes, ref tempBuffer);
		}

		byte[] outputBytes = new byte[byteCount];
		Buffer.BlockCopy(tempBuffer, 0, outputBytes, 0, byteCount);
		return outputBytes;
	}

	// Decompress outputBytes
	public static byte[] Decompress(byte[] inputBytes)
	{
		// Starting guess, increase it later if needed
		int outputByteCountGuess = inputBytes.Length * 2;
		byte[] tempBuffer = new byte[outputByteCountGuess];
		int byteCount = lzf_decompress (inputBytes, ref tempBuffer);

		// If byteCount is 0, then increase buffer and try again
		while (byteCount == 0)
		{
			outputByteCountGuess *=2;
			tempBuffer = new byte[outputByteCountGuess];
			byteCount = lzf_decompress (inputBytes, ref tempBuffer);
		}

		byte[] outputBytes = new byte[byteCount];
		Buffer.BlockCopy(tempBuffer, 0, outputBytes, 0, byteCount);
		return outputBytes;
	}

	#if !NETFX_CORE
	private static System.Threading.Thread decompressionThread;
	#endif
	public static void DecompressBytesAsync(byte[] input, Action<byte[]> callback)
	{
		runActOnBytesWithCallback = true;
		#if !NETFX_CORE
		if (decompressionThread==null) {
			UnityEngine.Debug.Log ("STARTING DECOMPRESSION THREAD");
			decompressionThread =
				new System.Threading.Thread (
					() => DecompressWithCallback (
					input,
					callback)
					);
			decompressionThread.Start ();
		}
		#else
		Windows.System.Threading.ThreadPool.RunAsync(
			(x) => DecompressWithCallback (
			input,
			callback)
			);
		#endif
	}

	public static void CancelDecompression()
	{
		runActOnBytesWithCallback = false;
	}

	public static bool runActOnBytesWithCallback;
	public static void DecompressWithCallback(byte[] inputBytes, Action<byte[]> callback)
	{
		// Starting guess, increase it later if needed
		int outputByteCountGuess = inputBytes.Length * 2;
		byte[] tempBuffer = new byte[outputByteCountGuess];
		int byteCount = lzf_decompress (inputBytes, ref tempBuffer);

		// If byteCount is 0, then increase buffer and try again
		while (byteCount == 0)
		{
			if(!runActOnBytesWithCallback)
			{
				if (callback != null)
					callback (null);
				return;
			}

			outputByteCountGuess *=2;
			tempBuffer = new byte[outputByteCountGuess];
			byteCount = lzf_decompress (inputBytes, ref tempBuffer);
		}

		byte[] outputBytes = new byte[byteCount];
		Buffer.BlockCopy(tempBuffer, 0, outputBytes, 0, byteCount);
		if (callback != null)
			callback (outputBytes);
	}

	/// <summary>
	/// Compresses the data using LibLZF algorithm
	/// </summary>
	/// <param name="input">Reference to the data to compress</param>
	/// <param name="output">Reference to a buffer which will contain the compressed data</param>
	/// <returns>The size of the compressed archive in the output buffer</returns>
	public static int lzf_compress(byte[] input, ref byte[] output)
	{
		int inputLength = input.Length;
		int outputLength = output.Length;

		Array.Clear(HashTable, 0, (int)HSIZE);

		long hslot;
		uint iidx = 0;
		uint oidx = 0;
		long reference;

		uint hval = (uint)(((input[iidx]) << 8) | input[iidx + 1]); // FRST(in_data, iidx);
		long off;
		int lit = 0;

		for (; ;)
		{
			if (iidx < inputLength - 2)
			{
				hval = (hval << 8) | input[iidx + 2];
				hslot = ((hval ^ (hval << 5)) >> (int)(((3 * 8 - HLOG)) - hval * 5) & (HSIZE - 1));
				reference = HashTable[hslot];
				HashTable[hslot] = (long)iidx;


				if ((off = iidx - reference - 1) < MAX_OFF
				    && iidx + 4 < inputLength
				    && reference > 0
				    && input[reference + 0] == input[iidx + 0]
				    && input[reference + 1] == input[iidx + 1]
				    && input[reference + 2] == input[iidx + 2]
				    )
				{
					/* match found at *reference++ */
					uint len = 2;
					uint maxlen = (uint)inputLength - iidx - len;
					maxlen = maxlen > MAX_REF ? MAX_REF : maxlen;

					if (oidx + lit + 1 + 3 >= outputLength)
						return 0;

					do
						len++;
					while (len < maxlen && input[reference + len] == input[iidx + len]);

					if (lit != 0)
					{
						output[oidx++] = (byte)(lit - 1);
						lit = -lit;
						do
							output[oidx++] = input[iidx + lit];
						while ((++lit) != 0);
					}

					len -= 2;
					iidx++;

					if (len < 7)
					{
						output[oidx++] = (byte)((off >> 8) + (len << 5));
					}
					else
					{
						output[oidx++] = (byte)((off >> 8) + (7 << 5));
						output[oidx++] = (byte)(len - 7);
					}

					output[oidx++] = (byte)off;

					iidx += len - 1;
					hval = (uint)(((input[iidx]) << 8) | input[iidx + 1]);

					hval = (hval << 8) | input[iidx + 2];
					HashTable[((hval ^ (hval << 5)) >> (int)(((3 * 8 - HLOG)) - hval * 5) & (HSIZE - 1))] = iidx;
					iidx++;

					hval = (hval << 8) | input[iidx + 2];
					HashTable[((hval ^ (hval << 5)) >> (int)(((3 * 8 - HLOG)) - hval * 5) & (HSIZE - 1))] = iidx;
					iidx++;
					continue;
				}
			}
			else if (iidx == inputLength)
				break;

			/* one more literal byte we must copy */
			lit++;
			iidx++;

			if (lit == MAX_LIT)
			{
				if (oidx + 1 + MAX_LIT >= outputLength)
					return 0;

				output[oidx++] = (byte)(MAX_LIT - 1);
				lit = -lit;
				do
					output[oidx++] = input[iidx + lit];
				while ((++lit) != 0);
			}
		}

		if (lit != 0)
		{
			if (oidx + lit + 1 >= outputLength)
				return 0;

			output[oidx++] = (byte)(lit - 1);
			lit = -lit;
			do
				output[oidx++] = input[iidx + lit];
			while ((++lit) != 0);
		}

		return (int)oidx;
	}


	/// <summary>
	/// Decompresses the data using LibLZF algorithm
	/// </summary>
	/// <param name="input">Reference to the data to decompress</param>
	/// <param name="output">Reference to a buffer which will contain the decompressed data</param>
	/// <returns>Returns decompressed size</returns>
	public static int lzf_decompress(byte[] input, ref byte[] output)
	{
		int inputLength = input.Length;
		int outputLength = output.Length;

		uint iidx = 0;
		uint oidx = 0;

		do
		{
			uint ctrl = input[iidx++];

			if (ctrl < (1 << 5)) /* literal run */
			{
				ctrl++;

				if (oidx + ctrl > outputLength)
				{
					//SET_ERRNO (E2BIG);
					return 0;
				}

				do
					output[oidx++] = input[iidx++];
				while ((--ctrl) != 0);
			}
			else /* back reference */
			{
				uint len = ctrl >> 5;

				int reference = (int)(oidx - ((ctrl & 0x1f) << 8) - 1);

				if (len == 7)
					len += input[iidx++];

				reference -= input[iidx++];

				if (oidx + len + 2 > outputLength)
				{
					//SET_ERRNO (E2BIG);
					return 0;
				}

				if (reference < 0)
				{
					//SET_ERRNO (EINVAL);
					return 0;
				}

				output[oidx++] = output[reference++];
				output[oidx++] = output[reference++];

				do
					output[oidx++] = output[reference++];
				while ((--len) != 0);
			}
		}
		while (iidx < inputLength);

		return (int)oidx;
	}

}