discord-jadx/app/src/main/java/d0/t/l0.java

package d0.t;

import d0.d0.f;
import d0.z.d.m;
import java.util.Arrays;
import java.util.Iterator;
import java.util.RandomAccess;
/* compiled from: SlidingWindow.kt */
public final class l0<T> extends c<T> implements RandomAccess {
    public final int j;
    public int k;
    public int l;
    public final Object[] m;

    /* compiled from: SlidingWindow.kt */
    public static final class a extends b<T> {
        public int k;
        public int l;
        public final /* synthetic */ l0 m;

        public a(l0 l0Var) {
            this.m = l0Var;
            this.k = l0Var.size();
            this.l = l0.access$getStartIndex$p(l0Var);
        }

        /* JADX DEBUG: Multi-variable search result rejected for r2v0, resolved type: d0.t.l0$a */
        /* JADX WARN: Multi-variable type inference failed */
        @Override // d0.t.b
        public void a() {
            if (this.k == 0) {
                this.i = 3;
                return;
            }
            b(l0.access$getBuffer$p(this.m)[this.l]);
            this.l = (this.l + 1) % l0.access$getCapacity$p(this.m);
            this.k--;
        }
    }

    public l0(int i) {
        this(new Object[i], 0);
    }

    public l0(Object[] objArr, int i) {
        m.checkNotNullParameter(objArr, "buffer");
        this.m = objArr;
        boolean z2 = true;
        if (i >= 0) {
            if (i > objArr.length ? false : z2) {
                this.j = objArr.length;
                this.l = i;
                return;
            }
            StringBuilder M = c.d.b.a.a.M("ring buffer filled size: ", i, " cannot be larger than the buffer size: ");
            M.append(objArr.length);
            throw new IllegalArgumentException(M.toString().toString());
        }
        throw new IllegalArgumentException(c.d.b.a.a.l("ring buffer filled size should not be negative but it is ", i).toString());
    }

    public static final /* synthetic */ Object[] access$getBuffer$p(l0 l0Var) {
        return l0Var.m;
    }

    public static final /* synthetic */ int access$getCapacity$p(l0 l0Var) {
        return l0Var.j;
    }

    public static final /* synthetic */ int access$getStartIndex$p(l0 l0Var) {
        return l0Var.k;
    }

    @Override // d0.t.a, java.util.Collection
    public final void add(T t) {
        if (!isFull()) {
            this.m[(size() + this.k) % access$getCapacity$p(this)] = t;
            this.l = size() + 1;
            return;
        }
        throw new IllegalStateException("ring buffer is full");
    }

    /* JADX DEBUG: Multi-variable search result rejected for r2v0, resolved type: d0.t.l0<T> */
    /* JADX WARN: Multi-variable type inference failed */
    public final l0<T> expanded(int i) {
        Object[] objArr;
        int i2 = this.j;
        int coerceAtMost = f.coerceAtMost(i2 + (i2 >> 1) + 1, i);
        if (this.k == 0) {
            objArr = Arrays.copyOf(this.m, coerceAtMost);
            m.checkNotNullExpressionValue(objArr, "java.util.Arrays.copyOf(this, newSize)");
        } else {
            objArr = toArray(new Object[coerceAtMost]);
        }
        return new l0<>(objArr, size());
    }

    @Override // d0.t.c, java.util.List
    public T get(int i) {
        c.i.checkElementIndex$kotlin_stdlib(i, size());
        return (T) this.m[(this.k + i) % access$getCapacity$p(this)];
    }

    @Override // d0.t.a
    public int getSize() {
        return this.l;
    }

    public final boolean isFull() {
        return size() == this.j;
    }

    @Override // d0.t.c, java.util.Collection, java.lang.Iterable, java.util.List
    public Iterator<T> iterator() {
        return new a(this);
    }

    public final void removeFirst(int i) {
        boolean z2 = true;
        if (i >= 0) {
            if (i > size()) {
                z2 = false;
            }
            if (!z2) {
                StringBuilder M = c.d.b.a.a.M("n shouldn't be greater than the buffer size: n = ", i, ", size = ");
                M.append(size());
                throw new IllegalArgumentException(M.toString().toString());
            } else if (i > 0) {
                int i2 = this.k;
                int access$getCapacity$p = (i2 + i) % access$getCapacity$p(this);
                if (i2 > access$getCapacity$p) {
                    j.fill(this.m, (Object) null, i2, this.j);
                    j.fill(this.m, (Object) null, 0, access$getCapacity$p);
                } else {
                    j.fill(this.m, (Object) null, i2, access$getCapacity$p);
                }
                this.k = access$getCapacity$p;
                this.l = size() - i;
            }
        } else {
            throw new IllegalArgumentException(c.d.b.a.a.l("n shouldn't be negative but it is ", i).toString());
        }
    }

    /* JADX DEBUG: Multi-variable search result rejected for r1v0, resolved type: d0.t.l0<T> */
    /* JADX WARN: Multi-variable type inference failed */
    @Override // d0.t.a, java.util.Collection
    public Object[] toArray() {
        return toArray(new Object[size()]);
    }

    /* JADX DEBUG: Multi-variable search result rejected for r6v6, resolved type: T[] */
    /* JADX DEBUG: Multi-variable search result rejected for r6v7, resolved type: T[] */
    /* JADX WARN: Multi-variable type inference failed */
    @Override // d0.t.a, java.util.Collection
    public <T> T[] toArray(T[] tArr) {
        m.checkNotNullParameter(tArr, "array");
        if (tArr.length < size()) {
            tArr = (T[]) Arrays.copyOf(tArr, size());
            m.checkNotNullExpressionValue(tArr, "java.util.Arrays.copyOf(this, newSize)");
        }
        int size = size();
        int i = this.k;
        int i2 = 0;
        int i3 = 0;
        while (i3 < size && i < this.j) {
            tArr[i3] = this.m[i];
            i3++;
            i++;
        }
        while (i3 < size) {
            tArr[i3] = this.m[i2];
            i3++;
            i2++;
        }
        if (tArr.length > size()) {
            tArr[size()] = null;
        }
        return tArr;
    }
}