package com.discord.utilities.search.suggestion;

import android.content.Context;
import c.d.b.a.a;
import com.airbnb.lottie.parser.AnimatableValueParser;
import com.discord.api.channel.Channel;
import com.discord.models.guild.UserGuildMember;
import com.discord.models.member.GuildMember;
import com.discord.models.user.User;
import com.discord.utilities.permissions.PermissionUtils;
import com.discord.utilities.rx.ObservableExtensionsKt;
import com.discord.utilities.search.query.FilterType;
import com.discord.utilities.search.query.node.QueryNode;
import com.discord.utilities.search.query.node.answer.HasAnswerOption;
import com.discord.utilities.search.query.node.content.ContentNode;
import com.discord.utilities.search.query.node.filter.FilterNode;
import com.discord.utilities.search.strings.SearchStringProvider;
import com.discord.utilities.search.suggestion.entries.ChannelSuggestion;
import com.discord.utilities.search.suggestion.entries.FilterSuggestion;
import com.discord.utilities.search.suggestion.entries.HasSuggestion;
import com.discord.utilities.search.suggestion.entries.RecentQuerySuggestion;
import com.discord.utilities.search.suggestion.entries.SearchSuggestion;
import com.discord.utilities.search.suggestion.entries.UserSuggestion;
import com.discord.utilities.search.validation.SearchData;
import d0.g0.w;
import d0.t.n;
import d0.t.o;
import d0.t.u;
import d0.z.d.m;
import j0.k.b;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.TreeSet;
import java.util.concurrent.TimeUnit;
import kotlin.jvm.functions.Function0;
import kotlin.jvm.functions.Function1;
import rx.Observable;
import rx.subjects.PublishSubject;
import rx.subjects.SerializedSubject;
/* compiled from: SearchSuggestionEngine.kt */
public final class SearchSuggestionEngine {
    public static final SearchSuggestionEngine INSTANCE;
    private static final int MAX_ENTRY_TYPE_COUNT = 10;
    private static final int MAX_USER_SORTING_THRESHOLD = 100;
    private static final SerializedSubject<CharSequence, CharSequence> membersRequestSubject = new SerializedSubject<>(PublishSubject.k0());
    private static Long targetGuildId;

    public final /* synthetic */ class WhenMappings {
        public static final /* synthetic */ int[] $EnumSwitchMapping$0;

        static {
            FilterType.values();
            int[] iArr = new int[4];
            $EnumSwitchMapping$0 = iArr;
            iArr[FilterType.FROM.ordinal()] = 1;
            iArr[FilterType.MENTIONS.ordinal()] = 2;
        }
    }

    static {
        SearchSuggestionEngine searchSuggestionEngine = new SearchSuggestionEngine();
        INSTANCE = searchSuggestionEngine;
        searchSuggestionEngine.setupMemberRequestSubscription();
    }

    private SearchSuggestionEngine() {
    }

    private final List<ChannelSuggestion> getChannelSuggestions(CharSequence charSequence, FilterType filterType, Map<Long, Channel> map, Map<Long, Long> map2) {
        if (filterType != FilterType.IN) {
            return n.emptyList();
        }
        Collection<Channel> values = map.values();
        ArrayList arrayList = new ArrayList();
        for (Object obj : values) {
            if (PermissionUtils.can(1024, (Long) a.d((Channel) obj, map2))) {
                arrayList.add(obj);
            }
        }
        ArrayList arrayList2 = new ArrayList();
        for (Object obj2 : arrayList) {
            if (ChannelSuggestion.Companion.canComplete(AnimatableValueParser.y0((Channel) obj2), charSequence)) {
                arrayList2.add(obj2);
            }
        }
        List<Channel> sortedWith = u.sortedWith(arrayList2, AnimatableValueParser.K0(Channel.Companion));
        ArrayList arrayList3 = new ArrayList(o.collectionSizeOrDefault(sortedWith, 10));
        for (Channel channel : sortedWith) {
            arrayList3.add(new ChannelSuggestion(AnimatableValueParser.y0(channel), channel.h()));
        }
        return u.take(arrayList3, MAX_ENTRY_TYPE_COUNT);
    }

    private final FilterType getCurrentFilterType(List<? extends QueryNode> list) {
        if (list.isEmpty()) {
            return null;
        }
        QueryNode queryNode = (QueryNode) u.last((List<? extends Object>) list);
        if (queryNode instanceof FilterNode) {
            return ((FilterNode) queryNode).getFilterType();
        }
        if (list.size() == 1) {
            return null;
        }
        QueryNode queryNode2 = (QueryNode) list.get(n.getLastIndex(list) - 1);
        if (!(queryNode instanceof ContentNode) || !(queryNode2 instanceof FilterNode)) {
            return null;
        }
        return ((FilterNode) queryNode2).getFilterType();
    }

    private final List<SearchSuggestion> getFilterSuggestions(CharSequence charSequence, SearchStringProvider searchStringProvider, boolean z2) {
        FilterType[] values = FilterType.values();
        ArrayList arrayList = new ArrayList();
        for (int i = 0; i < 4; i++) {
            FilterType filterType = values[i];
            if (z2 || filterType != FilterType.IN) {
                arrayList.add(filterType);
            }
        }
        ArrayList<FilterType> arrayList2 = new ArrayList();
        for (Object obj : arrayList) {
            if (FilterSuggestion.Companion.canComplete(charSequence, (FilterType) obj, searchStringProvider)) {
                arrayList2.add(obj);
            }
        }
        ArrayList arrayList3 = new ArrayList(o.collectionSizeOrDefault(arrayList2, 10));
        for (FilterType filterType2 : arrayList2) {
            arrayList3.add(new FilterSuggestion(filterType2));
        }
        return arrayList3;
    }

    private final List<SearchSuggestion> getHasSuggestions(CharSequence charSequence, FilterType filterType, SearchStringProvider searchStringProvider) {
        if (filterType != FilterType.HAS) {
            return n.emptyList();
        }
        HasAnswerOption[] values = HasAnswerOption.values();
        ArrayList<HasAnswerOption> arrayList = new ArrayList();
        for (int i = 0; i < 6; i++) {
            HasAnswerOption hasAnswerOption = values[i];
            if (HasSuggestion.Companion.canComplete(charSequence, hasAnswerOption, searchStringProvider)) {
                arrayList.add(hasAnswerOption);
            }
        }
        ArrayList arrayList2 = new ArrayList();
        for (HasAnswerOption hasAnswerOption2 : arrayList) {
            arrayList2.add(new HasSuggestion(hasAnswerOption2));
        }
        return arrayList2;
    }

    private final Collection<SearchSuggestion> getHistorySuggestions(Collection<? extends List<? extends QueryNode>> collection) {
        ArrayList arrayList = new ArrayList(o.collectionSizeOrDefault(collection, 10));
        Iterator<T> it = collection.iterator();
        while (it.hasNext()) {
            arrayList.add(new RecentQuerySuggestion((List) it.next()));
        }
        return arrayList;
    }

    private final CharSequence getRawContent(List<? extends QueryNode> list) {
        if (list.isEmpty()) {
            return "";
        }
        QueryNode queryNode = (QueryNode) u.last((List<? extends Object>) list);
        if (!(queryNode instanceof ContentNode)) {
            return "";
        }
        String obj = ((ContentNode) queryNode).getContent().toString();
        Objects.requireNonNull(obj, "null cannot be cast to non-null type kotlin.CharSequence");
        return w.trim(obj).toString();
    }

    public static final List<SearchSuggestion> getSuggestions(List<? extends QueryNode> list, SearchData searchData, SearchStringProvider searchStringProvider, Collection<? extends List<? extends QueryNode>> collection) {
        m.checkNotNullParameter(list, "input");
        m.checkNotNullParameter(searchData, "searchData");
        m.checkNotNullParameter(searchStringProvider, "searchStringProvider");
        m.checkNotNullParameter(collection, "recentQueries");
        ArrayList arrayList = new ArrayList();
        SearchSuggestionEngine searchSuggestionEngine = INSTANCE;
        FilterType currentFilterType = searchSuggestionEngine.getCurrentFilterType(list);
        CharSequence rawContent = searchSuggestionEngine.getRawContent(list);
        if (currentFilterType != null) {
            arrayList.addAll(searchSuggestionEngine.getUserSuggestions(rawContent, currentFilterType, searchData.getUsers()));
            arrayList.addAll(searchSuggestionEngine.getChannelSuggestions(rawContent, currentFilterType, searchData.getChannels(), searchData.getChannelPermissions()));
            arrayList.addAll(searchSuggestionEngine.getHasSuggestions(rawContent, currentFilterType, searchStringProvider));
        } else {
            arrayList.addAll(searchSuggestionEngine.getFilterSuggestions(rawContent, searchStringProvider, !searchData.getChannels().isEmpty()));
        }
        if (list.isEmpty()) {
            arrayList.addAll(searchSuggestionEngine.getHistorySuggestions(collection));
        }
        return arrayList;
    }

    private final Collection<UserSuggestion> getUserSuggestions(CharSequence charSequence, FilterType filterType, Map<Long, UserGuildMember> map) {
        UserSuggestion.TargetType targetType;
        int ordinal = filterType.ordinal();
        boolean z2 = true;
        if (ordinal == 0) {
            targetType = UserSuggestion.TargetType.FROM;
        } else if (ordinal != 1) {
            return n.emptyList();
        } else {
            targetType = UserSuggestion.TargetType.MENTIONS;
        }
        membersRequestSubject.j.onNext(charSequence);
        TreeSet treeSet = new TreeSet();
        if (map.size() >= MAX_USER_SORTING_THRESHOLD) {
            z2 = false;
        }
        for (Map.Entry<Long, UserGuildMember> entry : map.entrySet()) {
            UserGuildMember value = entry.getValue();
            User user = value.getUser();
            GuildMember guildMember = value.getGuildMember();
            if (UserSuggestion.Companion.canComplete(user.getUsername(), user.getDiscriminator(), value.getNickname(), charSequence)) {
                treeSet.add(new UserSuggestion(user, targetType, guildMember));
                if (!z2 && treeSet.size() >= MAX_ENTRY_TYPE_COUNT) {
                    return treeSet;
                }
            }
        }
        return u.take(treeSet, MAX_ENTRY_TYPE_COUNT);
    }

    /* JADX WARN: Multi-variable type inference failed */
    /* JADX DEBUG: Type inference failed for r0v2. Raw type applied. Possible types: rx.Observable<R>, rx.Observable */
    /* JADX WARNING: Unknown variable types count: 1 */
    private final void setupMemberRequestSubscription() {
        Observable F = membersRequestSubject.O(750, TimeUnit.MILLISECONDS).F(SearchSuggestionEngine$setupMemberRequestSubscription$1.INSTANCE);
        SearchSuggestionEngine$setupMemberRequestSubscription$2 searchSuggestionEngine$setupMemberRequestSubscription$2 = SearchSuggestionEngine$setupMemberRequestSubscription$2.INSTANCE;
        if (searchSuggestionEngine$setupMemberRequestSubscription$2 != null) {
            searchSuggestionEngine$setupMemberRequestSubscription$2 = new SearchSuggestionEngine$sam$rx_functions_Func1$0(searchSuggestionEngine$setupMemberRequestSubscription$2);
        }
        Observable r = F.x((b) searchSuggestionEngine$setupMemberRequestSubscription$2).r();
        m.checkNotNullExpressionValue(r, "membersRequestSubject\n  …  .distinctUntilChanged()");
        ObservableExtensionsKt.appSubscribe$default(r, SearchSuggestionEngine.class, (Context) null, (Function1) null, (Function1) null, (Function0) null, (Function0) null, SearchSuggestionEngine$setupMemberRequestSubscription$3.INSTANCE, 62, (Object) null);
    }

    public final Long getTargetGuildId() {
        return targetGuildId;
    }

    public final void setTargetGuildId(Long l) {
        targetGuildId = l;
    }
}