package com.google.android.gms.internal.pal;

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: classes2.dex */
public abstract class u1 {

    /* JADX INFO: renamed from: a, reason: collision with root package name */
    public static final Unsafe f21230a;

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

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

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

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

    /* JADX INFO: renamed from: f, reason: collision with root package name */
    public static final long f21235f;

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

    /* JADX WARN: Removed duplicated region for block: B:11:0x004a  */
    /* JADX WARN: Removed duplicated region for block: B:25:0x007b  */
    /* JADX WARN: Removed duplicated region for block: B:4:0x001e  */
    /* JADX WARN: Removed duplicated region for block: B:50:0x017a A[PHI: r0
      0x017a: PHI (r0v41 java.lang.reflect.Field) = (r0v35 java.lang.reflect.Field), (r0v37 java.lang.reflect.Field) binds: [B:43:0x0168, B:49:0x0178] A[DONT_GENERATE, DONT_INLINE]] */
    static {
        s1 s1Var;
        Field declaredField;
        boolean z10;
        boolean z11;
        Field declaredField2;
        Field field;
        s1 s1Var2;
        Unsafe unsafeJ = j();
        f21230a = unsafeJ;
        f21231b = k.a();
        Class<?> cls = Long.TYPE;
        boolean zT = t(cls);
        boolean zT2 = t(Integer.TYPE);
        if (unsafeJ != null) {
            s1Var = zT ? new s1(unsafeJ, 1) : zT2 ? new s1(unsafeJ, 0) : null;
        }
        f21232c = s1Var;
        if (s1Var == null) {
            z10 = false;
        } else {
            try {
                Class<?> cls2 = s1Var.f21217a.getClass();
                cls2.getMethod("objectFieldOffset", Field.class);
                cls2.getMethod("getLong", Object.class, cls);
                try {
                    declaredField = Buffer.class.getDeclaredField("effectiveDirectAddress");
                } catch (Throwable unused) {
                    declaredField = null;
                }
                if (declaredField == null) {
                    try {
                        declaredField = Buffer.class.getDeclaredField("address");
                    } catch (Throwable unused2) {
                        declaredField = null;
                    }
                    if (declaredField != null) {
                        if (declaredField.getType() != Long.TYPE) {
                            declaredField = null;
                        }
                    }
                }
                if (declaredField != null) {
                    z10 = true;
                }
            } catch (Throwable th) {
                Logger.getLogger(u1.class.getName()).logp(Level.WARNING, "com.google.protobuf.UnsafeUtil", "logMissingMethod", "platform method missing - proto runtime falling back to safer methods: ".concat(th.toString()));
            }
        }
        f21233d = z10;
        s1 s1Var3 = f21232c;
        if (s1Var3 == null) {
            z11 = false;
        } else {
            try {
                Class<?> cls3 = s1Var3.f21217a.getClass();
                cls3.getMethod("objectFieldOffset", Field.class);
                cls3.getMethod("arrayBaseOffset", Class.class);
                cls3.getMethod("arrayIndexScale", Class.class);
                Class<?> cls4 = Long.TYPE;
                cls3.getMethod("getInt", Object.class, cls4);
                cls3.getMethod("putInt", Object.class, cls4, Integer.TYPE);
                cls3.getMethod("getLong", Object.class, cls4);
                cls3.getMethod("putLong", Object.class, cls4, cls4);
                cls3.getMethod("getObject", Object.class, cls4);
                cls3.getMethod("putObject", Object.class, cls4, Object.class);
                z11 = true;
            } catch (Throwable th2) {
                Logger.getLogger(u1.class.getName()).logp(Level.WARNING, "com.google.protobuf.UnsafeUtil", "logMissingMethod", "platform method missing - proto runtime falling back to safer methods: ".concat(th2.toString()));
                z11 = false;
            }
        }
        f21234e = z11;
        f21235f = v(byte[].class);
        v(boolean[].class);
        a(boolean[].class);
        v(int[].class);
        a(int[].class);
        v(long[].class);
        a(long[].class);
        v(float[].class);
        a(float[].class);
        v(double[].class);
        a(double[].class);
        v(Object[].class);
        a(Object[].class);
        int i10 = k.f21002a;
        try {
            declaredField2 = Buffer.class.getDeclaredField("effectiveDirectAddress");
        } catch (Throwable unused3) {
            declaredField2 = null;
        }
        if (declaredField2 == null) {
            try {
                declaredField2 = Buffer.class.getDeclaredField("address");
            } catch (Throwable unused4) {
                declaredField2 = null;
            }
            field = (declaredField2 == null || declaredField2.getType() != Long.TYPE) ? null : declaredField2;
        }
        if (field != null && (s1Var2 = f21232c) != null) {
            s1Var2.e(field);
        }
        f21236g = ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN;
    }

    public static void a(Class cls) {
        if (f21234e) {
            f21232c.b(cls);
        }
    }

    public static void b(Object obj, long j10, byte b10) {
        long j11 = (-4) & j10;
        s1 s1Var = f21232c;
        int iC = s1Var.c(j11, obj);
        int i10 = ((~((int) j10)) & 3) << 3;
        s1Var.g(((255 & b10) << i10) | (iC & (~(255 << i10))), j11, obj);
    }

    public static void c(Object obj, long j10, byte b10) {
        long j11 = (-4) & j10;
        s1 s1Var = f21232c;
        int i10 = (((int) j10) & 3) << 3;
        s1Var.g(((255 & b10) << i10) | (s1Var.c(j11, obj) & (~(255 << i10))), j11, obj);
    }

    public static double d(Object obj, long j10) {
        s1 s1Var = f21232c;
        switch (s1Var.f21195b) {
        }
        return Double.longBitsToDouble(s1Var.d(j10, obj));
    }

    public static float e(Object obj, long j10) {
        s1 s1Var = f21232c;
        switch (s1Var.f21195b) {
        }
        return Float.intBitsToFloat(s1Var.c(j10, obj));
    }

    public static int f(Object obj, long j10) {
        return f21232c.c(j10, obj);
    }

    public static long g(Object obj, long j10) {
        return f21232c.d(j10, obj);
    }

    public static Object h(Class cls) {
        try {
            return f21230a.allocateInstance(cls);
        } catch (InstantiationException e10) {
            throw new IllegalStateException(e10);
        }
    }

    public static Object i(Object obj, long j10) {
        return f21232c.f(j10, obj);
    }

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

    public static void k(Object obj, long j10, boolean z10) {
        int i10 = f21232c.f21195b;
        boolean z11 = f21236g;
        switch (i10) {
            case 0:
                if (!z11) {
                    c(obj, j10, z10 ? (byte) 1 : (byte) 0);
                } else {
                    b(obj, j10, z10 ? (byte) 1 : (byte) 0);
                }
                break;
            default:
                if (!z11) {
                    c(obj, j10, z10 ? (byte) 1 : (byte) 0);
                } else {
                    b(obj, j10, z10 ? (byte) 1 : (byte) 0);
                }
                break;
        }
    }

    public static void l(byte[] bArr, long j10, byte b10) {
        long j11 = f21235f + j10;
        int i10 = f21232c.f21195b;
        boolean z10 = f21236g;
        switch (i10) {
            case 0:
                if (!z10) {
                    c(bArr, j11, b10);
                } else {
                    b(bArr, j11, b10);
                }
                break;
            default:
                if (!z10) {
                    c(bArr, j11, b10);
                } else {
                    b(bArr, j11, b10);
                }
                break;
        }
    }

    public static void m(Object obj, long j10, double d10) {
        s1 s1Var = f21232c;
        switch (s1Var.f21195b) {
            case 0:
                s1Var.h(obj, j10, Double.doubleToLongBits(d10));
                break;
            default:
                s1Var.h(obj, j10, Double.doubleToLongBits(d10));
                break;
        }
    }

    public static void n(Object obj, long j10, float f10) {
        s1 s1Var = f21232c;
        switch (s1Var.f21195b) {
            case 0:
                s1Var.g(Float.floatToIntBits(f10), j10, obj);
                break;
            default:
                s1Var.g(Float.floatToIntBits(f10), j10, obj);
                break;
        }
    }

    public static void o(Object obj, long j10, int i10) {
        f21232c.g(i10, j10, obj);
    }

    public static void p(Object obj, long j10, long j11) {
        f21232c.h(obj, j10, j11);
    }

    public static void q(Object obj, long j10, Object obj2) {
        f21232c.i(obj, j10, obj2);
    }

    public static /* bridge */ /* synthetic */ boolean r(Object obj, long j10) {
        return ((byte) ((f21232c.c((-4) & j10, obj) >>> ((int) (((~j10) & 3) << 3))) & 255)) != 0;
    }

    public static /* bridge */ /* synthetic */ boolean s(Object obj, long j10) {
        return ((byte) ((f21232c.c((-4) & j10, obj) >>> ((int) ((j10 & 3) << 3))) & 255)) != 0;
    }

    /* JADX WARN: Multi-variable type inference failed */
    public static boolean t(Class cls) {
        int i10 = k.f21002a;
        try {
            Class cls2 = f21231b;
            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 boolean u(Object obj, long j10) {
        int i10 = f21232c.f21195b;
        boolean z10 = f21236g;
        switch (i10) {
            case 0:
                return z10 ? r(obj, j10) : s(obj, j10);
            default:
                return z10 ? r(obj, j10) : s(obj, j10);
        }
    }

    public static int v(Class cls) {
        if (f21234e) {
            return f21232c.a(cls);
        }
        return -1;
    }
}