package kotlin.reflect.jvm.internal.impl.metadata.deserialization;

import defpackage.cr4;
import defpackage.ik2;
import defpackage.kp6;
import defpackage.pq6;
import defpackage.st;
import defpackage.uz1;
import defpackage.vw2;
import defpackage.vx8;
import defpackage.xt;
import defpackage.y41;
import java.util.ArrayList;
import java.util.List;

/* JADX INFO: loaded from: classes3.dex */
@vx8
public abstract class BinaryVersion {

    @kp6
    public static final Companion Companion = new Companion(null);
    private final int major;
    private final int minor;

    @kp6
    private final int[] numbers;
    private final int patch;

    @kp6
    private final List<Integer> rest;

    @vx8
    public static final class Companion {
        public /* synthetic */ Companion(uz1 uz1Var) {
            this();
        }

        private Companion() {
        }
    }

    public BinaryVersion(@kp6 int... iArr) {
        List<Integer> listBo;
        cr4.g(iArr, "numbers");
        this.numbers = iArr;
        Integer numZ = st.z(iArr, 0);
        this.major = numZ != null ? numZ.intValue() : -1;
        Integer numZ2 = st.z(iArr, 1);
        this.minor = numZ2 != null ? numZ2.intValue() : -1;
        Integer numZ3 = st.z(iArr, 2);
        this.patch = numZ3 != null ? numZ3.intValue() : -1;
        if (iArr.length <= 3) {
            listBo = ik2.a;
        } else {
            if (iArr.length > 1024) {
                throw new IllegalArgumentException(vw2.n(new StringBuilder("BinaryVersion with length more than 1024 are not supported. Provided length "), iArr.length, '.'));
            }
            listBo = y41.bo(new xt(iArr).subList(3, iArr.length));
        }
        this.rest = listBo;
    }

    public boolean equals(@pq6 Object obj) {
        if (obj == null || !getClass().equals(obj.getClass())) {
            return false;
        }
        BinaryVersion binaryVersion = (BinaryVersion) obj;
        return this.major == binaryVersion.major && this.minor == binaryVersion.minor && this.patch == binaryVersion.patch && cr4.b(this.rest, binaryVersion.rest);
    }

    public final int getMajor() {
        return this.major;
    }

    public final int getMinor() {
        return this.minor;
    }

    public int hashCode() {
        int i = this.major;
        int i2 = (i * 31) + this.minor + i;
        int i3 = (i2 * 31) + this.patch + i2;
        return this.rest.hashCode() + (i3 * 31) + i3;
    }

    public final boolean isAtLeast(@kp6 BinaryVersion binaryVersion) {
        cr4.g(binaryVersion, "version");
        return isAtLeast(binaryVersion.major, binaryVersion.minor, binaryVersion.patch);
    }

    public final boolean isAtMost(int i, int i2, int i3) {
        int i4 = this.major;
        if (i4 < i) {
            return true;
        }
        if (i4 > i) {
            return false;
        }
        int i5 = this.minor;
        if (i5 < i2) {
            return true;
        }
        return i5 <= i2 && this.patch <= i3;
    }

    public final boolean isCompatibleTo(@kp6 BinaryVersion binaryVersion) {
        cr4.g(binaryVersion, "ourVersion");
        int i = this.major;
        return i == 0 ? binaryVersion.major == 0 && this.minor == binaryVersion.minor : i == binaryVersion.major && this.minor <= binaryVersion.minor;
    }

    @kp6
    public final int[] toArray() {
        return this.numbers;
    }

    @kp6
    public String toString() {
        int[] array = toArray();
        ArrayList arrayList = new ArrayList();
        for (int i : array) {
            if (i == -1) {
                break;
            }
            arrayList.add(Integer.valueOf(i));
        }
        return arrayList.isEmpty() ? "unknown" : y41.ai(arrayList, ".", null, null, null, 62);
    }

    public final boolean isAtLeast(int i, int i2, int i3) {
        int i4 = this.major;
        if (i4 > i) {
            return true;
        }
        if (i4 < i) {
            return false;
        }
        int i5 = this.minor;
        if (i5 > i2) {
            return true;
        }
        return i5 >= i2 && this.patch >= i3;
    }
}