/*
	MX library.

	http://lostsidedead.com/svn


	libmx written by jared bruni, it is wrappers around SDL
and other api's to provide a set of classes and functions
to produce multi media applications, using object oriented
techniques.

 	(C) 2008 LostSideDead
*/




/* mximg v1 www.lostsidedead.com via GPL */



#include "mximg.h"
#include<cassert>
#include<cstring>
#include<cstdio>


namespace mx
{

	mximg_Item::mximg_Item() {
		compressed_length = 0;
		data_length = 0;
		name_length = 0;
		offset = 0;
	}

	mximg_Writer::mximg_Writer() {


	}

	bool mximg_Writer::addItem(const char *item) {

		std::fstream f;
		f.open(item, std::ios::in | std::ios::binary);
		if(!f.is_open())
			return false;
		f.seekg(0, std::ios::end);
		size_t len = f.tellg();
		f.close();

		if(len == 0) {
			std::cout << item << " is zero bytes, skipping..\n";
			return true;
		}


		mximg_Item it;
		it.data_length = len;

		it.fullname = item;

		std::string ex = item;
		if(ex.rfind("/")) {
			ex = ex.substr(ex.rfind("/")+1, ex.length());
			std::cout << ex << "\n";
		}

		it.name_length = ex.length()+1;
		snprintf(it.name, it.name_length, "%s", ex.c_str());

		return addItem(it);
	}

	bool mximg_Writer::addItem(const mximg_Item &item) {

		assert(item.data_length != 0);
		assert(item.name_length != 0);

		items_.push_back(item);
		return true;
	}

	bool mximg_Writer::writeData(std::fstream &file) {

		std::vector<mximg_Item>::iterator i, last;

		for(i = items_.begin(), last = items_.end(); i != last; i++) {

			if(i->name_length <= 0) continue;
			if(i->data_length <= 0) continue;


			file.write((char*)&i->name_length, sizeof(unsigned int));
			file.write((char*)i->name, i->name_length);

			unsigned char *temp_bytes = new unsigned char [ i->data_length + 1 ];
			std::fstream temp_file;
			temp_file.open(i->fullname.c_str(), std::ios::in | std::ios::binary);
			if(!temp_file.is_open()) {
				std::cerr << " could not open input file: " << i->name << "\n";
				file.close();
				return false;
			}
			temp_file.read((char*)temp_bytes, i->data_length);
			temp_file.close();
			i->compressed_length = i->data_length;

			int err;

			i->compressed_length = compressBound(i->data_length);
			unsigned char *comp_bytes = new unsigned char [ i->compressed_length + 1 ];

			if((err = compress((Bytef*)comp_bytes, (uLongf*)&i->compressed_length, (const Bytef*)temp_bytes, (uLong) i->data_length)) != Z_OK) {
				file.close();
				delete [] temp_bytes;
				delete [] comp_bytes;
				std::cerr << "error on compression of " << i->name <<  " " << zError(err) << " ...\n";
				return false;
			}

			file.write((char*)&i->data_length, sizeof(unsigned int));
			file.write((char*)&i->compressed_length, sizeof(unsigned int));
			file.write((char*)comp_bytes, i->compressed_length);

			delete [] temp_bytes;
			delete [] comp_bytes;
		}

		file.close();

		return true;
	}


	bool mximg_Writer::concatItems(const char *filen) {

		std::fstream file;

		file.open(filen, std::ios::binary | std::ios::app | std::ios::out);
		if(!file.is_open()) return false;

		return writeData(file);
	}

	bool mximg_Writer::writeItems(const char *filen)
	{
		std::fstream file;
		file.open(filen, std::ios::out | std::ios::binary);
		if(!file.is_open())
			return false;

		return writeData(file);
	}

	mximg_Reader::mximg_Reader() {}


 	bool mximg_Reader::openArchive(const char *filen) {

 		std::fstream f;

 		f.open(filen, std::ios::in | std::ios::binary);

 		if(!f.is_open()) return false;

 		while(!f.eof() ) {

 			mximg_Item item;
 			f.read((char*)&item.name_length, sizeof(unsigned int));
 			f.read((char*)&item.name, item.name_length);
 			f.read((char*)&item.data_length, sizeof(unsigned int));
 			f.read((char*)&item.compressed_length, sizeof(unsigned int));
 			item.offset = f.tellg();
 			f.seekg(item.compressed_length, std::ios::cur);

 			if(item.compressed_length != 0)
 			items_.push_back(item);
 		}
 		f.close();
 		file_name = filen;
		return true;
	}

	void mximg_Reader::listItems(std::ostream &stream) {

		std::vector<mximg_Item>::iterator i, last;

		using namespace std;

		stream << setw(25) << "filename" << setw(15) << "compressed" << setw(15) << "uncompressed" << "\n";

		for(i = items_.begin(), last = items_.end(); i != last; i++) {
			stream << setw(25) <<  i->name << setw(15) << i->compressed_length << setw(15) << i->data_length << "\n";
		}
	}

	void *mximg_Reader::accessBytes(const char *fname, size_t &length) {

		std::vector<mximg_Item>::iterator i,last;

		for(i = items_.begin(), last = items_.end(); i != last; i++) {

			if(strcmp(i->name, fname) == 0) {


				std::fstream f;
				f.open(file_name.c_str(), std::ios::in | std::ios::binary);
				if(!f.is_open()) return 0;

				length = i->data_length;
				unsigned char *compressed_bytes = new unsigned char [ i->compressed_length + 1 ];
				unsigned char *uncompressed = new unsigned char [ i->data_length + 1 ];

				f.seekg(i->offset, std::ios::beg);
				f.read((char*)compressed_bytes, i->compressed_length);
				f.close();
				if( uncompress((Bytef*)uncompressed, (uLongf*)&i->data_length,(const Bytef*)compressed_bytes, (uLongf)i->compressed_length) != Z_OK ) {

					std::cerr << "error on decompression\n";
					delete [] uncompressed;
					delete [] compressed_bytes;
					return 0;
				}

				delete [] compressed_bytes;
				return uncompressed;
			}

		}
		return 0;
	}

	void mximg_Reader::extractItem(const char *path, const char *fname) {

		std::string p = path;
		if(p[p.length()-1] == '/') p += fname; else p = p + '/' + fname;

		std::fstream file;
		file.open(p.c_str(), std::ios::out | std::ios::binary);
		if(!file.is_open()) {
			std::cerr << "error path is incorrect, supply correct path for extraction.";
			return;
		}

		size_t length = 0;
		char *bytes = (char*) accessBytes(fname, length);
		if(bytes == 0) std::cerr << "invalid identifier for extraction.";

		file.write((char*)bytes, length);
		file.close();
		delete [] bytes;

	}

	void mximg_Reader::extractAll(const char *path) {

		std::vector<mximg_Item>::iterator i, last;
		for(i = items_.begin(), last = items_.end(); i != last; i++)
				extractItem(path, i->name);

	}

	void mximg_Reader::closeArchive() {
		if(!items_.empty())
		items_.clear();
	}










}