package com.seewo.libsvendors.utils.e;

import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Constructor;
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 */
public class c {

    /* JADX INFO: renamed from: a, reason: collision with root package name */
    private final Class<?> f2465a;

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

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

    private c(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 e(String str, Class<?>[] clsArr) throws NoSuchMethodException {
        Class<?> clsT = t();
        try {
            return clsT.getMethod(str, clsArr);
        } catch (NoSuchMethodException unused) {
            do {
                try {
                    return clsT.getDeclaredMethod(str, clsArr);
                } catch (NoSuchMethodException unused2) {
                    clsT = clsT.getSuperclass();
                }
            } while (clsT != null);
            throw new NoSuchMethodException();
        }
    }

    private Field g(String str) throws d {
        Class<?> clsT = t();
        try {
            return (Field) a(clsT.getField(str));
        } catch (NoSuchFieldException e2) {
            do {
                try {
                    return (Field) a(clsT.getDeclaredField(str));
                } catch (NoSuchFieldException unused) {
                    clsT = clsT.getSuperclass();
                    if (clsT == null) {
                        throw new d(e2);
                    }
                }
            } while (clsT == null);
            throw new d(e2);
        }
    }

    private static Class<?> h(String str) throws d {
        try {
            return Class.forName(str);
        } catch (Exception e2) {
            throw new d(e2);
        }
    }

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

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

    public static c l(Class<?> cls) {
        return new c(cls);
    }

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

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

    public static c o(String str) throws d {
        return l(h(str));
    }

    private static c p(Constructor<?> constructor, Object... objArr) throws d {
        try {
            return m(constructor.getDeclaringClass(), ((Constructor) a(constructor)).newInstance(objArr));
        } catch (Exception e2) {
            throw new d(e2);
        }
    }

    private static c q(Method method, Object obj, Object... objArr) throws d {
        try {
            a(method);
            if (method.getReturnType() != Void.TYPE) {
                return n(method.invoke(obj, objArr));
            }
            method.invoke(obj, objArr);
            return n(obj);
        } catch (Exception e2) {
            throw new d(e2);
        }
    }

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

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

    private static Object v(Object obj) {
        return obj instanceof c ? ((c) obj).i() : obj;
    }

    public static Class<?> w(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 c b(String str) throws d {
        return c(str, new Object[0]);
    }

    public c c(String str, Object... objArr) throws d {
        Class<?>[] clsArrU = u(objArr);
        try {
            try {
                return q(e(str, clsArrU), this.f2466b, objArr);
            } catch (NoSuchMethodException e2) {
                throw new d(e2);
            }
        } catch (NoSuchMethodException unused) {
            return q(s(str, clsArrU), this.f2466b, objArr);
        }
    }

    public c d(Object... objArr) throws d {
        Class<?>[] clsArrU = u(objArr);
        try {
            return p(t().getDeclaredConstructor(clsArrU), objArr);
        } catch (NoSuchMethodException e2) {
            for (Constructor<?> constructor : t().getDeclaredConstructors()) {
                if (k(constructor.getParameterTypes(), clsArrU)) {
                    return p(constructor, objArr);
                }
            }
            throw new d(e2);
        }
    }

    public boolean equals(Object obj) {
        if (obj instanceof c) {
            return this.f2466b.equals(((c) obj).i());
        }
        return false;
    }

    public c f(String str) throws d {
        try {
            Field fieldG = g(str);
            return m(fieldG.getType(), fieldG.get(this.f2466b));
        } catch (Exception e2) {
            throw new d(e2);
        }
    }

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

    public <T> T i() {
        return (T) this.f2466b;
    }

    public c r(String str, Object obj) throws d {
        try {
            Field fieldG = g(str);
            if ((fieldG.getModifiers() & 16) == 16) {
                Field declaredField = Field.class.getDeclaredField("modifiers");
                declaredField.setAccessible(true);
                declaredField.setInt(fieldG, fieldG.getModifiers() & (-17));
            }
            fieldG.set(this.f2466b, v(obj));
            return this;
        } catch (Exception e2) {
            throw new d(e2);
        }
    }

    public Class<?> t() {
        return this.f2465a;
    }

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

    private c(Class<?> cls, Object obj) {
        this.f2465a = cls;
        this.f2466b = obj;
    }
}