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

#include "ui/views/cocoa/text_input_host.h"

#include "components/remote_cocoa/app_shim/native_widget_ns_window_bridge.h"
#include "ui/accelerated_widget_mac/window_resize_helper_mac.h"
#include "ui/base/ime/text_input_client.h"
#include "ui/events/keycodes/dom/dom_code.h"
#include "ui/views/cocoa/native_widget_mac_ns_window_host.h"

namespace {

// Returns the boundary rectangle for composition characters in the
// |requested_range|. Sets |actual_range| corresponding to the returned
// rectangle. For cases, where there is no composition text or the
// |requested_range| lies outside the composition range, a zero width rectangle
// corresponding to the caret bounds is returned. Logic used is similar to
// RenderWidgetHostViewMac::GetCachedFirstRectForCharacterRange(...).
gfx::Rect GetFirstRectForRangeHelper(const ui::TextInputClient* client,
                                     const gfx::Range& requested_range,
                                     gfx::Range* actual_range) {
  // NSRange doesn't support reversed ranges.
  DCHECK(!requested_range.is_reversed());
  DCHECK(actual_range);

  // Set up default return values, to be returned in case of unusual cases.
  gfx::Rect default_rect;
  *actual_range = gfx::Range::InvalidRange();
  if (!client) {
    return default_rect;
  }

  default_rect = client->GetCaretBounds();
  default_rect.set_width(0);

  // If possible, modify actual_range to correspond to caret position.
  gfx::Range selection_range;
  if (client->GetEditableSelectionRange(&selection_range)) {
    // Caret bounds correspond to end index of selection_range.
    *actual_range = gfx::Range(selection_range.end());
  }

  gfx::Range composition_range;
  if (!client->HasCompositionText() ||
      !client->GetCompositionTextRange(&composition_range) ||
      !requested_range.IsBoundedBy(composition_range)) {
    return default_rect;
  }

  DCHECK(!composition_range.is_reversed());

  const size_t from = requested_range.start() - composition_range.start();
  const size_t to = requested_range.end() - composition_range.start();

  // Pick the first character's bounds as the initial rectangle, then grow it to
  // the full |requested_range| if possible.
  const bool request_is_composition_end = from == composition_range.length();
  const size_t first_index = request_is_composition_end ? from - 1 : from;
  gfx::Rect union_rect;
  if (!client->GetCompositionCharacterBounds(first_index, &union_rect)) {
    return default_rect;
  }

  // If requested_range is empty, return a zero width rectangle corresponding to
  // it.
  if (from == to) {
    if (request_is_composition_end &&
        client->GetTextDirection() != base::i18n::RIGHT_TO_LEFT) {
      // In case of an empty requested range at end of composition, return the
      // rectangle to the right of the last compositioned character.
      union_rect.set_origin(union_rect.top_right());
    }
    union_rect.set_width(0);
    *actual_range = requested_range;
    return union_rect;
  }

  // Toolkit-views textfields are always single-line, so no need to check for
  // line breaks.
  for (size_t i = from + 1; i < to; i++) {
    gfx::Rect current_rect;
    if (client->GetCompositionCharacterBounds(i, &current_rect)) {
      union_rect.Union(current_rect);
    } else {
      *actual_range =
          gfx::Range(requested_range.start(), i + composition_range.start());
      return union_rect;
    }
  }
  *actual_range = requested_range;
  return union_rect;
}

// Returns the string corresponding to |requested_range| for the given |client|.
// If a gfx::Range::InvalidRange() is passed, the full string stored by |client|
// is returned. Sets |actual_range| corresponding to the returned string.
std::u16string AttributedSubstringForRangeHelper(
    const ui::TextInputClient* client,
    const gfx::Range& requested_range,
    gfx::Range* actual_range) {
  // NSRange doesn't support reversed ranges.
  DCHECK(!requested_range.is_reversed());
  DCHECK(actual_range);

  std::u16string substring;
  gfx::Range text_range;
  *actual_range = gfx::Range::InvalidRange();
  if (!client || !client->GetTextRange(&text_range)) {
    return substring;
  }

  // gfx::Range::Intersect() behaves a bit weirdly. If B is an empty range
  // contained inside a non-empty range A, B intersection A returns
  // gfx::Range::InvalidRange(), instead of returning B.
  *actual_range = text_range.Contains(requested_range)
                      ? requested_range
                      : text_range.Intersect(requested_range);

  // This is a special case for which the complete string should should be
  // returned. NSTextView also follows this, though the same is not mentioned in
  // NSTextInputClient documentation.
  if (!requested_range.IsValid()) {
    *actual_range = text_range;
  }

  client->GetTextFromRange(*actual_range, &substring);
  return substring;
}

}  // namespace

namespace views {

////////////////////////////////////////////////////////////////////////////////
// TextInputHost, public:

TextInputHost::TextInputHost(NativeWidgetMacNSWindowHost* host_impl)
    : host_impl_(host_impl) {}

TextInputHost::~TextInputHost() = default;

void TextInputHost::BindReceiver(
    mojo::PendingAssociatedReceiver<remote_cocoa::mojom::TextInputHost>
        receiver) {
  mojo_receiver_.Bind(std::move(receiver),
                      ui::WindowResizeHelperMac::Get()->task_runner());
}

ui::TextInputClient* TextInputHost::GetTextInputClient() const {
  return text_input_client_.get();
}

void TextInputHost::SetTextInputClient(
    ui::TextInputClient* new_text_input_client) {
  if (pending_text_input_client_.get() == new_text_input_client) {
    return;
  }

  // This method may cause the IME window to dismiss, which may cause it to
  // insert text (e.g. to replace marked text with "real" text). That should
  // happen in the old -inputContext (which AppKit stores a reference to).
  // Unfortunately, the only way to invalidate the the old -inputContext is to
  // invoke -[NSApp updateWindows], which also wants a reference to the _new_
  // -inputContext. So put the new inputContext in |pendingTextInputClient_| and
  // only use it for -inputContext.
  ui::TextInputClient* old_text_input_client = text_input_client_.get();

  // Since dismissing an IME may insert text, a misbehaving IME or a
  // ui::TextInputClient that acts on InsertChar() to change focus a second time
  // may invoke -setTextInputClient: recursively; with [NSApp updateWindows]
  // still on the stack. Calling [NSApp updateWindows] recursively may upset
  // an IME. Since the rest of this method is only to decide whether to call
  // updateWindows, and we're already calling it, just bail out.
  if (text_input_client_.get() != pending_text_input_client_.get()) {
    pending_text_input_client_ =
        new_text_input_client ? new_text_input_client->AsWeakPtr() : nullptr;
    return;
  }

  // Start by assuming no need to invoke -updateWindows.
  text_input_client_ =
      new_text_input_client ? new_text_input_client->AsWeakPtr() : nullptr;
  pending_text_input_client_ = text_input_client_;

  if (host_impl_->in_process_ns_window_bridge_ &&
      host_impl_->in_process_ns_window_bridge_->NeedsUpdateWindows()) {
    text_input_client_ =
        old_text_input_client ? old_text_input_client->AsWeakPtr() : nullptr;
    [NSApp updateWindows];
    // Note: |pending_text_input_client_| (and therefore +[NSTextInputContext
    // currentInputContext] may have changed if called recursively.
    text_input_client_ = pending_text_input_client_;
  }
}

////////////////////////////////////////////////////////////////////////////////
// TextInputHost, remote_cocoa::mojom::TextInputHost:

bool TextInputHost::HasClient(bool* out_has_client) {
  *out_has_client = text_input_client_ != nullptr;
  return true;
}

bool TextInputHost::HasInputContext(bool* out_has_input_context) {
  *out_has_input_context = false;

  // If the textInputClient_ does not exist, return nil since this view does not
  // conform to NSTextInputClient protocol.
  if (!pending_text_input_client_) {
    return true;
  }

  // If a menu is active, and -[NSView interpretKeyEvents:] asks for the
  // input context, return nil. This ensures the action message is sent to
  // the view, rather than any NSTextInputClient a subview has installed.
  bool has_menu_controller = false;
  host_impl_->GetHasMenuController(&has_menu_controller);
  if (has_menu_controller) {
    return true;
  }

  // When not in an editable mode, or while entering passwords
  // (http://crbug.com/23219), we don't want to show IME candidate windows.
  // Returning nil prevents this view from getting messages defined as part of
  // the NSTextInputClient protocol.
  switch (pending_text_input_client_->GetTextInputType()) {
    case ui::TEXT_INPUT_TYPE_NONE:
    case ui::TEXT_INPUT_TYPE_PASSWORD:
      return true;
    default:
      *out_has_input_context = true;
  }
  return true;
}

bool TextInputHost::IsRTL(bool* out_is_rtl) {
  *out_is_rtl = text_input_client_ && text_input_client_->GetTextDirection() ==
                                          base::i18n::RIGHT_TO_LEFT;
  return true;
}

bool TextInputHost::GetSelectionRange(gfx::Range* out_range) {
  if (!text_input_client_ ||
      !text_input_client_->GetEditableSelectionRange(out_range)) {
    *out_range = gfx::Range::InvalidRange();
  }
  return true;
}

bool TextInputHost::GetSelectionText(bool* out_result,
                                     std::u16string* out_text) {
  *out_result = false;
  if (!text_input_client_) {
    return true;
  }
  gfx::Range selection_range;
  if (!text_input_client_->GetEditableSelectionRange(&selection_range)) {
    return true;
  }
  *out_result = text_input_client_->GetTextFromRange(selection_range, out_text);
  return true;
}

void TextInputHost::InsertText(const std::u16string& text, bool as_character) {
  if (!text_input_client_) {
    return;
  }
  if (as_character) {
    // If a single character is inserted by keyDown's call to
    // interpretKeyEvents: then use InsertChar() to allow editing events to be
    // merged. We use ui::VKEY_UNKNOWN as the key code since it's not feasible
    // to determine the correct key code for each unicode character. Also a
    // correct keycode is not needed in the current context. Send ui::EF_NONE as
    // the key modifier since |text| already accounts for the pressed key
    // modifiers.
    text_input_client_->InsertChar(ui::KeyEvent::FromCharacter(
        text[0], ui::VKEY_UNKNOWN, ui::DomCode::NONE, ui::EF_NONE));
  } else {
    text_input_client_->InsertText(
        text,
        ui::TextInputClient::InsertTextCursorBehavior::kMoveCursorAfterText);
  }
}

void TextInputHost::DeleteRange(const gfx::Range& range) {
  if (!text_input_client_) {
    return;
  }
  text_input_client_->DeleteRange(range);
}

void TextInputHost::SetCompositionText(const std::u16string& text,
                                       const gfx::Range& selected_range,
                                       const gfx::Range& replacement_range) {
  if (!text_input_client_) {
    return;
  }

  text_input_client_->DeleteRange(replacement_range);
  ui::CompositionText composition;
  composition.text = text;
  composition.selection = selected_range;

  // Add an underline with text color and a transparent background to the
  // composition text. TODO(karandeepb): On Cocoa textfields, the target clause
  // of the composition has a thick underlines. The composition text also has
  // discontinuous underlines for different clauses. This is also supported in
  // the Chrome renderer. Add code to extract underlines from |text| once our
  // render text implementation supports thick underlines and discontinuous
  // underlines for consecutive characters. See http://crbug.com/612675.
  composition.ime_text_spans.emplace_back(
      ui::ImeTextSpan::Type::kComposition, 0, text.length(),
      ui::ImeTextSpan::Thickness::kThin,
      ui::ImeTextSpan::UnderlineStyle::kSolid, SK_ColorTRANSPARENT);
  text_input_client_->SetCompositionText(composition);
}

void TextInputHost::ConfirmCompositionText() {
  if (!text_input_client_) {
    return;
  }
  text_input_client_->ConfirmCompositionText(/* keep_selection */ false);
}

bool TextInputHost::HasCompositionText(bool* out_has_composition_text) {
  *out_has_composition_text = false;
  if (!text_input_client_) {
    return true;
  }
  *out_has_composition_text = text_input_client_->HasCompositionText();
  return true;
}

bool TextInputHost::GetCompositionTextRange(gfx::Range* out_composition_range) {
  *out_composition_range = gfx::Range::InvalidRange();
  if (!text_input_client_) {
    return true;
  }
  if (!text_input_client_->HasCompositionText()) {
    return true;
  }
  text_input_client_->GetCompositionTextRange(out_composition_range);
  return true;
}

bool TextInputHost::GetAttributedSubstringForRange(
    const gfx::Range& requested_range,
    std::u16string* out_text,
    gfx::Range* out_actual_range) {
  *out_text = AttributedSubstringForRangeHelper(
      text_input_client_.get(), requested_range, out_actual_range);
  return true;
}

bool TextInputHost::GetFirstRectForRange(const gfx::Range& requested_range,
                                         gfx::Rect* out_rect,
                                         gfx::Range* out_actual_range) {
  *out_rect = GetFirstRectForRangeHelper(text_input_client_.get(),
                                         requested_range, out_actual_range);
  return true;
}

bool TextInputHost::IsTextEditCommandEnabled(ui::TextEditCommand command,
                                             bool* out_enabled) {
  if (text_input_client_) {
    *out_enabled = text_input_client_->IsTextEditCommandEnabled(command);
  } else {
    *out_enabled = false;
  }
  return true;
}

void TextInputHost::SetTextEditCommandForNextKeyEvent(
    ui::TextEditCommand command) {
  if (text_input_client_) {
    text_input_client_->SetTextEditCommandForNextKeyEvent(command);
  }
}

////////////////////////////////////////////////////////////////////////////////
// TextInputHost, remote_cocoa::mojom::TextInputHost synchronous methods:

void TextInputHost::HasClient(HasClientCallback callback) {
  bool has_client = false;
  HasClient(&has_client);
  std::move(callback).Run(has_client);
}

void TextInputHost::HasInputContext(HasInputContextCallback callback) {
  bool has_input_context = false;
  HasClient(&has_input_context);
  std::move(callback).Run(has_input_context);
}

void TextInputHost::IsRTL(IsRTLCallback callback) {
  bool is_rtl = false;
  IsRTL(&is_rtl);
  std::move(callback).Run(is_rtl);
}

void TextInputHost::GetSelectionRange(GetSelectionRangeCallback callback) {
  gfx::Range range = gfx::Range::InvalidRange();
  GetSelectionRange(&range);
  std::move(callback).Run(range);
}

void TextInputHost::GetSelectionText(GetSelectionTextCallback callback) {
  bool result = false;
  std::u16string text;
  GetSelectionText(&result, &text);
  std::move(callback).Run(result, text);
}

void TextInputHost::HasCompositionText(HasCompositionTextCallback callback) {
  bool has_composition_text = false;
  HasCompositionText(&has_composition_text);
  std::move(callback).Run(has_composition_text);
}

void TextInputHost::GetCompositionTextRange(
    GetCompositionTextRangeCallback callback) {
  gfx::Range range = gfx::Range::InvalidRange();
  GetCompositionTextRange(&range);
  std::move(callback).Run(range);
}

void TextInputHost::GetAttributedSubstringForRange(
    const gfx::Range& requested_range,
    GetAttributedSubstringForRangeCallback callback) {
  std::u16string text;
  gfx::Range actual_range = gfx::Range::InvalidRange();
  GetAttributedSubstringForRange(requested_range, &text, &actual_range);
  std::move(callback).Run(text, actual_range);
}

void TextInputHost::GetFirstRectForRange(
    const gfx::Range& requested_range,
    GetFirstRectForRangeCallback callback) {
  gfx::Rect rect;
  gfx::Range actual_range;
  GetFirstRectForRange(requested_range, &rect, &actual_range);
  std::move(callback).Run(rect, actual_range);
}

void TextInputHost::IsTextEditCommandEnabled(
    ui::TextEditCommand command,
    IsTextEditCommandEnabledCallback callback) {
  bool enable;
  IsTextEditCommandEnabled(command, &enable);
  std::move(callback).Run(enable);
}

}  // namespace views