package io.netty.handler.codec;

import io.netty.handler.codec.Headers;
import io.netty.util.HashingStrategy;
import io.netty.util.internal.MathUtil;
import io.netty.util.internal.ObjectUtil;
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Set;

/* JADX INFO: loaded from: classes.dex */
public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers<K, V, T> {
    public static final int HASH_CODE_SEED = -1028477387;
    private final HeaderEntry<K, V>[] entries;
    private final byte hashMask;
    private final HashingStrategy<K> hashingStrategy;
    public final HeaderEntry<K, V> head;
    private final NameValidator<K> nameValidator;
    public int size;
    private final ValueConverter<V> valueConverter;

    public static class HeaderEntry<K, V> implements Map.Entry<K, V> {
        public HeaderEntry<K, V> after;
        public HeaderEntry<K, V> before;
        public final int hash;
        public final K key;
        public HeaderEntry<K, V> next;
        public V value;

        public HeaderEntry() {
            this.hash = -1;
            this.key = null;
            this.after = this;
            this.before = this;
        }

        public HeaderEntry(int i2, K k2) {
            this.hash = i2;
            this.key = k2;
        }

        public HeaderEntry(int i2, K k2, V v2, HeaderEntry<K, V> headerEntry, HeaderEntry<K, V> headerEntry2) {
            this.hash = i2;
            this.key = k2;
            this.value = v2;
            this.next = headerEntry;
            this.after = headerEntry2;
            this.before = headerEntry2.before;
            pointNeighborsToThis();
        }

        public final HeaderEntry<K, V> after() {
            return this.after;
        }

        public final HeaderEntry<K, V> before() {
            return this.before;
        }

        @Override // java.util.Map.Entry
        public boolean equals(Object obj) {
            if (!(obj instanceof Map.Entry)) {
                return false;
            }
            Map.Entry entry = (Map.Entry) obj;
            if (getKey() == null) {
                if (entry.getKey() != null) {
                    return false;
                }
            } else if (!getKey().equals(entry.getKey())) {
                return false;
            }
            if (getValue() == null) {
                if (entry.getValue() != null) {
                    return false;
                }
            } else if (!getValue().equals(entry.getValue())) {
                return false;
            }
            return true;
        }

        @Override // java.util.Map.Entry
        public final K getKey() {
            return this.key;
        }

        @Override // java.util.Map.Entry
        public final V getValue() {
            return this.value;
        }

        @Override // java.util.Map.Entry
        public int hashCode() {
            K k2 = this.key;
            int iHashCode = k2 == null ? 0 : k2.hashCode();
            V v2 = this.value;
            return iHashCode ^ (v2 != null ? v2.hashCode() : 0);
        }

        public final void pointNeighborsToThis() {
            this.before.after = this;
            this.after.before = this;
        }

        public void remove() {
            HeaderEntry<K, V> headerEntry = this.before;
            headerEntry.after = this.after;
            this.after.before = headerEntry;
        }

        @Override // java.util.Map.Entry
        public final V setValue(V v2) {
            ObjectUtil.checkNotNull(v2, "value");
            V v3 = this.value;
            this.value = v2;
            return v3;
        }

        public final String toString() {
            return this.key.toString() + '=' + this.value.toString();
        }
    }

    public final class HeaderIterator implements Iterator<Map.Entry<K, V>> {
        private HeaderEntry<K, V> current;

        private HeaderIterator() {
            this.current = DefaultHeaders.this.head;
        }

        @Override // java.util.Iterator
        public boolean hasNext() {
            return this.current.after != DefaultHeaders.this.head;
        }

        @Override // java.util.Iterator
        public Map.Entry<K, V> next() {
            HeaderEntry<K, V> headerEntry = this.current.after;
            this.current = headerEntry;
            if (headerEntry != DefaultHeaders.this.head) {
                return headerEntry;
            }
            throw new NoSuchElementException();
        }

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

    public interface NameValidator<K> {
        public static final NameValidator NOT_NULL = new NameValidator() { // from class: io.netty.handler.codec.DefaultHeaders.NameValidator.1
            @Override // io.netty.handler.codec.DefaultHeaders.NameValidator
            public void validateName(Object obj) {
                ObjectUtil.checkNotNull(obj, "name");
            }
        };

        void validateName(K k2);
    }

    public final class ValueIterator implements Iterator<V> {
        private final int hash;
        private final K name;
        private HeaderEntry<K, V> next;

        public ValueIterator(K k2) {
            this.name = (K) ObjectUtil.checkNotNull(k2, "name");
            int iHashCode = DefaultHeaders.this.hashingStrategy.hashCode(k2);
            this.hash = iHashCode;
            calculateNext(DefaultHeaders.this.entries[DefaultHeaders.this.index(iHashCode)]);
        }

        private void calculateNext(HeaderEntry<K, V> headerEntry) {
            while (headerEntry != null) {
                if (headerEntry.hash == this.hash && DefaultHeaders.this.hashingStrategy.equals(this.name, headerEntry.key)) {
                    this.next = headerEntry;
                    return;
                }
                headerEntry = headerEntry.next;
            }
            this.next = null;
        }

        @Override // java.util.Iterator
        public boolean hasNext() {
            return this.next != null;
        }

        @Override // java.util.Iterator
        public V next() {
            if (!hasNext()) {
                throw new NoSuchElementException();
            }
            HeaderEntry<K, V> headerEntry = this.next;
            calculateNext(headerEntry.next);
            return headerEntry.value;
        }

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

    public DefaultHeaders(ValueConverter<V> valueConverter) {
        this(HashingStrategy.JAVA_HASHER, valueConverter);
    }

    public DefaultHeaders(ValueConverter<V> valueConverter, NameValidator<K> nameValidator) {
        this(HashingStrategy.JAVA_HASHER, valueConverter, nameValidator);
    }

    public DefaultHeaders(HashingStrategy<K> hashingStrategy, ValueConverter<V> valueConverter) {
        this(hashingStrategy, valueConverter, NameValidator.NOT_NULL);
    }

    public DefaultHeaders(HashingStrategy<K> hashingStrategy, ValueConverter<V> valueConverter, NameValidator<K> nameValidator) {
        this(hashingStrategy, valueConverter, nameValidator, 16);
    }

    public DefaultHeaders(HashingStrategy<K> hashingStrategy, ValueConverter<V> valueConverter, NameValidator<K> nameValidator, int i2) {
        this.valueConverter = (ValueConverter) ObjectUtil.checkNotNull(valueConverter, "valueConverter");
        this.nameValidator = (NameValidator) ObjectUtil.checkNotNull(nameValidator, "nameValidator");
        this.hashingStrategy = (HashingStrategy) ObjectUtil.checkNotNull(hashingStrategy, "nameHashingStrategy");
        this.entries = new HeaderEntry[MathUtil.findNextPositivePowerOfTwo(Math.max(2, Math.min(i2, 128)))];
        this.hashMask = (byte) (r2.length - 1);
        this.head = new HeaderEntry<>();
    }

    private void add0(int i2, int i3, K k2, V v2) {
        HeaderEntry<K, V>[] headerEntryArr = this.entries;
        headerEntryArr[i3] = newHeaderEntry(i2, k2, v2, headerEntryArr[i3]);
        this.size++;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public int index(int i2) {
        return i2 & this.hashMask;
    }

    private V remove0(int i2, int i3, K k2) {
        HeaderEntry<K, V> headerEntry = this.entries[i3];
        V v2 = null;
        if (headerEntry == null) {
            return null;
        }
        while (true) {
            HeaderEntry<K, V> headerEntry2 = headerEntry.next;
            if (headerEntry2 == null) {
                break;
            }
            if (headerEntry2.hash == i2 && this.hashingStrategy.equals(k2, headerEntry2.key)) {
                v2 = headerEntry2.value;
                headerEntry.next = headerEntry2.next;
                headerEntry2.remove();
                this.size--;
            } else {
                headerEntry = headerEntry2;
            }
        }
        HeaderEntry<K, V> headerEntry3 = this.entries[i3];
        if (headerEntry3.hash == i2 && this.hashingStrategy.equals(k2, headerEntry3.key)) {
            if (v2 == null) {
                v2 = headerEntry3.value;
            }
            this.entries[i3] = headerEntry3.next;
            headerEntry3.remove();
            this.size--;
        }
        return v2;
    }

    private T thisT() {
        return this;
    }

    @Override // io.netty.handler.codec.Headers
    public T add(Headers<? extends K, ? extends V, ?> headers) {
        if (headers == this) {
            throw new IllegalArgumentException("can't add to itself.");
        }
        addImpl(headers);
        return (T) thisT();
    }

    @Override // io.netty.handler.codec.Headers
    public T add(K k2, Iterable<? extends V> iterable) {
        this.nameValidator.validateName(k2);
        int iHashCode = this.hashingStrategy.hashCode(k2);
        int iIndex = index(iHashCode);
        Iterator<? extends V> it = iterable.iterator();
        while (it.hasNext()) {
            add0(iHashCode, iIndex, k2, it.next());
        }
        return (T) thisT();
    }

    @Override // io.netty.handler.codec.Headers
    public T add(K k2, V v2) {
        this.nameValidator.validateName(k2);
        ObjectUtil.checkNotNull(v2, "value");
        int iHashCode = this.hashingStrategy.hashCode(k2);
        add0(iHashCode, index(iHashCode), k2, v2);
        return (T) thisT();
    }

    @Override // io.netty.handler.codec.Headers
    public T add(K k2, V... vArr) {
        this.nameValidator.validateName(k2);
        int iHashCode = this.hashingStrategy.hashCode(k2);
        int iIndex = index(iHashCode);
        for (V v2 : vArr) {
            add0(iHashCode, iIndex, k2, v2);
        }
        return (T) thisT();
    }

    @Override // io.netty.handler.codec.Headers
    public T addBoolean(K k2, boolean z2) {
        return (T) add(k2, this.valueConverter.convertBoolean(z2));
    }

    @Override // io.netty.handler.codec.Headers
    public T addByte(K k2, byte b2) {
        return (T) add(k2, this.valueConverter.convertByte(b2));
    }

    @Override // io.netty.handler.codec.Headers
    public T addChar(K k2, char c2) {
        return (T) add(k2, this.valueConverter.convertChar(c2));
    }

    @Override // io.netty.handler.codec.Headers
    public T addDouble(K k2, double d2) {
        return (T) add(k2, this.valueConverter.convertDouble(d2));
    }

    @Override // io.netty.handler.codec.Headers
    public T addFloat(K k2, float f2) {
        return (T) add(k2, this.valueConverter.convertFloat(f2));
    }

    public void addImpl(Headers<? extends K, ? extends V, ?> headers) {
        if (!(headers instanceof DefaultHeaders)) {
            for (Map.Entry<? extends K, ? extends V> entry : headers) {
                add(entry.getKey(), entry.getValue());
            }
            return;
        }
        DefaultHeaders defaultHeaders = (DefaultHeaders) headers;
        HeaderEntry<K, V> headerEntry = defaultHeaders.head.after;
        if (defaultHeaders.hashingStrategy == this.hashingStrategy && defaultHeaders.nameValidator == this.nameValidator) {
            while (headerEntry != defaultHeaders.head) {
                int i2 = headerEntry.hash;
                add0(i2, index(i2), headerEntry.key, headerEntry.value);
                headerEntry = headerEntry.after;
            }
        } else {
            while (headerEntry != defaultHeaders.head) {
                add(headerEntry.key, headerEntry.value);
                headerEntry = headerEntry.after;
            }
        }
    }

    @Override // io.netty.handler.codec.Headers
    public T addInt(K k2, int i2) {
        return (T) add(k2, this.valueConverter.convertInt(i2));
    }

    @Override // io.netty.handler.codec.Headers
    public T addLong(K k2, long j2) {
        return (T) add(k2, this.valueConverter.convertLong(j2));
    }

    @Override // io.netty.handler.codec.Headers
    public T addObject(K k2, Iterable<?> iterable) {
        Iterator<?> it = iterable.iterator();
        while (it.hasNext()) {
            addObject(k2, it.next());
        }
        return (T) thisT();
    }

    @Override // io.netty.handler.codec.Headers
    public T addObject(K k2, Object obj) {
        return (T) add(k2, this.valueConverter.convertObject(ObjectUtil.checkNotNull(obj, "value")));
    }

    @Override // io.netty.handler.codec.Headers
    public T addObject(K k2, Object... objArr) {
        for (Object obj : objArr) {
            addObject(k2, obj);
        }
        return (T) thisT();
    }

    @Override // io.netty.handler.codec.Headers
    public T addShort(K k2, short s2) {
        return (T) add(k2, this.valueConverter.convertShort(s2));
    }

    @Override // io.netty.handler.codec.Headers
    public T addTimeMillis(K k2, long j2) {
        return (T) add(k2, this.valueConverter.convertTimeMillis(j2));
    }

    @Override // io.netty.handler.codec.Headers
    public T clear() {
        Arrays.fill(this.entries, (Object) null);
        HeaderEntry<K, V> headerEntry = this.head;
        headerEntry.after = headerEntry;
        headerEntry.before = headerEntry;
        this.size = 0;
        return (T) thisT();
    }

    @Override // io.netty.handler.codec.Headers
    public boolean contains(K k2) {
        return get(k2) != null;
    }

    @Override // io.netty.handler.codec.Headers
    public boolean contains(K k2, V v2) {
        return contains(k2, v2, HashingStrategy.JAVA_HASHER);
    }

    public final boolean contains(K k2, V v2, HashingStrategy<? super V> hashingStrategy) {
        ObjectUtil.checkNotNull(k2, "name");
        int iHashCode = this.hashingStrategy.hashCode(k2);
        for (HeaderEntry<K, V> headerEntry = this.entries[index(iHashCode)]; headerEntry != null; headerEntry = headerEntry.next) {
            if (headerEntry.hash == iHashCode && this.hashingStrategy.equals(k2, headerEntry.key) && hashingStrategy.equals(v2, headerEntry.value)) {
                return true;
            }
        }
        return false;
    }

    @Override // io.netty.handler.codec.Headers
    public boolean containsBoolean(K k2, boolean z2) {
        return contains(k2, this.valueConverter.convertBoolean(z2));
    }

    @Override // io.netty.handler.codec.Headers
    public boolean containsByte(K k2, byte b2) {
        return contains(k2, this.valueConverter.convertByte(b2));
    }

    @Override // io.netty.handler.codec.Headers
    public boolean containsChar(K k2, char c2) {
        return contains(k2, this.valueConverter.convertChar(c2));
    }

    @Override // io.netty.handler.codec.Headers
    public boolean containsDouble(K k2, double d2) {
        return contains(k2, this.valueConverter.convertDouble(d2));
    }

    @Override // io.netty.handler.codec.Headers
    public boolean containsFloat(K k2, float f2) {
        return contains(k2, this.valueConverter.convertFloat(f2));
    }

    @Override // io.netty.handler.codec.Headers
    public boolean containsInt(K k2, int i2) {
        return contains(k2, this.valueConverter.convertInt(i2));
    }

    @Override // io.netty.handler.codec.Headers
    public boolean containsLong(K k2, long j2) {
        return contains(k2, this.valueConverter.convertLong(j2));
    }

    @Override // io.netty.handler.codec.Headers
    public boolean containsObject(K k2, Object obj) {
        return contains(k2, this.valueConverter.convertObject(ObjectUtil.checkNotNull(obj, "value")));
    }

    @Override // io.netty.handler.codec.Headers
    public boolean containsShort(K k2, short s2) {
        return contains(k2, this.valueConverter.convertShort(s2));
    }

    @Override // io.netty.handler.codec.Headers
    public boolean containsTimeMillis(K k2, long j2) {
        return contains(k2, this.valueConverter.convertTimeMillis(j2));
    }

    public DefaultHeaders<K, V, T> copy() {
        DefaultHeaders<K, V, T> defaultHeaders = new DefaultHeaders<>(this.hashingStrategy, this.valueConverter, this.nameValidator, this.entries.length);
        defaultHeaders.addImpl(this);
        return defaultHeaders;
    }

    public final boolean equals(Headers<K, V, ?> headers, HashingStrategy<V> hashingStrategy) {
        if (headers.size() != size()) {
            return false;
        }
        if (this == headers) {
            return true;
        }
        for (K k2 : names()) {
            List<V> all = headers.getAll(k2);
            List<V> all2 = getAll(k2);
            if (all.size() != all2.size()) {
                return false;
            }
            for (int i2 = 0; i2 < all.size(); i2++) {
                if (!hashingStrategy.equals(all.get(i2), all2.get(i2))) {
                    return false;
                }
            }
        }
        return true;
    }

    public boolean equals(Object obj) {
        if (obj instanceof Headers) {
            return equals((Headers) obj, HashingStrategy.JAVA_HASHER);
        }
        return false;
    }

    @Override // io.netty.handler.codec.Headers
    public V get(K k2) {
        ObjectUtil.checkNotNull(k2, "name");
        int iHashCode = this.hashingStrategy.hashCode(k2);
        V v2 = null;
        for (HeaderEntry<K, V> headerEntry = this.entries[index(iHashCode)]; headerEntry != null; headerEntry = headerEntry.next) {
            if (headerEntry.hash == iHashCode && this.hashingStrategy.equals(k2, headerEntry.key)) {
                v2 = headerEntry.value;
            }
        }
        return v2;
    }

    @Override // io.netty.handler.codec.Headers
    public V get(K k2, V v2) {
        V v3 = get(k2);
        return v3 == null ? v2 : v3;
    }

    @Override // io.netty.handler.codec.Headers
    public List<V> getAll(K k2) {
        ObjectUtil.checkNotNull(k2, "name");
        LinkedList linkedList = new LinkedList();
        int iHashCode = this.hashingStrategy.hashCode(k2);
        for (HeaderEntry<K, V> headerEntry = this.entries[index(iHashCode)]; headerEntry != null; headerEntry = headerEntry.next) {
            if (headerEntry.hash == iHashCode && this.hashingStrategy.equals(k2, headerEntry.key)) {
                linkedList.addFirst(headerEntry.getValue());
            }
        }
        return linkedList;
    }

    @Override // io.netty.handler.codec.Headers
    public List<V> getAllAndRemove(K k2) {
        List<V> all = getAll(k2);
        remove(k2);
        return all;
    }

    /* JADX WARN: Multi-variable type inference failed */
    @Override // io.netty.handler.codec.Headers
    public V getAndRemove(K k2) {
        int iHashCode = this.hashingStrategy.hashCode(k2);
        return (V) remove0(iHashCode, index(iHashCode), ObjectUtil.checkNotNull(k2, "name"));
    }

    @Override // io.netty.handler.codec.Headers
    public V getAndRemove(K k2, V v2) {
        V andRemove = getAndRemove(k2);
        return andRemove == null ? v2 : andRemove;
    }

    @Override // io.netty.handler.codec.Headers
    public Boolean getBoolean(K k2) {
        V v2 = get(k2);
        if (v2 == null) {
            return null;
        }
        try {
            return Boolean.valueOf(this.valueConverter.convertToBoolean(v2));
        } catch (RuntimeException unused) {
            return null;
        }
    }

    @Override // io.netty.handler.codec.Headers
    public boolean getBoolean(K k2, boolean z2) {
        Boolean bool = getBoolean(k2);
        return bool != null ? bool.booleanValue() : z2;
    }

    @Override // io.netty.handler.codec.Headers
    public Boolean getBooleanAndRemove(K k2) {
        V andRemove = getAndRemove(k2);
        if (andRemove == null) {
            return null;
        }
        try {
            return Boolean.valueOf(this.valueConverter.convertToBoolean(andRemove));
        } catch (RuntimeException unused) {
            return null;
        }
    }

    @Override // io.netty.handler.codec.Headers
    public boolean getBooleanAndRemove(K k2, boolean z2) {
        Boolean booleanAndRemove = getBooleanAndRemove(k2);
        return booleanAndRemove != null ? booleanAndRemove.booleanValue() : z2;
    }

    @Override // io.netty.handler.codec.Headers
    public byte getByte(K k2, byte b2) {
        Byte b3 = getByte(k2);
        return b3 != null ? b3.byteValue() : b2;
    }

    @Override // io.netty.handler.codec.Headers
    public Byte getByte(K k2) {
        V v2 = get(k2);
        if (v2 == null) {
            return null;
        }
        try {
            return Byte.valueOf(this.valueConverter.convertToByte(v2));
        } catch (RuntimeException unused) {
            return null;
        }
    }

    @Override // io.netty.handler.codec.Headers
    public byte getByteAndRemove(K k2, byte b2) {
        Byte byteAndRemove = getByteAndRemove(k2);
        return byteAndRemove != null ? byteAndRemove.byteValue() : b2;
    }

    @Override // io.netty.handler.codec.Headers
    public Byte getByteAndRemove(K k2) {
        V andRemove = getAndRemove(k2);
        if (andRemove == null) {
            return null;
        }
        try {
            return Byte.valueOf(this.valueConverter.convertToByte(andRemove));
        } catch (RuntimeException unused) {
            return null;
        }
    }

    @Override // io.netty.handler.codec.Headers
    public char getChar(K k2, char c2) {
        Character ch = getChar(k2);
        return ch != null ? ch.charValue() : c2;
    }

    @Override // io.netty.handler.codec.Headers
    public Character getChar(K k2) {
        V v2 = get(k2);
        if (v2 == null) {
            return null;
        }
        try {
            return Character.valueOf(this.valueConverter.convertToChar(v2));
        } catch (RuntimeException unused) {
            return null;
        }
    }

    @Override // io.netty.handler.codec.Headers
    public char getCharAndRemove(K k2, char c2) {
        Character charAndRemove = getCharAndRemove(k2);
        return charAndRemove != null ? charAndRemove.charValue() : c2;
    }

    @Override // io.netty.handler.codec.Headers
    public Character getCharAndRemove(K k2) {
        V andRemove = getAndRemove(k2);
        if (andRemove == null) {
            return null;
        }
        try {
            return Character.valueOf(this.valueConverter.convertToChar(andRemove));
        } catch (RuntimeException unused) {
            return null;
        }
    }

    @Override // io.netty.handler.codec.Headers
    public double getDouble(K k2, double d2) {
        Double d3 = getDouble(k2);
        return d3 != null ? d3.doubleValue() : d2;
    }

    @Override // io.netty.handler.codec.Headers
    public Double getDouble(K k2) {
        V v2 = get(k2);
        if (v2 == null) {
            return null;
        }
        try {
            return Double.valueOf(this.valueConverter.convertToDouble(v2));
        } catch (RuntimeException unused) {
            return null;
        }
    }

    @Override // io.netty.handler.codec.Headers
    public double getDoubleAndRemove(K k2, double d2) {
        Double doubleAndRemove = getDoubleAndRemove(k2);
        return doubleAndRemove != null ? doubleAndRemove.doubleValue() : d2;
    }

    @Override // io.netty.handler.codec.Headers
    public Double getDoubleAndRemove(K k2) {
        V andRemove = getAndRemove(k2);
        if (andRemove == null) {
            return null;
        }
        try {
            return Double.valueOf(this.valueConverter.convertToDouble(andRemove));
        } catch (RuntimeException unused) {
            return null;
        }
    }

    @Override // io.netty.handler.codec.Headers
    public float getFloat(K k2, float f2) {
        Float f3 = getFloat(k2);
        return f3 != null ? f3.floatValue() : f2;
    }

    @Override // io.netty.handler.codec.Headers
    public Float getFloat(K k2) {
        V v2 = get(k2);
        if (v2 == null) {
            return null;
        }
        try {
            return Float.valueOf(this.valueConverter.convertToFloat(v2));
        } catch (RuntimeException unused) {
            return null;
        }
    }

    @Override // io.netty.handler.codec.Headers
    public float getFloatAndRemove(K k2, float f2) {
        Float floatAndRemove = getFloatAndRemove(k2);
        return floatAndRemove != null ? floatAndRemove.floatValue() : f2;
    }

    @Override // io.netty.handler.codec.Headers
    public Float getFloatAndRemove(K k2) {
        V andRemove = getAndRemove(k2);
        if (andRemove == null) {
            return null;
        }
        try {
            return Float.valueOf(this.valueConverter.convertToFloat(andRemove));
        } catch (RuntimeException unused) {
            return null;
        }
    }

    @Override // io.netty.handler.codec.Headers
    public int getInt(K k2, int i2) {
        Integer num = getInt(k2);
        return num != null ? num.intValue() : i2;
    }

    @Override // io.netty.handler.codec.Headers
    public Integer getInt(K k2) {
        V v2 = get(k2);
        if (v2 == null) {
            return null;
        }
        try {
            return Integer.valueOf(this.valueConverter.convertToInt(v2));
        } catch (RuntimeException unused) {
            return null;
        }
    }

    @Override // io.netty.handler.codec.Headers
    public int getIntAndRemove(K k2, int i2) {
        Integer intAndRemove = getIntAndRemove(k2);
        return intAndRemove != null ? intAndRemove.intValue() : i2;
    }

    @Override // io.netty.handler.codec.Headers
    public Integer getIntAndRemove(K k2) {
        V andRemove = getAndRemove(k2);
        if (andRemove == null) {
            return null;
        }
        try {
            return Integer.valueOf(this.valueConverter.convertToInt(andRemove));
        } catch (RuntimeException unused) {
            return null;
        }
    }

    @Override // io.netty.handler.codec.Headers
    public long getLong(K k2, long j2) {
        Long l2 = getLong(k2);
        return l2 != null ? l2.longValue() : j2;
    }

    @Override // io.netty.handler.codec.Headers
    public Long getLong(K k2) {
        V v2 = get(k2);
        if (v2 == null) {
            return null;
        }
        try {
            return Long.valueOf(this.valueConverter.convertToLong(v2));
        } catch (RuntimeException unused) {
            return null;
        }
    }

    @Override // io.netty.handler.codec.Headers
    public long getLongAndRemove(K k2, long j2) {
        Long longAndRemove = getLongAndRemove(k2);
        return longAndRemove != null ? longAndRemove.longValue() : j2;
    }

    @Override // io.netty.handler.codec.Headers
    public Long getLongAndRemove(K k2) {
        V andRemove = getAndRemove(k2);
        if (andRemove == null) {
            return null;
        }
        try {
            return Long.valueOf(this.valueConverter.convertToLong(andRemove));
        } catch (RuntimeException unused) {
            return null;
        }
    }

    @Override // io.netty.handler.codec.Headers
    public Short getShort(K k2) {
        V v2 = get(k2);
        if (v2 == null) {
            return null;
        }
        try {
            return Short.valueOf(this.valueConverter.convertToShort(v2));
        } catch (RuntimeException unused) {
            return null;
        }
    }

    @Override // io.netty.handler.codec.Headers
    public short getShort(K k2, short s2) {
        Short sh = getShort(k2);
        return sh != null ? sh.shortValue() : s2;
    }

    @Override // io.netty.handler.codec.Headers
    public Short getShortAndRemove(K k2) {
        V andRemove = getAndRemove(k2);
        if (andRemove == null) {
            return null;
        }
        try {
            return Short.valueOf(this.valueConverter.convertToShort(andRemove));
        } catch (RuntimeException unused) {
            return null;
        }
    }

    @Override // io.netty.handler.codec.Headers
    public short getShortAndRemove(K k2, short s2) {
        Short shortAndRemove = getShortAndRemove(k2);
        return shortAndRemove != null ? shortAndRemove.shortValue() : s2;
    }

    @Override // io.netty.handler.codec.Headers
    public long getTimeMillis(K k2, long j2) {
        Long timeMillis = getTimeMillis(k2);
        return timeMillis != null ? timeMillis.longValue() : j2;
    }

    @Override // io.netty.handler.codec.Headers
    public Long getTimeMillis(K k2) {
        V v2 = get(k2);
        if (v2 == null) {
            return null;
        }
        try {
            return Long.valueOf(this.valueConverter.convertToTimeMillis(v2));
        } catch (RuntimeException unused) {
            return null;
        }
    }

    @Override // io.netty.handler.codec.Headers
    public long getTimeMillisAndRemove(K k2, long j2) {
        Long timeMillisAndRemove = getTimeMillisAndRemove(k2);
        return timeMillisAndRemove != null ? timeMillisAndRemove.longValue() : j2;
    }

    @Override // io.netty.handler.codec.Headers
    public Long getTimeMillisAndRemove(K k2) {
        V andRemove = getAndRemove(k2);
        if (andRemove == null) {
            return null;
        }
        try {
            return Long.valueOf(this.valueConverter.convertToTimeMillis(andRemove));
        } catch (RuntimeException unused) {
            return null;
        }
    }

    public int hashCode() {
        return hashCode(HashingStrategy.JAVA_HASHER);
    }

    public final int hashCode(HashingStrategy<V> hashingStrategy) {
        int i2 = -1028477387;
        for (K k2 : names()) {
            int iHashCode = this.hashingStrategy.hashCode(k2) + (i2 * 31);
            List<V> all = getAll(k2);
            for (int i3 = 0; i3 < all.size(); i3++) {
                iHashCode = (iHashCode * 31) + hashingStrategy.hashCode(all.get(i3));
            }
            i2 = iHashCode;
        }
        return i2;
    }

    @Override // io.netty.handler.codec.Headers
    public boolean isEmpty() {
        HeaderEntry<K, V> headerEntry = this.head;
        return headerEntry == headerEntry.after;
    }

    @Override // io.netty.handler.codec.Headers, java.lang.Iterable
    public Iterator<Map.Entry<K, V>> iterator() {
        return new HeaderIterator();
    }

    @Override // io.netty.handler.codec.Headers
    public Set<K> names() {
        if (isEmpty()) {
            return Collections.emptySet();
        }
        LinkedHashSet linkedHashSet = new LinkedHashSet(size());
        HeaderEntry<K, V> headerEntry = this.head;
        while (true) {
            headerEntry = headerEntry.after;
            if (headerEntry == this.head) {
                return linkedHashSet;
            }
            linkedHashSet.add(headerEntry.getKey());
        }
    }

    public HeaderEntry<K, V> newHeaderEntry(int i2, K k2, V v2, HeaderEntry<K, V> headerEntry) {
        return new HeaderEntry<>(i2, k2, v2, headerEntry, this.head);
    }

    @Override // io.netty.handler.codec.Headers
    public boolean remove(K k2) {
        return getAndRemove(k2) != null;
    }

    @Override // io.netty.handler.codec.Headers
    public T set(Headers<? extends K, ? extends V, ?> headers) {
        if (headers != this) {
            clear();
            addImpl(headers);
        }
        return (T) thisT();
    }

    @Override // io.netty.handler.codec.Headers
    public T set(K k2, Iterable<? extends V> iterable) {
        V next;
        this.nameValidator.validateName(k2);
        ObjectUtil.checkNotNull(iterable, "values");
        int iHashCode = this.hashingStrategy.hashCode(k2);
        int iIndex = index(iHashCode);
        remove0(iHashCode, iIndex, k2);
        Iterator<? extends V> it = iterable.iterator();
        while (it.hasNext() && (next = it.next()) != null) {
            add0(iHashCode, iIndex, k2, next);
        }
        return (T) thisT();
    }

    @Override // io.netty.handler.codec.Headers
    public T set(K k2, V v2) {
        this.nameValidator.validateName(k2);
        ObjectUtil.checkNotNull(v2, "value");
        int iHashCode = this.hashingStrategy.hashCode(k2);
        int iIndex = index(iHashCode);
        remove0(iHashCode, iIndex, k2);
        add0(iHashCode, iIndex, k2, v2);
        return (T) thisT();
    }

    @Override // io.netty.handler.codec.Headers
    public T set(K k2, V... vArr) {
        this.nameValidator.validateName(k2);
        ObjectUtil.checkNotNull(vArr, "values");
        int iHashCode = this.hashingStrategy.hashCode(k2);
        int iIndex = index(iHashCode);
        remove0(iHashCode, iIndex, k2);
        for (V v2 : vArr) {
            if (v2 == null) {
                break;
            }
            add0(iHashCode, iIndex, k2, v2);
        }
        return (T) thisT();
    }

    @Override // io.netty.handler.codec.Headers
    public T setAll(Headers<? extends K, ? extends V, ?> headers) {
        if (headers != this) {
            Iterator<? extends K> it = headers.names().iterator();
            while (it.hasNext()) {
                remove(it.next());
            }
            addImpl(headers);
        }
        return (T) thisT();
    }

    @Override // io.netty.handler.codec.Headers
    public T setBoolean(K k2, boolean z2) {
        return (T) set(k2, this.valueConverter.convertBoolean(z2));
    }

    @Override // io.netty.handler.codec.Headers
    public T setByte(K k2, byte b2) {
        return (T) set(k2, this.valueConverter.convertByte(b2));
    }

    @Override // io.netty.handler.codec.Headers
    public T setChar(K k2, char c2) {
        return (T) set(k2, this.valueConverter.convertChar(c2));
    }

    @Override // io.netty.handler.codec.Headers
    public T setDouble(K k2, double d2) {
        return (T) set(k2, this.valueConverter.convertDouble(d2));
    }

    @Override // io.netty.handler.codec.Headers
    public T setFloat(K k2, float f2) {
        return (T) set(k2, this.valueConverter.convertFloat(f2));
    }

    @Override // io.netty.handler.codec.Headers
    public T setInt(K k2, int i2) {
        return (T) set(k2, this.valueConverter.convertInt(i2));
    }

    @Override // io.netty.handler.codec.Headers
    public T setLong(K k2, long j2) {
        return (T) set(k2, this.valueConverter.convertLong(j2));
    }

    @Override // io.netty.handler.codec.Headers
    public T setObject(K k2, Iterable<?> iterable) {
        Object next;
        this.nameValidator.validateName(k2);
        int iHashCode = this.hashingStrategy.hashCode(k2);
        int iIndex = index(iHashCode);
        remove0(iHashCode, iIndex, k2);
        Iterator<?> it = iterable.iterator();
        while (it.hasNext() && (next = it.next()) != null) {
            add0(iHashCode, iIndex, k2, this.valueConverter.convertObject(next));
        }
        return (T) thisT();
    }

    /* JADX WARN: Multi-variable type inference failed */
    @Override // io.netty.handler.codec.Headers
    public T setObject(K k2, Object obj) {
        ObjectUtil.checkNotNull(obj, "value");
        return (T) set(k2, ObjectUtil.checkNotNull(this.valueConverter.convertObject(obj), "convertedValue"));
    }

    @Override // io.netty.handler.codec.Headers
    public T setObject(K k2, Object... objArr) {
        this.nameValidator.validateName(k2);
        int iHashCode = this.hashingStrategy.hashCode(k2);
        int iIndex = index(iHashCode);
        remove0(iHashCode, iIndex, k2);
        for (Object obj : objArr) {
            if (obj == null) {
                break;
            }
            add0(iHashCode, iIndex, k2, this.valueConverter.convertObject(obj));
        }
        return (T) thisT();
    }

    @Override // io.netty.handler.codec.Headers
    public T setShort(K k2, short s2) {
        return (T) set(k2, this.valueConverter.convertShort(s2));
    }

    @Override // io.netty.handler.codec.Headers
    public T setTimeMillis(K k2, long j2) {
        return (T) set(k2, this.valueConverter.convertTimeMillis(j2));
    }

    @Override // io.netty.handler.codec.Headers
    public int size() {
        return this.size;
    }

    public String toString() {
        return HeadersUtils.toString(getClass(), iterator(), size());
    }

    public ValueConverter<V> valueConverter() {
        return this.valueConverter;
    }

    public Iterator<V> valueIterator(K k2) {
        return new ValueIterator(k2);
    }
}