/*
	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
*/


#include "mxclamp.h"
#include<stdio.h>
#include<string.h>
#include<stdlib.h>



namespace mx
{


	mxClampOutFile::mxClampOutFile(string filename)
	{
		fname = filename;
	}

	mxClampOutFile::~mxClampOutFile()
	{

		if(file.is_open())
		file.close();

	}


	bool mxClampOutFile::openFile()
	{

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

		return true;
	}

	bool mxClampOutFile::openFile(string fname)
	{

		this->fname = fname;
		return openFile();

	}



	/* writes files to be compressed to disk

		provides the basic guarantee ( i think )

	*/

	bool mxClampOutFile::writeToFile()
	{

		vector<mxClamp_info>::iterator vi;
		vector<string>::iterator si;



		for(vi = files.begin(), si = file_names.begin(); vi != files.end(); vi++, si++)
		{
			void *temp = 0, *tempc = 0;

			try
			{

				uLongf size_compressed = vi->size_bytes;
				fstream ifile;
				temp = (void*) malloc ( sizeof(char) * vi->size_bytes+1 );
				tempc = (void*) malloc ( sizeof(char) * vi->size_bytes+1 );
				ifile.open(si->c_str(), std::ios::in | std::ios::binary);
				ifile.read((char*)temp, vi->size_bytes);
				ifile.close();
				if(compress((Bytef*)tempc, (uLongf*)&size_compressed, (const Bytef*) temp, (uLong) vi->size_bytes) != Z_OK)
				{
					throw mx::mxException<string>(" compression error ");
				}

				cout << *si << " " <<  vi->size_bytes << "/" << size_compressed << "\n";
				vi->size_compressed = size_compressed;
				file.write((char*)&*vi, sizeof(mxClamp_info));
				file.write((char*)tempc, vi->size_compressed);
				free(temp);
				free(tempc);
				temp = 0;
				tempc = 0;

			}
			catch (...)
			{

				if(temp != 0)
				free(temp);

				if(tempc != 0)
				free(tempc);

				file.close();

				throw; // propagate exception, must reopen the file before you can rewrite
			}

		}


		file.close();

		return true;
	}


	/* adds a file to the list of files to be written
		if file is not found throws mxException */

	bool mxClampOutFile::addFile(string name)
	{

		if(name.length()==0) return false;


		fstream testfile;
		testfile.open(name.c_str(), std::ios::in);
		if(!testfile.is_open())
			throw mx::mxException<std::string>(" Error file " + name + " not found cannot add to file list ");

		testfile.seekg(0, std::ios::end);
		mxClamp_info info;

		info.size_bytes = testfile.tellg();

		testfile.close();

		string pless;
		int pos = 0;

		pos = name.rfind("/");
		if(pos != -1)
		{

			pless = name.substr(pos+1, name.length()-pos);


		} else pless = name;
		snprintf(info.filename, 255, "%s", pless.c_str());

		files.push_back(info);
		file_names.push_back(name);
		return true;
	}


	/* attempts to open the file if fails throws mxException */

	mxClampResourceFile::mxClampResourceFile(string filename)
	{


		fname = filename;

		the_file.open(filename.c_str(), std::ios::in | std::ios::binary);
		if(!the_file.is_open())
			throw mx::mxException<string>(" error could not open .mxd resource file ");


		buildInfo();



	}

	mxClampResourceFile::~mxClampResourceFile()
	{

		if(the_file.is_open())
			the_file.close();

	}

	void mxClampResourceFile::reopen()
	{

		return ; // blah

		the_file.close();

		the_file.open(fname.c_str(), std::ios::in | std::ios::binary );
		if(!the_file.is_open())
			throw mx::mxException<string> (" Could not reopen .mxd archive \n");

		the_file.seekg(0, std::ios::beg);

	}


	void mxClampResourceFile::buildInfo()
	{

		mxClamp_info i;
		std::cout << "building information about compressed .mxd archive ...\n";


		while(!the_file.eof())
		{

			int position;

			memset(&i, 0, sizeof(i));

			the_file.read((char*)&i, sizeof(i));

			position = the_file.tellg();

			if(position == -1) break;

			std::cout << "file in archive:  " << i.filename <<  " " << i.size_compressed << " / " << i.size_bytes << " \n";
;
			file_names.push_back(i);
			clamp_off.push_back(position);

			the_file.seekg(i.size_compressed, std::ios::cur);

		}

		the_file.close();

	}


	/* operator [] throws a exception when a filename that is not within the archive is quiered
		access raw bytes returns zero instead */


	void *mxClampResourceFile::operator[](string filename)
	{
		unsigned int s;
		void *bytes = accessRawBytes(filename, s);
		if(bytes == 0)
			throw mxException<string>(" Invalid file name, does not exisit within archive ");

		return bytes;


	}


	void *mxClampResourceFile::accessRawBytes(string filename, unsigned int &size)
	{

		vector<mxClamp_info>::iterator i;
		vector<unsigned int>::iterator ui;
		std::fstream the_file;

		the_file.open(fname.c_str(), std::ios::in | std::ios::binary);

		if(!the_file.is_open()) { return 0; }

		the_file.seekg(0, std::ios::beg);


		for(i=file_names.begin(),ui=clamp_off.begin(); i!=file_names.end(); i++, ui++)
		{

			if(i->filename == filename)
			{

				uLongf ulen = i->size_bytes;
				the_file.seekg(*ui, std::ios::beg);
				void *ctemp, *temp;
				ctemp = (void*) malloc ( i->size_compressed + 1 );
				temp = (void *) malloc ( i->size_bytes + 1 );
				the_file.read((char*)ctemp, i->size_compressed );



				if(uncompress((Bytef*)temp, &ulen,(const Bytef*)ctemp, (uLongf)i->size_compressed) == Z_DATA_ERROR)
				{
					the_file.close();

					free(ctemp);
					free(temp);
					the_file.close();
					throw mx::mxException<string>(" error on decompression of file " + string(filename));

				}
				free(ctemp);

				std::cout << "Read: "  << filename << " [OK]\n";
				size = i->size_bytes;
				the_file.close();
				return temp;
			}

		}

		the_file.close();
		return 0;
	}


}