#include <Arduino.h>

// Intigrierte Bibliotheken
#include <Wire.h>
#include <EEPROM.h>
#include <LiquidCrystal_I2C.h>

// Adressierung des LCD
LiquidCrystal_I2C lcd(0x27, 20, 4);

// Counter für die Spieler
byte counter_1 = 0;
byte counter_2 = 0;
byte counter_3 = 0;
byte counter_4 = 0;
byte counter[4] = { counter_1, counter_2, counter_3, counter_4 };
// Timer für das Rücksetzen der Counter
unsigned long counter_millis = 0;

// Speicheradressen im EEPROM anlegen
int eeprom_address_1 = 0;
int eeprom_address_2 = 1;
int eeprom_address_3 = 2;
int eeprom_address_4 = 3;
int eeprom_adresses[4] = { eeprom_address_1, eeprom_address_2, eeprom_address_3, eeprom_address_4 };


// Belegung der Ventile
const byte pin_valve1 = 12;
const byte pin_valve2 = 10;
const byte pin_valve3 = 8;
const byte pin_valve4 = 6;
byte valvePins[4] = { pin_valve1, pin_valve2, pin_valve3, pin_valve4 };

// Variablen zum Speichern der Zustände für die Valves
bool valve1_flag = false;
bool valve2_flag = false;
bool valve3_flag = false;
bool valve4_flag = false;
bool valve_flags[4] = { valve1_flag, valve2_flag, valve3_flag, valve4_flag };

// Belegung der LED-Stripes
const byte pin_led_stripe1 = 11;
const byte pin_led_stripe2 = 9;
const byte pin_led_stripe3 = 7;
const byte pin_led_stripe4 = 5;
const byte pin_status_led = 4;
byte led_pins[5] = { pin_led_stripe1, pin_led_stripe2, pin_led_stripe3, pin_led_stripe4, pin_status_led };

// Variablen zum Speichern der Zustände für die LED-Stripes
bool led_stripe1_flag = false;
bool led_stripe2_flag = false;
bool led_stripe3_flag = false;
bool led_stripe4_flag = false;
bool status_led_flag = false;
bool led_flags[5] = { led_stripe1_flag, led_stripe2_flag, led_stripe3_flag, led_stripe4_flag, status_led_flag };

// Timer für das Blinken der LEDS
unsigned long led_millis = 0;

// Belegung des Taster
const byte pin_start_button = A2;
const byte pin_flush_button = A3;
byte button_pins[2] = { pin_start_button, pin_flush_button };

// Variablen für die Taster

// Variablen für den Start_Taster
bool button1_read = false;
bool button1_on = false;
bool switch1 = false;
// Timer für den Start_Taster
unsigned long button1_millis = 0;

// Variablen für den Flush_Taster
bool button2_read = false;
bool button2_on = false;
bool switch2 = false;
// Timer für den Flush_Taster
unsigned long button2_millis = 0;

// Belegung der Toggleschalter
const byte pin_toggle_switch1 = 3;
const byte pin_toggle_switch2 = 2;
const byte pin_toggle_switch3 = A0;
const byte pin_toggle_switch4 = A1;
byte toggle_switch_pins[4] = { pin_toggle_switch1, pin_toggle_switch2, pin_toggle_switch3, pin_toggle_switch4 };

// Variablen zum Auslesen der Toggleschalter
bool toggle_switch1 = false;
bool toggle_switch2 = false;
bool toggle_switch3 = false;
bool toggle_switch4 = false;
bool toggle_switches[4] = { toggle_switch1, toggle_switch2, toggle_switch3, toggle_switch4 };

// Pin zum Auslesen des Spannungssensors
const byte pin_voltage_value = A6;

// Variablen für den Spannungssensor
int voltage_value_raw = 0;
float voltage_value = 0;
// Timer für den Spannungssensor
unsigned long sensor_millis = 0;

// Timer für den Serial_Monitor
unsigned long serial_millis = 0;

// Timer für die Operation_States
unsigned long op_state_millis = 0;

// Timer für die Steuerung der Zustände
unsigned long section_timer[3] = {
  5000,  // Operation_state blink_select timer
  5000,  // Operation_state selection_done timer
  5000   // Operation_state open_valve timer
};

// Timer zum Steuern der Open-Intervalle
unsigned long open_timer[4] = {
  8000,  // 1 Ventile geöffnet 
  6000,  // 2 Ventile geöffnet
  4000,  // 3 Ventile geöffnet
  2000   // 4 Ventile geöffnet
  };

// Setzen der Section_Counters zum Einstellen der Zeit
bool time_counter[4] = {false, false, false, false}; 
byte time_changer = 0;


// Setzen der State_Maschine
enum current_operation_state {
  system_standby,  // OP_State = 0;
  blink_select,    // OP_State = 1;
  selection_done,  // OP_State = 2;
  open_valves,     // OP_State = 3;
  flush,           // OP_State = 4;
};
current_operation_state operation_state = system_standby;

// Variable das Auslesen des Analogen inputs für den Zufallsgenerator
int random_analog = 0;

// Variable für den Zufallsgenerator
byte random_number1 = 0;
byte random_number2 = 0;
byte random_number3 = 0;
byte random_number4 = 0;
byte random_numbers[4] = { random_number1, random_number2, random_number3, random_number4 };

// Speicherung des letzten Zustands für die Counter
byte previous_state = system_standby;


// Vorausdeklaration der Abschnitte
void measure_voltage();
void read_inputs();
void update_serial_monitor();
void update_lcd_display();
void setup_start_button();
void setup_flush_button();
void setup_random_selection();
void setup_counter();
void setup_timer();
void mangage_operation_states();
void execute_operation_states();
void execute_OUTPUTS();

void setup() {

  Serial.begin(9600);

  // Setzen der Outputs für die Ventile
  Serial.println("Setzen der Outputs für die Ventile: ");
  for (byte i = 0; i < 4; i++) {
    pinMode(valvePins[i], OUTPUT);
    Serial.print("Pins: ");
    Serial.print(valvePins[i]);
    Serial.println(" auf OUTPUT gesetzt.");
  }

  // Setzen der Outputs für die LEDs
  Serial.println("Setzen der Outputs für die LEDs: ");
  for (byte i = 0; i < 5; i++) {
    pinMode(led_pins[i], OUTPUT);
    Serial.print("Pins : ");
    Serial.print(led_pins[i]);
    Serial.println(" auf OUTPUT gesetzt.");
  }

  // Setzen der Inputs für die Taster
  Serial.println("Setzen der Input-Pullups für die Taster: ");
  for (byte i = 0; i < 2; i++) {
    pinMode(button_pins[i], INPUT_PULLUP);
    Serial.print("Pins : ");
    Serial.print(button_pins[i]);
    Serial.println(" auf INPUT-PULLUP gesetzt.");
  }

  // Setzen der Inputs für die Toggleschalter
  Serial.println("Setzen der Input-Pullups für die Toggleschalter: ");
  for (byte i = 0; i < 4; i++) {
    pinMode(toggle_switch_pins[i], INPUT_PULLUP);
    Serial.print("Pins: ");
    Serial.print(toggle_switch_pins[i]);
    Serial.println(" auf INPUT_PULLUP gesetzt.");
  }

  // Die aktuellen Counter aus dem Speicher lesen
  for (byte i = 0; i < 4; i++) {
    counter[i] = EEPROM.read(eeprom_adresses[i]);
  }

  // Wenn der Wert im EEPROM ungültig ist (z.B. 255), dann auf 0 setzen
  for (byte i = 0; i < 4; i++) {
    if (counter[i] == 255) {
      counter[i] = 0;
    }
  }

  // Initialisierung des LCD
  lcd.init();
  lcd.backlight();
}

void loop() {

  // Abruf der einzelnen Funktionen
  
  // Abruf der Funktion zum messen der Spannung
  measure_voltage();

  // Abruf der Funktion zum auslesen der Inputs
  read_inputs();

  // Abruf der Funktion zum Updaten des Serial_Monitors
  update_serial_monitor();

  // Abruf der Funktion zum Updaten des LCD-Displays
  update_lcd_display();

  // Abruf der Funktion für den Start_Taster
  setup_start_button();

  // Abruf der Funktion für den Flush_Taster
  setup_flush_button();

  // Abruf der Funktion zum Managen des Zufallgenerators
  setup_random_selection();

  // Abruf der Funktion für die Counter
  setup_counter();

  // Abruf der Funktion zum Managen der Timer
  setup_timer();

  // Abruf der Funktion zur Steuerung der Operation_states
  mangage_operation_states();

  // Abruf der Funktion zum Setzen der Ausgänge
  execute_operation_states();

  // Abruf der Funktion zum Setzen der Outputs
  execute_OUTPUTS();
}

//============================================================//
//========================FUNCTIONS===========================//
//============================================================//

void measure_voltage() {

  // Variablen für diesen Abschnitt
  voltage_value_raw = analogRead(pin_voltage_value);

  voltage_value = (float(voltage_value_raw) / 1023.0) * 25.0;
}

//============================================================//
//========================FUNCTIONS===========================//
//============================================================//

void update_serial_monitor() {

  // Timer für deisen Abschnitt
  unsigned long serial_timer = millis() - serial_millis;

  if (serial_timer > 200) {

    Serial.print(" s1: ");
    Serial.print(switch1);

    Serial.print(" s2: ");
    Serial.print(switch2);

    Serial.print(" OPSt: ");
    Serial.print(operation_state);

    Serial.print(" Time.Points: ");
    Serial.print(time_counter[0]);
    Serial.print(time_counter[1]);
    Serial.print(time_counter[2]);
    Serial.print(time_counter[3]);

    Serial.print(" t.Changer: ");
    Serial.print(time_changer);

    Serial.print(" Sensor: ");
    Serial.print(voltage_value);

    Serial.print(" open_valve_time: ");
    Serial.println(section_timer[2]);

    serial_millis = millis();
  }
}

//============================================================//
//========================FUNCTIONS===========================//
//============================================================//

void read_inputs() {

  // Auslesen der Inputs der Toggle_Schalter
  for (byte i = 0; i < 4; i++) {
    toggle_switches[i] = !digitalRead(toggle_switch_pins[i]);
  }

  // Auslesen des Analog-Eingangs, um Zufallszahlen zu generieren
  random_analog = analogRead(A7);
  randomSeed(random_analog);
}

//============================================================//
//========================FUNCTIONS===========================//
//============================================================//

void update_lcd_display() {

   switch(operation_state) {

  case system_standby:
  
  if (led_flags[0]) {
  lcd.setCursor(0, 0);
  lcd.print("TOURGE  =  ");
  lcd.setCursor(11, 0);
  lcd.print(counter[0]);
  lcd.setCursor(14, 0);
  lcd.print("Punkte");
  } else {
    lcd.setCursor(0, 0);
    lcd.print("WAS DA LOS       ?!?");
  }
  
  if (led_flags[1]) {
  lcd.setCursor(0, 1);
  lcd.print("KRIEG   =  ");
  lcd.setCursor(11, 1);
  lcd.print(counter[1]);
  lcd.setCursor(14, 1);
  lcd.print("Punkte");
  } else {
    lcd.setCursor(0, 1);
    lcd.print("KEINER BOCK      ?!?");
  }

  if (led_flags[2]) {
  lcd.setCursor(0, 2);
  lcd.print("PAIN    =  ");
  lcd.setCursor(11, 2);
  lcd.print(counter[2]);
  lcd.setCursor(14, 2);
  lcd.print("Punkte");
  } else {
    lcd.setCursor(0, 2);
    lcd.print("KOMM RAN         !!!");
  }

  if (led_flags[3]) {
  lcd.setCursor(0, 3);
  lcd.print("TERROR  =  ");
  lcd.setCursor(11, 3);
  lcd.print(counter[3]);
  lcd.setCursor(14, 3);
  lcd.print("Punkte");
  } else {
    lcd.setCursor(0, 3);
    lcd.print("SIEH ZU HIER     !!!");
  }
  break;


  case blink_select:

  lcd.setCursor(0, 0);
  lcd.print("                    ");
  lcd.setCursor(0, 1);
  lcd.print("    SAMMELT EUCH    ");
  lcd.setCursor(0, 2);
  lcd.print("                    ");
  lcd.setCursor(0, 3);
  lcd.print("                    ");
  break;


  case selection_done:

  if (led_flags[0] || led_flags[1] || led_flags[2] || led_flags[3]) {
  lcd.setCursor(0, 0);
  lcd.print("                    ");
  lcd.setCursor(0, 1);
  lcd.print("     DIE OPFER      ");
  lcd.setCursor(0, 2);
  lcd.print(" WURDEN AUSERKOREN  ");
  lcd.setCursor(0, 3);
  lcd.print("                    ");
  } else {
  lcd.setCursor(0, 0);
  lcd.print("                    ");
  lcd.setCursor(0, 1);
  lcd.print(" IHR MINDERWERTIGEN ");
  lcd.setCursor(0, 2);
  lcd.print("   TRUNK VERWEHRT   ");
  lcd.setCursor(0, 3);
  lcd.print("                    ");
  }
  break;


  case open_valves:
  if (led_flags[0] || led_flags[1] || led_flags[2] || led_flags[3]) {
  lcd.setCursor(0, 0);
  lcd.print("                    ");
  lcd.setCursor(0, 1);
  lcd.print("      SAUFT         ");
  lcd.setCursor(0, 2);
  lcd.print("      !!!!!         ");
  lcd.setCursor(0, 3);
  lcd.print("                    ");
  } else {
  lcd.setCursor(0, 0);
  lcd.print("                    ");
  lcd.setCursor(0, 1);
  lcd.print("    PECH GEHABT     ");
  lcd.setCursor(0, 2);
  lcd.print("      !!!!!         ");
  lcd.setCursor(0, 3);
  lcd.print("                    ");
  }
  break;

  case flush:

  lcd.setCursor(0, 0);
  lcd.print("                    ");
  lcd.setCursor(0, 1);
  lcd.print("      FLUTEN        ");
  lcd.setCursor(0, 2);
  lcd.print("      !!!!!!        ");
  lcd.setCursor(0, 3);
  lcd.print("                    ");
  break;
 }
}

//============================================================//
//========================FUNCTIONS===========================//
//============================================================//

void setup_start_button() {

  // Timer für deisen Abschnitt
  unsigned long button1_timer = millis() - button1_millis;
  unsigned long counter_timer = millis() - counter_millis;

  // Auslesen des Taster_Pins
  button1_read = digitalRead(button_pins[0]);

  if (button1_read) {
    button1_millis = millis();
    counter_millis = millis();
  }

  if (!button1_read && !button1_on && button1_timer > 20) {
    button1_on = true;
  }

  if (button1_read && button1_on) {
    button1_on = false;
    switch1 = !switch1;
  }

  if (counter_timer > 3000) {
    for (byte i = 0; i < 4; i++) {
      counter[i] = 0;
      eeprom_adresses[i] = 0;
      button1_on = false;
    }
  }
}

//============================================================//
//========================FUNCTIONS===========================//
//============================================================//

void setup_flush_button() {

  // Timer für deisen Abschnitt
  unsigned long button2_timer = millis() - button2_millis;

  // Auslesen des Taster_Pins
  button2_read = digitalRead(button_pins[1]);

  if (button2_read) {
    button2_millis = millis();
  }

  if (!button2_read && !button2_on && button2_timer > 20) {
    button2_on = true;
  }

  if (button2_read && button2_on) {
    button2_on = false;
    switch2 = !switch2;
  }
}

//============================================================//
//========================FUNCTIONS===========================//
//============================================================//

void setup_counter() {}

//============================================================//
//========================FUNCTIONS===========================//
//============================================================//

void setup_random_selection() {

  switch (operation_state) {

    case blink_select:

      for (byte i = 0; i < 4; i++) {
        random_numbers[i] = random(1, 3);
      }
      break;
  }
}

//============================================================//
//========================FUNCTIONS===========================//
//============================================================//

void setup_timer() {

  for (byte i = 0; i < 4; i++) {
    if (led_flags[i]) {
      time_counter[i] = true;
    } else {
      time_counter[i] = false;
    }
  }

  time_changer = time_counter[0] + time_counter[1] + time_counter[2] + time_counter[3];

  if (time_changer == 1) {
    section_timer[2] = open_timer[0];        // 1 Ventil aktiv
  } else if (time_changer == 2) {   
    section_timer[2] = open_timer[1];        // 2 Ventile aktiv
  } else if (time_changer == 3) {
    section_timer[2] = open_timer[2];        // 3 Ventile aktiv
  } else if (time_changer == 4) {
    section_timer[2] = open_timer[3];        // 4 Ventile aktiv
  }
}

//============================================================//
//========================FUNCTIONS===========================//
//============================================================//

void mangage_operation_states() {

  // Timer für diesen Abschnitt
  unsigned long op_state_timer = millis() - op_state_millis;
  previous_state = operation_state;


  if (switch1) {

    switch (operation_state) {

      case blink_select:
        if (op_state_timer > section_timer[0]) {
          operation_state = selection_done;
          op_state_millis = millis();
        }
        break;

      case selection_done:
        if (op_state_timer > section_timer[1]) {
          operation_state = open_valves;
          op_state_millis = millis();
          if (previous_state != open_valves) {
            for (byte i = 0; i < 4; i++) {
              if (led_flags[i]) {
                counter[i]++;
                EEPROM.write(eeprom_adresses[i], counter[i]);
              }
            }
          }
        }
        break;

      case open_valves:
        if (op_state_timer > section_timer[2]) {
          operation_state = system_standby;
          switch1 = false;
        }
        break;

      default:
        operation_state = blink_select;
        op_state_millis = millis();
        break;
    }
  } else {
    operation_state = system_standby;
  }

  if (switch2) {
    switch1 = false;
    operation_state = flush;
  }
}

//============================================================//
//========================FUNCTIONS===========================//
//============================================================//

void execute_operation_states() {

  // Timer für diesen Abschnitt
  unsigned long led_timer = millis() - led_millis;

  switch (operation_state) {

    case system_standby:

      for (byte i = 0; i < 4; i++) {
        led_flags[i] = toggle_switches[i];
      }

      for (byte i = 0; i < 4; i++) {
        valve_flags[i] = false;
      }

      led_flags[4] = true;

      led_millis = millis();
      break;

    case blink_select:

      for (byte i = 0; i < 4; i++) {
        if (toggle_switches[i]) {
          if (led_timer > 1000) {
            led_flags[i] = !led_flags[i];
          }
        }
      }

      if (led_timer > 1000) {
        led_flags[4] = !led_flags[4];
        led_millis = millis();
      }
      break;

    case selection_done:

      if (led_timer > 1000) {
        led_flags[4] = !led_flags[4];
        led_millis = millis();
      }

      for (byte i = 0; i < 4; i++) {
        if (random_numbers[i] >= 2) {
          led_flags[i] = true;
        } else {
          led_flags[i] = false;
        }
      }
      break;

    case open_valves:

      if (led_timer > 1000) {
        led_flags[4] = !led_flags[4];
        led_millis = millis();
      }

      for (byte i = 0; i < 4; i++) {
        if (led_flags[i]) {
          valve_flags[i] = led_flags[i];
        }
      }
      break;

    case flush:

      for (byte i = 0; i < 4; i++) {
        led_flags[i] = true;
      }

      for (byte i = 0; i < 4; i++) {
        valve_flags[i] = true;
      }
      break;
  }
}

//============================================================//
//========================FUNCTIONS===========================//
//============================================================//

void execute_OUTPUTS() {

  for (byte i = 0; i < 4; i++) {
    if (valve_flags[i]) {
      digitalWrite(valvePins[i], HIGH);
    } else {
      digitalWrite(valvePins[i], LOW);
    }
  }

  for (byte i = 0; i < 5; i++) {
    if (led_flags[i]) {
      digitalWrite(led_pins[i], HIGH);
    } else {
      digitalWrite(led_pins[i], LOW);
    }
  }
}

//============================================================//
//============================END=============================//
//============================================================//