#include <Wire.h> 
#include <LiquidCrystal_I2C.h>
#include <Keypad.h>
#include <EEPROM.h>

LiquidCrystal_I2C lcd(0x27, 20,4);

const byte ROWS = 4; 
const byte COLS = 4; 
const int PHONE_NUMBER_LENGTH = 10; // Longueur maximale du numéro de téléphone
const int PHONE_NUMBER_ADDRESS = 0; // Adresse de début dans la mémoire EEPROM pour le numéro de téléphone



char keys[ROWS][COLS] = {
  {'1','2','3','A'},
  {'4','5','6','B'},
  {'7','8','9','C'},
  {'*','0','#','D'}
};

byte rowPins[ROWS] = {9, 8, 7, 6}; 
byte colPins[COLS] = {5, 4, 3, 2}; 

Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );

const int buzzerPin = 10;

enum State { MENU_PRINCIPAL, CONTACTS, MESSAGERIE, PARAMETRE, MUSIQUE, AJOUTER_CONTACT, SUPPRIMER_CONTACT, SAISIE_TELEPHONE, SAISIR_MESSAGE, RECEVOIR_MESSAGE, MODIFIER_LUMINOSITE, MODIFIER_VOLUME, LISTE_MUSIQUE, COMPOSER_MUSIQUE,  ECOUTER_MUSIQUE_SAUVEGARDEE};
State currentState = MENU_PRINCIPAL;

bool addingContact = false;
bool deletingContact = false;

int menuPosition = 0; // Position du menu défilant
int brightnessLevel = 255; // Niveau de luminosité par défaut
int storedBrightnessLevel = 255; // Niveau de luminosité enregistré
char phoneNumber[12] = ""; // Numéro de téléphone du contact

// Tableau associatif pour les lettres associées à chaque touche
const char keypadChars[10][4][4] = {
  {" ", "", "", ""},       // Touche 1 (espaces)
  {"A", "B", "C", ""},    // Touche 2
  {"D", "E", "F", ""},    // Touche 3
  {"G", "H", "I", ""},    // Touche 4
  {"J", "K", "L", ""},    // Touche 5
  {"M", "N", "O", ""},    // Touche 6
  {"P", "Q", "R", "S"},   // Touche 7
  {"T", "U", "V", ""},    // Touche 8
  {"W", "X", "Y", "Z"},   // Touche 9
  {"", "", "", ""}        // Touche 0 et autres
};

// Indice du caractère sélectionné pour chaque touche
int selectedCharIndex[ROWS][COLS] = {};

void setup() {
  lcd.init();
  lcd.backlight();
  pinMode(buzzerPin, OUTPUT);
  Serial.begin(9600); // Initialisation de la communication série
}

void loop() {
  switch (currentState) {
    case MENU_PRINCIPAL:
      displayMenu("Menu principal");
      break;
    case CONTACTS:
      handleContacts();
      break;
    case AJOUTER_CONTACT:
      ajouterContact();
      break;
    case SUPPRIMER_CONTACT:
      supprimerContact();
      break;
    case MESSAGERIE:
      handleMessagerie();
      break;
    case SAISIR_MESSAGE:
      saisirMessage();
      break;

//    case RECEVOIR_MESSAGE:
//      recevoirMessage();
//      break;
    case PARAMETRE:
      handleParametre();
      break;
    case MODIFIER_LUMINOSITE:
      handleLuminosite();
      break;
    case MODIFIER_VOLUME:
      handleVolume();
      break;
    case MUSIQUE:
      handleMusic(); // Fixed function name
      break;
    case LISTE_MUSIQUE:
      listenToMusic(); // This should also be handleMusic()
      break;
    case COMPOSER_MUSIQUE:
      composerMusique();
      break;
    case SAISIE_TELEPHONE:
      saisirTelephone();
      break;
  }
}
void displayMenu(String title) {
  static unsigned long lastDisplayTime = 0; // Variable pour suivre le moment où le menu principal a été affiché pour la dernière fois
  static bool menuDisplayed = false; // Variable pour indiquer si le menu principal a déjà été affiché
  
  // Contrôler l'intervalle d'affichage du menu principal
  if (!menuDisplayed || (millis() - lastDisplayTime) > 250) { // Afficher toutes les 2 secondes
    lastDisplayTime = millis(); // Mettre à jour le dernier moment d'affichage
    menuDisplayed = true; // Marquer le menu comme déjà affiché
    
    // Effacer l'écran LCD et afficher le titre
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print(title);

    // Afficher le menu en commençant par la position actuelle
    String menuText = "1. Contacts     2. Messagerie     3. Parametres     4. Musique  ";
    int menuTextLength = menuText.length();

    lcd.setCursor(0, 1);

    // Afficher le menu en commençant par la position actuelle
    for (int i = 0; i < 20; i++) {
      lcd.print(menuText[(menuPosition + i) % menuTextLength]);
    }

    delay(250); // Définir la vitesse de défilement

    // Mettre à jour la position du menu pour le défilement
    menuPosition = (menuPosition + 1) % menuTextLength;
  }

  char key = keypad.getKey();

  if (key == '1') {
    currentState = CONTACTS;
  } else if (key == '2') {
    currentState = MESSAGERIE;
  } else if (key == '3') {
    currentState = PARAMETRE;
  } else if (key == '4') {
    currentState = MUSIQUE;
  } else if (key != NO_KEY) {
    // Afficher un message d'erreur pour une touche invalide
    lcd.clear();
    lcd.print("Touche invalide");
    delay(200);
  }
}



















//Contacts---------------------------------------
void handleContacts() {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Contact");
  
  // Afficher le menu Ajouter/Supprimer en commençant par la position actuelle
  String menuText = "1. Ajouter    2. Supprimer   ";
  int menuTextLength = menuText.length();
  
  lcd.setCursor(0, 1);
  
  // Afficher le menu Ajouter/Supprimer en commençant par la position actuelle
  for (int i = 0; i < 16; i++) {
    lcd.print(menuText[(menuPosition + i) % menuTextLength]);
  }
  
  delay(250); // Définir la vitesse de défilement
  
  // Mettre à jour la position du menu Ajouter/Supprimer pour le défilement
  menuPosition = (menuPosition + 1) % menuTextLength;

  char key = keypad.getKey();
  
  if (key == '1') {
    currentState = AJOUTER_CONTACT; // Passer à l'état d'ajout de contact si l'utilisateur appuie sur "1"
  } else if (key == '2') {
    currentState = SUPPRIMER_CONTACT;
  }else if (key == '#') {
    currentState = MENU_PRINCIPAL; // Retour au menu principal lorsque # est pressé
    storedBrightnessLevel = brightnessLevel; // Enregistrer la luminosité sélectionnée
  }
}

const int CONTACT_NAME_ADDRESS = 30; // Adresse de début dans la mémoire EEPROM pour le nom du contact
String contactName = ""; // Variable pour stocker le nom du contact

void ajouterContact() {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Entrez le numero:");

  String phoneNumber = ""; // Variable pour stocker le numéro de téléphone
  String contactName = ""; // Variable pour stocker le nom du contact

  // Boucle pour saisir et afficher le numéro de téléphone
  while (true) {
    char key = keypad.getKey();
    
    if (key >= '0' && key <= '9') {
      phoneNumber += key;
      lcd.setCursor(0, 1);
      lcd.print(phoneNumber); // Afficher le numéro saisi sur la deuxième ligne de l'écran LCD
    } else if (key == 'D') {
      // Effacer le dernier chiffre si D est pressé et si le numéro n'est pas vide
      if (phoneNumber.length() > 0) {
        phoneNumber = phoneNumber.substring(0, phoneNumber.length() - 1);
        lcd.setCursor(0, 1);
        lcd.print("                "); // Effacer l'affichage précédent
        lcd.setCursor(0, 1);
        lcd.print(phoneNumber); // Afficher le numéro mis à jour sur la deuxième ligne de l'écran LCD
      }
    } else if (key == 'C') {
      // Effacer complètement le numéro si C est pressé
      phoneNumber = "";
      lcd.setCursor(0, 1);
      lcd.print("                "); // Effacer l'affichage précédent
    } else if (key == '*') {
      // Terminer la saisie du numéro si # est pressé
      break;
    } else if (key == '#') {
      // Revenir à l'état CONTACTS si * est pressé
      currentState = CONTACTS;
      break;
    }
    
    delay(100); // Délai pour éviter la lecture de touches multiples
  }

  // Si le numéro est saisi avec succès, demandez maintenant le nom du contact
  if (phoneNumber.length() == PHONE_NUMBER_LENGTH) {
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Entrez le nom:");

    // Boucle pour saisir et afficher le nom du contact
    while (true) {
      char key = keypad.getKey();
      
      if ((key >= 'A' && key <= 'Z') || key == ' ') {
        contactName += key;
        lcd.setCursor(0, 1);
        lcd.print(contactName); // Afficher le nom du contact sur la deuxième ligne de l'écran LCD
      } else if (key == 'D') {
        // Effacer la dernière lettre si D est pressé et si le nom n'est pas vide
        if (contactName.length() > 0) {
          contactName = contactName.substring(0, contactName.length() - 1);
          lcd.setCursor(0, 1);
          lcd.print("                "); // Effacer l'affichage précédent
          lcd.setCursor(0, 1);
          lcd.print(contactName); // Afficher le nom mis à jour sur la deuxième ligne de l'écran LCD
        }
      } else if (key == 'C') {
        // Effacer complètement le nom si C est pressé
        contactName = "";
        lcd.setCursor(0, 1);
        lcd.print("                "); // Effacer l'affichage précédent
      } else if (key == '*') {
        // Terminer la saisie du nom si * est pressé
        break;
      } else if (key == '#') {
        // Revenir à l'état CONTACTS si # est pressé
        currentState = CONTACTS;
        break;
      }
      
      delay(100); // Délai pour éviter la lecture de touches multiples
    }
  }

  // Si le numéro et le nom sont saisis avec succès, enregistrez-les dans la mémoire EEPROM
  if (phoneNumber.length() == PHONE_NUMBER_LENGTH && contactName.length() > 0) {
    // Enregistrer le numéro de téléphone dans la mémoire EEPROM
    for (int i = 0; i < PHONE_NUMBER_LENGTH; i++) {
      EEPROM.write(PHONE_NUMBER_ADDRESS + i, phoneNumber[i]);
    }
    // Enregistrer le nom du contact dans la mémoire EEPROM
    for (int i = 0; i < contactName.length(); i++) {
      EEPROM.write(CONTACT_NAME_ADDRESS + i, contactName[i]);
    }
    
    lcd.clear();
    lcd.print("Contact enregistre!");
    delay(2000); // Afficher le message pendant 2 secondes
  } else {
    lcd.clear();
    lcd.print("Erreur! Numero ou nom incorrect");
    delay(2000); // Afficher le message d'erreur pendant 2 secondes
  }
}



void supprimerContact() {
  // Logique pour supprimer un contact
  lcd.clear();
  lcd.print("Supprimer un contact...");
}



void saisirTelephone() {
  char key = keypad.getKey();
  
  if (key != NO_KEY) {
    if (key >= '0' && key <= '9') {
      // Ajouter la touche numérique au numéro de téléphone
      if (strlen(phoneNumber) < 11) {
        strcat(phoneNumber, &key);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("Tel: ");
        lcd.setCursor(0, 1);
        lcd.print(phoneNumber);
      }
    } else if (key == '#') {
      addingContact = false;
      strcpy(phoneNumber, "");
      currentState = MENU_PRINCIPAL;
    }
  }
}
































//Messagerie---------------------------------------------------------------------------------------------------------
void handleMessagerie() {
  // Effacer l'écran LCD
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Messagerie :");
  
  // Afficher le menu Ajouter/Supprimer
  String menuText = "1. Envoyer    2. Recevoir   ";
  int menuTextLength = menuText.length();
  
  lcd.setCursor(0, 1);
  
  // Afficher le menu Ajouter/Supprimer
  for (int i = 0; i < 20; i++) {
    lcd.print(menuText[(menuPosition + i) % menuTextLength]);
  }
  
  delay(250); // Définir la vitesse de défilement
  
  // Mettre à jour la position du menu Ajouter/Supprimer pour le défilement
  menuPosition = (menuPosition + 1) % menuTextLength;

  char key = keypad.getKey();
  
  if (key == '1') {
    currentState = SAISIR_MESSAGE; // Passer à l'état de saisie de message si l'utilisateur appuie sur "1"
  } else if (key == '2') {
    currentState = RECEVOIR_MESSAGE;
  } else if (key == '#') {
    currentState = MENU_PRINCIPAL; // Retour au menu principal lorsque # est pressé
    storedBrightnessLevel = brightnessLevel; // Enregistrer la luminosité sélectionnée
  }
}

// Déclaration globale pour suivre la colonne actuelle sélectionnée
int currentColumn = 0;
const int SMILEY_BUTTON_PIN = 12;


// Fonction pour saisir le texte T9 en utilisant la logique de transition de colonne
String enterT9Text() {
  String text = ""; // Texte en cours de saisie
  int cursorPosition = 0; // Position du curseur dans le texte

  while (true) {
    char key = keypad.getKey(); // Lire la touche pressée

    if (key != NO_KEY) {
      if (key >= '0' && key <= '9') {
        int keyIndex = key - '0';
        int pressCount = 1; // Nombre de pressions sur la touche

        // Attendre jusqu'à ce que la touche soit relâchée pour compter le nombre de pressions
        while (keypad.getKey() == key) {
          delay(50); // Attendre un court délai entre chaque pression
          pressCount++;
        }

        // Sélectionner la lettre correspondant à la touche et au nombre de pressions
        char selectedChar = getSelectedChar(keyIndex - 1, currentColumn, pressCount - 1); // Modifier ici pour gérer les différentes pressions sur la touche

        // Ajouter la lettre sélectionnée au texte
        text += selectedChar;

        // Mettre à jour l'affichage sur l'écran LCD
        updateMessageDisplay(text, cursorPosition);
      } else if (key == '#') {
        // Terminer la saisie du texte
        break;
      } else if (key == 'B') {
        // Passer à la deuxième colonne
        currentColumn = 1;
      } else if (key == 'C') {
        // Passer à la troisième colonne
        currentColumn = 2;
      } else if (key == 'A') {
        // Passer à la première colonne
        currentColumn = 0;
      }
    }
  }

  return text;
}

// Fonction pour sélectionner la lettre correspondant à la touche T9
char getSelectedChar(int row, int col, int pressCount) {
  if (col == 0) {
    int index = selectedCharIndex[row][col] + pressCount;
    int numChars = strlen(keypadChars[row][col]); // Nombre de caractères associés à la touche
    return keypadChars[row][col][index % numChars];
  } else if (col == 1) {
    // Pour les touches B et C, retourner la lettre associée
    if (row == 0) return 'A';
    else if (row == 1) return 'B';
    else if (row == 2) return 'E';
    else if (row == 3) return 'H';
    else if (row == 4) return 'K';
    else if (row == 5) return 'N';
    else if (row == 6) return 'Q';
    else if (row == 7) return 'T';
    else if (row == 8) return 'W';
    else if (row == 9) return 'Z';

    
    else return ' ';
  } else if (col == 2) {
    // Pour les touches 3, 6, 9, retourner la lettre associée
    if (row == 0) return 'B';
    else if (row == 1) return 'C';
    else if (row == 2) return 'F';
    else if (row == 3) return 'I';
    else if (row == 4) return 'L';
    else if (row == 5) return 'O';
    else if (row == 6) return 'R';
    else if (row == 7) return 'U';
    else if (row == 7) return 'X';

    else return ' ';
  } else {
    return ' '; // Pour les autres touches, retourner un espace
  }
}


// Fonction pour mettre à jour l'affichage du message sur l'écran LCD avec le curseur
void updateMessageDisplay(String message, int cursorPosition) {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Saisir texte T9:");
  lcd.setCursor(0, 1);
  lcd.print(message);
  
  // Afficher le curseur à la position actuelle
  if (cursorPosition < 20) {
    lcd.setCursor(cursorPosition, 1);
    lcd.blink(); // Faire clignoter le curseur
  }
}

// Fonction pour saisir un message en utilisant le clavier T9
bool messageSent = false;

void saisirMessage() {
  lcd.clear(); // Nettoyer l'écran
  lcd.setCursor(0, 0);
  lcd.print("Message:");
  
  // Permet à l'utilisateur de saisir un message en utilisant le clavier T9
  String message = enterT9Text();
  
  // Mettez à jour le statut du message pour indiquer qu'un message a été envoyé
  messageSent = true;

  // Affichez un message de confirmation
  lcd.clear();
  lcd.print("ERREUR");

  // Attendez un court instant avant de revenir au menu principal
  delay(2000);

  // Retournez à l'état MENU_PRINCIPAL
  currentState = MENU_PRINCIPAL;
}

// Fonction pour gérer l'affichage de l'indication de message en attente
void handleMessageStatus() {
  if (messageSent) {
    lcd.setCursor(0, 1);
    lcd.print("Msg en attente");
  } else {
    lcd.setCursor(0, 1);
    lcd.print("               "); // Effacez l'indication précédente
  }
}

/* 

void sendMessage(String message) {
  Wire.beginTransmission(ADDRESS); // Commencer la transmission à l'adresse spécifiée
  Wire.write(message.c_str()); // Envoyer le message (converti en tableau de caractères)
  Wire.endTransmission(); // Terminer la transmission
}








*/
















//Paramètre------------------------------------------------------------------------------
void handleParametre() {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Parametre :");

  // Afficher le menu Ajouter/Supprimer en commençant par la position actuelle
  String menuText = "1. Luminosite    2. Volume   ";
  int menuTextLength = menuText.length();

  lcd.setCursor(0, 1);

  // Afficher le menu Ajouter/Supprimer en commençant par la position actuelle
  for (int i = 0; i < 16; i++) {
    lcd.print(menuText[(menuPosition + i) % menuTextLength]);
  }

  delay(250); // Définir la vitesse de défilement

  // Mettre à jour la position du menu Ajouter/Supprimer pour le défilement
  menuPosition = (menuPosition + 1) % menuTextLength;

  char key = keypad.getKey();

  if (key == '1') {
    currentState = MODIFIER_LUMINOSITE; // Passer à l'état de modification de la luminosité si l'utilisateur appuie sur "1"
  } else if (key == '2') {
    currentState = MODIFIER_VOLUME;
  } else if (key == '#') {
    currentState = MENU_PRINCIPAL; // Retour au menu principal lorsque # est pressé
    storedBrightnessLevel = brightnessLevel; // Enregistrer la luminosité sélectionnée
  }
}

void handleLuminosite() {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Luminosite:");

  // Afficher le niveau de luminosité actuel
  lcd.setCursor(0, 1);
  lcd.print("lvl: ");
  lcd.print(brightnessLevel);

  char key = keypad.getKey();

  if (key == 'A') {
    // Augmenter la luminosité si la touche 'A' est pressée
    increaseBrightness();
  } else if (key == 'B') {
    // Diminuer la luminosité si la touche 'B' est pressée
    decreaseBrightness();
  } else if (key == '#') {
    // Enregistrer le niveau de luminosité dans la mémoire EEPROM si la touche '#' est pressée
    EEPROM.write(PHONE_NUMBER_ADDRESS, brightnessLevel);
    currentState = PARAMETRE; // Retour au menu principal
  }
}


// Déclaration globale de la variable de volume et de son adresse dans la mémoire EEPROM
int volumeLevel = 50; // Valeur par défaut du volume
const int VOLUME_ADDRESS = 20; // Adresse dans la mémoire EEPROM pour enregistrer le volume


void handleVolume() {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Modifier Volume:");

  // Afficher le niveau de volume actuel
  lcd.setCursor(0, 1);
  lcd.print("Volume: ");
  lcd.print(volumeLevel);

  char key = keypad.getKey();

  if (key == 'A') {
    // Augmenter le volume si la touche 'A' est pressée
    increaseVolume();
    // Générer un bip de 1 seconde
    buzzForOneSecond();
  } else if (key == 'B') {
    // Diminuer le volume si la touche 'B' est pressée
    decreaseVolume();
    // Générer un bip de 1 seconde
    buzzForOneSecond();
  } else if (key == '#') {
    // Enregistrer le niveau de volume dans la mémoire EEPROM si la touche '#' est pressée
    EEPROM.write(VOLUME_ADDRESS, volumeLevel);
    currentState = MENU_PRINCIPAL; // Retour au menu principal
  }
}

void buzzForOneSecond() {
  tone(buzzerPin, 1000); // Jouer un son de 1000 Hz sur le buzzer
  delay(1000); // Jouer le son pendant 1 seconde
  noTone(buzzerPin); // Arrêter le son
}

void increaseVolume() {
  // Incrémente le niveau de volume par pas de 10
  volumeLevel += 10;

  // Assurez-vous que le volume reste dans les limites (0-100)
  if (volumeLevel > 100) {
    volumeLevel = 100;
  }

  // Mettre à jour la sortie du buzzer avec le nouveau niveau de volume
  analogWrite(buzzerPin, map(volumeLevel, 0, 100, 0, 255));
}

void decreaseVolume() {
  // Décrémente le niveau de volume par pas de 10
  volumeLevel -= 10;

  // Assurez-vous que le volume reste dans les limites (0-100)
  if (volumeLevel < 0) {
    volumeLevel = 0;
  }

  // Mettre à jour la sortie du buzzer avec le nouveau niveau de volume
  analogWrite(buzzerPin, map(volumeLevel, 0, 100, 0, 255));
}





void decreaseBrightness() {
  if (brightnessLevel > 0) {
    brightnessLevel -= 10; // Diminuer la luminosité par pas de 10
    lcd.setBacklight(brightnessLevel);
  }
}

void increaseBrightness() {
  if (brightnessLevel < 255) {
    brightnessLevel += 10; // Augmenter la luminosité par pas de 10
    lcd.setBacklight(brightnessLevel);
  }
}

















//Musique---------------------------------------------------------------------------------------------------
String music1 = "HHHIIJJK";
String music2 = "BBCEDFHJ";
String music3 = "AAAACDEFAB";
String music4 = "CCCCDEFGCDE";
String music5 = "GGGGFEDCBAG";

// Fonction pour jouer un morceau de musique
void playMusic(String music, int duration) {
  for (int i = 0; i < music.length(); i++) {
    char note = music.charAt(i);
    playNote(note); // Jouer chaque note
    delay(500); // Attendre 500 ms entre chaque note
  }
}

// Fonction pour écouter les morceaux de musique enregistrés
State listenToMusic() {
  lcd.clear();
  lcd.print("Ecouter Musique     entre 1 et 5 ");

  char keyPressed;

  // Attendre une pression de touche pour commencer la lecture des morceaux
  do {
    keyPressed = keypad.getKey();
  } while (keyPressed == NO_KEY);

  // Définir la durée de chaque morceau en millisecondes (5 secondes)
  int musicDuration = 5000;

  // Jouer le morceau de musique correspondant à la touche pressée
  switch (keyPressed) {
    case '1':
      lcd.clear();
      lcd.print("Music: music1");
      playMusic(music1, musicDuration);
      break;
    case '2':
      lcd.clear();
      lcd.print("Music: music2");
      playMusic(music2, musicDuration);
      break;
    case '3':
      lcd.clear();
      lcd.print("Music: music3");
      playMusic(music3, musicDuration);
      break;
    case '4':
      lcd.clear();
      lcd.print("Music: music4");
      playMusic(music4, musicDuration);
      break;
    case '5':
      lcd.clear();
      lcd.print("Music: music5");
      playMusic(music5, musicDuration);
      break;
    default:
      break;
  }

  // Retourner au menu principal une fois le morceau lu
  return MENU_PRINCIPAL;
}

// Fonction pour gérer l'état de la musique
void handleMusic() {
  lcd.clear();
  lcd.print("Musique :");

  // Afficher le menu Liste/Composer
  String menuText = "1. Liste    2. Composer  3. Ecouter musique   ";
  int menuTextLength = menuText.length();

  lcd.setCursor(0, 1);

  // Afficher le menu Liste/Composer en commençant par la position actuelle
  for (int i = 0; i < 20; i++) {
    lcd.print(menuText[(menuPosition + i) % menuTextLength]);
  }

  delay(250); // Définir la vitesse de défilement

  // Mettre à jour la position du menu Liste/Composer pour le défilement
  menuPosition = (menuPosition + 1) % menuTextLength;

  char key = keypad.getKey();

  if (key == '1') {
    // Passer à l'état de la liste de musique
    currentState = LISTE_MUSIQUE;
  } else if (key == '2') {
    // Passer à l'état de composition de musique
    currentState = COMPOSER_MUSIQUE;
  } else if (key == '3') {
    // Passer à l'état d'écoute de la musique sauvegardée
    currentState = ECOUTER_MUSIQUE_SAUVEGARDEE;
  } else if (key == '#') {
    // Retour au menu principal lorsque # est pressé
    currentState = MENU_PRINCIPAL;
    storedBrightnessLevel = brightnessLevel; // Enregistrer la luminosité sélectionnée
  }
}

// Déclaration de variable globale pour stocker la musique composée
String composedMusic = "";

void enterMusicNotes() {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Composer musique:");
  composedMusic = ""; // Utiliser la variable globale pour stocker la musique composée

  // Boucle pour saisir et afficher les notes musicales
  while (true) {
    char key = keypad.getKey();

    if (key != NO_KEY) {
      // Ajouter la note musicale à la composition
      if ((key >= '0' && key <= '9') || (key >= 'A' && key <= 'N')) { // Modifier la condition pour inclure la note 'N'
        switch (key) {
          case '0':
            composedMusic += 'O';
            break;
          case '1':
            composedMusic += 'A';
            break;
          case '2':
            composedMusic += 'B';
            break;
          case '3':
            composedMusic += 'C';
            break;
          case '4':
            composedMusic += 'D';
            break;
          case '5':
            composedMusic += 'E';
            break;
          case '6':
            composedMusic += 'F';
            break;
          case '7':
            composedMusic += 'G';
            break;
          case '8':
            composedMusic += 'H'; // Octave supérieure, même note que '1'
            break;
          case '9':
            composedMusic += 'I'; // Octave supérieure, même note que '2'
            break;
          case 'A':
            composedMusic += 'J';
            break;
          case 'B':
            composedMusic += 'K'; // Changer la correspondance de 'B' à 'K'
            break;
          case 'C':
            composedMusic += 'L';
            break;
          case 'D':
            composedMusic += 'M';
            break;
          case 'E':
            composedMusic += 'N'; // Ajout de la correspondance de 'E' à 'N'
            break;
        }
        lcd.clear();
        lcd.print("Composer musique:");
        lcd.setCursor(0, 1);
        lcd.print(composedMusic); // Afficher la musique composée
        playNote(composedMusic[composedMusic.length() - 1]); // Jouer la note sur le buzzer
      } else if (key == '#') {
        // Terminer la composition si # est pressé
        break;
      } else if (key == '*') {
        // Annuler la dernière note si * est pressé
        if (composedMusic.length() > 0) {
          composedMusic.remove(composedMusic.length() - 1);
          lcd.clear();
          lcd.print("Composer musique:");
          lcd.setCursor(0, 1);
          lcd.print(composedMusic); // Afficher la musique composée
        }
      }
    }
  }
}



void playNote(char note) {
  // Fréquences des notes de musique
  int frequencies[] = {262, 294, 330, 349, 392, 440, 494, 523, 600, 622, 655, 675, 700, 800, 900}; // Ajout de la fréquence pour la note 'H'
  // Correspondance entre les notes musicales et leurs indices dans le tableau des fréquences
  char notes[] = {'C', 'D', 'E', 'F', 'G', 'A', 'B', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O'}; // Ajout de la note 'H'

  // Recherche de la note dans le tableau des notes
  for (int i = 0; i < 15; i++) { // Utilisation de la taille correcte du tableau
    if (note == notes[i]) {
      // Jouer la note correspondante
      tone(buzzerPin, frequencies[i]);
      delay(500); // Jouer la note pendant 500 ms
      noTone(buzzerPin); // Arrêter la note
      break;
    }
  }
}




const int COMPOSED_MUSIC_ADDRESS = 100; // Example address in EEPROM for storing composed music

// Déclaration de playComposedMusic à l'extérieur de la fonction listenSavedMusic
void playComposedMusic();

void listenSavedMusic() {
  lcd.clear();
  lcd.print("Ecouter musique sauvegardee: ");

  // Ajoutez un message de débogage pour afficher la musique lue à partir de la mémoire EEPROM
  Serial.println("Musique lue: " + readComposedMusic());

  // Jouer la musique sauvegardée
  playComposedMusic();

  // Attendez que l'utilisateur appuie sur une touche pour revenir au menu principal
  while (keypad.getKey() == NO_KEY) {
    delay(100);
  }

  currentState = MENU_PRINCIPAL; // Revenir au menu principal
}


// Définition de la fonction playComposedMusic
void playComposedMusic() {
  String music = readComposedMusic(); // Lire la musique enregistrée
  // Ajoutez un message de débogage pour vérifier la musique lue avant de la jouer
  Serial.println("Musique à jouer: " + music);
  playMusic(music, 500); // Jouer la musique avec une durée de note de 500 ms
}


void saveComposedMusic(String music) {
  // Écrire la musique composée dans la mémoire EEPROM
  for (int i = 0; i < music.length(); i++) {
    EEPROM.write(COMPOSED_MUSIC_ADDRESS + i, music[i]);
  }
  // Ajouter un caractère de terminaison pour marquer la fin de la musique
  EEPROM.write(COMPOSED_MUSIC_ADDRESS + music.length(), '\0');
}

String readComposedMusic() {
  String music = ""; // Variable pour stocker la musique lue depuis la mémoire EEPROM
  char c;
  int address = COMPOSED_MUSIC_ADDRESS;

  // Lire la musique depuis la mémoire EEPROM
  while ((c = EEPROM.read(address)) != '\0') {
    music += c;
    address++;
  }
  return music;
}

void composerMusique() {
  enterMusicNotes(); // Saisir les notes musicales
  saveComposedMusic(composedMusic); // Enregistrer la musique composée dans la mémoire EEPROM
  
  // Jouer la musique composée automatiquement
  lcd.clear();
  lcd.print("Musique sauvegardee");
  delay(1000); // Attendre un court instant avant de jouer la musique
  playComposedMusic(); // Jouer la musique composée
  delay(2000); // Attendre un peu avant de revenir au menu principal
  
  currentState = MENU_PRINCIPAL; // Retourner au menu principal
}