package d.j0;

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

/* JADX INFO: compiled from: ArrayDeque.kt */
/* JADX INFO: loaded from: classes.dex */
@d.n
public final class e<E> extends c<E> {

    /* JADX INFO: renamed from: c, reason: collision with root package name */
    public static final a f2589c = new a(null);

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

    /* JADX INFO: renamed from: e, reason: collision with root package name */
    private int f2591e;

    /* JADX INFO: renamed from: f, reason: collision with root package name */
    private Object[] f2592f = f2590d;

    /* JADX INFO: renamed from: g, reason: collision with root package name */
    private int f2593g;

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

        public /* synthetic */ a(d.n0.c.l lVar) {
            this();
        }

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

    private final void c(int i, Collection<? extends E> collection) {
        Iterator<? extends E> it = collection.iterator();
        int length = this.f2592f.length;
        while (i < length && it.hasNext()) {
            this.f2592f[i] = it.next();
            i++;
        }
        int i2 = this.f2591e;
        for (int i3 = 0; i3 < i2 && it.hasNext(); i3++) {
            this.f2592f[i3] = it.next();
        }
        this.f2593g = size() + collection.size();
    }

    private final void d(int i) {
        Object[] objArr = new Object[i];
        Object[] objArr2 = this.f2592f;
        i.c(objArr2, objArr, 0, this.f2591e, objArr2.length);
        Object[] objArr3 = this.f2592f;
        int length = objArr3.length;
        int i2 = this.f2591e;
        i.c(objArr3, objArr, length - i2, 0, i2);
        this.f2591e = 0;
        this.f2592f = objArr;
    }

    private final int e(int i) {
        return i == 0 ? j.m(this.f2592f) : i - 1;
    }

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

    private final int g(int i) {
        if (i == j.m(this.f2592f)) {
            return 0;
        }
        return i + 1;
    }

    private final int h(int i) {
        return i < 0 ? i + this.f2592f.length : i;
    }

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

    @Override // d.j0.c
    public int a() {
        return this.f2593g;
    }

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

    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
    public boolean addAll(Collection<? extends E> collection) {
        d.n0.c.s.e(collection, "elements");
        if (collection.isEmpty()) {
            return false;
        }
        f(size() + collection.size());
        c(i(this.f2591e + size()), collection);
        return true;
    }

    public final void addFirst(E e2) {
        f(size() + 1);
        int iE = e(this.f2591e);
        this.f2591e = iE;
        this.f2592f[iE] = e2;
        this.f2593g = size() + 1;
    }

    public final void addLast(E e2) {
        f(size() + 1);
        this.f2592f[i(this.f2591e + size())] = e2;
        this.f2593g = size() + 1;
    }

    @Override // d.j0.c
    public E b(int i) {
        b.f2582c.a(i, size());
        if (i == p.e(this)) {
            return removeLast();
        }
        if (i == 0) {
            return removeFirst();
        }
        int i2 = i(this.f2591e + i);
        E e2 = (E) this.f2592f[i2];
        if (i < (size() >> 1)) {
            int i3 = this.f2591e;
            if (i2 >= i3) {
                Object[] objArr = this.f2592f;
                i.c(objArr, objArr, i3 + 1, i3, i2);
            } else {
                Object[] objArr2 = this.f2592f;
                i.c(objArr2, objArr2, 1, 0, i2);
                Object[] objArr3 = this.f2592f;
                objArr3[0] = objArr3[objArr3.length - 1];
                int i4 = this.f2591e;
                i.c(objArr3, objArr3, i4 + 1, i4, objArr3.length - 1);
            }
            Object[] objArr4 = this.f2592f;
            int i5 = this.f2591e;
            objArr4[i5] = null;
            this.f2591e = g(i5);
        } else {
            int i6 = i(this.f2591e + p.e(this));
            if (i2 <= i6) {
                Object[] objArr5 = this.f2592f;
                i.c(objArr5, objArr5, i2, i2 + 1, i6 + 1);
            } else {
                Object[] objArr6 = this.f2592f;
                i.c(objArr6, objArr6, i2, i2 + 1, objArr6.length);
                Object[] objArr7 = this.f2592f;
                objArr7[objArr7.length - 1] = objArr7[0];
                i.c(objArr7, objArr7, 0, 1, i6 + 1);
            }
            this.f2592f[i6] = null;
        }
        this.f2593g = size() - 1;
        return e2;
    }

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

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

    @Override // java.util.AbstractList, java.util.List
    public E get(int i) {
        b.f2582c.a(i, size());
        return (E) this.f2592f[i(this.f2591e + i)];
    }

    @Override // java.util.AbstractList, java.util.List
    public int indexOf(Object obj) {
        int i;
        int i2 = i(this.f2591e + size());
        int length = this.f2591e;
        if (length < i2) {
            while (length < i2) {
                if (d.n0.c.s.a(obj, this.f2592f[length])) {
                    i = this.f2591e;
                } else {
                    length++;
                }
            }
            return -1;
        }
        if (length < i2) {
            return -1;
        }
        int length2 = this.f2592f.length;
        while (true) {
            if (length >= length2) {
                for (int i3 = 0; i3 < i2; i3++) {
                    if (d.n0.c.s.a(obj, this.f2592f[i3])) {
                        length = i3 + this.f2592f.length;
                        i = this.f2591e;
                    }
                }
                return -1;
            }
            if (d.n0.c.s.a(obj, this.f2592f[length])) {
                i = this.f2591e;
                break;
            }
            length++;
        }
        return length - i;
    }

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

    public final E j() {
        if (isEmpty()) {
            return null;
        }
        return removeLast();
    }

    @Override // java.util.AbstractList, java.util.List
    public int lastIndexOf(Object obj) {
        int iM;
        int i;
        int i2 = i(this.f2591e + size());
        int i3 = this.f2591e;
        if (i3 < i2) {
            iM = i2 - 1;
            if (i3 <= iM) {
                while (!d.n0.c.s.a(obj, this.f2592f[iM])) {
                    if (iM != i3) {
                        iM--;
                    }
                }
                i = this.f2591e;
                return iM - i;
            }
            return -1;
        }
        if (i3 > i2) {
            int i4 = i2 - 1;
            while (true) {
                if (-1 >= i4) {
                    iM = j.m(this.f2592f);
                    int i5 = this.f2591e;
                    if (i5 <= iM) {
                        while (!d.n0.c.s.a(obj, this.f2592f[iM])) {
                            if (iM != i5) {
                                iM--;
                            }
                        }
                        i = this.f2591e;
                    }
                } else {
                    if (d.n0.c.s.a(obj, this.f2592f[i4])) {
                        iM = i4 + this.f2592f.length;
                        i = this.f2591e;
                        break;
                    }
                    i4--;
                }
            }
        }
        return -1;
    }

    @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 i;
        d.n0.c.s.e(collection, "elements");
        boolean z = false;
        z = false;
        z = false;
        if (!isEmpty()) {
            if ((this.f2592f.length == 0) == false) {
                int i2 = i(this.f2591e + size());
                int i3 = this.f2591e;
                if (i3 < i2) {
                    i = i3;
                    while (i3 < i2) {
                        Object obj = this.f2592f[i3];
                        if (!collection.contains(obj)) {
                            this.f2592f[i] = obj;
                            i++;
                        } else {
                            z = true;
                        }
                        i3++;
                    }
                    i.e(this.f2592f, null, i, i2);
                } else {
                    int length = this.f2592f.length;
                    boolean z2 = false;
                    int i4 = i3;
                    while (i3 < length) {
                        Object[] objArr = this.f2592f;
                        Object obj2 = objArr[i3];
                        objArr[i3] = null;
                        if (!collection.contains(obj2)) {
                            this.f2592f[i4] = obj2;
                            i4++;
                        } else {
                            z2 = true;
                        }
                        i3++;
                    }
                    i = i(i4);
                    for (int i5 = 0; i5 < i2; i5++) {
                        Object[] objArr2 = this.f2592f;
                        Object obj3 = objArr2[i5];
                        objArr2[i5] = null;
                        if (!collection.contains(obj3)) {
                            this.f2592f[i] = obj3;
                            i = g(i);
                        } else {
                            z2 = true;
                        }
                    }
                    z = z2;
                }
                if (z) {
                    this.f2593g = h(i - this.f2591e);
                }
            }
        }
        return z;
    }

    public final E removeFirst() {
        if (isEmpty()) {
            throw new NoSuchElementException("ArrayDeque is empty.");
        }
        Object[] objArr = this.f2592f;
        int i = this.f2591e;
        E e2 = (E) objArr[i];
        objArr[i] = null;
        this.f2591e = g(i);
        this.f2593g = size() - 1;
        return e2;
    }

    public final E removeLast() {
        if (isEmpty()) {
            throw new NoSuchElementException("ArrayDeque is empty.");
        }
        int i = i(this.f2591e + p.e(this));
        Object[] objArr = this.f2592f;
        E e2 = (E) objArr[i];
        objArr[i] = null;
        this.f2593g = size() - 1;
        return e2;
    }

    /* 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 i;
        d.n0.c.s.e(collection, "elements");
        boolean z = false;
        z = false;
        z = false;
        if (!isEmpty()) {
            if ((this.f2592f.length == 0) == false) {
                int i2 = i(this.f2591e + size());
                int i3 = this.f2591e;
                if (i3 < i2) {
                    i = i3;
                    while (i3 < i2) {
                        Object obj = this.f2592f[i3];
                        if (collection.contains(obj)) {
                            this.f2592f[i] = obj;
                            i++;
                        } else {
                            z = true;
                        }
                        i3++;
                    }
                    i.e(this.f2592f, null, i, i2);
                } else {
                    int length = this.f2592f.length;
                    boolean z2 = false;
                    int i4 = i3;
                    while (i3 < length) {
                        Object[] objArr = this.f2592f;
                        Object obj2 = objArr[i3];
                        objArr[i3] = null;
                        if (collection.contains(obj2)) {
                            this.f2592f[i4] = obj2;
                            i4++;
                        } else {
                            z2 = true;
                        }
                        i3++;
                    }
                    i = i(i4);
                    for (int i5 = 0; i5 < i2; i5++) {
                        Object[] objArr2 = this.f2592f;
                        Object obj3 = objArr2[i5];
                        objArr2[i5] = null;
                        if (collection.contains(obj3)) {
                            this.f2592f[i] = obj3;
                            i = g(i);
                        } else {
                            z2 = true;
                        }
                    }
                    z = z2;
                }
                if (z) {
                    this.f2593g = h(i - this.f2591e);
                }
            }
        }
        return z;
    }

    @Override // java.util.AbstractList, java.util.List
    public E set(int i, E e2) {
        b.f2582c.a(i, size());
        int i2 = i(this.f2591e + i);
        Object[] objArr = this.f2592f;
        E e3 = (E) objArr[i2];
        objArr[i2] = e2;
        return e3;
    }

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

    @Override // java.util.AbstractList, java.util.List
    public void add(int i, E e2) {
        b.f2582c.b(i, size());
        if (i == size()) {
            addLast(e2);
            return;
        }
        if (i == 0) {
            addFirst(e2);
            return;
        }
        f(size() + 1);
        int i2 = i(this.f2591e + i);
        if (i < ((size() + 1) >> 1)) {
            int iE = e(i2);
            int iE2 = e(this.f2591e);
            int i3 = this.f2591e;
            if (iE >= i3) {
                Object[] objArr = this.f2592f;
                objArr[iE2] = objArr[i3];
                i.c(objArr, objArr, i3, i3 + 1, iE + 1);
            } else {
                Object[] objArr2 = this.f2592f;
                i.c(objArr2, objArr2, i3 - 1, i3, objArr2.length);
                Object[] objArr3 = this.f2592f;
                objArr3[objArr3.length - 1] = objArr3[0];
                i.c(objArr3, objArr3, 0, 1, iE + 1);
            }
            this.f2592f[iE] = e2;
            this.f2591e = iE2;
        } else {
            int i4 = i(this.f2591e + size());
            if (i2 < i4) {
                Object[] objArr4 = this.f2592f;
                i.c(objArr4, objArr4, i2 + 1, i2, i4);
            } else {
                Object[] objArr5 = this.f2592f;
                i.c(objArr5, objArr5, 1, 0, i4);
                Object[] objArr6 = this.f2592f;
                objArr6[0] = objArr6[objArr6.length - 1];
                i.c(objArr6, objArr6, i2 + 1, i2, objArr6.length - 1);
            }
            this.f2592f[i2] = e2;
        }
        this.f2593g = size() + 1;
    }

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

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