#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#include "ParameterControl.h"
#include "zpr.h"

LiquidCrystal_I2C lcd(0x27, 20, 4);
// IO Variables
int IO_sPorte = 1;
int IO_sTemp = 2;
int IO_sHumi = 3;
int IO_sCO2 = 4;
int IO_Chauff1 = 13;
int IO_Chauff2 = 6;
int IO_Humi = 12;
int IO_Vntl = 8;
int IO_Extr = 9;
int IO_Md = 10;
int IO_Mg = 11;
int IO_Ecl = 12;

bool start = true;

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

bool bmenu;
bool bsmenu;
bool bselect;
bool bmode;
bool btemp;
bool bhumi;
bool bmotor;
bool backlight = true;


unsigned long startMillis;
unsigned long currentMillis;
unsigned long blstart;
unsigned long blcurrent;
const unsigned long tperiod = 50;
const unsigned long hperiod = 5;
const unsigned long mperiod = 200;
const unsigned long blperiod = 15000;

// Mode
bool bsmode1 =false;
bool bsmode2 =false;
bool bsmode3 =true;
String incubation = "Incubation";
String incubation1 = "__Oeufs_de_poules___";
String incubation2 = "__Oeufs_de_canards__";
String incubation3 = "__Oeufs_de_cailles__";
String date = "Livraison";



// Tempertur
const float tempStep = 0.01;
float temperatur = 38.5;
float istemp = 00.00;
float tempMax = 40.0;
float tempMin = 35.0;
float normTempMax = 40.0;
float normTempMin = 35.0;

// Humidity
const float humiStep = 0.01;
float humidity = 45.00;
float ishumi = 48.23;
float humiMax = 99.99;
float humiMin = 35.0;
float normHumiMax = 99.99;
float normHumiMin = 35.0;

// Motor
float turntime = 05.50;
bool automatik = true;
float motorStep = 0.25;
float normTurntimeMax = 24.0;
float normTurntimeMin = 00.0;

// Date
int  isttime = 14;
int solltime = 21;

//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 = "Oeuf Poule";
String mode2 = "Oeuf canard";
String mode3 = "Oeuf caille";

//Sous-Menu solltempe
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 = "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[] = {
  B11000,
  B11001,
  B00010,
  B00100,
  B01000,
  B10011,
  B00011,
  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
};




unsigned long myTimer1 = 0;
unsigned long myTimeout1 = 10;

unsigned long myTimer2 = 0;
unsigned long myTimeout2 = 10;

//int sensortemp = A0;
#define sensortemp 3
OneWire oneWire(sensortemp);
DallasTemperature sensors(&oneWire);
zpr tzpr;
zpr hzpr;







ParameterControl temperatureControl(lcd, upButton, downButton, selectButton, tempStep, &temperatur, &bselect);
ParameterControl tempMaxControl(lcd, upButton, downButton, selectButton, tempStep, &tempMax, &bselect);
ParameterControl tempMinControl(lcd, upButton, downButton, selectButton, tempStep, &tempMin, &bselect);
ParameterControl humidityControl(lcd, upButton, downButton, selectButton, humiStep, &humidity, &bselect);
ParameterControl humiMaxControl(lcd, upButton, downButton, selectButton, humiStep, &humiMax, &bselect);
ParameterControl humiMinControl(lcd, upButton, downButton, selectButton, humiStep, &humiMin, &bselect);
ParameterControl turntimeControl(lcd, upButton, downButton, selectButton, motorStep, &turntime, &bselect);

// Create instance of MenuSystem
//MenuSystem menuSystem(10, 1, downButtonPin, upButtonPin, selectButtonPin);













void setup() {
  initialisation();
  pinConfig();
  //gestionAfiche();
  //afficheDefaut();
}

void loop() {


  run();
  gestionAfiche();
  processControl(start);
  
}
void initialisation(){
  lcd.begin(20, 4);
  lcd.init();
  sensors.begin();
  Serial.begin(9600);
  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.clear();

  humidityControl.settPeriode(5);
  humiMaxControl.settPeriode(5);
  humiMinControl.settPeriode(5);
  turntimeControl.settPeriode(100);
}
void pinConfig(){
  //IO-Input / Capteurs
  pinMode(upButton, INPUT_PULLUP);
  pinMode(downButton, INPUT_PULLUP);
  pinMode(selectButton, INPUT_PULLUP);
  pinMode(IO_sHumi, INPUT);
/*  
  pinMode(IO_sPorte, INPUT);
  pinMode(IO_sTemp, INPUT);
  pinMode(IO_sHumi, INPUT);
  pinMode(IO_sCO2, INPUT);

  //IO-Output / Acteurs
  pinMode(IO_Chauff1, OUTPUT);
  pinMode(IO_Chauff2, OUTPUT);
  pinMode(IO_Humi, OUTPUT);
  pinMode(IO_Vntl, OUTPUT);
  pinMode(IO_Extr, OUTPUT);
  pinMode(IO_Md, OUTPUT);
  pinMode(IO_Mg, OUTPUT);
  pinMode(IO_Ecl, OUTPUT);
*/
}
void modeConfig(){

}
void run(){
  processSensorTemp();
  processSensorHumi();
  processControl(start);
}
void microSD(){

}

//Gestion des capteurs de temperature
void processSensorTemp(){
  sensors.requestTemperatures();
  istemp = sensors.getTempCByIndex(0);
}

//Gestion des capteurs d'humidité
void processSensorHumi(){
  sensors.requestTemperatures();
  ishumi = sensors.getTempCByIndex(0);
}














//Gestion des acteurs
void processControl(bool en){
  //Acteur de chauffage
  tzpr.def(true, istemp, tempMinControl.gettValue(), tempMaxControl.gettValue() );
  acteur(IO_Chauff1, en, tzpr.getAktiv());

  //Acteur humidificateur
  hzpr.def(true, ishumi, humiMinControl.gettValue(), humiMaxControl.gettValue() );
  acteur(IO_Humi, en, hzpr.getAktiv());

  //Moteur tourne gauche

  //Moteur tourne droite

  //Eclerage
  
}

//fonction actionneurs
void acteur(int pin, bool en, bool aktiv){
  digitalWrite(pin, (en && aktiv));
}

// affichage du menu principal
void gestionAfiche(){

  if ((!digitalRead(upButton) || !digitalRead(downButton) || !digitalRead(selectButton)) && !bmenu){
    bmenu = true;
    lcd.backlight();
    updateMenu();
    while (!digitalRead(upButton) || !digitalRead(downButton) || !digitalRead(selectButton));
  }

  if (bmenu){
    menuPrincipal();

    if (!bmenu){
      blstart = millis();
      backlight = true;
    }
  }else{
    afficheDefaut();
  }
  sousMenu();

  if (!bmenu && backlight){
    blcurrent = millis();  
    if (blcurrent - blstart >= blperiod)  
    {
      blstart = blcurrent;
      lcd.noBacklight();
      backlight = false;
    }
    
  }
}

// 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)){
    bsmenu = true;
    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();
    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)){
    executeHumi();
    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)){
    executeMotor();
    while (!digitalRead(selectButton));
  }
}

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

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


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

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

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

void executeMode() {
  switch (mode) {
    case 1:
      modeAction1();
      break;
    case 2:
      modeAction2();
      break;
    case 3:
      modeAction3();
      break;
    case 4:
      bmode = false;
      backToMenu1();
      break;
  }
}

// du sousmenu Temp au action de stemp
void executeTemp() {
  switch (temp) {
    case 1:
      tempAction1();
      break;
    case 2:
      tempAction2();
      break;
    case 3:
      tempAction3();
      break;
    case 4:
      btemp = false;
      backToMenu1();
      break;
  }
}

// du sousmenu Humi au action de shumi
void executeHumi() {
  switch (humi) {
    case 1:
      humiAction1();
      break;
    case 2:
      humiAction2();
      break;
    case 3:
      humiAction3();
      break;
    case 4:
      bhumi = false;
      backToMenu1();
      break;
  }
}

// du sousmenu Motor au action de smotor
void executeMotor() {
  switch (motor) {
    case 1:
      motorAction1();
      break;
    case 2:
      motorAction2();
      break;
    case 3:
      motorAction3();
      break;
    case 4:
      bmotor = false;
      backToMenu2();
      break;
  }
}

// du menu au sousmenus
void menuToSmenu() {
  if(bsmenu){
    if(!digitalRead(selectButton)){
      if(menu == 1){
        mode = 1;
        updateMode();
        bmode = true;
      }else
      if(menu == 2){
        temp = 1;
        updateTemp();
        btemp = true;
      }else
      if(menu == 3){
        humi = 1;
        updateHumi();
        bhumi = true;
      }else
      if(menu == 4){
        motor = 1;
        updateMotor();
        bmotor = true;
      }else
      if(menu == 5){
        menu = 1;
        bmenu = false;
        backToDefaut();
      }
    }
  }
}


void sousMenu(){
  while(bmode){
    menuMode();
    run();
  }
  while(btemp){
    menuTemp();
  }
  while(bhumi){
    menuHumi();
  }
  while(bmotor){
    menuMotor();
  }
}

// Reglage du mode 1
void modeAction1(){
  if(!digitalRead(selectButton)){
    bsmode1 = true;
    bsmode2 = false;
    bsmode3 = false;
    updateMode();
    bselect=false;
  }
}

// Reglage du mode 2
void modeAction2(){
  if(!digitalRead(selectButton)){
    bsmode1 = false;
    bsmode2 = true;
    bsmode3 = false;
    updateMode();
    bselect=false;
  }
}

// Reglage du mode 3
void modeAction3(){
  if(!digitalRead(selectButton)){
    bsmode1 = false;
    bsmode2 = false;
    bsmode3 = true;
    updateMode();
    bselect=false;
  }
}

// Reglage de la solltempe 
void tempAction1(){
  setbselectTrue();
  while(temp == 1 && bselect ){
    temperatureControl.updateParameter(12, 1, tempMin, tempMax);
    run();
  }
}

// Reglage de la solltempe minimale 
void tempAction2(){
  setbselectTrue();
  while(temp == 2 && bselect ){
    tempMinControl.updateParameter(12, 2, normTempMin, tempMax);
    run();
  }
}

// Reglage de la solltempe maximale
void tempAction3(){
  setbselectTrue();
  while(temp == 3 && bselect ){
    tempMaxControl.updateParameter(12, 3, tempMin, normTempMax);
    run();
  }
}

// Reglage de l'humidité 
void humiAction1(){
  setbselectTrue();
  while(humi == 1 && bselect ){
    humidityControl.updateParameter(12, 1, humiMin, humiMax);
    run();
  }
}

// Reglage de l'humidité minimale 
void humiAction2(){
  setbselectTrue();
  while(humi == 2 && bselect ){
    humiMinControl.updateParameter(12, 2, normHumiMin, humiMax);
    run();
  }
}

// Reglage de l'humidité maximale
void humiAction3(){
  setbselectTrue();
  while(humi == 3 && bselect ){
    humiMaxControl.updateParameter(12, 3, humiMin, normHumiMax);
    run();
  }
}

// Reglage du motor 1
void motorAction1(){
  setbselectTrue();
  if(motor == 1 && bselect ){
    automatik = true;
    bselect = false;
    updateMotor();
  }
}

// Reglage de l'interval de rotation de moteur
void motorAction2(){
  setbselectTrue();
  while(motor == 2 && bselect ){
    turntimeControl.updateParameter(12, 2, normTurntimeMin, normTurntimeMax);
    run();
  }
}

// Reglage du motor 3
void motorAction3(){
  setbselectTrue();
  if(motor == 3 && bselect ){
    automatik = false;
    bselect = false;
    updateMotor();
  }
}

// retour au principale
void backToMenu1(){
  afficheMenuLCD1();
  setBsmenuFalse();
}

// retour au principale
void backToMenu2(){
  afficheMenuLCD2();
  setBsmenuFalse();
}

// retour au principale
void backToDefaut(){
  lcd.clear();
  afficheDefaut();
  setBmenuFalse();
}

// Affichage par defaut
void afficheDefaut(){
  if(bsmode1){
    afficheText(0, 0, incubation1);
  }
  else
  if(bsmode2){
    afficheText(0, 0, incubation2);
  }
  else
  if(bsmode3){
    afficheText(0, 0, incubation3);
  }
  afficheText(0, 1, "Temp");
  afficheDecale(6, 1, istemp);
  //afficheValue(6, 1, istemp);
  afficheText(12, 1, "/");
  afficheValue(14, 1, temperatur);
  afficheSymbole(19, 1, Grad);
  afficheText(0, 2, "Humi");
  afficheValue(6, 2, ishumi);
  afficheText(12, 2, "/");
  afficheValue(14, 2, humidity);
  afficheSymbole(19, 2, dimRH);
  afficheText(0, 3, date);
  afficheValue(10, 3, isttime);
  afficheText(12, 3, "/");
  afficheValue(13, 3, solltime);
  afficheText(16, 3, "Days");
}

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

// Affichage des elements du menu mode
void afficheModeLCD1(){
  lcd.clear();
  afficheText(0, 0, smode);
  afficheText(2, 1, mode1);
  afficheText(2, 2, mode2);
  afficheText(2, 3, mode3);
  if(bsmode1){
    afficheSymbole(18, 1, yes);
  }
  else
  if(bsmode2){
    afficheSymbole(18, 2, yes);
  }
  else
  if(bsmode3){
    afficheSymbole(18, 3, yes);
  }
  afficheSymbole(0, mode, select);
  afficheSymbole(19, 3, down);
}
void afficheModeLCD2(){
  lcd.clear();
  afficheText(0, 0, smode);
  afficheText(2, 1, retour);
  afficheSymbole(0, mode-3, select);
  afficheSymbole(19, 1, up);
}

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

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

// Affichage des elements du menu Motor
void afficheMotorLCD1(){
  lcd.clear();
  afficheText(0, 0, smotor);
  afficheText(2, 1, motor1);
  afficheText(2, 2, motor2);
  afficheText(2, 3, motor3);
  afficheValue(12, 2, turntime);
  afficheText(18, 2, "h");
  if(automatik){
  afficheSymbole(18, 1, yes);
  }
  else
  {
  afficheSymbole(18, 3, yes);
  }
  afficheSymbole(0, motor, select);
  afficheSymbole(19, 3, down);
}
void afficheMotorLCD2(){
  lcd.clear();
  afficheText(0, 0, smotor);
  afficheText(2, 1, retour);
  afficheSymbole(0, motor-3, select);
  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 float à une positon donnée
void afficheValue(int col, int row, float value){
  lcd.setCursor(col, row);
  lcd.print(value, 2);
}

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

//Gestion de l'affiche avec decalage de chiffres
void afficheDecale(int col, int row, float value){
  if (value > 0.0 && value < 10.0){
    afficheValue(col, row, 0);
    afficheValue((col + 1), row, value);
  }
  else if(value > 99.99 || value < -9.99){
    afficheText(col, row, "Error");
  }
  else{
    afficheValue(col, row, value);
  }
}


void setbselectTrue(){
  if (!digitalRead(selectButton)){
    bselect = true;
    while (!digitalRead(selectButton));
  }
}
void setbselectfalse(){
  if (!digitalRead(selectButton)){
    bselect = false;
    while (!digitalRead(selectButton));
  }
}

void setBsmenuFalse(){
  if (!digitalRead(selectButton)){
    bsmenu = false;
    while (!digitalRead(selectButton));
  }
}

void setBmenuFalse(){
  if (!digitalRead(selectButton)){
    bmenu = false;
    while (!digitalRead(selectButton));
  }
}