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

#include "ash/accessibility/sticky_keys/sticky_keys_controller.h"

#include <memory>

#include "ash/accessibility/sticky_keys/sticky_keys_overlay.h"
#include "ui/aura/window.h"
#include "ui/aura/window_tracker.h"
#include "ui/aura/window_tree_host.h"
#include "ui/events/event.h"
#include "ui/events/event_processor.h"
#include "ui/events/keycodes/dom/dom_code.h"
#include "ui/events/keycodes/keyboard_code_conversion.h"

namespace ash {

namespace {

// Returns true if the type of mouse event should be modified by sticky keys.
bool ShouldModifyMouseEvent(const ui::MouseEvent& event) {
  ui::EventType type = event.type();
  return type == ui::EventType::kMousePressed ||
         type == ui::EventType::kMouseReleased ||
         type == ui::EventType::kMousewheel;
}

// Handle the common tail of event rewriting.
ui::EventRewriteStatus RewriteUpdate(
    bool consumed,
    bool released,
    int mod_down_flags,
    const ui::Event& event,
    std::unique_ptr<ui::Event>* rewritten_event) {
  if (consumed)
    return ui::EVENT_REWRITE_DISCARD;
  const bool flags_rewritten = mod_down_flags & ~event.flags();

  // If the flag is not changed and no need to send a release key event.
  if (!released && !flags_rewritten)
    return ui::EVENT_REWRITE_CONTINUE;

  *rewritten_event = event.Clone();
  if (mod_down_flags & ~event.flags()) {
    (*rewritten_event)->SetFlags(event.flags() | mod_down_flags);
  }

  if (released)
    return ui::EVENT_REWRITE_DISPATCH_ANOTHER;
  return ui::EVENT_REWRITE_REWRITTEN;
}

}  // namespace

///////////////////////////////////////////////////////////////////////////////
//  StickyKeys
StickyKeysController::StickyKeysController()
    : enabled_(false),
      mod3_enabled_(false),
      altgr_enabled_(false),
      fn_enabled_(false) {}

StickyKeysController::~StickyKeysController() = default;

void StickyKeysController::Enable(bool enabled) {
  if (enabled_ != enabled) {
    enabled_ = enabled;

    // Reset key handlers when activating sticky keys to ensure all
    // the handlers' states are reset.
    if (enabled_) {
      shift_sticky_key_ =
          std::make_unique<StickyKeysHandler>(ui::EF_SHIFT_DOWN);
      alt_sticky_key_ = std::make_unique<StickyKeysHandler>(ui::EF_ALT_DOWN);
      alt_sticky_key_->set_altgr_active(altgr_enabled_);
      altgr_sticky_key_ =
          std::make_unique<StickyKeysHandler>(ui::EF_ALTGR_DOWN);
      altgr_sticky_key_->set_altgr_active(altgr_enabled_);
      ctrl_sticky_key_ =
          std::make_unique<StickyKeysHandler>(ui::EF_CONTROL_DOWN);
      mod3_sticky_key_ = std::make_unique<StickyKeysHandler>(ui::EF_MOD3_DOWN);
      search_sticky_key_ =
          std::make_unique<StickyKeysHandler>(ui::EF_COMMAND_DOWN);
      fn_sticky_key_ =
          std::make_unique<StickyKeysHandler>(ui::EF_FUNCTION_DOWN);

      overlay_ = std::make_unique<StickyKeysOverlay>();
      overlay_->SetModifierVisible(ui::EF_FUNCTION_DOWN, fn_enabled_);
      overlay_->SetModifierVisible(ui::EF_ALTGR_DOWN, altgr_enabled_);
      overlay_->SetModifierVisible(ui::EF_MOD3_DOWN, mod3_enabled_);
    } else if (overlay_) {
      overlay_.reset();
    }
  }
}

void StickyKeysController::SetMod3AndAltGrModifiersEnabled(bool mod3_enabled,
                                                           bool altgr_enabled) {
  mod3_enabled_ = mod3_enabled;
  altgr_enabled_ = altgr_enabled;
  if (overlay_) {
    overlay_->SetModifierVisible(ui::EF_ALTGR_DOWN, altgr_enabled_);
    overlay_->SetModifierVisible(ui::EF_MOD3_DOWN, mod3_enabled_);
  }
  if (altgr_sticky_key_) {
    altgr_sticky_key_->set_altgr_active(altgr_enabled);
  }
  if (alt_sticky_key_) {
    alt_sticky_key_->set_altgr_active(altgr_enabled);
  }
}

void StickyKeysController::SetFnModifierEnabled(bool fn_enabled) {
  fn_enabled_ = fn_enabled;
  if (overlay_) {
    overlay_->SetModifierVisible(ui::EF_FUNCTION_DOWN, fn_enabled_);
  }
}

void StickyKeysController::UpdateStickyKeysOverlayBoundsIfNeeded() {
  if (!enabled_)
    return;

  overlay_->UpdateBoundsIfVisible();
}

StickyKeysOverlay* StickyKeysController::GetOverlayForTest() {
  return overlay_.get();
}

ui::EventRewriteStatus StickyKeysController::RewriteEvent(
    const ui::Event& event,
    std::unique_ptr<ui::Event>* rewritten_event) {
  DCHECK(rewritten_event);
  if (!enabled_)
    return ui::EVENT_REWRITE_CONTINUE;

  if (event.IsKeyEvent())
    return RewriteKeyEvent(*event.AsKeyEvent(), rewritten_event);

  if (event.IsMouseEvent())
    return RewriteMouseEvent(*event.AsMouseEvent(), rewritten_event);

  if (event.IsScrollEvent())
    return RewriteScrollEvent(*event.AsScrollEvent(), rewritten_event);

  NOTREACHED();
}

ui::EventRewriteStatus StickyKeysController::NextDispatchEvent(
    const ui::Event& last_event,
    std::unique_ptr<ui::Event>* new_event) {
  DCHECK(new_event);
  new_event->reset();
  int remaining = shift_sticky_key_->GetModifierUpEvent(new_event) +
                  alt_sticky_key_->GetModifierUpEvent(new_event) +
                  altgr_sticky_key_->GetModifierUpEvent(new_event) +
                  ctrl_sticky_key_->GetModifierUpEvent(new_event) +
                  mod3_sticky_key_->GetModifierUpEvent(new_event) +
                  search_sticky_key_->GetModifierUpEvent(new_event) +
                  fn_sticky_key_->GetModifierUpEvent(new_event);
  if (!new_event)
    return ui::EVENT_REWRITE_CONTINUE;
  if (remaining)
    return ui::EVENT_REWRITE_DISPATCH_ANOTHER;
  return ui::EVENT_REWRITE_REWRITTEN;
}

ui::EventRewriteStatus StickyKeysController::RewriteKeyEvent(
    const ui::KeyEvent& event,
    std::unique_ptr<ui::Event>* rewritten_event) {
  DCHECK(enabled_);
  int mod_down_flags = 0;
  bool released = false;
  bool consumed =
      shift_sticky_key_->HandleKeyEvent(event, &mod_down_flags, &released) ||
      alt_sticky_key_->HandleKeyEvent(event, &mod_down_flags, &released) ||
      altgr_sticky_key_->HandleKeyEvent(event, &mod_down_flags, &released) ||
      ctrl_sticky_key_->HandleKeyEvent(event, &mod_down_flags, &released) ||
      mod3_sticky_key_->HandleKeyEvent(event, &mod_down_flags, &released) ||
      search_sticky_key_->HandleKeyEvent(event, &mod_down_flags, &released) ||
      fn_sticky_key_->HandleKeyEvent(event, &mod_down_flags, &released);
  UpdateOverlay();
  return RewriteUpdate(consumed, released, mod_down_flags, event,
                       rewritten_event);
}

ui::EventRewriteStatus StickyKeysController::RewriteMouseEvent(
    const ui::MouseEvent& event,
    std::unique_ptr<ui::Event>* rewritten_event) {
  DCHECK(enabled_);
  int mod_down_flags = 0;
  bool released = false;
  bool consumed =
      shift_sticky_key_->HandleMouseEvent(event, &mod_down_flags, &released) ||
      alt_sticky_key_->HandleMouseEvent(event, &mod_down_flags, &released) ||
      altgr_sticky_key_->HandleMouseEvent(event, &mod_down_flags, &released) ||
      ctrl_sticky_key_->HandleMouseEvent(event, &mod_down_flags, &released) ||
      mod3_sticky_key_->HandleMouseEvent(event, &mod_down_flags, &released) ||
      fn_sticky_key_->HandleMouseEvent(event, &mod_down_flags, &released);
  return RewriteUpdate(consumed, released, mod_down_flags, event,
                       rewritten_event);
}

ui::EventRewriteStatus StickyKeysController::RewriteScrollEvent(
    const ui::ScrollEvent& event,
    std::unique_ptr<ui::Event>* rewritten_event) {
  DCHECK(enabled_);
  int mod_down_flags = 0;
  bool released = false;
  bool consumed =
      shift_sticky_key_->HandleScrollEvent(event, &mod_down_flags, &released) ||
      alt_sticky_key_->HandleScrollEvent(event, &mod_down_flags, &released) ||
      altgr_sticky_key_->HandleScrollEvent(event, &mod_down_flags, &released) ||
      ctrl_sticky_key_->HandleScrollEvent(event, &mod_down_flags, &released) ||
      mod3_sticky_key_->HandleScrollEvent(event, &mod_down_flags, &released) ||
      fn_sticky_key_->HandleScrollEvent(event, &mod_down_flags, &released);
  return RewriteUpdate(consumed, released, mod_down_flags, event,
                       rewritten_event);
}

void StickyKeysController::UpdateOverlay() {
  overlay_->SetModifierKeyState(ui::EF_SHIFT_DOWN,
                                shift_sticky_key_->current_state());
  overlay_->SetModifierKeyState(ui::EF_CONTROL_DOWN,
                                ctrl_sticky_key_->current_state());
  overlay_->SetModifierKeyState(ui::EF_ALT_DOWN,
                                alt_sticky_key_->current_state());
  overlay_->SetModifierKeyState(ui::EF_COMMAND_DOWN,
                                search_sticky_key_->current_state());
  overlay_->SetModifierKeyState(ui::EF_ALTGR_DOWN,
                                altgr_sticky_key_->current_state());
  overlay_->SetModifierKeyState(ui::EF_MOD3_DOWN,
                                mod3_sticky_key_->current_state());
  overlay_->SetModifierKeyState(ui::EF_FUNCTION_DOWN,
                                fn_sticky_key_->current_state());

  bool key_in_use =
      shift_sticky_key_->current_state() != STICKY_KEY_STATE_DISABLED ||
      alt_sticky_key_->current_state() != STICKY_KEY_STATE_DISABLED ||
      altgr_sticky_key_->current_state() != STICKY_KEY_STATE_DISABLED ||
      ctrl_sticky_key_->current_state() != STICKY_KEY_STATE_DISABLED ||
      search_sticky_key_->current_state() != STICKY_KEY_STATE_DISABLED ||
      mod3_sticky_key_->current_state() != STICKY_KEY_STATE_DISABLED ||
      fn_sticky_key_->current_state() != STICKY_KEY_STATE_DISABLED;

  overlay_->Show(enabled_ && key_in_use);
}

///////////////////////////////////////////////////////////////////////////////
//  StickyKeysHandler
StickyKeysHandler::StickyKeysHandler(ui::EventFlags modifier_flag)
    : modifier_flag_(modifier_flag),
      current_state_(STICKY_KEY_STATE_DISABLED),
      preparing_to_enable_(false),
      scroll_delta_(0) {}

StickyKeysHandler::~StickyKeysHandler() = default;

bool StickyKeysHandler::HandleKeyEvent(const ui::KeyEvent& event,
                                       int* mod_down_flags,
                                       bool* released) {
  switch (current_state_) {
    case STICKY_KEY_STATE_DISABLED:
      return HandleDisabledState(event);
    case STICKY_KEY_STATE_ENABLED:
      return HandleEnabledState(event, mod_down_flags, released);
    case STICKY_KEY_STATE_LOCKED:
      return HandleLockedState(event, mod_down_flags, released);
  }
  NOTREACHED();
}

bool StickyKeysHandler::HandleMouseEvent(const ui::MouseEvent& event,
                                         int* mod_down_flags,
                                         bool* released) {
  if (ShouldModifyMouseEvent(event))
    preparing_to_enable_ = false;

  if (current_state_ == STICKY_KEY_STATE_DISABLED ||
      !ShouldModifyMouseEvent(event)) {
    return false;
  }
  DCHECK(current_state_ == STICKY_KEY_STATE_ENABLED ||
         current_state_ == STICKY_KEY_STATE_LOCKED);

  *mod_down_flags |= modifier_flag_;
  // Only disable on the mouse released event in normal, non-locked mode.
  if (current_state_ == STICKY_KEY_STATE_ENABLED &&
      event.type() != ui::EventType::kMousePressed) {
    current_state_ = STICKY_KEY_STATE_DISABLED;
    *released = true;
    return false;
  }

  return false;
}

bool StickyKeysHandler::HandleScrollEvent(const ui::ScrollEvent& event,
                                          int* mod_down_flags,
                                          bool* released) {
  preparing_to_enable_ = false;
  if (current_state_ == STICKY_KEY_STATE_DISABLED)
    return false;
  DCHECK(current_state_ == STICKY_KEY_STATE_ENABLED ||
         current_state_ == STICKY_KEY_STATE_LOCKED);

  // We detect a direction change if the current |scroll_delta_| is assigned
  // and the offset of the current scroll event has the opposing sign.
  bool direction_changed = false;
  if (current_state_ == STICKY_KEY_STATE_ENABLED &&
      event.type() == ui::EventType::kScroll) {
    int offset = event.y_offset();
    if (scroll_delta_)
      direction_changed = offset * scroll_delta_ <= 0;
    scroll_delta_ = offset;
  }

  if (!direction_changed)
    *mod_down_flags |= modifier_flag_;

  // We want to modify all the scroll events in the scroll sequence, which ends
  // with a fling start event. We also stop when the scroll sequence changes
  // direction.
  if (current_state_ == STICKY_KEY_STATE_ENABLED &&
      (event.type() == ui::EventType::kScrollFlingStart || direction_changed)) {
    current_state_ = STICKY_KEY_STATE_DISABLED;
    scroll_delta_ = 0;
    *released = true;
    return false;
  }

  return false;
}

int StickyKeysHandler::GetModifierUpEvent(
    std::unique_ptr<ui::Event>* new_event) {
  if (current_state_ != STICKY_KEY_STATE_DISABLED || !modifier_up_event_)
    return 0;
  DCHECK(new_event);
  if (*new_event)
    return 1;
  *new_event = std::move(modifier_up_event_);
  return 0;
}

StickyKeysHandler::KeyEventType StickyKeysHandler::TranslateKeyEvent(
    ui::EventType type,
    ui::KeyboardCode key_code,
    ui::DomCode dom_code) {
  bool is_target_key = false;
  if (altgr_active_ && dom_code == ui::DomCode::ALT_RIGHT) {
    // Must check dom_code before key_code for alt, as
    // alt right has the same key_code as alt, but different
    // dom_code.
    is_target_key = (modifier_flag_ == ui::EF_ALTGR_DOWN);
  } else if (key_code == ui::VKEY_SHIFT || key_code == ui::VKEY_LSHIFT ||
             key_code == ui::VKEY_RSHIFT) {
    is_target_key = (modifier_flag_ == ui::EF_SHIFT_DOWN);
  } else if (key_code == ui::VKEY_CONTROL || key_code == ui::VKEY_LCONTROL ||
             key_code == ui::VKEY_RCONTROL) {
    is_target_key = (modifier_flag_ == ui::EF_CONTROL_DOWN);
  } else if (key_code == ui::VKEY_MENU || key_code == ui::VKEY_LMENU ||
             key_code == ui::VKEY_RMENU) {
    is_target_key = (modifier_flag_ == ui::EF_ALT_DOWN);
  } else if (altgr_active_ && key_code == ui::VKEY_ALTGR) {
    is_target_key = (modifier_flag_ == ui::EF_ALTGR_DOWN);
  } else if (key_code == ui::VKEY_OEM_8) {
    is_target_key = (modifier_flag_ == ui::EF_MOD3_DOWN);
  } else if (key_code == ui::VKEY_LWIN || key_code == ui::VKEY_RWIN) {
    is_target_key = (modifier_flag_ == ui::EF_COMMAND_DOWN);
  } else if (key_code == ui::VKEY_FUNCTION) {
    is_target_key = (modifier_flag_ == ui::EF_FUNCTION_DOWN);
  } else {
    return type == ui::EventType::kKeyPressed ? NORMAL_KEY_DOWN : NORMAL_KEY_UP;
  }

  if (is_target_key) {
    return type == ui::EventType::kKeyPressed ? TARGET_MODIFIER_DOWN
                                              : TARGET_MODIFIER_UP;
  }
  return type == ui::EventType::kKeyPressed ? OTHER_MODIFIER_DOWN
                                            : OTHER_MODIFIER_UP;
}

bool StickyKeysHandler::HandleDisabledState(const ui::KeyEvent& event) {
  switch (TranslateKeyEvent(event.type(), event.key_code(), event.code())) {
    case TARGET_MODIFIER_UP:
      if (preparing_to_enable_) {
        preparing_to_enable_ = false;
        scroll_delta_ = 0;
        current_state_ = STICKY_KEY_STATE_ENABLED;
        modifier_up_event_ = std::make_unique<ui::KeyEvent>(event);
        return true;
      }
      return false;
    case TARGET_MODIFIER_DOWN:
      preparing_to_enable_ = true;
      return false;
    case NORMAL_KEY_DOWN:
      preparing_to_enable_ = false;
      return false;
    case NORMAL_KEY_UP:
    case OTHER_MODIFIER_DOWN:
    case OTHER_MODIFIER_UP:
      return false;
  }
  NOTREACHED();
}

bool StickyKeysHandler::HandleEnabledState(const ui::KeyEvent& event,
                                           int* mod_down_flags,
                                           bool* released) {
  switch (TranslateKeyEvent(event.type(), event.key_code(), event.code())) {
    case NORMAL_KEY_UP:
    case TARGET_MODIFIER_DOWN:
      return false;
    case TARGET_MODIFIER_UP:
      current_state_ = STICKY_KEY_STATE_LOCKED;
      modifier_up_event_.reset();
      return true;
    case NORMAL_KEY_DOWN: {
      current_state_ = STICKY_KEY_STATE_DISABLED;
      *mod_down_flags |= modifier_flag_;
      *released = true;
      return false;
    }
    case OTHER_MODIFIER_DOWN:
    case OTHER_MODIFIER_UP:
      return false;
  }
  NOTREACHED();
}

bool StickyKeysHandler::HandleLockedState(const ui::KeyEvent& event,
                                          int* mod_down_flags,
                                          bool* released) {
  switch (TranslateKeyEvent(event.type(), event.key_code(), event.code())) {
    case TARGET_MODIFIER_DOWN:
      return true;
    case TARGET_MODIFIER_UP:
      current_state_ = STICKY_KEY_STATE_DISABLED;
      return false;
    case NORMAL_KEY_DOWN:
    case NORMAL_KEY_UP:
      *mod_down_flags |= modifier_flag_;
      return false;
    case OTHER_MODIFIER_DOWN:
    case OTHER_MODIFIER_UP:
      return false;
  }
  NOTREACHED();
}

}  // namespace ash