/*
* 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.support.constraint;

import android.content.Context;
import android.content.res.Resources;
import android.content.res.TypedArray;
import android.content.res.XmlResourceParser;
import android.os.Build;
import android.os.Build.VERSION_CODES;
import android.support.constraint.ConstraintLayout.LayoutParams;
import android.support.constraint.solver.widgets.ConstraintWidget;
import android.util.*;
import android.view.LayoutInflater;
import android.view.View;

import java.util.Arrays;
import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;

import java.io.IOException;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.HashSet;

/**
 * This class allows you to define programmatically a set of constraints to be used with {@link ConstraintLayout}.
 * It lets you create and save constraints, and apply them to an existing ConstraintLayout. ConstraintsSet can be created in various ways:
 * <ul>
 * <li>
 * Manually <br> {@code c = new ConstraintSet(); c.connect(....);}
 * </li>
 * <li>
 * from a R.layout.* object <br> {@code c.clone(context, R.layout.layout1);}
 * </li>
 * <li>
 * from a ConstraintLayout <br> {@code c.clone(clayout);}
 * </li>
 * </ul><p>
 * Example code:<br>
 * {@sample resources/examples/ExampleConstraintSet.java
 * Example}
 */
public class ConstraintSet {
    private static final String TAG = "ConstraintSet";

    /**
     * Used to indicate a parameter is cleared or not set
     */
    public static final int UNSET = LayoutParams.UNSET;

    /**
     * Dimension will be controlled by constraints
     */
    public static final int MATCH_CONSTRAINT = ConstraintLayout.LayoutParams.MATCH_CONSTRAINT;

    /**
     * Dimension will set by the view's content
     */
    public static final int WRAP_CONTENT = ConstraintLayout.LayoutParams.WRAP_CONTENT;

    /**
     * How to calculate the size of a view in 0 dp by using its wrap_content size
     */
    public static final int MATCH_CONSTRAINT_WRAP = ConstraintLayout.LayoutParams.MATCH_CONSTRAINT_WRAP;

    /**
     * Calculate the size of a view in 0 dp by reducing the constrains gaps as much as possible
     */
    public static final int MATCH_CONSTRAINT_SPREAD = ConstraintLayout.LayoutParams.MATCH_CONSTRAINT_SPREAD;

    /**
     * References the id of the parent.
     * Used in:
     * <ul>
     * <li>{@link #connect(int, int, int, int, int)}</li>
     * <li>{@link #center(int, int, int, int, int, int, int, float)}</li>
     * </ul>
     */
    public static final int PARENT_ID = ConstraintLayout.LayoutParams.PARENT_ID;

    /**
     * The horizontal orientation.
     */
    public static final int HORIZONTAL = ConstraintLayout.LayoutParams.HORIZONTAL;

    /**
     * The vertical orientation.
     */
    public static final int VERTICAL = ConstraintLayout.LayoutParams.VERTICAL;

    /**
     * Used to create a horizontal create guidelines.
     */
    public static final int HORIZONTAL_GUIDELINE = 0;

    /**
     * Used to create a vertical create guidelines.
     * see {@link #create(int, int)}
     */
    public static final int VERTICAL_GUIDELINE = 1;

    /**
     * This view is visible.
     * Use with {@link #setVisibility} and <a href="#attr_android:visibility">{@code
     * android:visibility}.
     */
    public static final int VISIBLE = View.VISIBLE;

    /**
     * This view is invisible, but it still takes up space for layout purposes.
     * Use with {@link #setVisibility} and <a href="#attr_android:visibility">{@code
     * android:visibility}.
     */
    public static final int INVISIBLE = View.INVISIBLE;

    /**
     * This view is gone, and will not take any space for layout
     * purposes. Use with {@link #setVisibility} and <a href="#attr_android:visibility">{@code
     * android:visibility}.
     */
    public static final int GONE = View.GONE;

    /**
     * The left side of a view.
     */
    public static final int LEFT = ConstraintLayout.LayoutParams.LEFT;

    /**
     * The right side of a view.
     */
    public static final int RIGHT = ConstraintLayout.LayoutParams.RIGHT;

    /**
     * The top of a view.
     */
    public static final int TOP = ConstraintLayout.LayoutParams.TOP;
    ;

    /**
     * The bottom side of a view.
     */
    public static final int BOTTOM = ConstraintLayout.LayoutParams.BOTTOM;
    ;

    /**
     * The baseline of the text in a view.
     */
    public static final int BASELINE = ConstraintLayout.LayoutParams.BASELINE;
    ;

    /**
     * The left side of a view in left to right languages.
     * In right to left languages it corresponds to the right side of the view
     */
    public static final int START = ConstraintLayout.LayoutParams.START;

    /**
     * The right side of a view in right to left languages.
     * In right to left languages it corresponds to the left side of the view
     */
    public static final int END = ConstraintLayout.LayoutParams.END;

    /**
     * Chain spread style
     */
    public static final int CHAIN_SPREAD = ConstraintLayout.LayoutParams.CHAIN_SPREAD;

    /**
     * Chain spread inside style
     */
    public static final int CHAIN_SPREAD_INSIDE = ConstraintLayout.LayoutParams.CHAIN_SPREAD_INSIDE;

    /**
     * Chain packed style
     */
    public static final int CHAIN_PACKED = ConstraintLayout.LayoutParams.CHAIN_PACKED;

    private static final boolean DEBUG = false;
    private static final int[] VISIBILITY_FLAGS = new int[]{VISIBLE, INVISIBLE, GONE};
    private static final int BARRIER_TYPE = 1;

    private HashMap<Integer, Constraint> mConstraints = new HashMap<Integer, Constraint>();

    private static SparseIntArray mapToConstant = new SparseIntArray();
    private static final int BASELINE_TO_BASELINE = 1;
    private static final int BOTTOM_MARGIN = 2;
    private static final int BOTTOM_TO_BOTTOM = 3;
    private static final int BOTTOM_TO_TOP = 4;
    private static final int DIMENSION_RATIO = 5;
    private static final int EDITOR_ABSOLUTE_X = 6;
    private static final int EDITOR_ABSOLUTE_Y = 7;
    private static final int END_MARGIN = 8;
    private static final int END_TO_END = 9;
    private static final int END_TO_START = 10;
    private static final int GONE_BOTTOM_MARGIN = 11;
    private static final int GONE_END_MARGIN = 12;
    private static final int GONE_LEFT_MARGIN = 13;
    private static final int GONE_RIGHT_MARGIN = 14;
    private static final int GONE_START_MARGIN = 15;
    private static final int GONE_TOP_MARGIN = 16;
    private static final int GUIDE_BEGIN = 17;
    private static final int GUIDE_END = 18;
    private static final int GUIDE_PERCENT = 19;
    private static final int HORIZONTAL_BIAS = 20;
    private static final int LAYOUT_HEIGHT = 21;
    private static final int LAYOUT_VISIBILITY = 22;
    private static final int LAYOUT_WIDTH = 23;
    private static final int LEFT_MARGIN = 24;
    private static final int LEFT_TO_LEFT = 25;
    private static final int LEFT_TO_RIGHT = 26;
    private static final int ORIENTATION = 27;
    private static final int RIGHT_MARGIN = 28;
    private static final int RIGHT_TO_LEFT = 29;
    private static final int RIGHT_TO_RIGHT = 30;
    private static final int START_MARGIN = 31;
    private static final int START_TO_END = 32;
    private static final int START_TO_START = 33;
    private static final int TOP_MARGIN = 34;
    private static final int TOP_TO_BOTTOM = 35;
    private static final int TOP_TO_TOP = 36;
    private static final int VERTICAL_BIAS = 37;
    private static final int VIEW_ID = 38;
    private static final int HORIZONTAL_WEIGHT = 39;
    private static final int VERTICAL_WEIGHT = 40;
    private static final int HORIZONTAL_STYLE = 41;
    private static final int VERTICAL_STYLE = 42;
    private static final int ALPHA = 43;
    private static final int ELEVATION = 44;
    private static final int ROTATION_X = 45;
    private static final int ROTATION_Y = 46;
    private static final int SCALE_X = 47;
    private static final int SCALE_Y = 48;
    private static final int TRANSFORM_PIVOT_X = 49;
    private static final int TRANSFORM_PIVOT_Y = 50;
    private static final int TRANSLATION_X = 51;
    private static final int TRANSLATION_Y = 52;
    private static final int TRANSLATION_Z = 53;
    private static final int WIDTH_DEFAULT = 54;
    private static final int HEIGHT_DEFAULT = 55;
    private static final int WIDTH_MAX = 56;
    private static final int HEIGHT_MAX = 57;
    private static final int WIDTH_MIN = 58;
    private static final int HEIGHT_MIN = 59;
    private static final int ROTATION = 60;
    private static final int CIRCLE = 61;
    private static final int CIRCLE_RADIUS = 62;
    private static final int CIRCLE_ANGLE = 63;

    private static final int WIDTH_PERCENT = 69;
    private static final int HEIGHT_PERCENT = 70;
    private static final int CHAIN_USE_RTL = 71;
    private static final int BARRIER_DIRECTION = 72;
    private static final int CONSTRAINT_REFERENCED_IDS = 73;
    private static final int BARRIER_ALLOWS_GONE_WIDGETS = 74;
    private static final int UNUSED = 75;

    static {
        mapToConstant.append(R.styleable.ConstraintSet_layout_constraintLeft_toLeftOf, LEFT_TO_LEFT);
        mapToConstant.append(R.styleable.ConstraintSet_layout_constraintLeft_toRightOf, LEFT_TO_RIGHT);
        mapToConstant.append(R.styleable.ConstraintSet_layout_constraintRight_toLeftOf, RIGHT_TO_LEFT);
        mapToConstant.append(R.styleable.ConstraintSet_layout_constraintRight_toRightOf, RIGHT_TO_RIGHT);
        mapToConstant.append(R.styleable.ConstraintSet_layout_constraintTop_toTopOf, TOP_TO_TOP);
        mapToConstant.append(R.styleable.ConstraintSet_layout_constraintTop_toBottomOf, TOP_TO_BOTTOM);
        mapToConstant.append(R.styleable.ConstraintSet_layout_constraintBottom_toTopOf, BOTTOM_TO_TOP);
        mapToConstant.append(R.styleable.ConstraintSet_layout_constraintBottom_toBottomOf, BOTTOM_TO_BOTTOM);
        mapToConstant.append(R.styleable.ConstraintSet_layout_constraintBaseline_toBaselineOf, BASELINE_TO_BASELINE);

        mapToConstant.append(R.styleable.ConstraintSet_layout_editor_absoluteX, EDITOR_ABSOLUTE_X);
        mapToConstant.append(R.styleable.ConstraintSet_layout_editor_absoluteY, EDITOR_ABSOLUTE_Y);
        mapToConstant.append(R.styleable.ConstraintSet_layout_constraintGuide_begin, GUIDE_BEGIN);
        mapToConstant.append(R.styleable.ConstraintSet_layout_constraintGuide_end, GUIDE_END);
        mapToConstant.append(R.styleable.ConstraintSet_layout_constraintGuide_percent, GUIDE_PERCENT);
        mapToConstant.append(R.styleable.ConstraintSet_android_orientation, ORIENTATION);
        mapToConstant.append(R.styleable.ConstraintSet_layout_constraintStart_toEndOf, START_TO_END);
        mapToConstant.append(R.styleable.ConstraintSet_layout_constraintStart_toStartOf, START_TO_START);
        mapToConstant.append(R.styleable.ConstraintSet_layout_constraintEnd_toStartOf, END_TO_START);
        mapToConstant.append(R.styleable.ConstraintSet_layout_constraintEnd_toEndOf, END_TO_END);
        mapToConstant.append(R.styleable.ConstraintSet_layout_goneMarginLeft, GONE_LEFT_MARGIN);
        mapToConstant.append(R.styleable.ConstraintSet_layout_goneMarginTop, GONE_TOP_MARGIN);
        mapToConstant.append(R.styleable.ConstraintSet_layout_goneMarginRight, GONE_RIGHT_MARGIN);
        mapToConstant.append(R.styleable.ConstraintSet_layout_goneMarginBottom, GONE_BOTTOM_MARGIN);
        mapToConstant.append(R.styleable.ConstraintSet_layout_goneMarginStart, GONE_START_MARGIN);
        mapToConstant.append(R.styleable.ConstraintSet_layout_goneMarginEnd, GONE_END_MARGIN);
        mapToConstant.append(R.styleable.ConstraintSet_layout_constraintVertical_weight, VERTICAL_WEIGHT);
        mapToConstant.append(R.styleable.ConstraintSet_layout_constraintHorizontal_weight, HORIZONTAL_WEIGHT);
        mapToConstant.append(R.styleable.ConstraintSet_layout_constraintHorizontal_chainStyle, HORIZONTAL_STYLE);
        mapToConstant.append(R.styleable.ConstraintSet_layout_constraintVertical_chainStyle, VERTICAL_STYLE);

        mapToConstant.append(R.styleable.ConstraintSet_layout_constraintHorizontal_bias, HORIZONTAL_BIAS);
        mapToConstant.append(R.styleable.ConstraintSet_layout_constraintVertical_bias, VERTICAL_BIAS);
        mapToConstant.append(R.styleable.ConstraintSet_layout_constraintDimensionRatio, DIMENSION_RATIO);
        mapToConstant.append(R.styleable.ConstraintSet_layout_constraintLeft_creator, UNUSED);
        mapToConstant.append(R.styleable.ConstraintSet_layout_constraintTop_creator, UNUSED);
        mapToConstant.append(R.styleable.ConstraintSet_layout_constraintRight_creator, UNUSED);
        mapToConstant.append(R.styleable.ConstraintSet_layout_constraintBottom_creator, UNUSED);
        mapToConstant.append(R.styleable.ConstraintSet_layout_constraintBaseline_creator, UNUSED);
        mapToConstant.append(R.styleable.ConstraintSet_android_layout_marginLeft, LEFT_MARGIN);
        mapToConstant.append(R.styleable.ConstraintSet_android_layout_marginRight, RIGHT_MARGIN);
        mapToConstant.append(R.styleable.ConstraintSet_android_layout_marginStart, START_MARGIN);
        mapToConstant.append(R.styleable.ConstraintSet_android_layout_marginEnd, END_MARGIN);
        mapToConstant.append(R.styleable.ConstraintSet_android_layout_marginTop, TOP_MARGIN);
        mapToConstant.append(R.styleable.ConstraintSet_android_layout_marginBottom, BOTTOM_MARGIN);
        mapToConstant.append(R.styleable.ConstraintSet_android_layout_width, LAYOUT_WIDTH);
        mapToConstant.append(R.styleable.ConstraintSet_android_layout_height, LAYOUT_HEIGHT);
        mapToConstant.append(R.styleable.ConstraintSet_android_visibility, LAYOUT_VISIBILITY);
        mapToConstant.append(R.styleable.ConstraintSet_android_alpha, ALPHA);
        mapToConstant.append(R.styleable.ConstraintSet_android_elevation, ELEVATION);
        mapToConstant.append(R.styleable.ConstraintSet_android_rotationX, ROTATION_X);
        mapToConstant.append(R.styleable.ConstraintSet_android_rotationY, ROTATION_Y);
        mapToConstant.append(R.styleable.ConstraintSet_android_rotation, ROTATION);
        mapToConstant.append(R.styleable.ConstraintSet_android_scaleX, SCALE_X);
        mapToConstant.append(R.styleable.ConstraintSet_android_scaleY, SCALE_Y);
        mapToConstant.append(R.styleable.ConstraintSet_android_transformPivotX, TRANSFORM_PIVOT_X);
        mapToConstant.append(R.styleable.ConstraintSet_android_transformPivotY, TRANSFORM_PIVOT_Y);
        mapToConstant.append(R.styleable.ConstraintSet_android_translationX, TRANSLATION_X);
        mapToConstant.append(R.styleable.ConstraintSet_android_translationY, TRANSLATION_Y);
        mapToConstant.append(R.styleable.ConstraintSet_android_translationZ, TRANSLATION_Z);
        mapToConstant.append(R.styleable.ConstraintSet_layout_constraintWidth_default, WIDTH_DEFAULT);
        mapToConstant.append(R.styleable.ConstraintSet_layout_constraintHeight_default, HEIGHT_DEFAULT);
        mapToConstant.append(R.styleable.ConstraintSet_layout_constraintWidth_max, WIDTH_MAX);
        mapToConstant.append(R.styleable.ConstraintSet_layout_constraintHeight_max, HEIGHT_MAX);
        mapToConstant.append(R.styleable.ConstraintSet_layout_constraintWidth_min, WIDTH_MIN);
        mapToConstant.append(R.styleable.ConstraintSet_layout_constraintHeight_min, HEIGHT_MIN);
        mapToConstant.append(R.styleable.ConstraintSet_layout_constraintCircle, CIRCLE);
        mapToConstant.append(R.styleable.ConstraintSet_layout_constraintCircleRadius, CIRCLE_RADIUS);
        mapToConstant.append(R.styleable.ConstraintSet_layout_constraintCircleAngle, CIRCLE_ANGLE);
        mapToConstant.append(R.styleable.ConstraintSet_android_id, VIEW_ID);

        mapToConstant.append(R.styleable.ConstraintSet_layout_constraintWidth_percent, WIDTH_PERCENT);
        mapToConstant.append(R.styleable.ConstraintSet_layout_constraintHeight_percent, HEIGHT_PERCENT);

        mapToConstant.append(R.styleable.ConstraintSet_chainUseRtl, CHAIN_USE_RTL);
        mapToConstant.append(R.styleable.ConstraintSet_barrierDirection, BARRIER_DIRECTION);
        mapToConstant.append(R.styleable.ConstraintSet_constraint_referenced_ids, CONSTRAINT_REFERENCED_IDS);
        mapToConstant.append(R.styleable.ConstraintSet_barrierAllowsGoneWidgets, BARRIER_ALLOWS_GONE_WIDGETS);
    }

    public Constraint getParameters(int mId) {
        return  get(mId);
    }

    private static class Constraint {
        boolean mIsGuideline = false;
        public int mWidth;
        public int mHeight;
        int mViewId;
        static final int UNSET = ConstraintLayout.LayoutParams.UNSET;
        public int guideBegin = UNSET;
        public int guideEnd = UNSET;
        public float guidePercent = UNSET;

        public int leftToLeft = UNSET;
        public int leftToRight = UNSET;
        public int rightToLeft = UNSET;
        public int rightToRight = UNSET;
        public int topToTop = UNSET;
        public int topToBottom = UNSET;
        public int bottomToTop = UNSET;
        public int bottomToBottom = UNSET;
        public int baselineToBaseline = UNSET;

        public int startToEnd = UNSET;
        public int startToStart = UNSET;
        public int endToStart = UNSET;
        public int endToEnd = UNSET;

        public float horizontalBias = 0.5f;
        public float verticalBias = 0.5f;
        public String dimensionRatio = null;

        public int circleConstraint = UNSET;
        public int circleRadius = 0;
        public float circleAngle = 0;

        public int editorAbsoluteX = UNSET;
        public int editorAbsoluteY = UNSET;

        public int orientation = UNSET;
        public int leftMargin = UNSET;
        public int rightMargin = UNSET;
        public int topMargin = UNSET;
        public int bottomMargin = UNSET;
        public int endMargin = UNSET;
        public int startMargin = UNSET;
        public int visibility = VISIBLE;
        public int goneLeftMargin = UNSET;
        public int goneTopMargin = UNSET;
        public int goneRightMargin = UNSET;
        public int goneBottomMargin = UNSET;
        public int goneEndMargin = UNSET;
        public int goneStartMargin = UNSET;
        public float verticalWeight = 0;
        public float horizontalWeight = 0;
        public int horizontalChainStyle = CHAIN_SPREAD;
        public int verticalChainStyle = CHAIN_SPREAD;
        public float alpha = 1;
        public boolean applyElevation = false;
        public float elevation = 0;
        public float rotation = 0;
        public float rotationX = 0;
        public float rotationY = 0;
        public float scaleX = 1;
        public float scaleY = 1;
        public float transformPivotX = Float.NaN;
        public float transformPivotY = Float.NaN;
        public float translationX = 0;
        public float translationY = 0;
        public float translationZ = 0;
        public boolean constrainedWidth = false;
        public boolean constrainedHeight = false;
        public int widthDefault = ConstraintWidget.MATCH_CONSTRAINT_SPREAD;
        public int heightDefault = ConstraintWidget.MATCH_CONSTRAINT_SPREAD;
        public int widthMax = UNSET;
        public int heightMax = UNSET;
        public int widthMin = UNSET;
        public int heightMin = UNSET;
        public float widthPercent = 1;
        public float heightPercent = 1;
	public boolean mBarrierAllowsGoneWidgets = false;
        public int mBarrierDirection = UNSET;
        public int mHelperType = UNSET;
        public int [] mReferenceIds;
	public String mReferenceIdString;

        public Constraint clone() {
            Constraint clone = new Constraint();
            clone.mIsGuideline = mIsGuideline;
            clone.mWidth = mWidth;
            clone.mHeight = mHeight;
            clone.guideBegin = guideBegin;
            clone.guideEnd = guideEnd;
            clone.guidePercent = guidePercent;
            clone.leftToLeft = leftToLeft;
            clone.leftToRight = leftToRight;
            clone.rightToLeft = rightToLeft;
            clone.rightToRight = rightToRight;
            clone.topToTop = topToTop;
            clone.topToBottom = topToBottom;
            clone.bottomToTop = bottomToTop;
            clone.bottomToBottom = bottomToBottom;
            clone.baselineToBaseline = baselineToBaseline;
            clone.startToEnd = startToEnd;
            clone.startToStart = startToStart;
            clone.endToStart = endToStart;
            clone.endToEnd = endToEnd;
            clone.horizontalBias = horizontalBias;
            clone.verticalBias = verticalBias;
            clone.dimensionRatio = dimensionRatio;
            clone.editorAbsoluteX = editorAbsoluteX;
            clone.editorAbsoluteY = editorAbsoluteY;
            clone.horizontalBias = horizontalBias;
            clone.horizontalBias = horizontalBias;
            clone.horizontalBias = horizontalBias;
            clone.horizontalBias = horizontalBias;
            clone.horizontalBias = horizontalBias;
            clone.orientation = orientation;
            clone.leftMargin = leftMargin;
            clone.rightMargin = rightMargin;
            clone.topMargin = topMargin;
            clone.bottomMargin = bottomMargin;
            clone.endMargin = endMargin;
            clone.startMargin = startMargin;
            clone.visibility = visibility;
            clone.goneLeftMargin = goneLeftMargin;
            clone.goneTopMargin = goneTopMargin;
            clone.goneRightMargin = goneRightMargin;
            clone.goneBottomMargin = goneBottomMargin;
            clone.goneEndMargin = goneEndMargin;
            clone.goneStartMargin = goneStartMargin;
            clone.verticalWeight = verticalWeight;
            clone.horizontalWeight = horizontalWeight;
            clone.horizontalChainStyle = horizontalChainStyle;
            clone.verticalChainStyle = verticalChainStyle;
            clone.alpha = alpha;
            clone.applyElevation = applyElevation;
            clone.elevation = elevation;
            clone.rotation = rotation;
            clone.rotationX = rotationX;
            clone.rotationY = rotationY;
            clone.scaleX = scaleX;
            clone.scaleY = scaleY;
            clone.transformPivotX = transformPivotX;
            clone.transformPivotY = transformPivotY;
            clone.translationX = translationX;
            clone.translationY = translationY;
            clone.translationZ = translationZ;
            clone.constrainedWidth = constrainedWidth;
            clone.constrainedHeight = constrainedHeight;
            clone.widthDefault = widthDefault;
            clone.heightDefault = heightDefault;
            clone.widthMax = widthMax;
            clone.heightMax = heightMax;
            clone.widthMin = widthMin;
            clone.heightMin = heightMin;
            clone.widthPercent = widthPercent;
            clone.heightPercent = heightPercent;
            clone.mBarrierDirection = mBarrierDirection;
            clone.mHelperType = mHelperType;
            if (mReferenceIds != null) {
                clone.mReferenceIds = Arrays.copyOf(mReferenceIds, mReferenceIds.length);
            }
            clone.circleConstraint = circleConstraint;
            clone.circleRadius = circleRadius;
            clone.circleAngle = circleAngle;
            clone.mBarrierAllowsGoneWidgets = mBarrierAllowsGoneWidgets;
            return clone;
        }

        private void fillFromConstraints(ConstraintHelper helper, int viewId, Constraints.LayoutParams param) {
            fillFromConstraints(viewId,param);
            if (helper instanceof Barrier) {
                mHelperType = BARRIER_TYPE;
                Barrier barrier = (Barrier)helper;
                mBarrierDirection = barrier.getType();
                mReferenceIds = barrier.getReferencedIds();
            }
        }

        private void fillFromConstraints(int viewId, Constraints.LayoutParams param) {
            fillFrom(viewId, param);
            alpha = param.alpha;
            rotation = param.rotation;
            rotationX = param.rotationX;
            rotationY = param.rotationY;
            scaleX = param.scaleX;
            scaleY = param.scaleY;
            transformPivotX = param.transformPivotX;
            transformPivotY = param.transformPivotY;
            translationX = param.translationX;
            translationY = param.translationY;
            translationZ = param.translationZ;
            elevation = param.elevation;
            applyElevation = param.applyElevation;
        }

        private void fillFrom(int viewId, ConstraintLayout.LayoutParams param) {
            mViewId = viewId;
            leftToLeft = param.leftToLeft;
            leftToRight = param.leftToRight;
            rightToLeft = param.rightToLeft;
            rightToRight = param.rightToRight;
            topToTop = param.topToTop;
            topToBottom = param.topToBottom;
            bottomToTop = param.bottomToTop;
            bottomToBottom = param.bottomToBottom;
            baselineToBaseline = param.baselineToBaseline;
            startToEnd = param.startToEnd;
            startToStart = param.startToStart;
            endToStart = param.endToStart;
            endToEnd = param.endToEnd;

            horizontalBias = param.horizontalBias;
            verticalBias = param.verticalBias;
            dimensionRatio = param.dimensionRatio;

            circleConstraint = param.circleConstraint;
            circleRadius = param.circleRadius;
            circleAngle = param.circleAngle;

            editorAbsoluteX = param.editorAbsoluteX;
            editorAbsoluteY = param.editorAbsoluteY;
            orientation = param.orientation;
            guidePercent = param.guidePercent;
            guideBegin = param.guideBegin;
            guideEnd = param.guideEnd;
            mWidth = param.width;
            mHeight = param.height;
            leftMargin = param.leftMargin;
            rightMargin = param.rightMargin;
            topMargin = param.topMargin;
            bottomMargin = param.bottomMargin;
            verticalWeight = param.verticalWeight;
            horizontalWeight = param.horizontalWeight;
            verticalChainStyle = param.verticalChainStyle;
            horizontalChainStyle = param.horizontalChainStyle;
            constrainedWidth = param.constrainedWidth;
            constrainedHeight = param.constrainedHeight;
            widthDefault = param.matchConstraintDefaultWidth;
            heightDefault = param.matchConstraintDefaultHeight;
            constrainedWidth = param.constrainedWidth;
            widthMax = param.matchConstraintMaxWidth;
            heightMax = param.matchConstraintMaxHeight;
            widthMin = param.matchConstraintMinWidth;
            heightMin = param.matchConstraintMinHeight;
            widthPercent = param.matchConstraintPercentWidth;
            heightPercent = param.matchConstraintPercentHeight;

            int currentapiVersion = android.os.Build.VERSION.SDK_INT;
            if (currentapiVersion >= android.os.Build.VERSION_CODES.JELLY_BEAN_MR1) {
                endMargin = param.getMarginEnd();
                startMargin = param.getMarginStart();
            }
        }

        public void applyTo(ConstraintLayout.LayoutParams param) {
            param.leftToLeft = leftToLeft;
            param.leftToRight = leftToRight;
            param.rightToLeft = rightToLeft;
            param.rightToRight = rightToRight;

            param.topToTop = topToTop;
            param.topToBottom = topToBottom;
            param.bottomToTop = bottomToTop;
            param.bottomToBottom = bottomToBottom;

            param.baselineToBaseline = baselineToBaseline;

            param.startToEnd = startToEnd;
            param.startToStart = startToStart;
            param.endToStart = endToStart;
            param.endToEnd = endToEnd;

            param.leftMargin = leftMargin;
            param.rightMargin = rightMargin;
            param.topMargin = topMargin;
            param.bottomMargin = bottomMargin;
            param.goneStartMargin = goneStartMargin;
            param.goneEndMargin = goneEndMargin;

            param.horizontalBias = horizontalBias;
            param.verticalBias = verticalBias;

            param.circleConstraint = circleConstraint;
            param.circleRadius = circleRadius;
            param.circleAngle = circleAngle;

            param.dimensionRatio = dimensionRatio;
            param.editorAbsoluteX = editorAbsoluteX;
            param.editorAbsoluteY = editorAbsoluteY;
            param.verticalWeight = verticalWeight;
            param.horizontalWeight = horizontalWeight;
            param.verticalChainStyle = verticalChainStyle;
            param.horizontalChainStyle = horizontalChainStyle;
            param.constrainedWidth = constrainedWidth;
            param.constrainedHeight = constrainedHeight;
            param.matchConstraintDefaultWidth = widthDefault;
            param.matchConstraintDefaultHeight = heightDefault;
            param.matchConstraintMaxWidth = widthMax;
            param.matchConstraintMaxHeight = heightMax;
            param.matchConstraintMinWidth = widthMin;
            param.matchConstraintMinHeight = heightMin;
            param.matchConstraintPercentWidth = widthPercent;
            param.matchConstraintPercentHeight = heightPercent;
            param.orientation = orientation;
            param.guidePercent = guidePercent;
            param.guideBegin = guideBegin;
            param.guideEnd = guideEnd;
            param.width = mWidth;
            param.height = mHeight;


            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
                param.setMarginStart(startMargin);
                param.setMarginEnd(endMargin);
            }

            param.validate();
        }
    }

    /**
     * Copy the constraints from a layout.
     *
     * @param context the context for the layout inflation
     * @param constraintLayoutId the id of the layout file
     */
    public void clone(Context context, int constraintLayoutId) {
        clone((ConstraintLayout) LayoutInflater.from(context).inflate(constraintLayoutId, null));
    }

    /**
     * Copy the constraints from a layout.
     *
     * @param set constraint set to copy
     */
    public void clone(ConstraintSet set) {
        mConstraints.clear();
        for (Integer key : set.mConstraints.keySet()) {
            mConstraints.put(key, set.mConstraints.get(key).clone());
        }
    }

    /**
     * Copy the layout parameters of a ConstraintLayout.
     *
     * @param constraintLayout The ConstraintLayout to be copied
     */
    public void clone(ConstraintLayout constraintLayout) {
        int count = constraintLayout.getChildCount();
        mConstraints.clear();
        for (int i = 0; i < count; i++) {
            View view = constraintLayout.getChildAt(i);
            ConstraintLayout.LayoutParams param = (ConstraintLayout.LayoutParams) view.getLayoutParams();

            int id = view.getId();
            if (id == -1) {
                throw new RuntimeException("All children of ConstraintLayout must have ids to use ConstraintSet");
            }
            if (!mConstraints.containsKey(id)) {
                mConstraints.put(id, new Constraint());
            }
            Constraint constraint = mConstraints.get(id);
            constraint.fillFrom(id, param);
            constraint.visibility = view.getVisibility();
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
                constraint.alpha = view.getAlpha();
                constraint.rotation = view.getRotation();
                constraint.rotationX = view.getRotationX();
                constraint.rotationY = view.getRotationY();
                constraint.scaleX = view.getScaleX();
                constraint.scaleY = view.getScaleY();

                float pivotX = view.getPivotX(); // we assume it is not set if set to 0.0
                float pivotY = view.getPivotY(); // we assume it is not set if set to 0.0

                if (pivotX != 0.0 || pivotY != 0.0) {
                    constraint.transformPivotX = pivotX;
                    constraint.transformPivotY = pivotY;
                }

                constraint.translationX = view.getTranslationX();
                constraint.translationY = view.getTranslationY();
                if (Build.VERSION.SDK_INT >= VERSION_CODES.LOLLIPOP) {
                    constraint.translationZ = view.getTranslationZ();
                    if (constraint.applyElevation) {
                        constraint.elevation = view.getElevation();
                    }
                }
            }
            if (view instanceof Barrier) {
                Barrier barrier = ((Barrier) view);
                constraint.mBarrierAllowsGoneWidgets = barrier.allowsGoneWidget();
                constraint.mReferenceIds = barrier.getReferencedIds();
                constraint.mBarrierDirection = barrier.getType();
            }
        }
    }

    /**
     * Copy the layout parameters of a ConstraintLayout.
     *
     * @param constraints The ConstraintLayout to be copied
     */
    public void clone(Constraints constraints) {
        int count = constraints.getChildCount();
        mConstraints.clear();
        for (int i = 0; i < count; i++) {
            View view = constraints.getChildAt(i);
            Constraints.LayoutParams param = (Constraints.LayoutParams) view.getLayoutParams();

            int id = view.getId();
            if (id == -1) {
                throw new RuntimeException("All children of ConstraintLayout must have ids to use ConstraintSet");
            }
            if (!mConstraints.containsKey(id)) {
                mConstraints.put(id, new Constraint());
            }
            Constraint constraint = mConstraints.get(id);
            if (view instanceof ConstraintHelper) {
                ConstraintHelper helper = (ConstraintHelper) view;
                constraint.fillFromConstraints(helper, id, param);
            }
            constraint.fillFromConstraints(id, param);
        }
    }

    /**
     * Apply the constraints to a ConstraintLayout.
     *
     * @param constraintLayout to be modified
     */
    public void applyTo(ConstraintLayout constraintLayout) {
        applyToInternal(constraintLayout);
        constraintLayout.setConstraintSet(null);
    }

    /**
     * Used to set constraints when used by constraint layout
     */
    void applyToInternal(ConstraintLayout constraintLayout) {
        int count = constraintLayout.getChildCount();
        HashSet<Integer> used = new HashSet<Integer>(mConstraints.keySet());

        for (int i = 0; i < count; i++) {
            View view = constraintLayout.getChildAt(i);
            int id = view.getId();
            if (id == -1) {
                throw new RuntimeException("All children of ConstraintLayout must have ids to use ConstraintSet");
            }
            if (mConstraints.containsKey(id)) {
                used.remove(id);
                Constraint constraint = mConstraints.get(id);
                if (view instanceof Barrier) {
                    constraint.mHelperType = BARRIER_TYPE;
                }
                if (constraint.mHelperType != UNSET) {
                    switch (constraint.mHelperType) {
                        case BARRIER_TYPE:
                            Barrier barrier = (Barrier) view;
                            barrier.setId(id);
                            barrier.setType(constraint.mBarrierDirection);
                            barrier.setAllowsGoneWidget(constraint.mBarrierAllowsGoneWidgets);
                            if (constraint.mReferenceIds != null) {
                                barrier.setReferencedIds(constraint.mReferenceIds);
                            } else if (constraint.mReferenceIdString != null) {
                                constraint.mReferenceIds = convertReferenceString(barrier,
                                        constraint.mReferenceIdString);
                                barrier.setReferencedIds(constraint.mReferenceIds);
                            }
                            break;
                    }
                }
                ConstraintLayout.LayoutParams param = (ConstraintLayout.LayoutParams) view
                    .getLayoutParams();
                constraint.applyTo(param);
                view.setLayoutParams(param);
                view.setVisibility(constraint.visibility);
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
                    view.setAlpha(constraint.alpha);
                    view.setRotation(constraint.rotation);
                    view.setRotationX(constraint.rotationX);
                    view.setRotationY(constraint.rotationY);
                    view.setScaleX(constraint.scaleX);
                    view.setScaleY(constraint.scaleY);
                    if (!Float.isNaN(constraint.transformPivotX)) {
                        view.setPivotX(constraint.transformPivotX);
                    }
                    if (!Float.isNaN(constraint.transformPivotY)) {
                        view.setPivotY(constraint.transformPivotY);
                    }
                    view.setTranslationX(constraint.translationX);
                    view.setTranslationY(constraint.translationY);
                    if (Build.VERSION.SDK_INT >= VERSION_CODES.LOLLIPOP) {
                        view.setTranslationZ(constraint.translationZ);
                        if (constraint.applyElevation) {
                            view.setElevation(constraint.elevation);
                        }
                    }
                }
            }
        }
        for (Integer id : used) {
            Constraint constraint = mConstraints.get(id);
            if (constraint.mHelperType != UNSET) {
                switch (constraint.mHelperType) {
                    case BARRIER_TYPE:
                        Barrier barrier = new Barrier(constraintLayout.getContext());
                        barrier.setId(id);
                        if (constraint.mReferenceIds != null) {
                            barrier.setReferencedIds(constraint.mReferenceIds);
                        } else if (constraint.mReferenceIdString != null) {
                            constraint.mReferenceIds = convertReferenceString(barrier,
                                    constraint.mReferenceIdString);
                            barrier.setReferencedIds(constraint.mReferenceIds);
                        }
                        barrier.setType(constraint.mBarrierDirection);
                        ConstraintLayout.LayoutParams param = constraintLayout
                            .generateDefaultLayoutParams();
                        barrier.validateParams();
                        constraint.applyTo(param);
                        constraintLayout.addView(barrier, param);
                        break;
                }
            }
            if (constraint.mIsGuideline) {
                Guideline g = new Guideline(constraintLayout.getContext());
                g.setId(id);
                ConstraintLayout.LayoutParams param = constraintLayout.generateDefaultLayoutParams();
                constraint.applyTo(param);
                constraintLayout.addView(g, param);
            }
        }
    }

    /**
     * Center widget between the other two widgets.
     *
     * @param centerID ID of the widget to be centered
     * @param firstID ID of the first widget to connect the left or top of the widget to
     * @param firstSide the side of the widget to connect to
     * @param firstMargin the connection margin
     * @param secondId the ID of the second widget to connect to right or top of the widget to
     * @param secondSide the side of the widget to connect to
     * @param secondMargin the connection margin
     * @param bias the ratio between two connections
     */
    public void center(int centerID,
        int firstID, int firstSide, int firstMargin,
        int secondId, int secondSide, int secondMargin,
        float bias) {
        // Error checking

        if (firstMargin < 0) {
            throw new IllegalArgumentException("margin must be > 0");
        }
        if (secondMargin < 0) {
            throw new IllegalArgumentException("margin must be > 0");
        }
        if (bias <= 0 || bias > 1) {
            throw new IllegalArgumentException("bias must be between 0 and 1 inclusive");
        }

        if (firstSide == LEFT || firstSide == RIGHT) {
            connect(centerID, LEFT, firstID, firstSide, firstMargin);
            connect(centerID, RIGHT, secondId, secondSide, secondMargin);
            Constraint constraint = mConstraints.get(centerID);
            constraint.horizontalBias = bias;
        } else if (firstSide == START || firstSide == END) {
            connect(centerID, START, firstID, firstSide, firstMargin);
            connect(centerID, END, secondId, secondSide, secondMargin);
            Constraint constraint = mConstraints.get(centerID);
            constraint.horizontalBias = bias;
        } else {
            connect(centerID, TOP, firstID, firstSide, firstMargin);
            connect(centerID, BOTTOM, secondId, secondSide, secondMargin);
            Constraint constraint = mConstraints.get(centerID);
            constraint.verticalBias = bias;
        }
    }

    /**
     * Centers the widget horizontally to the left and right side on another widgets sides.
     *
     * @param centerID ID of widget to be centered
     * @param leftId The Id of the widget on the left side
     * @param leftSide The side of the leftId widget to connect to
     * @param leftMargin The margin on the left side
     * @param rightId The Id of the widget on the right side
     * @param rightSide  The side  of the rightId widget to connect to
     * @param rightMargin The margin on the right side
     * @param bias The ratio of the space on the left vs. right sides 0.5 is centered (default)
     */
    public void centerHorizontally(int centerID, int leftId, int leftSide, int leftMargin,
        int rightId, int rightSide, int rightMargin, float bias) {
        connect(centerID, LEFT, leftId, leftSide, leftMargin);
        connect(centerID, RIGHT, rightId, rightSide, rightMargin);
        Constraint constraint = mConstraints.get(centerID);
        constraint.horizontalBias = bias;
    }

    /**
     * Centers the widgets horizontally to the left and right side on another widgets sides.
     *
     * @param centerID ID of widget to be centered
     * @param startId The Id of the widget on the start side (left in non rtl languages)
     * @param startSide The side of the startId widget to connect to
     * @param startMargin The margin on the start side
     * @param endId The Id of the widget on the start side (left in non rtl languages)
     * @param endSide The side of the endId widget to connect to
     * @param endMargin The margin on the end side
     * @param bias The ratio of the space on the start vs end side 0.5 is centered (default)
     */
    public void centerHorizontallyRtl(int centerID, int startId, int startSide, int startMargin,
        int endId, int endSide, int endMargin, float bias) {
        connect(centerID, START, startId, startSide, startMargin);
        connect(centerID, END, endId, endSide, endMargin);
        Constraint constraint = mConstraints.get(centerID);
        constraint.horizontalBias = bias;
    }

    /**
     * Centers the widgets Vertically to the top and bottom side on another widgets sides.
     *
     * @param centerID ID of widget to be centered
     * @param topId The Id of the widget on the top side
     * @param topSide The side of the leftId widget to connect to
     * @param topMargin The margin on the top side
     * @param bottomId The Id of the widget on the bottom side
     * @param bottomSide The side of the bottomId widget to connect to
     * @param bottomMargin The margin on the bottom side
     * @param bias The ratio of the space on the top vs. bottom sides 0.5 is centered (default)
     */
    public void centerVertically(int centerID, int topId, int topSide, int topMargin, int bottomId,
        int bottomSide, int bottomMargin, float bias) {
        connect(centerID, TOP, topId, topSide, topMargin);
        connect(centerID, BOTTOM, bottomId, bottomSide, bottomMargin);
        Constraint constraint = mConstraints.get(centerID);
        constraint.verticalBias = bias;
    }

    /**
     * Spaces a set of widgets vertically between the view topId and bottomId.
     * Widgets can be spaced with weights.
     *
     * @param topId The id of the widget to connect to or PARENT_ID
     * @param topSide the side of the start to connect to
     * @param bottomId The id of the widget to connect to or PARENT_ID
     * @param bottomSide the side of the right to connect to
     * @param chainIds widgets to use as a chain
     * @param weights can be null
     * @param style set the style of the chain
     */
    public void createVerticalChain(int topId, int topSide, int bottomId, int bottomSide, int[] chainIds, float[] weights,
        int style) {
        if (chainIds.length < 2) {
            throw new IllegalArgumentException("must have 2 or more widgets in a chain");
        }
        if (weights != null && weights.length != chainIds.length) {
            throw new IllegalArgumentException("must have 2 or more widgets in a chain");
        }
        if (weights != null) {
            get(chainIds[0]).verticalWeight = weights[0];
        }
        get(chainIds[0]).verticalChainStyle = style;

        connect(chainIds[0], TOP, topId, topSide, 0);
        for (int i = 1; i < chainIds.length; i++) {
            int chainId = chainIds[i];
            connect(chainIds[i], TOP, chainIds[i - 1], BOTTOM, 0);
            connect(chainIds[i - 1], BOTTOM, chainIds[i], TOP, 0);
            if (weights != null) {
                get(chainIds[i]).verticalWeight = weights[i];
            }
        }
        connect(chainIds[chainIds.length - 1], BOTTOM, bottomId, bottomSide, 0);
    }

    /**
     * Spaces a set of widgets horizontal between the view startID and endId.
     * Widgets can be spaced with weights.
     *
     * @param leftId The id of the widget to connect to or PARENT_ID
     * @param leftSide the side of the start to connect to
     * @param rightId The id of the widget to connect to or PARENT_ID
     * @param rightSide the side of the right to connect to
     * @param chainIds The widgets in the chain
     * @param weights The weight to assign to each element in the chain or null
     * @param style The type of chain
     */
    public void createHorizontalChain(int leftId, int leftSide, int rightId, int rightSide, int[] chainIds, float[] weights,
        int style) {
        createHorizontalChain(leftId, leftSide, rightId, rightSide, chainIds, weights, style, LEFT, RIGHT);
    }

    /**
     * Spaces a set of widgets horizontal between the view startID and endId.
     * Widgets can be spaced with weights.
     *
     * @param startId The id of the widget to connect to or PARENT_ID
     * @param startSide the side of the start to connect to
     * @param endId The id of the widget to connect to or PARENT_ID
     * @param endSide the side of the end to connect to
     * @param chainIds The widgets in the chain
     * @param weights The weight to assign to each element in the chain or null
     * @param style The type of chain
     */
    public void createHorizontalChainRtl(int startId, int startSide, int endId, int endSide, int[] chainIds, float[] weights,
        int style) {
        createHorizontalChain(startId, startSide, endId, endSide, chainIds, weights, style, START, END);
    }

    private void createHorizontalChain(int leftId,int leftSide, int rightId, int rightSide, int[] chainIds, float[] weights,
        int style, int left, int right) {

        if (chainIds.length < 2) {
            throw new IllegalArgumentException("must have 2 or more widgets in a chain");
        }
        if (weights != null && weights.length != chainIds.length) {
            throw new IllegalArgumentException("must have 2 or more widgets in a chain");
        }
        if (weights != null) {
            get(chainIds[0]).horizontalWeight = weights[0];
        }
        get(chainIds[0]).horizontalChainStyle = style;
        connect(chainIds[0], left, leftId, leftSide, UNSET);
        for (int i = 1; i < chainIds.length; i++) {
            int chainId = chainIds[i];
            connect(chainIds[i], left, chainIds[i - 1], right, UNSET);
            connect(chainIds[i - 1], right, chainIds[i], left, UNSET);
            if (weights != null) {
                get(chainIds[i]).horizontalWeight = weights[i];
            }
        }

        connect(chainIds[chainIds.length - 1], right, rightId, rightSide,
            UNSET);

    }

    /**
     * Create a constraint between two widgets.
     *
     * @param startID the ID of the widget to be constrained
     * @param startSide the side of the widget to constrain
     * @param endID the id of the widget to constrain to
     * @param endSide the side of widget to constrain to
     * @param margin the margin to constrain (margin must be positive)
     */
    public void connect(int startID, int startSide, int endID, int endSide, int margin) {
        if (!mConstraints.containsKey(startID)) {
            mConstraints.put(startID, new Constraint());
        }
        Constraint constraint = mConstraints.get(startID);
        switch (startSide) {
            case LEFT:
                if (endSide == LEFT) {
                    constraint.leftToLeft = endID;
                    constraint.leftToRight = Constraint.UNSET;
                } else if (endSide == RIGHT) {
                    constraint.leftToRight = endID;
                    constraint.leftToLeft = Constraint.UNSET;

                } else {
                    throw new IllegalArgumentException("Left to " + sideToString(endSide) + " undefined");
                }
                constraint.leftMargin = margin;
                break;
            case RIGHT:
                if (endSide == LEFT) {
                    constraint.rightToLeft = endID;
                    constraint.rightToRight = Constraint.UNSET;

                } else if (endSide == RIGHT) {
                    constraint.rightToRight = endID;
                    constraint.rightToLeft = Constraint.UNSET;

                } else {
                    throw new IllegalArgumentException("right to " + sideToString(endSide) + " undefined");
                }
                constraint.rightMargin = margin;
                break;
            case TOP:
                if (endSide == TOP) {
                    constraint.topToTop = endID;
                    constraint.topToBottom = Constraint.UNSET;
                    constraint.baselineToBaseline = Constraint.UNSET;
                } else if (endSide == BOTTOM) {
                    constraint.topToBottom = endID;
                    constraint.topToTop = Constraint.UNSET;
                    constraint.baselineToBaseline = Constraint.UNSET;

                } else {
                    throw new IllegalArgumentException("right to " + sideToString(endSide) + " undefined");
                }
                constraint.topMargin = margin;
                break;
            case BOTTOM:
                if (endSide == BOTTOM) {
                    constraint.bottomToBottom = endID;
                    constraint.bottomToTop = Constraint.UNSET;
                    constraint.baselineToBaseline = Constraint.UNSET;
                    ;
                } else if (endSide == TOP) {
                    constraint.bottomToTop = endID;
                    constraint.bottomToBottom = Constraint.UNSET;
                    constraint.baselineToBaseline = Constraint.UNSET;
                    ;
                } else {
                    throw new IllegalArgumentException("right to " + sideToString(endSide) + " undefined");
                }
                constraint.bottomMargin = margin;
                break;
            case BASELINE:
                if (endSide == BASELINE) {
                    constraint.baselineToBaseline = endID;
                    constraint.bottomToBottom = Constraint.UNSET;
                    constraint.bottomToTop = Constraint.UNSET;
                    constraint.topToTop = Constraint.UNSET;
                    constraint.topToBottom = Constraint.UNSET;
                } else {
                    throw new IllegalArgumentException("right to " + sideToString(endSide) + " undefined");
                }
                break;
            case START:
                if (endSide == START) {
                    constraint.startToStart = endID;
                    constraint.startToEnd = Constraint.UNSET;
                } else if (endSide == END) {
                    constraint.startToEnd = endID;
                    constraint.startToStart = Constraint.UNSET;
                } else {
                    throw new IllegalArgumentException("right to " + sideToString(endSide) + " undefined");
                }
                constraint.startMargin = margin;
                break;
            case END:
                if (endSide == END) {
                    constraint.endToEnd = endID;
                    constraint.endToStart = Constraint.UNSET;
                } else if (endSide == START) {
                    constraint.endToStart = endID;
                    constraint.endToEnd = Constraint.UNSET;
                } else {
                    throw new IllegalArgumentException("right to " + sideToString(endSide) + " undefined");
                }
                constraint.endMargin = margin;
                break;
            default:
                throw new IllegalArgumentException(
                    sideToString(startSide) + " to " + sideToString(endSide) + " unknown");
        }
    }

    /**
     * Create a constraint between two widgets.
     *
     * @param startID the ID of the widget to be constrained
     * @param startSide the side of the widget to constrain
     * @param endID the id of the widget to constrain to
     * @param endSide the side of widget to constrain to
     */
    public void connect(int startID, int startSide, int endID, int endSide) {
        if (!mConstraints.containsKey(startID)) {
            mConstraints.put(startID, new Constraint());
        }
        Constraint constraint = mConstraints.get(startID);
        switch (startSide) {
            case LEFT:
                if (endSide == LEFT) {
                    constraint.leftToLeft = endID;
                    constraint.leftToRight = Constraint.UNSET;
                } else if (endSide == RIGHT) {
                    constraint.leftToRight = endID;
                    constraint.leftToLeft = Constraint.UNSET;
                } else {
                    throw new IllegalArgumentException("left to " + sideToString(endSide) + " undefined");
                }
                break;
            case RIGHT:
                if (endSide == LEFT) {
                    constraint.rightToLeft = endID;
                    constraint.rightToRight = Constraint.UNSET;

                } else if (endSide == RIGHT) {
                    constraint.rightToRight = endID;
                    constraint.rightToLeft = Constraint.UNSET;
                } else {
                    throw new IllegalArgumentException("right to " + sideToString(endSide) + " undefined");
                }
                break;
            case TOP:
                if (endSide == TOP) {
                    constraint.topToTop = endID;
                    constraint.topToBottom = Constraint.UNSET;
                    constraint.baselineToBaseline = Constraint.UNSET;
                } else if (endSide == BOTTOM) {
                    constraint.topToBottom = endID;
                    constraint.topToTop = Constraint.UNSET;
                    constraint.baselineToBaseline = Constraint.UNSET;
                } else {
                    throw new IllegalArgumentException("right to " + sideToString(endSide) + " undefined");
                }
                break;
            case BOTTOM:
                if (endSide == BOTTOM) {
                    constraint.bottomToBottom = endID;
                    constraint.bottomToTop = Constraint.UNSET;
                    constraint.baselineToBaseline = Constraint.UNSET;
                } else if (endSide == TOP) {
                    constraint.bottomToTop = endID;
                    constraint.bottomToBottom = Constraint.UNSET;
                    constraint.baselineToBaseline = Constraint.UNSET;
                } else {
                    throw new IllegalArgumentException("right to " + sideToString(endSide) + " undefined");
                }
                break;
            case BASELINE:
                if (endSide == BASELINE) {
                    constraint.baselineToBaseline = endID;
                    constraint.bottomToBottom = Constraint.UNSET;
                    constraint.bottomToTop = Constraint.UNSET;
                    constraint.topToTop = Constraint.UNSET;
                    constraint.topToBottom = Constraint.UNSET;
                } else {
                    throw new IllegalArgumentException("right to " + sideToString(endSide) + " undefined");
                }
                break;
            case START:
                if (endSide == START) {
                    constraint.startToStart = endID;
                    constraint.startToEnd = Constraint.UNSET;
                } else if (endSide == END) {
                    constraint.startToEnd = endID;
                    constraint.startToStart = Constraint.UNSET;
                } else {
                    throw new IllegalArgumentException("right to " + sideToString(endSide) + " undefined");
                }
                break;
            case END:
                if (endSide == END) {
                    constraint.endToEnd = endID;
                    constraint.endToStart = Constraint.UNSET;
                } else if (endSide == START) {
                    constraint.endToStart = endID;
                    constraint.endToEnd = Constraint.UNSET;
                } else {
                    throw new IllegalArgumentException("right to " + sideToString(endSide) + " undefined");
                }
                break;
            default:
                throw new IllegalArgumentException(
                    sideToString(startSide) + " to " + sideToString(endSide) + " unknown");
        }
    }

    /**
     * Centers the view horizontally relative to toView's position.
     *
     * @param viewId ID of view to center Horizontally
     * @param toView ID of view to center on (or in)
     */
    public void centerHorizontally(int viewId, int toView) {
        if (toView == PARENT_ID) {
            center(viewId, PARENT_ID , ConstraintSet.LEFT, 0, PARENT_ID, ConstraintSet.RIGHT, 0, 0.5f);
        } else {
            center(viewId, toView, ConstraintSet.RIGHT, 0, toView, ConstraintSet.LEFT, 0, 0.5f);
        }
    }

    /**
     * Centers the view horizontally relative to toView's position.
     *
     * @param viewId ID of view to center Horizontally
     * @param toView ID of view to center on (or in)
     */
    public void centerHorizontallyRtl(int viewId, int toView) {
        if (toView == PARENT_ID) {
            center(viewId, PARENT_ID , ConstraintSet.START, 0, PARENT_ID, ConstraintSet.END, 0, 0.5f);
        } else {
            center(viewId, toView, ConstraintSet.END, 0, toView, ConstraintSet.START, 0, 0.5f);
        }
    }


    /**
     * Centers the view vertically relative to toView's position.
     *
     * @param viewId ID of view to center Horizontally
     * @param toView ID of view to center on (or in)
     */
    public void centerVertically(int viewId, int toView) {
        if (toView == PARENT_ID) {
            center(viewId, PARENT_ID, ConstraintSet.TOP, 0, PARENT_ID, ConstraintSet.BOTTOM, 0, 0.5f);
        } else {
            center(viewId, toView, ConstraintSet.BOTTOM, 0, toView, ConstraintSet.TOP, 0, 0.5f);
        }
    }

    /**
     * Remove all constraints from this view.
     *
     * @param viewId ID of view to remove all connections to
     */
    public void clear(int viewId) {
        mConstraints.remove(viewId);
    }

    /**
     * Remove a constraint from this view.
     *
     * @param viewId ID of view to center on (or in)
     * @param anchor the Anchor to remove constraint from
     */
    public void clear(int viewId, int anchor) {
        if (mConstraints.containsKey(viewId)) {
            Constraint constraint = mConstraints.get(viewId);
            switch (anchor) {
                case LEFT:
                    constraint.leftToRight = Constraint.UNSET;
                    constraint.leftToLeft = Constraint.UNSET;
                    constraint.leftMargin = Constraint.UNSET;
                    constraint.goneLeftMargin = Constraint.UNSET;
                    break;
                case RIGHT:
                    constraint.rightToRight = Constraint.UNSET;
                    constraint.rightToLeft = Constraint.UNSET;
                    constraint.rightMargin = Constraint.UNSET;
                    constraint.goneRightMargin = Constraint.UNSET;
                    break;
                case TOP:
                    constraint.topToBottom = Constraint.UNSET;
                    constraint.topToTop = Constraint.UNSET;
                    constraint.topMargin = Constraint.UNSET;
                    constraint.goneTopMargin = Constraint.UNSET;
                    break;
                case BOTTOM:
                    constraint.bottomToTop = Constraint.UNSET;
                    constraint.bottomToBottom = Constraint.UNSET;
                    constraint.bottomMargin = Constraint.UNSET;
                    constraint.goneBottomMargin = Constraint.UNSET;
                    break;
                case BASELINE:

                    constraint.baselineToBaseline = Constraint.UNSET;
                    break;
                case START:
                    constraint.startToEnd = Constraint.UNSET;
                    constraint.startToStart = Constraint.UNSET;
                    constraint.startMargin = Constraint.UNSET;
                    constraint.goneStartMargin = Constraint.UNSET;
                    break;
                case END:
                    constraint.endToStart = Constraint.UNSET;
                    constraint.endToEnd = Constraint.UNSET;
                    constraint.endMargin = Constraint.UNSET;
                    constraint.goneEndMargin = Constraint.UNSET;
                    break;
                default:
                    throw new IllegalArgumentException("unknown constraint");
            }
        }
    }

    /**
     * Sets the margin.
     *
     * @param viewId ID of view to adjust the margin on
     * @param anchor The side to adjust the margin on
     * @param value The new value for the margin
     */
    public void setMargin(int viewId, int anchor, int value) {
        Constraint constraint = get(viewId);
        switch (anchor) {
            case LEFT:
                constraint.leftMargin = value;
                break;
            case RIGHT:
                constraint.rightMargin = value;
                break;
            case TOP:
                constraint.topMargin = value;
                break;
            case BOTTOM:
                constraint.bottomMargin = value;
                break;
            case BASELINE:
                throw new IllegalArgumentException("baseline does not support margins");
            case START:
                constraint.startMargin = value;
                break;
            case END:
                constraint.endMargin = value;
                break;
            default:
                throw new IllegalArgumentException("unknown constraint");
        }
    }

    /**
     * Sets the gone margin.
     *
     * @param viewId ID of view to adjust the margin on
     * @param anchor The side to adjust the margin on
     * @param value The new value for the margin
     */
    public void setGoneMargin(int viewId, int anchor, int value) {
        Constraint constraint = get(viewId);
        switch (anchor) {
            case LEFT:
                constraint.goneLeftMargin = value;
                break;
            case RIGHT:
                constraint.goneRightMargin = value;
                break;
            case TOP:
                constraint.goneTopMargin = value;
                break;
            case BOTTOM:
                constraint.goneBottomMargin = value;
                break;
            case BASELINE:
                throw new IllegalArgumentException("baseline does not support margins");
            case START:
                constraint.goneStartMargin = value;
                break;
            case END:
                constraint.goneEndMargin = value;
                break;
            default:
                throw new IllegalArgumentException("unknown constraint");
        }
    }

    /**
     * Adjust the horizontal bias of the view (used with views constrained on left and right).
     *
     * @param viewId ID of view to adjust the horizontal
     * @param bias the new bias 0.5 is in the middle
     */
    public void setHorizontalBias(int viewId, float bias) {
        get(viewId).horizontalBias = bias;
    }

    /**
     * Adjust the vertical bias of the view (used with views constrained on left and right).
     *
     * @param viewId ID of view to adjust the vertical
     * @param bias the new bias 0.5 is in the middle
     */
    public void setVerticalBias(int viewId, float bias) {
        get(viewId).verticalBias = bias;
    }

    /**
     * Constrains the views aspect ratio.
     * For Example a HD screen is 16 by 9 = 16/(float)9 = 1.777f.
     *
     * @param viewId ID of view to constrain
     * @param ratio The ratio of the width to height (width / height)
     */
    public void setDimensionRatio(int viewId, String ratio) {
        get(viewId).dimensionRatio = ratio;
    }

    /**
     * Adjust the visibility of a view.
     *
     * @param viewId ID of view to adjust the vertical
     * @param visibility the visibility
     */
    public void setVisibility(int viewId, int visibility) {
        get(viewId).visibility = visibility;
    }

    /**
     * Adjust the alpha of a view.
     *
     * @param viewId ID of view to adjust the vertical
     * @param alpha the alpha
     */
    public void setAlpha(int viewId, float alpha) {
        get(viewId).alpha = alpha;
    }

    /**
     * return with the constraint set will apply elevation for the specified view.
     *
     * @return true if the elevation will be set on this view (default is false)
     */
    public boolean getApplyElevation(int viewId) {
        return get(viewId).applyElevation;
    }

    /**
     * set if elevation will be applied to the view.
     * Elevation logic is based on style and animation. By default it is not used because it would
     * lead to unexpected results.
     *
     * @param apply true if this constraint set applies elevation to this view
     */
    public void setApplyElevation(int viewId, boolean apply) {
        get(viewId).applyElevation = apply;
    }

    /**
     * Adjust the elevation of a view.
     *
     * @param viewId ID of view to adjust the elevation
     * @param elevation the elevation
     */
    public void setElevation(int viewId, float elevation) {
        get(viewId).elevation = elevation;
        get(viewId).applyElevation = true;
    }

    /**
     * Adjust the post-layout rotation about the Z axis of a view.
     *
     * @param viewId ID of view to adjust th X rotation
     * @param rotation the rotation about the X axis
     */
    public void setRotation(int viewId, float rotation) {
        get(viewId).rotation = rotation;
    }

    /**
     * Adjust the post-layout rotation about the X axis of a view.
     *
     * @param viewId ID of view to adjust th X rotation
     * @param rotationX the rotation about the X axis
     */
    public void setRotationX(int viewId, float rotationX) {
        get(viewId).rotationX = rotationX;
    }

    /**
     * Adjust the post-layout rotation about the Y axis of a view.
     *
     * @param viewId ID of view to adjust the Y rotation
     * @param rotationY the rotationY
     */
    public void setRotationY(int viewId, float rotationY) {
        get(viewId).rotationY = rotationY;
    }

    /**
     * Adjust the post-layout scale in X of a view.
     *
     * @param viewId ID of view to adjust the scale in X
     * @param scaleX the scale in X
     */
    public void setScaleX(int viewId, float scaleX) {
        get(viewId).scaleX = scaleX;
    }

    /**
     * Adjust the post-layout scale in Y of a view.
     *
     * @param viewId ID of view to adjust the scale in Y
     * @param scaleY the scale in Y
     */
    public void setScaleY(int viewId, float scaleY) {
        get(viewId).scaleY = scaleY;
    }

    /**
     * Set X location of the pivot point around which the view will rotate and scale.
     * use Float.NaN to clear the pivot value.
     * Note: once an actual View has had its pivot set it cannot be cleared.
     *
     * @param viewId ID of view to adjust the transforms pivot point about X
     * @param transformPivotX X location of the pivot point.
     */
    public void setTransformPivotX(int viewId, float transformPivotX) {
        get(viewId).transformPivotX = transformPivotX;
    }

    /**
     * Set Y location of the pivot point around which the view will rotate and scale.
     * use Float.NaN to clear the pivot value.
     * Note: once an actual View has had its pivot set it cannot be cleared.
     *
     * @param viewId ID of view to adjust the transforms pivot point about Y
     * @param transformPivotY Y location of the pivot point.
     */
    public void setTransformPivotY(int viewId, float transformPivotY) {
        get(viewId).transformPivotY = transformPivotY;
    }

    /**
     * Set X,Y location of the pivot point around which the view will rotate and scale.
     * use Float.NaN to clear the pivot value.
     * Note: once an actual View has had its pivot set it cannot be cleared.
     *
     * @param viewId ID of view to adjust the transforms pivot point
     * @param transformPivotX X location of the pivot point.
     * @param transformPivotY Y location of the pivot point.
     */
    public void setTransformPivot(int viewId, float transformPivotX, float transformPivotY) {
        Constraint constraint = get(viewId);
        constraint.transformPivotY = transformPivotY;
        constraint.transformPivotX = transformPivotX;
    }

    /**
     * Adjust the post-layout X translation of a view.
     *
     * @param viewId ID of view to translate in X
     * @param translationX the translation in X
     */
    public void setTranslationX(int viewId, float translationX) {
        get(viewId).translationX = translationX;
    }

    /**
     * Adjust the  post-layout Y translation of a view.
     *
     * @param viewId ID of view to to translate in Y
     * @param translationY the translation in Y
     */
    public void setTranslationY(int viewId, float translationY) {
        get(viewId).translationY = translationY;
    }

    /**
     * Adjust the post-layout translation of a view.
     *
     * @param viewId ID of view to adjust its translation in X & Y
     * @param translationX the translation in X
     * @param translationY the translation in Y
     */
    public void setTranslation(int viewId, float translationX, float translationY) {
        Constraint constraint = get(viewId);
        constraint.translationX = translationX;
        constraint.translationY = translationY;
    }

    /**
     * Adjust the translation in Z of a view.
     *
     * @param viewId ID of view to adjust
     * @param translationZ the translationZ
     */
    public void setTranslationZ(int viewId, float translationZ) {
        get(viewId).translationZ = translationZ;
    }

    /**
     * Sets the height of the view. It can be a dimension, {@link #WRAP_CONTENT} or {@link
     * #MATCH_CONSTRAINT}.
     *
     * @param viewId ID of view to adjust its height
     * @param height the height of the constraint
     *
     * @since 1.1
     */
    public void constrainHeight(int viewId, int height) {
        get(viewId).mHeight = height;
    }

    /**
     * Sets the width of the view. It can be a dimension, {@link #WRAP_CONTENT} or {@link
     * #MATCH_CONSTRAINT}.
     *
     * @param viewId ID of view to adjust its width
     * @param width the width of the view
     *
     * @since 1.1
     */
    public void constrainWidth(int viewId, int width) {
        get(viewId).mWidth = width;
    }

    /**
     * Constrain the view on a circle constraint
     *
     * @param viewId ID of the view we constrain
     * @param id ID of the view we constrain relative to
     * @param radius the radius of the circle in degrees
     * @param angle the angle
     *
     * @since 1.1
     */
    public void constrainCircle(int viewId, int id, int radius, float angle) {
        Constraint constraint = get(viewId);
        constraint.circleConstraint = id;
        constraint.circleRadius = radius;
        constraint.circleAngle = angle;
    }

    /**
     * Sets the maximum height of the view. It is a dimension, It is only applicable if height is
     * #MATCH_CONSTRAINT}.
     *
     * @param viewId ID of view to adjust it height
     * @param height the height of the constraint
     *
     * @since 1.1
     */
    public void constrainMaxHeight(int viewId, int height) {
        get(viewId).heightMax = height;
    }

    /**
     * Sets the maximum width of the view. It is a dimension, It is only applicable if width is
     * #MATCH_CONSTRAINT}.
     *
     * @param viewId ID of view to adjust its max height
     * @param width the width of the view
     *
     * @since 1.1
     */
    public void constrainMaxWidth(int viewId, int width) {
        get(viewId).widthMax = width;
    }

    /**
     * Sets the height of the view. It is a dimension, It is only applicable if height is
     * #MATCH_CONSTRAINT}.
     *
     * @param viewId ID of view to adjust its min height
     * @param height the minimum height of the view
     *
     * @since 1.1
     */
    public void constrainMinHeight(int viewId, int height) {
        get(viewId).heightMin = height;
    }

    /**
     * Sets the width of the view.  It is a dimension, It is only applicable if width is
     * #MATCH_CONSTRAINT}.
     *
     * @param viewId ID of view to adjust its min height
     * @param width the minimum width of the view
     *
     * @since 1.1
     */
    public void constrainMinWidth(int viewId, int width) {
        get(viewId).widthMin = width;
    }

    /**
     * Sets the width of the view as a percentage of the parent.
     * @param viewId
     * @param percent
     *
     * @since 1.1
     */
    public void constrainPercentWidth(int viewId, float percent) {
        get(viewId).widthPercent = percent;
    }

    /**
     * Sets the height of the view as a percentage of the parent.
     * @param viewId
     * @param percent
     *
     * @since 1.1
     */
    public void constrainPercentHeight(int viewId, float percent) {
        get(viewId).heightPercent = percent;
    }

    /**
     * Sets how the height is calculated ether MATCH_CONSTRAINT_WRAP or MATCH_CONSTRAINT_SPREAD.
     * Default is spread.
     *
     * @param viewId ID of view to adjust its matchConstraintDefaultHeight
     * @param height MATCH_CONSTRAINT_WRAP or MATCH_CONSTRAINT_SPREAD
     *
     * @since 1.1
     */
    public void constrainDefaultHeight(int viewId, int height) {
        get(viewId).heightDefault = height;
    }

    /**
     * Sets how the width is calculated ether MATCH_CONSTRAINT_WRAP or MATCH_CONSTRAINT_SPREAD.
     * Default is spread.
     *
     * @param viewId ID of view to adjust its matchConstraintDefaultWidth
     * @param width SPREAD or WRAP
     *
     * @since 1.1
     */
    public void constrainDefaultWidth(int viewId, int width) {
        get(viewId).widthDefault = width;
    }


    /**
     * The child's weight that we can use to distribute the available horizontal space
     * in a chain, if the dimension behaviour is set to MATCH_CONSTRAINT
     *
     * @param viewId ID of view to adjust its HorizontalWeight
     * @param weight the weight that we can use to distribute the horizontal space
     */
    public void setHorizontalWeight(int viewId, float weight) {
        get(viewId).horizontalWeight = weight;
    }

    /**
     * The child's weight that we can use to distribute the available horizontal space
     * in a chain, if the dimension behaviour is set to MATCH_CONSTRAINT
     *
     * @param viewId ID of view to adjust its VerticalWeight
     * @param weight the weight that we can use to distribute the horizontal space
     */
    public void setVerticalWeight(int viewId, float weight) {
        get(viewId).verticalWeight = weight;
    }

    /**
     * How the elements of the horizontal chain will be positioned. The possible values are:
     *
     * <ul> <li>{@see CHAIN_SPREAD} -- the elements will be spread out</li> <li>{@see
     * CHAIN_SPREAD_INSIDE} -- similar, but the endpoints of the chain will not be spread out</li>
     * <li>{@see CHAIN_PACKED} -- the elements of the chain will be packed together. The horizontal
     * bias attribute of the child will then affect the positioning of the packed elements</li> </ul>
     *
     * @param viewId ID of view to adjust its HorizontalChainStyle
     * @param chainStyle the weight that we can use to distribute the horizontal space
     */
    public void setHorizontalChainStyle(int viewId, int chainStyle) {
        get(viewId).horizontalChainStyle = chainStyle;
    }

    /**
     * How the elements of the vertical chain will be positioned. in a chain, if the dimension
     * behaviour is set to MATCH_CONSTRAINT
     *
     * <ul> <li>{@see CHAIN_SPREAD} -- the elements will be spread out</li> <li>{@see
     * CHAIN_SPREAD_INSIDE} -- similar, but the endpoints of the chain will not be spread out</li>
     * <li>{@see CHAIN_PACKED} -- the elements of the chain will be packed together. The horizontal
     * bias attribute of the child will then affect the positioning of the packed elements</li> </ul>
     *
     * @param viewId ID of view to adjust its VerticalChainStyle
     * @param chainStyle the weight that we can use to distribute the horizontal space
     */
    public void setVerticalChainStyle(int viewId, int chainStyle) {
        get(viewId).verticalChainStyle = chainStyle;
    }

    /**
     * Adds a view to a horizontal chain.
     *
     * @param viewId view to add
     * @param leftId view in chain to the left
     * @param rightId view in chain to the right
     */
    public void addToHorizontalChain(int viewId, int leftId, int rightId) {
        connect(viewId, LEFT, leftId, (leftId == PARENT_ID) ? LEFT : RIGHT, 0);
        connect(viewId, RIGHT, rightId, (rightId == PARENT_ID) ? RIGHT : LEFT, 0);
        if (leftId != PARENT_ID) {
            connect(leftId, RIGHT, viewId, LEFT, 0);
        }
        if (rightId != PARENT_ID) {
            connect(rightId, LEFT, viewId, RIGHT, 0);
        }
    }

    /**
     * Adds a view to a horizontal chain.
     *
     * @param viewId view to add
     * @param leftId view to the start side
     * @param rightId view to the end side
     */
    public void addToHorizontalChainRTL(int viewId, int leftId, int rightId) {
        connect(viewId, START, leftId, (leftId == PARENT_ID) ? START : END, 0);
        connect(viewId, END, rightId, (rightId == PARENT_ID) ? END : START, 0);
        if (leftId != PARENT_ID) {
            connect(leftId, END, viewId, START, 0);
        }
        if (rightId != PARENT_ID) {
            connect(rightId, START, viewId, END, 0);
        }
    }

    /**
     * Adds a view to a vertical chain.
     *
     * @param viewId view to add to a vertical chain
     * @param topId view above.
     * @param bottomId view below
     */
    public void addToVerticalChain(int viewId, int topId, int bottomId) {
        connect(viewId, TOP, topId, (topId == PARENT_ID) ? TOP : BOTTOM, 0);
        connect(viewId, BOTTOM, bottomId, (bottomId == PARENT_ID) ? BOTTOM : TOP, 0);
        if (topId != PARENT_ID) {
            connect(topId, BOTTOM, viewId, TOP, 0);
        }
        if (topId != PARENT_ID) {
            connect(bottomId, TOP, viewId, BOTTOM, 0);
        }
    }

    /**
     * Removes a view from a vertical chain.
     * This assumes the view is connected to a vertical chain.
     * Its behaviour is undefined if not part of a vertical chain.
     *
     * @param viewId the view to be removed
     */
    public void removeFromVerticalChain(int viewId) {
        if (mConstraints.containsKey(viewId)) {
            Constraint constraint = mConstraints.get(viewId);
            int topId = constraint.topToBottom;
            int bottomId = constraint.bottomToTop;
            if (topId != Constraint.UNSET || bottomId != Constraint.UNSET) {
                if (topId != Constraint.UNSET && bottomId != Constraint.UNSET) {
                    // top and bottom connected to views
                    connect(topId, BOTTOM, bottomId, TOP, 0);
                    connect(bottomId, TOP, topId, BOTTOM, 0);
                } else if (topId != Constraint.UNSET || bottomId != Constraint.UNSET) {
                    if (constraint.bottomToBottom != Constraint.UNSET) {
                        // top connected to view. Bottom connected to parent
                        connect(topId, BOTTOM, constraint.bottomToBottom, BOTTOM, 0);
                    } else if (constraint.topToTop != Constraint.UNSET) {
                        // bottom connected to view. Top connected to parent
                        connect(bottomId, TOP, constraint.topToTop, TOP, 0);
                    }
                }
            }
        }
        clear(viewId, TOP);
        clear(viewId, BOTTOM);
    }

    /**
     * Removes a view from a horizontal chain.
     * This assumes the view is connected to a horizontal chain.
     * Its behaviour is undefined if not part of a horizontal chain.
     *
     * @param viewId the view to be removed
     */
    public void removeFromHorizontalChain(int viewId) {
        if (mConstraints.containsKey(viewId)) {
            Constraint constraint = mConstraints.get(viewId);
            int leftId = constraint.leftToRight;
            int rightId = constraint.rightToLeft;
            if (leftId != Constraint.UNSET || rightId != Constraint.UNSET) {
                if (leftId != Constraint.UNSET && rightId != Constraint.UNSET) {
                    // left and right connected to views
                    connect(leftId, RIGHT, rightId, LEFT, 0);
                    connect(rightId, LEFT, leftId, RIGHT, 0);
                } else if (leftId != Constraint.UNSET || rightId != Constraint.UNSET) {
                    if (constraint.rightToRight != Constraint.UNSET) {
                        // left connected to view. right connected to parent
                        connect(leftId, RIGHT, constraint.rightToRight, RIGHT, 0);
                    } else if (constraint.leftToLeft != Constraint.UNSET) {
                        // right connected to view. left connected to parent
                        connect(rightId, LEFT, constraint.leftToLeft, LEFT, 0);
                    }
                }
                clear(viewId, LEFT);
                clear(viewId, RIGHT);
            } else {

                int startId = constraint.startToEnd;
                int endId = constraint.endToStart;
                if (startId != Constraint.UNSET || endId != Constraint.UNSET) {
                    if (startId != Constraint.UNSET && endId != Constraint.UNSET) {
                        // start and end connected to views
                        connect(startId, END, endId, START, 0);
                        connect(endId, START, leftId, END, 0);
                    } else if (leftId != Constraint.UNSET || endId != Constraint.UNSET) {
                        if (constraint.rightToRight != Constraint.UNSET) {
                            // left connected to view. right connected to parent
                            connect(leftId, END, constraint.rightToRight, END, 0);
                        } else if (constraint.leftToLeft != Constraint.UNSET) {
                            // right connected to view. left connected to parent
                            connect(endId, START, constraint.leftToLeft, START, 0);
                        }
                    }
                }
                clear(viewId, START);
                clear(viewId, END);
            }
        }
    }

    /**
     * Creates a ConstraintLayout virtual object. Currently only horizontal or vertical GuideLines.
     *
     * @param guidelineID ID of guideline to create
     * @param orientation the Orientation of the guideline
     */
    public void create(int guidelineID, int orientation) {
        Constraint constraint = get(guidelineID);
        constraint.mIsGuideline = true;
        constraint.orientation = orientation;
    }

    /**
     * Creates a ConstraintLayout Barrier object.
     *
     * @param id
     * @param direction Barrier.{LEFT,RIGHT,TOP,BOTTOM,START,END}
     * @param referenced
     *
     * @since 1.1
     */
    public void createBarrier(int id, int direction, int... referenced) {
        Constraint constraint = get(id);
        constraint.mHelperType = BARRIER_TYPE;
        constraint.mBarrierDirection = direction;
        constraint.mIsGuideline = false;
        constraint.mReferenceIds = referenced;
    }

    /**
     * Set the guideline's distance form the top or left edge.
     *
     * @param guidelineID ID of the guideline
     * @param margin the distance to the top or left edge
     */
    public void setGuidelineBegin(int guidelineID, int margin) {
        get(guidelineID).guideBegin = margin;
        get(guidelineID).guideEnd = Constraint.UNSET;
        get(guidelineID).guidePercent = Constraint.UNSET;

    }

    /**
     * Set a guideline's distance to end.
     *
     * @param guidelineID ID of the guideline
     * @param margin the margin to the right or bottom side of container
     */
    public void setGuidelineEnd(int guidelineID, int margin) {
        get(guidelineID).guideEnd = margin;
        get(guidelineID).guideBegin = Constraint.UNSET;
        get(guidelineID).guidePercent = Constraint.UNSET;
    }

    /**
     * Set a Guideline's percent.
     *
     * @param guidelineID ID of the guideline
     * @param ratio the ratio between the gap on the left and right 0.0 is top/left 0.5 is middle
     */
    public void setGuidelinePercent(int guidelineID, float ratio) {
        get(guidelineID).guidePercent = ratio;
        get(guidelineID).guideEnd = Constraint.UNSET;
        get(guidelineID).guideBegin = Constraint.UNSET;
    }

    public void setBarrierType(int id, int type) {

    }
    private Constraint get(int id) {
        if (!mConstraints.containsKey(id)) {
            mConstraints.put(id, new Constraint());
        }
        return mConstraints.get(id);
    }

    private String sideToString(int side) {
        switch (side) {
            case LEFT:
                return "left";
            case RIGHT:
                return "right";
            case TOP:
                return "top";
            case BOTTOM:
                return "bottom";
            case BASELINE:
                return "baseline";
            case START:
                return "start";
            case END:
                return "end";
        }
        return "undefined";
    }

    /**
     * Load a constraint set from a constraintSet.xml file.
     * Note. Do NOT use this to load a layout file.
     * It will fail silently as there is no efficient way to differentiate.
     *
     * @param context the context for the inflation
     * @param resourceId id of xml file in res/xml/
     */
    public void load(Context context, int resourceId) {
        Resources res = context.getResources();
        XmlPullParser parser = res.getXml(resourceId);
        String document = null;
        String tagName = null;
        try {

            for (int eventType = parser.getEventType();
                eventType != XmlResourceParser.END_DOCUMENT;
                eventType = parser.next()) {
                switch (eventType) {
                    case XmlResourceParser.START_DOCUMENT:
                        document = parser.getName();
                        break;
                    case XmlResourceParser.START_TAG:
                        tagName = parser.getName();
                        Constraint constraint = fillFromAttributeList(context, Xml.asAttributeSet(parser));
                        if (tagName.equalsIgnoreCase("Guideline")) {
                            constraint.mIsGuideline = true;
                        }
                        mConstraints.put(constraint.mViewId, constraint);
                        break;
                    case XmlResourceParser.END_TAG:
                        tagName = null;
                        break;
                    case XmlResourceParser.TEXT:
                        break;
                }
            }
        } catch (XmlPullParserException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static int lookupID(TypedArray a, int index, int def) {
        int ret = a.getResourceId(index, def);
        if (ret == Constraint.UNSET) {
            ret = a.getInt(index, Constraint.UNSET);
        }
        return ret;
    }

    private Constraint fillFromAttributeList(Context context, AttributeSet attrs) {
        Constraint c = new Constraint();
        TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.ConstraintSet);
        populateConstraint(c, a);
        a.recycle();
        return c;
    }

    private void populateConstraint(Constraint c, TypedArray a) {
        final int N = a.getIndexCount();
        for (int i = 0; i < N; i++) {
            int attr = a.getIndex(i);
            if (DEBUG) { // USEFUL when adding features to track tags being parsed
                try {
                    Field[] campos = R.styleable.class.getFields();
                    boolean found = false;
                    for (Field f : campos) {
                        try {
                            if (f.getType().isPrimitive() && attr == f.getInt(null) && f.getName()
                                .contains("ConstraintSet")) {
                                found = true;
                                Log.v(TAG, "L id " + f.getName() + " #" + attr);
                                break;
                            }
                        } catch (Exception e) {

                        }
                    }
                    if (!found) {
                        campos = android.R.attr.class.getFields();
                        for (Field f : campos) {
                            try {
                                if (f.getType().isPrimitive() && attr == f.getInt(null) && f.getName()
                                    .contains("ConstraintSet")) {
                                    found = false;
                                    Log.v(TAG, "x id " + f.getName());
                                    break;
                                }
                            } catch (Exception e) {

                            }
                        }
                    }
                    if (!found) {
                        Log.v(TAG, " ? " + attr);
                    }
                } catch (Exception e) {
                    Log.v(TAG, " " + e.toString());
                }
            }
            switch (mapToConstant.get(attr)) {
                case LEFT_TO_LEFT:
                    c.leftToLeft = lookupID(a, attr, c.leftToLeft);
                    break;
                case LEFT_TO_RIGHT:
                    c.leftToRight = lookupID(a, attr, c.leftToRight);
                    break;
                case RIGHT_TO_LEFT:
                    c.rightToLeft = lookupID(a, attr, c.rightToLeft);
                    break;
                case RIGHT_TO_RIGHT:
                    c.rightToRight = lookupID(a, attr, c.rightToRight);
                    break;
                case TOP_TO_TOP:
                    c.topToTop = lookupID(a, attr, c.topToTop);
                    break;
                case TOP_TO_BOTTOM:
                    c.topToBottom = lookupID(a, attr, c.topToBottom);
                    break;
                case BOTTOM_TO_TOP:
                    c.bottomToTop = lookupID(a, attr, c.bottomToTop);
                    break;
                case BOTTOM_TO_BOTTOM:
                    c.bottomToBottom = lookupID(a, attr, c.bottomToBottom);
                    break;
                case BASELINE_TO_BASELINE:
                    c.baselineToBaseline = lookupID(a, attr, c.baselineToBaseline);
                    break;
                case EDITOR_ABSOLUTE_X:
                    c.editorAbsoluteX = a.getDimensionPixelOffset(attr, c.editorAbsoluteX);
                    break;
                case EDITOR_ABSOLUTE_Y:
                    c.editorAbsoluteY = a.getDimensionPixelOffset(attr, c.editorAbsoluteY);
                    break;
                case GUIDE_BEGIN:
                    c.guideBegin = a.getDimensionPixelOffset(attr, c.guideBegin);
                    break;
                case GUIDE_END:
                    c.guideEnd = a.getDimensionPixelOffset(attr, c.guideEnd);
                    break;
                case GUIDE_PERCENT:
                    c.guidePercent = a.getFloat(attr, c.guidePercent);
                    break;
                case ORIENTATION:
                    c.orientation = a.getInt(attr, c.orientation);
                    break;
                case START_TO_END:
                    c.startToEnd = lookupID(a, attr, c.startToEnd);
                    break;
                case START_TO_START:
                    c.startToStart = lookupID(a, attr, c.startToStart);
                    break;
                case END_TO_START:
                    c.endToStart = lookupID(a, attr, c.endToStart);
                    break;
                case END_TO_END:
                    c.endToEnd = lookupID(a, attr, c.endToEnd);
                    break;
                case CIRCLE:
                    c.circleConstraint = lookupID(a, attr, c.circleConstraint);
                    break;
                case CIRCLE_RADIUS:
                    c.circleRadius = a.getDimensionPixelSize(attr, c.circleRadius);
                    break;
                case CIRCLE_ANGLE:
                    c.circleAngle = a.getFloat(attr, c.circleAngle);
                    break;
                case GONE_LEFT_MARGIN:
                    c.goneLeftMargin = a.getDimensionPixelSize(attr, c.goneLeftMargin);
                    break;
                case GONE_TOP_MARGIN:
                    c.goneTopMargin = a.getDimensionPixelSize(attr, c.goneTopMargin);
                    break;
                case GONE_RIGHT_MARGIN:
                    c.goneRightMargin = a.getDimensionPixelSize(attr, c.goneRightMargin);
                    break;
                case GONE_BOTTOM_MARGIN:
                    c.goneBottomMargin = a.getDimensionPixelSize(attr, c.goneBottomMargin);
                    break;
                case GONE_START_MARGIN:
                    c.goneStartMargin = a.getDimensionPixelSize(attr, c.goneStartMargin);
                    break;
                case GONE_END_MARGIN:
                    c.goneEndMargin = a.getDimensionPixelSize(attr, c.goneEndMargin);
                    break;
                case HORIZONTAL_BIAS:
                    c.horizontalBias = a.getFloat(attr, c.horizontalBias);
                    break;
                case VERTICAL_BIAS:
                    c.verticalBias = a.getFloat(attr, c.verticalBias);
                    break;
                case LEFT_MARGIN:
                    c.leftMargin = a.getDimensionPixelSize(attr, c.leftMargin);
                    break;
                case RIGHT_MARGIN:
                    c.rightMargin = a.getDimensionPixelSize(attr, c.rightMargin);
                    break;
                case START_MARGIN:
                    c.startMargin = a.getDimensionPixelSize(attr, c.startMargin);
                    break;
                case END_MARGIN:
                    c.endMargin = a.getDimensionPixelSize(attr, c.endMargin);
                    break;
                case TOP_MARGIN:
                    c.topMargin = a.getDimensionPixelSize(attr, c.topMargin);
                    break;
                case BOTTOM_MARGIN:
                    c.bottomMargin = a.getDimensionPixelSize(attr, c.bottomMargin);
                    break;
                case LAYOUT_WIDTH:
                    c.mWidth = a.getLayoutDimension(attr, c.mWidth);
                    break;
                case LAYOUT_HEIGHT:
                    c.mHeight = a.getLayoutDimension(attr, c.mHeight);
                    break;
                case LAYOUT_VISIBILITY:
                    c.visibility = a.getInt(attr, c.visibility);
                    c.visibility = VISIBILITY_FLAGS[c.visibility];
                    break;
                case ALPHA:
                    c.alpha = a.getFloat(attr, c.alpha);
                    break;
                case ELEVATION:
                    c.applyElevation = true;
                    c.elevation = a.getDimension(attr, c.elevation);
                    break;
                case ROTATION:
                    c.rotation = a.getFloat(attr, c.rotation);
                    break;
                case ROTATION_X:
                    c.rotationX = a.getFloat(attr, c.rotationX);
                    break;
                case ROTATION_Y:
                    c.rotationY = a.getFloat(attr, c.rotationY);
                    break;
                case SCALE_X:
                    c.scaleX = a.getFloat(attr, c.scaleX);
                    break;
                case SCALE_Y:
                    c.scaleY = a.getFloat(attr, c.scaleY);
                    break;
                case TRANSFORM_PIVOT_X:
                    c.transformPivotX = a.getFloat(attr, c.transformPivotX);
                    break;
                case TRANSFORM_PIVOT_Y:
                    c.transformPivotY = a.getFloat(attr, c.transformPivotY);
                    break;
                case TRANSLATION_X:
                    c.translationX = a.getDimension(attr, c.translationX);
                    break;
                case TRANSLATION_Y:
                    c.translationY = a.getDimension(attr, c.translationY);
                    break;
                case TRANSLATION_Z:
                    c.translationZ = a.getDimension(attr, c.translationZ);
                    break;
                case VERTICAL_WEIGHT:
                    c.verticalWeight = a.getFloat(attr, c.verticalWeight);
                    break;
                case HORIZONTAL_WEIGHT:
                    c.horizontalWeight = a.getFloat(attr, c.horizontalWeight);
                    break;
                case VERTICAL_STYLE:
                    c.verticalChainStyle = a.getInt(attr, c.verticalChainStyle);
                    break;
                case HORIZONTAL_STYLE:
                    c.horizontalChainStyle = a.getInt(attr, c.horizontalChainStyle);
                    break;
                case VIEW_ID:
                    c.mViewId = a.getResourceId(attr, c.mViewId);
                    break;
                case DIMENSION_RATIO:
                    c.dimensionRatio = a.getString(attr);
                    break;
                case WIDTH_PERCENT:
                    c.widthPercent = a.getFloat(attr, 1);
                    break;
                case HEIGHT_PERCENT:
                    c.heightPercent = a.getFloat(attr, 1);
                    break;
                case CHAIN_USE_RTL:
                    Log.e(TAG, "CURRENTLY UNSUPPORTED"); // TODO add support or remove
                 //  TODO add support or remove  c.mChainUseRtl = a.getBoolean(attr,c.mChainUseRtl);
                    break;
                case BARRIER_DIRECTION:
                    c.mBarrierDirection = a.getInt(attr,c.mBarrierDirection);
                    break;
                case CONSTRAINT_REFERENCED_IDS:
                    c.mReferenceIdString = a.getString(attr);
                     break;
                case BARRIER_ALLOWS_GONE_WIDGETS:
                    c.mBarrierAllowsGoneWidgets = a.getBoolean(attr,c.mBarrierAllowsGoneWidgets);
                    break;
                case UNUSED:
                    Log.w(TAG,
                        "unused attribute 0x" + Integer.toHexString(attr) + "   " + mapToConstant.get(attr));
                    break;
                default:
                    Log.w(TAG,
                        "Unknown attribute 0x" + Integer.toHexString(attr) + "   " + mapToConstant.get(attr));
            }
        }
    }

    private int[] convertReferenceString(View view, String referenceIdString) {
        String[] split = referenceIdString.split(",");
        Context context = view.getContext();
        int[]tags = new int[split.length];
        int count = 0;
        for (int i = 0; i < split.length; i++) {
            String idString = split[i];
            idString = idString.trim();
            int tag = 0;
            try {
                Class res = R.id.class;
                Field field = res.getField(idString);
                tag = field.getInt(null);
            }
            catch (Exception e) {
                // Do nothing
            }
            if (tag == 0) {
                tag = context.getResources().getIdentifier(idString, "id",
                        context.getPackageName());
            }

            if (tag == 0 && view.isInEditMode() && view.getParent() instanceof ConstraintLayout) {
                ConstraintLayout constraintLayout = (ConstraintLayout) view.getParent();
                Object value = constraintLayout.getDesignInformation(0, idString);
                if (value != null && value instanceof Integer) {
                    tag = (Integer) value;
                }
            }
            tags[count++] = tag;
        }
        if (count!=split.length) {
            tags = Arrays.copyOf(tags,count);
        }
        return tags;
    }

}