#define LED 13
#define VERBOSE 0
#define TRIGGER 2

#define setPin  digitalWrite
#define getPin  digitalRead

#define prnt Serial.print
#define prntln Serial.println
#define flsh Serial.flush

#define LengthOf(x) (sizeof(x)/sizeof(x[0]))
#define LITERAL(...) "" #__VA_ARGS__
#include <avr/pgmspace.h>


// ---------------------------------------------------------------//

// Generic catch-all implementation.
template <typename T_ty> struct TypeInfo { static const char * name; };
template <typename T_ty> const char * TypeInfo<T_ty>::name = "unknown";

//#define TYPE_NAME(var) TypeInfo< typeof(var) >::name
#define TYPE_NAME(var) TypeInfo< typeof(var) >::name

//#define MAKE_TYPE_INFO(type) \
//template <typename> const char * TypeInfo<type>::name = #type;

// ---------------------------------------------------------------//



template <class T>
String type_name_old(const T&){
  prntln();   
  //const __FlashStringHelper* str = __PRETTY_FUNCTION__; prntln(str);
  //const char *name = (String)__PRETTY_FUNCTION__; prntln(name);
  //String myStr = ((String)__PRETTY_FUNCTION__).substring(37,((String)__PRETTY_FUNCTION__).length()-1);prntln(myStr);

  //String myStr = ((String)__PRETTY_FUNCTION__); prntln(myStr);
  //.substring(37,((String)__PRETTY_FUNCTION__).length()-1);prntln(myStr);

  /*

  const char* myFuncName PROGMEM = __PRETTY_FUNCTION__;
  //Serial.println((char *)pgm_read_word(&myFuncName));
  //const char *name = __func__;
  //const PROGMEM char *str = __PRETTY_FUNCTION__;


  //String myStr = ((String)__PRETTY_FUNCTION__).substring(37,((String)__PRETTY_FUNCTION__).length()-1);
  //prntln(myStr);
  //const char *streng[70] = __PRETTY_FUNCTION__.substr(37, 40);prntln(streng);
  prnt("strlen_P: "),prntln(strlen_P(__PRETTY_FUNCTION__));
  //char str[] {(String)__PRETTY_FUNCTION__}; 
  //prnt("str: "),prntln(str);
  //char myString[sizeof __PRETTY_FUNCTION__] = (String)__PRETTY_FUNCTION__;
  String s = __PRETTY_FUNCTION__; // Serial.println(s);
  //prnt("s len: "),prntln(s.length());
  //int start = s.indexOf("[with T = ") + 10;
  int start = s.indexOf("= ")+2;
  int stop = s.lastIndexOf(']');

  //prntln( ((String)__PRETTY_FUNCTION__).substring(start,stop) );
  //prntln(s.substring(37,s.lastIndexOf(']')));

  //prnt("__PRETTY_FUNCTION__: "),prntln(s);
  //prnt(start), prnt(" "), prntln(stop);
  return s.substring(start, stop); 
  //return ((String)__PRETTY_FUNCTION__).substring(37,((String)__PRETTY_FUNCTION__).length()-1);
  */
}

/*
#define BUF_LEN 32
char buf[BUF_LEN];
int i;
*/
/*
template <class T>
String type_name(const T&){   
  for (i=37;i<(strlen(__PRETTY_FUNCTION__)-1);i++) 
    buf[i-37] = __PRETTY_FUNCTION__[i]; buf[i-37] = '\0';
  return buf;
*/

/* THIRD WORKING
  for (i=37;i<(strlen(__PRETTY_FUNCTION__)-1);i++) {
    buf[i-37] = __PRETTY_FUNCTION__[i]; 
    prnt(" buf["),prnt(i-37),prnt("] = "),prnt("__func__["),prnt(i),prnt("] ("),prnt(buf[i-37]),prntln(")");
  }
  buf[i-37] = '\0';
  prnt(" buf["),prnt(i-37),prnt("] = 0\\\n");
  prnt("buf = "); prntln(buf);
  return buf;
*/
  /* SECOND WORKING
  buf[0] = '\0'; strcpy(buf, ""); 
  for (int i=37;i<(strlen(__PRETTY_FUNCTION__)-1);i++) 
    buf[i-37] = __PRETTY_FUNCTION__[i];  prntln();
  prnt("buf = "); prntln(buf);
  return buf;
  */

  //strncpy(buf,(char *)__PRETTY_FUNCTION__,37);
  //strncpy(buf,__PRETTY_FUNCTION__ , (strlen_P(__PRETTY_FUNCTION__)-37)); prntln(buf);
  //prntln(strtok((char *)__PRETTY_FUNCTION__,"="));
  

  /* FIRST WORKING
  buf[0] = '\0'; strcpy(buf, ""); 
  for (int i=37;i<(strlen_P(__PRETTY_FUNCTION__)-1);i++) 
    //prnt(__PRETTY_FUNCTION__[i]);
    buf[i-37] = __PRETTY_FUNCTION__[i];
  prntln();
  prnt("buf = "); prntln(buf);
  return buf;
  */

  /* ONE LINER (UGLY)
  return ((String)__PRETTY_FUNCTION__).substring(37,((String)__PRETTY_FUNCTION__).length()-1);
  */
//}

template<typename T>
bool within(T val, T min, T max){
  return ((min <= val) && (val <= max));
}

// ---------------------------------------------------------------//

//const char* const myLongString PROGMEM = "This is a very long string that I would like in program memory.";

template <class T>
String type_name2(const T&){   
    String s = __PRETTY_FUNCTION__;
    Serial.println(s);
    int start = s.indexOf("[with T = ") + 10;
    int stop = s.lastIndexOf(']');

    return s.substring(start, stop);
}

template <class T>
String type_name_simple(const T&){
  //prntln(s.substring(37,s.lastIndexOf(']')));
  //return (int)((String)__PRETTY_FUNCTION__).indexOf("=");
  //return ((String)__PRETTY_FUNCTION__);
  return ((String)__PRETTY_FUNCTION__).substring(37,((String)__PRETTY_FUNCTION__).length()-1);
}

/*
#define BUF_LEN 32
char buf[BUF_LEN];
int i;
*/


/*
template <class T>
String type_token(const T&){
  char str[(strlen(__PRETTY_FUNCTION__)-1)] = __PRETTY_FUNCTION__;
  char * pos;
  pos = strtok (str, "="); // everything BEFORE the first " - ignore this result
  //pos = strtok (NULL, "\""); // everything AFTER the first " and BEFORE the next "
  prntln(pos);
}
*/


template <class T>
String type_namer(const T&){   
  return strtok((strstr((char*)__PRETTY_FUNCTION__, "= ")+2),"]");


  /*
  // WORKS!
  const char* name PROGMEM = __PRETTY_FUNCTION__;
  return strtok((strstr(name, "= ")+2),"]");
  */

  /*
  // WORKS
  char *start = strstr(name, "= ");
  char *end = strstr((start+=2), "]");
  return strtok(start, "]");
  */

  //char buf[strlen(__PRETTY_FUNCTION__)+1], i, *pos;
  //pos = strtok(name, "=");
  //for (i=37;i<(strlen(__PRETTY_FUNCTION__)-1);i++) buf[i-37] = __PRETTY_FUNCTION__[i]; buf[i-37] = '\0';
  //return (char*)(name.substr(start,end));
}


////////////////////////////////////////////////////////////////////

template <class T>
String type_name4(const T&){   
  char buf[32], i, *pos;
  const char* name PROGMEM = __PRETTY_FUNCTION__;
  //pos = strtok(name, "=");
  //for (i=37;i<(strlen(__PRETTY_FUNCTION__)-1);i++) buf[i-37] = __PRETTY_FUNCTION__[i]; buf[i-37] = '\0';
  return name;
}


void splitter(char *string) {
    const char delim[10] = "= ]";
    char *token = strtok(string, delim);
    while (token != NULL) prntln(token), token = strtok(NULL, delim);
}

void split2(char *input) {
  char *start = strstr(input, "= ");
  if (start != NULL) {
    start += 2;
    char *end = strstr(start, "]");
    if (end != NULL) {
      int length = end - start;
      char result[length + 1]; // +1 for the null terminator
      strncpy(result, start, length);
      result[length] = '\0';
      Serial.println(result);
    }
  }
}

void split3(char *input) {
  char *start = strstr(input, "= ");
  char *end = strstr((start+=2), "]");
  char result[(end-start) + 1]; // +1 for the null terminator
  strncpy(result, start, (end-start));
  result[(end-start)] = '\0';
  //Serial.println(result);
}


template <class T>
String type_name(const T&){   
  return strtok((strstr((char*)__PRETTY_FUNCTION__, "= ")+2),"]");
}

#define str "Teensy 3"

void setup() {
  pinMode(LED, OUTPUT);
  Serial.begin(9600);
  Serial.println("READY");

  //if (String(str).indexOf("Teensy") > -1) prntln("TEENSY!");

  //const char* str = "Teensy 3";
  //if (String(str).indexOf("Teensy") > -1) prntln("TEENSY!");

  //char test[80] = "The next appointment is on the 7.1.2019, 10:00 a.m., in HS 1 (Building C)";
  //splitter(test);

  char test[80] = "String type_name(const T&) [with T = long unsigned int]";
  split3(test);
  delay(1000);

  double someFloat = 2.4535232;
  const char* someString = "some string";
  const unsigned long someLong = 123456;
  
  Serial.println(type_name(someFloat));
  Serial.println(type_name(someLong));
  
}



/*
void test() {
    unsigned int flash_address = pgm_read_word(&myLongString);
    char c = 0;
    do {
      c = (char *) pgm_read_byte(flash_address++);
      Serial.print(c);
    } while (c!='\0');
    Serial.println();    
}

void myFunction(int var,const char* str) {
  Serial.println(__func__);
  Serial.println(__PRETTY_FUNCTION__);
}

void setup() {
  pinMode(LED, OUTPUT);
  Serial.begin(9600);
  Serial.println("READY");
  //test();
  //myFunction(1,"hello");
  delay(1000);

  Serial.println((char *)pgm_read_word(&myLongString));

  double someFloat = 2.4535232;
  const char* someString = "some string";
  const unsigned long someLong = 123456;
  type_name(someFloat);
  type_name(someLong);
  //prntln(type_name(someFloat));
  //prnt("type_name(): "),prntln(type_name(someString));

  //Serial.println(TypeInfo.name);
  
  //template <typename T_ty> 
  //const char * TypeInfo<T_ty>::name = "unknown";
  

  //int myVar = 17;
  //Serial.println( TYPE_NAME(myVar) );

 // MAKE_TYPE_INFO( int );
  //MAKE_TYPE_INFO( float );

}
*/

void loop() {

  delay(1);
}