package com.facebook.react.bridge;

public class ReactBridge extends Countable {

 static final String REACT_NATIVE_LIB = "reactnativejni";

 static {
  SoLoader.loadLibrary(REACT_NATIVE_LIB);
 }

 ...

 public native void callFunction(int moduleId, int methodId, NativeArray arguments);

 ...

}

public abstract class NativeArray {
 static {
  SoLoader.loadLibrary(ReactBridge.REACT_NATIVE_LIB);
 }

 protected NativeArray(HybridData hybridData) {
  mHybridData = hybridData;
 }

 @Override
 public native String toString();

 @DoNotStrip
 private HybridData mHybridData;
}

package com.facebook.react.bridge;

public class WritableNativeArray extends ReadableNativeArray implements WritableArray {

 static {
  SoLoader.loadLibrary(ReactBridge.REACT_NATIVE_LIB);
 }

 public WritableNativeArray() {
  super(initHybrid());
 }

 @Override
 public native void pushNull();
 @Override
 public native void pushBoolean(boolean value);
 @Override
 public native void pushDouble(double value);
 @Override
 public native void pushInt(int value);
 @Override
 public native void pushString(String value);

 @Override
 public void pushArray(WritableArray array) {
  Assertions.assertCondition(
    array == null || array instanceof WritableNativeArray, "Illegal type provided");
  pushNativeArray((WritableNativeArray) array);
 }

 @Override
 public void pushMap(WritableMap map) {
  Assertions.assertCondition(
    map == null || map instanceof WritableNativeMap, "Illegal type provided");
  pushNativeMap((WritableNativeMap) map);
 }

 private native static HybridData initHybrid();
 private native void pushNativeArray(WritableNativeArray array);
 private native void pushNativeMap(WritableNativeMap map);
}

 private static class JavaScriptModuleInvocationHandler implements InvocationHandler {

  private final CatalystInstanceImpl mCatalystInstance;
  private final JavaScriptModuleRegistration mModuleRegistration;

  public JavaScriptModuleInvocationHandler(
    CatalystInstanceImpl catalystInstance,
    JavaScriptModuleRegistration moduleRegistration) {
   mCatalystInstance = catalystInstance;
   mModuleRegistration = moduleRegistration;
  }

  @Override
  public @Nullable Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
   String tracingName = mModuleRegistration.getTracingName(method);
   mCatalystInstance.callFunction(
     mModuleRegistration.getModuleId(),
     mModuleRegistration.getMethodId(method),
     Arguments.fromJavaArgs(args),
     tracingName);
   return null;
  }
 }

 public static WritableNativeArray fromJavaArgs(Object[] args) {
  WritableNativeArray arguments = new WritableNativeArray();
  for (int i = 0; i < args.length; i++) {
   Object argument = args[i];
   if (argument == null) {
    arguments.pushNull();
    continue;
   }

   Class argumentClass = argument.getClass();
   if (argumentClass == Boolean.class) {
    arguments.pushBoolean(((Boolean) argument).booleanValue());
   } else if (argumentClass == Integer.class) {
    arguments.pushDouble(((Integer) argument).doubleValue());
   } else if (argumentClass == Double.class) {
    arguments.pushDouble(((Double) argument).doubleValue());
   } else if (argumentClass == Float.class) {
    arguments.pushDouble(((Float) argument).doubleValue());
   } else if (argumentClass == String.class) {
    arguments.pushString(argument.toString());
   } else if (argumentClass == WritableNativeMap.class) {
    arguments.pushMap((WritableNativeMap) argument);
   } else if (argumentClass == WritableNativeArray.class) {
    arguments.pushArray((WritableNativeArray) argument);
   } else {
    throw new RuntimeException("Cannot convert argument of type " + argumentClass);
   }
  }
  return arguments;
 }

static void registerNatives() {
  jni::registerNatives("com/facebook/react/bridge/WritableNativeArray", {
    makeNativeMethod("initHybrid", WritableNativeArray::initHybrid),
    makeNativeMethod("pushNull", WritableNativeArray::pushNull),
    makeNativeMethod("pushBoolean", WritableNativeArray::pushBoolean),
    makeNativeMethod("pushDouble", WritableNativeArray::pushDouble),
    makeNativeMethod("pushInt", WritableNativeArray::pushInt),
    makeNativeMethod("pushString", WritableNativeArray::pushString),
    makeNativeMethod("pushNativeArray", WritableNativeArray::pushNativeArray),
    makeNativeMethod("pushNativeMap", "(Lcom/facebook/react/bridge/WritableNativeMap;)V",
             WritableNativeArray::pushNativeMap),
  });
 }

struct WritableNativeArray
  : public jni::HybridClass<WritableNativeArray, ReadableNativeArray> {
 static constexpr const char* kJavaDescriptor = "Lcom/facebook/react/bridge/WritableNativeArray;";

 WritableNativeArray()
   : HybridBase(folly::dynamic({})) {}

 static local_ref<jhybriddata> initHybrid(alias_ref<jclass>) {
  return makeCxxInstance();
 }

 void pushNull() {
  ...
  array.push_back(nullptr);
 }

 void pushBoolean(jboolean value) {
  ...
  array.push_back(value == JNI_TRUE);
 }

 void pushDouble(jdouble value) {
  ...
  array.push_back(value);
 }

 void pushInt(jint value) {
  ...
  array.push_back(value);
 }

 void pushString(jstring value) {
  ...
  array.push_back(wrap_alias(value)->toStdString());
 }

 void pushNativeArray(WritableNativeArray* otherArray) {
  ...
  array.push_back(std::move(otherArray->array));
  otherArray->isConsumed = true;
 }

 void pushNativeMap(jobject jmap) {
  ...
  array.push_back(std::move(map->map));
  map->isConsumed = true;
 }
 ...
}

public class WritableNativeArray extends ReadableNativeArray implements WritableArray {
  ...
  public WritableNativeArray() {
   super(initHybrid());
  }
  ...
  private native static HybridData initHybrid();
  ...
}

public class HybridData {
  // Private C++ instance
  private long mNativePointer = 0;
  public HybridData() {
    Prerequisites.ensure();
  }
  public native void resetNative();

  protected void finalize() throws Throwable {
   resetNative();
   super.finalize();
  }
}

public class Prerequisites {
  ...
  public static void ensure() {
    SoLoader.loadLibrary("fbjni");
  }
  ...
}

struct WritableNativeArray
  : public jni::HybridClass<WritableNativeArray, ReadableNativeArray> {
  ...

 static local_ref<jhybriddata> initHybrid(alias_ref<jclass>) {
   return makeCxxInstance();
 }

  ... 
}

...

struct HybridData : public JavaClass<HybridData> {
 constexpr static auto kJavaDescriptor = "Lcom/facebook/jni/HybridData;";
 void setNativePointer(std::unique_ptr<BaseHybridClass> new_value);
 BaseHybridClass* getNativePointer();
 static local_ref<HybridData> create();
};

...

typedef detail::HybridData::javaobject jhybriddata;

...

class HybridClass : public detail::HybridTraits<Base>::CxxBase {
  ...

 static local_ref<detail::HybridData> makeHybridData(std::unique_ptr<T> cxxPart) {
  auto hybridData = detail::HybridData::create();
  hybridData->setNativePointer(std::move(cxxPart));
  return hybridData;
 }

 template <typename... Args>
 static local_ref<detail::HybridData> makeCxxInstance(Args&&... args) {
  return makeHybridData(std::unique_ptr<T>(new T(std::forward<Args>(args)...)));
 }

  ...
}

struct WritableNativeArray
  : public jni::HybridClass<WritableNativeArray, ReadableNativeArray> {
 static constexpr const char* kJavaDescriptor = "Lcom/facebook/react/bridge/WritableNativeArray;";

  ...

  static local_ref<jhybriddata> initHybrid(alias_ref<jclass>) {
   return makeCxxInstance();
  }

  ...
}

local_ref<HybridData> HybridData::create() {
 return newInstance();
}

void HybridData::setNativePointer(std::unique_ptr<basehybridclass> new_value) {
 static auto pointerField = getClass()->getField<jlong>("mNativePointer");
 auto* old_value = reinterpret_cast<BaseHybridClass*>(getFieldValue(pointerField));

 if (new_value) {
  ...
 } else if (old_value == 0) {
  return;
 }
 delete old_value;
 ...
 setFieldValue(pointerField, reinterpret_cast<jlong>(new_value.release()));

}

// Given a *_ref object which refers to a hybrid class, this will reach inside
// of it, find the mHybridData, extract the C++ instance pointer, cast it to
// the appropriate type, and return it.
template <typename T>
inline auto cthis(T jthis) -> decltype(jthis->cthis()) {
 return jthis->cthis();
}

inline T* HybridClass<T, B>::JavaPart::cthis() {
 static auto field =
  HybridClass<T, B>::JavaPart::javaClassStatic()->template getField<detail::HybridData::javaobject>("mHybridData");
 auto hybridData = this->getFieldValue(field);
 ...
 // I'd like to use dynamic_cast here, but -fno-rtti is the default.
 T* value = static_cast<T*>(hybridData->getNativePointer());
 ...
 return value;
};

BaseHybridClass* HybridData::getNativePointer() {
 static auto pointerField = getClass()->getField<jlong>("mNativePointer");
 auto* value = reinterpret_cast<BaseHybridClass*>(getFieldValue(pointerField));
 ...
 return value;
}

static void makeJavaCall(JNIEnv* env, ExecutorToken executorToken, jobject callback, const MethodCall& call) {
 if (call.arguments.isNull()) {
  return;
 }

 ...

 auto newArray = ReadableNativeArray::newObjectCxxArgs(std::move(call.arguments));
 env->CallVoidMethod(
   callback,
   gCallbackMethod,
   static_cast<JExecutorTokenHolder*>(executorToken.getPlatformExecutorToken().get())->getJobj(),
   call.moduleId,
   call.methodId,
   newArray.get());
}

template <typename... Args>
static local_ref<JavaPart> newObjectCxxArgs(Args&&... args) {
  auto hybridData = makeCxxInstance(std::forward<Args>(args)...);
  return JavaPart::newInstance(hybridData);
}

template <typename... Args>
static local_ref<detail::HybridData> makeCxxInstance(Args&&... args) {
 return makeHybridData(std::unique_ptr<T>(new T(std::forward<Args>(args)...)));
}

template<typename JC, typename... Args>
static local_ref<JC> newInstance(Args... args) {
 static auto cls = JC::javaClassStatic();
 static auto constructor = cls->template getConstructor<typename JC::javaobject(Args...)>();
 return cls->newObject(constructor, args...);
}

public class ReadableNativeArray extends NativeArray implements ReadableArray {
  static {
   SoLoader.loadLibrary(ReactBridge.REACT_NATIVE_LIB);
  }

  protected ReadableNativeArray(HybridData hybridData) {
   super(hybridData);
  }

  @Override
  public native int size();
  @Override
  public native boolean isNull(int index);
  @Override
  public native boolean getBoolean(int index);
  @Override
  public native double getDouble(int index);
  @Override
  public native int getInt(int index);
  @Override
  public native String getString(int index);
  @Override
  public native ReadableNativeArray getArray(int index);
  @Override
  public native ReadableNativeMap getMap(int index);
  @Override
  public native ReadableType getType(int index);
}

ReadableNativeArray::ReadableNativeArray(folly::dynamic array)
  : HybridBase(std::move(array)) {}

...

jint ReadableNativeArray::getSize() {
 return array.size();
}

jboolean ReadableNativeArray::isNull(jint index) {
 return array.at(index).isNull() ? JNI_TRUE : JNI_FALSE;
}

jboolean ReadableNativeArray::getBoolean(jint index) {
 return array.at(index).getBool() ? JNI_TRUE : JNI_FALSE;
}

jdouble ReadableNativeArray::getDouble(jint index) {
 const folly::dynamic& val = array.at(index);
 if (val.isInt()) {
  return val.getInt();
 }
 return val.getDouble();
}

jint ReadableNativeArray::getInt(jint index) {
 auto integer = array.at(index).getInt();
 ...
 jint javaint = static_cast<jint>(integer);
 ...
 return javaint;
}

const char* ReadableNativeArray::getString(jint index) {
 const folly::dynamic& dyn = array.at(index);
 if (dyn.isNull()) {
  return nullptr;
 }
 return dyn.getString().c_str();
}

ReadableNativeArray::getArray(jint index) {
 auto& elem = array.at(index);
 if (elem.isNull()) {
  return jni::local_ref<ReadableNativeArray::jhybridobject>(nullptr);
 } else {
  return ReadableNativeArray::newObjectCxxArgs(elem);
 }
}

jobject ReadableNativeArray::getMap(jint index) {
 return createReadableNativeMapWithContents(Environment::current(), array.at(index));
}

jobject ReadableNativeArray::getType(jint index) {
 return type::getType(array.at(index).type());
}

void ReadableNativeArray::registerNatives() {
 jni::registerNatives("com/facebook/react/bridge/ReadableNativeArray", {
  makeNativeMethod("size", ReadableNativeArray::getSize),
  makeNativeMethod("isNull", ReadableNativeArray::isNull),
  makeNativeMethod("getBoolean", ReadableNativeArray::getBoolean),
  makeNativeMethod("getDouble", ReadableNativeArray::getDouble),
  makeNativeMethod("getInt", ReadableNativeArray::getInt),
  makeNativeMethod("getString", ReadableNativeArray::getString),
  makeNativeMethod("getArray", ReadableNativeArray::getArray),
  makeNativeMethod("getMap", "(I)Lcom/facebook/react/bridge/ReadableNativeMap;",
           ReadableNativeArray::getMap),
  makeNativeMethod("getType", "(I)Lcom/facebook/react/bridge/ReadableType;",
           ReadableNativeArray::getType),
 });
}