/*
 * Copyright (C) 2018 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// JNI wrapper for actions.

#include "actions/actions_jni.h"

#include <jni.h>

#include <map>
#include <type_traits>
#include <vector>

#include "actions/actions-suggestions.h"
#include "annotator/annotator.h"
#include "annotator/annotator_jni_common.h"
#include "utils/base/integral_types.h"
#include "utils/base/status_macros.h"
#include "utils/base/statusor.h"
#include "utils/intents/intent-generator.h"
#include "utils/intents/jni.h"
#include "utils/intents/remote-action-template.h"
#include "utils/java/jni-base.h"
#include "utils/java/jni-cache.h"
#include "utils/java/jni-helper.h"
#include "utils/memory/mmap.h"

using libtextclassifier3::ActionsSuggestions;
using libtextclassifier3::ActionsSuggestionsResponse;
using libtextclassifier3::ActionSuggestionOptions;
using libtextclassifier3::Annotator;
using libtextclassifier3::Conversation;
using libtextclassifier3::IntentGenerator;
using libtextclassifier3::JStringToUtf8String;
using libtextclassifier3::ScopedLocalRef;
using libtextclassifier3::StatusOr;

// When using the Java's ICU, UniLib needs to be instantiated with a JavaVM
// pointer from JNI. When using a standard ICU the pointer is not needed and the
// objects are instantiated implicitly.
#ifdef TC3_UNILIB_JAVAICU
using libtextclassifier3::UniLib;
#endif

namespace libtextclassifier3 {

namespace {

// Cached state for model inference.
// Keeps a jni cache, intent generator and model instance so that they don't
// have to be recreated for each call.
class ActionsSuggestionsJniContext {
 public:
  static ActionsSuggestionsJniContext* Create(
      const std::shared_ptr<libtextclassifier3::JniCache>& jni_cache,
      std::unique_ptr<ActionsSuggestions> model) {
    if (jni_cache == nullptr || model == nullptr) {
      return nullptr;
    }
    std::unique_ptr<IntentGenerator> intent_generator =
        IntentGenerator::Create(model->model()->android_intent_options(),
                                model->model()->resources(), jni_cache);
    if (intent_generator == nullptr) {
      return nullptr;
    }

    TC3_ASSIGN_OR_RETURN_NULL(
        std::unique_ptr<RemoteActionTemplatesHandler> template_handler,
        libtextclassifier3::RemoteActionTemplatesHandler::Create(jni_cache));

    return new ActionsSuggestionsJniContext(jni_cache, std::move(model),
                                            std::move(intent_generator),
                                            std::move(template_handler));
  }

  std::shared_ptr<libtextclassifier3::JniCache> jni_cache() const {
    return jni_cache_;
  }

  ActionsSuggestions* model() const { return model_.get(); }

  IntentGenerator* intent_generator() const { return intent_generator_.get(); }

  RemoteActionTemplatesHandler* template_handler() const {
    return template_handler_.get();
  }

 private:
  ActionsSuggestionsJniContext(
      const std::shared_ptr<libtextclassifier3::JniCache>& jni_cache,
      std::unique_ptr<ActionsSuggestions> model,
      std::unique_ptr<IntentGenerator> intent_generator,
      std::unique_ptr<RemoteActionTemplatesHandler> template_handler)
      : jni_cache_(jni_cache),
        model_(std::move(model)),
        intent_generator_(std::move(intent_generator)),
        template_handler_(std::move(template_handler)) {}

  std::shared_ptr<libtextclassifier3::JniCache> jni_cache_;
  std::unique_ptr<ActionsSuggestions> model_;
  std::unique_ptr<IntentGenerator> intent_generator_;
  std::unique_ptr<RemoteActionTemplatesHandler> template_handler_;
};

ActionSuggestionOptions FromJavaActionSuggestionOptions(JNIEnv* env,
                                                        jobject joptions) {
  ActionSuggestionOptions options = ActionSuggestionOptions::Default();
  return options;
}

StatusOr<ScopedLocalRef<jobject>> ActionSuggestionsToJObject(
    JNIEnv* env, const ActionsSuggestionsJniContext* context,
    jobject app_context,
    const reflection::Schema* annotations_entity_data_schema,
    const ActionsSuggestionsResponse& action_response,
    const Conversation& conversation, const jstring device_locales,
    const bool generate_intents) {
  // Find the class ActionSuggestion.
  auto status_or_action_class = JniHelper::FindClass(
      env, TC3_PACKAGE_PATH TC3_ACTIONS_CLASS_NAME_STR "$ActionSuggestion");
  if (!status_or_action_class.ok()) {
    TC3_LOG(ERROR) << "Couldn't find ActionSuggestion class.";
    return status_or_action_class.status();
  }
  ScopedLocalRef<jclass> action_class =
      std::move(status_or_action_class.ValueOrDie());

  // Find the class ActionSuggestions
  auto status_or_result_class = JniHelper::FindClass(
      env, TC3_PACKAGE_PATH TC3_ACTIONS_CLASS_NAME_STR "$ActionSuggestions");
  if (!status_or_result_class.ok()) {
    TC3_LOG(ERROR) << "Couldn't find ActionSuggestions class.";
    return status_or_result_class.status();
  }
  ScopedLocalRef<jclass> result_class =
      std::move(status_or_result_class.ValueOrDie());

  // Find the class Slot.
  auto status_or_slot_class = JniHelper::FindClass(
      env, TC3_PACKAGE_PATH TC3_ACTIONS_CLASS_NAME_STR "$Slot");
  if (!status_or_slot_class.ok()) {
    TC3_LOG(ERROR) << "Couldn't find Slot class.";
    return status_or_slot_class.status();
  }
  ScopedLocalRef<jclass> slot_class =
      std::move(status_or_slot_class.ValueOrDie());

  TC3_ASSIGN_OR_RETURN(
      const jmethodID action_class_constructor,
      JniHelper::GetMethodID(
          env, action_class.get(), "<init>",
          "(Ljava/lang/String;Ljava/lang/String;F[L" TC3_PACKAGE_PATH
              TC3_NAMED_VARIANT_CLASS_NAME_STR
          ";[B[L" TC3_PACKAGE_PATH TC3_REMOTE_ACTION_TEMPLATE_CLASS_NAME_STR
          ";[L" TC3_PACKAGE_PATH TC3_ACTIONS_CLASS_NAME_STR "$Slot;)V"));
  TC3_ASSIGN_OR_RETURN(const jmethodID slot_class_constructor,
                       JniHelper::GetMethodID(env, slot_class.get(), "<init>",
                                              "(Ljava/lang/String;IIIF)V"));
  TC3_ASSIGN_OR_RETURN(
      ScopedLocalRef<jobjectArray> actions,
      JniHelper::NewObjectArray(env, action_response.actions.size(),
                                action_class.get(), nullptr));
  for (int i = 0; i < action_response.actions.size(); i++) {
    ScopedLocalRef<jobjectArray> extras;
    const reflection::Schema* actions_entity_data_schema =
        context->model()->entity_data_schema();
    if (actions_entity_data_schema != nullptr &&
        !action_response.actions[i].serialized_entity_data.empty()) {
      TC3_ASSIGN_OR_RETURN(
          extras, context->template_handler()->EntityDataAsNamedVariantArray(
                      actions_entity_data_schema,
                      action_response.actions[i].serialized_entity_data));
    }

    ScopedLocalRef<jbyteArray> serialized_entity_data;
    if (!action_response.actions[i].serialized_entity_data.empty()) {
      TC3_ASSIGN_OR_RETURN(
          serialized_entity_data,
          JniHelper::NewByteArray(
              env, action_response.actions[i].serialized_entity_data.size()));
      TC3_RETURN_IF_ERROR(JniHelper::SetByteArrayRegion(
          env, serialized_entity_data.get(), 0,
          action_response.actions[i].serialized_entity_data.size(),
          reinterpret_cast<const jbyte*>(
              action_response.actions[i].serialized_entity_data.data())));
    }

    ScopedLocalRef<jobjectArray> remote_action_templates_result;
    if (generate_intents) {
      std::vector<RemoteActionTemplate> remote_action_templates;
      if (context->intent_generator()->GenerateIntents(
              device_locales, action_response.actions[i], conversation,
              app_context,
              /*annotations_entity_data_schema=*/annotations_entity_data_schema,
              /*actions_entity_data_schema=*/actions_entity_data_schema,
              &remote_action_templates)) {
        TC3_ASSIGN_OR_RETURN(
            remote_action_templates_result,
            context->template_handler()->RemoteActionTemplatesToJObjectArray(
                remote_action_templates));
      }
    }

    TC3_ASSIGN_OR_RETURN(ScopedLocalRef<jstring> reply,
                         context->jni_cache()->ConvertToJavaString(
                             action_response.actions[i].response_text));

    TC3_ASSIGN_OR_RETURN(
        ScopedLocalRef<jstring> action_type,
        JniHelper::NewStringUTF(env, action_response.actions[i].type.c_str()));

    ScopedLocalRef<jobjectArray> slots;
    if (!action_response.actions[i].slots.empty()) {
      TC3_ASSIGN_OR_RETURN(slots,
                           JniHelper::NewObjectArray(
                               env, action_response.actions[i].slots.size(),
                               slot_class.get(), nullptr));
      for (int j = 0; j < action_response.actions[i].slots.size(); j++) {
        const Slot& slot_c = action_response.actions[i].slots[j];
        TC3_ASSIGN_OR_RETURN(ScopedLocalRef<jstring> slot_type,
                             JniHelper::NewStringUTF(env, slot_c.type.c_str()));

        TC3_ASSIGN_OR_RETURN(
            ScopedLocalRef<jobject> slot,
            JniHelper::NewObject(
                env, slot_class.get(), slot_class_constructor, slot_type.get(),
                slot_c.span.message_index, slot_c.span.span.first,
                slot_c.span.span.second, slot_c.confidence_score));

        TC3_RETURN_IF_ERROR(
            JniHelper::SetObjectArrayElement(env, slots.get(), j, slot.get()));
      }
    }

    TC3_ASSIGN_OR_RETURN(
        ScopedLocalRef<jobject> action,
        JniHelper::NewObject(
            env, action_class.get(), action_class_constructor, reply.get(),
            action_type.get(),
            static_cast<jfloat>(action_response.actions[i].score), extras.get(),
            serialized_entity_data.get(), remote_action_templates_result.get(),
            slots.get()));
    TC3_RETURN_IF_ERROR(
        JniHelper::SetObjectArrayElement(env, actions.get(), i, action.get()));
  }

  // Create the ActionSuggestions object.
  TC3_ASSIGN_OR_RETURN(
      const jmethodID result_class_constructor,
      JniHelper::GetMethodID(env, result_class.get(), "<init>",
                             "([L" TC3_PACKAGE_PATH TC3_ACTIONS_CLASS_NAME_STR
                             "$ActionSuggestion;Z)V"));
  TC3_ASSIGN_OR_RETURN(
      ScopedLocalRef<jobject> result,
      JniHelper::NewObject(env, result_class.get(), result_class_constructor,
                           actions.get(), action_response.is_sensitive));
  return result;
}

StatusOr<ConversationMessage> FromJavaConversationMessage(JNIEnv* env,
                                                          jobject jmessage) {
  if (!jmessage) {
    return {};
  }

  TC3_ASSIGN_OR_RETURN(
      ScopedLocalRef<jclass> message_class,
      JniHelper::FindClass(env, TC3_PACKAGE_PATH TC3_ACTIONS_CLASS_NAME_STR
                           "$ConversationMessage"));
  // .getText()
  TC3_ASSIGN_OR_RETURN(
      jmethodID get_text_method,
      JniHelper::GetMethodID(env, message_class.get(), "getText",
                             "()Ljava/lang/String;"));
  TC3_ASSIGN_OR_RETURN(
      ScopedLocalRef<jstring> text,
      JniHelper::CallObjectMethod<jstring>(env, jmessage, get_text_method));

  // .getUserId()
  TC3_ASSIGN_OR_RETURN(
      jmethodID get_user_id_method,
      JniHelper::GetMethodID(env, message_class.get(), "getUserId", "()I"));
  TC3_ASSIGN_OR_RETURN(int32 user_id, JniHelper::CallIntMethod(
                                          env, jmessage, get_user_id_method));

  // .getReferenceTimeMsUtc()
  TC3_ASSIGN_OR_RETURN(jmethodID get_reference_time_method,
                       JniHelper::GetMethodID(env, message_class.get(),
                                              "getReferenceTimeMsUtc", "()J"));
  TC3_ASSIGN_OR_RETURN(
      int64 reference_time,
      JniHelper::CallLongMethod(env, jmessage, get_reference_time_method));

  // .getReferenceTimezone()
  TC3_ASSIGN_OR_RETURN(
      jmethodID get_reference_timezone_method,
      JniHelper::GetMethodID(env, message_class.get(), "getReferenceTimezone",
                             "()Ljava/lang/String;"));
  TC3_ASSIGN_OR_RETURN(ScopedLocalRef<jstring> reference_timezone,
                       JniHelper::CallObjectMethod<jstring>(
                           env, jmessage, get_reference_timezone_method));

  // .getDetectedTextLanguageTags()
  TC3_ASSIGN_OR_RETURN(jmethodID get_detected_text_language_tags_method,
                       JniHelper::GetMethodID(env, message_class.get(),
                                              "getDetectedTextLanguageTags",
                                              "()Ljava/lang/String;"));
  TC3_ASSIGN_OR_RETURN(
      ScopedLocalRef<jstring> detected_text_language_tags,
      JniHelper::CallObjectMethod<jstring>(
          env, jmessage, get_detected_text_language_tags_method));

  ConversationMessage message;
  TC3_ASSIGN_OR_RETURN(message.text, JStringToUtf8String(env, text.get()));
  message.user_id = user_id;
  message.reference_time_ms_utc = reference_time;
  TC3_ASSIGN_OR_RETURN(message.reference_timezone,
                       JStringToUtf8String(env, reference_timezone.get()));
  TC3_ASSIGN_OR_RETURN(
      message.detected_text_language_tags,
      JStringToUtf8String(env, detected_text_language_tags.get()));
  return message;
}

StatusOr<Conversation> FromJavaConversation(JNIEnv* env,
                                            jobject jconversation) {
  if (!jconversation) {
    return {Status::UNKNOWN};
  }

  TC3_ASSIGN_OR_RETURN(
      ScopedLocalRef<jclass> conversation_class,
      JniHelper::FindClass(
          env, TC3_PACKAGE_PATH TC3_ACTIONS_CLASS_NAME_STR "$Conversation"));

  TC3_ASSIGN_OR_RETURN(
      jmethodID get_conversation_messages_method,
      JniHelper::GetMethodID(env, conversation_class.get(),
                             "getConversationMessages",
                             "()[L" TC3_PACKAGE_PATH TC3_ACTIONS_CLASS_NAME_STR
                             "$ConversationMessage;"));
  TC3_ASSIGN_OR_RETURN(
      ScopedLocalRef<jobjectArray> jmessages,
      JniHelper::CallObjectMethod<jobjectArray>(
          env, jconversation, get_conversation_messages_method));

  std::vector<ConversationMessage> messages;
  TC3_ASSIGN_OR_RETURN(const int size,
                       JniHelper::GetArrayLength(env, jmessages.get()));
  for (int i = 0; i < size; i++) {
    TC3_ASSIGN_OR_RETURN(
        ScopedLocalRef<jobject> jmessage,
        JniHelper::GetObjectArrayElement<jobject>(env, jmessages.get(), i));
    TC3_ASSIGN_OR_RETURN(ConversationMessage message,
                         FromJavaConversationMessage(env, jmessage.get()));
    messages.push_back(message);
  }
  Conversation conversation;
  conversation.messages = messages;
  return conversation;
}

StatusOr<ScopedLocalRef<jstring>> GetLocalesFromMmap(
    JNIEnv* env, libtextclassifier3::ScopedMmap* mmap) {
  if (!mmap->handle().ok()) {
    return JniHelper::NewStringUTF(env, "");
  }
  const ActionsModel* model = libtextclassifier3::ViewActionsModel(
      mmap->handle().start(), mmap->handle().num_bytes());
  if (!model || !model->locales()) {
    return JniHelper::NewStringUTF(env, "");
  }
  return JniHelper::NewStringUTF(env, model->locales()->c_str());
}

jint GetVersionFromMmap(JNIEnv* env, libtextclassifier3::ScopedMmap* mmap) {
  if (!mmap->handle().ok()) {
    return 0;
  }
  const ActionsModel* model = libtextclassifier3::ViewActionsModel(
      mmap->handle().start(), mmap->handle().num_bytes());
  if (!model) {
    return 0;
  }
  return model->version();
}

StatusOr<ScopedLocalRef<jstring>> GetNameFromMmap(
    JNIEnv* env, libtextclassifier3::ScopedMmap* mmap) {
  if (!mmap->handle().ok()) {
    return JniHelper::NewStringUTF(env, "");
  }
  const ActionsModel* model = libtextclassifier3::ViewActionsModel(
      mmap->handle().start(), mmap->handle().num_bytes());
  if (!model || !model->name()) {
    return JniHelper::NewStringUTF(env, "");
  }
  return JniHelper::NewStringUTF(env, model->name()->c_str());
}
}  // namespace
}  // namespace libtextclassifier3

using libtextclassifier3::ActionsSuggestionsJniContext;
using libtextclassifier3::ActionSuggestionsToJObject;
using libtextclassifier3::FromJavaActionSuggestionOptions;
using libtextclassifier3::FromJavaConversation;
using libtextclassifier3::JByteArrayToString;

TC3_JNI_METHOD(jlong, TC3_ACTIONS_CLASS_NAME, nativeNewActionsModel)
(JNIEnv* env, jobject clazz, jint fd, jbyteArray jserialized_preconditions) {
  std::shared_ptr<libtextclassifier3::JniCache> jni_cache =
      libtextclassifier3::JniCache::Create(env);
  std::string serialized_preconditions;
  if (jserialized_preconditions != nullptr) {
    TC3_ASSIGN_OR_RETURN_0(
        serialized_preconditions,
        JByteArrayToString(env, jserialized_preconditions),
        TC3_LOG(ERROR) << "Could not convert serialized preconditions.");
  }

#ifdef TC3_UNILIB_JAVAICU
  return reinterpret_cast<jlong>(ActionsSuggestionsJniContext::Create(
      jni_cache, ActionsSuggestions::FromFileDescriptor(
                     fd, std::unique_ptr<UniLib>(new UniLib(jni_cache)),
                     serialized_preconditions)));
#else
  return reinterpret_cast<jlong>(ActionsSuggestionsJniContext::Create(
      jni_cache, ActionsSuggestions::FromFileDescriptor(
                     fd, /*unilib=*/nullptr, serialized_preconditions)));
#endif  // TC3_UNILIB_JAVAICU
}

TC3_JNI_METHOD(jlong, TC3_ACTIONS_CLASS_NAME, nativeNewActionsModelFromPath)
(JNIEnv* env, jobject clazz, jstring path,
 jbyteArray jserialized_preconditions) {
  std::shared_ptr<libtextclassifier3::JniCache> jni_cache =
      libtextclassifier3::JniCache::Create(env);
  TC3_ASSIGN_OR_RETURN_0(const std::string path_str,
                         JStringToUtf8String(env, path));
  std::string serialized_preconditions;
  if (jserialized_preconditions != nullptr) {
    TC3_ASSIGN_OR_RETURN_0(
        serialized_preconditions,
        JByteArrayToString(env, jserialized_preconditions),
        TC3_LOG(ERROR) << "Could not convert serialized preconditions.");
  }
#ifdef TC3_UNILIB_JAVAICU
  return reinterpret_cast<jlong>(ActionsSuggestionsJniContext::Create(
      jni_cache, ActionsSuggestions::FromPath(
                     path_str, std::unique_ptr<UniLib>(new UniLib(jni_cache)),
                     serialized_preconditions)));
#else
  return reinterpret_cast<jlong>(ActionsSuggestionsJniContext::Create(
      jni_cache, ActionsSuggestions::FromPath(path_str, /*unilib=*/nullptr,
                                              serialized_preconditions)));
#endif  // TC3_UNILIB_JAVAICU
}

TC3_JNI_METHOD(jlong, TC3_ACTIONS_CLASS_NAME, nativeNewActionsModelWithOffset)
(JNIEnv* env, jobject clazz, jint fd, jlong offset, jlong size,
 jbyteArray jserialized_preconditions) {
  std::shared_ptr<libtextclassifier3::JniCache> jni_cache =
      libtextclassifier3::JniCache::Create(env);
  std::string serialized_preconditions;
  if (jserialized_preconditions != nullptr) {
    TC3_ASSIGN_OR_RETURN_0(
        serialized_preconditions,
        JByteArrayToString(env, jserialized_preconditions),
        TC3_LOG(ERROR) << "Could not convert serialized preconditions.");
  }
#ifdef TC3_UNILIB_JAVAICU
  return reinterpret_cast<jlong>(ActionsSuggestionsJniContext::Create(
      jni_cache,
      ActionsSuggestions::FromFileDescriptor(
          fd, offset, size, std::unique_ptr<UniLib>(new UniLib(jni_cache)),
          serialized_preconditions)));
#else
  return reinterpret_cast<jlong>(ActionsSuggestionsJniContext::Create(
      jni_cache,
      ActionsSuggestions::FromFileDescriptor(
          fd, offset, size, /*unilib=*/nullptr, serialized_preconditions)));
#endif  // TC3_UNILIB_JAVAICU
}

TC3_JNI_METHOD(jobject, TC3_ACTIONS_CLASS_NAME, nativeSuggestActions)
(JNIEnv* env, jobject thiz, jlong ptr, jobject jconversation, jobject joptions,
 jlong annotatorPtr, jobject app_context, jstring device_locales,
 jboolean generate_intents) {
  if (!ptr) {
    return nullptr;
  }
  TC3_ASSIGN_OR_RETURN_NULL(const Conversation conversation,
                            FromJavaConversation(env, jconversation));
  const ActionSuggestionOptions options =
      FromJavaActionSuggestionOptions(env, joptions);
  const ActionsSuggestionsJniContext* context =
      reinterpret_cast<ActionsSuggestionsJniContext*>(ptr);
  const Annotator* annotator = reinterpret_cast<Annotator*>(annotatorPtr);

  const ActionsSuggestionsResponse response =
      context->model()->SuggestActions(conversation, annotator, options);

  const reflection::Schema* anntotations_entity_data_schema =
      annotator ? annotator->entity_data_schema() : nullptr;

  TC3_ASSIGN_OR_RETURN_NULL(
      ScopedLocalRef<jobject> result,
      ActionSuggestionsToJObject(
          env, context, app_context, anntotations_entity_data_schema, response,
          conversation, device_locales, generate_intents));
  return result.release();
}

TC3_JNI_METHOD(void, TC3_ACTIONS_CLASS_NAME, nativeCloseActionsModel)
(JNIEnv* env, jobject thiz, jlong model_ptr) {
  const ActionsSuggestionsJniContext* context =
      reinterpret_cast<ActionsSuggestionsJniContext*>(model_ptr);
  delete context;
}

TC3_JNI_METHOD(jstring, TC3_ACTIONS_CLASS_NAME, nativeGetLocales)
(JNIEnv* env, jobject clazz, jint fd) {
  const std::unique_ptr<libtextclassifier3::ScopedMmap> mmap(
      new libtextclassifier3::ScopedMmap(fd));
  TC3_ASSIGN_OR_RETURN_NULL(
      ScopedLocalRef<jstring> result,
      libtextclassifier3::GetLocalesFromMmap(env, mmap.get()));
  return result.release();
}

TC3_JNI_METHOD(jstring, TC3_ACTIONS_CLASS_NAME, nativeGetLocalesWithOffset)
(JNIEnv* env, jobject clazz, jint fd, jlong offset, jlong size) {
  const std::unique_ptr<libtextclassifier3::ScopedMmap> mmap(
      new libtextclassifier3::ScopedMmap(fd, offset, size));
  TC3_ASSIGN_OR_RETURN_NULL(
      ScopedLocalRef<jstring> result,
      libtextclassifier3::GetLocalesFromMmap(env, mmap.get()));
  return result.release();
}

TC3_JNI_METHOD(jstring, TC3_ACTIONS_CLASS_NAME, nativeGetName)
(JNIEnv* env, jobject clazz, jint fd) {
  const std::unique_ptr<libtextclassifier3::ScopedMmap> mmap(
      new libtextclassifier3::ScopedMmap(fd));
  TC3_ASSIGN_OR_RETURN_NULL(
      ScopedLocalRef<jstring> result,
      libtextclassifier3::GetNameFromMmap(env, mmap.get()));
  return result.release();
}

TC3_JNI_METHOD(jstring, TC3_ACTIONS_CLASS_NAME, nativeGetNameWithOffset)
(JNIEnv* env, jobject clazz, jint fd, jlong offset, jlong size) {
  const std::unique_ptr<libtextclassifier3::ScopedMmap> mmap(
      new libtextclassifier3::ScopedMmap(fd, offset, size));
  TC3_ASSIGN_OR_RETURN_NULL(
      ScopedLocalRef<jstring> result,
      libtextclassifier3::GetNameFromMmap(env, mmap.get()));
  return result.release();
}

TC3_JNI_METHOD(jint, TC3_ACTIONS_CLASS_NAME, nativeGetVersion)
(JNIEnv* env, jobject clazz, jint fd) {
  const std::unique_ptr<libtextclassifier3::ScopedMmap> mmap(
      new libtextclassifier3::ScopedMmap(fd));
  return libtextclassifier3::GetVersionFromMmap(env, mmap.get());
}

TC3_JNI_METHOD(jint, TC3_ACTIONS_CLASS_NAME, nativeGetVersionWithOffset)
(JNIEnv* env, jobject clazz, jint fd, jlong offset, jlong size) {
  const std::unique_ptr<libtextclassifier3::ScopedMmap> mmap(
      new libtextclassifier3::ScopedMmap(fd, offset, size));
  return libtextclassifier3::GetVersionFromMmap(env, mmap.get());
}

TC3_JNI_METHOD(jlong, TC3_ACTIONS_CLASS_NAME, nativeGetNativeModelPtr)
(JNIEnv* env, jobject thiz, jlong ptr) {
  if (!ptr) {
    return 0L;
  }
  return reinterpret_cast<jlong>(
      reinterpret_cast<ActionsSuggestionsJniContext*>(ptr)->model());
}

TC3_JNI_METHOD(jboolean, TC3_ACTIONS_CLASS_NAME,
               nativeInitializeConversationIntentDetection)
(JNIEnv* env, jobject thiz, jlong ptr, jbyteArray jserialized_config) {
  if (!ptr) {
    return false;
  }

  ActionsSuggestions* model =
      reinterpret_cast<ActionsSuggestionsJniContext*>(ptr)->model();

  std::string serialized_config;
  TC3_ASSIGN_OR_RETURN_0(
      serialized_config, JByteArrayToString(env, jserialized_config),
      TC3_LOG(ERROR) << "Could not convert serialized conversation intent "
                        "detection config.");
  return model->InitializeConversationIntentDetection(serialized_config);
}