package io.netty.util.internal;

import g.a.a.a.a;
import io.netty.util.internal.PriorityQueueNode;
import java.util.AbstractQueue;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Iterator;
import java.util.NoSuchElementException;

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

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

        private PriorityQueueIterator() {
        }

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

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

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

    public DefaultPriorityQueue(Comparator<T> comparator, int i2) {
        this.comparator = (Comparator) ObjectUtil.checkNotNull(comparator, "comparator");
        this.queue = i2 != 0 ? (T[]) new PriorityQueueNode[i2] : (T[]) EMPTY_ARRAY;
    }

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

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

    private boolean contains(PriorityQueueNode priorityQueueNode, int i2) {
        return i2 >= 0 && i2 < this.size && priorityQueueNode.equals(this.queue[i2]);
    }

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

    @Override // io.netty.util.internal.PriorityQueue
    public void clearIgnoringIndexes() {
        this.size = 0;
    }

    @Override // java.util.AbstractCollection, java.util.Collection
    public boolean contains(Object obj) {
        if (!(obj instanceof PriorityQueueNode)) {
            return false;
        }
        PriorityQueueNode priorityQueueNode = (PriorityQueueNode) obj;
        return contains(priorityQueueNode, priorityQueueNode.priorityQueueIndex(this));
    }

    @Override // io.netty.util.internal.PriorityQueue
    public boolean containsTyped(T t2) {
        return contains(t2, t2.priorityQueueIndex(this));
    }

    @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.Queue
    public boolean offer(T t2) {
        if (t2.priorityQueueIndex(this) != -1) {
            StringBuilder sbF = a.F("e.priorityQueueIndex(): ");
            sbF.append(t2.priorityQueueIndex(this));
            sbF.append(" (expected: ");
            sbF.append(-1);
            sbF.append(") + e: ");
            sbF.append(t2);
            throw new IllegalArgumentException(sbF.toString());
        }
        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, t2);
        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 t2 = this.queue[0];
        t2.priorityQueueIndex(this, -1);
        T[] tArr = this.queue;
        int i2 = this.size - 1;
        this.size = i2;
        T t3 = tArr[i2];
        tArr[i2] = null;
        if (i2 != 0) {
            bubbleDown(0, t3);
        }
        return t2;
    }

    @Override // io.netty.util.internal.PriorityQueue
    public void priorityChanged(T t2) {
        int iPriorityQueueIndex = t2.priorityQueueIndex(this);
        if (contains(t2, iPriorityQueueIndex)) {
            if (iPriorityQueueIndex != 0) {
                if (this.comparator.compare(t2, this.queue[(iPriorityQueueIndex - 1) >>> 1]) < 0) {
                    bubbleUp(iPriorityQueueIndex, t2);
                    return;
                }
            }
            bubbleDown(iPriorityQueueIndex, t2);
        }
    }

    @Override // java.util.AbstractCollection, java.util.Collection
    public boolean remove(Object obj) {
        try {
            return removeTyped((PriorityQueueNode) obj);
        } catch (ClassCastException unused) {
            return false;
        }
    }

    @Override // io.netty.util.internal.PriorityQueue
    public boolean removeTyped(T t2) {
        int iPriorityQueueIndex = t2.priorityQueueIndex(this);
        if (!contains(t2, iPriorityQueueIndex)) {
            return false;
        }
        t2.priorityQueueIndex(this, -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 t3 = tArr[i2];
        tArr[iPriorityQueueIndex] = t3;
        tArr[i2] = null;
        if (this.comparator.compare(t2, t3) < 0) {
            bubbleDown(iPriorityQueueIndex, t3);
        } else {
            bubbleUp(iPriorityQueueIndex, t3);
        }
        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);
    }

    @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;
    }
}