#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;



// Prototypes des fonctions



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




// 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 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 obtient la valeur de la table de hachage 

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.
}



// 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 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.
}

void afficherCaracteristiquesTableHash(TableHash *tableHash) 
{
    float facteurDeCharge = (float) tableHash->nbEntreesOccupees / tableHash->taille; // Calcule le facteur de charge de la table.
    printf("************** Caractéristiques de la Table de Hachage **********************\n");
    printf("Nombre de seaux : %u \n", tableHash->taille); // Affiche le nombre total de seaux dans la table.
    printf("Facteur de charge : %.2f \n", facteurDeCharge); // Affiche le facteur de charge calculé.
    printf("Nombre total d'éléments : %u \n", tableHash->nbElements); // Affiche le nombre total d'éléments stockés dans la table.
    printf("***************************************************************************\n");
}

void menu(TableHash *tableHash) {
    bool quitter = false;
    int choix;

    while (!quitter) {
        printf("\n");
        printf("1  Vérifier l'existence d'un mot dans le dictionnaire\n");
        printf("2  Afficher les caractéristiques de la table de hachage\n");
        printf("3  Quitter\n");
        printf("Choix : ");
        scanf("%d", &choix);

        switch (choix) {
            case 1: {
                char mot[LONGUEUR_MAX_MOT];
                printf("\nEntrez le mot : ");
                scanf("%s", mot);
                if (verifierExistenceMotDansDictionnaire(tableHash, mot))
                    printf("\nLe mot \"%s\" existe dans le dictionnaire EN.", mot);
                else 
                    printf("\nLe mot \"%s\" n'existe pas dans le dictionnaire EN.", mot);
                break;
            }
            case 2:
                afficherCaracteristiquesTableHash(tableHash);
                break;
            case 3:
                quitter = true;
                break;
        }
    }
}


}
int main() {
    const char *nomFichierDictionnaire = "en_US_wordlist.txt";

    TableHash tableHash;
    initialiserTableHash(&tableHash);
    chargerDictionnaireDepuisFichier(&tableHash, nomFichierDictionnaire);
    menu(&tableHash);

    return 0;
}