package j.k0;

import java.util.Collection;
import java.util.Iterator;
import java.util.NoSuchElementException;

/* JADX INFO: compiled from: ArrayDeque.kt */
/* JADX INFO: loaded from: classes.dex */
public final class e<E> extends c<E> {
    public static final a f = new a(null);

    /* JADX INFO: renamed from: g, reason: collision with root package name */
    private static final Object[] f883g = new Object[0];
    private int b;
    private Object[] d = f883g;
    private int e;

    /* JADX INFO: compiled from: ArrayDeque.kt */
    public static final class a {
        private a() {
        }

        public /* synthetic */ a(j.p0.d.j jVar) {
            this();
        }

        public final int a(int i2, int i3) {
            int i4 = i2 + (i2 >> 1);
            if (i4 - i3 < 0) {
                i4 = i3;
            }
            return i4 - 2147483639 > 0 ? i3 > 2147483639 ? Integer.MAX_VALUE : 2147483639 : i4;
        }
    }

    private final void f(int i2, Collection<? extends E> collection) {
        Iterator<? extends E> it = collection.iterator();
        int length = this.d.length;
        while (i2 < length && it.hasNext()) {
            this.d[i2] = it.next();
            i2++;
        }
        int i3 = this.b;
        for (int i4 = 0; i4 < i3 && it.hasNext(); i4++) {
            this.d[i4] = it.next();
        }
        this.e = size() + collection.size();
    }

    private final void g(int i2) {
        Object[] objArr = new Object[i2];
        Object[] objArr2 = this.d;
        i.e(objArr2, objArr, 0, this.b, objArr2.length);
        Object[] objArr3 = this.d;
        int length = objArr3.length;
        int i3 = this.b;
        i.e(objArr3, objArr, length - i3, 0, i3);
        this.b = 0;
        this.d = objArr;
    }

    private final int h(int i2) {
        return i2 == 0 ? j.w(this.d) : i2 - 1;
    }

    private final void i(int i2) {
        if (i2 < 0) {
            throw new IllegalStateException("Deque is too big.");
        }
        Object[] objArr = this.d;
        if (i2 <= objArr.length) {
            return;
        }
        if (objArr == f883g) {
            this.d = new Object[j.r0.n.b(i2, 10)];
        } else {
            g(f.a(objArr.length, i2));
        }
    }

    private final int j(int i2) {
        if (i2 == j.w(this.d)) {
            return 0;
        }
        return i2 + 1;
    }

    private final int k(int i2) {
        return i2 < 0 ? i2 + this.d.length : i2;
    }

    private final int l(int i2) {
        Object[] objArr = this.d;
        return i2 >= objArr.length ? i2 - objArr.length : i2;
    }

    @Override // java.util.AbstractList, java.util.AbstractCollection, java.util.Collection, java.util.List
    public boolean add(E e) {
        e(e);
        return true;
    }

    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
    public boolean addAll(Collection<? extends E> collection) {
        j.p0.d.r.f(collection, "elements");
        if (collection.isEmpty()) {
            return false;
        }
        i(size() + collection.size());
        f(l(this.b + size()), collection);
        return true;
    }

    @Override // j.k0.c
    public int b() {
        return this.e;
    }

    @Override // j.k0.c
    public E c(int i2) {
        b.b.a(i2, size());
        if (i2 == o.h(this)) {
            return n();
        }
        if (i2 == 0) {
            return m();
        }
        int iL = l(this.b + i2);
        E e = (E) this.d[iL];
        if (i2 < (size() >> 1)) {
            int i3 = this.b;
            if (iL >= i3) {
                Object[] objArr = this.d;
                i.e(objArr, objArr, i3 + 1, i3, iL);
            } else {
                Object[] objArr2 = this.d;
                i.e(objArr2, objArr2, 1, 0, iL);
                Object[] objArr3 = this.d;
                objArr3[0] = objArr3[objArr3.length - 1];
                int i4 = this.b;
                i.e(objArr3, objArr3, i4 + 1, i4, objArr3.length - 1);
            }
            Object[] objArr4 = this.d;
            int i5 = this.b;
            objArr4[i5] = null;
            this.b = j(i5);
        } else {
            int iL2 = l(this.b + o.h(this));
            if (iL <= iL2) {
                Object[] objArr5 = this.d;
                i.e(objArr5, objArr5, iL, iL + 1, iL2 + 1);
            } else {
                Object[] objArr6 = this.d;
                i.e(objArr6, objArr6, iL, iL + 1, objArr6.length);
                Object[] objArr7 = this.d;
                objArr7[objArr7.length - 1] = objArr7[0];
                i.e(objArr7, objArr7, 0, 1, iL2 + 1);
            }
            this.d[iL2] = null;
        }
        this.e = size() - 1;
        return e;
    }

    @Override // java.util.AbstractList, java.util.AbstractCollection, java.util.Collection, java.util.List
    public void clear() {
        int iL = l(this.b + size());
        int i2 = this.b;
        if (i2 < iL) {
            i.j(this.d, null, i2, iL);
        } else if (!isEmpty()) {
            Object[] objArr = this.d;
            i.j(objArr, null, this.b, objArr.length);
            i.j(this.d, null, 0, iL);
        }
        this.b = 0;
        this.e = 0;
    }

    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
    public boolean contains(Object obj) {
        return indexOf(obj) != -1;
    }

    public final void d(E e) {
        i(size() + 1);
        int iH = h(this.b);
        this.b = iH;
        this.d[iH] = e;
        this.e = size() + 1;
    }

    public final void e(E e) {
        i(size() + 1);
        this.d[l(this.b + size())] = e;
        this.e = size() + 1;
    }

    @Override // java.util.AbstractList, java.util.List
    public E get(int i2) {
        b.b.a(i2, size());
        return (E) this.d[l(this.b + i2)];
    }

    @Override // java.util.AbstractList, java.util.List
    public int indexOf(Object obj) {
        int i2;
        int iL = l(this.b + size());
        int length = this.b;
        if (length < iL) {
            while (length < iL) {
                if (j.p0.d.r.a(obj, this.d[length])) {
                    i2 = this.b;
                } else {
                    length++;
                }
            }
            return -1;
        }
        if (length < iL) {
            return -1;
        }
        int length2 = this.d.length;
        while (true) {
            if (length >= length2) {
                for (int i3 = 0; i3 < iL; i3++) {
                    if (j.p0.d.r.a(obj, this.d[i3])) {
                        length = i3 + this.d.length;
                        i2 = this.b;
                    }
                }
                return -1;
            }
            if (j.p0.d.r.a(obj, this.d[length])) {
                i2 = this.b;
                break;
            }
            length++;
        }
        return length - i2;
    }

    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
    public boolean isEmpty() {
        return size() == 0;
    }

    @Override // java.util.AbstractList, java.util.List
    public int lastIndexOf(Object obj) {
        int iW;
        int i2;
        int iL = l(this.b + size());
        int i3 = this.b;
        if (i3 < iL) {
            iW = iL - 1;
            if (i3 <= iW) {
                while (!j.p0.d.r.a(obj, this.d[iW])) {
                    if (iW != i3) {
                        iW--;
                    }
                }
                i2 = this.b;
                return iW - i2;
            }
            return -1;
        }
        if (i3 > iL) {
            int i4 = iL - 1;
            while (true) {
                if (-1 >= i4) {
                    iW = j.w(this.d);
                    int i5 = this.b;
                    if (i5 <= iW) {
                        while (!j.p0.d.r.a(obj, this.d[iW])) {
                            if (iW != i5) {
                                iW--;
                            }
                        }
                        i2 = this.b;
                    }
                } else {
                    if (j.p0.d.r.a(obj, this.d[i4])) {
                        iW = i4 + this.d.length;
                        i2 = this.b;
                        break;
                    }
                    i4--;
                }
            }
        }
        return -1;
    }

    public final E m() {
        if (isEmpty()) {
            throw new NoSuchElementException("ArrayDeque is empty.");
        }
        Object[] objArr = this.d;
        int i2 = this.b;
        E e = (E) objArr[i2];
        objArr[i2] = null;
        this.b = j(i2);
        this.e = size() - 1;
        return e;
    }

    public final E n() {
        if (isEmpty()) {
            throw new NoSuchElementException("ArrayDeque is empty.");
        }
        int iL = l(this.b + o.h(this));
        Object[] objArr = this.d;
        E e = (E) objArr[iL];
        objArr[iL] = null;
        this.e = size() - 1;
        return e;
    }

    public final E o() {
        if (isEmpty()) {
            return null;
        }
        return n();
    }

    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
    public boolean remove(Object obj) {
        int iIndexOf = indexOf(obj);
        if (iIndexOf == -1) {
            return false;
        }
        remove(iIndexOf);
        return true;
    }

    /* JADX WARN: Multi-variable type inference failed */
    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
    public boolean removeAll(Collection<? extends Object> collection) {
        int iL;
        j.p0.d.r.f(collection, "elements");
        boolean z = false;
        z = false;
        z = false;
        if (!isEmpty()) {
            if ((this.d.length == 0) == false) {
                int iL2 = l(this.b + size());
                int i2 = this.b;
                if (i2 < iL2) {
                    iL = i2;
                    while (i2 < iL2) {
                        Object obj = this.d[i2];
                        if (!collection.contains(obj)) {
                            this.d[iL] = obj;
                            iL++;
                        } else {
                            z = true;
                        }
                        i2++;
                    }
                    i.j(this.d, null, iL, iL2);
                } else {
                    int length = this.d.length;
                    boolean z2 = false;
                    int i3 = i2;
                    while (i2 < length) {
                        Object[] objArr = this.d;
                        Object obj2 = objArr[i2];
                        objArr[i2] = null;
                        if (!collection.contains(obj2)) {
                            this.d[i3] = obj2;
                            i3++;
                        } else {
                            z2 = true;
                        }
                        i2++;
                    }
                    iL = l(i3);
                    for (int i4 = 0; i4 < iL2; i4++) {
                        Object[] objArr2 = this.d;
                        Object obj3 = objArr2[i4];
                        objArr2[i4] = null;
                        if (!collection.contains(obj3)) {
                            this.d[iL] = obj3;
                            iL = j(iL);
                        } else {
                            z2 = true;
                        }
                    }
                    z = z2;
                }
                if (z) {
                    this.e = k(iL - this.b);
                }
            }
        }
        return z;
    }

    /* JADX WARN: Multi-variable type inference failed */
    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
    public boolean retainAll(Collection<? extends Object> collection) {
        int iL;
        j.p0.d.r.f(collection, "elements");
        boolean z = false;
        z = false;
        z = false;
        if (!isEmpty()) {
            if ((this.d.length == 0) == false) {
                int iL2 = l(this.b + size());
                int i2 = this.b;
                if (i2 < iL2) {
                    iL = i2;
                    while (i2 < iL2) {
                        Object obj = this.d[i2];
                        if (collection.contains(obj)) {
                            this.d[iL] = obj;
                            iL++;
                        } else {
                            z = true;
                        }
                        i2++;
                    }
                    i.j(this.d, null, iL, iL2);
                } else {
                    int length = this.d.length;
                    boolean z2 = false;
                    int i3 = i2;
                    while (i2 < length) {
                        Object[] objArr = this.d;
                        Object obj2 = objArr[i2];
                        objArr[i2] = null;
                        if (collection.contains(obj2)) {
                            this.d[i3] = obj2;
                            i3++;
                        } else {
                            z2 = true;
                        }
                        i2++;
                    }
                    iL = l(i3);
                    for (int i4 = 0; i4 < iL2; i4++) {
                        Object[] objArr2 = this.d;
                        Object obj3 = objArr2[i4];
                        objArr2[i4] = null;
                        if (collection.contains(obj3)) {
                            this.d[iL] = obj3;
                            iL = j(iL);
                        } else {
                            z2 = true;
                        }
                    }
                    z = z2;
                }
                if (z) {
                    this.e = k(iL - this.b);
                }
            }
        }
        return z;
    }

    @Override // java.util.AbstractList, java.util.List
    public E set(int i2, E e) {
        b.b.a(i2, size());
        int iL = l(this.b + i2);
        Object[] objArr = this.d;
        E e2 = (E) objArr[iL];
        objArr[iL] = e;
        return e2;
    }

    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
    public <T> T[] toArray(T[] tArr) {
        j.p0.d.r.f(tArr, "array");
        if (tArr.length < size()) {
            tArr = (T[]) g.a(tArr, size());
        }
        j.p0.d.r.d(tArr, "null cannot be cast to non-null type kotlin.Array<kotlin.Any?>");
        int iL = l(this.b + size());
        int i2 = this.b;
        if (i2 < iL) {
            i.g(this.d, tArr, 0, i2, iL, 2, null);
        } else if (!isEmpty()) {
            Object[] objArr = this.d;
            i.e(objArr, tArr, 0, this.b, objArr.length);
            Object[] objArr2 = this.d;
            i.e(objArr2, tArr, objArr2.length - this.b, 0, iL);
        }
        if (tArr.length > size()) {
            tArr[size()] = null;
        }
        return tArr;
    }

    @Override // java.util.AbstractList, java.util.List
    public void add(int i2, E e) {
        b.b.b(i2, size());
        if (i2 == size()) {
            e(e);
            return;
        }
        if (i2 == 0) {
            d(e);
            return;
        }
        i(size() + 1);
        int iL = l(this.b + i2);
        if (i2 < ((size() + 1) >> 1)) {
            int iH = h(iL);
            int iH2 = h(this.b);
            int i3 = this.b;
            if (iH >= i3) {
                Object[] objArr = this.d;
                objArr[iH2] = objArr[i3];
                i.e(objArr, objArr, i3, i3 + 1, iH + 1);
            } else {
                Object[] objArr2 = this.d;
                i.e(objArr2, objArr2, i3 - 1, i3, objArr2.length);
                Object[] objArr3 = this.d;
                objArr3[objArr3.length - 1] = objArr3[0];
                i.e(objArr3, objArr3, 0, 1, iH + 1);
            }
            this.d[iH] = e;
            this.b = iH2;
        } else {
            int iL2 = l(this.b + size());
            if (iL < iL2) {
                Object[] objArr4 = this.d;
                i.e(objArr4, objArr4, iL + 1, iL, iL2);
            } else {
                Object[] objArr5 = this.d;
                i.e(objArr5, objArr5, 1, 0, iL2);
                Object[] objArr6 = this.d;
                objArr6[0] = objArr6[objArr6.length - 1];
                i.e(objArr6, objArr6, iL + 1, iL, objArr6.length - 1);
            }
            this.d[iL] = e;
        }
        this.e = size() + 1;
    }

    @Override // java.util.AbstractList, java.util.List
    public boolean addAll(int i2, Collection<? extends E> collection) {
        j.p0.d.r.f(collection, "elements");
        b.b.b(i2, size());
        if (collection.isEmpty()) {
            return false;
        }
        if (i2 == size()) {
            return addAll(collection);
        }
        i(size() + collection.size());
        int iL = l(this.b + size());
        int iL2 = l(this.b + i2);
        int size = collection.size();
        if (i2 < ((size() + 1) >> 1)) {
            int i3 = this.b;
            int length = i3 - size;
            if (iL2 < i3) {
                Object[] objArr = this.d;
                i.e(objArr, objArr, length, i3, objArr.length);
                if (size >= iL2) {
                    Object[] objArr2 = this.d;
                    i.e(objArr2, objArr2, objArr2.length - size, 0, iL2);
                } else {
                    Object[] objArr3 = this.d;
                    i.e(objArr3, objArr3, objArr3.length - size, 0, size);
                    Object[] objArr4 = this.d;
                    i.e(objArr4, objArr4, 0, size, iL2);
                }
            } else if (length >= 0) {
                Object[] objArr5 = this.d;
                i.e(objArr5, objArr5, length, i3, iL2);
            } else {
                Object[] objArr6 = this.d;
                length += objArr6.length;
                int i4 = iL2 - i3;
                int length2 = objArr6.length - length;
                if (length2 >= i4) {
                    i.e(objArr6, objArr6, length, i3, iL2);
                } else {
                    i.e(objArr6, objArr6, length, i3, i3 + length2);
                    Object[] objArr7 = this.d;
                    i.e(objArr7, objArr7, 0, this.b + length2, iL2);
                }
            }
            this.b = length;
            f(k(iL2 - size), collection);
        } else {
            int i5 = iL2 + size;
            if (iL2 < iL) {
                int i6 = size + iL;
                Object[] objArr8 = this.d;
                if (i6 <= objArr8.length) {
                    i.e(objArr8, objArr8, i5, iL2, iL);
                } else if (i5 >= objArr8.length) {
                    i.e(objArr8, objArr8, i5 - objArr8.length, iL2, iL);
                } else {
                    int length3 = iL - (i6 - objArr8.length);
                    i.e(objArr8, objArr8, 0, length3, iL);
                    Object[] objArr9 = this.d;
                    i.e(objArr9, objArr9, i5, iL2, length3);
                }
            } else {
                Object[] objArr10 = this.d;
                i.e(objArr10, objArr10, size, 0, iL);
                Object[] objArr11 = this.d;
                if (i5 >= objArr11.length) {
                    i.e(objArr11, objArr11, i5 - objArr11.length, iL2, objArr11.length);
                } else {
                    i.e(objArr11, objArr11, 0, objArr11.length - size, objArr11.length);
                    Object[] objArr12 = this.d;
                    i.e(objArr12, objArr12, i5, iL2, objArr12.length - size);
                }
            }
            f(iL2, collection);
        }
        return true;
    }

    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
    public Object[] toArray() {
        return toArray(new Object[size()]);
    }
}