package androidx.compose.runtime.changelist;

import J4.a;
import J4.c;
import J4.e;
import androidx.compose.runtime.Anchor;
import androidx.compose.runtime.ComposerImpl;
import androidx.compose.runtime.ComposerKt;
import androidx.compose.runtime.Composition;
import androidx.compose.runtime.CompositionContext;
import androidx.compose.runtime.ControlledComposition;
import androidx.compose.runtime.IntStack;
import androidx.compose.runtime.MovableContentState;
import androidx.compose.runtime.MovableContentStateReference;
import androidx.compose.runtime.RecomposeScopeImpl;
import androidx.compose.runtime.RememberObserverHolder;
import androidx.compose.runtime.SlotReader;
import androidx.compose.runtime.SlotTable;
import androidx.compose.runtime.Stack;
import androidx.compose.runtime.internal.IntRef;
import androidx.compose.runtime.internal.StabilityInferred;
import java.util.ArrayList;
import java.util.List;
import kotlin.jvm.internal.h;

/* JADX INFO: loaded from: classes.dex */
@StabilityInferred(parameters = 0)
public final class ComposerChangeListWriter {
    private static final int invalidGroupLocation = -2;
    private ChangeList changeList;
    private final ComposerImpl composer;
    private int moveCount;
    private int pendingUps;
    private boolean startedGroup;
    private int writersReaderDelta;
    public static final Companion Companion = new Companion(null);
    public static final int $stable = 8;
    private final IntStack startedGroups = new IntStack();
    private boolean implicitRootStart = true;
    private final ArrayList<Object> pendingDownNodes = Stack.m66constructorimpl$default(null, 1, null);
    private int removeFrom = -1;
    private int moveFrom = -1;
    private int moveTo = -1;

    public static final class Companion {
        public /* synthetic */ Companion(h hVar) {
            this();
        }

        private Companion() {
        }
    }

    public ComposerChangeListWriter(ComposerImpl composerImpl, ChangeList changeList) {
        this.composer = composerImpl;
        this.changeList = changeList;
    }

    private final void ensureGroupStarted(Anchor anchor) {
        pushSlotTableOperationPreamble$default(this, false, 1, null);
        this.changeList.pushEnsureGroupStarted(anchor);
        this.startedGroup = true;
    }

    private final void ensureRootStarted() {
        if (this.startedGroup || !this.implicitRootStart) {
            return;
        }
        pushSlotTableOperationPreamble$default(this, false, 1, null);
        this.changeList.pushEnsureRootStarted();
        this.startedGroup = true;
    }

    private final SlotReader getReader() {
        return this.composer.getReader$runtime();
    }

    public static /* synthetic */ void includeOperationsIn$default(ComposerChangeListWriter composerChangeListWriter, ChangeList changeList, IntRef intRef, int i6, Object obj) {
        if ((i6 & 2) != 0) {
            intRef = null;
        }
        composerChangeListWriter.includeOperationsIn(changeList, intRef);
    }

    private final void pushApplierOperationPreamble() {
        pushPendingUpsAndDowns();
    }

    private final void pushPendingUpsAndDowns() {
        int i6 = this.pendingUps;
        if (i6 > 0) {
            this.changeList.pushUps(i6);
            this.pendingUps = 0;
        }
        if (Stack.m72isNotEmptyimpl(this.pendingDownNodes)) {
            this.changeList.pushDowns(Stack.m77toArrayimpl(this.pendingDownNodes));
            Stack.m64clearimpl(this.pendingDownNodes);
        }
    }

    private final void pushSlotEditingOperationPreamble() {
        realizeOperationLocation$default(this, false, 1, null);
        recordSlotEditing();
    }

    private final void pushSlotTableOperationPreamble(boolean z6) {
        realizeOperationLocation(z6);
    }

    public static /* synthetic */ void pushSlotTableOperationPreamble$default(ComposerChangeListWriter composerChangeListWriter, boolean z6, int i6, Object obj) {
        if ((i6 & 1) != 0) {
            z6 = false;
        }
        composerChangeListWriter.pushSlotTableOperationPreamble(z6);
    }

    private final void realizeMoveNode(int i6, int i7, int i8) {
        pushApplierOperationPreamble();
        this.changeList.pushMoveNode(i6, i7, i8);
    }

    private final void realizeNodeMovementOperations() {
        int i6 = this.moveCount;
        if (i6 > 0) {
            int i7 = this.removeFrom;
            if (i7 >= 0) {
                realizeRemoveNode(i7, i6);
                this.removeFrom = -1;
            } else {
                realizeMoveNode(this.moveTo, this.moveFrom, i6);
                this.moveFrom = -1;
                this.moveTo = -1;
            }
            this.moveCount = 0;
        }
    }

    private final void realizeOperationLocation(boolean z6) {
        int parent = z6 ? getReader().getParent() : getReader().getCurrentGroup();
        int i6 = parent - this.writersReaderDelta;
        if (!(i6 >= 0)) {
            ComposerKt.composeImmediateRuntimeError("Tried to seek backward");
        }
        if (i6 > 0) {
            this.changeList.pushAdvanceSlotsBy(i6);
            this.writersReaderDelta = parent;
        }
    }

    public static /* synthetic */ void realizeOperationLocation$default(ComposerChangeListWriter composerChangeListWriter, boolean z6, int i6, Object obj) {
        if ((i6 & 1) != 0) {
            z6 = false;
        }
        composerChangeListWriter.realizeOperationLocation(z6);
    }

    private final void realizeRemoveNode(int i6, int i7) {
        pushApplierOperationPreamble();
        this.changeList.pushRemoveNode(i6, i7);
    }

    public final void appendValue(Anchor anchor, Object obj) {
        this.changeList.pushAppendValue(anchor, obj);
    }

    public final void copyNodesToNewAnchorLocation(List<? extends Object> list, IntRef intRef) {
        this.changeList.pushCopyNodesToNewAnchorLocation(list, intRef);
    }

    public final void copySlotTableToAnchorLocation(MovableContentState movableContentState, CompositionContext compositionContext, MovableContentStateReference movableContentStateReference, MovableContentStateReference movableContentStateReference2) {
        this.changeList.pushCopySlotTableToAnchorLocation(movableContentState, compositionContext, movableContentStateReference, movableContentStateReference2);
    }

    public final void deactivateCurrentGroup() {
        pushSlotTableOperationPreamble$default(this, false, 1, null);
        this.changeList.pushDeactivateCurrentGroup();
    }

    public final void determineMovableContentNodeIndex(IntRef intRef, Anchor anchor) {
        pushPendingUpsAndDowns();
        this.changeList.pushDetermineMovableContentNodeIndex(intRef, anchor);
    }

    public final void endCompositionScope(c cVar, Composition composition) {
        this.changeList.pushEndCompositionScope(cVar, composition);
    }

    public final void endCurrentGroup() {
        int parent = getReader().getParent();
        if (!(this.startedGroups.peekOr(-1) <= parent)) {
            ComposerKt.composeImmediateRuntimeError("Missed recording an endGroup");
        }
        if (this.startedGroups.peekOr(-1) == parent) {
            pushSlotTableOperationPreamble$default(this, false, 1, null);
            this.startedGroups.pop();
            this.changeList.pushEndCurrentGroup();
        }
    }

    public final void endMovableContentPlacement() {
        pushPendingUpsAndDowns();
        this.changeList.pushEndMovableContentPlacement();
        this.writersReaderDelta = 0;
    }

    public final void endNodeMovement() {
        realizeNodeMovementOperations();
    }

    public final void endNodeMovementAndDeleteNode(int i6, int i7) {
        endNodeMovement();
        pushPendingUpsAndDowns();
        int iNodeCount = getReader().isNode(i7) ? 1 : getReader().nodeCount(i7);
        if (iNodeCount > 0) {
            removeNode(i6, iNodeCount);
        }
    }

    public final void endResumingScope(RecomposeScopeImpl recomposeScopeImpl) {
        this.changeList.pushEndResumingScope(recomposeScopeImpl);
    }

    public final void endRoot() {
        if (this.startedGroup) {
            pushSlotTableOperationPreamble$default(this, false, 1, null);
            pushSlotTableOperationPreamble$default(this, false, 1, null);
            this.changeList.pushEndCurrentGroup();
            this.startedGroup = false;
        }
    }

    public final void finalizeComposition() {
        pushPendingUpsAndDowns();
        if (this.startedGroups.tos == 0) {
            return;
        }
        ComposerKt.composeImmediateRuntimeError("Missed recording an endGroup()");
    }

    public final ChangeList getChangeList() {
        return this.changeList;
    }

    public final boolean getImplicitRootStart() {
        return this.implicitRootStart;
    }

    public final boolean getPastParent() {
        return getReader().getParent() - this.writersReaderDelta < 0;
    }

    public final void includeOperationsIn(ChangeList changeList, IntRef intRef) {
        this.changeList.pushExecuteOperationsIn(changeList, intRef);
    }

    public final void insertSlots(Anchor anchor, SlotTable slotTable) {
        pushPendingUpsAndDowns();
        pushSlotEditingOperationPreamble();
        realizeNodeMovementOperations();
        this.changeList.pushInsertSlots(anchor, slotTable);
    }

    public final void moveCurrentGroup(int i6) {
        pushSlotEditingOperationPreamble();
        this.changeList.pushMoveCurrentGroup(i6);
    }

    public final void moveDown(Object obj) {
        realizeNodeMovementOperations();
        Stack.m76pushimpl(this.pendingDownNodes, obj);
    }

    public final void moveNode(int i6, int i7, int i8) {
        if (i8 > 0) {
            int i9 = this.moveCount;
            if (i9 > 0 && this.moveFrom == i6 - i9 && this.moveTo == i7 - i9) {
                this.moveCount = i9 + i8;
                return;
            }
            realizeNodeMovementOperations();
            this.moveFrom = i6;
            this.moveTo = i7;
            this.moveCount = i8;
        }
    }

    public final void moveReaderRelativeTo(int i6) {
        this.writersReaderDelta = (i6 - getReader().getCurrentGroup()) + this.writersReaderDelta;
    }

    public final void moveReaderToAbsolute(int i6) {
        this.writersReaderDelta = i6;
    }

    public final void moveUp() {
        realizeNodeMovementOperations();
        if (Stack.m72isNotEmptyimpl(this.pendingDownNodes)) {
            Stack.m75popimpl(this.pendingDownNodes);
        } else {
            this.pendingUps++;
        }
    }

    public final void recordSlotEditing() {
        SlotReader reader;
        int parent;
        if (getReader().getSize() <= 0 || this.startedGroups.peekOr(-2) == (parent = (reader = getReader()).getParent())) {
            return;
        }
        ensureRootStarted();
        if (parent > 0) {
            Anchor anchor = reader.anchor(parent);
            this.startedGroups.push(parent);
            ensureGroupStarted(anchor);
        }
    }

    public final void releaseMovableContent() {
        pushPendingUpsAndDowns();
        if (this.startedGroup) {
            skipToEndOfCurrentGroup();
            endRoot();
        }
    }

    public final void releaseMovableGroupAtCurrent(ControlledComposition controlledComposition, CompositionContext compositionContext, MovableContentStateReference movableContentStateReference) {
        this.changeList.pushReleaseMovableGroupAtCurrent(controlledComposition, compositionContext, movableContentStateReference);
    }

    public final void remember(RememberObserverHolder rememberObserverHolder) {
        this.changeList.pushRemember(rememberObserverHolder);
    }

    public final void rememberPausingScope(RecomposeScopeImpl recomposeScopeImpl) {
        this.changeList.pushRememberPausingScope(recomposeScopeImpl);
    }

    public final void removeCurrentGroup() {
        pushSlotEditingOperationPreamble();
        this.changeList.pushRemoveCurrentGroup();
        this.writersReaderDelta = getReader().getGroupSize() + this.writersReaderDelta;
    }

    public final void removeNode(int i6, int i7) {
        if (i7 > 0) {
            if (!(i6 >= 0)) {
                ComposerKt.composeImmediateRuntimeError("Invalid remove index " + i6);
            }
            if (this.removeFrom == i6) {
                this.moveCount += i7;
                return;
            }
            realizeNodeMovementOperations();
            this.removeFrom = i6;
            this.moveCount = i7;
        }
    }

    public final void resetSlots() {
        this.changeList.pushResetSlots();
    }

    public final void resetTransientState() {
        this.startedGroup = false;
        this.startedGroups.clear();
        this.writersReaderDelta = 0;
        this.implicitRootStart = true;
        this.pendingUps = 0;
        Stack.m64clearimpl(this.pendingDownNodes);
        this.removeFrom = -1;
        this.moveFrom = -1;
        this.moveTo = -1;
        this.moveCount = 0;
    }

    public final void setChangeList(ChangeList changeList) {
        this.changeList = changeList;
    }

    public final void setImplicitRootStart(boolean z6) {
        this.implicitRootStart = z6;
    }

    public final void sideEffect(a aVar) {
        this.changeList.pushSideEffect(aVar);
    }

    public final void skipToEndOfCurrentGroup() {
        this.changeList.pushSkipToEndOfCurrentGroup();
    }

    public final void startResumingScope(RecomposeScopeImpl recomposeScopeImpl) {
        this.changeList.pushStartResumingScope(recomposeScopeImpl);
    }

    public final void trimValues(int i6) {
        if (i6 > 0) {
            pushSlotEditingOperationPreamble();
            this.changeList.pushTrimValues(i6);
        }
    }

    public final void updateAnchoredValue(Object obj, Anchor anchor, int i6) {
        this.changeList.pushUpdateAnchoredValue(obj, anchor, i6);
    }

    public final void updateAuxData(Object obj) {
        pushSlotTableOperationPreamble$default(this, false, 1, null);
        this.changeList.pushUpdateAuxData(obj);
    }

    public final <T, V> void updateNode(V v3, e eVar) {
        pushApplierOperationPreamble();
        this.changeList.pushUpdateNode(v3, eVar);
    }

    public final void updateValue(Object obj, int i6) {
        pushSlotTableOperationPreamble(true);
        this.changeList.pushUpdateValue(obj, i6);
    }

    public final void useNode(Object obj) {
        pushApplierOperationPreamble();
        this.changeList.pushUseNode(obj);
    }

    public final void withChangeList(ChangeList changeList, a aVar) {
        ChangeList changeList2 = getChangeList();
        try {
            setChangeList(changeList);
            aVar.invoke();
        } finally {
            setChangeList(changeList2);
        }
    }

    public final void withoutImplicitRootStart(a aVar) {
        boolean implicitRootStart = getImplicitRootStart();
        try {
            setImplicitRootStart(false);
            aVar.invoke();
        } finally {
            setImplicitRootStart(implicitRootStart);
        }
    }

    public final void insertSlots(Anchor anchor, SlotTable slotTable, FixupList fixupList) {
        pushPendingUpsAndDowns();
        pushSlotEditingOperationPreamble();
        realizeNodeMovementOperations();
        this.changeList.pushInsertSlots(anchor, slotTable, fixupList);
    }
}