package ed;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import java.io.ByteArrayOutputStream;
import java.math.BigInteger;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

/* JADX INFO: loaded from: classes.dex */
public class z implements p {

    /* JADX INFO: renamed from: a, reason: collision with root package name */
    public static final z f25850a = new z();

    /* JADX INFO: renamed from: b, reason: collision with root package name */
    public static final boolean f25851b;

    /* JADX INFO: renamed from: c, reason: collision with root package name */
    public static final Charset f25852c;

    static {
        f25851b = ByteOrder.nativeOrder() == ByteOrder.LITTLE_ENDIAN;
        f25852c = Charset.forName("UTF8");
    }

    public static final void a(int i10, ByteBuffer byteBuffer) {
        int iPosition = byteBuffer.position() % i10;
        if (iPosition != 0) {
            byteBuffer.position((byteBuffer.position() + i10) - iPosition);
        }
    }

    public static final int b(ByteBuffer byteBuffer) {
        if (!byteBuffer.hasRemaining()) {
            throw new IllegalArgumentException("Message corrupted");
        }
        int i10 = byteBuffer.get() & 255;
        return i10 < 254 ? i10 : i10 == 254 ? byteBuffer.getChar() : byteBuffer.getInt();
    }

    public static final void c(ByteArrayOutputStream byteArrayOutputStream, int i10) {
        int size = byteArrayOutputStream.size() % i10;
        if (size != 0) {
            for (int i11 = 0; i11 < i10 - size; i11++) {
                byteArrayOutputStream.write(0);
            }
        }
    }

    public static final void d(ByteArrayOutputStream byteArrayOutputStream, int i10) {
        if (f25851b) {
            byteArrayOutputStream.write(i10);
            byteArrayOutputStream.write(i10 >>> 8);
            byteArrayOutputStream.write(i10 >>> 16);
            byteArrayOutputStream.write(i10 >>> 24);
            return;
        }
        byteArrayOutputStream.write(i10 >>> 24);
        byteArrayOutputStream.write(i10 >>> 16);
        byteArrayOutputStream.write(i10 >>> 8);
        byteArrayOutputStream.write(i10);
    }

    public static final void e(ByteArrayOutputStream byteArrayOutputStream, long j10) {
        if (f25851b) {
            byteArrayOutputStream.write((byte) j10);
            byteArrayOutputStream.write((byte) (j10 >>> 8));
            byteArrayOutputStream.write((byte) (j10 >>> 16));
            byteArrayOutputStream.write((byte) (j10 >>> 24));
            byteArrayOutputStream.write((byte) (j10 >>> 32));
            byteArrayOutputStream.write((byte) (j10 >>> 40));
            byteArrayOutputStream.write((byte) (j10 >>> 48));
            byteArrayOutputStream.write((byte) (j10 >>> 56));
            return;
        }
        byteArrayOutputStream.write((byte) (j10 >>> 56));
        byteArrayOutputStream.write((byte) (j10 >>> 48));
        byteArrayOutputStream.write((byte) (j10 >>> 40));
        byteArrayOutputStream.write((byte) (j10 >>> 32));
        byteArrayOutputStream.write((byte) (j10 >>> 24));
        byteArrayOutputStream.write((byte) (j10 >>> 16));
        byteArrayOutputStream.write((byte) (j10 >>> 8));
        byteArrayOutputStream.write((byte) j10);
    }

    public static final void f(ByteArrayOutputStream byteArrayOutputStream, int i10) {
        if (i10 < 254) {
            byteArrayOutputStream.write(i10);
            return;
        }
        if (i10 > 65535) {
            byteArrayOutputStream.write(255);
            d(byteArrayOutputStream, i10);
            return;
        }
        byteArrayOutputStream.write(254);
        if (f25851b) {
            byteArrayOutputStream.write(i10);
            byteArrayOutputStream.write(i10 >>> 8);
        } else {
            byteArrayOutputStream.write(i10 >>> 8);
            byteArrayOutputStream.write(i10);
        }
    }

    @Override // ed.p
    @Nullable
    public Object decodeMessage(@Nullable ByteBuffer byteBuffer) {
        if (byteBuffer == null) {
            return null;
        }
        byteBuffer.order(ByteOrder.nativeOrder());
        Object value = readValue(byteBuffer);
        if (byteBuffer.hasRemaining()) {
            throw new IllegalArgumentException("Message corrupted");
        }
        return value;
    }

    @Override // ed.p
    @Nullable
    public ByteBuffer encodeMessage(@Nullable Object obj) {
        if (obj == null) {
            return null;
        }
        y yVar = new y();
        writeValue(yVar, obj);
        ByteBuffer byteBufferAllocateDirect = ByteBuffer.allocateDirect(yVar.size());
        byteBufferAllocateDirect.put(yVar.e(), 0, yVar.size());
        return byteBufferAllocateDirect;
    }

    @Nullable
    public final Object readValue(@NonNull ByteBuffer byteBuffer) {
        if (byteBuffer.hasRemaining()) {
            return readValueOfType(byteBuffer.get(), byteBuffer);
        }
        throw new IllegalArgumentException("Message corrupted");
    }

    @Nullable
    public Object readValueOfType(byte b10, @NonNull ByteBuffer byteBuffer) {
        Object bigInteger;
        Charset charset = f25852c;
        int i10 = 0;
        switch (b10) {
            case 0:
                return null;
            case 1:
                return Boolean.TRUE;
            case 2:
                return Boolean.FALSE;
            case 3:
                return Integer.valueOf(byteBuffer.getInt());
            case 4:
                return Long.valueOf(byteBuffer.getLong());
            case 5:
                byte[] bArr = new byte[b(byteBuffer)];
                byteBuffer.get(bArr);
                bigInteger = new BigInteger(new String(bArr, charset), 16);
                break;
            case 6:
                a(8, byteBuffer);
                return Double.valueOf(byteBuffer.getDouble());
            case 7:
                byte[] bArr2 = new byte[b(byteBuffer)];
                byteBuffer.get(bArr2);
                bigInteger = new String(bArr2, charset);
                break;
            case 8:
                byte[] bArr3 = new byte[b(byteBuffer)];
                byteBuffer.get(bArr3);
                return bArr3;
            case 9:
                int iB = b(byteBuffer);
                int[] iArr = new int[iB];
                a(4, byteBuffer);
                byteBuffer.asIntBuffer().get(iArr);
                byteBuffer.position((iB * 4) + byteBuffer.position());
                return iArr;
            case 10:
                int iB2 = b(byteBuffer);
                long[] jArr = new long[iB2];
                a(8, byteBuffer);
                byteBuffer.asLongBuffer().get(jArr);
                byteBuffer.position((iB2 * 8) + byteBuffer.position());
                return jArr;
            case 11:
                int iB3 = b(byteBuffer);
                double[] dArr = new double[iB3];
                a(8, byteBuffer);
                byteBuffer.asDoubleBuffer().get(dArr);
                byteBuffer.position((iB3 * 8) + byteBuffer.position());
                return dArr;
            case 12:
                int iB4 = b(byteBuffer);
                ArrayList arrayList = new ArrayList(iB4);
                while (i10 < iB4) {
                    arrayList.add(readValue(byteBuffer));
                    i10++;
                }
                return arrayList;
            case 13:
                int iB5 = b(byteBuffer);
                HashMap map = new HashMap();
                while (i10 < iB5) {
                    map.put(readValue(byteBuffer), readValue(byteBuffer));
                    i10++;
                }
                return map;
            case 14:
                int iB6 = b(byteBuffer);
                float[] fArr = new float[iB6];
                a(4, byteBuffer);
                byteBuffer.asFloatBuffer().get(fArr);
                byteBuffer.position((iB6 * 4) + byteBuffer.position());
                return fArr;
            default:
                throw new IllegalArgumentException("Message corrupted");
        }
        return bigInteger;
    }

    public void writeValue(@NonNull ByteArrayOutputStream byteArrayOutputStream, @Nullable Object obj) {
        int i10 = 0;
        if (obj == null || obj.equals(null)) {
            byteArrayOutputStream.write(0);
            return;
        }
        if (obj instanceof Boolean) {
            byteArrayOutputStream.write(((Boolean) obj).booleanValue() ? 1 : 2);
            return;
        }
        boolean z10 = obj instanceof Number;
        Charset charset = f25852c;
        if (z10) {
            if ((obj instanceof Integer) || (obj instanceof Short) || (obj instanceof Byte)) {
                byteArrayOutputStream.write(3);
                d(byteArrayOutputStream, ((Number) obj).intValue());
                return;
            }
            if (obj instanceof Long) {
                byteArrayOutputStream.write(4);
                e(byteArrayOutputStream, ((Long) obj).longValue());
                return;
            }
            if ((obj instanceof Float) || (obj instanceof Double)) {
                byteArrayOutputStream.write(6);
                c(byteArrayOutputStream, 8);
                e(byteArrayOutputStream, Double.doubleToLongBits(((Number) obj).doubleValue()));
                return;
            } else {
                if (!(obj instanceof BigInteger)) {
                    throw new IllegalArgumentException("Unsupported Number type: " + obj.getClass());
                }
                byteArrayOutputStream.write(5);
                byte[] bytes = ((BigInteger) obj).toString(16).getBytes(charset);
                f(byteArrayOutputStream, bytes.length);
                byteArrayOutputStream.write(bytes, 0, bytes.length);
                return;
            }
        }
        if (obj instanceof CharSequence) {
            byteArrayOutputStream.write(7);
            byte[] bytes2 = obj.toString().getBytes(charset);
            f(byteArrayOutputStream, bytes2.length);
            byteArrayOutputStream.write(bytes2, 0, bytes2.length);
            return;
        }
        if (obj instanceof byte[]) {
            byteArrayOutputStream.write(8);
            byte[] bArr = (byte[]) obj;
            f(byteArrayOutputStream, bArr.length);
            byteArrayOutputStream.write(bArr, 0, bArr.length);
            return;
        }
        if (obj instanceof int[]) {
            byteArrayOutputStream.write(9);
            int[] iArr = (int[]) obj;
            f(byteArrayOutputStream, iArr.length);
            c(byteArrayOutputStream, 4);
            int length = iArr.length;
            while (i10 < length) {
                d(byteArrayOutputStream, iArr[i10]);
                i10++;
            }
            return;
        }
        if (obj instanceof long[]) {
            byteArrayOutputStream.write(10);
            long[] jArr = (long[]) obj;
            f(byteArrayOutputStream, jArr.length);
            c(byteArrayOutputStream, 8);
            int length2 = jArr.length;
            while (i10 < length2) {
                e(byteArrayOutputStream, jArr[i10]);
                i10++;
            }
            return;
        }
        if (obj instanceof double[]) {
            byteArrayOutputStream.write(11);
            double[] dArr = (double[]) obj;
            f(byteArrayOutputStream, dArr.length);
            c(byteArrayOutputStream, 8);
            int length3 = dArr.length;
            while (i10 < length3) {
                e(byteArrayOutputStream, Double.doubleToLongBits(dArr[i10]));
                i10++;
            }
            return;
        }
        if (obj instanceof List) {
            byteArrayOutputStream.write(12);
            List list = (List) obj;
            f(byteArrayOutputStream, list.size());
            Iterator it = list.iterator();
            while (it.hasNext()) {
                writeValue(byteArrayOutputStream, it.next());
            }
            return;
        }
        if (obj instanceof Map) {
            byteArrayOutputStream.write(13);
            Map map = (Map) obj;
            f(byteArrayOutputStream, map.size());
            for (Map.Entry entry : map.entrySet()) {
                writeValue(byteArrayOutputStream, entry.getKey());
                writeValue(byteArrayOutputStream, entry.getValue());
            }
            return;
        }
        if (!(obj instanceof float[])) {
            throw new IllegalArgumentException("Unsupported value: '" + obj + "' of type '" + obj.getClass() + "'");
        }
        byteArrayOutputStream.write(14);
        float[] fArr = (float[]) obj;
        f(byteArrayOutputStream, fArr.length);
        c(byteArrayOutputStream, 4);
        int length4 = fArr.length;
        while (i10 < length4) {
            d(byteArrayOutputStream, Float.floatToIntBits(fArr[i10]));
            i10++;
        }
    }
}