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

import androidx.media3.extractor.text.ttml.TtmlNode;
import com.google.android.gms.measurement.api.AppMeasurementSdk;
import defpackage.cp4;
import defpackage.cr4;
import defpackage.dp4;
import defpackage.ik2;
import defpackage.km8;
import defpackage.kp6;
import defpackage.pk2;
import defpackage.pq6;
import defpackage.sq3;
import defpackage.to4;
import defpackage.vx8;
import defpackage.y41;
import defpackage.zr7;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import kotlin.reflect.jvm.internal.impl.descriptors.NotFoundClasses;
import kotlin.reflect.jvm.internal.impl.descriptors.annotations.Annotations;
import kotlin.reflect.jvm.internal.impl.descriptors.impl.ClassDescriptorBase;
import kotlin.reflect.jvm.internal.impl.descriptors.impl.EmptyPackageFragmentDescriptor;
import kotlin.reflect.jvm.internal.impl.descriptors.impl.TypeParameterDescriptorImpl;
import kotlin.reflect.jvm.internal.impl.name.ClassId;
import kotlin.reflect.jvm.internal.impl.name.FqName;
import kotlin.reflect.jvm.internal.impl.name.Name;
import kotlin.reflect.jvm.internal.impl.resolve.descriptorUtil.DescriptorUtilsKt;
import kotlin.reflect.jvm.internal.impl.resolve.scopes.MemberScope;
import kotlin.reflect.jvm.internal.impl.storage.MemoizedFunctionToNotNull;
import kotlin.reflect.jvm.internal.impl.storage.StorageManager;
import kotlin.reflect.jvm.internal.impl.types.ClassTypeConstructorImpl;
import kotlin.reflect.jvm.internal.impl.types.SimpleType;
import kotlin.reflect.jvm.internal.impl.types.Variance;
import kotlin.reflect.jvm.internal.impl.types.checker.KotlinTypeRefiner;

/* JADX INFO: loaded from: classes3.dex */
public final class NotFoundClasses {

    @kp6
    private final MemoizedFunctionToNotNull<ClassRequest, ClassDescriptor> classes;

    @kp6
    private final ModuleDescriptor module;

    @kp6
    private final MemoizedFunctionToNotNull<FqName, PackageFragmentDescriptor> packageFragments;

    @kp6
    private final StorageManager storageManager;

    public static final class ClassRequest {

        @kp6
        private final ClassId classId;

        @kp6
        private final List<Integer> typeParametersCount;

        public ClassRequest(@kp6 ClassId classId, @kp6 List<Integer> list) {
            cr4.g(classId, "classId");
            cr4.g(list, "typeParametersCount");
            this.classId = classId;
            this.typeParametersCount = list;
        }

        @kp6
        public final ClassId component1() {
            return this.classId;
        }

        @kp6
        public final List<Integer> component2() {
            return this.typeParametersCount;
        }

        public boolean equals(@pq6 Object obj) {
            if (this == obj) {
                return true;
            }
            if (!(obj instanceof ClassRequest)) {
                return false;
            }
            ClassRequest classRequest = (ClassRequest) obj;
            return cr4.b(this.classId, classRequest.classId) && cr4.b(this.typeParametersCount, classRequest.typeParametersCount);
        }

        public int hashCode() {
            return this.typeParametersCount.hashCode() + (this.classId.hashCode() * 31);
        }

        @kp6
        public String toString() {
            return "ClassRequest(classId=" + this.classId + ", typeParametersCount=" + this.typeParametersCount + ')';
        }
    }

    @vx8
    public static final class MockClassDescriptor extends ClassDescriptorBase {

        @kp6
        private final List<TypeParameterDescriptor> declaredTypeParameters;
        private final boolean isInner;

        @kp6
        private final ClassTypeConstructorImpl typeConstructor;

        /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
        public MockClassDescriptor(@kp6 StorageManager storageManager, @kp6 DeclarationDescriptor declarationDescriptor, @kp6 Name name, boolean z, int i) {
            super(storageManager, declarationDescriptor, name, SourceElement.NO_SOURCE, false);
            cr4.g(storageManager, "storageManager");
            cr4.g(declarationDescriptor, TtmlNode.RUBY_CONTAINER);
            cr4.g(name, AppMeasurementSdk.ConditionalUserProperty.NAME);
            this.isInner = z;
            dp4 dp4VarG = zr7.g(0, i);
            ArrayList arrayList = new ArrayList(y41.p(dp4VarG, 10));
            Iterator<Integer> it = dp4VarG.iterator();
            while (((cp4) it).c) {
                int iNextInt = ((to4) it).nextInt();
                arrayList.add(TypeParameterDescriptorImpl.createWithDefaultBound(this, Annotations.Companion.getEMPTY(), false, Variance.INVARIANT, Name.identifier("T" + iNextInt), iNextInt, storageManager));
            }
            this.declaredTypeParameters = arrayList;
            this.typeConstructor = new ClassTypeConstructorImpl(this, TypeParameterUtilsKt.computeConstructorTypeParameters(this), km8.h(DescriptorUtilsKt.getModule(this).getBuiltIns().getAnyType()), storageManager);
        }

        @Override // kotlin.reflect.jvm.internal.impl.descriptors.annotations.Annotated
        @kp6
        public Annotations getAnnotations() {
            return Annotations.Companion.getEMPTY();
        }

        @Override // kotlin.reflect.jvm.internal.impl.descriptors.ClassDescriptor
        @pq6
        /* JADX INFO: renamed from: getCompanionObjectDescriptor */
        public ClassDescriptor mo163getCompanionObjectDescriptor() {
            return null;
        }

        @Override // kotlin.reflect.jvm.internal.impl.descriptors.ClassDescriptor
        @kp6
        public Collection<ClassConstructorDescriptor> getConstructors() {
            return pk2.a;
        }

        @Override // kotlin.reflect.jvm.internal.impl.descriptors.ClassDescriptor, kotlin.reflect.jvm.internal.impl.descriptors.ClassifierDescriptorWithTypeParameters
        @kp6
        public List<TypeParameterDescriptor> getDeclaredTypeParameters() {
            return this.declaredTypeParameters;
        }

        @Override // kotlin.reflect.jvm.internal.impl.descriptors.ClassDescriptor
        @kp6
        public ClassKind getKind() {
            return ClassKind.CLASS;
        }

        @Override // kotlin.reflect.jvm.internal.impl.descriptors.ClassDescriptor, kotlin.reflect.jvm.internal.impl.descriptors.MemberDescriptor
        @kp6
        public Modality getModality() {
            return Modality.FINAL;
        }

        @Override // kotlin.reflect.jvm.internal.impl.descriptors.ClassDescriptor
        @kp6
        public Collection<ClassDescriptor> getSealedSubclasses() {
            return ik2.a;
        }

        @Override // kotlin.reflect.jvm.internal.impl.descriptors.ClassDescriptor
        @pq6
        /* JADX INFO: renamed from: getUnsubstitutedPrimaryConstructor */
        public ClassConstructorDescriptor mo164getUnsubstitutedPrimaryConstructor() {
            return null;
        }

        @Override // kotlin.reflect.jvm.internal.impl.descriptors.ClassDescriptor
        @pq6
        public ValueClassRepresentation<SimpleType> getValueClassRepresentation() {
            return null;
        }

        @Override // kotlin.reflect.jvm.internal.impl.descriptors.ClassDescriptor, kotlin.reflect.jvm.internal.impl.descriptors.MemberDescriptor, kotlin.reflect.jvm.internal.impl.descriptors.DeclarationDescriptorWithVisibility
        @kp6
        public DescriptorVisibility getVisibility() {
            DescriptorVisibility descriptorVisibility = DescriptorVisibilities.PUBLIC;
            cr4.f(descriptorVisibility, "PUBLIC");
            return descriptorVisibility;
        }

        @Override // kotlin.reflect.jvm.internal.impl.descriptors.MemberDescriptor
        public boolean isActual() {
            return false;
        }

        @Override // kotlin.reflect.jvm.internal.impl.descriptors.ClassDescriptor
        public boolean isCompanionObject() {
            return false;
        }

        @Override // kotlin.reflect.jvm.internal.impl.descriptors.ClassDescriptor
        public boolean isData() {
            return false;
        }

        @Override // kotlin.reflect.jvm.internal.impl.descriptors.MemberDescriptor
        public boolean isExpect() {
            return false;
        }

        @Override // kotlin.reflect.jvm.internal.impl.descriptors.impl.ClassDescriptorBase, kotlin.reflect.jvm.internal.impl.descriptors.MemberDescriptor
        public boolean isExternal() {
            return false;
        }

        @Override // kotlin.reflect.jvm.internal.impl.descriptors.ClassDescriptor
        public boolean isFun() {
            return false;
        }

        @Override // kotlin.reflect.jvm.internal.impl.descriptors.ClassDescriptor
        public boolean isInline() {
            return false;
        }

        @Override // kotlin.reflect.jvm.internal.impl.descriptors.ClassifierDescriptorWithTypeParameters
        public boolean isInner() {
            return this.isInner;
        }

        @Override // kotlin.reflect.jvm.internal.impl.descriptors.ClassDescriptor
        public boolean isValue() {
            return false;
        }

        @kp6
        public String toString() {
            return "class " + getName() + " (not found)";
        }

        @Override // kotlin.reflect.jvm.internal.impl.descriptors.ClassDescriptor
        @kp6
        public MemberScope.Empty getStaticScope() {
            return MemberScope.Empty.INSTANCE;
        }

        @Override // kotlin.reflect.jvm.internal.impl.descriptors.ClassifierDescriptor
        @kp6
        public ClassTypeConstructorImpl getTypeConstructor() {
            return this.typeConstructor;
        }

        @Override // kotlin.reflect.jvm.internal.impl.descriptors.impl.ModuleAwareClassDescriptor
        @kp6
        public MemberScope.Empty getUnsubstitutedMemberScope(@kp6 KotlinTypeRefiner kotlinTypeRefiner) {
            cr4.g(kotlinTypeRefiner, "kotlinTypeRefiner");
            return MemberScope.Empty.INSTANCE;
        }
    }

    public NotFoundClasses(@kp6 StorageManager storageManager, @kp6 ModuleDescriptor moduleDescriptor) {
        cr4.g(storageManager, "storageManager");
        cr4.g(moduleDescriptor, "module");
        this.storageManager = storageManager;
        this.module = moduleDescriptor;
        this.packageFragments = storageManager.createMemoizedFunction(new sq3(this) { // from class: kotlin.reflect.jvm.internal.impl.descriptors.NotFoundClasses$$Lambda$0
            private final NotFoundClasses arg$0;

            {
                this.arg$0 = this;
            }

            @Override // defpackage.sq3
            public Object invoke(Object obj) {
                return NotFoundClasses.packageFragments$lambda$0(this.arg$0, (FqName) obj);
            }
        });
        this.classes = storageManager.createMemoizedFunction(new sq3(this) { // from class: kotlin.reflect.jvm.internal.impl.descriptors.NotFoundClasses$$Lambda$1
            private final NotFoundClasses arg$0;

            {
                this.arg$0 = this;
            }

            @Override // defpackage.sq3
            public Object invoke(Object obj) {
                return NotFoundClasses.classes$lambda$2(this.arg$0, (NotFoundClasses.ClassRequest) obj);
            }
        });
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final ClassDescriptor classes$lambda$2(NotFoundClasses notFoundClasses, ClassRequest classRequest) {
        DeclarationDescriptor declarationDescriptor;
        cr4.g(classRequest, "<destruct>");
        ClassId classIdComponent1 = classRequest.component1();
        List<Integer> listComponent2 = classRequest.component2();
        if (classIdComponent1.isLocal()) {
            throw new UnsupportedOperationException("Unresolved local class: " + classIdComponent1);
        }
        ClassId outerClassId = classIdComponent1.getOuterClassId();
        if (outerClassId == null || (declarationDescriptor = notFoundClasses.getClass(outerClassId, y41.u(listComponent2, 1))) == null) {
            declarationDescriptor = (ClassOrPackageFragmentDescriptor) notFoundClasses.packageFragments.invoke(classIdComponent1.getPackageFqName());
        }
        DeclarationDescriptor declarationDescriptor2 = declarationDescriptor;
        boolean zIsNestedClass = classIdComponent1.isNestedClass();
        StorageManager storageManager = notFoundClasses.storageManager;
        Name shortClassName = classIdComponent1.getShortClassName();
        Integer num = (Integer) y41.ab(listComponent2);
        return new MockClassDescriptor(storageManager, declarationDescriptor2, shortClassName, zIsNestedClass, num != null ? num.intValue() : 0);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final PackageFragmentDescriptor packageFragments$lambda$0(NotFoundClasses notFoundClasses, FqName fqName) {
        cr4.g(fqName, "fqName");
        return new EmptyPackageFragmentDescriptor(notFoundClasses.module, fqName);
    }

    @kp6
    public final ClassDescriptor getClass(@kp6 ClassId classId, @kp6 List<Integer> list) {
        cr4.g(classId, "classId");
        cr4.g(list, "typeParametersCount");
        return (ClassDescriptor) this.classes.invoke(new ClassRequest(classId, list));
    }
}