/******************************************************************************
**
** Version initiale.
** ----------------
** Ce programme se compose de trois fonctions. La fonction de distributeur
** est chargée de lire les caractères en provenance de l'entrée standard,
** d'envoyer les chiffres à compteur_chiffres et les lettres à compteur_lettres.
** Une fois la fin de fichier atteinte, les fonctions renvoient leurs
** résultats à la fonction de distribution qui affiche ensuite les résultats.
**
******************************************************************************/

#include <assert.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

int fd_chiffres[2];
int fd_lettres[2];
int fd_reponse_chiffres[2];
int fd_reponse_lettres[2];

/*
 * Distribution des caractères et affichage des résultats.
 */
void distributeur() {
  int car;
  int somme_chiffres = 0;
  char lettre_max = ' ';

  /* Distribution des caractères. */
  do {
    car = getchar() ;

    if (isalpha(car) || (car == EOF)) {
      /* on envoie le caractere a compteur_lettres */
      write(fd_lettres[1], &car, sizeof(car));
    }

    if (isdigit(car) || (car == EOF)) {
      /* on envoie le caractere a compteur_chiffres */
      write(fd_chiffres[1], &car, sizeof(car));
    }
  } while(car != EOF);

  /* On recupere les résultats */

  read(fd_reponse_chiffres[0], &car, sizeof(car));
  somme_chiffres = car;
  read(fd_reponse_lettres[0], &car, sizeof(car));
  lettre_max = car;

  printf("Somme des chiffres: %d\n", somme_chiffres);
  printf("La lettre la plus frequente est : %c\n", lettre_max);
}

/*
 * Fait la somme de tous les chiffres distribués
 */
void compteur_chiffres() {
  int c = 0;
  int somme = 0;

  while(1) {
    /* On reçoit un chiffre */
    int ret = read(fd_chiffres[0], &c, sizeof(c));
    if(ret < sizeof(c) || c == EOF) {
      break;
    }

    somme += (c - '0');
  }

  /* On envoie le résultat */
  write(fd_reponse_chiffres[1], &somme, sizeof(somme));
}

/*
 * Calcule la lettre la plus fréquente
 */
void compteur_lettres() {
  int c = 0;
  static int frequence['z' - 'a' + 1] ;

  while(1) {
    /* On reçoit une lettre */
    int ret = read(fd_lettres[0], &c, sizeof(c));
    if(ret < sizeof(c) || c == EOF) {
      break;
    }

    frequence [ tolower ( c ) - 'a' ] ++ ;
  }

  /* On cherche la lettre la plus fréquente */
  int i;
  int freq_max = 0;
  int lettre_max = ' ';
  for(i=0; i<'z' - 'a' + 1; i++) {
    if(frequence[i]>freq_max) {
      lettre_max = i+'a';
      freq_max= frequence[i];
    }
  }

  /* On envoie le résultat */
  write(fd_reponse_lettres[1], &lettre_max, sizeof(lettre_max));
}

/*
 * Lancement de la fonction de distribution.
 */
int main(int argc, char* argv[]) {
  int ret;

  /* Initialisation */
  ret = pipe(fd_chiffres);
  assert(!ret);

  ret = pipe(fd_lettres);
  assert(!ret);

  ret = pipe(fd_reponse_chiffres);
  assert(!ret);

  ret = pipe(fd_reponse_lettres);
  assert(!ret);


  /* Création des processus chargés de traiter les chiffres et les lettres */
  ret = fork();
  assert(ret>=0);
  if(!ret) {
    /* processus fils */
    compteur_chiffres();
    exit(0);
  }

  ret = fork();
  assert(ret>=0);
  if(!ret) {
    /* 2eme processus fils */
    compteur_lettres();
    exit(0);
  }

  /* Lancement du travail. */
  distributeur();


  int status;
  /* attente de la terminaison des 2 fils */
  ret = wait(&status);
  assert(ret>=0);

  ret = wait(&status);
  assert(ret>=0);

  /* Tout s'est bien terminé. */
  exit(0);
}