package io.netty.buffer;

import io.netty.util.Recycler;
import io.netty.util.internal.PlatformDependent;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.ClosedChannelException;
import java.nio.channels.FileChannel;
import java.nio.channels.GatheringByteChannel;
import java.nio.channels.ScatteringByteChannel;

/* JADX INFO: loaded from: classes.dex */
public class PooledHeapByteBuf extends PooledByteBuf<byte[]> {
    private static final Recycler<PooledHeapByteBuf> RECYCLER = new Recycler<PooledHeapByteBuf>() { // from class: io.netty.buffer.PooledHeapByteBuf.1
        /* JADX WARN: Can't rename method to resolve collision */
        @Override // io.netty.util.Recycler
        public PooledHeapByteBuf newObject(Recycler.Handle<PooledHeapByteBuf> handle) {
            return new PooledHeapByteBuf(handle, 0);
        }
    };

    public PooledHeapByteBuf(Recycler.Handle<? extends PooledHeapByteBuf> handle, int i2) {
        super(handle, i2);
    }

    /* JADX WARN: Multi-variable type inference failed */
    private int getBytes(int i2, FileChannel fileChannel, long j2, int i3, boolean z2) {
        checkIndex(i2, i3);
        int iIdx = idx(i2);
        return fileChannel.write((ByteBuffer) (z2 ? internalNioBuffer() : ByteBuffer.wrap((byte[]) this.memory)).clear().position(iIdx).limit(iIdx + i3), j2);
    }

    /* JADX WARN: Multi-variable type inference failed */
    private int getBytes(int i2, GatheringByteChannel gatheringByteChannel, int i3, boolean z2) {
        checkIndex(i2, i3);
        int iIdx = idx(i2);
        return gatheringByteChannel.write((ByteBuffer) (z2 ? internalNioBuffer() : ByteBuffer.wrap((byte[]) this.memory)).clear().position(iIdx).limit(iIdx + i3));
    }

    public static PooledHeapByteBuf newInstance(int i2) {
        PooledHeapByteBuf pooledHeapByteBuf = RECYCLER.get();
        pooledHeapByteBuf.reuse(i2);
        return pooledHeapByteBuf;
    }

    /* JADX WARN: Multi-variable type inference failed */
    @Override // io.netty.buffer.AbstractByteBuf
    public byte _getByte(int i2) {
        return HeapByteBufUtil.getByte((byte[]) this.memory, idx(i2));
    }

    /* JADX WARN: Multi-variable type inference failed */
    @Override // io.netty.buffer.AbstractByteBuf
    public int _getInt(int i2) {
        return HeapByteBufUtil.getInt((byte[]) this.memory, idx(i2));
    }

    /* JADX WARN: Multi-variable type inference failed */
    @Override // io.netty.buffer.AbstractByteBuf
    public int _getIntLE(int i2) {
        return HeapByteBufUtil.getIntLE((byte[]) this.memory, idx(i2));
    }

    /* JADX WARN: Multi-variable type inference failed */
    @Override // io.netty.buffer.AbstractByteBuf
    public long _getLong(int i2) {
        return HeapByteBufUtil.getLong((byte[]) this.memory, idx(i2));
    }

    /* JADX WARN: Multi-variable type inference failed */
    @Override // io.netty.buffer.AbstractByteBuf
    public long _getLongLE(int i2) {
        return HeapByteBufUtil.getLongLE((byte[]) this.memory, idx(i2));
    }

    /* JADX WARN: Multi-variable type inference failed */
    @Override // io.netty.buffer.AbstractByteBuf
    public short _getShort(int i2) {
        return HeapByteBufUtil.getShort((byte[]) this.memory, idx(i2));
    }

    /* JADX WARN: Multi-variable type inference failed */
    @Override // io.netty.buffer.AbstractByteBuf
    public short _getShortLE(int i2) {
        return HeapByteBufUtil.getShortLE((byte[]) this.memory, idx(i2));
    }

    /* JADX WARN: Multi-variable type inference failed */
    @Override // io.netty.buffer.AbstractByteBuf
    public int _getUnsignedMedium(int i2) {
        return HeapByteBufUtil.getUnsignedMedium((byte[]) this.memory, idx(i2));
    }

    /* JADX WARN: Multi-variable type inference failed */
    @Override // io.netty.buffer.AbstractByteBuf
    public int _getUnsignedMediumLE(int i2) {
        return HeapByteBufUtil.getUnsignedMediumLE((byte[]) this.memory, idx(i2));
    }

    /* JADX WARN: Multi-variable type inference failed */
    @Override // io.netty.buffer.AbstractByteBuf
    public void _setByte(int i2, int i3) {
        HeapByteBufUtil.setByte((byte[]) this.memory, idx(i2), i3);
    }

    /* JADX WARN: Multi-variable type inference failed */
    @Override // io.netty.buffer.AbstractByteBuf
    public void _setInt(int i2, int i3) {
        HeapByteBufUtil.setInt((byte[]) this.memory, idx(i2), i3);
    }

    /* JADX WARN: Multi-variable type inference failed */
    @Override // io.netty.buffer.AbstractByteBuf
    public void _setIntLE(int i2, int i3) {
        HeapByteBufUtil.setIntLE((byte[]) this.memory, idx(i2), i3);
    }

    /* JADX WARN: Multi-variable type inference failed */
    @Override // io.netty.buffer.AbstractByteBuf
    public void _setLong(int i2, long j2) {
        HeapByteBufUtil.setLong((byte[]) this.memory, idx(i2), j2);
    }

    /* JADX WARN: Multi-variable type inference failed */
    @Override // io.netty.buffer.AbstractByteBuf
    public void _setLongLE(int i2, long j2) {
        HeapByteBufUtil.setLongLE((byte[]) this.memory, idx(i2), j2);
    }

    /* JADX WARN: Multi-variable type inference failed */
    @Override // io.netty.buffer.AbstractByteBuf
    public void _setMedium(int i2, int i3) {
        HeapByteBufUtil.setMedium((byte[]) this.memory, idx(i2), i3);
    }

    /* JADX WARN: Multi-variable type inference failed */
    @Override // io.netty.buffer.AbstractByteBuf
    public void _setMediumLE(int i2, int i3) {
        HeapByteBufUtil.setMediumLE((byte[]) this.memory, idx(i2), i3);
    }

    /* JADX WARN: Multi-variable type inference failed */
    @Override // io.netty.buffer.AbstractByteBuf
    public void _setShort(int i2, int i3) {
        HeapByteBufUtil.setShort((byte[]) this.memory, idx(i2), i3);
    }

    /* JADX WARN: Multi-variable type inference failed */
    @Override // io.netty.buffer.AbstractByteBuf
    public void _setShortLE(int i2, int i3) {
        HeapByteBufUtil.setShortLE((byte[]) this.memory, idx(i2), i3);
    }

    /* JADX WARN: Multi-variable type inference failed */
    @Override // io.netty.buffer.ByteBuf
    public final byte[] array() {
        ensureAccessible();
        return (byte[]) this.memory;
    }

    @Override // io.netty.buffer.ByteBuf
    public final int arrayOffset() {
        return this.offset;
    }

    /* JADX WARN: Multi-variable type inference failed */
    @Override // io.netty.buffer.ByteBuf
    public final ByteBuf copy(int i2, int i3) {
        checkIndex(i2, i3);
        ByteBuf byteBufHeapBuffer = alloc().heapBuffer(i3, maxCapacity());
        byteBufHeapBuffer.writeBytes((byte[]) this.memory, idx(i2), i3);
        return byteBufHeapBuffer;
    }

    @Override // io.netty.buffer.ByteBuf
    public final int getBytes(int i2, FileChannel fileChannel, long j2, int i3) {
        return getBytes(i2, fileChannel, j2, i3, false);
    }

    @Override // io.netty.buffer.ByteBuf
    public final int getBytes(int i2, GatheringByteChannel gatheringByteChannel, int i3) {
        return getBytes(i2, gatheringByteChannel, i3, false);
    }

    /* JADX WARN: Multi-variable type inference failed */
    @Override // io.netty.buffer.ByteBuf
    public final ByteBuf getBytes(int i2, ByteBuf byteBuf, int i3, int i4) {
        checkDstIndex(i2, i4, i3, byteBuf.capacity());
        if (byteBuf.hasMemoryAddress()) {
            PlatformDependent.copyMemory((byte[]) this.memory, idx(i2), ((long) i3) + byteBuf.memoryAddress(), i4);
        } else if (byteBuf.hasArray()) {
            getBytes(i2, byteBuf.array(), byteBuf.arrayOffset() + i3, i4);
        } else {
            byteBuf.setBytes(i3, (byte[]) this.memory, idx(i2), i4);
        }
        return this;
    }

    /* JADX WARN: Multi-variable type inference failed */
    @Override // io.netty.buffer.ByteBuf
    public final ByteBuf getBytes(int i2, OutputStream outputStream, int i3) throws IOException {
        checkIndex(i2, i3);
        outputStream.write((byte[]) this.memory, idx(i2), i3);
        return this;
    }

    /* JADX WARN: Multi-variable type inference failed */
    @Override // io.netty.buffer.ByteBuf
    public final ByteBuf getBytes(int i2, ByteBuffer byteBuffer) {
        checkIndex(i2, byteBuffer.remaining());
        byteBuffer.put((byte[]) this.memory, idx(i2), byteBuffer.remaining());
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public final ByteBuf getBytes(int i2, byte[] bArr, int i3, int i4) {
        checkDstIndex(i2, i4, i3, bArr.length);
        System.arraycopy(this.memory, idx(i2), bArr, i3, i4);
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public final boolean hasArray() {
        return true;
    }

    @Override // io.netty.buffer.ByteBuf
    public final boolean hasMemoryAddress() {
        return false;
    }

    @Override // io.netty.buffer.ByteBuf
    public final ByteBuffer internalNioBuffer(int i2, int i3) {
        checkIndex(i2, i3);
        int iIdx = idx(i2);
        return (ByteBuffer) internalNioBuffer().clear().position(iIdx).limit(iIdx + i3);
    }

    @Override // io.netty.buffer.ByteBuf
    public final boolean isDirect() {
        return false;
    }

    @Override // io.netty.buffer.ByteBuf
    public final long memoryAddress() {
        throw new UnsupportedOperationException();
    }

    @Override // io.netty.buffer.PooledByteBuf
    public final ByteBuffer newInternalNioBuffer(byte[] bArr) {
        return ByteBuffer.wrap(bArr);
    }

    /* JADX WARN: Multi-variable type inference failed */
    @Override // io.netty.buffer.ByteBuf
    public final ByteBuffer nioBuffer(int i2, int i3) {
        checkIndex(i2, i3);
        return ByteBuffer.wrap((byte[]) this.memory, idx(i2), i3).slice();
    }

    @Override // io.netty.buffer.ByteBuf
    public final int nioBufferCount() {
        return 1;
    }

    @Override // io.netty.buffer.ByteBuf
    public final ByteBuffer[] nioBuffers(int i2, int i3) {
        return new ByteBuffer[]{nioBuffer(i2, i3)};
    }

    @Override // io.netty.buffer.AbstractByteBuf, io.netty.buffer.ByteBuf
    public final int readBytes(FileChannel fileChannel, long j2, int i2) {
        checkReadableBytes(i2);
        int bytes = getBytes(this.readerIndex, fileChannel, j2, i2, true);
        this.readerIndex += bytes;
        return bytes;
    }

    @Override // io.netty.buffer.AbstractByteBuf, io.netty.buffer.ByteBuf
    public final int readBytes(GatheringByteChannel gatheringByteChannel, int i2) {
        checkReadableBytes(i2);
        int bytes = getBytes(this.readerIndex, gatheringByteChannel, i2, true);
        this.readerIndex += bytes;
        return bytes;
    }

    /* JADX WARN: Multi-variable type inference failed */
    @Override // io.netty.buffer.ByteBuf
    public final int setBytes(int i2, InputStream inputStream, int i3) {
        checkIndex(i2, i3);
        return inputStream.read((byte[]) this.memory, idx(i2), i3);
    }

    @Override // io.netty.buffer.ByteBuf
    public final int setBytes(int i2, FileChannel fileChannel, long j2, int i3) {
        checkIndex(i2, i3);
        int iIdx = idx(i2);
        try {
            return fileChannel.read((ByteBuffer) internalNioBuffer().clear().position(iIdx).limit(iIdx + i3), j2);
        } catch (ClosedChannelException unused) {
            return -1;
        }
    }

    @Override // io.netty.buffer.ByteBuf
    public final int setBytes(int i2, ScatteringByteChannel scatteringByteChannel, int i3) {
        checkIndex(i2, i3);
        int iIdx = idx(i2);
        try {
            return scatteringByteChannel.read((ByteBuffer) internalNioBuffer().clear().position(iIdx).limit(iIdx + i3));
        } catch (ClosedChannelException unused) {
            return -1;
        }
    }

    /* JADX WARN: Multi-variable type inference failed */
    @Override // io.netty.buffer.ByteBuf
    public final ByteBuf setBytes(int i2, ByteBuf byteBuf, int i3, int i4) {
        checkSrcIndex(i2, i4, i3, byteBuf.capacity());
        if (byteBuf.hasMemoryAddress()) {
            PlatformDependent.copyMemory(byteBuf.memoryAddress() + ((long) i3), (byte[]) this.memory, idx(i2), i4);
        } else if (byteBuf.hasArray()) {
            setBytes(i2, byteBuf.array(), byteBuf.arrayOffset() + i3, i4);
        } else {
            byteBuf.getBytes(i3, (byte[]) this.memory, idx(i2), i4);
        }
        return this;
    }

    /* JADX WARN: Multi-variable type inference failed */
    @Override // io.netty.buffer.ByteBuf
    public final ByteBuf setBytes(int i2, ByteBuffer byteBuffer) {
        int iRemaining = byteBuffer.remaining();
        checkIndex(i2, iRemaining);
        byteBuffer.get((byte[]) this.memory, idx(i2), iRemaining);
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public final ByteBuf setBytes(int i2, byte[] bArr, int i3, int i4) {
        checkSrcIndex(i2, i4, i3, bArr.length);
        System.arraycopy(bArr, i3, this.memory, idx(i2), i4);
        return this;
    }
}