package androidx.compose.runtime;

import B.C0096y;
import androidx.compose.runtime.collection.MultiValueMap;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import n.N;
import n.O;
import n.a0;
import w4.C3137A;

/* JADX INFO: loaded from: classes.dex */
public final class ComposerImplKt {
    private static final Comparator<Invalidation> InvalidationLocationAscending = new g();
    public static final int nodeKey = 125;
    public static final int rootKey = 100;

    /* JADX INFO: Access modifiers changed from: private */
    public static final int InvalidationLocationAscending$lambda$0(Invalidation invalidation, Invalidation invalidation2) {
        return kotlin.jvm.internal.o.i(invalidation.getLocation(), invalidation2.getLocation());
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final boolean asBool(int i6) {
        return i6 != 0;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final int asInt(boolean z6) {
        return z6 ? 1 : 0;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final List<Object> collectNodesFrom(SlotTable slotTable, Anchor anchor) {
        ArrayList arrayList = new ArrayList();
        SlotReader slotReaderOpenReader = slotTable.openReader();
        try {
            collectNodesFrom$lambda$0$collectFromGroup(slotReaderOpenReader, arrayList, slotTable.anchorIndex(anchor));
            return arrayList;
        } finally {
            slotReaderOpenReader.close();
        }
    }

    private static final void collectNodesFrom$lambda$0$collectFromGroup(SlotReader slotReader, List<Object> list, int i6) {
        if (slotReader.isNode(i6)) {
            list.add(slotReader.node(i6));
            return;
        }
        int iGroupSize = i6 + 1;
        int iGroupSize2 = slotReader.groupSize(i6) + i6;
        while (iGroupSize < iGroupSize2) {
            collectNodesFrom$lambda$0$collectFromGroup(slotReader, list, iGroupSize);
            iGroupSize += slotReader.groupSize(iGroupSize);
        }
    }

    public static final void deactivateCurrentGroup(SlotWriter slotWriter, RememberManager rememberManager) {
        slotWriter.forAllDataInRememberOrder(slotWriter.getCurrentGroup(), new C0096y(11, rememberManager, slotWriter));
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final C3137A deactivateCurrentGroup$lambda$0(RememberManager rememberManager, SlotWriter slotWriter, int i6, Object obj) {
        if (obj instanceof ComposeNodeLifecycleCallback) {
            rememberManager.deactivating((ComposeNodeLifecycleCallback) obj);
        } else if (!(obj instanceof ReusableRememberObserverHolder)) {
            if (obj instanceof RememberObserverHolder) {
                removeData(slotWriter, i6, obj);
                rememberManager.forgetting((RememberObserverHolder) obj);
            } else if (obj instanceof RecomposeScopeImpl) {
                removeData(slotWriter, i6, obj);
                ((RecomposeScopeImpl) obj).release();
            }
        }
        return C3137A.f25453a;
    }

    private static final int distanceFrom(SlotReader slotReader, int i6, int i7) {
        int i8 = 0;
        while (i6 > 0 && i6 != i7) {
            i6 = slotReader.parent(i6);
            i8++;
        }
        return i8;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final int findInsertLocation(List<Invalidation> list, int i6) {
        int iFindLocation = findLocation(list, i6);
        return iFindLocation < 0 ? -(iFindLocation + 1) : iFindLocation;
    }

    private static final int findLocation(List<Invalidation> list, int i6) {
        int size = list.size() - 1;
        int i7 = 0;
        while (i7 <= size) {
            int i8 = (i7 + size) >>> 1;
            int i9 = kotlin.jvm.internal.o.i(list.get(i8).getLocation(), i6);
            if (i9 < 0) {
                i7 = i8 + 1;
            } else {
                if (i9 <= 0) {
                    return i8;
                }
                size = i8 - 1;
            }
        }
        return -(i7 + 1);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final Invalidation firstInRange(List<Invalidation> list, int i6, int i7) {
        int iFindInsertLocation = findInsertLocation(list, i6);
        if (iFindInsertLocation >= list.size()) {
            return null;
        }
        Invalidation invalidation = list.get(iFindInsertLocation);
        if (invalidation.getLocation() < i7) {
            return invalidation;
        }
        return null;
    }

    private static final void forEachInRange(List<Invalidation> list, int i6, int i7, J4.c cVar) {
        for (int iFindInsertLocation = findInsertLocation(list, i6); iFindInsertLocation < list.size(); iFindInsertLocation++) {
            Invalidation invalidation = list.get(iFindInsertLocation);
            if (invalidation.getLocation() >= i7) {
                return;
            }
            cVar.invoke(invalidation);
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final Object getJoinedKey(KeyInfo keyInfo) {
        return keyInfo.getObjectKey() != null ? new JoinedKey(Integer.valueOf(keyInfo.getKey()), keyInfo.getObjectKey()) : Integer.valueOf(keyInfo.getKey());
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final Object getKey(Object obj, Object obj2, Object obj3) {
        JoinedKey joinedKey = obj instanceof JoinedKey ? (JoinedKey) obj : null;
        if (joinedKey == null) {
            return null;
        }
        if (kotlin.jvm.internal.o.c(joinedKey.getLeft(), obj2) && kotlin.jvm.internal.o.c(joinedKey.getRight(), obj3)) {
            return obj;
        }
        Object key = getKey(joinedKey.getLeft(), obj2, obj3);
        return key == null ? getKey(joinedKey.getRight(), obj2, obj3) : key;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final void insertIfMissing(List<Invalidation> list, int i6, RecomposeScopeImpl recomposeScopeImpl, Object obj) {
        int iFindLocation = findLocation(list, i6);
        if (iFindLocation < 0) {
            int i7 = -(iFindLocation + 1);
            if (!(obj instanceof DerivedState)) {
                obj = null;
            }
            list.add(i7, new Invalidation(recomposeScopeImpl, i6, obj));
            return;
        }
        Invalidation invalidation = list.get(iFindLocation);
        if (!(obj instanceof DerivedState)) {
            invalidation.setInstances(null);
            return;
        }
        Object instances = invalidation.getInstances();
        if (instances == null) {
            invalidation.setInstances(obj);
            return;
        }
        if (instances instanceof O) {
            ((O) instances).d(obj);
            return;
        }
        O o6 = a0.f21397a;
        O o7 = new O(2);
        o7.j(instances);
        o7.j(obj);
        invalidation.setInstances(o7);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final <K, V> N multiMap(int i6) {
        return MultiValueMap.m160constructorimpl(new N(i6));
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final int nearestCommonRootOf(SlotReader slotReader, int i6, int i7, int i8) {
        if (i6 != i7) {
            if (i6 == i8 || i7 == i8) {
                return i8;
            }
            if (slotReader.parent(i6) == i7) {
                return i7;
            }
            if (slotReader.parent(i7) != i6) {
                if (slotReader.parent(i6) == slotReader.parent(i7)) {
                    return slotReader.parent(i6);
                }
                int iDistanceFrom = distanceFrom(slotReader, i6, i8);
                int iDistanceFrom2 = distanceFrom(slotReader, i7, i8);
                int i9 = iDistanceFrom - iDistanceFrom2;
                for (int i10 = 0; i10 < i9; i10++) {
                    i6 = slotReader.parent(i6);
                }
                int i11 = iDistanceFrom2 - iDistanceFrom;
                for (int i12 = 0; i12 < i11; i12++) {
                    i7 = slotReader.parent(i7);
                }
                while (i6 != i7) {
                    i6 = slotReader.parent(i6);
                    i7 = slotReader.parent(i7);
                }
                return i6;
            }
        }
        return i6;
    }

    private static final void removeData(SlotWriter slotWriter, int i6, Object obj) {
        Object objClear = slotWriter.clear(i6);
        if (obj == objClear) {
            return;
        }
        ComposerKt.composeImmediateRuntimeError("Slot table is out of sync (expected " + obj + ", got " + objClear + ')');
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final Invalidation removeLocation(List<Invalidation> list, int i6) {
        int iFindLocation = findLocation(list, i6);
        if (iFindLocation >= 0) {
            return list.remove(iFindLocation);
        }
        return null;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final void removeRange(List<Invalidation> list, int i6, int i7) {
        int iFindInsertLocation = findInsertLocation(list, i6);
        while (iFindInsertLocation < list.size() && list.get(iFindInsertLocation).getLocation() < i7) {
            list.remove(iFindInsertLocation);
        }
    }
}