#include <iostream>
#include <fstream>
#include <vector>
#include <cmath>
#include <iomanip>

class BMP2Gcode
{
	public:
		BMP2Gcode();
		void traitement(char* nom_fichier);
		void fichier_conf();

	private:
		int entete();
		int donnees();
		int sortie();

		unsigned int conversion(unsigned int valeur, unsigned int min, unsigned int max);
		unsigned int consecutif(unsigned int indice, unsigned int min, unsigned int max, unsigned int puissance, int sens);

		unsigned int BMP_largeur, BMP_hauteur, BMP_offset, BMP_profondeur, BMP_taille;
		double conf_taille_laser, conf_puissance_min, conf_puissance_max, conf_vitesse, conf_taille_image;
		std::vector<unsigned int> tab_donnees;
		std::string nom_fichier_bmp;
};

BMP2Gcode::BMP2Gcode()
:BMP_largeur(0), BMP_hauteur(0), BMP_offset(0), BMP_profondeur(0), BMP_taille(0)
{}

void BMP2Gcode::traitement(char* nom_fichier)
{
	nom_fichier_bmp = nom_fichier;
	
	if(entete() == 0)
	{
		if(donnees() == 0)
		{sortie();}
	}
}

int BMP2Gcode::entete()
{
	//ouverture du fichier
	std::ifstream fichier(nom_fichier_bmp, std::ifstream::binary);

	//test de l'ouverture du fichier
	if(!fichier)
	{
		std::cerr << "impossible d'ouvrir le fichier" << std::endl;
		return 1;
	}

	/*lecture de l'en tête de 54 octets composé comme suit :
	-2 octets [0-1] pour la signature
	-4 octets [2-5] pour la taille du fichier en octets
	-4 octets [6-9] de champ réservé
	-4 octets [10-13] pour l'offset
	-4 octets [14-17] pour la taille de l'en-tête de l'image (28 octets pour windows)
	-4 octets [18-21] pour la largeur de l'image
	-4 octets [22-25] pour la hauteur de l'image
	-2 octets [26-27] pour le nombre de plans (valeur toujours à 1)
	-2 octets [28-29] pour la profondeur de l'encodage (nbr de bit pour la couleur)
	-4 octets [30-33] pour la métode de compression (0 non compressé, 1 RLE 8bits/pixel, 2 RLE 4bits/pixel, 3 bitfields)
	-4 octets [35-38] pour la taille de l'image
	-4 octets [39-42] pour la résolution horizontale
	-4 octets [43-46] pour la résolution verticale
	-4 octets [47-50] pour la palette de couleur
	-4 octets [50-53] pour le nombre de couleurs importantes.
	*/

	char *entete = new char [54];
	fichier.read(entete, 54);

	if(entete[0] == 'B')
	{
		if(entete[1] == 'M')
		{
			std::cout << "Bitmap windows" << std::endl;
		}
	}

	/*Pour récupérer les informations on va utiliser l'astuce suivante :
	pour la valeur commençant à entete[indice] on va commencer par prendre l'adresse :
	&entete[indice]
	puis on va caster ça dans le type qui correspond bien, int * si c'est sur 4 octets,
	short * si c'est sur 2 octets.

	(int *)&entete[indice] correspond donc à un pointeur de type int *, il suffit alors
	de prendre sa valeur en faisant : *(int *)entete[indice]
	*/

	BMP_offset = *(int*)&entete[10];

	BMP_largeur = *(int*)&entete[18];
	BMP_hauteur = *(int*)&entete[22];
	BMP_profondeur = *(short*)&entete[28];
	
	std::cout << "compression : " << *(int*)&entete[30] << std::endl;

	std::cout << "offset BMP : " << BMP_offset << std::endl;
	std::cout << "largeur BMP : " << BMP_largeur << std::endl;
	std::cout << "hauteur BMP : " << BMP_hauteur << std::endl;
	std::cout << "profondeur BMP : " << BMP_profondeur << std::endl;
	
	delete[] entete;
	fichier.close();

	return 0;
}

int BMP2Gcode::donnees()
{
	//ouverture du fichier
	std::ifstream fichier(nom_fichier_bmp, std::ifstream::binary);

	//test de l'ouverture du fichier
	if(!fichier)
	{
		std::cerr << "impossible d'ouvrir le fichier" << std::endl;
		return 1;
	}

	if(BMP_offset == 0)
	{entete();}

	/* /!\ATTENTION/!\
	Contrairement à la plupart des formats d'images, les pixels de l'image sont codés en partant de la ligne inférieure de l'image. Chaque ligne (codée de gauche à droite) doit toujours occuper un nombre d'octets multiple de 4, excepté si l'image est compressée. Si la ligne ne possède pas un nombre d'octets multiple de 4, on ajoute FF, 00FF, ou 0000FF à la fin de chaque ligne
	
	Source : https://fr.wikipedia.org/wiki/Windows_bitmap#Disposition_des_donn%C3%A9es_de_l'image
	
	Il est donc nécessaire pour lire correctement les données de prévoir une limite qui est un multiple de 4
	mais également de sauter ces éventuels informations
	*/
	
	int reste = BMP_largeur % 4, longueur_ligne = BMP_largeur;
	
	if(reste != 0)
	{
		//Si la longueur d'une ligne n'est un multiple de 4
		//il suffit alors d'ajouter à la ligne 4 - reste
		longueur_ligne += 4 - reste;
	}
	

	int limite = longueur_ligne*BMP_hauteur * BMP_profondeur/8 + BMP_offset;

	char *donnees = new char [ limite ];
	fichier.read(donnees, limite);

	std::cout << "données brutes : " << std::endl;
	
	int depart = BMP_offset;
	for(int i = 0 ; i < BMP_hauteur ; i++)
	{
		//on récupère une ligne
		for(int j = depart ; j < depart + BMP_largeur * BMP_profondeur/8; j += BMP_profondeur/8)
		{
			if(donnees[j] < 0)
			{tab_donnees.push_back(256 + (int)donnees[j]);}
			else
			{tab_donnees.push_back((int)donnees[j]);}
		}

		depart += longueur_ligne * BMP_profondeur/8;
	}
	delete[] donnees;
	fichier.close();

	return 0;
}

int BMP2Gcode::sortie()
{
	std::string nom_fichier_gcode;
	nom_fichier_gcode = nom_fichier_bmp + ".gcode";

	std::ofstream fichier_sortie;
	fichier_sortie.open (nom_fichier_gcode);

	/****************************CONDITIONS INITIALES****************************/
	double taille_pixel = (double)(conf_taille_image)/(double)(BMP_largeur);

	int sens = 1, nbr_passage = 1, ligne = 0, colonne = 0;

	//on arrondi la taille du pixel pour quelle corresponde à un multiple de la taille du laser
	double rapport = ceil(taille_pixel/conf_taille_laser);
	taille_pixel = rapport * conf_taille_laser;

	std::cout << "***SORTIE***" << std::endl;
	std::cout << "largeur = " << BMP_largeur * taille_pixel << " mm" << std::endl;
	std::cout << "hauteur = " << BMP_hauteur * conf_taille_image/BMP_largeur << " mm" << std::endl;
	std::cout << "taille pixel = " << taille_pixel << " mm" << std::endl;

	//On passe en mode relatif
	fichier_sortie << "G91" << std::endl;

	//on s'assure que le laser est éteint
	fichier_sortie << "M106 P1 S0" << std::endl;

	//on défini la vitesse
	fichier_sortie << "G1 F" << conf_vitesse << std::endl;
	
	//on parcourt toutes les lignes
	while(ligne < BMP_hauteur)
	{
		//pour graver une ligne on fera des aller-retour tant que :
		do
		{
			fichier_sortie << ";colonne numéro : " << colonne << std::endl;
			fichier_sortie << ";ligne numéro : " << ligne << std::endl;
			fichier_sortie << ";sens : " << sens << std::endl;

			int indice = ligne * BMP_largeur + colonne; 
			
			fichier_sortie << ";indice : " << indice << std::endl;
			
			unsigned int puissance = 0, indice_min = 0, indice_max = 0, nbr = 1;
			puissance = conversion(255 - tab_donnees[indice], conf_puissance_min, conf_puissance_max);
			indice_min = ligne * BMP_largeur;
			indice_max = indice_min + BMP_largeur - 1;
			

			//on détermine le nombre de pixels successifs pour lesquels la puissance du laser sera la même
			nbr = consecutif(indice, indice_min, indice_max, puissance, sens);

			fichier_sortie << "M106 P1 S" << puissance << std::endl;

			//on se déplace selon le sens
			fichier_sortie << "G1 X" << sens * taille_pixel * nbr << std::endl;
			colonne += sens * nbr;
		}
		while(colonne < BMP_largeur && colonne >= 0);
		
		/*arrivé ici on vient de tracer une ligne et le paramètre colonne est hors limite, il faut donc le rectifier.
		Il est peut être également nécessaire de faire un retour cela va dépendre du rapport
		entre la taille du pixel et la taille du laser*/
		
		if(colonne < 0)
		{colonne = 0;}
		if(colonne >= BMP_largeur)
		{colonne = BMP_largeur - 1;}
		
		if(taille_pixel > conf_taille_laser * nbr_passage)
		{
			/*si on a pas fait un nombre de passage suffisent pour égaler la taille du pixel
			alors on repart dans l'autre sens en prennant soin de décaler la colonne
			et on recommence*/
			nbr_passage ++;
			fichier_sortie << ";passage numéro : " << nbr_passage << std::endl;
			fichier_sortie << ";colonne numéro : " << colonne << std::endl;
		}
		else
		{
			/*si le nombre de passage permet d'égaler la taille du pixel
			alors on change de ligne et on recommence*/
			ligne ++;
			nbr_passage = 1;
			fichier_sortie << ";changement de ligne : " << ligne << std::endl;
			fichier_sortie << ";colonne numéro : " << colonne << std::endl;
		}
		
		/*Dans les 2 cas il est nécessaire de se déplacer sur l'axe Y
		et de changer de sens*/
		fichier_sortie << "G1 Y" << conf_taille_laser << std::endl;
		sens *= -1;
	}

	//il ne faut pas oublier d'éteindre le laser à la fini
	fichier_sortie << "M106 P1 S0" << std::endl;

	fichier_sortie.close();

	return 0;
}

unsigned int BMP2Gcode::conversion(unsigned int valeur, unsigned int min, unsigned int max)
{
	/*pour une valeur de 0 la puissance du laser doit être égale à min
	*pour une valeur de 255 la puissance du laser doit être égal à max
	*pour trouver la valeur entre les deux on utilise une fonction affine
	y = ax + b
	pour x = 0 <=> y = b = min
	pour x = 255 <=> y = 255*a+min = max
	<=> a = (max - min)/255
	*/
	
	return valeur * (max - min)/255 + min;
}

unsigned int BMP2Gcode::consecutif(unsigned int indice, unsigned int min, unsigned int max, unsigned int puissance, int sens)
{
	/*Cette fonction va déterminer le nombre de pixel consécutif
	avec la même couleur que le premier pixel, dans un interval donné
	
	du fait de la calibration il se peut que des teintes de gris proches
	soient associées à la même puissance laser,
	il est donc nécessaire de comparer les puissance et non les données des pixel*/
	
	unsigned int nbr = 0;
	
	while(indice >= min && indice <= max)
	{
		if(puissance == conversion(255 - tab_donnees[indice], conf_puissance_min, conf_puissance_max))
		{nbr ++;}
		else
		{return nbr;}
		
		indice += sens;
	}
	return nbr;
}

void BMP2Gcode::fichier_conf()
{
	//On regarde si le fichier de configuration existe déjà
	std::ifstream fichier_conf("laser.conf");

	//s'il n'existe pas
	if(!fichier_conf)
	{
		//alors on le crée
		std::ofstream fichier_conf;
		fichier_conf.open("laser.conf");
		fichier_conf << "taille_laser(mm) 0.2" << std::endl;
		fichier_conf << "puissance_min 0" << std::endl;
		fichier_conf << "puissance_max 255" << std::endl;
		fichier_conf << "vitesse(mm/min) 1300" << std::endl;
		fichier_conf << "taille_image_x(mm) 150" << std::endl;

		std::cout << "*************************************************" <<std::endl;
		std::cout << "ATTENTION, un fichier de configuration a été crée" <<std::endl;
		std::cout << "Il ne contient probablement pas les bonnes valeurs" <<std::endl;
		std::cout << "Pour les connaitre il est nécessaire dutiliser" <<std::endl;
		std::cout << "les scripts d'étalonnage" <<std::endl;
		std::cout << "*************************************************" <<std::endl;

		conf_taille_laser = 0.2;
		conf_puissance_min = 0;
		conf_puissance_max = 255;
		conf_vitesse = 1300;
		conf_taille_image = 150;
	}
	else
	{
		//s'il existe on récupère les valeurs
		std::string clef;
		double valeur;
		while(fichier_conf >> clef >> valeur)
		{
			if(clef == "taille_laser(mm)")
			{conf_taille_laser = valeur;}

			if(clef == "puissance_min")
			{conf_puissance_min = valeur;}

			if(clef == "puissance_max")
			{conf_puissance_max = valeur;}

			if(clef == "vitesse(mm/min)")
			{conf_vitesse = valeur;}

			if(clef == "taille_image_x(mm)")
			{conf_taille_image = valeur;}
		}

		std::cout << "***CONFIGURATION***" << std::endl;
		std::cout << "taille_laser = " << conf_taille_laser << " mm" << std::endl;
		std::cout << "puissance_min = " << conf_puissance_min << " PWM 0-255" << std::endl;
		std::cout << "puissance_max = " << conf_puissance_max << " PWM 0-255" << std::endl;
		std::cout << "vitesse = " << conf_vitesse << " mm/min" << std::endl;
		std::cout << "taille_image = " << conf_taille_image << " mm" << std::endl;
	}

	fichier_conf.close();
}

int main(int argc, char* argv[])
{
	if(argc >= 2)
	{
		std::string entree = argv[1];
		BMP2Gcode image;
		image.fichier_conf();
		image.traitement(argv[1]);
	}
	else
	{std::cout << "Veuillez préciser un nom de fichier BMP" << std::endl;}

	return 1;
}