package io.netty.buffer;

import io.netty.util.internal.PlatformDependent;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Objects;

/* JADX INFO: loaded from: classes.dex */
public final class Unpooled {
    public static final /* synthetic */ boolean $assertionsDisabled = false;
    private static final ByteBufAllocator ALLOC;
    public static final ByteOrder BIG_ENDIAN;
    public static final ByteBuf EMPTY_BUFFER;
    public static final ByteOrder LITTLE_ENDIAN;

    static {
        UnpooledByteBufAllocator unpooledByteBufAllocator = UnpooledByteBufAllocator.DEFAULT;
        ALLOC = unpooledByteBufAllocator;
        BIG_ENDIAN = ByteOrder.BIG_ENDIAN;
        LITTLE_ENDIAN = ByteOrder.LITTLE_ENDIAN;
        EMPTY_BUFFER = unpooledByteBufAllocator.buffer(0, 0);
    }

    private Unpooled() {
    }

    public static ByteBuf buffer() {
        return ALLOC.heapBuffer();
    }

    public static ByteBuf buffer(int i2) {
        return ALLOC.heapBuffer(i2);
    }

    public static ByteBuf buffer(int i2, int i3) {
        return ALLOC.heapBuffer(i2, i3);
    }

    public static CompositeByteBuf compositeBuffer() {
        return compositeBuffer(16);
    }

    public static CompositeByteBuf compositeBuffer(int i2) {
        return new CompositeByteBuf(ALLOC, false, i2);
    }

    public static ByteBuf copiedBuffer(ByteBuf byteBuf) {
        int i2 = byteBuf.readableBytes();
        if (i2 <= 0) {
            return EMPTY_BUFFER;
        }
        ByteBuf byteBufBuffer = buffer(i2);
        byteBufBuffer.writeBytes(byteBuf, byteBuf.readerIndex(), i2);
        return byteBufBuffer;
    }

    public static ByteBuf copiedBuffer(CharSequence charSequence, int i2, int i3, Charset charset) {
        Objects.requireNonNull(charSequence, "string");
        if (i3 == 0) {
            return EMPTY_BUFFER;
        }
        if (!(charSequence instanceof CharBuffer)) {
            return copiedBuffer(CharBuffer.wrap(charSequence, i2, i3 + i2), charset);
        }
        CharBuffer charBuffer = (CharBuffer) charSequence;
        if (charBuffer.hasArray()) {
            return copiedBuffer(charBuffer.array(), charBuffer.position() + charBuffer.arrayOffset() + i2, i3, charset);
        }
        CharBuffer charBufferSlice = charBuffer.slice();
        charBufferSlice.limit(i3);
        charBufferSlice.position(i2);
        return copiedBuffer(charBufferSlice, charset);
    }

    public static ByteBuf copiedBuffer(CharSequence charSequence, Charset charset) {
        Objects.requireNonNull(charSequence, "string");
        return copiedBuffer(charSequence instanceof CharBuffer ? (CharBuffer) charSequence : CharBuffer.wrap(charSequence), charset);
    }

    public static ByteBuf copiedBuffer(ByteBuffer byteBuffer) {
        int iRemaining = byteBuffer.remaining();
        if (iRemaining == 0) {
            return EMPTY_BUFFER;
        }
        byte[] bArr = new byte[iRemaining];
        ByteBuffer byteBufferDuplicate = byteBuffer.duplicate();
        byteBufferDuplicate.get(bArr);
        return wrappedBuffer(bArr).order(byteBufferDuplicate.order());
    }

    private static ByteBuf copiedBuffer(CharBuffer charBuffer, Charset charset) {
        return ByteBufUtil.encodeString0(ALLOC, true, charBuffer, charset, 0);
    }

    public static ByteBuf copiedBuffer(byte[] bArr) {
        return bArr.length == 0 ? EMPTY_BUFFER : wrappedBuffer((byte[]) bArr.clone());
    }

    public static ByteBuf copiedBuffer(byte[] bArr, int i2, int i3) {
        if (i3 == 0) {
            return EMPTY_BUFFER;
        }
        byte[] bArr2 = new byte[i3];
        System.arraycopy(bArr, i2, bArr2, 0, i3);
        return wrappedBuffer(bArr2);
    }

    public static ByteBuf copiedBuffer(char[] cArr, int i2, int i3, Charset charset) {
        Objects.requireNonNull(cArr, "array");
        return i3 == 0 ? EMPTY_BUFFER : copiedBuffer(CharBuffer.wrap(cArr, i2, i3), charset);
    }

    public static ByteBuf copiedBuffer(char[] cArr, Charset charset) {
        Objects.requireNonNull(cArr, "array");
        return copiedBuffer(cArr, 0, cArr.length, charset);
    }

    public static ByteBuf copiedBuffer(ByteBuf... byteBufArr) {
        int length = byteBufArr.length;
        if (length == 0) {
            return EMPTY_BUFFER;
        }
        if (length == 1) {
            return copiedBuffer(byteBufArr[0]);
        }
        ByteOrder byteOrderOrder = null;
        int i2 = 0;
        for (ByteBuf byteBuf : byteBufArr) {
            int i3 = byteBuf.readableBytes();
            if (i3 > 0) {
                if (Integer.MAX_VALUE - i2 < i3) {
                    throw new IllegalArgumentException("The total length of the specified buffers is too big.");
                }
                i2 += i3;
                if (byteOrderOrder == null) {
                    byteOrderOrder = byteBuf.order();
                } else if (!byteOrderOrder.equals(byteBuf.order())) {
                    throw new IllegalArgumentException("inconsistent byte order");
                }
            }
        }
        if (i2 == 0) {
            return EMPTY_BUFFER;
        }
        byte[] bArr = new byte[i2];
        int i4 = 0;
        for (ByteBuf byteBuf2 : byteBufArr) {
            int i5 = byteBuf2.readableBytes();
            byteBuf2.getBytes(byteBuf2.readerIndex(), bArr, i4, i5);
            i4 += i5;
        }
        return wrappedBuffer(bArr).order(byteOrderOrder);
    }

    public static ByteBuf copiedBuffer(ByteBuffer... byteBufferArr) {
        int length = byteBufferArr.length;
        if (length == 0) {
            return EMPTY_BUFFER;
        }
        if (length == 1) {
            return copiedBuffer(byteBufferArr[0]);
        }
        ByteOrder byteOrderOrder = null;
        int i2 = 0;
        for (ByteBuffer byteBuffer : byteBufferArr) {
            int iRemaining = byteBuffer.remaining();
            if (iRemaining > 0) {
                if (Integer.MAX_VALUE - i2 < iRemaining) {
                    throw new IllegalArgumentException("The total length of the specified buffers is too big.");
                }
                i2 += iRemaining;
                if (byteOrderOrder == null) {
                    byteOrderOrder = byteBuffer.order();
                } else if (!byteOrderOrder.equals(byteBuffer.order())) {
                    throw new IllegalArgumentException("inconsistent byte order");
                }
            }
        }
        if (i2 == 0) {
            return EMPTY_BUFFER;
        }
        byte[] bArr = new byte[i2];
        int i3 = 0;
        for (ByteBuffer byteBuffer2 : byteBufferArr) {
            ByteBuffer byteBufferDuplicate = byteBuffer2.duplicate();
            int iRemaining2 = byteBufferDuplicate.remaining();
            byteBufferDuplicate.get(bArr, i3, iRemaining2);
            i3 += iRemaining2;
        }
        return wrappedBuffer(bArr).order(byteOrderOrder);
    }

    public static ByteBuf copiedBuffer(byte[]... bArr) {
        int length = bArr.length;
        if (length == 0) {
            return EMPTY_BUFFER;
        }
        if (length == 1) {
            return bArr[0].length == 0 ? EMPTY_BUFFER : copiedBuffer(bArr[0]);
        }
        int length2 = 0;
        for (byte[] bArr2 : bArr) {
            if (Integer.MAX_VALUE - length2 < bArr2.length) {
                throw new IllegalArgumentException("The total length of the specified arrays is too big.");
            }
            length2 += bArr2.length;
        }
        if (length2 == 0) {
            return EMPTY_BUFFER;
        }
        byte[] bArr3 = new byte[length2];
        int length3 = 0;
        for (byte[] bArr4 : bArr) {
            System.arraycopy(bArr4, 0, bArr3, length3, bArr4.length);
            length3 += bArr4.length;
        }
        return wrappedBuffer(bArr3);
    }

    public static ByteBuf copyBoolean(boolean z2) {
        ByteBuf byteBufBuffer = buffer(1);
        byteBufBuffer.writeBoolean(z2);
        return byteBufBuffer;
    }

    public static ByteBuf copyBoolean(boolean... zArr) {
        if (zArr == null || zArr.length == 0) {
            return EMPTY_BUFFER;
        }
        ByteBuf byteBufBuffer = buffer(zArr.length);
        for (boolean z2 : zArr) {
            byteBufBuffer.writeBoolean(z2);
        }
        return byteBufBuffer;
    }

    public static ByteBuf copyDouble(double d2) {
        ByteBuf byteBufBuffer = buffer(8);
        byteBufBuffer.writeDouble(d2);
        return byteBufBuffer;
    }

    public static ByteBuf copyDouble(double... dArr) {
        if (dArr == null || dArr.length == 0) {
            return EMPTY_BUFFER;
        }
        ByteBuf byteBufBuffer = buffer(dArr.length * 8);
        for (double d2 : dArr) {
            byteBufBuffer.writeDouble(d2);
        }
        return byteBufBuffer;
    }

    public static ByteBuf copyFloat(float f2) {
        ByteBuf byteBufBuffer = buffer(4);
        byteBufBuffer.writeFloat(f2);
        return byteBufBuffer;
    }

    public static ByteBuf copyFloat(float... fArr) {
        if (fArr == null || fArr.length == 0) {
            return EMPTY_BUFFER;
        }
        ByteBuf byteBufBuffer = buffer(fArr.length * 4);
        for (float f2 : fArr) {
            byteBufBuffer.writeFloat(f2);
        }
        return byteBufBuffer;
    }

    public static ByteBuf copyInt(int i2) {
        ByteBuf byteBufBuffer = buffer(4);
        byteBufBuffer.writeInt(i2);
        return byteBufBuffer;
    }

    public static ByteBuf copyInt(int... iArr) {
        if (iArr == null || iArr.length == 0) {
            return EMPTY_BUFFER;
        }
        ByteBuf byteBufBuffer = buffer(iArr.length * 4);
        for (int i2 : iArr) {
            byteBufBuffer.writeInt(i2);
        }
        return byteBufBuffer;
    }

    public static ByteBuf copyLong(long j2) {
        ByteBuf byteBufBuffer = buffer(8);
        byteBufBuffer.writeLong(j2);
        return byteBufBuffer;
    }

    public static ByteBuf copyLong(long... jArr) {
        if (jArr == null || jArr.length == 0) {
            return EMPTY_BUFFER;
        }
        ByteBuf byteBufBuffer = buffer(jArr.length * 8);
        for (long j2 : jArr) {
            byteBufBuffer.writeLong(j2);
        }
        return byteBufBuffer;
    }

    public static ByteBuf copyMedium(int i2) {
        ByteBuf byteBufBuffer = buffer(3);
        byteBufBuffer.writeMedium(i2);
        return byteBufBuffer;
    }

    public static ByteBuf copyMedium(int... iArr) {
        if (iArr == null || iArr.length == 0) {
            return EMPTY_BUFFER;
        }
        ByteBuf byteBufBuffer = buffer(iArr.length * 3);
        for (int i2 : iArr) {
            byteBufBuffer.writeMedium(i2);
        }
        return byteBufBuffer;
    }

    public static ByteBuf copyShort(int i2) {
        ByteBuf byteBufBuffer = buffer(2);
        byteBufBuffer.writeShort(i2);
        return byteBufBuffer;
    }

    public static ByteBuf copyShort(int... iArr) {
        if (iArr == null || iArr.length == 0) {
            return EMPTY_BUFFER;
        }
        ByteBuf byteBufBuffer = buffer(iArr.length * 2);
        for (int i2 : iArr) {
            byteBufBuffer.writeShort(i2);
        }
        return byteBufBuffer;
    }

    public static ByteBuf copyShort(short... sArr) {
        if (sArr == null || sArr.length == 0) {
            return EMPTY_BUFFER;
        }
        ByteBuf byteBufBuffer = buffer(sArr.length * 2);
        for (short s2 : sArr) {
            byteBufBuffer.writeShort(s2);
        }
        return byteBufBuffer;
    }

    public static ByteBuf directBuffer() {
        return ALLOC.directBuffer();
    }

    public static ByteBuf directBuffer(int i2) {
        return ALLOC.directBuffer(i2);
    }

    public static ByteBuf directBuffer(int i2, int i3) {
        return ALLOC.directBuffer(i2, i3);
    }

    @Deprecated
    public static ByteBuf unmodifiableBuffer(ByteBuf byteBuf) {
        ByteOrder byteOrderOrder = byteBuf.order();
        ByteOrder byteOrder = BIG_ENDIAN;
        return byteOrderOrder == byteOrder ? new ReadOnlyByteBuf(byteBuf) : new ReadOnlyByteBuf(byteBuf.order(byteOrder)).order(LITTLE_ENDIAN);
    }

    public static ByteBuf unmodifiableBuffer(ByteBuf... byteBufArr) {
        return new FixedCompositeByteBuf(ALLOC, byteBufArr);
    }

    public static ByteBuf unreleasableBuffer(ByteBuf byteBuf) {
        return new UnreleasableByteBuf(byteBuf);
    }

    public static ByteBuf wrappedBuffer(int i2, ByteBuf... byteBufArr) {
        int length = byteBufArr.length;
        if (length != 0) {
            if (length != 1) {
                for (int i3 = 0; i3 < byteBufArr.length; i3++) {
                    ByteBuf byteBuf = byteBufArr[i3];
                    if (byteBuf.isReadable()) {
                        return new CompositeByteBuf(ALLOC, false, i2, byteBufArr, i3, byteBufArr.length);
                    }
                    byteBuf.release();
                }
            } else {
                ByteBuf byteBuf2 = byteBufArr[0];
                if (byteBuf2.isReadable()) {
                    return wrappedBuffer(byteBuf2.order(BIG_ENDIAN));
                }
                byteBuf2.release();
            }
        }
        return EMPTY_BUFFER;
    }

    public static ByteBuf wrappedBuffer(int i2, ByteBuffer... byteBufferArr) {
        int length = byteBufferArr.length;
        if (length != 0) {
            if (length != 1) {
                ArrayList arrayList = new ArrayList(byteBufferArr.length);
                for (ByteBuffer byteBuffer : byteBufferArr) {
                    if (byteBuffer == null) {
                        break;
                    }
                    if (byteBuffer.remaining() > 0) {
                        arrayList.add(wrappedBuffer(byteBuffer.order(BIG_ENDIAN)));
                    }
                }
                if (!arrayList.isEmpty()) {
                    return new CompositeByteBuf(ALLOC, false, i2, (Iterable<ByteBuf>) arrayList);
                }
            } else if (byteBufferArr[0].hasRemaining()) {
                return wrappedBuffer(byteBufferArr[0].order(BIG_ENDIAN));
            }
        }
        return EMPTY_BUFFER;
    }

    public static ByteBuf wrappedBuffer(int i2, byte[]... bArr) {
        int length = bArr.length;
        if (length != 0) {
            if (length != 1) {
                ArrayList arrayList = new ArrayList(bArr.length);
                for (byte[] bArr2 : bArr) {
                    if (bArr2 == null) {
                        break;
                    }
                    if (bArr2.length > 0) {
                        arrayList.add(wrappedBuffer(bArr2));
                    }
                }
                if (!arrayList.isEmpty()) {
                    return new CompositeByteBuf(ALLOC, false, i2, (Iterable<ByteBuf>) arrayList);
                }
            } else if (bArr[0].length != 0) {
                return wrappedBuffer(bArr[0]);
            }
        }
        return EMPTY_BUFFER;
    }

    public static ByteBuf wrappedBuffer(long j2, int i2, boolean z2) {
        return new WrappedUnpooledUnsafeDirectByteBuf(ALLOC, j2, i2, z2);
    }

    public static ByteBuf wrappedBuffer(ByteBuf byteBuf) {
        if (byteBuf.isReadable()) {
            return byteBuf.slice();
        }
        byteBuf.release();
        return EMPTY_BUFFER;
    }

    public static ByteBuf wrappedBuffer(ByteBuffer byteBuffer) {
        if (!byteBuffer.hasRemaining()) {
            return EMPTY_BUFFER;
        }
        if (byteBuffer.isDirect() || !byteBuffer.hasArray()) {
            return PlatformDependent.hasUnsafe() ? byteBuffer.isReadOnly() ? byteBuffer.isDirect() ? new ReadOnlyUnsafeDirectByteBuf(ALLOC, byteBuffer) : new ReadOnlyByteBufferBuf(ALLOC, byteBuffer) : new UnpooledUnsafeDirectByteBuf(ALLOC, byteBuffer, byteBuffer.remaining()) : byteBuffer.isReadOnly() ? new ReadOnlyByteBufferBuf(ALLOC, byteBuffer) : new UnpooledDirectByteBuf(ALLOC, byteBuffer, byteBuffer.remaining());
        }
        return wrappedBuffer(byteBuffer.array(), byteBuffer.position() + byteBuffer.arrayOffset(), byteBuffer.remaining()).order(byteBuffer.order());
    }

    public static ByteBuf wrappedBuffer(byte[] bArr) {
        return bArr.length == 0 ? EMPTY_BUFFER : new UnpooledHeapByteBuf(ALLOC, bArr, bArr.length);
    }

    public static ByteBuf wrappedBuffer(byte[] bArr, int i2, int i3) {
        return i3 == 0 ? EMPTY_BUFFER : (i2 == 0 && i3 == bArr.length) ? wrappedBuffer(bArr) : wrappedBuffer(bArr).slice(i2, i3);
    }

    public static ByteBuf wrappedBuffer(ByteBuf... byteBufArr) {
        return wrappedBuffer(16, byteBufArr);
    }

    public static ByteBuf wrappedBuffer(ByteBuffer... byteBufferArr) {
        return wrappedBuffer(16, byteBufferArr);
    }

    public static ByteBuf wrappedBuffer(byte[]... bArr) {
        return wrappedBuffer(16, bArr);
    }
}