// --------------------------------------------------------
  // Projet IMA3 2019 - Lecture d'une bibliothèque
  // Décompte du nombre de fautes d'orthographe dans un texte
  // Normand Quentin & Rouillé Guillaume
  // --------------------------------------------------------
  

  #include "tree.h"

  // Fonction permettant de savoir si la structure est vide

  bool is_empty_tree(Node Tree)

  {

    return(Tree==NULL);

  }
  

  // Fonction permettant de savoir si le tableau 'next' est un tableau de pointeurs NULL

  bool is_leaf(Node Tree)

  {

    for(int i=0; i<NB_CARAC; i++)
      if(Tree->next[i] != NULL)
        return false;
    return true;

  }
  

  // Initialisation de la structure accueillant le dictionnaire

  void init_tree(Node* Tree)
  {

    if(is_empty_tree(*Tree))

      {

        *Tree = malloc(sizeof(node));

        (*Tree)->letter = 7; // caractère sans utilité

        (* Tree)->endWord = false;

        for(int i=0; i<NB_CARAC; i++)

          (*Tree)->next[i] = NULL; // initialisation du tableau 'next' à un tableau de pointeurs NULL

      }

  } 

  // Détermine l'indice de rangement dans le tableau 'next' du caractère 'letter'

  int find_caract_indice(char letter)

  {

    if(letter>=97 && letter<=122) return letter-'a';
    if(letter>=65 && letter<=90) return letter-'A';

    if(letter == 39) return 26; // l'apostrophe est placée en 27ème position
    else return -1;

  }
  
  // Fonction d'ajout d'un mot 'word' dans la structure 'tree' de type 'arbre indexé'

  void add_in_tree(Node Tree, char word[])

  {

    int j=0; // indice du caractère dans le mot 'word'
    int ind; // indice du caractère dans le tableau 'next'

    Node Tree2 = Tree;

    while(word[j] != '\0') // on parcourt tout le mot 'word'

      {

        char letter = word[j];

        ind = find_caract_indice(letter); // on récupère l'indice de rangement de 'letter'
        
        if(Tree2->next[ind]!=NULL) // si le pointeur du tableau 'next' correspondant au caractère lu n'est pas NULL, on s'insère dans cette 'branche' de l'arbre indexé et on continue avec le caractère suivant

        {
          Tree2 = Tree2->next[ind];

        }
        else // sinon, on ajoute une nouvelle cellule de type 'struct node' et on y insère les informations concernant le caractères
        {
          Node new = NULL;
          new = malloc(sizeof(node));

  	
          new->letter = letter;
          for(int i=0; i<NB_CARAC; i++)

            {
              new->next[i]=NULL;
            }

  	new->endWord = false;

          Tree2->next[ind] = new;  // on fait pointé le tableau du caractère précédent vers cette cellule (vers ce caractère)

          if(!(Tree2->endWord)) // si le caractère précédent n'est pas un caractère de fin, on lui donne la valeur 'false'

            Tree2->endWord = false;

          Tree2=Tree2->next[ind]; // on se place au niveau du caractère suivant dans l'arbre indexé

        }

        j++;

        if(word[j]=='\0') // si le caractère suivant est la fin de la chaîne, on dit que le caractère précédent est un caractère de fin
          Tree2->endWord = true;

      }

  }
  

  // Fonction qui détermine si le caractère est un caractère de fin de mot (espace, ',', ';', '.', etc..)

  bool is_end_caract(char letter)
  {

    if(letter==0) return true;

    if((letter>=32 && letter<=38)||(letter>=40 && letter<=47)||(letter>=58 && letter<=64)||(letter>=123 && letter<=126)) return true;

    return false;
  }
  

  // Renvoi l'indice maximum du mot 'word'

  char max_index(char word[])
  {
    int index = 0;
    while(!is_end_caract(word[index]))
      index++;
    return index;
  }
  

  // Fonction qui scanne les mots du fichier à vérifier et les analyse
  void scan_word(Node Tree, char word[], int* error, FILE* fp_txt, int* correct)

  {

    bool endWord = false; // true : le caractère est un caractère de fin, false : le caractère n'est pas un caractère de fin
    bool stop = false; // permet de ne pas compte 2 fois certaines erreurs
    int ind = 0; // indice dans le mot 'word'
    int indice; // indice de rangement de letter dans le tableau 'next'

    char letter;
    Node Tree2 = Tree;

    while(!is_end_caract(word[ind])) // si 'word[ind]' n'est pas un caractère de fin

    {

      stop = false;

      letter = word[ind];

      indice = find_caract_indice(letter); // récupération de l'indice de rangement

      if(Tree2 != NULL && Tree2->next[indice]!=NULL) // si l'arbre n'est pas vide et que la case correspondant à la lettre dans l'arbre n'est pas vide

      {

        ind++; // on passe à la lettre suivante
        Tree2 = Tree2->next[indice]; // on se met dans la case de la lettre qui vient d'être vérifiée

        endWord = Tree2->endWord;

      }
      else
      {

        add_error(error, word, ind, Tree2, fp_txt, correct); // si l'abre est vide ou que la case de l'arbre correspondant à la lettre est vide, on ajoute une erreur
        ind = max_index(word); // on se place à la fin du mot pour ne pas continuer de vérifier ses lettres

        stop = true;

        endWord = false;

      }

    }

    if(!endWord && !stop) // si un mot manque d'au moins une lettre (endWord == false alors qu'on a atteint la fin du mot à scanner)

      {

        add_error(error, word, ind, Tree2, fp_txt, correct); // on ajoute une erreur

      }

  }
  

  // Ajoute une erreur, donne le type d'erreur et lance le processus de correction

  void add_error(int* error, char word[], int index, Node Tree, FILE* fp_txt, int* correct)

  {
    (*error)++;

    if(index==0) // si la première lettre n'est pas reconnu, on ne propose pas de correction

      {

        printf("Le mot '%s' ne correspond à aucun mot du dictionnaire.\n\n", word);

        return;
      }

    else if(index<(int)strlen(word)) // si l'index d'erreur n'est pas le dernier indice du mot, on a une faute dans le mot

        printf("Il y a une erreur dans le mot '%s', au caractère %c d'incide %d.\n", word, word[index], index);

    else // sinon l'erreur a lieu à la fin du mot

        printf("Il manque au moins une lettre au mot '%s'.\n", word);

    make_correction(word, index, Tree, fp_txt, correct); // processus de correction

  }
  

  // Lance le processus de correction, avec les différentes initialisations
  void make_correction(char word[], int index, Node Tree, FILE* fp_txt, int* correct)

  {

    correction liste = NULL; // crée une liste contigüe qui contiendra les propositions de correction
    init_correction(&liste); // initalise cette liste
    char end; // permet de stocker un éventuel caractère de fin (',', ';', '?', etc..)
    bool testEnd; // true si le mot possede un caractère de fin, false sinon
    testEnd = detect_end_caract(&end, word);
    int longueur = strlen(word);
    Node Tree2 = Tree;
    word[index-1]='\0'; // on coupe le mot avant l'erreur
    printf("\n");
    char words[MAX] = ""; // chaine de caractères permettant le stockage des différentes lettres pouvant composer les mots de correction
    make_tree_correct(Tree2, 0, words, word, liste); // rempli la liste chainée avec les propositions de correction
    choice_word(liste, fp_txt, end, longueur, correct, testEnd); // permet le choix du mot de correction et lance le processus de remplacement
    free(liste);

  }
  

  // Détermine si le mot word possède un caractère de fin et le renvoie si c'est le cas

  bool detect_end_caract(char* end, char word[])
  {

    if(is_end_caract(word[strlen(word)-1]))
      {
        *end = word[strlen(word)-1];
        return true;
      }
    return false;

  }
  

  // Permet le choix du mot de correction et lance le processus de remplacement

  void choice_word(correction liste, FILE* fp_txt, char end, int longueur, int* correct, bool testEnd)
  {

    int choix;
    printf("Voici les mots possibles pour corriger ce mot :\n");
    for(int i=0; i<liste->dernier+1; i++) // on propose tous les mots de la liste contigüe
      printf("%d. %s\n", i+1, liste->mots[i]);
    printf("\n");
    choix = -1;
    printf("Quel mot voulez-vous sélectionner ? (Entrez %d pour ne pas corriger le mot)\n", (liste->dernier)+2); // exemple : 3 mots possibles. Si on entre 4, alors on ne veut pas corriger
    while(choix<1 || choix>liste->dernier+2) // vérifie que la valeur entrée est correcte
      {
        scanf("%d", &choix);
      }
    if(choix==(liste->dernier)+2) // si on ne corrige pas
      {
        printf("\n");
        return;
      }
    (*correct)++; // on incrémente un compteur de corrections
    char word[MAX]; // contiendra le mot choisi
    strcpy(word, liste->mots[choix-1]);
    printf("Le mot %s a été sélectionné.\n\n", word);
    if(testEnd) add_caract(word, end); // s'il y a un caractère de fin, on l'ajoute
    correct_word(word, fp_txt, longueur); // processus de remplacement

  }
  

  // Remplace le mot comportant une erreur par le mot choisi dans choice_word

  void correct_word(char word[], FILE* fp_txt, int longueur)
  {

    FILE* fp_tamp; // création d'un fichier tampon
    fp_tamp = fopen("tampon.txt", "w+"); // ouverture en mode lecture/écriture avec suppression du contenu au préalable
    if(fp_tamp==NULL)

      {

        printf("Erreur lors de l'ouverture du fichier tampon.\n");
        return;
      }
    int position = ftell(fp_txt)-longueur; // on récupère la position dans le fichier à analyser du début du mot avec erreur
    rewind(fp_txt); // on se place au début du fichier à scanner
    char tempo;
    while(ftell(fp_tamp)<position) // tant qu'on est pas arrivé au mot avec erreur

      {

        tempo = fgetc(fp_txt); // copie d'un caractère à la fois
        if(tempo==EOF) break; // jusque la fin du fichier
        fputc(tempo, fp_tamp); // on ajoute le caractère dans le fichier tampon
      }
    fprintf(fp_tamp, "%s", word); // on ajout le mot corrigé dans le fichier tampon
    long newPosition = ftell(fp_tamp); // on récupère la position de la fin du mot corrigé
    fseek(fp_txt, ftell(fp_txt)+longueur, SEEK_SET); // on se place après le mot avec erreur dans le fichier à analyser
    while(1) // on copie la fin du fichier à analyser dans le fichier tampon
      {
        tempo = fgetc(fp_txt);
        if(tempo==EOF) break;
        fputc(tempo, fp_tamp);
      }
    rewind(fp_txt); // on se remet au debut des 2 fichiers pour renvoyer le contenu du fichier tampon dans le fichier à analyser
    rewind(fp_tamp);
    char temp[MAX_READ];
    while(1) // on procède ligne par ligne car aucune modification sur un mot ne sera effectuée
      {
        if(fgets(temp, MAX_READ, fp_tamp)==NULL)
  	break;
        fputs(temp, fp_txt);
      }
    fseek(fp_txt, newPosition, SEEK_SET); // on avait récupérer la position après le mot corrigé, on s'y place pour continuer l'analyse du fichier
    fclose(fp_tamp); // fermeture du fichier tampon et suppression
    remove("tampon.txt");

  }
  

  // Initialise la liste contigüe contenant les mots de correction

  void init_correction(correction* liste)
  {

    if((*liste)!=NULL)
      {
        printf("Déjà initialisé.\n");
        return;
      }
    *liste = malloc(sizeof(struct liste));
    (*liste)->dernier = -1;
    for(int i=0; i<NB_MOT_CORRECTION; i++)
      {
        strcpy((*liste)->mots[i], "");
      }

  }
  

  // Affichage

  void init_pgrm(void)
  {
    printf("\n------------------------------------------\n");
    printf("Correcteur ortographique.\n");
    printf("Normand Quentin & Rouillé Guillaume.\n");
    printf("------------------------------------------\n\n");
  }
  

  // Renvoie true si 'word' ne comprend pas d'accent, false sinon

  bool no_accent(char word[])
  {
    int index_max = max_index(word);
    for(int i=0; i<index_max; i++)
      if(word[i]<0) return false;
    return true;
  }
  

  // Lecture du fichier à analyser

  void read_txt(FILE* fp, Node* Tree, int* error, int* correct)

  {
    char word[MAX];
    while(1)
    {

      if(fscanf(fp, "%s", word)!=1) // tant qu'on a pas fini la lecture du fichier

        break;

      if(no_accent(word)) // on ne prend pas en compte les mots accentués (voir compte-rendu pour explications)
        scan_word(*Tree, word, error, fp, correct); // on scanne le mot

    }

    if(feof(fp)) printf("Fin de la lecture du fichier à scanner.\n\n");
    if(ferror(fp)) printf("Erreur lors de la lecture du fichier à scanner.\n\n");

  }
  

  // Lecture du dictionnaire

  void read_lib(FILE* fp, Node* Tree)
  {
    char word[MAX];
    while(1)
      {

        if(fscanf(fp, "%s", word)!=1) // tant qu'on a pas fini la lecture du fichier

  	break;

        if(no_accent(word)) // on ne prend pas en compte les mots accentués (voir compte-rendu pour explications)
  	add_in_tree(*Tree, word); // on ajoute le mot dans l'arbre indexé

      } 

      if(feof(fp)) printf("Fin de la lecture de la bibliothèque.\n\n");
      if(ferror(fp)) printf("Erreur lors de la lecture de la  bibliothèque.\n\n");

  }
  

  // Affichage de l'arbre indexé (inutile pour le code, fonction d'aide)

  void print_tree(Node Tree, int index, char word[])
  {

    if(is_empty_tree(Tree)) // si l'arbre est vide, rien a imprimer
      return;
    add_caract(word, Tree->letter); // sinon, on stocke le caractère dans une chaine
    if(is_leaf(Tree)) // si on atteint une feuille, on imprime et on supprime le dernier caractère car il n'est plus utile
      {
        printf("%s\n", word);
        supp_caract(word);
        return;
      }
    if(Tree->endWord) // si on est à la fin d'un mot, on l'imprime mais on enlève pas de lettre car il peut y avoir des mots plus grands de même racine
      printf("%s\n", word);
    while(index < NB_CARAC) // on parcourt tout le tableau de pointeur de chaque cellule
      {
        if(!is_empty_tree(Tree->next[index])) // si la case du tableau n'est pas vide

  	{

  	  print_tree(Tree->next[index], 0, word); // on relance la fonction en partant de la case

  	}

        index++;
      }
    supp_caract(word); // on supprime le dernier caractère stocké car il n'est plus utile
    return;

  }

  // Comme son nom l'indique, cette fonction sélectionne les mots possibles pour la correction du mot 'word' et les ajoute dans la liste contigüe
  void make_tree_correct(Node Tree, int index, char word[], char start[], correction liste) // même principe que la fonction d'affichage de l'arbre indexé

  {

    if(is_empty_tree(Tree)) // si l'arbre est vide, il n'y a pas de correction possible
      return;
    add_caract(word, Tree->letter); // on ajoute le caractère à la chaine de stockage
    if(is_leaf(Tree)) // si on arrive au bout d'une branche, on ajoute le mot dans la liste et on supprime le dernier caractère stocké
      {
        add_in_liste(liste, start, word);
        supp_caract(word);
        return;
      }
    if(Tree->endWord) // si on arrive à la fin d'un mot, on l'ajout dans la liste
      {
        add_in_liste(liste, start, word);
      }
    while(index < NB_CARAC) // on parcourt le tableau de chaque cellule
      {
        if(!is_empty_tree(Tree->next[index])) // si la case n'est pas vide

  	{

  	  make_tree_correct(Tree->next[index], 0, word, start, liste); // on relance la fonction à partir de cette case

  	}

        index++;
      }
    supp_caract(word); // on supprime le dernier caractère stocké, inutile maintenant
    return;

  }
  

  // Ajoute les mots de correction dans la liste contigüe

  void add_in_liste(correction liste, char start[], char word[])

  {

    char temp[MAX];
    strcpy(temp, start); // on concatène le debut du mot (avant l'erreur) avec la suite envoyée dans 'word'
    strcat(temp, word);
    if(liste->dernier<NB_MOT_CORRECTION-1) // pour ne pas dépasser le nombre de mots proposés
      {
        (liste->dernier)++;
        strcpy(liste->mots[liste->dernier], temp);
      }

  }
  

  // Ajoute un caractère à une chaine de caractères

  void add_caract(char word[], char caract)

  {

  	char str[2];
  	str[0] = caract;
  	str[1] = '\0';
  	strcat(word, str);
  }
  

  // Supprime un caractère d'une chaine de caractères

  void supp_caract(char word[])
  {
  	word[strlen(word)-1]='\0';

  }
  

  // Désalloue la mémoire utilisée par l'arbre indexé

  void free_tree(Node* Tree)

  {

    if(*Tree!=NULL)

      {

        for(int i=0; i<NB_CARAC; i++)
  	{
  	  free_tree(&(*Tree)->next[i]);
  	}
        free(*Tree);

      }

  }