package io.reactivex.internal.operators.observable;

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.SimplePlainQueue;
import io.reactivex.internal.fuseable.SimpleQueue;
import io.reactivex.internal.queue.SpscArrayQueue;
import io.reactivex.internal.queue.SpscLinkedArrayQueue;
import io.reactivex.internal.util.AtomicThrowable;
import io.reactivex.internal.util.ExceptionHelper;
import io.reactivex.plugins.RxJavaPlugins;
import java.util.ArrayDeque;
import java.util.Queue;
import java.util.concurrent.Callable;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;

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

    static final class InnerObserver<T, U> extends AtomicReference<Disposable> implements Observer<U> {
        final long a;
        final MergeObserver<T, U> b;
        volatile boolean c;
        volatile SimpleQueue<U> d;
        int e;

        InnerObserver(MergeObserver<T, U> mergeObserver, long j) {
            this.a = j;
            this.b = mergeObserver;
        }

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

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

        @Override // io.reactivex.Observer
        public void onError(Throwable th) {
            if (!this.b.h.addThrowable(th)) {
                RxJavaPlugins.b(th);
                return;
            }
            MergeObserver<T, U> mergeObserver = this.b;
            if (!mergeObserver.c) {
                mergeObserver.b();
            }
            this.c = true;
            this.b.c();
        }

        @Override // io.reactivex.Observer
        public void onNext(U u) {
            if (this.e == 0) {
                this.b.a(u, this);
            } else {
                this.b.c();
            }
        }

        @Override // io.reactivex.Observer
        public void onSubscribe(Disposable disposable) {
            if (DisposableHelper.setOnce(this, disposable) && (disposable instanceof QueueDisposable)) {
                QueueDisposable queueDisposable = (QueueDisposable) disposable;
                int requestFusion = queueDisposable.requestFusion(7);
                if (requestFusion == 1) {
                    this.e = requestFusion;
                    this.d = queueDisposable;
                    this.c = true;
                    this.b.c();
                    return;
                }
                if (requestFusion == 2) {
                    this.e = requestFusion;
                    this.d = queueDisposable;
                }
            }
        }
    }

    public ObservableFlatMap(ObservableSource<T> observableSource, Function<? super T, ? extends ObservableSource<? extends U>> function, boolean z, int i, int i2) {
        super(observableSource);
        this.b = function;
        this.c = z;
        this.d = i;
        this.e = i2;
    }

    @Override // io.reactivex.Observable
    public void subscribeActual(Observer<? super U> observer) {
        if (ObservableScalarXMap.a(this.a, observer, this.b)) {
            return;
        }
        this.a.subscribe(new MergeObserver(observer, this.b, this.c, this.d, this.e));
    }

    static final class MergeObserver<T, U> extends AtomicInteger implements Disposable, Observer<T> {
        static final InnerObserver<?, ?>[] q = new InnerObserver[0];
        static final InnerObserver<?, ?>[] r = new InnerObserver[0];
        final Observer<? super U> a;
        final Function<? super T, ? extends ObservableSource<? extends U>> b;
        final boolean c;
        final int d;
        final int e;
        volatile SimplePlainQueue<U> f;
        volatile boolean g;
        final AtomicThrowable h = new AtomicThrowable();
        volatile boolean i;
        final AtomicReference<InnerObserver<?, ?>[]> j;
        Disposable k;
        long l;
        long m;
        int n;
        Queue<ObservableSource<? extends U>> o;
        int p;

        MergeObserver(Observer<? super U> observer, Function<? super T, ? extends ObservableSource<? extends U>> function, boolean z, int i, int i2) {
            this.a = observer;
            this.b = function;
            this.c = z;
            this.d = i;
            this.e = i2;
            if (i != Integer.MAX_VALUE) {
                this.o = new ArrayDeque(i);
            }
            this.j = new AtomicReference<>(q);
        }

        void a(ObservableSource<? extends U> observableSource) {
            ObservableSource<? extends U> poll;
            while (observableSource instanceof Callable) {
                if (!a((Callable) observableSource) || this.d == Integer.MAX_VALUE) {
                    return;
                }
                boolean z = false;
                synchronized (this) {
                    poll = this.o.poll();
                    if (poll == null) {
                        this.p--;
                        z = true;
                    }
                }
                if (z) {
                    c();
                    return;
                }
                observableSource = poll;
            }
            long j = this.l;
            this.l = 1 + j;
            InnerObserver<T, U> innerObserver = new InnerObserver<>(this, j);
            if (a(innerObserver)) {
                observableSource.subscribe(innerObserver);
            }
        }

        /* JADX WARN: Multi-variable type inference failed */
        void b(InnerObserver<T, U> innerObserver) {
            InnerObserver<?, ?>[] innerObserverArr;
            InnerObserver<?, ?>[] innerObserverArr2;
            do {
                innerObserverArr = this.j.get();
                int length = innerObserverArr.length;
                if (length == 0) {
                    return;
                }
                int i = -1;
                int i2 = 0;
                while (true) {
                    if (i2 >= length) {
                        break;
                    }
                    if (innerObserverArr[i2] == innerObserver) {
                        i = i2;
                        break;
                    }
                    i2++;
                }
                if (i < 0) {
                    return;
                }
                if (length == 1) {
                    innerObserverArr2 = q;
                } else {
                    InnerObserver<?, ?>[] innerObserverArr3 = new InnerObserver[length - 1];
                    System.arraycopy(innerObserverArr, 0, innerObserverArr3, 0, i);
                    System.arraycopy(innerObserverArr, i + 1, innerObserverArr3, i, (length - i) - 1);
                    innerObserverArr2 = innerObserverArr3;
                }
            } while (!this.j.compareAndSet(innerObserverArr, innerObserverArr2));
        }

        void c() {
            if (getAndIncrement() == 0) {
                d();
            }
        }

        /* JADX WARN: Multi-variable type inference failed */
        void d() {
            int i;
            boolean z;
            Observer<? super U> observer = this.a;
            int i2 = 1;
            while (!a()) {
                SimplePlainQueue<U> simplePlainQueue = this.f;
                if (simplePlainQueue != null) {
                    while (!a()) {
                        U poll = simplePlainQueue.poll();
                        if (poll != null) {
                            observer.onNext(poll);
                        } else if (poll == null) {
                        }
                    }
                    return;
                }
                boolean z2 = this.g;
                SimplePlainQueue<U> simplePlainQueue2 = this.f;
                InnerObserver<?, ?>[] innerObserverArr = this.j.get();
                int length = innerObserverArr.length;
                if (this.d != Integer.MAX_VALUE) {
                    synchronized (this) {
                        i = this.o.size();
                    }
                } else {
                    i = 0;
                }
                if (z2 && ((simplePlainQueue2 == null || simplePlainQueue2.isEmpty()) && length == 0 && i == 0)) {
                    Throwable terminate = this.h.terminate();
                    if (terminate != ExceptionHelper.a) {
                        if (terminate == null) {
                            observer.onComplete();
                            return;
                        } else {
                            observer.onError(terminate);
                            return;
                        }
                    }
                    return;
                }
                if (length != 0) {
                    long j = this.m;
                    int i3 = this.n;
                    if (length <= i3 || innerObserverArr[i3].a != j) {
                        if (length <= i3) {
                            i3 = 0;
                        }
                        int i4 = i3;
                        for (int i5 = 0; i5 < length && innerObserverArr[i4].a != j; i5++) {
                            i4++;
                            if (i4 == length) {
                                i4 = 0;
                            }
                        }
                        this.n = i4;
                        this.m = innerObserverArr[i4].a;
                        i3 = i4;
                    }
                    int i6 = 0;
                    z = false;
                    while (i6 < length) {
                        if (a()) {
                            return;
                        }
                        InnerObserver<T, U> innerObserver = innerObserverArr[i3];
                        while (!a()) {
                            SimpleQueue<U> simpleQueue = innerObserver.d;
                            if (simpleQueue != null) {
                                do {
                                    try {
                                        U poll2 = simpleQueue.poll();
                                        if (poll2 != null) {
                                            observer.onNext(poll2);
                                        } else if (poll2 == null) {
                                        }
                                    } catch (Throwable th) {
                                        Exceptions.b(th);
                                        innerObserver.a();
                                        this.h.addThrowable(th);
                                        if (a()) {
                                            return;
                                        }
                                        b(innerObserver);
                                        i6++;
                                        z = true;
                                    }
                                } while (!a());
                                return;
                            }
                            boolean z3 = innerObserver.c;
                            SimpleQueue<U> simpleQueue2 = innerObserver.d;
                            if (z3 && (simpleQueue2 == null || simpleQueue2.isEmpty())) {
                                b(innerObserver);
                                if (a()) {
                                    return;
                                } else {
                                    z = true;
                                }
                            }
                            i3++;
                            if (i3 == length) {
                                i3 = 0;
                            }
                            i6++;
                        }
                        return;
                    }
                    this.n = i3;
                    this.m = innerObserverArr[i3].a;
                } else {
                    z = false;
                }
                if (!z) {
                    i2 = addAndGet(-i2);
                    if (i2 == 0) {
                        return;
                    }
                } else if (this.d != Integer.MAX_VALUE) {
                    synchronized (this) {
                        ObservableSource<? extends U> poll3 = this.o.poll();
                        if (poll3 == null) {
                            this.p--;
                        } else {
                            a(poll3);
                        }
                    }
                } else {
                    continue;
                }
            }
        }

        @Override // io.reactivex.disposables.Disposable
        public void dispose() {
            Throwable terminate;
            if (this.i) {
                return;
            }
            this.i = true;
            if (!b() || (terminate = this.h.terminate()) == null || terminate == ExceptionHelper.a) {
                return;
            }
            RxJavaPlugins.b(terminate);
        }

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

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

        @Override // io.reactivex.Observer
        public void onNext(T t) {
            if (this.g) {
                return;
            }
            try {
                ObservableSource<? extends U> apply = this.b.apply(t);
                ObjectHelper.a(apply, "The mapper returned a null ObservableSource");
                ObservableSource<? extends U> observableSource = apply;
                if (this.d != Integer.MAX_VALUE) {
                    synchronized (this) {
                        if (this.p == this.d) {
                            this.o.offer(observableSource);
                            return;
                        }
                        this.p++;
                    }
                }
                a(observableSource);
            } catch (Throwable th) {
                Exceptions.b(th);
                this.k.dispose();
                onError(th);
            }
        }

        @Override // io.reactivex.Observer
        public void onSubscribe(Disposable disposable) {
            if (DisposableHelper.validate(this.k, disposable)) {
                this.k = disposable;
                this.a.onSubscribe(this);
            }
        }

        boolean b() {
            InnerObserver<?, ?>[] andSet;
            this.k.dispose();
            InnerObserver<?, ?>[] innerObserverArr = this.j.get();
            InnerObserver<?, ?>[] innerObserverArr2 = r;
            if (innerObserverArr == innerObserverArr2 || (andSet = this.j.getAndSet(innerObserverArr2)) == r) {
                return false;
            }
            for (InnerObserver<?, ?> innerObserver : andSet) {
                innerObserver.a();
            }
            return true;
        }

        /* JADX WARN: Multi-variable type inference failed */
        boolean a(InnerObserver<T, U> innerObserver) {
            InnerObserver<?, ?>[] innerObserverArr;
            InnerObserver[] innerObserverArr2;
            do {
                innerObserverArr = this.j.get();
                if (innerObserverArr == r) {
                    innerObserver.a();
                    return false;
                }
                int length = innerObserverArr.length;
                innerObserverArr2 = new InnerObserver[length + 1];
                System.arraycopy(innerObserverArr, 0, innerObserverArr2, 0, length);
                innerObserverArr2[length] = innerObserver;
            } while (!this.j.compareAndSet(innerObserverArr, innerObserverArr2));
            return true;
        }

        boolean a(Callable<? extends U> callable) {
            try {
                U call = callable.call();
                if (call == null) {
                    return true;
                }
                if (get() == 0 && compareAndSet(0, 1)) {
                    this.a.onNext(call);
                    if (decrementAndGet() == 0) {
                        return true;
                    }
                } else {
                    SimplePlainQueue<U> simplePlainQueue = this.f;
                    if (simplePlainQueue == null) {
                        int i = this.d;
                        if (i == Integer.MAX_VALUE) {
                            simplePlainQueue = new SpscLinkedArrayQueue<>(this.e);
                        } else {
                            simplePlainQueue = new SpscArrayQueue(i);
                        }
                        this.f = simplePlainQueue;
                    }
                    if (!simplePlainQueue.offer(call)) {
                        onError(new IllegalStateException("Scalar queue full?!"));
                        return true;
                    }
                    if (getAndIncrement() != 0) {
                        return false;
                    }
                }
                d();
                return true;
            } catch (Throwable th) {
                Exceptions.b(th);
                this.h.addThrowable(th);
                c();
                return true;
            }
        }

        void a(U u, InnerObserver<T, U> innerObserver) {
            if (get() == 0 && compareAndSet(0, 1)) {
                this.a.onNext(u);
                if (decrementAndGet() == 0) {
                    return;
                }
            } else {
                SimpleQueue simpleQueue = innerObserver.d;
                if (simpleQueue == null) {
                    simpleQueue = new SpscLinkedArrayQueue(this.e);
                    innerObserver.d = simpleQueue;
                }
                simpleQueue.offer(u);
                if (getAndIncrement() != 0) {
                    return;
                }
            }
            d();
        }

        boolean a() {
            if (this.i) {
                return true;
            }
            Throwable th = this.h.get();
            if (this.c || th == null) {
                return false;
            }
            b();
            Throwable terminate = this.h.terminate();
            if (terminate != ExceptionHelper.a) {
                this.a.onError(terminate);
            }
            return true;
        }
    }
}