package io.netty.resolver.dns;

import g.a.a.a.a;
import io.netty.channel.AddressedEnvelope;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelPromise;
import io.netty.handler.codec.dns.AbstractDnsOptPseudoRrRecord;
import io.netty.handler.codec.dns.DatagramDnsQuery;
import io.netty.handler.codec.dns.DnsQuery;
import io.netty.handler.codec.dns.DnsQuestion;
import io.netty.handler.codec.dns.DnsRecord;
import io.netty.handler.codec.dns.DnsResponse;
import io.netty.handler.codec.dns.DnsSection;
import io.netty.util.concurrent.Future;
import io.netty.util.concurrent.GenericFutureListener;
import io.netty.util.concurrent.Promise;
import io.netty.util.concurrent.ScheduledFuture;
import io.netty.util.internal.ObjectUtil;
import io.netty.util.internal.logging.InternalLogger;
import io.netty.util.internal.logging.InternalLoggerFactory;
import java.net.InetSocketAddress;
import java.util.concurrent.TimeUnit;
import kotlinx.serialization.json.internal.AbstractJsonLexerKt;

/* JADX INFO: loaded from: classes.dex */
public final class DnsQueryContext {
    private static final InternalLogger logger = InternalLoggerFactory.getInstance((Class<?>) DnsQueryContext.class);
    private final DnsRecord[] additionals;
    private final int id;
    private final InetSocketAddress nameServerAddr;
    private final DnsRecord optResource;
    private final DnsNameResolver parent;
    private final Promise<AddressedEnvelope<DnsResponse, InetSocketAddress>> promise;
    private final DnsQuestion question;
    private final boolean recursionDesired;
    private volatile ScheduledFuture<?> timeoutFuture;

    public DnsQueryContext(DnsNameResolver dnsNameResolver, InetSocketAddress inetSocketAddress, DnsQuestion dnsQuestion, DnsRecord[] dnsRecordArr, Promise<AddressedEnvelope<DnsResponse, InetSocketAddress>> promise) {
        this.parent = (DnsNameResolver) ObjectUtil.checkNotNull(dnsNameResolver, "parent");
        this.nameServerAddr = (InetSocketAddress) ObjectUtil.checkNotNull(inetSocketAddress, "nameServerAddr");
        this.question = (DnsQuestion) ObjectUtil.checkNotNull(dnsQuestion, "question");
        this.additionals = (DnsRecord[]) ObjectUtil.checkNotNull(dnsRecordArr, "additionals");
        this.promise = (Promise) ObjectUtil.checkNotNull(promise, "promise");
        this.recursionDesired = dnsNameResolver.isRecursionDesired();
        this.id = dnsNameResolver.queryContextManager.add(this);
        if (!dnsNameResolver.isOptResourceEnabled()) {
            this.optResource = null;
        } else {
            int i2 = 0;
            this.optResource = new AbstractDnsOptPseudoRrRecord(dnsNameResolver.maxPayloadSize(), i2, i2) { // from class: io.netty.resolver.dns.DnsQueryContext.1
            };
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void onQueryWriteCompletion(ChannelFuture channelFuture) {
        if (!channelFuture.isSuccess()) {
            setFailure("failed to send a query", channelFuture.cause());
            return;
        }
        final long jQueryTimeoutMillis = this.parent.queryTimeoutMillis();
        if (jQueryTimeoutMillis > 0) {
            this.timeoutFuture = this.parent.ch.eventLoop().schedule(new Runnable() { // from class: io.netty.resolver.dns.DnsQueryContext.4
                @Override // java.lang.Runnable
                public void run() {
                    if (DnsQueryContext.this.promise.isDone()) {
                        return;
                    }
                    DnsQueryContext dnsQueryContext = DnsQueryContext.this;
                    StringBuilder sbF = a.F("query timed out after ");
                    sbF.append(jQueryTimeoutMillis);
                    sbF.append(" milliseconds");
                    dnsQueryContext.setFailure(sbF.toString(), null);
                }
            }, jQueryTimeoutMillis, TimeUnit.MILLISECONDS);
        }
    }

    private void sendQuery(final DnsQuery dnsQuery, final ChannelPromise channelPromise) {
        if (this.parent.channelFuture.isDone()) {
            writeQuery(dnsQuery, channelPromise);
        } else {
            this.parent.channelFuture.addListener(new GenericFutureListener<Future<? super Channel>>() { // from class: io.netty.resolver.dns.DnsQueryContext.2
                @Override // io.netty.util.concurrent.GenericFutureListener
                public void operationComplete(Future<? super Channel> future) {
                    if (future.isSuccess()) {
                        DnsQueryContext.this.writeQuery(dnsQuery, channelPromise);
                        return;
                    }
                    Throwable thCause = future.cause();
                    DnsQueryContext.this.promise.tryFailure(thCause);
                    channelPromise.setFailure(thCause);
                }
            });
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void setFailure(String str, Throwable th) {
        InetSocketAddress inetSocketAddressNameServerAddr = nameServerAddr();
        this.parent.queryContextManager.remove(inetSocketAddressNameServerAddr, this.id);
        StringBuilder sb = new StringBuilder(str.length() + 64);
        sb.append(AbstractJsonLexerKt.BEGIN_LIST);
        sb.append(inetSocketAddressNameServerAddr);
        sb.append("] ");
        sb.append(str);
        sb.append(" (no stack trace available)");
        this.promise.tryFailure(th == null ? new DnsNameResolverTimeoutException(inetSocketAddressNameServerAddr, question(), sb.toString()) : new DnsNameResolverException(inetSocketAddressNameServerAddr, question(), sb.toString(), th));
    }

    /* JADX WARN: Multi-variable type inference failed */
    /* JADX WARN: Type inference fix 'apply assigned field type' failed
    java.lang.UnsupportedOperationException: ArgType.getObject(), call class: class jadx.core.dex.instructions.args.ArgType$UnknownArg
    	at jadx.core.dex.instructions.args.ArgType.getObject(ArgType.java:593)
    	at jadx.core.dex.attributes.nodes.ClassTypeVarsAttr.getTypeVarsMapFor(ClassTypeVarsAttr.java:35)
    	at jadx.core.dex.nodes.utils.TypeUtils.replaceClassGenerics(TypeUtils.java:177)
    	at jadx.core.dex.visitors.typeinference.FixTypesVisitor.insertExplicitUseCast(FixTypesVisitor.java:397)
    	at jadx.core.dex.visitors.typeinference.FixTypesVisitor.tryFieldTypeWithNewCasts(FixTypesVisitor.java:359)
    	at jadx.core.dex.visitors.typeinference.FixTypesVisitor.applyFieldType(FixTypesVisitor.java:309)
    	at jadx.core.dex.visitors.typeinference.FixTypesVisitor.visit(FixTypesVisitor.java:94)
     */
    private void setSuccess(AddressedEnvelope<? extends DnsResponse, InetSocketAddress> addressedEnvelope) {
        this.parent.queryContextManager.remove(nameServerAddr(), this.id);
        ScheduledFuture<?> scheduledFuture = this.timeoutFuture;
        if (scheduledFuture != null) {
            scheduledFuture.cancel(false);
        }
        Promise<AddressedEnvelope<DnsResponse, InetSocketAddress>> promise = this.promise;
        if (!promise.setUncancellable() || promise.trySuccess(addressedEnvelope.retain())) {
            return;
        }
        addressedEnvelope.release();
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void writeQuery(DnsQuery dnsQuery, ChannelPromise channelPromise) {
        final ChannelFuture channelFutureWriteAndFlush = this.parent.ch.writeAndFlush(dnsQuery, channelPromise);
        if (channelFutureWriteAndFlush.isDone()) {
            onQueryWriteCompletion(channelFutureWriteAndFlush);
        } else {
            channelFutureWriteAndFlush.addListener((GenericFutureListener<? extends Future<? super Void>>) new ChannelFutureListener() { // from class: io.netty.resolver.dns.DnsQueryContext.3
                @Override // io.netty.util.concurrent.GenericFutureListener
                public void operationComplete(ChannelFuture channelFuture) {
                    DnsQueryContext.this.onQueryWriteCompletion(channelFutureWriteAndFlush);
                }
            });
        }
    }

    public void finish(AddressedEnvelope<? extends DnsResponse, InetSocketAddress> addressedEnvelope) {
        InternalLogger internalLogger;
        String str;
        DnsResponse dnsResponseContent = addressedEnvelope.content();
        DnsSection dnsSection = DnsSection.QUESTION;
        if (dnsResponseContent.count(dnsSection) != 1) {
            internalLogger = logger;
            str = "Received a DNS response with invalid number of questions: {}";
        } else if (question().equals(dnsResponseContent.recordAt(dnsSection))) {
            setSuccess(addressedEnvelope);
            return;
        } else {
            internalLogger = logger;
            str = "Received a mismatching DNS response: {}";
        }
        internalLogger.warn(str, addressedEnvelope);
    }

    public InetSocketAddress nameServerAddr() {
        return this.nameServerAddr;
    }

    public void query(ChannelPromise channelPromise) {
        DnsQuestion dnsQuestionQuestion = question();
        InetSocketAddress inetSocketAddressNameServerAddr = nameServerAddr();
        DatagramDnsQuery datagramDnsQuery = new DatagramDnsQuery(null, inetSocketAddressNameServerAddr, this.id);
        datagramDnsQuery.setRecursionDesired(this.recursionDesired);
        datagramDnsQuery.addRecord(DnsSection.QUESTION, (DnsRecord) dnsQuestionQuestion);
        for (DnsRecord dnsRecord : this.additionals) {
            datagramDnsQuery.addRecord(DnsSection.ADDITIONAL, dnsRecord);
        }
        DnsRecord dnsRecord2 = this.optResource;
        if (dnsRecord2 != null) {
            datagramDnsQuery.addRecord(DnsSection.ADDITIONAL, dnsRecord2);
        }
        InternalLogger internalLogger = logger;
        if (internalLogger.isDebugEnabled()) {
            internalLogger.debug("{} WRITE: [{}: {}], {}", this.parent.ch, Integer.valueOf(this.id), inetSocketAddressNameServerAddr, dnsQuestionQuestion);
        }
        sendQuery(datagramDnsQuery, channelPromise);
    }

    public DnsQuestion question() {
        return this.question;
    }
}