package com.kwad.sdk.utils;
import com.kwad.sdk.core.e.b;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
public final class r {
private static final Map<Class<?>, Class<?>> bBp;
public static class a<T> {
public final Class<? extends T> bBq;
public final T obj;
}
static {
HashMap hashMap = new HashMap();
bBp = hashMap;
hashMap.put(Boolean.class, Boolean.TYPE);
hashMap.put(Byte.class, Byte.TYPE);
hashMap.put(Character.class, Character.TYPE);
hashMap.put(Short.class, Short.TYPE);
hashMap.put(Integer.class, Integer.TYPE);
hashMap.put(Float.class, Float.TYPE);
hashMap.put(Long.class, Long.TYPE);
hashMap.put(Double.class, Double.TYPE);
Class cls = Boolean.TYPE;
hashMap.put(cls, cls);
Class cls2 = Byte.TYPE;
hashMap.put(cls2, cls2);
Class cls3 = Character.TYPE;
hashMap.put(cls3, cls3);
Class cls4 = Short.TYPE;
hashMap.put(cls4, cls4);
Class cls5 = Integer.TYPE;
hashMap.put(cls5, cls5);
Class cls6 = Float.TYPE;
hashMap.put(cls6, cls6);
Class cls7 = Long.TYPE;
hashMap.put(cls7, cls7);
Class cls8 = Double.TYPE;
hashMap.put(cls8, cls8);
}
public static <T> T C(Class<?> cls) {
try {
return (T) D(cls);
} catch (Throwable th) {
t(th);
return null;
}
}
private static <T> T D(Class<?> cls) {
Constructor<?>[] declaredConstructors = cls.getDeclaredConstructors();
if (declaredConstructors == null || declaredConstructors.length == 0) {
throw new IllegalArgumentException("Can't get even one available constructor for " + cls);
}
Constructor<?> constructor = declaredConstructors[0];
constructor.setAccessible(true);
Class<?>[] parameterTypes = constructor.getParameterTypes();
if (parameterTypes == null || parameterTypes.length == 0) {
return (T) constructor.newInstance(new Object[0]);
}
Object[] objArr = new Object[parameterTypes.length];
for (int i = 0; i < parameterTypes.length; i++) {
objArr[i] = E(parameterTypes[i]);
}
return (T) constructor.newInstance(objArr);
}
private static Object E(Class<?> cls) {
if (Integer.TYPE.equals(cls) || Integer.class.equals(cls) || Byte.TYPE.equals(cls) || Byte.class.equals(cls) || Short.TYPE.equals(cls) || Short.class.equals(cls) || Long.TYPE.equals(cls) || Long.class.equals(cls) || Double.TYPE.equals(cls) || Double.class.equals(cls) || Float.TYPE.equals(cls) || Float.class.equals(cls)) {
return 0;
}
return (Boolean.TYPE.equals(cls) || Boolean.class.equals(cls)) ? Boolean.FALSE : (Character.TYPE.equals(cls) || Character.class.equals(cls)) ? (char) (char) 0 : null;
}
public static <T> T a(Class<?> cls, Object... objArr) {
try {
return (T) b(cls, objArr);
} catch (Throwable th) {
t(th);
return null;
}
}
public static <T> T a(Object obj, String str, Object... objArr) {
try {
return (T) b(obj, str, objArr);
} catch (Throwable th) {
t(th);
return null;
}
}
public static <T> T a(String str, String str2, Object... objArr) {
try {
return (T) c(Class.forName(str), str2, objArr);
} catch (Throwable th) {
t(th);
return null;
}
}
private static Method a(Method[] methodArr, String str, Class<?>[] clsArr) {
an.fw(str);
for (Method method : methodArr) {
if (method.getName().equals(str) && b(method.getParameterTypes(), clsArr)) {
return method;
}
}
return null;
}
public static void a(Object obj, String str, Object obj2) {
try {
b(obj, str, obj2);
} catch (Throwable th) {
t(th);
}
}
public static <T> T aa(String str, String str2) {
try {
return (T) ab(str, str2);
} catch (Throwable th) {
t(th);
return null;
}
}
private static <T> T ab(String str, String str2) {
return (T) d(Class.forName(str), str2);
}
public static <T> T b(Class<?> cls, String str, Object... objArr) {
try {
return (T) c(cls, str, objArr);
} catch (Throwable th) {
t(th);
return null;
}
}
private static <T> T b(Class<?> cls, Object... objArr) {
return (T) cls.getConstructor(c(objArr)).newInstance(d(objArr));
}
public static <T> T b(Object obj, String str, Object... objArr) {
return (T) c(obj.getClass(), str, c(objArr)).invoke(obj, d(objArr));
}
public static void b(Object obj, String str, Object obj2) {
Class<?> cls = obj.getClass();
Field field = null;
while (field == null) {
try {
field = cls.getDeclaredField(str);
continue;
} catch (NoSuchFieldException unused) {
cls = cls.getSuperclass();
continue;
}
if (cls == null) {
throw new NoSuchFieldException();
}
}
field.setAccessible(true);
field.set(obj, obj2);
}
private static boolean b(Class<?>[] clsArr, Class<?>[] clsArr2) {
if (clsArr == null) {
return clsArr2 == null || clsArr2.length == 0;
}
if (clsArr2 == null) {
return clsArr.length == 0;
}
if (clsArr.length != clsArr2.length) {
return false;
}
for (int i = 0; i < clsArr.length; i++) {
if (!clsArr[i].isAssignableFrom(clsArr2[i])) {
Map<Class<?>, Class<?>> map = bBp;
if (!map.containsKey(clsArr[i]) || !map.get(clsArr[i]).equals(map.get(clsArr2[i]))) {
return false;
}
}
}
return true;
}
public static <T> T c(Class<?> cls, String str) {
try {
return (T) d(cls, str);
} catch (Throwable th) {
t(th);
return null;
}
}
public static <T> T c(Class<?> cls, String str, Object... objArr) {
return (T) c(cls, str, c(objArr)).invoke(null, d(objArr));
}
public static <T> T c(Object obj, String str) {
try {
return (T) d(obj, str);
} catch (Throwable th) {
t(th);
return null;
}
}
public static <T> T c(String str, Object... objArr) {
try {
return (T) f(str, objArr);
} catch (Throwable th) {
t(th);
return null;
}
}
private static Method c(Class<?> cls, String str, Class<?>... clsArr) {
while (true) {
Method a2 = a(cls.getDeclaredMethods(), str, clsArr);
if (a2 != null) {
a2.setAccessible(true);
return a2;
} else if (cls.getSuperclass() != null) {
cls = cls.getSuperclass();
} else {
throw new NoSuchMethodException();
}
}
}
private static Class<?>[] c(Object... objArr) {
if (objArr == null || objArr.length <= 0) {
return null;
}
Class<?>[] clsArr = new Class[objArr.length];
for (int i = 0; i < objArr.length; i++) {
Object obj = objArr[i];
clsArr[i] = (obj == null || !(obj instanceof a)) ? obj == null ? null : obj.getClass() : ((a) obj).bBq;
}
return clsArr;
}
private static <T> T d(Class<?> cls, String str) {
Field declaredField = cls.getDeclaredField(str);
declaredField.setAccessible(true);
return (T) declaredField.get(null);
}
public static <T> T d(Object obj, String str) {
Class<?> cls = obj.getClass();
Field field = null;
while (field == null) {
try {
field = cls.getDeclaredField(str);
field.setAccessible(true);
continue;
} catch (NoSuchFieldException unused) {
cls = cls.getSuperclass();
continue;
}
if (cls == null) {
throw new NoSuchFieldException();
}
}
field.setAccessible(true);
return (T) field.get(obj);
}
private static Object[] d(Object... objArr) {
if (objArr == null || objArr.length <= 0) {
return null;
}
Object[] objArr2 = new Object[objArr.length];
for (int i = 0; i < objArr.length; i++) {
Object obj = objArr[i];
if (obj == null || !(obj instanceof a)) {
objArr2[i] = obj;
} else {
objArr2[i] = ((a) obj).obj;
}
}
return objArr2;
}
private static <T> T f(String str, Object... objArr) {
return (T) b(Class.forName(str), d(objArr));
}
private static void t(Throwable th) {
if (!com.kwad.a.a.ci.booleanValue()) {
b.printStackTrace(th);
} else if (th instanceof RuntimeException) {
throw ((RuntimeException) th);
} else {
throw new RuntimeException(th);
}
}
}