package d.e.b;

import d.e.a.i;
import d.e.a.j;
import d.e.a.k;
import d.e.a.l;
import d.e.a.m;
import d.e.a.n;
import d.e.a.o;
import d.e.a.p;
import d.e.a.q;
import d.e.a.r;
import d.e.a.s;
import d.e.a.t;
import d.e.a.u;
import d.e.a.v;
import d.e.a.w;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

/* JADX INFO: loaded from: classes.dex */
public final class b implements d.g.a<Object>, a {

    /* JADX INFO: renamed from: a, reason: collision with root package name */
    public static final Map<Class<?>, Integer> f1643a;

    /* JADX INFO: renamed from: b, reason: collision with root package name */
    public static final HashMap<String, String> f1644b;

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

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

    /* JADX INFO: renamed from: e, reason: collision with root package name */
    public final Class<?> f1647e;

    static {
        Map<Class<?>, Integer> mapSingletonMap;
        List listB = d.c.a.b(d.e.a.a.class, l.class, p.class, q.class, r.class, s.class, t.class, u.class, v.class, w.class, d.e.a.b.class, d.e.a.c.class, d.e.a.d.class, d.e.a.e.class, d.e.a.f.class, d.e.a.g.class, d.e.a.h.class, i.class, j.class, k.class, m.class, n.class, o.class);
        ArrayList arrayList = new ArrayList(b.f.b.b.i(listB, 10));
        int i = 0;
        for (Object obj : listB) {
            int i2 = i + 1;
            if (i < 0) {
                throw new ArithmeticException("Index overflow has happened.");
            }
            arrayList.add(new d.a((Class) obj, Integer.valueOf(i)));
            i = i2;
        }
        e.d(arrayList, "<this>");
        int size = arrayList.size();
        if (size == 0) {
            mapSingletonMap = d.c.d.f1638a;
        } else if (size != 1) {
            mapSingletonMap = new LinkedHashMap<>(b.f.b.b.x(arrayList.size()));
            d.c.a.c(arrayList, mapSingletonMap);
        } else {
            d.a aVar = (d.a) arrayList.get(0);
            e.d(aVar, "pair");
            mapSingletonMap = Collections.singletonMap(aVar.f1634a, aVar.f1635b);
            e.c(mapSingletonMap, "singletonMap(pair.first, pair.second)");
        }
        f1643a = mapSingletonMap;
        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");
        f1644b = 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");
        f1645c = 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();
        e.c(collectionValues, "primitiveFqNames.values");
        for (String str : collectionValues) {
            StringBuilder sb = new StringBuilder();
            sb.append("kotlin.jvm.internal.");
            e.c(str, "kotlinName");
            sb.append(d.i.j.j(str, '.', null, 2));
            sb.append("CompanionObject");
            map3.put(sb.toString(), str + ".Companion");
        }
        for (Map.Entry<Class<?>, Integer> entry : f1643a.entrySet()) {
            Class<?> key = entry.getKey();
            int iIntValue = entry.getValue().intValue();
            map3.put(key.getName(), "kotlin.Function" + iIntValue);
        }
        f1646d = map3;
        LinkedHashMap linkedHashMap = new LinkedHashMap(b.f.b.b.x(map3.size()));
        Iterator<T> it = map3.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry entry2 = (Map.Entry) it.next();
            linkedHashMap.put(entry2.getKey(), d.i.j.j((String) entry2.getValue(), '.', null, 2));
        }
    }

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

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

    public boolean equals(Object obj) {
        return (obj instanceof b) && e.a(b.f.b.b.m(this), b.f.b.b.m((d.g.a) obj));
    }

    public int hashCode() {
        return b.f.b.b.m(this).hashCode();
    }

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