module utils.miniz;

import
		std.conv,
		std.file,
		std.array,
		std.stdio,
		std..string,
		std.algorithm,
		std.exception,

		utils.miniz.binding;


final class Zip
{
	this(string name, bool writeable = true, bool create = false)
	{
		auto s = name.toStringz;

		if(create)
		{
			assert(writeable, `cannot create in readonly mode`);

			mz_zip_writer_init_file_v2(&_zip, name.toStringz, 0, MZ_ZIP_FLAG_WRITE_ZIP64 | MZ_ZIP_FLAG_WRITE_ALLOW_READING);
		}
		else
		{
			enforce(name.exists, `archive does not exist`);

			mz_zip_reader_init_file(&_zip, s, 0);

			if(writeable)
			{
				mz_zip_writer_init_from_reader(&_zip, s);
			}
			else
			{
				_ro = true;
			}
		}
	}

	~this()
	{
		if(_ro)
		{
			mz_zip_reader_end(&_zip);
		}
		else
		{
			mz_zip_writer_finalize_archive(&_zip);
			mz_zip_writer_end(&_zip);
		}
	}

	auto get(string name)
	{
		auto idx = mz_zip_reader_locate_file(&_zip, name.toStringz, null, 0);
		enforce(idx >= 0, lastError);

		mz_zip_archive_file_stat s;
		enforce(mz_zip_reader_file_stat(&_zip, idx, &s), lastError);

		auto res = new ubyte[cast(size_t)s.m_uncomp_size];

		enforce(mz_zip_reader_extract_to_mem(&_zip, idx, res.ptr, res.length, 0), lastError);
		return res;
	}

	void put(string name, in void[] data)
	{
		mz_zip_writer_add_mem(&_zip, name.toStringz, data.ptr, data.length, 0);
	}

private:
	auto lastError()
	{
		return mz_zip_get_last_error(&_zip).mz_zip_get_error_string.fromStringz.assumeUnique;
	}

	bool _ro;
	mz_zip_archive _zip;
}