// Copyright 2010-2014, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#ifndef MOZC_WIN32_IME_IME_KEYBOARD_
#define MOZC_WIN32_IME_IME_KEYBOARD_

#include <windows.h>

#include <vector>

#include "base/port.h"

namespace mozc {
namespace win32 {
class KeyboardStatus {
 public:
  KeyboardStatus();
  explicit KeyboardStatus(const BYTE key_status[256]);
  BYTE GetState(int virtual_key) const;
  void SetState(int virtual_key, BYTE value);
  bool IsToggled(int virtual_key) const;
  bool IsPressed(int virtual_key) const;
  const BYTE *status() const;
  BYTE *mutable_status();
  size_t status_size() const;
 private:
  BYTE status_[256];
};

class LParamKeyInfo {
 public:
  LParamKeyInfo();
  explicit LParamKeyInfo(LPARAM lparam);
  int GetKeyRepeatCount() const;
  BYTE GetScanCode() const;
  bool IsExtendedKey() const;
  bool HasContextCode() const;
  bool IsPreviousStateDwon() const;
  bool IsInTansitionState() const;
  // In ImeProcessKey callback, the highest bit represents if this is key-down
  // event or not.  You should not use this value in other situations including
  // WM_KEYDOWN/WM_KEYUP event handler.
  // Returns true if this is key-down event assuming this is the LPARAM passed
  // to ImeProcessKey callback.
  bool IsKeyDownInImeProcessKey() const;
  LPARAM lparam() const;
 private:
  LPARAM lparam_;
};

class VirtualKey {
 public:
  VirtualKey();

  // Construct an instance from a given |virtual_key|.
  // You cannot specify VK_PACKET for |virtual_key|.
  static VirtualKey FromVirtualKey(BYTE virtual_key);
  // Construct an instance from a given |combined_virtual_key|.
  // If the low word of |combined_virtual_key| is VK_PACKET,
  // the high word will be used as |wide_char_|.
  // Otherwise, the lowest byte of |combined_virtual_key| will be
  // used as |virtual_key_|.
  static VirtualKey FromCombinedVirtualKey(UINT combined_virtual_key);
  // Construct an instance from a given ucs4 character.
  // In this case, |virtual_key_| will be set to VK_PACKET.
  static VirtualKey FromUnicode(char32 unicode);

  wchar_t wide_char() const;
  char32 unicode_char() const;
  BYTE virtual_key() const;

 private:
  VirtualKey(BYTE virtual_key, wchar_t wide_char, char32 unicode_char);
  char32 unicode_char_;
  wchar_t wide_char_;
  BYTE virtual_key_;
};

// We intentionally wrap some APIs as virthal methods so that unit tests can
// inject their own mock into the key handler.  You can implement each method
// as a redirector to the corresponding API for production, or implement it as
// a mock which emulates the API predictably for unit tests.
class Win32KeyboardInterface {
 public:
  virtual ~Win32KeyboardInterface() {}

  // Injection point for keyboard_state.IsPressed(VK_KANA).
  virtual bool IsKanaLocked(const KeyboardStatus &keyboard_state) = 0;

  // Injection point for SetKeyboardState API.
  virtual bool SetKeyboardState(const KeyboardStatus &keyboard_state) = 0;

  // Injection point for GetKeyboardState API.
  virtual bool GetKeyboardState(KeyboardStatus *keyboard_state) = 0;

  // Injection point for GetAsyncKeyState API.
  virtual bool AsyncIsKeyPressed(int virtual_key) = 0;

  // Injection point for ToUnicode API.
  virtual int ToUnicode(
    __in UINT wVirtKey,
    __in UINT wScanCode,
    __in_bcount_opt(256) CONST BYTE *lpKeyState,
    __out_ecount(cchBuff) LPWSTR pwszBuff,
    __in int cchBuff,
    __in UINT wFlags) = 0;

  // Injection point for SendInput API.
  virtual UINT SendInput(const vector<INPUT> &inputs) = 0;

  static Win32KeyboardInterface *CreateDefault();
};

class JapaneseKeyboardLayoutEmulator {
 public:
  // This methods emulates ToUnicode API as if the current keyboard layout was
  // Japanese keyboard.  Currently this emulation ignores |scan_code|.
  static int ToUnicode(
    __in UINT virtual_key,
    __in UINT scan_code,
    __in_bcount_opt(256) CONST BYTE *key_state,
    __out_ecount(character_buffer_size) LPWSTR character_buffer,
    __in int character_buffer_size,
    __in UINT flags);

  // Returns generated character for Japanese keyboard layout based on the
  // given keyboard state.  Returns '\0' if no character is generated.
  // Note that built-in Japanese keyboard layout generates at most 1 character
  // for any key combination, and there is no key to generate '\0', as far as
  // we have observed with the built-in layout on Windows Vista.
  static wchar_t GetCharacterForKeyDown(
    BYTE virtual_key,
    const BYTE keyboard_state[256],
    bool is_menu_active);
 private:
  DISALLOW_COPY_AND_ASSIGN(JapaneseKeyboardLayoutEmulator);
};
}  // namespace win32
}  // namespace mozc
#endif  // MOZC_WIN32_IME_IME_KEYBOARD_