/*
 * Copyright (C) 2018 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.contentcapture;

import android.annotation.NonNull;
import android.annotation.Nullable;
import android.annotation.SystemApi;
import android.annotation.TestApi;
import android.app.assist.AssistStructure;
import android.graphics.Matrix;
import android.graphics.Rect;
import android.os.Bundle;
import android.os.LocaleList;
import android.os.Parcel;
import android.text.TextUtils;
import android.util.Log;
import android.view.View;
import android.view.ViewParent;
import android.view.ViewStructure;
import android.view.ViewStructure.HtmlInfo.Builder;
import android.view.autofill.AutofillId;
import android.view.autofill.AutofillValue;

import com.android.internal.util.Preconditions;

//TODO(b/122484602): add javadocs / implement Parcelable / implement
//TODO(b/122484602): for now it's extending ViewNode directly as it needs most of its properties,
// but it might be better to create a common, abstract android.view.ViewNode class that both extend
// instead
/** @hide */
@SystemApi
@TestApi
public final class ViewNode extends AssistStructure.ViewNode {

    private static final String TAG = ViewNode.class.getSimpleName();

    private static final long FLAGS_HAS_TEXT = 1L << 0;
    private static final long FLAGS_HAS_COMPLEX_TEXT = 1L << 1;
    private static final long FLAGS_VISIBILITY_MASK = View.VISIBLE | View.INVISIBLE | View.GONE;
    private static final long FLAGS_HAS_CLASSNAME = 1L << 4;
    private static final long FLAGS_HAS_AUTOFILL_ID = 1L << 5;
    private static final long FLAGS_HAS_AUTOFILL_PARENT_ID = 1L << 6;
    private static final long FLAGS_HAS_ID = 1L << 7;
    private static final long FLAGS_HAS_LARGE_COORDS = 1L << 8;
    private static final long FLAGS_HAS_SCROLL = 1L << 9;
    private static final long FLAGS_ASSIST_BLOCKED = 1L << 10;
    private static final long FLAGS_DISABLED = 1L << 11;
    private static final long FLAGS_CLICKABLE = 1L << 12;
    private static final long FLAGS_LONG_CLICKABLE = 1L << 13;
    private static final long FLAGS_CONTEXT_CLICKABLE = 1L << 14;
    private static final long FLAGS_FOCUSABLE = 1L << 15;
    private static final long FLAGS_FOCUSED = 1L << 16;
    private static final long FLAGS_ACCESSIBILITY_FOCUSED = 1L << 17;
    private static final long FLAGS_CHECKABLE = 1L << 18;
    private static final long FLAGS_CHECKED = 1L << 19;
    private static final long FLAGS_SELECTED = 1L << 20;
    private static final long FLAGS_ACTIVATED = 1L << 21;
    private static final long FLAGS_OPAQUE = 1L << 22;
    private static final long FLAGS_HAS_CONTENT_DESCRIPTION = 1L << 23;
    private static final long FLAGS_HAS_EXTRAS = 1L << 24;
    private static final long FLAGS_HAS_LOCALE_LIST = 1L << 25;
    private static final long FLAGS_HAS_INPUT_TYPE = 1L << 26;
    private static final long FLAGS_HAS_MIN_TEXT_EMS = 1L << 27;
    private static final long FLAGS_HAS_MAX_TEXT_EMS = 1L << 28;
    private static final long FLAGS_HAS_MAX_TEXT_LENGTH = 1L << 29;
    private static final long FLAGS_HAS_TEXT_ID_ENTRY = 1L << 30;
    private static final long FLAGS_HAS_AUTOFILL_TYPE = 1L << 31;
    private static final long FLAGS_HAS_AUTOFILL_VALUE = 1L << 32;
    private static final long FLAGS_HAS_AUTOFILL_HINTS = 1L << 33;
    private static final long FLAGS_HAS_AUTOFILL_OPTIONS = 1L << 34;

    /** Flags used to optimize what's written to the parcel */
    private long mFlags;

    private AutofillId mParentAutofillId;

    private AutofillId mAutofillId;
    private ViewNodeText mText;
    private String mClassName;
    private int mId = View.NO_ID;
    private String mIdPackage;
    private String mIdType;
    private String mIdEntry;
    private int mX;
    private int mY;
    private int mScrollX;
    private int mScrollY;
    private int mWidth;
    private int mHeight;
    private CharSequence mContentDescription;
    private Bundle mExtras;
    private LocaleList mLocaleList;
    private int mInputType;
    private int mMinEms = -1;
    private int mMaxEms = -1;
    private int mMaxLength = -1;
    private String mTextIdEntry;
    private @View.AutofillType int mAutofillType = View.AUTOFILL_TYPE_NONE;
    private String[] mAutofillHints;
    private AutofillValue mAutofillValue;
    private CharSequence[] mAutofillOptions;

    /** @hide */
    public ViewNode() {
    }

    private ViewNode(long nodeFlags, @NonNull Parcel parcel) {
        mFlags = nodeFlags;

        if ((nodeFlags & FLAGS_HAS_AUTOFILL_ID) != 0) {
            mAutofillId = parcel.readParcelable(null);
        }
        if ((nodeFlags & FLAGS_HAS_AUTOFILL_PARENT_ID) != 0) {
            mParentAutofillId = parcel.readParcelable(null);
        }
        if ((nodeFlags & FLAGS_HAS_TEXT) != 0) {
            mText = new ViewNodeText(parcel, (nodeFlags & FLAGS_HAS_COMPLEX_TEXT) == 0);
        }
        if ((nodeFlags & FLAGS_HAS_CLASSNAME) != 0) {
            mClassName = parcel.readString();
        }
        if ((nodeFlags & FLAGS_HAS_ID) != 0) {
            mId = parcel.readInt();
            if (mId != View.NO_ID) {
                mIdEntry = parcel.readString();
                if (mIdEntry != null) {
                    mIdType = parcel.readString();
                    mIdPackage = parcel.readString();
                }
            }
        }
        if ((nodeFlags & FLAGS_HAS_LARGE_COORDS) != 0) {
            mX = parcel.readInt();
            mY = parcel.readInt();
            mWidth = parcel.readInt();
            mHeight = parcel.readInt();
        } else {
            int val = parcel.readInt();
            mX = val & 0x7fff;
            mY = (val >> 16) & 0x7fff;
            val = parcel.readInt();
            mWidth = val & 0x7fff;
            mHeight = (val >> 16) & 0x7fff;
        }
        if ((nodeFlags & FLAGS_HAS_SCROLL) != 0) {
            mScrollX = parcel.readInt();
            mScrollY = parcel.readInt();
        }
        if ((nodeFlags & FLAGS_HAS_CONTENT_DESCRIPTION) != 0) {
            mContentDescription = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(parcel);
        }
        if ((nodeFlags & FLAGS_HAS_EXTRAS) != 0) {
            mExtras = parcel.readBundle();
        }
        if ((nodeFlags & FLAGS_HAS_LOCALE_LIST) != 0) {
            mLocaleList = parcel.readParcelable(null);
        }
        if ((nodeFlags & FLAGS_HAS_INPUT_TYPE) != 0) {
            mInputType = parcel.readInt();
        }
        if ((nodeFlags & FLAGS_HAS_MIN_TEXT_EMS) != 0) {
            mMinEms = parcel.readInt();
        }
        if ((nodeFlags & FLAGS_HAS_MAX_TEXT_EMS) != 0) {
            mMaxEms = parcel.readInt();
        }
        if ((nodeFlags & FLAGS_HAS_MAX_TEXT_LENGTH) != 0) {
            mMaxLength = parcel.readInt();
        }
        if ((nodeFlags & FLAGS_HAS_TEXT_ID_ENTRY) != 0) {
            mTextIdEntry = parcel.readString();
        }
        if ((nodeFlags & FLAGS_HAS_AUTOFILL_TYPE) != 0) {
            mAutofillType = parcel.readInt();
        }
        if ((nodeFlags & FLAGS_HAS_AUTOFILL_HINTS) != 0) {
            mAutofillHints = parcel.readStringArray();
        }
        if ((nodeFlags & FLAGS_HAS_AUTOFILL_VALUE) != 0) {
            mAutofillValue = parcel.readParcelable(null);
        }
        if ((nodeFlags & FLAGS_HAS_AUTOFILL_OPTIONS) != 0) {
            mAutofillOptions = parcel.readCharSequenceArray();
        }
    }

    /**
     * Returns the {@link AutofillId} of this view's parent, if the parent is also part of the
     * screen observation tree.
     */
    @Nullable
    public AutofillId getParentAutofillId() {
        return mParentAutofillId;
    }

    @Override
    public AutofillId getAutofillId() {
        return mAutofillId;
    }

    @Override
    public CharSequence getText() {
        return mText != null ? mText.mText : null;
    }

    @Override
    public String getClassName() {
        return mClassName;
    }

    @Override
    public int getId() {
        return mId;
    }

    @Override
    public String getIdPackage() {
        return mIdPackage;
    }

    @Override
    public String getIdType() {
        return mIdType;
    }

    @Override
    public String getIdEntry() {
        return mIdEntry;
    }

    @Override
    public int getLeft() {
        return mX;
    }

    @Override
    public int getTop() {
        return mY;
    }

    @Override
    public int getScrollX() {
        return mScrollX;
    }

    @Override
    public int getScrollY() {
        return mScrollY;
    }

    @Override
    public int getWidth() {
        return mWidth;
    }

    @Override
    public int getHeight() {
        return mHeight;
    }

    @Override
    public boolean isAssistBlocked() {
        return (mFlags & FLAGS_ASSIST_BLOCKED) != 0;
    }

    @Override
    public boolean isEnabled() {
        return (mFlags & FLAGS_DISABLED) == 0;
    }

    @Override
    public boolean isClickable() {
        return (mFlags & FLAGS_CLICKABLE) != 0;
    }

    @Override
    public boolean isLongClickable() {
        return (mFlags & FLAGS_LONG_CLICKABLE) != 0;
    }

    @Override
    public boolean isContextClickable() {
        return (mFlags & FLAGS_CONTEXT_CLICKABLE) != 0;
    }

    @Override
    public boolean isFocusable() {
        return (mFlags & FLAGS_FOCUSABLE) != 0;
    }

    @Override
    public boolean isFocused() {
        return (mFlags & FLAGS_FOCUSED) != 0;
    }

    @Override
    public boolean isAccessibilityFocused() {
        return (mFlags & FLAGS_ACCESSIBILITY_FOCUSED) != 0;
    }

    @Override
    public boolean isCheckable() {
        return (mFlags & FLAGS_CHECKABLE) != 0;
    }

    @Override
    public boolean isChecked() {
        return (mFlags & FLAGS_CHECKED) != 0;
    }

    @Override
    public boolean isSelected() {
        return (mFlags & FLAGS_SELECTED) != 0;
    }

    @Override
    public boolean isActivated() {
        return (mFlags & FLAGS_ACTIVATED) != 0;
    }

    @Override
    public boolean isOpaque() {
        return (mFlags & FLAGS_OPAQUE) != 0;
    }

    @Override
    public CharSequence getContentDescription() {
        return mContentDescription;
    }

    @Override
    public Bundle getExtras() {
        return mExtras;
    }

    @Override
    public String getHint() {
        return mText != null ? mText.mHint : null;
    }

    @Override
    public int getTextSelectionStart() {
        return mText != null ? mText.mTextSelectionStart : -1;
    }

    @Override
    public int getTextSelectionEnd() {
        return mText != null ? mText.mTextSelectionEnd : -1;
    }

    @Override
    public int getTextColor() {
        return mText != null ? mText.mTextColor : TEXT_COLOR_UNDEFINED;
    }

    @Override
    public int getTextBackgroundColor() {
        return mText != null ? mText.mTextBackgroundColor : TEXT_COLOR_UNDEFINED;
    }

    @Override
    public float getTextSize() {
        return mText != null ? mText.mTextSize : 0;
    }

    @Override
    public int getTextStyle() {
        return mText != null ? mText.mTextStyle : 0;
    }

    @Override
    public int[] getTextLineCharOffsets() {
        return mText != null ? mText.mLineCharOffsets : null;
    }

    @Override
    public int[] getTextLineBaselines() {
        return mText != null ? mText.mLineBaselines : null;
    }

    @Override
    public int getVisibility() {
        return (int) (mFlags & FLAGS_VISIBILITY_MASK);
    }

    @Override
    public int getInputType() {
        return mInputType;
    }

    @Override
    public int getMinTextEms() {
        return mMinEms;
    }

    @Override
    public int getMaxTextEms() {
        return mMaxEms;
    }

    @Override
    public int getMaxTextLength() {
        return mMaxLength;
    }

    @Override
    public String getTextIdEntry() {
        return mTextIdEntry;
    }

    @Override
    public @View.AutofillType int getAutofillType() {
        return mAutofillType;
    }

    @Override
    @Nullable public String[] getAutofillHints() {
        return mAutofillHints;
    }

    @Override
    @Nullable public AutofillValue getAutofillValue() {
        return mAutofillValue;
    }

    @Override
    @Nullable public CharSequence[] getAutofillOptions() {
        return mAutofillOptions;
    }

    @Override
    public LocaleList getLocaleList() {
        return mLocaleList;
    }

    private void writeSelfToParcel(@NonNull Parcel parcel, int parcelFlags) {
        long nodeFlags = mFlags;

        if (mAutofillId != null) {
            nodeFlags |= FLAGS_HAS_AUTOFILL_ID;
        }

        if (mParentAutofillId != null) {
            nodeFlags |= FLAGS_HAS_AUTOFILL_PARENT_ID;
        }

        if (mText != null) {
            nodeFlags |= FLAGS_HAS_TEXT;
            if (!mText.isSimple()) {
                nodeFlags |= FLAGS_HAS_COMPLEX_TEXT;
            }
        }
        if (mClassName != null) {
            nodeFlags |= FLAGS_HAS_CLASSNAME;
        }
        if (mId != View.NO_ID) {
            nodeFlags |= FLAGS_HAS_ID;
        }
        if ((mX & ~0x7fff) != 0 || (mY & ~0x7fff) != 0
                || (mWidth & ~0x7fff) != 0 | (mHeight & ~0x7fff) != 0) {
            nodeFlags |= FLAGS_HAS_LARGE_COORDS;
        }
        if (mScrollX != 0 || mScrollY != 0) {
            nodeFlags |= FLAGS_HAS_SCROLL;
        }
        if (mContentDescription != null) {
            nodeFlags |= FLAGS_HAS_CONTENT_DESCRIPTION;
        }
        if (mExtras != null) {
            nodeFlags |= FLAGS_HAS_EXTRAS;
        }
        if (mLocaleList != null) {
            nodeFlags |= FLAGS_HAS_LOCALE_LIST;
        }
        if (mInputType != 0) {
            nodeFlags |= FLAGS_HAS_INPUT_TYPE;
        }
        if (mMinEms > -1) {
            nodeFlags |= FLAGS_HAS_MIN_TEXT_EMS;
        }
        if (mMaxEms > -1) {
            nodeFlags |= FLAGS_HAS_MAX_TEXT_EMS;
        }
        if (mMaxLength > -1) {
            nodeFlags |= FLAGS_HAS_MAX_TEXT_LENGTH;
        }
        if (mTextIdEntry != null) {
            nodeFlags |= FLAGS_HAS_TEXT_ID_ENTRY;
        }
        if (mAutofillValue != null) {
            nodeFlags |= FLAGS_HAS_AUTOFILL_VALUE;
        }
        if (mAutofillType != View.AUTOFILL_TYPE_NONE) {
            nodeFlags |= FLAGS_HAS_AUTOFILL_TYPE;
        }
        if (mAutofillHints != null) {
            nodeFlags |= FLAGS_HAS_AUTOFILL_HINTS;
        }
        if (mAutofillOptions != null) {
            nodeFlags |= FLAGS_HAS_AUTOFILL_OPTIONS;
        }
        parcel.writeLong(nodeFlags);

        if ((nodeFlags & FLAGS_HAS_AUTOFILL_ID) != 0) {
            parcel.writeParcelable(mAutofillId, parcelFlags);
        }
        if ((nodeFlags & FLAGS_HAS_AUTOFILL_PARENT_ID) != 0) {
            parcel.writeParcelable(mParentAutofillId, parcelFlags);
        }
        if ((nodeFlags & FLAGS_HAS_TEXT) != 0) {
            mText.writeToParcel(parcel, (nodeFlags & FLAGS_HAS_COMPLEX_TEXT) == 0);
        }
        if ((nodeFlags & FLAGS_HAS_CLASSNAME) != 0) {
            parcel.writeString(mClassName);
        }
        if ((nodeFlags & FLAGS_HAS_ID) != 0) {
            parcel.writeInt(mId);
            if (mId != View.NO_ID) {
                parcel.writeString(mIdEntry);
                if (mIdEntry != null) {
                    parcel.writeString(mIdType);
                    parcel.writeString(mIdPackage);
                }
            }
        }
        if ((nodeFlags & FLAGS_HAS_LARGE_COORDS) != 0) {
            parcel.writeInt(mX);
            parcel.writeInt(mY);
            parcel.writeInt(mWidth);
            parcel.writeInt(mHeight);
        } else {
            parcel.writeInt((mY << 16) | mX);
            parcel.writeInt((mHeight << 16) | mWidth);
        }
        if ((nodeFlags & FLAGS_HAS_SCROLL) != 0) {
            parcel.writeInt(mScrollX);
            parcel.writeInt(mScrollY);
        }
        if ((nodeFlags & FLAGS_HAS_CONTENT_DESCRIPTION) != 0) {
            TextUtils.writeToParcel(mContentDescription, parcel, 0);
        }
        if ((nodeFlags & FLAGS_HAS_EXTRAS) != 0) {
            parcel.writeBundle(mExtras);
        }
        if ((nodeFlags & FLAGS_HAS_LOCALE_LIST) != 0) {
            parcel.writeParcelable(mLocaleList, 0);
        }
        if ((nodeFlags & FLAGS_HAS_INPUT_TYPE) != 0) {
            parcel.writeInt(mInputType);
        }
        if ((nodeFlags & FLAGS_HAS_MIN_TEXT_EMS) != 0) {
            parcel.writeInt(mMinEms);
        }
        if ((nodeFlags & FLAGS_HAS_MAX_TEXT_EMS) != 0) {
            parcel.writeInt(mMaxEms);
        }
        if ((nodeFlags & FLAGS_HAS_MAX_TEXT_LENGTH) != 0) {
            parcel.writeInt(mMaxLength);
        }
        if ((nodeFlags & FLAGS_HAS_TEXT_ID_ENTRY) != 0) {
            parcel.writeString(mTextIdEntry);
        }
        if ((nodeFlags & FLAGS_HAS_AUTOFILL_TYPE) != 0) {
            parcel.writeInt(mAutofillType);
        }
        if ((nodeFlags & FLAGS_HAS_AUTOFILL_HINTS) != 0) {
            parcel.writeStringArray(mAutofillHints);
        }
        if ((nodeFlags & FLAGS_HAS_AUTOFILL_VALUE) != 0) {
            parcel.writeParcelable(mAutofillValue, 0);
        }
        if ((nodeFlags & FLAGS_HAS_AUTOFILL_OPTIONS) != 0) {
            parcel.writeCharSequenceArray(mAutofillOptions);
        }
    }

    /** @hide */
    @TestApi
    public static void writeToParcel(@NonNull Parcel parcel, @Nullable ViewNode node, int flags) {
        if (node == null) {
            parcel.writeLong(0);
        } else {
            node.writeSelfToParcel(parcel, flags);
        }
    }

    /** @hide */
    @TestApi
    public static @Nullable ViewNode readFromParcel(@NonNull Parcel parcel) {
        final long nodeFlags = parcel.readLong();
        return nodeFlags == 0 ? null : new ViewNode(nodeFlags, parcel);
    }

    /** @hide */
    @TestApi
    public static final class ViewStructureImpl extends ViewStructure {

        final ViewNode mNode = new ViewNode();

        /** @hide */
        @TestApi
        public ViewStructureImpl(@NonNull View view) {
            mNode.mAutofillId = Preconditions.checkNotNull(view).getAutofillId();
            final ViewParent parent = view.getParent();
            if (parent instanceof View) {
                mNode.mParentAutofillId = ((View) parent).getAutofillId();
            }
        }

        /** @hide */
        @TestApi
        public ViewStructureImpl(@NonNull AutofillId parentId, long virtualId, int sessionId) {
            mNode.mParentAutofillId = Preconditions.checkNotNull(parentId);
            mNode.mAutofillId = new AutofillId(parentId, virtualId, sessionId);
        }

        /** @hide */
        @TestApi
        public ViewNode getNode() {
            return mNode;
        }

        @Override
        public void setId(int id, String packageName, String typeName, String entryName) {
            mNode.mId = id;
            mNode.mIdPackage = packageName;
            mNode.mIdType = typeName;
            mNode.mIdEntry = entryName;
        }

        @Override
        public void setDimens(int left, int top, int scrollX, int scrollY, int width, int height) {
            mNode.mX = left;
            mNode.mY = top;
            mNode.mScrollX = scrollX;
            mNode.mScrollY = scrollY;
            mNode.mWidth = width;
            mNode.mHeight = height;
        }

        @Override
        public void setTransformation(Matrix matrix) {
            Log.w(TAG, "setTransformation() is not supported");
        }

        @Override
        public void setElevation(float elevation) {
            Log.w(TAG, "setElevation() is not supported");
        }

        @Override
        public void setAlpha(float alpha) {
            Log.w(TAG, "setAlpha() is not supported");
        }

        @Override
        public void setVisibility(int visibility) {
            mNode.mFlags = (mNode.mFlags & ~FLAGS_VISIBILITY_MASK)
                    | (visibility & FLAGS_VISIBILITY_MASK);
        }

        @Override
        public void setAssistBlocked(boolean state) {
            mNode.mFlags = (mNode.mFlags & ~FLAGS_ASSIST_BLOCKED)
                    | (state ? FLAGS_ASSIST_BLOCKED : 0);
        }

        @Override
        public void setEnabled(boolean state) {
            mNode.mFlags = (mNode.mFlags & ~FLAGS_DISABLED) | (state ? 0 : FLAGS_DISABLED);
        }

        @Override
        public void setClickable(boolean state) {
            mNode.mFlags = (mNode.mFlags & ~FLAGS_CLICKABLE) | (state ? FLAGS_CLICKABLE : 0);
        }

        @Override
        public void setLongClickable(boolean state) {
            mNode.mFlags = (mNode.mFlags & ~FLAGS_LONG_CLICKABLE)
                    | (state ? FLAGS_LONG_CLICKABLE : 0);
        }

        @Override
        public void setContextClickable(boolean state) {
            mNode.mFlags = (mNode.mFlags & ~FLAGS_CONTEXT_CLICKABLE)
                    | (state ? FLAGS_CONTEXT_CLICKABLE : 0);
        }

        @Override
        public void setFocusable(boolean state) {
            mNode.mFlags = (mNode.mFlags & ~FLAGS_FOCUSABLE) | (state ? FLAGS_FOCUSABLE : 0);
        }

        @Override
        public void setFocused(boolean state) {
            mNode.mFlags = (mNode.mFlags & ~FLAGS_FOCUSED) | (state ? FLAGS_FOCUSED : 0);
        }

        @Override
        public void setAccessibilityFocused(boolean state) {
            mNode.mFlags = (mNode.mFlags & ~FLAGS_ACCESSIBILITY_FOCUSED)
                    | (state ? FLAGS_ACCESSIBILITY_FOCUSED : 0);
        }

        @Override
        public void setCheckable(boolean state) {
            mNode.mFlags = (mNode.mFlags & ~FLAGS_CHECKABLE) | (state ? FLAGS_CHECKABLE : 0);
        }

        @Override
        public void setChecked(boolean state) {
            mNode.mFlags = (mNode.mFlags & ~FLAGS_CHECKED) | (state ? FLAGS_CHECKED : 0);
        }

        @Override
        public void setSelected(boolean state) {
            mNode.mFlags = (mNode.mFlags & ~FLAGS_SELECTED) | (state ? FLAGS_SELECTED : 0);
        }

        @Override
        public void setActivated(boolean state) {
            mNode.mFlags = (mNode.mFlags & ~FLAGS_ACTIVATED) | (state ? FLAGS_ACTIVATED : 0);
        }

        @Override
        public void setOpaque(boolean opaque) {
            mNode.mFlags = (mNode.mFlags & ~FLAGS_OPAQUE) | (opaque ? FLAGS_OPAQUE : 0);
        }

        @Override
        public void setClassName(String className) {
            mNode.mClassName = className;
        }

        @Override
        public void setContentDescription(CharSequence contentDescription) {
            mNode.mContentDescription = contentDescription;
        }

        @Override
        public void setText(CharSequence text) {
            final ViewNodeText t = getNodeText();
            t.mText = TextUtils.trimNoCopySpans(text);
            t.mTextSelectionStart = t.mTextSelectionEnd = -1;
        }

        @Override
        public void setText(CharSequence text, int selectionStart, int selectionEnd) {
            final ViewNodeText t = getNodeText();
            t.mText = TextUtils.trimNoCopySpans(text);
            t.mTextSelectionStart = selectionStart;
            t.mTextSelectionEnd = selectionEnd;
        }

        @Override
        public void setTextStyle(float size, int fgColor, int bgColor, int style) {
            final ViewNodeText t = getNodeText();
            t.mTextColor = fgColor;
            t.mTextBackgroundColor = bgColor;
            t.mTextSize = size;
            t.mTextStyle = style;
        }

        @Override
        public void setTextLines(int[] charOffsets, int[] baselines) {
            final ViewNodeText t = getNodeText();
            t.mLineCharOffsets = charOffsets;
            t.mLineBaselines = baselines;
        }

        @Override
        public void setTextIdEntry(String entryName) {
            mNode.mTextIdEntry = Preconditions.checkNotNull(entryName);
        }

        @Override
        public void setHint(CharSequence hint) {
            getNodeText().mHint = hint != null ? hint.toString() : null;
        }

        @Override
        public CharSequence getText() {
            return mNode.getText();
        }

        @Override
        public int getTextSelectionStart() {
            return mNode.getTextSelectionStart();
        }

        @Override
        public int getTextSelectionEnd() {
            return mNode.getTextSelectionEnd();
        }

        @Override
        public CharSequence getHint() {
            return mNode.getHint();
        }

        @Override
        public Bundle getExtras() {
            if (mNode.mExtras != null) {
                return mNode.mExtras;
            }
            mNode.mExtras = new Bundle();
            return mNode.mExtras;
        }

        @Override
        public boolean hasExtras() {
            return mNode.mExtras != null;
        }

        @Override
        public void setChildCount(int num) {
            Log.w(TAG, "setChildCount() is not supported");
        }

        @Override
        public int addChildCount(int num) {
            Log.w(TAG, "addChildCount() is not supported");
            return 0;
        }

        @Override
        public int getChildCount() {
            Log.w(TAG, "getChildCount() is not supported");
            return 0;
        }

        @Override
        public ViewStructure newChild(int index) {
            Log.w(TAG, "newChild() is not supported");
            return null;
        }

        @Override
        public ViewStructure asyncNewChild(int index) {
            Log.w(TAG, "asyncNewChild() is not supported");
            return null;
        }

        @Override
        public AutofillId getAutofillId() {
            return mNode.mAutofillId;
        }

        @Override
        public void setAutofillId(AutofillId id) {
            mNode.mAutofillId = Preconditions.checkNotNull(id);
        }


        @Override
        public void setAutofillId(AutofillId parentId, int virtualId) {
            mNode.mParentAutofillId = Preconditions.checkNotNull(parentId);
            mNode.mAutofillId = new AutofillId(parentId, virtualId);
        }

        @Override
        public void setAutofillType(@View.AutofillType int type) {
            mNode.mAutofillType = type;
        }

        @Override
        public void setAutofillHints(String[] hints) {
            mNode.mAutofillHints = hints;
        }

        @Override
        public void setAutofillValue(AutofillValue value) {
            mNode.mAutofillValue = value;
        }

        @Override
        public void setAutofillOptions(CharSequence[] options) {
            mNode.mAutofillOptions = options;
        }

        @Override
        public void setInputType(int inputType) {
            mNode.mInputType = inputType;
        }

        @Override
        public void setMinTextEms(int minEms) {
            mNode.mMinEms = minEms;
        }

        @Override
        public void setMaxTextEms(int maxEms) {
            mNode.mMaxEms = maxEms;
        }

        @Override
        public void setMaxTextLength(int maxLength) {
            mNode.mMaxLength = maxLength;
        }

        @Override
        public void setDataIsSensitive(boolean sensitive) {
            Log.w(TAG, "setDataIsSensitive() is not supported");
        }

        @Override
        public void asyncCommit() {
            Log.w(TAG, "asyncCommit() is not supported");
        }

        @Override
        public Rect getTempRect() {
            Log.w(TAG, "getTempRect() is not supported");
            return null;
        }

        @Override
        public void setWebDomain(String domain) {
            Log.w(TAG, "setWebDomain() is not supported");
        }

        @Override
        public void setLocaleList(LocaleList localeList) {
            mNode.mLocaleList = localeList;
        }

        @Override
        public Builder newHtmlInfoBuilder(String tagName) {
            Log.w(TAG, "newHtmlInfoBuilder() is not supported");
            return null;
        }

        @Override
        public void setHtmlInfo(HtmlInfo htmlInfo) {
            Log.w(TAG, "setHtmlInfo() is not supported");
        }

        private ViewNodeText getNodeText() {
            if (mNode.mText != null) {
                return mNode.mText;
            }
            mNode.mText = new ViewNodeText();
            return mNode.mText;
        }
    }

    //TODO(b/122484602): copied 'as-is' from AssistStructure, except for writeSensitive
    static final class ViewNodeText {
        CharSequence mText;
        float mTextSize;
        int mTextStyle;
        int mTextColor = ViewNode.TEXT_COLOR_UNDEFINED;
        int mTextBackgroundColor = ViewNode.TEXT_COLOR_UNDEFINED;
        int mTextSelectionStart;
        int mTextSelectionEnd;
        int[] mLineCharOffsets;
        int[] mLineBaselines;
        String mHint;

        ViewNodeText() {
        }

        boolean isSimple() {
            return mTextBackgroundColor == ViewNode.TEXT_COLOR_UNDEFINED
                    && mTextSelectionStart == 0 && mTextSelectionEnd == 0
                    && mLineCharOffsets == null && mLineBaselines == null && mHint == null;
        }

        ViewNodeText(Parcel in, boolean simple) {
            mText = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(in);
            mTextSize = in.readFloat();
            mTextStyle = in.readInt();
            mTextColor = in.readInt();
            if (!simple) {
                mTextBackgroundColor = in.readInt();
                mTextSelectionStart = in.readInt();
                mTextSelectionEnd = in.readInt();
                mLineCharOffsets = in.createIntArray();
                mLineBaselines = in.createIntArray();
                mHint = in.readString();
            }
        }

        void writeToParcel(Parcel out, boolean simple) {
            TextUtils.writeToParcel(mText, out, 0);
            out.writeFloat(mTextSize);
            out.writeInt(mTextStyle);
            out.writeInt(mTextColor);
            if (!simple) {
                out.writeInt(mTextBackgroundColor);
                out.writeInt(mTextSelectionStart);
                out.writeInt(mTextSelectionEnd);
                out.writeIntArray(mLineCharOffsets);
                out.writeIntArray(mLineBaselines);
                out.writeString(mHint);
            }
        }
    }
}