/*
 * Copyright (C) 2022 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package android.view.inputmethod;

import static android.graphics.Typeface.NORMAL;

import android.annotation.ColorInt;
import android.annotation.IntRange;
import android.annotation.NonNull;
import android.annotation.Nullable;
import android.annotation.Px;
import android.graphics.Paint;
import android.graphics.Typeface;
import android.graphics.fonts.FontStyle;
import android.graphics.text.LineBreakConfig;
import android.inputmethodservice.InputMethodService;
import android.os.LocaleList;
import android.os.Parcel;
import android.os.Parcelable;
import android.text.Spanned;
import android.text.TextPaint;
import android.text.method.TransformationMethod;
import android.text.style.CharacterStyle;
import android.widget.TextView;

import java.util.Objects;

/**
 * Information about text appearance in an editor, passed through
 * {@link CursorAnchorInfo} for use by {@link InputMethodService}.
 * @see TextView
 * @see Paint
 * @see CursorAnchorInfo.Builder#setTextAppearanceInfo(TextAppearanceInfo)
 * @see CursorAnchorInfo#getTextAppearanceInfo()
 */
public final class TextAppearanceInfo implements Parcelable {
    /**
     * The text size (in pixels) for current editor.
     */
    private final @Px float mTextSize;

    /**
     * The {@link LocaleList} of the text.
     */
    @NonNull private final LocaleList mTextLocales;

    /**
     * The font family name if the {@link Typeface} of the text is created from a system font
     * family, otherwise this value should be null.
     */
    @Nullable private final String mSystemFontFamilyName;

    /**
     * The weight of the text.
     */
    @IntRange(from = FontStyle.FONT_WEIGHT_UNSPECIFIED, to = FontStyle.FONT_WEIGHT_MAX)
    private final int mTextFontWeight;

    /**
     * The style (normal, bold, italic, bold|italic) of the text, see {@link Typeface}.
     */
    private final @Typeface.Style int mTextStyle;

    /**
     * Whether the transformation method applied to the current editor is set to all caps.
     */
    private final boolean mAllCaps;

    /**
     * The horizontal offset (in pixels) of the text shadow.
     */
    private final @Px float mShadowDx;

    /**
     * The vertical offset (in pixels) of the text shadow.
     */
    private final @Px float mShadowDy;

    /**
     * The blur radius (in pixels) of the text shadow.
     */
    private final @Px float mShadowRadius;

    /**
     * The shadow color of the text shadow.
     */
    private final @ColorInt int mShadowColor;

    /**
     * The elegant text height, especially for less compacted complex script text.
     */
    private final boolean mElegantTextHeight;

    /**
     * Whether to expand linespacing based on fallback fonts.
     */
    private final boolean mFallbackLineSpacing;

    /**
     * The text letter-spacing (in ems), which determines the spacing between characters.
     */
    private final float mLetterSpacing;

    /**
     * The font feature settings.
     */
    @Nullable private final String mFontFeatureSettings;

    /**
     * The font variation settings.
     */
    @Nullable private final String mFontVariationSettings;

    /**
     * The line-break strategies for text wrapping.
     */
    private final @LineBreakConfig.LineBreakStyle int mLineBreakStyle;

    /**
     * The line-break word strategies for text wrapping.
     */
    private final @LineBreakConfig.LineBreakWordStyle int mLineBreakWordStyle;

    /**
     * The extent by which text should be stretched horizontally. Returns 1.0 if not specified.
     */
    private final float mTextScaleX;

    /**
     * The color of the text selection highlight.
     */
    private final @ColorInt int mHighlightTextColor;

    /**
     * The current text color of the editor.
     */
    private final @ColorInt int mTextColor;

    /**
     *  The current color of the hint text.
     */
    private final @ColorInt int mHintTextColor;

    /**
     * The text color used to paint the links in the editor.
     */
    private final @ColorInt int mLinkTextColor;

    private TextAppearanceInfo(@NonNull final TextAppearanceInfo.Builder builder) {
        mTextSize = builder.mTextSize;
        mTextLocales = builder.mTextLocales;
        mSystemFontFamilyName = builder.mSystemFontFamilyName;
        mTextFontWeight = builder.mTextFontWeight;
        mTextStyle = builder.mTextStyle;
        mAllCaps = builder.mAllCaps;
        mShadowDx = builder.mShadowDx;
        mShadowDy = builder.mShadowDy;
        mShadowRadius = builder.mShadowRadius;
        mShadowColor = builder.mShadowColor;
        mElegantTextHeight = builder.mElegantTextHeight;
        mFallbackLineSpacing = builder.mFallbackLineSpacing;
        mLetterSpacing = builder.mLetterSpacing;
        mFontFeatureSettings = builder.mFontFeatureSettings;
        mFontVariationSettings = builder.mFontVariationSettings;
        mLineBreakStyle = builder.mLineBreakStyle;
        mLineBreakWordStyle = builder.mLineBreakWordStyle;
        mTextScaleX = builder.mTextScaleX;
        mHighlightTextColor = builder.mHighlightTextColor;
        mTextColor = builder.mTextColor;
        mHintTextColor = builder.mHintTextColor;
        mLinkTextColor = builder.mLinkTextColor;
    }

    /**
     * Creates a new instance of {@link TextAppearanceInfo} by extracting text appearance from the
     * character before cursor in the target {@link TextView}.
     * @param textView the target {@link TextView}.
     * @return the new instance of {@link TextAppearanceInfo}.
     * @hide
     */
    @NonNull
    public static TextAppearanceInfo createFromTextView(@NonNull TextView textView) {
        final int selectionStart = textView.getSelectionStart();
        final CharSequence text = textView.getText();
        TextPaint textPaint = new TextPaint();
        textPaint.set(textView.getPaint());    // Copy from textView
        if (text instanceof Spanned && text.length() > 0 && selectionStart > 0) {
            // Extract the CharacterStyle spans that changes text appearance in the character before
            // cursor.
            Spanned spannedText = (Spanned) text;
            int lastCh = selectionStart - 1;
            CharacterStyle[] spans = spannedText.getSpans(lastCh, lastCh, CharacterStyle.class);
            if (spans != null) {
                for (CharacterStyle span: spans) {
                    // Exclude spans that end at lastCh
                    if (spannedText.getSpanStart(span) <= lastCh
                            && lastCh < spannedText.getSpanEnd(span)) {
                        span.updateDrawState(textPaint); // Override the TextPaint
                    }
                }
            }
        }
        Typeface typeface = textPaint.getTypeface();
        String systemFontFamilyName = null;
        int textWeight = FontStyle.FONT_WEIGHT_UNSPECIFIED;
        int textStyle = Typeface.NORMAL;
        if (typeface != null) {
            systemFontFamilyName = typeface.getSystemFontFamilyName();
            textWeight = typeface.getWeight();
            textStyle = typeface.getStyle();
        }
        TextAppearanceInfo.Builder builder = new TextAppearanceInfo.Builder();
        builder.setTextSize(textPaint.getTextSize())
                .setTextLocales(textPaint.getTextLocales())
                .setSystemFontFamilyName(systemFontFamilyName)
                .setTextFontWeight(textWeight)
                .setTextStyle(textStyle)
                .setShadowDx(textPaint.getShadowLayerDx())
                .setShadowDy(textPaint.getShadowLayerDy())
                .setShadowRadius(textPaint.getShadowLayerRadius())
                .setShadowColor(textPaint.getShadowLayerColor())
                .setElegantTextHeight(textPaint.isElegantTextHeight())
                .setLetterSpacing(textPaint.getLetterSpacing())
                .setFontFeatureSettings(textPaint.getFontFeatureSettings())
                .setFontVariationSettings(textPaint.getFontVariationSettings())
                .setTextScaleX(textPaint.getTextScaleX())
                // When there is a hint text (text length is 0), the text color should be the normal
                // text color rather than hint text color.
                .setTextColor(text.length() == 0
                        ? textView.getCurrentTextColor() : textPaint.getColor())
                .setLinkTextColor(textPaint.linkColor)
                .setAllCaps(textView.isAllCaps())
                .setFallbackLineSpacing(textView.isFallbackLineSpacing())
                .setLineBreakStyle(textView.getLineBreakStyle())
                .setLineBreakWordStyle(textView.getLineBreakWordStyle())
                .setHighlightTextColor(textView.getHighlightColor())
                .setHintTextColor(textView.getCurrentHintTextColor());
        return builder.build();
    }

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(@NonNull Parcel dest, int flags) {
        dest.writeFloat(mTextSize);
        mTextLocales.writeToParcel(dest, flags); // NonNull
        dest.writeBoolean(mAllCaps);
        dest.writeString8(mSystemFontFamilyName);
        dest.writeInt(mTextFontWeight);
        dest.writeInt(mTextStyle);
        dest.writeFloat(mShadowDx);
        dest.writeFloat(mShadowDy);
        dest.writeFloat(mShadowRadius);
        dest.writeInt(mShadowColor);
        dest.writeBoolean(mElegantTextHeight);
        dest.writeBoolean(mFallbackLineSpacing);
        dest.writeFloat(mLetterSpacing);
        dest.writeString8(mFontFeatureSettings);
        dest.writeString8(mFontVariationSettings);
        dest.writeInt(mLineBreakStyle);
        dest.writeInt(mLineBreakWordStyle);
        dest.writeFloat(mTextScaleX);
        dest.writeInt(mHighlightTextColor);
        dest.writeInt(mTextColor);
        dest.writeInt(mHintTextColor);
        dest.writeInt(mLinkTextColor);
    }

    TextAppearanceInfo(@NonNull Parcel in) {
        mTextSize = in.readFloat();
        mTextLocales = LocaleList.CREATOR.createFromParcel(in);
        mAllCaps = in.readBoolean();
        mSystemFontFamilyName = in.readString8();
        mTextFontWeight = in.readInt();
        mTextStyle = in.readInt();
        mShadowDx = in.readFloat();
        mShadowDy = in.readFloat();
        mShadowRadius = in.readFloat();
        mShadowColor = in.readInt();
        mElegantTextHeight = in.readBoolean();
        mFallbackLineSpacing = in.readBoolean();
        mLetterSpacing = in.readFloat();
        mFontFeatureSettings = in.readString8();
        mFontVariationSettings = in.readString8();
        mLineBreakStyle = in.readInt();
        mLineBreakWordStyle = in.readInt();
        mTextScaleX = in.readFloat();
        mHighlightTextColor = in.readInt();
        mTextColor = in.readInt();
        mHintTextColor = in.readInt();
        mLinkTextColor = in.readInt();
    }

    @NonNull
    public static final Creator<TextAppearanceInfo> CREATOR = new Creator<TextAppearanceInfo>() {
        @Override
        public TextAppearanceInfo createFromParcel(@NonNull Parcel in) {
            return new TextAppearanceInfo(in);
        }

        @Override
        public TextAppearanceInfo[] newArray(int size) {
            return new TextAppearanceInfo[size];
        }
    };

    /**
     * Returns the text size (in pixels) for current editor.
     */
    public @Px float getTextSize() {
        return mTextSize;
    }

    /**
     * Returns the {@link LocaleList} of the text.
     */
    @NonNull
    public LocaleList getTextLocales() {
        return mTextLocales;
    }

    /**
     * Returns the font family name if the {@link Typeface} of the text is created from a
     * system font family. Returns null if no {@link Typeface} is specified, or it is not created
     * from a system font family.
     *
     * @see Typeface#getSystemFontFamilyName()
     */
    @Nullable
    public String getSystemFontFamilyName() {
        return mSystemFontFamilyName;
    }

    /**
     * Returns the weight of the text, or {@code FontStyle#FONT_WEIGHT_UNSPECIFIED}
     * when no {@link Typeface} is specified.
     */
    @IntRange(from = FontStyle.FONT_WEIGHT_UNSPECIFIED, to = FontStyle.FONT_WEIGHT_MAX)
    public int getTextFontWeight() {
        return mTextFontWeight;
    }

    /**
     * Returns the style (normal, bold, italic, bold|italic) of the text. Returns
     * {@link Typeface#NORMAL} when no {@link Typeface} is specified.
     *
     * @see Typeface
     */
    public @Typeface.Style int getTextStyle() {
        return mTextStyle;
    }

    /**
     * Returns whether the transformation method applied to the current editor is set to all caps.
     *
     * @see TextView#setAllCaps(boolean)
     * @see TextView#setTransformationMethod(TransformationMethod)
     */
    public boolean isAllCaps() {
        return mAllCaps;
    }

    /**
     * Returns the horizontal offset (in pixels) of the text shadow.
     *
     * @see Paint#setShadowLayer(float, float, float, int)
     */
    public @Px float getShadowDx() {
        return mShadowDx;
    }

    /**
     * Returns the vertical offset (in pixels) of the text shadow.
     *
     * @see Paint#setShadowLayer(float, float, float, int)
     */
    public @Px float getShadowDy() {
        return mShadowDy;
    }

    /**
     * Returns the blur radius (in pixels) of the text shadow.
     *
     * @see Paint#setShadowLayer(float, float, float, int)
     */
    public @Px float getShadowRadius() {
        return mShadowRadius;
    }

    /**
     * Returns the color of the text shadow.
     *
     * @see Paint#setShadowLayer(float, float, float, int)
     */
    public @ColorInt int getShadowColor() {
        return mShadowColor;
    }

    /**
     * Returns {@code true} if the elegant height metrics flag is set. This setting selects font
     * variants that have not been compacted to fit Latin-based vertical metrics, and also increases
     * top and bottom bounds to provide more space.
     *
     * @see Paint#isElegantTextHeight()
     */
    public boolean isElegantTextHeight() {
        return mElegantTextHeight;
    }

    /**
     * Returns whether to expand linespacing based on fallback fonts.
     *
     * @see TextView#setFallbackLineSpacing(boolean)
     */
    public boolean isFallbackLineSpacing() {
        return mFallbackLineSpacing;
    }

    /**
     * Returns the text letter-spacing, which determines the spacing between characters.
     * The value is in 'EM' units. Normally, this value is 0.0.
     */
    public float getLetterSpacing() {
        return mLetterSpacing;
    }

    /**
     * Returns the font feature settings. Returns null if not specified.
     *
     * @see Paint#getFontFeatureSettings()
     */
    @Nullable
    public String getFontFeatureSettings() {
        return mFontFeatureSettings;
    }

    /**
     * Returns the font variation settings. Returns null if no variation is specified.
     *
     * @see Paint#getFontVariationSettings()
     */
    @Nullable
    public String getFontVariationSettings() {
        return mFontVariationSettings;
    }

    /**
     * Returns the line-break strategies for text wrapping.
     *
     * @see TextView#setLineBreakStyle(int)
     */
    public @LineBreakConfig.LineBreakStyle int getLineBreakStyle() {
        return mLineBreakStyle;
    }

    /**
     * Returns the line-break word strategies for text wrapping.
     *
     * @see TextView#setLineBreakWordStyle(int)
     */
    public @LineBreakConfig.LineBreakWordStyle int getLineBreakWordStyle() {
        return mLineBreakWordStyle;
    }

    /**
     * Returns the extent by which text should be stretched horizontally. Returns 1.0 if not
     * specified.
     */
    public float getTextScaleX() {
        return mTextScaleX;
    }

    /**
     * Returns the color of the text selection highlight.
     *
     * @see TextView#getHighlightColor()
     */
    public @ColorInt int getHighlightTextColor() {
        return mHighlightTextColor;
    }

    /**
     * Returns the current text color of the editor.
     *
     * @see TextView#getCurrentTextColor()
     */
    public @ColorInt int getTextColor() {
        return mTextColor;
    }

    /**
     * Returns the current color of the hint text.
     *
     * @see TextView#getCurrentHintTextColor()
     */
    public @ColorInt int getHintTextColor() {
        return mHintTextColor;
    }

    /**
     * Returns the text color used to paint the links in the editor.
     *
     * @see TextView#getLinkTextColors()
     */
    public @ColorInt int getLinkTextColor() {
        return mLinkTextColor;
    }


    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof TextAppearanceInfo)) return false;
        TextAppearanceInfo that = (TextAppearanceInfo) o;
        return Float.compare(that.mTextSize, mTextSize) == 0
                && mTextFontWeight == that.mTextFontWeight && mTextStyle == that.mTextStyle
                && mAllCaps == that.mAllCaps && Float.compare(that.mShadowDx, mShadowDx) == 0
                && Float.compare(that.mShadowDy, mShadowDy) == 0 && Float.compare(
                that.mShadowRadius, mShadowRadius) == 0 && that.mShadowColor == mShadowColor
                && mElegantTextHeight == that.mElegantTextHeight
                && mFallbackLineSpacing == that.mFallbackLineSpacing && Float.compare(
                that.mLetterSpacing, mLetterSpacing) == 0 && mLineBreakStyle == that.mLineBreakStyle
                && mLineBreakWordStyle == that.mLineBreakWordStyle
                && mHighlightTextColor == that.mHighlightTextColor
                && mTextColor == that.mTextColor
                && mLinkTextColor == that.mLinkTextColor
                && mHintTextColor == that.mHintTextColor
                && Objects.equals(mTextLocales, that.mTextLocales)
                && Objects.equals(mSystemFontFamilyName, that.mSystemFontFamilyName)
                && Objects.equals(mFontFeatureSettings, that.mFontFeatureSettings)
                && Objects.equals(mFontVariationSettings, that.mFontVariationSettings)
                && Float.compare(that.mTextScaleX, mTextScaleX) == 0;
    }

    @Override
    public int hashCode() {
        return Objects.hash(mTextSize, mTextLocales, mSystemFontFamilyName, mTextFontWeight,
                mTextStyle, mAllCaps, mShadowDx, mShadowDy, mShadowRadius, mShadowColor,
                mElegantTextHeight, mFallbackLineSpacing, mLetterSpacing, mFontFeatureSettings,
                mFontVariationSettings, mLineBreakStyle, mLineBreakWordStyle, mTextScaleX,
                mHighlightTextColor, mTextColor, mHintTextColor, mLinkTextColor);
    }

    @Override
    public String toString() {
        return "TextAppearanceInfo{"
                + "mTextSize=" + mTextSize
                + ", mTextLocales=" + mTextLocales
                + ", mSystemFontFamilyName='" + mSystemFontFamilyName + '\''
                + ", mTextFontWeight=" + mTextFontWeight
                + ", mTextStyle=" + mTextStyle
                + ", mAllCaps=" + mAllCaps
                + ", mShadowDx=" + mShadowDx
                + ", mShadowDy=" + mShadowDy
                + ", mShadowRadius=" + mShadowRadius
                + ", mShadowColor=" + mShadowColor
                + ", mElegantTextHeight=" + mElegantTextHeight
                + ", mFallbackLineSpacing=" + mFallbackLineSpacing
                + ", mLetterSpacing=" + mLetterSpacing
                + ", mFontFeatureSettings='" + mFontFeatureSettings + '\''
                + ", mFontVariationSettings='" + mFontVariationSettings + '\''
                + ", mLineBreakStyle=" + mLineBreakStyle
                + ", mLineBreakWordStyle=" + mLineBreakWordStyle
                + ", mTextScaleX=" + mTextScaleX
                + ", mHighlightTextColor=" + mHighlightTextColor
                + ", mTextColor=" + mTextColor
                + ", mHintTextColor=" + mHintTextColor
                + ", mLinkTextColor=" + mLinkTextColor
                + '}';
    }

    /**
     * Builder for {@link TextAppearanceInfo}.
     */
    public static final class Builder {
        private @Px float mTextSize = -1;
        private @NonNull LocaleList mTextLocales = LocaleList.getAdjustedDefault();
        @Nullable private String mSystemFontFamilyName = null;
        @IntRange(from = FontStyle.FONT_WEIGHT_UNSPECIFIED, to = FontStyle.FONT_WEIGHT_MAX)
        private int mTextFontWeight = FontStyle.FONT_WEIGHT_UNSPECIFIED;
        private @Typeface.Style int mTextStyle = NORMAL;
        private boolean mAllCaps = false;
        private @Px float mShadowDx = 0;
        private @Px float mShadowDy = 0;
        private @Px float mShadowRadius = 0;
        private @ColorInt int mShadowColor = 0;
        private boolean mElegantTextHeight = false;
        private boolean mFallbackLineSpacing = false;
        private float mLetterSpacing = 0;
        @Nullable private String mFontFeatureSettings = null;
        @Nullable private String mFontVariationSettings = null;
        @LineBreakConfig.LineBreakStyle
        private int mLineBreakStyle = LineBreakConfig.LINE_BREAK_STYLE_NONE;
        @LineBreakConfig.LineBreakWordStyle
        private int mLineBreakWordStyle = LineBreakConfig.LINE_BREAK_WORD_STYLE_NONE;
        private float mTextScaleX = 1;
        private @ColorInt int mHighlightTextColor = 0;
        private @ColorInt int mTextColor = 0;
        private @ColorInt int mHintTextColor = 0;
        private @ColorInt int mLinkTextColor = 0;

        /**
         * Set the text size (in pixels) obtained from the current editor.
         */
        @NonNull
        public Builder setTextSize(@Px float textSize) {
            mTextSize = textSize;
            return this;
        }

        /**
         * Set the {@link LocaleList} of the text.
         */
        @NonNull
        public Builder setTextLocales(@NonNull LocaleList textLocales) {
            mTextLocales = textLocales;
            return this;
        }

        /**
         * Set the system font family name if the {@link Typeface} of the text is created from a
         * system font family.
         *
         * @see Typeface#getSystemFontFamilyName()
         */
        @NonNull
        public Builder setSystemFontFamilyName(@Nullable String systemFontFamilyName) {
            mSystemFontFamilyName = systemFontFamilyName;
            return this;
        }

        /**
         * Set the weight of the text.
         */
        @NonNull
        public Builder setTextFontWeight(
                @IntRange(from = FontStyle.FONT_WEIGHT_UNSPECIFIED,
                        to = FontStyle.FONT_WEIGHT_MAX) int textFontWeight) {
            mTextFontWeight = textFontWeight;
            return this;
        }

        /**
         * Set the style (normal, bold, italic, bold|italic) of the text.
         *
         * @see Typeface
         */
        @NonNull
        public Builder setTextStyle(@Typeface.Style int textStyle) {
            mTextStyle = textStyle;
            return this;
        }

        /**
         * Set whether the transformation method applied to the current editor  is set to all caps.
         *
         * @see TextView#setAllCaps(boolean)
         * @see TextView#setTransformationMethod(TransformationMethod)
         */
        @NonNull
        public Builder setAllCaps(boolean allCaps) {
            mAllCaps = allCaps;
            return this;
        }

        /**
         * Set the horizontal offset (in pixels) of the text shadow.
         *
         * @see Paint#setShadowLayer(float, float, float, int)
         */
        @NonNull
        public Builder setShadowDx(@Px float shadowDx) {
            mShadowDx = shadowDx;
            return this;
        }

        /**
         * Set the vertical offset (in pixels) of the text shadow.
         *
         * @see Paint#setShadowLayer(float, float, float, int)
         */
        @NonNull
        public Builder setShadowDy(@Px float shadowDy) {
            mShadowDy = shadowDy;
            return this;
        }

        /**
         * Set the blur radius (in pixels) of the text shadow.
         *
         * @see Paint#setShadowLayer(float, float, float, int)
         */
        @NonNull
        public Builder setShadowRadius(@Px float shadowRadius) {
            mShadowRadius = shadowRadius;
            return this;
        }

        /**
         * Set the color of the text shadow.
         *
         * @see Paint#setShadowLayer(float, float, float, int)
         */
        @NonNull
        public Builder setShadowColor(@ColorInt int shadowColor) {
            mShadowColor = shadowColor;
            return this;
        }

        /**
         * Set the elegant height metrics flag. This setting selects font variants that
         * have not been compacted to fit Latin-based vertical metrics, and also increases
         * top and bottom bounds to provide more space.
         *
         * @see Paint#isElegantTextHeight()
         */
        @NonNull
        public Builder setElegantTextHeight(boolean elegantTextHeight) {
            mElegantTextHeight = elegantTextHeight;
            return this;
        }

        /**
         * Set whether to expand linespacing based on fallback fonts.
         *
         * @see TextView#setFallbackLineSpacing(boolean)
         */
        @NonNull
        public Builder setFallbackLineSpacing(boolean fallbackLineSpacing) {
            mFallbackLineSpacing = fallbackLineSpacing;
            return this;
        }

        /**
         * Set the text letter-spacing, which determines the spacing between characters.
         * The value is in 'EM' units. Normally, this value is 0.0.
         */
        @NonNull
        public Builder setLetterSpacing(float letterSpacing) {
            mLetterSpacing = letterSpacing;
            return this;
        }

        /**
         * Set the font feature settings.
         *
         * @see Paint#getFontFeatureSettings()
         */
        @NonNull
        public Builder setFontFeatureSettings(@Nullable String fontFeatureSettings) {
            mFontFeatureSettings = fontFeatureSettings;
            return this;
        }

        /**
         * Set the font variation settings. Set {@code null} if no variation is specified.
         *
         * @see Paint#getFontVariationSettings()
         */
        @NonNull
        public Builder setFontVariationSettings(@Nullable String fontVariationSettings) {
            mFontVariationSettings = fontVariationSettings;
            return this;
        }

        /**
         * Set the line-break strategies for text wrapping.
         *
         * @see TextView#setLineBreakStyle(int)
         */
        @NonNull
        public Builder setLineBreakStyle(@LineBreakConfig.LineBreakStyle int lineBreakStyle) {
            mLineBreakStyle = lineBreakStyle;
            return this;
        }

        /**
         * Set the line-break word strategies for text wrapping.
         *
         * @see TextView#setLineBreakWordStyle(int)
         */
        @NonNull
        public Builder setLineBreakWordStyle(
                @LineBreakConfig.LineBreakWordStyle int lineBreakWordStyle) {
            mLineBreakWordStyle = lineBreakWordStyle;
            return this;
        }

        /**
         * Set the extent by which text should be stretched horizontally.
         */
        @NonNull
        public Builder setTextScaleX(float textScaleX) {
            mTextScaleX = textScaleX;
            return this;
        }

        /**
         * Set the color of the text selection highlight.
         *
         * @see TextView#getHighlightColor()
         */
        @NonNull
        public Builder setHighlightTextColor(@ColorInt int highlightTextColor) {
            mHighlightTextColor = highlightTextColor;
            return this;
        }

        /**
         * Set the current text color of the editor.
         *
         * @see TextView#getCurrentTextColor()
         */
        @NonNull
        public Builder setTextColor(@ColorInt int textColor) {
            mTextColor = textColor;
            return this;
        }

        /**
         * Set the current color of the hint text.
         *
         * @see TextView#getCurrentHintTextColor()
         */
        @NonNull
        public Builder setHintTextColor(@ColorInt int hintTextColor) {
            mHintTextColor = hintTextColor;
            return this;
        }

        /**
         * Set the text color used to paint the links in the editor.
         *
         * @see TextView#getLinkTextColors()
         */
        @NonNull
        public Builder setLinkTextColor(@ColorInt int linkTextColor) {
            mLinkTextColor = linkTextColor;
            return this;
        }

        /**
         * Returns {@link TextAppearanceInfo} using parameters in this
         * {@link TextAppearanceInfo.Builder}.
         */
        @NonNull
        public TextAppearanceInfo build() {
            return new TextAppearanceInfo(this);
        }
    }
}