package com.discord.stores;

import android.content.Context;
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.ChannelNode;
import com.discord.utilities.search.query.node.answer.HasAnswerOption;
import com.discord.utilities.search.query.node.answer.HasNode;
import com.discord.utilities.search.query.node.answer.UserNode;
import com.discord.utilities.search.query.node.content.ContentNode;
import com.discord.utilities.search.query.node.filter.FilterNode;
import com.discord.utilities.search.query.parsing.QueryParser;
import com.discord.utilities.search.strings.SearchStringProvider;
import com.discord.utilities.search.suggestion.entries.ChannelSuggestion;
import com.discord.utilities.search.suggestion.entries.UserSuggestion;
import d0.t.n;
import d0.t.u;
import d0.z.d.m;
import d0.z.d.o;
import j0.k.b;
import j0.p.a;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.TimeUnit;
import kotlin.NoWhenBranchMatchedException;
import kotlin.Unit;
import kotlin.jvm.functions.Function0;
import kotlin.jvm.functions.Function1;
import rx.Observable;
import rx.Subscription;
import rx.subjects.BehaviorSubject;
import rx.subjects.PublishSubject;
import rx.subjects.SerializedSubject;
/* compiled from: StoreSearchInput.kt */
public final class StoreSearchInput {
    private final SerializedSubject<List<QueryNode>, List<QueryNode>> astSubject;
    private final Observable<List<QueryNode>> currentParsedInput;
    private final Observable<List<QueryNode>> forcedInput;
    private final PublishSubject<List<QueryNode>> forcedInputSubject;
    private final SerializedSubject<String, String> inputSubject = new SerializedSubject<>(BehaviorSubject.l0(""));
    private Subscription inputSubscription;
    private final Observable<Boolean> isInputValid;
    private final SerializedSubject<Boolean, Boolean> isInputValidSubject;

    /* compiled from: StoreSearchInput.kt */
    /* renamed from: com.discord.stores.StoreSearchInput$1  reason: invalid class name */
    public static final class AnonymousClass1<T, R> implements b<List<? extends QueryNode>, Boolean> {
        public static final AnonymousClass1 INSTANCE = new AnonymousClass1();

        public final Boolean call(List<? extends QueryNode> list) {
            m.checkNotNullExpressionValue(list, "it");
            boolean z2 = true;
            if (!(list instanceof Collection) || !list.isEmpty()) {
                Iterator<T> it = list.iterator();
                while (true) {
                    if (it.hasNext()) {
                        if (!(it.next() instanceof FilterNode)) {
                            break;
                        }
                    } else {
                        break;
                    }
                }
            }
            z2 = false;
            return Boolean.valueOf(z2);
        }
    }

    /* compiled from: StoreSearchInput.kt */
    /* renamed from: com.discord.stores.StoreSearchInput$2  reason: invalid class name */
    public static final class AnonymousClass2 extends o implements Function1<Boolean, Unit> {
        public final /* synthetic */ StoreSearchInput this$0;

        /* JADX INFO: super call moved to the top of the method (can break code semantics) */
        public AnonymousClass2(StoreSearchInput storeSearchInput) {
            super(1);
            this.this$0 = storeSearchInput;
        }

        /* Return type fixed from 'java.lang.Object' to match base method */
        /* JADX DEBUG: Method arguments types fixed to match base method, original types: [java.lang.Object] */
        @Override // kotlin.jvm.functions.Function1
        public /* bridge */ /* synthetic */ Unit invoke(Boolean bool) {
            invoke(bool);
            return Unit.a;
        }

        public final void invoke(Boolean bool) {
            StoreSearchInput.access$isInputValidSubject$p(this.this$0).j.onNext(bool);
        }
    }

    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;
            iArr[FilterType.IN.ordinal()] = 3;
            iArr[FilterType.HAS.ordinal()] = 4;
        }
    }

    public StoreSearchInput() {
        SerializedSubject<List<QueryNode>, List<QueryNode>> serializedSubject = new SerializedSubject<>(BehaviorSubject.k0());
        this.astSubject = serializedSubject;
        SerializedSubject<Boolean, Boolean> serializedSubject2 = new SerializedSubject<>(BehaviorSubject.l0(Boolean.FALSE));
        this.isInputValidSubject = serializedSubject2;
        PublishSubject<List<QueryNode>> k0 = PublishSubject.k0();
        this.forcedInputSubject = k0;
        this.isInputValid = serializedSubject2;
        this.currentParsedInput = serializedSubject;
        m.checkNotNullExpressionValue(k0, "forcedInputSubject");
        this.forcedInput = k0;
        Observable X = ObservableExtensionsKt.leadingEdgeThrottle(serializedSubject, 50, TimeUnit.MILLISECONDS).F(AnonymousClass1.INSTANCE).X(a.a());
        m.checkNotNullExpressionValue(X, "astSubject\n        .lead…Schedulers.computation())");
        ObservableExtensionsKt.appSubscribe$default(X, (Context) null, "validateSearchInput", (Function1) null, new AnonymousClass2(this), (Function1) null, (Function0) null, (Function0) null, 117, (Object) null);
    }

    public static final /* synthetic */ void access$handleInputSubscription(StoreSearchInput storeSearchInput, Subscription subscription) {
        storeSearchInput.handleInputSubscription(subscription);
    }

    public static final /* synthetic */ SerializedSubject access$isInputValidSubject$p(StoreSearchInput storeSearchInput) {
        return storeSearchInput.isInputValidSubject;
    }

    private final int getAnswerReplacementStart(List<? extends QueryNode> list) {
        if (list.size() <= 1) {
            return 0;
        }
        int lastIndex = n.getLastIndex(list);
        QueryNode queryNode = (QueryNode) list.get(lastIndex);
        int i = lastIndex - 1;
        QueryNode queryNode2 = (QueryNode) list.get(i);
        if (queryNode instanceof FilterNode) {
            return lastIndex;
        }
        if (!(queryNode instanceof ContentNode) || !(queryNode2 instanceof FilterNode)) {
            return -1;
        }
        return i;
    }

    private final synchronized void handleInputSubscription(Subscription subscription) {
        Subscription subscription2 = this.inputSubscription;
        if (subscription2 != null) {
            subscription2.unsubscribe();
        }
        this.inputSubscription = subscription;
    }

    private final void replaceAndPublish(int i, List<? extends QueryNode> list, List<QueryNode> list2) {
        if (i >= 0 && i <= list2.size()) {
            list2.subList(i, list2.size()).clear();
            list2.addAll(i, list);
            this.forcedInputSubject.j.onNext(list2);
        }
    }

    public final void clear() {
        handleInputSubscription(null);
        this.inputSubject.j.onNext("");
    }

    public final Observable<List<QueryNode>> getCurrentParsedInput() {
        return this.currentParsedInput;
    }

    public final Observable<List<QueryNode>> getForcedInput() {
        return this.forcedInput;
    }

    public final void init(SearchStringProvider searchStringProvider) {
        m.checkNotNullParameter(searchStringProvider, "searchStringProvider");
        Observable X = ObservableExtensionsKt.leadingEdgeThrottle(this.inputSubject, 100, TimeUnit.MILLISECONDS).r().F(new StoreSearchInput$init$1(new QueryParser(searchStringProvider))).X(a.a());
        m.checkNotNullExpressionValue(X, "inputSubject\n        .le…Schedulers.computation())");
        ObservableExtensionsKt.appSubscribe$default(X, StoreSearchInput.class, (Context) null, new StoreSearchInput$init$2(this), (Function1) null, (Function0) null, (Function0) null, new StoreSearchInput$init$3(this.astSubject), 58, (Object) null);
    }

    public final Observable<Boolean> isInputValid() {
        return this.isInputValid;
    }

    public final void onFilterClicked(FilterType filterType, SearchStringProvider searchStringProvider, List<QueryNode> list) {
        FilterNode filterNode;
        m.checkNotNullParameter(filterType, "filterType");
        m.checkNotNullParameter(searchStringProvider, "searchStringProvider");
        m.checkNotNullParameter(list, "query");
        ArrayList arrayList = new ArrayList(list);
        int ordinal = filterType.ordinal();
        if (ordinal == 0) {
            filterNode = new FilterNode(FilterType.FROM, searchStringProvider.getFromFilterString());
        } else if (ordinal == 1) {
            filterNode = new FilterNode(FilterType.MENTIONS, searchStringProvider.getMentionsFilterString());
        } else if (ordinal == 2) {
            filterNode = new FilterNode(FilterType.HAS, searchStringProvider.getHasFilterString());
        } else if (ordinal == 3) {
            filterNode = new FilterNode(FilterType.IN, searchStringProvider.getInFilterString());
        } else {
            throw new NoWhenBranchMatchedException();
        }
        replaceAndPublish(arrayList.isEmpty() ? 0 : ((QueryNode) u.last(arrayList)) instanceof ContentNode ? n.getLastIndex(list) : list.size(), d0.t.m.listOf(filterNode), list);
    }

    public final void onFromUserClicked(UserSuggestion userSuggestion, CharSequence charSequence, List<QueryNode> list) {
        m.checkNotNullParameter(userSuggestion, "userSuggestion");
        m.checkNotNullParameter(charSequence, "fromFilterString");
        m.checkNotNullParameter(list, "query");
        replaceAndPublish(getAnswerReplacementStart(list), n.listOf((Object[]) new QueryNode[]{new FilterNode(FilterType.FROM, charSequence), new UserNode(userSuggestion.getUserName(), userSuggestion.getDiscriminator())}), list);
    }

    public final void onHasClicked(HasAnswerOption hasAnswerOption, CharSequence charSequence, CharSequence charSequence2, List<QueryNode> list) {
        m.checkNotNullParameter(hasAnswerOption, "hasAnswerOption");
        m.checkNotNullParameter(charSequence, "hasFilterString");
        m.checkNotNullParameter(charSequence2, "hasAnswerString");
        m.checkNotNullParameter(list, "query");
        replaceAndPublish(getAnswerReplacementStart(list), n.listOf((Object[]) new QueryNode[]{new FilterNode(FilterType.HAS, charSequence), new HasNode(hasAnswerOption, charSequence2)}), list);
    }

    public final void onInChannelClicked(ChannelSuggestion channelSuggestion, CharSequence charSequence, List<QueryNode> list) {
        m.checkNotNullParameter(channelSuggestion, "channelSuggestion");
        m.checkNotNullParameter(charSequence, "inFilterString");
        m.checkNotNullParameter(list, "query");
        replaceAndPublish(getAnswerReplacementStart(list), n.listOf((Object[]) new QueryNode[]{new FilterNode(FilterType.IN, charSequence), new ChannelNode(channelSuggestion.getChannelName())}), list);
    }

    public final void onMentionsUserClicked(UserSuggestion userSuggestion, CharSequence charSequence, List<QueryNode> list) {
        m.checkNotNullParameter(userSuggestion, "userSuggestion");
        m.checkNotNullParameter(charSequence, "mentionsFilterString");
        m.checkNotNullParameter(list, "query");
        replaceAndPublish(getAnswerReplacementStart(list), n.listOf((Object[]) new QueryNode[]{new FilterNode(FilterType.MENTIONS, charSequence), new UserNode(userSuggestion.getUserName(), userSuggestion.getDiscriminator())}), list);
    }

    public final void onQueryClicked(List<? extends QueryNode> list) {
        m.checkNotNullParameter(list, "query");
        this.forcedInputSubject.j.onNext(list);
    }

    public final void updateInput(String str) {
        m.checkNotNullParameter(str, "input");
        this.inputSubject.j.onNext(str);
    }
}