package io.netty.util.internal;

import io.netty.util.internal.PriorityQueueNode;
import java.util.AbstractQueue;
import java.util.Arrays;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.Queue;
import org.snmp4j.util.SnmpConfigurator;

/* JADX INFO: loaded from: classes.dex */
public final class PriorityQueue<T extends PriorityQueueNode<T>> extends AbstractQueue<T> implements Queue<T> {
    private static final PriorityQueueNode[] EMPTY_QUEUE = new PriorityQueueNode[0];
    private T[] queue;
    private int size;

    private final class PriorityQueueIterator implements Iterator<T> {
        private int index;

        private PriorityQueueIterator() {
        }

        @Override // java.util.Iterator
        public boolean hasNext() {
            return this.index < PriorityQueue.this.size;
        }

        @Override // java.util.Iterator
        public void remove() {
            throw new UnsupportedOperationException("remove");
        }

        @Override // java.util.Iterator
        public T next() {
            if (this.index >= PriorityQueue.this.size) {
                throw new NoSuchElementException();
            }
            PriorityQueueNode[] priorityQueueNodeArr = PriorityQueue.this.queue;
            int i2 = this.index;
            this.index = i2 + 1;
            return (T) priorityQueueNodeArr[i2];
        }
    }

    public PriorityQueue() {
        this(8);
    }

    private void bubbleDown(int i2, T t) {
        int i3 = this.size >>> 1;
        while (i2 < i3) {
            int i4 = (i2 << 1) + 1;
            T[] tArr = this.queue;
            T t2 = tArr[i4];
            int i5 = i4 + 1;
            if (i5 < this.size && t2.compareTo(tArr[i5]) > 0) {
                t2 = this.queue[i5];
                i4 = i5;
            }
            if (t.compareTo(t2) <= 0) {
                break;
            }
            this.queue[i2] = t2;
            t2.priorityQueueIndex(i2);
            i2 = i4;
        }
        this.queue[i2] = t;
        t.priorityQueueIndex(i2);
    }

    private void bubbleUp(int i2, T t) {
        while (i2 > 0) {
            int i3 = (i2 - 1) >>> 1;
            T t2 = this.queue[i3];
            if (t.compareTo(t2) >= 0) {
                break;
            }
            this.queue[i2] = t2;
            t2.priorityQueueIndex(i2);
            i2 = i3;
        }
        this.queue[i2] = t;
        t.priorityQueueIndex(i2);
    }

    @Override // java.util.AbstractQueue, java.util.AbstractCollection, java.util.Collection
    public void clear() {
        for (int i2 = 0; i2 < this.size; i2++) {
            T t = this.queue[i2];
            if (t != null) {
                t.priorityQueueIndex(-1);
                this.queue[i2] = null;
            }
        }
        this.size = 0;
    }

    @Override // java.util.AbstractCollection, java.util.Collection
    public boolean contains(Object obj) {
        PriorityQueueNode priorityQueueNode;
        int iPriorityQueueIndex;
        return (obj instanceof PriorityQueueNode) && (iPriorityQueueIndex = (priorityQueueNode = (PriorityQueueNode) obj).priorityQueueIndex()) >= 0 && iPriorityQueueIndex < this.size && priorityQueueNode.equals(this.queue[iPriorityQueueIndex]);
    }

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

    @Override // java.util.AbstractCollection, java.util.Collection, java.lang.Iterable
    public Iterator<T> iterator() {
        return new PriorityQueueIterator();
    }

    @Override // java.util.AbstractCollection, java.util.Collection
    public boolean remove(Object obj) {
        if (!contains(obj)) {
            return false;
        }
        PriorityQueueNode priorityQueueNode = (PriorityQueueNode) obj;
        int iPriorityQueueIndex = priorityQueueNode.priorityQueueIndex();
        priorityQueueNode.priorityQueueIndex(-1);
        int i2 = this.size - 1;
        this.size = i2;
        if (i2 == 0 || i2 == iPriorityQueueIndex) {
            this.queue[iPriorityQueueIndex] = null;
            return true;
        }
        T[] tArr = this.queue;
        T t = tArr[i2];
        tArr[iPriorityQueueIndex] = t;
        tArr[i2] = null;
        if (priorityQueueNode.compareTo(t) < 0) {
            bubbleDown(iPriorityQueueIndex, t);
        } else {
            bubbleUp(iPriorityQueueIndex, t);
        }
        return true;
    }

    @Override // java.util.AbstractCollection, java.util.Collection
    public int size() {
        return this.size;
    }

    @Override // java.util.AbstractCollection, java.util.Collection
    public Object[] toArray() {
        return Arrays.copyOf(this.queue, this.size);
    }

    public PriorityQueue(int i2) {
        this.queue = i2 != 0 ? (T[]) new PriorityQueueNode[i2] : (T[]) EMPTY_QUEUE;
    }

    @Override // java.util.Queue
    public boolean offer(T t) {
        ObjectUtil.checkNotNull(t, SnmpConfigurator.O_AUTHORITATIVE_ENGINE_ID);
        if (t.priorityQueueIndex() != -1) {
            throw new IllegalArgumentException("e.priorityQueueIndex(): " + t.priorityQueueIndex() + " (expected: -1)");
        }
        int i2 = this.size;
        T[] tArr = this.queue;
        if (i2 >= tArr.length) {
            this.queue = (T[]) ((PriorityQueueNode[]) Arrays.copyOf(tArr, tArr.length + (tArr.length < 64 ? tArr.length + 2 : tArr.length >>> 1)));
        }
        int i3 = this.size;
        this.size = i3 + 1;
        bubbleUp(i3, t);
        return true;
    }

    @Override // java.util.Queue
    public T peek() {
        if (this.size == 0) {
            return null;
        }
        return this.queue[0];
    }

    @Override // java.util.Queue
    public T poll() {
        if (this.size == 0) {
            return null;
        }
        T t = this.queue[0];
        t.priorityQueueIndex(-1);
        T[] tArr = this.queue;
        int i2 = this.size - 1;
        this.size = i2;
        T t2 = tArr[i2];
        tArr[i2] = null;
        if (i2 != 0) {
            bubbleDown(0, t2);
        }
        return t;
    }

    @Override // java.util.AbstractCollection, java.util.Collection
    public <X> X[] toArray(X[] xArr) {
        int length = xArr.length;
        int i2 = this.size;
        if (length < i2) {
            return (X[]) Arrays.copyOf(this.queue, i2, xArr.getClass());
        }
        System.arraycopy(this.queue, 0, xArr, 0, i2);
        int length2 = xArr.length;
        int i3 = this.size;
        if (length2 > i3) {
            xArr[i3] = null;
        }
        return xArr;
    }
}