// Copyright 2017 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "content/browser/android/text_suggestion_host_android.h"

#include "base/android/jni_android.h"
#include "base/android/jni_array.h"
#include "base/android/jni_string.h"
#include "base/functional/bind.h"
#include "content/browser/android/text_suggestion_host_mojo_impl_android.h"
#include "content/browser/renderer_host/render_widget_host_impl.h"
#include "content/browser/web_contents/web_contents_impl.h"
#include "content/public/android/content_jni_headers/SuggestionInfo_jni.h"
#include "content/public/android/content_jni_headers/TextSuggestionHost_jni.h"
#include "content/public/browser/browser_task_traits.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/browser/render_frame_host.h"
#include "services/service_manager/public/cpp/interface_provider.h"
#include "ui/gfx/android/view_configuration.h"

using base::android::AttachCurrentThread;
using base::android::ConvertJavaStringToUTF8;
using base::android::ConvertUTF8ToJavaString;
using base::android::GetClass;
using base::android::JavaParamRef;
using base::android::MethodID;
using base::android::ScopedJavaLocalRef;
using base::android::ToJavaArrayOfStrings;

namespace content {

namespace {

const size_t kMaxNumberOfSuggestions = 5;

}  // namespace

void TextSuggestionHostAndroid::Create(JNIEnv* env, WebContents* web_contents) {
  auto* text_suggestion_host = new TextSuggestionHostAndroid(env, web_contents);
  text_suggestion_host->Initialize();
}

TextSuggestionHostAndroid::TextSuggestionHostAndroid(JNIEnv* env,
                                                     WebContents* web_contents)
    : RenderWidgetHostConnector(web_contents),
      rwhva_(nullptr),
      suggestion_menu_timeout_(
          base::BindRepeating(
              &TextSuggestionHostAndroid::OnSuggestionMenuTimeout,
              base::Unretained(this)),
          GetUIThreadTaskRunner({BrowserTaskType::kUserInput})) {}

TextSuggestionHostAndroid::~TextSuggestionHostAndroid() {
  JNIEnv* env = AttachCurrentThread();
  ScopedJavaLocalRef<jobject> obj = java_text_suggestion_host_.get(env);
  if (!obj.is_null())
    Java_TextSuggestionHost_onNativeDestroyed(env, obj);
}

void TextSuggestionHostAndroid::UpdateRenderProcessConnection(
    RenderWidgetHostViewAndroid* old_rwhva,
    RenderWidgetHostViewAndroid* new_rwhva) {
  text_suggestion_backend_.reset();
  if (old_rwhva)
    old_rwhva->set_text_suggestion_host(nullptr);
  if (new_rwhva)
    new_rwhva->set_text_suggestion_host(this);
  rwhva_ = new_rwhva;
}

void TextSuggestionHostAndroid::ApplySpellCheckSuggestion(
    JNIEnv* env,
    const JavaParamRef<jobject>&,
    const base::android::JavaParamRef<jstring>& replacement) {
  const mojo::Remote<blink::mojom::TextSuggestionBackend>&
      text_suggestion_backend = GetTextSuggestionBackend();
  if (!text_suggestion_backend)
    return;
  text_suggestion_backend->ApplySpellCheckSuggestion(
      ConvertJavaStringToUTF8(env, replacement));
}

void TextSuggestionHostAndroid::ApplyTextSuggestion(
    JNIEnv*,
    const JavaParamRef<jobject>&,
    int marker_tag,
    int suggestion_index) {
  const mojo::Remote<blink::mojom::TextSuggestionBackend>&
      text_suggestion_backend = GetTextSuggestionBackend();
  if (!text_suggestion_backend)
    return;
  text_suggestion_backend->ApplyTextSuggestion(marker_tag, suggestion_index);
}

void TextSuggestionHostAndroid::DeleteActiveSuggestionRange(
    JNIEnv*,
    const JavaParamRef<jobject>&) {
  const mojo::Remote<blink::mojom::TextSuggestionBackend>&
      text_suggestion_backend = GetTextSuggestionBackend();
  if (!text_suggestion_backend)
    return;
  text_suggestion_backend->DeleteActiveSuggestionRange();
}

void TextSuggestionHostAndroid::OnNewWordAddedToDictionary(
    JNIEnv* env,
    const JavaParamRef<jobject>&,
    const base::android::JavaParamRef<jstring>& word) {
  const mojo::Remote<blink::mojom::TextSuggestionBackend>&
      text_suggestion_backend = GetTextSuggestionBackend();
  if (!text_suggestion_backend)
    return;
  text_suggestion_backend->OnNewWordAddedToDictionary(
      ConvertJavaStringToUTF8(env, word));
}

void TextSuggestionHostAndroid::OnSuggestionMenuClosed(
    JNIEnv*,
    const JavaParamRef<jobject>&) {
  const mojo::Remote<blink::mojom::TextSuggestionBackend>&
      text_suggestion_backend = GetTextSuggestionBackend();
  if (!text_suggestion_backend)
    return;
  text_suggestion_backend->OnSuggestionMenuClosed();
}

ScopedJavaLocalRef<jobject>
TextSuggestionHostAndroid::GetJavaTextSuggestionHost() {
  JNIEnv* env = AttachCurrentThread();
  ScopedJavaLocalRef<jobject> obj = java_text_suggestion_host_.get(env);
  if (obj.is_null()) {
    obj = Java_TextSuggestionHost_create(
        env, RenderWidgetHostConnector::web_contents()->GetJavaWebContents(),
        reinterpret_cast<intptr_t>(this));
    java_text_suggestion_host_ = JavaObjectWeakGlobalRef(env, obj);
  }
  return obj;
}

void TextSuggestionHostAndroid::ShowSpellCheckSuggestionMenu(
    double caret_x,
    double caret_y,
    const std::string& marked_text,
    const std::vector<blink::mojom::SpellCheckSuggestionPtr>& suggestions) {
  std::vector<std::string> suggestion_strings;
  // Enforce kMaxNumberOfSuggestions here in case the renderer is hijacked and
  // tries to send bad input.
  for (size_t i = 0; i < suggestions.size() && i < kMaxNumberOfSuggestions; ++i)
    suggestion_strings.push_back(suggestions[i]->suggestion);
  JNIEnv* env = AttachCurrentThread();
  ScopedJavaLocalRef<jobject> obj = GetJavaTextSuggestionHost();
  if (obj.is_null())
    return;

  Java_TextSuggestionHost_showSpellCheckSuggestionMenu(
      env, obj, caret_x, caret_y, ConvertUTF8ToJavaString(env, marked_text),
      ToJavaArrayOfStrings(env, suggestion_strings));
}

void TextSuggestionHostAndroid::ShowTextSuggestionMenu(
    double caret_x,
    double caret_y,
    const std::string& marked_text,
    const std::vector<blink::mojom::TextSuggestionPtr>& suggestions) {
  JNIEnv* env = AttachCurrentThread();
  ScopedJavaLocalRef<jobject> obj = GetJavaTextSuggestionHost();
  if (obj.is_null())
    return;

  // Enforce kMaxNumberOfSuggestions here in case the renderer is hijacked and
  // tries to send bad input.
  size_t suggestion_count =
      std::min(suggestions.size(), kMaxNumberOfSuggestions);
  ScopedJavaLocalRef<jobjectArray> jsuggestion_infos =
      Java_SuggestionInfo_createArray(env, suggestion_count);

  for (size_t i = 0; i < suggestion_count; ++i) {
    const blink::mojom::TextSuggestionPtr& suggestion_ptr = suggestions[i];
    Java_SuggestionInfo_createSuggestionInfoAndPutInArray(
        env, jsuggestion_infos, i, suggestion_ptr->marker_tag,
        suggestion_ptr->suggestion_index,
        ConvertUTF8ToJavaString(env, suggestion_ptr->prefix),
        ConvertUTF8ToJavaString(env, suggestion_ptr->suggestion),
        ConvertUTF8ToJavaString(env, suggestion_ptr->suffix));
  }

  Java_TextSuggestionHost_showTextSuggestionMenu(
      env, obj, caret_x, caret_y, ConvertUTF8ToJavaString(env, marked_text),
      jsuggestion_infos);
}

void TextSuggestionHostAndroid::StartSuggestionMenuTimer() {
  suggestion_menu_timeout_.Stop();
  suggestion_menu_timeout_.Start(
      base::Milliseconds(gfx::ViewConfiguration::GetDoubleTapTimeoutInMs()));
}

void TextSuggestionHostAndroid::OnKeyEvent() {
  suggestion_menu_timeout_.Stop();

  JNIEnv* env = AttachCurrentThread();
  ScopedJavaLocalRef<jobject> obj = java_text_suggestion_host_.get(env);
  if (obj.is_null())
    return;

  Java_TextSuggestionHost_hidePopups(env, obj);
}

void TextSuggestionHostAndroid::StopSuggestionMenuTimer() {
  suggestion_menu_timeout_.Stop();
}

void TextSuggestionHostAndroid::BindTextSuggestionHost(
    mojo::PendingReceiver<blink::mojom::TextSuggestionHost> receiver) {
  text_suggestion_impl_ =
      TextSuggestionHostMojoImplAndroid::Create(this, std::move(receiver));
}

RenderFrameHost* TextSuggestionHostAndroid::GetFocusedFrame() {
  DCHECK_CURRENTLY_ON(BrowserThread::UI);
  // We get the focused frame from the WebContents of the page. Although
  // |rwhva_->GetFocusedWidget()| does a similar thing, there is no direct way
  // to get a RenderFrameHost from its RWH.
  if (!rwhva_)
    return nullptr;
  RenderWidgetHostImpl* rwh =
      RenderWidgetHostImpl::From(rwhva_->GetRenderWidgetHost());
  if (auto* contents = WebContentsImpl::FromRenderWidgetHostImpl(rwh))
    return contents->GetFocusedFrame();

  return nullptr;
}

const mojo::Remote<blink::mojom::TextSuggestionBackend>&
TextSuggestionHostAndroid::GetTextSuggestionBackend() {
  if (!text_suggestion_backend_) {
    if (RenderFrameHost* rfh = GetFocusedFrame()) {
      rfh->GetRemoteInterfaces()->GetInterface(
          text_suggestion_backend_.BindNewPipeAndPassReceiver());
    }
  }
  return text_suggestion_backend_;
}

void TextSuggestionHostAndroid::OnSuggestionMenuTimeout() {
  const mojo::Remote<blink::mojom::TextSuggestionBackend>&
      text_suggestion_backend = GetTextSuggestionBackend();
  if (!text_suggestion_backend)
    return;
  text_suggestion_backend->SuggestionMenuTimeoutCallback(
      kMaxNumberOfSuggestions);
}

}  // namespace content