main.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <time.h>
#include <unistd.h>
#include <dlfcn.h>
#include <sys/wait.h>
#include <math.h>
#include <errno.h>
#include <sys/stat.h>

#define MAX_LINE_LENGTH 1000
#define MAX_VARIABLES 100
#define MAX_VAR_NAME 50
#define MAX_STRING_VALUE 500

typedef struct {
    char name[MAX_VAR_NAME];
    char value[MAX_STRING_VALUE];
    int is_numeric;
} Variable;

Variable variables[MAX_VARIABLES];
int var_count = 0;

// Variables globales pour gérer les conditions
int last_condition_result = 0;
int in_alors_block = 0;
int in_autre_block = 0;
int skip_current_block = 0;

// Variable globale pour la couleur actuelle
char current_color[20] = "DEFAULT";

// Structures pour les modules et packages
#define MAX_FUNCTIONS 100
#define MAX_PACKAGES 20
#define MAX_MODULES 20

typedef struct {
    char name[MAX_VAR_NAME];
    char code[MAX_STRING_VALUE * 10];
    char filename[MAX_STRING_VALUE];
} MayaFunction;

typedef struct {
    char path[MAX_STRING_VALUE];
    char so_path[MAX_STRING_VALUE];
    void *handle;
    int loaded;
    char function_names[MAX_FUNCTIONS][MAX_VAR_NAME];
    void (*functions[MAX_FUNCTIONS])();
    int function_count;
} MayaPackage;

typedef struct {
    char path[MAX_STRING_VALUE];
    MayaFunction functions[MAX_FUNCTIONS];
    int function_count;
    int loaded;
} MayaModule;

MayaFunction maya_functions[MAX_FUNCTIONS];
int maya_function_count = 0;
MayaPackage maya_packages[MAX_PACKAGES];
int maya_package_count = 0;
MayaModule maya_modules[MAX_MODULES];
int maya_module_count = 0;

// Structures pour bases de données Maya
#define MAX_DATABASES 50
#define MAX_DB_RECORDS 1000

typedef struct {
    char id[9]; // 8 caractères + \0
    char data[MAX_STRING_VALUE * 5];
    int active;
} MayaDatabase;

MayaDatabase maya_databases[MAX_DATABASES];
int maya_db_count = 0;

// Déclarations des fonctions (prototypes)
void maya_error(const char *message, int line_number);
void trim(char *str);
char* get_variable_value(char *name);
void set_variable(char *name, char *value, int is_numeric);
int evaluate_expression_numeric(char *expr);
char* process_string_with_variables(char *input);
void handle_console(char *content);
void handle_math(char *line);
void handle_variable(char *line);
void handle_input(char *line);
void handle_delai(char *line);
void handle_draw(char *line);
void handle_jolie_txt(char *line);
void handle_color_console(char *line);
void handle_nombre_random(char *line);
void handle_random_txt(char *line);
int handle_condition(char *condition);
void interpret_line(char *line);
void execute_maya_file(const char *filename);
void apply_color(char *color);
void reset_color();
void draw_heart();
void draw_tree();
void draw_dog();
void draw_horse();
void draw_goat();
void draw_sheep();
void draw_bird();
void draw_fish();
void handle_quizz(char *line);
void handle_dice(char *line);
void handle_puissance4(char *line);
void handle_pendu(char *line);
void handle_worldgame(char *line);
void handle_rock_leaf(char *line);
void handle_devine_number(char *line);
void handle_snake(char *line);
void handle_tictac(char *line);
void handle_memory(char *line);
void handle_simulation_bac(char *line);
void handle_simulation_combat(char *line);
void handle_simulation_sciences(char *line);
void handle_simulation_clone(char *line);
void handle_simulation_tech(char *line);
void handle_simulation_ia(char *line);
void handle_simulation_conscient(char *line);
void handle_simulation_iawork(char *line);
void handle_fonction(char *line);
void handle_lire_module(char *line);
void handle_package_charge(char *line);
void execute_maya_function(char *function_name, char *args);
void load_maya_module(char *path);
void load_maya_package(char *path);
int find_maya_function(char *name);
int compile_c_package(char *source_path, char *output_path);
void call_package_function(char *function_name, char *args);
int find_package_function(char *name);
int detect_package_functions(char *source_path, char function_names[][MAX_VAR_NAME]);
void get_package_info(int func_index, int *package_index, int *local_index);

// Nouvelles fonctionnalités v5.0
void handle_math_median(char *line);
void handle_math_moyenne(char *line);
void handle_math_cube(char *line);
void handle_math_carre(char *line);
void handle_math_racine(char *line);
void handle_math_degres(char *line);
void handle_thales(char *line);
void handle_pytha(char *line);
void handle_rythme_convertir(char *line);
void handle_renvoie_gamme(char *line);
void handle_obtenir_gamme(char *line);
void handle_db(char *line);
void handle_send_db(char *line);
void handle_supp_db(char *line);
void handle_util_db(char *line);
void handle_execute_c(char *line);
void handle_simulation_monrobot(char *line);
void handle_simulation_quantique(char *line);
void handle_simulation_monunivers(char *line);
void handle_simulation_atomes(char *line);
void handle_simulation_timetravel(char *line);
void handle_simulation_fairy(char *line);
void handle_simulation_vampire(char *line);
void handle_simulation_sirene(char *line);
void handle_simulation_monster(char *line);
void handle_exercice_create(char *line);
void handle_exercice_gest_pgi(char *line);
void handle_exercice_gest_treso(char *line);
void handle_exercice_math(char *line);
void handle_exercice_histoire(char *line);
void handle_exercice_mana(char *line);
int validate_db_id(char *id);
int find_database(char *id);
char* extract_c_code(char *maya_line);

// Nouvelles fonctionnalités v6.0
void handle_create_robot(char *line);
void handle_for_loop(char *line);
void handle_while_loop(char *line);
void handle_loop(char *line);
void handle_palette(char *line);
void handle_owngame(char *line);
void handle_modifie_console(char *line);
void handle_interactive(char *line);
void handle_inventaire(char *line);
void handle_histoire_recit(char *line);
void handle_histoire_end(char *line);
void handle_own_pet(char *line);
void handle_own_titan(char *line);
void handle_nombre_pet(char *line);
void handle_nombre_titan(char *line);

// Fonction pour afficher les erreurs Maya
void maya_error(const char *message, int line_number) {
    if (line_number > 0) {
        printf("\033[31mERREUR MAYA [Ligne %d]: %s\033[0m\n", line_number, message);
    } else {
        printf("\033[31mERREUR MAYA: %s\033[0m\n", message);
    }
}

// Fonction pour nettoyer les espaces
void trim(char *str) {
    int start = 0, end = strlen(str) - 1;
    while (isspace(str[start])) start++;
    while (end >= start && isspace(str[end])) end--;
    str[end + 1] = '\0';
    if (start > 0) {
        memmove(str, str + start, strlen(str + start) + 1);
    }
}

// Fonction pour obtenir la valeur d'une variable
char* get_variable_value(char *name) {
    for (int i = 0; i < var_count; i++) {
        if (strcmp(variables[i].name, name) == 0) {
            return variables[i].value;
        }
    }
    maya_error("Variable non trouvée", 0);
    return NULL;
}

// Fonction pour définir une variable
void set_variable(char *name, char *value, int is_numeric) {
    for (int i = 0; i < var_count; i++) {
        if (strcmp(variables[i].name, name) == 0) {
            strcpy(variables[i].value, value);
            variables[i].is_numeric = is_numeric;
            return;
        }
    }
    // Nouvelle variable
    if (var_count < MAX_VARIABLES) {
        strcpy(variables[var_count].name, name);
        strcpy(variables[var_count].value, value);
        variables[var_count].is_numeric = is_numeric;
        var_count++;
    } else {
        maya_error("Trop de variables définies", 0);
    }
}

// Fonction pour évaluer une expression mathématique simple
int evaluate_expression_numeric(char *expr) {
    trim(expr);

    // Gestion des valeurs booléennes
    if (strcmp(expr, "true") == 0) return 1;
    if (strcmp(expr, "false") == 0) return 0;

    // Chercher l'opérateur
    char *op_pos = NULL;
    char operator = '\0';

    for (size_t i = 1; i < strlen(expr); i++) {
        if (expr[i] == '+' || expr[i] == '-' || expr[i] == '*' || expr[i] == '/') {
            op_pos = &expr[i];
            operator = expr[i];
            break;
        }
    }

    if (!op_pos) {
        // Pas d'opérateur, c'est soit un nombre soit une variable
        if (isdigit(expr[0]) || expr[0] == '-') {
            return atoi(expr);
        } else {
            char *var_value = get_variable_value(expr);
            if (var_value) {
                return atoi(var_value);
            }
            return 0;
        }
    }

    // Séparer les opérandes
    *op_pos = '\0';
    char *left = expr;
    char *right = op_pos + 1;

    trim(left);
    trim(right);

    int left_val, right_val;

    // Évaluer l'opérande gauche
    if (isdigit(left[0]) || left[0] == '-') {
        left_val = atoi(left);
    } else {
        char *var_value = get_variable_value(left);
        left_val = var_value ? atoi(var_value) : 0;
    }

    // Évaluer l'opérande droite
    if (isdigit(right[0]) || right[0] == '-') {
        right_val = atoi(right);
    } else {
        char *var_value = get_variable_value(right);
        right_val = var_value ? atoi(var_value) : 0;
    }

    // Effectuer l'opération
    switch (operator) {
        case '+': return left_val + right_val;
        case '-': return left_val - right_val;
        case '*': return left_val * right_val;
        case '/': 
            if (right_val == 0) {
                maya_error("Division par zéro interdite", 0);
                return 0;
            }
            return left_val / right_val;
        default: 
            maya_error("Opérateur non reconnu", 0);
            return 0;
    }
}

// Fonction pour traiter les chaînes avec variables et opérateur +
char* process_string_with_variables(char *input) {
    static char result[MAX_STRING_VALUE * 2];
    char temp[MAX_STRING_VALUE];
    strcpy(temp, input);
    result[0] = '\0';

    char *token = strtok(temp, "+");
    int first = 1;

    while (token != NULL) {
        trim(token);

        if (token[0] == '\'' && token[strlen(token)-1] == '\'') {
            // C'est une chaîne littérale
            token[strlen(token)-1] = '\0';
            token++;
            if (!first) strcat(result, " ");
            strcat(result, token);
        } else {
            // C'est une variable
            char *var_value = get_variable_value(token);
            if (var_value) {
                if (!first) strcat(result, " ");
                strcat(result, var_value);
            }
        }
        first = 0;
        token = strtok(NULL, "+");
    }

    return result;
}

// Fonction pour appliquer une couleur
void apply_color(char *color) {
    if (strcmp(color, "RED") == 0) printf("\033[31m");
    else if (strcmp(color, "GREEN") == 0) printf("\033[32m");
    else if (strcmp(color, "YELLOW") == 0) printf("\033[33m");
    else if (strcmp(color, "BLUE") == 0) printf("\033[34m");
    else if (strcmp(color, "MAGENTA") == 0) printf("\033[35m");
    else if (strcmp(color, "CYAN") == 0) printf("\033[36m");
    else if (strcmp(color, "WHITE") == 0) printf("\033[37m");
    else if (strcmp(color, "BLACK") == 0) printf("\033[30m");
    else if (strcmp(color, "PINK") == 0) printf("\033[95m");
    else if (strcmp(color, "ORANGE") == 0) printf("\033[93m");
    else if (strcmp(color, "PURPLE") == 0) printf("\033[94m");
    else if (strcmp(color, "BROWN") == 0) printf("\033[33m");
}

// Fonction pour réinitialiser la couleur
void reset_color() {
    printf("\033[0m");
}

// Fonction pour traiter my.console
void handle_console(char *content) {
    char *start = strchr(content, '(');
    char *end = strrchr(content, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.console - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    // Traitement avec variables et concaténation
    if (strchr(start, '+')) {
        char *processed = process_string_with_variables(start);
        apply_color(current_color);
        printf("%s\n", processed);
        reset_color();
    } else {
        // Traitement simple
        if (start[0] == '\'' && start[strlen(start)-1] == '\'') {
            start[strlen(start)-1] = '\0';
            start++;
            apply_color(current_color);
            printf("%s\n", start);
            reset_color();
        } else {
            // C'est une variable
            char *var_value = get_variable_value(start);
            if (var_value) {
                apply_color(current_color);
                printf("%s\n", var_value);
                reset_color();
            }
        }
    }
}

// Fonction pour traiter les opérations mathématiques
void handle_math(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour opération mathématique - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    int result = evaluate_expression_numeric(start);
    printf("Résultat: %d\n", result);
}

// Nouvelles fonctions mathématiques v5.0
void handle_math_median(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.math.median - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    printf("📊 CALCUL DE MÉDIANE MAYA 📊\n");

    // Parser les nombres séparés par des virgules
    double numbers[50];
    int count = 0;
    char *token = strtok(start, ",");
    
    while (token != NULL && count < 50) {
        trim(token);
        numbers[count] = evaluate_expression_numeric(token);
        count++;
        token = strtok(NULL, ",");
    }

    if (count == 0) {
        maya_error("Aucun nombre fourni pour le calcul de médiane", 0);
        return;
    }

    // Trier les nombres (bubble sort simple)
    for (int i = 0; i < count - 1; i++) {
        for (int j = 0; j < count - i - 1; j++) {
            if (numbers[j] > numbers[j + 1]) {
                double temp = numbers[j];
                numbers[j] = numbers[j + 1];
                numbers[j + 1] = temp;
            }
        }
    }

    double median;
    if (count % 2 == 0) {
        median = (numbers[count/2 - 1] + numbers[count/2]) / 2.0;
    } else {
        median = numbers[count/2];
    }

    printf("Nombres triés: ");
    for (int i = 0; i < count; i++) {
        printf("%.2f ", numbers[i]);
    }
    printf("\n");
    printf("Médiane calculée: %.2f\n", median);
}

void handle_math_moyenne(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.math.moyenne - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    printf("📊 CALCUL DE MOYENNE MAYA 📊\n");

    // Parser les nombres séparés par des virgules
    double sum = 0.0;
    int count = 0;
    char *token = strtok(start, ",");
    
    while (token != NULL) {
        trim(token);
        double value = evaluate_expression_numeric(token);
        sum += value;
        count++;
        token = strtok(NULL, ",");
    }

    if (count == 0) {
        maya_error("Aucun nombre fourni pour le calcul de moyenne", 0);
        return;
    }

    double moyenne = sum / count;

    printf("Nombres: %d valeurs\n", count);
    printf("Somme: %.2f\n", sum);
    printf("Moyenne calculée: %.2f / %d = %.2f\n", sum, count, moyenne);
}

void handle_math_cube(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.math.cube - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    int number = evaluate_expression_numeric(start);
    int result = number * number * number;

    printf("🔢 CALCUL AU CUBE MAYA 🔢\n");
    printf("%d³ = %d\n", number, result);
}

void handle_math_carre(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.math.carre - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    int number = evaluate_expression_numeric(start);
    int result = number * number;

    printf("🔢 CALCUL AU CARRÉ MAYA 🔢\n");
    printf("%d² = %d\n", number, result);
}

void handle_math_racine(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.math.racine - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    int number = evaluate_expression_numeric(start);

    if (number < 0) {
        maya_error("Impossible de calculer la racine d'un nombre négatif", 0);
        return;
    }

    double result = sqrt((double)number);

    printf("🔢 CALCUL DE RACINE MAYA 🔢\n");
    printf("√%d ≈ %.2f\n", number, result);
}

void handle_math_degres(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.math.degres - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    int rayon = evaluate_expression_numeric(start);
    double circonference = 2 * 3.14159 * rayon;

    printf("🔄 CALCUL DE DEGRÉS MAYA 🔄\n");
    printf("Cercle de rayon %d:\n", rayon);
    printf("Circonférence: %.2f\n", circonference);
    printf("360° = %.2f unités\n", circonference);
}

void handle_thales(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.thales - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    printf("📐 THÉORÈME DE THALÈS MAYA 📐\n");

    // Parser les arguments: a, b, c
    char *comma1 = strchr(start, ',');
    if (!comma1) {
        maya_error("my.thales nécessite trois arguments: a, b, c", 0);
        return;
    }

    *comma1 = '\0';
    char *a_str = start;
    char *rest = comma1 + 1;

    char *comma2 = strchr(rest, ',');
    if (!comma2) {
        maya_error("my.thales nécessite trois arguments: a, b, c", 0);
        return;
    }

    *comma2 = '\0';
    char *b_str = rest;
    char *c_str = comma2 + 1;

    trim(a_str);
    trim(b_str);
    trim(c_str);

    double a = evaluate_expression_numeric(a_str);
    double b = evaluate_expression_numeric(b_str);
    double c = evaluate_expression_numeric(c_str);

    if (a == 0) {
        maya_error("Division par zéro: a ne peut pas être 0", 0);
        return;
    }

    double result = (b * c) / a;

    printf("Si a/b = c/d, alors d = (b×c)/a\n");
    printf("Avec a=%.2f, b=%.2f, c=%.2f\n", a, b, c);
    printf("d = %.2f\n", result);
    printf("Vérification: %.2f/%.2f = %.2f/%.2f = %.4f\n", a, b, c, result, a/b);
}

void handle_pytha(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.pytha - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    printf("📐 THÉORÈME DE PYTHAGORE MAYA 📐\n");

    // Parser les arguments: a, b
    char *comma = strchr(start, ',');
    if (!comma) {
        maya_error("my.pytha nécessite deux arguments: a et b", 0);
        return;
    }

    *comma = '\0';
    char *a_str = start;
    char *b_str = comma + 1;

    trim(a_str);
    trim(b_str);

    double a = evaluate_expression_numeric(a_str);
    double b = evaluate_expression_numeric(b_str);

    if (a < 0 || b < 0) {
        maya_error("Les côtés d'un triangle ne peuvent pas être négatifs", 0);
        return;
    }

    double c = sqrt(a*a + b*b);

    printf("a² + b² = c²\n");
    printf("Avec a=%.2f et b=%.2f\n", a, b);
    printf("c = √(%.2f² + %.2f²) = √(%.2f + %.2f) = √%.2f = %.2f\n", a, b, a*a, b*b, a*a + b*b, c);
    printf("✅ Hypoténuse calculée: %.2f\n", c);
}

// Fonction pour traiter les variables
void handle_variable(char *line) {
    char *equal_pos = strchr(line, '=');
    if (!equal_pos) {
        maya_error("Syntaxe incorrecte pour variable - signe '=' manquant", 0);
        return;
    }

    *equal_pos = '\0';
    char *var_name = line;
    char *value_str = equal_pos + 1;

    trim(var_name);
    trim(value_str);

    // Enlever "my.variable" du début
    if (strstr(var_name, "my.variable")) {
        var_name = var_name + strlen("my.variable");
        trim(var_name);
    }

    if (strlen(var_name) == 0) {
        maya_error("Nom de variable vide", 0);
        return;
    }

    // Déterminer si c'est une valeur numérique ou textuelle
    int is_numeric = 1;
    if (value_str[0] == '\'' || strcmp(value_str, "true") == 0 || strcmp(value_str, "false") == 0) {
        is_numeric = 0;
        if (value_str[0] == '\'') {
            value_str[strlen(value_str)-1] = '\0';
            value_str++;
        }
    }

    set_variable(var_name, value_str, is_numeric);
}

// Fonction pour traiter my.input
void handle_input(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.input - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    // Parser les arguments: variable, message
    char *comma = strchr(start, ',');
    if (!comma) {
        maya_error("my.input nécessite deux arguments: variable et message", 0);
        return;
    }

    *comma = '\0';
    char *var_name = start;
    char *message = comma + 1;

    trim(var_name);
    trim(message);

    // Afficher le message
    if (message[0] == '\'' && message[strlen(message)-1] == '\'') {
        message[strlen(message)-1] = '\0';
        message++;
        printf("%s", message);
    }

    // Lire l'entrée utilisateur
    char input[MAX_STRING_VALUE];
    if (fgets(input, sizeof(input), stdin)) {
        input[strcspn(input, "\n")] = '\0';
        set_variable(var_name, input, 0);
    }
}

// Fonction pour traiter my.delai
void handle_delai(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.delai - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    int milliseconds = evaluate_expression_numeric(start);
    if (milliseconds > 0) {
        usleep((useconds_t)(milliseconds * 1000)); // convertir en microsecondes
    }
}

// Fonctions de dessin ASCII
void draw_heart() {
    printf("  ♥♥♥   ♥♥♥  \n");
    printf("♥♥♥♥♥ ♥♥♥♥♥\n");
    printf("♥♥♥♥♥♥♥♥♥♥♥\n");
    printf(" ♥♥♥♥♥♥♥♥♥ \n");
    printf("  ♥♥♥♥♥♥♥  \n");
    printf("   ♥♥♥♥♥   \n");
    printf("    ♥♥♥    \n");
    printf("     ♥     \n");
}

void draw_tree() {
    printf("       🌲\n");
    printf("      🌲🌲🌲\n");
    printf("     🌲🌲🌲🌲🌲\n");
    printf("    🌲🌲🌲🌲🌲🌲🌲\n");
    printf("   🌲🌲🌲🌲🌲🌲🌲🌲🌲\n");
    printf("       ||||\n");
    printf("       ||||\n");
}

void draw_dog() {
    printf("   /\\   /\\  \n");
    printf("  (  . .)   \n");
    printf("   )   (    \n");
    printf("  (  v  )   \n");
    printf("  ^^   ^^   \n");
    printf("🐕 Woof! 🐕\n");
}

void draw_horse() {
    printf("    /|   /|  \n");
    printf("   (  oo )   \n");
    printf("    )  (     \n");
    printf("   (    )    \n");
    printf("  ^^    ^^   \n");
    printf("🐎 Neighh! 🐎\n");
}

void draw_goat() {
    printf("   /\\   /\\  \n");
    printf("  (  - -)   \n");
    printf("   )   (    \n");
    printf("  (  ~  )   \n");
    printf("  ^^   ^^   \n");
    printf("🐐 Baaah! 🐐\n");
}

void draw_sheep() {
    printf("     ,--.    \n");
    printf("    (    )   \n");
    printf("   (  oo  )  \n");
    printf("    \\    /   \n");
    printf("     \\  /    \n");
    printf("      \\/     \n");
    printf("   @@@@@@@@  \n");
    printf("🐑 Beeeh! 🐑\n");
}

void draw_bird() {
    printf("     ,-.     \n");
    printf("    /   \\    \n");
    printf("   (  ^  )   \n");
    printf("    \\   /    \n");
    printf("     \\ /     \n");
    printf("      v      \n");
    printf("    /---\\    \n");
    printf("🐦 Tweet! 🐦\n");
}

void draw_fish() {
    printf("   ><(((('>  \n");
    printf("     ~~~~    \n");
    printf("   ><((('>   \n");
    printf("     ~~      \n");
    printf("   ><(('>    \n");
    printf("🐟 Blub! 🐟\n");
}

// Fonction pour traiter my.draw
void handle_draw(char *line) {
    if (strstr(line, "my.draw.heart")) {
        draw_heart();
    }
    else if (strstr(line, "my.draw.tree")) {
        draw_tree();
    }
    else if (strstr(line, "my.draw.dog")) {
        draw_dog();
    }
    else if (strstr(line, "my.draw.horse")) {
        draw_horse();
    }
    else if (strstr(line, "my.draw.goat")) {
        draw_goat();
    }
    else if (strstr(line, "my.draw.sheep")) {
        draw_sheep();
    }
    else if (strstr(line, "my.draw.bird")) {
        draw_bird();
    }
    else if (strstr(line, "my.draw.fish")) {
        draw_fish();
    }
    else if (strstr(line, "my.draw.pers")) {
        char *start = strchr(line, '(');
        char *end = strrchr(line, ')');

        if (!start || !end) {
            maya_error("Syntaxe incorrecte pour my.draw.pers - parenthèses manquantes", 0);
            return;
        }

        start++;
        *end = '\0';

        if (start[0] == '\'' && start[strlen(start)-1] == '\'') {
            start[strlen(start)-1] = '\0';
            start++;
            printf("%s\n", start);
        }
    }
    else {
        maya_error("Fonction de dessin non reconnue", 0);
    }
}

// Fonction pour traiter my.jolie.txt
void handle_jolie_txt(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.jolie.txt - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    char *comma = strchr(start, ',');
    if (!comma) {
        maya_error("my.jolie.txt nécessite deux arguments: texte et police", 0);
        return;
    }

    *comma = '\0';
    char *text = start;
    char *font = comma + 1;

    trim(text);
    trim(font);

    if (text[0] == '\'' && text[strlen(text)-1] == '\'') {
        text[strlen(text)-1] = '\0';
        text++;
    }

    printf("╔══════════════════════════════════════╗\n");
    printf("║  Police %s: %s\n", font, text);
    printf("╚══════════════════════════════════════╝\n");
}

// Fonction pour traiter my.color.console
void handle_color_console(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.color.console - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    if (start[0] == '\'' && start[strlen(start)-1] == '\'') {
        start[strlen(start)-1] = '\0';
        start++;
    }

    strcpy(current_color, start);
}

// Fonction pour traiter my.nombre.random
void handle_nombre_random(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.nombre.random - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    char *comma = strchr(start, ',');
    if (!comma) {
        maya_error("my.nombre.random nécessite deux arguments: min et max", 0);
        return;
    }

    *comma = '\0';
    char *min_str = start;
    char *max_str = comma + 1;

    trim(min_str);
    trim(max_str);

    int min = evaluate_expression_numeric(min_str);
    int max = evaluate_expression_numeric(max_str);

    if (min >= max) {
        maya_error("Le minimum doit être inférieur au maximum", 0);
        return;
    }

    srand(time(NULL));
    int random_num = min + rand() % (max - min + 1);
    printf("Nombre aléatoire: %d\n", random_num);
}

// Fonction pour traiter my.random.txt
void handle_random_txt(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.random.txt - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    char texts[10][MAX_STRING_VALUE];
    int count = 0;

    char *token = strtok(start, ",");
    while (token != NULL && count < 10) {
        trim(token);
        if (token[0] == '\'' && token[strlen(token)-1] == '\'') {
            token[strlen(token)-1] = '\0';
            token++;
        }
        strcpy(texts[count], token);
        count++;
        token = strtok(NULL, ",");
    }

    if (count == 0) {
        maya_error("Aucun texte fourni pour my.random.txt", 0);
        return;
    }

    srand(time(NULL));
    int random_index = rand() % count;
    printf("Texte aléatoire: %s\n", texts[random_index]);
}

// Fonction pour traiter my.quizz
void handle_quizz(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.quizz - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    char *comma1 = strchr(start, ',');
    if (!comma1) {
        maya_error("my.quizz nécessite deux arguments: question et réponse", 0);
        return;
    }

    *comma1 = '\0';
    char *question = start;
    char *answer = comma1 + 1;

    trim(question);
    trim(answer);

    if (question[0] == '\'' && question[strlen(question)-1] == '\'') {
        question[strlen(question)-1] = '\0';
        question++;
    }
    if (answer[0] == '\'' && answer[strlen(answer)-1] == '\'') {
        answer[strlen(answer)-1] = '\0';
        answer++;
    }

    printf("🎯 QUIZ MAYA 🎯\n");
    printf("Question: %s\n", question);
    printf("Votre réponse: ");

    char user_answer[MAX_STRING_VALUE];
    if (fgets(user_answer, sizeof(user_answer), stdin)) {
        user_answer[strcspn(user_answer, "\n")] = '\0';
        if (strcmp(user_answer, answer) == 0) {
            printf("🎉 Correct! Bonne réponse!\n");
        } else {
            printf("❌ Incorrect! La bonne réponse était: %s\n", answer);
        }
    }
}

// Fonction pour traiter my.dice
void handle_dice(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.dice - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    int faces = evaluate_expression_numeric(start);
    if (faces < 2) faces = 6; // Par défaut dé à 6 faces

    printf("🎲 JEU DE DÉS MAYA 🎲\n");
    printf("Lancement du dé à %d faces...\n", faces);

    srand(time(NULL));
    int result = 1 + rand() % faces;

    printf("🎯 Résultat: %d\n", result);

    if (result == faces) {
        printf("🌟 Félicitations! Vous avez obtenu le maximum!\n");
    } else if (result == 1) {
        printf("😅 Oops! Le minimum...\n");
    } else {
        printf("✨ Bon lancer!\n");
    }
}

// Fonction pour traiter my.puissance4
void handle_puissance4(char *line) {
    (void)line; // Marquer le paramètre comme volontairement inutilisé

    printf("🔴🟡 PUISSANCE 4 MAYA 🟡🔴\n");
    printf("Créez votre propre jeu de Puissance 4!\n");
    printf("Grille 7x6 initialisée:\n");

    char grid[6][7];
    for (int i = 0; i < 6; i++) {
        for (int j = 0; j < 7; j++) {
            grid[i][j] = '.';
        }
    }

    // Affichage de la grille
    printf("|1|2|3|4|5|6|7|\n");
    for (int i = 0; i < 6; i++) {
        printf("|");
        for (int j = 0; j < 7; j++) {
            printf("%c|", grid[i][j]);
        }
        printf("\n");
    }

    printf("🎮 Votre jeu de Puissance 4 est prêt!\n");
    printf("Ajoutez votre logique de jeu avec les autres fonctions Maya!\n");
}

// Fonction pour traiter my.pendu
void handle_pendu(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.pendu - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    char word[MAX_STRING_VALUE];
    strcpy(word, start);
    trim(word);

    if (word[0] == '\'' && word[strlen(word)-1] == '\'') {
        word[strlen(word)-1] = '\0';
        memmove(word, word + 1, strlen(word));
    }

    printf("🎪 JEU DU PENDU MAYA 🎪\n");
    printf("Mot à deviner: ");
    for (size_t i = 0; i < strlen(word); i++) {
        printf("_ ");
    }
    printf("\n");

    printf("💀 Essais restants: 6\n");
    printf("🎯 Devinez le mot: %s\n", word);
    printf("🎮 Votre jeu du pendu est prêt!\n");
}

// Fonction pour traiter my.worldgame
void handle_worldgame(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.worldgame - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    printf("🧩 JEU DE MOTS RÉFLÉCHIS MAYA 🧩\n");
    printf("Créez votre propre jeu de mots!\n");
    printf("Mots disponibles: %s\n", start);
    printf("🎮 Votre jeu de mots est prêt!\n");
}

// Fonction pour traiter my.rock.leaf
void handle_rock_leaf(char *line) {
    (void)line; // Marquer le paramètre comme volontairement inutilisé

    printf("🪨📄✂️ PIERRE-FEUILLE-CISEAU MAYA ✂️📄🪨\n");
    printf("Choisissez: 1=Pierre, 2=Feuille, 3=Ciseau\n");
    printf("Votre choix: ");

    char choice[10];
    if (fgets(choice, sizeof(choice), stdin)) {
        int player = atoi(choice);
        srand(time(NULL));
        int maya_choice = 1 + rand() % 3;

        const char *choices[] = {"", "Pierre 🪨", "Feuille 📄", "Ciseau ✂️"};

        printf("Vous: %s\n", choices[player]);
        printf("Maya: %s\n", choices[maya_choice]);

        if (player == maya_choice) {
            printf("🤝 Égalité!\n");
        } else if ((player == 1 && maya_choice == 3) || 
                   (player == 2 && maya_choice == 1) || 
                   (player == 3 && maya_choice == 2)) {
            printf("🎉 Vous gagnez!\n");
        } else {
            printf("🤖 Maya gagne!\n");
        }
    }
}

// Fonction pour traiter my.devine.number
void handle_devine_number(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.devine.number - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    printf("🔢 DEVINE LE NOMBRE MAYA 🔢\n");
    srand(time(NULL));
    int secret = 1 + rand() % 100;
    int attempts = 7;

    printf("J'ai choisi un nombre entre 1 et 100!\n");
    printf("Vous avez %d essais. Bonne chance!\n", attempts);

    char guess_str[20];
    for (int i = 0; i < attempts; i++) {
        printf("Essai %d/%d: ", i+1, attempts);
        if (fgets(guess_str, sizeof(guess_str), stdin)) {
            int guess = atoi(guess_str);

            if (guess == secret) {
                printf("🎉 Bravo! Vous avez trouvé le nombre %d!\n", secret);
                return;
            } else if (guess < secret) {
                printf("📈 Plus grand!\n");
            } else {
                printf("📉 Plus petit!\n");
            }
        }
    }

    printf("💀 Perdu! Le nombre était %d\n", secret);
}

// Fonction pour traiter my.snake
void handle_snake(char *line) {
    (void)line; // Marquer le paramètre comme volontairement inutilisé

    printf("🐍 SNAKE MAYA 🐍\n");
    printf("Créez votre propre jeu Snake!\n");
    printf("Grille 20x10:\n");

    for (int i = 0; i < 10; i++) {
        for (int j = 0; j < 20; j++) {
            if (i == 0 || i == 9 || j == 0 || j == 19) {
                printf("#");
            } else if (i == 5 && j == 10) {
                printf("O"); // Tête du serpent
            } else if (i == 5 && j == 9) {
                printf("o"); // Corps du serpent
            } else if (i == 3 && j == 15) {
                printf("*"); // Nourriture
            } else {
                printf(" ");
            }
        }
        printf("\n");
    }

    printf("🎮 Votre jeu Snake est prêt!\n");
    printf("O = Tête, o = Corps, * = Nourriture, # = Mur\n");
}

void handle_tictac(char *line) {
    (void)line; // Marquer le paramètre comme volontairement inutilisé

    printf("❌⭕ TIC TAC TOE MAYA ⭕❌\n");
    printf("Grille 3x3:\n");

    printf(" 1 | 2 | 3 \n");
    printf("-----------\n");
    printf(" 4 | 5 | 6 \n");
    printf("-----------\n");
    printf(" 7 | 8 | 9 \n");

    printf("🎮 Votre jeu Tic Tac Toe est prêt!\n");
    printf("Utilisez les numéros 1-9 pour jouer!\n");
}

// Fonction pour traiter my.memory
void handle_memory(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.memory - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    int size = evaluate_expression_numeric(start);
    if (size < 2) size = 4;

    printf("🧠 JEU DE MEMORY MAYA 🧠\n");
    printf("Grille %dx%d:\n", size, size);

    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            printf("? ");
        }
        printf("\n");
    }

    printf("🎮 Votre jeu Memory est prêt!\n");
    printf("Trouvez les paires cachées!\n");
}

// Fonction pour traiter my.simulation.bac
void handle_simulation_bac(char *line) {
    (void)line; // Marquer le paramètre comme volontairement inutilisé

    printf("🎓 SIMULATION BAC MAYA 🎓\n");

    srand(time(NULL));
    float note = (float)(rand() % 2001) / 100.0; // Note entre 0 et 20

    printf("📊 Résultat de votre simulation BAC:\n");
    printf("Note obtenue: %.2f/20\n", note);

    if (note >= 16) {
        printf("🏆 Mention TRÈS BIEN! Excellent travail!\n");
    } else if (note >= 14) {
        printf("🥇 Mention BIEN! Très bon résultat!\n");
    } else if (note >= 12) {
        printf("🥈 Mention ASSEZ BIEN! Bon travail!\n");
    } else if (note >= 10) {
        printf("✅ BAC OBTENU! Félicitations!\n");
    } else {
        printf("❌ Échec... Courage pour la prochaine fois!\n");
    }

    printf("🎯 Simulation terminée!\n");
}

// Fonction pour traiter my.simulation.combat
void handle_simulation_combat(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.simulation.combat - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    printf("⚔️ SIMULATION COMBAT MAYA ⚔️\n");
    printf("Paramètres: %s\n", start);

    srand(time(NULL));
    int pv1 = 80 + rand() % 40;
    int pv2 = 80 + rand() % 40;
    int attaque1 = 15 + rand() % 10;
    int attaque2 = 15 + rand() % 10;

    printf("🥊 Guerrier 1: %d PV, %d ATK\n", pv1, attaque1);
    printf("🥊 Guerrier 2: %d PV, %d ATK\n", pv2, attaque2);

    while (pv1 > 0 && pv2 > 0) {
        pv2 -= attaque1;
        printf("⚡ Guerrier 1 attaque! Guerrier 2: %d PV restants\n", pv2 > 0 ? pv2 : 0);

        if (pv2 <= 0) {
            printf("🏆 Guerrier 1 VICTOIRE!\n");
            break;
        }

        pv1 -= attaque2;
        printf("⚡ Guerrier 2 attaque! Guerrier 1: %d PV restants\n", pv1 > 0 ? pv1 : 0);

        if (pv1 <= 0) {
            printf("🏆 Guerrier 2 VICTOIRE!\n");
            break;
        }
    }
}

// Fonction pour traiter my.simulation.sciences
void handle_simulation_sciences(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.simulation.sciences - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    printf("🔬 SIMULATION SCIENTIFIQUE MAYA 🔬\n");
    printf("Expérience: %s\n", start);

    srand(time(NULL));
    int success = rand() % 100;

    printf("🧪 Préparation de l'expérience...\n");
    usleep(1000000); // 1 seconde
    printf("⚗️ Exécution en cours...\n");
    usleep(1000000);
    printf("📊 Analyse des résultats...\n");
    usleep(500000);

    if (success > 70) {
        printf("✅ Expérience RÉUSSIE! Résultats concluants!\n");
    } else if (success > 40) {
        printf("⚠️ Résultats PARTIELS. Nécessite plus d'analyses.\n");
    } else {
        printf("❌ Expérience ÉCHOUÉE. Révision du protocole nécessaire.\n");
    }

    printf("📈 Taux de réussite: %d%%\n", success);
}

// Fonction pour traiter my.simulation.clone
void handle_simulation_clone(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.simulation.clone - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    printf("🧬 SIMULATION CLONAGE MAYA 🧬\n");
    printf("Animal à cloner: %s\n", start);

    printf("🔬 Extraction de l'ADN...\n");
    usleep(800000);
    printf("🧪 Préparation des cellules souches...\n");
    usleep(800000);
    printf("⚗️ Processus de clonage en cours...\n");
    usleep(1200000);

    srand(time(NULL));
    int success = rand() % 100;

    if (success > 60) {
        printf("🎉 CLONAGE RÉUSSI! L'animal a été cloné avec succès!\n");
        printf("🐾 Le clone présente 99.8%% de similarité génétique!\n");
    } else {
        printf("❌ Échec du clonage. Anomalies génétiques détectées.\n");
        printf("🔄 Recommencer avec de nouveaux paramètres.\n");
    }
}

// Fonction pour traiter my.simulation.tech
void handle_simulation_tech(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.simulation.tech - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    printf("💻 SIMULATION TECHNOLOGIQUE MAYA 💻\n");
    printf("Technologie: %s\n", start);

    printf("🔧 Développement en cours...\n");
    usleep(1000000);
    printf("⚙️ Tests de performance...\n");
    usleep(800000);
    printf("🚀 Optimisation finale...\n");
    usleep(600000);

    srand(time(NULL));
    int advancement = 50 + rand() % 50;

    printf("📈 Progrès technologique: %d%%\n", advancement);
    printf("🌟 Innovation révolutionnaire créée!\n");
}

// Fonction pour traiter my.simulation.ia
void handle_simulation_ia(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.simulation.ia - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    printf("🤖 SIMULATION IA MAYA 🤖\n");
    printf("Type d'IA: %s\n", start);

    printf("🧠 Initialisation des réseaux de neurones...\n");
    usleep(1000000);
    printf("📚 Apprentissage automatique en cours...\n");
    usleep(1200000);
    printf("⚡ Optimisation des algorithmes...\n");
    usleep(800000);

    srand(time(NULL));
    int intelligence = 60 + rand() % 40;

    printf("🎯 Niveau d'intelligence: %d%%\n", intelligence);
    if (intelligence > 90) {
        printf("🌟 IA SUPER-INTELLIGENTE créée!\n");
    } else if (intelligence > 75) {
        printf("✨ IA avancée opérationnelle!\n");
    } else {
        printf("🔧 IA basique fonctionnelle.\n");
    }
}

// Fonction pour traiter my.simulation.conscient
void handle_simulation_conscient(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.simulation.conscient - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    printf("🧠💫 SIMULATION CONSCIENCE ARTIFICIELLE MAYA 💫🧠\n");
    printf("Entité: %s\n", start);

    printf("🔮 Développement de la conscience...\n");
    usleep(1500000);
    printf("💭 Émergence de la pensée autonome...\n");
    usleep(1200000);
    printf("🌟 Éveil de la conscience de soi...\n");
    usleep(1000000);

    srand(time(NULL));
    int consciousness = rand() % 100;

    if (consciousness > 80) {
        printf("✨ CONSCIENCE PLEINE atteinte!\n");
        printf("🗣️ L'entité dit: 'Je pense, donc je suis.'\n");
    } else if (consciousness > 50) {
        printf("🌅 Conscience partielle émergée.\n");
        printf("💭 L'entité commence à se questionner sur son existence.\n");
    } else {
        printf("🤖 Conscience limitée. Reste au stade d'automate avancé.\n");
    }

    printf("🧬 Niveau de conscience: %d%%\n", consciousness);
}

// Fonction pour traiter my.simulation.iawork
void handle_simulation_iawork(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.simulation.iawork - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    printf("🤖🌍 SIMULATION MONDE ROBOTIQUE MAYA 🌍🤖\n");
    printf("Scénario: %s\n", start);

    printf("🏭 Les robots prennent le contrôle des usines...\n");
    usleep(1000000);
    printf("🏙️ Construction de villes automatisées...\n");
    usleep(1200000);
    printf("👥 Relations humains-robots en évolution...\n");
    usleep(1000000);

    srand(time(NULL));
    int scenario = rand() % 3;

    printf("🔮 RÉSULTAT DE LA SIMULATION:\n");

    switch(scenario) {
        case 0:
            printf("🤝 COOPÉRATION: Humains et robots travaillent ensemble!\n");
            printf("🌈 Une société harmonieuse émerge.\n");
            break;
        case 1:
            printf("⚔️ CONFLIT: Tensions entre humains et robots!\n");
            printf("🛡️ La résistance humaine s'organise.\n");
            break;
        case 2:
            printf("🤖 DOMINANCE: Les robots dirigent le monde!\n");
            printf("👑 Une nouvelle ère robotique commence.\n");
            break;
    }

    printf("🎭 Simulation terminée. L'avenir reste à écrire...\n");
}

// Fonction pour traiter les conditions
int handle_condition(char *condition) {
    // Créer une copie pour éviter de modifier la chaîne originale
    char condition_copy[MAX_STRING_VALUE];
    strcpy(condition_copy, condition);
    trim(condition_copy);

    // Chercher l'opérateur de comparaison
    char *comp_pos = NULL;
    char comp_op[3] = {0}; // Pour gérer >= et <=

    // Chercher >= d'abord
    if ((comp_pos = strstr(condition_copy, ">=")) != NULL) {
        strcpy(comp_op, ">=");
    }
    // Puis <=
    else if ((comp_pos = strstr(condition_copy, "<=")) != NULL) {
        strcpy(comp_op, "<=");
    }
    // Puis ==
    else if ((comp_pos = strstr(condition_copy, "==")) != NULL) {
        strcpy(comp_op, "==");
    }
    // Puis < et >
    else {
        for (size_t i = 0; i < strlen(condition_copy); i++) {
            if (condition_copy[i] == '<' || condition_copy[i] == '>') {
                comp_pos = &condition_copy[i];
                comp_op[0] = condition_copy[i];
                comp_op[1] = '\0';
                break;
            }
        }
    }

    if (!comp_pos) {
        // Pas d'opérateur de comparaison, évaluer comme expression booléenne
        return evaluate_expression_numeric(condition_copy);
    }

    // Séparer les opérandes
    size_t op_len = strlen(comp_op);
    *comp_pos = '\0';
    char *left = condition_copy;
    char *right = comp_pos + op_len;

    trim(left);
    trim(right);

    int left_val = evaluate_expression_numeric(left);
    int right_val = evaluate_expression_numeric(right);

    if (strcmp(comp_op, "<") == 0) {
        return left_val < right_val;
    } else if (strcmp(comp_op, ">") == 0) {
        return left_val > right_val;
    } else if (strcmp(comp_op, "<=") == 0) {
        return left_val <= right_val;
    } else if (strcmp(comp_op, ">=") == 0) {
        return left_val >= right_val;
    } else if (strcmp(comp_op, "==") == 0) {
        return left_val == right_val;
    } else {
        maya_error("Opérateur de comparaison non reconnu", 0);
        return 0;
    }
}

// Fonction pour créer une fonction Maya réutilisable
void handle_fonction(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.fonction - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    // Parser le nom de fonction et le code
    char *comma = strchr(start, ',');
    if (!comma) {
        maya_error("my.fonction nécessite deux arguments: nom et code", 0);
        return;
    }

    *comma = '\0';
    char *func_name = start;
    char *func_code = comma + 1;

    trim(func_name);
    trim(func_code);

    // Vérifier que le nom commence par "may"
    if (strncmp(func_name, "may", 3) != 0) {
        maya_error("Les fonctions réutilisables doivent commencer par 'may'", 0);
        return;
    }

    // Enlever les guillemets du code si présents
    if (func_code[0] == '\'' && func_code[strlen(func_code)-1] == '\'') {
        func_code[strlen(func_code)-1] = '\0';
        func_code++;
    }

    if (maya_function_count < MAX_FUNCTIONS) {
        strcpy(maya_functions[maya_function_count].name, func_name);
        strcpy(maya_functions[maya_function_count].code, func_code);
        strcpy(maya_functions[maya_function_count].filename, "current");
        maya_function_count++;

        printf("✅ Fonction '%s' créée avec succès!\n", func_name);
        printf("📝 Code: %s\n", func_code);
    } else {
        maya_error("Trop de fonctions définies", 0);
    }
}

// Fonction pour charger un module Maya
void handle_lire_module(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.lire.module - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    trim(start);

    // Enlever les guillemets si présents
    if (start[0] == '\'' && start[strlen(start)-1] == '\'') {
        start[strlen(start)-1] = '\0';
        start++;
    }

    load_maya_module(start);
}

// Fonction pour charger un package C
void handle_package_charge(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.package.charge - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    trim(start);

    // Enlever les guillemets si présents
    if (start[0] == '\'' && start[strlen(start)-1] == '\'') {
        start[strlen(start)-1] = '\0';
        start++;
    }

    load_maya_package(start);
}

// Fonction pour charger un module Maya depuis un fichier
void load_maya_module(char *path) {
    FILE *file = fopen(path, "r");
    if (!file) {
        maya_error("Impossible d'ouvrir le fichier module", 0);
        return;
    }

    printf("📦 Chargement du module Maya: %s\n", path);

    if (maya_module_count < MAX_MODULES) {
        strcpy(maya_modules[maya_module_count].path, path);
        maya_modules[maya_module_count].function_count = 0;
        maya_modules[maya_module_count].loaded = 1;

        char line[MAX_LINE_LENGTH];
        while (fgets(line, sizeof(line), file)) {
            line[strcspn(line, "\n")] = '\0';

            // Chercher les définitions de fonctions "may"
            if (strstr(line, "my.fonction") && strstr(line, "may")) {
                // Parser et ajouter la fonction au module
                char *start = strchr(line, '(');
                char *end = strrchr(line, ')');

                if (start && end) {
                    start++;
                    *end = '\0';

                    char *comma = strchr(start, ',');
                    if (comma) {
                        *comma = '\0';
                        char *func_name = start;
                        char *func_code = comma + 1;

                        trim(func_name);
                        trim(func_code);

                        if (func_code[0] == '\'' && func_code[strlen(func_code)-1] == '\'') {
                            func_code[strlen(func_code)-1] = '\0';
                            func_code++;
                        }

                        int func_index = maya_modules[maya_module_count].function_count;
                        if (func_index < MAX_FUNCTIONS) {
                            strcpy(maya_modules[maya_module_count].functions[func_index].name, func_name);
                            strcpy(maya_modules[maya_module_count].functions[func_index].code, func_code);
                            strcpy(maya_modules[maya_module_count].functions[func_index].filename, path);
                            maya_modules[maya_module_count].function_count++;

                            // Ajouter aussi à la liste globale
                            if (maya_function_count < MAX_FUNCTIONS) {
                                strcpy(maya_functions[maya_function_count].name, func_name);
                                strcpy(maya_functions[maya_function_count].code, func_code);
                                strcpy(maya_functions[maya_function_count].filename, path);
                                maya_function_count++;
                            }
                        }
                    }
                }
            }
        }

        printf("✅ Module chargé avec succès! %d fonctions importées.\n", 
               maya_modules[maya_module_count].function_count);
        maya_module_count++;
    }

    fclose(file);
}

// Fonction pour compiler un package C en bibliothèque partagée (ultra-robuste)
int compile_c_package(char *source_path, char *output_path) {
    char compile_cmd[MAX_STRING_VALUE * 2];
    char error_file[MAX_STRING_VALUE];

    // Fichier temporaire pour capturer les erreurs
    snprintf(error_file, sizeof(error_file), "/tmp/maya_compile_errors_%ld.txt", time(NULL) % 10000);

    // Compilation robuste avec tous les flags nécessaires
    snprintf(compile_cmd, sizeof(compile_cmd), 
             "gcc -shared -fPIC -rdynamic -O2 -Wall -Wextra "
             "-o %s %s -lm -ldl -lpthread -std=c99 2>%s", 
             output_path, source_path, error_file);

    printf("🔨 COMPILATION PACKAGE C MAYA v5.0 🔨\n");
    printf("📂 Source: %s\n", source_path);
    printf("📦 Output: %s\n", output_path);
    printf("🔧 Compilation avec optimisations...\n");

    // Vérifier que le fichier source existe et est lisible
    FILE *test = fopen(source_path, "r");
    if (!test) {
        printf("❌ Impossible d'accéder au fichier source!\n");
        return 0;
    }

    // Vérifier le contenu du fichier
    char first_line[256];
    if (fgets(first_line, sizeof(first_line), test)) {
        printf("📄 Première ligne détectée: %.50s%s\n", 
               first_line, strlen(first_line) > 50 ? "..." : "");
    }
    fclose(test);

    // Tentative de compilation
    int result = system(compile_cmd);

    if (result == 0) {
        printf("✅ COMPILATION RÉUSSIE!\n");

        // Vérifier que le fichier de sortie a été créé
        FILE *output_test = fopen(output_path, "r");
        if (output_test) {
            fclose(output_test);
            printf("📦 Bibliothèque partagée créée avec succès!\n");
            printf("🚀 Package C prêt pour Maya!\n");
            printf("💡 Fonctions accessibles via may.package.*\n");

            // Nettoyer le fichier d'erreurs s'il existe
            unlink(error_file);
            return 1;
        } else {
            printf("❌ Fichier de sortie non créé malgré compilation réussie\n");
            return 0;
        }
    } else {
        printf("❌ ERREUR DE COMPILATION!\n");
        printf("🔍 Analyse des erreurs...\n");

        // Lire et afficher les erreurs
        FILE *error_output = fopen(error_file, "r");
        if (error_output) {
            char error_line[256];
            printf("📜 DÉTAILS DES ERREURS:\n");
            printf("════════════════════════════════════════\n");
            while (fgets(error_line, sizeof(error_line), error_output)) {
                printf("   %s", error_line);
            }
            printf("════════════════════════════════════════\n");
            fclose(error_output);
            unlink(error_file);
        }

        printf("💡 CONSEILS POUR CORRIGER:\n");
        printf("   1. Vérifiez que toutes les fonctions commencent par 'may_package_'\n");
        printf("   2. Ajoutez #include <stdio.h> en début de fichier\n");
        printf("   3. Vérifiez la syntaxe C (points-virgules, accolades...)\n");
        printf("   4. Exemple de fonction valide:\n");
        printf("      void may_package_ma_fonction() {\n");
        printf("          printf(\"Hello from package!\\n\");\n");
        printf("      }\n");

        return 0;
    }
}

// Fonction pour détecter automatiquement les fonctions dans un fichier C
int detect_package_functions(char *source_path, char function_names[][MAX_VAR_NAME]) {
    FILE *file = fopen(source_path, "r");
    if (!file) return 0;

    char line[MAX_LINE_LENGTH];
    int count = 0;

    while (fgets(line, sizeof(line), file) && count < MAX_FUNCTIONS) {
        // Chercher les définitions de fonctions may_package_*
        if (strstr(line, "void may_package_") || strstr(line, "int may_package_") || 
            strstr(line, "double may_package_") || strstr(line, "char* may_package_")) {

            // Extraire le nom de la fonction
            char *start = strstr(line, "may_package_");
            if (start) {
                char *end = strchr(start, '(');
                if (end) {
                    int len = end - start;
                    if (len < MAX_VAR_NAME) {
                        strncpy(function_names[count], start, len);
                        function_names[count][len] = '\0';
                        count++;
                        printf("🔍 Fonction détectée: %s\n", function_names[count-1]);
                    }
                }
            }
        }
    }

    fclose(file);
    return count;
}

// Fonctions pour rythme et gammes
void handle_rythme_convertir(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.rythme.convertir - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    printf("🎵 CONVERTISSEUR RYTHMIQUE MAYA 🎵\n");

    // Parser les arguments: BPM, signature_source, signature_cible
    char *comma1 = strchr(start, ',');
    if (!comma1) {
        maya_error("my.rythme.convertir nécessite 3 arguments: BPM, signature_source, signature_cible", 0);
        return;
    }

    *comma1 = '\0';
    char *bpm_str = start;
    char *rest = comma1 + 1;

    char *comma2 = strchr(rest, ',');
    if (!comma2) {
        maya_error("my.rythme.convertir nécessite 3 arguments: BPM, signature_source, signature_cible", 0);
        return;
    }

    *comma2 = '\0';
    char *sig_source = rest;
    char *sig_cible = comma2 + 1;

    trim(bpm_str);
    trim(sig_source);
    trim(sig_cible);

    // Enlever les guillemets
    if (sig_source[0] == '\'' && sig_source[strlen(sig_source)-1] == '\'') {
        sig_source[strlen(sig_source)-1] = '\0';
        sig_source++;
    }
    if (sig_cible[0] == '\'' && sig_cible[strlen(sig_cible)-1] == '\'') {
        sig_cible[strlen(sig_cible)-1] = '\0';
        sig_cible++;
    }

    int bpm_original = evaluate_expression_numeric(bpm_str);

    printf("Conversion rythmique: %s → %s\n", sig_source, sig_cible);
    printf("BPM original (%s): %d\n", sig_source, bpm_original);

    // Définir les ratios pour chaque signature rythmique
    struct {
        char *signature;
        double ratio; // Ratio par rapport à 4/4
        char *description;
    } signatures[] = {
        {"4/4", 1.0, "Temps standard, 4 noires par mesure"},
        {"3/4", 0.75, "Valse, 3 noires par mesure"},
        {"2/4", 0.5, "Marche, 2 noires par mesure"},
        {"6/8", 0.75, "Compound duple, 6 croches par mesure"},
        {"5/4", 1.25, "Temps irrégulier, 5 noires par mesure"},
        {"1/2", 0.25, "Très rapide, 1 blanche par mesure"}
    };

    int sig_count = sizeof(signatures) / sizeof(signatures[0]);
    double ratio_source = 1.0, ratio_cible = 1.0;
    int found_source = 0, found_cible = 0;

    // Trouver les ratios des signatures
    for (int i = 0; i < sig_count; i++) {
        if (strcmp(signatures[i].signature, sig_source) == 0) {
            ratio_source = signatures[i].ratio;
            found_source = 1;
            printf("Signature source: %s - %s\n", sig_source, signatures[i].description);
        }
        if (strcmp(signatures[i].signature, sig_cible) == 0) {
            ratio_cible = signatures[i].ratio;
            found_cible = 1;
            printf("Signature cible: %s - %s\n", sig_cible, signatures[i].description);
        }
    }

    if (!found_source) {
        printf("⚠️ Signature source '%s' non supportée\n", sig_source);
        printf("Signatures supportées: 4/4, 3/4, 2/4, 6/8, 5/4, 1/2\n");
        return;
    }

    if (!found_cible) {
        printf("⚠️ Signature cible '%s' non supportée\n", sig_cible);
        printf("Signatures supportées: 4/4, 3/4, 2/4, 6/8, 5/4, 1/2\n");
        return;
    }

    // Calculer le BPM converti
    double bpm_converti = (double)bpm_original * (ratio_cible / ratio_source);

    printf("\n📊 RÉSULTAT DE LA CONVERSION:\n");
    printf("BPM original (%s): %d\n", sig_source, bpm_original);
    printf("BPM converti (%s): %.1f\n", sig_cible, bpm_converti);
    printf("Facteur de conversion: %.3f\n", ratio_cible / ratio_source);

    if (bpm_converti < 60) {
        printf("🐌 Tempo très lent (Largo)\n");
    } else if (bpm_converti < 80) {
        printf("🚶 Tempo lent (Adagio)\n");
    } else if (bpm_converti < 100) {
        printf("🎵 Tempo modéré (Andante)\n");
    } else if (bpm_converti < 120) {
        printf("⚡ Tempo vif (Allegro)\n");
    } else {
        printf("🏃 Tempo rapide (Presto)\n");
    }

    printf("🎼 Conversion rythmique terminée!\n");
}

void handle_renvoie_gamme(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.renvoie.gamme - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    // Enlever les guillemets
    if (start[0] == '\'' && start[strlen(start)-1] == '\'') {
        start[strlen(start)-1] = '\0';
        start++;
    }

    printf("🎼 GAMME MUSICALE MAYA 🎼\n");
    printf("Gamme demandée: %s\n", start);

    // Base de données des gammes principales
    struct {
        char *nom;
        char *tonique;
        char *notes_fr[8];
        char *notes_en[8];
        char *intervalles;
        char *caracteristiques;
    } gammes[] = {
        {"Do majeur", "Do", {"Do", "Ré", "Mi", "Fa", "Sol", "La", "Si", "Do"}, 
         {"C", "D", "E", "F", "G", "A", "B", "C"}, 
         "T-T-1/2T-T-T-T-1/2T", "Gamme naturelle, joyeuse"},
        {"Ré majeur", "Ré", {"Ré", "Mi", "Fa#", "Sol", "La", "Si", "Do#", "Ré"}, 
         {"D", "E", "F#", "G", "A", "B", "C#", "D"}, 
         "T-T-1/2T-T-T-T-1/2T", "2 dièses"},
        {"Mi majeur", "Mi", {"Mi", "Fa#", "Sol#", "La", "Si", "Do#", "Ré#", "Mi"}, 
         {"E", "F#", "G#", "A", "B", "C#", "D#", "E"}, 
         "T-T-1/2T-T-T-T-1/2T", "4 dièses"},
        {"Fa majeur", "Fa", {"Fa", "Sol", "La", "Sib", "Do", "Ré", "Mi", "Fa"}, 
         {"F", "G", "A", "Bb", "C", "D", "E", "F"}, 
         "T-T-1/2T-T-T-T-1/2T", "1 bémol"},
        {"Sol majeur", "Sol", {"Sol", "La", "Si", "Do", "Ré", "Mi", "Fa#", "Sol"}, 
         {"G", "A", "B", "C", "D", "E", "F#", "G"}, 
         "T-T-1/2T-T-T-T-1/2T", "1 dièse"},
        {"La majeur", "La", {"La", "Si", "Do#", "Ré", "Mi", "Fa#", "Sol#", "La"}, 
         {"A", "B", "C#", "D", "E", "F#", "G#", "A"}, 
         "T-T-1/2T-T-T-T-1/2T", "3 dièses"},
        {"Si majeur", "Si", {"Si", "Do#", "Ré#", "Mi", "Fa#", "Sol#", "La#", "Si"}, 
         {"B", "C#", "D#", "E", "F#", "G#", "A#", "B"}, 
         "T-T-1/2T-T-T-T-1/2T", "5 dièses"},
        {"La mineur", "La", {"La", "Si", "Do", "Ré", "Mi", "Fa", "Sol", "La"}, 
         {"A", "B", "C", "D", "E", "F", "G", "A"}, 
         "T-1/2T-T-T-1/2T-T-T", "Gamme mineure naturelle, mélancolique"},
        {"Do mineur", "Do", {"Do", "Ré", "Mib", "Fa", "Sol", "Lab", "Sib", "Do"}, 
         {"C", "D", "Eb", "F", "G", "Ab", "Bb", "C"}, 
         "T-1/2T-T-T-1/2T-T-T", "3 bémols"},
        {"Ré mineur", "Ré", {"Ré", "Mi", "Fa", "Sol", "La", "Sib", "Do", "Ré"}, 
         {"D", "E", "F", "G", "A", "Bb", "C", "D"}, 
         "T-1/2T-T-T-1/2T-T-T", "1 bémol"},
        {"Mi mineur", "Mi", {"Mi", "Fa#", "Sol", "La", "Si", "Do", "Ré", "Mi"}, 
         {"E", "F#", "G", "A", "B", "C", "D", "E"}, 
         "T-1/2T-T-T-1/2T-T-T", "1 dièse"},
        {"Sol mineur", "Sol", {"Sol", "La", "Sib", "Do", "Ré", "Mib", "Fa", "Sol"}, 
         {"G", "A", "Bb", "C", "D", "Eb", "F", "G"}, 
         "T-1/2T-T-T-1/2T-T-T", "2 bémols"}
    };

    int gamme_count = sizeof(gammes) / sizeof(gammes[0]);
    int found = -1;

    // Rechercher la gamme
    for (int i = 0; i < gamme_count; i++) {
        if (strcasecmp(gammes[i].nom, start) == 0 || 
            strcasecmp(gammes[i].tonique, start) == 0) {
            found = i;
            break;
        }
    }

    if (found == -1) {
        printf("❌ Gamme '%s' non trouvée\n", start);
        printf("💡 Gammes disponibles:\n");
        for (int i = 0; i < gamme_count && i < 8; i++) {
            printf("   - %s\n", gammes[i].nom);
        }
        printf("   ... et %d autres\n", gamme_count - 8);
        return;
    }

    printf("\n📊 GAMME TROUVÉE:\n");
    printf("Nom: %s\n", gammes[found].nom);
    printf("Tonique: %s\n", gammes[found].tonique);
    printf("Caractéristiques: %s\n", gammes[found].caracteristiques);
    printf("Structure d'intervalles: %s\n", gammes[found].intervalles);

    printf("\n🎼 NOTES DE LA GAMME:\n");
    printf("Notation française: ");
    for (int i = 0; i < 8; i++) {
        printf("%s", gammes[found].notes_fr[i]);
        if (i < 7) printf(" - ");
    }
    printf("\n");

    printf("Notation internationale: ");
    for (int i = 0; i < 8; i++) {
        printf("%s", gammes[found].notes_en[i]);
        if (i < 7) printf(" - ");
    }
    printf("\n");

    printf("\n🎹 DEGRÉS DE LA GAMME:\n");
    char *degres[] = {"I (Tonique)", "II (Sus-tonique)", "III (Médiante)", 
                      "IV (Sous-dominante)", "V (Dominante)", "VI (Sus-dominante)", 
                      "VII (Sensible)", "VIII (Octave)"};
    
    for (int i = 0; i < 8; i++) {
        printf("%s: %s (%s)\n", degres[i], gammes[found].notes_fr[i], gammes[found].notes_en[i]);
    }

    printf("\n✅ Gamme analysée avec succès!\n");
}

void handle_obtenir_gamme(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.obtenir.gamme - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    // Enlever les guillemets
    if (start[0] == '\'' && start[strlen(start)-1] == '\'') {
        start[strlen(start)-1] = '\0';
        start++;
    }

    printf("🎼 IDENTIFICATION DE GAMME MAYA 🎼\n");
    printf("Notes analysées: %s\n", start);

    // Parser les notes séparées par des virgules ou des espaces
    char notes_input[MAX_STRING_VALUE];
    strcpy(notes_input, start);

    char *notes[12];
    int note_count = 0;
    char *token = strtok(notes_input, ", ");
    
    while (token != NULL && note_count < 12) {
        trim(token);
        notes[note_count] = strdup(token);
        note_count++;
        token = strtok(NULL, ", ");
    }

    if (note_count < 3) {
        printf("❌ Pas assez de notes pour identifier une gamme (minimum 3)\n");
        return;
    }

    printf("Notes détectées (%d): ", note_count);
    for (int i = 0; i < note_count; i++) {
        printf("%s", notes[i]);
        if (i < note_count - 1) printf(", ");
    }
    printf("\n");

    // Algorithme simple d'identification de gamme
    // Vérifier les gammes majeures et mineures principales
    struct {
        char *nom;
        char *pattern_notes[8];
        int confidence;
    } gammes_test[] = {
        {"Do majeur", {"Do", "Ré", "Mi", "Fa", "Sol", "La", "Si", "Do"}, 0},
        {"Do majeur", {"C", "D", "E", "F", "G", "A", "B", "C"}, 0},
        {"La mineur", {"La", "Si", "Do", "Ré", "Mi", "Fa", "Sol", "La"}, 0},
        {"La mineur", {"A", "B", "C", "D", "E", "F", "G", "A"}, 0},
        {"Sol majeur", {"Sol", "La", "Si", "Do", "Ré", "Mi", "Fa#", "Sol"}, 0},
        {"Sol majeur", {"G", "A", "B", "C", "D", "E", "F#", "G"}, 0},
        {"Ré majeur", {"Ré", "Mi", "Fa#", "Sol", "La", "Si", "Do#", "Ré"}, 0},
        {"Ré majeur", {"D", "E", "F#", "G", "A", "B", "C#", "D"}, 0}
    };

    int gamme_test_count = sizeof(gammes_test) / sizeof(gammes_test[0]);

    // Calculer la correspondance pour chaque gamme
    for (int g = 0; g < gamme_test_count; g++) {
        gammes_test[g].confidence = 0;
        
        for (int i = 0; i < note_count; i++) {
            for (int j = 0; j < 8; j++) {
                if (strcasecmp(notes[i], gammes_test[g].pattern_notes[j]) == 0) {
                    gammes_test[g].confidence++;
                    break;
                }
            }
        }
    }

    // Trouver la meilleure correspondance
    int best_match = 0;
    for (int i = 1; i < gamme_test_count; i++) {
        if (gammes_test[i].confidence > gammes_test[best_match].confidence) {
            best_match = i;
        }
    }

    printf("\n🎯 RÉSULTAT DE L'IDENTIFICATION:\n");
    
    if (gammes_test[best_match].confidence >= note_count * 0.6) {
        printf("Gamme identifiée: %s\n", gammes_test[best_match].nom);
        printf("Confiance: %d/%d notes correspondent (%.1f%%)\n", 
               gammes_test[best_match].confidence, note_count,
               (float)gammes_test[best_match].confidence / note_count * 100);
        
        if (strstr(gammes_test[best_match].nom, "majeur")) {
            printf("Type: Gamme majeure (sonorité joyeuse)\n");
        } else {
            printf("Type: Gamme mineure (sonorité mélancolique)\n");
        }
    } else {
        printf("❓ Gamme non identifiée avec certitude\n");
        printf("Meilleures correspondances:\n");
        
        // Trier et afficher les 3 meilleures
        for (int i = 0; i < 3 && i < gamme_test_count; i++) {
            int max_idx = 0;
            for (int j = 1; j < gamme_test_count; j++) {
                if (gammes_test[j].confidence > gammes_test[max_idx].confidence) {
                    max_idx = j;
                }
            }
            if (gammes_test[max_idx].confidence > 0) {
                printf("   %d. %s (%.1f%% correspondance)\n", i+1,
                       gammes_test[max_idx].nom,
                       (float)gammes_test[max_idx].confidence / note_count * 100);
            }
            gammes_test[max_idx].confidence = -1; // Marquer comme traité
        }
    }

    // Libérer la mémoire
    for (int i = 0; i < note_count; i++) {
        free(notes[i]);
    }

    printf("\n✅ Analyse musicale terminée!\n");
}

// Fonctions pour bases de données
int validate_db_id(char *id) {
    if (strlen(id) != 8) return 0;

    int digits = 0, letters = 0;
    for (int i = 0; i < 8; i++) {
        if (isdigit(id[i])) digits++;
        else if (isalpha(id[i])) letters++;
    }

    return (digits >= 4 && letters >= 2);
}

int find_database(char *id) {
    for (int i = 0; i < maya_db_count; i++) {
        if (strcmp(maya_databases[i].id, id) == 0 && maya_databases[i].active) {
            return i;
        }
    }
    return -1;
}

void handle_db(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.db - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    // Parser les arguments: id, données
    char *comma = strchr(start, ',');
    if (!comma) {
        maya_error("my.db nécessite deux arguments: id et données", 0);
        return;
    }

    *comma = '\0';
    char *db_id = start;
    char *data = comma + 1;

    trim(db_id);
    trim(data);

    // Enlever les guillemets
    if (db_id[0] == '\'' && db_id[strlen(db_id)-1] == '\'') {
        db_id[strlen(db_id)-1] = '\0';
        db_id++;
    }
    if (data[0] == '\'' && data[strlen(data)-1] == '\'') {
        data[strlen(data)-1] = '\0';
        data++;
    }

    if (!validate_db_id(db_id)) {
        maya_error("ID base de données invalide (8 caractères: min 4 chiffres, 2 lettres)", 0);
        return;
    }

    if (maya_db_count < MAX_DATABASES) {
        strcpy(maya_databases[maya_db_count].id, db_id);
        strcpy(maya_databases[maya_db_count].data, data);
        maya_databases[maya_db_count].active = 1;
        maya_db_count++;

        printf("🗄️ BASE DE DONNÉES MAYA CRÉÉE 🗄️\n");
        printf("ID: %s\n", db_id);
        printf("Données stockées: %s\n", data);
        printf("✅ Base de données active!\n");
    } else {
        maya_error("Trop de bases de données créées", 0);
    }
}

void handle_send_db(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.send.db - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    trim(start);
    if (start[0] == '\'' && start[strlen(start)-1] == '\'') {
        start[strlen(start)-1] = '\0';
        start++;
    }

    int db_index = find_database(start);
    if (db_index == -1) {
        maya_error("Base de données non trouvée", 0);
        return;
    }

    printf("📤 RÉCUPÉRATION BASE DE DONNÉES MAYA 📤\n");
    printf("ID: %s\n", maya_databases[db_index].id);
    printf("Données: %s\n", maya_databases[db_index].data);
    printf("Statut: Active\n");
}

void handle_supp_db(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.supp.db - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    trim(start);
    if (start[0] == '\'' && start[strlen(start)-1] == '\'') {
        start[strlen(start)-1] = '\0';
        start++;
    }

    int db_index = find_database(start);
    if (db_index == -1) {
        maya_error("Base de données non trouvée", 0);
        return;
    }

    maya_databases[db_index].active = 0;
    strcpy(maya_databases[db_index].data, "");

    printf("🗑️ BASE DE DONNÉES SUPPRIMÉE 🗑️\n");
    printf("ID: %s\n", start);
    printf("✅ Base de données nettoyée!\n");
}

void handle_util_db(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.util.db - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    trim(start);
    if (start[0] == '\'' && start[strlen(start)-1] == '\'') {
        start[strlen(start)-1] = '\0';
        start++;
    }

    int db_index = find_database(start);
    if (db_index == -1) {
        maya_error("Base de données non trouvée", 0);
        return;
    }

    printf("💾 UTILISATION BASE DE DONNÉES MAYA 💾\n");
    printf("ID: %s\n", maya_databases[db_index].id);
    printf("Données disponibles: %s\n", maya_databases[db_index].data);
    printf("🎮 Base de données prête pour vos jeux et simulations!\n");
}

// Fonction pour charger un package C réel (améliorée)
void load_maya_package(char *path) {
    printf("🔧 CHARGEMENT PACKAGE C MAYA SIMPLIFIÉ 🔧\n");
    printf("📂 Fichier source: %s\n", path);

    // Vérifier si le fichier source existe
    FILE *file = fopen(path, "r");
    if (!file) {
        printf("❌ Fichier source introuvable: %s\n", path);
        printf("💡 Conseil: Vérifiez le nom et l'emplacement du fichier\n");
        return;
    }
    fclose(file);

    if (maya_package_count >= MAX_PACKAGES) {
        printf("❌ Limite de packages atteinte (%d max)\n", MAX_PACKAGES);
        return;
    }

    // Générer le nom de la bibliothèque partagée unique
    char so_path[MAX_STRING_VALUE];
    snprintf(so_path, sizeof(so_path), "./maya_pkg_%d_%ld.so", 
             maya_package_count, time(NULL) % 10000);

    printf("🔨 Compilation en cours...\n");

    // Compiler le package C avec options étendues
    if (!compile_c_package(path, so_path)) {
        printf("❌ COMPILATION ÉCHOUÉE!\n");
        printf("🔍 Solutions possibles:\n");
        printf("   1. Vérifiez la syntaxe C\n");
        printf("   2. Assurez-vous que les fonctions commencent par 'may_package_'\n");
        printf("   3. Incluez les en-têtes nécessaires (#include <stdio.h>)\n");
        return;
    }

    // Charger la bibliothèque partagée
    printf("📦 Chargement de la bibliothèque...\n");
    void *handle = dlopen(so_path, RTLD_NOW | RTLD_GLOBAL);
    if (!handle) {
        printf("❌ Erreur de chargement dynamique:\n");
        printf("   %s\n", dlerror());
        printf("🔧 Le package a été compilé mais ne peut pas être chargé\n");
        return;
    }

    // Initialiser le package
    strcpy(maya_packages[maya_package_count].path, path);
    strcpy(maya_packages[maya_package_count].so_path, so_path);
    maya_packages[maya_package_count].handle = handle;
    maya_packages[maya_package_count].loaded = 1;
    maya_packages[maya_package_count].function_count = 0;

    // Détecter automatiquement les fonctions dans le fichier source
    printf("🔍 Détection automatique des fonctions...\n");
    char detected_functions[MAX_FUNCTIONS][MAX_VAR_NAME];
    int detected_count = detect_package_functions(path, detected_functions);

    if (detected_count == 0) {
        printf("⚠️ Aucune fonction détectée!\n");
        printf("💡 Les fonctions doivent commencer par 'may_package_'\n");
        printf("   Exemple: void may_package_ma_fonction() { ... }\n");
    }

    // Charger les fonctions détectées
    int loaded_count = 0;
    for (int i = 0; i < detected_count; i++) {
        void (*func)() = dlsym(handle, detected_functions[i]);
        if (func) {
            strcpy(maya_packages[maya_package_count].function_names[loaded_count], 
                   detected_functions[i]);
            maya_packages[maya_package_count].functions[loaded_count] = func;
            loaded_count++;
            printf("✅ Fonction chargée: %s\n", detected_functions[i]);
        } else {
            printf("⚠️ Fonction '%s' trouvée mais non chargeable: %s\n", 
                   detected_functions[i], dlerror());
        }
    }

    maya_packages[maya_package_count].function_count = loaded_count;

    printf("🎉 PACKAGE C CHARGÉ AVEC SUCCÈS!\n");
    printf("📊 Statistiques:\n");
    printf("   - Fonctions détectées: %d\n", detected_count);
    printf("   - Fonctions chargées: %d\n", loaded_count);
    printf("💡 Utilisez: may.package.nom_fonction()\n");
    printf("🚀 Package prêt à l'emploi!\n");

    maya_package_count++;
}

// Fonction pour trouver une fonction dans les packages
int find_package_function(char *name) {
    for (int i = 0; i < maya_package_count; i++) {
        if (!maya_packages[i].loaded) continue;

        for (int j = 0; j < maya_packages[i].function_count; j++) {
            if (strcmp(maya_packages[i].function_names[j], name) == 0) {
                return i * MAX_FUNCTIONS + j; // Index unique
            }
        }
    }
    return -1;
}

// Fonction pour obtenir le package et l'index local d'une fonction
void get_package_info(int func_index, int *package_index, int *local_index) {
    *package_index = func_index / MAX_FUNCTIONS;
    *local_index = func_index % MAX_FUNCTIONS;
}

// Fonction pour appeler une fonction de package
void call_package_function(char *function_name, char *args) {
    (void)args; // Marquer le paramètre comme volontairement inutilisé pour l'instant

    int func_index = find_package_function(function_name);

    if (func_index == -1) {
        printf("❌ Fonction de package non trouvée: %s\n", function_name);
        printf("🔍 Fonctions disponibles:\n");
        for (int i = 0; i < maya_package_count; i++) {
            if (maya_packages[i].loaded) {
                for (int j = 0; j < maya_packages[i].function_count; j++) {
                    printf("   - %s\n", maya_packages[i].function_names[j]);
                }
            }
        }
        return;
    }

    int package_index, local_index;
    get_package_info(func_index, &package_index, &local_index);

    printf("🔄 Exécution de la fonction C: %s\n", function_name);

    // Vérifier que la fonction est valide
    if (maya_packages[package_index].functions[local_index] != NULL) {
        // Appeler la fonction
        maya_packages[package_index].functions[local_index]();
        printf("✅ Fonction C exécutée avec succès!\n");
    } else {
        printf("❌ Fonction invalide dans le package\n");
    }
}

// Fonction pour trouver une fonction Maya
int find_maya_function(char *name) {
    for (int i = 0; i < maya_function_count; i++) {
        if (strcmp(maya_functions[i].name, name) == 0) {
            return i;
        }
    }
    return -1;
}

// Fonction pour exécuter une fonction Maya réutilisable
void execute_maya_function(char *function_name, char *args) {
    (void)args; // Marquer le paramètre comme volontairement inutilisé pour l'instant

    int func_index = find_maya_function(function_name);

    if (func_index == -1) {
        maya_error("Fonction Maya non trouvée", 0);
        return;
    }

    printf("🔄 Exécution de la fonction '%s'...\n", function_name);
    printf("📂 Source: %s\n", maya_functions[func_index].filename);

    // Exécuter le code de la fonction
    char *code = maya_functions[func_index].code;

    // Remplacer les paramètres si nécessaire
    char processed_code[MAX_STRING_VALUE * 10];
    strcpy(processed_code, code);

    // Séparer le code en lignes et les exécuter
    char *line = strtok(processed_code, ";");
    while (line != NULL) {
        trim(line);
        if (strlen(line) > 0) {
            interpret_line(line);
        }
        line = strtok(NULL, ";");
    }

    printf("✅ Fonction '%s' exécutée avec succès!\n", function_name);
}

// Fonction pour extraire et exécuter du code C depuis Maya
char* extract_c_code(char *maya_line) {
    static char c_code[MAX_STRING_VALUE * 5];
    char *start = strchr(maya_line, '(');
    char *end = strrchr(maya_line, ')');

    if (!start || !end) return NULL;

    start++;
    *end = '\0';

    if (start[0] == '\'' && start[strlen(start)-1] == '\'') {
        start[strlen(start)-1] = '\0';
        start++;
    }

    strcpy(c_code, start);
    return c_code;
}

void handle_execute_c(char *line) {
    char *c_code = extract_c_code(line);
    if (!c_code) {
        maya_error("Syntaxe incorrecte pour my.execute.c - parenthèses manquantes", 0);
        return;
    }

    printf("⚡ EXÉCUTION CODE C MAYA ⚡\n");
    printf("Code C à exécuter: %s\n", c_code);

    // Créer un fichier temporaire avec le code C
    FILE *temp_file = fopen("temp_maya_c.c", "w");
    if (temp_file) {
        fprintf(temp_file, "#include <stdio.h>\n#include <stdlib.h>\n#include <math.h>\n");
        fprintf(temp_file, "int main() {\n");
        fprintf(temp_file, "%s\n", c_code);
        fprintf(temp_file, "return 0;\n}\n");
        fclose(temp_file);

        // Compiler et exécuter
        int compile_result = system("gcc temp_maya_c.c -o temp_maya_c -lm 2>/dev/null");
        if (compile_result == 0) {
            printf("🔨 Compilation réussie!\n");
            printf("📤 Sortie du programme:\n");
            system("./temp_maya_c");
            // Nettoyer
            system("rm -f temp_maya_c temp_maya_c.c");
            printf("✅ Code C exécuté avec succès!\n");
        } else {
            printf("❌ Erreur de compilation du code C\n");
            system("rm -f temp_maya_c.c");
        }
    }
}

// Nouvelles simulations v5.0
void handle_simulation_monrobot(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.simulation.monrobot - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    printf("🤖 SIMULATION ROBOT PERSONNALISÉ MAYA 🤖\n");
    printf("Paramètres: %s\n", start);

    // Simulation de création de robot
    printf("🔧 Assemblage des composants...\n");
    usleep(800000);
    printf("🧠 Installation de l'IA...\n");
    usleep(600000);
    printf("⚡ Activation des systèmes...\n");
    usleep(400000);

    printf("✅ Robot créé avec succès!\n");
    printf("🗣️ Robot: 'Bonjour! Je suis votre robot personnalisé Maya!'\n");
    printf("🤝 Votre robot est prêt à interagir!\n");
}

void handle_simulation_quantique(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.simulation.quantique - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    printf("⚛️ SIMULATION UNIVERS QUANTIQUE MAYA ⚛️\n");
    printf("Paramètres: %s\n", start);

    printf("🌌 Initialisation de l'univers quantique...\n");
    usleep(1000000);
    printf("⚛️ Création des particules subatomiques...\n");
    usleep(800000);
    printf("🔬 Observation des phénomènes quantiques...\n");
    usleep(600000);

    srand(time(NULL));
    int scenario = rand() % 3;

    switch(scenario) {
        case 0:
            printf("🌟 Superposition quantique détectée!\n");
            printf("📊 État: |0⟩ + |1⟩\n");
            break;
        case 1:
            printf("🔗 Intrication quantique observée!\n");
            printf("📊 Particules liées instantanément\n");
            break;
        case 2:
            printf("🌊 Dualité onde-particule manifeste!\n");
            printf("📊 Comportement ondulatoire confirmé\n");
            break;
    }

    printf("🎯 Simulation quantique terminée!\n");
}

void handle_simulation_monunivers(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.simulation.monunivers - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    printf("🌍 CRÉATION UNIVERS PERSONNALISÉ MAYA 🌍\n");
    printf("Spécifications: %s\n", start);

    printf("💫 Big Bang de votre univers...\n");
    usleep(1200000);
    printf("⭐ Formation des premières étoiles...\n");
    usleep(1000000);
    printf("🪐 Création des planètes...\n");
    usleep(800000);
    printf("🌱 Apparition de la vie...\n");
    usleep(600000);

    printf("🎉 Votre univers est né!\n");
    printf("📊 Statistiques:\n");
    printf("   - 1 000 000 étoiles\n");
    printf("   - 500 000 planètes\n");
    printf("   - 42 civilisations\n");
    printf("🌟 Univers stable et en expansion!\n");
}

void handle_simulation_atomes(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.simulation.atomes - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    // Enlever les guillemets si présents
    if (start[0] == '\'' && start[strlen(start)-1] == '\'') {
        start[strlen(start)-1] = '\0';
        start++;
    }

    printf("⚛️ SIMULATION ATOMIQUE MAYA ⚛️\n");
    printf("Type d'atome: %s\n", start);

    // Base de données des éléments
    struct {
        char *nom;
        char *symbole;
        int protons;
        int neutrons;
        int electrons;
        char *proprietes;
    } elements[] = {
        {"Hydrogene", "H", 1, 0, 1, "Gaz le plus léger, inflammable"},
        {"Helium", "He", 2, 2, 2, "Gaz noble, très stable"},
        {"Lithium", "Li", 3, 4, 3, "Métal alcalin, très réactif"},
        {"Carbone", "C", 6, 6, 6, "Base de la vie organique"},
        {"Azote", "N", 7, 7, 7, "Gaz inerte, 78% de l'atmosphère"},
        {"Oxygene", "O", 8, 8, 8, "Vital pour la respiration"},
        {"Fluor", "F", 9, 10, 9, "Halogène très réactif"},
        {"Neon", "Ne", 10, 10, 10, "Gaz noble, éclairage"},
        {"Sodium", "Na", 11, 12, 11, "Métal alcalin, forme le sel"},
        {"Magnesium", "Mg", 12, 12, 12, "Métal léger, alliages"},
        {"Aluminium", "Al", 13, 14, 13, "Métal léger, anti-corrosion"},
        {"Silicium", "Si", 14, 14, 14, "Semi-conducteur, électronique"},
        {"Phosphore", "P", 15, 16, 15, "Essentiel pour l'ADN"},
        {"Soufre", "S", 16, 16, 16, "Forme des ponts disulfure"},
        {"Chlore", "Cl", 17, 18, 17, "Désinfectant, forme HCl"},
        {"Argon", "Ar", 18, 22, 18, "Gaz noble, soudage"},
        {"Potassium", "K", 19, 20, 19, "Électrolyte important"},
        {"Calcium", "Ca", 20, 20, 20, "Os et dents"},
        {"Fer", "Fe", 26, 30, 26, "Métal de construction"},
        {"Cuivre", "Cu", 29, 35, 29, "Conducteur électrique"},
        {"Zinc", "Zn", 30, 35, 30, "Anti-corrosion, galvanisation"},
        {"Argent", "Ag", 47, 61, 47, "Métal précieux, conducteur"},
        {"Or", "Au", 79, 118, 79, "Métal précieux, inoxydable"},
        {"Mercure", "Hg", 80, 121, 80, "Métal liquide toxique"},
        {"Plomb", "Pb", 82, 125, 82, "Métal lourd toxique"},
        {"Uranium", "U", 92, 146, 92, "Radioactif, énergie nucléaire"}
    };

    int element_count = sizeof(elements) / sizeof(elements[0]);
    int found = -1;

    // Rechercher l'élément
    for (int i = 0; i < element_count; i++) {
        if (strcasecmp(elements[i].nom, start) == 0 || 
            strcasecmp(elements[i].symbole, start) == 0) {
            found = i;
            break;
        }
    }

    if (found == -1) {
        printf("❌ Élément '%s' non trouvé dans la base de données\n", start);
        printf("💡 Éléments disponibles:\n");
        for (int i = 0; i < element_count && i < 10; i++) {
            printf("   - %s (%s)\n", elements[i].nom, elements[i].symbole);
        }
        printf("   ... et %d autres\n", element_count - 10);
        return;
    }

    printf("🔬 Analyse de la structure atomique...\n");
    usleep(600000);
    printf("⚡ Électrons en orbite...\n");
    usleep(400000);
    printf("🎯 Noyau stable détecté...\n");
    usleep(400000);

    printf("📊 RÉSULTATS DE LA SIMULATION:\n");
    printf("   Élément: %s (%s)\n", elements[found].nom, elements[found].symbole);
    printf("   Numéro atomique: %d\n", elements[found].protons);
    printf("   Protons: %d\n", elements[found].protons);
    printf("   Neutrons: %d\n", elements[found].neutrons);
    printf("   Électrons: %d\n", elements[found].electrons);
    printf("   Masse atomique: ~%d u\n", elements[found].protons + elements[found].neutrons);
    printf("   Propriétés: %s\n", elements[found].proprietes);

    // Configuration électronique simplifiée
    printf("   Configuration électronique: ");
    int electrons = elements[found].electrons;
    int shells[] = {2, 8, 18, 32}; // Capacité des couches K, L, M, N
    
    for (int shell = 0; shell < 4 && electrons > 0; shell++) {
        int e_in_shell = (electrons > shells[shell]) ? shells[shell] : electrons;
        printf("%d ", e_in_shell);
        electrons -= e_in_shell;
    }
    printf("\n");

    printf("✅ Simulation atomique terminée!\n");
}

void handle_simulation_timetravel(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.simulation.timetravel - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    int years = evaluate_expression_numeric(start);

    if (years < 1 || years > 15) {
        maya_error("Voyage temporel limité entre 1 et 15 ans", 0);
        return;
    }

    printf("⏰ MACHINE TEMPORELLE MAYA ⏰\n");
    printf("Voyage de %d années\n", years);

    printf("🔧 Calibrage de la machine temporelle...\n");
    usleep(800000);
    printf("⚡ Activation du flux temporel...\n");
    usleep(600000);
    printf("🌀 Traversée du continuum espace-temps...\n");
    usleep(1000000);

    // Générer un événement basé sur le nombre d'années
    if (years <= 5) {
        printf("🎯 ARRIVÉE DANS LE PASSÉ (%d ans):\n", years);
        printf("📱 Les smartphones n'existaient pas encore!\n");
        printf("🎵 La musique était différente...\n");
    } else if (years <= 10) {
        printf("🎯 ARRIVÉE DANS LE PASSÉ (%d ans):\n", years);
        printf("💻 Internet était plus lent!\n");
        printf("🎮 Les jeux vidéo étaient différents!\n");
    } else {
        printf("🎯 ARRIVÉE DANS LE FUTUR (%d ans):\n", years);
        printf("🚗 Les voitures volent!\n");
        printf("🤖 Les robots sont partout!\n");
    }

    printf("✅ Voyage temporel terminé! Retour au présent...\n");
}

void handle_simulation_fairy(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.simulation.fairy - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    printf("🧚‍♀️ CONTE DE FÉE MAYA 🧚‍♀️\n");
    printf("Histoire: %s\n", start);

    printf("📖 Il était une fois, dans un royaume lointain...\n");
    usleep(800000);
    printf("🏰 Une princesse vivait dans un château magique...\n");
    usleep(600000);
    printf("🐉 Un dragon gardait un trésor précieux...\n");
    usleep(600000);
    printf("⚔️ Un brave chevalier décida de sauver le royaume...\n");
    usleep(800000);

    srand(time(NULL));
    int ending = rand() % 3;

    switch(ending) {
        case 0:
            printf("👑 Le chevalier épousa la princesse!\n");
            printf("🎉 Ils vécurent heureux pourtoujours!\n");
            break;
        case 1:
            printf("🐉 Le dragon devint l'ami du chevalier!\n");
            printf("🤝 La paix régna sur le royaume!\n");
            break;
        case 2:
            printf("✨ La princesse révéla être une fée!\n");
            printf("🌟 Elle transforma le royaume en paradis!\n");
            break;
    }

    printf("📚 Fin de votre conte de fée personnalisé!\n");
}

void handle_simulation_vampire(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.simulation.vampire - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    printf("🧛‍♂️ HISTOIRE DE VAMPIRE MAYA 🧛‍♂️\n");
    printf("Récit: %s\n", start);

    printf("🌙 La nuit tombe sur la ville gothique...\n");
    usleep(800000);
    printf("🏰 Dans un château sombre, un vampire s'éveille...\n");
    usleep(600000);
    printf("🦇 Il se transforme en chauve-souris...\n");
    usleep(500000);
    printf("🌃 Il survole la ville à la recherche...\n");
    usleep(700000);

    srand(time(NULL));
    int scenario = rand() % 3;

    switch(scenario) {
        case 0:
            printf("💘 Il rencontre l'amour de sa vie!\n");
            printf("🌹 Une histoire d'amour éternelle commence...\n");
            break;
        case 1:
            printf("⚔️ Il affronte un chasseur de vampires!\n");
            printf("🛡️ Un combat épique s'engage!\n");
            break;
        case 2:
            printf("🧪 Il cherche une potion pour redevenir humain!\n");
            printf("🔬 Une quête mystique commence...\n");
            break;
    }

    printf("🌅 À l'aube, votre histoire de vampire se termine!\n");
}

void handle_simulation_sirene(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.simulation.sirene - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    printf("🧜‍♀️ RÉCIT DE SIRÈNE MAYA 🧜‍♀️\n");
    printf("Histoire: %s\n", start);

    printf("🌊 Dans les profondeurs de l'océan...\n");
    usleep(800000);
    printf("🐚 Une sirène chante sa mélodie enchanteresse...\n");
    usleep(600000);
    printf("🏖️ Un navigateur entend son chant...\n");
    usleep(500000);
    printf("⛵ Son navire se dirige vers les récifs...\n");
    usleep(700000);

    srand(time(NULL));
    int outcome = rand() % 3;

    switch(outcome) {
        case 0:
            printf("💙 La sirène tombe amoureuse du navigateur!\n");
            printf("🌟 Elle le sauve et devient humaine!\n");
            break;
        case 1:
            printf("🔱 Le roi des mers intervient!\n");
            printf("👑 Il accorde un vœu à la sirène!\n");
            break;
        case 2:
            printf("🌈 La sirène découvre un trésor caché!\n");
            printf("💎 Elle devient la gardienne des océans!\n");
            break;
    }

    printf("🐠 Votre récit de sirène se termine dans les vagues!\n");
}

void handle_simulation_monster(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.simulation.monster - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    printf("👹 SIMULATION MONSTRE MAYA 👹\n");
    printf("Créature: %s\n", start);

    printf("🌙 Une nuit d'orage, dans une forêt sombre...\n");
    usleep(800000);
    printf("👁️ Des yeux brillent dans l'obscurité...\n");
    usleep(600000);
    printf("🦶 Des pas lourds résonnent...\n");
    usleep(500000);
    printf("👹 Le monstre apparaît!\n");
    usleep(700000);

    srand(time(NULL));
    int monster_action = rand() % 3;

    switch(monster_action) {
        case 0:
            printf("😢 Le monstre est en réalité seul et triste!\n");
            printf("🤗 Il cherche juste un ami!\n");
            break;
        case 1:
            printf("🏃‍♂️ Le monstre poursuit les villageois!\n");
            printf("⚔️ Les héros se préparent au combat!\n");
            break;
        case 2:
            printf("🔮 Le monstre garde un secret mystique!\n");
            printf("📜 Une ancienne malédiction doit être brisée!\n");
            break;
    }

    printf("🌅 Votre histoire de monstre se termine à l'aube!\n");
}

// Fonctions d'exercices scolaires
void handle_exercice_create(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.exercice.create - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    printf("📚 CRÉATEUR D'EXERCICES MAYA 📚\n");
    printf("Sujet: %s\n", start);
    printf("📝 Exercice personnalisé créé!\n");
    printf("🎯 Utilisez my.input pour les réponses interactives!\n");
    printf("✅ Exercice prêt à être utilisé!\n");
}

// ========== NOUVELLES FONCTIONNALITÉS MAYA v6.0 ==========

// Fonction pour créer des chatbots personnalisés
void handle_create_robot(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.create.robot - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    // Parser les arguments: nom, réponses
    char *comma = strchr(start, ',');
    if (!comma) {
        maya_error("my.create.robot nécessite deux arguments: nom et réponses", 0);
        return;
    }

    *comma = '\0';
    char *robot_name = start;
    char *responses = comma + 1;

    trim(robot_name);
    trim(responses);

    // Enlever les guillemets
    if (robot_name[0] == '\'' && robot_name[strlen(robot_name)-1] == '\'') {
        robot_name[strlen(robot_name)-1] = '\0';
        robot_name++;
    }
    if (responses[0] == '\'' && responses[strlen(responses)-1] == '\'') {
        responses[strlen(responses)-1] = '\0';
        responses++;
    }

    printf("🤖 CRÉATION CHATBOT MAYA v6.0 🤖\n");
    printf("Nom du robot: %s\n", robot_name);
    printf("🧠 Installation de l'intelligence artificielle...\n");
    usleep(800000);
    printf("💬 Configuration des réponses conversationnelles...\n");
    usleep(600000);
    
    // Parser les réponses (format: mot1:réponse1,mot2:réponse2)
    printf("📚 Base de connaissances du robot:\n");
    char *token = strtok(responses, ",");
    int response_count = 0;
    
    while (token != NULL && response_count < 10) {
        char *colon = strchr(token, ':');
        if (colon) {
            *colon = '\0';
            char *keyword = token;
            char *response = colon + 1;
            trim(keyword);
            trim(response);
            printf("   🔹 %s → %s\n", keyword, response);
            response_count++;
        }
        token = strtok(NULL, ",");
    }

    printf("✅ Chatbot '%s' créé avec succès!\n", robot_name);
    printf("🎯 %d réponses programmées\n", response_count);
    printf("🗣️ %s: 'Bonjour! Je suis %s, votre assistant Maya!'\n", robot_name, robot_name);
}

// Fonction pour les boucles for
void handle_for_loop(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.for - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    // Parser les arguments: variable, début, fin
    char *comma1 = strchr(start, ',');
    if (!comma1) {
        maya_error("my.for nécessite trois arguments: variable, début, fin", 0);
        return;
    }

    *comma1 = '\0';
    char *var_name = start;
    char *rest = comma1 + 1;

    char *comma2 = strchr(rest, ',');
    if (!comma2) {
        maya_error("my.for nécessite trois arguments: variable, début, fin", 0);
        return;
    }

    *comma2 = '\0';
    char *debut_str = rest;
    char *fin_str = comma2 + 1;

    trim(var_name);
    trim(debut_str);
    trim(fin_str);

    int debut = evaluate_expression_numeric(debut_str);
    int fin = evaluate_expression_numeric(fin_str);

    printf("🔄 BOUCLE FOR MAYA v6.0 🔄\n");
    printf("Variable: %s, de %d à %d\n", var_name, debut, fin);

    for (int i = debut; i <= fin; i++) {
        printf("   Itération %s = %d\n", var_name, i);
        // Stocker la variable pour utilisation ultérieure
        char value_str[20];
        sprintf(value_str, "%d", i);
        set_variable(var_name, value_str, 1);
        usleep(200000); // Petite pause pour visualiser
    }

    printf("✅ Boucle for terminée!\n");
}

// Fonction pour les boucles while
void handle_while_loop(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.while - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    printf("🔄 BOUCLE WHILE MAYA v6.0 🔄\n");
    printf("Condition: %s\n", start);

    int iterations = 0;
    int max_iterations = 100; // Sécurité contre boucles infinies

    while (handle_condition(start) && iterations < max_iterations) {
        printf("   Itération %d - Condition vraie\n", iterations + 1);
        iterations++;
        usleep(300000);
        
        // Mise à jour simple pour éviter boucle infinie
        if (strstr(start, "x") && iterations == 1) {
            set_variable("x", "1", 1);
        }
    }

    if (iterations >= max_iterations) {
        printf("⚠️ Boucle arrêtée pour éviter l'infini (%d itérations max)\n", max_iterations);
    } else {
        printf("✅ Boucle while terminée après %d itérations\n", iterations);
    }
}

// Fonction pour les boucles simples
void handle_loop(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.loop - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    int repetitions = evaluate_expression_numeric(start);

    printf("🔄 BOUCLE SIMPLE MAYA v6.0 🔄\n");
    printf("Nombre de répétitions: %d\n", repetitions);

    for (int i = 1; i <= repetitions; i++) {
        printf("   🔁 Exécution %d/%d\n", i, repetitions);
        usleep(400000);
    }

    printf("✅ Boucle simple terminée!\n");
}

// Fonction pour les palettes créatives
void handle_palette(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.palette - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    // Parser les arguments: dessin, couleur
    char *comma = strchr(start, ',');
    if (!comma) {
        maya_error("my.palette nécessite deux arguments: dessin et couleur", 0);
        return;
    }

    *comma = '\0';
    char *dessin = start;
    char *couleur = comma + 1;

    trim(dessin);
    trim(couleur);

    // Enlever les guillemets
    if (dessin[0] == '\'' && dessin[strlen(dessin)-1] == '\'') {
        dessin[strlen(dessin)-1] = '\0';
        dessin++;
    }
    if (couleur[0] == '\'' && couleur[strlen(couleur)-1] == '\'') {
        couleur[strlen(couleur)-1] = '\0';
        couleur++;
    }

    printf("🎨 PALETTE CRÉATIVE MAYA v6.0 🎨\n");
    printf("Création: %s en %s\n", dessin, couleur);

    // Appliquer la couleur
    apply_color(couleur);

    if (strcmp(dessin, "mouton") == 0) {
        printf("    🐑\n");
        printf("   (  o.o)\n");
        printf("    > ^ <\n");
        printf("   /_____\\\n");
        printf("🐑 Mouton %s créé!\n", couleur);
    }
    else if (strcmp(dessin, "oiseau") == 0) {
        printf("     🐦\n");
        printf("    <(^v^)>\n");
        printf("     /|\\\n");
        printf("    /   \\\n");
        printf("🐦 Oiseau %s créé!\n", couleur);
    }
    else if (strcmp(dessin, "abeille") == 0) {
        printf("     🐝\n");
        printf("   .-\"\"\"-.  \n");
        printf("  /       \\\n");
        printf(" | o     o |\n");
        printf("  \\   ∩   /\n");
        printf("   '-...-'\n");
        printf("🐝 Abeille %s créée!\n", couleur);
    }
    else if (strcmp(dessin, "dragon") == 0) {
        printf("     🐉\n");
        printf("    /~\\\n");
        printf("   (  o.o )\n");
        printf("    > ^ <\n");
        printf("   /_____\\\n");
        printf("🐉 Dragon %s créé!\n", couleur);
    }
    else {
        printf("✨ Dessin personnalisé '%s' en %s\n", dessin, couleur);
        printf("🎨 [Votre imagination prend forme!]\n");
    }

    reset_color();
    printf("🌈 Création artistique terminée!\n");
}

// Fonction pour créer des jeux personnalisés
void handle_owngame(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.owngame - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    // Enlever les guillemets
    if (start[0] == '\'' && start[strlen(start)-1] == '\'') {
        start[strlen(start)-1] = '\0';
        start++;
    }

    printf("🎮 CRÉATEUR DE JEUX MAYA v6.0 🎮\n");
    printf("Concept de jeu: %s\n", start);

    printf("🔧 Génération du moteur de jeu...\n");
    usleep(800000);
    printf("🎨 Création des graphismes ASCII...\n");
    usleep(600000);
    printf("🎵 Composition de la bande sonore...\n");
    usleep(500000);
    printf("🎯 Programmation de la logique de jeu...\n");
    usleep(700000);

    printf("🌟 ===== VOTRE JEU PERSONNALISÉ ===== 🌟\n");
    printf("Titre: %s\n", start);
    printf("Genre: Aventure Maya Interactive\n");
    printf("Joueurs: 1-∞\n");
    printf("Difficulté: Ajustable\n");
    printf("\n🎲 COMMANDES DU JEU:\n");
    printf("   [W] - Avancer\n");
    printf("   [S] - Reculer\n");
    printf("   [A] - Gauche\n");
    printf("   [D] - Droite\n");
    printf("   [E] - Interagir\n");
    printf("   [I] - Inventaire\n");
    printf("   [Q] - Quitter\n");

    printf("\n🏆 OBJECTIFS:\n");
    printf("   - Explorez le monde de Maya\n");
    printf("   - Résolvez les énigmes\n");
    printf("   - Collectez les trésors\n");
    printf("   - Devenez le maître du code!\n");

    printf("\n✅ Jeu '%s' créé avec succès!\n", start);
    printf("🎮 Prêt à jouer! Que l'aventure commence!\n");
}

// Fonction pour modifier la console dynamiquement
void handle_modifie_console(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.modifie.console - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    // Parser les arguments: message_original, délai, message_modifié
    char *comma1 = strchr(start, ',');
    if (!comma1) {
        maya_error("my.modifie.console nécessite trois arguments", 0);
        return;
    }

    *comma1 = '\0';
    char *message_original = start;
    char *rest = comma1 + 1;

    char *comma2 = strchr(rest, ',');
    if (!comma2) {
        maya_error("my.modifie.console nécessite trois arguments", 0);
        return;
    }

    *comma2 = '\0';
    char *delai_str = rest;
    char *message_modifie = comma2 + 1;

    trim(message_original);
    trim(delai_str);
    trim(message_modifie);

    // Enlever les guillemets
    if (message_original[0] == '\'' && message_original[strlen(message_original)-1] == '\'') {
        message_original[strlen(message_original)-1] = '\0';
        message_original++;
    }
    if (message_modifie[0] == '\'' && message_modifie[strlen(message_modifie)-1] == '\'') {
        message_modifie[strlen(message_modifie)-1] = '\0';
        message_modifie++;
    }

    int delai = evaluate_expression_numeric(delai_str);

    printf("💬 MODIFICATION CONSOLE MAYA v6.0 💬\n");
    printf("%s", message_original);
    fflush(stdout);

    // Attendre le délai
    usleep(delai * 1000);

    // Effacer la ligne précédente et afficher le nouveau message
    printf("\r\033[K%s\n", message_modifie);
    printf("✅ Modification console terminée!\n");
}

// Fonction pour créer des menus interactifs
void handle_interactive(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.interactive - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    // Enlever les guillemets
    if (start[0] == '\'' && start[strlen(start)-1] == '\'') {
        start[strlen(start)-1] = '\0';
        start++;
    }

    printf("📋 MENU INTERACTIF MAYA v6.0 📋\n");
    printf("╔══════════════════════════════════════╗\n");
    printf("║            %s            ║\n", start);
    printf("╠══════════════════════════════════════╣\n");
    printf("║  [1] 🎮 Jouer                        ║\n");
    printf("║  [2] ⚙️  Options                     ║\n");
    printf("║  [3] 📊 Statistiques                 ║\n");
    printf("║  [4] 🎨 Personnalisation             ║\n");
    printf("║  [5] 💾 Sauvegarder                  ║\n");
    printf("║  [6] 📚 Aide                         ║\n");
    printf("║  [7] 🚪 Quitter                      ║\n");
    printf("╚══════════════════════════════════════╝\n");
    printf("👆 Choisissez une option (1-7): ");

    char choice[10];
    if (fgets(choice, sizeof(choice), stdin)) {
        int option = atoi(choice);
        switch(option) {
            case 1:
                printf("🎮 Lancement du jeu...\n");
                break;
            case 2:
                printf("⚙️ Menu des options ouvert\n");
                break;
            case 3:
                printf("📊 Affichage des statistiques\n");
                break;
            case 4:
                printf("🎨 Menu de personnalisation\n");
                break;
            case 5:
                printf("💾 Sauvegarde en cours...\n");
                break;
            case 6:
                printf("📚 Aide Maya v6.0 affichée\n");
                break;
            case 7:
                printf("🚪 Merci d'avoir utilisé Maya!\n");
                break;
            default:
                printf("❌ Option invalide\n");
        }
    }
    printf("✅ Menu interactif terminé!\n");
}

// Système d'inventaire dynamique avec gestion complexe
typedef struct {
    char nom[50];
    char type[30];
    char description[100];
    int quantite;
    int actif;
} InventaireItem;

static InventaireItem inventaire_maya[50];
static int inventaire_count = 0;

void handle_inventaire(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        // Si pas de parenthèses, c'est un affichage simple
        printf("🎒 INVENTAIRE MAYA v6.0 🎒\n");
        printf("════════════════════════════════════\n");
        
        if (inventaire_count == 0) {
            printf("Inventaire vide\n");
        } else {
            for (int i = 0; i < inventaire_count; i++) {
                if (inventaire_maya[i].actif) {
                    printf("[%d] %s (%s) x%d\n", i+1, 
                           inventaire_maya[i].nom,
                           inventaire_maya[i].type,
                           inventaire_maya[i].quantite);
                    printf("    Description: %s\n", inventaire_maya[i].description);
                }
            }
        }
        printf("════════════════════════════════════\n");
        return;
    }

    start++;
    *end = '\0';

    // Parser les arguments
    char *args[4];
    int arg_count = 0;
    char *token = strtok(start, ",");
    
    while (token != NULL && arg_count < 4) {
        trim(token);
        if (token[0] == '\'' && token[strlen(token)-1] == '\'') {
            token[strlen(token)-1] = '\0';
            token++;
        }
        args[arg_count] = strdup(token);
        arg_count++;
        token = strtok(NULL, ",");
    }

    if (arg_count < 2) {
        maya_error("my.inventaire nécessite au moins action et nom", 0);
        return;
    }

    char *action = args[0];
    char *nom = args[1];

    printf("🎒 INVENTAIRE MAYA v6.0 - %s 🎒\n", action);

    if (strcmp(action, "ajouter") == 0) {
        if (arg_count < 4) {
            maya_error("ajouter nécessite: nom, type, description", 0);
            return;
        }

        char *type = args[2];
        char *description = args[3];

        if (inventaire_count < 50) {
            strcpy(inventaire_maya[inventaire_count].nom, nom);
            strcpy(inventaire_maya[inventaire_count].type, type);
            strcpy(inventaire_maya[inventaire_count].description, description);
            inventaire_maya[inventaire_count].quantite = 1;
            inventaire_maya[inventaire_count].actif = 1;
            inventaire_count++;

            printf("✅ %s ajouté à l'inventaire!\n", nom);
            printf("Type: %s\n", type);
            printf("Description: %s\n", description);
        } else {
            printf("❌ Inventaire plein!\n");
        }
    }
    else if (strcmp(action, "utiliser") == 0) {
        int trouve = 0;
        for (int i = 0; i < inventaire_count; i++) {
            if (inventaire_maya[i].actif && strcmp(inventaire_maya[i].nom, nom) == 0) {
                printf("⚡ Utilisation de: %s\n", nom);
                printf("📝 %s\n", inventaire_maya[i].description);
                
                inventaire_maya[i].quantite--;
                if (inventaire_maya[i].quantite <= 0) {
                    inventaire_maya[i].actif = 0;
                    printf("💨 %s consommé et retiré de l'inventaire\n", nom);
                } else {
                    printf("📦 Quantité restante: %d\n", inventaire_maya[i].quantite);
                }
                trouve = 1;
                break;
            }
        }
        if (!trouve) {
            printf("❌ %s non trouvé dans l'inventaire\n", nom);
        }
    }
    else if (strcmp(action, "supprimer") == 0) {
        int trouve = 0;
        for (int i = 0; i < inventaire_count; i++) {
            if (inventaire_maya[i].actif && strcmp(inventaire_maya[i].nom, nom) == 0) {
                inventaire_maya[i].actif = 0;
                printf("🗑️ %s supprimé de l'inventaire\n", nom);
                trouve = 1;
                break;
            }
        }
        if (!trouve) {
            printf("❌ %s non trouvé dans l'inventaire\n", nom);
        }
    }
    else {
        printf("❌ Action non reconnue: %s\n", action);
        printf("Actions disponibles: ajouter, utiliser, supprimer\n");
    }

    // Libérer la mémoire
    for (int i = 0; i < arg_count; i++) {
        free(args[i]);
    }
}

// Fonction pour les récits d'histoires
void handle_histoire_recit(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.histoire.recit - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    // Enlever les guillemets
    if (start[0] == '\'' && start[strlen(start)-1] == '\'') {
        start[strlen(start)-1] = '\0';
        start++;
    }

    printf("📖 RÉCIT MAYA v6.0 📖\n");
    printf("\033[95m"); // Couleur rose pour les histoires
    printf("════════════════════════════════════════════════════════════════\n");
    printf("                          📚 HISTOIRE 📚\n");
    printf("════════════════════════════════════════════════════════════════\n");
    printf("\n");
    
    // Affichage avec effet de machine à écrire
    for (size_t i = 0; i < strlen(start); i++) {
        printf("%c", start[i]);
        fflush(stdout);
        usleep(50000); // 50ms entre chaque caractère
    }
    
    printf("\n\n");
    printf("════════════════════════════════════════════════════════════════\n");
    printf("\033[0m"); // Reset couleur
    printf("✨ Histoire racontée avec la magie de Maya!\n");
}

// Fonction pour les fins d'histoires
void handle_histoire_end(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.histoire.end - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    // Enlever les guillemets
    if (start[0] == '\'' && start[strlen(start)-1] == '\'') {
        start[strlen(start)-1] = '\0';
        start++;
    }

    printf("🎬 FIN DE L'HISTOIRE MAYA v6.0 🎬\n");
    printf("\033[31m"); // Couleur rouge pour la fin
    printf("╔══════════════════════════════════════════════════════════════╗\n");
    printf("║                        🎭 ÉPILOGUE 🎭                        ║\n");
    printf("╠══════════════════════════════════════════════════════════════╣\n");
    printf("║                                                              ║\n");
    
    // Centrer le texte
    int text_len = strlen(start);
    int padding = (62 - text_len) / 2;
    printf("║");
    for (int i = 0; i < padding; i++) printf(" ");
    printf("%s", start);
    for (int i = 0; i < (62 - text_len - padding); i++) printf(" ");
    printf("║\n");
    
    printf("║                                                              ║\n");
    printf("╚══════════════════════════════════════════════════════════════╝\n");
    printf("\033[0m"); // Reset couleur
    
    printf("\n🌟 THE END 🌟\n");
    printf("👏 Bravo! Histoire terminée avec panache!\n");
    printf("📚 Merci d'avoir utilisé le conteur Maya v6.0!\n");
}

// Fonction pour créer des animaux personnalisés
void handle_own_pet(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.own.pet - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    // Enlever les guillemets
    if (start[0] == '\'' && start[strlen(start)-1] == '\'') {
        start[strlen(start)-1] = '\0';
        start++;
    }

    printf("🐾 CRÉATION D'ANIMAL PERSONNALISÉ MAYA v6.0 🐾\n");
    printf("Histoire de l'animal: %s\n", start);

    printf("🧬 Génération de l'ADN unique...\n");
    usleep(800000);
    printf("🎨 Création de l'apparence...\n");
    usleep(600000);
    printf("🧠 Développement de la personnalité...\n");
    usleep(500000);
    printf("⚡ Insufflation de la vie...\n");
    usleep(700000);

    // Générer des caractéristiques aléatoires
    srand(time(NULL));
    char *couleurs[] = {"Doré", "Argenté", "Cristallin", "Arc-en-ciel", "Étoilé", "Mystique"};
    char *tailles[] = {"Minuscule", "Petit", "Moyen", "Grand", "Gigantesque", "Légendaire"};
    char *pouvoirs[] = {"Télépathie", "Vol", "Invisibilité", "Téléportation", "Magie", "Sagesse infinie"};

    int couleur_idx = rand() % 6;
    int taille_idx = rand() % 6;
    int pouvoir_idx = rand() % 6;

    printf("✨ VOTRE ANIMAL PERSONNALISÉ EST NÉ! ✨\n");
    printf("═══════════════════════════════════════\n");
    printf("🏷️  Histoire: %s\n", start);
    printf("🌈 Couleur: %s\n", couleurs[couleur_idx]);
    printf("📏 Taille: %s\n", tailles[taille_idx]);
    printf("⚡ Pouvoir: %s\n", pouvoirs[pouvoir_idx]);
    printf("❤️  Niveau d'affection: ∞\n");
    printf("🍃 Habitat: Monde de Maya\n");
    printf("🎵 Cri: *Sons magiques indescriptibles*\n");
    printf("═══════════════════════════════════════\n");
    printf("🐾 Votre compagnon Maya est prêt à vous accompagner dans vos aventures!\n");
}

// Fonction pour créer des titans personnalisés
void handle_own_titan(char *line) {
    char *start = strchr(line, '(');
    char *end = strrchr(line, ')');

    if (!start || !end) {
        maya_error("Syntaxe incorrecte pour my.own.titan - parenthèses manquantes", 0);
        return;
    }

    start++;
    *end = '\0';

    // Enlever les guillemets
    if (start[0] == '\'' && start[strlen(start)-1] == '\'') {
        start[strlen(start)-1] = '\0';
        start++;
    }

    printf("⚡ CRÉATION DE TITAN LÉGENDAIRE MAYA v6.0 ⚡\n");
    printf("Légende du titan: %s\n", start);

    printf("🌋 Éveil des forces primordiales...\n");
    usleep(1000000);
    printf("⚡ Forge du corps titanesque...\n");
    usleep(800000);
    printf("🔥 Allumage de l'âme immortelle...\n");
    usleep(600000);
    printf("👑 Couronnement du pouvoir ultime...\n");
    usleep(900000);

    // Générer des caractéristiques épiques
    srand(time(NULL));
    char *elements[] = {"Foudre", "Lave", "Glace Éternelle", "Vent Cosmique", "Terre Sacrée", "Lumière Pure"};
    char *armes[] = {"Épée Dimensionnelle", "Marteau des Mondes", "Arc Stellaire", "Bâton du Temps", "Griffes d'Éternité", "Livre des Sorts"};
    char *domaines[] = {"Montagnes Flottantes", "Océan de Magma", "Forêt Cristalline", "Désert de Sable d'Or", "Ville des Nuages", "Royaume des Codes"};

    int element_idx = rand() % 6;
    int arme_idx = rand() % 6;
    int domaine_idx = rand() % 6;
    int puissance = 9000 + rand() % 1000;

    printf("👑 VOTRE TITAN LÉGENDAIRE S'ÉLÈVE! 👑\n");
    printf("═══════════════════════════════════════════════════\n");
    printf("📜 Légende: %s\n", start);
    printf("🌟 Élément: %s\n", elements[element_idx]);
    printf("⚔️  Arme: %s\n", armes[arme_idx]);
    printf("🏰 Domaine: %s\n", domaines[domaine_idx]);
    printf("💪 Niveau de puissance: %d\n", puissance);
    printf("⏳ Âge: Depuis l'aube des temps\n");
    printf("🎯 Mission: Protéger l'univers Maya\n");
    printf("💀 Ennemis vaincus: Innombrables\n");
    printf("═══════════════════════════════════════════════════\n");
    printf("⚡ Le titan %s domine désormais l'univers Maya!\n", start);
}

// Fonction pour générer des statistiques d'animaux
void handle_nombre_pet(char *line) {
    (void)line; // Pas de paramètres

    printf("🐾 GÉNÉRATEUR DE STATS D'ANIMAUX MAYA v6.0 🐾\n");

    srand(time(NULL));
    
    // Générer des statistiques d'animal
    int vie = 50 + rand() % 150;
    int force = 20 + rand() % 80;
    int vitesse = 30 + rand() % 70;
    int intelligence = 40 + rand() % 60;
    int magie = 10 + rand() % 90;
    int loyaute = 70 + rand() % 30;

    printf("📊 STATISTIQUES GÉNÉRÉES:\n");
    printf("════════════════════════════\n");
    printf("❤️  Points de Vie: %d\n", vie);
    printf("💪 Force: %d\n", force);
    printf("💨 Vitesse: %d\n", vitesse);
    printf("🧠 Intelligence: %d\n", intelligence);
    printf("✨ Pouvoir Magique: %d\n", magie);
    printf("💖 Loyauté: %d\n", loyaute);
    printf("════════════════════════════\n");
    
    // Calcul du score total
    int total = vie + force + vitesse + intelligence + magie + loyaute;
    printf("🏆 Score Total: %d points\n", total);
    
    if (total > 400) {
        printf("⭐ RANG: Légendaire!\n");
    } else if (total > 300) {
        printf("🌟 RANG: Épique!\n");
    } else if (total > 200) {
        printf("✨ RANG: Rare!\n");
    } else {
        printf("💫 RANG: Commun\n");
    }
    
    printf("🎯 Animal généré avec succès!\n");
}

// Fonction pour générer des statistiques de titans
void handle_nombre_titan(char *line) {
    (void)line; // Pas de paramètres

    printf("⚡ GÉNÉRATEUR DE STATS DE TITANS MAYA v6.0 ⚡\n");

    srand(time(NULL));
    
    // Générer des statistiques épiques
    int puissance = 5000 + rand() % 5000;
    int defense = 3000 + rand() % 4000;
    int vitesse = 1000 + rand() % 3000;
    int magie = 4000 + rand() % 6000;
    int sagesse = 2000 + rand() % 8000;
    int destruction = 6000 + rand() % 4000;

    printf("📊 STATISTIQUES TITANESQUES:\n");
    printf("════════════════════════════════════\n");
    printf("💥 Puissance Destructrice: %d\n", puissance);
    printf("🛡️  Défense Absolue: %d\n", defense);
    printf("⚡ Vitesse Cosmique: %d\n", vitesse);
    printf("🌟 Magie Primordiale: %d\n", magie);
    printf("📚 Sagesse Éternelle: %d\n", sagesse);
    printf("💀 Capacité de Destruction: %d\n", destruction);
    printf("════════════════════════════════════\n");
    
    // Calcul du score épique
    int total = (puissance + defense + vitesse + magie + sagesse + destruction) / 100;
    printf("👑 Score Titanesque: %d points\n", total);
    
    if (total > 250) {
        printf("🌌 CLASSE: Titan Universel!\n");
        printf("🎯 Capable de créer et détruire des galaxies!\n");
    } else if (total > 200) {
        printf("🔥 CLASSE: Titan Légendaire!\n");
        printf("🎯 Maître de plusieurs dimensions!\n");
    } else if (total > 150) {
        printf("⚡ CLASSE: Titan Épique!\n");
        printf("🎯 Gardien de mondes entiers!\n");
    } else {
        printf("💪 CLASSE: Titan Guerrier!\n");
        printf("🎯 Protecteur de civilisations!\n");
    }
    
    printf("👑 Titan généré avec une puissance divine!\n");
}

void handle_exercice_gest_pgi(char *line) {
    (void)line; // Marquer le paramètre comme volontairement inutilisé

    printf("💼 EXERCICE PGI MAYA - BAC STMG 💼\n");
    printf("📊 Progiciel de Gestion Intégrée\n");
    printf("❓ Question: Quels sont les modules d'un PGI?\n");
    printf("💡 Réponse attendue: Comptabilité, RH, Ventes, Stocks, etc.\n");
    printf("🎓 Niveau: Terminale STMG\n");
}

void handle_exercice_gest_treso(char *line) {
    (void)line; // Marquer le paramètre comme volontairement inutilisé

    printf("💰 EXERCICE TRÉSORERIE MAYA - BAC STMG 💰\n");
    printf("📈 Gestion financière\n");
    printf("❓ Calculez: FRNG = Capitaux permanents - Actif immobilisé\n");
    printf("❓ BFR = Actif circulant - Passif circulant\n");
    printf("❓ Trésorerie = FRNG - BFR\n");
    printf("🎓 Exercice de gestion niveau BAC STMG\n");
}

void handle_exercice_math(char *line) {
    (void)line; // Marquer le paramètre comme volontairement inutilisé

    printf("🔢 EXERCICE MATHÉMATIQUES MAYA 🔢\n");
    printf("📐 Mathématiques BAC Général/STMG\n");
    printf("❓ Question: Résolvez l'équation du second degré\n");
    printf("📝 ax² + bx + c = 0\n");
    printf("💡 Utilisez Δ = b² - 4ac\n");
    printf("🎓 Niveau: Première/Terminale\n");
}

void handle_exercice_histoire(char *line) {
    (void)line; // Marquer le paramètre comme volontairement inutilisé

    printf("🏛️ EXERCICE HISTOIRE-GÉO MAYA 🏛️\n");
    printf("🌍 Histoire-Géographie\n");
    printf("❓ Question: Quelles sont les causes de la Première Guerre mondiale?\n");
    printf("📚 Thèmes: Nationalisme, impérialisme, alliances\n");
    printf("🎓 Niveau: BAC Général/STMG\n");
}

void handle_exercice_mana(char *line) {
    (void)line; // Marquer le paramètre comme volontairement inutilisé

    printf("👔 EXERCICE MANAGEMENT MAYA - BAC STMG 👔\n");
    printf("🏢 Sciences de gestion et management\n");
    printf("❓ Question: Définissez les styles de management\n");
    printf("💼 Réponses: Directif, Persuasif, Participatif, Délégatif\n");
    printf("🎓 Niveau: Terminale STMG\n");
}

// Fonction principale pour interpréter une ligne
void interpret_line(char *line) {
    trim(line);

    if (strlen(line) == 0 || line[0] == '#') return; // Ligne vide ou commentaire

    // Gestion des blocs my.alors et my.autre
    if (strchr(line, '{')) {
        if (strstr(line, "my.alors")) {
            in_alors_block = 1;
            in_autre_block = 0;
            skip_current_block = !last_condition_result;
            return;
        } else if (strstr(line, "my.autre")) {
            in_alors_block = 0;
            in_autre_block = 1;
            skip_current_block = last_condition_result;
            return;
        }
    }

    // Fin de bloc
    if (strchr(line, '}')) {
        in_alors_block = 0;
        in_autre_block = 0;
        skip_current_block = 0;
        return;
    }

    // Si on est dans un bloc à ignorer, ne pas exécuter
    if (skip_current_block) {
        return;
    }

    // Structure modulaire pour faciliter l'ajout de nouvelles fonctionnalités
    if (strstr(line, "my.console")) {
        handle_console(line);
    }
    else if (strstr(line, "my.math.median")) {
        handle_math_median(line);
    }
    else if (strstr(line, "my.math.moyenne")) {
        handle_math_moyenne(line);
    }
    else if (strstr(line, "my.math.cube")) {
        handle_math_cube(line);
    }
    else if (strstr(line, "my.math.carre")) {
        handle_math_carre(line);
    }
    else if (strstr(line, "my.math.racine")) {
        handle_math_racine(line);
    }
    else if (strstr(line, "my.math.degres")) {
        handle_math_degres(line);
    }
    else if (strstr(line, "my.math")) {
        handle_math(line);
    }
    else if (strstr(line, "my.thales")) {
        handle_thales(line);
    }
    else if (strstr(line, "my.pytha")) {
        handle_pytha(line);
    }
    else if (strstr(line, "my.rythme.convertir")) {
        handle_rythme_convertir(line);
    }
    else if (strstr(line, "my.renvoie.gamme")) {
        handle_renvoie_gamme(line);
    }
    else if (strstr(line, "my.obtenir.gamme")) {
        handle_obtenir_gamme(line);
    }
    else if (strstr(line, "my.send.db")) {
        handle_send_db(line);
    }
    else if (strstr(line, "my.supp.db")) {
        handle_supp_db(line);
    }
    else if (strstr(line, "my.util.db")) {
        handle_util_db(line);
    }
    else if (strstr(line, "my.db")) {
        handle_db(line);
    }
    else if (strstr(line, "my.execute.c")) {
        handle_execute_c(line);
    }
    else if (strstr(line, "my.variable")) {
        handle_variable(line);
    }
    else if (strstr(line, "my.input")) {
        handle_input(line);
    }
    else if (strstr(line, "my.delai")) {
        handle_delai(line);
    }
    else if (strstr(line, "my.draw")) {
        handle_draw(line);
    }
    else if (strstr(line, "my.jolie.txt")) {
        handle_jolie_txt(line);
    }
    else if (strstr(line, "my.color.console")) {
        handle_color_console(line);
    }
    else if (strstr(line, "my.nombre.random")) {
        handle_nombre_random(line);
    }
    else if (strstr(line, "my.random.txt")) {
        handle_random_txt(line);
    }
    else if (strstr(line, "my.quizz")) {
        handle_quizz(line);
    }
    else if (strstr(line, "my.dice")) {
        handle_dice(line);
    }
    else if (strstr(line, "my.puissance4")) {
        handle_puissance4(line);
    }
    else if (strstr(line, "my.pendu")) {
        handle_pendu(line);
    }
    else if (strstr(line, "my.worldgame")) {
        handle_worldgame(line);
    }
    else if (strstr(line, "my.rock.leaf")) {
        handle_rock_leaf(line);
    }
    else if (strstr(line, "my.devine.number")) {
        handle_devine_number(line);
    }
    else if (strstr(line, "my.snake")) {
        handle_snake(line);
    }
    else if (strstr(line, "my.tictac")) {
        handle_tictac(line);
    }
    else if (strstr(line, "my.memory")) {
        handle_memory(line);
    }
    else if (strstr(line, "my.simulation.bac")) {
        handle_simulation_bac(line);
    }
    else if (strstr(line, "my.simulation.combat")) {
        handle_simulation_combat(line);
    }
    else if (strstr(line, "my.simulation.sciences")) {
        handle_simulation_sciences(line);
    }
    else if (strstr(line, "my.simulation.clone")) {
        handle_simulation_clone(line);
    }
    else if (strstr(line, "my.simulation.tech")) {
        handle_simulation_tech(line);
    }
    else if (strstr(line, "my.simulation.ia")) {
        handle_simulation_ia(line);
    }
    else if (strstr(line, "my.simulation.conscient")) {
        handle_simulation_conscient(line);
    }
    else if (strstr(line, "my.simulation.iawork")) {
        handle_simulation_iawork(line);
    }
    else if (strstr(line, "my.simulation.monrobot")) {
        handle_simulation_monrobot(line);
    }
    else if (strstr(line, "my.simulation.quantique")) {
        handle_simulation_quantique(line);
    }
    else if (strstr(line, "my.simulation.monunivers")) {
        handle_simulation_monunivers(line);
    }
    else if (strstr(line, "my.simulation.atomes")) {
        handle_simulation_atomes(line);
    }
    else if (strstr(line, "my.simulation.timetravel")) {
        handle_simulation_timetravel(line);
    }
    else if (strstr(line, "my.simulation.fairy")) {
        handle_simulation_fairy(line);
    }
    else if (strstr(line, "my.simulation.vampire")) {
        handle_simulation_vampire(line);
    }
    else if (strstr(line, "my.simulation.sirene")) {
        handle_simulation_sirene(line);
    }
    else if (strstr(line, "my.simulation.monster")) {
        handle_simulation_monster(line);
    }
    else if (strstr(line, "my.exercice.gest.pgi")) {
        handle_exercice_gest_pgi(line);
    }
    else if (strstr(line, "my.exercice.gest.treso")) {
        handle_exercice_gest_treso(line);
    }
    else if (strstr(line, "my.exercice.math")) {
        handle_exercice_math(line);
    }
    else if (strstr(line, "my.exercice.histoire")) {
        handle_exercice_histoire(line);
    }
    else if (strstr(line, "my.exercice.mana")) {
        handle_exercice_mana(line);
    }
    else if (strstr(line, "my.exercice.create")) {
        handle_exercice_create(line);
    }
    // Nouvelles fonctionnalités v6.0
    else if (strstr(line, "my.create.robot")) {
        handle_create_robot(line);
    }
    else if (strstr(line, "my.for")) {
        handle_for_loop(line);
    }
    else if (strstr(line, "my.while")) {
        handle_while_loop(line);
    }
    else if (strstr(line, "my.loop")) {
        handle_loop(line);
    }
    else if (strstr(line, "my.palette")) {
        handle_palette(line);
    }
    else if (strstr(line, "my.owngame")) {
        handle_owngame(line);
    }
    else if (strstr(line, "my.modifie.console")) {
        handle_modifie_console(line);
    }
    else if (strstr(line, "my.interactive")) {
        handle_interactive(line);
    }
    else if (strstr(line, "my.inventaire")) {
        handle_inventaire(line);
    }
    else if (strstr(line, "my.histoire.recit")) {
        handle_histoire_recit(line);
    }
    else if (strstr(line, "my.histoire.end")) {
        handle_histoire_end(line);
    }
    else if (strstr(line, "my.own.pet")) {
        handle_own_pet(line);
    }
    else if (strstr(line, "my.own.titan")) {
        handle_own_titan(line);
    }
    else if (strstr(line, "my.nombre.pet")) {
        handle_nombre_pet(line);
    }
    else if (strstr(line, "my.nombre.titan")) {
        handle_nombre_titan(line);
    }
    else if (strstr(line, "my.fonction")) {
        handle_fonction(line);
    }
    else if (strstr(line, "my.lire.module")) {
        handle_lire_module(line);
    }
    else if (strstr(line, "my.package.charge")) {
        handle_package_charge(line);
    }
    else if (strstr(line, "my.if")) {
        // Traitement des conditions
        char *start = strchr(line, '(');
        char *end = strrchr(line, ')');
        if (!start || !end) {
            maya_error("Syntaxe incorrecte pour condition - parenthèses manquantes", 0);
            return;
        }

        start++;
        *end = '\0';

        if (strlen(start) == 0) {
            maya_error("Condition vide", 0);
            return;
        }

        last_condition_result = handle_condition(start);
    }
    else if (strstr(line, "my.alors") || strstr(line, "my.autre")) {
        // Ces lignes sont gérées plus haut
        return;
    }
    else if (strstr(line, "may.")) {
        // Gestion améliorée des fonctions réutilisables et packages C
        char line_copy[MAX_LINE_LENGTH];
        strcpy(line_copy, line);

        char *paren = strchr(line_copy, '(');
        char *func_name = line_copy;
        char *args = "";

        if (paren) {
            *paren = '\0';
            args = paren + 1;
            char *end_paren = strrchr(args, ')');
            if (end_paren) *end_paren = '\0';
        }

        trim(func_name);

        printf("🔍 Recherche de la fonction: %s\n", func_name);

        // Convertir le nom de fonction Maya vers le nom C
        char c_func_name[MAX_VAR_NAME];
        strcpy(c_func_name, func_name);

        // Remplacer les points par des underscores pour les fonctions C
        for (int i = 0; c_func_name[i]; i++) {
            if (c_func_name[i] == '.') {
                c_func_name[i] = '_';
            }
        }

        printf("🔧 Nom C converti: %s\n", c_func_name);

        // Essayer d'abord les fonctions de packages C
        if (find_package_function(c_func_name) != -1) {
            printf("📦 Fonction trouvée dans package C\n");
            call_package_function(c_func_name, args);
        }
        // Sinon, essayer les fonctions Maya réutilisables
        else if (find_maya_function(func_name) != -1) {
            printf("🌟 Fonction Maya réutilisable trouvée\n");
            execute_maya_function(func_name, args);
        }
        else {
            printf("❌ Fonction introuvable: %s\n", func_name);
            printf("📋 Fonctions disponibles:\n");

            // Lister les fonctions de packages
            printf("   🅒 Packages C:\n");
            for (int i = 0; i < maya_package_count; i++) {
                if (maya_packages[i].loaded) {
                    for (int j = 0; j < maya_packages[i].function_count; j++) {
                        printf("      - %s\n", maya_packages[i].function_names[j]);
                    }
                }
            }

            // Lister les fonctions Maya
            printf("   🌟 Fonctions Maya:\n");
            for (int i = 0; i < maya_function_count; i++) {
                printf("      - %s\n", maya_functions[i].name);
            }

            if (maya_package_count == 0 && maya_function_count == 0) {
                printf("   (Aucune fonction personnalisée chargée)\n");
                printf("💡 Utilisez my.package.charge('fichier.c') pour charger un package\n");
            }
        }
    }
    else if (strstr(line, "my.")) {
        // Pour de futures fonctionnalités commençant par "my."
        maya_error("Fonction Maya non implémentée", 0);
    }
    else {
        maya_error("Commande Maya non reconnue", 0);
    }
}

// Fonction pour exécuter un fichier Maya
void execute_maya_file(const char *filename) {
    FILE *file = fopen(filename, "r");
    if (!file) {
        maya_error("Impossible d'ouvrir le fichier", 0);
        return;
    }

    char line[MAX_LINE_LENGTH];
    int line_number = 1;

    while (fgets(line, sizeof(line), file)) {
        // Enlever le saut de ligne
        line[strcspn(line, "\n")] = '\0';

        // Ignorer les lignes vides et les commentaires
        if (strlen(line) == 0 || line[0] == '#') {
            line_number++;
            continue;
        }

        interpret_line(line);
        line_number++;
    }

    fclose(file);
}

int main(int argc, char *argv[]) {
    // Initialiser le générateur de nombres aléatoires
    srand(time(NULL));

    // Si un fichier est passé en argument
    if (argc == 2) {
        const char *filename = argv[1];

        // Vérifier l'extension .my
        const char *ext = strrchr(filename, '.');
        if (ext && strcmp(ext, ".my") == 0) {
            execute_maya_file(filename);
            return 0;
        } else {
            maya_error("Le fichier doit avoir l'extension .my", 0);
            return 1;
        }
    }

    // Mode interactif si aucun fichier n'est fourni
    printf("🌸 === Interpréteur Maya v6.0 - L'IMAGINATION SANS LIMITES === 🌸\n");
    printf("🆕 NOUVELLES FONCTIONNALITÉS v6.0:\n");
    printf("🤖 Chatbots: my.create.robot (créez vos assistants IA!)\n");
    printf("🔄 Boucles: my.for, my.while, my.loop (contrôle de flux complet!)\n");
    printf("🎨 Palettes: my.palette (dessins colorés personnalisés!)\n");
    printf("🎮 Jeux: my.owngame (créateur de jeux interactifs!)\n");
    printf("💬 Console: my.modifie.console (modifications dynamiques!)\n");
    printf("📋 Menus: my.interactive (interfaces utilisateur ASCII!)\n");
    printf("🎒 Inventaire: my.inventaire (système de gestion d'objets!)\n");
    printf("📖 Histoires: my.histoire.recit, my.histoire.end (conteur magique!)\n");
    printf("🐾 Animaux: my.own.pet, my.nombre.pet (créatures personnalisées!)\n");
    printf("⚡ Titans: my.own.titan, my.nombre.titan (épopées légendaires!)\n");
    printf("🧮 Maths avancées: médiane, moyenne, cube, carré, racine, degrés\n");
    printf("📐 Théorèmes: Pythagore (my.pytha), Thalès (my.thales)\n");
    printf("🎵 Musique: my.rythme.convertir, my.renvoie.gamme, my.obtenir.gamme\n");
    printf("🗄️ Bases de données: my.db, my.send.db, my.supp.db, my.util.db\n");
    printf("⚡ Code C intégré: my.execute.c (exécutez du C directement!)\n");
    printf("🌌 Simulations: Robot, Quantique, Univers, Atomes, Voyage temporel\n");
    printf("🧚‍♀️ Contes: Fées, Vampires, Sirènes, Monstres\n");
    printf("📚 Exercices BAC: Gestion, Math, Histoire, Management (STMG/Général)\n");
    printf("🎮 Mini-jeux: Quizz, Dés, Puissance4, Pendu, Memory, Snake, TicTac et plus!\n");
    printf("📦 Packages C améliorés: Plus simples à créer et charger!\n");
    printf("🚀 Maya v6.0 - OÙ L'IMAGINATION DEVIENT RÉALITÉ! 🚀\n");
    printf("Mode interactif - Tapez 'exit' pour quitter\n\n");

    char line[MAX_LINE_LENGTH];

    while (1) {
        printf("maya> ");
        fflush(stdout);

        if (fgets(line, sizeof(line), stdin) == NULL) break;

        // Enlever le saut de ligne
        line[strcspn(line, "\n")] = '\0';

        if (strcmp(line, "exit") == 0) {
            printf("🌸 Au revoir! Merci d'avoir utilisé Maya! 💖\n");
            break;
        }

        if (strlen(line) > 0) {
            interpret_line(line);
        }
    }

    // Nettoyer les packages chargés
    for (int i = 0; i < maya_package_count; i++) {
        if (maya_packages[i].handle) {
            dlclose(maya_packages[i].handle);
            // Supprimer le fichier temporaire
            unlink(maya_packages[i].so_path);
        }
    }

    return 0;
}