#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <signal.h>
#include <ctype.h>

#define MAX_WORDS 14
#define MAX_TRIES 6

const char *words[MAX_WORDS] = {
    "programmation", "ordinateur", "langage", "jeu", 
    "algorithmique", "fontainebleau", "koala", 
    "anticonstitutionnellement", "code", "canard", 
    "gyroscope", "periclitation", "susurrer", 
    "eclesiastique"
};

// Fonction pour afficher le pendu
void display_hangman(int tries) {
    switch (tries) {
        case 0: printf("  ----\n  |  |\n  |\n  |\n  |\n  |\n--------\n"); break;
        case 1: printf("  ----\n  |  |\n  |  O\n  |\n  |\n  |\n--------\n"); break;
        case 2: printf("  ----\n  |  |\n  |  O\n  |  |\n  |\n  |\n--------\n"); break;
        case 3: printf("  ----\n  |  |\n  |  O\n  | /|\n  |\n  |\n--------\n"); break;
        case 4: printf("  ----\n  |  |\n  |  O\n  | /|\\\n  |\n  |\n--------\n"); break;
        case 5: printf("  ----\n  |  |\n  |  O\n  | /|\\\n  | /\n  |\n--------\n"); break;
        case 6: printf("  ----\n  |  |\n  |  O\n  | /|\\\n  | / \\\n  |\n--------\n"); break;
    }
}

// Fonction pour gérer le signal d'alarme
void alarm_handler(int sig) {
    printf("\nTrop tard ! Vous avez dépassé les 30 secondes.\n");
    exit(1);  
}

// Fonction pour filtrer les mots selon la taille maximale
int filter_words(const char *filtered_words[], int max_word_length) {
    int count = 0;
    for (int i = 0; i < MAX_WORDS; i++) {
        if (strlen(words[i]) <= max_word_length) {
            filtered_words[count++] = words[i];
        }
    }
    return count;
}

// Fonction pour choisir plusieurs mots uniques aléatoirement
void choose_random_words(const char *filtered_words[], int num_filtered_words, char *result, int max_length) {
    int total_length = 0;
    while (total_length < max_length) {
        int index = rand() % num_filtered_words;
        const char *chosen_word = filtered_words[index];
        
        if (total_length + strlen(chosen_word) + 1 > max_length) {
            break;
        }

        strcat(result, chosen_word);
        total_length += strlen(chosen_word);

        if (total_length < max_length) {
            strcat(result, " ");
            total_length++;
        }
    }
}

// Fonction pour initialiser le mot deviné avec des underscores
void initialize_guessed_word(char guessed[], const char *word, int word_length) {
    for (int i = 0; i < word_length; i++) {
        guessed[i] = (word[i] == ' ') ? ' ' : '_';  // Gérer les espaces
    }
    guessed[word_length] = '\0';
}

// Fonction pour traiter chaque saisie de l'utilisateur
int handle_guess(char guess, const char *word, char guessed[], int word_length, int *score) {
    int found = 0;
    clock_t start_time = clock();

    for (int i = 0; i < word_length; i++) {
        if (word[i] == guess) {
            if (guessed[i] == '_') {
                guessed[i] = guess;
                found = 1;
                *score += 1000 - (clock() - start_time) * 1000 / CLOCKS_PER_SEC;
            }
        }
    }

    return found;
}

// Fonction principale pour jouer une partie
int play_game(const char *word, int word_length) {
    char guessed[word_length + 1];
    int tries = 0;
    int guessed_correctly = 0;
    int score = 0;

    initialize_guessed_word(guessed, word, word_length);

    while (tries < MAX_TRIES && guessed_correctly < word_length) {
        printf("\nMot à deviner : %s\n", guessed);
        display_hangman(tries);
        char guess;

        alarm(30);
        printf("Entrez une lettre (ou '1' pour quitter) : ");
        scanf(" %c", &guess);
        alarm(0);

        if (guess == '1') {
            printf("Vous avez quitté le jeu. À bientôt !\n");
            return 0;
        }

        if (!isalpha(guess)) {
            printf("Veuillez entrer une lettre valide.\n");
            continue;
        }

        guess = tolower(guess);
        int found = handle_guess(guess, word, guessed, word_length, &score);

        if (!found) {
            tries++;
            score -= 200;  // Malus pour une mauvaise réponse
        } else {
            guessed_correctly += found;
        }
    }

    if (guessed_correctly == word_length) {
        printf("Félicitations ! Vous avez deviné le mot : %s\n", word);
        if (tries < 3) {
            score += 500;
        }
    } else {
        printf("Désolé, vous avez perdu. Le mot était : %s\n", word);
        display_hangman(MAX_TRIES);
    }

    printf("Votre score est : %d\n", score);
    return score;
}

int main() {
    srand(time(NULL));

    while (1) {
        int max_word_length;
        printf("Entrez la taille maximale des mots à deviner : ");
        scanf("%d", &max_word_length);

        const char *filtered_words[MAX_WORDS];
        int num_filtered_words = filter_words(filtered_words, max_word_length);

        if (num_filtered_words == 0) {
            printf("Aucun mot ne correspond à cette taille maximale.\n");
            continue;
        }

        char word[256] = "";
        choose_random_words(filtered_words, num_filtered_words, word, max_word_length);
        int word_length = strlen(word);
        printf("%s",word);
        int score = play_game(word, word_length);

        char play_again;
        printf("Voulez-vous jouer à nouveau ? (o/n) : ");
        scanf(" %c", &play_again);
        if (tolower(play_again) != 'o') {
            break;
        }
    }

    return 0;
}