package defpackage;

import java.lang.reflect.Field;
import java.nio.Buffer;
import java.nio.ByteOrder;
import java.security.AccessController;
import java.util.logging.Level;
import java.util.logging.Logger;
import sun.misc.Unsafe;

/* JADX INFO: loaded from: classes.dex */
final class g8a {
    public static final Logger a = Logger.getLogger(g8a.class.getName());
    public static final Unsafe b;
    public static final Class c;
    public static final d d;
    public static final boolean e;
    public static final boolean f;
    public static final long g;
    public static final long h;
    public static final boolean i;

    public static final class a extends d {
        @Override // g8a.d
        public final void c(long j, byte[] bArr, long j2, long j3) {
            throw new UnsupportedOperationException();
        }

        @Override // g8a.d
        public final void d(byte[] bArr, long j, long j2, long j3) {
            throw new UnsupportedOperationException();
        }

        @Override // g8a.d
        public final boolean e(Object obj, long j) {
            return g8a.i ? g8a.g(obj, j) != 0 : g8a.h(obj, j) != 0;
        }

        @Override // g8a.d
        public final byte f(long j) {
            throw new UnsupportedOperationException();
        }

        @Override // g8a.d
        public final byte g(Object obj, long j) {
            return g8a.i ? g8a.g(obj, j) : g8a.h(obj, j);
        }

        @Override // g8a.d
        public final double h(Object obj, long j) {
            return Double.longBitsToDouble(l(obj, j));
        }

        @Override // g8a.d
        public final float i(Object obj, long j) {
            return Float.intBitsToFloat(j(obj, j));
        }

        @Override // g8a.d
        public final long k(long j) {
            throw new UnsupportedOperationException();
        }

        @Override // g8a.d
        public final void o(Object obj, long j, boolean z) {
            if (g8a.i) {
                g8a.l(obj, j, z ? (byte) 1 : (byte) 0);
            } else {
                g8a.m(obj, j, z ? (byte) 1 : (byte) 0);
            }
        }

        @Override // g8a.d
        public final void p(long j, byte b) {
            throw new UnsupportedOperationException();
        }

        @Override // g8a.d
        public final void q(Object obj, long j, byte b) {
            if (g8a.i) {
                g8a.l(obj, j, b);
            } else {
                g8a.m(obj, j, b);
            }
        }

        @Override // g8a.d
        public final void r(Object obj, long j, double d) {
            u(obj, j, Double.doubleToLongBits(d));
        }

        @Override // g8a.d
        public final void s(Object obj, long j, float f) {
            t(obj, j, Float.floatToIntBits(f));
        }
    }

    public static final class b extends d {
        @Override // g8a.d
        public final void c(long j, byte[] bArr, long j2, long j3) {
            throw new UnsupportedOperationException();
        }

        @Override // g8a.d
        public final void d(byte[] bArr, long j, long j2, long j3) {
            throw new UnsupportedOperationException();
        }

        @Override // g8a.d
        public final boolean e(Object obj, long j) {
            return g8a.i ? g8a.g(obj, j) != 0 : g8a.h(obj, j) != 0;
        }

        @Override // g8a.d
        public final byte f(long j) {
            throw new UnsupportedOperationException();
        }

        @Override // g8a.d
        public final byte g(Object obj, long j) {
            return g8a.i ? g8a.g(obj, j) : g8a.h(obj, j);
        }

        @Override // g8a.d
        public final double h(Object obj, long j) {
            return Double.longBitsToDouble(l(obj, j));
        }

        @Override // g8a.d
        public final float i(Object obj, long j) {
            return Float.intBitsToFloat(j(obj, j));
        }

        @Override // g8a.d
        public final long k(long j) {
            throw new UnsupportedOperationException();
        }

        @Override // g8a.d
        public final void o(Object obj, long j, boolean z) {
            if (g8a.i) {
                g8a.l(obj, j, z ? (byte) 1 : (byte) 0);
            } else {
                g8a.m(obj, j, z ? (byte) 1 : (byte) 0);
            }
        }

        @Override // g8a.d
        public final void p(long j, byte b) {
            throw new UnsupportedOperationException();
        }

        @Override // g8a.d
        public final void q(Object obj, long j, byte b) {
            if (g8a.i) {
                g8a.l(obj, j, b);
            } else {
                g8a.m(obj, j, b);
            }
        }

        @Override // g8a.d
        public final void r(Object obj, long j, double d) {
            u(obj, j, Double.doubleToLongBits(d));
        }

        @Override // g8a.d
        public final void s(Object obj, long j, float f) {
            t(obj, j, Float.floatToIntBits(f));
        }
    }

    public static final class c extends d {
        @Override // g8a.d
        public final void c(long j, byte[] bArr, long j2, long j3) {
            this.a.copyMemory((Object) null, j, bArr, g8a.g + j2, j3);
        }

        @Override // g8a.d
        public final void d(byte[] bArr, long j, long j2, long j3) {
            this.a.copyMemory(bArr, g8a.g + j, (Object) null, j2, j3);
        }

        @Override // g8a.d
        public final boolean e(Object obj, long j) {
            return this.a.getBoolean(obj, j);
        }

        @Override // g8a.d
        public final byte f(long j) {
            return this.a.getByte(j);
        }

        @Override // g8a.d
        public final byte g(Object obj, long j) {
            return this.a.getByte(obj, j);
        }

        @Override // g8a.d
        public final double h(Object obj, long j) {
            return this.a.getDouble(obj, j);
        }

        @Override // g8a.d
        public final float i(Object obj, long j) {
            return this.a.getFloat(obj, j);
        }

        @Override // g8a.d
        public final long k(long j) {
            return this.a.getLong(j);
        }

        @Override // g8a.d
        public final void o(Object obj, long j, boolean z) {
            this.a.putBoolean(obj, j, z);
        }

        @Override // g8a.d
        public final void p(long j, byte b) {
            this.a.putByte(j, b);
        }

        @Override // g8a.d
        public final void q(Object obj, long j, byte b) {
            this.a.putByte(obj, j, b);
        }

        @Override // g8a.d
        public final void r(Object obj, long j, double d) {
            this.a.putDouble(obj, j, d);
        }

        @Override // g8a.d
        public final void s(Object obj, long j, float f) {
            this.a.putFloat(obj, j, f);
        }
    }

    public static abstract class d {
        public final Unsafe a;

        public d(Unsafe unsafe) {
            this.a = unsafe;
        }

        public final int a(Class cls) {
            return this.a.arrayBaseOffset(cls);
        }

        public final int b(Class cls) {
            return this.a.arrayIndexScale(cls);
        }

        public abstract void c(long j, byte[] bArr, long j2, long j3);

        public abstract void d(byte[] bArr, long j, long j2, long j3);

        public abstract boolean e(Object obj, long j);

        public abstract byte f(long j);

        public abstract byte g(Object obj, long j);

        public abstract double h(Object obj, long j);

        public abstract float i(Object obj, long j);

        public final int j(Object obj, long j) {
            return this.a.getInt(obj, j);
        }

        public abstract long k(long j);

        public final long l(Object obj, long j) {
            return this.a.getLong(obj, j);
        }

        public final Object m(Object obj, long j) {
            return this.a.getObject(obj, j);
        }

        public final long n(Field field) {
            return this.a.objectFieldOffset(field);
        }

        public abstract void o(Object obj, long j, boolean z);

        public abstract void p(long j, byte b);

        public abstract void q(Object obj, long j, byte b);

        public abstract void r(Object obj, long j, double d);

        public abstract void s(Object obj, long j, float f);

        public final void t(Object obj, long j, int i) {
            this.a.putInt(obj, j, i);
        }

        public final void u(Object obj, long j, long j2) {
            this.a.putLong(obj, j, j2);
        }

        public final void v(Object obj, long j, Object obj2) {
            this.a.putObject(obj, j, obj2);
        }
    }

    static {
        Class cls;
        boolean z;
        boolean z2;
        d dVar;
        Unsafe unsafeI = i();
        b = unsafeI;
        c = zi.a;
        Class cls2 = Long.TYPE;
        boolean zE = e(cls2);
        Class cls3 = Integer.TYPE;
        boolean zE2 = e(cls3);
        d cVar = null;
        if (unsafeI != null) {
            if (!zi.a()) {
                cVar = new c(unsafeI);
            } else if (zE) {
                cVar = new b(unsafeI);
            } else if (zE2) {
                cVar = new a(unsafeI);
            }
        }
        d = cVar;
        Class cls4 = Byte.TYPE;
        if (unsafeI == null) {
            cls = Field.class;
            z = false;
        } else {
            try {
                Class<?> cls5 = unsafeI.getClass();
                cls5.getMethod("objectFieldOffset", Field.class);
                cls5.getMethod("getLong", Object.class, cls2);
                if (d() == null) {
                    cls = Field.class;
                } else {
                    if (!zi.a()) {
                        cls5.getMethod("getByte", cls2);
                        cls5.getMethod("putByte", cls2, cls4);
                        cls5.getMethod("getInt", cls2);
                        cls5.getMethod("putInt", cls2, cls3);
                        cls5.getMethod("getLong", cls2);
                        cls5.getMethod("putLong", cls2, cls2);
                        cls5.getMethod("copyMemory", cls2, cls2, cls2);
                        cls5.getMethod("copyMemory", Object.class, cls2, Object.class, cls2, cls2);
                    }
                    cls = Field.class;
                    z = true;
                }
            } catch (Throwable th) {
                cls = Field.class;
                a.log(Level.WARNING, "platform method missing - proto runtime falling back to safer methods: " + th);
            }
            z = false;
        }
        e = z;
        Unsafe unsafe = b;
        if (unsafe == null) {
            z2 = false;
        } else {
            try {
                Class<?> cls6 = unsafe.getClass();
                cls6.getMethod("objectFieldOffset", cls);
                cls6.getMethod("arrayBaseOffset", Class.class);
                cls6.getMethod("arrayIndexScale", Class.class);
                cls6.getMethod("getInt", Object.class, cls2);
                cls6.getMethod("putInt", Object.class, cls2, cls3);
                cls6.getMethod("getLong", Object.class, cls2);
                cls6.getMethod("putLong", Object.class, cls2, cls2);
                cls6.getMethod("getObject", Object.class, cls2);
                cls6.getMethod("putObject", Object.class, cls2, Object.class);
                if (!zi.a()) {
                    cls6.getMethod("getByte", Object.class, cls2);
                    cls6.getMethod("putByte", Object.class, cls2, cls4);
                    cls6.getMethod("getBoolean", Object.class, cls2);
                    cls6.getMethod("putBoolean", Object.class, cls2, Boolean.TYPE);
                    cls6.getMethod("getFloat", Object.class, cls2);
                    cls6.getMethod("putFloat", Object.class, cls2, Float.TYPE);
                    cls6.getMethod("getDouble", Object.class, cls2);
                    cls6.getMethod("putDouble", Object.class, cls2, Double.TYPE);
                }
                z2 = true;
            } catch (Throwable th2) {
                a.log(Level.WARNING, "platform method missing - proto runtime falling back to safer methods: " + th2);
                z2 = false;
            }
        }
        f = z2;
        g = b(byte[].class);
        b(boolean[].class);
        c(boolean[].class);
        b(int[].class);
        c(int[].class);
        b(long[].class);
        c(long[].class);
        b(float[].class);
        c(float[].class);
        b(double[].class);
        c(double[].class);
        b(Object[].class);
        c(Object[].class);
        Field fieldD = d();
        h = (fieldD == null || (dVar = d) == null) ? -1L : dVar.n(fieldD);
        i = ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN;
    }

    public static Object a(Class cls) {
        try {
            return b.allocateInstance(cls);
        } catch (InstantiationException e2) {
            throw new IllegalStateException(e2);
        }
    }

    public static int b(Class cls) {
        if (f) {
            return d.a(cls);
        }
        return -1;
    }

    public static void c(Class cls) {
        if (f) {
            d.b(cls);
        }
    }

    public static Field d() {
        Field declaredField;
        Field declaredField2;
        if (zi.a()) {
            try {
                declaredField2 = Buffer.class.getDeclaredField("effectiveDirectAddress");
            } catch (Throwable unused) {
                declaredField2 = null;
            }
            if (declaredField2 != null) {
                return declaredField2;
            }
        }
        try {
            declaredField = Buffer.class.getDeclaredField("address");
        } catch (Throwable unused2) {
            declaredField = null;
        }
        if (declaredField == null || declaredField.getType() != Long.TYPE) {
            return null;
        }
        return declaredField;
    }

    public static boolean e(Class cls) {
        if (!zi.a()) {
            return false;
        }
        try {
            Class cls2 = c;
            Class cls3 = Boolean.TYPE;
            cls2.getMethod("peekLong", cls, cls3);
            cls2.getMethod("pokeLong", cls, Long.TYPE, cls3);
            Class cls4 = Integer.TYPE;
            cls2.getMethod("pokeInt", cls, cls4, cls3);
            cls2.getMethod("peekInt", cls, cls3);
            cls2.getMethod("pokeByte", cls, Byte.TYPE);
            cls2.getMethod("peekByte", cls);
            cls2.getMethod("pokeByteArray", cls, byte[].class, cls4, cls4);
            cls2.getMethod("peekByteArray", cls, byte[].class, cls4, cls4);
            return true;
        } catch (Throwable unused) {
            return false;
        }
    }

    public static byte f(byte[] bArr, long j) {
        return d.g(bArr, g + j);
    }

    public static byte g(Object obj, long j) {
        return (byte) ((d.j(obj, (-4) & j) >>> ((int) (((~j) & 3) << 3))) & 255);
    }

    public static byte h(Object obj, long j) {
        return (byte) ((d.j(obj, (-4) & j) >>> ((int) ((j & 3) << 3))) & 255);
    }

    public static Unsafe i() {
        try {
            return (Unsafe) AccessController.doPrivileged(new f8a());
        } catch (Throwable unused) {
            return null;
        }
    }

    public static void j(long j, byte b2) {
        d.p(j, b2);
    }

    public static void k(byte[] bArr, long j, byte b2) {
        d.q(bArr, g + j, b2);
    }

    public static void l(Object obj, long j, byte b2) {
        long j2 = (-4) & j;
        int iJ = d.j(obj, j2);
        int i2 = ((~((int) j)) & 3) << 3;
        n(obj, j2, ((255 & b2) << i2) | (iJ & (~(255 << i2))));
    }

    public static void m(Object obj, long j, byte b2) {
        long j2 = (-4) & j;
        int i2 = (((int) j) & 3) << 3;
        n(obj, j2, ((255 & b2) << i2) | (d.j(obj, j2) & (~(255 << i2))));
    }

    public static void n(Object obj, long j, int i2) {
        d.t(obj, j, i2);
    }

    public static void o(Object obj, long j, long j2) {
        d.u(obj, j, j2);
    }

    public static void p(Object obj, long j, Object obj2) {
        d.v(obj, j, obj2);
    }
}