package io.netty.resolver;

import g.a.a.a.a;
import io.netty.util.concurrent.EventExecutor;
import io.netty.util.concurrent.Future;
import io.netty.util.concurrent.FutureListener;
import io.netty.util.concurrent.Promise;
import io.netty.util.internal.ObjectUtil;
import java.util.Arrays;
import java.util.List;
import kotlinx.serialization.json.internal.AbstractJsonLexerKt;

/* JADX INFO: loaded from: classes.dex */
public final class CompositeNameResolver<T> extends SimpleNameResolver<T> {
    private final NameResolver<T>[] resolvers;

    public CompositeNameResolver(EventExecutor eventExecutor, NameResolver<T>... nameResolverArr) {
        super(eventExecutor);
        ObjectUtil.checkNotNull(nameResolverArr, "resolvers");
        for (int i2 = 0; i2 < nameResolverArr.length; i2++) {
            if (nameResolverArr[i2] == null) {
                throw new NullPointerException("resolvers[" + i2 + AbstractJsonLexerKt.END_LIST);
            }
        }
        if (nameResolverArr.length >= 2) {
            this.resolvers = (NameResolver[]) nameResolverArr.clone();
            return;
        }
        StringBuilder sbF = a.F("resolvers: ");
        sbF.append(Arrays.asList(nameResolverArr));
        sbF.append(" (expected: at least 2 resolvers)");
        throw new IllegalArgumentException(sbF.toString());
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void doResolveAllRec(final String str, final Promise<List<T>> promise, final int i2, Throwable th) {
        NameResolver<T>[] nameResolverArr = this.resolvers;
        if (i2 >= nameResolverArr.length) {
            promise.setFailure(th);
        } else {
            nameResolverArr[i2].resolveAll(str).addListener(new FutureListener<List<T>>() { // from class: io.netty.resolver.CompositeNameResolver.2
                @Override // io.netty.util.concurrent.GenericFutureListener
                public void operationComplete(Future<List<T>> future) {
                    if (future.isSuccess()) {
                        promise.setSuccess(future.getNow());
                    } else {
                        CompositeNameResolver.this.doResolveAllRec(str, promise, i2 + 1, future.cause());
                    }
                }
            });
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void doResolveRec(final String str, final Promise<T> promise, final int i2, Throwable th) {
        NameResolver<T>[] nameResolverArr = this.resolvers;
        if (i2 >= nameResolverArr.length) {
            promise.setFailure(th);
        } else {
            nameResolverArr[i2].resolve(str).addListener(new FutureListener<T>() { // from class: io.netty.resolver.CompositeNameResolver.1
                @Override // io.netty.util.concurrent.GenericFutureListener
                public void operationComplete(Future<T> future) {
                    if (future.isSuccess()) {
                        promise.setSuccess(future.getNow());
                    } else {
                        CompositeNameResolver.this.doResolveRec(str, promise, i2 + 1, future.cause());
                    }
                }
            });
        }
    }

    @Override // io.netty.resolver.SimpleNameResolver
    public void doResolve(String str, Promise<T> promise) {
        doResolveRec(str, promise, 0, null);
    }

    @Override // io.netty.resolver.SimpleNameResolver
    public void doResolveAll(String str, Promise<List<T>> promise) {
        doResolveAllRec(str, promise, 0, null);
    }
}