// 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.

package org.mozc.android.inputmethod.japanese.hardwarekeyboard;

import org.mozc.android.inputmethod.japanese.KeycodeConverter.KeyEventInterface;
import org.mozc.android.inputmethod.japanese.MozcLog;
import org.mozc.android.inputmethod.japanese.hardwarekeyboard.HardwareKeyboard.CompositionSwitchMode;
import org.mozc.android.inputmethod.japanese.hardwarekeyboard.KeyEventMapperFactory.KeyEventMapper;
import org.mozc.android.inputmethod.japanese.keyboard.Keyboard.KeyboardSpecification;
import org.mozc.android.inputmethod.japanese.preference.ClientSidePreference.HardwareKeyMap;
import org.mozc.android.inputmethod.japanese.preference.PreferenceUtil;
import org.mozc.android.inputmethod.japanese.protobuf.ProtoCommands;
import org.mozc.android.inputmethod.japanese.protobuf.ProtoCommands.KeyEvent.ModifierKey;
import org.mozc.android.inputmethod.japanese.protobuf.ProtoCommands.KeyEvent.SpecialKey;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;

import android.annotation.SuppressLint;
import android.content.SharedPreferences;
import android.content.res.Configuration;
import android.view.KeyEvent;

import java.util.Collections;
import java.util.EnumMap;
import java.util.Map;

import javax.annotation.Nullable;

/**
 * Converts Hardware KeyEvent to Mozc's KeyEvent
 *
 * Android OS's keyboard management is like following;
 * <ol>
 * <li>Android OS receives LKC (Linux Key Code, ≒ scan code) from the keyboard.
 * <li>Android OS converts LKC into AKC (Android Key Code) using key layout file (.kl).
 * A user/developer cannot override this behavior.
 * <li>Android OS converts AKC into a tuple of (AKC, unicode character)
 * using key character mapping file (.kcm).
 * <ul>
 * <li>Given AKC might be converted into another AKC (e.g. KEYCODE_GRAVE might be converted
 * into KEYCODE_ZENKAKU_HANKAKU).
 * <li>Since API Level 16 a user/developer has been able to override the behavior.
 * </ul>
 * </ol>
 * To use Japanese keyboard, the default behavior is not sufficient.
 * <ul>
 * <li>Even the latest OS (API Level 19) Japanese key character mapping is not shipped by default.
 * <li>There are Japanese unique AKC (e.g. KEYCODE_ZENKAKU_HANKAKU) but they are available
 * since API Level 16. (Note since API Level 16 some Japanese unique ones (e.g. KEYCODE_RO)
 * can be sent though Japanese KCM is not supported)
 * </ul>
 * The main responsibility of this class is to convert android's KeyEvent into Mozc's KeyEvent.
 * To do this above behavior must be respected. CompactKeyEvent (and its internal KeyEventMapper)
 * does this.
 *
 */
public enum HardwareKeyboardSpecification {

  /**
   * System key map.
   */
  DEFAULT(HardwareKeyMap.DEFAULT,
          KeyEventMapperFactory.DEFAULT_KEYBOARD_MAPPER,
          KeyboardSpecification.HARDWARE_QWERTY_KANA,
          KeyboardSpecification.HARDWARE_QWERTY_ALPHABET),

  /**
   * Represents Japanese 109 Keyboard
   */
  JAPANESE109A(HardwareKeyMap.JAPANESE109A,
               KeyEventMapperFactory.JAPANESE_KEYBOARD_MAPPER,
               KeyboardSpecification.HARDWARE_QWERTY_KANA,
               KeyboardSpecification.HARDWARE_QWERTY_ALPHABET);

  /**
   * Returns true if the given {@code codepoint} is printable.
   *
   * {@link KeyEvent#isPrintingKey()} cannot be used for this purpose as
   * the method doesn't take codepoint but keycode.
   */
  @VisibleForTesting
  static boolean isPrintable(int codepoint) {
    Preconditions.checkArgument(codepoint >= 0);
    if (Character.isISOControl(codepoint)) {
      return false;
    }
    Character.UnicodeBlock block = Character.UnicodeBlock.of(codepoint);
    return block != null &&
           block != Character.UnicodeBlock.SPECIALS;
  }

  /**
   * Returns true if composition mode should be changed.
   */
  @SuppressLint("InlinedApi")
  private static boolean isKeyForCompositinoModeChange(int keyCode, int metaState) {
    boolean shift = (metaState & KeyEvent.META_SHIFT_MASK) != 0;
    boolean alt = (metaState & KeyEvent.META_ALT_MASK) != 0;
    boolean ctrl = (metaState & KeyEvent.META_CTRL_MASK) != 0;
    boolean meta = (metaState & KeyEvent.META_META_MASK) != 0;
    // ZEN/HAN with no modifier.
    if (keyCode == KeyEvent.KEYCODE_ZENKAKU_HANKAKU && !shift && !alt && !ctrl && !meta) {
      return true;
    }
    // GRAVE with ALT.
    if (keyCode == KeyEvent.KEYCODE_GRAVE && !shift && alt && !ctrl && !meta) {
      return true;
    }
    return false;
  }

  private final HardwareKeyMap hardwareKeyMap;

  private final KeyboardSpecification kanaKeyboardSpecification;

  private final KeyboardSpecification alphabetKeyboardSpecification;

  private final KeyEventMapper keyEventMapper;

  private static final Map<HardwareKeyMap, HardwareKeyboardSpecification>
      hardwareKeyMapToSpecificationMap;

  static {
    // Initialize preference name to HardwareKeyboardSpecification mapping.
    Map<HardwareKeyMap, HardwareKeyboardSpecification> tmpMap =
        new EnumMap<HardwareKeyMap, HardwareKeyboardSpecification>(HardwareKeyMap.class);
    for (HardwareKeyboardSpecification hardwareKeyboardSpecification :
        HardwareKeyboardSpecification.values()) {
      tmpMap.put(hardwareKeyboardSpecification.hardwareKeyMap, hardwareKeyboardSpecification);
    }
    hardwareKeyMapToSpecificationMap = Collections.unmodifiableMap(tmpMap);
  }

  private HardwareKeyboardSpecification(
      HardwareKeyMap hardwareKeyMap,
      KeyEventMapper keyEventMapper,
      KeyboardSpecification kanaKeyboardSpecification,
      KeyboardSpecification alphabetKeyboardSpecification) {
    this.hardwareKeyMap = hardwareKeyMap;
    this.keyEventMapper = keyEventMapper;
    this.kanaKeyboardSpecification = kanaKeyboardSpecification;
    this.alphabetKeyboardSpecification = alphabetKeyboardSpecification;
  }

  /**
   * Returns HardwareKeyboadSpecification based on given preference.
   */
  static Optional<HardwareKeyboardSpecification> getHardwareKeyboardSpecification(
     Optional<HardwareKeyMap> hardwareKeyMap) {
    return hardwareKeyMap.isPresent()
        ? Optional.of(hardwareKeyMapToSpecificationMap.get(hardwareKeyMap.get()))
        : Optional.<HardwareKeyboardSpecification>absent();
  }

  /**
   * Detects hardware keyboard type and sets it to the given {@code sharedPreferences}.
   * If the {@code sharedPreferences} is {@code null}, or already has valid hardware keyboard type,
   * just does nothing.
   *
   * Note: if the new detected hardware keyboard type is set to the {@code sharedPreferences}
   * and if it has registered callbacks, of course, they will be invoked as usual.
   */
  public static void maybeSetDetectedHardwareKeyMap(
      @Nullable SharedPreferences sharedPreferences, Configuration configuration,
      boolean forceToSet) {
    Preconditions.checkNotNull(configuration);
    if (sharedPreferences == null) {
      return;
    }

    // First, check if the hardware keyboard type has already set to the preference.
    if (getHardwareKeyMap(sharedPreferences) != null) {
      // Found the valid value.
      return;
    }

    // Here, the HardwareKeyMap hasn't set yet, so detect hardware keyboard type.
    HardwareKeyMap detectedKeyMap = null;
    switch(configuration.keyboard) {
      case Configuration.KEYBOARD_12KEY:
      case Configuration.KEYBOARD_QWERTY:
        detectedKeyMap = HardwareKeyMap.DEFAULT;
        break;
      case Configuration.KEYBOARD_NOKEYS:
      case Configuration.KEYBOARD_UNDEFINED:
      default:
        break;
    }

    if (detectedKeyMap != null) {
      setHardwareKeyMap(sharedPreferences, detectedKeyMap);
    } else if (forceToSet) {
      setHardwareKeyMap(sharedPreferences, HardwareKeyMap.DEFAULT);
    }

    MozcLog.i("RUN HARDWARE KEYBOARD DETECTION: " + detectedKeyMap);
  }

  /**
   * Returns currently set key map based on the default SharedPreferences.
   *
   * @param sharedPreferences a SharedPreference to be retrieved
   * @return null if no preference has not been set
   */
  public static HardwareKeyMap getHardwareKeyMap(SharedPreferences sharedPreferences) {
    String prefHardwareKeyMap =
        Preconditions.checkNotNull(sharedPreferences)
            .getString(PreferenceUtil.PREF_HARDWARE_KEYMAP, null);
    if (prefHardwareKeyMap != null) {
      try {
        return HardwareKeyMap.valueOf(prefHardwareKeyMap);
      } catch (IllegalArgumentException e) {
        return null;
      }
    }
    return null;
  }

  @VisibleForTesting
  static void setHardwareKeyMap(
      SharedPreferences sharedPreference, HardwareKeyMap hardwareKeyMap) {
    Preconditions.checkNotNull(sharedPreference);
    Preconditions.checkNotNull(hardwareKeyMap);
    sharedPreference.edit()
         .putString(PreferenceUtil.PREF_HARDWARE_KEYMAP, hardwareKeyMap.name()).commit();
  }

  public HardwareKeyMap getHardwareKeyMap() {
    return hardwareKeyMap;
  }

  public ProtoCommands.KeyEvent getMozcKeyEvent(android.view.KeyEvent keyEvent) {
    Preconditions.checkNotNull(keyEvent);
    CompactKeyEvent compactKeyEvent = new CompactKeyEvent(keyEvent, keyEventMapper);

    // Check if the key is for changing composition mode.
    // The event should be consumed client-side so nothing should be returned.
    if (isKeyForCompositinoModeChange(compactKeyEvent.getKeyCode(),
                                      compactKeyEvent.getMetaState())) {
      return null;
    }

    int keyCode = compactKeyEvent.getKeyCode();
    ProtoCommands.KeyEvent.Builder builder = ProtoCommands.KeyEvent.newBuilder();
    // Check if the event is special key.
    // This check should be done in advance of checking unicode-character (done in default block)
    // because KEYCODE_SPACE/TAB, which are special keys, are sent with unicode-character.
    switch(keyCode) {
      case android.view.KeyEvent.KEYCODE_SPACE:
        builder.setSpecialKey(SpecialKey.SPACE);
        break;
      case android.view.KeyEvent.KEYCODE_FORWARD_DEL:
        builder.setSpecialKey(SpecialKey.DEL);
        break;
      case android.view.KeyEvent.KEYCODE_DEL:
        builder.setSpecialKey(SpecialKey.BACKSPACE);
        break;
      case android.view.KeyEvent.KEYCODE_INSERT:
        builder.setSpecialKey(SpecialKey.INSERT);
        break;
      case android.view.KeyEvent.KEYCODE_HENKAN:
        builder.setSpecialKey(SpecialKey.HENKAN);
        break;
      case android.view.KeyEvent.KEYCODE_MUHENKAN:
        builder.setSpecialKey(SpecialKey.MUHENKAN);
        break;
      case android.view.KeyEvent.KEYCODE_KANA:
        builder.setSpecialKey(SpecialKey.KANA);
        break;
      case android.view.KeyEvent.KEYCODE_KATAKANA_HIRAGANA:
        builder.setSpecialKey(SpecialKey.KATAKANA);
        break;
      case android.view.KeyEvent.KEYCODE_TAB:
        builder.setSpecialKey(SpecialKey.TAB);
        break;
      case android.view.KeyEvent.KEYCODE_ENTER:
        builder.setSpecialKey(SpecialKey.ENTER);
        break;
      case android.view.KeyEvent.KEYCODE_DPAD_LEFT:
        builder.setSpecialKey(SpecialKey.LEFT);
        break;
      case android.view.KeyEvent.KEYCODE_DPAD_RIGHT:
        builder.setSpecialKey(SpecialKey.RIGHT);
        break;
      case android.view.KeyEvent.KEYCODE_DPAD_UP:
        builder.setSpecialKey(SpecialKey.UP);
        break;
      case android.view.KeyEvent.KEYCODE_DPAD_DOWN:
        builder.setSpecialKey(SpecialKey.DOWN);
        break;
      case android.view.KeyEvent.KEYCODE_ESCAPE:
        builder.setSpecialKey(SpecialKey.ESCAPE);
        break;
      case android.view.KeyEvent.KEYCODE_MOVE_HOME:
        builder.setSpecialKey(SpecialKey.HOME);
        break;
      case android.view.KeyEvent.KEYCODE_MOVE_END:
        builder.setSpecialKey(SpecialKey.END);
        break;
      case android.view.KeyEvent.KEYCODE_PAGE_UP:
        builder.setSpecialKey(SpecialKey.PAGE_UP);
        break;
      case android.view.KeyEvent.KEYCODE_PAGE_DOWN:
        builder.setSpecialKey(SpecialKey.PAGE_DOWN);
        break;
      case android.view.KeyEvent.KEYCODE_NUMPAD_DIVIDE:
        builder.setSpecialKey(SpecialKey.DIVIDE);
        break;
      case android.view.KeyEvent.KEYCODE_NUMPAD_MULTIPLY:
        builder.setSpecialKey(SpecialKey.MULTIPLY);
        break;
      case android.view.KeyEvent.KEYCODE_NUMPAD_SUBTRACT:
        builder.setSpecialKey(SpecialKey.SUBTRACT);
        break;
      case android.view.KeyEvent.KEYCODE_NUMPAD_ADD:
        builder.setSpecialKey(SpecialKey.ADD);
        break;
      case android.view.KeyEvent.KEYCODE_NUMPAD_ENTER:
        builder.setSpecialKey(SpecialKey.SEPARATOR);
        break;
      case android.view.KeyEvent.KEYCODE_NUMPAD_DOT:
        builder.setSpecialKey(SpecialKey.DECIMAL);
        break;
      case android.view.KeyEvent.KEYCODE_NUMPAD_0:
        builder.setSpecialKey(SpecialKey.NUMPAD0);
        break;
      case android.view.KeyEvent.KEYCODE_NUMPAD_1:
        builder.setSpecialKey(SpecialKey.NUMPAD1);
        break;
      case android.view.KeyEvent.KEYCODE_NUMPAD_2:
        builder.setSpecialKey(SpecialKey.NUMPAD2);
        break;
      case android.view.KeyEvent.KEYCODE_NUMPAD_3:
        builder.setSpecialKey(SpecialKey.NUMPAD3);
        break;
      case android.view.KeyEvent.KEYCODE_NUMPAD_4:
        builder.setSpecialKey(SpecialKey.NUMPAD4);
        break;
      case android.view.KeyEvent.KEYCODE_NUMPAD_5:
        builder.setSpecialKey(SpecialKey.NUMPAD5);
        break;
      case android.view.KeyEvent.KEYCODE_NUMPAD_6:
        builder.setSpecialKey(SpecialKey.NUMPAD6);
        break;
      case android.view.KeyEvent.KEYCODE_NUMPAD_7:
        builder.setSpecialKey(SpecialKey.NUMPAD7);
        break;
      case android.view.KeyEvent.KEYCODE_NUMPAD_8:
        builder.setSpecialKey(SpecialKey.NUMPAD8);
        break;
      case android.view.KeyEvent.KEYCODE_NUMPAD_9:
        builder.setSpecialKey(SpecialKey.NUMPAD9);
        break;
      case android.view.KeyEvent.KEYCODE_F1:
        builder.setSpecialKey(SpecialKey.F1);
        break;
      case android.view.KeyEvent.KEYCODE_F2:
        builder.setSpecialKey(SpecialKey.F2);
        break;
      case android.view.KeyEvent.KEYCODE_F3:
        builder.setSpecialKey(SpecialKey.F3);
        break;
      case android.view.KeyEvent.KEYCODE_F4:
        builder.setSpecialKey(SpecialKey.F4);
        break;
      case android.view.KeyEvent.KEYCODE_F5:
        builder.setSpecialKey(SpecialKey.F5);
        break;
      case android.view.KeyEvent.KEYCODE_F6:
        builder.setSpecialKey(SpecialKey.F6);
        break;
      case android.view.KeyEvent.KEYCODE_F7:
        builder.setSpecialKey(SpecialKey.F7);
        break;
      case android.view.KeyEvent.KEYCODE_F8:
        builder.setSpecialKey(SpecialKey.F8);
        break;
      case android.view.KeyEvent.KEYCODE_F9:
        builder.setSpecialKey(SpecialKey.F9);
        break;
      case android.view.KeyEvent.KEYCODE_F10:
        builder.setSpecialKey(SpecialKey.F10);
        break;
      case android.view.KeyEvent.KEYCODE_F11:
        builder.setSpecialKey(SpecialKey.F11);
        break;
      case android.view.KeyEvent.KEYCODE_F12:
        builder.setSpecialKey(SpecialKey.F12);
        break;
      default: {
        // Reach here as the key code is not special one.
        // There are some cases.
        // 1. The event has unicode-character. Simple key event should be sent to the engine.
        //    Note that in this case no modifiers should be sent.
        // 2. No unicode-character.
        //   2-1. Printable character with modifier (except for shift key).
        //   2-2. Ignoreable key event.
        int unicodeChar = compactKeyEvent.getUnicodeCharacter();
        if (isPrintable(unicodeChar)) {
          // Case 1.
          return builder.setKeyCode(unicodeChar).build();
        }
        if (keyCode >= android.view.KeyEvent.KEYCODE_A
            && keyCode <= android.view.KeyEvent.KEYCODE_Z) {
          // Case 2-1.
          builder.setKeyCode(keyCode - android.view.KeyEvent.KEYCODE_A + 'a');
        } else if (keyCode >= android.view.KeyEvent.KEYCODE_0
            && keyCode <= android.view.KeyEvent.KEYCODE_9) {
          // Case 2-1.
          builder.setKeyCode(keyCode - android.view.KeyEvent.KEYCODE_0 + '0');
        } else {
          // Case 2-2.
          return null;
        }
      }
    }
    // Reach here because the key event is special one (including printable + modifier).
    int metaState = compactKeyEvent.getMetaState();
    if ((metaState & android.view.KeyEvent.META_SHIFT_MASK) != 0) {
        builder.addModifierKeys(ModifierKey.SHIFT);
    }
    if ((metaState & android.view.KeyEvent.META_ALT_MASK) != 0) {
      builder.addModifierKeys(ModifierKey.ALT);
    }
    if ((metaState & android.view.KeyEvent.META_CTRL_MASK) != 0) {
      builder.addModifierKeys(ModifierKey.CTRL);
    }
    return builder.build();
  }

  public KeyEventInterface getKeyEventInterface(final android.view.KeyEvent keyEvent) {
    Preconditions.checkNotNull(keyEvent);
    final CompactKeyEvent compactKeyEvent = new CompactKeyEvent(keyEvent, keyEventMapper);
    return new KeyEventInterface() {

      @Override
      public int getKeyCode() {
        return compactKeyEvent.getKeyCode();
      }

      @Override
      public Optional<android.view.KeyEvent> getNativeEvent() {
        return Optional.of(keyEvent);
      }
    };
  }

  public Optional<CompositionSwitchMode> getCompositionSwitchMode(
      android.view.KeyEvent keyEvent) {
    CompactKeyEvent compactKeyEvent
        = new CompactKeyEvent(Preconditions.checkNotNull(keyEvent), keyEventMapper);
    return isKeyForCompositinoModeChange(compactKeyEvent.getKeyCode(),
                                         compactKeyEvent.getMetaState())
        ? Optional.of(CompositionSwitchMode.TOGGLE)
        : Optional.<CompositionSwitchMode>absent();
  }

  public KeyboardSpecification getKanaKeyboardSpecification() {
    return kanaKeyboardSpecification;
  }

  public KeyboardSpecification getAlphabetKeyboardSpecification() {
    return alphabetKeyboardSpecification;
  }
}