package com.google.firebase.sessions.api;

import A4.d;
import android.util.Log;
import com.google.firebase.sessions.api.SessionSubscriber;
import e5.a;
import e5.c;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import kotlin.jvm.internal.h;
import kotlin.jvm.internal.o;
import m3.AbstractC2467b;
import x4.AbstractC3229F;

/* JADX INFO: loaded from: classes3.dex */
public final class FirebaseSessionsDependencies {
    private static final String TAG = "SessionsDependencies";
    public static final FirebaseSessionsDependencies INSTANCE = new FirebaseSessionsDependencies();
    private static final Map<SessionSubscriber.Name, Dependency> dependencies = Collections.synchronizedMap(new LinkedHashMap());

    public static final class Dependency {
        private final a mutex;
        private SessionSubscriber subscriber;

        public Dependency(a mutex, SessionSubscriber sessionSubscriber) {
            o.h(mutex, "mutex");
            this.mutex = mutex;
            this.subscriber = sessionSubscriber;
        }

        public static /* synthetic */ Dependency copy$default(Dependency dependency, a aVar, SessionSubscriber sessionSubscriber, int i6, Object obj) {
            if ((i6 & 1) != 0) {
                aVar = dependency.mutex;
            }
            if ((i6 & 2) != 0) {
                sessionSubscriber = dependency.subscriber;
            }
            return dependency.copy(aVar, sessionSubscriber);
        }

        public final a component1() {
            return this.mutex;
        }

        public final SessionSubscriber component2() {
            return this.subscriber;
        }

        public final Dependency copy(a mutex, SessionSubscriber sessionSubscriber) {
            o.h(mutex, "mutex");
            return new Dependency(mutex, sessionSubscriber);
        }

        public boolean equals(Object obj) {
            if (this == obj) {
                return true;
            }
            if (!(obj instanceof Dependency)) {
                return false;
            }
            Dependency dependency = (Dependency) obj;
            return o.c(this.mutex, dependency.mutex) && o.c(this.subscriber, dependency.subscriber);
        }

        public final a getMutex() {
            return this.mutex;
        }

        public final SessionSubscriber getSubscriber() {
            return this.subscriber;
        }

        public int hashCode() {
            int iHashCode = this.mutex.hashCode() * 31;
            SessionSubscriber sessionSubscriber = this.subscriber;
            return iHashCode + (sessionSubscriber == null ? 0 : sessionSubscriber.hashCode());
        }

        public final void setSubscriber(SessionSubscriber sessionSubscriber) {
            this.subscriber = sessionSubscriber;
        }

        public String toString() {
            return "Dependency(mutex=" + this.mutex + ", subscriber=" + this.subscriber + ')';
        }

        public /* synthetic */ Dependency(a aVar, SessionSubscriber sessionSubscriber, int i6, h hVar) {
            this(aVar, (i6 & 2) != 0 ? null : sessionSubscriber);
        }
    }

    private FirebaseSessionsDependencies() {
    }

    /* JADX WARN: Multi-variable type inference failed */
    public static final void addDependency(SessionSubscriber.Name subscriberName) {
        o.h(subscriberName, "subscriberName");
        if (subscriberName == SessionSubscriber.Name.PERFORMANCE) {
            throw new IllegalArgumentException("Incompatible versions of Firebase Perf and Firebase Sessions.\nA safe combination would be:\n  firebase-sessions:1.1.0\n  firebase-crashlytics:18.5.0\n  firebase-perf:20.5.0\nFor more information contact Firebase Support.");
        }
        Map<SessionSubscriber.Name, Dependency> dependencies2 = dependencies;
        if (dependencies2.containsKey(subscriberName)) {
            Log.d(TAG, "Dependency " + subscriberName + " already added.");
            return;
        }
        o.g(dependencies2, "dependencies");
        dependencies2.put(subscriberName, new Dependency(new c(true), null, 2, 0 == true ? 1 : 0));
        Log.d(TAG, "Dependency to " + subscriberName + " added.");
    }

    private final Dependency getDependency(SessionSubscriber.Name name) {
        Map<SessionSubscriber.Name, Dependency> dependencies2 = dependencies;
        o.g(dependencies2, "dependencies");
        Dependency dependency = dependencies2.get(name);
        if (dependency != null) {
            return dependency;
        }
        throw new IllegalStateException("Cannot get dependency " + name + ". Dependencies should be added at class load time.");
    }

    public static final void register(SessionSubscriber subscriber) {
        o.h(subscriber, "subscriber");
        SessionSubscriber.Name sessionSubscriberName = subscriber.getSessionSubscriberName();
        Dependency dependency = INSTANCE.getDependency(sessionSubscriberName);
        if (dependency.getSubscriber() != null) {
            Log.d(TAG, "Subscriber " + sessionSubscriberName + " already registered.");
            return;
        }
        dependency.setSubscriber(subscriber);
        Log.d(TAG, "Subscriber " + sessionSubscriberName + " registered.");
        ((c) dependency.getMutex()).g(null);
    }

    /* JADX WARN: Removed duplicated region for block: B:17:0x006e  */
    /* JADX WARN: Removed duplicated region for block: B:27:0x00ba A[RETURN] */
    /* JADX WARN: Removed duplicated region for block: B:7:0x0013  */
    /* JADX WARN: Unsupported multi-entry loop pattern (BACK_EDGE: B:20:0x00a1 -> B:21:0x00a2). Please report as a decompilation issue!!! */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public final Object getRegisteredSubscribers$com_google_firebase_firebase_sessions(d dVar) {
        FirebaseSessionsDependencies$getRegisteredSubscribers$1 firebaseSessionsDependencies$getRegisteredSubscribers$1;
        Iterator it;
        Map map;
        if (dVar instanceof FirebaseSessionsDependencies$getRegisteredSubscribers$1) {
            firebaseSessionsDependencies$getRegisteredSubscribers$1 = (FirebaseSessionsDependencies$getRegisteredSubscribers$1) dVar;
            int i6 = firebaseSessionsDependencies$getRegisteredSubscribers$1.label;
            if ((i6 & Integer.MIN_VALUE) != 0) {
                firebaseSessionsDependencies$getRegisteredSubscribers$1.label = i6 - Integer.MIN_VALUE;
            } else {
                firebaseSessionsDependencies$getRegisteredSubscribers$1 = new FirebaseSessionsDependencies$getRegisteredSubscribers$1(this, dVar);
            }
        }
        Object obj = firebaseSessionsDependencies$getRegisteredSubscribers$1.result;
        B4.a aVar = B4.a.f492a;
        int i7 = firebaseSessionsDependencies$getRegisteredSubscribers$1.label;
        if (i7 == 0) {
            AbstractC2467b.l(obj);
            Map<SessionSubscriber.Name, Dependency> dependencies2 = dependencies;
            o.g(dependencies2, "dependencies");
            LinkedHashMap linkedHashMap = new LinkedHashMap(AbstractC3229F.u(dependencies2.size()));
            it = dependencies2.entrySet().iterator();
            map = linkedHashMap;
            if (it.hasNext()) {
            }
        } else {
            if (i7 != 1) {
                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
            }
            Object key = firebaseSessionsDependencies$getRegisteredSubscribers$1.L$5;
            map = (Map) firebaseSessionsDependencies$getRegisteredSubscribers$1.L$4;
            a aVar2 = (a) firebaseSessionsDependencies$getRegisteredSubscribers$1.L$3;
            SessionSubscriber.Name name = (SessionSubscriber.Name) firebaseSessionsDependencies$getRegisteredSubscribers$1.L$2;
            it = (Iterator) firebaseSessionsDependencies$getRegisteredSubscribers$1.L$1;
            Map map2 = (Map) firebaseSessionsDependencies$getRegisteredSubscribers$1.L$0;
            AbstractC2467b.l(obj);
            a aVar3 = aVar2;
            try {
                SessionSubscriber subscriber$com_google_firebase_firebase_sessions = INSTANCE.getSubscriber$com_google_firebase_firebase_sessions(name);
                ((c) aVar3).g(null);
                map.put(key, subscriber$com_google_firebase_firebase_sessions);
                map = map2;
                if (it.hasNext()) {
                    Map.Entry entry = (Map.Entry) it.next();
                    key = entry.getKey();
                    name = (SessionSubscriber.Name) entry.getKey();
                    a mutex = ((Dependency) entry.getValue()).getMutex();
                    firebaseSessionsDependencies$getRegisteredSubscribers$1.L$0 = map;
                    firebaseSessionsDependencies$getRegisteredSubscribers$1.L$1 = it;
                    firebaseSessionsDependencies$getRegisteredSubscribers$1.L$2 = name;
                    firebaseSessionsDependencies$getRegisteredSubscribers$1.L$3 = mutex;
                    firebaseSessionsDependencies$getRegisteredSubscribers$1.L$4 = map;
                    firebaseSessionsDependencies$getRegisteredSubscribers$1.L$5 = key;
                    firebaseSessionsDependencies$getRegisteredSubscribers$1.label = 1;
                    c cVar = (c) mutex;
                    if (cVar.e(firebaseSessionsDependencies$getRegisteredSubscribers$1) == aVar) {
                        return aVar;
                    }
                    map2 = map;
                    aVar3 = cVar;
                    SessionSubscriber subscriber$com_google_firebase_firebase_sessions2 = INSTANCE.getSubscriber$com_google_firebase_firebase_sessions(name);
                    ((c) aVar3).g(null);
                    map.put(key, subscriber$com_google_firebase_firebase_sessions2);
                    map = map2;
                    if (it.hasNext()) {
                        return map;
                    }
                }
            } catch (Throwable th) {
                ((c) aVar3).g(null);
                throw th;
            }
        }
    }

    public final SessionSubscriber getSubscriber$com_google_firebase_firebase_sessions(SessionSubscriber.Name subscriberName) {
        o.h(subscriberName, "subscriberName");
        SessionSubscriber subscriber = getDependency(subscriberName).getSubscriber();
        if (subscriber != null) {
            return subscriber;
        }
        throw new IllegalStateException("Subscriber " + subscriberName + " has not been registered.");
    }

    public final void reset$com_google_firebase_firebase_sessions() {
        dependencies.clear();
    }
}