// Time functions
auto myMillis(uint64_t& uiMyMillis) -> void;
uint16_t uiMillisOld1 = 4294967230;
uint16_t uiMillisOld2 = 0;
uint16_t uiMillisOld3 = 0;
uint16_t uiMillisOld4 = 0;


// FOR FUNCTIOM: bool detectRisingFlag;
#define RISING_EDGE 0
#define FALLING_EDGE 1

// FOR FUNCTION: edge detection
#define BOOL_INPUT 10
#define ANALOG_INPUT A0

auto functionTrigger(uint16_t &uiMillisOld, uint16_t uiTargetTime) -> bool;
bool xFunctionTrigger1 = false;
bool xFunctionTrigger2 = false;
bool xFunctionTrigger3 = false;
bool xFunctionTrigger4 = false;




bool xInput10 = false;
bool xPreviousSignal;
uint16_t uiAnalogSignal = 0; 
uint16_t uiPreviousSignal = 0;

bool xEdgeDetectionResult1 = false;
bool xEdgeDetectionResult2 = false;






void setup() {
  Serial.begin(115200);

  pinMode(BOOL_INPUT, INPUT);
  pinMode(ANALOG_INPUT, INPUT);


}

void loop() {
  // StringToChar();
  // using_Strtok();

  // myMillis(uiMillis);
  // Serial.println(int(uiMillis));

  // FUNCTION TRIGGER EXAMPLE
  xFunctionTrigger1 = functionTrigger(uiMillisOld1,1000);
  //xFunctionTrigger2 = functionTrigger(uiMillisOld2,1000);
  //xFunctionTrigger3 = functionTrigger(uiMillisOld3,1000);
  //xFunctionTrigger4 = functionTrigger(uiMillisOld4,1000);

  Serial.println("millis = " + String(millis()) + "xFunctionTrigger1: " + String(xFunctionTrigger1));
  Serial.println("Old Time = " + String(uiMillisOld1));
  //Serial.println("millis = " + String(millis()) + "xFunctionTrigger2: " + String(xFunctionTrigger2));
  //Serial.println("millis = " + String(millis()) + "xFunctionTrigger3: " + String(xFunctionTrigger3));
  //Serial.println("millis = " + String(millis()) + "xFunctionTrigger4: " + String(xFunctionTrigger4));

  // RISING FLAG DETECTION EXAMPLE
  /*
  xInput10 = digitalRead(BOOL_INPUT);
  xEdgeDetectionResult1 = detectRisingFlag (xInput10, xPreviousSignal, FALLING_EDGE, LOW );
  Serial.print("Rising Edge BOOL: ");
  Serial.println(xEdgeDetectionResult1);

  uiAnalogSignal = analogRead(ANALOG_INPUT);
  xEdgeDetectionResult2 = detectRisingFlag (uiAnalogSignal, uiPreviousSignal, RISING_EDGE, 500);
  Serial.print("Rising Edge ANALOG: ");
  Serial.println(xEdgeDetectionResult2);
  Serial.print("ANALOG Value: ");
  Serial.println(uiAnalogSignal);
  delay(500);
  */

}


// HOW TO CONVERT STRING TO CHAR ARRAY
// https://www.arduino.cc/reference/en/language/variables/data-types/string/functions/tochararray/

void StringToChar() {
  String sExample = "Example";
  uint8_t uiStringLength = sExample.length() + 1; // +1 is important otherwise you will loose one char

  char cConvertedString[uiStringLength];
  sExample.toCharArray(cConvertedString, uiStringLength);

  Serial.print("cConvertedString = ");
  Serial.println(cConvertedString);
}

// How to use Strtok for converting String to char array
// please consider that the Variable which used for strtok have to be pointer chars!
void using_Strtok() {
  char cExample [] = "uiExampleVar=1337";
  char *cName = strtok(cExample, "=");

  // Read until the equal sign
  if (cName) {
    Serial.print("cName = ");
    Serial.println(cName);

    // If cName is valid, strtok the remaining chars
    char *cValue = strtok(NULL, " ");
    if (cValue) {
      Serial.print("cValue = ");
      Serial.println(cValue);
    }
  }

}


// Function for saving the current system time in secods
// this function is using millis which will be converted into seconds and the function returns the seconds
uint32_t seconds(uint64_t uiInputMs) {
  myMillis(uiInputMs);

  uint32_t uiElapsedSeconds = (uiInputMs / 1000);
  return uiElapsedSeconds;
}

// ########;
// my "millis()" Function;
// ########;
// My Own millis function because the basic millis() will overflow after 50 days;
// if you know that your MCU is running longer than 50 days you have to detect the overflow
auto myMillis(uint64_t& uiMyMillis) -> void {
  uint32_t uiMillis = 0;
  uint64_t uiMillisMax = 4294967295; // Max Value of millis
  uint64_t uiNewStartpoint = 0;     // This value will work as new start point for myMillis()
  uint16_t uiMultiplier = 0;


  uiMultiplier    = uiMyMillis / uiMillisMax;
  uiNewStartpoint = uiMillisMax * uiMultiplier; //calculating the multiplier which will calculate automatically

  uiMillis = millis();

  // if millis() < MyMillis, then add the millis onto my millis
  // max millis which could be saved with uint64t: 18446744073709551616 == 213503982334 days

  if (uiMillis < 4320000000 && uiMyMillis >= uiNewStartpoint) {
     uiMyMillis = uiNewStartpoint + uiMillis;
  }
  // my Millis counted up to 100 days
  else {
    uiMyMillis = uiMillis;
  }
}


// ##############;
// my time based triggering;
// ##############;
// executing a function if specific time is elapsed;
// working with reference parameter (updating uiMillisOLd trough the function);
// you have to pass your old millis time and the target time;
// needs the myMillis function
// Max Targettime: about 65s
auto functionTrigger(uint16_t &uiMillisOld, uint16_t uiTargetTime) -> bool {
  
  uint16_t uiMillisTemp = millis() - uiMillisOld;

  if (uiMillisTemp >= uiTargetTime) {
    uiMillisOld += uiTargetTime;
    return true;
  } else {
    return false;
  }

}


// #########
// Detecting rising Flag of an arbitary inputSignal
// #########
// Tdirection = Last Value for detecting whether rising or falling trigger function;
// TpreviousSignal = have to be a different variable which is needed for storing the last inputSignal
// TinputSignal = your Signal
// Ttrigger = Threshold value for firing the Trigger
// bySignalType = passing the information about the kind of signal
template<typename T1, typename T2, typename T3 >
bool detectRisingFlag (T1 TinputSignal, T2 &TpreviousSignal, byte byEdgeType, T3 Ttrigger ) {
  // RISING EDGE detection
  if (byEdgeType == RISING_EDGE) {
    if (TinputSignal >= Ttrigger && TpreviousSignal < Ttrigger ) {
      TpreviousSignal = TinputSignal;
      return true;
    }
    // Resetting the signal if Ttrigger was reached
    else if ((TinputSignal >= Ttrigger && TpreviousSignal >= Ttrigger) || (TinputSignal < Ttrigger && TpreviousSignal >= Ttrigger)) {
      TpreviousSignal = TinputSignal;
      return false;
    } 
  }
  // FALLING EDGE detection
  if (byEdgeType == FALLING_EDGE) {
    //rising edge
    if (TinputSignal <= Ttrigger && TpreviousSignal > Ttrigger) {
      TpreviousSignal = TinputSignal;
      return true;
    }
    else if((TinputSignal <= Ttrigger && TpreviousSignal <= Ttrigger) || (TinputSignal > Ttrigger && TpreviousSignal <= Ttrigger)){
      TpreviousSignal = TinputSignal;
      return false;
    }
  }
}