#include <stdio.h>
#include <stdlib.h>
#include <eyd.hh>
#include <exception>
#include <vector>

void usage(){
	printf("usage : bitcopy <int> <file>\n");
}

int main(int argc, char ** argv){
	EydLib::BitGroup bg;
	int cell_size; 
	std::string original;
	std::string copy;

	if (argc<2){ usage(); exit(-1); }
	cell_size = atoi(argv[1]);
	original = argv[2];

	copy = original + ".rl1";

	EydLib::BitReader bitread(cell_size, 256);
	bitread.open(original);

	EydLib::BitWriter bitwrite(cell_size,256);
	bitwrite.open(copy);

	EydLib::BitGroup rleBg(cell_size);
	EydLib::BitGroup lenBg(cell_size);

	printf("Maximum value of cell : %d\n",lenBg.maxValue()); 
	printf("File opened\n");

	bool done=false;
	std::vector<EydLib::BitGroup> record;
	while(!done){
		try{
			bg = bitread.read();
			printf("%s ",bg.toString().c_str());
			fflush(stdout);
			// on pousse le bit sur dans la file
			if (record.size() == 0){
				// on attend la suite...
			} else {
				EydLib::BitGroup tmpBg;
				EydLib::BitGroup oldBg;

				tmpBg = record.back();
				// si le caractère est différent de celui d'avant
				if (tmpBg != bg){
					// on compte le nombre d'éléments
					// on pose un marqueur
					if (record.size()<3){
						// FIXME: dans le cas de cellules "0" ?
						// on ecrit les cellules telles quelles...
						// si la taille est incompressible
						for (int i=0; i<record.size(); i++){
							oldBg = record[i];
							if (oldBg.getValue() == 0){
								// on échape le caractere avec un RLE
								bitwrite.write(rleBg); // echapement
								fprintf(stderr,"RLE ");
							}
							bitwrite.write(oldBg);
							fprintf(stderr,"%s ",oldBg.toString().c_str());
						}
						record.clear();
					} else {
						// la cellule courante est différente de l'ancienne
						// et la taille est compressible
						bitwrite.write(rleBg); // echapement
						fprintf(stderr,"RLE ");
						lenBg.setValue(record.size());
						bitwrite.write(lenBg); // longueur
						fprintf(stderr,"%s ",lenBg.toString().c_str());
						// on a pas besoind d'échaper le caractere avec un RLE
						// parce qu'il est reconnaissable (2 places apres un RLE)
						bitwrite.write(tmpBg); // cellule
						fprintf(stderr,"%s ",tmpBg.toString().c_str());
						// TODO: penser a calculer le taux de compression
						record.clear();
					}
				} else {
					// on ne fait rien car le caractère est le meme qu'avant
					// sauf si la longueur est >  a celle "enregistrable"
					// par une cellule de donnée
					if (record.size() >= rleBg.maxValue()){
						// on flushe artificiellement
						bitwrite.write(rleBg); // echapement
						fprintf(stderr,"RLE ");
						lenBg.setValue(record.size());
						bitwrite.write(lenBg); // longueur
						fprintf(stderr,"%s ",lenBg.toString().c_str());
						
						// on a pas besoind d'échaper le caractere avec un RLE
						// parce qu'il est reconnaissable (2 places apres un RLE)
						bitwrite.write(tmpBg); // cellule
						fprintf(stderr,"%s ",tmpBg.toString().c_str());
						// TODO: penser a calculer le taux de compression
						record.clear();
					} else {
						// sinon on ne fait rien, on a encore de la marge
					}
				}

			}
			record.push_back(bg);
			//bitwrite.write(bg);	
		} catch (EydLib::eBitReaderEndOfFile& e) {
			done = true;		
			// TODO: on flushe le contenu de record
		} catch (std::exception& e){
			printf("ERROR\n");
		}
	}
	printf("compression done\n");

	bitread.close();
	bitwrite.close();

	printf("file closed\n");
}