#define LED (8)
 #include <stdlib.h>
 #include <stdbool.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <sys/un.h>

// Init Serie

/* Quelques constantes */

 #define SOCKET_ECRITURE "/tmp/serial.send"
 #define SOCKET_LECTURE "/tmp/serial.recv"
 #define PING_Draw 300000
 #define PING_Read 300000

/* Creation d'un client socket famille Unix */

 int connexionServeur(char *chemin){

 int ds;                         /* Descripteur de SOCKET */

 struct sockaddr_un adresse;     /* Adresse du serveur */

 int statut;                     /* Stocke le statut des 
 commandes */

/* Creation de la SOCKET du client */

 ds=socket(AF_UNIX,SOCK_STREAM,0);

 if(ds<0) {perror("connexionServeur.socket"); 

 exit(-1);}

/* Preparation de la structure adresse du serveur */

 adresse.sun_family=AF_UNIX;

 strcpy(adresse.sun_path,chemin);

/* Connexion au serveur */
 statut=connect(ds,(struct sockaddr*)&adresse,sizeofdresse)
 if(statut<0)

 {perror("connexionServeur.bind"); 

 exit(-1);}

 printf("ds=%d\n",ds);

 return ds;
 }

// Structures
//structure du snake.

//On utilise un tableau qui memorise la coordonnee de chaque partie du snake

//Les valeurs des coordonnees se deplacent cicliquement dans le tableau pour n'avoir qu'a faire une unique affectation par deplacement.
 typedef struct {
    int t; //numéro de la queue (tail) dans le tableau
    int l; //taille du snake  (length)
    int T[LED*LED]; //tableau de position du corp
  } 
 snake;


// fonction de lecture d'entrée \\

//l'objectif de cette fonction est de lire les entrées (touches) et de modifier la variable associé pour la direction du snake seulement si une touche est appuyé

 void lire (int * dir,int sl) {
  printf("debut lecture\n");
  int c;
  int d=0;
  int k;

  usleep(PING_Read); //attente pour eviter les conflits lecture/ecriture

  //cette boucle a pour but de faire un nombre de lecture eleveet de memoriser dans c les valeurs ssi elles ne sont pas =0
  for(k=0;k<30;k++) { 
    read(sl,&d,1);
    if (d!=0) c=d;
    printf("(%d:%d)", k, d);// affichage pour verification
  }

  
  if (c==2 || c==130) *dir=-8; //haut
  if (c==4 || c==132) *dir=8; //bas
  if (c==8 || c==136) *dir=-1; //gauche
  if (c==1 || c==129) *dir=1; //droite
 }


//genere intelligemment  une nouvelle cible
 
 void change(int * sou, int * pt, bool * Mat) {
  int i;
  if (*pt==1) {
    *pt=2;i=50;
  }
  else {
    *pt=1;i=22;
  } 
  while (Mat[i]) i=(i+1)%(LED*LED);
  *sou=i;
  Mat[i]=true;
 } 


// envoi la matrice a afficher
 
 void draw (bool * Mat, int se) {
  int i,j,k;
  int col=0;
  int puiss=0;
  int cur=0;
  
  usleep(PING_Draw);
  //affichage dans la console
  for (i=0;i<LED;i++) {
    for (j=0;j<LED;j++) {
      if (Mat[i*LED+j]) printf("1");
      else if (!(Mat[i*LED+j])) printf("0");
      else printf("Error !");
    }
    printf("\n");
  }//*/
  
//*********envoi sur le port serie*****************

  //* 
  for (i=0;i<LED;i++) { //pour chaque ligne
    col=0;
    for (j=0;j<LED;j++) { //pour chaque colone
      if (Mat[i*LED+j]) {

	//calcul de la valeur a envoyer

	// remarque : la notation x^y ne compile pas

 cur=2;
 puiss=7-j;
 for (k=0;k<puiss;k++) cur=cur*2;	
 col = col + cur;
      }
    }
    write(se,&col,1); // on envoi la valeur de la ligne
  }
  //*/
  
  /********pour le mode 14*********
  int LedOn = 1; //pour mode 14
  int LedOff = 0;
  int cpt=0;  
  for (i=0;i<LED*2;i++) {
    for (j=0;j<LED;j++) {
      if (Mat[(i/2)*LED+j]) {
 write(se,&LedOn,1);
 write(se,&LedOn,1);
 cpt = cpt +2;
      }
      else { write(se,&LedOff,1);
 write(se,&LedOff,1);
 cpt = cpt + 2;}
    }
  }
  printf("J'ai fait %d write\n", cpt);
  //*/
 } 




// déplacement du serpent \\

// déplace le serpent d'un cran

 void move (snake * kaa, bool * Mat, int  dir) {
  int tail = kaa->t;
  int length = kaa->l;
  int new;
  Mat[kaa->T[tail]]=false; //on efface le bout de la queue
  kaa->t=(kaa->t+1); //on incremente la position de la queue
  tail = (tail+1)%(LED*LED); 
  if (kaa->t>=(LED*LED)) kaa->t=kaa->t-(LED*LED) ;
  new=tail+length-1; 
  if (new>=(LED*LED)) {
    new=new-(LED*LED); 
    kaa->T[new]=kaa->T[((new-1+LED*LED)%(LED*LED))]+dir;
  }
  else {
    if (new!=0) {
      kaa->T[new]=kaa->T[new-1]+dir;      
    }    
    else {
      kaa->T[new]=kaa->T[(LED*LED-1)]+dir; } }
    
  Mat[kaa->T[new]]=true;
    
 }

//vérifie les positions pour le coup prochain

//mort ; mange ; rien
 void checkNext (snake *  kaa, bool * Mat, int * sou, int * sco, bool * vie, int dir, int * pt) { 
  int i;
  int head; //point où le serpent est
  head=((kaa)->T[((kaa)->t+(kaa)->l-1)%(LED*LED)]);
  
//Gestion des murs 

  if ((head%LED==0) && (dir==-1)) { //mur gauche
    *vie=false;
    printf("murg\n");}
  else if ((head<LED) && (dir==-LED)) { //mur haut
    *vie=false;printf("murh\n");}
  else if ((head>=(LED*(LED-1))) && (dir==+LED)) {//mur bas
    *vie=false;printf("murb\n");}
  else if ((head%LED==(LED-1)) && (dir==1)) { //mur droite
    *vie=false;printf("murd\n");}
  else if (head==*sou) { // gestion des kills
    printf("miam !\n");
    change(sou,pt, Mat);
      (*sco)++;
      (kaa)->l++;
      (kaa)->t--;
      if ((kaa)->t==-1) {
 (kaa)->t=(LED*LED-1);
 }
  }
  else {
    //se mange la queue
    head+=dir; //head = là ou le serpent va
    for (i=0;i<((kaa)->l);i++) {
      *vie= *vie && (head!=((kaa)->T[((kaa)->t+i)%(LED*LED)]));
    }
    if (!*vie) printf("canibale ! \n");
  }
 } 
// action d'initialisation

// initialise l'affichage, le snake et la cible

 void init (bool * Mat, snake * kaa, int * dir, int * tar, int sl, int * pt) {
  int i;
  int c,e=1;
  printf("debut init\n");
  *dir = 1;
  *tar = 22;
  *pt = 1;
  (kaa)->l=1;
  (kaa)->t=0;
  (kaa)->T[0]=0;
  for (i=0;i<(LED*LED);i++) {
    Mat[i]=false;
    
  }
  Mat[0]=true;
  Mat[22]=true;

//on attend que tout les bouttons renvoient 0
 
 printf("ok, give me a 0 with the button\n");
  while (e!=0 && e!=128) {
    printf("0!=(%d)\n", e);
    usleep(PING_Draw);
    read(sl,&e,1);}

//on attend que l'utilisateur appuie sur une touche
  
 printf("nice, now push the right button\n");
  c=e;
  while (e==c) {
    printf("0=(%d)\n", c);
    usleep(PING_Draw);
    read(sl,&c,1);}
 }

//affichage de fin du jeu

 void TheEnd (int se) {
  printf("fin du jeu\n");
  int smile;
  smile=255;write(se,&smile,1); // 
  write(se,&smile,1);           //
  smile=102;write(se,&smile,1); // **  **
  write(se,&smile,1);           // **  **  
  smile=0;write(se,&smile,1); // 
  write(se,&smile,1);           //
  smile=60;write(se,&smile,1); //  ****  
  smile=0;write(se,&smile,1); //
 }


// Fonctions d'affichage

 void clear(int se)
 {
 int i;
 unsigned char c=0;
 usleep(PING_Draw);
 c=0x00;
  for (i=0;i<LED;i++) 
 {
    write(se,&c,1);
  }
 
 }

 int main ( )
 {
  
  bool Matrice[64]; //vecteur de représentation de la matrice de led
  bool alive=true; // booleen de fin du jeu (mort du snake)
  snake  kaa; //kaa est le nom du serpent dans le livre de la jungle
  int direction; // +1 droite ; -1 gauche ; +8 bas ; -8 haut
  int mouse; //emplacement de la cible
  int etat; //etat de la cible
  int score=0; //score du joueur
  
// Affichage matrice

  int se=connexionServeur(SOCKET_ECRITURE);
  if(se<0){ fprintf(stderr,"Serveur serie (ecriture) absent\\n"); exit(-1); }
  int sl=connexionServeur(SOCKET_LECTURE);
  if(sl<0){ fprintf(stderr,"Serveur serie (electure) absent\\n"); exit(-1); }

  init (Matrice,&kaa,&direction,&mouse, sl, &etat); //initialisation 
 
 direction=1;


//début de la boucle de jeu
  
 while (alive) {
    lire(&direction, sl); //lecture
    checkNext (&kaa,Matrice,&mouse,&score,&alive,direction,&etat);    //analyse du coup suivant
    move (&kaa,Matrice,direction); //mouvement
    draw(Matrice, se); //affichage
  }
  TheEnd(se); 
  close(se);
  close(sl);  
  return 0;
 }