#ifndef CLEVERSYNC_JNI_HPP
#define CLEVERSYNC_JNI_HPP

#include <jni.h>
#include <cstdint>
#include <string>
#include <vector>

#define ABORT_IF_NOT_OK(x) (::jni::internal::_abort_if_not_ok(__FILE__, __LINE__, (x)))
#define ABORT_IF_NULL(env, x) (::jni::internal::_abort_if_null(__FILE__, __LINE__, (env), (x)))

namespace jni {

namespace internal {

void _abort_if_not_ok(const char *file, int line, jint ret);
void _abort_with_exception(const char* file, int line, JNIEnv* env);

JNIEnv* NonFatalAttachCurrentThread();

}  // namespace internal

template<class T>
class Ref {
 public:
  constexpr Ref() : ptr_(nullptr) {}
  constexpr Ref(std::nullptr_t) : ptr_(nullptr) {}
  Ref(const Ref<T>&) = delete;

  [[nodiscard]] T get() const { return ptr_; }
  [[nodiscard]] T release() {
    auto ret = release_to_local();
    ptr_ = nullptr;
    return ret;
  }

  void reset() {
    del();
    ptr_ = nullptr;
  }

  explicit operator bool() const { return ptr_ != nullptr; }

 protected:
  Ref(JNIEnv* env, T ptr): env_(env), ptr_(ptr) {}
  virtual ~Ref() = default;

  virtual T release_to_local() = 0;
  virtual void del() = 0;

  JNIEnv* env_;
  T ptr_;
};

constexpr jint JNI_VERSION = JNI_VERSION_1_4;

JNIEnv* AttachCurrentThread();

JNIEnv* OnLoad(JavaVM* vm);

template<class T>
class LocalRef : public Ref<T> {
 public:
  constexpr LocalRef(): Ref<T>() {}
  constexpr LocalRef(std::nullptr_t): Ref<T>() {}
  LocalRef(JNIEnv* env, T ptr): Ref<T>(env, ptr) {}
  ~LocalRef() override { free(); }

  LocalRef(LocalRef<T> &&ref) noexcept : Ref<T>(ref.env_, ref.release()) {}

  LocalRef& operator=(const Ref<T>& other) = delete;

  LocalRef& operator=(LocalRef<T> &&ref) noexcept {
    free();
    this->env_ = ref.env_;
    this->ptr_ = ref.release();
    return *this;
  }

 protected:
  T release_to_local() override { return this->ptr_; }
  void del() override { free(); }

 private:
  void free() {
    if (this->ptr_)
      this->env_->DeleteLocalRef(this->ptr_);
  }
};

template<class T>
class ParamRef : public Ref<T> {
 public:
  ParamRef(JNIEnv* env, T ptr) : Ref<T>(env, ptr) {}
  ~ParamRef() override = default;

  ParamRef& operator=(const Ref<T>& other) = delete;

 protected:
  T release_to_local() override {
    if (this->ptr_)
      return static_cast<T>(this->env_->NewLocalRef(static_cast<jobject>(this->ptr_)));
    return nullptr;
  }
  void del() override {}
};

template<class T>
class GlobalRef : public Ref<T> {
 public:
  constexpr GlobalRef() : Ref<T>() {}
  constexpr GlobalRef(std::nullptr_t) : Ref<T>() {}
  GlobalRef(JNIEnv* env, T ptr) : Ref<T>() {
    if (ptr) {
      if (!env)
        env = AttachCurrentThread();
      this->ptr_ = static_cast<T>(env->NewGlobalRef(static_cast<jobject>(ptr)));
    }
  }
  GlobalRef(const Ref<T>& other) : Ref<T>() {
    if (other) {
      auto* env = AttachCurrentThread();
      this->ptr_ = static_cast<T>(env->NewGlobalRef(static_cast<jobject>(other.get())));
    }
  }
  GlobalRef(GlobalRef<T>&& other) noexcept : Ref<T>(nullptr, other.ptr_) {
    other.ptr_ = nullptr;
    return *this;
  }

  ~GlobalRef() override { free(); }

  GlobalRef& operator=(const Ref<T>& other) {
    free();
    if (other) {
      auto* env = AttachCurrentThread();
      this->ptr_ = other ? static_cast<T>(env->NewGlobalRef(static_cast<jobject>(other.get()))) : nullptr;
    } else {
      this->ptr_ = nullptr;
    }
    return *this;
  }

  GlobalRef& operator=(GlobalRef<T>&& other) {
    free();
    this->ptr_ = other.ptr_;
    other.ptr_ = nullptr;
  }

 protected:
  T release_to_local() override {
    if (this->ptr_) {
      auto* env = AttachCurrentThread();
      auto ret = static_cast<T>(env->NewLocalRef(static_cast<jobject>(this->ptr_)));
      env->DeleteGlobalRef(static_cast<jobject>(this->ptr_));
      return ret;
    }
    return nullptr;
  }
  void del() override { free(); }

 private:
  void free() {
    if (this->ptr_) {
      auto* env = internal::NonFatalAttachCurrentThread();
      if (env)
        env->DeleteGlobalRef(static_cast<jobject>(this->ptr_));
    }
  }
};

LocalRef<jclass> FindClass(JNIEnv *env, const char *name);

LocalRef<jthrowable> ExceptionOccurred(JNIEnv* env);

template<typename Out, typename In, typename... Params>
LocalRef<Out> CallObjectMethod(JNIEnv* env, const Ref<In>& object, jmethodID method, Params... params) {
  return {env, static_cast<Out>(env->CallObjectMethod(object.get(), method, params...))};
}

template<typename Out, typename... Params>
LocalRef<Out> CallStaticObjectMethod(JNIEnv* env, const Ref<jclass>& clazz, jmethodID method, Params... params) {
  return {env, static_cast<Out>(env->CallStaticObjectMethod(clazz.get(), method, params...))};
}

std::string StringToUTF8(JNIEnv* env, const Ref<jstring>& str);

LocalRef<jstring> UTF8ToString(JNIEnv* env, const std::string& str);

LocalRef<jstring> UTF8ToString(JNIEnv* env, const char* str);

LocalRef<jbyteArray> VectorToByteArray(JNIEnv* env, const std::vector<uint8_t>& data);

std::vector<uint8_t> ByteArrayToVector(JNIEnv* env, const Ref<jbyteArray>& data);

LocalRef<jobjectArray> CreateArray(JNIEnv* env, const Ref<jclass>& element_class, std::vector<LocalRef<jobject>> objects);

namespace internal {

template<typename T>
inline void _abort_if_null(const char* file, int line, JNIEnv* env, const jni::Ref<T>& ref) {
  if (ref) [[likely]] return;

  _abort_with_exception(file, line, env);
}

inline void _abort_if_null(const char* file, int line, JNIEnv* env, jmethodID ref) {
  if (ref) [[likely]] return;

  _abort_with_exception(file, line, env);
}

}  // namespace internal

}  // namespace jni

#endif // CLEVERSYNC_JNI_HPP