package io.netty.channel.pool;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.EventLoop;
import io.netty.util.AttributeKey;
import io.netty.util.concurrent.Future;
import io.netty.util.concurrent.FutureListener;
import io.netty.util.concurrent.GenericFutureListener;
import io.netty.util.concurrent.Promise;
import io.netty.util.internal.ObjectUtil;
import io.netty.util.internal.PlatformDependent;
import io.netty.util.internal.ThrowableUtil;
import java.util.Deque;

/* JADX INFO: loaded from: classes.dex */
public class SimpleChannelPool implements ChannelPool {
    public static final /* synthetic */ boolean $assertionsDisabled = false;
    private final Bootstrap bootstrap;
    private final Deque<Channel> deque;
    private final ChannelPoolHandler handler;
    private final ChannelHealthChecker healthCheck;
    private final boolean lastRecentUsed;
    private final boolean releaseHealthCheck;
    private static final AttributeKey<SimpleChannelPool> POOL_KEY = AttributeKey.newInstance("channelPool");
    private static final IllegalStateException FULL_EXCEPTION = (IllegalStateException) ThrowableUtil.unknownStackTrace(new IllegalStateException("ChannelPool full"), SimpleChannelPool.class, "releaseAndOffer(...)");

    public SimpleChannelPool(Bootstrap bootstrap, ChannelPoolHandler channelPoolHandler) {
        this(bootstrap, channelPoolHandler, ChannelHealthChecker.ACTIVE);
    }

    public SimpleChannelPool(Bootstrap bootstrap, ChannelPoolHandler channelPoolHandler, ChannelHealthChecker channelHealthChecker) {
        this(bootstrap, channelPoolHandler, channelHealthChecker, true);
    }

    public SimpleChannelPool(Bootstrap bootstrap, ChannelPoolHandler channelPoolHandler, ChannelHealthChecker channelHealthChecker, boolean z2) {
        this(bootstrap, channelPoolHandler, channelHealthChecker, z2, true);
    }

    public SimpleChannelPool(Bootstrap bootstrap, final ChannelPoolHandler channelPoolHandler, ChannelHealthChecker channelHealthChecker, boolean z2, boolean z3) {
        this.deque = PlatformDependent.newConcurrentDeque();
        this.handler = (ChannelPoolHandler) ObjectUtil.checkNotNull(channelPoolHandler, "handler");
        this.healthCheck = (ChannelHealthChecker) ObjectUtil.checkNotNull(channelHealthChecker, "healthCheck");
        this.releaseHealthCheck = z2;
        Bootstrap bootstrapMo10clone = ((Bootstrap) ObjectUtil.checkNotNull(bootstrap, "bootstrap")).mo10clone();
        this.bootstrap = bootstrapMo10clone;
        bootstrapMo10clone.handler(new ChannelInitializer<Channel>() { // from class: io.netty.channel.pool.SimpleChannelPool.1
            public static final /* synthetic */ boolean $assertionsDisabled = false;

            @Override // io.netty.channel.ChannelInitializer
            public void initChannel(Channel channel) {
                channelPoolHandler.channelCreated(channel);
            }
        });
        this.lastRecentUsed = z3;
    }

    private Future<Channel> acquireHealthyFromPoolOrNew(final Promise<Channel> promise) {
        final Channel channelPollChannel;
        try {
            channelPollChannel = pollChannel();
        } catch (Throwable th) {
            promise.tryFailure(th);
        }
        if (channelPollChannel != null) {
            EventLoop eventLoop = channelPollChannel.eventLoop();
            if (eventLoop.inEventLoop()) {
                doHealthCheck(channelPollChannel, promise);
            } else {
                eventLoop.execute(new Runnable() { // from class: io.netty.channel.pool.SimpleChannelPool.3
                    @Override // java.lang.Runnable
                    public void run() {
                        SimpleChannelPool.this.doHealthCheck(channelPollChannel, promise);
                    }
                });
            }
            return promise;
        }
        Bootstrap bootstrapMo10clone = this.bootstrap.mo10clone();
        bootstrapMo10clone.attr(POOL_KEY, this);
        ChannelFuture channelFutureConnectChannel = connectChannel(bootstrapMo10clone);
        if (channelFutureConnectChannel.isDone()) {
            notifyConnect(channelFutureConnectChannel, promise);
        } else {
            channelFutureConnectChannel.addListener((GenericFutureListener<? extends Future<? super Void>>) new ChannelFutureListener() { // from class: io.netty.channel.pool.SimpleChannelPool.2
                @Override // io.netty.util.concurrent.GenericFutureListener
                public void operationComplete(ChannelFuture channelFuture) {
                    SimpleChannelPool.this.notifyConnect(channelFuture, promise);
                }
            });
        }
        return promise;
    }

    private static void closeAndFail(Channel channel, Throwable th, Promise<?> promise) {
        closeChannel(channel);
        promise.tryFailure(th);
    }

    private static void closeChannel(Channel channel) {
        channel.attr(POOL_KEY).getAndSet(null);
        channel.close();
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void doHealthCheck(final Channel channel, final Promise<Channel> promise) {
        Future<Boolean> futureIsHealthy = this.healthCheck.isHealthy(channel);
        if (futureIsHealthy.isDone()) {
            notifyHealthCheck(futureIsHealthy, channel, promise);
        } else {
            futureIsHealthy.addListener(new FutureListener<Boolean>() { // from class: io.netty.channel.pool.SimpleChannelPool.4
                @Override // io.netty.util.concurrent.GenericFutureListener
                public void operationComplete(Future<Boolean> future) {
                    SimpleChannelPool.this.notifyHealthCheck(future, channel, promise);
                }
            });
        }
    }

    private void doHealthCheckOnRelease(final Channel channel, final Promise<Void> promise) {
        final Future<Boolean> futureIsHealthy = this.healthCheck.isHealthy(channel);
        if (futureIsHealthy.isDone()) {
            releaseAndOfferIfHealthy(channel, promise, futureIsHealthy);
        } else {
            futureIsHealthy.addListener(new FutureListener<Boolean>() { // from class: io.netty.channel.pool.SimpleChannelPool.6
                @Override // io.netty.util.concurrent.GenericFutureListener
                public void operationComplete(Future<Boolean> future) {
                    SimpleChannelPool.this.releaseAndOfferIfHealthy(channel, promise, futureIsHealthy);
                }
            });
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void doReleaseChannel(Channel channel, Promise<Void> promise) {
        if (channel.attr(POOL_KEY).getAndSet(null) != this) {
            th = new IllegalArgumentException("Channel " + channel + " was not acquired from this ChannelPool");
        } else {
            try {
                if (this.releaseHealthCheck) {
                    doHealthCheckOnRelease(channel, promise);
                } else {
                    releaseAndOffer(channel, promise);
                }
                return;
            } catch (Throwable th) {
                th = th;
            }
        }
        closeAndFail(channel, th, promise);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void notifyConnect(ChannelFuture channelFuture, Promise<Channel> promise) {
        if (!channelFuture.isSuccess()) {
            promise.tryFailure(channelFuture.cause());
            return;
        }
        Channel channel = channelFuture.channel();
        if (promise.trySuccess(channel)) {
            return;
        }
        release(channel);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void notifyHealthCheck(Future<Boolean> future, Channel channel, Promise<Channel> promise) {
        if (!future.isSuccess() || !future.getNow().booleanValue()) {
            closeChannel(channel);
            acquireHealthyFromPoolOrNew(promise);
            return;
        }
        try {
            channel.attr(POOL_KEY).set(this);
            this.handler.channelAcquired(channel);
            promise.setSuccess(channel);
        } catch (Throwable th) {
            closeAndFail(channel, th, promise);
        }
    }

    private void releaseAndOffer(Channel channel, Promise<Void> promise) {
        if (!offerChannel(channel)) {
            closeAndFail(channel, FULL_EXCEPTION, promise);
        } else {
            this.handler.channelReleased(channel);
            promise.setSuccess(null);
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void releaseAndOfferIfHealthy(Channel channel, Promise<Void> promise, Future<Boolean> future) {
        if (future.getNow().booleanValue()) {
            releaseAndOffer(channel, promise);
        } else {
            this.handler.channelReleased(channel);
            promise.setSuccess(null);
        }
    }

    @Override // io.netty.channel.pool.ChannelPool
    public final Future<Channel> acquire() {
        return acquire(this.bootstrap.config().group().next().newPromise());
    }

    @Override // io.netty.channel.pool.ChannelPool
    public Future<Channel> acquire(Promise<Channel> promise) {
        ObjectUtil.checkNotNull(promise, "promise");
        return acquireHealthyFromPoolOrNew(promise);
    }

    public Bootstrap bootstrap() {
        return this.bootstrap;
    }

    @Override // io.netty.channel.pool.ChannelPool, java.io.Closeable, java.lang.AutoCloseable
    public void close() {
        while (true) {
            Channel channelPollChannel = pollChannel();
            if (channelPollChannel == null) {
                return;
            } else {
                channelPollChannel.close();
            }
        }
    }

    public ChannelFuture connectChannel(Bootstrap bootstrap) {
        return bootstrap.connect();
    }

    public ChannelPoolHandler handler() {
        return this.handler;
    }

    public ChannelHealthChecker healthChecker() {
        return this.healthCheck;
    }

    public boolean offerChannel(Channel channel) {
        return this.deque.offer(channel);
    }

    public Channel pollChannel() {
        return this.lastRecentUsed ? this.deque.pollLast() : this.deque.pollFirst();
    }

    @Override // io.netty.channel.pool.ChannelPool
    public final Future<Void> release(Channel channel) {
        return release(channel, channel.eventLoop().newPromise());
    }

    @Override // io.netty.channel.pool.ChannelPool
    public Future<Void> release(final Channel channel, final Promise<Void> promise) {
        ObjectUtil.checkNotNull(channel, "channel");
        ObjectUtil.checkNotNull(promise, "promise");
        try {
            EventLoop eventLoop = channel.eventLoop();
            if (eventLoop.inEventLoop()) {
                doReleaseChannel(channel, promise);
            } else {
                eventLoop.execute(new Runnable() { // from class: io.netty.channel.pool.SimpleChannelPool.5
                    @Override // java.lang.Runnable
                    public void run() {
                        SimpleChannelPool.this.doReleaseChannel(channel, promise);
                    }
                });
            }
        } catch (Throwable th) {
            closeAndFail(channel, th, promise);
        }
        return promise;
    }

    public boolean releaseHealthCheck() {
        return this.releaseHealthCheck;
    }
}