package androidx.lifecycle;

import com.google.android.gms.measurement.internal.u1;
import java.lang.ref.WeakReference;
import java.lang.reflect.Constructor;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicReference;

/* JADX INFO: loaded from: classes.dex */
public final class r extends l {

    /* JADX INFO: renamed from: a, reason: collision with root package name */
    public final boolean f2690a;

    /* JADX INFO: renamed from: b, reason: collision with root package name */
    public n.a f2691b;

    /* JADX INFO: renamed from: c, reason: collision with root package name */
    public Lifecycle$State f2692c;

    /* JADX INFO: renamed from: d, reason: collision with root package name */
    public final WeakReference f2693d;

    /* JADX INFO: renamed from: e, reason: collision with root package name */
    public int f2694e;

    /* JADX INFO: renamed from: f, reason: collision with root package name */
    public boolean f2695f;

    /* JADX INFO: renamed from: g, reason: collision with root package name */
    public boolean f2696g;

    /* JADX INFO: renamed from: h, reason: collision with root package name */
    public final ArrayList f2697h;

    /* JADX INFO: renamed from: i, reason: collision with root package name */
    public final kotlinx.coroutines.flow.v f2698i;

    public r(p pVar) {
        nb.g.i(pVar, "provider");
        new AtomicReference(null);
        this.f2690a = true;
        this.f2691b = new n.a();
        Lifecycle$State lifecycle$State = Lifecycle$State.f2632b;
        this.f2692c = lifecycle$State;
        this.f2697h = new ArrayList();
        this.f2693d = new WeakReference(pVar);
        this.f2698i = new kotlinx.coroutines.flow.v(lifecycle$State);
    }

    @Override // androidx.lifecycle.l
    public final void a(LifecycleObserver lifecycleObserver) {
        LifecycleEventObserver reflectiveGenericLifecycleObserver;
        p pVar;
        nb.g.i(lifecycleObserver, "observer");
        d("addObserver");
        Lifecycle$State lifecycle$State = this.f2692c;
        Lifecycle$State lifecycle$State2 = Lifecycle$State.f2631a;
        if (lifecycle$State != lifecycle$State2) {
            lifecycle$State2 = Lifecycle$State.f2632b;
        }
        q qVar = new q();
        HashMap map = s.f2702a;
        boolean z10 = lifecycleObserver instanceof LifecycleEventObserver;
        boolean z11 = lifecycleObserver instanceof DefaultLifecycleObserver;
        if (z10 && z11) {
            reflectiveGenericLifecycleObserver = new DefaultLifecycleObserverAdapter((DefaultLifecycleObserver) lifecycleObserver, (LifecycleEventObserver) lifecycleObserver);
        } else if (z11) {
            reflectiveGenericLifecycleObserver = new DefaultLifecycleObserverAdapter((DefaultLifecycleObserver) lifecycleObserver, null);
        } else if (z10) {
            reflectiveGenericLifecycleObserver = (LifecycleEventObserver) lifecycleObserver;
        } else {
            Class<?> cls = lifecycleObserver.getClass();
            if (s.b(cls) == 2) {
                Object obj = s.f2703b.get(cls);
                nb.g.f(obj);
                List list = (List) obj;
                if (list.size() == 1) {
                    s.a((Constructor) list.get(0), lifecycleObserver);
                    throw null;
                }
                int size = list.size();
                g[] gVarArr = new g[size];
                if (size > 0) {
                    s.a((Constructor) list.get(0), lifecycleObserver);
                    throw null;
                }
                reflectiveGenericLifecycleObserver = new CompositeGeneratedAdaptersObserver(gVarArr);
            } else {
                reflectiveGenericLifecycleObserver = new ReflectiveGenericLifecycleObserver(lifecycleObserver);
            }
        }
        qVar.f2685b = reflectiveGenericLifecycleObserver;
        qVar.f2684a = lifecycle$State2;
        if (((q) this.f2691b.f(lifecycleObserver, qVar)) == null && (pVar = (p) this.f2693d.get()) != null) {
            boolean z12 = this.f2694e != 0 || this.f2695f;
            Lifecycle$State lifecycle$StateC = c(lifecycleObserver);
            this.f2694e++;
            while (qVar.f2684a.compareTo(lifecycle$StateC) < 0 && this.f2691b.f30702e.containsKey(lifecycleObserver)) {
                this.f2697h.add(qVar.f2684a);
                j jVar = Lifecycle$Event.Companion;
                Lifecycle$State lifecycle$State3 = qVar.f2684a;
                jVar.getClass();
                Lifecycle$Event lifecycle$EventB = j.b(lifecycle$State3);
                if (lifecycle$EventB == null) {
                    throw new IllegalStateException("no event up from " + qVar.f2684a);
                }
                qVar.a(pVar, lifecycle$EventB);
                ArrayList arrayList = this.f2697h;
                arrayList.remove(arrayList.size() - 1);
                lifecycle$StateC = c(lifecycleObserver);
            }
            if (!z12) {
                h();
            }
            this.f2694e--;
        }
    }

    @Override // androidx.lifecycle.l
    public final void b(LifecycleObserver lifecycleObserver) {
        nb.g.i(lifecycleObserver, "observer");
        d("removeObserver");
        this.f2691b.c(lifecycleObserver);
    }

    public final Lifecycle$State c(LifecycleObserver lifecycleObserver) {
        q qVar;
        Map.Entry<Object, Object> entryCeil = this.f2691b.ceil(lifecycleObserver);
        Lifecycle$State lifecycle$State = (entryCeil == null || (qVar = (q) entryCeil.getValue()) == null) ? null : qVar.f2684a;
        ArrayList arrayList = this.f2697h;
        Lifecycle$State lifecycle$State2 = arrayList.isEmpty() ^ true ? (Lifecycle$State) u1.e(arrayList, 1) : null;
        Lifecycle$State lifecycle$State3 = this.f2692c;
        nb.g.i(lifecycle$State3, "state1");
        if (lifecycle$State == null || lifecycle$State.compareTo(lifecycle$State3) >= 0) {
            lifecycle$State = lifecycle$State3;
        }
        return (lifecycle$State2 == null || lifecycle$State2.compareTo(lifecycle$State) >= 0) ? lifecycle$State : lifecycle$State2;
    }

    public final void d(String str) {
        if (this.f2690a && !m.b.d().f30272a.b()) {
            throw new IllegalStateException(u1.k("Method ", str, " must be called on the main thread").toString());
        }
    }

    public final void e(Lifecycle$Event lifecycle$Event) {
        nb.g.i(lifecycle$Event, "event");
        d("handleLifecycleEvent");
        f(lifecycle$Event.a());
    }

    public final void f(Lifecycle$State lifecycle$State) {
        Lifecycle$State lifecycle$State2 = this.f2692c;
        if (lifecycle$State2 == lifecycle$State) {
            return;
        }
        Lifecycle$State lifecycle$State3 = Lifecycle$State.f2632b;
        Lifecycle$State lifecycle$State4 = Lifecycle$State.f2631a;
        if (lifecycle$State2 == lifecycle$State3 && lifecycle$State == lifecycle$State4) {
            throw new IllegalStateException(("State must be at least CREATED to move to " + lifecycle$State + ", but was " + this.f2692c + " in component " + this.f2693d.get()).toString());
        }
        this.f2692c = lifecycle$State;
        if (this.f2695f || this.f2694e != 0) {
            this.f2696g = true;
            return;
        }
        this.f2695f = true;
        h();
        this.f2695f = false;
        if (this.f2692c == lifecycle$State4) {
            this.f2691b = new n.a();
        }
    }

    public final void g() {
        Lifecycle$State lifecycle$State = Lifecycle$State.f2633c;
        d("setCurrentState");
        f(lifecycle$State);
    }

    /* JADX WARN: Code restructure failed: missing block: B:11:0x0038, code lost:
    
        r8.f2696g = false;
        r0 = r8.f2692c;
        r1 = r8.f2698i;
        r1.getClass();
     */
    /* JADX WARN: Code restructure failed: missing block: B:12:0x0041, code lost:
    
        if (r0 != null) goto L14;
     */
    /* JADX WARN: Code restructure failed: missing block: B:13:0x0043, code lost:
    
        r0 = kotlinx.coroutines.flow.internal.b.f29385b;
     */
    /* JADX WARN: Code restructure failed: missing block: B:14:0x0045, code lost:
    
        r1.h(null, r0);
     */
    /* JADX WARN: Code restructure failed: missing block: B:15:0x0049, code lost:
    
        return;
     */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public final void h() {
        p pVar = (p) this.f2693d.get();
        if (pVar == null) {
            throw new IllegalStateException("LifecycleOwner of this LifecycleRegistry is already garbage collected. It is too late to change lifecycle state.");
        }
        while (true) {
            n.a aVar = this.f2691b;
            if (aVar.f30716d != 0) {
                Map.Entry<Object, Object> entryEldest = aVar.eldest();
                nb.g.f(entryEldest);
                Lifecycle$State lifecycle$State = ((q) entryEldest.getValue()).f2684a;
                Map.Entry<Object, Object> entryNewest = this.f2691b.newest();
                nb.g.f(entryNewest);
                Lifecycle$State lifecycle$State2 = ((q) entryNewest.getValue()).f2684a;
                if (lifecycle$State == lifecycle$State2 && this.f2692c == lifecycle$State2) {
                    break;
                }
                this.f2696g = false;
                Lifecycle$State lifecycle$State3 = this.f2692c;
                Map.Entry<Object, Object> entryEldest2 = this.f2691b.eldest();
                nb.g.f(entryEldest2);
                if (lifecycle$State3.compareTo(((q) entryEldest2.getValue()).f2684a) < 0) {
                    n.a aVar2 = this.f2691b;
                    n.b bVar = new n.b(aVar2.f30714b, aVar2.f30713a, 1);
                    aVar2.f30715c.put(bVar, Boolean.FALSE);
                    while (bVar.hasNext() && !this.f2696g) {
                        Map.Entry entry = (Map.Entry) bVar.next();
                        nb.g.h(entry, "next()");
                        LifecycleObserver lifecycleObserver = (LifecycleObserver) entry.getKey();
                        q qVar = (q) entry.getValue();
                        while (qVar.f2684a.compareTo(this.f2692c) > 0 && !this.f2696g && this.f2691b.f30702e.containsKey(lifecycleObserver)) {
                            j jVar = Lifecycle$Event.Companion;
                            Lifecycle$State lifecycle$State4 = qVar.f2684a;
                            jVar.getClass();
                            Lifecycle$Event lifecycle$EventA = j.a(lifecycle$State4);
                            if (lifecycle$EventA == null) {
                                throw new IllegalStateException("no event down from " + qVar.f2684a);
                            }
                            this.f2697h.add(lifecycle$EventA.a());
                            qVar.a(pVar, lifecycle$EventA);
                            ArrayList arrayList = this.f2697h;
                            arrayList.remove(arrayList.size() - 1);
                        }
                    }
                }
                Map.Entry<Object, Object> entryNewest2 = this.f2691b.newest();
                if (!this.f2696g && entryNewest2 != null && this.f2692c.compareTo(((q) entryNewest2.getValue()).f2684a) > 0) {
                    n.a aVar3 = this.f2691b;
                    aVar3.getClass();
                    n.d dVar = new n.d(aVar3);
                    aVar3.f30715c.put(dVar, Boolean.FALSE);
                    while (dVar.hasNext() && !this.f2696g) {
                        Map.Entry entry2 = (Map.Entry) dVar.next();
                        LifecycleObserver lifecycleObserver2 = (LifecycleObserver) entry2.getKey();
                        q qVar2 = (q) entry2.getValue();
                        while (qVar2.f2684a.compareTo(this.f2692c) < 0 && !this.f2696g && this.f2691b.f30702e.containsKey(lifecycleObserver2)) {
                            this.f2697h.add(qVar2.f2684a);
                            j jVar2 = Lifecycle$Event.Companion;
                            Lifecycle$State lifecycle$State5 = qVar2.f2684a;
                            jVar2.getClass();
                            Lifecycle$Event lifecycle$EventB = j.b(lifecycle$State5);
                            if (lifecycle$EventB == null) {
                                throw new IllegalStateException("no event up from " + qVar2.f2684a);
                            }
                            qVar2.a(pVar, lifecycle$EventB);
                            ArrayList arrayList2 = this.f2697h;
                            arrayList2.remove(arrayList2.size() - 1);
                        }
                    }
                }
            } else {
                break;
            }
        }
    }
}