#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>

#include "libbmp.h"
#include "libstegano.h"
#include "libcrypto.h"

int insert (byte *pix, unsigned int pix_size, byte *msg, unsigned int msg_size)
{	
	//Conversion de [msg_size] en binaire
	byte *sizeMsgBin;	//Déclaration tableau binaire 
	sizeMsgBin = convBin(msg_size);	//Conversion [msg_size] en binaire + mise dans tableau
	
	//Conversion du message en binaire
	byte *msgBin;
	msgBin = convBin2(msg, msg_size);	//Séparation de chaque bit en 1 octet
	
	//Insertion taille du message
	int i;
	unsigned int bit_pf_pix;	//déclaration bit de poids faible de *pix
	for(i=0; i<32; i++)		//Ajout octets par octets dans *pix de taille msg
	{
		bit_pf_pix = (pix[i] & 1);	//Récupération bit poids faible pix[i]
		
		if(bit_pf_pix != (unsigned int)sizeMsgBin[i])	//Comparaison bit de poids faible et bit du message
		{
			if(bit_pf_pix==0)
			{	
				pix[i] = pix[i] >> 1;
				pix[i] = pix[i] << 1;
			}				
			pix[i] = pix[i] | sizeMsgBin[i];
		}
	}

	//Insertion du message chiffré
	for(i=33; i<(33+msg_size*8); i++)	//Jusqu'à l'octet 32 : la taille du message est codée
	{
		bit_pf_pix = (pix[i] & 1);
		if(bit_pf_pix != (unsigned int)msgBin[i])	//Comparaison bit de poids faible et bit du 
		{
			if(bit_pf_pix==0)
			{	
				pix[i] = pix[i] >> 1;
				pix[i] = pix[i] << 1;
			}				
			pix[i] = pix[i] | msgBin[i];
			
		}
	}	//Fin de l'insertion du message dans le tableau de pixel

	free(msgBin);
	free(sizeMsgBin);

	return 0;
}

byte *extract (byte *pix, unsigned int pix_size, unsigned int *msg_size)
{
	int i, j;
	unsigned int res=0;
	unsigned int bit_pf_pix;
	byte *tabMsg;
	tabMsg = (byte*) calloc(*msg_size, sizeof(byte));
	
	unsigned int k = 32+*msg_size*8;
	for(i=*msg_size; i>=0; i--)	//Parcours octet par octet
	{
		for(j=0; j<8; j++)	//Remplissage de l'octet
		{
			bit_pf_pix = (pix[k] & 1);
			
			res = res*10 + bit_pf_pix ;
			
			k= k - 1;
		}
		tabMsg[*msg_size] = res;	//Entrer de chaque octet dans le tableau du message
		res = 0;
	}
	
	return tabMsg;
}

byte *convBin(unsigned int size)
{
	int i;
	unsigned int bit_pf;
	unsigned char *bit ;
	bit = (unsigned char*) calloc(32, sizeof(unsigned char));
	for(i=0 ; i<32; i++)
	{
		bit_pf = size >> i;	//Récupération du bit de poids faible
		bit[i] = (bit_pf & 1);
	}
	return bit;
}



byte *convBin2(byte *msg , unsigned int size)	// ATTENTION : size est la taille du msg en octet
{
	int n;
	int unsigned getBit;
	
	int i;
	int isz=0;
	unsigned int bit_pf;
	unsigned char *bit2 ;
	bit2 = (unsigned char*) calloc(size*8, sizeof(unsigned char));	//size*8 car on multiplie souhaite ajouter tous chaque bit dans un octet
	
	for(n=0; n<size; n++)
	{
		
		getBit = (unsigned int) msg[n];	//Récupération d'un octet en entier
		printf("%d\n", getBit);
		
		//Conversion de l'entier en binaire + intégration dans le tableau de valeur
		for(i=0 ; i<8; i++)
		{
			bit_pf = getBit >> i;	//Récupération du bit de poids faible
			bit2[isz+i] = (bit_pf & 1);
		}
		
		isz = isz + 8;	//Déplacement de l'entrée de valeur dans la tableau
	}

	return bit2;
}