package com.discord.stores;

import android.content.Context;
import c.a.d.q;
import c.d.b.a.a;
import com.airbnb.lottie.parser.AnimatableValueParser;
import com.discord.api.channel.Channel;
import com.discord.api.friendsuggestions.FriendSuggestion;
import com.discord.api.guild.Guild;
import com.discord.api.guildmember.GuildMember;
import com.discord.api.guildmember.GuildMembersChunk;
import com.discord.api.message.Message;
import com.discord.api.premium.PremiumTier;
import com.discord.api.presence.Presence;
import com.discord.api.thread.AugmentedThreadMember;
import com.discord.api.thread.ThreadListMember;
import com.discord.api.thread.ThreadMemberListUpdate;
import com.discord.api.thread.ThreadMembersUpdate;
import com.discord.api.user.NsfwAllowance;
import com.discord.api.user.User;
import com.discord.app.AppLog;
import com.discord.models.domain.ModelPayload;
import com.discord.models.domain.ModelUserRelationship;
import com.discord.models.user.CoreUser;
import com.discord.models.user.MeUser;
import com.discord.stores.StoreMessagesLoader;
import com.discord.stores.updates.ObservationDeck;
import com.discord.stores.updates.ObservationDeckProvider;
import com.discord.utilities.collections.SnowflakePartitionMap;
import com.discord.utilities.persister.Persister;
import com.discord.utilities.user.UserRequestManager;
import com.discord.utilities.user.UserUtils;
import d0.d0.f;
import d0.t.g0;
import d0.t.h0;
import d0.t.o;
import d0.z.d.m;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import kotlin.Unit;
import kotlin.jvm.functions.Function1;
import kotlin.jvm.internal.DefaultConstructorMarker;
import rx.Observable;
/* compiled from: StoreUser.kt */
public final class StoreUser extends StoreV2 {
    public static final Companion Companion = new Companion(null);
    private static final MeUser EMPTY_ME_USER = new MeUser(0, "EMPTY_USERNAME", null, null, false, false, 0, PremiumTier.NONE, null, false, false, null, 0, 0, null, NsfwAllowance.UNKNOWN, null, null, 204800, null);
    private static final ObservationDeck.UpdateSource MeUpdate = new StoreUser$Companion$MeUpdate$1();
    private static final ObservationDeck.UpdateSource UsersUpdate = new StoreUser$Companion$UsersUpdate$1();
    private final Dispatcher dispatcher;

    /* renamed from: me  reason: collision with root package name */
    private MeUser f2118me;
    private final Persister<MeUser> meCache;
    private MeUser meSnapshot;
    private final Function1<User, Unit> notifyUserUpdated;
    private final ObservationDeck observationDeck;
    private final UserRequestManager userRequestManager;
    private final SnowflakePartitionMap.CopiablePartitionMap<com.discord.models.user.User> users;
    private Map<Long, ? extends com.discord.models.user.User> usersSnapshot;

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

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

        public final ObservationDeck.UpdateSource getMeUpdate() {
            return StoreUser.access$getMeUpdate$cp();
        }

        public final ObservationDeck.UpdateSource getUsersUpdate() {
            return StoreUser.access$getUsersUpdate$cp();
        }
    }

    /* JADX DEBUG: Multi-variable search result rejected for r2v0, resolved type: kotlin.jvm.functions.Function1<? super com.discord.api.user.User, kotlin.Unit> */
    /* JADX WARN: Multi-variable type inference failed */
    public StoreUser(Function1<? super User, Unit> function1, Dispatcher dispatcher, ObservationDeck observationDeck, Persister<MeUser> persister) {
        m.checkNotNullParameter(function1, "notifyUserUpdated");
        m.checkNotNullParameter(dispatcher, "dispatcher");
        m.checkNotNullParameter(observationDeck, "observationDeck");
        m.checkNotNullParameter(persister, "meCache");
        this.notifyUserUpdated = function1;
        this.dispatcher = dispatcher;
        this.observationDeck = observationDeck;
        this.meCache = persister;
        MeUser meUser = EMPTY_ME_USER;
        this.f2118me = meUser;
        this.users = new SnowflakePartitionMap.CopiablePartitionMap<>(0, 1, null);
        this.meSnapshot = meUser;
        this.usersSnapshot = h0.emptyMap();
        this.userRequestManager = new UserRequestManager(new StoreUser$userRequestManager$1(this));
    }

    /* JADX INFO: this call moved to the top of the method (can break code semantics) */
    public /* synthetic */ StoreUser(Function1 function1, Dispatcher dispatcher, ObservationDeck observationDeck, Persister persister, int i, DefaultConstructorMarker defaultConstructorMarker) {
        this(function1, dispatcher, (i & 4) != 0 ? ObservationDeckProvider.get() : observationDeck, (i & 8) != 0 ? new Persister("STORE_USERS_ME_V13", EMPTY_ME_USER) : persister);
    }

    public static final /* synthetic */ void access$fetchMissing(StoreUser storeUser, Collection collection, Set set) {
        storeUser.fetchMissing(collection, set);
    }

    public static final /* synthetic */ Dispatcher access$getDispatcher$p(StoreUser storeUser) {
        return storeUser.dispatcher;
    }

    public static final /* synthetic */ MeUser access$getEMPTY_ME_USER$cp() {
        return EMPTY_ME_USER;
    }

    public static final /* synthetic */ MeUser access$getMe$p(StoreUser storeUser) {
        return storeUser.f2118me;
    }

    public static final /* synthetic */ ObservationDeck.UpdateSource access$getMeUpdate$cp() {
        return MeUpdate;
    }

    public static final /* synthetic */ Function1 access$getNotifyUserUpdated$p(StoreUser storeUser) {
        return storeUser.notifyUserUpdated;
    }

    public static final /* synthetic */ ObservationDeck.UpdateSource access$getUsersUpdate$cp() {
        return UsersUpdate;
    }

    public static final /* synthetic */ void access$setMe$p(StoreUser storeUser, MeUser meUser) {
        storeUser.f2118me = meUser;
    }

    @StoreThread
    private final void fetchMissing(Collection<Long> collection, Set<Long> set) {
        HashSet hashSet = new HashSet();
        for (Long l : collection) {
            long longValue = l.longValue();
            if (!set.contains(Long.valueOf(longValue))) {
                hashSet.add(Long.valueOf(longValue));
            }
        }
        this.userRequestManager.requestUsers(hashSet);
    }

    public static /* synthetic */ Observable observeMe$default(StoreUser storeUser, boolean z2, int i, Object obj) {
        if ((i & 1) != 0) {
            z2 = false;
        }
        return storeUser.observeMe(z2);
    }

    @StoreThread
    private final void updateUser(User user) {
        CoreUser coreUser = new CoreUser(user);
        if (!m.areEqual(coreUser, this.users.get(Long.valueOf(user.i())))) {
            this.users.put(Long.valueOf(user.i()), coreUser);
            markChanged(UsersUpdate);
        }
    }

    public final void fetchUsers(List<Long> list) {
        m.checkNotNullParameter(list, "users");
        this.dispatcher.schedule(new StoreUser$fetchUsers$1(this, list));
    }

    public final MeUser getMe() {
        return this.meSnapshot;
    }

    @StoreThread
    public final MeUser getMeInternal$app_productionBetaRelease() {
        return this.f2118me;
    }

    /* JADX DEBUG: Type inference failed for r0v0. Raw type applied. Possible types: java.util.Map<java.lang.Long, ? extends com.discord.models.user.User>, java.util.Map<java.lang.Long, com.discord.models.user.User> */
    public final Map<Long, com.discord.models.user.User> getUsers() {
        return this.usersSnapshot;
    }

    public final Map<Long, com.discord.models.user.User> getUsers(Collection<Long> collection, boolean z2) {
        m.checkNotNullParameter(collection, "userIds");
        Map<Long, ? extends com.discord.models.user.User> map = this.usersSnapshot;
        ArrayList arrayList = new ArrayList();
        for (Number number : collection) {
            com.discord.models.user.User user = (com.discord.models.user.User) map.get(Long.valueOf(number.longValue()));
            if (user != null) {
                arrayList.add(user);
            }
        }
        LinkedHashMap linkedHashMap = new LinkedHashMap(f.coerceAtLeast(g0.mapCapacity(o.collectionSizeOrDefault(arrayList, 10)), 16));
        for (Object obj : arrayList) {
            linkedHashMap.put(Long.valueOf(((com.discord.models.user.User) obj).getId()), obj);
        }
        if (z2) {
            fetchMissing(collection, linkedHashMap.keySet());
        }
        return linkedHashMap;
    }

    @StoreThread
    public final Map<Long, com.discord.models.user.User> getUsersInternal$app_productionBetaRelease() {
        return this.users;
    }

    @StoreThread
    public final void handleAuthToken(String str) {
        if (str == null) {
            markChanged(MeUpdate);
            this.f2118me = EMPTY_ME_USER;
        }
    }

    @StoreThread
    public final void handleChannelCreated(Channel channel) {
        m.checkNotNullParameter(channel, "channel");
        List<User> w = channel.w();
        if (w != null) {
            for (User user : w) {
                updateUser(user);
            }
        }
    }

    @StoreThread
    public final void handleConnectionOpen(ModelPayload modelPayload) {
        m.checkNotNullParameter(modelPayload, "payload");
        this.users.clear();
        User me2 = modelPayload.getMe();
        m.checkNotNullExpressionValue(me2, "payload.me");
        MeUser meUser = new MeUser(me2);
        this.f2118me = meUser;
        this.users.put(Long.valueOf(meUser.getId()), meUser);
        for (Channel channel : modelPayload.getPrivateChannels()) {
            m.checkNotNullExpressionValue(channel, "channel");
            for (com.discord.models.user.User user : AnimatableValueParser.G0(channel)) {
                this.users.put(Long.valueOf(user.getId()), user);
            }
        }
        for (ModelUserRelationship modelUserRelationship : modelPayload.getRelationships()) {
            m.checkNotNullExpressionValue(modelUserRelationship, "relationship");
            if (modelUserRelationship.getUser() != null) {
                SnowflakePartitionMap.CopiablePartitionMap<com.discord.models.user.User> copiablePartitionMap = this.users;
                Long valueOf = Long.valueOf(modelUserRelationship.getUser().i());
                User user2 = modelUserRelationship.getUser();
                m.checkNotNullExpressionValue(user2, "relationship.user");
                copiablePartitionMap.put(valueOf, new CoreUser(user2));
            }
        }
        for (Guild guild : modelPayload.getGuilds()) {
            List<GuildMember> s2 = guild.s();
            if (s2 != null) {
                for (GuildMember guildMember : s2) {
                    this.users.put(Long.valueOf(guildMember.j().i()), new CoreUser(guildMember.j()));
                }
            }
        }
        StringBuilder L = a.L("Discovered ");
        L.append(this.users.size());
        L.append(" initial users.");
        AppLog.i(L.toString());
        Long valueOf2 = Long.valueOf(meUser.getId());
        String email = meUser.getEmail();
        AppLog.g(valueOf2, email, meUser.getUsername() + UserUtils.INSTANCE.getDiscriminatorWithPadding(meUser));
        markChanged(MeUpdate, UsersUpdate);
    }

    @StoreThread
    public final void handleFriendSuggestionCreate(FriendSuggestion friendSuggestion) {
        m.checkNotNullParameter(friendSuggestion, "suggestion");
        updateUser(friendSuggestion.b());
    }

    @StoreThread
    public final void handleFriendSuggestionsLoaded(List<FriendSuggestion> list) {
        m.checkNotNullParameter(list, "loadedSuggestions");
        for (FriendSuggestion friendSuggestion : list) {
            updateUser(friendSuggestion.b());
        }
    }

    @StoreThread
    public final void handleGuildAddOrSync(Guild guild) {
        m.checkNotNullParameter(guild, "guild");
        List<GuildMember> s2 = guild.s();
        if (s2 != null) {
            for (GuildMember guildMember : s2) {
                updateUser(guildMember.j());
            }
        }
    }

    @StoreThread
    public final void handleGuildMemberAdd(GuildMember guildMember) {
        m.checkNotNullParameter(guildMember, "member");
        updateUser(guildMember.j());
    }

    @StoreThread
    public final void handleGuildMembersChunk(GuildMembersChunk guildMembersChunk) {
        m.checkNotNullParameter(guildMembersChunk, "chunk");
        for (GuildMember guildMember : guildMembersChunk.b()) {
            updateUser(guildMember.j());
        }
    }

    @StoreThread
    public final void handleMessageCreateOrUpdate(Message message) {
        m.checkNotNullParameter(message, "message");
        List<User> t = message.t();
        if (t != null) {
            for (User user : t) {
                updateUser(user);
            }
        }
        Long l = message.l();
        if (((l != null ? l.longValue() : 0) & 16) != 0) {
            this.f2118me = MeUser.copy$default(this.f2118me, 0, null, null, null, false, false, 0, null, null, false, false, null, this.f2118me.getFlags() | 8192, 0, null, null, null, null, 258047, null);
            markChanged(MeUpdate);
        }
    }

    @StoreThread
    public final void handleMessagesLoaded(StoreMessagesLoader.ChannelChunk channelChunk) {
        m.checkNotNullParameter(channelChunk, "chunk");
        for (com.discord.models.message.Message message : channelChunk.getMessages()) {
            User author = message.getAuthor();
            if (author != null) {
                updateUser(author);
            }
            List<User> mentions = message.getMentions();
            if (mentions != null) {
                for (User user : mentions) {
                    updateUser(user);
                }
            }
        }
    }

    @StoreThread
    public final void handlePresenceUpdate(Presence presence) {
        m.checkNotNullParameter(presence, "presence");
        User f = presence.f();
        if ((f != null ? f.f() : null) != null) {
            updateUser(f);
        }
    }

    @StoreThread
    public final void handleThreadMemberListUpdate(ThreadMemberListUpdate threadMemberListUpdate) {
        m.checkNotNullParameter(threadMemberListUpdate, "threadMemberListUpdate");
        List<ThreadListMember> b = threadMemberListUpdate.b();
        if (b != null) {
            for (ThreadListMember threadListMember : b) {
                GuildMember a = threadListMember.a();
                if (a != null) {
                    updateUser(a.j());
                }
                Presence b2 = threadListMember.b();
                User f = b2 != null ? b2.f() : null;
                if (f != null) {
                    updateUser(f);
                }
            }
        }
    }

    @StoreThread
    public final void handleThreadMembersUpdate(ThreadMembersUpdate threadMembersUpdate) {
        m.checkNotNullParameter(threadMembersUpdate, "threadMembersUpdate");
        List<AugmentedThreadMember> a = threadMembersUpdate.a();
        if (a != null) {
            for (AugmentedThreadMember augmentedThreadMember : a) {
                GuildMember c2 = augmentedThreadMember.c();
                if (c2 != null) {
                    updateUser(c2.j());
                }
                Presence d = augmentedThreadMember.d();
                User f = d != null ? d.f() : null;
                if (f != null) {
                    updateUser(f);
                }
            }
        }
    }

    @StoreThread
    public final void handleUserRelationshipAdd(ModelUserRelationship modelUserRelationship) {
        m.checkNotNullParameter(modelUserRelationship, "relationship");
        User user = modelUserRelationship.getUser();
        m.checkNotNullExpressionValue(user, "relationship.user");
        updateUser(user);
    }

    @StoreThread
    public final void handleUserUpdated(User user) {
        m.checkNotNullParameter(user, "user");
        updateUser(user);
        if (this.f2118me.getId() == user.i()) {
            this.f2118me = MeUser.Companion.merge(this.f2118me, user);
            markChanged(MeUpdate);
        }
    }

    @Override // com.discord.stores.Store
    public void init(Context context) {
        m.checkNotNullParameter(context, "context");
        super.init(context);
        this.f2118me = this.meCache.get();
        markChanged(MeUpdate);
    }

    public final Observable<Map<Long, com.discord.models.user.User>> observeAllUsers() {
        return ObservationDeck.connectRx$default(this.observationDeck, new ObservationDeck.UpdateSource[]{this}, false, null, null, new StoreUser$observeAllUsers$1(this), 14, null);
    }

    public final Observable<MeUser> observeMe() {
        return observeMe$default(this, false, 1, null);
    }

    public final Observable<MeUser> observeMe(boolean z2) {
        Observable<MeUser> r = ObservationDeck.connectRx$default(this.observationDeck, new ObservationDeck.UpdateSource[]{MeUpdate}, false, null, null, new StoreUser$observeMe$1(this), 14, null).x(new StoreUser$observeMe$2(z2)).r();
        m.checkNotNullExpressionValue(r, "observationDeck.connectR…  .distinctUntilChanged()");
        return r;
    }

    public final Observable<Long> observeMeId() {
        Observable<Long> r = ObservationDeck.connectRx$default(this.observationDeck, new ObservationDeck.UpdateSource[]{MeUpdate}, false, null, null, new StoreUser$observeMeId$1(this), 14, null).r();
        m.checkNotNullExpressionValue(r, "observationDeck.connectR…  .distinctUntilChanged()");
        return r;
    }

    public final Observable<com.discord.models.user.User> observeUser(long j) {
        Observable<com.discord.models.user.User> r = observeAllUsers().F(new StoreUser$observeUser$1(j)).r();
        m.checkNotNullExpressionValue(r, "observeAllUsers()\n      …  .distinctUntilChanged()");
        return r;
    }

    public final Observable<Map<Long, String>> observeUsernames(Collection<Long> collection) {
        m.checkNotNullParameter(collection, "userIds");
        Observable<R> k = observeAllUsers().k(q.b(collection, StoreUser$observeUsernames$1.INSTANCE));
        m.checkNotNullExpressionValue(k, "observeAllUsers()\n      …er!!.username }\n        )");
        return k;
    }

    public final Observable<Map<Long, com.discord.models.user.User>> observeUsers(Collection<Long> collection) {
        m.checkNotNullParameter(collection, "userIds");
        return observeUsers(collection, false);
    }

    public final Observable<Map<Long, com.discord.models.user.User>> observeUsers(Collection<Long> collection, boolean z2) {
        m.checkNotNullParameter(collection, "userIds");
        Observable<Map<Long, com.discord.models.user.User>> t = observeAllUsers().k(q.a(collection)).t(new StoreUser$observeUsers$1(this, z2, collection));
        m.checkNotNullExpressionValue(t, "observeAllUsers()\n      …ys)\n          }\n        }");
        return t;
    }

    @Override // com.discord.stores.StoreV2
    @StoreThread
    public void snapshotData() {
        if (getUpdateSources().contains(UsersUpdate)) {
            this.usersSnapshot = this.users.fastCopy();
        }
        if (getUpdateSources().contains(MeUpdate)) {
            MeUser meUser = this.f2118me;
            this.meSnapshot = meUser;
            Persister.set$default(this.meCache, meUser, false, 2, null);
        }
    }
}