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

#include <assert.h>
#include <iostream>
#include <memory>
#include <string>

#include "keyboard_manager_win32.h"

#include "keyboard_win32_common.h"

namespace flutter {

namespace {

// The maximum number of pending events to keep before
// emitting a warning on the console about unhandled events.
static constexpr int kMaxPendingEvents = 1000;

// Returns true if this key is an AltRight key down event.
//
// This is used to resolve an issue where an AltGr press causes CtrlLeft to hang
// when pressed, as reported in https://github.com/flutter/flutter/issues/78005.
//
// When AltGr is pressed (in a supporting layout such as Spanish), Win32 first
// fires a fake CtrlLeft down event, then an AltRight down event.
// This is significant because this fake CtrlLeft down event will not be paired
// with a up event, which is fine until Flutter redispatches the CtrlDown
// event, which Win32 then interprets as a real event, leaving both Win32 and
// the Flutter framework thinking that CtrlLeft is still pressed.
//
// To resolve this, Flutter recognizes this fake CtrlLeft down event using the
// following AltRight down event. Flutter then synthesizes a CtrlLeft key up
// event immediately after the corresponding AltRight key up event.
//
// One catch is that it is impossible to distinguish the fake CtrlLeft down
// from a normal CtrlLeft down (followed by a AltRight down), since they
// contain the exactly same information, including the GetKeyState result.
// Fortunately, this will require the two events to occur *really* close, which
// would be rare, and a misrecognition would only cause a minor consequence
// where the CtrlLeft is released early; the later, real, CtrlLeft up event will
// be ignored.
static bool IsKeyDownAltRight(int action, int virtual_key, bool extended) {
#ifdef WINUWP
  return false;
#else
  return virtual_key == VK_RMENU && extended &&
         (action == WM_KEYDOWN || action == WM_SYSKEYDOWN);
#endif
}

// Returns true if this key is a key up event of AltRight.
//
// This is used to assist a corner case described in |IsKeyDownAltRight|.
static bool IsKeyUpAltRight(int action, int virtual_key, bool extended) {
#ifdef WINUWP
  return false;
#else
  return virtual_key == VK_RMENU && extended &&
         (action == WM_KEYUP || action == WM_SYSKEYUP);
#endif
}

// Returns true if this key is a key down event of CtrlLeft.
//
// This is used to assist a corner case described in |IsKeyDownAltRight|.
static bool IsKeyDownCtrlLeft(int action, int virtual_key) {
#ifdef WINUWP
  return false;
#else
  return virtual_key == VK_LCONTROL &&
         (action == WM_KEYDOWN || action == WM_SYSKEYDOWN);
#endif
}

// Returns true if this key is a key down event of ShiftRight.
//
// This is a temporary solution to
// https://github.com/flutter/flutter/issues/81674, and forces ShiftRight
// KeyDown events to not be redispatched regardless of the framework's response.
//
// If a ShiftRight KeyDown event is not handled by the framework and is
// redispatched, Win32 will not send its following KeyUp event and keeps
// recording ShiftRight as being pressed.
static bool IsKeyDownShiftRight(int virtual_key, bool was_down) {
#ifdef WINUWP
  return false;
#else
  return virtual_key == VK_RSHIFT && !was_down;
#endif
}

// Returns if a character sent by Win32 is a dead key.
static bool IsDeadKey(uint32_t ch) {
  return (ch & kDeadKeyCharMask) != 0;
}

static char32_t CodePointFromSurrogatePair(wchar_t high, wchar_t low) {
  return 0x10000 + ((static_cast<char32_t>(high) & 0x000003FF) << 10) +
         (low & 0x3FF);
}

static uint16_t ResolveKeyCode(uint16_t original,
                               bool extended,
                               uint8_t scancode) {
  switch (original) {
    case VK_SHIFT:
    case VK_LSHIFT:
      return MapVirtualKey(scancode, MAPVK_VSC_TO_VK_EX);
    case VK_MENU:
    case VK_LMENU:
      return extended ? VK_RMENU : VK_LMENU;
    case VK_CONTROL:
    case VK_LCONTROL:
      return extended ? VK_RCONTROL : VK_LCONTROL;
    default:
      return original;
  }
}

static bool IsPrintable(uint32_t c) {
  constexpr char32_t kMinPrintable = ' ';
  constexpr char32_t kDelete = 0x7F;
  return c >= kMinPrintable && c != kDelete;
}

}  // namespace

KeyboardManagerWin32::KeyboardManagerWin32(WindowDelegate* delegate)
    : window_delegate_(delegate),
      last_key_is_ctrl_left_down(false),
      should_synthesize_ctrl_left_up(false) {}

void KeyboardManagerWin32::RedispatchEvent(
    std::unique_ptr<PendingEvent> event) {
  for (const Win32Message& message : event->session) {
    pending_redispatches_.push_back(message);
    UINT result = window_delegate_->Win32DispatchMessage(
        message.action, message.wparam, message.lparam);
    if (result != 0) {
      std::cerr << "Unable to synthesize event for keyboard event."
                << std::endl;
    }
  }
  if (pending_redispatches_.size() > kMaxPendingEvents) {
    std::cerr
        << "There are " << pending_redispatches_.size()
        << " keyboard events that have not yet received a response from the "
        << "framework. Are responses being sent?" << std::endl;
  }
}

bool KeyboardManagerWin32::RemoveRedispatchedMessage(UINT const action,
                                                     WPARAM const wparam,
                                                     LPARAM const lparam) {
  for (auto iter = pending_redispatches_.begin();
       iter != pending_redispatches_.end(); ++iter) {
    if (action == iter->action && wparam == iter->wparam) {
      pending_redispatches_.erase(iter);
      return true;
    }
  }
  return false;
}

void KeyboardManagerWin32::OnKey(std::unique_ptr<PendingEvent> event,
                                 OnKeyCallback callback) {
  if (IsKeyDownAltRight(event->action, event->key, event->extended)) {
    if (last_key_is_ctrl_left_down) {
      should_synthesize_ctrl_left_up = true;
    }
  }
  if (IsKeyDownCtrlLeft(event->action, event->key)) {
    last_key_is_ctrl_left_down = true;
    ctrl_left_scancode = event->scancode;
    should_synthesize_ctrl_left_up = false;
  } else {
    last_key_is_ctrl_left_down = false;
  }
  if (IsKeyUpAltRight(event->action, event->key, event->extended)) {
    if (should_synthesize_ctrl_left_up) {
      should_synthesize_ctrl_left_up = false;
      const LPARAM lParam =
          (1 /* repeat_count */ << 0) | (ctrl_left_scancode << 16) |
          (0 /* extended */ << 24) | (1 /* prev_state */ << 30) |
          (1 /* transition */ << 31);
      window_delegate_->Win32DispatchMessage(WM_KEYUP, VK_LCONTROL, lParam);
    }
  }

  const PendingEvent clone = *event;
  window_delegate_->OnKey(clone.key, clone.scancode, clone.action,
                          clone.character, clone.extended, clone.was_down,
                          [this, event = event.release(),
                           callback = std::move(callback)](bool handled) {
                            callback(std::unique_ptr<PendingEvent>(event),
                                     handled);
                          });
}

void KeyboardManagerWin32::DispatchReadyTexts() {
  auto front = pending_texts_.begin();
  for (; front != pending_texts_.end() && front->ready; ++front) {
    window_delegate_->OnText(front->content);
  }
  pending_texts_.erase(pending_texts_.begin(), front);
}

void KeyboardManagerWin32::HandleOnKeyResult(
    std::unique_ptr<PendingEvent> event,
    bool handled,
    std::list<PendingText>::iterator pending_text) {
  // First, patch |handled|, because some key events must always be treated as
  // handled.
  //
  // Redispatching dead keys events makes Win32 ignore the dead key state
  // and redispatches a normal character without combining it with the
  // next letter key.
  //
  // Redispatching sys events is impossible due to the limitation of
  // |SendInput|.
  const bool is_syskey =
      event->action == WM_SYSKEYDOWN || event->action == WM_SYSKEYUP;
  const bool real_handled = handled || IsDeadKey(event->character) ||
                            is_syskey ||
                            IsKeyDownShiftRight(event->key, event->was_down);

  // For handled events, that's all.
  if (real_handled) {
    if (pending_text != pending_texts_.end()) {
      pending_texts_.erase(pending_text);
    }
    return;
  }

  // For unhandled events, dispatch them to OnText.

  if (pending_text != pending_texts_.end()) {
    pending_text->ready = true;
    DispatchReadyTexts();
  }

  RedispatchEvent(std::move(event));
}

bool KeyboardManagerWin32::HandleMessage(UINT const action,
                                         WPARAM const wparam,
                                         LPARAM const lparam) {
  if (RemoveRedispatchedMessage(action, wparam, lparam)) {
    return false;
  }
  switch (action) {
    case WM_DEADCHAR:
    case WM_SYSDEADCHAR:
    case WM_CHAR:
    case WM_SYSCHAR: {
      const Win32Message message =
          Win32Message{.action = action, .wparam = wparam, .lparam = lparam};
      current_session_.push_back(message);

      std::u16string text;
      char32_t code_point;
      if (message.IsHighSurrogate()) {
        // A high surrogate is always followed by a low surrogate.  Process the
        // session later and consider this message as handled.
        return true;
      } else if (message.IsLowSurrogate()) {
        const Win32Message* last_message =
            current_session_.size() <= 1
                ? nullptr
                : &current_session_[current_session_.size() - 2];
        if (last_message == nullptr || !last_message->IsHighSurrogate()) {
          return false;
        }
        // A low surrogate always follows a high surrogate, marking the end of
        // a char session. Process the session after the if clause.
        text.push_back(static_cast<wchar_t>(last_message->wparam));
        text.push_back(static_cast<wchar_t>(message.wparam));
        code_point =
            CodePointFromSurrogatePair(last_message->wparam, message.wparam);
      } else {
        // A non-surrogate character always appears alone. Process the session
        // after the if clause.
        text.push_back(static_cast<wchar_t>(message.wparam));
        code_point = static_cast<wchar_t>(message.wparam);
      }

      // If this char message is preceded by a key down message, then dispatch
      // the key down message as a key down event first, and only dispatch the
      // OnText if the key down event is not handled.
      if (current_session_.front().IsGeneralKeyDown()) {
        const Win32Message first_message = current_session_.front();
        const uint8_t scancode = (lparam >> 16) & 0xff;
        const uint16_t key_code = first_message.wparam;
        const bool extended = ((lparam >> 24) & 0x01) == 0x01;
        const bool was_down = lparam & 0x40000000;
        // Certain key combinations yield control characters as WM_CHAR's
        // lParam. For example, 0x01 for Ctrl-A. Filter these characters. See
        // https://docs.microsoft.com/en-us/windows/win32/learnwin32/accelerator-tables
        char32_t character;
        if (action == WM_DEADCHAR || action == WM_SYSDEADCHAR) {
          // Mask the resulting char with kDeadKeyCharMask anyway, because in
          // rare cases the bit is *not* set (US INTL Shift-6 circumflex, see
          // https://github.com/flutter/flutter/issues/92654 .)
          character =
              window_delegate_->Win32MapVkToChar(key_code) | kDeadKeyCharMask;
        } else {
          character = IsPrintable(code_point) ? code_point : 0;
        }
        auto event = std::make_unique<PendingEvent>(PendingEvent{
            .key = key_code,
            .scancode = scancode,
            .action = static_cast<UINT>(action == WM_SYSCHAR ? WM_SYSKEYDOWN
                                                             : WM_KEYDOWN),
            .character = character,
            .extended = extended,
            .was_down = was_down,
            .session = std::move(current_session_),
        });
        // Compute the text that might be dispatched later.
        //
        // Of the messages handled here, only WM_CHAR should be treated as
        // characters. WM_SYS*CHAR are not part of text input, and WM_DEADCHAR
        // will be incorporated into a later WM_CHAR with the full character.
        //
        // Checking `character` filters out non-printable event characters.
        std::list<PendingText>::iterator pending_text;
        if (action == WM_CHAR && character != 0) {
          pending_texts_.push_back(PendingText{
              .ready = false,
              .content = text,
          });
          pending_text = std::prev(pending_texts_.end());
        } else {
          pending_text = pending_texts_.end();
        }
        // SYS messages must not be handled by `HandleMessage` or be
        // redispatched.
        const bool is_syskey = action == WM_SYSCHAR || action == WM_SYSDEADCHAR;
        OnKey(std::move(event),
              [this, pending_text, is_syskey](
                  std::unique_ptr<PendingEvent> event, bool handled) {
                bool real_handled = handled || is_syskey;
                HandleOnKeyResult(std::move(event), handled, pending_text);
              });
        return !is_syskey;
      }

      // If the charcter session is not preceded by a key down message, dispatch
      // the OnText immediately.

      // Only WM_CHAR should be treated as characters. WM_SYS*CHAR are not part
      // of text input, and WM_DEADCHAR will be incorporated into a later
      // WM_CHAR with the full character.
      //
      // Also filter out ASCII control characters, which are sent as WM_CHAR
      // events for all control key shortcuts.
      current_session_.clear();
      if (action == WM_CHAR && IsPrintable(wparam)) {
        pending_texts_.push_back(PendingText{
            .ready = true,
            .content = text,
        });
        DispatchReadyTexts();
      }
      return true;
    }

    case WM_KEYDOWN:
    case WM_SYSKEYDOWN:
    case WM_KEYUP:
    case WM_SYSKEYUP: {
      current_session_.clear();
      current_session_.push_back(
          Win32Message{.action = action, .wparam = wparam, .lparam = lparam});
      const bool is_keydown_message =
          (action == WM_KEYDOWN || action == WM_SYSKEYDOWN);
      // Check if this key produces a character. If so, the key press should
      // be sent with the character produced at WM_CHAR. Store the produced
      // keycode (it's not accessible from WM_CHAR) to be used in WM_CHAR.
      //
      // Messages with Control or Win modifiers down are never considered as
      // character messages. This allows key combinations such as "CTRL + Digit"
      // to properly produce key down events even though `MapVirtualKey` returns
      // a valid character. See https://github.com/flutter/flutter/issues/85587.
      unsigned int character = window_delegate_->Win32MapVkToChar(wparam);
      UINT next_key_message = PeekNextMessageType(WM_KEYFIRST, WM_KEYLAST);
      bool has_wm_char =
          (next_key_message == WM_DEADCHAR ||
           next_key_message == WM_SYSDEADCHAR || next_key_message == WM_CHAR ||
           next_key_message == WM_SYSCHAR);
      if (character > 0 && is_keydown_message && has_wm_char) {
        // This key down message has following char events. Process later,
        // because the character for the OnKey should be decided by the char
        // events. Consider this event as handled.
        return true;
      }

      // Resolve session: A non-char key event.
      const uint8_t scancode = (lparam >> 16) & 0xff;
      const bool extended = ((lparam >> 24) & 0x01) == 0x01;
      // If the key is a modifier, get its side.
      const uint16_t key_code = ResolveKeyCode(wparam, extended, scancode);
      const bool was_down = lparam & 0x40000000;
      auto event = std::make_unique<PendingEvent>(PendingEvent{
          .key = key_code,
          .scancode = scancode,
          .action = action,
          .character = 0,
          .extended = extended,
          .was_down = was_down,
          .session = std::move(current_session_),
      });
      // SYS messages must not be handled by `HandleMessage` or be
      // redispatched.
      const bool is_syskey = action == WM_SYSKEYDOWN || action == WM_SYSKEYUP;
      OnKey(
          std::move(event),
          [this, is_syskey](std::unique_ptr<PendingEvent> event, bool handled) {
            bool real_handled = handled || is_syskey;
            HandleOnKeyResult(std::move(event), handled, pending_texts_.end());
          });
      return !is_syskey;
    }
    default:
      assert(false);
  }
  return false;
}

UINT KeyboardManagerWin32::PeekNextMessageType(UINT wMsgFilterMin,
                                               UINT wMsgFilterMax) {
  MSG next_message;
  BOOL has_msg = window_delegate_->Win32PeekMessage(
      &next_message, wMsgFilterMin, wMsgFilterMax, PM_NOREMOVE);
  if (!has_msg) {
    return 0;
  }
  return next_message.message;
}

uint64_t KeyboardManagerWin32::ComputeEventHash(const PendingEvent& event) {
  // Calculate a key event ID based on the scan code of the key pressed,
  // and the flags we care about.
  return event.scancode | (((event.action == WM_KEYUP ? KEYEVENTF_KEYUP : 0x0) |
                            (event.extended ? KEYEVENTF_EXTENDEDKEY : 0x0))
                           << 16);
}

}  // namespace flutter