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;

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

    private Unpooled() {
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    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 wrappedBuffer(byte[] bArr, int i2, int i3) {
        if (i3 == 0) {
            return EMPTY_BUFFER;
        }
        if (i2 == 0 && i3 == bArr.length) {
            return wrappedBuffer(bArr);
        }
        return wrappedBuffer(bArr).slice(i2, i3);
    }

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

    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());
    }

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

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

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

    public static ByteBuf copiedBuffer(byte[]... bArr) {
        int length = bArr.length;
        if (length == 0) {
            return EMPTY_BUFFER;
        }
        if (length != 1) {
            int length2 = 0;
            for (byte[] bArr2 : bArr) {
                if (Integer.MAX_VALUE - length2 >= bArr2.length) {
                    length2 += bArr2.length;
                } else {
                    throw new IllegalArgumentException("The total length of the specified arrays is too big.");
                }
            }
            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);
        }
        if (bArr[0].length == 0) {
            return EMPTY_BUFFER;
        }
        return copiedBuffer(bArr[0]);
    }

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

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

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

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

    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 copiedBuffer(ByteBuf... byteBufArr) {
        int length = byteBufArr.length;
        if (length == 0) {
            return EMPTY_BUFFER;
        }
        if (length != 1) {
            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) {
                        if (!byteOrderOrder.equals(byteBuf.order())) {
                            throw new IllegalArgumentException("inconsistent byte order");
                        }
                    } else {
                        byteOrderOrder = byteBuf.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);
        }
        return copiedBuffer(byteBufArr[0]);
    }

    public static ByteBuf wrappedBuffer(int i2, ByteBuf... byteBufArr) {
        int length = byteBufArr.length;
        if (length != 0) {
            if (length != 1) {
                for (ByteBuf byteBuf : byteBufArr) {
                    if (byteBuf.isReadable()) {
                        return new CompositeByteBuf(ALLOC, false, i2, byteBufArr);
                    }
                    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 copiedBuffer(ByteBuffer... byteBufferArr) {
        int length = byteBufferArr.length;
        if (length == 0) {
            return EMPTY_BUFFER;
        }
        if (length != 1) {
            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) {
                        if (!byteOrderOrder.equals(byteBuffer.order())) {
                            throw new IllegalArgumentException("inconsistent byte order");
                        }
                    } else {
                        byteOrderOrder = byteBuffer.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);
        }
        return copiedBuffer(byteBufferArr[0]);
    }

    public static ByteBuf copiedBuffer(CharSequence charSequence, Charset charset) {
        if (charSequence != null) {
            if (charSequence instanceof CharBuffer) {
                return copiedBuffer((CharBuffer) charSequence, charset);
            }
            return copiedBuffer(CharBuffer.wrap(charSequence), charset);
        }
        throw new NullPointerException("string");
    }

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

    public static ByteBuf copiedBuffer(char[] cArr, Charset charset) {
        if (cArr != null) {
            return copiedBuffer(cArr, 0, cArr.length, charset);
        }
        throw new NullPointerException("array");
    }

    public static ByteBuf copiedBuffer(char[] cArr, int i2, int i3, Charset charset) {
        if (cArr == null) {
            throw new NullPointerException("array");
        }
        if (i3 == 0) {
            return EMPTY_BUFFER;
        }
        return copiedBuffer(CharBuffer.wrap(cArr, i2, i3), charset);
    }

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