package com.discord.utilities.analytics;

import android.app.Application;
import android.content.Context;
import android.os.Bundle;
import androidx.annotation.MainThread;
import com.discord.api.channel.Channel;
import com.discord.api.user.User;
import com.discord.app.AppLog;
import com.discord.restapi.RestAPIParams;
import com.discord.rtcconnection.RtcConnection;
import com.discord.stores.StoreStream;
import com.discord.utilities.device.RtcCameraConfig;
import com.discord.utilities.logging.Logger;
import com.discord.utilities.rest.RestAPI;
import com.discord.utilities.rx.ObservableExtensionsKt;
import com.discord.utilities.time.Clock;
import com.google.firebase.analytics.FirebaseAnalytics;
import d0.g;
import d0.g0.t;
import d0.o;
import d0.t.g0;
import d0.t.h0;
import d0.z.d.m;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.TimeUnit;
import kotlin.Lazy;
import kotlin.Pair;
import kotlin.jvm.functions.Function0;
import kotlin.jvm.functions.Function1;
import kotlin.jvm.internal.DefaultConstructorMarker;
import rx.Observable;
/* compiled from: AnalyticsUtils.kt */
public final class AnalyticsUtils {
    public static final AnalyticsUtils INSTANCE = new AnalyticsUtils();
    private static FirebaseAnalytics fireBaseInstance;

    /* compiled from: AnalyticsUtils.kt */
    public static final class Tracker {
        public static final Companion Companion = new Companion(null);
        private static final Lazy instance$delegate = g.lazy(AnalyticsUtils$Tracker$Companion$instance$2.INSTANCE);
        private String analyticsToken;
        private final Clock clock;
        private final ConcurrentLinkedQueue<RestAPIParams.Science.Event> eventsQueue;
        private final ConcurrentHashMap<Pair<String, Long>, Long> eventsThrottledUntilMillis = new ConcurrentHashMap<>();
        private boolean fingerprinted;
        private final RestAPI restAPI;

        /* compiled from: AnalyticsUtils.kt */
        public static final class Companion {
            private Companion() {
            }

            public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
                this();
            }

            public final Tracker getInstance() {
                Lazy access$getInstance$cp = Tracker.access$getInstance$cp();
                Companion companion = Tracker.Companion;
                return (Tracker) access$getInstance$cp.getValue();
            }
        }

        public Tracker(Clock clock, RestAPI restAPI, ConcurrentLinkedQueue<RestAPIParams.Science.Event> concurrentLinkedQueue) {
            m.checkNotNullParameter(clock, "clock");
            m.checkNotNullParameter(restAPI, "restAPI");
            m.checkNotNullParameter(concurrentLinkedQueue, "eventsQueue");
            this.clock = clock;
            this.restAPI = restAPI;
            this.eventsQueue = concurrentLinkedQueue;
        }

        public static final /* synthetic */ void access$drainEventsQueue(Tracker tracker) {
            tracker.drainEventsQueue();
        }

        public static final /* synthetic */ ConcurrentLinkedQueue access$getEventsQueue$p(Tracker tracker) {
            return tracker.eventsQueue;
        }

        public static final /* synthetic */ Lazy access$getInstance$cp() {
            return instance$delegate;
        }

        private final synchronized void drainEventsQueue() {
            if (getCanDrain()) {
                ArrayList arrayList = new ArrayList(this.eventsQueue);
                this.eventsQueue.clear();
                ObservableExtensionsKt.appSubscribe$default(ObservableExtensionsKt.restSubscribeOn$default(this.restAPI.science(new RestAPIParams.Science(this.analyticsToken, arrayList)), false, 1, null), getClass(), (Context) null, (Function1) null, new AnalyticsUtils$Tracker$drainEventsQueue$2(this, arrayList), (Function0) null, (Function0) null, AnalyticsUtils$Tracker$drainEventsQueue$1.INSTANCE, 54, (Object) null);
            }
        }

        private final boolean getCanDrain() {
            return (this.eventsQueue.isEmpty() ^ true) && (this.fingerprinted || isAuthed$app_productionBetaRelease());
        }

        private final boolean isEventThrottled(Pair<String, Long> pair) {
            long currentTimeMillis = this.clock.currentTimeMillis();
            Long l = this.eventsThrottledUntilMillis.get(pair);
            if (l == null) {
                l = 0L;
            }
            m.checkNotNullExpressionValue(l, "eventsThrottledUntilMillis[throttleKey] ?: 0");
            return currentTimeMillis < l.longValue();
        }

        private final Bundle putMap(Bundle bundle, Map<String, ? extends Object> map) {
            try {
                for (Map.Entry<String, ? extends Object> entry : map.entrySet()) {
                    String key = entry.getKey();
                    Object value = entry.getValue();
                    if (value instanceof String) {
                        bundle.putString(key, (String) value);
                    } else if (value instanceof Integer) {
                        bundle.putInt(key, ((Number) value).intValue());
                    } else if (value instanceof Long) {
                        bundle.putLong(key, ((Number) value).longValue());
                    } else if (value instanceof Double) {
                        bundle.putDouble(key, ((Number) value).doubleValue());
                    } else if (value instanceof Float) {
                        bundle.putFloat(key, ((Number) value).floatValue());
                    }
                }
            } catch (Throwable th) {
                AppLog appLog = AppLog.g;
                Logger.e$default(appLog, bundle.getClass().getSimpleName() + " putMap", th, null, 4, null);
            }
            return bundle;
        }

        public static /* synthetic */ void setTrackingData$default(Tracker tracker, String str, boolean z2, int i, Object obj) {
            if ((i & 2) != 0) {
                z2 = false;
            }
            tracker.setTrackingData(str, z2);
        }

        /* JADX DEBUG: Multi-variable search result rejected for r0v0, resolved type: com.discord.utilities.analytics.AnalyticsUtils$Tracker */
        /* JADX WARN: Multi-variable type inference failed */
        public static /* synthetic */ void track$default(Tracker tracker, String str, Map map, int i, Object obj) {
            if ((i & 2) != 0) {
                map = null;
            }
            tracker.track(str, map);
        }

        public final boolean isAuthed$app_productionBetaRelease() {
            String str = this.analyticsToken;
            return !(str == null || t.isBlank(str));
        }

        public final synchronized void setTrackingData(String str, boolean z2) {
            drainEventsQueue();
            this.analyticsToken = str;
            this.fingerprinted = z2;
            drainEventsQueue();
        }

        public final void track(String str, Map<String, ? extends Object> map) {
            m.checkNotNullParameter(str, "event");
            ConcurrentLinkedQueue<RestAPIParams.Science.Event> concurrentLinkedQueue = this.eventsQueue;
            if (map == null) {
                map = h0.emptyMap();
            }
            concurrentLinkedQueue.add(new RestAPIParams.Science.Event(str, map));
            Observable<Long> d02 = Observable.d0(1500, TimeUnit.MILLISECONDS);
            m.checkNotNullExpressionValue(d02, "Observable\n          .ti…0, TimeUnit.MILLISECONDS)");
            ObservableExtensionsKt.appSubscribe$default(d02, Tracker.class, (Context) null, (Function1) null, (Function1) null, (Function0) null, (Function0) null, new AnalyticsUtils$Tracker$track$1(this), 62, (Object) null);
        }

        public final void track(Pair<String, Long> pair, long j, Function0<? extends Map<String, ? extends Object>> function0) {
            m.checkNotNullParameter(pair, "throttleKey");
            m.checkNotNullParameter(function0, "lazyPropertyProvider");
            if (!isEventThrottled(pair)) {
                track(pair.component1(), (Map) function0.mo1invoke());
                this.eventsThrottledUntilMillis.put(pair, Long.valueOf(this.clock.currentTimeMillis() + j));
            }
        }

        public final void trackFireBase(String str, Map<String, ? extends Object> map) {
            m.checkNotNullParameter(str, "event");
            m.checkNotNullParameter(map, "properties");
            Bundle putMap = putMap(new Bundle(), map);
            FirebaseAnalytics access$getFireBaseInstance$p = AnalyticsUtils.access$getFireBaseInstance$p(AnalyticsUtils.INSTANCE);
            if (access$getFireBaseInstance$p != null) {
                access$getFireBaseInstance$p.b.c(null, str, putMap, false, true, null);
            }
        }
    }

    private AnalyticsUtils() {
    }

    public static final /* synthetic */ FirebaseAnalytics access$getFireBaseInstance$p(AnalyticsUtils analyticsUtils) {
        return fireBaseInstance;
    }

    public static final /* synthetic */ void access$setFireBaseInstance$p(AnalyticsUtils analyticsUtils, FirebaseAnalytics firebaseAnalytics) {
        fireBaseInstance = firebaseAnalytics;
    }

    /* JADX DEBUG: Can't convert new array creation: APUT found in different block: 0x003f: APUT  
      (r0v2 kotlin.Pair[])
      (2 ??[int, float, short, byte, char])
      (wrap: kotlin.Pair : 0x003a: INVOKE  (r5v3 kotlin.Pair) = 
      ("channel_size_total")
      (wrap: java.lang.Integer : 0x0034: INVOKE  (r5v2 java.lang.Integer) = (r2v2 int) type: STATIC call: java.lang.Integer.valueOf(int):java.lang.Integer)
     type: STATIC call: d0.o.to(java.lang.Object, java.lang.Object):kotlin.Pair)
     */
    public final Map<String, Object> getProperties$app_productionBetaRelease(Channel channel) {
        m.checkNotNullParameter(channel, "$this$properties");
        Pair[] pairArr = new Pair[3];
        int i = 0;
        pairArr[0] = o.to("channel_id", Long.valueOf(channel.h()));
        pairArr[1] = o.to("channel_type", Integer.valueOf(channel.A()));
        List<User> w = channel.w();
        if (w != null) {
            i = w.size();
        }
        pairArr[2] = o.to("channel_size_total", Integer.valueOf(i));
        return h0.mapOf(pairArr);
    }

    public final Map<String, String> getProperties$app_productionBetaRelease(RtcConnection rtcConnection) {
        m.checkNotNullParameter(rtcConnection, "$this$properties");
        return g0.mapOf(o.to("rtc_connection_id", rtcConnection.l));
    }

    @MainThread
    public final void initAppOpen(Application application) {
        m.checkNotNullParameter(application, "context");
        if (fireBaseInstance == null) {
            fireBaseInstance = FirebaseAnalytics.getInstance(application);
            ObservableExtensionsKt.appSubscribe$default(StoreStream.Companion.getUsers().observeMe(true), AnalyticsUtils.class, (Context) null, (Function1) null, (Function1) null, (Function0) null, (Function0) null, AnalyticsUtils$initAppOpen$1.INSTANCE, 62, (Object) null);
            RtcCameraConfig.INSTANCE.init();
        }
    }
}