#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);
void afficherTousLesMots(TableHash *tableHash) ;

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

void spam(struct Mail* liste,TableHash *tableHash);


// 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;
    for (int i = 0; chaine[i] != '\0'; i++) {
        valeurHash = (valeurHash * BASE + chaine[i]) % TAILLE_HASH;
    }
    return valeurHash;
}



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(" %s \n ", 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 index = obtenirValeurHash(mot);
    Element *element = tableHash->elements[index];
    while (element != NULL) {
        if (strcmp(mot, element->mot) == 0) {
       
        printf("Le mot '%s' a été trouvé dans la table de hachage.\n", mot);
            return true;
        }
        element = element->suivant;
    }
    printf("Le mot '%s' n'a pas été trouvé dans la table de hachage.\n", mot);
    return false;
}



// Fonction pour afficher tous les mots dans la table de hachage

void afficherTousLesMots(TableHash *tableHash)

{
    printf("Affichage de tous les mots dans la table de hachage :\n");
    for (unsigned int i = 0; i < tableHash->taille; i++) { // Parcourt chaque entrée de la table de hachage
        Element *element = tableHash->elements[i];
        while (element != NULL) { // Parcourt chaque élément de la liste chaînée pour cette entrée
            printf("%s\n", element->mot); // Affiche le mot stocké dans l'élément
            element = element->suivant; // Passe à l'élément suivant dans la liste
        }
    }
}

// Fonction qui verifie si le mail ets un spam


void spam(struct Mail* liste,TableHash *tableHash)

{
    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
   int compteur = 0;
   
    while (courant != NULL) // tant que le pointeur courant n'est pas NULL
   
     {
     
     if (verifierExistenceMotSpam(tableHash,courant->mot)== true)
        compteur+=1;
         
        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
                                   
                                                                     
    }
   
     if (compteur<3)
     {  printf("Pas Spam");
     }
     else{
     printf("Spam");
     
     }

}


int main()
{

struct Mail* listeEleves = lireDonneesDuFichier("mail.txt");
//afficherListe(listeEleves );
const char *nomFichierDictionnaire = "mot.txt";
char lot[50]="loterie";
char lot1[50]="caca";
    TableHash tableHash;
    initialiserTableHash(&tableHash);
    chargerDictionnaireDepuisFichier(&tableHash, nomFichierDictionnaire);
    verifierExistenceMotSpam(&tableHash,lot);
     verifierExistenceMotSpam(&tableHash,lot1);
     afficherTousLesMots(&tableHash) ;
     
     spam(listeEleves ,&tableHash);
 

    return 0;
   
}