package com.seewo.hiddenapi.c;

import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Field;
import java.lang.reflect.Member;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Arrays;

/* JADX INFO: compiled from: Reflect.java */
/* JADX INFO: loaded from: classes.dex */
class b {
    private final Class<?> a;
    private final Object b;

    /* JADX INFO: compiled from: Reflect.java */
    private static class a {
        private a() {
        }
    }

    private b(Class<?> cls) {
        this(cls, cls);
    }

    public static <T extends AccessibleObject> T a(T t) {
        if (t == null) {
            return null;
        }
        if (t instanceof Member) {
            Member member = (Member) t;
            if (Modifier.isPublic(member.getModifiers()) && Modifier.isPublic(member.getDeclaringClass().getModifiers())) {
                return t;
            }
        }
        if (!t.isAccessible()) {
            t.setAccessible(true);
        }
        return t;
    }

    private Method c(String str, Class<?>[] clsArr) throws NoSuchMethodException {
        Class<?> clsN = n();
        try {
            return clsN.getMethod(str, clsArr);
        } catch (NoSuchMethodException unused) {
            do {
                try {
                    return clsN.getDeclaredMethod(str, clsArr);
                } catch (NoSuchMethodException unused2) {
                    clsN = clsN.getSuperclass();
                }
            } while (clsN != null);
            throw new NoSuchMethodException();
        }
    }

    private Field e(String str) throws c {
        Class<?> clsN = n();
        try {
            return (Field) a(clsN.getField(str));
        } catch (NoSuchFieldException e) {
            do {
                try {
                    return (Field) a(clsN.getDeclaredField(str));
                } catch (NoSuchFieldException unused) {
                    clsN = clsN.getSuperclass();
                    if (clsN == null) {
                        throw new c(e);
                    }
                }
            } while (clsN == null);
            throw new c(e);
        }
    }

    private boolean g(Method method, String str, Class<?>[] clsArr) {
        return method.getName().equals(str) && h(method.getParameterTypes(), clsArr);
    }

    private boolean h(Class<?>[] clsArr, Class<?>[] clsArr2) {
        if (clsArr.length != clsArr2.length) {
            return false;
        }
        for (int i2 = 0; i2 < clsArr2.length; i2++) {
            if (clsArr2[i2] != a.class && !p(clsArr[i2]).isAssignableFrom(p(clsArr2[i2]))) {
                return false;
            }
        }
        return true;
    }

    public static b i(Class<?> cls) {
        return new b(cls);
    }

    private static b j(Class<?> cls, Object obj) {
        return new b(cls, obj);
    }

    public static b k(Object obj) {
        return new b(obj == null ? Object.class : obj.getClass(), obj);
    }

    private static b l(Method method, Object obj, Object... objArr) throws c {
        try {
            a(method);
            if (method.getReturnType() != Void.TYPE) {
                return k(method.invoke(obj, objArr));
            }
            method.invoke(obj, objArr);
            return k(obj);
        } catch (Exception e) {
            throw new c(e);
        }
    }

    private Method m(String str, Class<?>[] clsArr) throws NoSuchMethodException {
        Class<?> clsN = n();
        for (Method method : clsN.getMethods()) {
            if (g(method, str, clsArr)) {
                return method;
            }
        }
        do {
            for (Method method2 : clsN.getDeclaredMethods()) {
                if (g(method2, str, clsArr)) {
                    return method2;
                }
            }
            clsN = clsN.getSuperclass();
        } while (clsN != null);
        throw new NoSuchMethodException("No similar method " + str + " with params " + Arrays.toString(clsArr) + " could be found on type " + n() + ".");
    }

    private static Class<?>[] o(Object... objArr) {
        if (objArr == null) {
            return new Class[0];
        }
        Class<?>[] clsArr = new Class[objArr.length];
        for (int i2 = 0; i2 < objArr.length; i2++) {
            Object obj = objArr[i2];
            clsArr[i2] = obj == null ? a.class : obj.getClass();
        }
        return clsArr;
    }

    public static Class<?> p(Class<?> cls) {
        if (cls == null) {
            return null;
        }
        return cls.isPrimitive() ? Boolean.TYPE == cls ? Boolean.class : Integer.TYPE == cls ? Integer.class : Long.TYPE == cls ? Long.class : Short.TYPE == cls ? Short.class : Byte.TYPE == cls ? Byte.class : Double.TYPE == cls ? Double.class : Float.TYPE == cls ? Float.class : Character.TYPE == cls ? Character.class : Void.TYPE == cls ? Void.class : cls : cls;
    }

    public b b(String str, Object... objArr) throws c {
        Class<?>[] clsArrO = o(objArr);
        try {
            try {
                return l(c(str, clsArrO), this.b, objArr);
            } catch (NoSuchMethodException e) {
                throw new c(e);
            }
        } catch (NoSuchMethodException unused) {
            return l(m(str, clsArrO), this.b, objArr);
        }
    }

    public b d(String str) throws c {
        try {
            Field fieldE = e(str);
            return j(fieldE.getType(), fieldE.get(this.b));
        } catch (Exception e) {
            throw new c(e);
        }
    }

    public boolean equals(Object obj) {
        if (obj instanceof b) {
            return this.b.equals(((b) obj).f());
        }
        return false;
    }

    public <T> T f() {
        return (T) this.b;
    }

    public int hashCode() {
        return this.b.hashCode();
    }

    public Class<?> n() {
        return this.a;
    }

    public String toString() {
        return this.b.toString();
    }

    private b(Class<?> cls, Object obj) {
        this.a = cls;
        this.b = obj;
    }
}