package io.netty.resolver.dns;

import g.a.a.a.a;
import io.netty.channel.ChannelFactory;
import io.netty.channel.EventLoop;
import io.netty.channel.ReflectiveChannelFactory;
import io.netty.channel.socket.DatagramChannel;
import io.netty.resolver.AddressResolver;
import io.netty.resolver.AddressResolverGroup;
import io.netty.resolver.InetSocketAddressResolver;
import io.netty.resolver.NameResolver;
import io.netty.util.concurrent.EventExecutor;
import io.netty.util.concurrent.Promise;
import io.netty.util.internal.PlatformDependent;
import io.netty.util.internal.StringUtil;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.util.List;
import java.util.concurrent.ConcurrentMap;

/* JADX INFO: loaded from: classes.dex */
public class DnsAddressResolverGroup extends AddressResolverGroup<InetSocketAddress> {
    private final ChannelFactory<? extends DatagramChannel> channelFactory;
    private final DnsServerAddressStreamProvider nameServerProvider;
    private final ConcurrentMap<String, Promise<List<InetAddress>>> resolveAllsInProgress;
    private final ConcurrentMap<String, Promise<InetAddress>> resolvesInProgress;

    public DnsAddressResolverGroup(ChannelFactory<? extends DatagramChannel> channelFactory, DnsServerAddressStreamProvider dnsServerAddressStreamProvider) {
        this.resolvesInProgress = PlatformDependent.newConcurrentHashMap();
        this.resolveAllsInProgress = PlatformDependent.newConcurrentHashMap();
        this.channelFactory = channelFactory;
        this.nameServerProvider = dnsServerAddressStreamProvider;
    }

    public DnsAddressResolverGroup(Class<? extends DatagramChannel> cls, DnsServerAddressStreamProvider dnsServerAddressStreamProvider) {
        this(new ReflectiveChannelFactory(cls), dnsServerAddressStreamProvider);
    }

    public AddressResolver<InetSocketAddress> newAddressResolver(EventLoop eventLoop, NameResolver<InetAddress> nameResolver) {
        return new InetSocketAddressResolver(eventLoop, nameResolver);
    }

    public NameResolver<InetAddress> newNameResolver(EventLoop eventLoop, ChannelFactory<? extends DatagramChannel> channelFactory, DnsServerAddressStreamProvider dnsServerAddressStreamProvider) {
        return new DnsNameResolverBuilder(eventLoop).channelFactory(channelFactory).nameServerProvider(dnsServerAddressStreamProvider).build();
    }

    @Deprecated
    public AddressResolver<InetSocketAddress> newResolver(EventLoop eventLoop, ChannelFactory<? extends DatagramChannel> channelFactory, DnsServerAddressStreamProvider dnsServerAddressStreamProvider) {
        return newAddressResolver(eventLoop, new InflightNameResolver(eventLoop, newNameResolver(eventLoop, channelFactory, dnsServerAddressStreamProvider), this.resolvesInProgress, this.resolveAllsInProgress));
    }

    @Override // io.netty.resolver.AddressResolverGroup
    public final AddressResolver<InetSocketAddress> newResolver(EventExecutor eventExecutor) {
        if (eventExecutor instanceof EventLoop) {
            return newResolver((EventLoop) eventExecutor, this.channelFactory, this.nameServerProvider);
        }
        StringBuilder sbF = a.F("unsupported executor type: ");
        sbF.append(StringUtil.simpleClassName(eventExecutor));
        sbF.append(" (expected: ");
        sbF.append(StringUtil.simpleClassName((Class<?>) EventLoop.class));
        throw new IllegalStateException(sbF.toString());
    }
}