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

#define LONGUEUR_MAX_MOT 30    // Longueur maximale d'un mot
#define TAILLE_HASH      37987 // Un nombre premier pour la taille de la table
#define BASE             128   // La base pour le calcul de hachage

typedef struct _element {
    char mot[LONGUEUR_MAX_MOT]; // Le mot stocké dans l'élément
    struct _element *suivant;   // Pointeur vers l'élément suivant
} Element;

typedef struct _tableHash {
    unsigned int taille;              // Taille de la table de hachage
    unsigned int nbEntreesOccupees;   // Nombre d'entrées occupées dans la table
    unsigned int nbElements;          // Nombre total d'éléments stockés
    Element **elements;               // Tableau de pointeurs vers les éléments
} TableHash;


struct Mail
{

char mot[50];
struct Mail* suivant;

};


// Prototypes des fonctions


void initialiserTableHash(TableHash *tableHash);
void insererElementDansTableHash(TableHash *tableHash, char *mot);
void chargerDictionnaireDepuisFichier(TableHash *tableHash, const char *nomFichierDictionnaire);
unsigned long obtenirValeurHash(char *chaine);
bool verifierExistenceMotSpam(TableHash *tableHash, char *mot);

struct Mail* ajoutermot( struct Mail* liste,  char mot[50]) ;
struct Mail* lireDonneesDuFichier(char* nomFichier);
void afficherListe(struct Mail* liste);



// Fonctions

// Fonction qui initialise la table de hashage 

void initialiserTableHash(TableHash *tableHash) 

{
    tableHash->taille = TAILLE_HASH; // Définit la taille de la table de hachage avec une valeur prédéfinie.
    
    tableHash->nbEntreesOccupees = 0; // Initialise le nombre d'entrées occupées dans la table à 0.
    
    tableHash->nbElements = 0; // Initialise le compteur total d'éléments stockés dans la table à 0.
    
    tableHash->elements = (Element **) malloc(tableHash->taille * sizeof(Element*)); // Alloue dynamiquement la mémoire pour le tableau d'éléments basé sur la taille de la table.

    for (unsigned int i = 0; i < tableHash->taille; i++) // Boucle sur chaque entrée du tableau d'éléments.
        tableHash->elements[i] = NULL; // Initialise chaque entrée du tableau à NULL, indiquant qu'aucun élément n'est encore stocké à cet index.
}



// Fonction qui insere un element dans la table de hachage 


void insererElementDansTableHash(TableHash *tableHash, char *mot)

{
    
    tableHash->nbElements++; // Incrémente le nombre total d'éléments dans la table de hachage.
    
    unsigned long index = obtenirValeurHash(mot); // Calcule l'index de la table où le mot sera inséré, basé sur sa valeur de hachage.
    Element *nouvelElement = (Element *) malloc(sizeof(Element)); // Alloue de la mémoire pour un nouvel élément.

    strcpy(nouvelElement->mot, mot); // Copie le mot dans le nouvel élément.

    if (tableHash->elements[index] == NULL) // Vérifie si l'emplacement à l'index calculé est vide (aucun élément inséré précédemment).
        
        tableHash->nbEntreesOccupees++; // Si c'est le cas, incrémente le nombre d'entrées occupées dans la table de hachage.

    nouvelElement->suivant = tableHash->elements[index]; // Fait pointer le nouvel élément vers le premier élément actuel de la liste à cet index.
    tableHash->elements[index] = nouvelElement; // Fait devenir le nouvel élément le premier élément de la liste à cet index.
}


// Fonction qui charge le dictionnaire depuis un fichier dans une table de hachage 

void chargerDictionnaireDepuisFichier(TableHash *tableHash, const char *nomFichierDictionnaire) 

{
    FILE *fichier = fopen(nomFichierDictionnaire, "r"); // Tente d'ouvrir le fichier du dictionnaire en mode lecture.

    if (fichier != NULL) // Vérifie si le fichier a été ouvert avec succès.
    { 
        char mot[LONGUEUR_MAX_MOT]; // Crée un tableau pour stocker temporairement chaque mot lu.

        while (fscanf(fichier, "%s", mot) == 1) // Lit les mots du fichier un par un.

            
            insererElementDansTableHash(tableHash, mot); // Insère chaque mot lu dans la table de hachage.
        
    } 
    
    else printf("Fichier non trouvé."); // Affiche un message d'erreur si le fichier n'a pas pu être ouvert.
    
    fclose(fichier); // Ferme le fichier après avoir fini de lire ou en cas d'erreur.
}


// Fonction qui verifie si mot dans dictionnaire 




bool verifierExistenceMotDansDictionnaire(TableHash *tableHash, char *mot)
{
    unsigned long valeurHash = obtenirValeurHash(mot); // Calcule la valeur de hachage du mot pour trouver son emplacement potentiel dans la table.

    Element *element = tableHash->elements[valeurHash]; // Récupère la liste d'éléments à cet emplacement de hachage.
    bool trouve = false; // Initialise le flag de recherche à faux.

    while (!trouve && element != NULL)// Parcourt la liste tant que le mot n'est pas trouvé et que la liste n'est pas terminée.
        
    { 
        trouve = (strcmp(mot, element->mot) == 0); // Compare le mot recherché avec le mot de l'élément courant.
        element = element->suivant; // Passe à l'élément suivant dans la liste.
    }

    return trouve; // Retourne vrai si le mot a été trouvé, faux sinon.
}



unsigned long obtenirValeurHash(char *chaine)
{
    unsigned long valeurHash = 0; // Démarre avec une valeur de hachage initiale de 0 pour accumuler le résultat.
    
    int i = 0; // Utilise i pour suivre la position du caractère dans la chaîne, influençant son poids dans le calcul de hachage.
    
    while ((*chaine) != '\0')// Continue de traiter chaque caractère jusqu'à atteindre la fin de la chaîne ('\0').
        
    { 
        // Pour chaque caractère, ajoute à la valeur de hachage actuelle, pondérée par sa position (i) et la valeur ASCII du caractère.
        valeurHash = (valeurHash + (*chaine) * (unsigned long) pow(BASE, i)) % TAILLE_HASH; 
        
        i++; // Passe à la position suivante pour le prochain caractère.
        
        chaine++; // Avance dans la chaîne pour traiter le prochain caractère.
    }
    return valeurHash % TAILLE_HASH; // Assure que la valeur de hachage retournée est dans les limites valides de la table de hachage.
}



struct Mail * ajoutermot( struct Mail*liste,  char mot[50])

{
    struct Mail* nouveaumot = (struct Mail*)malloc(sizeof( struct Mail));
   
    if (nouveaumot != NULL)
     {
        strcpy(nouveaumot->mot, mot);
       
      
       
        nouveaumot->suivant = liste;
         
        return nouveaumot;
    }
   
    return NULL;
}




struct Mail* lireDonneesDuFichier(char* nomFichier)

 {
    struct Mail* listemot = NULL; // permet de stocker le début de la liste chaîne élève . L'initialisation NULL indique que la liste est vide au départ.
   
    FILE* fichier = fopen(nomFichier, "r"); //résulat stocké avec un pointeur de type FILE* nomé fichier et ouvre le fichier.

    if (fichier == NULL) // Si fichier == NULL, l'ouverture a échoué
   
    {
        printf("Le fichier %s n'a pas été trouvé.\n", nomFichier);
       
        return NULL;
    }

    char mot[50]; // déclare 2 variables locales
   
    
    while (fscanf(fichier, "%s", mot) == 1) // ATTENTION QUAND ON A UN STRING , ON MET PAS L'"&" ALORS QUE QUAND ON A UN FLOAT OU UN INT OU LE RESTE, ON MET L'&.
        // Lit les valeurs à chaque itération. La boucle continue tant que fscan renvoie 2 ce qui signifie que els 2 valeurs ont été lues avec succès
   
    {
        listemot = ajoutermot(listemot, mot); // La liste chainée nommée liste elvèves ets implémntée avec la note et le nom  qui viennent d'être lues sur le fichier
    }

    fclose(fichier);
   
    return listemot; // Renvoie le pointeur vers le début de la liste chaînée remplie avec les données lues du fichier texte et de les stocker dans une structure de données.
}



void afficherListe(struct Mail* liste)

{
    struct Mail* courant = liste; // Initialise le pointeur courant avec la valeur de liste. Au début courant pointe vers le premier élément de la liste
   
    while (courant != NULL) // tant que le pointeur courant n'est pas NULL
   
     {
        printf("Mot: %s ", courant->mot); 
         
        courant = courant->suivant; //On met à jour le pointeur courant pour qu'il pointe vers le prochain élève de la liste chaînée. Cela se fait en assignant à 'courant' la valeur du pointeur suivant de
                                   // l'élément courant
                                   
                                                                     
    }

}

    // Fonction qui verifie si mot dans dictionnaire 




bool verifierExistenceMotSpam(TableHash *tableHash, char *mot)
    
{
    unsigned long valeurHash = obtenirValeurHash(mot); // Calcule la valeur de hachage du mot pour trouver son emplacement potentiel dans la table.

    Element *element = tableHash->elements[valeurHash]; // Récupère la liste d'éléments à cet emplacement de hachage.
    bool trouve = false; // Initialise le flag de recherche à faux.

    while (!trouve && element != NULL)// Parcourt la liste tant que le mot n'est pas trouvé et que la liste n'est pas terminée.
        
    { 
        trouve = (strcmp(mot, element->mot) == 0); // Compare le mot recherché avec le mot de l'élément courant.
        element = element->suivant; // Passe à l'élément suivant dans la liste.
    }

    return trouve; // Retourne vrai si le mot a été trouvé, faux sinon.
}

int main()
{



    return 0;
    
}