package io.reactivex.internal.operators.observable;

import android.Manifest;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.exceptions.Exceptions;
import io.reactivex.functions.Function;
import io.reactivex.internal.disposables.DisposableHelper;
import io.reactivex.internal.functions.ObjectHelper;
import io.reactivex.internal.fuseable.QueueDisposable;
import io.reactivex.internal.fuseable.SimpleQueue;
import io.reactivex.internal.queue.SpscLinkedArrayQueue;
import io.reactivex.internal.util.AtomicThrowable;
import io.reactivex.internal.util.ErrorMode;
import io.reactivex.observers.SerializedObserver;
import io.reactivex.plugins.RxJavaPlugins;
import java.util.concurrent.Callable;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;

/* loaded from: classes2.dex */
public final class ObservableConcatMap<T, U> extends AbstractObservableWithUpstream<T, U> {
    final Function<? super T, ? extends ObservableSource<? extends U>> b;
    final int c;
    final ErrorMode d;

    static final class ConcatMapDelayErrorObserver<T, R> extends AtomicInteger implements Observer<T>, Disposable {
        final Observer<? super R> a;
        final Function<? super T, ? extends ObservableSource<? extends R>> b;
        final int c;
        final AtomicThrowable d = new AtomicThrowable();
        final DelayErrorInnerObserver<R> e;
        final boolean f;
        SimpleQueue<T> g;
        Disposable h;
        volatile boolean i;
        volatile boolean j;
        volatile boolean k;
        int l;

        static final class DelayErrorInnerObserver<R> extends AtomicReference<Disposable> implements Observer<R> {
            final Observer<? super R> a;
            final ConcatMapDelayErrorObserver<?, R> b;

            DelayErrorInnerObserver(Observer<? super R> observer, ConcatMapDelayErrorObserver<?, R> concatMapDelayErrorObserver) {
                this.a = observer;
                this.b = concatMapDelayErrorObserver;
            }

            void a() {
                DisposableHelper.dispose(this);
            }

            @Override // io.reactivex.Observer
            public void onComplete() {
                ConcatMapDelayErrorObserver<?, R> concatMapDelayErrorObserver = this.b;
                concatMapDelayErrorObserver.i = false;
                concatMapDelayErrorObserver.a();
            }

            @Override // io.reactivex.Observer
            public void onError(Throwable th) {
                ConcatMapDelayErrorObserver<?, R> concatMapDelayErrorObserver = this.b;
                if (!concatMapDelayErrorObserver.d.addThrowable(th)) {
                    RxJavaPlugins.b(th);
                    return;
                }
                if (!concatMapDelayErrorObserver.f) {
                    concatMapDelayErrorObserver.h.dispose();
                }
                concatMapDelayErrorObserver.i = false;
                concatMapDelayErrorObserver.a();
            }

            @Override // io.reactivex.Observer
            public void onNext(R r) {
                this.a.onNext(r);
            }

            @Override // io.reactivex.Observer
            public void onSubscribe(Disposable disposable) {
                DisposableHelper.replace(this, disposable);
            }
        }

        ConcatMapDelayErrorObserver(Observer<? super R> observer, Function<? super T, ? extends ObservableSource<? extends R>> function, int i, boolean z) {
            this.a = observer;
            this.b = function;
            this.c = i;
            this.f = z;
            this.e = new DelayErrorInnerObserver<>(observer, this);
        }

        void a() {
            if (getAndIncrement() != 0) {
                return;
            }
            Observer<? super R> observer = this.a;
            SimpleQueue<T> simpleQueue = this.g;
            AtomicThrowable atomicThrowable = this.d;
            while (true) {
                if (!this.i) {
                    if (this.k) {
                        simpleQueue.clear();
                        return;
                    }
                    if (!this.f && atomicThrowable.get() != null) {
                        simpleQueue.clear();
                        this.k = true;
                        observer.onError(atomicThrowable.terminate());
                        return;
                    }
                    boolean z = this.j;
                    try {
                        T poll = simpleQueue.poll();
                        boolean z2 = poll == null;
                        if (z && z2) {
                            this.k = true;
                            Throwable terminate = atomicThrowable.terminate();
                            if (terminate != null) {
                                observer.onError(terminate);
                                return;
                            } else {
                                observer.onComplete();
                                return;
                            }
                        }
                        if (!z2) {
                            try {
                                ObservableSource<? extends R> apply = this.b.apply(poll);
                                ObjectHelper.a(apply, "The mapper returned a null ObservableSource");
                                ObservableSource<? extends R> observableSource = apply;
                                if (observableSource instanceof Callable) {
                                    try {
                                        Manifest manifest = (Object) ((Callable) observableSource).call();
                                        if (manifest != null && !this.k) {
                                            observer.onNext(manifest);
                                        }
                                    } catch (Throwable th) {
                                        Exceptions.b(th);
                                        atomicThrowable.addThrowable(th);
                                    }
                                } else {
                                    this.i = true;
                                    observableSource.subscribe(this.e);
                                }
                            } catch (Throwable th2) {
                                Exceptions.b(th2);
                                this.k = true;
                                this.h.dispose();
                                simpleQueue.clear();
                                atomicThrowable.addThrowable(th2);
                                observer.onError(atomicThrowable.terminate());
                                return;
                            }
                        }
                    } catch (Throwable th3) {
                        Exceptions.b(th3);
                        this.k = true;
                        this.h.dispose();
                        atomicThrowable.addThrowable(th3);
                        observer.onError(atomicThrowable.terminate());
                        return;
                    }
                }
                if (decrementAndGet() == 0) {
                    return;
                }
            }
        }

        @Override // io.reactivex.disposables.Disposable
        public void dispose() {
            this.k = true;
            this.h.dispose();
            this.e.a();
        }

        @Override // io.reactivex.Observer
        public void onComplete() {
            this.j = true;
            a();
        }

        @Override // io.reactivex.Observer
        public void onError(Throwable th) {
            if (!this.d.addThrowable(th)) {
                RxJavaPlugins.b(th);
            } else {
                this.j = true;
                a();
            }
        }

        @Override // io.reactivex.Observer
        public void onNext(T t) {
            if (this.l == 0) {
                this.g.offer(t);
            }
            a();
        }

        @Override // io.reactivex.Observer
        public void onSubscribe(Disposable disposable) {
            if (DisposableHelper.validate(this.h, disposable)) {
                this.h = disposable;
                if (disposable instanceof QueueDisposable) {
                    QueueDisposable queueDisposable = (QueueDisposable) disposable;
                    int requestFusion = queueDisposable.requestFusion(3);
                    if (requestFusion == 1) {
                        this.l = requestFusion;
                        this.g = queueDisposable;
                        this.j = true;
                        this.a.onSubscribe(this);
                        a();
                        return;
                    }
                    if (requestFusion == 2) {
                        this.l = requestFusion;
                        this.g = queueDisposable;
                        this.a.onSubscribe(this);
                        return;
                    }
                }
                this.g = new SpscLinkedArrayQueue(this.c);
                this.a.onSubscribe(this);
            }
        }
    }

    static final class SourceObserver<T, U> extends AtomicInteger implements Observer<T>, Disposable {
        final Observer<? super U> a;
        final Function<? super T, ? extends ObservableSource<? extends U>> b;
        final InnerObserver<U> c;
        final int d;
        SimpleQueue<T> e;
        Disposable f;
        volatile boolean g;
        volatile boolean h;
        volatile boolean i;
        int j;

        static final class InnerObserver<U> extends AtomicReference<Disposable> implements Observer<U> {
            final Observer<? super U> a;
            final SourceObserver<?, ?> b;

            InnerObserver(Observer<? super U> observer, SourceObserver<?, ?> sourceObserver) {
                this.a = observer;
                this.b = sourceObserver;
            }

            void a() {
                DisposableHelper.dispose(this);
            }

            @Override // io.reactivex.Observer
            public void onComplete() {
                this.b.b();
            }

            @Override // io.reactivex.Observer
            public void onError(Throwable th) {
                this.b.dispose();
                this.a.onError(th);
            }

            @Override // io.reactivex.Observer
            public void onNext(U u) {
                this.a.onNext(u);
            }

            @Override // io.reactivex.Observer
            public void onSubscribe(Disposable disposable) {
                DisposableHelper.set(this, disposable);
            }
        }

        SourceObserver(Observer<? super U> observer, Function<? super T, ? extends ObservableSource<? extends U>> function, int i) {
            this.a = observer;
            this.b = function;
            this.d = i;
            this.c = new InnerObserver<>(observer, this);
        }

        void a() {
            if (getAndIncrement() != 0) {
                return;
            }
            while (!this.h) {
                if (!this.g) {
                    boolean z = this.i;
                    try {
                        T poll = this.e.poll();
                        boolean z2 = poll == null;
                        if (z && z2) {
                            this.h = true;
                            this.a.onComplete();
                            return;
                        }
                        if (!z2) {
                            try {
                                ObservableSource<? extends U> apply = this.b.apply(poll);
                                ObjectHelper.a(apply, "The mapper returned a null ObservableSource");
                                ObservableSource<? extends U> observableSource = apply;
                                this.g = true;
                                observableSource.subscribe(this.c);
                            } catch (Throwable th) {
                                Exceptions.b(th);
                                dispose();
                                this.e.clear();
                                this.a.onError(th);
                                return;
                            }
                        }
                    } catch (Throwable th2) {
                        Exceptions.b(th2);
                        dispose();
                        this.e.clear();
                        this.a.onError(th2);
                        return;
                    }
                }
                if (decrementAndGet() == 0) {
                    return;
                }
            }
            this.e.clear();
        }

        void b() {
            this.g = false;
            a();
        }

        @Override // io.reactivex.disposables.Disposable
        public void dispose() {
            this.h = true;
            this.c.a();
            this.f.dispose();
            if (getAndIncrement() == 0) {
                this.e.clear();
            }
        }

        @Override // io.reactivex.Observer
        public void onComplete() {
            if (this.i) {
                return;
            }
            this.i = true;
            a();
        }

        @Override // io.reactivex.Observer
        public void onError(Throwable th) {
            if (this.i) {
                RxJavaPlugins.b(th);
                return;
            }
            this.i = true;
            dispose();
            this.a.onError(th);
        }

        @Override // io.reactivex.Observer
        public void onNext(T t) {
            if (this.i) {
                return;
            }
            if (this.j == 0) {
                this.e.offer(t);
            }
            a();
        }

        @Override // io.reactivex.Observer
        public void onSubscribe(Disposable disposable) {
            if (DisposableHelper.validate(this.f, disposable)) {
                this.f = disposable;
                if (disposable instanceof QueueDisposable) {
                    QueueDisposable queueDisposable = (QueueDisposable) disposable;
                    int requestFusion = queueDisposable.requestFusion(3);
                    if (requestFusion == 1) {
                        this.j = requestFusion;
                        this.e = queueDisposable;
                        this.i = true;
                        this.a.onSubscribe(this);
                        a();
                        return;
                    }
                    if (requestFusion == 2) {
                        this.j = requestFusion;
                        this.e = queueDisposable;
                        this.a.onSubscribe(this);
                        return;
                    }
                }
                this.e = new SpscLinkedArrayQueue(this.d);
                this.a.onSubscribe(this);
            }
        }
    }

    public ObservableConcatMap(ObservableSource<T> observableSource, Function<? super T, ? extends ObservableSource<? extends U>> function, int i, ErrorMode errorMode) {
        super(observableSource);
        this.b = function;
        this.d = errorMode;
        this.c = Math.max(8, i);
    }

    @Override // io.reactivex.Observable
    public void subscribeActual(Observer<? super U> observer) {
        if (ObservableScalarXMap.a(this.a, observer, this.b)) {
            return;
        }
        ErrorMode errorMode = this.d;
        if (errorMode == ErrorMode.IMMEDIATE) {
            this.a.subscribe(new SourceObserver(new SerializedObserver(observer), this.b, this.c));
        } else {
            this.a.subscribe(new ConcatMapDelayErrorObserver(observer, this.b, this.c, errorMode == ErrorMode.END));
        }
    }
}