/*
 * Copyright (C) 2016 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.graphics.drawable;

import com.android.layoutlib.bridge.impl.DelegateManager;
import com.android.tools.layoutlib.annotations.LayoutlibDelegate;

import android.annotation.NonNull;
import android.content.res.Resources;
import android.content.res.Resources.Theme;
import android.content.res.TypedArray;
import android.graphics.BaseCanvas_Delegate;
import android.graphics.Canvas_Delegate;
import android.graphics.Color;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.Paint.Cap;
import android.graphics.Paint.Join;
import android.graphics.Paint_Delegate;
import android.graphics.Path;
import android.graphics.Path.FillType;
import android.graphics.PathMeasure;
import android.graphics.Path_Delegate;
import android.graphics.Rect;
import android.graphics.Region;
import android.graphics.Region.Op;
import android.graphics.Shader_Delegate;
import android.util.ArrayMap;
import android.util.AttributeSet;
import android.util.Log;
import android.util.MathUtils;
import android.util.PathParser_Delegate;

import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;
import java.util.ArrayList;
import java.util.function.Consumer;

import static android.graphics.Canvas.CLIP_SAVE_FLAG;
import static android.graphics.Canvas.MATRIX_SAVE_FLAG;
import static android.graphics.Paint.Cap.BUTT;
import static android.graphics.Paint.Cap.ROUND;
import static android.graphics.Paint.Cap.SQUARE;
import static android.graphics.Paint.Join.BEVEL;
import static android.graphics.Paint.Join.MITER;
import static android.graphics.Paint.Style;

/**
 * Delegate used to provide new implementation of a select few methods of {@link VectorDrawable}
 * <p>
 * Through the layoutlib_create tool, the original  methods of VectorDrawable have been replaced by
 * calls to methods of the same name in this delegate class.
 */
@SuppressWarnings("unused")
public class VectorDrawable_Delegate {
    private static final String LOGTAG = VectorDrawable_Delegate.class.getSimpleName();
    private static final boolean DBG_VECTOR_DRAWABLE = false;

    private static final DelegateManager<VNativeObject> sPathManager =
            new DelegateManager<>(VNativeObject.class);

    private static long addNativeObject(VNativeObject object) {
        long ptr = sPathManager.addNewDelegate(object);
        object.setNativePtr(ptr);

        return ptr;
    }

    /**
     * Obtains styled attributes from the theme, if available, or unstyled resources if the theme is
     * null.
     */
    private static TypedArray obtainAttributes(
            Resources res, Theme theme, AttributeSet set, int[] attrs) {
        if (theme == null) {
            return res.obtainAttributes(set, attrs);
        }
        return theme.obtainStyledAttributes(set, attrs, 0, 0);
    }

    private static int applyAlpha(int color, float alpha) {
        int alphaBytes = Color.alpha(color);
        color &= 0x00FFFFFF;
        color |= ((int) (alphaBytes * alpha)) << 24;
        return color;
    }

    @LayoutlibDelegate
    static long nCreateTree(long rootGroupPtr) {
        return addNativeObject(new VPathRenderer_Delegate(rootGroupPtr));
    }

    @LayoutlibDelegate
    static long nCreateTreeFromCopy(long rendererToCopyPtr, long rootGroupPtr) {
        VPathRenderer_Delegate rendererToCopy = VNativeObject.getDelegate(rendererToCopyPtr);
        return addNativeObject(new VPathRenderer_Delegate(rendererToCopy,
                rootGroupPtr));
    }

    @LayoutlibDelegate
    static void nSetRendererViewportSize(long rendererPtr, float viewportWidth,
            float viewportHeight) {
        VPathRenderer_Delegate nativePathRenderer = VNativeObject.getDelegate(rendererPtr);
        nativePathRenderer.mViewportWidth = viewportWidth;
        nativePathRenderer.mViewportHeight = viewportHeight;
    }

    @LayoutlibDelegate
    static boolean nSetRootAlpha(long rendererPtr, float alpha) {
        VPathRenderer_Delegate nativePathRenderer = VNativeObject.getDelegate(rendererPtr);
        nativePathRenderer.setRootAlpha(alpha);

        return true;
    }

    @LayoutlibDelegate
    static float nGetRootAlpha(long rendererPtr) {
        VPathRenderer_Delegate nativePathRenderer = VNativeObject.getDelegate(rendererPtr);

        return nativePathRenderer.getRootAlpha();
    }

    @LayoutlibDelegate
    static void nSetAntiAlias(long rendererPtr, boolean aa) {
        VPathRenderer_Delegate nativePathRenderer = VNativeObject.getDelegate(rendererPtr);
        nativePathRenderer.setAntiAlias(aa);
    }

    @LayoutlibDelegate
    static void nSetAllowCaching(long rendererPtr, boolean allowCaching) {
        // ignored
    }

    @LayoutlibDelegate
    static int nDraw(long rendererPtr, long canvasWrapperPtr,
            long colorFilterPtr, Rect bounds, boolean needsMirroring, boolean canReuseCache) {
        VPathRenderer_Delegate nativePathRenderer = VNativeObject.getDelegate(rendererPtr);

        Canvas_Delegate.nSave(canvasWrapperPtr, MATRIX_SAVE_FLAG | CLIP_SAVE_FLAG);
        Canvas_Delegate.nClipRect(canvasWrapperPtr,
                bounds.left, bounds.top, bounds.right, bounds.bottom,
                Region.Op.INTERSECT.nativeInt);
        Canvas_Delegate.nTranslate(canvasWrapperPtr, bounds.left, bounds.top);

        if (needsMirroring) {
            Canvas_Delegate.nTranslate(canvasWrapperPtr, bounds.width(), 0);
            Canvas_Delegate.nScale(canvasWrapperPtr, -1.0f, 1.0f);
        }

        // At this point, canvas has been translated to the right position.
        // And we use this bound for the destination rect for the drawBitmap, so
        // we offset to (0, 0);
        bounds.offsetTo(0, 0);
        nativePathRenderer.draw(canvasWrapperPtr, colorFilterPtr, bounds.width(), bounds.height());

        Canvas_Delegate.nRestore(canvasWrapperPtr);

        return bounds.width() * bounds.height();
    }

    @LayoutlibDelegate
    static long nCreateFullPath() {
        return addNativeObject(new VFullPath_Delegate());
    }

    @LayoutlibDelegate
    static long nCreateFullPath(long nativeFullPathPtr) {
        VFullPath_Delegate original = VNativeObject.getDelegate(nativeFullPathPtr);
        return addNativeObject(new VFullPath_Delegate(original));
    }

    @LayoutlibDelegate
    static boolean nGetFullPathProperties(long pathPtr, byte[] propertiesData,
            int length) {
        VFullPath_Delegate path = VNativeObject.getDelegate(pathPtr);

        ByteBuffer properties = ByteBuffer.wrap(propertiesData);
        properties.order(ByteOrder.nativeOrder());

        properties.putFloat(VFullPath_Delegate.STROKE_WIDTH_INDEX * 4, path.getStrokeWidth());
        properties.putInt(VFullPath_Delegate.STROKE_COLOR_INDEX * 4, path.getStrokeColor());
        properties.putFloat(VFullPath_Delegate.STROKE_ALPHA_INDEX * 4, path.getStrokeAlpha());
        properties.putInt(VFullPath_Delegate.FILL_COLOR_INDEX * 4, path.getFillColor());
        properties.putFloat(VFullPath_Delegate.FILL_ALPHA_INDEX * 4, path.getStrokeAlpha());
        properties.putFloat(VFullPath_Delegate.TRIM_PATH_START_INDEX * 4, path.getTrimPathStart());
        properties.putFloat(VFullPath_Delegate.TRIM_PATH_END_INDEX * 4, path.getTrimPathEnd());
        properties.putFloat(VFullPath_Delegate.TRIM_PATH_OFFSET_INDEX * 4,
                path.getTrimPathOffset());
        properties.putInt(VFullPath_Delegate.STROKE_LINE_CAP_INDEX * 4, path.getStrokeLineCap());
        properties.putInt(VFullPath_Delegate.STROKE_LINE_JOIN_INDEX * 4, path.getStrokeLineJoin());
        properties.putFloat(VFullPath_Delegate.STROKE_MITER_LIMIT_INDEX * 4,
                path.getStrokeMiterlimit());
        properties.putInt(VFullPath_Delegate.FILL_TYPE_INDEX * 4, path.getFillType());

        return true;
    }

    @LayoutlibDelegate
    static void nUpdateFullPathProperties(long pathPtr, float strokeWidth,
            int strokeColor, float strokeAlpha, int fillColor, float fillAlpha, float trimPathStart,
            float trimPathEnd, float trimPathOffset, float strokeMiterLimit, int strokeLineCap,
            int strokeLineJoin, int fillType) {
        VFullPath_Delegate path = VNativeObject.getDelegate(pathPtr);

        path.setStrokeWidth(strokeWidth);
        path.setStrokeColor(strokeColor);
        path.setStrokeAlpha(strokeAlpha);
        path.setFillColor(fillColor);
        path.setFillAlpha(fillAlpha);
        path.setTrimPathStart(trimPathStart);
        path.setTrimPathEnd(trimPathEnd);
        path.setTrimPathOffset(trimPathOffset);
        path.setStrokeMiterlimit(strokeMiterLimit);
        path.setStrokeLineCap(strokeLineCap);
        path.setStrokeLineJoin(strokeLineJoin);
        path.setFillType(fillType);
    }

    @LayoutlibDelegate
    static void nUpdateFullPathFillGradient(long pathPtr, long fillGradientPtr) {
        VFullPath_Delegate path = VNativeObject.getDelegate(pathPtr);

        path.setFillGradient(fillGradientPtr);
    }

    @LayoutlibDelegate
    static void nUpdateFullPathStrokeGradient(long pathPtr, long strokeGradientPtr) {
        VFullPath_Delegate path = VNativeObject.getDelegate(pathPtr);

        path.setStrokeGradient(strokeGradientPtr);
    }

    @LayoutlibDelegate
    static long nCreateClipPath() {
        return addNativeObject(new VClipPath_Delegate());
    }

    @LayoutlibDelegate
    static long nCreateClipPath(long clipPathPtr) {
        VClipPath_Delegate original = VNativeObject.getDelegate(clipPathPtr);
        return addNativeObject(new VClipPath_Delegate(original));
    }

    @LayoutlibDelegate
    static long nCreateGroup() {
        return addNativeObject(new VGroup_Delegate());
    }

    @LayoutlibDelegate
    static long nCreateGroup(long groupPtr) {
        VGroup_Delegate original = VNativeObject.getDelegate(groupPtr);
        return addNativeObject(new VGroup_Delegate(original, new ArrayMap<>()));
    }

    @LayoutlibDelegate
    static void nSetName(long nodePtr, String name) {
        VNativeObject group = VNativeObject.getDelegate(nodePtr);
        group.setName(name);
    }

    @LayoutlibDelegate
    static boolean nGetGroupProperties(long groupPtr, float[] propertiesData,
            int length) {
        VGroup_Delegate group = VNativeObject.getDelegate(groupPtr);

        FloatBuffer properties = FloatBuffer.wrap(propertiesData);

        properties.put(VGroup_Delegate.ROTATE_INDEX, group.getRotation());
        properties.put(VGroup_Delegate.PIVOT_X_INDEX, group.getPivotX());
        properties.put(VGroup_Delegate.PIVOT_Y_INDEX, group.getPivotY());
        properties.put(VGroup_Delegate.SCALE_X_INDEX, group.getScaleX());
        properties.put(VGroup_Delegate.SCALE_Y_INDEX, group.getScaleY());
        properties.put(VGroup_Delegate.TRANSLATE_X_INDEX, group.getTranslateX());
        properties.put(VGroup_Delegate.TRANSLATE_Y_INDEX, group.getTranslateY());

        return true;
    }
    @LayoutlibDelegate
    static void nUpdateGroupProperties(long groupPtr, float rotate, float pivotX,
            float pivotY, float scaleX, float scaleY, float translateX, float translateY) {
        VGroup_Delegate group = VNativeObject.getDelegate(groupPtr);

        group.setRotation(rotate);
        group.setPivotX(pivotX);
        group.setPivotY(pivotY);
        group.setScaleX(scaleX);
        group.setScaleY(scaleY);
        group.setTranslateX(translateX);
        group.setTranslateY(translateY);
    }

    @LayoutlibDelegate
    static void nAddChild(long groupPtr, long nodePtr) {
        VGroup_Delegate group = VNativeObject.getDelegate(groupPtr);
        group.mChildren.add(VNativeObject.getDelegate(nodePtr));
    }

    @LayoutlibDelegate
    static void nSetPathString(long pathPtr, String pathString, int length) {
        VPath_Delegate path = VNativeObject.getDelegate(pathPtr);
        path.setPathData(PathParser_Delegate.createNodesFromPathData(pathString));
    }

    /**
     * The setters and getters below for paths and groups are here temporarily, and will be removed
     * once the animation in AVD is replaced with RenderNodeAnimator, in which case the animation
     * will modify these properties in native. By then no JNI hopping would be necessary for VD
     * during animation, and these setters and getters will be obsolete.
     */
    // Setters and getters during animation.
    @LayoutlibDelegate
    static float nGetRotation(long groupPtr) {
        VGroup_Delegate group = VNativeObject.getDelegate(groupPtr);
        return group.getRotation();
    }

    @LayoutlibDelegate
    static void nSetRotation(long groupPtr, float rotation) {
        VGroup_Delegate group = VNativeObject.getDelegate(groupPtr);
        group.setRotation(rotation);
    }

    @LayoutlibDelegate
    static float nGetPivotX(long groupPtr) {
        VGroup_Delegate group = VNativeObject.getDelegate(groupPtr);
        return group.getPivotX();
    }

    @LayoutlibDelegate
    static void nSetPivotX(long groupPtr, float pivotX) {
        VGroup_Delegate group = VNativeObject.getDelegate(groupPtr);
        group.setPivotX(pivotX);
    }

    @LayoutlibDelegate
    static float nGetPivotY(long groupPtr) {
        VGroup_Delegate group = VNativeObject.getDelegate(groupPtr);
        return group.getPivotY();
    }

    @LayoutlibDelegate
    static void nSetPivotY(long groupPtr, float pivotY) {
        VGroup_Delegate group = VNativeObject.getDelegate(groupPtr);
        group.setPivotY(pivotY);
    }

    @LayoutlibDelegate
    static float nGetScaleX(long groupPtr) {
        VGroup_Delegate group = VNativeObject.getDelegate(groupPtr);
        return group.getScaleX();
    }

    @LayoutlibDelegate
    static void nSetScaleX(long groupPtr, float scaleX) {
        VGroup_Delegate group = VNativeObject.getDelegate(groupPtr);
        group.setScaleX(scaleX);
    }

    @LayoutlibDelegate
    static float nGetScaleY(long groupPtr) {
        VGroup_Delegate group = VNativeObject.getDelegate(groupPtr);
        return group.getScaleY();
    }

    @LayoutlibDelegate
    static void nSetScaleY(long groupPtr, float scaleY) {
        VGroup_Delegate group = VNativeObject.getDelegate(groupPtr);
        group.setScaleY(scaleY);
    }

    @LayoutlibDelegate
    static float nGetTranslateX(long groupPtr) {
        VGroup_Delegate group = VNativeObject.getDelegate(groupPtr);
        return group.getTranslateX();
    }

    @LayoutlibDelegate
    static void nSetTranslateX(long groupPtr, float translateX) {
        VGroup_Delegate group = VNativeObject.getDelegate(groupPtr);
        group.setTranslateX(translateX);
    }

    @LayoutlibDelegate
    static float nGetTranslateY(long groupPtr) {
        VGroup_Delegate group = VNativeObject.getDelegate(groupPtr);
        return group.getTranslateY();
    }

    @LayoutlibDelegate
    static void nSetTranslateY(long groupPtr, float translateY) {
        VGroup_Delegate group = VNativeObject.getDelegate(groupPtr);
        group.setTranslateY(translateY);
    }

    @LayoutlibDelegate
    static void nSetPathData(long pathPtr, long pathDataPtr) {
        VPath_Delegate path = VNativeObject.getDelegate(pathPtr);
        path.setPathData(PathParser_Delegate.getDelegate(pathDataPtr).getPathDataNodes());
    }

    @LayoutlibDelegate
    static float nGetStrokeWidth(long pathPtr) {
        VFullPath_Delegate path = VNativeObject.getDelegate(pathPtr);
        return path.getStrokeWidth();
    }

    @LayoutlibDelegate
    static void nSetStrokeWidth(long pathPtr, float width) {
        VFullPath_Delegate path = VNativeObject.getDelegate(pathPtr);
        path.setStrokeWidth(width);
    }

    @LayoutlibDelegate
    static int nGetStrokeColor(long pathPtr) {
        VFullPath_Delegate path = VNativeObject.getDelegate(pathPtr);
        return path.getStrokeColor();
    }

    @LayoutlibDelegate
    static void nSetStrokeColor(long pathPtr, int strokeColor) {
        VFullPath_Delegate path = VNativeObject.getDelegate(pathPtr);
        path.setStrokeColor(strokeColor);
    }

    @LayoutlibDelegate
    static float nGetStrokeAlpha(long pathPtr) {
        VFullPath_Delegate path = VNativeObject.getDelegate(pathPtr);
        return path.getStrokeAlpha();
    }

    @LayoutlibDelegate
    static void nSetStrokeAlpha(long pathPtr, float alpha) {
        VFullPath_Delegate path = VNativeObject.getDelegate(pathPtr);
        path.setStrokeAlpha(alpha);
    }

    @LayoutlibDelegate
    static int nGetFillColor(long pathPtr) {
        VFullPath_Delegate path = VNativeObject.getDelegate(pathPtr);
        return path.getFillColor();
    }

    @LayoutlibDelegate
    static void nSetFillColor(long pathPtr, int fillColor) {
        VFullPath_Delegate path = VNativeObject.getDelegate(pathPtr);
        path.setFillColor(fillColor);
    }

    @LayoutlibDelegate
    static float nGetFillAlpha(long pathPtr) {
        VFullPath_Delegate path = VNativeObject.getDelegate(pathPtr);
        return path.getFillAlpha();
    }

    @LayoutlibDelegate
    static void nSetFillAlpha(long pathPtr, float fillAlpha) {
        VFullPath_Delegate path = VNativeObject.getDelegate(pathPtr);
        path.setFillAlpha(fillAlpha);
    }

    @LayoutlibDelegate
    static float nGetTrimPathStart(long pathPtr) {
        VFullPath_Delegate path = VNativeObject.getDelegate(pathPtr);
        return path.getTrimPathStart();
    }

    @LayoutlibDelegate
    static void nSetTrimPathStart(long pathPtr, float trimPathStart) {
        VFullPath_Delegate path = VNativeObject.getDelegate(pathPtr);
        path.setTrimPathStart(trimPathStart);
    }

    @LayoutlibDelegate
    static float nGetTrimPathEnd(long pathPtr) {
        VFullPath_Delegate path = VNativeObject.getDelegate(pathPtr);
        return path.getTrimPathEnd();
    }

    @LayoutlibDelegate
    static void nSetTrimPathEnd(long pathPtr, float trimPathEnd) {
        VFullPath_Delegate path = VNativeObject.getDelegate(pathPtr);
        path.setTrimPathEnd(trimPathEnd);
    }

    @LayoutlibDelegate
    static float nGetTrimPathOffset(long pathPtr) {
        VFullPath_Delegate path = VNativeObject.getDelegate(pathPtr);
        return path.getTrimPathOffset();
    }

    @LayoutlibDelegate
    static void nSetTrimPathOffset(long pathPtr, float trimPathOffset) {
        VFullPath_Delegate path = VNativeObject.getDelegate(pathPtr);
        path.setTrimPathOffset(trimPathOffset);
    }

    /**
     * Base class for all the internal Delegates that does two functions:
     * <ol>
     *     <li>Serves as base class to store all the delegates in one {@link DelegateManager}
     *     <li>Provides setName for all the classes. {@link VPathRenderer_Delegate} does actually
     *     not need it
     * </ol>
     */
    abstract static class VNativeObject {
        long mNativePtr = 0;

        @NonNull
        static <T> T getDelegate(long nativePtr) {
            //noinspection unchecked
            T vNativeObject = (T) sPathManager.getDelegate(nativePtr);

            assert vNativeObject != null;
            return vNativeObject;
        }

        abstract void setName(String name);

        void setNativePtr(long nativePtr) {
            mNativePtr = nativePtr;
        }

        /**
         * Method to explicitly dispose native objects
         */
        void dispose() {
        }
    }

    private static class VClipPath_Delegate extends VPath_Delegate {
        private VClipPath_Delegate() {
            // Empty constructor.
        }

        private VClipPath_Delegate(VClipPath_Delegate copy) {
            super(copy);
        }

        @Override
        public boolean isClipPath() {
            return true;
        }
    }

    static class VFullPath_Delegate extends VPath_Delegate {
        // These constants need to be kept in sync with their values in VectorDrawable.VFullPath
        private static final int STROKE_WIDTH_INDEX = 0;
        private static final int STROKE_COLOR_INDEX = 1;
        private static final int STROKE_ALPHA_INDEX = 2;
        private static final int FILL_COLOR_INDEX = 3;
        private static final int FILL_ALPHA_INDEX = 4;
        private static final int TRIM_PATH_START_INDEX = 5;
        private static final int TRIM_PATH_END_INDEX = 6;
        private static final int TRIM_PATH_OFFSET_INDEX = 7;
        private static final int STROKE_LINE_CAP_INDEX = 8;
        private static final int STROKE_LINE_JOIN_INDEX = 9;
        private static final int STROKE_MITER_LIMIT_INDEX = 10;
        private static final int FILL_TYPE_INDEX = 11;

        private static final int LINECAP_BUTT = 0;
        private static final int LINECAP_ROUND = 1;
        private static final int LINECAP_SQUARE = 2;

        private static final int LINEJOIN_MITER = 0;
        private static final int LINEJOIN_ROUND = 1;
        private static final int LINEJOIN_BEVEL = 2;

        @NonNull
        public Consumer<Float> getFloatPropertySetter(int propertyIdx) {
            switch (propertyIdx) {
                case STROKE_WIDTH_INDEX:
                    return this::setStrokeWidth;
                case STROKE_ALPHA_INDEX:
                    return this::setStrokeAlpha;
                case FILL_ALPHA_INDEX:
                    return this::setFillAlpha;
                case TRIM_PATH_START_INDEX:
                    return this::setTrimPathStart;
                case TRIM_PATH_END_INDEX:
                    return this::setTrimPathEnd;
                case TRIM_PATH_OFFSET_INDEX:
                    return this::setTrimPathOffset;
            }

            assert false : ("Invalid VFullPath_Delegate property index " + propertyIdx);
            return t -> {};
        }

        @NonNull
        public Consumer<Integer> getIntPropertySetter(int propertyIdx) {
            switch (propertyIdx) {
                case STROKE_COLOR_INDEX:
                    return this::setStrokeColor;
                case FILL_COLOR_INDEX:
                    return this::setFillColor;
            }

            assert false : ("Invalid VFullPath_Delegate property index " + propertyIdx);
            return t -> {};
        }

        /////////////////////////////////////////////////////
        // Variables below need to be copied (deep copy if applicable) for mutation.

        int mStrokeColor = Color.TRANSPARENT;
        float mStrokeWidth = 0;

        int mFillColor = Color.TRANSPARENT;
        long mStrokeGradient = 0;
        long mFillGradient = 0;
        float mStrokeAlpha = 1.0f;
        float mFillAlpha = 1.0f;
        float mTrimPathStart = 0;
        float mTrimPathEnd = 1;
        float mTrimPathOffset = 0;

        Cap mStrokeLineCap = BUTT;
        Join mStrokeLineJoin = MITER;
        float mStrokeMiterlimit = 4;

        int mFillType = 0; // WINDING(0) is the default value. See Path.FillType

        private VFullPath_Delegate() {
            // Empty constructor.
        }

        private VFullPath_Delegate(VFullPath_Delegate copy) {
            super(copy);

            mStrokeColor = copy.mStrokeColor;
            mStrokeWidth = copy.mStrokeWidth;
            mStrokeAlpha = copy.mStrokeAlpha;
            mFillColor = copy.mFillColor;
            mFillAlpha = copy.mFillAlpha;
            mTrimPathStart = copy.mTrimPathStart;
            mTrimPathEnd = copy.mTrimPathEnd;
            mTrimPathOffset = copy.mTrimPathOffset;

            mStrokeLineCap = copy.mStrokeLineCap;
            mStrokeLineJoin = copy.mStrokeLineJoin;
            mStrokeMiterlimit = copy.mStrokeMiterlimit;

            mStrokeGradient = copy.mStrokeGradient;
            mFillGradient = copy.mFillGradient;
            mFillType = copy.mFillType;
        }

        private int getStrokeLineCap() {
            switch (mStrokeLineCap) {
                case BUTT:
                    return LINECAP_BUTT;
                case ROUND:
                    return LINECAP_ROUND;
                case SQUARE:
                    return LINECAP_SQUARE;
                default:
                    assert false;
            }

            return -1;
        }

        private void setStrokeLineCap(int cap) {
            switch (cap) {
                case LINECAP_BUTT:
                    mStrokeLineCap = BUTT;
                    break;
                case LINECAP_ROUND:
                    mStrokeLineCap = ROUND;
                    break;
                case LINECAP_SQUARE:
                    mStrokeLineCap = SQUARE;
                    break;
                default:
                    assert false;
            }
        }

        private int getStrokeLineJoin() {
            switch (mStrokeLineJoin) {
                case MITER:
                    return LINEJOIN_MITER;
                case ROUND:
                    return LINEJOIN_ROUND;
                case BEVEL:
                    return LINEJOIN_BEVEL;
                default:
                    assert false;
            }

            return -1;
        }

        private void setStrokeLineJoin(int join) {
            switch (join) {
                case LINEJOIN_BEVEL:
                    mStrokeLineJoin = BEVEL;
                    break;
                case LINEJOIN_MITER:
                    mStrokeLineJoin = MITER;
                    break;
                case LINEJOIN_ROUND:
                    mStrokeLineJoin = Join.ROUND;
                    break;
                default:
                    assert false;
            }
        }

        private int getStrokeColor() {
            return mStrokeColor;
        }

        private void setStrokeColor(int strokeColor) {
            mStrokeColor = strokeColor;
        }

        private float getStrokeWidth() {
            return mStrokeWidth;
        }

        private void setStrokeWidth(float strokeWidth) {
            mStrokeWidth = strokeWidth;
        }

        private float getStrokeAlpha() {
            return mStrokeAlpha;
        }

        private void setStrokeAlpha(float strokeAlpha) {
            mStrokeAlpha = strokeAlpha;
        }

        private int getFillColor() {
            return mFillColor;
        }

        private void setFillColor(int fillColor) {
            mFillColor = fillColor;
        }

        private float getFillAlpha() {
            return mFillAlpha;
        }

        private void setFillAlpha(float fillAlpha) {
            mFillAlpha = fillAlpha;
        }

        private float getTrimPathStart() {
            return mTrimPathStart;
        }

        private void setTrimPathStart(float trimPathStart) {
            mTrimPathStart = trimPathStart;
        }

        private float getTrimPathEnd() {
            return mTrimPathEnd;
        }

        private void setTrimPathEnd(float trimPathEnd) {
            mTrimPathEnd = trimPathEnd;
        }

        private float getTrimPathOffset() {
            return mTrimPathOffset;
        }

        private void setTrimPathOffset(float trimPathOffset) {
            mTrimPathOffset = trimPathOffset;
        }

        private void setStrokeMiterlimit(float limit) {
            mStrokeMiterlimit = limit;
        }

        private float getStrokeMiterlimit() {
            return mStrokeMiterlimit;
        }

        private void setStrokeGradient(long gradientPtr) {
            mStrokeGradient = gradientPtr;
        }

        private void setFillGradient(long gradientPtr) {
            mFillGradient = gradientPtr;
        }

        private void setFillType(int fillType) {
            mFillType = fillType;
        }

        private int getFillType() {
            return mFillType;
        }
    }

    static class VGroup_Delegate extends VNativeObject {
        // This constants need to be kept in sync with their definitions in VectorDrawable.Group
        private static final int ROTATE_INDEX = 0;
        private static final int PIVOT_X_INDEX = 1;
        private static final int PIVOT_Y_INDEX = 2;
        private static final int SCALE_X_INDEX = 3;
        private static final int SCALE_Y_INDEX = 4;
        private static final int TRANSLATE_X_INDEX = 5;
        private static final int TRANSLATE_Y_INDEX = 6;

        public Consumer<Float> getPropertySetter(int propertyIdx) {
            switch (propertyIdx) {
                case ROTATE_INDEX:
                    return this::setRotation;
                case PIVOT_X_INDEX:
                    return this::setPivotX;
                case PIVOT_Y_INDEX:
                    return this::setPivotY;
                case SCALE_X_INDEX:
                    return this::setScaleX;
                case SCALE_Y_INDEX:
                    return this::setScaleY;
                case TRANSLATE_X_INDEX:
                    return this::setTranslateX;
                case TRANSLATE_Y_INDEX:
                    return this::setTranslateY;
            }

            assert false : ("Invalid VGroup_Delegate property index " + propertyIdx);
            return t -> {};
        }

        /////////////////////////////////////////////////////
        // Variables below need to be copied (deep copy if applicable) for mutation.
        final ArrayList<Object> mChildren = new ArrayList<>();
        // mStackedMatrix is only used temporarily when drawing, it combines all
        // the parents' local matrices with the current one.
        private final Matrix mStackedMatrix = new Matrix();
        // mLocalMatrix is updated based on the update of transformation information,
        // either parsed from the XML or by animation.
        private final Matrix mLocalMatrix = new Matrix();
        private float mRotate = 0;
        private float mPivotX = 0;
        private float mPivotY = 0;
        private float mScaleX = 1;
        private float mScaleY = 1;
        private float mTranslateX = 0;
        private float mTranslateY = 0;
        private int mChangingConfigurations;
        private String mGroupName = null;

        private VGroup_Delegate(VGroup_Delegate copy, ArrayMap<String, Object> targetsMap) {
            mRotate = copy.mRotate;
            mPivotX = copy.mPivotX;
            mPivotY = copy.mPivotY;
            mScaleX = copy.mScaleX;
            mScaleY = copy.mScaleY;
            mTranslateX = copy.mTranslateX;
            mTranslateY = copy.mTranslateY;
            mGroupName = copy.mGroupName;
            mChangingConfigurations = copy.mChangingConfigurations;
            if (mGroupName != null) {
                targetsMap.put(mGroupName, this);
            }

            mLocalMatrix.set(copy.mLocalMatrix);
        }

        private VGroup_Delegate() {
        }

        private void updateLocalMatrix() {
            // The order we apply is the same as the
            // RenderNode.cpp::applyViewPropertyTransforms().
            mLocalMatrix.reset();
            mLocalMatrix.postTranslate(-mPivotX, -mPivotY);
            mLocalMatrix.postScale(mScaleX, mScaleY);
            mLocalMatrix.postRotate(mRotate, 0, 0);
            mLocalMatrix.postTranslate(mTranslateX + mPivotX, mTranslateY + mPivotY);
        }

        /* Setters and Getters, used by animator from AnimatedVectorDrawable. */
        private float getRotation() {
            return mRotate;
        }

        private void setRotation(float rotation) {
            if (rotation != mRotate) {
                mRotate = rotation;
                updateLocalMatrix();
            }
        }

        private float getPivotX() {
            return mPivotX;
        }

        private void setPivotX(float pivotX) {
            if (pivotX != mPivotX) {
                mPivotX = pivotX;
                updateLocalMatrix();
            }
        }

        private float getPivotY() {
            return mPivotY;
        }

        private void setPivotY(float pivotY) {
            if (pivotY != mPivotY) {
                mPivotY = pivotY;
                updateLocalMatrix();
            }
        }

        private float getScaleX() {
            return mScaleX;
        }

        private void setScaleX(float scaleX) {
            if (scaleX != mScaleX) {
                mScaleX = scaleX;
                updateLocalMatrix();
            }
        }

        private float getScaleY() {
            return mScaleY;
        }

        private void setScaleY(float scaleY) {
            if (scaleY != mScaleY) {
                mScaleY = scaleY;
                updateLocalMatrix();
            }
        }

        private float getTranslateX() {
            return mTranslateX;
        }

        private void setTranslateX(float translateX) {
            if (translateX != mTranslateX) {
                mTranslateX = translateX;
                updateLocalMatrix();
            }
        }

        private float getTranslateY() {
            return mTranslateY;
        }

        private void setTranslateY(float translateY) {
            if (translateY != mTranslateY) {
                mTranslateY = translateY;
                updateLocalMatrix();
            }
        }

        @Override
        public void setName(String name) {
            mGroupName = name;
        }

        @Override
        protected void dispose() {
            mChildren.stream().filter(child -> child instanceof VNativeObject).forEach(child
                    -> {
                VNativeObject nativeObject = (VNativeObject) child;
                if (nativeObject.mNativePtr != 0) {
                    sPathManager.removeJavaReferenceFor(nativeObject.mNativePtr);
                    nativeObject.mNativePtr = 0;
                }
                nativeObject.dispose();
            });
            mChildren.clear();
        }

        @Override
        protected void finalize() throws Throwable {
            super.finalize();
        }
    }

    public static class VPath_Delegate extends VNativeObject {
        protected PathParser_Delegate.PathDataNode[] mNodes = null;
        String mPathName;
        int mChangingConfigurations;

        public VPath_Delegate() {
            // Empty constructor.
        }

        public VPath_Delegate(VPath_Delegate copy) {
            mPathName = copy.mPathName;
            mChangingConfigurations = copy.mChangingConfigurations;
            mNodes = copy.mNodes != null ? PathParser_Delegate.deepCopyNodes(copy.mNodes) : null;
        }

        public void toPath(Path path) {
            path.reset();
            if (mNodes != null) {
                PathParser_Delegate.PathDataNode.nodesToPath(mNodes,
                        Path_Delegate.getDelegate(path.mNativePath));
            }
        }

        @Override
        public void setName(String name) {
            mPathName = name;
        }

        public boolean isClipPath() {
            return false;
        }

        private void setPathData(PathParser_Delegate.PathDataNode[] nodes) {
            if (!PathParser_Delegate.canMorph(mNodes, nodes)) {
                // This should not happen in the middle of animation.
                mNodes = PathParser_Delegate.deepCopyNodes(nodes);
            } else {
                PathParser_Delegate.updateNodes(mNodes, nodes);
            }
        }

        @Override
        void dispose() {
            mNodes = null;
        }
    }

    static class VPathRenderer_Delegate extends VNativeObject {
        /* Right now the internal data structure is organized as a tree.
         * Each node can be a group node, or a path.
         * A group node can have groups or paths as children, but a path node has
         * no children.
         * One example can be:
         *                 Root Group
         *                /    |     \
         *           Group    Path    Group
         *          /     \             |
         *         Path   Path         Path
         *
         */
        // Variables that only used temporarily inside the draw() call, so there
        // is no need for deep copying.
        private final Path mPath;
        private final Path mRenderPath;
        private final Matrix mFinalPathMatrix = new Matrix();
        private final long mRootGroupPtr;
        private float mViewportWidth = 0;
        private float mViewportHeight = 0;
        private float mRootAlpha = 1.0f;
        private Paint mStrokePaint;
        private Paint mFillPaint;
        private PathMeasure mPathMeasure;
        private boolean mAntiAlias = true;

        private VPathRenderer_Delegate(long rootGroupPtr) {
            mRootGroupPtr = rootGroupPtr;
            mPath = new Path();
            mRenderPath = new Path();
        }

        private VPathRenderer_Delegate(VPathRenderer_Delegate rendererToCopy,
                long rootGroupPtr) {
            this(rootGroupPtr);
            mViewportWidth = rendererToCopy.mViewportWidth;
            mViewportHeight = rendererToCopy.mViewportHeight;
            mRootAlpha = rendererToCopy.mRootAlpha;
        }

        private float getRootAlpha() {
            return mRootAlpha;
        }

        void setRootAlpha(float alpha) {
            mRootAlpha = alpha;
        }

        private void drawGroupTree(VGroup_Delegate currentGroup, Matrix currentMatrix,
                long canvasPtr, int w, int h, long filterPtr) {
            // Calculate current group's matrix by preConcat the parent's and
            // and the current one on the top of the stack.
            // Basically the Mfinal = Mviewport * M0 * M1 * M2;
            // Mi the local matrix at level i of the group tree.
            currentGroup.mStackedMatrix.set(currentMatrix);
            currentGroup.mStackedMatrix.preConcat(currentGroup.mLocalMatrix);

            // Save the current clip information, which is local to this group.
            Canvas_Delegate.nSave(canvasPtr, MATRIX_SAVE_FLAG | CLIP_SAVE_FLAG);
            // Draw the group tree in the same order as the XML file.
            for (int i = 0; i < currentGroup.mChildren.size(); i++) {
                Object child = currentGroup.mChildren.get(i);
                if (child instanceof VGroup_Delegate) {
                    VGroup_Delegate childGroup = (VGroup_Delegate) child;
                    drawGroupTree(childGroup, currentGroup.mStackedMatrix,
                            canvasPtr, w, h, filterPtr);
                } else if (child instanceof VPath_Delegate) {
                    VPath_Delegate childPath = (VPath_Delegate) child;
                    drawPath(currentGroup, childPath, canvasPtr, w, h, filterPtr);
                }
            }
            Canvas_Delegate.nRestore(canvasPtr);
        }

        public void draw(long canvasPtr, long filterPtr, int w, int h) {
            // Traverse the tree in pre-order to draw.
            drawGroupTree(VNativeObject.getDelegate(mRootGroupPtr), Matrix.IDENTITY_MATRIX, canvasPtr, w, h, filterPtr);
        }

        private void drawPath(VGroup_Delegate VGroup, VPath_Delegate VPath, long canvasPtr,
                int w,
                int h,
                long filterPtr) {
            final float scaleX = w / mViewportWidth;
            final float scaleY = h / mViewportHeight;
            final float minScale = Math.min(scaleX, scaleY);
            final Matrix groupStackedMatrix = VGroup.mStackedMatrix;

            mFinalPathMatrix.set(groupStackedMatrix);
            mFinalPathMatrix.postScale(scaleX, scaleY);

            final float matrixScale = getMatrixScale(groupStackedMatrix);
            if (matrixScale == 0) {
                // When either x or y is scaled to 0, we don't need to draw anything.
                return;
            }
            VPath.toPath(mPath);
            final Path path = mPath;

            mRenderPath.reset();

            if (VPath.isClipPath()) {
                mRenderPath.setFillType(FillType.WINDING);
                mRenderPath.addPath(path, mFinalPathMatrix);
                Canvas_Delegate.nClipPath(canvasPtr, mRenderPath.mNativePath, Op
                        .INTERSECT.nativeInt);
            } else {
                VFullPath_Delegate fullPath = (VFullPath_Delegate) VPath;
                if (fullPath.mTrimPathStart != 0.0f || fullPath.mTrimPathEnd != 1.0f) {
                    float start = (fullPath.mTrimPathStart + fullPath.mTrimPathOffset) % 1.0f;
                    float end = (fullPath.mTrimPathEnd + fullPath.mTrimPathOffset) % 1.0f;

                    if (mPathMeasure == null) {
                        mPathMeasure = new PathMeasure();
                    }
                    mPathMeasure.setPath(mPath, false);

                    float len = mPathMeasure.getLength();
                    start = start * len;
                    end = end * len;
                    path.reset();
                    if (start > end) {
                        mPathMeasure.getSegment(start, len, path, true);
                        mPathMeasure.getSegment(0f, end, path, true);
                    } else {
                        mPathMeasure.getSegment(start, end, path, true);
                    }
                    path.rLineTo(0, 0); // fix bug in measure
                }
                mRenderPath.addPath(path, mFinalPathMatrix);

                if (fullPath.mFillColor != Color.TRANSPARENT) {
                    if (mFillPaint == null) {
                        mFillPaint = new Paint();
                        mFillPaint.setStyle(Style.FILL);
                        mFillPaint.setAntiAlias(mAntiAlias);
                    }

                    final Paint fillPaint = mFillPaint;
                    fillPaint.setColor(applyAlpha(applyAlpha(fullPath.mFillColor, fullPath
                      .mFillAlpha), getRootAlpha()));
                    Paint_Delegate fillPaintDelegate = Paint_Delegate.getDelegate(fillPaint
                            .getNativeInstance());
                    // mFillPaint can not be null at this point so we will have a delegate
                    assert fillPaintDelegate != null;
                    fillPaintDelegate.setColorFilter(filterPtr);

                    Shader_Delegate shaderDelegate =
                            Shader_Delegate.getDelegate(fullPath.mFillGradient);
                    if (shaderDelegate != null) {
                        // If there is a shader, apply the local transformation to make sure
                        // the gradient is transformed to match the viewport
                        shaderDelegate.setLocalMatrix(mFinalPathMatrix.native_instance);
                        shaderDelegate.setAlpha(fullPath.mFillAlpha);
                    }

                    fillPaintDelegate.setShader(fullPath.mFillGradient);
                    Path_Delegate.nSetFillType(mRenderPath.mNativePath, fullPath.mFillType);
                    BaseCanvas_Delegate.nDrawPath(canvasPtr, mRenderPath.mNativePath, fillPaint
                            .getNativeInstance());
                    if (shaderDelegate != null) {
                        // Remove the local matrix
                        shaderDelegate.setLocalMatrix(0);
                    }
                }

                if (fullPath.mStrokeColor != Color.TRANSPARENT) {
                    if (mStrokePaint == null) {
                        mStrokePaint = new Paint();
                        mStrokePaint.setStyle(Style.STROKE);
                        mStrokePaint.setAntiAlias(mAntiAlias);
                    }

                    final Paint strokePaint = mStrokePaint;
                    if (fullPath.mStrokeLineJoin != null) {
                        strokePaint.setStrokeJoin(fullPath.mStrokeLineJoin);
                    }

                    if (fullPath.mStrokeLineCap != null) {
                        strokePaint.setStrokeCap(fullPath.mStrokeLineCap);
                    }

                    strokePaint.setStrokeMiter(fullPath.mStrokeMiterlimit);
                    strokePaint.setColor(applyAlpha(applyAlpha(fullPath.mStrokeColor, fullPath
                      .mStrokeAlpha), getRootAlpha()));
                    Paint_Delegate strokePaintDelegate = Paint_Delegate.getDelegate(strokePaint
                            .getNativeInstance());
                    // mStrokePaint can not be null at this point so we will have a delegate
                    assert strokePaintDelegate != null;
                    strokePaintDelegate.setColorFilter(filterPtr);
                    final float finalStrokeScale = minScale * matrixScale;
                    strokePaint.setStrokeWidth(fullPath.mStrokeWidth * finalStrokeScale);
                    Shader_Delegate strokeShaderDelegate =
                            Shader_Delegate.getDelegate(fullPath.mStrokeGradient);
                    if (strokeShaderDelegate != null) {
                        strokeShaderDelegate.setAlpha(fullPath.mStrokeAlpha);
                    }
                    strokePaintDelegate.setShader(fullPath.mStrokeGradient);
                    BaseCanvas_Delegate.nDrawPath(canvasPtr, mRenderPath.mNativePath, strokePaint
                            .getNativeInstance());
                }
            }
        }

        private float getMatrixScale(Matrix groupStackedMatrix) {
            // Given unit vectors A = (0, 1) and B = (1, 0).
            // After matrix mapping, we got A' and B'. Let theta = the angel b/t A' and B'.
            // Therefore, the final scale we want is min(|A'| * sin(theta), |B'| * sin(theta)),
            // which is (|A'| * |B'| * sin(theta)) / max (|A'|, |B'|);
            // If  max (|A'|, |B'|) = 0, that means either x or y has a scale of 0.
            //
            // For non-skew case, which is most of the cases, matrix scale is computing exactly the
            // scale on x and y axis, and take the minimal of these two.
            // For skew case, an unit square will mapped to a parallelogram. And this function will
            // return the minimal height of the 2 bases.
            float[] unitVectors = new float[]{0, 1, 1, 0};
            groupStackedMatrix.mapVectors(unitVectors);
            float scaleX = MathUtils.mag(unitVectors[0], unitVectors[1]);
            float scaleY = MathUtils.mag(unitVectors[2], unitVectors[3]);
            float crossProduct = MathUtils.cross(unitVectors[0], unitVectors[1],
                    unitVectors[2], unitVectors[3]);
            float maxScale = MathUtils.max(scaleX, scaleY);

            float matrixScale = 0;
            if (maxScale > 0) {
                matrixScale = MathUtils.abs(crossProduct) / maxScale;
            }
            if (DBG_VECTOR_DRAWABLE) {
                Log.d(LOGTAG, "Scale x " + scaleX + " y " + scaleY + " final " + matrixScale);
            }
            return matrixScale;
        }

        private void setAntiAlias(boolean aa) {
            mAntiAlias = aa;
        }

        @Override
        public void setName(String name) {
        }

        @Override
        protected void finalize() throws Throwable {
            // The mRootGroupPtr is not explicitly freed by anything in the VectorDrawable so we
            // need to free it here.
            VNativeObject nativeObject = sPathManager.getDelegate(mRootGroupPtr);
            sPathManager.removeJavaReferenceFor(mRootGroupPtr);
            assert nativeObject != null;
            nativeObject.dispose();

            super.finalize();
        }
    }
}