package a0.c;

import io.netty.handler.codec.dns.DefaultDnsRecordDecoder;
import java.lang.invoke.MethodHandles;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Arrays;
import java.util.Optional;

/* JADX INFO: loaded from: classes2.dex */
public class a {
    public final Class<?> a;

    /* JADX INFO: renamed from: b, reason: collision with root package name */
    public final Object f373b;

    /* JADX INFO: renamed from: a0.c.a$a, reason: collision with other inner class name */
    public static class C0001a {
    }

    static {
        try {
            try {
                Optional.class.getMethod("stream", new Class[0]);
            } catch (NoSuchMethodException unused) {
                Constructor declaredConstructor = MethodHandles.Lookup.class.getDeclaredConstructor(Class.class);
                if (!declaredConstructor.isAccessible()) {
                    declaredConstructor.setAccessible(true);
                }
            }
        } catch (Throwable unused2) {
        }
    }

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

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

    public static a d(Method method, Object obj, Object... objArr) {
        if (method != null) {
            try {
                if ((!Modifier.isPublic(method.getModifiers()) || !Modifier.isPublic(method.getDeclaringClass().getModifiers())) && !method.isAccessible()) {
                    method.setAccessible(true);
                }
            } catch (Exception e2) {
                throw new b(e2);
            }
        }
        if (method.getReturnType() != Void.TYPE) {
            return c(method.invoke(obj, objArr));
        }
        method.invoke(obj, objArr);
        return c(obj);
    }

    public static <T> Class<T> f(Class<T> 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 a a(String str, Object... objArr) {
        Method declaredMethod;
        Class<?>[] clsArr = new Class[objArr.length];
        for (int i2 = 0; i2 < objArr.length; i2++) {
            Object obj = objArr[i2];
            clsArr[i2] = obj == null ? C0001a.class : obj.getClass();
        }
        try {
            Class<?> superclass = this.a;
            try {
                declaredMethod = superclass.getMethod(str, clsArr);
            } catch (NoSuchMethodException unused) {
                do {
                    try {
                        try {
                            declaredMethod = superclass.getDeclaredMethod(str, clsArr);
                        } catch (NoSuchMethodException unused2) {
                            superclass = superclass.getSuperclass();
                            if (superclass == null) {
                                throw new NoSuchMethodException();
                            }
                        }
                    } catch (NoSuchMethodException e2) {
                        throw new b(e2);
                    }
                } while (superclass == null);
                throw new NoSuchMethodException();
            }
            return d(declaredMethod, this.f373b, objArr);
        } catch (NoSuchMethodException unused3) {
            return d(e(str, clsArr), this.f373b, objArr);
        }
    }

    public final boolean b(Method method, String str, Class<?>[] clsArr) {
        boolean z2;
        if (!method.getName().equals(str)) {
            return false;
        }
        Class<?>[] parameterTypes = method.getParameterTypes();
        if (parameterTypes.length != clsArr.length) {
            z2 = false;
            break;
        }
        for (int i2 = 0; i2 < clsArr.length; i2++) {
            if (clsArr[i2] != C0001a.class && !f(parameterTypes[i2]).isAssignableFrom(f(clsArr[i2]))) {
                z2 = false;
                break;
            }
        }
        z2 = true;
        return z2;
    }

    public final Method e(String str, Class<?>[] clsArr) throws NoSuchMethodException {
        Class<?> superclass = this.a;
        for (Method method : superclass.getMethods()) {
            if (b(method, str, clsArr)) {
                return method;
            }
        }
        do {
            for (Method method2 : superclass.getDeclaredMethods()) {
                if (b(method2, str, clsArr)) {
                    return method2;
                }
            }
            superclass = superclass.getSuperclass();
        } while (superclass != null);
        StringBuilder sbK = g.a.a.a.a.K("No similar method ", str, " with params ");
        sbK.append(Arrays.toString(clsArr));
        sbK.append(" could be found on type ");
        sbK.append(this.a);
        sbK.append(DefaultDnsRecordDecoder.ROOT);
        throw new NoSuchMethodException(sbK.toString());
    }

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

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

    public String toString() {
        return String.valueOf(this.f373b);
    }
}