package androidx.constraintlayout.solver.widgets;

import androidx.constraintlayout.solver.widgets.ConstraintWidget;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/* loaded from: classes.dex */
public class Analyzer {
    public static void a(ConstraintWidgetContainer constraintWidgetContainer) {
        if ((constraintWidgetContainer.M() & 32) != 32) {
            b(constraintWidgetContainer);
            return;
        }
        constraintWidgetContainer.D0 = true;
        constraintWidgetContainer.x0 = false;
        constraintWidgetContainer.y0 = false;
        constraintWidgetContainer.z0 = false;
        ArrayList<ConstraintWidget> arrayList = constraintWidgetContainer.k0;
        List<ConstraintWidgetGroup> list = constraintWidgetContainer.w0;
        boolean z = constraintWidgetContainer.j() == ConstraintWidget.DimensionBehaviour.WRAP_CONTENT;
        boolean z2 = constraintWidgetContainer.q() == ConstraintWidget.DimensionBehaviour.WRAP_CONTENT;
        boolean z3 = z || z2;
        list.clear();
        for (ConstraintWidget constraintWidget : arrayList) {
            constraintWidget.p = null;
            constraintWidget.d0 = false;
            constraintWidget.F();
        }
        for (ConstraintWidget constraintWidget2 : arrayList) {
            if (constraintWidget2.p == null && !a(constraintWidget2, list, z3)) {
                b(constraintWidgetContainer);
                constraintWidgetContainer.D0 = false;
                return;
            }
        }
        int i = 0;
        int i2 = 0;
        for (ConstraintWidgetGroup constraintWidgetGroup : list) {
            i = Math.max(i, a(constraintWidgetGroup, 0));
            i2 = Math.max(i2, a(constraintWidgetGroup, 1));
        }
        if (z) {
            constraintWidgetContainer.a(ConstraintWidget.DimensionBehaviour.FIXED);
            constraintWidgetContainer.o(i);
            constraintWidgetContainer.x0 = true;
            constraintWidgetContainer.y0 = true;
            constraintWidgetContainer.A0 = i;
        }
        if (z2) {
            constraintWidgetContainer.b(ConstraintWidget.DimensionBehaviour.FIXED);
            constraintWidgetContainer.g(i2);
            constraintWidgetContainer.x0 = true;
            constraintWidgetContainer.z0 = true;
            constraintWidgetContainer.B0 = i2;
        }
        a(list, 0, constraintWidgetContainer.s());
        a(list, 1, constraintWidgetContainer.i());
    }

    private static void b(ConstraintWidgetContainer constraintWidgetContainer) {
        constraintWidgetContainer.w0.clear();
        constraintWidgetContainer.w0.add(0, new ConstraintWidgetGroup(constraintWidgetContainer.k0));
    }

    private static boolean a(ConstraintWidget constraintWidget, List<ConstraintWidgetGroup> list, boolean z) {
        ConstraintWidgetGroup constraintWidgetGroup = new ConstraintWidgetGroup(new ArrayList(), true);
        list.add(constraintWidgetGroup);
        return a(constraintWidget, constraintWidgetGroup, list, z);
    }

    /* JADX WARN: Code restructure failed: missing block: B:139:0x0181, code lost:
    
        if (r3.b == r4) goto L123;
     */
    /* JADX WARN: Code restructure failed: missing block: B:159:0x0128, code lost:
    
        if (r3.b == r4) goto L92;
     */
    /* JADX WARN: Removed duplicated region for block: B:134:0x0173  */
    /* JADX WARN: Removed duplicated region for block: B:85:0x01a0  */
    /* JADX WARN: Removed duplicated region for block: B:99:0x01c2  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct code enable 'Show inconsistent code' option in preferences
    */
    private static boolean a(androidx.constraintlayout.solver.widgets.ConstraintWidget r8, androidx.constraintlayout.solver.widgets.ConstraintWidgetGroup r9, java.util.List<androidx.constraintlayout.solver.widgets.ConstraintWidgetGroup> r10, boolean r11) {
        /*
            Method dump skipped, instructions count: 560
            To view this dump change 'Code comments level' option to 'DEBUG'
        */
        throw new UnsupportedOperationException("Method not decompiled: androidx.constraintlayout.solver.widgets.Analyzer.a(androidx.constraintlayout.solver.widgets.ConstraintWidget, androidx.constraintlayout.solver.widgets.ConstraintWidgetGroup, java.util.List, boolean):boolean");
    }

    private static void a(ConstraintWidgetContainer constraintWidgetContainer, ConstraintWidget constraintWidget, ConstraintWidgetGroup constraintWidgetGroup) {
        constraintWidgetGroup.d = false;
        constraintWidgetContainer.D0 = false;
        constraintWidget.b0 = false;
    }

    private static int a(ConstraintWidgetGroup constraintWidgetGroup, int i) {
        int i2 = i * 2;
        List<ConstraintWidget> a = constraintWidgetGroup.a(i);
        int size = a.size();
        int i3 = 0;
        for (int i4 = 0; i4 < size; i4++) {
            ConstraintWidget constraintWidget = a.get(i4);
            ConstraintAnchor[] constraintAnchorArr = constraintWidget.A;
            int i5 = i2 + 1;
            i3 = Math.max(i3, a(constraintWidget, i, constraintAnchorArr[i5].d == null || !(constraintAnchorArr[i2].d == null || constraintAnchorArr[i5].d == null), 0));
        }
        constraintWidgetGroup.e[i] = i3;
        return i3;
    }

    private static int a(ConstraintWidget constraintWidget, int i, boolean z, int i2) {
        int i3;
        int c;
        int i4;
        int i5;
        int i6;
        int i7;
        int s;
        int i8;
        int i9;
        int i10;
        int i11 = 0;
        if (!constraintWidget.b0) {
            return 0;
        }
        boolean z2 = constraintWidget.w.d != null && i == 1;
        if (z) {
            i3 = constraintWidget.c();
            c = constraintWidget.i() - constraintWidget.c();
            i5 = i * 2;
            i4 = i5 + 1;
        } else {
            i3 = constraintWidget.i() - constraintWidget.c();
            c = constraintWidget.c();
            i4 = i * 2;
            i5 = i4 + 1;
        }
        ConstraintAnchor[] constraintAnchorArr = constraintWidget.A;
        if (constraintAnchorArr[i4].d == null || constraintAnchorArr[i5].d != null) {
            i6 = i4;
            i7 = 1;
        } else {
            i6 = i5;
            i5 = i4;
            i7 = -1;
        }
        int i12 = z2 ? i2 - i3 : i2;
        int b = (constraintWidget.A[i5].b() * i7) + a(constraintWidget, i);
        int i13 = i12 + b;
        int s2 = (i == 0 ? constraintWidget.s() : constraintWidget.i()) * i7;
        Iterator<ResolutionNode> it = constraintWidget.A[i5].d().a.iterator();
        while (it.hasNext()) {
            i11 = Math.max(i11, a(((ResolutionAnchor) it.next()).c.b, i, z, i13));
        }
        int i14 = 0;
        for (Iterator<ResolutionNode> it2 = constraintWidget.A[i6].d().a.iterator(); it2.hasNext(); it2 = it2) {
            i14 = Math.max(i14, a(((ResolutionAnchor) it2.next()).c.b, i, z, s2 + i13));
        }
        if (z2) {
            i11 -= i3;
            s = i14 + c;
        } else {
            s = i14 + ((i == 0 ? constraintWidget.s() : constraintWidget.i()) * i7);
        }
        int i15 = 1;
        if (i == 1) {
            Iterator<ResolutionNode> it3 = constraintWidget.w.d().a.iterator();
            int i16 = 0;
            while (it3.hasNext()) {
                Iterator<ResolutionNode> it4 = it3;
                ResolutionAnchor resolutionAnchor = (ResolutionAnchor) it3.next();
                if (i7 == i15) {
                    i16 = Math.max(i16, a(resolutionAnchor.c.b, i, z, i3 + i13));
                    i10 = i6;
                } else {
                    i10 = i6;
                    i16 = Math.max(i16, a(resolutionAnchor.c.b, i, z, (c * i7) + i13));
                }
                it3 = it4;
                i6 = i10;
                i15 = 1;
            }
            i8 = i6;
            int i17 = i16;
            i9 = (constraintWidget.w.d().a.size() <= 0 || z2) ? i17 : i7 == 1 ? i17 + i3 : i17 - c;
        } else {
            i8 = i6;
            i9 = 0;
        }
        int max = b + Math.max(i11, Math.max(s, i9));
        int i18 = i13 + s2;
        if (i7 != -1) {
            i13 = i18;
            i18 = i13;
        }
        if (z) {
            Optimizer.a(constraintWidget, i, i18);
            constraintWidget.a(i18, i13, i);
        } else {
            constraintWidget.p.a(constraintWidget, i);
            constraintWidget.d(i18, i);
        }
        if (constraintWidget.c(i) == ConstraintWidget.DimensionBehaviour.MATCH_CONSTRAINT && constraintWidget.G != 0.0f) {
            constraintWidget.p.a(constraintWidget, i);
        }
        ConstraintAnchor[] constraintAnchorArr2 = constraintWidget.A;
        if (constraintAnchorArr2[i5].d != null && constraintAnchorArr2[i8].d != null) {
            ConstraintWidget k = constraintWidget.k();
            ConstraintAnchor[] constraintAnchorArr3 = constraintWidget.A;
            if (constraintAnchorArr3[i5].d.b == k && constraintAnchorArr3[i8].d.b == k) {
                constraintWidget.p.a(constraintWidget, i);
            }
        }
        return max;
    }

    private static void a(ConstraintAnchor constraintAnchor) {
        ResolutionAnchor d = constraintAnchor.d();
        ConstraintAnchor constraintAnchor2 = constraintAnchor.d;
        if (constraintAnchor2 == null || constraintAnchor2.d == constraintAnchor) {
            return;
        }
        constraintAnchor2.d().a(d);
    }

    public static void a(List<ConstraintWidgetGroup> list, int i, int i2) {
        int size = list.size();
        for (int i3 = 0; i3 < size; i3++) {
            for (ConstraintWidget constraintWidget : list.get(i3).b(i)) {
                if (constraintWidget.b0) {
                    a(constraintWidget, i, i2);
                }
            }
        }
    }

    private static void a(ConstraintWidget constraintWidget, int i, int i2) {
        int i3 = i * 2;
        ConstraintAnchor[] constraintAnchorArr = constraintWidget.A;
        ConstraintAnchor constraintAnchor = constraintAnchorArr[i3];
        ConstraintAnchor constraintAnchor2 = constraintAnchorArr[i3 + 1];
        if ((constraintAnchor.d == null || constraintAnchor2.d == null) ? false : true) {
            Optimizer.a(constraintWidget, i, a(constraintWidget, i) + constraintAnchor.b());
            return;
        }
        if (constraintWidget.G != 0.0f && constraintWidget.c(i) == ConstraintWidget.DimensionBehaviour.MATCH_CONSTRAINT) {
            int a = a(constraintWidget);
            int i4 = (int) constraintWidget.A[i3].d().g;
            constraintAnchor2.d().f = constraintAnchor.d();
            constraintAnchor2.d().g = a;
            constraintAnchor2.d().b = 1;
            constraintWidget.a(i4, i4 + a, i);
            return;
        }
        int e = i2 - constraintWidget.e(i);
        int d = e - constraintWidget.d(i);
        constraintWidget.a(d, e, i);
        Optimizer.a(constraintWidget, i, d);
    }

    private static int a(ConstraintWidget constraintWidget, int i) {
        ConstraintAnchor constraintAnchor;
        int i2 = i * 2;
        ConstraintAnchor[] constraintAnchorArr = constraintWidget.A;
        ConstraintAnchor constraintAnchor2 = constraintAnchorArr[i2];
        ConstraintAnchor constraintAnchor3 = constraintAnchorArr[i2 + 1];
        ConstraintAnchor constraintAnchor4 = constraintAnchor2.d;
        if (constraintAnchor4 == null) {
            return 0;
        }
        ConstraintWidget constraintWidget2 = constraintAnchor4.b;
        ConstraintWidget constraintWidget3 = constraintWidget.D;
        if (constraintWidget2 != constraintWidget3 || (constraintAnchor = constraintAnchor3.d) == null || constraintAnchor.b != constraintWidget3) {
            return 0;
        }
        return (int) ((((constraintWidget3.d(i) - constraintAnchor2.b()) - constraintAnchor3.b()) - constraintWidget.d(i)) * (i == 0 ? constraintWidget.V : constraintWidget.W));
    }

    private static int a(ConstraintWidget constraintWidget) {
        float s;
        float i;
        if (constraintWidget.j() == ConstraintWidget.DimensionBehaviour.MATCH_CONSTRAINT) {
            if (constraintWidget.H == 0) {
                i = constraintWidget.i() * constraintWidget.G;
            } else {
                i = constraintWidget.i() / constraintWidget.G;
            }
            int i2 = (int) i;
            constraintWidget.o(i2);
            return i2;
        }
        if (constraintWidget.q() != ConstraintWidget.DimensionBehaviour.MATCH_CONSTRAINT) {
            return -1;
        }
        if (constraintWidget.H == 1) {
            s = constraintWidget.s() * constraintWidget.G;
        } else {
            s = constraintWidget.s() / constraintWidget.G;
        }
        int i3 = (int) s;
        constraintWidget.g(i3);
        return i3;
    }
}