package io.netty.buffer;

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.ByteOrder;
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 UnpooledHeapByteBuf extends AbstractReferenceCountedByteBuf {
    private final ByteBufAllocator alloc;
    byte[] array;
    private ByteBuffer tmpNioBuf;

    protected UnpooledHeapByteBuf(ByteBufAllocator byteBufAllocator, int i2, int i3) {
        this(byteBufAllocator, new byte[i2], 0, 0, i3);
    }

    private void setArray(byte[] bArr) {
        this.array = bArr;
        this.tmpNioBuf = null;
    }

    @Override // io.netty.buffer.AbstractByteBuf
    protected byte _getByte(int i2) {
        return HeapByteBufUtil.getByte(this.array, i2);
    }

    @Override // io.netty.buffer.AbstractByteBuf
    protected int _getInt(int i2) {
        return HeapByteBufUtil.getInt(this.array, i2);
    }

    @Override // io.netty.buffer.AbstractByteBuf
    protected int _getIntLE(int i2) {
        return HeapByteBufUtil.getIntLE(this.array, i2);
    }

    @Override // io.netty.buffer.AbstractByteBuf
    protected long _getLong(int i2) {
        return HeapByteBufUtil.getLong(this.array, i2);
    }

    @Override // io.netty.buffer.AbstractByteBuf
    protected long _getLongLE(int i2) {
        return HeapByteBufUtil.getLongLE(this.array, i2);
    }

    @Override // io.netty.buffer.AbstractByteBuf
    protected short _getShort(int i2) {
        return HeapByteBufUtil.getShort(this.array, i2);
    }

    @Override // io.netty.buffer.AbstractByteBuf
    protected short _getShortLE(int i2) {
        return HeapByteBufUtil.getShortLE(this.array, i2);
    }

    @Override // io.netty.buffer.AbstractByteBuf
    protected int _getUnsignedMedium(int i2) {
        return HeapByteBufUtil.getUnsignedMedium(this.array, i2);
    }

    @Override // io.netty.buffer.AbstractByteBuf
    protected int _getUnsignedMediumLE(int i2) {
        return HeapByteBufUtil.getUnsignedMediumLE(this.array, i2);
    }

    @Override // io.netty.buffer.AbstractByteBuf
    protected void _setByte(int i2, int i3) {
        HeapByteBufUtil.setByte(this.array, i2, i3);
    }

    @Override // io.netty.buffer.AbstractByteBuf
    protected void _setInt(int i2, int i3) {
        HeapByteBufUtil.setInt(this.array, i2, i3);
    }

    @Override // io.netty.buffer.AbstractByteBuf
    protected void _setIntLE(int i2, int i3) {
        HeapByteBufUtil.setIntLE(this.array, i2, i3);
    }

    @Override // io.netty.buffer.AbstractByteBuf
    protected void _setLong(int i2, long j2) {
        HeapByteBufUtil.setLong(this.array, i2, j2);
    }

    @Override // io.netty.buffer.AbstractByteBuf
    protected void _setLongLE(int i2, long j2) {
        HeapByteBufUtil.setLongLE(this.array, i2, j2);
    }

    @Override // io.netty.buffer.AbstractByteBuf
    protected void _setMedium(int i2, int i3) {
        HeapByteBufUtil.setMedium(this.array, i2, i3);
    }

    @Override // io.netty.buffer.AbstractByteBuf
    protected void _setMediumLE(int i2, int i3) {
        HeapByteBufUtil.setMediumLE(this.array, i2, i3);
    }

    @Override // io.netty.buffer.AbstractByteBuf
    protected void _setShort(int i2, int i3) {
        HeapByteBufUtil.setShort(this.array, i2, i3);
    }

    @Override // io.netty.buffer.AbstractByteBuf
    protected void _setShortLE(int i2, int i3) {
        HeapByteBufUtil.setShortLE(this.array, i2, i3);
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBufAllocator alloc() {
        return this.alloc;
    }

    @Override // io.netty.buffer.ByteBuf
    public byte[] array() {
        ensureAccessible();
        return this.array;
    }

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

    @Override // io.netty.buffer.ByteBuf
    public int capacity() {
        ensureAccessible();
        return this.array.length;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf copy(int i2, int i3) {
        checkIndex(i2, i3);
        byte[] bArr = new byte[i3];
        System.arraycopy(this.array, i2, bArr, 0, i3);
        return new UnpooledHeapByteBuf(alloc(), bArr, maxCapacity());
    }

    @Override // io.netty.buffer.AbstractReferenceCountedByteBuf
    protected void deallocate() {
        this.array = null;
    }

    @Override // io.netty.buffer.AbstractByteBuf, io.netty.buffer.ByteBuf
    public byte getByte(int i2) {
        ensureAccessible();
        return _getByte(i2);
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf getBytes(int i2, ByteBuf byteBuf, int i3, int i4) {
        checkDstIndex(i2, i4, i3, byteBuf.capacity());
        if (byteBuf.hasMemoryAddress()) {
            PlatformDependent.copyMemory(this.array, i2, byteBuf.memoryAddress() + ((long) i3), i4);
        } else if (byteBuf.hasArray()) {
            getBytes(i2, byteBuf.array(), byteBuf.arrayOffset() + i3, i4);
        } else {
            byteBuf.setBytes(i3, this.array, i2, i4);
        }
        return this;
    }

    @Override // io.netty.buffer.AbstractByteBuf, io.netty.buffer.ByteBuf
    public int getInt(int i2) {
        ensureAccessible();
        return _getInt(i2);
    }

    @Override // io.netty.buffer.AbstractByteBuf, io.netty.buffer.ByteBuf
    public int getIntLE(int i2) {
        ensureAccessible();
        return _getIntLE(i2);
    }

    @Override // io.netty.buffer.AbstractByteBuf, io.netty.buffer.ByteBuf
    public long getLong(int i2) {
        ensureAccessible();
        return _getLong(i2);
    }

    @Override // io.netty.buffer.AbstractByteBuf, io.netty.buffer.ByteBuf
    public long getLongLE(int i2) {
        ensureAccessible();
        return _getLongLE(i2);
    }

    @Override // io.netty.buffer.AbstractByteBuf, io.netty.buffer.ByteBuf
    public short getShort(int i2) {
        ensureAccessible();
        return _getShort(i2);
    }

    @Override // io.netty.buffer.AbstractByteBuf, io.netty.buffer.ByteBuf
    public short getShortLE(int i2) {
        ensureAccessible();
        return _getShortLE(i2);
    }

    @Override // io.netty.buffer.AbstractByteBuf, io.netty.buffer.ByteBuf
    public int getUnsignedMedium(int i2) {
        ensureAccessible();
        return _getUnsignedMedium(i2);
    }

    @Override // io.netty.buffer.AbstractByteBuf, io.netty.buffer.ByteBuf
    public int getUnsignedMediumLE(int i2) {
        ensureAccessible();
        return _getUnsignedMediumLE(i2);
    }

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

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

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

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

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

    @Override // io.netty.buffer.ByteBuf
    public ByteBuffer nioBuffer(int i2, int i3) {
        ensureAccessible();
        return ByteBuffer.wrap(this.array, i2, i3).slice();
    }

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

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

    @Override // io.netty.buffer.ByteBuf
    public ByteOrder order() {
        return ByteOrder.BIG_ENDIAN;
    }

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

    @Override // io.netty.buffer.AbstractByteBuf, io.netty.buffer.ByteBuf
    public ByteBuf setByte(int i2, int i3) {
        ensureAccessible();
        _setByte(i2, i3);
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public 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), this.array, i2, i4);
        } else if (byteBuf.hasArray()) {
            setBytes(i2, byteBuf.array(), byteBuf.arrayOffset() + i3, i4);
        } else {
            byteBuf.getBytes(i3, this.array, i2, i4);
        }
        return this;
    }

    @Override // io.netty.buffer.AbstractByteBuf, io.netty.buffer.ByteBuf
    public ByteBuf setInt(int i2, int i3) {
        ensureAccessible();
        _setInt(i2, i3);
        return this;
    }

    @Override // io.netty.buffer.AbstractByteBuf, io.netty.buffer.ByteBuf
    public ByteBuf setIntLE(int i2, int i3) {
        ensureAccessible();
        _setIntLE(i2, i3);
        return this;
    }

    @Override // io.netty.buffer.AbstractByteBuf, io.netty.buffer.ByteBuf
    public ByteBuf setLong(int i2, long j2) {
        ensureAccessible();
        _setLong(i2, j2);
        return this;
    }

    @Override // io.netty.buffer.AbstractByteBuf, io.netty.buffer.ByteBuf
    public ByteBuf setLongLE(int i2, long j2) {
        ensureAccessible();
        _setLongLE(i2, j2);
        return this;
    }

    @Override // io.netty.buffer.AbstractByteBuf, io.netty.buffer.ByteBuf
    public ByteBuf setMedium(int i2, int i3) {
        ensureAccessible();
        _setMedium(i2, i3);
        return this;
    }

    @Override // io.netty.buffer.AbstractByteBuf, io.netty.buffer.ByteBuf
    public ByteBuf setMediumLE(int i2, int i3) {
        ensureAccessible();
        _setMediumLE(i2, i3);
        return this;
    }

    @Override // io.netty.buffer.AbstractByteBuf, io.netty.buffer.ByteBuf
    public ByteBuf setShort(int i2, int i3) {
        ensureAccessible();
        _setShort(i2, i3);
        return this;
    }

    @Override // io.netty.buffer.AbstractByteBuf, io.netty.buffer.ByteBuf
    public ByteBuf setShortLE(int i2, int i3) {
        ensureAccessible();
        _setShortLE(i2, i3);
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf unwrap() {
        return null;
    }

    protected UnpooledHeapByteBuf(ByteBufAllocator byteBufAllocator, byte[] bArr, int i2) {
        this(byteBufAllocator, bArr, 0, bArr.length, i2);
    }

    private UnpooledHeapByteBuf(ByteBufAllocator byteBufAllocator, byte[] bArr, int i2, int i3, int i4) {
        super(i4);
        if (byteBufAllocator == null) {
            throw new NullPointerException("alloc");
        }
        if (bArr != null) {
            if (bArr.length <= i4) {
                this.alloc = byteBufAllocator;
                setArray(bArr);
                setIndex(i2, i3);
                return;
            }
            throw new IllegalArgumentException(String.format("initialCapacity(%d) > maxCapacity(%d)", Integer.valueOf(bArr.length), Integer.valueOf(i4)));
        }
        throw new NullPointerException("initialArray");
    }

    private ByteBuffer internalNioBuffer() {
        ByteBuffer byteBuffer = this.tmpNioBuf;
        if (byteBuffer != null) {
            return byteBuffer;
        }
        ByteBuffer byteBufferWrap = ByteBuffer.wrap(this.array);
        this.tmpNioBuf = byteBufferWrap;
        return byteBufferWrap;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf capacity(int i2) {
        ensureAccessible();
        if (i2 >= 0 && i2 <= maxCapacity()) {
            byte[] bArr = this.array;
            int length = bArr.length;
            if (i2 > length) {
                byte[] bArr2 = new byte[i2];
                System.arraycopy(bArr, 0, bArr2, 0, bArr.length);
                setArray(bArr2);
            } else if (i2 < length) {
                byte[] bArr3 = new byte[i2];
                int i3 = readerIndex();
                if (i3 < i2) {
                    int iWriterIndex = writerIndex();
                    if (iWriterIndex > i2) {
                        writerIndex(i2);
                    } else {
                        i2 = iWriterIndex;
                    }
                    System.arraycopy(this.array, i3, bArr3, i3, i2 - i3);
                } else {
                    setIndex(i2, i2);
                }
                setArray(bArr3);
            }
            return this;
        }
        throw new IllegalArgumentException("newCapacity: " + i2);
    }

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

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

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

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf getBytes(int i2, ByteBuffer byteBuffer) {
        ensureAccessible();
        byteBuffer.put(this.array, i2, Math.min(capacity() - i2, byteBuffer.remaining()));
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf setBytes(int i2, ByteBuffer byteBuffer) {
        ensureAccessible();
        byteBuffer.get(this.array, i2, byteBuffer.remaining());
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public ByteBuf getBytes(int i2, OutputStream outputStream, int i3) throws IOException {
        ensureAccessible();
        outputStream.write(this.array, i2, i3);
        return this;
    }

    @Override // io.netty.buffer.ByteBuf
    public int setBytes(int i2, InputStream inputStream, int i3) throws IOException {
        ensureAccessible();
        return inputStream.read(this.array, i2, i3);
    }

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

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

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

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

    private int getBytes(int i2, GatheringByteChannel gatheringByteChannel, int i3, boolean z) throws IOException {
        ByteBuffer byteBufferWrap;
        ensureAccessible();
        if (z) {
            byteBufferWrap = internalNioBuffer();
        } else {
            byteBufferWrap = ByteBuffer.wrap(this.array);
        }
        return gatheringByteChannel.write((ByteBuffer) byteBufferWrap.clear().position(i2).limit(i2 + i3));
    }

    private int getBytes(int i2, FileChannel fileChannel, long j2, int i3, boolean z) throws IOException {
        ensureAccessible();
        return fileChannel.write((ByteBuffer) (z ? internalNioBuffer() : ByteBuffer.wrap(this.array)).clear().position(i2).limit(i2 + i3), j2);
    }
}