/* --------------------------------------------------------
                         cout_light.h

     abgespeckte Streamfunktionen fuer cout, um Ausgaben
     auf einem Arduino aehnlich dem zu machen, wie es sich
     fuer ein C++ Programm "gehoert"

     Usage:
     
        #include <Arduino.h>
        #include "cout_light.h"
        
        cout_light<HardwareSerial> cout_serial(Serial);
        
        #define cout  cout_serial
        
        void setup() 
        {
          Serial.begin(115200);
          while(!Serial);
        
          cout << F("\n\rHallo Welt\n\n\r");
          cout << Hex << 255 << Dec << 218 << F("\n\r");
        }
        
        void loop() 
        {
        
        }
      
     07.03.2026 R. Seelig
   -------------------------------------------------------- */

#ifndef COUT_LIGHT_H
  #define COUT_LIGHT_H
  
  #include <Arduino.h>
  
  enum manipulators { Hex, Dec, BoolAlpha, NoBoolAlpha, Endl };
  
  template <typename T>
/* --------------------------------------------------------
                     class cout_light
   -------------------------------------------------------- */  
  class cout_light
  {
  public:
    cout_light(T &outStream)
    :
      out(outStream),
      useHex(false),
      useBoolAlpha(false)
    {}
  
    // int
    cout_light& operator<<(int val)
    {
      printNumber(val);
      return *this;
    }
  
    // unsigned int
    cout_light& operator<<(unsigned int val)
    {
      printNumber(val);
      return *this;
    }
  
    // long
    cout_light& operator<<(long val)
    {
      printNumber(val);
      return *this;
    }
  
    // unsigned long
    cout_light& operator<<(unsigned long val)
    {
      printNumber(val);
      return *this;
    }
  
    // bool
    cout_light& operator<<(bool val)
    {
      if (useBoolAlpha)
      {
        out.print(val ? "true" : "false");
      }
      else
      {
        out.print(val);
      }
      return *this;
    }
  
    // char
    cout_light& operator<<(char val)
    {
      out.print(val);
      return *this;
    }
  
    // const char* oder Flashstrings
    cout_light& operator<<(const __FlashStringHelper *val)
    {
      out.print(val);
      return *this;
    }
  
    // Arduino String
    cout_light& operator<<(const String &val)
    {
      out.print(val);
      return *this;
    }
  
    // Manipulatoren
    cout_light& operator<<(manipulators m)
    {
      switch (m)
      {
        case Hex:
          useHex = true;
          break;
        case Dec:
          useHex = false;
          break;
        case BoolAlpha:
          useBoolAlpha = true;
          break;
        case NoBoolAlpha:
          useBoolAlpha = false;
          break;
        case Endl:
          out.print("\n");
          break;
      }
      return *this;
    }
  
  private:
    T &out;
    bool useHex;
    bool useBoolAlpha;
  
    void printNumber(int val)
    {
      if (useHex)
      {
        out.print((unsigned int)val, HEX);
      }
      else
      {
        out.print(val, DEC);
      }
    }
  
    void printNumber(unsigned int val)
    {
      if (useHex)
      {
        out.print(val, HEX);
      }
      else
      {
        out.print(val, DEC);
      }
    }
  
    void printNumber(long val)
    {
      if (useHex)
      {
        out.print((unsigned long)val, HEX);
      }
      else
      {
        out.print(val, DEC);
      }
    }
  
    void printNumber(unsigned long val)
    {
      if (useHex)
      {
        out.print(val, HEX);
      }
      else
      {
        out.print(val, DEC);
      }
    }
  };

#endif