package o;

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;

/* renamed from: o.gco, reason: case insensitive filesystem */
/* loaded from: classes.dex */
public final class C14950gco implements InterfaceC14981gdm<Object>, InterfaceC14951gcp {
    private static final Map<String, String> a;
    private static final Map<Class<? extends fZN<?>>, Integer> e;
    private final Class<?> d;

    public C14950gco(Class<?> cls) {
        C14957gcv.e(cls, "");
        this.d = cls;
    }

    public final boolean equals(Object obj) {
        return (obj instanceof C14950gco) && C14957gcv.b(gbL.d(this), gbL.d((InterfaceC14981gdm) obj));
    }

    public final int hashCode() {
        return gbL.d(this).hashCode();
    }

    public final String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append(this.d.toString());
        sb.append(" (Kotlin reflection is not available)");
        return sb.toString();
    }

    /* renamed from: o.gco$HBt */
    /* loaded from: classes.dex */
    public static final class HBt {
        private HBt() {
        }

        public /* synthetic */ HBt(byte b) {
            this();
        }
    }

    /* JADX WARN: Multi-variable type inference failed */
    static {
        int i = 0;
        new HBt(0 == true ? 1 : 0);
        List e2 = C14881gav.e(InterfaceC14890gbN.class, InterfaceC14894gbR.class, InterfaceC14937gcb.class, InterfaceC14939gcd.class, InterfaceC14938gcc.class, InterfaceC14942gcg.class, InterfaceC14948gcm.class, InterfaceC14946gck.class, InterfaceC14945gcj.class, InterfaceC14944gci.class, InterfaceC14891gbO.class, InterfaceC14893gbQ.class, gbT.class, gbU.class, gbV.class, InterfaceC14895gbS.class, gbW.class, InterfaceC14897gbY.class, InterfaceC14896gbX.class, InterfaceC14898gbZ.class, InterfaceC14936gca.class, InterfaceC14940gce.class, InterfaceC14941gcf.class);
        C14957gcv.e(e2, "");
        ArrayList arrayList = new ArrayList(e2 instanceof Collection ? e2.size() : 10);
        for (Object obj : e2) {
            if (i >= 0) {
                arrayList.add(new C13396fZU((Class) obj, Integer.valueOf(i)));
                i++;
            } else {
                throw new ArithmeticException("Index overflow has happened.");
            }
        }
        e = C14856gaP.c(arrayList);
        HashMap hashMap = new HashMap();
        hashMap.put("boolean", "kotlin.Boolean");
        hashMap.put("char", "kotlin.Char");
        hashMap.put("byte", "kotlin.Byte");
        hashMap.put("short", "kotlin.Short");
        hashMap.put("int", "kotlin.Int");
        hashMap.put("float", "kotlin.Float");
        hashMap.put("long", "kotlin.Long");
        hashMap.put("double", "kotlin.Double");
        HashMap hashMap2 = new HashMap();
        hashMap2.put("java.lang.Boolean", "kotlin.Boolean");
        hashMap2.put("java.lang.Character", "kotlin.Char");
        hashMap2.put("java.lang.Byte", "kotlin.Byte");
        hashMap2.put("java.lang.Short", "kotlin.Short");
        hashMap2.put("java.lang.Integer", "kotlin.Int");
        hashMap2.put("java.lang.Float", "kotlin.Float");
        hashMap2.put("java.lang.Long", "kotlin.Long");
        hashMap2.put("java.lang.Double", "kotlin.Double");
        HashMap hashMap3 = new HashMap();
        hashMap3.put("java.lang.Object", "kotlin.Any");
        hashMap3.put("java.lang.String", "kotlin.String");
        hashMap3.put("java.lang.CharSequence", "kotlin.CharSequence");
        hashMap3.put("java.lang.Throwable", "kotlin.Throwable");
        hashMap3.put("java.lang.Cloneable", "kotlin.Cloneable");
        hashMap3.put("java.lang.Number", "kotlin.Number");
        hashMap3.put("java.lang.Comparable", "kotlin.Comparable");
        hashMap3.put("java.lang.Enum", "kotlin.Enum");
        hashMap3.put("java.lang.annotation.Annotation", "kotlin.Annotation");
        hashMap3.put("java.lang.Iterable", "kotlin.collections.Iterable");
        hashMap3.put("java.util.Iterator", "kotlin.collections.Iterator");
        hashMap3.put("java.util.Collection", "kotlin.collections.Collection");
        hashMap3.put("java.util.List", "kotlin.collections.List");
        hashMap3.put("java.util.Set", "kotlin.collections.Set");
        hashMap3.put("java.util.ListIterator", "kotlin.collections.ListIterator");
        hashMap3.put("java.util.Map", "kotlin.collections.Map");
        hashMap3.put("java.util.Map$Entry", "kotlin.collections.Map.Entry");
        hashMap3.put("o.gcH", "kotlin.String.Companion");
        hashMap3.put("o.gcw", "kotlin.Enum.Companion");
        hashMap3.putAll(hashMap);
        hashMap3.putAll(hashMap2);
        Collection<String> values = hashMap.values();
        C14957gcv.c(values, "");
        for (String str : values) {
            StringBuilder sb = new StringBuilder("kotlin.jvm.internal.");
            C14957gcv.c((Object) str, "");
            sb.append(gdZ.c(str, str));
            sb.append("CompanionObject");
            String obj2 = sb.toString();
            StringBuilder sb2 = new StringBuilder();
            sb2.append(str);
            sb2.append(".Companion");
            C13396fZU c13396fZU = new C13396fZU(obj2, sb2.toString());
            hashMap3.put(c13396fZU.d, c13396fZU.e);
        }
        HashMap hashMap4 = hashMap3;
        for (Map.Entry<Class<? extends fZN<?>>, Integer> entry : e.entrySet()) {
            hashMap3.put(entry.getKey().getName(), "o.fZN".concat(String.valueOf(entry.getValue().intValue())));
        }
        LinkedHashMap linkedHashMap = new LinkedHashMap(C14856gaP.a(hashMap4.size()));
        for (Map.Entry entry2 : hashMap4.entrySet()) {
            Object key = entry2.getKey();
            String str2 = (String) entry2.getValue();
            linkedHashMap.put(key, gdZ.c(str2, str2));
        }
        a = linkedHashMap;
    }

    @Override // o.InterfaceC14981gdm
    public final String a() {
        String str;
        String str2;
        Class<?> cls = this.d;
        C14957gcv.e(cls, "");
        String str3 = null;
        if (cls.isAnonymousClass()) {
            return null;
        }
        if (cls.isLocalClass()) {
            str = cls.getSimpleName();
            Method enclosingMethod = cls.getEnclosingMethod();
            if (enclosingMethod != null) {
                C14957gcv.c((Object) str, "");
                StringBuilder sb = new StringBuilder();
                sb.append(enclosingMethod.getName());
                sb.append('$');
                String d = gdZ.d(str, sb.toString(), str);
                if (d != null) {
                    return d;
                }
            }
            Constructor<?> enclosingConstructor = cls.getEnclosingConstructor();
            if (enclosingConstructor != null) {
                C14957gcv.c((Object) str, "");
                StringBuilder sb2 = new StringBuilder();
                sb2.append(enclosingConstructor.getName());
                sb2.append('$');
                return gdZ.d(str, sb2.toString(), str);
            }
            C14957gcv.c((Object) str, "");
            C14957gcv.e(str, "");
            C14957gcv.e(str, "");
            int a2 = gdZ.a((CharSequence) str, '$', 0, false);
            if (a2 != -1) {
                String substring = str.substring(a2 + 1, str.length());
                C14957gcv.c((Object) substring, "");
                return substring;
            }
        } else if (cls.isArray()) {
            Class<?> componentType = cls.getComponentType();
            str = "Array";
            if (componentType.isPrimitive() && (str2 = a.get(componentType.getName())) != null) {
                StringBuilder sb3 = new StringBuilder();
                sb3.append(str2);
                sb3.append("Array");
                str3 = sb3.toString();
            }
            if (str3 != null) {
                return str3;
            }
        } else {
            String str4 = a.get(cls.getName());
            return str4 == null ? cls.getSimpleName() : str4;
        }
        return str;
    }

    @Override // o.InterfaceC14951gcp
    public final Class<?> d() {
        return this.d;
    }
}