/*
 * Copyright (C)2005-2019 Haxe Foundation
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */

package haxe.zip;

import haxe.crypto.Adler32;
import haxe.ds.Vector;
import haxe.zip.Huffman;

private class Window {
	public static inline var SIZE = 1 << 15;
	public static inline var BUFSIZE = 1 << 16;

	public var buffer:haxe.io.Bytes;
	public var pos:Int;

	var crc:Adler32;

	public function new(hasCrc) {
		buffer = haxe.io.Bytes.alloc(BUFSIZE);
		pos = 0;
		if (hasCrc)
			crc = new Adler32();
	}

	public function slide() {
		if (crc != null)
			crc.update(buffer, 0, SIZE);
		var b = haxe.io.Bytes.alloc(BUFSIZE);
		pos -= SIZE;
		b.blit(0, buffer, SIZE, pos);
		buffer = b;
	}

	public function addBytes(b, p, len) {
		if (pos + len > BUFSIZE)
			slide();
		buffer.blit(pos, b, p, len);
		pos += len;
	}

	public function addByte(c) {
		if (pos == BUFSIZE)
			slide();
		buffer.set(pos, c);
		pos++;
	}

	public function getLastChar() {
		return buffer.get(pos - 1);
	}

	public function available() {
		return pos;
	}

	public function checksum() {
		if (crc != null)
			crc.update(buffer, 0, pos);
		return crc;
	}
}

private enum State {
	Head;
	Block;
	CData;
	Flat;
	Crc;
	Dist;
	DistOne;
	Done;
}

/**
	A pure Haxe implementation of the ZLIB Inflate algorithm which allows reading compressed data without any platform-specific support.
**/
class InflateImpl {
	static var LEN_EXTRA_BITS_TBL = [
		0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, -1, -1
	];
	static var LEN_BASE_VAL_TBL = [
		3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258
	];
	static var DIST_EXTRA_BITS_TBL = [
		0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, -1, -1
	];
	static var DIST_BASE_VAL_TBL = [
		1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577
	];
	static var CODE_LENGTHS_POS = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];

	var nbits:Int;
	var bits:Int;
	var state:State;
	var isFinal:Bool;
	var huffman:Huffman;
	var huffdist:Null<Huffman>;
	var htools:HuffTools;
	var len:Int;
	var dist:Int;
	var needed:Int;
	var output:haxe.io.Bytes;
	var outpos:Int;
	var input:haxe.io.Input;
	var lengths:Vector<Int>;
	var window:Window;

	static var FIXED_HUFFMAN = null;

	public function new(i, header = true, crc = true) {
		isFinal = false;
		htools = new HuffTools();
		huffman = buildFixedHuffman();
		huffdist = null;
		len = 0;
		dist = 0;
		state = header ? Head : Block;
		input = i;
		bits = 0;
		nbits = 0;
		needed = 0;
		output = null;
		outpos = 0;
		lengths = new Vector(19, -1);
		window = new Window(crc);
	}

	function buildFixedHuffman() {
		if (FIXED_HUFFMAN != null)
			return FIXED_HUFFMAN;
		var a = new Vector(288);
		for (n in 0...288)
			a[n] = (if (n <= 143) 8 else if (n <= 255) 9 else if (n <= 279) 7 else 8);
		FIXED_HUFFMAN = htools.make(a, 0, 288, 10);
		return FIXED_HUFFMAN;
	}

	public function readBytes(b, pos, len) {
		needed = len;
		outpos = pos;
		output = b;
		if (len > 0)
			while (inflateLoop()) {}
		return len - needed;
	}

	function getBits(n) {
		while (nbits < n) {
			bits |= input.readByte() << nbits;
			nbits += 8;
		}
		var b = bits & ((1 << n) - 1);
		nbits -= n;
		bits >>= n;
		return b;
	}

	function getBit() {
		if (nbits == 0) {
			nbits = 8;
			bits = input.readByte();
		}
		var b = bits & 1 == 1;
		nbits--;
		bits >>= 1;
		return b;
	}

	function getRevBits(n) {
		return if (n == 0)
			0
		else if (getBit())
			(1 << (n - 1)) | getRevBits(n - 1)
		else
			getRevBits(n - 1);
	}

	function resetBits() {
		bits = 0;
		nbits = 0;
	}

	function addBytes(b, p, len) {
		window.addBytes(b, p, len);
		output.blit(outpos, b, p, len);
		needed -= len;
		outpos += len;
	}

	function addByte(b) {
		window.addByte(b);
		output.set(outpos, b);
		needed--;
		outpos++;
	}

	function addDistOne(n) {
		var c = window.getLastChar();
		for (i in 0...n)
			addByte(c);
	}

	function addDist(d, len) {
		addBytes(window.buffer, window.pos - d, len);
	}

	function applyHuffman(h) {
		return switch (h) {
			case Found(n): n;
			case NeedBit(a, b): applyHuffman(getBit() ? b : a);
			case NeedBits(n, tbl): applyHuffman(tbl[getBits(n)]);
		}
	}

	function inflateLengths(a:Vector<Int>, max) {
		var i = 0;
		var prev = 0;
		while (i < max) {
			var n = applyHuffman(huffman);
			switch (n) {
				case 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15:
					prev = n;
					a[i] = n;
					i++;
				case 16:
					var end = i + 3 + getBits(2);
					if (end > max)
						throw "Invalid data";
					while (i < end) {
						a[i] = prev;
						i++;
					}
				case 17:
					i += 3 + getBits(3);
					if (i > max)
						throw "Invalid data";
				case 18:
					i += 11 + getBits(7);
					if (i > max)
						throw "Invalid data";
				default:
					throw "Invalid data";
			}
		}
	}

	function inflateLoop() {
		switch (state) {
			case Head:
				var cmf = input.readByte();
				var cm = cmf & 15;
				var cinfo = cmf >> 4;
				if (cm != 8)
					throw "Invalid data";
				var flg = input.readByte();
				// var fcheck = flg & 31;
				var fdict = flg & 32 != 0;
				// var flevel = flg >> 6;
				if (((cmf << 8) + flg) % 31 != 0)
					throw "Invalid data";
				if (fdict)
					throw "Unsupported dictionary";
				state = Block;
				return true;
			case Crc:
				var calc = window.checksum();
				if (calc == null) {
					state = Done;
					return true;
				}
				var crc = Adler32.read(input);
				if (!calc.equals(crc))
					throw "Invalid CRC";
				state = Done;
				return true;
			case Done:
				// nothing
				return false;
			case Block:
				isFinal = getBit();
				switch (getBits(2)) {
					case 0: // no compression
						len = input.readUInt16();
						var nlen = input.readUInt16();
						if (nlen != 0xFFFF - len) throw "Invalid data";
						state = Flat;
						var r = inflateLoop();
						resetBits();
						return r;
					case 1: // fixed Huffman
						huffman = buildFixedHuffman();
						huffdist = null;
						state = CData;
						return true;
					case 2: // dynamic Huffman
						var hlit = getBits(5) + 257;
						var hdist = getBits(5) + 1;
						var hclen = getBits(4) + 4;
						for (i in 0...hclen)
							lengths[CODE_LENGTHS_POS[i]] = getBits(3);
						for (i in hclen...19)
							lengths[CODE_LENGTHS_POS[i]] = 0;
						huffman = htools.make(lengths, 0, 19, 8);
						var lengths = new Vector(hlit + hdist, 0);
						inflateLengths(lengths, hlit + hdist);
						huffdist = htools.make(lengths, hlit, hdist, 16);
						huffman = htools.make(lengths, 0, hlit, 16);
						state = CData;
						return true;
					default:
						throw "Invalid data";
				}
			case Flat:
				var rlen = (len < needed) ? len : needed;
				var bytes = input.read(rlen);
				len -= rlen;
				addBytes(bytes, 0, rlen);
				if (len == 0)
					state = isFinal ? Crc : Block;
				return needed > 0;
			case DistOne:
				var rlen = (len < needed) ? len : needed;
				addDistOne(rlen);
				len -= rlen;
				if (len == 0)
					state = CData;
				return needed > 0;
			case Dist:
				while (len > 0 && needed > 0) {
					var rdist = (len < dist) ? len : dist;
					var rlen = (needed < rdist) ? needed : rdist;
					addDist(dist, rlen);
					len -= rlen;
				}
				if (len == 0)
					state = CData;
				return needed > 0;
			case CData:
				var n = applyHuffman(huffman);
				if (n < 256) {
					addByte(n);
					return needed > 0;
				} else if (n == 256) {
					state = isFinal ? Crc : Block;
					return true;
				} else {
					n -= 257;
					var extra_bits = LEN_EXTRA_BITS_TBL[n];
					if (extra_bits == -1)
						throw "Invalid data";
					len = LEN_BASE_VAL_TBL[n] + getBits(extra_bits);
					var dist_code = if (huffdist == null) getRevBits(5) else applyHuffman(huffdist);
					extra_bits = DIST_EXTRA_BITS_TBL[dist_code];
					if (extra_bits == -1)
						throw "Invalid data";
					dist = DIST_BASE_VAL_TBL[dist_code] + getBits(extra_bits);
					if (dist > window.available())
						throw "Invalid data";
					state = (dist == 1) ? DistOne : Dist;
					return true;
				}
		}
	}

	public static function run(i:haxe.io.Input, bufsize = 65536) {
		var buf = haxe.io.Bytes.alloc(bufsize);
		var output = new haxe.io.BytesBuffer();
		var inflate = new InflateImpl(i);
		while (true) {
			var len = inflate.readBytes(buf, 0, bufsize);
			output.addBytes(buf, 0, len);
			if (len < bufsize)
				break;
		}
		return output.getBytes();
	}
}
