// enums MOETEN ALTIJD ALS EERSTE AANGEGEVEN WORDEN!!
enum status {RIJZEND, HOOG, DALEND, LAAG};

class Led {
 /* De class led heeft:
*2 public atributes: poort en output. De namen spreken voor zichzelf
*4 methods:
-> aan    : doet de led branden
-> uit    : doet de led uit
-> toggle : wisselt van aan naar uit en andersom.
-> lees   : geeft de toestand van de led aan in output.*/
  public:
    int poort;
    int output;

    //Methods van de class Led
    void aan()
    {
      digitalWrite(poort, LOW);
      output = LOW;
    }

    void uit()
    {
      digitalWrite(poort, HIGH);
      output = HIGH;
    }

    void toggle()
    {
      digitalWrite(poort, !digitalRead(poort));
      output = !output;
    }
    int lees()
    {
      return output;
    }

    //constructor van class Led:
    Led (int a, int b) {
      poort = a;
      output = b;
      pinMode(poort, output);
    }
};

class Knop {
 /*De class knop heeft:
*3 private attributes: 
->vorige = is de vorige waarde
->offon  = is de huidige toestand
->poort  = spreekt voor zichzelf
*1 method:
->lees = retourneert de flank in de vorm een ENUM */
  private:
    int  vorige;
    int poort;
    int offon;
  public:
    status flanK;

    //Methods van de class Knop
    int lees()
    {
      offon = digitalRead(poort);
      if (vorige < offon) {
        flanK = RIJZEND;
      }
      if (vorige > offon) {
        flanK = DALEND;
      }
      if (vorige == offon and offon == HIGH) {
        flanK = HOOG;
      }
      if (vorige == offon and offon == LOW) {
        flanK = LAAG;
      }
      vorige = offon;
      return flanK;
    }
    //constructor van class Knop:
    Knop (int c, int d, status eflank) {
      poort = c;
      offon = d;
      flanK = eflank;
    }
};

class Pot {
/* De class pot heeft :
*4 public attributes:
-> poort    = spreekt voor zichzelf
-> laagst   = de laagst mogelijke waarde die mag geretourneerd worden
-> hoogst   = de hoogst mogelijk waarde die mag geretouneerd worden
-> waarde   = de waarde die geretouneerd zal worden (dus tussen laagst en hoogst)
*1 method:
-> lees = leest de pot uit ,herschaald die en retouneerd ze in waarde.*/
  public:
    int poort;
    int laagst;
    int hoogst;
    int waarde;
    //Methods van de class Pot
    int lees() {
      waarde = map(analogRead(poort), 0, 1023, laagst, hoogst);
      return waarde;
    }
    // constructor van de class Pot
    Pot (int e, int f, int g) {
      poort = e;
      laagst = f;
      hoogst = g;
    }
};

class Timer {
  /* De class Timer heeft:
  *2 private attributes:
  -> nu         = is de uitlezing van millis
  -> verleden   = is de vorige nu 
  *3 public attributes:
  -> wachtTijd       = is de tijd die moet verstijken voordat go op 'true' wordt gezet.
  -> verstrekenTijd  = is de tijd die effectief verstreken is sinds de vorige reset
  -> go              = wordt op 'true' gezet als de wachtTijd is verstreken.
  *3 Methods
  -> verstreken      = berekend de versteken tijd sinds de vorige reset,
  ->                   vergelijkt die tijd met de wachttijd,
  ->                   zet go op 'true' als de tijd verstreken is.
  -> reset           = zet de verstreken tijd terug op 0 en go op 'false'
  -> set             = foutje van mij, ik was aan het proberen hoe class werkte.*/
  private:
    unsigned long nu;
    unsigned long verleden;

  public:
    unsigned long wachtTijd;
    bool go ;
    unsigned long verstrekenTijd;
    //Methods van de class Timer
    void verstreken() { // Method die berekend hoeveel tijd er versteken is tov vorige keer.
      verleden = nu;
      nu = millis();
      verstrekenTijd += (nu - verleden);
      if (verstrekenTijd > wachtTijd) {
        go = true;
      }
      return go;
    }
    bool reset() { // Method om de wachttijd van de timer opnieuw in te stellen
      verstrekenTijd = 0;
      nu = millis();
      verleden = nu;
      go = false;
      return go;
    }
    void set(unsigned long x) {//Totaal nuttloos
      wachtTijd = x;
    }
    //constructor van de class Timer
    Timer (unsigned long wachtTijd_a, bool go_b) {
      wachtTijd = wachtTijd_a;
      go = go_b;
    }

};
// Alles na de klassen

// Constanten
// Ledjes (Actuatoren)
const int PIN_GROEN = 12;
const int PIN_GEEL = 11;
const int PIN_ROOD = 10;
const int PIN_BLAUW = 9;
//Drukknoppen (Digitale sensoren)
const int PIN_WIT = 3;
const int PIN_GRIJS = 4;
//Potentiometers (Analoge sensoren)
const int PIN_POT = A0;
const int MAX = 5000; //Bovenlimiet van de knippertijd
const int MIN = 40;//Onderlimiet van de knippertijd

// Variabelen.
int grijs = LOW;
int wit = LOW;
int pot = 0;
unsigned long wachtTijd;
bool go = false;
bool vorigeFlankGrijs = false;
bool vorigeFlankWit = false;

// speciale variabelen
status flanK ;//flanK kan nu enkel de waarden RIJZEND, HOOG, DALEND en LAAG hebben
// Zie de enum van status hierboven.

// Aanmaken van Ojecten
Led Groen(PIN_GROEN, OUTPUT);
Led Geel(PIN_GEEL, OUTPUT);
Led Rood(PIN_ROOD, OUTPUT);
Led Blauw(PIN_BLAUW, OUTPUT);
Knop Wit(PIN_WIT, wit, flanK);
Knop Grijs(PIN_GRIJS, grijs, flanK);
Pot Vijs(PIN_POT, MIN, MAX);
Timer Klok(wachtTijd, go);

void setup() {
  // put your setup code here, to run once:
  Groen.aan(); //Begin situatie klaarzetten
  Geel.uit();
  Rood.uit();
  Blauw.uit();
  }


void loop() {
  //Gegevens binnenhalen.
  Wit.lees();
  Grijs.lees();
  wachtTijd = Vijs.lees();
  Klok.set(wachtTijd);
  Klok.verstreken();

  if (Wit.flanK == RIJZEND) { // Aan/Uit zetten van Naar links of rechts
    vorigeFlankWit = !vorigeFlankWit;
  }
  if (Grijs.flanK == RIJZEND) {// Aan/Uit zetten van knipperen ja of nee.
    vorigeFlankGrijs = !vorigeFlankGrijs;
  }
  if (Klok.go) {// als de tijd verstreken is dan zal go 'true' zijn
    if (vorigeFlankGrijs) {// als vorigeFlankGrijs 'true' is dan knipper naar de volgende
      if (vorigeFlankWit) {// als vorigeFlankWit 'true' is dan ...
        shiftRechts();//...knipper naar rechts
      } else {
        shiftLinks();// ... en anders naar links.
      }
    }
    Klok.reset();// de tijd was verstreken dus moeten we herstarten.
  }
  delay(30);// Dendertijd iets kleiner dan de minimumtijd.
}

//Functies
void shiftLinks() {
  // Bereken op basis van de ledje(s) die actief zijn welke er moet uit gaan en welke links daarvan aan.
  switch (Groen.output + (Geel.output * 2) + (Rood.output * 4) + (Blauw.output * 8)) {
    case 14: {
        Groen.toggle();
        Blauw.toggle();
        break;
      }
    case 7: {
        Blauw.toggle();
        Rood.toggle();
        break;
      }
    case 11: {
        Rood.toggle();
        Geel.toggle();
        break;
    } case 13: {
        Geel.toggle();
        Groen.toggle();
        break;
      }
    default:
      break;
  }
}

void shiftRechts() {
  // Bereken op basis van de ledje(s) die actief zijn welke er moet uit gaan en welke rechts daarvan aan.
  switch (Groen.output + (Geel.output * 2) + (Rood.output * 4) + (Blauw.output * 8)) {
    case 14: {
        Groen.toggle();
        Geel.toggle();
        break;
      }
    case 13: {
        Geel.toggle();
        Rood.toggle();
        break;
      }
    case 11: {
        Rood.toggle();
        Blauw.toggle();
        break;
    } case 7: {
        Blauw.toggle();
        Groen.toggle();
        break;
      }
    default:
      break;
  }
}