package kotlin.reflect.jvm.internal.impl.descriptors.runtime.structure;

import defpackage.ar3;
import defpackage.br3;
import defpackage.cr4;
import defpackage.dr3;
import defpackage.er3;
import defpackage.fr3;
import defpackage.gr3;
import defpackage.h15;
import defpackage.ik2;
import defpackage.ir3;
import defpackage.iw7;
import defpackage.kp6;
import defpackage.kr3;
import defpackage.kw7;
import defpackage.lr3;
import defpackage.mr3;
import defpackage.n89;
import defpackage.nr3;
import defpackage.og8;
import defpackage.or3;
import defpackage.pq6;
import defpackage.pr3;
import defpackage.q07;
import defpackage.qq3;
import defpackage.qr3;
import defpackage.rq3;
import defpackage.sg8;
import defpackage.sq3;
import defpackage.st;
import defpackage.tq3;
import defpackage.uq3;
import defpackage.vq3;
import defpackage.vx8;
import defpackage.wo5;
import defpackage.wq3;
import defpackage.xq3;
import defpackage.y41;
import defpackage.yq3;
import defpackage.zq3;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import kotlin.reflect.KClass;
import kotlin.reflect.jvm.internal.impl.name.ClassId;
import kotlin.reflect.jvm.internal.impl.name.FqName;
import kotlin.reflect.jvm.internal.impl.name.Name;

/* JADX INFO: loaded from: classes3.dex */
@vx8
public final class ReflectClassUtilKt {

    @kp6
    private static final Map<Class<? extends lr3<?>>, Integer> FUNCTION_CLASSES;

    @kp6
    private static final List<KClass<? extends Object>> PRIMITIVE_CLASSES;

    @kp6
    private static final Map<Class<? extends Object>, Class<? extends Object>> PRIMITIVE_TO_WRAPPER;

    @kp6
    private static final Map<Class<? extends Object>, Class<? extends Object>> WRAPPER_TO_PRIMITIVE;

    static {
        kw7 kw7Var = iw7.a;
        int i = 0;
        List<KClass<? extends Object>> listAn = y41.an(kw7Var.getOrCreateKotlinClass(Boolean.TYPE), kw7Var.getOrCreateKotlinClass(Byte.TYPE), kw7Var.getOrCreateKotlinClass(Character.TYPE), kw7Var.getOrCreateKotlinClass(Double.TYPE), kw7Var.getOrCreateKotlinClass(Float.TYPE), kw7Var.getOrCreateKotlinClass(Integer.TYPE), kw7Var.getOrCreateKotlinClass(Long.TYPE), kw7Var.getOrCreateKotlinClass(Short.TYPE));
        PRIMITIVE_CLASSES = listAn;
        List<KClass<? extends Object>> list = listAn;
        ArrayList arrayList = new ArrayList(y41.p(list, 10));
        Iterator<T> it = list.iterator();
        while (it.hasNext()) {
            KClass kClass = (KClass) it.next();
            arrayList.add(new q07(h15.c(kClass), h15.d(kClass)));
        }
        WRAPPER_TO_PRIMITIVE = wo5.m(arrayList);
        List<KClass<? extends Object>> list2 = PRIMITIVE_CLASSES;
        ArrayList arrayList2 = new ArrayList(y41.p(list2, 10));
        Iterator<T> it2 = list2.iterator();
        while (it2.hasNext()) {
            KClass kClass2 = (KClass) it2.next();
            arrayList2.add(new q07(h15.d(kClass2), h15.c(kClass2)));
        }
        PRIMITIVE_TO_WRAPPER = wo5.m(arrayList2);
        List listAn2 = y41.an(qq3.class, sq3.class, gr3.class, ir3.class, kr3.class, mr3.class, nr3.class, or3.class, pr3.class, qr3.class, rq3.class, tq3.class, uq3.class, vq3.class, wq3.class, xq3.class, yq3.class, zq3.class, ar3.class, br3.class, dr3.class, er3.class, fr3.class);
        ArrayList arrayList3 = new ArrayList(y41.p(listAn2, 10));
        for (Object obj : listAn2) {
            int i2 = i + 1;
            if (i < 0) {
                y41.bm();
                throw null;
            }
            arrayList3.add(new q07((Class) obj, Integer.valueOf(i)));
            i = i2;
        }
        FUNCTION_CLASSES = wo5.m(arrayList3);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final ParameterizedType _get_parameterizedTypeArguments_$lambda$3(ParameterizedType parameterizedType) {
        cr4.g(parameterizedType, "it");
        Type ownerType = parameterizedType.getOwnerType();
        if (ownerType instanceof ParameterizedType) {
            return (ParameterizedType) ownerType;
        }
        return null;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final og8 _get_parameterizedTypeArguments_$lambda$4(ParameterizedType parameterizedType) {
        cr4.g(parameterizedType, "it");
        Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
        cr4.f(actualTypeArguments, "getActualTypeArguments(...)");
        return st.e(actualTypeArguments);
    }

    @kp6
    public static final ClassId getClassId(@kp6 Class<?> cls) {
        ClassId classId;
        cr4.g(cls, "<this>");
        if (cls.isPrimitive()) {
            throw new IllegalArgumentException("Can't compute ClassId for primitive type: " + cls);
        }
        if (cls.isArray()) {
            throw new IllegalArgumentException("Can't compute ClassId for array type: " + cls);
        }
        if (cls.getEnclosingMethod() != null || cls.getEnclosingConstructor() != null || cls.getSimpleName().length() == 0) {
            FqName fqName = new FqName(cls.getName());
            return new ClassId(fqName.parent(), FqName.Companion.topLevel(fqName.shortName()), true);
        }
        Class<?> declaringClass = cls.getDeclaringClass();
        if (declaringClass != null && (classId = getClassId(declaringClass)) != null) {
            Name nameIdentifier = Name.identifier(cls.getSimpleName());
            cr4.f(nameIdentifier, "identifier(...)");
            ClassId classIdCreateNestedClassId = classId.createNestedClassId(nameIdentifier);
            if (classIdCreateNestedClassId != null) {
                return classIdCreateNestedClassId;
            }
        }
        return ClassId.Companion.topLevel(new FqName(cls.getName()));
    }

    /* JADX WARN: Failed to restore switch over string. Please report as a decompilation issue */
    @kp6
    public static final String getDesc(@kp6 Class<?> cls) {
        cr4.g(cls, "<this>");
        if (!cls.isPrimitive()) {
            if (cls.isArray()) {
                return n89.am(cls.getName(), '.', '/');
            }
            return "L" + n89.am(cls.getName(), '.', '/') + ';';
        }
        String name = cls.getName();
        switch (name.hashCode()) {
            case -1325958191:
                if (name.equals("double")) {
                    return "D";
                }
                break;
            case 104431:
                if (name.equals("int")) {
                    return "I";
                }
                break;
            case 3039496:
                if (name.equals("byte")) {
                    return "B";
                }
                break;
            case 3052374:
                if (name.equals("char")) {
                    return "C";
                }
                break;
            case 3327612:
                if (name.equals("long")) {
                    return "J";
                }
                break;
            case 3625364:
                if (name.equals("void")) {
                    return "V";
                }
                break;
            case 64711720:
                if (name.equals("boolean")) {
                    return "Z";
                }
                break;
            case 97526364:
                if (name.equals("float")) {
                    return "F";
                }
                break;
            case 109413500:
                if (name.equals("short")) {
                    return "S";
                }
                break;
        }
        throw new IllegalArgumentException("Unsupported primitive type: " + cls);
    }

    @pq6
    public static final Integer getFunctionClassArity(@kp6 Class<?> cls) {
        cr4.g(cls, "<this>");
        return FUNCTION_CLASSES.get(cls);
    }

    @kp6
    public static final List<Type> getParameterizedTypeArguments(@kp6 Type type) {
        cr4.g(type, "<this>");
        if (!(type instanceof ParameterizedType)) {
            return ik2.a;
        }
        ParameterizedType parameterizedType = (ParameterizedType) type;
        if (parameterizedType.getOwnerType() != null) {
            return sg8.s(sg8.i(sg8.j(new sq3() { // from class: kotlin.reflect.jvm.internal.impl.descriptors.runtime.structure.ReflectClassUtilKt$$Lambda$0
                @Override // defpackage.sq3
                public Object invoke(Object obj) {
                    return ReflectClassUtilKt._get_parameterizedTypeArguments_$lambda$3((ParameterizedType) obj);
                }
            }, type), new sq3() { // from class: kotlin.reflect.jvm.internal.impl.descriptors.runtime.structure.ReflectClassUtilKt$$Lambda$1
                @Override // defpackage.sq3
                public Object invoke(Object obj) {
                    return ReflectClassUtilKt._get_parameterizedTypeArguments_$lambda$4((ParameterizedType) obj);
                }
            }));
        }
        Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
        cr4.f(actualTypeArguments, "getActualTypeArguments(...)");
        return st.al(actualTypeArguments);
    }

    @pq6
    public static final Class<?> getPrimitiveByWrapper(@kp6 Class<?> cls) {
        cr4.g(cls, "<this>");
        return WRAPPER_TO_PRIMITIVE.get(cls);
    }

    @kp6
    public static final ClassLoader getSafeClassLoader(@kp6 Class<?> cls) {
        cr4.g(cls, "<this>");
        ClassLoader classLoader = cls.getClassLoader();
        if (classLoader != null) {
            return classLoader;
        }
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        cr4.f(systemClassLoader, "getSystemClassLoader(...)");
        return systemClassLoader;
    }

    @pq6
    public static final Class<?> getWrapperByPrimitive(@kp6 Class<?> cls) {
        cr4.g(cls, "<this>");
        return PRIMITIVE_TO_WRAPPER.get(cls);
    }

    public static final boolean isEnumClassOrSpecializedEnumEntryClass(@kp6 Class<?> cls) {
        cr4.g(cls, "<this>");
        return Enum.class.isAssignableFrom(cls);
    }
}