// 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 "components/exo/wayland/zwp_text_input_manager.h"

#include <sys/mman.h>
#include <text-input-extension-unstable-v1-server-protocol.h>
#include <text-input-unstable-v1-server-protocol.h>
#include <wayland-server-core.h>
#include <wayland-server-protocol-core.h>
#include <xkbcommon/xkbcommon.h>

#include <string_view>

#include "ash/constants/ash_features.h"
#include "base/files/file_util.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/strings/utf_offset_string_conversions.h"
#include "base/strings/utf_string_conversions.h"
#include "components/exo/display.h"
#include "components/exo/text_input.h"
#include "components/exo/wayland/serial_tracker.h"
#include "components/exo/wayland/server_util.h"
#include "components/exo/wayland/wl_seat.h"
#include "components/exo/xkb_tracker.h"
#include "net/base/data_url.h"
#include "ui/base/ime/utf_offset.h"
#include "ui/base/wayland/wayland_server_input_types.h"
#include "ui/events/event.h"
#include "ui/events/keycodes/dom/dom_code.h"
#include "ui/events/keycodes/dom/keycode_converter.h"
#include "ui/events/ozone/layout/xkb/xkb_modifier_converter.h"

namespace exo {
namespace wayland {

namespace {

// The list of modifiers that this supports.
// This is consistent with X.h.
constexpr const char* kModifierNames[] = {
    XKB_MOD_NAME_SHIFT, XKB_MOD_NAME_CAPS,
    XKB_MOD_NAME_CTRL,  XKB_MOD_NAME_ALT,
    XKB_MOD_NAME_NUM,   "Mod3",
    XKB_MOD_NAME_LOGO,  "Mod5",
};
uint32_t keyCharToKeySym(char16_t keychar) {
  // TODO(b/237461655): Lacros fails to handle key presses properly when the
  // key character is not present in the keyboard layout.
  if ((keychar >= 0x20 && keychar <= 0x7e) ||
      (keychar >= 0xa0 && keychar <= 0xff)) {
    return keychar;
  }
  // The spec also requires event.GetCharacter() <= 0x10ffff but this is
  // always true due to the type of event.GetCharacter().
  if (keychar >= 0x100) {
    return keychar + 0x01000000;
  }
  // keysym 0 is used for unidentified events
  return 0;
}

////////////////////////////////////////////////////////////////////////////////
// text_input_v1 interface:

class WaylandTextInputDelegate : public TextInput::Delegate {
 public:
  WaylandTextInputDelegate(wl_resource* text_input,
                           const XkbTracker* xkb_tracker,
                           SerialTracker* serial_tracker)
      : text_input_(text_input),
        xkb_tracker_(xkb_tracker),
        serial_tracker_(serial_tracker) {}
  ~WaylandTextInputDelegate() override = default;

  void set_surface(wl_resource* surface) { surface_ = surface; }

  void set_extended_text_input(wl_resource* extended_text_input) {
    extended_text_input_ = extended_text_input;
  }

  bool has_extended_text_input() const { return extended_text_input_; }

  base::WeakPtr<WaylandTextInputDelegate> GetWeakPtr() {
    return weak_factory_.GetWeakPtr();
  }

  wl_resource* resource() { return text_input_; }

  ui::TextInputClient::FocusReason pending_focus_reason() const {
    return pending_focus_reason_;
  }

  void set_pending_focus_reason(ui::TextInputClient::FocusReason reason) {
    pending_focus_reason_ = reason;
  }

  bool pending_surrounding_text_supported() const {
    return pending_surrounding_text_supported_;
  }

  void set_pending_surrounding_text_supported(bool is_supported) {
    pending_surrounding_text_supported_ = is_supported;
  }

  void SetPendingGrammarFragment(
      const std::optional<ui::GrammarFragment>& grammar_fragment) {
    pending_grammar_fragment_ = grammar_fragment;
  }

  std::optional<ui::GrammarFragment> TakeGrammarFragment() {
    auto result = pending_grammar_fragment_;
    pending_grammar_fragment_.reset();
    return result;
  }

  void SetPendingAutocorrectInfo(const ui::AutocorrectInfo& autocorrect_info) {
    pending_autocorrect_info_ = autocorrect_info;
  }

  std::optional<ui::AutocorrectInfo> TakeAutocorrectInfo() {
    auto result = pending_autocorrect_info_;
    pending_autocorrect_info_.reset();
    return result;
  }

  void SetSurroundingTextOffsetUtf16(uint32_t offset) {
    pending_surrounding_text_offset_utf16_ = offset;
  }

  std::optional<uint32_t> TakeSurroundingTextOffsetUtf16() {
    auto result = pending_surrounding_text_offset_utf16_;
    pending_surrounding_text_offset_utf16_.reset();
    return result;
  }

 private:
  wl_client* client() { return wl_resource_get_client(text_input_); }

  // TextInput::Delegate:
  void Activated() override {
    zwp_text_input_v1_send_enter(text_input_, surface_);
    wl_client_flush(client());
  }

  void Deactivated() override {
    zwp_text_input_v1_send_leave(text_input_);
    wl_client_flush(client());
  }

  void OnVirtualKeyboardVisibilityChanged(bool is_visible) override {
    // The detailed spec of |state| is implementation dependent.
    // So, now we use the lowest bit to indicate whether keyboard is visible.
    // This behavior is consistent with ozone/wayland to support Lacros.
    zwp_text_input_v1_send_input_panel_state(text_input_,
                                             static_cast<uint32_t>(is_visible));
    wl_client_flush(client());
  }

  void OnVirtualKeyboardOccludedBoundsChanged(
      const gfx::Rect& screen_bounds) override {
    if (!extended_text_input_)
      return;

    if (wl_resource_get_version(extended_text_input_) >=
        ZCR_EXTENDED_TEXT_INPUT_V1_SET_VIRTUAL_KEYBOARD_OCCLUDED_BOUNDS_SINCE_VERSION) {
      zcr_extended_text_input_v1_send_set_virtual_keyboard_occluded_bounds(
          extended_text_input_, screen_bounds.x(), screen_bounds.y(),
          screen_bounds.width(), screen_bounds.height());
      wl_client_flush(client());
    }
  }

  bool SupportsFinalizeVirtualKeyboardChanges() override {
    return extended_text_input_ &&
           wl_resource_get_version(extended_text_input_) >=
               ZCR_EXTENDED_TEXT_INPUT_V1_FINALIZE_VIRTUAL_KEYBOARD_CHANGES_SINCE_VERSION;
  }

  void SetCompositionText(const ui::CompositionText& composition) override {
    SendPreeditStyle(composition.text, composition.ime_text_spans);

    std::vector<size_t> offsets = {composition.selection.start()};
    const std::string utf8 =
        base::UTF16ToUTF8AndAdjustOffsets(composition.text, &offsets);

    if (offsets[0] != std::string::npos)
      zwp_text_input_v1_send_preedit_cursor(text_input_, offsets[0]);

    zwp_text_input_v1_send_preedit_string(
        text_input_,
        serial_tracker_->GetNextSerial(SerialTracker::EventType::OTHER_EVENT),
        utf8.c_str(), utf8.c_str());

    wl_client_flush(client());
  }

  void Commit(std::u16string_view text) override {
    zwp_text_input_v1_send_commit_string(
        text_input_,
        serial_tracker_->GetNextSerial(SerialTracker::EventType::OTHER_EVENT),
        base::UTF16ToUTF8(text).c_str());
    wl_client_flush(client());
  }

  void SetCursor(std::u16string_view surrounding_text,
                 const gfx::Range& selection) override {
    std::vector<size_t> offsets{selection.start(), selection.end()};
    base::UTF16ToUTF8AndAdjustOffsets(surrounding_text, &offsets);
    zwp_text_input_v1_send_cursor_position(text_input_,
                                           static_cast<uint32_t>(offsets[1]),
                                           static_cast<uint32_t>(offsets[0]));
  }

  void DeleteSurroundingText(std::u16string_view surrounding_text,
                             const gfx::Range& range) override {
    std::vector<size_t> offsets{range.GetMin(), range.GetMax()};
    base::UTF16ToUTF8AndAdjustOffsets(surrounding_text, &offsets);
    // Currently, the arguments are conflicting with spec.
    // However, the only client, Lacros, also interprets wrongly in the same
    // way so just fixing here could cause visible regression.
    // TODO(crbug.com/40189286): Fix the behavior with versioning.
    zwp_text_input_v1_send_delete_surrounding_text(
        text_input_, static_cast<uint32_t>(offsets[0]),
        static_cast<uint32_t>(offsets[1] - offsets[0]));
    wl_client_flush(client());
  }

  void SendKey(const ui::KeyEvent& event) override {
    uint32_t keysym =
        event.code() != ui::DomCode::NONE
            ? xkb_tracker_->GetKeysym(
                  ui::KeycodeConverter::DomCodeToNativeKeycode(event.code()))
            : 0;
    // Some artificial key events (e.g. from virtual keyboard) do not set code,
    // so must be handled separately.
    // https://www.x.org/releases/X11R7.6/doc/xproto/x11protocol.html#keysym_encoding
    // suggests that we can just directly map some parts of unicode.
    if (keysym == 0) {
      keysym = keyCharToKeySym(event.GetCharacter());
    }

    if (keysym == 0) {
      VLOG(0) << "Unable to find keysym for: " << event.ToString();
    }

    bool pressed = (event.type() == ui::EventType::kKeyPressed);
    zwp_text_input_v1_send_keysym(
        text_input_, TimeTicksToMilliseconds(event.time_stamp()),
        serial_tracker_->GetNextSerial(SerialTracker::EventType::OTHER_EVENT),
        keysym,
        pressed ? WL_KEYBOARD_KEY_STATE_PRESSED
                : WL_KEYBOARD_KEY_STATE_RELEASED,
        modifier_converter_.MaskFromUiFlags(event.flags()));
    wl_client_flush(client());
  }

  void OnTextDirectionChanged(base::i18n::TextDirection direction) override {
    uint32_t wayland_direction = ZWP_TEXT_INPUT_V1_TEXT_DIRECTION_AUTO;
    switch (direction) {
      case base::i18n::RIGHT_TO_LEFT:
        wayland_direction = ZWP_TEXT_INPUT_V1_TEXT_DIRECTION_LTR;
        break;
      case base::i18n::LEFT_TO_RIGHT:
        wayland_direction = ZWP_TEXT_INPUT_V1_TEXT_DIRECTION_RTL;
        break;
      case base::i18n::UNKNOWN_DIRECTION:
        LOG(ERROR) << "Unrecognized direction: " << direction;
    }

    zwp_text_input_v1_send_text_direction(
        text_input_,
        serial_tracker_->GetNextSerial(SerialTracker::EventType::OTHER_EVENT),
        wayland_direction);
  }

  void SetCompositionFromExistingText(
      std::u16string_view surrounding_text,
      const gfx::Range& cursor,
      const gfx::Range& range,
      const std::vector<ui::ImeTextSpan>& ui_ime_text_spans) override {
    if (!extended_text_input_)
      return;

    uint32_t begin = range.GetMin();
    uint32_t end = range.GetMax();
    SendPreeditStyle(surrounding_text.substr(begin, range.length()),
                     ui_ime_text_spans);

    std::vector<size_t> offsets = {begin, end, cursor.end()};
    base::UTF16ToUTF8AndAdjustOffsets(surrounding_text, &offsets);
    int32_t index =
        static_cast<int32_t>(offsets[0]) - static_cast<int32_t>(offsets[2]);
    uint32_t length = static_cast<uint32_t>(offsets[1] - offsets[0]);
    zcr_extended_text_input_v1_send_set_preedit_region(extended_text_input_,
                                                       index, length);
    wl_client_flush(client());
  }

  void ClearGrammarFragments(std::u16string_view surrounding_text,
                             const gfx::Range& range) override {
    if (!extended_text_input_)
      return;

    if (wl_resource_get_version(extended_text_input_) >=
        ZCR_EXTENDED_TEXT_INPUT_V1_CLEAR_GRAMMAR_FRAGMENTS_SINCE_VERSION) {
      std::vector<size_t> offsets = {range.start(), range.end()};
      base::UTF16ToUTF8AndAdjustOffsets(surrounding_text, &offsets);
      zcr_extended_text_input_v1_send_clear_grammar_fragments(
          extended_text_input_, static_cast<uint32_t>(offsets[0]),
          static_cast<uint32_t>(offsets[1]));
      wl_client_flush(client());
    }
  }

  void AddGrammarFragment(std::u16string_view surrounding_text,
                          const ui::GrammarFragment& fragment) override {
    if (!extended_text_input_)
      return;

    if (wl_resource_get_version(extended_text_input_) >=
        ZCR_EXTENDED_TEXT_INPUT_V1_ADD_GRAMMAR_FRAGMENT_SINCE_VERSION) {
      std::vector<size_t> offsets = {fragment.range.start(),
                                     fragment.range.end()};
      base::UTF16ToUTF8AndAdjustOffsets(surrounding_text, &offsets);
      zcr_extended_text_input_v1_send_add_grammar_fragment(
          extended_text_input_, static_cast<uint32_t>(offsets[0]),
          static_cast<uint32_t>(offsets[1]), fragment.suggestion.c_str());
      wl_client_flush(client());
    }
  }

  void SetAutocorrectRange(std::u16string_view surrounding_text,
                           const gfx::Range& range) override {
    if (!extended_text_input_) {
      return;
    }

    if (wl_resource_get_version(extended_text_input_) <
        ZCR_EXTENDED_TEXT_INPUT_V1_SET_AUTOCORRECT_RANGE_SINCE_VERSION) {
      return;
    }

    std::vector<size_t> offsets{range.GetMin(), range.GetMax()};
    base::UTF16ToUTF8AndAdjustOffsets(surrounding_text, &offsets);
    zcr_extended_text_input_v1_send_set_autocorrect_range(
        extended_text_input_, offsets[0], offsets[1]);
    wl_client_flush(client());
  }

  bool HasImageInsertSupport() override {
    if (!extended_text_input_) {
      return false;
    }

    return wl_resource_get_version(extended_text_input_) >=
           ZCR_EXTENDED_TEXT_INPUT_V1_INSERT_IMAGE_SINCE_VERSION;
  }

  void InsertImage(const GURL& src) override {
    if (!extended_text_input_) {
      return;
    }

    // Due to the limit of wayland protocol, we should check the size of
    // payload here.
    static constexpr size_t kSizeLimit = 4000;
    const size_t src_size = src.spec().size();
    if (src_size > kSizeLimit) {
      if (wl_resource_get_version(extended_text_input_) <
          ZCR_EXTENDED_TEXT_INPUT_V1_INSERT_IMAGE_WITH_LARGE_URL_SINCE_VERSION) {
        LOG(ERROR) << "Inserting image with large URL is not supported";
        return;
      }

      std::string mime_type, charset, raw_data;
      if (!net::DataURL::Parse(src, &mime_type, &charset, &raw_data)) {
        LOG(ERROR) << "Failed to parse data url";
        return;
      }

      base::ScopedFD memfd(memfd_create("inserting_image", MFD_CLOEXEC));
      if (!memfd.get()) {
        PLOG(ERROR) << "Failed to create memfd";
        return;
      }

      if (!base::WriteFileDescriptor(memfd.get(), raw_data)) {
        LOG(ERROR) << "Failed to write into memfd";
        return;
      }
      if (lseek(memfd.get(), 0, SEEK_SET) != 0) {
        LOG(ERROR) << "Failed to reset file descriptor";
        return;
      }
      zcr_extended_text_input_v1_send_insert_image_with_large_url(
          extended_text_input_, mime_type.c_str(), charset.c_str(), memfd.get(),
          raw_data.size());
      wl_client_flush(client());
      return;
    }

    if (wl_resource_get_version(extended_text_input_) >=
        ZCR_EXTENDED_TEXT_INPUT_V1_INSERT_IMAGE_SINCE_VERSION) {
      zcr_extended_text_input_v1_send_insert_image(extended_text_input_,
                                                   src.spec().c_str());
      wl_client_flush(client());
    }
  }

  void SendPreeditStyle(std::u16string_view text,
                        const std::vector<ui::ImeTextSpan>& spans) {
    if (spans.empty())
      return;

    // Convert all offsets from UTF16 to UTF8.
    std::vector<size_t> offsets;
    offsets.reserve(spans.size() * 2);
    for (const auto& span : spans) {
      auto minmax = std::minmax(span.start_offset, span.end_offset);
      offsets.push_back(minmax.first);
      offsets.push_back(minmax.second);
    }
    base::UTF16ToUTF8AndAdjustOffsets(text, &offsets);

    for (size_t i = 0; i < spans.size(); ++i) {
      if (offsets[i * 2] == std::string::npos ||
          offsets[i * 2 + 1] == std::string::npos) {
        // Invalid span is specified.
        continue;
      }
      const auto& span = spans[i];
      const uint32_t begin = offsets[i * 2];
      const uint32_t end = offsets[i * 2 + 1];

      uint32_t style = ZWP_TEXT_INPUT_V1_PREEDIT_STYLE_DEFAULT;
      switch (span.type) {
        case ui::ImeTextSpan::Type::kComposition:
          if (span.thickness == ui::ImeTextSpan::Thickness::kThick) {
            style = ZWP_TEXT_INPUT_V1_PREEDIT_STYLE_HIGHLIGHT;
          } else {
            style = ZWP_TEXT_INPUT_V1_PREEDIT_STYLE_UNDERLINE;
          }
          break;
        case ui::ImeTextSpan::Type::kSuggestion:
          style = ZWP_TEXT_INPUT_V1_PREEDIT_STYLE_SELECTION;
          break;
        case ui::ImeTextSpan::Type::kMisspellingSuggestion:
        case ui::ImeTextSpan::Type::kAutocorrect:
        case ui::ImeTextSpan::Type::kGrammarSuggestion:
          style = ZWP_TEXT_INPUT_V1_PREEDIT_STYLE_INCORRECT;
          break;
      }
      zwp_text_input_v1_send_preedit_styling(text_input_, begin, end - begin,
                                             style);
    }
  }

  bool ConfirmComposition(bool keep_selection) override {
    if (!extended_text_input_) {
      return false;
    }

    if (wl_resource_get_version(extended_text_input_) <
        ZCR_EXTENDED_TEXT_INPUT_V1_CONFIRM_PREEDIT_SINCE_VERSION) {
      return false;
    }

    zcr_extended_text_input_v1_send_confirm_preedit(
        extended_text_input_,
        keep_selection
            ? ZCR_EXTENDED_TEXT_INPUT_V1_CONFIRM_PREEDIT_SELECTION_BEHAVIOR_UNCHANGED
            : ZCR_EXTENDED_TEXT_INPUT_V1_CONFIRM_PREEDIT_SELECTION_BEHAVIOR_AFTER_PREEDIT);
    wl_client_flush(client());
    return true;
  }

  bool SupportsConfirmPreedit() override {
    // Note: until this is supported by crostini, crostini won't be able to add
    // the new extension api.
    return extended_text_input_ &&
           wl_resource_get_version(extended_text_input_) >=
               ZCR_EXTENDED_TEXT_INPUT_V1_CONFIRM_PREEDIT_SINCE_VERSION;
  }

  raw_ptr<wl_resource, DanglingUntriaged> text_input_;
  raw_ptr<wl_resource, DanglingUntriaged> extended_text_input_ = nullptr;
  raw_ptr<wl_resource, DanglingUntriaged> surface_ = nullptr;

  // Owned by Seat, which is updated before calling the callbacks of this
  // class.
  const raw_ptr<const XkbTracker> xkb_tracker_;

  // Owned by Server, which always outlives this delegate.
  const raw_ptr<SerialTracker> serial_tracker_;
  ui::XkbModifierConverter modifier_converter_{
      std::vector<std::string>(std::begin(kModifierNames),
                               std::end(kModifierNames))};

  // Pending focus reason.
  ui::TextInputClient::FocusReason pending_focus_reason_ =
      ui::TextInputClient::FOCUS_REASON_OTHER;

  // Pending surrounding text supported flag.
  bool pending_surrounding_text_supported_ = true;
  std::optional<ui::GrammarFragment> pending_grammar_fragment_;
  std::optional<ui::AutocorrectInfo> pending_autocorrect_info_;
  std::optional<std::uint32_t> pending_surrounding_text_offset_utf16_;

  base::WeakPtrFactory<WaylandTextInputDelegate> weak_factory_{this};
};

// Holds WeakPtr to WaylandTextInputDelegate, and the lifetime of this class's
// instance is tied to zcr_extended_text_input connection.
// If text_input connection is destroyed earlier than extended_text_input,
// then delegate_ will return nullptr automatically.
class WaylandExtendedTextInput {
 public:
  explicit WaylandExtendedTextInput(
      base::WeakPtr<WaylandTextInputDelegate> delegate)
      : delegate_(delegate) {}
  WaylandExtendedTextInput(const WaylandExtendedTextInput&) = delete;
  WaylandExtendedTextInput& operator=(const WaylandExtendedTextInput&) = delete;
  ~WaylandExtendedTextInput() {
    if (delegate_)
      delegate_->set_extended_text_input(nullptr);
  }

  WaylandTextInputDelegate* delegate() { return delegate_.get(); }

 private:
  base::WeakPtr<WaylandTextInputDelegate> delegate_;
};

void SetSurroundingTextImpl(TextInput* text_input,
                            WaylandTextInputDelegate* delegate,
                            std::string_view text,
                            uint32_t cursor,
                            uint32_t anchor) {
  uint32_t offset_utf16 =
      delegate->TakeSurroundingTextOffsetUtf16().value_or(0u);
  auto grammar_fragment = delegate->TakeGrammarFragment();
  auto autocorrect_info = delegate->TakeAutocorrectInfo();

  // TODO(crbug.com/40189286): Selection range should keep cursor/anchor
  // relationship.
  auto minmax = std::minmax(cursor, anchor);
  std::vector<size_t> offsets{minmax.first, minmax.second};
  if (grammar_fragment.has_value()) {
    offsets.push_back(grammar_fragment->range.start());
    offsets.push_back(grammar_fragment->range.end());
  }
  if (autocorrect_info.has_value()) {
    offsets.push_back(autocorrect_info->range.start());
    offsets.push_back(autocorrect_info->range.end());
  }

  std::u16string u16_text = base::UTF8ToUTF16AndAdjustOffsets(text, &offsets);
  if (offsets[0] == std::u16string::npos ||
      offsets[1] == std::u16string::npos) {
    return;
  }

  if (grammar_fragment.has_value()) {
    grammar_fragment->range =
        gfx::Range(offsets[2] + offset_utf16, offsets[3] + offset_utf16);
  }

  // Original implementation did not convert the range. Guard this by the
  // feature flag to be reverted to old behavior just in case for transition
  // period.
  if (autocorrect_info.has_value()) {
    size_t index = grammar_fragment.has_value() ? 4u : 2u;
    autocorrect_info->range = gfx::Range(offsets[index] + offset_utf16,
                                         offsets[index + 1] + offset_utf16);
  }

  text_input->SetSurroundingText(
      u16_text, offset_utf16,
      gfx::Range(offsets[0] + offset_utf16, offsets[1] + offset_utf16),
      grammar_fragment, autocorrect_info);
}

void text_input_activate(wl_client* client,
                         wl_resource* resource,
                         wl_resource* seat_resource,
                         wl_resource* surface_resource) {
  TextInput* text_input = GetUserDataAs<TextInput>(resource);
  Surface* surface = GetUserDataAs<Surface>(surface_resource);
  Seat* seat = GetUserDataAs<WaylandSeat>(seat_resource)->seat;
  auto* delegate =
      static_cast<WaylandTextInputDelegate*>(text_input->delegate());
  delegate->set_surface(surface_resource);
  auto focus_reason = delegate->pending_focus_reason();
  delegate->set_pending_focus_reason(ui::TextInputClient::FOCUS_REASON_OTHER);
  text_input->Activate(seat, surface, focus_reason);

  // Sending modifiers.
  wl_array modifiers;
  wl_array_init(&modifiers);
  for (const char* modifier : kModifierNames) {
    char* p =
        static_cast<char*>(wl_array_add(&modifiers, ::strlen(modifier) + 1));
    ::strcpy(p, modifier);
  }
  zwp_text_input_v1_send_modifiers_map(resource, &modifiers);
  wl_array_release(&modifiers);
}

void text_input_deactivate(wl_client* client,
                           wl_resource* resource,
                           wl_resource* seat) {
  TextInput* text_input = GetUserDataAs<TextInput>(resource);
  auto* delegate =
      static_cast<WaylandTextInputDelegate*>(text_input->delegate());
  delegate->set_pending_focus_reason(ui::TextInputClient::FOCUS_REASON_OTHER);
  text_input->Deactivate();
}

void text_input_show_input_panel(wl_client* client, wl_resource* resource) {
  GetUserDataAs<TextInput>(resource)->ShowVirtualKeyboardIfEnabled();
}

void text_input_hide_input_panel(wl_client* client, wl_resource* resource) {
  GetUserDataAs<TextInput>(resource)->HideVirtualKeyboard();
}

void text_input_reset(wl_client* client, wl_resource* resource) {
  GetUserDataAs<TextInput>(resource)->Reset();
}

void text_input_set_surrounding_text(wl_client* client,
                                     wl_resource* resource,
                                     const char* text,
                                     uint32_t cursor,
                                     uint32_t anchor) {
  TextInput* text_input = GetUserDataAs<TextInput>(resource);
  auto* delegate =
      static_cast<WaylandTextInputDelegate*>(text_input->delegate());
  SetSurroundingTextImpl(text_input, delegate, text, cursor, anchor);
}

void text_input_set_content_type(wl_client* client,
                                 wl_resource* resource,
                                 uint32_t hint,
                                 uint32_t purpose) {
  TextInput* text_input = GetUserDataAs<TextInput>(resource);
  ui::TextInputType type = ui::TEXT_INPUT_TYPE_TEXT;
  ui::TextInputMode mode = ui::TEXT_INPUT_MODE_DEFAULT;
  int flags = ui::TEXT_INPUT_FLAG_NONE;
  bool should_do_learning = true;
  if (hint & ZWP_TEXT_INPUT_V1_CONTENT_HINT_AUTO_COMPLETION)
    flags |= ui::TEXT_INPUT_FLAG_AUTOCOMPLETE_ON;
  if (hint & ZWP_TEXT_INPUT_V1_CONTENT_HINT_AUTO_CORRECTION)
    flags |= ui::TEXT_INPUT_FLAG_AUTOCORRECT_ON;
  if (hint & ZWP_TEXT_INPUT_V1_CONTENT_HINT_AUTO_CAPITALIZATION)
    flags |= ui::TEXT_INPUT_FLAG_AUTOCAPITALIZE_SENTENCES;
  if (hint & ZWP_TEXT_INPUT_V1_CONTENT_HINT_LOWERCASE)
    flags |= ui::TEXT_INPUT_FLAG_AUTOCAPITALIZE_NONE;
  if (hint & ZWP_TEXT_INPUT_V1_CONTENT_HINT_UPPERCASE)
    flags |= ui::TEXT_INPUT_FLAG_AUTOCAPITALIZE_CHARACTERS;
  if (hint & ZWP_TEXT_INPUT_V1_CONTENT_HINT_TITLECASE)
    flags |= ui::TEXT_INPUT_FLAG_AUTOCAPITALIZE_WORDS;
  if (hint & ZWP_TEXT_INPUT_V1_CONTENT_HINT_HIDDEN_TEXT) {
    flags |= ui::TEXT_INPUT_FLAG_AUTOCOMPLETE_OFF |
             ui::TEXT_INPUT_FLAG_AUTOCORRECT_OFF;
  }
  if (hint & ZWP_TEXT_INPUT_V1_CONTENT_HINT_SENSITIVE_DATA)
    should_do_learning = false;
  // Unused hints: LATIN, MULTILINE.

  switch (purpose) {
    case ZWP_TEXT_INPUT_V1_CONTENT_PURPOSE_DIGITS:
      mode = ui::TEXT_INPUT_MODE_DECIMAL;
      type = ui::TEXT_INPUT_TYPE_NUMBER;
      break;
    case ZWP_TEXT_INPUT_V1_CONTENT_PURPOSE_NUMBER:
      mode = ui::TEXT_INPUT_MODE_NUMERIC;
      type = ui::TEXT_INPUT_TYPE_NUMBER;
      break;
    case ZWP_TEXT_INPUT_V1_CONTENT_PURPOSE_PHONE:
      mode = ui::TEXT_INPUT_MODE_TEL;
      type = ui::TEXT_INPUT_TYPE_TELEPHONE;
      break;
    case ZWP_TEXT_INPUT_V1_CONTENT_PURPOSE_URL:
      mode = ui::TEXT_INPUT_MODE_URL;
      type = ui::TEXT_INPUT_TYPE_URL;
      break;
    case ZWP_TEXT_INPUT_V1_CONTENT_PURPOSE_EMAIL:
      mode = ui::TEXT_INPUT_MODE_EMAIL;
      type = ui::TEXT_INPUT_TYPE_EMAIL;
      break;
    case ZWP_TEXT_INPUT_V1_CONTENT_PURPOSE_PASSWORD:
      should_do_learning = false;
      type = ui::TEXT_INPUT_TYPE_PASSWORD;
      break;
    case ZWP_TEXT_INPUT_V1_CONTENT_PURPOSE_DATE:
      type = ui::TEXT_INPUT_TYPE_DATE;
      break;
    case ZWP_TEXT_INPUT_V1_CONTENT_PURPOSE_TIME:
      type = ui::TEXT_INPUT_TYPE_TIME;
      break;
    case ZWP_TEXT_INPUT_V1_CONTENT_PURPOSE_DATETIME:
      type = ui::TEXT_INPUT_TYPE_DATE_TIME;
      break;
    case ZWP_TEXT_INPUT_V1_CONTENT_PURPOSE_NORMAL:
    case ZWP_TEXT_INPUT_V1_CONTENT_PURPOSE_ALPHA:
    case ZWP_TEXT_INPUT_V1_CONTENT_PURPOSE_NAME:
    case ZWP_TEXT_INPUT_V1_CONTENT_PURPOSE_TERMINAL:
      // No special type / mode are set.
      break;
  }

  auto* delegate =
      static_cast<WaylandTextInputDelegate*>(text_input->delegate());
  bool surrounding_text_supported =
    delegate->pending_surrounding_text_supported();
  delegate->set_pending_surrounding_text_supported(/*is_supported = */ true);

  text_input->SetTypeModeFlags(type, mode, flags, should_do_learning,
                               /* can_compose_inline = */ true,
                               surrounding_text_supported);
}

void text_input_set_cursor_rectangle(wl_client* client,
                                     wl_resource* resource,
                                     int32_t x,
                                     int32_t y,
                                     int32_t width,
                                     int32_t height) {
  GetUserDataAs<TextInput>(resource)->SetCaretBounds(
      gfx::Rect(x, y, width, height));
}

void text_input_set_preferred_language(wl_client* client,
                                       wl_resource* resource,
                                       const char* language) {
  // Nothing needs to be done.
}

void text_input_commit_state(wl_client* client,
                             wl_resource* resource,
                             uint32_t serial) {
  // Nothing needs to be done.
}

void text_input_invoke_action(wl_client* client,
                              wl_resource* resource,
                              uint32_t button,
                              uint32_t index) {
  GetUserDataAs<TextInput>(resource)->Resync();
}

constexpr struct zwp_text_input_v1_interface text_input_v1_implementation = {
    text_input_activate,
    text_input_deactivate,
    text_input_show_input_panel,
    text_input_hide_input_panel,
    text_input_reset,
    text_input_set_surrounding_text,
    text_input_set_content_type,
    text_input_set_cursor_rectangle,
    text_input_set_preferred_language,
    text_input_commit_state,
    text_input_invoke_action,
};

////////////////////////////////////////////////////////////////////////////////
// text_input_manager_v1 interface:

void text_input_manager_create_text_input(wl_client* client,
                                          wl_resource* resource,
                                          uint32_t id) {
  auto* data = GetUserDataAs<WaylandTextInputManager>(resource);

  wl_resource* text_input_resource =
      wl_resource_create(client, &zwp_text_input_v1_interface, 1, id);

  SetImplementation(
      text_input_resource, &text_input_v1_implementation,
      std::make_unique<TextInput>(std::make_unique<WaylandTextInputDelegate>(
          text_input_resource, data->xkb_tracker, data->serial_tracker)));
}

constexpr struct zwp_text_input_manager_v1_interface
    text_input_manager_implementation = {
        text_input_manager_create_text_input,
};

////////////////////////////////////////////////////////////////////////////////
// extended_text_input_v1 interface:

void extended_text_input_destroy(wl_client* client, wl_resource* resource) {
  wl_resource_destroy(resource);
}

void extended_text_input_set_input_type(wl_client* client,
                                        wl_resource* resource,
                                        uint32_t input_type,
                                        uint32_t input_mode,
                                        uint32_t input_flags,
                                        uint32_t learning_mode,
                                        uint32_t inline_composition_support) {
  auto* delegate =
      GetUserDataAs<WaylandExtendedTextInput>(resource)->delegate();
  if (!delegate)
    return;

  // If unknown value is passed, fall back to the default one.
  auto ui_type =
      ui::wayland::ConvertToTextInputType(
          static_cast<zcr_extended_text_input_v1_input_type>(input_type))
          .value_or(ui::TEXT_INPUT_TYPE_TEXT);
  auto ui_mode =
      ui::wayland::ConvertToTextInputMode(
          static_cast<zcr_extended_text_input_v1_input_mode>(input_mode))
          .value_or(ui::TEXT_INPUT_MODE_DEFAULT);
  // Ignore unknown flags.
  auto ui_flags = ui::wayland::ConvertToTextInputFlags(input_flags).first;
  bool should_do_learning =
      learning_mode == ZCR_EXTENDED_TEXT_INPUT_V1_LEARNING_MODE_ENABLED;
  bool can_compose_inline =
      inline_composition_support ==
      ZCR_EXTENDED_TEXT_INPUT_V1_INLINE_COMPOSITION_SUPPORT_SUPPORTED;

  bool surrounding_text_supported =
    delegate->pending_surrounding_text_supported();
  delegate->set_pending_surrounding_text_supported(/*is_supported = */ true);

  auto* text_input = GetUserDataAs<TextInput>(delegate->resource());
  text_input->SetTypeModeFlags(ui_type, ui_mode, ui_flags, should_do_learning,
                               can_compose_inline, surrounding_text_supported);
}

void extended_text_input_deprecated_set_input_type(wl_client* client,
                                                   wl_resource* resource,
                                                   uint32_t input_type,
                                                   uint32_t input_mode,
                                                   uint32_t input_flags,
                                                   uint32_t learning_mode) {
  // TODO(crbug.com/40258785) This deprecated method signature is preserved to
  // maintain backwards compatibility with older client versions. Once both Exo
  // and Lacros have stabilized on the new API, delete this implementation or
  // otherwise make it impossible to call.
  extended_text_input_set_input_type(client, resource, input_type, input_mode,
                                     input_flags, learning_mode,
                                     /*inline_composition_support=*/true);
}

void extended_text_input_set_grammar_fragment_at_cursor(
    wl_client* client,
    wl_resource* resource,
    uint32_t start,
    uint32_t end,
    const char* suggestion) {
  auto* delegate =
      GetUserDataAs<WaylandExtendedTextInput>(resource)->delegate();
  if (!delegate) {
    return;
  }

  delegate->SetPendingGrammarFragment(
      start == end ? std::nullopt
                   : std::make_optional(ui::GrammarFragment(
                         gfx::Range(start, end), suggestion)));
}

void extended_text_input_set_autocorrect_info(wl_client* client,
                                              wl_resource* resource,
                                              uint32_t start,
                                              uint32_t end,
                                              uint32_t x,
                                              uint32_t y,
                                              uint32_t width,
                                              uint32_t height) {
  auto* delegate =
      GetUserDataAs<WaylandExtendedTextInput>(resource)->delegate();
  if (!delegate) {
    return;
  }

  delegate->SetPendingAutocorrectInfo(ui::AutocorrectInfo{
      gfx::Range(start, end),
      gfx::Rect(x, y, width, height),
  });
}

void extended_text_input_finalize_virtual_keyboard_changes(
    wl_client* client,
    wl_resource* resource) {
  auto* delegate =
      GetUserDataAs<WaylandExtendedTextInput>(resource)->delegate();
  if (!delegate)
    return;

  auto* text_input = GetUserDataAs<TextInput>(delegate->resource());
  text_input->FinalizeVirtualKeyboardChanges();
}

void extended_text_input_set_focus_reason(wl_client* client,
                                          wl_resource* resource,
                                          uint32_t reason) {
  ui::TextInputClient::FocusReason focus_reason;
  switch (reason) {
    case ZCR_EXTENDED_TEXT_INPUT_V1_FOCUS_REASON_TYPE_NONE:
      focus_reason = ui::TextInputClient::FOCUS_REASON_NONE;
      break;
    case ZCR_EXTENDED_TEXT_INPUT_V1_FOCUS_REASON_TYPE_MOUSE:
      focus_reason = ui::TextInputClient::FOCUS_REASON_MOUSE;
      break;
    case ZCR_EXTENDED_TEXT_INPUT_V1_FOCUS_REASON_TYPE_TOUCH:
      focus_reason = ui::TextInputClient::FOCUS_REASON_TOUCH;
      break;
    case ZCR_EXTENDED_TEXT_INPUT_V1_FOCUS_REASON_TYPE_PEN:
      focus_reason = ui::TextInputClient::FOCUS_REASON_PEN;
      break;
    case ZCR_EXTENDED_TEXT_INPUT_V1_FOCUS_REASON_TYPE_OTHER:
      focus_reason = ui::TextInputClient::FOCUS_REASON_OTHER;
      break;
    default:
      LOG(ERROR) << "Unknown focus reason: " << reason;
      return;
  }

  // Keep tracking in WaylandExtendedTextInput. This will be passed to
  // TextInput::Activate.
  auto* delegate =
      GetUserDataAs<WaylandExtendedTextInput>(resource)->delegate();
  if (!delegate) {
    return;
  }
  delegate->set_pending_focus_reason(focus_reason);
}

void extended_text_input_set_surrounding_text_support(wl_client* client,
                                                      wl_resource* resource,
                                                      uint32_t support) {
  auto* delegate =
      GetUserDataAs<WaylandExtendedTextInput>(resource)->delegate();
  if (!delegate) {
    return;
  }

  switch (support) {
    case ZCR_EXTENDED_TEXT_INPUT_V1_SURROUNDING_TEXT_SUPPORT_SUPPORTED:
      delegate->set_pending_surrounding_text_supported(/*is_supported=*/true);
      return;
    case ZCR_EXTENDED_TEXT_INPUT_V1_SURROUNDING_TEXT_SUPPORT_UNSUPPORTED:
      delegate->set_pending_surrounding_text_supported(/*is_supported=*/false);
      return;
    default:
      LOG(ERROR) << "Unknown surrounding_text_support: " << support;
      return;
  }
}

void extended_text_input_set_surrounding_text_offset_utf16(
    wl_client* client,
    wl_resource* resource,
    uint32_t offset_utf16) {
  auto* delegate =
      GetUserDataAs<WaylandExtendedTextInput>(resource)->delegate();
  if (!delegate) {
    return;
  }

  delegate->SetSurroundingTextOffsetUtf16(offset_utf16);
}

void extended_text_input_set_large_surrounding_text(wl_client* client,
                                                    wl_resource* resource,
                                                    int32_t raw_fd,
                                                    uint32_t size,
                                                    uint32_t cursor,
                                                    uint32_t anchor) {
  std::string text;
  {
    text.resize(size);
    base::ScopedFD fd(raw_fd);
    if (!base::ReadFromFD(fd.get(), text)) {
      PLOG(ERROR) << "Failed to read file descriptor for surrounding text";
      return;
    }
  }

  auto* delegate =
      GetUserDataAs<WaylandExtendedTextInput>(resource)->delegate();
  if (!delegate) {
    return;
  }
  auto* text_input = GetUserDataAs<TextInput>(delegate->resource());
  if (!text_input) {
    return;
  }
  SetSurroundingTextImpl(text_input, delegate, text, cursor, anchor);
}

constexpr struct zcr_extended_text_input_v1_interface
    extended_text_input_implementation = {
        extended_text_input_destroy,
        extended_text_input_deprecated_set_input_type,
        extended_text_input_set_grammar_fragment_at_cursor,
        extended_text_input_set_autocorrect_info,
        extended_text_input_finalize_virtual_keyboard_changes,
        extended_text_input_set_focus_reason,
        extended_text_input_set_input_type,
        extended_text_input_set_surrounding_text_support,
        extended_text_input_set_surrounding_text_offset_utf16,
        extended_text_input_set_large_surrounding_text,
};

////////////////////////////////////////////////////////////////////////////////
// text_input_extension_v1 interface:

void text_input_extension_get_extended_text_input(
    wl_client* client,
    wl_resource* resource,
    uint32_t id,
    wl_resource* text_input_resource) {
  TextInput* text_input = GetUserDataAs<TextInput>(text_input_resource);
  auto* delegate =
      static_cast<WaylandTextInputDelegate*>(text_input->delegate());
  if (delegate->has_extended_text_input()) {
    wl_resource_post_error(
        resource, ZCR_TEXT_INPUT_EXTENSION_V1_ERROR_EXTENDED_TEXT_INPUT_EXISTS,
        "text_input has already been associated with a extended_text_input "
        "object");
    return;
  }

  uint32_t version = wl_resource_get_version(resource);
  wl_resource* extended_text_input_resource = wl_resource_create(
      client, &zcr_extended_text_input_v1_interface, version, id);

  delegate->set_extended_text_input(extended_text_input_resource);

  SetImplementation(
      extended_text_input_resource, &extended_text_input_implementation,
      std::make_unique<WaylandExtendedTextInput>(delegate->GetWeakPtr()));
}

constexpr struct zcr_text_input_extension_v1_interface
    text_input_extension_implementation = {
        text_input_extension_get_extended_text_input};

}  // namespace

void bind_text_input_manager(wl_client* client,
                             void* data,
                             uint32_t version,
                             uint32_t id) {
  wl_resource* resource =
      wl_resource_create(client, &zwp_text_input_manager_v1_interface, 1, id);
  wl_resource_set_implementation(resource, &text_input_manager_implementation,
                                 data, nullptr);
}

void bind_text_input_extension(wl_client* client,
                               void* data,
                               uint32_t version,
                               uint32_t id) {
  wl_resource* resource = wl_resource_create(
      client, &zcr_text_input_extension_v1_interface, version, id);
  wl_resource_set_implementation(resource, &text_input_extension_implementation,
                                 data, nullptr);
}

}  // namespace wayland
}  // namespace exo