package io.netty.handler.ssl;

import g.a.a.a.a;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.DecoderException;
import io.netty.util.AsyncMapping;
import io.netty.util.DomainNameMapping;
import io.netty.util.Mapping;
import io.netty.util.ReferenceCountUtil;
import io.netty.util.concurrent.Future;
import io.netty.util.concurrent.Promise;
import io.netty.util.internal.ObjectUtil;
import io.netty.util.internal.PlatformDependent;

/* JADX INFO: loaded from: classes.dex */
public class SniHandler extends AbstractSniHandler<SslContext> {
    private static final Selection EMPTY_SELECTION = new Selection(null, null);
    public final AsyncMapping<String, SslContext> mapping;
    private volatile Selection selection;

    public static final class AsyncMappingAdapter implements AsyncMapping<String, SslContext> {
        private final Mapping<? super String, ? extends SslContext> mapping;

        private AsyncMappingAdapter(Mapping<? super String, ? extends SslContext> mapping) {
            this.mapping = (Mapping) ObjectUtil.checkNotNull(mapping, "mapping");
        }

        @Override // io.netty.util.AsyncMapping
        public Future<SslContext> map(String str, Promise<SslContext> promise) {
            try {
                return promise.setSuccess(this.mapping.map(str));
            } catch (Throwable th) {
                return promise.setFailure(th);
            }
        }
    }

    public static final class Selection {
        public final SslContext context;
        public final String hostname;

        public Selection(SslContext sslContext, String str) {
            this.context = sslContext;
            this.hostname = str;
        }
    }

    public SniHandler(AsyncMapping<? super String, ? extends SslContext> asyncMapping) {
        this.selection = EMPTY_SELECTION;
        this.mapping = (AsyncMapping) ObjectUtil.checkNotNull(asyncMapping, "mapping");
    }

    public SniHandler(DomainNameMapping<? extends SslContext> domainNameMapping) {
        this((Mapping<? super String, ? extends SslContext>) domainNameMapping);
    }

    public SniHandler(Mapping<? super String, ? extends SslContext> mapping) {
        this(new AsyncMappingAdapter(mapping));
    }

    public String hostname() {
        return this.selection.hostname;
    }

    @Override // io.netty.handler.ssl.AbstractSniHandler
    public Future<SslContext> lookup(ChannelHandlerContext channelHandlerContext, String str) {
        return this.mapping.map(str, channelHandlerContext.executor().newPromise());
    }

    @Override // io.netty.handler.ssl.AbstractSniHandler
    public final void onLookupComplete(ChannelHandlerContext channelHandlerContext, String str, Future<SslContext> future) {
        if (!future.isSuccess()) {
            Throwable thCause = future.cause();
            if (!(thCause instanceof Error)) {
                throw new DecoderException(a.t("failed to get the SslContext for ", str), thCause);
            }
            throw ((Error) thCause);
        }
        SslContext now = future.getNow();
        this.selection = new Selection(now, str);
        try {
            replaceHandler(channelHandlerContext, str, now);
        } catch (Throwable th) {
            this.selection = EMPTY_SELECTION;
            PlatformDependent.throwException(th);
        }
    }

    public void replaceHandler(ChannelHandlerContext channelHandlerContext, String str, SslContext sslContext) {
        SslHandler sslHandlerNewHandler = null;
        try {
            sslHandlerNewHandler = sslContext.newHandler(channelHandlerContext.alloc());
            channelHandlerContext.pipeline().replace(this, SslHandler.class.getName(), sslHandlerNewHandler);
        } catch (Throwable th) {
            if (sslHandlerNewHandler != null) {
                ReferenceCountUtil.safeRelease(sslHandlerNewHandler.engine());
            }
            throw th;
        }
    }

    public SslContext sslContext() {
        return this.selection.context;
    }
}