#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

/* A COMPLETER: ajout de directives #include */
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <assert.h>


#define SCRIPT_NAME "./cartoon.sh"
#define BUFFER_SIZE 1024
#define NOMTUBESERVEUR "./client-serveur"


/* Appelle le script cartoon.sh
 *   input_filename: nom du fichier image a traiter
 *   output_filename: nom du fichier image resultat
 */
void create_output_image(const char* input_filename, const char* output_filename) {
  char command[BUFFER_SIZE];
  snprintf(command, BUFFER_SIZE, "%s %s %s", SCRIPT_NAME, input_filename, output_filename);
  printf("Running command %s\n", command);
  int ret = system(command);
  if(ret > 0) {
    fprintf(stderr, "The command '%s' failed !\n", command);
    abort();
  }
}

/* Traite une requete
 */
void traiterRequete(char *requete){
  char input_filename[BUFFER_SIZE];
  char tube_client[BUFFER_SIZE];

  /* crée un fichier temporaire pour stocker le resultat */
  char output_filename[BUFFER_SIZE];
  sprintf(output_filename, "/tmp/image_XXXXXX.jpeg");
  int fd = mkstemps(output_filename, 5);
  close(fd);

  /* Analyse de la requete */
  sscanf(requete,"%s\n%s", tube_client, input_filename);

  /* Traitement de la requete */
  create_output_image(input_filename, output_filename);

  /* A COMPLETER: renvoyer le contenu de output_filename au client */

  int fdW = open(tube_client, O_WRONLY);
  if (fdW == -1) {
    perror("open(nomTubeClient)");
    exit(EXIT_FAILURE);
  }

  int fd_in = open(output_filename, O_RDONLY);
  assert(fd_in>=0);

  int nb_read = 0;
  int total_read = 0;
  char buffer[BUFFER_SIZE];
  int nb_write;

  struct stat stat_info;
  int ret = fstat(fd_in, &stat_info);
  assert(ret == 0);
  printf("File size: %lu bytes\n", stat_info.st_size);

  nb_write = write(fdW, &stat_info.st_size, sizeof(stat_info.st_size));
  if (nb_write < sizeof(off_t)) {
    perror("pb ecriture sur tube nomme");
  }

  do {
    nb_read = read(fd_in, buffer, BUFFER_SIZE);
    total_read += nb_read;
    printf("Ecriture de %d bytes\n", nb_read);
    nb_write = write(fdW, buffer, nb_read);
    if (nb_write < nb_read) {
      perror("pb ecriture sur tube nomme");
    }
  } while(nb_read > 0);

  printf("Fin du traitement\n");

  close(fd_in);
  /* 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 wait_for_a_client() {
  char requete[BUFFER_SIZE];

  /* A COMPLETER : ouvrir un tube nommé NOMTUBESERVEUR */
  int fdR;
  int nbRead;

  /* Création du tube nommé côté serveur (qui permettra les communications */
  /* client-serveur)                                                       */
  if (mkfifo(NOMTUBESERVEUR, S_IRUSR|S_IWUSR) < 0) {
    if (errno != EEXIST) {
      perror("mkfifo(tube nommé serveur");
      exit(EXIT_FAILURE);
    }
    else {
      printf("%s existe deja : on suppose que c'est un pipe nomme\n",
	     NOMTUBESERVEUR);
      printf("et qu'on peut continuer le programme sans probleme\n");
      puts("");
    }
  }
  /* Ouverture de ce tube nommé */
  fdR = open(NOMTUBESERVEUR, O_RDWR);
  if (fdR == -1) {
    perror("open(tube nommé)");
    exit(EXIT_FAILURE);
  }

  /* Attente de requêtes */
  do{
    /* A COMPLETER: recevoir une requete d'un client */
    nbRead = read(fdR, requete, sizeof(requete));
    if (nbRead != sizeof(requete)) {
      perror("read sur tube nomme NOK");
      abort();
    }

    /* On traite la requête */
    traiterRequete(requete);
  } while(1);
}

int main(int argc, char**argv) {
  wait_for_a_client();
  return EXIT_SUCCESS;
}