package h.x.d;

import h.s.d0;
import h.s.e0;
import java.lang.annotation.Annotation;
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: compiled from: ClassReference.kt */
/* JADX INFO: loaded from: classes.dex */
public final class f implements h.a0.c<Object>, e {

    /* JADX INFO: renamed from: e, reason: collision with root package name */
    private static final Map<Class<? extends h.c<?>>, Integer> f990e;

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

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

    /* JADX INFO: renamed from: h, reason: collision with root package name */
    private static final HashMap<String, String> f993h;
    private final Class<?> b;

    /* JADX WARN: Multi-variable type inference failed */
    static {
        int i2 = 0;
        List listH = h.s.m.h(h.x.c.a.class, h.x.c.l.class, h.x.c.p.class, h.x.c.q.class, h.x.c.r.class, h.x.c.s.class, h.x.c.t.class, h.x.c.u.class, h.x.c.v.class, h.x.c.w.class, h.x.c.b.class, h.x.c.c.class, h.x.c.d.class, h.x.c.e.class, h.x.c.f.class, h.x.c.g.class, h.x.c.h.class, h.x.c.i.class, h.x.c.j.class, h.x.c.k.class, h.x.c.m.class, h.x.c.n.class, h.x.c.o.class);
        ArrayList arrayList = new ArrayList(h.s.n.o(listH, 10));
        for (Object obj : listH) {
            int i3 = i2 + 1;
            if (i2 < 0) {
                h.s.k.n();
                throw null;
            }
            arrayList.add(h.o.a((Class) obj, Integer.valueOf(i2)));
            i2 = i3;
        }
        f990e = e0.i(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");
        f991f = 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");
        f992g = 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(f991f);
        map3.putAll(f992g);
        Collection<String> collectionValues = f991f.values();
        k.c(collectionValues, "primitiveFqNames.values");
        for (String str : collectionValues) {
            StringBuilder sb = new StringBuilder();
            sb.append("kotlin.jvm.internal.");
            k.c(str, "kotlinName");
            sb.append(h.c0.q.t0(str, '.', null, 2, null));
            sb.append("CompanionObject");
            h.k kVarA = h.o.a(sb.toString(), str + ".Companion");
            map3.put(kVarA.c(), kVarA.d());
        }
        for (Map.Entry<Class<? extends h.c<?>>, Integer> entry : f990e.entrySet()) {
            Class<? extends h.c<?>> key = entry.getKey();
            int iIntValue = entry.getValue().intValue();
            map3.put(key.getName(), "kotlin.Function" + iIntValue);
        }
        f993h = map3;
        LinkedHashMap linkedHashMap = new LinkedHashMap(d0.a(map3.size()));
        for (Map.Entry entry2 : map3.entrySet()) {
            linkedHashMap.put(entry2.getKey(), h.c0.q.t0((String) entry2.getValue(), '.', null, 2, null));
        }
    }

    public f(Class<?> cls) {
        k.d(cls, "jClass");
        this.b = cls;
    }

    private final Void b() {
        throw new h.x.b();
    }

    @Override // h.x.d.e
    public Class<?> a() {
        return this.b;
    }

    public boolean equals(Object obj) {
        return (obj instanceof f) && k.a(h.x.a.a(this), h.x.a.a((h.a0.c) obj));
    }

    @Override // h.a0.a
    public List<Annotation> getAnnotations() {
        b();
        throw null;
    }

    public int hashCode() {
        return h.x.a.a(this).hashCode();
    }

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