// 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/zcr_keyboard_configuration.h"

#include <linux/input.h>
#include <wayland-server-core.h>
#include <wayland-server-protocol-core.h>
#include <xkbcommon/xkbcommon.h>

#include "ash/ime/ime_controller_impl.h"
#include "ash/shell.h"
#include "base/containers/contains.h"
#include "base/feature_list.h"
#include "base/memory/free_deleter.h"
#include "base/memory/raw_ptr.h"
#include "base/task/current_thread.h"
#include "base/task/thread_pool.h"
#include "components/exo/keyboard.h"
#include "components/exo/keyboard_device_configuration_delegate.h"
#include "components/exo/keyboard_observer.h"
#include "components/exo/wayland/server_util.h"
#include "ui/base/ime/ash/input_method_manager.h"
#include "ui/events/devices/device_data_manager.h"
#include "ui/events/devices/input_device_event_observer.h"
#include "ui/events/event_constants.h"
#include "ui/events/keycodes/scoped_xkb.h"  // nogncheck
#include "ui/events/ozone/evdev/event_device_util.h"
#include "ui/events/ozone/layout/xkb/xkb_keyboard_layout_engine.h"
#include "ui/events/ozone/layout/xkb/xkb_modifier_converter.h"
#include "ui/ozone/public/input_controller.h"
#include "ui/ozone/public/ozone_platform.h"

namespace exo::wayland {

namespace {

////////////////////////////////////////////////////////////////////////////////
// keyboard_device_configuration interface:

class WaylandKeyboardDeviceConfigurationDelegate
    : public ash::input_method::InputMethodManager::ImeMenuObserver,
      public KeyboardDeviceConfigurationDelegate,
      public KeyboardObserver,
      public ash::ImeControllerImpl::Observer,
      public ui::InputDeviceEventObserver {
 public:
  WaylandKeyboardDeviceConfigurationDelegate(wl_resource* resource,
                                             Keyboard* keyboard)
      : resource_(resource), keyboard_(keyboard) {
    keyboard_->SetDeviceConfigurationDelegate(this);
    keyboard_->AddObserver(this);
    ash::ImeControllerImpl* ime_controller =
        ash::Shell::Get()->ime_controller();
    ime_controller->AddObserver(this);
    ui::DeviceDataManager::GetInstance()->AddObserver(this);
    ash::input_method::InputMethodManager::Get()->AddImeMenuObserver(this);
    // Call this once to setup initial installed keyboard layout data.
    ImeMenuListChanged();
    ProcessKeyBitsUpdate();
    OnKeyboardLayoutNameChanged(ime_controller->keyboard_layout_name());
  }
  WaylandKeyboardDeviceConfigurationDelegate(
      const WaylandKeyboardDeviceConfigurationDelegate&) = delete;
  WaylandKeyboardDeviceConfigurationDelegate& operator=(
      const WaylandKeyboardDeviceConfigurationDelegate&) = delete;

  ~WaylandKeyboardDeviceConfigurationDelegate() override {
    ash::input_method::InputMethodManager::Get()->RemoveImeMenuObserver(this);
    ui::DeviceDataManager::GetInstance()->RemoveObserver(this);
    ash::Shell::Get()->ime_controller()->RemoveObserver(this);
    if (keyboard_) {
      keyboard_->SetDeviceConfigurationDelegate(nullptr);
      keyboard_->RemoveObserver(this);
    }
  }

  // Overridden from KeyboardObserver:
  void OnKeyboardDestroying(Keyboard* keyboard) override {
    keyboard_ = nullptr;
  }

  // Overridden from KeyboardDeviceConfigurationDelegate:
  void OnKeyboardTypeChanged(bool is_physical) override {
    zcr_keyboard_device_configuration_v1_send_type_change(
        resource_,
        is_physical
            ? ZCR_KEYBOARD_DEVICE_CONFIGURATION_V1_KEYBOARD_TYPE_PHYSICAL
            : ZCR_KEYBOARD_DEVICE_CONFIGURATION_V1_KEYBOARD_TYPE_VIRTUAL);
    wl_client_flush(client());
  }

  // Overridden from ImeControllerImpl::Observer:
  void OnCapsLockChanged(bool enabled) override {}

  void OnKeyboardLayoutNameChanged(const std::string& layout_name) override {
    zcr_keyboard_device_configuration_v1_send_layout_change(
        resource_, layout_name.c_str());
    wl_client_flush(client());
  }

  // Overridden from ui::InputDeviceEventObserver:
  void OnInputDeviceConfigurationChanged(uint8_t input_device_types) override {
    if (!(input_device_types & ui::InputDeviceEventObserver::kKeyboard)) {
      return;
    }
    ProcessKeyBitsUpdate();
  }

  // ash::input_method::InputMethodManager::ImeMenuObserver:
  void ImeMenuActivationChanged(bool) override {}

  void ImeMenuListChanged() override {
    // We'll scan ime list changes and notify if a new one was installed.
    // However if we're not sending event to the client, we can return early.
    if (wl_resource_get_version(resource_) <
        ZCR_KEYBOARD_DEVICE_CONFIGURATION_V1_LAYOUT_INSTALL_SINCE_VERSION) {
      return;
    }

    ash::input_method::InputMethodManager::State* state =
        ash::input_method::InputMethodManager::Get()->GetActiveIMEState().get();
    if (!state) {
      return;
    }
    std::vector<ash::input_method::InputMethodDescriptor>
        enabled_ime_descriptors = state->GetEnabledInputMethods();

    for (const auto& descriptor : enabled_ime_descriptors) {
      const std::string& keyboard_layout = descriptor.keyboard_layout();
      if (!base::Contains(installed_keyboard_layouts_, keyboard_layout)) {
        sequenced_task_runner_->PostTaskAndReplyWithResult(
            FROM_HERE,
            base::BindOnce(
                &WaylandKeyboardDeviceConfigurationDelegate::GetXkbKeymap,
                keyboard_layout),
            base::BindOnce(&WaylandKeyboardDeviceConfigurationDelegate::
                               OnKeyboardLayoutInstalled,
                           weak_factory_.GetWeakPtr(), keyboard_layout));
      }
    }

    installed_keyboard_layouts_.clear();
    for (const auto& descriptor : enabled_ime_descriptors) {
      const std::string& keyboard_layout = descriptor.keyboard_layout();
      installed_keyboard_layouts_.insert(keyboard_layout);
    }
  }

  void ImeMenuItemsChanged(
      const std::string&,
      const std::vector<ash::input_method::InputMethodManager::MenuItem>&)
      override {}

 private:
  void OnKeyboardLayoutInstalled(
      const std::string& layout_name,
      std::unique_ptr<char, base::FreeDeleter> keymap_str) {
    // Wayland methods should be run in UI Thread.
    DCHECK(base::CurrentUIThread::IsSet());

    base::StringPiece keymap = keymap_str.get();
    // Send the content of |keymap| with trailing '\0' termination via shared
    // memory.
    base::UnsafeSharedMemoryRegion shared_keymap_region =
        base::UnsafeSharedMemoryRegion::Create(keymap.size() + 1);
    base::WritableSharedMemoryMapping shared_keymap =
        shared_keymap_region.Map();
    base::subtle::PlatformSharedMemoryRegion platform_shared_keymap =
        base::UnsafeSharedMemoryRegion::TakeHandleForSerialization(
            std::move(shared_keymap_region));
    DCHECK(shared_keymap.IsValid());

    std::memcpy(shared_keymap.memory(), keymap.data(), keymap.size());
    static_cast<uint8_t*>(shared_keymap.memory())[keymap.size()] = '\0';

    zcr_keyboard_device_configuration_v1_send_layout_install(
        resource_, layout_name.c_str(), WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1,
        platform_shared_keymap.GetPlatformHandle().fd, keymap.size() + 1);
    wl_client_flush(client());
  }

  // Notify key bits update.
  void ProcessKeyBitsUpdate() {
    if (wl_resource_get_version(resource_) <
        ZCR_KEYBOARD_DEVICE_CONFIGURATION_V1_SUPPORTED_KEY_BITS_SINCE_VERSION) {
      return;
    }

    // Preparing wayland keybits.
    wl_array wl_key_bits;
    wl_array_init(&wl_key_bits);
    size_t key_bits_len = EVDEV_BITS_TO_INT64(KEY_CNT) * sizeof(uint64_t);
    uint64_t* wl_key_bits_ptr =
        static_cast<uint64_t*>(wl_array_add(&wl_key_bits, key_bits_len));
    if (!wl_key_bits_ptr) {
      wl_array_release(&wl_key_bits);
      return;
    }
    memset(wl_key_bits_ptr, 0, key_bits_len);

    ui::InputController* input_controller =
        ui::OzonePlatform::GetInstance()->GetInputController();
    // Combine supported key bits from all keyboard into single key bits.
    for (const ui::InputDevice& device :
         ui::DeviceDataManager::GetInstance()->GetKeyboardDevices()) {
      const std::vector<uint64_t>& key_bits =
          input_controller->GetKeyboardKeyBits(device.id);
      for (size_t i = 0; i < key_bits.size(); i++) {
        wl_key_bits_ptr[i] |= key_bits[i];
      }
    }

    zcr_keyboard_device_configuration_v1_send_supported_key_bits(resource_,
                                                                 &wl_key_bits);
    wl_array_release(&wl_key_bits);
    wl_client_flush(client());
  }

  // This method shouldn't run on UI thread since it involves I/O operation.
  static std::unique_ptr<char, base::FreeDeleter> GetXkbKeymap(
      const std::string& layout_name) {
    std::unique_ptr<xkb_context, ui::XkbContextDeleter> xkb_context{
        xkb_context_new(XKB_CONTEXT_NO_FLAGS)};
    std::string layout_id, layout_variant;
    ui::XkbKeyboardLayoutEngine::ParseLayoutName(layout_name, &layout_id,
                                                 &layout_variant);
    xkb_rule_names names = {.rules = nullptr,
                            .model = "pc101",
                            .layout = layout_id.c_str(),
                            .variant = layout_variant.c_str(),
                            .options = ""};

    std::unique_ptr<xkb_keymap, ui::XkbKeymapDeleter> xkb_keymap(
        xkb_keymap_new_from_names(xkb_context.get(), &names,
                                  XKB_KEYMAP_COMPILE_NO_FLAGS));

    return std::unique_ptr<char, base::FreeDeleter>(
        xkb_keymap_get_as_string(xkb_keymap.get(), XKB_KEYMAP_FORMAT_TEXT_V1));
  }

  wl_client* client() const { return wl_resource_get_client(resource_); }

  raw_ptr<wl_resource, ExperimentalAsh> resource_;
  raw_ptr<Keyboard, ExperimentalAsh> keyboard_;

  // List of acknowledged installed keyboard layouts. Used to determine if there
  // are new keyboard layouts installed.
  std::set<std::string> installed_keyboard_layouts_;

  scoped_refptr<base::SequencedTaskRunner> sequenced_task_runner_{
      base::ThreadPool::CreateSequencedTaskRunner(
          {base::MayBlock(), base::TaskPriority::BEST_EFFORT})};
  base::WeakPtrFactory<WaylandKeyboardDeviceConfigurationDelegate>
      weak_factory_{this};
};

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

const struct zcr_keyboard_device_configuration_v1_interface
    keyboard_device_configuration_implementation = {
        keyboard_device_configuration_destroy};

////////////////////////////////////////////////////////////////////////////////
// keyboard_configuration interface:

void keyboard_configuration_get_keyboard_device_configuration(
    wl_client* client,
    wl_resource* resource,
    uint32_t id,
    wl_resource* keyboard_resource) {
  Keyboard* keyboard = GetUserDataAs<Keyboard>(keyboard_resource);
  if (keyboard->HasDeviceConfigurationDelegate()) {
    wl_resource_post_error(
        resource,
        ZCR_KEYBOARD_CONFIGURATION_V1_ERROR_DEVICE_CONFIGURATION_EXISTS,
        "keyboard has already been associated with a device configuration "
        "object");
    return;
  }

  wl_resource* keyboard_device_configuration_resource = wl_resource_create(
      client, &zcr_keyboard_device_configuration_v1_interface,
      wl_resource_get_version(resource), id);

  SetImplementation(
      keyboard_device_configuration_resource,
      &keyboard_device_configuration_implementation,
      std::make_unique<WaylandKeyboardDeviceConfigurationDelegate>(
          keyboard_device_configuration_resource, keyboard));
}

const struct zcr_keyboard_configuration_v1_interface
    keyboard_configuration_implementation = {
        keyboard_configuration_get_keyboard_device_configuration};

}  // namespace

void bind_keyboard_configuration(wl_client* client,
                                 void* data,
                                 uint32_t version,
                                 uint32_t id) {
  wl_resource* resource = wl_resource_create(
      client, &zcr_keyboard_configuration_v1_interface,
      std::min<uint32_t>(version,
                         zcr_keyboard_configuration_v1_interface.version),
      id);
  wl_resource_set_implementation(
      resource, &keyboard_configuration_implementation, data, nullptr);
}

}  // namespace exo::wayland