package w1;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import l1.y;
import l1.z;
import v1.o;
import v1.p;
import v1.q;
import v1.r;
import v1.s;
import v1.t;
import v1.u;
import v1.v;
import v1.w;

/* JADX INFO: compiled from: ClassReference.kt */
/* JADX INFO: loaded from: classes.dex */
public final class c implements a2.b<Object>, b {

    /* JADX INFO: renamed from: b, reason: collision with root package name */
    private static final Map<Class<Object>, Integer> f5885b;

    /* JADX INFO: renamed from: c, reason: collision with root package name */
    private static final HashMap<String, String> f5886c;

    /* JADX INFO: renamed from: d, reason: collision with root package name */
    private static final HashMap<String, String> f5887d;

    /* JADX INFO: renamed from: e, reason: collision with root package name */
    private static final HashMap<String, String> f5888e;

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

    /* JADX INFO: compiled from: ClassReference.kt */
    public static final class a {
        private a() {
        }

        public /* synthetic */ a(e eVar) {
            this();
        }
    }

    /* JADX WARN: Multi-variable type inference failed */
    static {
        new a(null);
        int i3 = 0;
        List listC = l1.i.c(v1.a.class, v1.l.class, p.class, q.class, r.class, s.class, t.class, u.class, v.class, w.class, v1.b.class, v1.c.class, v1.d.class, v1.e.class, v1.f.class, v1.g.class, v1.h.class, v1.i.class, v1.j.class, v1.k.class, v1.m.class, v1.n.class, o.class);
        ArrayList arrayList = new ArrayList(l1.j.f(listC, 10));
        for (Object obj : listC) {
            int i4 = i3 + 1;
            if (i3 < 0) {
                l1.i.e();
            }
            arrayList.add(k1.l.a((Class) obj, Integer.valueOf(i3)));
            i3 = i4;
        }
        f5885b = z.g(arrayList);
        HashMap<String, String> 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");
        f5886c = map;
        HashMap<String, String> 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");
        f5887d = map2;
        HashMap<String, String> 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, "primitiveFqNames.values");
        for (String str : collectionValues) {
            StringBuilder sb = new StringBuilder();
            sb.append("kotlin.jvm.internal.");
            g.d(str, "kotlinName");
            sb.append(c2.m.w(str, '.', null, 2, null));
            sb.append("CompanionObject");
            k1.h hVarA = k1.l.a(sb.toString(), str + ".Companion");
            map3.put(hVarA.c(), hVarA.d());
        }
        for (Map.Entry<Class<Object>, Integer> entry : f5885b.entrySet()) {
            Class<Object> key = entry.getKey();
            int iIntValue = entry.getValue().intValue();
            map3.put(key.getName(), "kotlin.Function" + iIntValue);
        }
        f5888e = map3;
        LinkedHashMap linkedHashMap = new LinkedHashMap(y.a(map3.size()));
        for (Map.Entry entry2 : map3.entrySet()) {
            linkedHashMap.put(entry2.getKey(), c2.m.w((String) entry2.getValue(), '.', null, 2, null));
        }
    }

    public c(Class<?> cls) {
        g.e(cls, "jClass");
        this.f5889a = cls;
    }

    @Override // w1.b
    public Class<?> a() {
        return this.f5889a;
    }

    public boolean equals(Object obj) {
        return (obj instanceof c) && g.a(u1.a.b(this), u1.a.b((a2.b) obj));
    }

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

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