package io.netty.util.concurrent;

import io.netty.util.internal.ObjectUtil;
import io.netty.util.internal.logging.InternalLogger;
import io.netty.util.internal.logging.InternalLoggerFactory;

/* JADX INFO: loaded from: classes.dex */
public final class UnaryPromiseNotifier<T> implements FutureListener<T> {
    private static final InternalLogger logger = InternalLoggerFactory.getInstance((Class<?>) UnaryPromiseNotifier.class);
    private final Promise<? super T> promise;

    public UnaryPromiseNotifier(Promise<? super T> promise) {
        this.promise = (Promise) ObjectUtil.checkNotNull(promise, "promise");
    }

    public static <X> void cascadeTo(Future<X> future, Promise<? super X> promise) {
        InternalLogger internalLogger;
        String str;
        if (future.isSuccess()) {
            if (promise.trySuccess(future.getNow())) {
                return;
            }
            internalLogger = logger;
            str = "Failed to mark a promise as success because it is done already: {}";
        } else if (!future.isCancelled()) {
            if (promise.tryFailure(future.cause())) {
                return;
            }
            logger.warn("Failed to mark a promise as failure because it's done already: {}", promise, future.cause());
            return;
        } else {
            if (promise.cancel(false)) {
                return;
            }
            internalLogger = logger;
            str = "Failed to cancel a promise because it is done already: {}";
        }
        internalLogger.warn(str, promise);
    }

    @Override // io.netty.util.concurrent.GenericFutureListener
    public void operationComplete(Future<T> future) {
        cascadeTo(future, this.promise);
    }
}