/**

* Copyright (c) 2016-present, Gregory Szorc

* All rights reserved.

*

* This software may be modified and distributed under the terms

* of the BSD license. See the LICENSE file for details.

*/

#include "python-zstandard.h"

#include "pool.h"

extern PyObject* ZstdError;

/**

	size_t zresult;

		if (ZSTD_isError(zresult)) {

				ZSTD_getErrorName(zresult));

		}

	}

	}

	}

	return 0;

}

PyDoc_STRVAR(Decompressor__doc__,

"ZstdDecompressor(dict_data=None)\n"

"\n"

"Create an object used to perform Zstandard decompression.\n"

"\n"

"An instance can perform multiple decompression operations."

);

static int Decompressor_init(ZstdDecompressor* self, PyObject* args, PyObject* kwargs) {

	static char* kwlist[] = {

		"dict_data",

		NULL

	};

	ZstdCompressionDict* dict = NULL;

	self->dctx = NULL;

	self->dict = NULL;

		return -1;

	}

	self->dctx = ZSTD_createDCtx();

	if (!self->dctx) {

		PyErr_NoMemory();

		goto except;

	}

	if (dict) {

		self->dict = dict;

		Py_INCREF(dict);

	}

	return 0;

except:

	if (self->dctx) {

		ZSTD_freeDCtx(self->dctx);

		self->dctx = NULL;

	}

	return -1;

}

static void Decompressor_dealloc(ZstdDecompressor* self) {

	Py_CLEAR(self->dict);

	if (self->dctx) {

		ZSTD_freeDCtx(self->dctx);

		self->dctx = NULL;

	}

	PyObject_Del(self);

}

PyDoc_STRVAR(Decompressor_copy_stream__doc__,

	"copy_stream(ifh, ofh[, read_size=default, write_size=default]) -- decompress data between streams\n"

	"\n"

	"Compressed data will be read from ``ifh``, decompressed, and written to\n"

	"``ofh``. ``ifh`` must have a ``read(size)`` method. ``ofh`` must have a\n"

	"``write(data)`` method.\n"

	"\n"

	"The optional ``read_size`` and ``write_size`` arguments control the chunk\n"

	"size of data that is ``read()`` and ``write()`` between streams. They default\n"

	"to the default input and output sizes of zstd decompressor streams.\n"

);

static PyObject* Decompressor_copy_stream(ZstdDecompressor* self, PyObject* args, PyObject* kwargs) {

	static char* kwlist[] = {

		"ifh",

		"ofh",

		"read_size",

		"write_size",

		NULL

	};

	PyObject* source;

	PyObject* dest;

	size_t inSize = ZSTD_DStreamInSize();

	size_t outSize = ZSTD_DStreamOutSize();

	ZSTD_inBuffer input;

	ZSTD_outBuffer output;

	Py_ssize_t totalRead = 0;

	Py_ssize_t totalWrite = 0;

	char* readBuffer;

	Py_ssize_t readSize;

	PyObject* res = NULL;

	size_t zresult = 0;

	PyObject* writeResult;

	PyObject* totalReadPy;

	PyObject* totalWritePy;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|kk:copy_stream", kwlist,

		&source, &dest, &inSize, &outSize)) {

		return NULL;

	}

	if (!PyObject_HasAttrString(source, "read")) {

		PyErr_SetString(PyExc_ValueError, "first argument must have a read() method");

		return NULL;

	}

	if (!PyObject_HasAttrString(dest, "write")) {

		PyErr_SetString(PyExc_ValueError, "second argument must have a write() method");

		return NULL;

	}

	/* Prevent free on uninitialized memory in finally. */

	output.dst = NULL;

		res = NULL;

		goto finally;

	}

	output.dst = PyMem_Malloc(outSize);

	if (!output.dst) {

		PyErr_NoMemory();

		res = NULL;

		goto finally;

	}

	output.size = outSize;

	output.pos = 0;

	/* Read source stream until EOF */

	while (1) {

		readResult = PyObject_CallMethod(source, "read", "n", inSize);

		if (!readResult) {

			PyErr_SetString(ZstdError, "could not read() from source");

			goto finally;

		}

		PyBytes_AsStringAndSize(readResult, &readBuffer, &readSize);

		/* If no data was read, we're at EOF. */

		if (0 == readSize) {

			break;

		}

		totalRead += readSize;

		/* Send data to decompressor */

		input.src = readBuffer;

		input.size = readSize;

		input.pos = 0;

		while (input.pos < input.size) {

			Py_BEGIN_ALLOW_THREADS

			Py_END_ALLOW_THREADS

			if (ZSTD_isError(zresult)) {

				PyErr_Format(ZstdError, "zstd decompressor error: %s",

					ZSTD_getErrorName(zresult));

				res = NULL;

				goto finally;

			}

			if (output.pos) {

#if PY_MAJOR_VERSION >= 3

				writeResult = PyObject_CallMethod(dest, "write", "y#",

#else

				writeResult = PyObject_CallMethod(dest, "write", "s#",

#endif

					output.dst, output.pos);

				Py_XDECREF(writeResult);

				totalWrite += output.pos;

				output.pos = 0;

			}

		}

	}

	/* Source stream is exhausted. Finish up. */

	totalReadPy = PyLong_FromSsize_t(totalRead);

	totalWritePy = PyLong_FromSsize_t(totalWrite);

	res = PyTuple_Pack(2, totalReadPy, totalWritePy);

	Py_DECREF(totalReadPy);

	Py_DECREF(totalWritePy);

finally:

	if (output.dst) {

		PyMem_Free(output.dst);

	}

	return res;

}

PyDoc_STRVAR(Decompressor_decompress__doc__,

"decompress(data[, max_output_size=None]) -- Decompress data in its entirety\n"

"\n"

"This method will decompress the entirety of the argument and return the\n"

"result.\n"

"\n"

"The input bytes are expected to contain a full Zstandard frame (something\n"

"compressed with ``ZstdCompressor.compress()`` or similar). If the input does\n"

"not contain a full frame, an exception will be raised.\n"

"\n"

"If the frame header of the compressed data does not contain the content size\n"

"``max_output_size`` must be specified or ``ZstdError`` will be raised. An\n"

"allocation of size ``max_output_size`` will be performed and an attempt will\n"

"be made to perform decompression into that buffer. If the buffer is too\n"

"small or cannot be allocated, ``ZstdError`` will be raised. The buffer will\n"

"be resized if it is too large.\n"

"\n"

"Uncompressed data could be much larger than compressed data. As a result,\n"

"calling this function could result in a very large memory allocation being\n"

"performed to hold the uncompressed data. Therefore it is **highly**\n"

"recommended to use a streaming decompression method instead of this one.\n"

);

PyObject* Decompressor_decompress(ZstdDecompressor* self, PyObject* args, PyObject* kwargs) {

	static char* kwlist[] = {

		"data",

		"max_output_size",

		NULL

	};

	Py_ssize_t maxOutputSize = 0;

	unsigned long long decompressedSize;

	size_t destCapacity;

	PyObject* result = NULL;

	size_t zresult;

#if PY_MAJOR_VERSION >= 3

#else

#endif

		return NULL;

	}

	}

	}

		if (0 == maxOutputSize) {

		}

		}

	}

	if (!result) {

	}

	Py_BEGIN_ALLOW_THREADS

	Py_END_ALLOW_THREADS

	if (ZSTD_isError(zresult)) {

		PyErr_Format(ZstdError, "decompression error: %s", ZSTD_getErrorName(zresult));

	}

		PyErr_Format(ZstdError, "decompression error: decompressed %zu bytes; expected %llu",

			zresult, decompressedSize);

	}

		}

	}

	return result;

}

PyDoc_STRVAR(Decompressor_decompressobj__doc__,

"\n"

"Incrementally feed data into a decompressor.\n"

"\n"

"The returned object exposes a ``decompress(data)`` method. This makes it\n"

"compatible with ``zlib.decompressobj`` and ``bz2.BZ2Decompressor`` so that\n"

"callers can swap in the zstd decompressor while using the same API.\n"

);

	if (!result) {

		return NULL;

	}

		Py_DECREF(result);

		return NULL;

	}

	result->decompressor = self;

	Py_INCREF(result->decompressor);

	return result;

}

"Read compressed data and return an iterator\n"

"\n"

"Returns an iterator of decompressed data chunks produced from reading from\n"

"the ``reader``.\n"

"\n"

"Compressed data will be obtained from ``reader`` by calling the\n"

"``read(size)`` method of it. The source data will be streamed into a\n"

"decompressor. As decompressed data is available, it will be exposed to the\n"

"returned iterator.\n"

"\n"

"Data is ``read()`` in chunks of size ``read_size`` and exposed to the\n"

"iterator in chunks of size ``write_size``. The default values are the input\n"

"and output sizes for a zstd streaming decompressor.\n"

"\n"

"There is also support for skipping the first ``skip_bytes`` of data from\n"

"the source.\n"

);

	static char* kwlist[] = {

		"reader",

		"read_size",

		"write_size",

		"skip_bytes",

		NULL

	};

	PyObject* reader;

	size_t inSize = ZSTD_DStreamInSize();

	size_t outSize = ZSTD_DStreamOutSize();

	ZstdDecompressorIterator* result;

	size_t skipBytes = 0;

		&reader, &inSize, &outSize, &skipBytes)) {

		return NULL;

	}

	if (skipBytes >= inSize) {

		PyErr_SetString(PyExc_ValueError,

			"skip_bytes must be smaller than read_size");

		return NULL;

	}

	result = (ZstdDecompressorIterator*)PyObject_CallObject((PyObject*)&ZstdDecompressorIteratorType, NULL);

	if (!result) {

		return NULL;

	}