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

import org.mozc.android.inputmethod.japanese.keyboard.BackgroundDrawableFactory.DrawableType;
import org.mozc.android.inputmethod.japanese.keyboard.Key.Stick;
import org.mozc.android.inputmethod.japanese.resources.R;
import com.google.common.base.Objects;
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;

import android.content.res.Resources;
import android.content.res.TypedArray;
import android.content.res.XmlResourceParser;
import android.util.DisplayMetrics;
import android.util.TypedValue;

import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.EnumSet;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 */
public class KeyboardParser {

  /** Attributes for the key dimensions. */
  private static class KeyAttributes {
    final int width;
    final int height;
    final int horizontalGap;
    final int verticalGap;
    DrawableType keyBackgroundDrawableType;

    KeyAttributes(int width, int height, int horizontalGap, int verticalGap,
                 DrawableType keyBackgroundDrawableType) {
      this.width = width;
      this.height = height;
      this.horizontalGap = horizontalGap;
      this.verticalGap = verticalGap;
      this.keyBackgroundDrawableType = keyBackgroundDrawableType;
    }
  }

  /** Attributes for the popup dimensions. */
  private static class PopUpAttributes {
    final int popUpWidth;
    final int popUpHeight;
    final int popUpXOffset;
    final int popUpYOffset;

    PopUpAttributes(int popUpWidth, int popUpHeight, int popUpXOffset, int popUpYOffset) {
      this.popUpWidth = popUpWidth;
      this.popUpHeight = popUpHeight;
      this.popUpXOffset = popUpXOffset;
      this.popUpYOffset = popUpYOffset;
    }
  }

  /*
   * Following codes are the list of attributes which a particular element can be support.
   * Note that, although it seems undocumented, the order of values in int[] attributes array
   * needs to be sorted. Considering the maintenance, we list attributes as we like,
   * sort in static block, and initialize the XXX_INDEX by binarySearch the value,
   * to keep the correct behavior regardless of editing the attr.xml file in future.
   */

  /** The attributes for a {@code <Row>} element. */
  private static final int[] ROW_ATTRIBUTES = {
    R.attr.verticalGap,
    R.attr.keyHeight,
    R.attr.rowEdgeFlags,
  };
  static {
    Arrays.sort(ROW_ATTRIBUTES);
  }
  private static final int ROW_VERTICAL_GAP_INDEX =
      Arrays.binarySearch(ROW_ATTRIBUTES, R.attr.verticalGap);
  private static final int ROW_KEY_HEIGHT_INDEX =
      Arrays.binarySearch(ROW_ATTRIBUTES, R.attr.keyHeight);
  private static final int ROW_ROW_EDGE_FLAGS_INDEX =
      Arrays.binarySearch(ROW_ATTRIBUTES, R.attr.rowEdgeFlags);

  /** Attributes for a {@code <Key>} element. */
  private static final int[] KEY_ATTRIBUTES = {
    R.attr.keyWidth,
    R.attr.keyHeight,
    R.attr.horizontalGap,
    R.attr.keyBackground,
    R.attr.keyEdgeFlags,
    R.attr.isRepeatable,
    R.attr.isModifier,
    R.attr.isSticky,
  };
  static {
    Arrays.sort(KEY_ATTRIBUTES);
  }
  private static final int KEY_KEY_WIDTH_INDEX =
      Arrays.binarySearch(KEY_ATTRIBUTES, R.attr.keyWidth);
  private static final int KEY_KEY_HEIGHT_INDEX =
      Arrays.binarySearch(KEY_ATTRIBUTES, R.attr.keyHeight);
  private static final int KEY_HORIZONTAL_GAP_INDEX =
      Arrays.binarySearch(KEY_ATTRIBUTES, R.attr.horizontalGap);
  private static final int KEY_KEY_BACKGROUND_INDEX =
      Arrays.binarySearch(KEY_ATTRIBUTES, R.attr.keyBackground);
  private static final int KEY_KEY_EDGE_FLAGS_INDEX =
      Arrays.binarySearch(KEY_ATTRIBUTES, R.attr.keyEdgeFlags);
  private static final int KEY_IS_REPEATABLE_INDEX =
      Arrays.binarySearch(KEY_ATTRIBUTES, R.attr.isRepeatable);
  private static final int KEY_IS_MODIFIER_INDEX =
      Arrays.binarySearch(KEY_ATTRIBUTES, R.attr.isModifier);
  private static final int KEY_IS_STICKY_INDEX =
      Arrays.binarySearch(KEY_ATTRIBUTES, R.attr.isSticky);

  /** Attributes for a {@code <Spacer>} element. */
  private static final int[] SPACER_ATTRIBUTES = {
    R.attr.keyHeight,
    R.attr.horizontalGap,
    R.attr.keyEdgeFlags,
    R.attr.stick,
  };
  static {
    Arrays.sort(SPACER_ATTRIBUTES);
  }
  private static final int SPACER_KEY_HEIGHT_INDEX =
      Arrays.binarySearch(SPACER_ATTRIBUTES, R.attr.keyHeight);
  private static final int SPACER_HORIZONTAL_GAP_INDEX =
      Arrays.binarySearch(SPACER_ATTRIBUTES, R.attr.horizontalGap);
  private static final int SPACER_KEY_EDGE_FLAGS_INDEX =
      Arrays.binarySearch(SPACER_ATTRIBUTES, R.attr.keyEdgeFlags);
  private static final int SPACER_STICK_INDEX =
      Arrays.binarySearch(SPACER_ATTRIBUTES, R.attr.stick);

  /** Attributes for a {@code <KeyState>} element. */
  private static final int[] KEY_STATE_ATTRIBUTES = {
    R.attr.contentDescription,
    R.attr.keyBackground,
    R.attr.metaState,
    R.attr.nextMetaState,
    R.attr.nextRemovedMetaStates,
  };
  static {
    Arrays.sort(KEY_STATE_ATTRIBUTES);
  }
  private static final int KEY_STATE_CONTENT_DESCRIPTION_INDEX =
      Arrays.binarySearch(KEY_STATE_ATTRIBUTES, R.attr.contentDescription);
  private static final int KEY_STATE_KEY_BACKGROUND_INDEX =
      Arrays.binarySearch(KEY_STATE_ATTRIBUTES, R.attr.keyBackground);
  private static final int KEY_STATE_META_STATE_INDEX =
      Arrays.binarySearch(KEY_STATE_ATTRIBUTES, R.attr.metaState);
  private static final int KEY_STATE_NEXT_META_STATE_INDEX =
      Arrays.binarySearch(KEY_STATE_ATTRIBUTES, R.attr.nextMetaState);
  private static final int KEY_STATE_NEXT_REMOVED_META_STATES_INDEX =
      Arrays.binarySearch(KEY_STATE_ATTRIBUTES, R.attr.nextRemovedMetaStates);

  /** Attributes for a {@code <KeyEntity>} element. */
  private static final int[] KEY_ENTITY_ATTRIBUTES = {
    R.attr.sourceId,
    R.attr.keyCode,
    R.attr.longPressKeyCode,
    R.attr.keyIcon,
    R.attr.keyCharacter,
    R.attr.flickHighlight,
  };
  static {
    Arrays.sort(KEY_ENTITY_ATTRIBUTES);
  }
  private static final int KEY_ENTITY_SOURCE_ID_INDEX =
      Arrays.binarySearch(KEY_ENTITY_ATTRIBUTES, R.attr.sourceId);
  private static final int KEY_ENTITY_KEY_CODE_INDEX =
      Arrays.binarySearch(KEY_ENTITY_ATTRIBUTES, R.attr.keyCode);
  private static final int KEY_ENTITY_LONG_PRESS_KEY_CODE_INDEX =
      Arrays.binarySearch(KEY_ENTITY_ATTRIBUTES, R.attr.longPressKeyCode);
  private static final int KEY_ENTITY_KEY_ICON_INDEX =
      Arrays.binarySearch(KEY_ENTITY_ATTRIBUTES, R.attr.keyIcon);
  private static final int KEY_ENTITY_KEY_CHAR_INDEX =
      Arrays.binarySearch(KEY_ENTITY_ATTRIBUTES, R.attr.keyCharacter);
  private static final int KEY_ENTITY_FLICK_HIGHLIGHT_INDEX =
      Arrays.binarySearch(KEY_ENTITY_ATTRIBUTES, R.attr.flickHighlight);

  /**
   * Mapping table from enum value in xml to DrawableType by using the enum value as index.
   */
  private static final DrawableType[] KEY_BACKGROUND_DRAWABLE_TYPE_MAP = {
    DrawableType.TWELVEKEYS_REGULAR_KEY_BACKGROUND,
    DrawableType.TWELVEKEYS_FUNCTION_KEY_BACKGROUND,
    DrawableType.TWELVEKEYS_FUNCTION_KEY_BACKGROUND_WITH_THREEDOTS,
    DrawableType.QWERTY_REGULAR_KEY_BACKGROUND,
    DrawableType.QWERTY_FUNCTION_KEY_BACKGROUND,
    DrawableType.QWERTY_FUNCTION_KEY_BACKGROUND_WITH_THREEDOTS,
    DrawableType.QWERTY_FUNCTION_KEY_LIGHT_ON_BACKGROUND,
    DrawableType.QWERTY_FUNCTION_KEY_LIGHT_OFF_BACKGROUND,
  };

  /**
   * @return "sourceId" assigned to {@code value}.
   */
  static int getSourceId(TypedValue value, @SuppressWarnings("unused") int defaultValue) {
    if (value == null ||
        (value.type != TypedValue.TYPE_INT_DEC &&
         value.type != TypedValue.TYPE_INT_HEX)) {
      throw new IllegalArgumentException("sourceId is mandatory for KeyEntity.");
    }
    return value.data;
  }

  /**
   * @return the pixel offsets based on metrics and base
   */
  static int getDimensionOrFraction(
      TypedValue value, int base, int defaultValue, DisplayMetrics metrics) {
    if (value == null) {
      return defaultValue;
    }

    switch (value.type) {
      case TypedValue.TYPE_DIMENSION:
        return TypedValue.complexToDimensionPixelOffset(value.data, metrics);
      case TypedValue.TYPE_FRACTION:
        return Math.round(TypedValue.complexToFraction(value.data, base, base));
    }

    throw new IllegalArgumentException("The type dimension or fraction is required." +
                                       "  value = " + value.toString());
  }

  /**
   * @return "codes" assigned to {@code value}
   */
  static int getCode(TypedValue value, int defaultValue) {
    if (value == null) {
      return defaultValue;
    }

    if (value.type == TypedValue.TYPE_INT_DEC ||
        value.type == TypedValue.TYPE_INT_HEX) {
      return value.data;
    }
    if (value.type == TypedValue.TYPE_STRING) {
      return Integer.parseInt(value.string.toString());
    }

    return defaultValue;
  }

  /**
   * A simple wrapper of {@link CharSequence#toString()}, in order to avoid
   * {@code NullPointerException}.
   * @param sequence input character sequence
   * @return {@code sequence.toString()} if {@code sequence} is not {@code null}.
   *         Otherwise, {@code null}.
   */
  static String toStringOrNull(CharSequence sequence) {
    if (sequence == null) {
      return null;
    }
    return sequence.toString();
  }

  private static void ignoreWhiteSpaceAndComment(XmlPullParser parser)
      throws XmlPullParserException, IOException {
    int event = parser.getEventType();
    while (event == XmlPullParser.IGNORABLE_WHITESPACE || event == XmlPullParser.COMMENT) {
      event = parser.next();
    }
  }

  private static void assertStartDocument(XmlPullParser parser) throws XmlPullParserException {
    if (parser.getEventType() != XmlPullParser.START_DOCUMENT) {
      throw new IllegalArgumentException(
          "The start of document is expected, but actually not: " +
          parser.getPositionDescription());
    }
  }

  private static void assertEndDocument(XmlPullParser parser) throws XmlPullParserException {
    if (parser.getEventType() != XmlPullParser.END_DOCUMENT) {
      throw new IllegalArgumentException(
          "The end of document is expected, but actually not: " + parser.getPositionDescription());
    }
  }

  private static void assertNotEndDocument(XmlPullParser parser) throws XmlPullParserException {
    if (parser.getEventType() == XmlPullParser.END_DOCUMENT) {
      throw new IllegalArgumentException(
          "Unexpected end of document is found: " + parser.getPositionDescription());
    }
  }

  private static void assertTagName(XmlPullParser parser, String expectedName) {
    String actualName = parser.getName();
    if (!actualName.equals(expectedName)) {
      throw new IllegalArgumentException(
          "Tag <" + expectedName + "> is expected, but found <" + actualName + ">: " +
          parser.getPositionDescription());
    }
  }

  private static void assertStartTag(XmlPullParser parser, String expectedName)
      throws XmlPullParserException {
    if (parser.getEventType() != XmlPullParser.START_TAG) {
      throw new IllegalArgumentException(
          "Start tag <" + expectedName + "> is expected: " + parser.getPositionDescription());
    }
    assertTagName(parser, expectedName);
  }

  private static void assertEndTag(XmlPullParser parser, String expectedName)
      throws XmlPullParserException {
    if (parser.getEventType() != XmlPullParser.END_TAG) {
      throw new IllegalArgumentException(
          "End tag </" + expectedName + "> is expected: " + parser.getPositionDescription());
    }
    assertTagName(parser, expectedName);
  }

  private final Resources resources;
  private final XmlResourceParser xmlResourceParser;
  private final Set<Integer> sourceIdSet = new HashSet<Integer>();
  private final int keyboardWidth;
  private final int keyboardHeight;

  public KeyboardParser(Resources resources, XmlResourceParser xmlResourceParser,
                        int keyboardWidth, int keyboardHeight) {
    if (resources == null) {
      throw new NullPointerException("resources shouldn't be null.");
    }
    if (xmlResourceParser == null) {
      throw new NullPointerException("xmlResourceParser shouldn't be null.");
    }

    this.resources = resources;
    this.xmlResourceParser = xmlResourceParser;
    this.keyboardWidth = keyboardWidth;
    this.keyboardHeight = keyboardHeight;
  }

  /**
   * Parses a XML resource and returns a Keyboard instance.
   */
  public Keyboard parseKeyboard() throws XmlPullParserException, IOException {
    // TODO(hidehiko): Refactor by spliting this method into two layers,
    //                 one is parse Keyboard element, and another is parsing a full xml file.
    XmlResourceParser parser = this.xmlResourceParser;

    // Initial two events should be START_DOCUMENT and then START_TAG.
    parser.next();
    assertStartDocument(parser);

    // The root element should be "Keyboard".
    parser.next();
    assertStartTag(parser, "Keyboard");

    // To clean the code, we probably should make a class which holds attributes of each
    // element in this method and following parseXxx methods, e.g.;
    //
    // private Attributes parseAttributes(int[] styles) {
    //   TypedArray attributes = ...
    //   try {
    //     Type1 var1 = ...;  // Read from attributes.
    //     Type2 var2 = ...;
    //     return new Attribute(var1, var2, ...);
    //   } finally {
    //     attributes.recycle();
    //   }
    // }
    //
    // However, it turned out that the code consumed the time a lot. So, considering the
    // situation, we'll use the following style in parseXxx methods in this class:
    //
    //    Type1 var1;
    //    Type2 var2;
    //    {
    //      TypedArray attributes = ...;
    //      try {
    //         // initialization of var1, var2, ...
    //      } finally {
    //        attributes.recycle();
    //      }
    //    }
    //    // Here, we can use var1 and var2 as these are initialized.
    //
    // By this code, the consumed time of parseKeyboard method is reduced by about 40%.
    // So, it should be beneficial enough.
    KeyAttributes keyAttributes;
    PopUpAttributes popUpAttributes;
    float flickThreshold;
    Optional<String> contentDescription = Optional.absent();
    {
      TypedArray attributes = resources.obtainAttributes(parser, R.styleable.Keyboard);
      try {
        DisplayMetrics metrics = resources.getDisplayMetrics();
        // The default keyWidth is 10% of the display for width, and 50px for height.
        keyAttributes = parseKeyAttributes(
            attributes,
            new KeyAttributes(keyboardWidth / 10, 50, 0, 0, null),
            metrics,
            this.keyboardWidth,
            this.keyboardHeight,
            R.styleable.Keyboard_keyWidth,
            R.styleable.Keyboard_keyHeight,
            R.styleable.Keyboard_horizontalGap,
            R.styleable.Keyboard_verticalGap,
            R.styleable.Keyboard_keyBackground);
        popUpAttributes = parsePopUpAttributes(
            attributes,
            metrics,
            this.keyboardWidth,
            R.styleable.Keyboard_popUpWidth,
            R.styleable.Keyboard_popUpHeight,
            R.styleable.Keyboard_popUpXOffset,
            R.styleable.Keyboard_popUpYOffset);
        flickThreshold = parseFlickThreshold(
            attributes, R.styleable.Keyboard_flickThreshold);
        contentDescription = Optional.fromNullable(
            attributes.getString(R.styleable.Keyboard_keyboardContentDescription));
      } finally {
        attributes.recycle();
      }
    }

    List<Row> rowList = new ArrayList<Row>();
    int y = 0;
    while (true) {
      parser.next();
      ignoreWhiteSpaceAndComment(parser);
      assertNotEndDocument(parser);
      if (parser.getEventType() == XmlResourceParser.END_TAG) {
        break;
      }
      Row row = parseRow(y, keyAttributes, popUpAttributes);
      rowList.add(row);
      y += row.getHeight() + row.getVerticalGap();
    }
    assertEndTag(parser, "Keyboard");

    // Meke sure the end of document.
    parser.next();
    ignoreWhiteSpaceAndComment(parser);
    assertEndDocument(parser);

    return buildKeyboard(contentDescription, rowList, flickThreshold);
  }

  /**
   * Parses a {@code Row} element, and returns a {@code Row} instance
   * containing a list of {@code Key}s.
   */
  private Row parseRow(
      int y, KeyAttributes defaultKeyAttributes, PopUpAttributes popUpAttributes)
      throws XmlPullParserException, IOException {
    XmlResourceParser parser = this.xmlResourceParser;
    assertStartTag(parser, "Row");

    int verticalGap;
    int rowHeight;
    int edgeFlags;
    {
      DisplayMetrics metrics = resources.getDisplayMetrics();
      TypedArray attributes = resources.obtainAttributes(parser, ROW_ATTRIBUTES);
      try {
        verticalGap = getDimensionOrFraction(
            attributes.peekValue(ROW_VERTICAL_GAP_INDEX),
            keyboardHeight, defaultKeyAttributes.verticalGap, metrics);
        rowHeight = getDimensionOrFraction(
            attributes.peekValue(ROW_KEY_HEIGHT_INDEX), keyboardHeight,
            defaultKeyAttributes.height, metrics);
        edgeFlags = attributes.getInt(ROW_ROW_EDGE_FLAGS_INDEX, 0);
      } finally {
        attributes.recycle();
      }
    }

    List<Key> keyList = new ArrayList<Key>();
    int x = 0;
    while (true) {
      parser.next();
      ignoreWhiteSpaceAndComment(parser);
      assertNotEndDocument(parser);
      if (parser.getEventType() == XmlResourceParser.END_TAG) {
        break;
      }
      if ("Key".equals(parser.getName())) {
        Key key = parseKey(x, y, edgeFlags, defaultKeyAttributes, popUpAttributes);
        keyList.add(key);
        x += key.getWidth();
      } else if ("Spacer".equals(parser.getName())) {
        Key key = parseSpacer(x, y, edgeFlags, defaultKeyAttributes);
        keyList.add(key);
        x += key.getWidth();
      }
    }

    assertEndTag(parser, "Row");
    return buildRow(keyList, rowHeight, verticalGap);
  }

  /**
   * Parses a {@code Key} element, and returns an instance.
   */
  private Key parseKey(int x, int y, int edgeFlags,
                       KeyAttributes defaultKeyAttributes, PopUpAttributes popUpAttributes)
      throws XmlPullParserException, IOException {
    XmlResourceParser parser = this.xmlResourceParser;
    assertStartTag(parser, "Key");

    KeyAttributes keyAttributes;
    boolean isRepeatable;
    boolean isModifier;
    boolean isSticky;
    {
      TypedArray attributes = resources.obtainAttributes(parser, KEY_ATTRIBUTES);
      try {
        DisplayMetrics metrics = resources.getDisplayMetrics();
        keyAttributes = parseKeyAttributes(
            attributes, defaultKeyAttributes, metrics, keyboardWidth, keyboardHeight,
            KEY_KEY_WIDTH_INDEX, KEY_KEY_HEIGHT_INDEX, KEY_HORIZONTAL_GAP_INDEX, -1,
            KEY_KEY_BACKGROUND_INDEX);
        edgeFlags |= attributes.getInt(KEY_KEY_EDGE_FLAGS_INDEX, 0);
        isRepeatable = attributes.getBoolean(KEY_IS_REPEATABLE_INDEX, false);
        isModifier = attributes.getBoolean(KEY_IS_MODIFIER_INDEX, false);
        isSticky = attributes.getBoolean(KEY_IS_STICKY_INDEX, false);
      } finally {
        attributes.recycle();
      }
    }

    List<KeyState> keyStateList = new ArrayList<KeyState>();
    while (true) {
      parser.next();
      ignoreWhiteSpaceAndComment(parser);
      assertNotEndDocument(parser);
      if (parser.getEventType() == XmlResourceParser.END_TAG) {
        break;
      }

      keyStateList.add(
          parseKeyState(keyAttributes.keyBackgroundDrawableType, popUpAttributes));
    }

    // At the moment, we just accept keys which has default state.
    boolean hasDefault = false;
    boolean hasLongPressKeyCode = false;
    for (KeyState keyState : keyStateList) {
      if (keyState.getMetaStateSet().isEmpty()) {
        hasDefault = true;
        if (keyState.getFlick(Flick.Direction.CENTER).getKeyEntity().getLongPressKeyCode() !=
            KeyEntity.INVALID_KEY_CODE) {
          hasLongPressKeyCode = true;
        }
        break;
      }
    }
    if (!hasDefault) {
      throw new IllegalArgumentException(
          "No default KeyState element is found: " + parser.getPositionDescription());
    }

    if (isRepeatable && hasLongPressKeyCode) {
      throw new IllegalArgumentException(
          "The key has both isRepeatable attribute and longPressKeyCode: " +
          parser.getPositionDescription());
    }

    assertEndTag(parser, "Key");
    return new Key(
        x, y, keyAttributes.width, keyAttributes.height, keyAttributes.horizontalGap,
        edgeFlags, isRepeatable, isModifier, isSticky, Stick.EVEN, keyStateList);
  }

  /**
   * Parses a {@code Spacer} element, and returns an instance.
   */
  private Key parseSpacer(int x, int y, int edgeFlags, KeyAttributes defaultKeyAttributes)
      throws XmlPullParserException, IOException {
    XmlResourceParser parser = this.xmlResourceParser;
    DisplayMetrics metrics = resources.getDisplayMetrics();
    assertStartTag(parser, "Spacer");

    KeyAttributes keyAttributes;
    Stick stick;
    {
      TypedArray attributes = resources.obtainAttributes(parser, SPACER_ATTRIBUTES);
      try {
        keyAttributes = parseKeyAttributes(
            attributes, defaultKeyAttributes, metrics, keyboardWidth, keyboardHeight,
            -1, SPACER_KEY_HEIGHT_INDEX, SPACER_HORIZONTAL_GAP_INDEX, -1, -1);
        edgeFlags |= attributes.getInt(SPACER_KEY_EDGE_FLAGS_INDEX, 0);
        stick = Stick.values()[attributes.getInt(SPACER_STICK_INDEX, 0)];
      } finally {
        attributes.recycle();
      }
    }

    parser.next();
    assertEndTag(parser, "Spacer");

    // Returns a dummy key object.
    return new Key(
        x, y, keyAttributes.horizontalGap, keyAttributes.height,
        0, edgeFlags, false, false, false, stick, Collections.<KeyState>emptyList());
  }

  private KeyState parseKeyState(DrawableType defaultBackgroundDrawableType,
                                 PopUpAttributes popUpAttributes)
      throws XmlPullParserException, IOException {
    XmlResourceParser parser = this.xmlResourceParser;
    assertStartTag(parser, "KeyState");

    String contentDescription;
    DrawableType backgroundDrawableType;
    Set<KeyState.MetaState> metaStateSet;
    Set<KeyState.MetaState> nextAddMetaState;
    Set<KeyState.MetaState> nextRemoveMetaState;
    {
      TypedArray attributes = resources.obtainAttributes(parser, KEY_STATE_ATTRIBUTES);
      try {
        contentDescription = Objects.firstNonNull(
            attributes.getText(KEY_STATE_CONTENT_DESCRIPTION_INDEX), "").toString();
        backgroundDrawableType = parseKeyBackgroundDrawableType(
            attributes, KEY_STATE_KEY_BACKGROUND_INDEX, defaultBackgroundDrawableType);
        metaStateSet = parseMetaState(attributes, KEY_STATE_META_STATE_INDEX);
        nextAddMetaState = parseMetaState(attributes, KEY_STATE_NEXT_META_STATE_INDEX);
        nextRemoveMetaState = parseMetaState(attributes, KEY_STATE_NEXT_REMOVED_META_STATES_INDEX);
      } finally {
        attributes.recycle();
      }
    }

    List<Flick> flickList = new ArrayList<Flick>();
    while (true) {
      parser.next();
      ignoreWhiteSpaceAndComment(parser);
      assertNotEndDocument(parser);
      if (parser.getEventType() == XmlResourceParser.END_TAG) {
        break;
      }
      flickList.add(parseFlick(backgroundDrawableType, popUpAttributes));
    }

    // At the moment, we support only keys which has flick data to the CENTER direction.
    boolean isCenterFound = false;
    for (Flick flick : flickList) {
      if (flick.getDirection() == Flick.Direction.CENTER) {
        isCenterFound = true;
        break;
      }
    }
    if (!isCenterFound) {
      throw new IllegalArgumentException(
          "No CENTER flick element is found: " + parser.getPositionDescription());
    }

    assertEndTag(parser, "KeyState");
    return new KeyState(contentDescription, metaStateSet, nextAddMetaState, nextRemoveMetaState,
                        flickList);
  }

  private Flick parseFlick(DrawableType backgroundDrawableType,
                           PopUpAttributes popUpAttributes)
      throws XmlPullParserException, IOException {
    XmlResourceParser parser = this.xmlResourceParser;
    assertStartTag(parser, "Flick");

    Flick.Direction direction;
    {
      TypedArray attributes = resources.obtainAttributes(parser, R.styleable.Flick);
      try {
        direction = parseFlickDirection(attributes, R.styleable.Flick_direction);
      } finally {
        attributes.recycle();
      }
    }

    parser.next();
    KeyEntity entity = parseKeyEntity(backgroundDrawableType, popUpAttributes);

    if (entity.getLongPressKeyCode() != KeyEntity.INVALID_KEY_CODE &&
        direction != Flick.Direction.CENTER) {
      throw new IllegalArgumentException(
          "longPressKeyCode can be set to only a KenEntity for CENTER direction: " +
          parser.getPositionDescription());
    }

    parser.next();
    assertEndTag(parser, "Flick");

    return new Flick(direction, entity);
  }

  private KeyEntity parseKeyEntity(
      DrawableType backgroundDrawableType, PopUpAttributes popUpAttributes)
      throws XmlPullParserException, IOException {
    XmlResourceParser parser = this.xmlResourceParser;
    assertStartTag(parser, "KeyEntity");

    int sourceId;
    int keyCode;
    int longPressKeyCode;
    int keyIconResourceId;
    String keyCharacter;
    @SuppressWarnings("unused")
    DrawableType keyBackgroundDrawableType;
    boolean flickHighlight;
    {
      TypedArray attributes = resources.obtainAttributes(parser, KEY_ENTITY_ATTRIBUTES);
      try {
        sourceId = getSourceId(attributes.peekValue(KEY_ENTITY_SOURCE_ID_INDEX), 0);
        if (!sourceIdSet.add(sourceId)) {
          //  Same sourceId is found.
          throw new IllegalArgumentException(
              "Duplicataed sourceId is found: " + xmlResourceParser.getPositionDescription());
        }
        keyCode = getCode(
            attributes.peekValue(KEY_ENTITY_KEY_CODE_INDEX), KeyEntity.INVALID_KEY_CODE);
        longPressKeyCode = getCode(attributes.peekValue(KEY_ENTITY_LONG_PRESS_KEY_CODE_INDEX),
                                   KeyEntity.INVALID_KEY_CODE);
        keyIconResourceId = attributes.getResourceId(KEY_ENTITY_KEY_ICON_INDEX, 0);
        keyCharacter = attributes.getString(KEY_ENTITY_KEY_CHAR_INDEX);
        flickHighlight = attributes.getBoolean(KEY_ENTITY_FLICK_HIGHLIGHT_INDEX, false);
      } finally {
        attributes.recycle();
      }
    }

    parser.next();
    ignoreWhiteSpaceAndComment(parser);

    PopUp popUp = null;
    if (parser.getEventType() == XmlResourceParser.START_TAG) {
      popUp = parsePopUp(popUpAttributes);
      parser.next();
      ignoreWhiteSpaceAndComment(parser);
    }

    assertEndTag(parser, "KeyEntity");

    return new KeyEntity(sourceId, keyCode, longPressKeyCode, keyIconResourceId, keyCharacter,
                         backgroundDrawableType, flickHighlight, popUp);
  }

  private PopUp parsePopUp(PopUpAttributes popUpAttributes)
      throws XmlPullParserException, IOException {
    XmlResourceParser parser = this.xmlResourceParser;
    assertStartTag(parser, "PopUp");

    int popUpIconResourceId;
    {
      TypedArray attributes = resources.obtainAttributes(parser, R.styleable.PopUp);
      try {
        popUpIconResourceId = attributes.getResourceId(R.styleable.PopUp_popUpIcon, 0);
      } finally {
        attributes.recycle();
      }
    }
    parser.next();
    assertEndTag(parser, "PopUp");

    return new PopUp(popUpIconResourceId,
                     popUpAttributes.popUpWidth,
                     popUpAttributes.popUpHeight,
                     popUpAttributes.popUpXOffset,
                     popUpAttributes.popUpYOffset);
  }

  private float parseFlickThreshold(TypedArray attributes, int index) {
    float flickThreshold = attributes.getDimension(
        index, resources.getDimension(R.dimen.default_flick_threshold));
    if (flickThreshold <= 0) {
      throw new IllegalArgumentException(
          "flickThreshold must be greater than 0.  value = " + flickThreshold);
    }
    return flickThreshold;
  }

  private static KeyAttributes parseKeyAttributes(
      TypedArray attributes, KeyAttributes defaultValue, DisplayMetrics metrics,
      int keyboardWidth, int keyboardHeight,
      int keyWidthIndex, int keyHeightIndex, int horizontalGapIndex, int verticalGapIndex,
      int keyBackgroundIndex) {
    int keyWidth = (keyWidthIndex >= 0)
        ? getDimensionOrFraction(
              attributes.peekValue(keyWidthIndex), keyboardWidth,
              defaultValue.width, metrics)
        : defaultValue.width;
    int keyHeight = (keyHeightIndex >= 0)
        ? getDimensionOrFraction(
              attributes.peekValue(keyHeightIndex), keyboardHeight,
              defaultValue.height, metrics)
        : defaultValue.height;

    int horizontalGap = (horizontalGapIndex >= 0)
        ? getDimensionOrFraction(
              attributes.peekValue(horizontalGapIndex),
              keyboardWidth, defaultValue.horizontalGap, metrics)
        : defaultValue.horizontalGap;
    int verticalGap = (verticalGapIndex >= 0)
        ? getDimensionOrFraction(
              attributes.peekValue(verticalGapIndex),
              keyboardHeight, defaultValue.verticalGap, metrics)
        : defaultValue.verticalGap;

    DrawableType keyBackgroundDrawableType = parseKeyBackgroundDrawableType(
        attributes, keyBackgroundIndex, defaultValue.keyBackgroundDrawableType);
    return new KeyAttributes(
        keyWidth, keyHeight, horizontalGap, verticalGap, keyBackgroundDrawableType);
  }

  private static DrawableType parseKeyBackgroundDrawableType(
      TypedArray attributes, int index, DrawableType defaultValue) {
    if (index < 0) {
      return defaultValue;
    }
    int value = attributes.getInt(index, -1);
    return (value < 0) ? defaultValue : KEY_BACKGROUND_DRAWABLE_TYPE_MAP[value];
  }

  private static PopUpAttributes parsePopUpAttributes(
      TypedArray attributes, DisplayMetrics metrics, int keyboardWidth,
      int popUpWidthIndex, int popUpHeightIndex, int popUpXOffsetIndex, int popUpYOffsetIndex) {
    int popUpWidth = getDimensionOrFraction(
        attributes.peekValue(popUpWidthIndex), keyboardWidth, 0, metrics);
    int popUpHeight = getDimensionOrFraction(
        attributes.peekValue(popUpHeightIndex), keyboardWidth, 0, metrics);
    int popUpXOffset = getDimensionOrFraction(
        attributes.peekValue(popUpXOffsetIndex), keyboardWidth, 0, metrics);
    int popUpYOffset = getDimensionOrFraction(
        attributes.peekValue(popUpYOffsetIndex), keyboardWidth, 0, metrics);
    return new PopUpAttributes(popUpWidth, popUpHeight, popUpXOffset, popUpYOffset);
  }

  /**
   * Returns set of MetaState.
   *
   * <p>Empty set is returned if corresponding attribute is not found.
   * This is used for default KeyState.
   */
  private Set<KeyState.MetaState> parseMetaState(TypedArray attributes, int index) {
    int metaStateFlags = attributes.getInt(index, 0);
    if (metaStateFlags == 0) {
      return Collections.emptySet();
    }

    Set<KeyState.MetaState> result = EnumSet.noneOf(KeyState.MetaState.class);
    for (int i = 0; i < Integer.SIZE; ++i) {
      int flag = metaStateFlags & (1 << i);
      if (flag != 0) {
        result.add(KeyState.MetaState.valueOf(flag));
      }
    }
    return result;
  }

  private Flick.Direction parseFlickDirection(TypedArray attributes, int index) {
    return Flick.Direction.valueOf(attributes.getInt(index, Flick.Direction.CENTER.index));
  }

  protected Keyboard buildKeyboard(
      Optional<String> contentDescription, List<Row> rowList, float flickThreshold) {
    return new Keyboard(Preconditions.checkNotNull(contentDescription),
                        Preconditions.checkNotNull(rowList), flickThreshold);
  }

  protected Row buildRow(List<Key> keyList, int height, int verticalGap) {
    return new Row(keyList, height, verticalGap);
  }
}