package androidx.constraintlayout.solver.widgets.analyzer;

import androidx.constraintlayout.solver.widgets.ConstraintAnchor;
import androidx.constraintlayout.solver.widgets.ConstraintWidget;
import androidx.constraintlayout.solver.widgets.ConstraintWidgetContainer;
import b.d.b.a.a;
import java.util.ArrayList;
import java.util.Iterator;
/* loaded from: classes.dex */
public class ChainRun extends WidgetRun {
    private int chainStyle;
    public ArrayList<WidgetRun> widgets = new ArrayList<>();

    public ChainRun(ConstraintWidget constraintWidget, int i) {
        super(constraintWidget);
        this.orientation = i;
        build();
    }

    private void build() {
        ConstraintWidget constraintWidget = this.widget;
        constraintWidget = constraintWidget.getPreviousChainMember(this.orientation);
        while (constraintWidget != null) {
            constraintWidget = constraintWidget.getPreviousChainMember(this.orientation);
        }
        this.widget = constraintWidget;
        this.widgets.add(constraintWidget.getRun(this.orientation));
        ConstraintWidget nextChainMember = constraintWidget.getNextChainMember(this.orientation);
        while (nextChainMember != null) {
            this.widgets.add(nextChainMember.getRun(this.orientation));
            nextChainMember = nextChainMember.getNextChainMember(this.orientation);
        }
        Iterator<WidgetRun> it = this.widgets.iterator();
        while (it.hasNext()) {
            WidgetRun next = it.next();
            int i = this.orientation;
            if (i == 0) {
                next.widget.horizontalChainRun = this;
            } else if (i == 1) {
                next.widget.verticalChainRun = this;
            }
        }
        if ((this.orientation == 0 && ((ConstraintWidgetContainer) this.widget.getParent()).isRtl()) && this.widgets.size() > 1) {
            ArrayList<WidgetRun> arrayList = this.widgets;
            this.widget = arrayList.get(arrayList.size() - 1).widget;
        }
        this.chainStyle = this.orientation == 0 ? this.widget.getHorizontalChainStyle() : this.widget.getVerticalChainStyle();
    }

    private ConstraintWidget getFirstVisibleWidget() {
        for (int i = 0; i < this.widgets.size(); i++) {
            WidgetRun widgetRun = this.widgets.get(i);
            if (widgetRun.widget.getVisibility() != 8) {
                return widgetRun.widget;
            }
        }
        return null;
    }

    private ConstraintWidget getLastVisibleWidget() {
        for (int size = this.widgets.size() - 1; size >= 0; size--) {
            WidgetRun widgetRun = this.widgets.get(size);
            if (widgetRun.widget.getVisibility() != 8) {
                return widgetRun.widget;
            }
        }
        return null;
    }

    @Override // androidx.constraintlayout.solver.widgets.analyzer.WidgetRun
    public void apply() {
        Iterator<WidgetRun> it = this.widgets.iterator();
        while (it.hasNext()) {
            it.next().apply();
        }
        int size = this.widgets.size();
        if (size >= 1) {
            ConstraintWidget constraintWidget = this.widgets.get(0).widget;
            ConstraintWidget constraintWidget2 = this.widgets.get(size - 1).widget;
            if (this.orientation == 0) {
                ConstraintAnchor constraintAnchor = constraintWidget.mLeft;
                ConstraintAnchor constraintAnchor2 = constraintWidget2.mRight;
                DependencyNode target = getTarget(constraintAnchor, 0);
                int margin = constraintAnchor.getMargin();
                ConstraintWidget firstVisibleWidget = getFirstVisibleWidget();
                if (firstVisibleWidget != null) {
                    margin = firstVisibleWidget.mLeft.getMargin();
                }
                if (target != null) {
                    addTarget(this.start, target, margin);
                }
                DependencyNode target2 = getTarget(constraintAnchor2, 0);
                int margin2 = constraintAnchor2.getMargin();
                ConstraintWidget lastVisibleWidget = getLastVisibleWidget();
                if (lastVisibleWidget != null) {
                    margin2 = lastVisibleWidget.mRight.getMargin();
                }
                if (target2 != null) {
                    addTarget(this.end, target2, -margin2);
                }
            } else {
                ConstraintAnchor constraintAnchor3 = constraintWidget.mTop;
                ConstraintAnchor constraintAnchor4 = constraintWidget2.mBottom;
                DependencyNode target3 = getTarget(constraintAnchor3, 1);
                int margin3 = constraintAnchor3.getMargin();
                ConstraintWidget firstVisibleWidget2 = getFirstVisibleWidget();
                if (firstVisibleWidget2 != null) {
                    margin3 = firstVisibleWidget2.mTop.getMargin();
                }
                if (target3 != null) {
                    addTarget(this.start, target3, margin3);
                }
                DependencyNode target4 = getTarget(constraintAnchor4, 1);
                int margin4 = constraintAnchor4.getMargin();
                ConstraintWidget lastVisibleWidget2 = getLastVisibleWidget();
                if (lastVisibleWidget2 != null) {
                    margin4 = lastVisibleWidget2.mBottom.getMargin();
                }
                if (target4 != null) {
                    addTarget(this.end, target4, -margin4);
                }
            }
            this.start.updateDelegate = this;
            this.end.updateDelegate = this;
        }
    }

    @Override // androidx.constraintlayout.solver.widgets.analyzer.WidgetRun
    public void applyToWidget() {
        for (int i = 0; i < this.widgets.size(); i++) {
            this.widgets.get(i).applyToWidget();
        }
    }

    @Override // androidx.constraintlayout.solver.widgets.analyzer.WidgetRun
    public void clear() {
        this.runGroup = null;
        Iterator<WidgetRun> it = this.widgets.iterator();
        while (it.hasNext()) {
            it.next().clear();
        }
    }

    @Override // androidx.constraintlayout.solver.widgets.analyzer.WidgetRun
    public long getWrapDimension() {
        int size = this.widgets.size();
        long j = 0;
        for (int i = 0; i < size; i++) {
            WidgetRun widgetRun = this.widgets.get(i);
            j = widgetRun.end.margin + widgetRun.getWrapDimension() + j + widgetRun.start.margin;
        }
        return j;
    }

    @Override // androidx.constraintlayout.solver.widgets.analyzer.WidgetRun
    public void reset() {
        this.start.resolved = false;
        this.end.resolved = false;
    }

    @Override // androidx.constraintlayout.solver.widgets.analyzer.WidgetRun
    public boolean supportsWrapComputation() {
        int size = this.widgets.size();
        for (int i = 0; i < size; i++) {
            if (!this.widgets.get(i).supportsWrapComputation()) {
                return false;
            }
        }
        return true;
    }

    public String toString() {
        StringBuilder R = a.R("ChainRun ");
        R.append(this.orientation == 0 ? "horizontal : " : "vertical : ");
        String sb = R.toString();
        Iterator<WidgetRun> it = this.widgets.iterator();
        while (it.hasNext()) {
            String v = a.v(sb, "<");
            sb = a.v(v + it.next(), "> ");
        }
        return sb;
    }

    /* JADX WARN: Code restructure failed: missing block: B:106:0x01a6, code lost:
        if (r1 != r7) goto L_0x01ce;
     */
    /* JADX WARN: Code restructure failed: missing block: B:114:0x01cc, code lost:
        if (r1 != r7) goto L_0x01ce;
     */
    /* JADX WARN: Code restructure failed: missing block: B:115:0x01ce, code lost:
        r13 = r13 + 1;
     */
    /* JADX WARN: Code restructure failed: missing block: B:116:0x01d1, code lost:
        r9.dimension.resolve(r7);
     */
    /* JADX WARN: Code restructure failed: missing block: B:274:0x041a, code lost:
        r7 = r7 - r10;
     */
    /* JADX WARN: Removed duplicated region for block: B:62:0x00d9  */
    /* JADX WARN: Removed duplicated region for block: B:65:0x00eb  */
    @Override // androidx.constraintlayout.solver.widgets.analyzer.WidgetRun, androidx.constraintlayout.solver.widgets.analyzer.Dependency
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public void update(Dependency dependency) {
        int i;
        int i2;
        int i3;
        int i4;
        int i5;
        float f;
        int i6;
        boolean z2;
        int i7;
        int i8;
        int i9;
        int i10;
        if (this.start.resolved && this.end.resolved) {
            ConstraintWidget parent = this.widget.getParent();
            boolean isRtl = (parent == null || !(parent instanceof ConstraintWidgetContainer)) ? false : ((ConstraintWidgetContainer) parent).isRtl();
            int i11 = this.end.value - this.start.value;
            int size = this.widgets.size();
            int i12 = 0;
            while (true) {
                i = -1;
                i2 = 8;
                if (i12 >= size) {
                    i12 = -1;
                    break;
                }
                if (this.widgets.get(i12).widget.getVisibility() != 8) {
                    break;
                }
                i12++;
            }
            int i13 = size - 1;
            int i14 = i13;
            while (true) {
                if (i14 < 0) {
                    break;
                }
                if (this.widgets.get(i14).widget.getVisibility() != 8) {
                    i = i14;
                    break;
                }
                i14--;
            }
            int i15 = 0;
            while (i15 < 2) {
                int i16 = 0;
                i4 = 0;
                i5 = 0;
                int i17 = 0;
                f = 0.0f;
                while (i16 < size) {
                    WidgetRun widgetRun = this.widgets.get(i16);
                    if (widgetRun.widget.getVisibility() != i2) {
                        i17++;
                        if (i16 > 0 && i16 >= i12) {
                            i4 += widgetRun.start.margin;
                        }
                        DimensionDependency dimensionDependency = widgetRun.dimension;
                        int i18 = dimensionDependency.value;
                        boolean z3 = widgetRun.dimensionBehavior != ConstraintWidget.DimensionBehaviour.MATCH_CONSTRAINT;
                        if (z3) {
                            int i19 = this.orientation;
                            if (i19 == 0 && !widgetRun.widget.horizontalRun.dimension.resolved) {
                                return;
                            }
                            if (i19 != 1 || widgetRun.widget.verticalRun.dimension.resolved) {
                                i10 = i18;
                            } else {
                                return;
                            }
                        } else {
                            i10 = i18;
                            if (widgetRun.matchConstraintsType == 1 && i15 == 0) {
                                i10 = dimensionDependency.wrapValue;
                                i5++;
                            } else if (dimensionDependency.resolved) {
                                i10 = i10;
                            }
                            z3 = true;
                            if (z3) {
                                i5++;
                                float f2 = widgetRun.widget.mWeight[this.orientation];
                                if (f2 >= 0.0f) {
                                    f += f2;
                                }
                            } else {
                                i4 += i10;
                            }
                            if (i16 < i13 && i16 < i) {
                                i4 += -widgetRun.end.margin;
                            }
                        }
                        if (z3) {
                        }
                        if (i16 < i13) {
                            i4 += -widgetRun.end.margin;
                        }
                    }
                    i16++;
                    i2 = 8;
                }
                if (i4 < i11 || i5 == 0) {
                    i3 = i17;
                    break;
                } else {
                    i15++;
                    i2 = 8;
                }
            }
            i3 = 0;
            i4 = 0;
            i5 = 0;
            f = 0.0f;
            int i20 = this.start.value;
            if (isRtl) {
                i20 = this.end.value;
            }
            if (i4 > i11) {
                i20 = isRtl ? i20 + ((int) (((i4 - i11) / 2.0f) + 0.5f)) : i20 - ((int) (((i4 - i11) / 2.0f) + 0.5f));
            }
            if (i5 > 0) {
                float f3 = i11 - i4;
                int i21 = (int) ((f3 / i5) + 0.5f);
                int i22 = 0;
                int i23 = 0;
                while (i22 < size) {
                    WidgetRun widgetRun2 = this.widgets.get(i22);
                    if (widgetRun2.widget.getVisibility() != 8 && widgetRun2.dimensionBehavior == ConstraintWidget.DimensionBehaviour.MATCH_CONSTRAINT) {
                        DimensionDependency dimensionDependency2 = widgetRun2.dimension;
                        if (!dimensionDependency2.resolved) {
                            if (f > 0.0f) {
                                i20 = i20;
                                i9 = (int) (((widgetRun2.widget.mWeight[this.orientation] * f3) / f) + 0.5f);
                            } else {
                                i20 = i20;
                                i9 = i21;
                            }
                            if (this.orientation == 0) {
                                ConstraintWidget constraintWidget = widgetRun2.widget;
                                f3 = f3;
                                int i24 = constraintWidget.mMatchConstraintMaxWidth;
                                isRtl = isRtl;
                                i3 = i3;
                                i9 = Math.max(constraintWidget.mMatchConstraintMinWidth, widgetRun2.matchConstraintsType == 1 ? Math.min(i9, dimensionDependency2.wrapValue) : i9);
                                if (i24 > 0) {
                                    i9 = Math.min(i24, i9);
                                }
                            } else {
                                isRtl = isRtl;
                                i3 = i3;
                                f3 = f3;
                                ConstraintWidget constraintWidget2 = widgetRun2.widget;
                                int i25 = constraintWidget2.mMatchConstraintMaxHeight;
                                i9 = Math.max(constraintWidget2.mMatchConstraintMinHeight, widgetRun2.matchConstraintsType == 1 ? Math.min(i9, dimensionDependency2.wrapValue) : i9);
                                if (i25 > 0) {
                                    i9 = Math.min(i25, i9);
                                }
                            }
                            i22++;
                            i21 = i21;
                            i4 = i4;
                        }
                    }
                    isRtl = isRtl;
                    i3 = i3;
                    i20 = i20;
                    f3 = f3;
                    i22++;
                    i21 = i21;
                    i4 = i4;
                }
                z2 = isRtl;
                i6 = i3;
                i7 = i20;
                if (i23 > 0) {
                    i5 -= i23;
                    int i26 = 0;
                    for (int i27 = 0; i27 < size; i27++) {
                        WidgetRun widgetRun3 = this.widgets.get(i27);
                        if (widgetRun3.widget.getVisibility() != 8) {
                            if (i27 > 0 && i27 >= i12) {
                                i26 += widgetRun3.start.margin;
                            }
                            i26 += widgetRun3.dimension.value;
                            if (i27 < i13 && i27 < i) {
                                i26 += -widgetRun3.end.margin;
                            }
                        }
                    }
                    i4 = i26;
                } else {
                    i4 = i4;
                }
                i8 = 2;
                if (this.chainStyle == 2 && i23 == 0) {
                    this.chainStyle = 0;
                }
            } else {
                z2 = isRtl;
                i6 = i3;
                i7 = i20;
                i8 = 2;
            }
            if (i4 > i11) {
                this.chainStyle = i8;
            }
            if (i6 > 0 && i5 == 0 && i12 == i) {
                this.chainStyle = i8;
            }
            int i28 = this.chainStyle;
            if (i28 == 1) {
                int i29 = i6 > 1 ? (i11 - i4) / (i6 - 1) : i6 == 1 ? (i11 - i4) / 2 : 0;
                if (i5 > 0) {
                    i29 = 0;
                }
                int i30 = i7;
                for (int i31 = 0; i31 < size; i31++) {
                    WidgetRun widgetRun4 = this.widgets.get(z2 ? size - (i31 + 1) : i31);
                    if (widgetRun4.widget.getVisibility() == 8) {
                        widgetRun4.start.resolve(i30);
                        widgetRun4.end.resolve(i30);
                    } else {
                        if (i31 > 0) {
                            i30 = z2 ? i30 - i29 : i30 + i29;
                        }
                        if (i31 > 0 && i31 >= i12) {
                            i30 = z2 ? i30 - widgetRun4.start.margin : i30 + widgetRun4.start.margin;
                        }
                        if (z2) {
                            widgetRun4.end.resolve(i30);
                        } else {
                            widgetRun4.start.resolve(i30);
                        }
                        DimensionDependency dimensionDependency3 = widgetRun4.dimension;
                        int i32 = dimensionDependency3.value;
                        if (widgetRun4.dimensionBehavior == ConstraintWidget.DimensionBehaviour.MATCH_CONSTRAINT && widgetRun4.matchConstraintsType == 1) {
                            i32 = dimensionDependency3.wrapValue;
                        }
                        i30 = z2 ? i30 - i32 : i30 + i32;
                        if (z2) {
                            widgetRun4.start.resolve(i30);
                        } else {
                            widgetRun4.end.resolve(i30);
                        }
                        widgetRun4.resolved = true;
                        if (i31 < i13 && i31 < i) {
                            i30 = z2 ? i30 - (-widgetRun4.end.margin) : i30 + (-widgetRun4.end.margin);
                        }
                    }
                }
            } else if (i28 == 0) {
                int i33 = (i11 - i4) / (i6 + 1);
                if (i5 > 0) {
                    i33 = 0;
                }
                int i34 = i7;
                for (int i35 = 0; i35 < size; i35++) {
                    WidgetRun widgetRun5 = this.widgets.get(z2 ? size - (i35 + 1) : i35);
                    if (widgetRun5.widget.getVisibility() == 8) {
                        widgetRun5.start.resolve(i34);
                        widgetRun5.end.resolve(i34);
                    } else {
                        int i36 = z2 ? i34 - i33 : i34 + i33;
                        if (i35 > 0 && i35 >= i12) {
                            i36 = z2 ? i36 - widgetRun5.start.margin : i36 + widgetRun5.start.margin;
                        }
                        if (z2) {
                            widgetRun5.end.resolve(i36);
                        } else {
                            widgetRun5.start.resolve(i36);
                        }
                        DimensionDependency dimensionDependency4 = widgetRun5.dimension;
                        int i37 = dimensionDependency4.value;
                        if (widgetRun5.dimensionBehavior == ConstraintWidget.DimensionBehaviour.MATCH_CONSTRAINT && widgetRun5.matchConstraintsType == 1) {
                            i37 = Math.min(i37, dimensionDependency4.wrapValue);
                        }
                        i34 = z2 ? i36 - i37 : i36 + i37;
                        if (z2) {
                            widgetRun5.start.resolve(i34);
                        } else {
                            widgetRun5.end.resolve(i34);
                        }
                        if (i35 < i13 && i35 < i) {
                            i34 = z2 ? i34 - (-widgetRun5.end.margin) : i34 + (-widgetRun5.end.margin);
                        }
                    }
                }
            } else if (i28 == 2) {
                float horizontalBiasPercent = this.orientation == 0 ? this.widget.getHorizontalBiasPercent() : this.widget.getVerticalBiasPercent();
                if (z2) {
                    horizontalBiasPercent = 1.0f - horizontalBiasPercent;
                }
                int i38 = (int) (((i11 - i4) * horizontalBiasPercent) + 0.5f);
                if (i38 < 0 || i5 > 0) {
                    i38 = 0;
                }
                int i39 = z2 ? i7 - i38 : i7 + i38;
                for (int i40 = 0; i40 < size; i40++) {
                    WidgetRun widgetRun6 = this.widgets.get(z2 ? size - (i40 + 1) : i40);
                    if (widgetRun6.widget.getVisibility() == 8) {
                        widgetRun6.start.resolve(i39);
                        widgetRun6.end.resolve(i39);
                    } else {
                        if (i40 > 0 && i40 >= i12) {
                            i39 = z2 ? i39 - widgetRun6.start.margin : i39 + widgetRun6.start.margin;
                        }
                        if (z2) {
                            widgetRun6.end.resolve(i39);
                        } else {
                            widgetRun6.start.resolve(i39);
                        }
                        DimensionDependency dimensionDependency5 = widgetRun6.dimension;
                        int i41 = dimensionDependency5.value;
                        if (widgetRun6.dimensionBehavior == ConstraintWidget.DimensionBehaviour.MATCH_CONSTRAINT && widgetRun6.matchConstraintsType == 1) {
                            i41 = dimensionDependency5.wrapValue;
                        }
                        i39 += i41;
                        if (z2) {
                            widgetRun6.start.resolve(i39);
                        } else {
                            widgetRun6.end.resolve(i39);
                        }
                        if (i40 < i13 && i40 < i) {
                            i39 = z2 ? i39 - (-widgetRun6.end.margin) : i39 + (-widgetRun6.end.margin);
                        }
                    }
                }
            }
        }
    }
}