#include <stdio.h>
#include <memory>
#include <string>
#include <optional>
#include <emscripten/bind.h>

using namespace emscripten;

class Test {
 public:
  int function_one(char x, int y) { return 42; }
  int function_two(unsigned char x, int y) { return 43; }
  int function_three(const std::string&) { return 1; }
  int function_four(bool x) { return 2; }

  long long_fn(unsigned long a) { return 3; }

  int const_fn() const { return 0; }

  int getX() const { return x; }
  void setX(int x_) { x = x_; }

  int getY() const { return y; }

  std::string string_property;

  static int static_function(int x) { return 1; }

  static int static_property;
  static std::string static_string_property;

private:
  int x;
  int y;
};

class Foo {
 public:
  void process(const Test& input) {}
};

class IterableClass {
 public:
  IterableClass() : data{1, 2, 3} {}
  unsigned int count() const { return 3; }
  int at(unsigned int index) const { return data[index]; }

 private:
  int data[3];
};

Test class_returning_fn() { return Test(); }

std::unique_ptr<Test> class_unique_ptr_returning_fn() {
  return std::make_unique<Test>();
}

enum FirstEnum { kValueOne, kValueTwo, kValueThree };
enum SecondEnum { kValueA, kValueB, kValueC };
enum ThirdEnum { kValueAlpha, kValueBeta, kValueGamma };
enum EmptyEnum {};

FirstEnum enum_returning_fn() { return kValueOne; }
SecondEnum num_enum_returning_fn() { return kValueA; }
ThirdEnum str_enum_returning_fn() { return kValueAlpha; }

struct ValArr {
  int x, y, z;
};

EMSCRIPTEN_DECLARE_VAL_TYPE(CallbackType);

struct ValObj {
  FirstEnum firstEnum;
  SecondEnum secondEnum;
  ThirdEnum thirdEnum;
  std::string string;
  CallbackType callback;
  std::optional<int> optionalInt;
  ValObj() : callback(val::undefined()) {}
};

EMSCRIPTEN_DECLARE_VAL_TYPE(AliasedVal);


ValObj getValObj() {
  ValObj o;
  return o;
}

void setValObj(ValObj v) {}

class ClassWithConstructor {
 public:
  ClassWithConstructor(int, const ValArr&) {}

  int fn(int x) { return 0; }
};

class ClassWithTwoConstructors {
 public:
  ClassWithTwoConstructors() {}
  ClassWithTwoConstructors(int) {}
};

class ClassWithSmartPtrConstructor {
 public:
  ClassWithSmartPtrConstructor(int, const ValArr&) {}

  int fn(int x) { return 0; }
};

int smart_ptr_function(std::shared_ptr<ClassWithSmartPtrConstructor>) {
  return 0;
}

struct Obj {};
Obj* get_pointer(Obj* ptr) { return ptr; }
Obj* get_nonnull_pointer() { return new Obj(); }

int function_with_callback_param(CallbackType ct) {
  ct(val("hello"));
  return 0;
}

void function_consuming_aliased_val(AliasedVal) {
}

int global_fn(int, int) { return 0; }

std::string string_test(std::string arg) {
  return "hi";
}

std::wstring wstring_test(std::wstring arg) {
  return L"hi";
}

std::optional<std::string> optional_string_test(std::string arg) {
  return "hi";
}

std::optional<int> optional_test(std::optional<Foo> arg) {
  return {};
}

std::optional<int> optional_and_nonoptional_test(std::optional<Foo> arg1, int arg2) {
  return {};
}

class BaseClass {
 public:
  virtual ~BaseClass() = default;
  virtual int fn(int x) { return 0; }
};

class DerivedClass : public BaseClass {
 public:
  int fn(int x) override { return 1; }
  int fn2(int x) { return 2; }
};

struct Interface {
  virtual void invoke(const std::string& str) = 0;
  virtual ~Interface() {}
};

struct InterfaceWrapper : public wrapper<Interface> {
  EMSCRIPTEN_WRAPPER(InterfaceWrapper);
  void invoke(const std::string& str) {
      return call<void>("invoke", str);
  }
};

EMSCRIPTEN_BINDINGS(Test) {
  class_<Test>("Test")
      .function("functionOne", &Test::function_one)
      .function("functionTwo", &Test::function_two)
      .function("functionThree", &Test::function_three)
      .function("functionFour", &Test::function_four)
      .function("functionFive(x, y)", &Test::function_one)
      .function("functionSix(str)", &Test::function_three)
      .function("longFn", &Test::long_fn)
      .function("constFn", &Test::const_fn)
      .property("x", &Test::getX, &Test::setX)
      .property("y", &Test::getY)
      .property("stringProperty", &Test::string_property)
      .class_function("staticFunction", &Test::static_function)
      .class_function("staticFunctionWithParam(x)", &Test::static_function)
      .class_property("staticProperty", &Test::static_property)
      .class_property("staticStringProperty", &Test::static_string_property)
	;

  function("class_returning_fn", &class_returning_fn);
  function("class_unique_ptr_returning_fn",
                   &class_unique_ptr_returning_fn);
  class_<Obj>("Obj");
  function("getPointer", &get_pointer, allow_raw_pointers());
  function("getNonnullPointer", &get_nonnull_pointer, allow_raw_pointers(), nonnull<ret_val>());

  constant("an_int", 5);
  constant("a_bool", false);
  constant("an_enum", FirstEnum::kValueOne);
  constant("a_class_instance", Test());

  enum_<FirstEnum>("FirstEnum", enum_value_type::object)
      .value("kValueOne", FirstEnum::kValueOne)
      .value("kValueTwo", FirstEnum::kValueTwo)
      .value("kValueThree", FirstEnum::kValueThree);
  enum_<SecondEnum>("SecondEnum", enum_value_type::number)
      .value("kValueA", SecondEnum::kValueA)
      .value("kValueB", SecondEnum::kValueB)
      .value("kValueC", SecondEnum::kValueC);
  enum_<ThirdEnum>("ThirdEnum", enum_value_type::string)
      .value("kValueAlpha", ThirdEnum::kValueAlpha)
      .value("kValueBeta", ThirdEnum::kValueBeta)
      .value("kValueGamma", ThirdEnum::kValueGamma);
  enum_<EmptyEnum>("EmptyEnum");

  function("enum_returning_fn", &enum_returning_fn);
  function("num_enum_returning_fn", &num_enum_returning_fn);
  function("str_enum_returning_fn", &str_enum_returning_fn);

  value_array<ValArr>("ValArr")
      .element(&ValArr::x)
      .element(&ValArr::y)
      .element(&ValArr::z);

  value_array<std::array<FirstEnum, 4>>("ValArrIx")
    .element(emscripten::index<0>())
    .element(emscripten::index<1>())
    .element(emscripten::index<2>())
    .element(emscripten::index<3>());

  value_object<ValObj>("ValObj")
      .field("string", &ValObj::string)
      .field("firstEnum", &ValObj::firstEnum)
      .field("secondEnum", &ValObj::secondEnum)
      .field("thirdEnum", &ValObj::thirdEnum)
      .field("optionalInt", &ValObj::optionalInt)
      .field("callback", &ValObj::callback);
  function("getValObj", &getValObj);
  function("setValObj", &setValObj);

  register_vector<int>("IntVec");

  class_<IterableClass>("IterableClass")
      .constructor<>()
      .function("count", &IterableClass::count)
      .function("at", &IterableClass::at)
      .iterable<int>("count", "at");

  register_map<int, int>("MapIntInt");

  class_<Foo>("Foo").function("process", &Foo::process);

  function("global_fn", &global_fn);

  register_optional<int>();
  register_optional<std::string>();
  register_optional<Foo>();
  function("optional_test", &optional_test);
  function("optional_and_nonoptional_test", &optional_and_nonoptional_test);

  function("string_test", &string_test);
  function("wstring_test", &wstring_test);
  function("optional_string_test", &optional_string_test);

  class_<ClassWithConstructor>("ClassWithConstructor")
      .constructor<int, const ValArr&>()
      .function("fn", &ClassWithConstructor::fn);

  // The last defined constructor should be used in the definition.
  class_<ClassWithTwoConstructors>("ClassWithTwoConstructors")
      .constructor<>()
      .constructor<int>();

  class_<ClassWithSmartPtrConstructor>("ClassWithSmartPtrConstructor")
      .smart_ptr_constructor(
          "ClassWithSmartPtrConstructor",
          &std::make_shared<ClassWithSmartPtrConstructor, int, const ValArr&>)
      .function("fn", &ClassWithSmartPtrConstructor::fn);

  function("smart_ptr_function", &smart_ptr_function);
  function("smart_ptr_function_with_params(foo)", &smart_ptr_function);

  function("function_with_callback_param",
           &function_with_callback_param);

  function("function_consuming_aliased_val",
           &function_consuming_aliased_val);

  register_type<CallbackType>("(message: string) => void");
  register_type<AliasedVal>("AliasedVal", "number");

  class_<BaseClass>("BaseClass").function("fn", &BaseClass::fn);

  class_<DerivedClass, base<BaseClass>>("DerivedClass")
      .function("fn2", &DerivedClass::fn2);

  class_<Interface>("Interface")
    .function("invoke", &Interface::invoke, pure_virtual())
    .allow_subclass<InterfaceWrapper>("InterfaceWrapper")
    ;
}

int Test::static_property = 42;
std::string Test::static_string_property = "";

int main() {
  // Main should not be run during TypeScript generation, but should run when
  // the program is run normally.
  printf("main ran\n");
  return 0;
}