//---------------------------------------------------------------------------

#pragma hdrstop
#include <stdio.h>
#include <string.h>
#include <stdlib.h>//malloc se trouve dans cette bibliothéque qui doit être inclut pour utiliser maaloc
//---------------------------------------------------------------------------
#pragma argsused


//la declaration des fonctions doit être avant leur utilisation (n'oublie pas ça)
long filesize(FILE *stream);
int decode(int* caractere);
int encodage(int* caractere);
 
int main(int argc, char argv[])//soit (char * argr) soit(char argr[])
  {
  char* source=NULL;
  char dest;
  char option[2];
  char* final;
  char* temp;
  char ajout[2];
  unsigned char code;
  char resultat;
  FILE* fichierSource;
  FILE* fichierDest;
  int i,j,tabCaract[8],tabCaracte[8];
  long taille_fichier;
 //exemple
  // on vérifie qu'il y ait les 4 arguments
argc=4;
*argv='-';
*(argv+1)='c';
*(argv+2)='b';
*(argv+3)='c';

source = &argv[2];

fichierSource = fopen(source,"w");
fwrite("j",1,sizeof(char)*2,fichierSource);
fwrite("m",1,sizeof(char)*2,fichierSource);
fwrite("c",1,sizeof(char)*2,fichierSource);
fwrite("6",1,sizeof(char)*2,fichierSource);
fclose(fichierSource);



if(argc!=4)
{
  printf("il manque des arguements");
  return(0);
}
else
{
    // récupération des arguments
	option[0]=argv[0];
	option[1]=argv[1];
    source = &argv[2];
    dest = *(argv+3);
 
    // ouverture et lecture du fichier source
    if(fichierSource = fopen(source, "r+"))
      {
      taille_fichier = filesize (fichierSource);
      temp=(char *)malloc(sizeof(char) * taille_fichier);
      final=(char *)malloc(sizeof(char) * taille_fichier);
	  final="";
      fread (temp,1,taille_fichier,fichierSource);
      fclose(fichierSource);
      }
    // traitement du contenu
    for (i=0;i<taille_fichier;i++)
      {
      code = temp[i];
      // on passe le caractère en tableau de 8bits
      for(j=0;j<8;j++)
        {
        tabCaracte[j] = (code>127?1:0) ;
        code<<=1;
        }
      // on code ou décode en fonction de l'option
      for(j=0;j<8;j++)
        {
        if(strcmp(option,"-c")==1)
          tabCaract[j] = encodage(tabCaracte+j);

        if(strcmp(option,"-d")==1)
          tabCaract[j]= decode(tabCaracte+j);
       printf("%d\n",tabCaract+j); 
	  }
      //tab_caractere[nbcaractere++]=caractere;
 } //fin for (i=0;i<taille_fichier;i++)
     
	
	// on repase le résultat en caractère et on le stock
      resultat = (128*tabCaract[0])+(64*tabCaract[1])+(32*tabCaract[2])+(16*tabCaract[3])+(8*tabCaract[4])+(4*tabCaract[5])+(2*tabCaract[6])+(1*tabCaract[7]);
      ajout[0] = (char)resultat;
	  ajout[1] = '\0';
	  printf("%s\n\n",ajout);
      final=ajout;
     
 
    //on enregistre dans le fichier de destination
   fichierDest=fopen(&dest,"w+");
	
	if(fichierDest!=NULL)
      {
      fwrite(final,1,taille_fichier,fichierDest);
      fclose(fichierDest);
      }
} // fin else
  printf("%s",final);
  return(0);
  }
 
//*************************************
//********** FONCTION ENCODE **********
//*************************************
int encodage(int * caractere)
  {
  int binaire1[4],final[8],binaire2[4],d0[4],d1[4],i,m,j;

 //pour ne pas perdre le contenu du tableau on utilise static pour ne pas être écrasé aprés la fin de la fonction
  static int resultat=0;

  // on sépare en 2 blocque de 4
  for(i=0;i<4;i++)
    {
    binaire1[i]=caractere[i];
    binaire2[i]=caractere[i+4];
    }
 
  // on inverse selon la clé
  d0[0]=binaire2[1];
  d0[1]=binaire2[0];
  d0[2]=binaire2[3];
  d0[3]=binaire2[2];
 
  // on fais le XOR
  d1[0] = binaire1[0]+d0[0];
  d1[1] = binaire1[1]+d0[1];
  d1[2] = binaire1[2]+d0[2];
  d1[3] = binaire1[3]+d0[3];
 
  for(i=0;i<4;i++)
    {
    if(d1[i]==2)
      d1[i]=0;
    }
 
  //on complete la fin
  final[4]=d1[0];
  final[5]=d1[1];
  final[6]=d1[2];
  final[7]=d1[3];
  m=1;
 for(i=4;i<8;i++)
 {	 for(j=7-i;j>0;j--)
		 m=m*10;
	 resultat+=final[i]*m;
	 m=1;
}
  return resultat;
  }
 
//*************************************
//********** FONCTION ENCODE **********
//*************************************
int decode(int caractere[])
  {
  int binaire1[4],final[8],binaire2[4],d0[4],g0[4],i,m,j;
   static int resultat=0;
  // on sépare en 2 blocque de 4
  for(i=0;i<4;i++)
    {
    binaire1[i]=final[i+4]=caractere[i];
    binaire2[i]=caractere[i+4];
    }
 
  // on inverse selon la clé
  d0[0]=binaire1[1];
  d0[1]=binaire1[0];
  d0[2]=binaire1[3];
  d0[3]=binaire1[2];
 
  // on fais le XOR
  final[0] = binaire2[0]+d0[0];
  final[1] = binaire2[1]+d0[1];
  final[2] = binaire2[2]+d0[2];
  final[3] = binaire2[3]+d0[3];
 
  for(i=0;i<4;i++)
    {
    if(final[i]==2)
      final[i]=0;
	    }
  for(i=4;i<8;i++)
 {	 for(j=7-i;j>0;j--)
		 m=m*10;
	 resultat+=final[i]*m;
	 m=1;
}
  return resultat;
  }
//---------------------------------------------------------------------------
long filesize(FILE *stream)
{
   long curpos, length;
 
   curpos = ftell(stream);
   fseek(stream, 0L, SEEK_END);
   length = ftell(stream);
   fseek(stream, curpos, SEEK_SET);
   return length;
 
}