package io.netty.util.concurrent;

import io.netty.util.concurrent.Future;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Objects;
import java.util.Set;

/* JADX INFO: loaded from: classes.dex */
@Deprecated
public class PromiseAggregator<V, F extends Future<V>> implements GenericFutureListener<F> {
    private final Promise<?> aggregatePromise;
    private final boolean failPending;
    private Set<Promise<V>> pendingPromises;

    public PromiseAggregator(Promise<Void> promise) {
        this(promise, true);
    }

    public PromiseAggregator(Promise<Void> promise, boolean z2) {
        Objects.requireNonNull(promise, "aggregatePromise");
        this.aggregatePromise = promise;
        this.failPending = z2;
    }

    @SafeVarargs
    public final PromiseAggregator<V, F> add(Promise<V>... promiseArr) {
        Objects.requireNonNull(promiseArr, "promises");
        if (promiseArr.length == 0) {
            return this;
        }
        synchronized (this) {
            if (this.pendingPromises == null) {
                this.pendingPromises = new LinkedHashSet(promiseArr.length > 1 ? promiseArr.length : 2);
            }
            for (Promise<V> promise : promiseArr) {
                if (promise != null) {
                    this.pendingPromises.add(promise);
                    promise.addListener((GenericFutureListener) this);
                }
            }
        }
        return this;
    }

    @Override // io.netty.util.concurrent.GenericFutureListener
    public synchronized void operationComplete(F f2) {
        Promise<?> promise;
        Set<Promise<V>> set = this.pendingPromises;
        if (set == null) {
            promise = this.aggregatePromise;
        } else {
            set.remove(f2);
            if (!f2.isSuccess()) {
                Throwable thCause = f2.cause();
                this.aggregatePromise.setFailure(thCause);
                if (this.failPending) {
                    Iterator<Promise<V>> it = this.pendingPromises.iterator();
                    while (it.hasNext()) {
                        it.next().setFailure(thCause);
                    }
                }
            } else if (this.pendingPromises.isEmpty()) {
                promise = this.aggregatePromise;
            }
        }
        promise.setSuccess(null);
    }
}