package io.netty.buffer;

import io.netty.util.ResourceLeak;
import io.netty.util.ResourceLeakDetector;
import io.netty.util.internal.PlatformDependent;
import io.netty.util.internal.StringUtil;
import org.snmp4j.mp.MPv3;

/* JADX INFO: loaded from: classes.dex */
public abstract class AbstractByteBufAllocator implements ByteBufAllocator {
    private static final int DEFAULT_INITIAL_CAPACITY = 256;
    static final int DEFAULT_MAX_COMPONENTS = 16;
    private final boolean directByDefault;
    private final ByteBuf emptyBuf;

    /* JADX INFO: renamed from: io.netty.buffer.AbstractByteBufAllocator$1, reason: invalid class name */
    static /* synthetic */ class AnonymousClass1 {
        static final /* synthetic */ int[] $SwitchMap$io$netty$util$ResourceLeakDetector$Level;

        static {
            int[] iArr = new int[ResourceLeakDetector.Level.values().length];
            $SwitchMap$io$netty$util$ResourceLeakDetector$Level = iArr;
            try {
                iArr[ResourceLeakDetector.Level.SIMPLE.ordinal()] = 1;
            } catch (NoSuchFieldError unused) {
            }
            try {
                $SwitchMap$io$netty$util$ResourceLeakDetector$Level[ResourceLeakDetector.Level.ADVANCED.ordinal()] = 2;
            } catch (NoSuchFieldError unused2) {
            }
            try {
                $SwitchMap$io$netty$util$ResourceLeakDetector$Level[ResourceLeakDetector.Level.PARANOID.ordinal()] = 3;
            } catch (NoSuchFieldError unused3) {
            }
        }
    }

    protected AbstractByteBufAllocator() {
        this(false);
    }

    protected static ByteBuf toLeakAwareBuffer(ByteBuf byteBuf) {
        ByteBuf simpleLeakAwareByteBuf;
        ResourceLeak resourceLeakOpen;
        int i2 = AnonymousClass1.$SwitchMap$io$netty$util$ResourceLeakDetector$Level[ResourceLeakDetector.getLevel().ordinal()];
        if (i2 == 1) {
            ResourceLeak resourceLeakOpen2 = AbstractByteBuf.leakDetector.open(byteBuf);
            if (resourceLeakOpen2 == null) {
                return byteBuf;
            }
            simpleLeakAwareByteBuf = new SimpleLeakAwareByteBuf(byteBuf, resourceLeakOpen2);
        } else {
            if ((i2 != 2 && i2 != 3) || (resourceLeakOpen = AbstractByteBuf.leakDetector.open(byteBuf)) == null) {
                return byteBuf;
            }
            simpleLeakAwareByteBuf = new AdvancedLeakAwareByteBuf(byteBuf, resourceLeakOpen);
        }
        return simpleLeakAwareByteBuf;
    }

    private static void validate(int i2, int i3) {
        if (i2 >= 0) {
            if (i2 > i3) {
                throw new IllegalArgumentException(String.format("initialCapacity: %d (expected: not greater than maxCapacity(%d)", Integer.valueOf(i2), Integer.valueOf(i3)));
            }
        } else {
            throw new IllegalArgumentException("initialCapacity: " + i2 + " (expectd: 0+)");
        }
    }

    @Override // io.netty.buffer.ByteBufAllocator
    public ByteBuf buffer() {
        return this.directByDefault ? directBuffer() : heapBuffer();
    }

    @Override // io.netty.buffer.ByteBufAllocator
    public int calculateNewCapacity(int i2, int i3) {
        if (i2 < 0) {
            throw new IllegalArgumentException("minNewCapacity: " + i2 + " (expectd: 0+)");
        }
        if (i2 > i3) {
            throw new IllegalArgumentException(String.format("minNewCapacity: %d (expected: not greater than maxCapacity(%d)", Integer.valueOf(i2), Integer.valueOf(i3)));
        }
        if (i2 == 4194304) {
            return 4194304;
        }
        if (i2 > 4194304) {
            int i4 = (i2 / 4194304) * 4194304;
            return i4 > i3 - 4194304 ? i3 : i4 + 4194304;
        }
        int i5 = 64;
        while (i5 < i2) {
            i5 <<= 1;
        }
        return Math.min(i5, i3);
    }

    @Override // io.netty.buffer.ByteBufAllocator
    public CompositeByteBuf compositeBuffer() {
        return this.directByDefault ? compositeDirectBuffer() : compositeHeapBuffer();
    }

    @Override // io.netty.buffer.ByteBufAllocator
    public CompositeByteBuf compositeDirectBuffer() {
        return compositeDirectBuffer(16);
    }

    @Override // io.netty.buffer.ByteBufAllocator
    public CompositeByteBuf compositeHeapBuffer() {
        return compositeHeapBuffer(16);
    }

    @Override // io.netty.buffer.ByteBufAllocator
    public ByteBuf directBuffer() {
        return directBuffer(DEFAULT_INITIAL_CAPACITY, MPv3.MAX_MESSAGE_ID);
    }

    @Override // io.netty.buffer.ByteBufAllocator
    public ByteBuf heapBuffer() {
        return heapBuffer(DEFAULT_INITIAL_CAPACITY, MPv3.MAX_MESSAGE_ID);
    }

    @Override // io.netty.buffer.ByteBufAllocator
    public ByteBuf ioBuffer() {
        return PlatformDependent.hasUnsafe() ? directBuffer(DEFAULT_INITIAL_CAPACITY) : heapBuffer(DEFAULT_INITIAL_CAPACITY);
    }

    protected abstract ByteBuf newDirectBuffer(int i2, int i3);

    protected abstract ByteBuf newHeapBuffer(int i2, int i3);

    public String toString() {
        return StringUtil.simpleClassName(this) + "(directByDefault: " + this.directByDefault + ')';
    }

    protected AbstractByteBufAllocator(boolean z) {
        this.directByDefault = z && PlatformDependent.hasUnsafe();
        this.emptyBuf = new EmptyByteBuf(this);
    }

    @Override // io.netty.buffer.ByteBufAllocator
    public CompositeByteBuf compositeDirectBuffer(int i2) {
        return toLeakAwareBuffer(new CompositeByteBuf(this, true, i2));
    }

    @Override // io.netty.buffer.ByteBufAllocator
    public CompositeByteBuf compositeHeapBuffer(int i2) {
        return toLeakAwareBuffer(new CompositeByteBuf(this, false, i2));
    }

    @Override // io.netty.buffer.ByteBufAllocator
    public ByteBuf directBuffer(int i2) {
        return directBuffer(i2, MPv3.MAX_MESSAGE_ID);
    }

    @Override // io.netty.buffer.ByteBufAllocator
    public ByteBuf heapBuffer(int i2) {
        return heapBuffer(i2, MPv3.MAX_MESSAGE_ID);
    }

    @Override // io.netty.buffer.ByteBufAllocator
    public ByteBuf directBuffer(int i2, int i3) {
        if (i2 == 0 && i3 == 0) {
            return this.emptyBuf;
        }
        validate(i2, i3);
        return newDirectBuffer(i2, i3);
    }

    @Override // io.netty.buffer.ByteBufAllocator
    public ByteBuf heapBuffer(int i2, int i3) {
        if (i2 == 0 && i3 == 0) {
            return this.emptyBuf;
        }
        validate(i2, i3);
        return newHeapBuffer(i2, i3);
    }

    @Override // io.netty.buffer.ByteBufAllocator
    public ByteBuf buffer(int i2) {
        if (this.directByDefault) {
            return directBuffer(i2);
        }
        return heapBuffer(i2);
    }

    @Override // io.netty.buffer.ByteBufAllocator
    public CompositeByteBuf compositeBuffer(int i2) {
        if (this.directByDefault) {
            return compositeDirectBuffer(i2);
        }
        return compositeHeapBuffer(i2);
    }

    @Override // io.netty.buffer.ByteBufAllocator
    public ByteBuf ioBuffer(int i2) {
        if (PlatformDependent.hasUnsafe()) {
            return directBuffer(i2);
        }
        return heapBuffer(i2);
    }

    protected static CompositeByteBuf toLeakAwareBuffer(CompositeByteBuf compositeByteBuf) {
        CompositeByteBuf simpleLeakAwareCompositeByteBuf;
        ResourceLeak resourceLeakOpen;
        int i2 = AnonymousClass1.$SwitchMap$io$netty$util$ResourceLeakDetector$Level[ResourceLeakDetector.getLevel().ordinal()];
        if (i2 == 1) {
            ResourceLeak resourceLeakOpen2 = AbstractByteBuf.leakDetector.open(compositeByteBuf);
            if (resourceLeakOpen2 == null) {
                return compositeByteBuf;
            }
            simpleLeakAwareCompositeByteBuf = new SimpleLeakAwareCompositeByteBuf(compositeByteBuf, resourceLeakOpen2);
        } else {
            if ((i2 != 2 && i2 != 3) || (resourceLeakOpen = AbstractByteBuf.leakDetector.open(compositeByteBuf)) == null) {
                return compositeByteBuf;
            }
            simpleLeakAwareCompositeByteBuf = new AdvancedLeakAwareCompositeByteBuf(compositeByteBuf, resourceLeakOpen);
        }
        return simpleLeakAwareCompositeByteBuf;
    }

    @Override // io.netty.buffer.ByteBufAllocator
    public ByteBuf buffer(int i2, int i3) {
        if (this.directByDefault) {
            return directBuffer(i2, i3);
        }
        return heapBuffer(i2, i3);
    }

    @Override // io.netty.buffer.ByteBufAllocator
    public ByteBuf ioBuffer(int i2, int i3) {
        if (PlatformDependent.hasUnsafe()) {
            return directBuffer(i2, i3);
        }
        return heapBuffer(i2, i3);
    }
}