/* Anmerkung fürs Weitermachen!!
!!!!!!!!!!!!
!!!!!!!!!!!!

Programm bekommt keine Werte für "Im Freien AB" wenn man nicht vorher hoch/runter drückt.
Workaround: AB Werte werden im Init definiert.
prüfen warum!!!!!!
!!!!!!!!!!!!
!!!!!!!!!!!!

*/
#define ersteTaste 0
#define letzteTaste 7

// Pins für Tasten-Inputs definieren
#define bt_rechts 0
#define bt_hoch 1
#define bt_bestaetigen 2
#define bt_runter 3
#define bt_links 4
#define bt_start 5
#define bt_pause 6
#define bt_reset 7

// Pins für Outputs definieren
#define ton 10
#define rot 11
#define gelb 12
#define gruen 13

// Diverse Varbialen im Programm definieren für erhöhte Lesbarkeit

#define im_freien_ab 0
#define im_freien_abcd 1
#define in_halle_ab 2
#define in_halle_abcd 3
#define alternierend 4
#define nachschiessen 5
#define kk_duell 6
#define gk_duell 7

// Hauptmenü
#define erstmenue 0
#define menuebogen 1
#define menuepistole 2

// Submenü


 // Konfiguration des Displays
#include <Wire.h>
#include <LiquidCrystal_I2C.h> // LiquidCrystal I2C von Frank de Brabander

// Initialisiere das LCD mit den entsprechenden Pins
LiquidCrystal_I2C lcd(0x27, 16, 2);   // Setze die Anzahl der Spalten und Zeilen des LCDs (1602)
char array2[] = "Hello World! ";


// Variablen
unsigned long previousMillis = 0; // Variable um die letzte gespeicherte Zeit zu speichern
unsigned long zeitdifferenz = 0;

bool buttongedrueckt; // Variable um zu sagen ob der Programmablauf gestartet wurde
unsigned long currentMillis; // Variable für die aktuelle Zeit

bool einpiep = true; //Um zu verhindern dass es in der eingestelten Zeit dauerhaft piept
bool dreipiep = true;
bool bestaetigt = false; // zum bestätigen des ausgewählten Programms, Wenn false befindet sich das Programm in der Menueführung

unsigned long endevorbereitung = 0; // Zeit nach wievielen Millisekunden die Vorbereitung(Gelb) zu Ende ist
// und die Schießphase(Grün) startet.
unsigned long endegruen = 0; // Zeit nach wievielen Millisekunden die Schießphase(grün) zu Ende ist
// und die Schießphase(Gelb) startet.
unsigned long endegelb = 0; // Zeit nach wievielen Millisekunden die Schießphase(Gelb) zu Ende ist
// und der Programmablauf endet.
unsigned long endemanuell = 0; // Zeit die eingestellt wird wenn man manuell die Schießzeit beendet.

int menue = 0; // Auswahl des Schussprogramms im Menü

int zustand = 1; // für Schritkette im Programmablauf

int timer = 0;  //Restzeitanzeigetimer
int dauer = 0; // Dauer der Schießzeit = Timerdauer
bool bogendisziplin = true; // um Bogenspezifische Funktionen die bei Pistole nicht gebraucht werden zu aktivieren
bool mitcd = false; // Bei True findet der Programmablauf mit CD Schießen statt
bool sonderdisziplin = false; // für Alternierend, KK Duell und Nachschießen, dann auf true
int durchgaenge = 0; // Gibt an wie oft der Programmablauf automatisch durchläuft
int durchgang = 1; //zum vergleichen der bereits gelaufenen Durchgänge
int anzahlpfeile =1; //Anzahl der Pfeile die beim nachschießen geschossen werden
int nachschiesszeit =0; //Gesamtzeit fürs nachschießen.
bool pfeilebestaetigt = true; // Zum Abfragen der Bestätigung der Nachschießpfeile
bool hierhin = true; //nur wenn die Variable gesetzt ist geht es nach Bestätigen in das eigentliche Schießprogramm (für Nachschießzeitauswahl wichtig)

void setup() {
  // Workaround, später löschen
endevorbereitung = 10000; //Zeiteinstellungen je nach Disziplin
endegruen = 220000; 
endegelb = 250000; 
endemanuell = 249000; 
dauer = 240; 
// Bis hierhin 

  // Pins definieren
  pinMode(rot, OUTPUT); 
  pinMode(gelb, OUTPUT); 
  pinMode(gruen, OUTPUT); 
  pinMode(ton, OUTPUT); 

  pinMode(bt_rechts, INPUT);
  pinMode(bt_hoch, INPUT);
  pinMode(bt_bestaetigen, INPUT);
  pinMode(bt_runter, INPUT);
  pinMode(bt_links, INPUT);
  pinMode(bt_start, INPUT);
  pinMode(bt_pause, INPUT);
  pinMode(bt_reset, INPUT);

  //Display starten
  lcd.init();
  lcd.backlight();
  

  //Für Zeit
  #if defined(__AVR_ATtiny85__) && (F_CPU == 16000000)
  clock_prescale_set(clock_div_1);
  
  #endif
  //für ggf Fehlersuche
  Serial.begin(9600);

  // zum Start, rote Leuchte, Rest aus
  //Ampel(LOW, LOW, LOW);
  digitalWrite(ton, LOW);

  // Startbildschirm
  //Display("im Freien AB", "");
}

bool bt_start_pressed = LOW;


bool rot_HIGH = LOW;
bool gelb_HIGH = LOW;
bool gruen_HIGH = LOW;

bool lastState = LOW;

enum MyButtons
{
  A,
  B,
  C,
  D
};

void loop()
{
  /*
  if( digitalRead(bt_start) == HIGH )
  {
    digitalWrite(gruen, HIGH);
    //Serial.print("*");
    //delay(300);
  }
  else
  {
    digitalWrite(gruen, LOW);
  }


  if(digitalRead(bt_reset) == HIGH)
  {
    rot_HIGH != rot_HIGH;
    Serial.println(" pressed");
  }

  digitalWrite(rot, rot_HIGH);
  digitalWrite(gelb, gelb_HIGH);
  //digitalWrite(gruen, gruen_HIGH);
*/
  /*
  wasButtonPressed(bt_reset);

  int value = digitalRead((bt_pause));

  if (lastState != value) {
    lastState = value;
    if (value == LOW) {
      Serial.println(" released");
    }
    if (value == HIGH) {
      Serial.println(" pressed");
    }
  }
  */

  testButton();

  Hauptmenue();

  if( wurde_diese_taste_gedruckt(7) )
  {
    Serial.println("Ja");
  }
}

void display(String str0, String str1)
{
  // leere das Display
  lcd.clear();

  // Setz den Cursor auf das erste Zeichen der ersten Zeile
  lcd.setCursor(0,0);
  // schreibe den übergebenen Text in die (erste) Zeile
  lcd.print(str0);

  // Setz den Cursor auf das erste Zeichen der zweiten Zeile
  lcd.setCursor(0,1);
  // schreibe den übergebenen Text in die (zweite) Zeile
  lcd.print(str1);
}

bool bt_startPressed = LOW;
bool bt_resetPressed = LOW;
bool bt_pausePressed = LOW;


bool wasButtonPressed(int button)
{
  bool pressed = digitalRead(button);

  if(bt_startPressed != pressed)
  {
    bt_startPressed = pressed;
    if(pressed)
    {
      //bt_startPressed = HIGH;
      //Serial.println(" pressed");
    }
    else
    {
      //Serial.println(" released");
    }
  }
}

// speichert zwischen ob Taste gedrückt wurde
bool temp_TasteGedruckt = false;

// gibt 1 Mal TRUE zurück wenn die übergebene Taste gedrückt wurde
bool wurde_diese_taste_gedruckt(byte taste)
{
  // initialisiere Rückgabewert mit FALSE
  bool wurde_gedrueckt = false;
  // lese digitalen input der jeweiligen Taste ein
  bool value = digitalRead(taste);

  // TRUE wenn sich der Zustand der Taste ändert
  // (= wenn die Taste gedrückt ODER losgelassen wurde)
  if( value != temp_TasteGedruckt )
  {
    // speichert den neuen Zustand der Taste damit die obere Abfrage nicht mehr TRUE ist
    temp_TasteGedruckt = value;

    // prüfe ob die taste gedrückt (HIGH) oder losgelassen wurde
    if( value == HIGH )
    {
      wurde_gedrueckt = true;
    }
    else
    {
      // aktuell nichts zu tun
    }
  }

  return wurde_gedrueckt;
}


int pressedCount[8];
int releasedCount[8];
bool isPressed[8];
byte isTriggered[8];

byte gedrueckteTaste = 255;

void testButton()
{

  gedrueckteTaste = 255;

  for(byte n=2; n<8; n++)
  {
    bool value = digitalRead(n);
    if(n == 0)
    {
      value = !value;
    }

    if (isPressed[n] != value) {
      isPressed[n] = value;
      if (value == LOW) 
      {
        //releasedCount[n]++;
        //display("released",String(releasedCount[n]));
      }
      if (value == HIGH) 
      {
        gedrueckteTaste = n;
        //pressedCount[n]++;
        display("pressed",String(n));
      }
    }
  }
}

/////////////////////////////////
//////////  Hauptmenü  //////////
/////////////////////////////////
byte auswahl_hauptmenue = 0;
byte aktivesMenue = 255;

void Hauptmenue()
{
  byte optionen[] = {4,
                     8,
                     12};

  switch( gedrueckteTaste )
  {
    case bt_links:
      Serial.println("Links");
      if( auswahl_hauptmenue >= sizeof(optionen)-1 )
      {
        auswahl_hauptmenue = 0;
      }
      else
      {
        auswahl_hauptmenue++;
      }
      display("test","test");
      break;
    case bt_runter:
      if( auswahl_hauptmenue == 0 )
      {
        auswahl_hauptmenue = sizeof(optionen)-1;
      }
      else
      {
        auswahl_hauptmenue--;
      }
      break;
    case bt_bestaetigen:
      Serial.println("Besaetigen");
      aktivesMenue = optionen[auswahl_hauptmenue];
      break;
  }

  if( aktivesMenue != auswahl_hauptmenue )
  {
    Serial.println("Change Menu");
    switch( auswahl_hauptmenue )
    {
      case 0:
        display("Auswahl:  ", String(optionen[auswahl_hauptmenue]) );
        aktivesMenue = auswahl_hauptmenue;
        break;
      case 1:
        display("Auswahl:  ", String(optionen[auswahl_hauptmenue]) );
        aktivesMenue = auswahl_hauptmenue;
        break;
      case 2:
        display("Auswahl:  ", String(optionen[auswahl_hauptmenue]) );
        aktivesMenue = auswahl_hauptmenue;
        break;
    }
  }
}

/////////////////////////////////
//////////  Bogenmenü  //////////
/////////////////////////////////
int auswahl_bogenmenue = 0;

void Bogenmenue()
{

}

////////////////////////////////////
//////////  Pistolenmenü  //////////
////////////////////////////////////
int auswahl_pistolenmenue = 0;

void Pistolenmenue()
{

}