//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package rx.subjects;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.List;
import rx.Observable.OnSubscribe;
import rx.exceptions.Exceptions;
import rx.functions.Action1;
import rx.internal.operators.NotificationLite;
import rx.subjects.SubjectSubscriptionManager.SubjectObserver;

public final class BehaviorSubject<T> extends Subject<T, T> {
    private static final Object[] EMPTY_ARRAY = new Object[0];
    private final SubjectSubscriptionManager<T> state;

    public static <T> BehaviorSubject<T> create() {
        return create((Object)null, false);
    }

    public static <T> BehaviorSubject<T> create(T defaultValue) {
        return create(defaultValue, true);
    }

    private static <T> BehaviorSubject<T> create(T defaultValue, boolean hasDefault) {
        final SubjectSubscriptionManager<T> state = new SubjectSubscriptionManager();
        if (hasDefault) {
            state.setLatest(NotificationLite.next(defaultValue));
        }

        state.onAdded = new Action1<SubjectObserver<T>>() {
            public void call(SubjectObserver<T> o) {
                o.emitFirst(state.getLatest());
            }
        };
        state.onTerminated = state.onAdded;
        return new BehaviorSubject(state, state);
    }

    protected BehaviorSubject(OnSubscribe<T> onSubscribe, SubjectSubscriptionManager<T> state) {
        super(onSubscribe);
        this.state = state;
    }

    public void onCompleted() {
        Object last = this.state.getLatest();
        if (last == null || this.state.active) {
            Object n = NotificationLite.completed();
            SubjectObserver[] var3 = this.state.terminate(n);
            int var4 = var3.length;

            for(int var5 = 0; var5 < var4; ++var5) {
                SubjectObserver<T> bo = var3[var5];
                bo.emitNext(n);
            }
        }

    }

    public void onError(Throwable e) {
        Object last = this.state.getLatest();
        if (last == null || this.state.active) {
            Object n = NotificationLite.error(e);
            List<Throwable> errors = null;
            SubjectObserver[] var5 = this.state.terminate(n);
            int var6 = var5.length;

            for(int var7 = 0; var7 < var6; ++var7) {
                SubjectObserver bo = var5[var7];

                try {
                    bo.emitNext(n);
                } catch (Throwable var10) {
                    if (errors == null) {
                        errors = new ArrayList();
                    }

                    errors.add(var10);
                }
            }

            Exceptions.throwIfAny(errors);
        }

    }

    public void onNext(T v) {
        Object last = this.state.getLatest();
        if (last == null || this.state.active) {
            Object n = NotificationLite.next(v);
            SubjectObserver[] var4 = this.state.next(n);
            int var5 = var4.length;

            for(int var6 = 0; var6 < var5; ++var6) {
                SubjectObserver<T> bo = var4[var6];
                bo.emitNext(n);
            }
        }

    }

    int subscriberCount() {
        return this.state.observers().length;
    }

    public boolean hasObservers() {
        return this.state.observers().length > 0;
    }

    public boolean hasValue() {
        Object o = this.state.getLatest();
        return NotificationLite.isNext(o);
    }

    public boolean hasThrowable() {
        Object o = this.state.getLatest();
        return NotificationLite.isError(o);
    }

    public boolean hasCompleted() {
        Object o = this.state.getLatest();
        return NotificationLite.isCompleted(o);
    }

    public T getValue() {
        Object o = this.state.getLatest();
        return NotificationLite.isNext(o) ? NotificationLite.getValue(o) : null;
    }

    public Throwable getThrowable() {
        Object o = this.state.getLatest();
        return NotificationLite.isError(o) ? NotificationLite.getError(o) : null;
    }

    public T[] getValues(T[] a) {
        Object o = this.state.getLatest();
        if (NotificationLite.isNext(o)) {
            if (a.length == 0) {
                a = (Object[])((Object[])Array.newInstance(a.getClass().getComponentType(), 1));
            }

            a[0] = NotificationLite.getValue(o);
            if (a.length > 1) {
                a[1] = null;
            }
        } else if (a.length > 0) {
            a[0] = null;
        }

        return a;
    }

    public Object[] getValues() {
        T[] r = this.getValues((Object[])EMPTY_ARRAY);
        return r == EMPTY_ARRAY ? new Object[0] : r;
    }
}