package io.netty.util.collection;

import g.a.a.a.a;
import io.netty.util.collection.IntObjectMap;
import io.netty.util.internal.MathUtil;
import java.util.AbstractCollection;
import java.util.AbstractSet;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Set;
import kotlinx.serialization.json.internal.AbstractJsonLexerKt;

/* JADX INFO: loaded from: classes.dex */
public class IntObjectHashMap<V> implements IntObjectMap<V> {
    public static final /* synthetic */ boolean $assertionsDisabled = false;
    public static final int DEFAULT_CAPACITY = 8;
    public static final float DEFAULT_LOAD_FACTOR = 0.5f;
    private static final Object NULL_VALUE = new Object();
    private final Iterable<IntObjectMap.PrimitiveEntry<V>> entries;
    private final Set<Map.Entry<Integer, V>> entrySet;
    private final Set<Integer> keySet;
    private int[] keys;
    private final float loadFactor;
    private int mask;
    private int maxSize;
    private int size;
    private V[] values;

    public final class EntrySet extends AbstractSet<Map.Entry<Integer, V>> {
        private EntrySet() {
        }

        @Override // java.util.AbstractCollection, java.util.Collection, java.lang.Iterable, java.util.Set
        public Iterator<Map.Entry<Integer, V>> iterator() {
            return new MapIterator();
        }

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

    public final class KeySet extends AbstractSet<Integer> {
        private KeySet() {
        }

        @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
        public void clear() {
            IntObjectHashMap.this.clear();
        }

        @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
        public boolean contains(Object obj) {
            return IntObjectHashMap.this.containsKey(obj);
        }

        @Override // java.util.AbstractCollection, java.util.Collection, java.lang.Iterable, java.util.Set
        public Iterator<Integer> iterator() {
            return new Iterator<Integer>() { // from class: io.netty.util.collection.IntObjectHashMap.KeySet.1
                private final Iterator<Map.Entry<Integer, V>> iter;

                {
                    this.iter = IntObjectHashMap.this.entrySet.iterator();
                }

                @Override // java.util.Iterator
                public boolean hasNext() {
                    return this.iter.hasNext();
                }

                /* JADX WARN: Can't rename method to resolve collision */
                @Override // java.util.Iterator
                public Integer next() {
                    return this.iter.next().getKey();
                }

                @Override // java.util.Iterator
                public void remove() {
                    this.iter.remove();
                }
            };
        }

        @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
        public boolean remove(Object obj) {
            return IntObjectHashMap.this.remove(obj) != null;
        }

        @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
        public boolean retainAll(Collection<?> collection) {
            Iterator<IntObjectMap.PrimitiveEntry<V>> it = IntObjectHashMap.this.entries().iterator();
            boolean z2 = false;
            while (it.hasNext()) {
                if (!collection.contains(Integer.valueOf(it.next().key()))) {
                    z2 = true;
                    it.remove();
                }
            }
            return z2;
        }

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

    public final class MapEntry implements Map.Entry<Integer, V> {
        private final int entryIndex;

        public MapEntry(int i2) {
            this.entryIndex = i2;
        }

        private void verifyExists() {
            if (IntObjectHashMap.this.values[this.entryIndex] == null) {
                throw new IllegalStateException("The map entry has been removed");
            }
        }

        /* JADX WARN: Can't rename method to resolve collision */
        @Override // java.util.Map.Entry
        public Integer getKey() {
            verifyExists();
            return Integer.valueOf(IntObjectHashMap.this.keys[this.entryIndex]);
        }

        @Override // java.util.Map.Entry
        public V getValue() {
            verifyExists();
            return (V) IntObjectHashMap.toExternal(IntObjectHashMap.this.values[this.entryIndex]);
        }

        @Override // java.util.Map.Entry
        public V setValue(V v2) {
            verifyExists();
            V v3 = (V) IntObjectHashMap.toExternal(IntObjectHashMap.this.values[this.entryIndex]);
            IntObjectHashMap.this.values[this.entryIndex] = IntObjectHashMap.toInternal(v2);
            return v3;
        }
    }

    public final class MapIterator implements Iterator<Map.Entry<Integer, V>> {
        private final IntObjectHashMap<V>.PrimitiveIterator iter;

        private MapIterator() {
            this.iter = new PrimitiveIterator();
        }

        @Override // java.util.Iterator
        public boolean hasNext() {
            return this.iter.hasNext();
        }

        @Override // java.util.Iterator
        public Map.Entry<Integer, V> next() {
            if (!hasNext()) {
                throw new NoSuchElementException();
            }
            this.iter.next();
            return new MapEntry(((PrimitiveIterator) this.iter).entryIndex);
        }

        @Override // java.util.Iterator
        public void remove() {
            this.iter.remove();
        }
    }

    public final class PrimitiveIterator implements Iterator<IntObjectMap.PrimitiveEntry<V>>, IntObjectMap.PrimitiveEntry<V> {
        private int entryIndex;
        private int nextIndex;
        private int prevIndex;

        private PrimitiveIterator() {
            this.prevIndex = -1;
            this.nextIndex = -1;
            this.entryIndex = -1;
        }

        private void scanNext() {
            do {
                int i2 = this.nextIndex + 1;
                this.nextIndex = i2;
                if (i2 == IntObjectHashMap.this.values.length) {
                    return;
                }
            } while (IntObjectHashMap.this.values[this.nextIndex] == null);
        }

        @Override // java.util.Iterator
        public boolean hasNext() {
            if (this.nextIndex == -1) {
                scanNext();
            }
            return this.nextIndex != IntObjectHashMap.this.values.length;
        }

        @Override // io.netty.util.collection.IntObjectMap.PrimitiveEntry
        public int key() {
            return IntObjectHashMap.this.keys[this.entryIndex];
        }

        @Override // java.util.Iterator
        public IntObjectMap.PrimitiveEntry<V> next() {
            if (!hasNext()) {
                throw new NoSuchElementException();
            }
            this.prevIndex = this.nextIndex;
            scanNext();
            this.entryIndex = this.prevIndex;
            return this;
        }

        @Override // java.util.Iterator
        public void remove() {
            int i2 = this.prevIndex;
            if (i2 == -1) {
                throw new IllegalStateException("next must be called before each remove.");
            }
            if (IntObjectHashMap.this.removeAt(i2)) {
                this.nextIndex = this.prevIndex;
            }
            this.prevIndex = -1;
        }

        @Override // io.netty.util.collection.IntObjectMap.PrimitiveEntry
        public void setValue(V v2) {
            IntObjectHashMap.this.values[this.entryIndex] = IntObjectHashMap.toInternal(v2);
        }

        @Override // io.netty.util.collection.IntObjectMap.PrimitiveEntry
        public V value() {
            return (V) IntObjectHashMap.toExternal(IntObjectHashMap.this.values[this.entryIndex]);
        }
    }

    public IntObjectHashMap() {
        this(8, 0.5f);
    }

    public IntObjectHashMap(int i2) {
        this(i2, 0.5f);
    }

    public IntObjectHashMap(int i2, float f2) {
        this.keySet = new KeySet();
        this.entrySet = new EntrySet();
        this.entries = new Iterable<IntObjectMap.PrimitiveEntry<V>>() { // from class: io.netty.util.collection.IntObjectHashMap.1
            @Override // java.lang.Iterable
            public Iterator<IntObjectMap.PrimitiveEntry<V>> iterator() {
                return new PrimitiveIterator();
            }
        };
        if (f2 <= 0.0f || f2 > 1.0f) {
            throw new IllegalArgumentException("loadFactor must be > 0 and <= 1");
        }
        this.loadFactor = f2;
        int iSafeFindNextPositivePowerOfTwo = MathUtil.safeFindNextPositivePowerOfTwo(i2);
        this.mask = iSafeFindNextPositivePowerOfTwo - 1;
        this.keys = new int[iSafeFindNextPositivePowerOfTwo];
        this.values = (V[]) new Object[iSafeFindNextPositivePowerOfTwo];
        this.maxSize = calcMaxSize(iSafeFindNextPositivePowerOfTwo);
    }

    private int calcMaxSize(int i2) {
        return Math.min(i2 - 1, (int) (i2 * this.loadFactor));
    }

    private void growSize() {
        int i2 = this.size + 1;
        this.size = i2;
        if (i2 > this.maxSize) {
            int[] iArr = this.keys;
            if (iArr.length != Integer.MAX_VALUE) {
                rehash(iArr.length << 1);
            } else {
                StringBuilder sbF = a.F("Max capacity reached at size=");
                sbF.append(this.size);
                throw new IllegalStateException(sbF.toString());
            }
        }
    }

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

    private int hashIndex(int i2) {
        return hashCode(i2) & this.mask;
    }

    private int indexOf(int i2) {
        int iHashIndex = hashIndex(i2);
        int iProbeNext = iHashIndex;
        while (this.values[iProbeNext] != null) {
            if (i2 == this.keys[iProbeNext]) {
                return iProbeNext;
            }
            iProbeNext = probeNext(iProbeNext);
            if (iProbeNext == iHashIndex) {
                return -1;
            }
        }
        return -1;
    }

    private int objectToKey(Object obj) {
        return ((Integer) obj).intValue();
    }

    private int probeNext(int i2) {
        return (i2 + 1) & this.mask;
    }

    private void rehash(int i2) {
        V[] vArr;
        int[] iArr = this.keys;
        V[] vArr2 = this.values;
        this.keys = new int[i2];
        this.values = (V[]) new Object[i2];
        this.maxSize = calcMaxSize(i2);
        this.mask = i2 - 1;
        for (int i3 = 0; i3 < vArr2.length; i3++) {
            V v2 = vArr2[i3];
            if (v2 != null) {
                int i4 = iArr[i3];
                int iHashIndex = hashIndex(i4);
                while (true) {
                    vArr = this.values;
                    if (vArr[iHashIndex] == null) {
                        break;
                    } else {
                        iHashIndex = probeNext(iHashIndex);
                    }
                }
                this.keys[iHashIndex] = i4;
                vArr[iHashIndex] = v2;
            }
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public boolean removeAt(int i2) {
        this.size--;
        this.keys[i2] = 0;
        this.values[i2] = null;
        int iProbeNext = probeNext(i2);
        V v2 = this.values[iProbeNext];
        int i3 = i2;
        while (v2 != null) {
            int i4 = this.keys[iProbeNext];
            int iHashIndex = hashIndex(i4);
            if ((iProbeNext < iHashIndex && (iHashIndex <= i3 || i3 <= iProbeNext)) || (iHashIndex <= i3 && i3 <= iProbeNext)) {
                int[] iArr = this.keys;
                iArr[i3] = i4;
                V[] vArr = this.values;
                vArr[i3] = v2;
                iArr[iProbeNext] = 0;
                vArr[iProbeNext] = null;
                i3 = iProbeNext;
            }
            V[] vArr2 = this.values;
            iProbeNext = probeNext(iProbeNext);
            v2 = vArr2[iProbeNext];
        }
        return i3 != i2;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static <T> T toExternal(T t2) {
        if (t2 == NULL_VALUE) {
            return null;
        }
        return t2;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static <T> T toInternal(T t2) {
        return t2 == null ? (T) NULL_VALUE : t2;
    }

    @Override // java.util.Map
    public void clear() {
        Arrays.fill(this.keys, 0);
        Arrays.fill(this.values, (Object) null);
        this.size = 0;
    }

    @Override // io.netty.util.collection.IntObjectMap
    public boolean containsKey(int i2) {
        return indexOf(i2) >= 0;
    }

    @Override // java.util.Map
    public boolean containsKey(Object obj) {
        return containsKey(objectToKey(obj));
    }

    @Override // java.util.Map
    public boolean containsValue(Object obj) {
        Object internal = toInternal(obj);
        for (V v2 : this.values) {
            if (v2 != null && v2.equals(internal)) {
                return true;
            }
        }
        return false;
    }

    @Override // io.netty.util.collection.IntObjectMap
    public Iterable<IntObjectMap.PrimitiveEntry<V>> entries() {
        return this.entries;
    }

    @Override // java.util.Map
    public Set<Map.Entry<Integer, V>> entrySet() {
        return this.entrySet;
    }

    @Override // java.util.Map
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (!(obj instanceof IntObjectMap)) {
            return false;
        }
        IntObjectMap intObjectMap = (IntObjectMap) obj;
        if (this.size != intObjectMap.size()) {
            return false;
        }
        int i2 = 0;
        while (true) {
            V[] vArr = this.values;
            if (i2 >= vArr.length) {
                return true;
            }
            V v2 = vArr[i2];
            if (v2 != null) {
                Object obj2 = intObjectMap.get(this.keys[i2]);
                if (v2 == NULL_VALUE) {
                    if (obj2 != null) {
                        return false;
                    }
                } else if (!v2.equals(obj2)) {
                    return false;
                }
            }
            i2++;
        }
    }

    @Override // io.netty.util.collection.IntObjectMap
    public V get(int i2) {
        int iIndexOf = indexOf(i2);
        if (iIndexOf == -1) {
            return null;
        }
        return (V) toExternal(this.values[iIndexOf]);
    }

    @Override // java.util.Map
    public V get(Object obj) {
        return get(objectToKey(obj));
    }

    @Override // java.util.Map
    public int hashCode() {
        int iHashCode = this.size;
        for (int i2 : this.keys) {
            iHashCode ^= hashCode(i2);
        }
        return iHashCode;
    }

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

    @Override // java.util.Map
    public Set<Integer> keySet() {
        return this.keySet;
    }

    public String keyToString(int i2) {
        return Integer.toString(i2);
    }

    @Override // io.netty.util.collection.IntObjectMap
    public V put(int i2, V v2) {
        int iHashIndex = hashIndex(i2);
        int iProbeNext = iHashIndex;
        do {
            Object[] objArr = this.values;
            if (objArr[iProbeNext] == null) {
                this.keys[iProbeNext] = i2;
                objArr[iProbeNext] = toInternal(v2);
                growSize();
                return null;
            }
            if (this.keys[iProbeNext] == i2) {
                Object obj = objArr[iProbeNext];
                objArr[iProbeNext] = toInternal(v2);
                return (V) toExternal(obj);
            }
            iProbeNext = probeNext(iProbeNext);
        } while (iProbeNext != iHashIndex);
        throw new IllegalStateException("Unable to insert");
    }

    @Override // java.util.Map
    public V put(Integer num, V v2) {
        return put(objectToKey(num), v2);
    }

    @Override // java.util.Map
    public void putAll(Map<? extends Integer, ? extends V> map) {
        if (!(map instanceof IntObjectHashMap)) {
            for (Map.Entry<? extends Integer, ? extends V> entry : map.entrySet()) {
                put(entry.getKey(), (Object) entry.getValue());
            }
            return;
        }
        IntObjectHashMap intObjectHashMap = (IntObjectHashMap) map;
        int i2 = 0;
        while (true) {
            V[] vArr = intObjectHashMap.values;
            if (i2 >= vArr.length) {
                return;
            }
            V v2 = vArr[i2];
            if (v2 != null) {
                put(intObjectHashMap.keys[i2], v2);
            }
            i2++;
        }
    }

    @Override // io.netty.util.collection.IntObjectMap
    public V remove(int i2) {
        int iIndexOf = indexOf(i2);
        if (iIndexOf == -1) {
            return null;
        }
        V v2 = this.values[iIndexOf];
        removeAt(iIndexOf);
        return (V) toExternal(v2);
    }

    @Override // java.util.Map
    public V remove(Object obj) {
        return remove(objectToKey(obj));
    }

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

    public String toString() {
        if (isEmpty()) {
            return "{}";
        }
        StringBuilder sb = new StringBuilder(this.size * 4);
        sb.append(AbstractJsonLexerKt.BEGIN_OBJ);
        boolean z2 = true;
        int i2 = 0;
        while (true) {
            V[] vArr = this.values;
            if (i2 >= vArr.length) {
                sb.append(AbstractJsonLexerKt.END_OBJ);
                return sb.toString();
            }
            V v2 = vArr[i2];
            if (v2 != null) {
                if (!z2) {
                    sb.append(", ");
                }
                sb.append(keyToString(this.keys[i2]));
                sb.append('=');
                sb.append(v2 == this ? "(this Map)" : toExternal(v2));
                z2 = false;
            }
            i2++;
        }
    }

    @Override // java.util.Map
    public Collection<V> values() {
        return new AbstractCollection<V>() { // from class: io.netty.util.collection.IntObjectHashMap.2
            @Override // java.util.AbstractCollection, java.util.Collection, java.lang.Iterable
            public Iterator<V> iterator() {
                return new Iterator<V>() { // from class: io.netty.util.collection.IntObjectHashMap.2.1
                    public final IntObjectHashMap<V>.PrimitiveIterator iter;

                    {
                        this.iter = new PrimitiveIterator();
                    }

                    @Override // java.util.Iterator
                    public boolean hasNext() {
                        return this.iter.hasNext();
                    }

                    @Override // java.util.Iterator
                    public V next() {
                        return this.iter.next().value();
                    }

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

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