#include <map>
#include <iostream>
#include <string>
using namespace std;

typedef void* (*PTRCreateObject)(void);  

class ClassFactory {
private:  
    map<string, PTRCreateObject> m_classMap ;  
	ClassFactory(){}; //构造函数私有化
	
public:   
    void* getClassByName(string className);  
    void registClass(string name, PTRCreateObject method) ;  
    static ClassFactory& getInstance() ;  
};

void* ClassFactory::getClassByName(string className){  
    map<string, PTRCreateObject>::const_iterator iter;  
    iter = m_classMap.find(className) ;  
    if ( iter == m_classMap.end() )  
        return NULL ;  
    else  
        return iter->second() ;  
}  
   
void ClassFactory::registClass(string name, PTRCreateObject method){  
    m_classMap.insert(pair<string, PTRCreateObject>(name, method)) ;  
}  
   
ClassFactory& ClassFactory::getInstance(){
    static ClassFactory sLo_factory;  
    return sLo_factory ;  
}  

class RegisterAction{
public:
	RegisterAction(string className,PTRCreateObject ptrCreateFn){
		ClassFactory::getInstance().registClass(className,ptrCreateFn);
	}
};

#define REGISTER(className)                                             \
    className* objectCreator##className(){                              \
        return new className;                                           \
    }                                                                   \
    RegisterAction g_creatorRegister##className(                        \
        #className,(PTRCreateObject)objectCreator##className)

// test class
class TestClass{
public:
	void m_print(){
		cout<<"hello TestClass"<<endl;
	};
};
REGISTER(TestClass);

int main(int argc,char* argv[]) {
	TestClass* ptrObj=(TestClass*)ClassFactory::getInstance().getClassByName("TestClass");
	ptrObj->m_print();
}

class Foo {
 public:
  void PassByValue(std::string s) const {
    std::cout << "Foo::PassByValue(`" << s << "`)" << std::endl;
  }

  void PassByConstRef(const std::string &s) const {
    std::cout << "Foo::PassByConstRef(const `" << s << "` &)" << std::endl;
  }

  std::string Concat(const std::string &head, const std::string &tail) {
    auto res = head + tail;
    return res;
  }

  // std::unique_ptr will result in compile-time error
  std::shared_ptr<float> MakeFloatPtr(float i) {
    return std::make_shared<float>(i);
  }

  static void MakeReflectable() {
    reflect::AddClass<Foo>("Foo")
        .AddMemberVar("name", &Foo::name)
        .AddMemberVar("x_", &Foo::x_)
        .AddMemberFunc("PassByValue", &Foo::PassByValue)
        .AddMemberFunc("PassByConstRef", &Foo::PassByConstRef)
        .AddMemberFunc("Concat", &Foo::Concat)
        .AddMemberFunc("MakeFloatPtr", &Foo::MakeFloatPtr);
  }

  int x() const { return x_; }

  std::string name;

 private:
  int x_{0};
};

template <typename T>
details::TypeDescriptorBuilder<T> AddClass(const std::string &name) {
  details::TypeDescriptorBuilder<T> b{name};
  return b;
}

class TypeDescriptor {
 public:
  const std::string &name() const {
    return name_;
  }

  const std::vector<MemberVariable> &member_vars() const {
    return member_vars_;
  }

  const std::vector<MemberFunction> &member_funcs() const {
    return member_funcs_;
  }

  MemberVariable GetMemberVar(const std::string &name) const {
    for (const auto &mv : member_vars_) {
      if (mv.name() == name) {
        return mv;
      }
    }
    return MemberVariable{};
  }

  MemberFunction GetMemberFunc(const std::string &name) const {
    for (const auto &mf : member_funcs_) {
      if (mf.name() == name) {
        return mf;
      }
    }
    return MemberFunction{};
  }

 private:
  friend class RawTypeDescriptorBuilder;

  std::string name_;
  std::vector<MemberVariable> member_vars_;
  std::vector<MemberFunction> member_funcs_;
};

class MemberVariable {
 public:
  MemberVariable() = default;

  template <typename C, typename T>
  MemberVariable(T C::*var) {
    getter_ = [var](std::any obj) -> std::any {
      return std::any_cast<const C *>(obj)->*var;
    };
    setter_ = [var](std::any obj, std::any val) {
      // Syntax: https://stackoverflow.com/a/670744/12003165
      // `obj.*member_var`
      auto *self = std::any_cast<C *>(obj);
      self->*var = std::any_cast<T>(val);
    };
  }

  const std::string &name() const {
    return name_;
  }

  template <typename T, typename C>
  T GetValue(const C &c) const {
    return std::any_cast<T>(getter_(&c));
  }

  template <typename C, typename T>
  void SetValue(C &c, T val) {
    setter_(&c, val);
  }

 private:
  friend class RawTypeDescriptorBuilder;

  std::string name_;
  std::function<std::any(std::any)> getter_{nullptr};
  std::function<void(std::any, std::any)> setter_{nullptr};
};

class MemberFunction {
 public:
  MemberFunction() = default;

  template <typename C, typename R, typename... Args>
  explicit MemberFunction(R (C::*func)(Args...)) {
    fn_ = [this, func](std::any obj_args) -> std::any {
      using tuple_t = std::tuple<C &, Args...>;
      // How to debug compile-time types...
      // static_assert(std::is_same<tuple_t, void>::value, "Hoi!");
      auto *tp_ptr = std::any_cast<tuple_t *>(obj_args);
      return std::apply(func, *tp_ptr);
    };
  }

  template <typename C, typename... Args>
  explicit MemberFunction(void (C::*func)(Args...)) {
    fn_ = [this, func](std::any obj_args) -> std::any {
      using tuple_t = std::tuple<C &, Args...>;
      auto *tp_ptr = std::any_cast<tuple_t *>(obj_args);
      std::apply(func, *tp_ptr);
      return std::any{};
    };
  }

  template <typename C, typename R, typename... Args>
  explicit MemberFunction(R (C::*func)(Args...) const) {
    fn_ = [this, func](std::any obj_args) -> std::any {
      using tuple_t = std::tuple<const C &, Args...>;
      // How to debug compile-time types...
      // static_assert(std::is_same<tuple_t, void>::value, "Hoi!");
      auto *tp_ptr = std::any_cast<tuple_t *>(obj_args);
      return std::apply(func, *tp_ptr);
    };
    is_const_ = true;
  }

  template <typename C, typename... Args>
  explicit MemberFunction(void (C::*func)(Args...) const) {
    fn_ = [this, func](std::any obj_args) -> std::any {
      using tuple_t = std::tuple<const C &, Args...>;
      auto *tp_ptr = std::any_cast<tuple_t *>(obj_args);
      std::apply(func, *tp_ptr);
      return std::any{};
    };
    is_const_ = true;
  }

  const std::string &name() const {
    return name_;
  }

  bool is_const() const {
    return is_const_;
  }

  template <typename C, typename... Args>
  std::any Invoke(C &c, Args &&... args) {
    if (is_const_) {
      auto tp = std::make_tuple(std::reference_wrapper<const C>(c), args...);
      return fn_(&tp);
    }
    auto tp = std::make_tuple(std::reference_wrapper<C>(c), args...);
    return fn_(&tp);
  }

 private:
  friend class RawTypeDescriptorBuilder;

  std::string name_;
  bool is_const_{false};
  std::function<std::any(std::any)> fn_{nullptr};
};

void TestFoo() {
  std::cout << ">>> TestFoo\n" << std::endl;

  Foo::MakeReflectable();
  auto foo_t = reflect::GetByName("Foo");
  for (const auto &mv : foo_t.member_vars()) {
    std::cout << "member var: " << mv.name() << std::endl;
  }
  std::cout << std::endl;
  for (const auto &mf : foo_t.member_funcs()) {
    std::cout << "member func: " << mf.name() << ", is_const=" << mf.is_const()
              << std::endl;
  }
  std::cout << std::endl;

  Foo f;
  // Test member variables
  auto name_var = foo_t.GetMemberVar("name");
  name_var.SetValue(f, std::string{"taichi"});
  std::cout << "f.name=" << f.name << std::endl;
  auto x_var = foo_t.GetMemberVar("x_");
  x_var.SetValue(f, 42);
  std::cout << "f.x=" << f.x() << std::endl;
  std::cout << std::endl;

  // Test member functions
  auto foo_make_float_ptr = foo_t.GetMemberFunc("MakeFloatPtr");
  auto res = foo_make_float_ptr.Invoke(f, 123.4f);
  auto float_sptr = std::any_cast<std::shared_ptr<float>>(res);
  std::cout << "MakeFloatPtr res: " << *float_sptr << std::endl;

  std::string hello_s{"hello"};
  std::string world_s{" world"};

  auto foo_pass_by_val = foo_t.GetMemberFunc("PassByValue");
  foo_pass_by_val.Invoke(f, hello_s);

  auto foo_pass_by_cref = foo_t.GetMemberFunc("PassByConstRef");
  // foo_pass_by_cref.Invoke(f, hello_s);  // Crash, value
  // foo_pass_by_cref.Invoke(f, std::ref(hello_s));  // Crash, non-const ref
  foo_pass_by_cref.Invoke(f, std::cref(hello_s));  // OK: const ref

  auto foo_concat = foo_t.GetMemberFunc("Concat");
  // foo_concat.Invoke(f, hello_s, world_s);
  res = foo_concat.Invoke(f, std::cref(hello_s), std::cref(world_s));
  std::cout << "Concat got: " << std::any_cast<std::string>(res) << std::endl;
  std::cout << std::endl;

  std::cout << "<<< TestFoo OK\n" << std::endl;
}