package androidx.compose.runtime.snapshots;

import E3.v;
import a0.I0;
import androidx.compose.runtime.collection.ScatterSetWrapperKt;
import androidx.compose.runtime.internal.AtomicInt;
import androidx.compose.runtime.internal.SnapshotThreadLocal;
import androidx.compose.runtime.internal.WeakReference;
import androidx.compose.runtime.snapshots.Snapshot;
import androidx.compose.runtime.snapshots.SnapshotIdSet;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import kotlin.jvm.internal.o;
import n.O;
import w4.C3137A;
import x4.y;

/* JADX INFO: loaded from: classes.dex */
public final class SnapshotKt {
    private static final long INVALID_SNAPSHOT = 0;
    private static List<? extends J4.e> applyObservers;
    private static final SnapshotWeakSet<StateObject> extraStateObjects;
    private static final GlobalSnapshot globalSnapshot;
    private static List<? extends J4.c> globalWriteObservers;
    private static long nextSnapshotId;
    private static SnapshotIdSet openSnapshots;
    private static AtomicInt pendingApplyObserverCount;
    private static final SnapshotDoubleIndexHeap pinningTable;
    private static final Snapshot snapshotInitializer;
    private static final J4.c emptyLambda = new I0(10);
    private static final SnapshotThreadLocal<Snapshot> threadSnapshot = new SnapshotThreadLocal<>();
    private static final Object lock = new Object();

    static {
        SnapshotIdSet.Companion companion = SnapshotIdSet.Companion;
        openSnapshots = companion.getEMPTY();
        long j4 = 1;
        nextSnapshotId = SnapshotId_jvmKt.toSnapshotId(1) + j4;
        pinningTable = new SnapshotDoubleIndexHeap();
        extraStateObjects = new SnapshotWeakSet<>();
        y yVar = y.f26065a;
        applyObservers = yVar;
        globalWriteObservers = yVar;
        long j6 = nextSnapshotId;
        nextSnapshotId = j4 + j6;
        GlobalSnapshot globalSnapshot2 = new GlobalSnapshot(j6, companion.getEMPTY());
        openSnapshots = openSnapshots.set(globalSnapshot2.getSnapshotId());
        globalSnapshot = globalSnapshot2;
        snapshotInitializer = globalSnapshot2;
        pendingApplyObserverCount = new AtomicInt(0);
    }

    public static final SnapshotIdSet addRange(SnapshotIdSet snapshotIdSet, long j4, long j6) {
        while (o.j(j4, j6) < 0) {
            snapshotIdSet = snapshotIdSet.set(j4);
            j4 += (long) 1;
        }
        return snapshotIdSet;
    }

    /* JADX INFO: Access modifiers changed from: private */
    /* JADX WARN: Removed duplicated region for block: B:42:0x0093  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public static final <T> T advanceGlobalSnapshot(J4.c cVar) {
        O modified$runtime;
        T t6;
        GlobalSnapshot globalSnapshot2 = globalSnapshot;
        synchronized (getLock()) {
            try {
                modified$runtime = globalSnapshot2.getModified$runtime();
                if (modified$runtime != null) {
                    pendingApplyObserverCount.add(1);
                }
                t6 = (T) resetGlobalSnapshotLocked(globalSnapshot2, cVar);
            } catch (Throwable th) {
                throw th;
            }
        }
        if (modified$runtime != null) {
            try {
                List<? extends J4.e> list = applyObservers;
                int size = list.size();
                for (int i6 = 0; i6 < size; i6++) {
                    list.get(i6).invoke(ScatterSetWrapperKt.wrapIntoSet(modified$runtime), globalSnapshot2);
                }
            } finally {
                pendingApplyObserverCount.add(-1);
            }
        }
        synchronized (getLock()) {
            checkAndOverwriteUnusedRecordsLocked();
            if (modified$runtime != null) {
                Object[] objArr = modified$runtime.f21389b;
                long[] jArr = modified$runtime.f21388a;
                int length = jArr.length - 2;
                if (length >= 0) {
                    int i7 = 0;
                    while (true) {
                        long j4 = jArr[i7];
                        if ((((~j4) << 7) & j4 & (-9187201950435737472L)) != -9187201950435737472L) {
                            int i8 = 8 - ((~(i7 - length)) >>> 31);
                            for (int i9 = 0; i9 < i8; i9++) {
                                if ((255 & j4) < 128) {
                                    processForUnusedRecordsLocked((StateObject) objArr[(i7 << 3) + i9]);
                                }
                                j4 >>= 8;
                            }
                            if (i8 != 8) {
                                break;
                            }
                            if (i7 == length) {
                                break;
                            }
                            i7++;
                        }
                    }
                }
            }
        }
        return t6;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final void checkAndOverwriteUnusedRecordsLocked() {
        SnapshotWeakSet<StateObject> snapshotWeakSet = extraStateObjects;
        int size$runtime = snapshotWeakSet.getSize$runtime();
        int i6 = 0;
        int i7 = 0;
        while (true) {
            if (i6 >= size$runtime) {
                break;
            }
            WeakReference<StateObject> weakReference = snapshotWeakSet.getValues$runtime()[i6];
            StateObject stateObject = weakReference != null ? weakReference.get() : null;
            if (stateObject != null && overwriteUnusedRecordsLocked(stateObject)) {
                if (i7 != i6) {
                    snapshotWeakSet.getValues$runtime()[i7] = weakReference;
                    snapshotWeakSet.getHashes$runtime()[i7] = snapshotWeakSet.getHashes$runtime()[i6];
                }
                i7++;
            }
            i6++;
        }
        for (int i8 = i7; i8 < size$runtime; i8++) {
            snapshotWeakSet.getValues$runtime()[i8] = null;
            snapshotWeakSet.getHashes$runtime()[i8] = 0;
        }
        if (i7 != size$runtime) {
            snapshotWeakSet.setSize$runtime(i7);
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final Snapshot createTransparentSnapshotWithNoParentReadObserver(Snapshot snapshot, J4.c cVar, boolean z6) {
        boolean z7 = snapshot instanceof MutableSnapshot;
        if (z7 || snapshot == null) {
            return new TransparentObserverMutableSnapshot(z7 ? (MutableSnapshot) snapshot : null, cVar, null, false, z6);
        }
        return new TransparentObserverSnapshot(snapshot, cVar, false, z6);
    }

    public static /* synthetic */ Snapshot createTransparentSnapshotWithNoParentReadObserver$default(Snapshot snapshot, J4.c cVar, boolean z6, int i6, Object obj) {
        if ((i6 & 2) != 0) {
            cVar = null;
        }
        if ((i6 & 4) != 0) {
            z6 = false;
        }
        return createTransparentSnapshotWithNoParentReadObserver(snapshot, cVar, z6);
    }

    public static final <T extends StateRecord> T current(T t6, Snapshot snapshot) {
        T t7;
        T t8 = (T) readable(t6, snapshot.getSnapshotId(), snapshot.getInvalid$runtime());
        if (t8 != null) {
            return t8;
        }
        synchronized (getLock()) {
            t7 = (T) readable(t6, snapshot.getSnapshotId(), snapshot.getInvalid$runtime());
        }
        if (t7 != null) {
            return t7;
        }
        readError();
        throw new v();
    }

    public static final Snapshot currentSnapshot() {
        Snapshot snapshot = threadSnapshot.get();
        return snapshot == null ? globalSnapshot : snapshot;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final C3137A emptyLambda$lambda$0(SnapshotIdSet snapshotIdSet) {
        return C3137A.f25453a;
    }

    private static final StateRecord findYoungestOr(StateRecord stateRecord, J4.c cVar) {
        StateRecord stateRecord2 = stateRecord;
        while (stateRecord != null) {
            if (((Boolean) cVar.invoke(stateRecord)).booleanValue()) {
                return stateRecord;
            }
            if (o.j(stateRecord2.getSnapshotId$runtime(), stateRecord.getSnapshotId$runtime()) < 0) {
                stateRecord2 = stateRecord;
            }
            stateRecord = stateRecord.getNext$runtime();
        }
        return stateRecord2;
    }

    public static final Object getLock() {
        return lock;
    }

    public static /* synthetic */ void getLock$annotations() {
    }

    public static final Snapshot getSnapshotInitializer() {
        return snapshotInitializer;
    }

    public static /* synthetic */ void getSnapshotInitializer$annotations() {
    }

    public static final J4.c mergedReadObserver(J4.c cVar, J4.c cVar2, boolean z6) {
        if (!z6) {
            cVar2 = null;
        }
        return (cVar == null || cVar2 == null || cVar == cVar2) ? cVar == null ? cVar2 : cVar : new b(0, cVar, cVar2);
    }

    public static /* synthetic */ J4.c mergedReadObserver$default(J4.c cVar, J4.c cVar2, boolean z6, int i6, Object obj) {
        if ((i6 & 4) != 0) {
            z6 = true;
        }
        return mergedReadObserver(cVar, cVar2, z6);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final C3137A mergedReadObserver$lambda$0(J4.c cVar, J4.c cVar2, Object obj) {
        cVar.invoke(obj);
        cVar2.invoke(obj);
        return C3137A.f25453a;
    }

    public static final J4.c mergedWriteObserver(J4.c cVar, J4.c cVar2) {
        return (cVar == null || cVar2 == null || cVar == cVar2) ? cVar == null ? cVar2 : cVar : new b(1, cVar, cVar2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final C3137A mergedWriteObserver$lambda$0(J4.c cVar, J4.c cVar2, Object obj) {
        cVar.invoke(obj);
        cVar2.invoke(obj);
        return C3137A.f25453a;
    }

    public static final <T extends StateRecord> T newOverwritableRecordLocked(T t6, StateObject stateObject) {
        T t7 = (T) usedLocked(stateObject);
        if (t7 != null) {
            t7.setSnapshotId$runtime(Long.MAX_VALUE);
            return t7;
        }
        T t8 = (T) t6.create(Long.MAX_VALUE);
        t8.setNext$runtime(stateObject.getFirstStateRecord());
        stateObject.prependStateRecord(t8);
        return t8;
    }

    public static final <T extends StateRecord> T newWritableRecord(T t6, StateObject stateObject, Snapshot snapshot) {
        T t7;
        synchronized (getLock()) {
            t7 = (T) newWritableRecordLocked(t6, stateObject, snapshot);
        }
        return t7;
    }

    private static final <T extends StateRecord> T newWritableRecordLocked(T t6, StateObject stateObject, Snapshot snapshot) {
        T t7 = (T) newOverwritableRecordLocked(t6, stateObject);
        t7.assign(t6);
        t7.setSnapshotId$runtime(snapshot.getSnapshotId());
        return t7;
    }

    public static final void notifyWrite(Snapshot snapshot, StateObject stateObject) {
        snapshot.setWriteCount$runtime(snapshot.getWriteCount$runtime() + 1);
        J4.c writeObserver$runtime = snapshot.getWriteObserver$runtime();
        if (writeObserver$runtime != null) {
            writeObserver$runtime.invoke(stateObject);
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final Map<StateRecord, StateRecord> optimisticMerges(long j4, MutableSnapshot mutableSnapshot, SnapshotIdSet snapshotIdSet) {
        long[] jArr;
        Map<StateRecord, StateRecord> map;
        SnapshotIdSet snapshotIdSet2;
        Object[] objArr;
        int i6;
        long[] jArr2;
        Map<StateRecord, StateRecord> map2;
        SnapshotIdSet snapshotIdSet3;
        Object[] objArr2;
        int i7;
        int i8;
        O modified$runtime = mutableSnapshot.getModified$runtime();
        Map<StateRecord, StateRecord> map3 = null;
        if (modified$runtime == null) {
            return null;
        }
        long snapshotId = mutableSnapshot.getSnapshotId();
        SnapshotIdSet snapshotIdSetOr = mutableSnapshot.getInvalid$runtime().set(snapshotId).or(mutableSnapshot.getPreviousIds$runtime());
        Object[] objArr3 = modified$runtime.f21389b;
        long[] jArr3 = modified$runtime.f21388a;
        int length = jArr3.length - 2;
        if (length < 0) {
            return null;
        }
        HashMap map4 = null;
        int i9 = 0;
        while (true) {
            long j6 = jArr3[i9];
            if ((((~j6) << 7) & j6 & (-9187201950435737472L)) != -9187201950435737472L) {
                int i10 = 8;
                int i11 = 8 - ((~(i9 - length)) >>> 31);
                int i12 = 0;
                while (i12 < i11) {
                    if ((255 & j6) < 128) {
                        StateObject stateObject = (StateObject) objArr3[(i9 << 3) + i12];
                        map2 = map3;
                        StateRecord firstStateRecord = stateObject.getFirstStateRecord();
                        jArr2 = jArr3;
                        i7 = i9;
                        i8 = i10;
                        StateRecord stateRecord = readable(firstStateRecord, j4, snapshotIdSet);
                        if (stateRecord == null) {
                            objArr2 = objArr3;
                        } else {
                            objArr2 = objArr3;
                            StateRecord stateRecord2 = readable(firstStateRecord, snapshotId, snapshotIdSetOr);
                            if (stateRecord2 != null && !stateRecord.equals(stateRecord2)) {
                                snapshotIdSet3 = snapshotIdSetOr;
                                StateRecord stateRecord3 = readable(firstStateRecord, snapshotId, mutableSnapshot.getInvalid$runtime());
                                if (stateRecord3 == null) {
                                    readError();
                                    throw new v();
                                }
                                StateRecord stateRecordMergeRecords = stateObject.mergeRecords(stateRecord2, stateRecord, stateRecord3);
                                if (stateRecordMergeRecords == null) {
                                    return map2;
                                }
                                if (map4 == null) {
                                    map4 = new HashMap();
                                }
                                map4.put(stateRecord, stateRecordMergeRecords);
                                map4 = map4;
                            }
                        }
                        snapshotIdSet3 = snapshotIdSetOr;
                    } else {
                        jArr2 = jArr3;
                        map2 = map3;
                        snapshotIdSet3 = snapshotIdSetOr;
                        objArr2 = objArr3;
                        i7 = i9;
                        i8 = i10;
                    }
                    j6 >>= i8;
                    i12++;
                    map3 = map2;
                    i9 = i7;
                    i10 = i8;
                    jArr3 = jArr2;
                    objArr3 = objArr2;
                    snapshotIdSetOr = snapshotIdSet3;
                }
                jArr = jArr3;
                map = map3;
                snapshotIdSet2 = snapshotIdSetOr;
                objArr = objArr3;
                i6 = i9;
                if (i11 != i10) {
                    return map4;
                }
            } else {
                jArr = jArr3;
                map = map3;
                snapshotIdSet2 = snapshotIdSetOr;
                objArr = objArr3;
                i6 = i9;
            }
            int i13 = i6;
            if (i13 == length) {
                return map4;
            }
            i9 = i13 + 1;
            map3 = map;
            jArr3 = jArr;
            objArr3 = objArr;
            snapshotIdSetOr = snapshotIdSet2;
        }
    }

    public static final <T extends StateRecord, R> R overwritable(T t6, StateObject stateObject, T t7, J4.c cVar) {
        Snapshot current;
        R r5;
        synchronized (getLock()) {
            current = Snapshot.Companion.getCurrent();
            r5 = (R) cVar.invoke(overwritableRecord(t6, stateObject, current, t7));
        }
        notifyWrite(current, stateObject);
        return r5;
    }

    public static final <T extends StateRecord> T overwritableRecord(T t6, StateObject stateObject, Snapshot snapshot, T t7) {
        T t8;
        if (snapshot.getReadOnly()) {
            snapshot.mo255recordModified$runtime(stateObject);
        }
        long snapshotId = snapshot.getSnapshotId();
        if (t7.getSnapshotId$runtime() == snapshotId) {
            return t7;
        }
        synchronized (getLock()) {
            t8 = (T) newOverwritableRecordLocked(t6, stateObject);
        }
        t8.setSnapshotId$runtime(snapshotId);
        if (t7.getSnapshotId$runtime() != SnapshotId_jvmKt.toSnapshotId(1)) {
            snapshot.mo255recordModified$runtime(stateObject);
        }
        return t8;
    }

    private static final boolean overwriteUnusedRecordsLocked(StateObject stateObject) {
        StateRecord stateRecord;
        long jLowestOrDefault = pinningTable.lowestOrDefault(nextSnapshotId);
        StateRecord stateRecord2 = null;
        StateRecord firstStateRecord = null;
        int i6 = 0;
        for (StateRecord firstStateRecord2 = stateObject.getFirstStateRecord(); firstStateRecord2 != null; firstStateRecord2 = firstStateRecord2.getNext$runtime()) {
            long snapshotId$runtime = firstStateRecord2.getSnapshotId$runtime();
            if (snapshotId$runtime != INVALID_SNAPSHOT) {
                if (o.j(snapshotId$runtime, jLowestOrDefault) >= 0) {
                    i6++;
                } else if (stateRecord2 == null) {
                    i6++;
                    stateRecord2 = firstStateRecord2;
                } else {
                    if (o.j(firstStateRecord2.getSnapshotId$runtime(), stateRecord2.getSnapshotId$runtime()) < 0) {
                        stateRecord = stateRecord2;
                        stateRecord2 = firstStateRecord2;
                    } else {
                        stateRecord = firstStateRecord2;
                    }
                    if (firstStateRecord == null) {
                        firstStateRecord = stateObject.getFirstStateRecord();
                        StateRecord stateRecord3 = firstStateRecord;
                        while (true) {
                            if (firstStateRecord == null) {
                                firstStateRecord = stateRecord3;
                                break;
                            }
                            if (o.j(firstStateRecord.getSnapshotId$runtime(), jLowestOrDefault) >= 0) {
                                break;
                            }
                            if (o.j(stateRecord3.getSnapshotId$runtime(), firstStateRecord.getSnapshotId$runtime()) < 0) {
                                stateRecord3 = firstStateRecord;
                            }
                            firstStateRecord = firstStateRecord.getNext$runtime();
                        }
                    }
                    stateRecord2.setSnapshotId$runtime(INVALID_SNAPSHOT);
                    stateRecord2.assign(firstStateRecord);
                    stateRecord2 = stateRecord;
                }
            }
        }
        return i6 > 1;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final void processForUnusedRecordsLocked(StateObject stateObject) {
        if (overwriteUnusedRecordsLocked(stateObject)) {
            extraStateObjects.add(stateObject);
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final Void readError() {
        throw new IllegalStateException("Reading a state that was created after the snapshot was taken or in a snapshot that has not yet been applied");
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final <T extends StateRecord> T readable(T t6, long j4, SnapshotIdSet snapshotIdSet) {
        T t7 = null;
        while (t6 != null) {
            if (valid(t6, j4, snapshotIdSet) && (t7 == null || o.j(t7.getSnapshotId$runtime(), t6.getSnapshotId$runtime()) < 0)) {
                t7 = t6;
            }
            t6 = (T) t6.getNext$runtime();
        }
        if (t7 != null) {
            return t7;
        }
        return null;
    }

    public static final void releasePinningLocked(int i6) {
        pinningTable.remove(i6);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final Void reportReadonlySnapshotWrite() {
        throw new IllegalStateException("Cannot modify a state object in a read-only snapshot");
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final <T> T resetGlobalSnapshotLocked(GlobalSnapshot globalSnapshot2, J4.c cVar) {
        long snapshotId = globalSnapshot2.getSnapshotId();
        T t6 = (T) cVar.invoke(openSnapshots.clear(snapshotId));
        long j4 = nextSnapshotId;
        nextSnapshotId = ((long) 1) + j4;
        openSnapshots = openSnapshots.clear(snapshotId);
        globalSnapshot2.setSnapshotId$runtime(j4);
        globalSnapshot2.setInvalid$runtime(openSnapshots);
        globalSnapshot2.setWriteCount$runtime(0);
        globalSnapshot2.setModified$runtime(null);
        globalSnapshot2.releasePinnedSnapshotLocked$runtime();
        openSnapshots = openSnapshots.set(j4);
        return t6;
    }

    public static final <T> T sync(J4.a aVar) {
        T t6;
        synchronized (getLock()) {
            t6 = (T) aVar.invoke();
        }
        return t6;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final <T extends Snapshot> T takeNewSnapshot(J4.c cVar) {
        return (T) advanceGlobalSnapshot(new c(0, cVar));
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final Snapshot takeNewSnapshot$lambda$0(J4.c cVar, SnapshotIdSet snapshotIdSet) {
        Snapshot snapshot = (Snapshot) cVar.invoke(snapshotIdSet);
        synchronized (getLock()) {
            openSnapshots = openSnapshots.set(snapshot.getSnapshotId());
        }
        return snapshot;
    }

    public static final int trackPinning(long j4, SnapshotIdSet snapshotIdSet) {
        int iAdd;
        long jLowest = snapshotIdSet.lowest(j4);
        synchronized (getLock()) {
            iAdd = pinningTable.add(jLowest);
        }
        return iAdd;
    }

    private static final StateRecord usedLocked(StateObject stateObject) {
        long jLowestOrDefault = pinningTable.lowestOrDefault(nextSnapshotId) - ((long) 1);
        SnapshotIdSet empty = SnapshotIdSet.Companion.getEMPTY();
        StateRecord stateRecord = null;
        for (StateRecord firstStateRecord = stateObject.getFirstStateRecord(); firstStateRecord != null; firstStateRecord = firstStateRecord.getNext$runtime()) {
            if (firstStateRecord.getSnapshotId$runtime() != INVALID_SNAPSHOT) {
                if (valid(firstStateRecord, jLowestOrDefault, empty)) {
                    if (stateRecord == null) {
                        stateRecord = firstStateRecord;
                    } else if (o.j(firstStateRecord.getSnapshotId$runtime(), stateRecord.getSnapshotId$runtime()) >= 0) {
                        return stateRecord;
                    }
                }
            }
            return firstStateRecord;
        }
        return null;
    }

    private static final boolean valid(long j4, long j6, SnapshotIdSet snapshotIdSet) {
        return (j6 == INVALID_SNAPSHOT || o.j(j6, j4) > 0 || snapshotIdSet.get(j6)) ? false : true;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final void validateOpen(Snapshot snapshot) {
        long jLowestOrDefault;
        if (openSnapshots.get(snapshot.getSnapshotId())) {
            return;
        }
        StringBuilder sb = new StringBuilder("Snapshot is not open: snapshotId=");
        sb.append(snapshot.getSnapshotId());
        sb.append(", disposed=");
        sb.append(snapshot.getDisposed$runtime());
        sb.append(", applied=");
        MutableSnapshot mutableSnapshot = snapshot instanceof MutableSnapshot ? (MutableSnapshot) snapshot : null;
        sb.append(mutableSnapshot != null ? Boolean.valueOf(mutableSnapshot.getApplied$runtime()) : "read-only");
        sb.append(", lowestPin=");
        synchronized (getLock()) {
            jLowestOrDefault = pinningTable.lowestOrDefault(-1L);
        }
        sb.append(jLowestOrDefault);
        throw new IllegalStateException(sb.toString().toString());
    }

    public static final <T extends StateRecord, R> R withCurrent(T t6, J4.c cVar) {
        return (R) cVar.invoke(current(t6));
    }

    public static final <T extends StateRecord, R> R writable(T t6, StateObject stateObject, Snapshot snapshot, J4.c cVar) {
        R r5;
        synchronized (getLock()) {
            r5 = (R) cVar.invoke(writableRecord(t6, stateObject, snapshot));
        }
        notifyWrite(snapshot, stateObject);
        return r5;
    }

    public static final <T extends StateRecord> T writableRecord(T t6, StateObject stateObject, Snapshot snapshot) {
        T t7;
        if (snapshot.getReadOnly()) {
            snapshot.mo255recordModified$runtime(stateObject);
        }
        long snapshotId = snapshot.getSnapshotId();
        T t8 = (T) readable(t6, snapshotId, snapshot.getInvalid$runtime());
        if (t8 == null) {
            readError();
            throw new v();
        }
        if (t8.getSnapshotId$runtime() == snapshot.getSnapshotId()) {
            return t8;
        }
        synchronized (getLock()) {
            t7 = (T) readable(stateObject.getFirstStateRecord(), snapshotId, snapshot.getInvalid$runtime());
            if (t7 == null) {
                readError();
                throw new v();
            }
            if (t7.getSnapshotId$runtime() != snapshotId) {
                t7 = (T) newWritableRecordLocked(t7, stateObject, snapshot);
            }
        }
        o.f(t7, "null cannot be cast to non-null type T of androidx.compose.runtime.snapshots.SnapshotKt.writableRecord");
        if (t8.getSnapshotId$runtime() != SnapshotId_jvmKt.toSnapshotId(1)) {
            snapshot.mo255recordModified$runtime(stateObject);
        }
        return t7;
    }

    private static final boolean valid(StateRecord stateRecord, long j4, SnapshotIdSet snapshotIdSet) {
        return valid(j4, stateRecord.getSnapshotId$runtime(), snapshotIdSet);
    }

    public static final <T extends StateRecord> T readable(T t6, StateObject stateObject) {
        T t7;
        Snapshot.Companion companion = Snapshot.Companion;
        Snapshot current = companion.getCurrent();
        J4.c readObserver = current.getReadObserver();
        if (readObserver != null) {
            readObserver.invoke(stateObject);
        }
        T t8 = (T) readable(t6, current.getSnapshotId(), current.getInvalid$runtime());
        if (t8 != null) {
            return t8;
        }
        synchronized (getLock()) {
            Snapshot current2 = companion.getCurrent();
            StateRecord firstStateRecord = stateObject.getFirstStateRecord();
            o.f(firstStateRecord, "null cannot be cast to non-null type T of androidx.compose.runtime.snapshots.SnapshotKt.readable");
            t7 = (T) readable(firstStateRecord, current2.getSnapshotId(), current2.getInvalid$runtime());
            if (t7 == null) {
                readError();
                throw new v();
            }
        }
        return t7;
    }

    public static final <T extends StateRecord, R> R writable(T t6, StateObject stateObject, J4.c cVar) {
        Snapshot current;
        R r5;
        synchronized (getLock()) {
            current = Snapshot.Companion.getCurrent();
            r5 = (R) cVar.invoke(writableRecord(t6, stateObject, current));
        }
        notifyWrite(current, stateObject);
        return r5;
    }

    public static final <T extends StateRecord> T current(T t6) {
        T t7;
        Snapshot.Companion companion = Snapshot.Companion;
        Snapshot current = companion.getCurrent();
        T t8 = (T) readable(t6, current.getSnapshotId(), current.getInvalid$runtime());
        if (t8 != null) {
            return t8;
        }
        synchronized (getLock()) {
            Snapshot current2 = companion.getCurrent();
            t7 = (T) readable(t6, current2.getSnapshotId(), current2.getInvalid$runtime());
        }
        if (t7 != null) {
            return t7;
        }
        readError();
        throw new v();
    }

    public static final <T extends StateRecord> T readable(T t6, StateObject stateObject, Snapshot snapshot) {
        T t7;
        J4.c readObserver = snapshot.getReadObserver();
        if (readObserver != null) {
            readObserver.invoke(stateObject);
        }
        T t8 = (T) readable(t6, snapshot.getSnapshotId(), snapshot.getInvalid$runtime());
        if (t8 != null) {
            return t8;
        }
        synchronized (getLock()) {
            Snapshot current = Snapshot.Companion.getCurrent();
            StateRecord firstStateRecord = stateObject.getFirstStateRecord();
            o.f(firstStateRecord, "null cannot be cast to non-null type T of androidx.compose.runtime.snapshots.SnapshotKt.readable");
            t7 = (T) readable(firstStateRecord, current.getSnapshotId(), current.getInvalid$runtime());
            if (t7 == null) {
                readError();
                throw new v();
            }
        }
        return t7;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final void advanceGlobalSnapshot() {
        advanceGlobalSnapshot(emptyLambda);
    }
}