package androidx.compose.runtime.reflect;

import I2.C0334s;
import L4.a;
import P4.g;
import androidx.compose.runtime.Composer;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Iterator;
import kotlin.jvm.internal.o;
import x4.AbstractC3226C;
import x4.AbstractC3253s;

/* JADX INFO: loaded from: classes.dex */
public final class ComposableMethodKt {
    private static final int BITS_PER_INT = 31;

    public static final ComposableMethod asComposableMethod(Method method) {
        ComposableInfo composableInfo = getComposableInfo(method);
        if (composableInfo.isComposable()) {
            return new ComposableMethod(method, composableInfo);
        }
        return null;
    }

    private static final int changedParamCount(int i6, int i7) {
        if (i6 == 0) {
            return 1;
        }
        return (int) Math.ceil(((double) (i6 + i7)) / 10.0d);
    }

    private static final int defaultParamCount(int i6) {
        return (int) Math.ceil(((double) i6) / 31.0d);
    }

    private static final <T> T[] dup(T t6, int i6) {
        g gVarL0 = a.l0(0, i6);
        ArrayList arrayList = new ArrayList(AbstractC3253s.G(gVarL0, 10));
        Iterator<T> it = gVarL0.iterator();
        while (it.hasNext()) {
            ((AbstractC3226C) it).a();
            arrayList.add(t6);
        }
        o.m();
        throw null;
    }

    private static final ComposableInfo getComposableInfo(Method method) {
        Class<?>[] parameterTypes = method.getParameterTypes();
        int length = parameterTypes.length - 1;
        if (length >= 0) {
            while (true) {
                int i6 = length - 1;
                if (o.c(parameterTypes[length], Composer.class)) {
                    break;
                }
                if (i6 < 0) {
                    break;
                }
                length = i6;
            }
            length = -1;
        } else {
            length = -1;
        }
        if (length == -1) {
            return new ComposableInfo(false, method.getParameterTypes().length, 0, 0);
        }
        int iChangedParamCount = changedParamCount(length, !Modifier.isStatic(method.getModifiers()) ? 1 : 0);
        int i7 = length + 1 + iChangedParamCount;
        int length2 = method.getParameterTypes().length;
        int iDefaultParamCount = length2 != i7 ? defaultParamCount(length) : 0;
        return new ComposableInfo(i7 + iDefaultParamCount == length2, length, iChangedParamCount, iDefaultParamCount);
    }

    public static final ComposableMethod getDeclaredComposableMethod(Class<?> cls, String str, Class<?>... clsArr) throws NoSuchMethodException {
        Method declaredMethod;
        Class cls2 = Integer.TYPE;
        int iChangedParamCount = changedParamCount(clsArr.length, 0);
        try {
            C0334s c0334s = new C0334s(3);
            ArrayList arrayList = c0334s.f2658b;
            c0334s.f(clsArr);
            c0334s.b(Composer.class);
            g gVarL0 = a.l0(0, iChangedParamCount);
            ArrayList arrayList2 = new ArrayList(AbstractC3253s.G(gVarL0, 10));
            Iterator it = gVarL0.iterator();
            while (it.hasNext()) {
                ((AbstractC3226C) it).a();
                arrayList2.add(cls2);
            }
            c0334s.f(arrayList2.toArray(new Class[0]));
            declaredMethod = cls.getDeclaredMethod(str, (Class[]) arrayList.toArray(new Class[arrayList.size()]));
        } catch (ReflectiveOperationException unused) {
            int iDefaultParamCount = defaultParamCount(clsArr.length);
            try {
                C0334s c0334s2 = new C0334s(4);
                ArrayList arrayList3 = c0334s2.f2658b;
                c0334s2.f(clsArr);
                c0334s2.b(Composer.class);
                g gVarL02 = a.l0(0, iChangedParamCount);
                ArrayList arrayList4 = new ArrayList(AbstractC3253s.G(gVarL02, 10));
                Iterator it2 = gVarL02.iterator();
                while (it2.hasNext()) {
                    ((AbstractC3226C) it2).a();
                    arrayList4.add(cls2);
                }
                c0334s2.f(arrayList4.toArray(new Class[0]));
                g gVarL03 = a.l0(0, iDefaultParamCount);
                ArrayList arrayList5 = new ArrayList(AbstractC3253s.G(gVarL03, 10));
                Iterator it3 = gVarL03.iterator();
                while (it3.hasNext()) {
                    ((AbstractC3226C) it3).a();
                    arrayList5.add(cls2);
                }
                c0334s2.f(arrayList5.toArray(new Class[0]));
                declaredMethod = cls.getDeclaredMethod(str, (Class[]) arrayList3.toArray(new Class[arrayList3.size()]));
            } catch (ReflectiveOperationException unused2) {
                declaredMethod = null;
            }
        }
        if (declaredMethod != null) {
            ComposableMethod composableMethodAsComposableMethod = asComposableMethod(declaredMethod);
            o.e(composableMethodAsComposableMethod);
            return composableMethodAsComposableMethod;
        }
        throw new NoSuchMethodException(cls.getName() + '.' + str);
    }

    /* JADX INFO: Access modifiers changed from: private */
    /* JADX WARN: Failed to restore switch over string. Please report as a decompilation issue */
    public static final Object getDefaultValue(Class<?> cls) {
        String name = cls.getName();
        switch (name.hashCode()) {
            case -1325958191:
                if (name.equals("double")) {
                    return Double.valueOf(0.0d);
                }
                return null;
            case 104431:
                return !name.equals("int") ? null : 0;
            case 3039496:
                return !name.equals("byte") ? null : (byte) 0;
            case 3052374:
                return !name.equals("char") ? null : (char) 0;
            case 3327612:
                return !name.equals("long") ? null : 0L;
            case 64711720:
                if (name.equals("boolean")) {
                    return Boolean.FALSE;
                }
                return null;
            case 97526364:
                if (name.equals("float")) {
                    return Float.valueOf(0.0f);
                }
                return null;
            case 109413500:
                return !name.equals("short") ? null : (short) 0;
            default:
                return null;
        }
    }
}