package io.netty.util.internal.shaded.org.jctools.queues;

import io.netty.util.internal.shaded.org.jctools.queues.MessagePassingQueue;
import io.netty.util.internal.shaded.org.jctools.util.UnsafeRefArrayAccess;

/* JADX INFO: loaded from: classes.dex */
public class MpscArrayQueue<E> extends MpscArrayQueueConsumerField<E> implements QueueProgressIndicators {
    long p01;
    long p02;
    long p03;
    long p04;
    long p05;
    long p06;
    long p07;
    long p10;
    long p11;
    long p12;
    long p13;
    long p14;
    long p15;
    long p16;
    long p17;

    public MpscArrayQueue(int i2) {
        super(i2);
    }

    @Override // io.netty.util.internal.shaded.org.jctools.queues.QueueProgressIndicators
    public long currentConsumerIndex() {
        return lvConsumerIndex();
    }

    @Override // io.netty.util.internal.shaded.org.jctools.queues.QueueProgressIndicators
    public long currentProducerIndex() {
        return lvProducerIndex();
    }

    @Override // io.netty.util.internal.shaded.org.jctools.queues.MessagePassingQueue
    public int drain(MessagePassingQueue.Consumer<E> consumer) {
        return drain(consumer, capacity());
    }

    public final int failFastOffer(E e2) {
        if (e2 == null) {
            throw null;
        }
        long j2 = this.mask;
        long j3 = j2 + 1;
        long jLvProducerIndex = lvProducerIndex();
        if (jLvProducerIndex >= lvProducerLimit()) {
            long jLvConsumerIndex = lvConsumerIndex() + j3;
            if (jLvProducerIndex >= jLvConsumerIndex) {
                return 1;
            }
            soProducerLimit(jLvConsumerIndex);
        }
        if (!casProducerIndex(jLvProducerIndex, 1 + jLvProducerIndex)) {
            return -1;
        }
        UnsafeRefArrayAccess.soElement(this.buffer, ConcurrentCircularArrayQueue.calcElementOffset(jLvProducerIndex, j2), e2);
        return 0;
    }

    @Override // io.netty.util.internal.shaded.org.jctools.queues.MessagePassingQueue
    public int fill(MessagePassingQueue.Supplier<E> supplier) {
        int iCapacity = capacity();
        long j2 = 0;
        do {
            int iFill = fill(supplier, MpmcArrayQueue.RECOMENDED_OFFER_BATCH);
            if (iFill == 0) {
                return (int) j2;
            }
            j2 += (long) iFill;
        } while (j2 <= iCapacity);
        return (int) j2;
    }

    @Override // java.util.AbstractCollection, java.util.Collection, io.netty.util.internal.shaded.org.jctools.queues.MessagePassingQueue
    public boolean isEmpty() {
        return lvConsumerIndex() == lvProducerIndex();
    }

    @Override // java.util.Queue, io.netty.util.internal.shaded.org.jctools.queues.MessagePassingQueue
    public boolean offer(E e2) {
        long jLvProducerIndex;
        if (e2 == null) {
            throw null;
        }
        long j2 = this.mask;
        long jLvProducerLimit = lvProducerLimit();
        do {
            jLvProducerIndex = lvProducerIndex();
            if (jLvProducerIndex >= jLvProducerLimit) {
                jLvProducerLimit = lvConsumerIndex() + j2 + 1;
                if (jLvProducerIndex >= jLvProducerLimit) {
                    return false;
                }
                soProducerLimit(jLvProducerLimit);
            }
        } while (!casProducerIndex(jLvProducerIndex, 1 + jLvProducerIndex));
        UnsafeRefArrayAccess.soElement(this.buffer, ConcurrentCircularArrayQueue.calcElementOffset(jLvProducerIndex, j2), e2);
        return true;
    }

    public boolean offerIfBelowThreshold(E e2, int i2) {
        long jLvProducerIndex;
        if (e2 == null) {
            throw null;
        }
        long j2 = this.mask;
        long j3 = j2 + 1;
        long jLvProducerLimit = lvProducerLimit();
        do {
            jLvProducerIndex = lvProducerIndex();
            long j4 = i2;
            if (j3 - (jLvProducerLimit - jLvProducerIndex) >= j4) {
                long jLvConsumerIndex = lvConsumerIndex();
                if (jLvProducerIndex - jLvConsumerIndex >= j4) {
                    return false;
                }
                jLvProducerLimit = jLvConsumerIndex + j3;
                soProducerLimit(jLvProducerLimit);
            }
        } while (!casProducerIndex(jLvProducerIndex, jLvProducerIndex + 1));
        UnsafeRefArrayAccess.soElement(this.buffer, ConcurrentCircularArrayQueue.calcElementOffset(jLvProducerIndex, j2), e2);
        return true;
    }

    @Override // java.util.Queue, io.netty.util.internal.shaded.org.jctools.queues.MessagePassingQueue
    public E peek() {
        E[] eArr = this.buffer;
        long jLpConsumerIndex = lpConsumerIndex();
        long jCalcElementOffset = calcElementOffset(jLpConsumerIndex);
        E e2 = (E) UnsafeRefArrayAccess.lvElement(eArr, jCalcElementOffset);
        if (e2 == null) {
            if (jLpConsumerIndex == lvProducerIndex()) {
                return null;
            }
            do {
                e2 = (E) UnsafeRefArrayAccess.lvElement(eArr, jCalcElementOffset);
            } while (e2 == null);
        }
        return e2;
    }

    @Override // java.util.Queue, io.netty.util.internal.shaded.org.jctools.queues.MessagePassingQueue
    public E poll() {
        long jLpConsumerIndex = lpConsumerIndex();
        long jCalcElementOffset = calcElementOffset(jLpConsumerIndex);
        E[] eArr = this.buffer;
        E e2 = (E) UnsafeRefArrayAccess.lvElement(eArr, jCalcElementOffset);
        if (e2 == null) {
            if (jLpConsumerIndex == lvProducerIndex()) {
                return null;
            }
            do {
                e2 = (E) UnsafeRefArrayAccess.lvElement(eArr, jCalcElementOffset);
            } while (e2 == null);
        }
        UnsafeRefArrayAccess.spElement(eArr, jCalcElementOffset, null);
        soConsumerIndex(jLpConsumerIndex + 1);
        return e2;
    }

    @Override // io.netty.util.internal.shaded.org.jctools.queues.MessagePassingQueue
    public boolean relaxedOffer(E e2) {
        return offer(e2);
    }

    @Override // io.netty.util.internal.shaded.org.jctools.queues.MessagePassingQueue
    public E relaxedPeek() {
        return (E) UnsafeRefArrayAccess.lvElement(this.buffer, ConcurrentCircularArrayQueue.calcElementOffset(lpConsumerIndex(), this.mask));
    }

    @Override // io.netty.util.internal.shaded.org.jctools.queues.MessagePassingQueue
    public E relaxedPoll() {
        E[] eArr = this.buffer;
        long jLpConsumerIndex = lpConsumerIndex();
        long jCalcElementOffset = calcElementOffset(jLpConsumerIndex);
        E e2 = (E) UnsafeRefArrayAccess.lvElement(eArr, jCalcElementOffset);
        if (e2 == null) {
            return null;
        }
        UnsafeRefArrayAccess.spElement(eArr, jCalcElementOffset, null);
        soConsumerIndex(jLpConsumerIndex + 1);
        return e2;
    }

    @Override // java.util.AbstractCollection, java.util.Collection, io.netty.util.internal.shaded.org.jctools.queues.MessagePassingQueue
    public int size() {
        long jLvConsumerIndex = lvConsumerIndex();
        while (true) {
            long jLvProducerIndex = lvProducerIndex();
            long jLvConsumerIndex2 = lvConsumerIndex();
            if (jLvConsumerIndex == jLvConsumerIndex2) {
                return (int) (jLvProducerIndex - jLvConsumerIndex2);
            }
            jLvConsumerIndex = jLvConsumerIndex2;
        }
    }

    /* JADX WARN: Multi-variable type inference failed */
    @Override // io.netty.util.internal.shaded.org.jctools.queues.MessagePassingQueue
    public int drain(MessagePassingQueue.Consumer<E> consumer, int i2) {
        E[] eArr = this.buffer;
        long j2 = this.mask;
        long jLpConsumerIndex = lpConsumerIndex();
        for (int i3 = 0; i3 < i2; i3++) {
            long j3 = ((long) i3) + jLpConsumerIndex;
            long jCalcElementOffset = ConcurrentCircularArrayQueue.calcElementOffset(j3, j2);
            Object objLvElement = UnsafeRefArrayAccess.lvElement(eArr, jCalcElementOffset);
            if (objLvElement == null) {
                return i3;
            }
            UnsafeRefArrayAccess.soElement(eArr, jCalcElementOffset, null);
            soConsumerIndex(j3 + 1);
            consumer.accept(objLvElement);
        }
        return i2;
    }

    @Override // io.netty.util.internal.shaded.org.jctools.queues.MessagePassingQueue
    public int fill(MessagePassingQueue.Supplier<E> supplier, int i2) {
        long jLvProducerIndex;
        int i3;
        int iMin;
        long j2 = this.mask;
        long j3 = 1 + j2;
        long jLvProducerLimit = lvProducerLimit();
        do {
            jLvProducerIndex = lvProducerIndex();
            long j4 = jLvProducerLimit - jLvProducerIndex;
            if (j4 <= 0) {
                jLvProducerLimit = lvConsumerIndex() + j3;
                j4 = jLvProducerLimit - jLvProducerIndex;
                if (j4 <= 0) {
                    return 0;
                }
                soProducerLimit(jLvProducerLimit);
            }
            iMin = Math.min((int) j4, i2);
        } while (!casProducerIndex(jLvProducerIndex, ((long) iMin) + jLvProducerIndex));
        E[] eArr = this.buffer;
        for (i3 = 0; i3 < iMin; i3++) {
            UnsafeRefArrayAccess.soElement(eArr, ConcurrentCircularArrayQueue.calcElementOffset(((long) i3) + jLvProducerIndex, j2), supplier.get());
        }
        return iMin;
    }

    /* JADX WARN: Multi-variable type inference failed */
    @Override // io.netty.util.internal.shaded.org.jctools.queues.MessagePassingQueue
    public void drain(MessagePassingQueue.Consumer<E> consumer, MessagePassingQueue.WaitStrategy waitStrategy, MessagePassingQueue.ExitCondition exitCondition) {
        E[] eArr = this.buffer;
        long j2 = this.mask;
        long jLpConsumerIndex = lpConsumerIndex();
        int iIdle = 0;
        while (exitCondition.keepRunning()) {
            for (int i2 = 0; i2 < 4096; i2++) {
                long jCalcElementOffset = ConcurrentCircularArrayQueue.calcElementOffset(jLpConsumerIndex, j2);
                Object objLvElement = UnsafeRefArrayAccess.lvElement(eArr, jCalcElementOffset);
                if (objLvElement == null) {
                    iIdle = waitStrategy.idle(iIdle);
                } else {
                    jLpConsumerIndex++;
                    UnsafeRefArrayAccess.soElement(eArr, jCalcElementOffset, null);
                    soConsumerIndex(jLpConsumerIndex);
                    consumer.accept(objLvElement);
                    iIdle = 0;
                }
            }
        }
    }

    @Override // io.netty.util.internal.shaded.org.jctools.queues.MessagePassingQueue
    public void fill(MessagePassingQueue.Supplier<E> supplier, MessagePassingQueue.WaitStrategy waitStrategy, MessagePassingQueue.ExitCondition exitCondition) {
        while (true) {
            while (exitCondition.keepRunning()) {
                int iIdle = fill(supplier, MpmcArrayQueue.RECOMENDED_OFFER_BATCH) == 0 ? waitStrategy.idle(iIdle) : 0;
            }
            return;
        }
    }
}