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

import org.mozc.android.inputmethod.japanese.FeedbackManager.FeedbackEvent;
import org.mozc.android.inputmethod.japanese.emoji.EmojiProviderType;
import org.mozc.android.inputmethod.japanese.keyboard.BackgroundDrawableFactory;
import org.mozc.android.inputmethod.japanese.keyboard.BackgroundDrawableFactory.DrawableType;
import org.mozc.android.inputmethod.japanese.keyboard.KeyEventHandler;
import org.mozc.android.inputmethod.japanese.model.SymbolCandidateStorage;
import org.mozc.android.inputmethod.japanese.model.SymbolMajorCategory;
import org.mozc.android.inputmethod.japanese.model.SymbolMinorCategory;
import org.mozc.android.inputmethod.japanese.preference.PreferenceUtil;
import org.mozc.android.inputmethod.japanese.protobuf.ProtoCandidates.CandidateList;
import org.mozc.android.inputmethod.japanese.protobuf.ProtoCandidates.CandidateWord;
import org.mozc.android.inputmethod.japanese.resources.R;
import org.mozc.android.inputmethod.japanese.ui.CandidateLayoutRenderer.DescriptionLayoutPolicy;
import org.mozc.android.inputmethod.japanese.ui.CandidateLayoutRenderer.ValueScalingPolicy;
import org.mozc.android.inputmethod.japanese.ui.ScrollGuideView;
import org.mozc.android.inputmethod.japanese.ui.SpanFactory;
import org.mozc.android.inputmethod.japanese.ui.SymbolCandidateLayouter;
import org.mozc.android.inputmethod.japanese.view.MozcDrawableFactory;
import org.mozc.android.inputmethod.japanese.view.RoundRectKeyDrawable;
import org.mozc.android.inputmethod.japanese.view.SkinType;
import org.mozc.android.inputmethod.japanese.view.SymbolMajorCategoryButtonDrawableFactory;
import org.mozc.android.inputmethod.japanese.view.TabSelectedBackgroundDrawable;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;

import android.app.AlertDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.SharedPreferences;
import android.content.res.Resources;
import android.content.res.TypedArray;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Typeface;
import android.graphics.drawable.ColorDrawable;
import android.graphics.drawable.Drawable;
import android.graphics.drawable.LayerDrawable;
import android.os.IBinder;
import android.preference.PreferenceManager;
import android.support.v4.view.PagerAdapter;
import android.support.v4.view.ViewPager;
import android.support.v4.view.ViewPager.OnPageChangeListener;
import android.util.AttributeSet;
import android.util.TypedValue;
import android.view.GestureDetector;
import android.view.GestureDetector.OnGestureListener;
import android.view.Gravity;
import android.view.InflateException;
import android.view.LayoutInflater;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;
import android.view.animation.Animation;
import android.widget.ImageButton;
import android.widget.ImageView;
import android.widget.TabHost;
import android.widget.TabHost.OnTabChangeListener;
import android.widget.TabHost.TabSpec;
import android.widget.TabWidget;
import android.widget.TextView;

import java.util.List;

/**
 * This class is used to show symbol input view on which an user can
 * input emoticon/symbol/emoji.
 *
 * In this class,
 * "Emoticon" means "Kaomoji", like ＼(^o^)／
 * "Symbol" means symbol character, like $ % ! €
 * "Emoji" means a more graphical character of face, building, food etc.
 *
 * This class treats all Emoticon, Symbol and Emoji category as "SymbolMajorCategory".
 * A major category has several minor categories.
 * Each minor category belongs to only one major category.
 * Major-Minor relation is defined by using R.layout.symbol_minor_category_*.
 *
 */
public class SymbolInputView extends InOutAnimatedFrameLayout implements MemoryManageable {

  /**
   * Adapter for symbol candidate selection.
   * Exposed as package private for testing.
   */
  // TODO(hidehiko): make this class static.
  class SymbolCandidateSelectListener implements CandidateSelectListener {
    @Override
    public void onCandidateSelected(CandidateWord candidateWord, Optional<Integer> row) {
      if (viewEventListener != null) {
        // If we are on password field, history shouldn't be updated to protect privacy.
        viewEventListener.onSymbolCandidateSelected(
            currentMajorCategory, candidateWord.getValue(), !isPasswordField);
      }
    }
  }

  /**
   * Click handler of major category buttons.
   */
  class MajorCategoryButtonClickListener implements OnClickListener {
    private final SymbolMajorCategory majorCategory;

    MajorCategoryButtonClickListener(SymbolMajorCategory majorCategory) {
      if (majorCategory == null) {
        throw new NullPointerException("majorCategory should not be null.");
      }
      this.majorCategory = majorCategory;
    }

    @Override
    public void onClick(View majorCategorySelectorButton) {
      if (viewEventListener != null) {
        viewEventListener.onFireFeedbackEvent(FeedbackEvent.INPUTVIEW_EXPAND);
      }

      if (emojiEnabled
          && majorCategory == SymbolMajorCategory.EMOJI
          && emojiProviderType == EmojiProviderType.NONE) {
        // Ask the user which emoji provider s/he'd like to use.
        // If the user cancels the dialog, do nothing.
        maybeInitializeEmojiProviderDialog(getContext());
        if (emojiProviderDialog != null) {
          IBinder token = getWindowToken();
          if (token != null) {
            MozcUtil.setWindowToken(token, emojiProviderDialog);
          } else {
            MozcLog.w("Unknown window token.");
          }

          // If a user selects a provider, the dialog handler will set major category
          // to EMOJI automatically. If s/he cancels, nothing will be happened.
          emojiProviderDialog.show();
          return;
        }
      }

      setMajorCategory(majorCategory);
    }
  }

  // Manages the relationship between.
  static class SymbolTabWidgetViewPagerAdapter extends PagerAdapter
      implements OnTabChangeListener, OnPageChangeListener {

    private static final int HISTORY_INDEX = 0;

    private final Context context;
    private final SymbolCandidateStorage symbolCandidateStorage;
    private final ViewEventListener viewEventListener;
    private final CandidateSelectListener candidateSelectListener;
    private final SymbolMajorCategory majorCategory;
    private final SkinType skinType;
    private final EmojiProviderType emojiProviderType;
    private final TabHost tabHost;
    private final ViewPager viewPager;
    private final float candidateTextSize;
    private final float descriptionTextSize;

    private View historyViewCache = null;
    private int scrollState = ViewPager.SCROLL_STATE_IDLE;

    SymbolTabWidgetViewPagerAdapter(
        Context context, SymbolCandidateStorage symbolCandidateStorage,
        ViewEventListener viewEventListener, CandidateSelectListener candidateSelectListener,
        SymbolMajorCategory majorCategory,
        SkinType skinType, EmojiProviderType emojiProviderType,
        TabHost tabHost, ViewPager viewPager,
        float candidateTextSize, float descriptionTextSize) {
      Preconditions.checkNotNull(emojiProviderType);

      this.context = context;
      this.symbolCandidateStorage = symbolCandidateStorage;
      this.viewEventListener = viewEventListener;
      this.candidateSelectListener = candidateSelectListener;
      this.majorCategory = majorCategory;
      this.skinType = skinType;
      this.emojiProviderType = emojiProviderType;
      this.tabHost = tabHost;
      this.viewPager = viewPager;
      this.candidateTextSize = candidateTextSize;
      this.descriptionTextSize = descriptionTextSize;
    }

    private void maybeResetHistoryView() {
      if (viewPager.getCurrentItem() != HISTORY_INDEX && historyViewCache != null) {
        resetHistoryView();
      }
    }

    private void resetHistoryView() {
      CandidateList candidateList =
          symbolCandidateStorage.getCandidateList(majorCategory.minorCategories.get(0));
      if (candidateList.getCandidatesCount() == 0) {
        historyViewCache.findViewById(R.id.symbol_input_no_history).setVisibility(View.VISIBLE);
      } else {
        historyViewCache.findViewById(R.id.symbol_input_no_history).setVisibility(View.GONE);
      }
      SymbolCandidateView.class.cast(
          historyViewCache.findViewById(R.id.symbol_input_candidate_view)).update(candidateList);
    }

    @Override
    public void onPageScrollStateChanged(int state) {
      if (scrollState == ViewPager.SCROLL_STATE_IDLE) {
        maybeResetHistoryView();
      }
      scrollState = state;
    }

    @Override
    public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
      // Do nothing.
    }

    @Override
    public void onPageSelected(int position) {
      tabHost.setOnTabChangedListener(null);
      tabHost.setCurrentTab(position);
      tabHost.setOnTabChangedListener(this);

      if (viewEventListener != null) {
        viewEventListener.onFireFeedbackEvent(FeedbackEvent.INPUTVIEW_EXPAND);
      }
    }

    @Override
    public void onTabChanged(String tabId) {
      int position = Integer.parseInt(tabId);

      if (position == HISTORY_INDEX) {
        maybeResetHistoryView();
      }
      viewPager.setCurrentItem(position, false);

      if (viewEventListener != null) {
        viewEventListener.onFireFeedbackEvent(FeedbackEvent.INPUTVIEW_EXPAND);
      }
    }

    @Override
    public int getCount() {
      return majorCategory.minorCategories.size();
    }

    @Override
    public boolean isViewFromObject(View view, Object item) {
      return view == item;
    }

    @Override
    public Object instantiateItem(ViewGroup container, int position) {
      LayoutInflater inflater = LayoutInflater.from(context);
      inflater = inflater.cloneInContext(context);

      View view = MozcUtil.inflateWithOutOfMemoryRetrial(
          View.class, inflater, R.layout.symbol_candidate_view, Optional.<ViewGroup>absent(),
          false);
      SymbolCandidateView symbolCandidateView =
          SymbolCandidateView.class.cast(view.findViewById(R.id.symbol_input_candidate_view));
      symbolCandidateView.setCandidateSelectListener(candidateSelectListener);
      symbolCandidateView.setMinColumnWidth(
          context.getResources().getDimension(majorCategory.minColumnWidthResourceId));
      symbolCandidateView.setSkinType(skinType);
      symbolCandidateView.setEmojiProviderType(emojiProviderType);
      symbolCandidateView.setCandidateTextDimension(candidateTextSize, descriptionTextSize);

      // Set candidate contents.
      if (position == HISTORY_INDEX) {
        historyViewCache = view;
        resetHistoryView();
      } else {
        symbolCandidateView.update(symbolCandidateStorage.getCandidateList(
            majorCategory.minorCategories.get(position)));
        symbolCandidateView.updateScrollPositionBasedOnFocusedIndex();
      }

      ScrollGuideView scrollGuideView =
          ScrollGuideView.class.cast(view.findViewById(R.id.symbol_input_scroll_guide_view));
      scrollGuideView.setSkinType(skinType);

      // Connect guide and candidate view.
      scrollGuideView.setScroller(symbolCandidateView.scroller);
      symbolCandidateView.setScrollIndicator(scrollGuideView);

      container.addView(view);
      return view;
    }

    @Override
    public void destroyItem(ViewGroup collection, int position, Object view) {
      if (position == HISTORY_INDEX) {
        historyViewCache = null;
      }
      collection.removeView(View.class.cast(view));
    }
  }

  /**
   * The text view for the minor category tab.
   * The most thing is as same as base TextView, but if the text is too long to fit in
   * the view, this view automatically scales the text horizontally. (If there is enough
   * space, doesn't widen.)
   */
  private static class TabTextView extends TextView {

    /** Cached Paint instance to measure the text. */
    private final Paint paint = new Paint();

    TabTextView(Context context) {
      super(context);
    }

    @Override
    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
      super.onLayout(changed, left, top, right, bottom);
      resetTextXSize();
    }

    private void resetTextXSize() {
      // Reset the paint instance.
      Paint paint = this.paint;
      paint.reset();
      paint.setAntiAlias(true);
      paint.setTextSize(getTextSize());
      paint.setTypeface(getTypeface());

      // Measure the width for each line.
      CharSequence text = getText().toString();
      float maxTextWidth = 0;
      int beginIndex = 0;
      for (int i = beginIndex; i < text.length(); ++i) {
        if (text.charAt(i) == '\n') {
          // Split the line.
          float textWidth = paint.measureText(text, beginIndex, i);
          if (textWidth > maxTextWidth) {
            maxTextWidth = textWidth;
          }
          // Exclude '\n'.
          beginIndex = i + 1;
        }
      }
      {
        // Last line.
        float textWidth = paint.measureText(text, beginIndex, text.length());
        if (textWidth > maxTextWidth) {
          maxTextWidth = textWidth;
        }
      }

      // Calculate scale factory. Note that 0.98f is the heuristic value,
      // in order to avoid wrapping lines by sub px calculations just in case.
      float scaleX = (getWidth() - getPaddingLeft() - getPaddingRight()) * 0.98f / maxTextWidth;

      // Cap the scaleX by 1f not to widen.
      setTextScaleX(Math.min(scaleX, 1f));
    }
  }

  /**
   * An event listener for the menu dialog window.
   */
  private class EmojiProviderDialogListener implements DialogInterface.OnClickListener {
    private final Context context;

    EmojiProviderDialogListener(Context context) {
      this.context = context;
    }

    @Override
    public void onClick(DialogInterface dialog, int which) {
      String value;
      TypedArray typedArray =
          context.getResources().obtainTypedArray(R.array.pref_emoji_provider_type_values);
      try {
        value = typedArray.getString(which);
      } finally {
        typedArray.recycle();
      }
      sharedPreferences.edit()
          .putString(PreferenceUtil.PREF_EMOJI_PROVIDER_TYPE, value)
          .commit();
      setMajorCategory(SymbolMajorCategory.EMOJI);
    }
  }

  /**
   * The candidate view for SymbolInputView.
   *
   * The differences from CandidateView.CandidateWordViewForConversion are
   * 1) this class scrolls horizontally 2) the layout algorithm is simpler.
   */
  static class SymbolCandidateView extends CandidateWordView {
    private static final String DESCRIPTION_DELIMITER = "\n";

    private View scrollGuideView = null;
    private GestureDetector gestureDetector = null;

    public SymbolCandidateView(Context context) {
      super(context, Orientation.VERTICAL);
    }

    public SymbolCandidateView(Context context, AttributeSet attributeSet) {
      super(context, attributeSet, Orientation.VERTICAL);
    }

    public SymbolCandidateView(Context context, AttributeSet attributeSet, int defaultStyle) {
      super(context, attributeSet, defaultStyle, Orientation.VERTICAL);
    }

    // Shared instance initializer.
    {
      setBackgroundDrawableType(DrawableType.SYMBOL_CANDIDATE_BACKGROUND);
      Resources resources = getResources();
      scroller.setDecayRate(
          resources.getInteger(R.integer.symbol_input_scroller_velocity_decay_rate) / 1000000f);
      scroller.setMinimumVelocity(
          resources.getInteger(R.integer.symbol_input_scroller_minimum_velocity));
      layouter = new SymbolCandidateLayouter();
    }

    void setCandidateTextDimension(float textSize, float descriptionTextSize) {
      Preconditions.checkArgument(textSize > 0);
      Preconditions.checkArgument(descriptionTextSize > 0);

      Resources resources = getResources();

      float valueHorizontalPadding =
          resources.getDimension(R.dimen.candidate_horizontal_padding_size);
      float descriptionHorizontalPadding =
          resources.getDimension(R.dimen.symbol_description_right_padding);
      float descriptionVerticalPadding =
          resources.getDimension(R.dimen.symbol_description_bottom_padding);

      candidateLayoutRenderer.setValueTextSize(textSize);
      candidateLayoutRenderer.setValueHorizontalPadding(valueHorizontalPadding);
      candidateLayoutRenderer.setValueScalingPolicy(ValueScalingPolicy.UNIFORM);
      candidateLayoutRenderer.setDescriptionTextSize(descriptionTextSize);
      candidateLayoutRenderer.setDescriptionHorizontalPadding(descriptionHorizontalPadding);
      candidateLayoutRenderer.setDescriptionVerticalPadding(descriptionVerticalPadding);
      candidateLayoutRenderer.setDescriptionLayoutPolicy(DescriptionLayoutPolicy.OVERLAY);

      SpanFactory spanFactory = new SpanFactory();
      spanFactory.setValueTextSize(textSize);
      spanFactory.setDescriptionTextSize(descriptionTextSize);
      spanFactory.setDescriptionDelimiter(DESCRIPTION_DELIMITER);

      SymbolCandidateLayouter layouter = SymbolCandidateLayouter.class.cast(this.layouter);
      layouter.setSpanFactory(spanFactory);
      layouter.setRowHeight(resources.getDimensionPixelSize(R.dimen.symbol_view_candidate_height));
    }

    @Override
    SymbolCandidateLayouter getCandidateLayouter() {
      return SymbolCandidateLayouter.class.cast(super.getCandidateLayouter());
    }

    void setMinColumnWidth(float minColumnWidth) {
      getCandidateLayouter().setMinColumnWidth(minColumnWidth);
      updateLayouter();
    }

    void setOnGestureListener(OnGestureListener gestureListener) {
      if (gestureListener == null) {
        gestureDetector = null;
      } else {
        gestureDetector = new GestureDetector(getContext(), gestureListener);
      }
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
      if (gestureDetector != null && gestureDetector.onTouchEvent(event)) {
        return true;
      }
      return super.onTouchEvent(event);
    }

    @Override
    protected void onDraw(Canvas canvas) {
      super.onDraw(canvas);
      if (scrollGuideView != null) {
        scrollGuideView.invalidate();
      }
    }

    void setScrollIndicator(View scrollGuideView) {
      this.scrollGuideView = scrollGuideView;
    }
  }

  private class OutAnimationAdapter extends AnimationAdapter {
    @Override
    public void onAnimationEnd(Animation animation) {
      // Releases candidate resources. Also, on some devices, this cancels repeating invalidation
      // to support emoji related stuff.
      TabHost tabHost = getTabHost();
      tabHost.setOnTabChangedListener(null);
      ViewPager candidateViewPager = getCandidateViewPager();
      candidateViewPager.setAdapter(null);
      candidateViewPager.setOnPageChangeListener(null);
    }
  }

  /**
   * Name to represent this view for logging.
   */
  static final KeyboardSpecificationName SPEC_NAME =
      new KeyboardSpecificationName("SYMBOL_INPUT_VIEW", 0, 1, 0);
  // Source ID of the delete button for logging usage stats.
  private static final int DELETE_BUTTON_SOURCE_ID = 1;

  // TODO(hidehiko): move these parameters to skin instance.
  private static final float BUTTON_CORNOR_RADIUS = 3.5f;  // in dip.
  private static final float BUTTON_LEFT_OFFSET = 2.0f;
  private static final float BUTTON_TOP_OFFSET = 2.0f;
  private static final float BUTTON_RIGHT_OFFSET = 2.0f;
  private static final float BUTTON_BOTTOM_OFFSET = 2.0f;

  private static final int MAJOR_CATEGORY_TOP_COLOR = 0xFFF5F5F5;
  private static final int MAJOR_CATEGORY_BOTTOM_COLOR = 0xFFD2D2D2;
  private static final int MAJOR_CATEGORY_PRESSED_TOP_COLOR = 0xFFAAAAAA;
  private static final int MAJOR_CATEGORY_PRESSED_BOTTOM_COLOR = 0xFF828282;
  private static final int MAJOR_CATEGORY_SHADOW_COLOR = 0x57000000;

  // TODO(hidehiko): This parameter is not fixed yet. Needs to revisit again.
  private static final float SYMBOL_VIEW_MINOR_CATEGORY_TAB_SELECTED_HEIGHT = 6f;

  private static final int NUM_TABS = 6;

  private SymbolCandidateStorage symbolCandidateStorage;

  @VisibleForTesting SymbolMajorCategory currentMajorCategory;
  @VisibleForTesting boolean emojiEnabled;
  private boolean isPasswordField;
  @VisibleForTesting EmojiProviderType emojiProviderType = EmojiProviderType.NONE;

  @VisibleForTesting SharedPreferences sharedPreferences;
  @VisibleForTesting AlertDialog emojiProviderDialog;

  private ViewEventListener viewEventListener;
  private final KeyEventButtonTouchListener deleteKeyEventButtonTouchListener =
      createDeleteKeyEventButtonTouchListener(getResources());
  private OnClickListener closeButtonClickListener = null;
  private final SymbolCandidateSelectListener symbolCandidateSelectListener =
      new SymbolCandidateSelectListener();

  private SkinType skinType = SkinType.ORANGE_LIGHTGRAY;
  private final MozcDrawableFactory mozcDrawableFactory = new MozcDrawableFactory(getResources());
  private final SymbolMajorCategoryButtonDrawableFactory majorCategoryButtonDrawableFactory =
      new SymbolMajorCategoryButtonDrawableFactory(
          mozcDrawableFactory,
          MAJOR_CATEGORY_TOP_COLOR,
          MAJOR_CATEGORY_BOTTOM_COLOR,
          MAJOR_CATEGORY_PRESSED_TOP_COLOR,
          MAJOR_CATEGORY_PRESSED_BOTTOM_COLOR,
          MAJOR_CATEGORY_SHADOW_COLOR,
          BUTTON_CORNOR_RADIUS * getResources().getDisplayMetrics().density);
  // Candidate text size in dip.
  private float candidateTextSize;
  // Description text size in dip.
  private float desciptionTextSize;

  public SymbolInputView(Context context, AttributeSet attrs, int defStyle) {
    super(context, attrs, defStyle);
  }

  public SymbolInputView(Context context) {
    super(context);
  }

  public SymbolInputView(Context context, AttributeSet attrs) {
    super(context, attrs);
  }

  {
    setOutAnimationListener(new OutAnimationAdapter());
    sharedPreferences = PreferenceManager.getDefaultSharedPreferences(getContext());
  }

  private static KeyEventButtonTouchListener createDeleteKeyEventButtonTouchListener(
      Resources resources) {
    // Use 8 as default value of backspace key code (only for testing).
    // This code is introduced just for testing purpose due to AndroidMock's limitation.
    // When we move to EasyMock, we can remove this method.
    int ucharBackspace = resources == null ? 8 : resources.getInteger(R.integer.uchar_backspace);
    return new KeyEventButtonTouchListener(DELETE_BUTTON_SOURCE_ID, ucharBackspace);
  }


  boolean isInflated() {
    return getChildCount() > 0;
  }

  void inflateSelf() {
    if (isInflated()) {
      throw new IllegalStateException("The symbol input view is already inflated.");
    }

    // Hack: Because we wrap the real context to inject "retrying" for Drawable loading,
    // LayoutInflater.from(getContext()).getContext() may be different from getContext().
    // So, we clone the inflater here, too, with actual context.
    Context context = getContext();
    LayoutInflater inflater = LayoutInflater.from(context);
    inflater = inflater.cloneInContext(context);
    MozcUtil.inflateWithOutOfMemoryRetrial(
        SymbolInputView.class, inflater, R.layout.symbol_view, Optional.<ViewGroup>of(this), true);
    // Note: onFinishInflate won't be invoked on android ver 3.0 or later, while it is invoked
    // on android 2.3 or earlier. So, we define another (but similar) method and invoke it here
    // manually.
    onFinishInflateSelf();
  }

  /**
   * Initializes the instance. Called only once.
   * {@code onFinishInflate()} is *not* invoked for the inflation of &lt;merge&gt; element we use.
   * So, instead, we define another onFinishInflate method and invoke this manually.
   */
  protected void onFinishInflateSelf() {
    initializeMajorCategoryButtons();
    initializeMinorCategoryTab();
    initializeCloseButton();
    initializeDeleteButton();

    resetMajorCategoryBackground();
    resetTabBackground();
    enableEmoji(emojiEnabled);
    reset();
  }

  private void resetCandidateViewPager() {
    if (!isInflated()) {
      return;
    }

    ViewPager candidateViewPager = getCandidateViewPager();
    TabHost tabHost = getTabHost();

    SymbolTabWidgetViewPagerAdapter adapter = new SymbolTabWidgetViewPagerAdapter(
        getContext(),
        symbolCandidateStorage, viewEventListener, symbolCandidateSelectListener,
        currentMajorCategory, skinType, emojiProviderType, tabHost, candidateViewPager,
        candidateTextSize, desciptionTextSize);
    candidateViewPager.setAdapter(adapter);
    candidateViewPager.setOnPageChangeListener(adapter);
    tabHost.setOnTabChangedListener(adapter);
  }

  private void resetMajorCategoryBackground() {
    View view = findViewById(R.id.symbol_major_category);
    if (view != null) {
      if (skinType == null) {
        view.setBackgroundColor(Color.BLACK);
      } else {
        view.setBackgroundResource(skinType.windowBackgroundResourceId);
      }
    }
  }

  private void setMozcDrawable(ImageView imageView, int resourceId) {
    Optional<Drawable> drawable = mozcDrawableFactory.getDrawable(resourceId);
    if (drawable.isPresent()) {
      imageView.setImageDrawable(drawable.get());
    }
  }

  /**
   * Sets click event handlers to each major category button.
   * It is necessary that the inflation has been done before this method invocation.
   */
  @SuppressWarnings("deprecation")
  private void initializeMajorCategoryButtons() {
    for (SymbolMajorCategory majorCategory : SymbolMajorCategory.values()) {
      ImageView view = ImageView.class.cast(findViewById(majorCategory.buttonResourceId));
      if (view == null) {
        throw new IllegalStateException(
            "The view corresponding to " + majorCategory.name() + " is not found.");
      }
      view.setOnClickListener(new MajorCategoryButtonClickListener(majorCategory));
      setMozcDrawable(view, majorCategory.buttonImageResourceId);

      switch (majorCategory) {
        case SYMBOL:
          view.setBackgroundDrawable(
              majorCategoryButtonDrawableFactory.createLeftButtonDrawable());
          break;
        case EMOJI:
          view.setBackgroundDrawable(
              majorCategoryButtonDrawableFactory.createRightButtonDrawable(emojiEnabled));
          break;
        default:
          view.setBackgroundDrawable(
              majorCategoryButtonDrawableFactory.createCenterButtonDrawable());
          break;
      }
    }
  }

  private void initializeMinorCategoryTab() {
    TabHost tabhost = TabHost.class.cast(findViewById(android.R.id.tabhost));
    tabhost.setup();

    float textSize = getResources().getDimension(R.dimen.symbol_view_minor_category_text_size);
    int textColor = getResources().getColor(android.R.color.black);

    // Create NUM_TABS (= 6) tabs.
    // Note that we may want to change the number of tabs, however due to the limitation of
    // the current TabHost implementation, it is difficult. Fortunately, all major categories
    // have the same number of minor categories, so we use it as hard-coded value.
    for (int i = 0; i < NUM_TABS; ++i) {
      // The tab's id is the index of the tab.
      TabSpec tab = tabhost.newTabSpec(String.valueOf(i));
      TextView textView = new TabTextView(getContext());
      textView.setTypeface(Typeface.DEFAULT_BOLD);
      textView.setTextColor(textColor);
      textView.setTextSize(TypedValue.COMPLEX_UNIT_PX, textSize);
      textView.setGravity(Gravity.CENTER);
      tab.setIndicator(textView);
      // Set dummy view for the content. The actual content will be managed by ViewPager.
      tab.setContent(R.id.symbol_input_dummy);
      tabhost.addTab(tab);
    }

    // Hack: Set the current tab to the non-default (neither 0 nor 1) position,
    // so that the reset process will set the view's visibility appropriately.
    tabhost.setCurrentTab(2);
  }

  @SuppressWarnings("deprecation")
  private void resetTabBackground() {
    if (!isInflated()) {
      return;
    }

    float density = getResources().getDisplayMetrics().density;

    TabWidget tabWidget = TabWidget.class.cast(findViewById(android.R.id.tabs));
    for (int i = 0; i < tabWidget.getTabCount(); ++i) {
      View view = tabWidget.getChildTabViewAt(i);
      view.setBackgroundDrawable(createTabBackgroundDrawable(skinType, density));
    }
  }

  private static Drawable createTabBackgroundDrawable(SkinType skinType, float density) {
    return new LayerDrawable(new Drawable[] {
        BackgroundDrawableFactory.createSelectableDrawable(
            new TabSelectedBackgroundDrawable(
                (int) (SYMBOL_VIEW_MINOR_CATEGORY_TAB_SELECTED_HEIGHT * density),
                skinType.symbolMinorCategoryTabSelectedColor),
            null),
        BackgroundDrawableFactory.createPressableDrawable(
            new ColorDrawable(skinType.symbolMinorCategoryTabPressedColor), null),
    });
  }

  private void resetTabText() {
    if (!isInflated()) {
      return;
    }

    TabWidget tabWidget = TabWidget.class.cast(findViewById(android.R.id.tabs));
    List<SymbolMinorCategory> minorCategoryList = currentMajorCategory.minorCategories;
    for (int i = 0; i < tabWidget.getChildCount(); ++i) {
      TextView textView = TextView.class.cast(tabWidget.getChildTabViewAt(i));
      textView.setText(minorCategoryList.get(i).textResourceId);
    }
  }

  private static Drawable createButtonBackgroundDrawable(SkinType skinType, float density) {
    return BackgroundDrawableFactory.createPressableDrawable(
        new RoundRectKeyDrawable(
            (int) (BUTTON_LEFT_OFFSET * density),
            (int) (BUTTON_TOP_OFFSET * density),
            (int) (BUTTON_RIGHT_OFFSET * density),
            (int) (BUTTON_BOTTOM_OFFSET * density),
            (int) (BUTTON_CORNOR_RADIUS * density),
            skinType.symbolPressedFunctionKeyTopColor,
            skinType.symbolPressedFunctionKeyBottomColor,
            skinType.symbolPressedFunctionKeyHighlightColor,
            skinType.symbolPressedFunctionKeyShadowColor),
        new RoundRectKeyDrawable(
            (int) (BUTTON_LEFT_OFFSET * density),
            (int) (BUTTON_TOP_OFFSET * density),
            (int) (BUTTON_RIGHT_OFFSET * density),
            (int) (BUTTON_BOTTOM_OFFSET * density),
            (int) (BUTTON_CORNOR_RADIUS * density),
            skinType.symbolReleasedFunctionKeyTopColor,
            skinType.symbolReleasedFunctionKeyBottomColor,
            skinType.symbolReleasedFunctionKeyHighlightColor,
            skinType.symbolReleasedFunctionKeyShadowColor));
  }

  @SuppressWarnings("deprecation")
  private void initializeCloseButton() {
    ImageView closeButton = ImageView.class.cast(findViewById(R.id.symbol_view_close_button));
    if (closeButtonClickListener != null) {
      closeButton.setOnClickListener(closeButtonClickListener);
    }
    closeButton.setBackgroundDrawable(
        createButtonBackgroundDrawable(skinType, getResources().getDisplayMetrics().density));
    setMozcDrawable(closeButton, R.raw.symbol__function__close);
    closeButton.setPadding(2, 2, 2, 2);
  }

  /**
   * Sets a click event handler to the delete button.
   * It is necessary that the inflation has been done before this method invocation.
   */
  @SuppressWarnings("deprecation")
  private void initializeDeleteButton() {
    ImageView deleteButton = ImageView.class.cast(findViewById(R.id.symbol_view_delete_button));
    deleteButton.setOnTouchListener(deleteKeyEventButtonTouchListener);
    deleteButton.setBackgroundDrawable(
        createButtonBackgroundDrawable(skinType, getResources().getDisplayMetrics().density));
    setMozcDrawable(deleteButton, R.raw.symbol__function__delete);
    deleteButton.setPadding(0, 0, 0, 0);
  }

  TabHost getTabHost() {
    return TabHost.class.cast(findViewById(android.R.id.tabhost));
  }

  ViewPager getCandidateViewPager() {
    return ViewPager.class.cast(findViewById(R.id.symbol_input_candidate_view_pager));
  }

  ImageButton getMajorCategoryButton(SymbolMajorCategory majorCategory) {
    if (majorCategory == null) {
      throw new NullPointerException("majorCategory shouldn't be null.");
    }
    return ImageButton.class.cast(findViewById(majorCategory.buttonResourceId));
  }

  View getEmojiDisabledMessageView() {
    return findViewById(R.id.symbol_emoji_disabled_message_view);
  }

  public void setEmojiEnabled(boolean unicodeEmojiEnabled, boolean carrierEmojiEnabled) {
    this.emojiEnabled = unicodeEmojiEnabled || carrierEmojiEnabled;
    enableEmoji(this.emojiEnabled);
    symbolCandidateStorage.setEmojiEnabled(unicodeEmojiEnabled, carrierEmojiEnabled);
  }

  public void setPasswordField(boolean isPasswordField) {
    this.isPasswordField = isPasswordField;
  }

  @SuppressWarnings("deprecation")
  private void enableEmoji(boolean enableEmoji) {
    if (!isInflated()) {
      return;
    }

    ImageButton imageButton = getMajorCategoryButton(SymbolMajorCategory.EMOJI);
    imageButton.setBackgroundDrawable(
        majorCategoryButtonDrawableFactory.createRightButtonDrawable(enableEmoji));
  }

  /**
   * Resets the status.
   */
  void reset() {
    // the current minor category is also updated in setMajorCategory.
    setMajorCategory(SymbolMajorCategory.SYMBOL);
    deleteKeyEventButtonTouchListener.reset();
  }

  @Override
  public void setVisibility(int visibility) {
    int previousVisibility = getVisibility();
    super.setVisibility(visibility);
    if (viewEventListener != null
        && previousVisibility == View.VISIBLE && visibility != View.VISIBLE) {
      viewEventListener.onCloseSymbolInputView();
    }
  }

  void setSymbolCandidateStorage(SymbolCandidateStorage symbolCandidateStorage) {
    this.symbolCandidateStorage = symbolCandidateStorage;
  }

  void setKeyEventHandler(KeyEventHandler keyEventHandler) {
    deleteKeyEventButtonTouchListener.setKeyEventHandler(keyEventHandler);
  }

  void setCandidateTextDimension(float candidateTextSize, float descriptionTextSize) {
    Preconditions.checkArgument(candidateTextSize > 0);
    Preconditions.checkArgument(descriptionTextSize > 0);

    this.candidateTextSize = candidateTextSize;
    this.desciptionTextSize = descriptionTextSize;
  }

  /**
   * Initializes EmojiProvider selection dialog, if necessary.
   * Exposed as protected for testing purpose.
   */
  protected void maybeInitializeEmojiProviderDialog(Context context) {
    if (emojiProviderDialog != null) {
      return;
    }

    EmojiProviderDialogListener listener = new EmojiProviderDialogListener(context);
    try {
      AlertDialog dialog = new AlertDialog.Builder(context)
          .setTitle(R.string.pref_emoji_provider_type_title)
          .setItems(R.array.pref_emoji_provider_type_entries, listener)
          .create();
      this.emojiProviderDialog = dialog;
    } catch (InflateException e) {
      // Ignore the exception.
    }
  }

  /**
   * Sets the major category to show.
   *
   * The view is updated.
   * The active minor category is also updated.
   *
   * @param newCategory the major category to show.
   */
  protected void setMajorCategory(SymbolMajorCategory newCategory) {
    if (newCategory == null) {
      throw new NullPointerException("newCategory must be non-null.");
    }
    currentMajorCategory = newCategory;

    // Reset the minor category to the default value.
    resetTabText();
    resetCandidateViewPager();
    SymbolMinorCategory minorCategory = currentMajorCategory.getDefaultMinorCategory();
    if (symbolCandidateStorage.getCandidateList(minorCategory).getCandidatesCount() == 0) {
      minorCategory = currentMajorCategory.getMinorCategoryByRelativeIndex(minorCategory, 1);
    }
    int index = newCategory.minorCategories.indexOf(minorCategory);
    getCandidateViewPager().setCurrentItem(index);
    getTabHost().setCurrentTab(index);

    // Update visibility relating attributes.
    for (SymbolMajorCategory majorCategory : SymbolMajorCategory.values()) {
      // Update major category selector button's look and feel.
      ImageButton button = getMajorCategoryButton(majorCategory);
      if (button != null) {
        button.setSelected(majorCategory == newCategory);
        button.setEnabled(majorCategory != newCategory);
      }
    }

    View emojiDisabledMessageView = getEmojiDisabledMessageView();
    if (emojiDisabledMessageView != null) {
      // Show messages about emoji-disabling, if necessary.
      emojiDisabledMessageView.setVisibility(
          newCategory == SymbolMajorCategory.EMOJI && !emojiEnabled ? View.VISIBLE : View.GONE);
    }
  }

  void setEmojiProviderType(EmojiProviderType emojiProviderType) {
    Preconditions.checkNotNull(emojiProviderType);

    this.emojiProviderType = emojiProviderType;
    this.symbolCandidateStorage.setEmojiProviderType(emojiProviderType);
    if (!isInflated()) {
      return;
    }

    resetCandidateViewPager();
  }

  void setViewEventListener(ViewEventListener listener, OnClickListener closeButtonClickListener) {
    if (listener == null) {
      throw new NullPointerException("lister must be non-null.");
    }
    viewEventListener = listener;
    this.closeButtonClickListener = closeButtonClickListener;
  }

  void setSkinType(SkinType skinType) {
    if (this.skinType == skinType) {
      return;
    }

    this.skinType = skinType;
    mozcDrawableFactory.setSkinType(skinType);
    if (!isInflated()) {
      return;
    }

    // Reset the minor category tab, candidate view and major category buttons.
    resetTabBackground();
    resetCandidateViewPager();
    resetMajorCategoryBackground();
  }

  @Override
  public void trimMemory() {
    ViewGroup viewGroup = getCandidateViewPager();
    if (viewGroup == null) {
      return;
    }
    for (int i = 0; i < viewGroup.getChildCount(); ++i) {
      View view = viewGroup.getChildAt(i);
      if (view instanceof MemoryManageable) {
        MemoryManageable.class.cast(view).trimMemory();
      }
    }
  }
}