package i.a.n.f;

import i.a.n.c.d;
import i.a.n.h.f;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.AtomicReferenceArray;

/* JADX INFO: compiled from: SpscLinkedArrayQueue.java */
/* JADX INFO: loaded from: classes.dex */
public final class b<T> implements d<T> {

    /* JADX INFO: renamed from: k, reason: collision with root package name */
    static final int f861k = Integer.getInteger("jctools.spsc.max.lookahead.step", 4096).intValue();

    /* JADX INFO: renamed from: l, reason: collision with root package name */
    private static final Object f862l = new Object();
    int d;
    long e;
    final int f;

    /* JADX INFO: renamed from: g, reason: collision with root package name */
    AtomicReferenceArray<Object> f863g;

    /* JADX INFO: renamed from: h, reason: collision with root package name */
    final int f864h;

    /* JADX INFO: renamed from: i, reason: collision with root package name */
    AtomicReferenceArray<Object> f865i;
    final AtomicLong b = new AtomicLong();

    /* JADX INFO: renamed from: j, reason: collision with root package name */
    final AtomicLong f866j = new AtomicLong();

    public b(int i2) {
        int iA = f.a(Math.max(8, i2));
        int i3 = iA - 1;
        AtomicReferenceArray<Object> atomicReferenceArray = new AtomicReferenceArray<>(iA + 1);
        this.f863g = atomicReferenceArray;
        this.f = i3;
        a(iA);
        this.f865i = atomicReferenceArray;
        this.f864h = i3;
        this.e = i3 - 1;
        o(0L);
    }

    private void a(int i2) {
        this.d = Math.min(i2 / 4, f861k);
    }

    private static int b(int i2) {
        return i2;
    }

    private static int c(long j2, int i2) {
        int i3 = ((int) j2) & i2;
        b(i3);
        return i3;
    }

    private long d() {
        return this.f866j.get();
    }

    private long e() {
        return this.b.get();
    }

    private long f() {
        return this.f866j.get();
    }

    private static <E> Object g(AtomicReferenceArray<Object> atomicReferenceArray, int i2) {
        return atomicReferenceArray.get(i2);
    }

    private AtomicReferenceArray<Object> h(AtomicReferenceArray<Object> atomicReferenceArray, int i2) {
        b(i2);
        AtomicReferenceArray<Object> atomicReferenceArray2 = (AtomicReferenceArray) g(atomicReferenceArray, i2);
        m(atomicReferenceArray, i2, null);
        return atomicReferenceArray2;
    }

    private long i() {
        return this.b.get();
    }

    private T j(AtomicReferenceArray<Object> atomicReferenceArray, long j2, int i2) {
        this.f865i = atomicReferenceArray;
        int iC = c(j2, i2);
        T t = (T) g(atomicReferenceArray, iC);
        if (t != null) {
            m(atomicReferenceArray, iC, null);
            l(j2 + 1);
        }
        return t;
    }

    private void k(AtomicReferenceArray<Object> atomicReferenceArray, long j2, int i2, T t, long j3) {
        AtomicReferenceArray<Object> atomicReferenceArray2 = new AtomicReferenceArray<>(atomicReferenceArray.length());
        this.f863g = atomicReferenceArray2;
        this.e = (j3 + j2) - 1;
        m(atomicReferenceArray2, i2, t);
        n(atomicReferenceArray, atomicReferenceArray2);
        m(atomicReferenceArray, i2, f862l);
        o(j2 + 1);
    }

    private void l(long j2) {
        this.f866j.lazySet(j2);
    }

    private static void m(AtomicReferenceArray<Object> atomicReferenceArray, int i2, Object obj) {
        atomicReferenceArray.lazySet(i2, obj);
    }

    private void n(AtomicReferenceArray<Object> atomicReferenceArray, AtomicReferenceArray<Object> atomicReferenceArray2) {
        int length = atomicReferenceArray.length() - 1;
        b(length);
        m(atomicReferenceArray, length, atomicReferenceArray2);
    }

    private void o(long j2) {
        this.b.lazySet(j2);
    }

    private boolean p(AtomicReferenceArray<Object> atomicReferenceArray, T t, long j2, int i2) {
        m(atomicReferenceArray, i2, t);
        o(j2 + 1);
        return true;
    }

    @Override // i.a.n.c.e
    public void clear() {
        while (true) {
            if (poll() == null && isEmpty()) {
                return;
            }
        }
    }

    @Override // i.a.n.c.e
    public boolean isEmpty() {
        return i() == f();
    }

    @Override // i.a.n.c.e
    public boolean offer(T t) {
        if (t == null) {
            throw new NullPointerException("Null is not a valid element");
        }
        AtomicReferenceArray<Object> atomicReferenceArray = this.f863g;
        long jE = e();
        int i2 = this.f;
        int iC = c(jE, i2);
        if (jE < this.e) {
            return p(atomicReferenceArray, t, jE, iC);
        }
        long j2 = ((long) this.d) + jE;
        if (g(atomicReferenceArray, c(j2, i2)) == null) {
            this.e = j2 - 1;
            return p(atomicReferenceArray, t, jE, iC);
        }
        if (g(atomicReferenceArray, c(1 + jE, i2)) == null) {
            return p(atomicReferenceArray, t, jE, iC);
        }
        k(atomicReferenceArray, jE, iC, t, i2);
        return true;
    }

    @Override // i.a.n.c.d, i.a.n.c.e
    public T poll() {
        AtomicReferenceArray<Object> atomicReferenceArray = this.f865i;
        long jD = d();
        int i2 = this.f864h;
        int iC = c(jD, i2);
        T t = (T) g(atomicReferenceArray, iC);
        boolean z = t == f862l;
        if (t == null || z) {
            if (z) {
                return j(h(atomicReferenceArray, i2 + 1), jD, i2);
            }
            return null;
        }
        m(atomicReferenceArray, iC, null);
        l(jD + 1);
        return t;
    }
}