package androidx.compose.runtime.internal;

import androidx.compose.runtime.ComposeNodeLifecycleCallback;
import androidx.compose.runtime.RecomposeScopeImpl;
import androidx.compose.runtime.RememberManager;
import androidx.compose.runtime.RememberObserver;
import androidx.compose.runtime.RememberObserverHolder;
import androidx.compose.runtime.Stack;
import androidx.compose.runtime.collection.MutableVector;
import androidx.compose.runtime.tooling.CompositionErrorContext;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Set;
import n.N;
import n.O;
import n.Y;
import n.Z;
import n.a0;

/* JADX INFO: loaded from: classes.dex */
@StabilityInferred(parameters = 0)
public final class RememberEventDispatcher implements RememberManager {
    public static final int $stable = 8;
    private Set<RememberObserver> abandoning;
    private MutableVector<RememberObserverHolder> currentRememberingList;
    private Z ignoreLeavingSet;
    private final MutableVector<Object> leaving;
    private ArrayList<MutableVector<RememberObserverHolder>> nestedRemembersLists;
    private N pausedPlaceholders;
    private O releasing;
    private O rememberSet;
    private final MutableVector<RememberObserverHolder> remembering;
    private final MutableVector<J4.a> sideEffects;
    private CompositionErrorContext traceContext;

    public RememberEventDispatcher() {
        MutableVector<RememberObserverHolder> mutableVector = new MutableVector<>(new RememberObserverHolder[16], 0);
        this.remembering = mutableVector;
        O o6 = a0.f21397a;
        this.rememberSet = new O();
        this.currentRememberingList = mutableVector;
        this.leaving = new MutableVector<>(new Object[16], 0);
        this.sideEffects = new MutableVector<>(new J4.a[16], 0);
    }

    private final void dispatchRememberList(MutableVector<RememberObserverHolder> mutableVector) {
        Set<RememberObserver> set = this.abandoning;
        if (set == null) {
            return;
        }
        RememberObserverHolder[] rememberObserverHolderArr = mutableVector.content;
        int size = mutableVector.getSize();
        for (int i6 = 0; i6 < size; i6++) {
            RememberObserverHolder rememberObserverHolder = rememberObserverHolderArr[i6];
            RememberObserver wrapped = rememberObserverHolder.getWrapped();
            set.remove(wrapped);
            try {
                wrapped.onRemembered();
            } catch (Throwable th) {
                CompositionErrorContext compositionErrorContext = this.traceContext;
                if (compositionErrorContext != null) {
                    compositionErrorContext.attachComposeStackTrace(th, rememberObserverHolder);
                }
                throw th;
            }
        }
    }

    private static final boolean forgetting$removeFrom(RememberObserverHolder rememberObserverHolder, MutableVector<RememberObserverHolder> mutableVector) {
        RememberObserverHolder[] rememberObserverHolderArr = mutableVector.content;
        int size = mutableVector.getSize();
        for (int i6 = 0; i6 < size; i6++) {
            RememberObserver wrapped = rememberObserverHolderArr[i6].getWrapped();
            if (wrapped instanceof PausedCompositionRemembers) {
                MutableVector<RememberObserverHolder> pausedRemembers = ((PausedCompositionRemembers) wrapped).getPausedRemembers();
                if (pausedRemembers.remove(rememberObserverHolder) || forgetting$removeFrom(rememberObserverHolder, pausedRemembers)) {
                    return true;
                }
            }
        }
        return false;
    }

    private final void recordLeaving(Object obj) {
        this.leaving.add(obj);
    }

    private final <T> T withComposeStackTrace(Object obj, J4.a aVar) {
        try {
            return (T) aVar.invoke();
        } catch (Throwable th) {
            CompositionErrorContext compositionErrorContext = this.traceContext;
            if (compositionErrorContext != null) {
                compositionErrorContext.attachComposeStackTrace(th, obj);
            }
            throw th;
        }
    }

    public final void clear() {
        this.abandoning = null;
        this.traceContext = null;
        this.remembering.clear();
        this.rememberSet.e();
        this.currentRememberingList = this.remembering;
        this.leaving.clear();
        this.sideEffects.clear();
        this.releasing = null;
        this.pausedPlaceholders = null;
        this.nestedRemembersLists = null;
    }

    @Override // androidx.compose.runtime.RememberManager
    public void deactivating(ComposeNodeLifecycleCallback composeNodeLifecycleCallback) {
        recordLeaving(composeNodeLifecycleCallback);
    }

    public final void dispatchAbandons() {
        Set<RememberObserver> set = this.abandoning;
        if (set == null || set.isEmpty()) {
            return;
        }
        Object objBeginSection = Trace.INSTANCE.beginSection("Compose:abandons");
        try {
            Iterator<RememberObserver> it = set.iterator();
            while (it.hasNext()) {
                RememberObserver next = it.next();
                it.remove();
                next.onAbandoned();
            }
        } finally {
            Trace.INSTANCE.endSection(objBeginSection);
        }
    }

    public final void dispatchOnDeactivateIfNecessary(ComposeNodeLifecycleCallback composeNodeLifecycleCallback) {
        if (this.leaving.remove(composeNodeLifecycleCallback)) {
            composeNodeLifecycleCallback.onDeactivate();
        }
    }

    public final void dispatchRememberObservers() {
        Object objBeginSection;
        Set<RememberObserver> set = this.abandoning;
        if (set == null) {
            return;
        }
        this.ignoreLeavingSet = null;
        if (this.leaving.getSize() != 0) {
            objBeginSection = Trace.INSTANCE.beginSection("Compose:onForgotten");
            try {
                O o6 = this.releasing;
                int size = this.leaving.getSize();
                while (true) {
                    size--;
                    if (-1 >= size) {
                        break;
                    }
                    Object obj = this.leaving.content[size];
                    try {
                        if (obj instanceof RememberObserverHolder) {
                            RememberObserver wrapped = ((RememberObserverHolder) obj).getWrapped();
                            set.remove(wrapped);
                            wrapped.onForgotten();
                        }
                        if (obj instanceof ComposeNodeLifecycleCallback) {
                            if (o6 == null || !o6.a(obj)) {
                                ((ComposeNodeLifecycleCallback) obj).onDeactivate();
                            } else {
                                ((ComposeNodeLifecycleCallback) obj).onRelease();
                            }
                        }
                    } finally {
                    }
                }
            } catch (Throwable th) {
                throw th;
            }
        }
        if (this.remembering.getSize() != 0) {
            Trace trace = Trace.INSTANCE;
            objBeginSection = trace.beginSection("Compose:onRemembered");
            try {
                dispatchRememberList(this.remembering);
                trace.endSection(objBeginSection);
            } finally {
                Trace.INSTANCE.endSection(objBeginSection);
            }
        }
    }

    public final void dispatchSideEffects() {
        if (this.sideEffects.getSize() != 0) {
            Object objBeginSection = Trace.INSTANCE.beginSection("Compose:sideeffects");
            try {
                MutableVector<J4.a> mutableVector = this.sideEffects;
                J4.a[] aVarArr = mutableVector.content;
                int size = mutableVector.getSize();
                for (int i6 = 0; i6 < size; i6++) {
                    aVarArr[i6].invoke();
                }
                this.sideEffects.clear();
                Trace.INSTANCE.endSection(objBeginSection);
            } catch (Throwable th) {
                Trace.INSTANCE.endSection(objBeginSection);
                throw th;
            }
        }
    }

    @Override // androidx.compose.runtime.RememberManager
    public void endResumingScope(RecomposeScopeImpl recomposeScopeImpl) {
        MutableVector<RememberObserverHolder> mutableVector;
        N n6 = this.pausedPlaceholders;
        if (n6 == null || ((PausedCompositionRemembers) n6.d(recomposeScopeImpl)) == null) {
            return;
        }
        ArrayList<MutableVector<RememberObserverHolder>> arrayList = this.nestedRemembersLists;
        if (arrayList != null && (mutableVector = (MutableVector) Stack.m75popimpl(arrayList)) != null) {
            this.currentRememberingList = mutableVector;
        }
        n6.j(recomposeScopeImpl);
    }

    public final Z extractRememberSet() {
        if (!this.rememberSet.c()) {
            return null;
        }
        O o6 = this.rememberSet;
        O o7 = a0.f21397a;
        this.rememberSet = new O();
        this.remembering.clear();
        return o6;
    }

    @Override // androidx.compose.runtime.RememberManager
    public void forgetting(RememberObserverHolder rememberObserverHolder) {
        if (!this.rememberSet.a(rememberObserverHolder)) {
            Z z6 = this.ignoreLeavingSet;
            if (z6 == null || !z6.a(rememberObserverHolder)) {
                recordLeaving(rememberObserverHolder);
                return;
            }
            return;
        }
        this.rememberSet.l(rememberObserverHolder);
        if (!this.currentRememberingList.remove(rememberObserverHolder) && !this.remembering.remove(rememberObserverHolder)) {
            forgetting$removeFrom(rememberObserverHolder, this.remembering);
        }
        Set<RememberObserver> set = this.abandoning;
        if (set == null) {
            return;
        }
        set.add(rememberObserverHolder.getWrapped());
    }

    public final void ignoreForgotten(Z z6) {
        this.ignoreLeavingSet = z6;
    }

    public final void prepare(Set<RememberObserver> set, CompositionErrorContext compositionErrorContext) {
        clear();
        this.abandoning = set;
        this.traceContext = compositionErrorContext;
    }

    @Override // androidx.compose.runtime.RememberManager
    public void releasing(ComposeNodeLifecycleCallback composeNodeLifecycleCallback) {
        O o6 = this.releasing;
        if (o6 == null) {
            O o7 = a0.f21397a;
            o6 = new O();
            this.releasing = o6;
        }
        o6.j(composeNodeLifecycleCallback);
        recordLeaving(composeNodeLifecycleCallback);
    }

    @Override // androidx.compose.runtime.RememberManager
    public void rememberPausingScope(RecomposeScopeImpl recomposeScopeImpl) {
        Set<RememberObserver> set = this.abandoning;
        if (set == null) {
            return;
        }
        PausedCompositionRemembers pausedCompositionRemembers = new PausedCompositionRemembers(set);
        N n6 = this.pausedPlaceholders;
        if (n6 == null) {
            long[] jArr = Y.f21386a;
            n6 = new N();
            this.pausedPlaceholders = n6;
        }
        n6.l(recomposeScopeImpl, pausedCompositionRemembers);
        this.currentRememberingList.add(new RememberObserverHolder(pausedCompositionRemembers, -1));
    }

    @Override // androidx.compose.runtime.RememberManager
    public void remembering(RememberObserverHolder rememberObserverHolder) {
        this.currentRememberingList.add(rememberObserverHolder);
        this.rememberSet.d(rememberObserverHolder);
    }

    @Override // androidx.compose.runtime.RememberManager
    public void sideEffect(J4.a aVar) {
        this.sideEffects.add(aVar);
    }

    @Override // androidx.compose.runtime.RememberManager
    public void startResumingScope(RecomposeScopeImpl recomposeScopeImpl) {
        N n6 = this.pausedPlaceholders;
        PausedCompositionRemembers pausedCompositionRemembers = n6 != null ? (PausedCompositionRemembers) n6.d(recomposeScopeImpl) : null;
        if (pausedCompositionRemembers != null) {
            ArrayList<MutableVector<RememberObserverHolder>> arrayListM66constructorimpl$default = this.nestedRemembersLists;
            if (arrayListM66constructorimpl$default == null) {
                arrayListM66constructorimpl$default = Stack.m66constructorimpl$default(null, 1, null);
                this.nestedRemembersLists = arrayListM66constructorimpl$default;
            }
            Stack.m76pushimpl(arrayListM66constructorimpl$default, this.currentRememberingList);
            this.currentRememberingList = pausedCompositionRemembers.getPausedRemembers();
        }
    }

    public final void use(Set<RememberObserver> set, CompositionErrorContext compositionErrorContext, J4.c cVar) {
        try {
            prepare(set, compositionErrorContext);
            cVar.invoke(this);
        } finally {
            clear();
        }
    }
}