#include <Arduino.h>
#include <stdio.h>
#include <stdarg.h>
#include "pico/stdlib.h"

template <class F, typename ...Args>
auto invoke(F f, Args && ...args) {
  Serial1.print("Args: "); Serial1.println(args...);
  return f((args)...);
  //return f(std::forward<Args>(args)...);
}

//template <class T> const char* type_name(const T&){ return strtok((strstr((char*)__PRETTY_FUNCTION__, "= ")+2),"]"); }
template <class T> String type_name(const T&){
  String s = String(__PRETTY_FUNCTION__); s.replace("arduino::","");
  return s.substring(s.indexOf("= ")+2, s.lastIndexOf(']'));
}

#define myprintf(fmt, ...)({ Serial1.print(fmt); Serial1.print(__FUNCTION__); Serial1.println(__VA_ARGS__); }) //Serial1.printf("[ %s ] " fmt, __FUNCTION__, __VA_ARGS__); 



inline const char* typeStr (int   var)       { return " int ";   }
inline const char* typeStr (long  var)       { return " long ";  }
inline const char* typeStr (float var)       { return " float "; }
inline const char* typeStr (String *var)     { return " String ";  }
inline const char* typeStr (const char *var) { return " char ";  }

void hello() { ; }

void getTypes() {
  boolean       a = false;
  bool          b = true;
  byte          x = 255;
  uint8_t       z = 128;
  int8_t        w = 42;
  char          c = 'A';
  int           i = 123;;
  int*          u = &i;
  long          l = 987654;
  float         f = 3.14;
  double        d = 3.14;
  const char*   s = "hello";
  String        S = "oi mate";
	int16_t       j = 42;
	uint16_t      k = 42;
	unsigned int  m = 42;
  uint32_t      n = 42;
  int32_t       o = 42;
	word          p = 42;
	unsigned long q = 42;
	int64_t       r = 42;  
	uint64_t      t = 42;
  int           vals[3] = {1,2,3};

  Serial1.println("getTypes():");
  Serial1.print("boolean       ->  (a): "); Serial1.println(type_name(a)); // bool
  Serial1.print("bool          ->  (b): "); Serial1.println(type_name(b)); // bool
  Serial1.print("byte          ->  (x): "); Serial1.println(type_name(x)); // byte
  Serial1.print("uint8_t       ->  (z): "); Serial1.println(type_name(z)); // uint8_t
  Serial1.print("int8_t        ->  (w): "); Serial1.println(type_name(w)); // int8_t
  Serial1.print("char          ->  (c): "); Serial1.println(type_name(c)); // char
  Serial1.print("int           ->  (i): "); Serial1.println(type_name(i)); // int
  Serial1.print("int*          ->  (u): "); Serial1.println(type_name(u)); // int*
  Serial1.print("long          ->  (l): "); Serial1.println(type_name(l)); // long int
  Serial1.print("float         ->  (f): "); Serial1.println(type_name(f)); // float
  Serial1.print("double        ->  (d): "); Serial1.println(type_name(d)); // double
  Serial1.print("const char*   ->  (s): "); Serial1.println(type_name(s)); // const char*
  Serial1.print("String        ->  (S): "); Serial1.println(type_name(S)); // arduino::String]
  Serial1.print("int16_t       ->  (j): "); Serial1.println(type_name(j)); // short int]
  Serial1.print("uint16_t      ->  (k): "); Serial1.println(type_name(k)); // short unsigned int]
  Serial1.print("unsigned int  ->  (m): "); Serial1.println(type_name(m)); // unsigned int]
  Serial1.print("uint32_t      ->  (n): "); Serial1.println(type_name(n)); // long unsigned int]
  Serial1.print("int32_t       ->  (o): "); Serial1.println(type_name(o)); // long int
  Serial1.print("word          ->  (p): "); Serial1.println(type_name(p)); // short unsigned int]
  Serial1.print("unsigned long ->  (q): "); Serial1.println(type_name(q)); // long unsigned int]
  Serial1.print("int64_t       ->  (r): "); Serial1.println(type_name(r)); // long long int]
  Serial1.print("uint64_t      ->  (t): "); Serial1.println(type_name(t)); // long long unsigned int]
  Serial1.print("int[]         ->  (?): "); Serial1.println(type_name(vals)); // long long unsigned int]
  Serial1.print("FlashString   ->  (?): "); Serial1.println(type_name(F("hardTurnLeft")));
}



// main template
template <typename A, typename B = void, typename C = void> struct Foo {
    void output() { Serial1.print(a_); Serial1.print(","); Serial1.print(b_); Serial1.print(","); Serial1.println(c_); }
    A a_;
    B b_;
    C c_;
};

// Partial specialisation for two parameters
template <typename A, typename B> struct Foo<A, B, void> {
    void output() { Serial1.print(a_); Serial1.print(","); Serial1.println(b_); }
    A a_;
    B b_;
};

// Partial specialisation for one parameter
template <typename A> struct Foo<A, void, void> {
    void output() { Serial1.println(a_); }
    A a_;
};

/*
template<typename T> struct Entry { const char* key; T val; };
template<typename T> void getData(struct Entry entry) {
  Serial1.print(".key: "); Serial1.println(entry.key);
  Serial1.print(".val: "); Serial1.println(entry.val);
}
*/
void setup() {
  Serial1.begin(9600);
  Serial1.println("");
  myprintf("Hello world");
  while (!Serial1);

  Foo<int> singleint;
  singleint.a_ = 1;
  singleint.output();

  Foo<int, int> doubleint;
  doubleint.a_ = 1;
  doubleint.b_ = 2;
  doubleint.output();

  Foo<int, int, int> tripleint;
  tripleint.a_ = 1;
  tripleint.b_ = 2;
  tripleint.c_ = 3;
  tripleint.output();

  delay(2000);

  getTypes();

  /*
  Entry entry<int> = {"HELLO", 42};
  Serial1.print(".key: "); Serial1.println(entry.key);
  Serial1.print(".val: "); Serial1.println(entry.val);
  //getData<int>(entry);
  */
}

void loop() { delay(1); }


/*
	// bool
  // boolean
	// uint8_t
	// int8_t
	// unsigned char
	// uint8_t
	// byte
	// int8_t
  // int
	// int16_t
	// uint16_t
	// unsigned int
  // uint32_t
  // int32_t
	// word
	// long
	// unsigned long
	// int64_t
	// uint64_t
	// float
  // double
  // char
  // const char
  // String

*/


/*
template <class T> String type_name(const T&){
  String s = String(__PRETTY_FUNCTION__);
  bool isPtr = false;
  bool isConst = false;

  s = s.substring(
    ((s.indexOf("= ") != -1) ? s.indexOf("= ")+2  : s.length()),
    ((s.indexOf(']')  != -1) ? s.lastIndexOf(']') : s.length())
  );

  isPtr   = (s.endsWith("*"));
  isConst = (s.startsWith("const ")); 

  s = s.substring(
    ((s.startsWith("const ")) ? 6 : 0),
    ((s.endsWith("*")) ? s.indexOf('*') : s.length())
  );

  s = (s.startsWith("arduino::")) ? s.substring(9,s.length()) : s;
  s = (
    (s.indexOf("long long") != -1) ? ((s.indexOf("unsigned") != -1) ? "uint64_t" : "int64_t") : 
    (s.indexOf("long") != -1)      ? ((s.indexOf("unsigned") != -1) ? "uint32_t" : "int32_t") : 
    (s.indexOf("short") != -1)     ? ((s.indexOf("unsigned") != -1) ? "uint16_t" : "int16_t") : 
    (s.indexOf("char") != -1)      ? ((s.indexOf("unsigned") != -1) ? "uint8_t"  : "int8_t") : s
  );
  s = (
    (s == "int8_t") ? "char" :
    (s == "unsigned int") ? "uint32" :
    (s.endsWith("_t")) ? s.substring(0, s.lastIndexOf("_t")) :
    (s.indexOf('[') != -1 && s.indexOf(']') != -1) ? s.substring(0, s.lastIndexOf(" [")) + s.substring(s.lastIndexOf('['), s.length()) : s
  );

  s = ((isConst) ? "const " : "") + s + ((isPtr) ? "*" : "");
  return s;
  //return strtok((strstr((char*)__PRETTY_FUNCTION__, "= ")+2),"]"); 
}
*/

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

/*
#include <stdio.h>
#include <stdlib.h>
//#include <iostream.h>

template<typename type, typename...args>
  void getFuncInfo(type(*func)(args...)) {
      // some code here...
      // here my example:
      //((std::cout << typeid(args).name() << "\n"),...);
      Serial1.print(typeid(args).name());
      Serial1.print("\n");
      Serial1.println(...);

  }


// every Augments you can imagines...
void someRandomFunction(int a, float b, double c, const char* d, int e[], std::pair<int, const char*> f){ ; }

void setup() {
  Serial1.begin(9600);
  Serial1.println("");
  while (!Serial1);
  getFuncInfo(someRandomFunction);
}

void loop() { delay(1); }
*/
/*
template<typename T> struct Entry { const char* key; T val; };
void func1() { Serial1.println("func1"); }
void func2() { Serial1.println("func2"); }
void funcPrint(const char* str) { Serial1.println(str); }

void CallFunc(void(*func)(void *), void *param) {
  func(param);
}

void (*f)(); // declare pointer
void (*f2)(void *p = ".."); // declare pointer

void setup() {
  Serial1.begin(9600);
  while (!Serial1);

  f = func1;
  (*f)();

  f2 = CallFunc;
  (*f2)("hello");
  //void (*f2)(void *) = &func2;
}

void loop() { delay(1); }
*/