package P6;

import O6.q;
import O6.r;
import O6.s;
import O6.t;
import O6.u;
import O6.v;
import O6.w;
import com.google.android.gms.internal.measurement.X1;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

/* JADX INFO: loaded from: classes.dex */
public final class d implements V6.b, c {

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

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

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

    /* JADX INFO: renamed from: a, reason: collision with root package name */
    public final Class f5526a;

    static {
        int i = 0;
        List listW = B6.l.W(O6.a.class, O6.l.class, O6.p.class, q.class, r.class, s.class, t.class, u.class, v.class, w.class, O6.b.class, O6.c.class, O6.d.class, O6.e.class, O6.f.class, O6.g.class, O6.h.class, O6.i.class, O6.j.class, O6.k.class, O6.m.class, O6.n.class, O6.o.class);
        ArrayList arrayList = new ArrayList(B6.m.a0(listW));
        for (Object obj : listW) {
            int i5 = i + 1;
            if (i < 0) {
                B6.l.Z();
                throw null;
            }
            arrayList.add(new A6.h((Class) obj, Integer.valueOf(i)));
            i = i5;
        }
        f5523b = B6.w.o0(arrayList);
        HashMap map = new HashMap();
        map.put("boolean", "kotlin.Boolean");
        map.put("char", "kotlin.Char");
        map.put("byte", "kotlin.Byte");
        map.put("short", "kotlin.Short");
        map.put("int", "kotlin.Int");
        map.put("float", "kotlin.Float");
        map.put("long", "kotlin.Long");
        map.put("double", "kotlin.Double");
        HashMap map2 = new HashMap();
        map2.put("java.lang.Boolean", "kotlin.Boolean");
        map2.put("java.lang.Character", "kotlin.Char");
        map2.put("java.lang.Byte", "kotlin.Byte");
        map2.put("java.lang.Short", "kotlin.Short");
        map2.put("java.lang.Integer", "kotlin.Int");
        map2.put("java.lang.Float", "kotlin.Float");
        map2.put("java.lang.Long", "kotlin.Long");
        map2.put("java.lang.Double", "kotlin.Double");
        HashMap map3 = new HashMap();
        map3.put("java.lang.Object", "kotlin.Any");
        map3.put("java.lang.String", "kotlin.String");
        map3.put("java.lang.CharSequence", "kotlin.CharSequence");
        map3.put("java.lang.Throwable", "kotlin.Throwable");
        map3.put("java.lang.Cloneable", "kotlin.Cloneable");
        map3.put("java.lang.Number", "kotlin.Number");
        map3.put("java.lang.Comparable", "kotlin.Comparable");
        map3.put("java.lang.Enum", "kotlin.Enum");
        map3.put("java.lang.annotation.Annotation", "kotlin.Annotation");
        map3.put("java.lang.Iterable", "kotlin.collections.Iterable");
        map3.put("java.util.Iterator", "kotlin.collections.Iterator");
        map3.put("java.util.Collection", "kotlin.collections.Collection");
        map3.put("java.util.List", "kotlin.collections.List");
        map3.put("java.util.Set", "kotlin.collections.Set");
        map3.put("java.util.ListIterator", "kotlin.collections.ListIterator");
        map3.put("java.util.Map", "kotlin.collections.Map");
        map3.put("java.util.Map$Entry", "kotlin.collections.Map.Entry");
        map3.put("kotlin.jvm.internal.StringCompanionObject", "kotlin.String.Companion");
        map3.put("kotlin.jvm.internal.EnumCompanionObject", "kotlin.Enum.Companion");
        map3.putAll(map);
        map3.putAll(map2);
        Collection<String> collectionValues = map.values();
        g.d(collectionValues, "<get-values>(...)");
        for (String str : collectionValues) {
            StringBuilder sb = new StringBuilder("kotlin.jvm.internal.");
            g.b(str);
            sb.append(X6.e.g0(str, '.', str));
            sb.append("CompanionObject");
            map3.put(sb.toString(), str.concat(".Companion"));
        }
        for (Map.Entry entry : f5523b.entrySet()) {
            Class cls = (Class) entry.getKey();
            int iIntValue = ((Number) entry.getValue()).intValue();
            map3.put(cls.getName(), "kotlin.Function" + iIntValue);
        }
        f5524c = map3;
        LinkedHashMap linkedHashMap = new LinkedHashMap(B6.w.l0(map3.size()));
        for (Map.Entry entry2 : map3.entrySet()) {
            Object key = entry2.getKey();
            String str2 = (String) entry2.getValue();
            g.b(str2);
            linkedHashMap.put(key, X6.e.g0(str2, '.', str2));
        }
        f5525d = linkedHashMap;
    }

    public d(Class cls) {
        g.e(cls, "jClass");
        this.f5526a = cls;
    }

    @Override // P6.c
    public final Class a() {
        return this.f5526a;
    }

    public final String b() {
        String str;
        Class cls = this.f5526a;
        g.e(cls, "jClass");
        String strConcat = null;
        if (cls.isAnonymousClass() || cls.isLocalClass()) {
            return null;
        }
        boolean zIsArray = cls.isArray();
        HashMap map = f5524c;
        if (!zIsArray) {
            String str2 = (String) map.get(cls.getName());
            return str2 == null ? cls.getCanonicalName() : str2;
        }
        Class<?> componentType = cls.getComponentType();
        if (componentType.isPrimitive() && (str = (String) map.get(componentType.getName())) != null) {
            strConcat = str.concat("Array");
        }
        return strConcat == null ? "kotlin.Array" : strConcat;
    }

    public final String c() {
        String str;
        Class cls = this.f5526a;
        g.e(cls, "jClass");
        String strConcat = null;
        if (cls.isAnonymousClass()) {
            return null;
        }
        if (!cls.isLocalClass()) {
            boolean zIsArray = cls.isArray();
            LinkedHashMap linkedHashMap = f5525d;
            if (!zIsArray) {
                String str2 = (String) linkedHashMap.get(cls.getName());
                return str2 == null ? cls.getSimpleName() : str2;
            }
            Class<?> componentType = cls.getComponentType();
            if (componentType.isPrimitive() && (str = (String) linkedHashMap.get(componentType.getName())) != null) {
                strConcat = str.concat("Array");
            }
            return strConcat == null ? "Array" : strConcat;
        }
        String simpleName = cls.getSimpleName();
        Method enclosingMethod = cls.getEnclosingMethod();
        if (enclosingMethod != null) {
            return X6.e.f0(simpleName, enclosingMethod.getName() + '$');
        }
        Constructor<?> enclosingConstructor = cls.getEnclosingConstructor();
        if (enclosingConstructor == null) {
            return X6.e.e0(simpleName, '$');
        }
        return X6.e.f0(simpleName, enclosingConstructor.getName() + '$');
    }

    public final boolean d(Object obj) {
        Class clsN = this.f5526a;
        g.e(clsN, "jClass");
        Map map = f5523b;
        g.c(map, "null cannot be cast to non-null type kotlin.collections.Map<K of kotlin.collections.MapsKt__MapsKt.get, V of kotlin.collections.MapsKt__MapsKt.get>");
        Integer num = (Integer) map.get(clsN);
        if (num != null) {
            return p.c(num.intValue(), obj);
        }
        if (clsN.isPrimitive()) {
            clsN = X1.n(n.a(clsN));
        }
        return clsN.isInstance(obj);
    }

    public final boolean equals(Object obj) {
        return (obj instanceof d) && X1.n(this).equals(X1.n((V6.b) obj));
    }

    public final int hashCode() {
        return X1.n(this).hashCode();
    }

    public final String toString() {
        return this.f5526a + " (Kotlin reflection is not available)";
    }
}