/******************* manipbits.cpp *****************/

#include <iostream>
#include <ctype.h>
using namespace std;

const int tailleint = 8 * sizeof(int); // variable contenant la taille (en bits) d'un nombre entier

void aff_bits( int n ); // affiche la representation binaire de "n"
int inverse( int x, int p, int n ); // complmente les n bits de x  partir du bit  la position p
int rot_droite( int n, int b ); // permutation circulaire vers la droite de b bits d'un entier n
#ifdef _WIN32
void soulign_bit( int p, int nb ); //souligne les bits modifiés lors de l'inversion ( uniquement sous windows)
#endif

/*************************************/
/****** fonction principale **********/
/*************************************/

int main()
{
	int entier, nbinv, pos, nbrot, choix;
	bool vrf;
	char rep;
	cout << "\t********************************************************" << endl;
	cout << "\t**************** Manipulation de bits ******************" << endl;
	cout << "\t********************************************************" << endl << endl;
	do
	{
		do
		{
			vrf = true;
			cout << "Entrez un nombre entier dont on manipulera la representation binaire:";
			if ( ! ( cin >> entier ) ) vrf = false;
			cin.clear();
			cin.ignore( 80, '\n' );
		}while ( ! vrf );
		cout << "Choisissez l' operation que vous voulez realiser sur ces bits:" << endl;
		cout << "1/ Affichage de la representation binaire de n" << endl;
		cout << "2/ Inversion de bits" << endl;
		cout << "3/ Rotation des bits (vers la droite)" << endl;
		cout << "4/ Fin du programme" << endl;
		do
		{
			vrf = true;
			cout << "Veuillez entrer l'option que vous souhaiter:";
			if ( ! ( cin >> choix ) || choix < 1 || choix > 4 ) vrf = false;
			cin.clear();
			cin.ignore( 80, '\n' );
		}while ( ! vrf );
		if ( choix == 1 )
		{
			cout << "Voici la representation binaire du nombre n:" << endl;
			aff_bits( entier );
		} else if ( choix == 2 )
		{
			cout << "Nous allons maintenant inverser un certain nombre de ces bits" << endl;
			do
			{
				vrf = true;
				cout << "Entrez le nombre de bits a inverser ( entre 1 et " << tailleint << " ):";
				if ( ! ( cin >> nbinv ) || nbinv > tailleint || nbinv < 1 ) vrf = false;
				cin.clear();
				cin.ignore( 80, '\n' );
			}while ( ! vrf );
			do
			{
				vrf = true;
				cout << "Entrez la position a partir de laquelle inverser ces bits ( entre " << nbinv << " et " << tailleint << " ):";
				if ( ! ( cin >> pos ) || pos < nbinv || pos > tailleint ) vrf = false;
				cin.clear();
				cin.ignore( 80, '\n' );
			}while ( ! vrf );
			cout << "Voici la representation binaire du nombre n avant inversion:" << endl;
			aff_bits( entier );
			cout << endl;
			cout << "Voici la nouvelle representation binaire apres inversion des " << nbinv << " bits." << endl;
			aff_bits( inverse( entier, pos, nbinv ) );
#ifdef _WIN32
			soulign_bit( pos, nbinv );
#endif
			cout << endl;
		} else if ( choix == 3 )
		{
			cout << "Nous allons effectuer des rotations de ces bits vers la droite" << endl;
			do
			{
				vrf = true;
				cout << "Entrer le nombre de rotations a effectuer ( > 0 ):";
				if ( ! ( cin >> nbrot ) || nbrot < 1 ) vrf = false;
				cin.clear();
				cin.ignore( 80, '\n' );
			}while ( ! vrf );
			cout << "Voici la representation binaire du nombre n avant rotation des bits:" << endl;
			aff_bits( entier );
			cout << endl;
			cout << "Voivi la nouvelle representation binaire apres " << nbrot << " rotations vers la droite." << endl;
			aff_bits( rot_droite( entier, nbrot ) );
		} else if ( choix == 4 )
		{
			return 0;
		}
		cout << "Voulez-vous recommencer? (o/n):";
		cin >> rep;
		cin.ignore( 80, '\n' );
	}while ( tolower(rep) == 'o' );
	return 0;
}

/*************************************/
/********* fonction aff_bits *********/
/*************************************/

void aff_bits( int n )
{
	unsigned int bit;
	unsigned int masque = 1;
	masque <<= ( tailleint - 1 ); // permet de décaler le bit 1 vers la gauche;
	for ( int i = 1; i <= tailleint; i++ )
	{
		bit = ( n & masque ) >> ( tailleint - 1 ); // l'application de ce masque permet de déterminer la valeur du premier bit de n en mettant tous les autres à zéro
		cout << bit << " ";
		n <<= 1;
		if ( i % 4 == 0) cout << " ";
	}
	cout << endl;
}

/*************************************/
/********* fonction inverse **********/
/*************************************/

int inverse( int x, int p, int n )
{
	unsigned int masque = 1; // masque qui servira à inverser les bits choisis
	for ( int i = 1; i < n; i++ ) masque = masque * 2 + 1; // on met les n bits à inverser à 1
	x ^= ( masque <<= ( p - n ) ); // on positionne les bits à inverser puis on inverse les bits choisis dans le nombre entier x
	return x;
}

/*************************************/
/****** fonction rot_droite **********/
/*************************************/

int rot_droite( int n, int b )
{
	unsigned int masque;
	b %= tailleint; //  avec le reste de la division de b par la taille de l'entier, on peut simuler une rotation de "plusieurs tours"
	for ( int i = 0; i < b; i++ )
	{
		masque = 1;
		masque &= n; // on verifie la valeur du dernier bit
		masque <<= ( tailleint - 1 ); // on met le premier bit à 1 et on laisse les autres à 0
		n >>= 1;
		if ( masque == 0 ) n &= ( ~( 1 << ( tailleint - 1 ) ) ); // on met le premier bit de n à 0
		else n |= masque; // on met le premier bit de n à 1
	}
	return n;
}

#ifdef _WIN32
/*************************************/
/****** fonction soulign_bit *********/
/*************************************/

void soulign_bit( int p, int nb )
{
	for ( int i = 1; i <= ( tailleint - p + nb ); i++ )
	{
		if ( i <= ( tailleint - p ) ) cout << "  ";
		else if( i >= ( tailleint - p ) ) cout << "- ";
		if ( ( i % 4 ) == 0 ) cout << " ";
	}
	cout << endl << endl;
}
#endif