/**
 * dictionnaire.c
 *
 * Implémente l'importation et la libération d'un dictionnaire en mémoire
 * depuis un fichier texte.
 */

#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
/* ctype.h pour les fonctions isalpha, tolower, isdigit et isspace */
#include <ctype.h>
#include <string.h>

#include "dictionnaire.h"



/* Variables globales */

// Declaration du Noeud racine
Noeud *racine;

// Déclaration de reserve_noeud : permet d'allouer la taile du dictionnaire en une fois, simplifie la gestion
// mémoire.
Noeud *reserve_noeuds;

// Déclaration du compteur de nombre de mots dans le dictionnaire.
// Est utilise par la fonction taille_dic().
unsigned int nbr_mots;

// Variable global permettant de construire une  reserve de noeuds.
// Type "long" pour ne pas être limité.
long taille_fic;

/**
 * Teste si un mot appartient au dictionnaire.
 * Retourne True si le mot est dans le dictionaire ou False sinon
 */
bool appartient(const char *mot) // Const pour que mot soit en lecture seule, il n'y a pas besoin de le modifier
{
    // Déclaration du pointeur parcourant le trie et initialisation a NULL
    Noeud *nd_parcours_tmp = NULL;

    // Fais pointer nd_parcours_tmp sur la racine
    // Pour chaque nouveau nd_parcours_tmp pointe sur la racine pour verifier le mot
    nd_parcours_tmp = racine;

    // Variable pour iterer char par char dans un mot
    int i = 0;

    // Vérifie que le le mot entré correspond à un parcours de l'arbre se terminant par mot_fini = True
    while (mot[i] != '\0') {
        // On convertit le mot en minuscule pour se préoccuper uniquement de l'orthographe
        char c;
        if (isalpha(mot[i])) {
            c = tolower(mot[i]);
        } else {
            c = mot[i];
        }

        // Gestion de l'apostrophe
        if (c == '\'') {
            // On regarde s'il existe un mot comprenant l'apostrophe, sinon le mot n'appartient pas au dico
            if (nd_parcours_tmp->enfants[NB_CARAC - 1] == NULL) {
                return false;
            }
            // Sinon on continue le parcours en allant au noeud suivant
            nd_parcours_tmp = nd_parcours_tmp->enfants[NB_CARAC - 1];
        }

        // Gestion des lettres
        else if (isalpha(c)) {
            // Verifie que le parcours correspondant au lettres du mot existe jusqu'ici.
            // Retourne False si ce n'est pas le cas.
            if (nd_parcours_tmp->enfants[c - 'a'] == NULL) {
                return false;
            }
            // Sinon on passe à la lettre suivante dans le dico
            nd_parcours_tmp = nd_parcours_tmp->enfants[c - 'a'];
        }
        // On avance dans le mot à vérifier
        i++;
    }

    // Retourne True si le mot existe dans le dictionnaire
    return nd_parcours_tmp->mot_fini;
}

/**
 * Importe le dictionnaire en mémoire.
 * Retourne True en cas de succes et False sinon.
 */
bool importer_dict(const char *nom_dic)
{
    // Ouvre le fichier du dictionnaire
    // 'b' permet d'avoir un stream de byte et non l'interpretation des caractères d'indentation en fonction du système.
    // Cela garantie que fseek determine correctement la taille du fichier.
    FILE *dict = fopen(nom_dic, "rb");

    // Erreur sur le fichier?
    if (dict == false) {
        printf("Impossible d'ouvrir le fichier (dictionnaire.c)");
        return false;
    }

    // Determination de la taille_dic du fichier (en bytes)
    fseek(dict, 0, SEEK_END);
    taille_fic = ftell(dict);

    // Remise du pointeur de fichier au debut
    fseek(dict, 0, SEEK_SET);

    // Initalise reserve_noeuds avec suffisament de mémoire pour différents dictionnaires
    reserve_noeuds = calloc(taille_fic, sizeof(Noeud));

    // Premier Noeud du dictionnaire
    Noeud *prochain_noeud_vide = reserve_noeuds;

    // On transfère le fichier depuis un stream dans un tableau
    char *buffer = malloc(taille_fic); // +1 pour le caractere de terminaison
    fread(buffer, 1, taille_fic, dict);

    // Marque la fin du fichier
    buffer[taille_fic] = '\0';

    // Initialisation du Noeud racine du trie
    racine = prochain_noeud_vide + 1;

    // Déclare et initialise le pointeur sur le Noeud courant
    Noeud *nd_courant = NULL;

    // Nouveau string permettant de charger les mots dans le trie
    char *mots_fichier = buffer;

    // Initialise le compteur pour la fonction taille()
    nbr_mots = 0;

    // On boucle tant que le caractere n'est pas  '\0' ou 'NULL'
    while (*mots_fichier) {
        // Départ du Noeud racine pour chaque mot
        nd_courant = racine;

        // Insère les mot dans l'espace mémoire pré-allouée.
        // Si le char est un saut de ligne le mot est terminé fin d'un mot
        for (; *mots_fichier != '\n' && *mots_fichier; mots_fichier++) {
            // Gestion des mots avec apostrophe
            if (*mots_fichier == '\'') {
                // Si le mot avec apostrophe n'existe pas, on l'ajoute
                if (nd_courant->enfants[NB_CARAC - 1] == NULL) {
                    nd_courant->enfants[NB_CARAC - 1] = prochain_noeud_vide++;
                }
                // Passage au noeud suivant
                nd_courant = nd_courant->enfants[NB_CARAC - 1];
            }

            // Gestion des lettres
            else {
                // Si le mot n'existe pas, on l'ajoute en prenant le prochain noeud dans la réserve
                if (nd_courant->enfants[*mots_fichier - 'a'] == NULL) {
                    nd_courant->enfants[*mots_fichier - 'a'] = prochain_noeud_vide++;
                }
                // Passage au noeud suivant
                nd_courant = nd_courant->enfants[*mots_fichier - 'a'];
            }
        }

        // On est arrivé sur '\n' donc le mot est fini
        nd_courant->mot_fini = true;
        // Un mot de plus dans le dico
        nbr_mots++;

        // On absorbe le saut de ligne
        if (*mots_fichier == '\n') {
            mots_fichier++;
        }
    }

    // Fermeture proprement du fichier et libération de la mémoire
    fclose(dict);
    free(buffer);

    // Chargement avec succès
    return true;
}

/**
 * Retourne le nombre de mot dans un dictionnaire (0 si non chargé)
 */
unsigned int taille_dic()
{
    // Déjà calculée lors l'importation du dictionnaire
    return nbr_mots;
}

/**
 * Libération du dictionnaire en mémoire.
 * Retourne true en cas de succès et false sinon.
 */
bool decharger()
{
    // Avantage de l'appel unique à calloc :
    // Un seul appel à free est nécéssaire !
    free(reserve_noeuds);
    // Libération mémoire avec succès
    return true;
}