#include <Keypad.h>
#include <SoftwareSerial.h>

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

uint8_t colPins[COLS] = { A4, A5, A6, A7 }; // Pins connected to C1, C2, C3, C4
uint8_t rowPins[ROWS] = { A0, A1, A2, A3 }; // Pins connected to R1, R2, R3, R4

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

bool code = false;
bool phare = false;
bool stop = false;
bool appPhare = false;
bool clignoG = false;
bool clignoD = false ;
bool extClignoG = false;
bool extClignoD = false;
bool warning = false ;
bool extWarning = false; 
bool alimEcu = false;
bool armEcl = true ;
bool armCligno = true;
bool armPhare = true ;
bool armEcu = true;


const int inputStop = 22;
const int inputCode = 23;
const int inputPhare = 25;
const int inputAppPhare = 27;
const int inputClignoG = 29;
const int inputClignoD = 31;
const int inputWarning = 33;
const int inputEcu = 35;
const int commStop = 4;
const int commCode = 2;
const int commPhare = 3;
const int commVeill = 5;
const int commClignoG = 6;
const int commClignoD = 7;
const int commEcu = 8;
const int contrEcu = 9;
const int delaiCligno = 125;
const int reboundDelay = 80;

byte mCligno = 0;
byte mEclai = 0;
byte mEcu = 0;
byte lastEclai = 0;
byte lastCligno = 0;
unsigned int currentMillis = 0;
unsigned int lastMillis = 0 ;
unsigned int lastMillisBouton = 0;
char keyPressed = IDLE ;
char keyPhare = 0;
char key = NO_KEY;

void setup()
{
  pinMode(LED_BUILTIN, OUTPUT);
  pinMode(commCode, OUTPUT);
  pinMode(commPhare, OUTPUT);
  pinMode(commStop, OUTPUT);
  pinMode(commVeill, OUTPUT);
  pinMode(commClignoG, OUTPUT);
  pinMode(commClignoD, OUTPUT);
  pinMode(commEcu, OUTPUT);
  pinMode(contrEcu, OUTPUT);
  pinMode(inputStop, INPUT_PULLUP);
  pinMode(inputCode, INPUT_PULLUP);
  pinMode(inputPhare, INPUT_PULLUP);
  pinMode(inputAppPhare, INPUT_PULLUP);
  pinMode(inputClignoG, INPUT_PULLUP);
  pinMode(inputClignoD, INPUT_PULLUP);
  pinMode(inputWarning, INPUT_PULLUP);
  pinMode(inputEcu, INPUT_PULLUP);
  Serial.begin(19200);
}

void loop()
{
  currentMillis = millis();
  // Serial.print("temps :");
  //Serial.println(currentMillis);
  key = keypad.getKey();//lecture touche enfoncé
  keyPressed = keypad.getState();//utile pour fonction eclairage appel de phare
  switch (key) {// tambour de selection variable pour les autres fonctions, controle externe placé sur no_Key
    case NO_KEY :
      //Serial.println("pas de touche");
      if (currentMillis - lastMillisBouton >= reboundDelay){
      code = !digitalRead(inputCode);
      phare = !digitalRead(inputPhare);
      appPhare = !digitalRead(inputAppPhare);
      extClignoG = !digitalRead(inputClignoG);
      extClignoD = !digitalRead(inputClignoD);
      extWarning = !digitalRead(inputWarning);
      alimEcu = !digitalRead(inputEcu);
      lastMillisBouton = currentMillis;
      clignoG = false;
      clignoD = false;
      warning = false;
      
      }
      break;

    case '1':
      alimEcu = true;
      break;
    case '4' :
      clignoG = true;
      clignoD = false;
      warning = false;
      break;
    case '5':
      clignoG = false;
      clignoD = false;
      warning = true;
      break;
    case '6' :
      clignoG = false;
      clignoD = true;
      warning = false;
      break;
    case '7' :
      code = false;
      phare = false;
      appPhare = true;
      break;
    case '8' :
      code = true;
      phare = false;
      appPhare = false;
      break ;
    case '9' :
      code = false;
      phare = true;
      appPhare = false;
      break;
  }
  //Serial.print("key : ");
  //Serial.println(key);
  fStop(digitalRead(inputStop));
  eclairage(code, phare, appPhare);
  cligno(clignoG, clignoD, warning, extClignoG, extClignoD, extWarning);
  gestMot(alimEcu);
  
}
void eclairage( bool code, bool phare, bool appPhare) {  //Fonction eclairage
  if (armEcl == true && code == true ) {//Demande code et verif arm debounce
    armEcl = false;
    switch (mEclai) {
      case 0:
        mEclai = 1;
        break;
      case 1:
        mEclai = 0;
        break;
      case 2:
        mEclai = 0;
        break;

    }
    Serial.println("suce le coucou");
  }
  if (armEcl == true && phare == true ) {//demande phare et verif arm debounce
    armEcl = false;
    switch (mEclai) {
      case 0:
        mEclai = 0;
        break;
      case 1:
        mEclai = 2;
        break;
      case 2:
        mEclai = 1;
    }
  }
  if (appPhare == true) {//demande appel de phares
    switch (mEclai) {
      case 0 :
        lastEclai = 0;
        mEclai = 3;
        break;
      case 1 :
        lastEclai = 1;
        mEclai = 3;
        break;
      case 2 :
        break;
    }

  }
  switch (mEclai) {//Mise en fonction eclairage selon mEclai
    case 0 :
      digitalWrite(commCode, LOW);
      digitalWrite(commVeill, LOW);
      digitalWrite(commPhare, LOW);
      break;
    case 1 :
      digitalWrite(commCode, HIGH);
      digitalWrite(commVeill, HIGH);
      digitalWrite(commPhare, LOW);
      break;
    case 2:
      digitalWrite(commCode, LOW);
      digitalWrite(commVeill, HIGH);
      digitalWrite(commPhare, HIGH);
      break;
    case 3:
      armEcl = false,
      digitalWrite(commPhare, HIGH);
      break;

  }

  switch (keyPressed) {// controle appuie bouton appel de phare (bug: verifie tout le clavier a corriger)
    case PRESSED:
      armPhare = false;
      break;
    case IDLE:
      armPhare = true;
      break;
    case HOLD:
      armPhare = false;
      break;
    case RELEASED:
      armPhare = true;
      break;
  }

  if ( armPhare == true && appPhare == false  && mEclai == 3 ) {// retour état initial apres laché bouton
    mEclai = lastEclai;
  }

  if (phare == false && code == false) {//rearmement armEcl si code et phare 0
    armEcl = true;

  }
  //Serial.print("mEclai :");
  //Serial.println(mEclai);
}
void fStop(bool stop) { //fonction feu stop toute conne
  digitalWrite(commStop, stop);
  //Serial.print("stop :");
  //Serial.println(stop);
  return;
}

void cligno(bool gauche, bool droite, bool warning, bool extClignoG, bool extClignoD, bool extWarning) {
  if (extClignoD == true) {
    mCligno = 2;
  }
  if (armCligno == true) {// verification armement debounce pour demande cligno
    if (gauche == true) {// demande cligno gauche
      armCligno = false;
      switch (mCligno) {
        case 0 :
          mCligno = 1;
          break;
        case 1 :
          mCligno = 0;
          break;
        case 2 :
          mCligno = 1 ;
      }
    }
    else if (droite == true ) {// demande cligno droit
      armCligno = false;
      switch (mCligno) {
        case 0 :
          mCligno = 2;
          break;
        case 1 :
          mCligno = 2;
          break;
        case 2 :
          mCligno = 0 ;
      }
    }
    else if (warning == true ) { // demande warning
      armCligno = false;
      switch (mCligno) {
        case 0 :
          digitalWrite(commClignoG, LOW);
          digitalWrite(commClignoD, LOW);
          lastCligno = 0;
          mCligno = 3;
          break;
        case 1 :
          digitalWrite(commClignoG, LOW);
          digitalWrite(commClignoD, LOW);
          lastCligno = 1;
          mCligno = 3;
          break;
        case 2 :
          digitalWrite(commClignoG, LOW);
          digitalWrite(commClignoD, LOW);
          lastCligno = 2;
          mCligno = 3;
          break;
        case 3:
          mCligno = lastCligno;
          break;
      }
    }
  }
  if (currentMillis - lastMillis >= delaiCligno) {// Mise en fonction clignotant selon mCligno
    switch (mCligno) {
      case 0 :
        digitalWrite(commClignoG, LOW);
        digitalWrite(commClignoD, LOW);
        lastMillis = currentMillis ;
        break;
      case 1 :
        digitalWrite(commClignoG, !digitalRead(commClignoG));
        lastMillis = currentMillis ;
        digitalWrite(commClignoD, LOW);
        break;
      case 2 :
        digitalWrite(commClignoD, !digitalRead(commClignoD));
        lastMillis = currentMillis ;
        digitalWrite(commClignoG, LOW);
        break;
      case 3 :
        digitalWrite(commClignoD, !digitalRead(commClignoD));
        digitalWrite(commClignoG, !digitalRead(commClignoG));
        lastMillis = currentMillis ;
    }
  }
  if (gauche == false && droite == false && warning == false) { // rearmement cligno debounce
    armCligno = true;
  }
  Serial.print("mCligno :");
  Serial.println(gauche);
}

void gestMot(bool alimEcu) {
  if (alimEcu == true && armEcu == true) {
    Serial.println("coucou");
    armEcu = false;
    switch (mEcu) {
      case 0:
        mEcu = 1;
        break;
      case 1:
        mEcu = 0;
        break;
    }

  }
  switch (mEcu) {
    case 0:
      digitalWrite(commEcu, LOW);

      break;
    case 1:
      digitalWrite(commEcu, HIGH);

      break;
  }
  digitalWrite(contrEcu, digitalRead(commEcu));
  if (alimEcu == false ) {
    armEcu = true;
  }

}