/*
  Devil Elec - µC.net
  IDE 1.8.19
  avr-gcc: 7.5.0 & C++17
  Arduino Mega 2560
  22.05.2026
*/

#include <Streaming.h>

template<typename T, size_t N>
constexpr size_t arrayCount(const T (&)[N]) {
  return N;
}

template<typename Callback>
class SimpleTimer
{
  private:
    unsigned long lastMillis {0xEFFFFFFF};  // provoziert eine sofortige Auslösung nach uC Reset
    unsigned long duration   {0};
    Callback callback;

  public:
    SimpleTimer (unsigned long d, Callback cb):
      duration(d),
      callback(cb)
    {}

    void update() {
      const unsigned long ms {millis()};
      if (ms - lastMillis >= duration) {
        lastMillis = ms;
        callback();  // direkt, ohne std::function
      }
    }

    void set (const unsigned long d) {
      duration = (0<d) ? d : 1;
      // lastMillis = millis(); sofort ändern
    }

    void operator = (unsigned long d) { // Operator '=' Überladung
      set(d);
    }
};

template<uint8_t pinA, uint8_t pinB>
class DipSwitch
{
  private:
    uint8_t readNew {0};
    uint8_t readOld {3};
    bool state {false}; // Trigger für: es gibt neue Werte
    uint32_t lastMillis {0};

    bool updateDebounce() {
      bool status {false};
      const uint32_t ms {millis()};
      if (ms - lastMillis >= 50) {
        lastMillis = ms;
        status = true;
      }
      return status;
    }

  public:
    DipSwitch() = default;
    
    void init() { 
      pinMode(pinA, INPUT_PULLUP);
      pinMode(pinB, INPUT_PULLUP);
    }

    bool update (void) {
      state = false;
      if (updateDebounce() ) {
        readNew = 0;
        if (digitalRead(pinA)) {readNew  = 0x01; }
        if (digitalRead(pinB)) {readNew |= 0x02; }
        
        if (readNew != readOld) {
          state = true;
        }
        readOld = readNew;                 
      }
      return state;
    }

    uint8_t getSwitchValue (void) {
      return readOld;
    }
};

template<uint8_t pin, uint8_t filterFactor>
class AnalogRead
{
  static_assert(1 <= filterFactor && filterFactor <= 255, "Filterfaktor erlaubt 1 ... 255");
    
  private:
    float filteredValue {0};
    uint16_t newValue   {0};
    
    void readAnalog (void) {
      newValue = analogRead(pin);
    }
    
    /**********************************************************
    ** Funktion Filtern() by GuntherB                        **
    ***********************************************************
    ** Bildet einen Tiefpassfilter (RC-Glied) nach.          **
    ** Tau = Filterfaktor / Aufruffrequenz                   **
    ***********************************************************/
    void filtern (void) {
      readAnalog();
      filteredValue = ((filteredValue * filterFactor) + newValue) / (filterFactor + 1);
    }

  public:
    // Konstruktor
    AnalogRead() = default;
    
    void init() { 
      pinMode(pin, INPUT);
    }

    void update (void) {
      filtern();
      //Serial.println(filteredValue + 0.5);
    }

    unsigned int getValue (void) {
      return static_cast<unsigned int>(filteredValue + 0.5);
    }
};      

// *** Behandlung der Bitmaps - Muster für das Schieberegister ***
struct Bitmap {
  const uint8_t *data;
  size_t length;
  const char *name;
  const uint8_t *begin() { return data; }         // für Range based for Schleife
  const uint8_t *end() { return data + length; }  // für Range based for Schleife
  uint8_t operator[](size_t index) const { return data[index]; } // []Operator Überladung
};

template <size_t N>
constexpr Bitmap helperBitmap(const uint8_t (&arr)[N], const char* name) {
  return Bitmap {arr, N, name};   // Rückgabe des Objekts
}

const uint8_t lauf_bmp0[] {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 
                           0x40, 0x20, 0x10, 0x08, 0x04, 0x02};

const uint8_t lauf_bmp1[] {0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F, 0xFF, 
                           0xFE, 0xFC, 0xF8, 0xF0, 0xE0, 0xC0, 0x80, 0x00};

const uint8_t lauf_bmp2[] {0x33, 0x66, 0xCC, 0x99};  
                
const uint8_t lauf_bmp3[] {0x03, 0x06, 0x0C, 0x18, 0x30, 0x60, 0xC0, 0x81};

Bitmap lauflicht[] {
  helperBitmap(lauf_bmp0, "eins"),
  helperBitmap(lauf_bmp1, "zwei"),
  helperBitmap(lauf_bmp2, "drei"),
  helperBitmap(lauf_bmp3, "vier")
};

constexpr size_t lauflichtCount {arrayCount(lauflicht)};

struct LauflichtPlayer {
  Bitmap currentBitmap {nullptr, 0, ""}; // aktuelles Lauflicht-Bitmaps
  size_t currentBitmapIndex {0};         // aktueller Index vom aktuellen Lauflicht-Bitmap
  uint8_t currentBitmapValue {0};
  
  void set (const Bitmap &bitmap) {
    currentBitmapIndex = 0;
    currentBitmap = bitmap;
    Serial << (currentBitmap.name) << " " << currentBitmap.length << endl;
  }

  void run () {
    if (nullptr == currentBitmap.data) {
      return;
    }
    if (currentBitmapIndex >= currentBitmap.length) {
      currentBitmapIndex = 0;
    }
    currentBitmapValue = currentBitmap[currentBitmapIndex];
    currentBitmapIndex++;
  }

  uint8_t getCurrentBitmap (void) {
    return currentBitmapValue;
  }
};

// Instanzen / Objekte
DipSwitch <7, 8> dipSwitch;             // 2 Pins
AnalogRead <A0, 10> poti;               // Pin und Filterfaktor
LauflichtPlayer player;                 // 

void dipSwitchToLauflichtMode (void) {
  if (dipSwitch.update()) {
    const size_t bmpMode = dipSwitch.getSwitchValue();
    if (bmpMode < lauflichtCount) {
      player.set(lauflicht[bmpMode]);
      Serial << ("change - ") << bmpMode << (" - Name: ") << lauflicht[bmpMode].name << endl;
    }
  }
}

SimpleTimer timerDipSwitch (50, []() {  // Instanz, mit Aufruf aller 50ms, einfache Entprellung
  dipSwitchToLauflichtMode();
});

SimpleTimer timerPoti (100, []() {  // Instanz, mit Aufruf aller 100ms
  poti.update();
});

SimpleTimer timerSerialPoti (1000, []() {  // Instanz, mit Aufruf aller 1000ms
  Serial.print("Poti: ");
  Serial.println(poti.getValue());
});

SimpleTimer timerLauflicht (250, []() {  // Instanz, mit Aufruf aller 250ms
  player.run();
  Serial.print("BMP 0x");
  Serial.println(player.getCurrentBitmap(), HEX);
});

void setup (void)
{
  dipSwitch.init();
  poti.init();
  player.set(lauflicht[2]);
  Serial.begin(9600);
  Serial.println("\nStart ###\n");
}

void loop (void)
{
  timerDipSwitch.update();
  timerPoti.update();
  timerSerialPoti.update();
  timerLauflicht.update();
  //timerLauflicht.set(poti.getValue());  // Millisekunden
  timerLauflicht = poti.getValue();       // Millisekunden mit Operator '=' Überladung
}