package j0.l.a;

import j0.l.a.e;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.AtomicReference;
import rx.Observable;
import rx.Producer;
import rx.Subscriber;
import rx.Subscription;
import rx.exceptions.OnErrorThrowable;
import rx.functions.Action1;
import rx.functions.Func0;
/* compiled from: OperatorReplay */
public final class j1<T> extends j0.m.c<T> implements Subscription {
    public static final Func0 j = new a();
    public final Observable<? extends T> k;
    public final AtomicReference<f<T>> l;
    public final Func0<? extends e<T>> m;

    /* compiled from: OperatorReplay */
    public static class a implements Func0 {
        @Override // rx.functions.Func0, java.util.concurrent.Callable
        public Object call() {
            return new h(16);
        }
    }

    /* compiled from: OperatorReplay */
    public static class b<T> extends AtomicReference<d> implements e<T> {
        private static final long serialVersionUID = 2346567790059478686L;
        public long index;
        public int size;
        public d tail;

        public b() {
            d dVar = new d(null, 0);
            this.tail = dVar;
            set(dVar);
        }

        public void a() {
        }

        @Override // j0.l.a.j1.e
        public final void complete() {
            Object obj = e.a;
            long j = this.index + 1;
            this.index = j;
            d dVar = new d(obj, j);
            this.tail.set(dVar);
            this.tail = dVar;
            this.size++;
        }

        @Override // j0.l.a.j1.e
        public final void g(T t) {
            if (t == null) {
                t = (T) e.b;
            }
            long j = this.index + 1;
            this.index = j;
            d dVar = new d(t, j);
            this.tail.set(dVar);
            this.tail = dVar;
            this.size++;
            a();
        }

        @Override // j0.l.a.j1.e
        public final void h(c<T> cVar) {
            Subscriber<? super T> subscriber;
            d dVar;
            synchronized (cVar) {
                if (cVar.emitting) {
                    cVar.missed = true;
                    return;
                }
                cVar.emitting = true;
            }
            while (!cVar.isUnsubscribed()) {
                d dVar2 = (d) cVar.index;
                if (dVar2 == null) {
                    dVar2 = get();
                    cVar.index = dVar2;
                    cVar.a(dVar2.index);
                }
                if (!cVar.isUnsubscribed() && (subscriber = cVar.child) != null) {
                    long j = cVar.get();
                    long j2 = 0;
                    while (j2 != j && (dVar = dVar2.get()) != null) {
                        Object obj = dVar.value;
                        try {
                            if (e.a(subscriber, obj)) {
                                cVar.index = null;
                                return;
                            }
                            j2++;
                            if (!cVar.isUnsubscribed()) {
                                dVar2 = dVar;
                            } else {
                                return;
                            }
                        } catch (Throwable th) {
                            cVar.index = null;
                            c.q.a.k.a.a0(th);
                            cVar.unsubscribe();
                            if (!(obj instanceof e.c) && !e.c(obj)) {
                                subscriber.onError(OnErrorThrowable.a(th, e.b(obj)));
                                return;
                            }
                            return;
                        }
                    }
                    if (j2 != 0) {
                        cVar.index = dVar2;
                        if (j != Long.MAX_VALUE) {
                            cVar.b(j2);
                        }
                    }
                    synchronized (cVar) {
                        if (!cVar.missed) {
                            cVar.emitting = false;
                            return;
                        }
                        cVar.missed = false;
                    }
                } else {
                    return;
                }
            }
        }

        @Override // j0.l.a.j1.e
        public final void i(Throwable th) {
            e.c cVar = new e.c(th);
            long j = this.index + 1;
            this.index = j;
            d dVar = new d(cVar, j);
            this.tail.set(dVar);
            this.tail = dVar;
            this.size++;
        }
    }

    /* compiled from: OperatorReplay */
    public static final class c<T> extends AtomicLong implements Producer, Subscription {
        private static final long serialVersionUID = -4453897557930727610L;
        public Subscriber<? super T> child;
        public boolean emitting;
        public Object index;
        public boolean missed;
        public final f<T> parent;
        public final AtomicLong totalRequested = new AtomicLong();

        public c(f<T> fVar, Subscriber<? super T> subscriber) {
            this.parent = fVar;
            this.child = subscriber;
        }

        public void a(long j) {
            long j2;
            long j3;
            do {
                j2 = this.totalRequested.get();
                j3 = j2 + j;
                if (j3 < 0) {
                    j3 = Long.MAX_VALUE;
                }
            } while (!this.totalRequested.compareAndSet(j2, j3));
        }

        public long b(long j) {
            long j2;
            long j3;
            if (j > 0) {
                do {
                    j2 = get();
                    if (j2 == Long.MIN_VALUE) {
                        return Long.MIN_VALUE;
                    }
                    j3 = j2 - j;
                    if (j3 < 0) {
                        throw new IllegalStateException(c.d.b.a.a.A(c.d.b.a.a.O("More produced (", j, ") than requested ("), j2, ")"));
                    }
                } while (!compareAndSet(j2, j3));
                return j3;
            }
            throw new IllegalArgumentException("Cant produce zero or less");
        }

        @Override // rx.Subscription
        public boolean isUnsubscribed() {
            return get() == Long.MIN_VALUE;
        }

        @Override // rx.Producer
        public void j(long j) {
            long j2;
            long j3;
            int i = (j > 0 ? 1 : (j == 0 ? 0 : -1));
            if (i >= 0) {
                do {
                    j2 = get();
                    if (j2 != Long.MIN_VALUE) {
                        if (j2 < 0 || i != 0) {
                            j3 = j2 + j;
                            if (j3 < 0) {
                                j3 = Long.MAX_VALUE;
                            }
                        } else {
                            return;
                        }
                    } else {
                        return;
                    }
                } while (!compareAndSet(j2, j3));
                a(j);
                this.parent.c(this);
                this.parent.j.h(this);
            }
        }

        @Override // rx.Subscription
        public void unsubscribe() {
            if (get() != Long.MIN_VALUE && getAndSet(Long.MIN_VALUE) != Long.MIN_VALUE) {
                f<T> fVar = this.parent;
                if (!fVar.l) {
                    synchronized (fVar.m) {
                        if (!fVar.l) {
                            j0.l.e.f<c<T>> fVar2 = fVar.m;
                            c<T>[] cVarArr = fVar2.d;
                            int i = fVar2.a;
                            int b = j0.l.e.f.b(hashCode()) & i;
                            c<T> cVar = cVarArr[b];
                            boolean z2 = true;
                            if (cVar != null) {
                                if (!cVar.equals(this)) {
                                    while (true) {
                                        b = (b + 1) & i;
                                        c<T> cVar2 = cVarArr[b];
                                        if (cVar2 != null) {
                                            if (cVar2.equals(this)) {
                                                fVar2.c(b, cVarArr, i);
                                                break;
                                            }
                                        } else {
                                            break;
                                        }
                                    }
                                } else {
                                    fVar2.c(b, cVarArr, i);
                                }
                            }
                            if (fVar.m.b != 0) {
                                z2 = false;
                            }
                            if (z2) {
                                fVar.n = f.i;
                            }
                            fVar.o++;
                        }
                    }
                }
                this.parent.c(this);
                this.child = null;
            }
        }
    }

    /* compiled from: OperatorReplay */
    public static final class d extends AtomicReference<d> {
        private static final long serialVersionUID = 245354315435971818L;
        public final long index;
        public final Object value;

        public d(Object obj, long j) {
            this.value = obj;
            this.index = j;
        }
    }

    /* compiled from: OperatorReplay */
    public interface e<T> {
        void complete();

        void g(T t);

        void h(c<T> cVar);

        void i(Throwable th);
    }

    /* compiled from: OperatorReplay */
    public static final class f<T> extends Subscriber<T> implements Subscription {
        public static final c[] i = new c[0];
        public final e<T> j;
        public boolean k;
        public volatile boolean l;
        public final j0.l.e.f<c<T>> m = new j0.l.e.f<>();
        public c<T>[] n = i;
        public volatile long o;
        public long p;
        public final AtomicBoolean q = new AtomicBoolean();
        public boolean r;

        /* renamed from: s  reason: collision with root package name */
        public boolean f2834s;
        public long t;
        public long u;
        public volatile Producer v;
        public List<c<T>> w;

        /* renamed from: x  reason: collision with root package name */
        public boolean f2835x;

        public f(e<T> eVar) {
            this.j = eVar;
            request(0);
        }

        public c<T>[] a() {
            c<T>[] cVarArr;
            synchronized (this.m) {
                c<T>[] cVarArr2 = this.m.d;
                int length = cVarArr2.length;
                cVarArr = new c[length];
                System.arraycopy(cVarArr2, 0, cVarArr, 0, length);
            }
            return cVarArr;
        }

        public void b(long j, long j2) {
            long j3 = this.u;
            Producer producer = this.v;
            long j4 = j - j2;
            if (j4 != 0) {
                this.t = j;
                if (producer == null) {
                    long j5 = j3 + j4;
                    if (j5 < 0) {
                        j5 = Long.MAX_VALUE;
                    }
                    this.u = j5;
                } else if (j3 != 0) {
                    this.u = 0;
                    producer.j(j3 + j4);
                } else {
                    producer.j(j4);
                }
            } else if (j3 != 0 && producer != null) {
                this.u = 0;
                producer.j(j3);
            }
        }

        public void c(c<T> cVar) {
            long j;
            List<c<T>> list;
            boolean z2;
            long j2;
            if (!isUnsubscribed()) {
                synchronized (this) {
                    if (this.r) {
                        if (cVar != null) {
                            List list2 = this.w;
                            if (list2 == null) {
                                list2 = new ArrayList();
                                this.w = list2;
                            }
                            list2.add(cVar);
                        } else {
                            this.f2835x = true;
                        }
                        this.f2834s = true;
                        return;
                    }
                    this.r = true;
                }
                long j3 = this.t;
                if (cVar != null) {
                    j = Math.max(j3, cVar.totalRequested.get());
                } else {
                    c<T>[] a = a();
                    long j4 = j3;
                    for (c<T> cVar2 : a) {
                        if (cVar2 != null) {
                            j4 = Math.max(j4, cVar2.totalRequested.get());
                        }
                    }
                    j = j4;
                }
                b(j, j3);
                while (!isUnsubscribed()) {
                    synchronized (this) {
                        if (!this.f2834s) {
                            this.r = false;
                            return;
                        }
                        this.f2834s = false;
                        list = this.w;
                        this.w = null;
                        z2 = this.f2835x;
                        this.f2835x = false;
                    }
                    long j5 = this.t;
                    if (list != null) {
                        j2 = j5;
                        for (c<T> cVar3 : list) {
                            j2 = Math.max(j2, cVar3.totalRequested.get());
                        }
                    } else {
                        j2 = j5;
                    }
                    if (z2) {
                        c<T>[] a2 = a();
                        for (c<T> cVar4 : a2) {
                            if (cVar4 != null) {
                                j2 = Math.max(j2, cVar4.totalRequested.get());
                            }
                        }
                    }
                    b(j2, j5);
                }
            }
        }

        public void d() {
            c<T>[] cVarArr = this.n;
            if (this.p != this.o) {
                synchronized (this.m) {
                    cVarArr = this.n;
                    c<T>[] cVarArr2 = this.m.d;
                    int length = cVarArr2.length;
                    if (cVarArr.length != length) {
                        cVarArr = new c[length];
                        this.n = cVarArr;
                    }
                    System.arraycopy(cVarArr2, 0, cVarArr, 0, length);
                    this.p = this.o;
                }
            }
            e<T> eVar = this.j;
            for (c<T> cVar : cVarArr) {
                if (cVar != null) {
                    eVar.h(cVar);
                }
            }
        }

        @Override // j0.g
        public void onCompleted() {
            if (!this.k) {
                this.k = true;
                try {
                    this.j.complete();
                    d();
                } finally {
                    unsubscribe();
                }
            }
        }

        @Override // j0.g
        public void onError(Throwable th) {
            if (!this.k) {
                this.k = true;
                try {
                    this.j.i(th);
                    d();
                } finally {
                    unsubscribe();
                }
            }
        }

        @Override // j0.g
        public void onNext(T t) {
            if (!this.k) {
                this.j.g(t);
                d();
            }
        }

        @Override // rx.Subscriber
        public void setProducer(Producer producer) {
            if (this.v == null) {
                this.v = producer;
                c(null);
                d();
                return;
            }
            throw new IllegalStateException("Only a single producer can be set on a Subscriber.");
        }
    }

    /* compiled from: OperatorReplay */
    public static final class g<T> extends b<T> {
        private static final long serialVersionUID = -5898283885385201806L;
        public final int limit;

        public g(int i) {
            this.limit = i;
        }

        @Override // j0.l.a.j1.b
        public void a() {
            if (this.size > this.limit) {
                d dVar = get().get();
                if (dVar != null) {
                    this.size--;
                    set(dVar);
                    return;
                }
                throw new IllegalStateException("Empty list!");
            }
        }
    }

    /* compiled from: OperatorReplay */
    public static final class h<T> extends ArrayList<Object> implements e<T> {
        private static final long serialVersionUID = 7063189396499112664L;
        public volatile int size;

        public h(int i) {
            super(i);
        }

        @Override // j0.l.a.j1.e
        public void complete() {
            add(e.a);
            this.size++;
        }

        @Override // j0.l.a.j1.e
        public void g(T t) {
            if (t == null) {
                t = (T) e.b;
            }
            add(t);
            this.size++;
        }

        @Override // j0.l.a.j1.e
        public void h(c<T> cVar) {
            synchronized (cVar) {
                if (cVar.emitting) {
                    cVar.missed = true;
                    return;
                }
                cVar.emitting = true;
            }
            while (!cVar.isUnsubscribed()) {
                int i = this.size;
                Integer num = (Integer) cVar.index;
                int intValue = num != null ? num.intValue() : 0;
                Subscriber<? super T> subscriber = cVar.child;
                if (subscriber != null) {
                    long j = cVar.get();
                    long j2 = 0;
                    while (j2 != j && intValue < i) {
                        Object obj = get(intValue);
                        try {
                            if (!e.a(subscriber, obj) && !cVar.isUnsubscribed()) {
                                intValue++;
                                j2++;
                            } else {
                                return;
                            }
                        } catch (Throwable th) {
                            c.q.a.k.a.a0(th);
                            cVar.unsubscribe();
                            if (!(obj instanceof e.c) && !e.c(obj)) {
                                subscriber.onError(OnErrorThrowable.a(th, e.b(obj)));
                                return;
                            }
                            return;
                        }
                    }
                    if (j2 != 0) {
                        cVar.index = Integer.valueOf(intValue);
                        if (j != Long.MAX_VALUE) {
                            cVar.b(j2);
                        }
                    }
                    synchronized (cVar) {
                        if (!cVar.missed) {
                            cVar.emitting = false;
                            return;
                        }
                        cVar.missed = false;
                    }
                } else {
                    return;
                }
            }
        }

        @Override // j0.l.a.j1.e
        public void i(Throwable th) {
            add(new e.c(th));
            this.size++;
        }
    }

    public j1(Observable.a<T> aVar, Observable<? extends T> observable, AtomicReference<f<T>> atomicReference, Func0<? extends e<T>> func0) {
        super(aVar);
        this.k = observable;
        this.l = atomicReference;
        this.m = func0;
    }

    @Override // rx.Subscription
    public boolean isUnsubscribed() {
        f<T> fVar = this.l.get();
        return fVar == null || fVar.isUnsubscribed();
    }

    @Override // j0.m.c
    public void k0(Action1<? super Subscription> action1) {
        f<T> fVar;
        while (true) {
            fVar = this.l.get();
            if (fVar != null && !fVar.isUnsubscribed()) {
                break;
            }
            f<T> fVar2 = new f<>((e) this.m.call());
            fVar2.add(new j0.r.a(new m1(fVar2)));
            if (this.l.compareAndSet(fVar, fVar2)) {
                fVar = fVar2;
                break;
            }
        }
        boolean z2 = true;
        if (fVar.q.get() || !fVar.q.compareAndSet(false, true)) {
            z2 = false;
        }
        ((z) action1).call(fVar);
        if (z2) {
            this.k.i0(fVar);
        }
    }

    @Override // rx.Subscription
    public void unsubscribe() {
        this.l.lazySet(null);
    }
}