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

LiquidCrystal_I2C lcd(0x27, 16, 4);

int upButton = 9;
int downButton = 8;
int selectButton = 7;
int menu = 1;
int mode = 1;
int temp = 1;
int humi = 1;
int motor = 1;


unsigned long startMillis;
unsigned long currentMillis;
const unsigned long period = 50;
bool btemp;

// Tempertur
const float tempStep = 0.01;
float temperatur = 38.5;
float tempMax = 40.7;;
float tempMin = 35.9;;
float normTempMax = 40;
float normTempMin = 35;

// Humidity
float humidity = 38.5;
float humiMax = 40.7;;
float humiMin = 35.9;;

//Menu principal
String hmenu = "________Menu________";
String menu1 = "Mode";
String menu2 = "Temperatur";
String menu3 = "Humidity";
String menu4 = "Motor";

//Sous-Menu Mode
String smode = "________Mode________";
String mode1 = "Chauf. Oeuf Poule";
String mode2 = "Chauf. Oeuf canard";
String mode3 = "Chauf. Oeuf caille";

//Sous-Menu temperature
String stemp = "_____Temperatur_____";
String temp1 = "Temperatur";
String temp2 = "Temp min";
String temp3 = "Temp max";

//Sous-Menu humidity
String shumi = "______Humidity______";
String humi1 = "Humidity";
String humi2 = "Humi min";
String humi3 = "Humi max";

//Sous-Menu Motor turn time
String smotor = "________Motor_______";
String motor1 = "Automatic";
String motor2 = "Motor Turn time";
String motor3 = "Manuel";


String retour = "exit";

byte select = 0;
byte sel[] = {
  B11000,
  B11100,
  B11110,
  B11111,
  B11110,
  B11100,
  B11000,
  B00000
};
byte Grad = 1;
byte gradCelcius[] = {
  B11100,
  B10100,
  B11100,
  B00000,
  B01111,
  B01000,
  B01000,
  B01111
};
byte dimRH = 2;
byte rH[] = {
  B00000,
  B00000,
  B00101,
  B00101,
  B11111,
  B10101,
  B10101,
  B00000
};

byte down = 3;
byte dirDown[] = {
  B00000,
  B00000,
  B00000,
  B00000,
  B11111,
  B01110,
  B00100,
  B00000
};

byte up = 4;
byte dirUp[] = {
  B00000,
  B00100,
  B01110,
  B11111,
  B00000,
  B00000,
  B00000,
  B00000
};
byte yes = 5;
byte ye[] = {
  B00000,
  B00000,
  B00000,
  B00001,
  B00010,
  B10100,
  B01000,
  B00000
};
byte cle = 6;
byte ver[] = {
  B00000,
  B01110,
  B01010,
  B11111,
  B10101,
  B10011,
  B11111,
  B00000
};


void setup() {
  lcd.begin(20, 4);
  lcd.backlight();
  lcd.createChar(select, sel);
  lcd.createChar(Grad, gradCelcius);
  lcd.createChar(dimRH, rH);
  lcd.createChar(down, dirDown);
  lcd.createChar(up, dirUp);
  lcd.createChar(yes, ye);
  lcd.createChar(cle, ver);
  lcd.clear();
  pinMode(upButton, INPUT_PULLUP);
  pinMode(downButton, INPUT_PULLUP);
  pinMode(selectButton, INPUT_PULLUP);
  pinMode(13, OUTPUT);
  updateMenu();
}

void loop() {
  menuPrincipal();
}

// affichage du menu principal
void menuPrincipal(){
  if (!digitalRead(downButton)){
    menu++;
    if (menu > 5){
      menu = 5;
    }
    updateMenu();
    while (!digitalRead(downButton));
  }
  if (!digitalRead(upButton)){
    menu--;
    if (menu <= 0){
      menu = 1;
    }
    updateMenu();
    while(!digitalRead(upButton));
  }
  if (!digitalRead(selectButton)){
    menuToSmenu();
    while (!digitalRead(selectButton));
  }
}

// affichage du menu mode
void menuMode(){
  if (!digitalRead(downButton)){
    mode++;
    if (mode > 4){
      mode = 4;
    }
    updateMode();
    while (!digitalRead(downButton));
  }
  if (!digitalRead(upButton)){
    mode--;
    if (mode <= 0){
      mode = 1;
    }
    updateMode();
    while(!digitalRead(upButton));
  }
  if (!digitalRead(selectButton)){
    executeMode();
    //updateMode();
    while (!digitalRead(selectButton));
  }
}

// affichage du menu temperatur
void menuTemp(){
  if (!digitalRead(downButton)){
    temp++;
    if (temp > 4){
      temp = 4;
    }
    updateTemp();
    while (!digitalRead(downButton));
  }
  if (!digitalRead(upButton)){
    temp--;
    if (temp <= 0){
      temp = 1;
    }
    updateTemp();
    while(!digitalRead(upButton));
  }
  if (!digitalRead(selectButton)){
      executeTemp();
    while (!digitalRead(selectButton));
  }
}

// affichage du menu Humidity
void menuHumi(){
  if (!digitalRead(downButton)){
    humi++;
    if (humi > 4){
      humi = 4;
    }
    updateHumi();
    while (!digitalRead(downButton));
  }
  if (!digitalRead(upButton)){
    humi--;
    if (humi <= 0){
      humi = 1;
    }
    updateHumi();
    while(!digitalRead(upButton));
  }
  if (!digitalRead(selectButton)){
    updateHumi();
    while (!digitalRead(selectButton));
  }
}

// affichage du menu Motor
void menuMotor(){
  if (!digitalRead(downButton)){
    motor++;
    if (motor > 4){
      motor = 4;
    }
    updateMotor();
    while (!digitalRead(downButton));
  }
  if (!digitalRead(upButton)){
    motor--;
    if (motor <= 0){
      motor = 1;
    }
    updateMotor();
    while(!digitalRead(upButton));
  }
  if (!digitalRead(selectButton)){
    updateMotor();
    while (!digitalRead(selectButton));
  }
}

//actualise le menu principal lorsque les boutons de direction sont appuyés
void updateMenu() {
  switch (menu) {
    case 1:
      afficheMenuLCD1(select);
      break;
    case 2:
      afficheMenuLCD1(select);
      break;
    case 3:
      afficheMenuLCD1(select);
      break;
    case 4:
      afficheMenuLCD2(select);
      break;
    case 5:
      afficheMenuLCD2(select);
      break;
  }
}

//actualise le menu Mode lorsque les boutons de direction sont appuyés
void updateMode() {
  switch (mode) {
    case 1:
      afficheModeLCD1(select);
      break;
    case 2:
      afficheModeLCD1(select);
      break;
    case 3:
      afficheModeLCD1(select);
      break;
    case 4:
      afficheModeLCD2(select);
      break;
  }
}

//actualise le menu Temp lorsque les boutons de direction sont appuyés
void updateTemp() {
  switch (temp) {
    case 1:
      afficheTempLCD1(select);
      break;
    case 2:
      afficheTempLCD1(select);
      break;
    case 3:
      afficheTempLCD1(select);
      break;
    case 4:
      afficheTempLCD2(select);
      break;
  }
}

//actualise le menu Humi lorsque les boutons de direction sont appuyés
void updateHumi() {
  switch (humi) {
    case 1:
      afficheHumiLCD1(select);
      break;
    case 2:
      afficheHumiLCD1(select);
      break;
    case 3:
      afficheHumiLCD1(select);
      break;
    case 4:
      afficheHumiLCD2(select);
      break;
  }
}

//actualise le menu Motor lorsque les boutons de direction sont appuyés
void updateMotor() {
  switch (motor) {
    case 1:
      afficheMotorLCD1(select);
      break;
    case 2:
      afficheMotorLCD1(select);
      break;
    case 3:
      afficheMotorLCD1(select);
      break;
    case 4:
      afficheMotorLCD2(select);
      break;
  }
}

void executeMode() {
  switch (mode) {
    case 1:
      action1();
      break;
    case 2:
      action2();
      break;
    case 3:
      action3();
      break;
    case 4:
      action4();
      break;
  }
}

// du sousmenu Mode au action de smode
void executeTemp() {
  switch (temp) {
    case 1:
      tempAction1();
      break;
    case 2:
      if (!digitalRead(selectButton)){
        btemp = true;
        while (!digitalRead(selectButton));
      }
      while(temp == 2 && btemp){
        setTempMin();
      }
      break;
    case 3:
      if (!digitalRead(selectButton)){
        btemp = true;
        while (!digitalRead(selectButton));
      }
      while(temp == 3 && btemp){
        setTempMax();
      }
      break;
    case 4:
      action6();
      break;
  }
}

// du menu au sousmenus
void menuToSmenu() {
  switch (menu) {
    case 1:
    while(menu == 1){
      if (!digitalRead(selectButton)){
        mode = 1;
        updateMode();
        while (!digitalRead(selectButton));
      }
      menuMode();
    }
      break;
    case 2:
    while(menu == 2){
      if (!digitalRead(selectButton)){
        temp = 1;
        updateTemp();
        while (!digitalRead(selectButton));
      }
      menuTemp();
    }
      break;
    case 3:
    while(menu == 3){
      if (!digitalRead(selectButton)){
        humi = 1;
        updateHumi();
        while (!digitalRead(selectButton));
      }
      menuHumi();
    }
      break;
    case 4:
    while(menu == 4){
      if (!digitalRead(selectButton)){
        motor = 1;
        updateMotor();
        while (!digitalRead(selectButton));
      }
      menuMotor();
    }
      break;
    case 5:
      return;
      break;
  }
}

void action1() {

  lcd.clear();
  lcd.print(">Executing #1");
  delay(100);
  updateMode();
}
void action2() {
  lcd.clear();
  lcd.print(">Executing #2");
  delay(100);
  updateMode();
}
void action3() {
  lcd.clear();
  lcd.print(">Executing #3");
  delay(100);
  updateMode();
}
void action4() {
  afficheMenuLCD1(cle);
  menu = 0;
  mode = 0;
}
void action6() {
  afficheMenuLCD1(cle);
  menu = 0;
  temp = 0;
}

// Reglage de la temperature 
void tempAction1(){
  setBtempTrue();
  while(temp == 1 && btemp ){
    setTemp();
  }
}

// Reglage de la temperature minimale 
void tempAction2(){
  setBtempTrue();
  while(temp == 2 && btemp ){
    setTempMin();
  }
}

// Reglage de la temperature maximale
void tempAction3(){
  setBtempTrue();
  while(temp == 3 && btemp ){
    setTempMax();
  }
}

// Affichage des elements du menu principal
void afficheMenuLCD1(byte symbole){
  lcd.clear();
  afficheText(0, 0, hmenu);
  afficheText(2, 1, menu1);
  afficheText(2, 2, menu2);
  afficheText(2, 3, menu3);
  afficheSymbole(0, menu, symbole);
  afficheSymbole(19, 3, down);
}
void afficheMenuLCD2(byte symbole){
  lcd.clear();
  afficheText(0, 0, hmenu);
  afficheText(2, 1, menu4);
  afficheText(2, 2, retour);
  afficheSymbole(0, menu-3, symbole);
  afficheSymbole(19, 1, up);
}

// Affichage des elements du menu mode
void afficheModeLCD1(byte symbole){
  lcd.clear();
  afficheText(0, 0, smode);
  afficheText(2, 1, mode1);
  afficheText(2, 2, mode2);
  afficheText(2, 3, mode3);
  afficheSymbole(0, mode, symbole);
  afficheSymbole(19, 3, down);
}
void afficheModeLCD2(byte symbole){
  lcd.clear();
  afficheText(0, 0, smode);
  afficheText(2, 1, retour);
  afficheSymbole(0, mode-3, symbole);
  afficheSymbole(19, 1, up);
}

// Affichage des elements du menu Temp
void afficheTempLCD1(byte symbole){
  lcd.clear();
  afficheText(0, 0, stemp);
  afficheText(2, 1, temp1);
  afficheText(2, 2, temp2);
  afficheText(2, 3, temp3);
  //Valeurs
  afficheValue(13, 1, temperatur);
  afficheValue(13, 2, tempMin);
  afficheValue(13, 3, tempMax);
  afficheSymbole(18, 1, 2, 3, Grad);
  //Symboles
  afficheSymbole(0, temp, symbole);
  afficheSymbole(19, 3, down);
}
void afficheTempLCD2(byte symbole){
  lcd.clear();
  afficheText(0, 0, stemp);
  afficheText(2, 1, retour);
  //Symboles
  afficheSymbole(0, temp-3, symbole);
  afficheSymbole(19, 1, up);
}

// Affichage des elements du menu Humi
void afficheHumiLCD1(byte symbole){
  lcd.clear();
  //textes
  afficheText(0, 0, shumi);
  afficheText(2, 1, humi1);
  afficheText(2, 2, humi2);
  afficheText(2, 3, humi3);
  //Valeurs
  afficheValue(13, 1, humidity);
  afficheValue(13, 2, humiMin);
  afficheValue(13, 3, humiMax);
  afficheSymbole(18, 1, 2, 3, dimRH);
  //Symboles
  afficheSymbole(0, humi, symbole);
  afficheSymbole(19, 3, down);
}
void afficheHumiLCD2(byte symbole){
  lcd.clear();
  //textes
  afficheText(0, 0, shumi);
  afficheText(2, 1, retour);
  //Symboles
  afficheSymbole(0, humi-3, symbole);
  afficheSymbole(19, 1, up);
}

// Affichage des elements du menu Motor
void afficheMotorLCD1(byte symbole){
  lcd.clear();
  afficheText(0, 0, smotor);
  afficheText(2, 1, motor1);
  afficheText(2, 2, motor2);
  afficheText(2, 3, motor3);
  afficheSymbole(0, motor, symbole);
  afficheSymbole(19, 3, down);
}
void afficheMotorLCD2(byte symbole){
  lcd.clear();
  afficheText(0, 0, smotor);
  afficheText(2, 1, retour);
  afficheSymbole(0, motor-3, symbole);
  afficheSymbole(19, 1, up);
}

// affichage d'un symbole à une positon donnée
void afficheSymbole(int col, int row, byte symbole){
  lcd.setCursor(col, row);
  lcd.write(symbole);
}

// affichage d'un symbole à 3 positons données
void afficheSymbole(int col, int row1, int row2, int row3, byte symbole){
  lcd.setCursor(col, row1);
  lcd.write(symbole);
  lcd.setCursor(col, row2);
  lcd.write(symbole);
  lcd.setCursor(col, row3);
  lcd.write(symbole);
}

// affichage du texte à une positon donnée
void afficheText(int col, int row, String text){
  lcd.setCursor(col, row);
  lcd.print(text);
}

// affichage de la valeur d'une variable à une positon donnée
void afficheValue(int col, int row, float value){
  lcd.setCursor(col, row);
  lcd.print(value);
}

void setTemp(){
  if(btemp){
    if (!digitalRead(upButton)){

      currentMillis = millis();  
      if (currentMillis - startMillis >= period)  
      {
        setTempUp();
        startMillis = currentMillis;  
      }
      templimit();
      afficheValue(13, 1, temperatur);

    }
    if (!digitalRead(downButton)){

      currentMillis = millis();  
      if (currentMillis - startMillis >= period)  
      {
        setTempDown();
        startMillis = currentMillis;  
      }
      templimit();
      afficheValue(13, 1, temperatur);

    }
    setBtempfalse();
  }
}

void setTempMin(){
  if(btemp){
    if (!digitalRead(upButton)){

      currentMillis = millis();  
      if (currentMillis - startMillis >= period)  
      {
        setTempMinUp();
        startMillis = currentMillis;  
      }
      tempMinlimit();
      afficheValue(13, 2, tempMin);;

    }
    if (!digitalRead(downButton)){

      currentMillis = millis();  
      if (currentMillis - startMillis >= period)  
      {
        setTempMinDown();
        startMillis = currentMillis;  
      }
      tempMinlimit();
      afficheValue(13, 2, tempMin);;

    }
    setBtempfalse();
  }
}

void setTempMax(){
  if(btemp){
    if (!digitalRead(upButton)){

      currentMillis = millis();  
      if (currentMillis - startMillis >= period)  
      {
        setTempMaxUp();
        startMillis = currentMillis;  
      }
      tempMaxlimit();
      afficheValue(13, 3, tempMax);;

    }
    if (!digitalRead(downButton)){

      currentMillis = millis();  
      if (currentMillis - startMillis >= period)  
      {
        setTempMaxDown();
        startMillis = currentMillis;  
      }
      tempMaxlimit();
      afficheValue(13, 3, tempMax);;

    }
    setBtempfalse();
  }
}

void setTempUp(){
  temperatur = temperatur + tempStep;
}
void setTempDown(){
  temperatur = temperatur - tempStep;
}
void templimit(){
  if (temperatur <= normTempMin){
    temperatur = normTempMin;
  }
  if (temperatur >= normTempMax){
    temperatur = normTempMax;
  }
}

void setTempMaxUp(){
  tempMax = tempMax + tempStep;
}
void setTempMaxDown(){
  tempMax = tempMax - tempStep;
}
void tempMaxlimit(){
  if (tempMax <= normTempMin){
    tempMax = normTempMin;
  }
  if (tempMax >= normTempMax){
    tempMax = normTempMax;
  }
}

void setTempMinUp(){
  tempMin = tempMin + tempStep;
}
void setTempMinDown(){
  tempMin = tempMin - tempStep;
}
void tempMinlimit(){
  if (tempMin <= normTempMin){
    tempMin = normTempMin;
  }
  if (tempMin >= normTempMax){
    tempMin = normTempMax;
  }
}
void setBtempTrue(){
  if (!digitalRead(selectButton)){
    btemp = true;
    while (!digitalRead(selectButton));
  }
}
void setBtempfalse(){
  if (!digitalRead(selectButton)){
    btemp = false;
    while (!digitalRead(selectButton));
  }
}