#include <LiquidCrystal.h>
#include <JC_Button.h>

// output pins
const byte PIN_EV_OLIO = 2;
const byte PIN_EV_ARIA = 3;
const byte PIN_EV_VACUUM = 4;
const byte PIN_VACUUM_PUMP = 5;

// input pins
const byte PIN_BTN_1 = A0;
const byte PIN_BTN_2 = A1;

//                RS, E,  D4, D5, D6, D7
LiquidCrystal lcd(12, 11, 10, 9, 8, 7);

Button btn1(PIN_BTN_1);
Button btn2(PIN_BTN_2);

byte fase;
byte ripetizioni = 0;

byte program1State = 0;
byte saveFase;

bool g_delayAbort;
bool safetyAlgoEnd;

void process() {
// !!! NON usare QUI mai dly(t) !!!
// Puoi usare delay(t) (non consigliato)

    btn1.read();
    btn2.read();
    if (btn1.wasPressed()) {
        //Serial.println(".");
        if (program1State == 0) {
            Serial.println("programma1 in esecuzione");
            program1State = 1;
        } else if (program1State == 1) {
            dlyAbort();
            saveFase = fase;
            Serial.println(fase);
            Serial.println("programma1 in pausa");
            program1State = 2;
               
        } else if (program1State == 2) {
            Serial.println("programma1 riprende l'esecuzione");
            program1State = 1;
            safetyAlgoEnd = false;
        }
    }
}

void dlyAbort() {
    g_delayAbort = true;
}


// copiata dal core lib di arduino per AVR
void dly(unsigned long ms) {
	uint32_t start = micros();

	while (ms > 0) {
		process();       // chiama update
		while ( ms > 0 && (micros() - start) >= 1000) {
      
			ms--;
			start += 1000;
      if (g_delayAbort) {
          g_delayAbort = false;
          ms = 0;
      }
		}
	}
}

void programma1() {
    switch(fase) {
      case 0:
          // APERTURA ELETTROVALVOLA PASSAGGIO OLIO
          Serial.println("OPEN EV_OIL");
          digitalWrite(PIN_EV_OLIO, HIGH);
          dly(2000);
          fase = 1;
          break;
      case 1:
          // CHIUSURA ELETTROVALVOLA PASSAGGIO OLIO
          Serial.println("CLOSE EV_OIL");
          digitalWrite(PIN_EV_OLIO, LOW); 
          dly(1000);
          fase = 2;
          break;
      case 2:
          // APERTURA ELETTROVALVOLA SCARICO ARIA
          Serial.println("OPEN EV_ARIA");
          digitalWrite(PIN_EV_ARIA, HIGH);   
          dly(2000);
          fase = 3;
          break;
      case 3:
          // CHIUSURA  SCARICO ARIA
          Serial.println("CLOSE EV_ARIA");
          digitalWrite(PIN_EV_ARIA, LOW); 
          dly(1000);
          
          fase = 4; // dopo  il delay verrà eseguito il case 4
          break;
      case 4:
          Serial.println("OPEN EV_VACUUM");
          digitalWrite(PIN_EV_VACUUM, HIGH); 
          dly(2000);
          fase = 5; 
          break;
      case 5:
          Serial.println("RUN VACUUM PUMP");
          digitalWrite(PIN_VACUUM_PUMP, HIGH); 
          dly(2000);
          fase = 6;  
          break;
      case 6:
          Serial.println("CLOSE EV VACUUM");
          digitalWrite(PIN_EV_VACUUM, LOW); 
          dly(1000);
          fase = 7; 
          break;
      case 7:
          Serial.println("STOP VACUUM PUMP");
          digitalWrite(PIN_VACUUM_PUMP, LOW); 
          dly(1000);
          fase = 8; 
          break;
      case 8:
          Serial.println("OPEN EV_ARIA");
          // APERTURA SCARICO ARIA
          digitalWrite(PIN_EV_ARIA, HIGH);  
          dly(2000);
          fase = 9; 
          break;
      case 9:
          Serial.println("CLOSE EV_ARIA");
          // CHIUSURA  SCARICO ARIA
          digitalWrite(PIN_EV_ARIA, LOW); 
          dly(1000);
          fase = 10; 
          break;
    }
}

void setup() {
    btn1.begin();
    pinMode(LED_BUILTIN, OUTPUT);
    pinMode(PIN_EV_OLIO, OUTPUT);
    pinMode(PIN_EV_ARIA, OUTPUT);
    pinMode(PIN_EV_VACUUM, OUTPUT);
    pinMode(PIN_VACUUM_PUMP, OUTPUT);
      
    lcd.begin(16, 2);

    Serial.begin(115200);
}

// algoritomo di sicurezza eseguito durante la pausa
// algoritmo "bloccante"
void safetyAlgo() {
  if (!safetyAlgoEnd) {
    digitalWrite(PIN_EV_VACUUM, LOW);
    digitalWrite(PIN_VACUUM_PUMP, LOW); 
    digitalWrite(PIN_EV_OLIO, LOW); 
    digitalWrite(PIN_EV_ARIA, HIGH);
    delay(3000);      // <-- Usa delay al posto di dly
    digitalWrite(PIN_EV_ARIA, LOW);
    Serial.println("safety end");
    safetyAlgoEnd = true;
  }
}

void loop() {
    if (program1State == 1) {
        // numero di ripetizioni 10
        if (ripetizioni < 10) {
            
            programma1();
            // da fase 0 a fase 9 10 fasi in totale
            if (fase == 10) {
                ripetizioni++;
                Serial.print("ripetizioni = ");
                Serial.println(ripetizioni);
                fase = 0;
            }
        } else {
            Serial.println("Fine programma 1");
            program1State = 0;
            ripetizioni = 0;
        }
    } else if (program1State == 2) {
        // eseguito quando in pausa
        fase = 0;  // riparte da fase 0
        
        safetyAlgo(); 
        process();
    } else {
        process();
    }
    
    
    
    //sprintf(lcdBuffer, "%-4u", th);
      
}