/*
/////////////////////////////////////////////////////////////////////////////////////////////////////
//	bitio.cpp class written by sourena maroofi.  						   //
//	Email: maroofi[what do you think should be here]gmail.com				   //
//	This class contain 2 file(this file and bitio.h).					   //
//	you are free to use it anywhere you like.						   //
//	use it at your own risk...i am not responsible for any damage caused by this class. 	   //
//	send your comment or any possible bug (i dont think so!!!) to my email.			   //
//	use this class is very simple.just a few function to use:			           //
//	*initialize class like this:								   //
//		bitio myvar("filename",bitio::in or bitio::out);				   //
//	*send bit to write in filename like this:						   //
//		myvar.outputBit(1)  or myvar.outputBit(0);					   //
//	*write buffer to filename like this:							   //
//		myvar.flushBuffer();								   //
//	*print out buffer like this:								   //
//		myvar.printBuffer();								   //
//	*get any possible error using:								   //
//		myvar.getLastError();								   //
//	and Thats it(No more help...easy to use)!!!!!!!!					   //
//	sample driver for this class:(copy one file to another bit by bit!!!)			   //
//	#include <iostream>									   //
//	#include <string>									   //
//	#include "bitio.h"									   //
//	using namespace std;									   //
//	int main()										   //
//	{											   //
//		bitio input1("ass.txt",bitio::in);						   //
//		bitio output("assss.txt",bitio::out);						   //
//		input1.getLastError();								   //
//		while(! input1.eof())								   //
//		{										   //
//			output.outputBit(input1.inputBit());					   //
//		}										   //
//		output.printBuffer();								   //
//		output.flushBuffer();								   //
//		output.getLastError();								   //
//		input1.getLastError();								   //
//		return 0;									   //
//	}											   //
//												   //
//												   //
/////////////////////////////////////////////////////////////////////////////////////////////////////
*/



//#include "stdafx.h"

#include <iostream>
#include <fstream>
#include <string>
#include <new>
#include <stdlib.h>
#include "bitio.h"
using namespace std;

/*********************************************************************************************************/
bitio::bitio(const char * fileName,int mode)
{
	buffer_is_empty=true;
	errorMessage="No Error Yet";
	bytePos=0;
	error_occured=false;
	bitPos=0;
	currentPos=0;
	eof_occured=false;
	readBlock=false;
	hiLimit=0;
	Buffer=new(nothrow)unsigned char [maxBufferSize];
	
	if (Buffer==0)
	{
		cout<<"can not allocate just fuckin 256 bytes of memory for buffer,damn!!!"<<endl;
		error_occured=true;
		exit(1);
	}


	this->fileName=fileName;
	
	
	if ((int)mode==out)
	{
		
		this->fileMode=FILE_OUTPUT;

		myFileOut.open(fileName,ios::out|ios::binary);
		if (! myFileOut.is_open())
		{
			errorMessage="can not open fuckin " + (string)fileName +" file...dont know y and dont give a damn!!!";
			getLastError();
			error_occured=true;			
			exit(1);
		}
		
	}
	else if ((int)mode==in)
	{
		this->fileMode=FILE_INPUT;
		myFileIn.open(fileName,ios::in|ios::binary);
		if (!myFileIn.is_open())
		{
			errorMessage="can not open input file " + (string) fileName + " .check if file exist!!!";
			getLastError();
			error_occured=true;
			exit(1);
		}
		myFileIn.seekg(0,ios::end);
		fileSize=myFileIn.tellg();
		myFileIn.seekg(0,ios::beg);
		readBlock=false;
		//cout<<"file size : "<<(unsigned long int)fileSize<<endl;		
		
	}
	else
	{
		errorMessage="invalid file mode.shoud be 0=in or 1=out.";
		getLastError();
		error_occured=true;
		exit(1);
	}
	
	
	
}

/************************************************************************************************/
int bitio::inputBit(void)
{	
	if (error_occured==true)
	{
		cout<<"Error occured...check getLastError() ."<<endl;
		return -1;
	}
	if (fileSize==0)
	{
		eof_occured=true;
		cout<<"input file is empty!!!"<<endl;
		return -1;
	}
	if (readBlock==false)
	{
		
		
		if (fileSize<maxBufferSize)
		{
			hiLimit=fileSize*8;
			myFileIn.read((char *)Buffer,fileSize);
			readBlock=true;
			buffer_is_empty=false;
			currentPos=0;
		}
		else
		{
			myFileIn.read((char *)Buffer,maxBufferSize);
			buffer_is_empty=false;
			currentPos=0;
			hiLimit=0;  //you know why???	
			readBlock=true;
	}	}
	if (currentPos==(maxBufferSize*8))
	{
		
		if (( (unsigned long int)(myFileIn.tellg())+maxBufferSize)<fileSize)
		{
			
			myFileIn.read((char *)Buffer,maxBufferSize);
			buffer_is_empty=false;
			currentPos=0;
			hiLimit=0;  //you know why???	
		}
		else
		{
			hiLimit=fileSize-myFileIn.tellg();
			myFileIn.read((char *)Buffer,hiLimit);
			buffer_is_empty=false;
			hiLimit*=8;
			currentPos=0;
			
		}
	}
	bytePos=(int)(currentPos/8);
	bitPos=currentPos%8;
	unsigned char byteTemp;
	byteTemp=Buffer[bytePos];
	byteTemp=byteTemp<<((bitPos-1<0)?0:(bitPos));
	byteTemp=byteTemp>>7;
	if (byteTemp==0)
	{
		currentPos++;
		if (currentPos==hiLimit)
		{
			eof_occured=true;
		}

		return 0;
	}
	else if (byteTemp==1)
	{	
		currentPos++;
		if (currentPos==hiLimit)
		{
			eof_occured=true;
		}

		return 1;
	}
	else
	{
		cout<<"What the fuck is this??????"<<endl;
		return -1;
	}
	return -1;
	
}

/********************************************************************/

bitio::~bitio()
{
	if (fileMode==FILE_OUTPUT)
	{
		flushBuffer();
		myFileOut.close();
	}
}

/**************************************************************************************************/
bool bitio::outputBit ( int biti)
{
	

	if (error_occured==true)
	{
		cout<<"Error occured...check getLastError() ."<<endl;
		return false;
	}
	if (biti !=0 && biti !=1 && biti !=-1)
	{
		errorMessage="What the fuck is this?? .just output 1 or 0.";
		return false;
	}
	if (biti==-1)
	{
		errorMessage="outputBit argument is -1 so flushBuffer and return true...";
		flushBuffer();
		return true;
	}
	if (currentPos==(maxBufferSize*8))
	{
		
		if (flushBuffer()!=true)
		{
			errorMessage="buffer is full but can not write it to file"+(string)fileName;
			return false;
		}
	}
	bytePos=(int)(currentPos/8);
	bitPos=(int)(currentPos%8);
	unsigned char temp=0;
	temp=Buffer[bytePos];
	temp=temp>>(7- (bitPos));
	if (biti==1)
	{	
		temp=temp | 0x01;	
		temp=temp<<(7- (bitPos));
		Buffer[bytePos]=temp;
		currentPos++;	
		buffer_is_empty=false;
		return true;
	}
	if (biti==0)
	{
		
		temp=temp & 0xfe;
		currentPos++;
		temp=temp<<(7- (bitPos));
		Buffer[bytePos]=temp;
		buffer_is_empty=false;
		return true;
	}
	return false;
}
/**************************************************************************************************/
void bitio::printBuffer(void)
{
	if (error_occured==true)
	{
		cout<<"Error occured...check getLastError() ."<<endl;
		return;
	}
	bytePos=(int)(currentPos/8);
	cout<<"this is the containing of the buffer in Hex representation : "<<endl;
	for(int i=0;i<bytePos;i++)
	{
		cout<<hex<<(int)Buffer[i]<<" ";
	}
	cout<<endl;
}
/**********************************************************************************************/
void bitio::getLastError(void)
{
	
	cout<<endl;
	cout<<errorMessage;
	cout<<endl;
}
/**********************************************************************************************/
bool bitio::flushBuffer(void)
{
	if (buffer_is_empty==true)
		return true;
	if (error_occured==true)
	{
		cout<<"Error occured...check getLastError() ."<<endl;
		return false;
	}
	
	bytePos=(int)(currentPos/8);
	bitPos=(int)(currentPos%8);
	if (currentPos==(maxBufferSize*8))
	{
		myFileOut.write((char *)Buffer,maxBufferSize);
		//myFile.close();
		currentPos=0;
		buffer_is_empty=true;
		return true;
		
	}
	else
	{
		unsigned char temp=0;
		temp=Buffer[bytePos];
		
		for (int i=(7-bitPos);i>=0;i--)
		{
			temp=temp>>i;
			temp=temp | 0x01;
			temp=temp<<i;
		}
		Buffer[bytePos]=temp;
		myFileOut.write((char *)Buffer,(bytePos+1));
		//myFile.close();
		currentPos=0;
		buffer_is_empty=true;
		return true;
	}
	return false;	
}
/***************************************************************************************************/
bool bitio::eof(void)
{
	//cout<<"ss";
	if (eof_occured==true)
	{
		//cout<<"true eof"<<endl;
		return true;
	}
	else
	{
		//cout<<"false eof"<<endl;
		return false;
	}
}
/*********************************************************************************************************/
void bitio::writeByte(unsigned char * byte,int len)
{
	unsigned char bitmask=0x80;
	unsigned char temp=0,tempo=0;
	if (fileMode==FILE_OUTPUT)
	{
		for (int i=0;i<len;i++)
		{
			temp=byte[i];
			for (int j=0,k=7;j<8;j++,k--)
			{
				tempo=temp & bitmask;
				tempo=tempo>>k;
				this->outputBit(tempo);
				
				tempo=0;
				bitmask=bitmask>>1;
			}
			tempo=0;temp=0;
			bitmask=0x80;
		}		
	}
	return;
}
/*********************************************************************************************************/