#include <pthread.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <ctype.h>
#include <errno.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>

#include "client-serveur.corrige.h"

#define NBENFANTS 26

int pereEnfant[NBENFANTS][2];

void traiterRequete(requete_t *requete, FILE *f, int debutRech, int finRech){
  reponse_t reponse;
  char ligne[256];
  int fdW;
  int nbWrite;

  /* Calcul reponse->pointAccesPrive */
  strcpy(reponse.pointAccesPrive, "");
              /* Le point d'accès privé n'est pas utilisé dans cette appli */

  /* Calcul reponse.contenu. */
  if (fseek(f, debutRech, SEEK_SET) < 0) {
    perror("fseek");
    exit(EXIT_FAILURE);
  }
  while ((feof(f) == 0) && (ftell(f) < finRech)) {
    if (fgets(ligne, sizeof(ligne), f) != NULL) {
      if (strncmp(ligne, requete->contenu, strlen(requete->contenu)) == 0){
	break;
      }
    }
  }
  if ((feof(f) == 0) && (ftell(f) < finRech)) {
    strcpy(reponse.contenu, ligne);
    reponse.contenu[strlen(ligne)-1] = '\0'; /* Supprime le '\n' final */
  }
  else {
    strcpy(reponse.contenu,"Désolé, je ne le connais pas");
  }

  /* Affichage */
  printf("L'enfant %d du serveur a recu \"%s\" et repond \"%s\"\n",
	 getpid(),
	 requete->contenu,
	 reponse.contenu );

  /* Connexion au point d'accès client et réponse */
  fdW = open(requete->pointAccesClient, O_WRONLY);
  if (fdW == -1) {
    perror("open(pointAccessClient)");
    exit(EXIT_FAILURE);
  }
  nbWrite = write(fdW, &reponse, sizeof(reponse));
  if (nbWrite < sizeof(reponse)) {
    perror("pb ecriture sur pipe nomme");
  }

  sleep(5);
  /* Dans cette application, le client ne renvoie pas de requête ultérieure*/
  /* nécessitant une réponse ==> On peut fermer ce tube                    */
  close(fdW);

}

void *attenteRequete(void *arg){
  requete_t requete;
  FILE *f;
  int debutRech;
  int finRech;
  char ligne[256];
  int monNum;

  monNum = (int)arg;
  /* Ouverture du fichier de M. et Mme */
  f = fopen("mEtMme.txt", "r");
  if (f == NULL) {
    perror("open(mEtMme.txt)");
    exit(EXIT_FAILURE);
  }

  /* On cherche à partir d'où il y a des enregistrements qui correspondent à */
  /* la lettre associée à monNum (si monNum == 0, 'A', 1 'B'...              */
  while (feof(f) == 0) {
    debutRech = ftell(f);
    if (fgets(ligne, sizeof(ligne), f) != NULL) {
      if ((ligne[0]-'A') == monNum) {
	break;
      }
    }
  }
  if (feof(f) == 0) {
    /* On a trouvé la lettre dans le fichier : on cherche le dernier endroit*/
    /* où elle apparaît pour avoir finRech                                  */
    int dernFgetsOK;
    while (feof(f) == 0) {
      dernFgetsOK = ftell(f);
      if (fgets(ligne, sizeof(ligne), f) != NULL) {
	if ((ligne[0]-'A') != monNum) {
	  finRech = ftell(f);
	  break;
	}
      }
    }
    if (feof(f) != 0){
      finRech = dernFgetsOK + strlen(ligne);
    }
  }
  else {
    /* On n'a pas trouvé la lettre dans le fichier : on positionne debutRech */
    /* et finRech de la manière qui nous arrange le plus pour la suite       */
    debutRech = 0;
    finRech = 0;
  }

  /* Attente de requête */
  while(1){

    /* On attend une requête */
    read(pereEnfant[monNum][0], &requete, sizeof(requete));

    /* On la traite */
    traiterRequete(&requete, f, debutRech, finRech);
  }
}
    
int main() {
  requete_t requete;
  int fdR;
  int nbRead;
  int i;

  /* Création du tube nommé du serveur */
  if (mkfifo(NOMPOINTACCESSERV, S_IRUSR|S_IWUSR) < 0) {
    if (errno != EEXIST) {
      perror("mkfifo(tube nommé client");
      exit(EXIT_FAILURE);
    }
    else {
      printf("%s existe deja : on suppose que c'est un pipe nomme\n",
	     NOMPOINTACCESSERV );
      printf("et qu'on peut continuer le programme sans probleme\n");
      puts("");
    }
  }

  /* Création du pool de fils                                             */
  /* Le pool est représenté par un tube sur lequel le père lit les        */
  /* numéros des fils qui se considèrent prêts à traiter des requêtes     */
  for (i=0 ; i<NBENFANTS ; i++){
    pipe(pereEnfant[i]);
  }
  for (i=0 ; i<NBENFANTS ; i++){
    int retcode;
    pthread_t thread;
    retcode = pthread_create(&thread, NULL, attenteRequete, (void *)i);
    if (retcode != 0)
      {
	fprintf(stderr, "pthread_create: %s", strerror(retcode));
	exit(EXIT_FAILURE);
      }
    pthread_detach(thread);
  }

  /* Ouverture de ce tube nommé (equivalent a une ouverture de connexion).
     NB : On l'ouvre en RDWR et pas en RDONLY,
     car (cf. Blaess) : si nous ouvrons le client en lecture seule, à chaque
     fois que le client se termine, la lecture du tube nomme va echouer
     car le noyau detecte une fermeture de fichier. En demandant un tube
     en lecture et en ecriture, nous evitons ce genre de situation, car il
     reste toujours au moins un descripteur ouvert sur la sortie
  */
  fdR = open(NOMPOINTACCESSERV, O_RDWR);
  if (fdR == -1) {
    perror("open(tube nommé)");
    exit(EXIT_FAILURE);
  }
  /* Attente de requêtes */
  do{
    nbRead = read(fdR, &requete, sizeof(requete));
    if (nbRead != sizeof(requete)) {
      perror("read sur tube nomme NOK");
      return EXIT_FAILURE;
    }
    /* On envoie la requête a l'enfant concerné */
    if ((requete.contenu[0] >='A') && (requete.contenu[0] <= 'Z')) {
      write(pereEnfant[requete.contenu[0]-'A'][1], &requete, sizeof(requete));
    }
    else {
      /* On demande à l'enfant qui s'occupe des 'A' de répondre "Désolé" */
      /* pour nous                                                       */
      write(pereEnfant[0][1], &requete, sizeof(requete));
    }
  }while(1);
}