package androidx.compose.runtime.reflect;

import L4.a;
import P4.g;
import androidx.compose.runtime.Composer;
import androidx.compose.runtime.internal.StabilityInferred;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import kotlin.jvm.internal.o;
import x4.AbstractC3226C;
import x4.AbstractC3250p;
import x4.AbstractC3252r;
import x4.AbstractC3253s;

/* JADX INFO: loaded from: classes.dex */
@StabilityInferred(parameters = 0)
public final class ComposableMethod {
    public static final int $stable = 8;
    private final ComposableInfo composableInfo;
    private final Method method;

    public ComposableMethod(Method method, ComposableInfo composableInfo) {
        this.method = method;
        this.composableInfo = composableInfo;
    }

    public final Method asMethod() {
        return this.method;
    }

    public boolean equals(Object obj) {
        if (obj instanceof ComposableMethod) {
            return o.c(this.method, ((ComposableMethod) obj).method);
        }
        return false;
    }

    public final int getParameterCount() {
        return this.composableInfo.getRealParamsCount();
    }

    public final Class<?>[] getParameterTypes() {
        return (Class[]) AbstractC3250p.G(this.method.getParameterTypes(), 0, this.composableInfo.getRealParamsCount());
    }

    public final Parameter[] getParameters() {
        return (Parameter[]) AbstractC3250p.G(this.method.getParameters(), 0, this.composableInfo.getRealParamsCount());
    }

    public int hashCode() {
        return this.method.hashCode();
    }

    public final Object invoke(Composer composer, Object obj, Object... objArr) {
        Object defaultValue;
        ComposableInfo composableInfo = this.composableInfo;
        int iComponent2 = composableInfo.component2();
        int iComponent3 = composableInfo.component3();
        int iComponent4 = composableInfo.component4();
        int length = this.method.getParameterTypes().length;
        int i6 = iComponent2 + 1;
        int i7 = iComponent3 + i6;
        Object[] objArr2 = new Integer[iComponent4];
        int i8 = 0;
        for (int i9 = 0; i9 < iComponent4; i9++) {
            int i10 = i9 * 31;
            g gVarL0 = a.l0(i10, Math.min(i10 + 31, iComponent2));
            ArrayList arrayList = new ArrayList(AbstractC3253s.G(gVarL0, 10));
            Iterator it = gVarL0.iterator();
            while (it.hasNext()) {
                int iA = ((AbstractC3226C) it).a();
                arrayList.add(Integer.valueOf((iA >= objArr.length || objArr[iA] == null) ? 1 : 0));
            }
            int iIntValue = 0;
            int i11 = 0;
            for (Object obj2 : arrayList) {
                int i12 = i11 + 1;
                if (i11 < 0) {
                    AbstractC3252r.F();
                    throw null;
                }
                iIntValue |= ((Number) obj2).intValue() << i11;
                i11 = i12;
            }
            objArr2[i9] = Integer.valueOf(iIntValue);
        }
        Object[] objArr3 = new Object[length];
        while (i8 < length) {
            if (i8 >= 0 && i8 < iComponent2) {
                defaultValue = (i8 < 0 || i8 >= objArr.length) ? ComposableMethodKt.getDefaultValue(this.method.getParameterTypes()[i8]) : objArr[i8];
            } else if (i8 == iComponent2) {
                defaultValue = composer;
            } else if (i8 == i6 || (iComponent2 + 2 <= i8 && i8 < i7)) {
                defaultValue = 0;
            } else {
                if (i7 > i8 || i8 >= length) {
                    throw new IllegalStateException("Unexpected index");
                }
                defaultValue = objArr2[i8 - i7];
            }
            objArr3[i8] = defaultValue;
            i8++;
        }
        return this.method.invoke(obj, Arrays.copyOf(objArr3, length));
    }
}