// -*- coding: utf-8 -*-

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

// ************************************************************
// ... Problème I
// ************************************************************
#define MAX 100

void exo1() {
  char nom1[]="F1.txt", nom2[]="F2.txt", nomSortie[MAX];
  // saisir nom du fichier sortie
  printf("Nom de fichier en sortie\n");
  // saisir et nettoyer la chaine du '\n' pris par fgets
  fgets(nomSortie,MAX,stdin);
  if (nomSortie[strlen(nomSortie)-1]=='\n')
    nomSortie[strlen(nomSortie)-1]=0;

  // ouvrir les fichiers en lecture
  FILE *f1, *f2;
  if (f1=fopen(nom1,"r"), !f1) {
    printf("Ouverture de f1 impossible\n");
    exit(1);
  }
  if (f2=fopen(nom2,"r"), !f2) {
    printf("Ouverture de f2 impossible\n");
    exit(1);
  }

  // ouvrir le fichier en sortie
  FILE *fSortie;
  // attention à ne pas écraser de fichier existant
  if (fSortie=fopen(nomSortie,"r"), fSortie) {
    printf("Annulation! %s existe déjà\n", nomSortie);
    exit(1);
  }
  // c'est bon, essai d'ouverture en écriture
  if (fSortie=fopen(nomSortie,"w"), !fSortie) {
    printf("Ouverture %s impossible\n", nomSortie);
    exit(1);
  }
  
  // saisir alternativement dans f1 et f2
  int n1, cpt1, n2, cpt2;
  // code non optimisé (mais simple...)
  while (1) { //on sortira par break
    cpt1=fscanf(f1,"%d",&n1);
    cpt2=fscanf(f2,"%d",&n2);
    // contrôle de la lecture
    printf("%d %d / %d %d\n", n1, cpt1, n2, cpt2);
    // sortie dans le fichier
    if (cpt1 == 1) // encore des données dans f1
      fprintf(fSortie,"%d\n",n1);
    if (cpt2 == 1) // encore des données dans f2
      fprintf(fSortie,"%d\n",n2);
    // tout est fini ?
    if (cpt1!=1 && cpt2!=1)
      break;
  }
  
  fclose(fSortie);
  fclose(f1);
  fclose(f2);

} // exo1

// ************************************************************
// ... Problème II
// ************************************************************

typedef struct chainonMot{
  char *mot;
  struct chainonMot *suiv;
}CHAINON_MOT;

void inserer(char *mot, CHAINON_MOT **pliste) {
  // alllouer la zone de stockage du mot
  char *mot_compact = (char*) malloc(sizeof(char)*(strlen(mot)+1));
  // allouer le chainon de liste
  CHAINON_MOT *tmp = (CHAINON_MOT*) malloc(sizeof(CHAINON_MOT));

  // remplir le chainon
  tmp->mot=mot_compact;
  strcpy(tmp->mot, mot); 

  // établir le chainage
  tmp->suiv=*pliste;
  *pliste=tmp;
} // inserer

void rechercher(char lettre, CHAINON_MOT *liste) {
  // boucler tant que pas en fin de liste
  while (liste) { // ou bien: while (liste!=0)
    // y a-t-il bien un mot? commencant par la lettre?
    if (liste->mot && liste->mot[0] == lettre)
      printf("%s\n", liste->mot); // oui, afficher
    liste=liste->suiv; // voir plus loin
  }   
} //rechercher

void exo2() {
  CHAINON_MOT *liste=0; // vide au départ!
  char tampon[MAX];
  char lettre;

  // saisie et insertion
  printf("saisir les mots, chaine vide pour stopper\n");
  do {
    // saisir et nettoyer la chaine du '\n' pris par fgets
    fgets(tampon,MAX,stdin);
    if (tampon[strlen(tampon)-1]=='\n')
      tampon[strlen(tampon)-1]=0;
    // fin de saisie?
    if (strlen(tampon)==0) // fini
      break;
    // inserer le mot courant
    inserer(tampon,&liste); // liste va etre modifiée
  } while(1);

  // recherche
  printf("saisir la lettre à chercher: ");
  scanf("%c", &lettre);
  rechercher(lettre, liste);

  // nettoyer (pourrait être dans une fonction à part)
  CHAINON_MOT *tmp;
  while (liste) { // jusqu'en fin de liste
    // preparer le passage au suivant
    tmp=liste;
    liste=liste->suiv; 
    // nettoyer
    free(tmp);
  }
  liste=0;
} // exo2



// ************************************************************
int main() {

  exo1();
  exo2();

  return 0;
}