package p491;

import java.lang.annotation.Annotation;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Proxy;
import java.lang.reflect.Type;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executor;
import javax.annotation.Nullable;
import p447.AbstractC6930;
import p447.AbstractC6936;
import p447.C6908;
import p447.C6921;
import p447.InterfaceC6868;
import p491.C7303;
import p491.InterfaceC7311;
import p491.InterfaceC7320;

/* JADX INFO: renamed from: ޓ.ޚ, reason: contains not printable characters */
/* JADX INFO: loaded from: classes.dex */
public final class C7367 {

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public final Map<Method, AbstractC7370<?>> f21358 = new ConcurrentHashMap();

    /* JADX INFO: renamed from: ؠ, reason: contains not printable characters */
    public final InterfaceC6868.InterfaceC6869 f21359;

    /* JADX INFO: renamed from: ހ, reason: contains not printable characters */
    public final C6908 f21360;

    /* JADX INFO: renamed from: ށ, reason: contains not printable characters */
    public final List<InterfaceC7320.AbstractC7321> f21361;

    /* JADX INFO: renamed from: ނ, reason: contains not printable characters */
    public final List<InterfaceC7311.AbstractC7312> f21362;

    /* JADX INFO: renamed from: ރ, reason: contains not printable characters */
    public final boolean f21363;

    /* JADX INFO: renamed from: ޓ.ޚ$֏, reason: contains not printable characters */
    public class C7368 implements InvocationHandler {

        /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
        public final C7359 f21364 = C7359.f21301;

        /* JADX INFO: renamed from: ؠ, reason: contains not printable characters */
        public final Object[] f21365 = new Object[0];

        /* JADX INFO: renamed from: ހ, reason: contains not printable characters */
        public final /* synthetic */ Class f21366;

        public C7368(Class cls) {
            this.f21366 = cls;
        }

        @Override // java.lang.reflect.InvocationHandler
        @Nullable
        public Object invoke(Object obj, Method method, @Nullable Object[] objArr) {
            if (method.getDeclaringClass() == Object.class) {
                return method.invoke(this, objArr);
            }
            if (objArr == null) {
                objArr = this.f21365;
            }
            if (this.f21364.f21302 && method.isDefault()) {
                return this.f21364.mo10967(method, this.f21366, obj, objArr);
            }
            AbstractC7326 abstractC7326 = (AbstractC7326) C7367.this.m10981(method);
            return abstractC7326.mo10962(new C7339(abstractC7326.f21229, objArr, abstractC7326.f21230, abstractC7326.f21231), objArr);
        }
    }

    /* JADX INFO: renamed from: ޓ.ޚ$ؠ, reason: contains not printable characters */
    public static final class C7369 {

        /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
        public final C7359 f21368;

        /* JADX INFO: renamed from: ؠ, reason: contains not printable characters */
        @Nullable
        public C6908 f21369;

        /* JADX INFO: renamed from: ހ, reason: contains not printable characters */
        public final List<InterfaceC7320.AbstractC7321> f21370;

        /* JADX INFO: renamed from: ށ, reason: contains not printable characters */
        public final List<InterfaceC7311.AbstractC7312> f21371;

        public C7369() {
            C7359 c7359 = C7359.f21301;
            this.f21370 = new ArrayList();
            this.f21371 = new ArrayList();
            this.f21368 = c7359;
        }

        /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
        public C7369 m10984(String str) {
            Objects.requireNonNull(str, "baseUrl == null");
            C6908 c6908M10099 = C6908.f20012.m10099(str);
            Objects.requireNonNull(c6908M10099, "baseUrl == null");
            if ("".equals(c6908M10099.f20019.get(r0.size() - 1))) {
                this.f21369 = c6908M10099;
                return this;
            }
            throw new IllegalArgumentException("baseUrl must end in /: " + c6908M10099);
        }

        /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
        public C7367 m10985() {
            if (this.f21369 == null) {
                throw new IllegalStateException("Base URL required.");
            }
            C6921 c6921 = new C6921();
            Executor executorMo10968 = this.f21368.mo10968();
            ArrayList arrayList = new ArrayList(this.f21371);
            C7359 c7359 = this.f21368;
            if (c7359 == null) {
                throw null;
            }
            C7322 c7322 = new C7322(executorMo10968);
            arrayList.addAll(c7359.f21302 ? Arrays.asList(C7314.f21216, c7322) : Collections.singletonList(c7322));
            ArrayList arrayList2 = new ArrayList(this.f21370.size() + 1 + (this.f21368.f21302 ? 1 : 0));
            arrayList2.add(new C7303());
            arrayList2.addAll(this.f21370);
            arrayList2.addAll(this.f21368.f21302 ? Collections.singletonList(C7344.f21265) : Collections.emptyList());
            return new C7367(c6921, this.f21369, Collections.unmodifiableList(arrayList2), Collections.unmodifiableList(arrayList), executorMo10968, false);
        }
    }

    public C7367(InterfaceC6868.InterfaceC6869 interfaceC6869, C6908 c6908, List<InterfaceC7320.AbstractC7321> list, List<InterfaceC7311.AbstractC7312> list2, @Nullable Executor executor, boolean z) {
        this.f21359 = interfaceC6869;
        this.f21360 = c6908;
        this.f21361 = list;
        this.f21362 = list2;
        this.f21363 = z;
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public <T> T m10978(Class<T> cls) {
        if (!cls.isInterface()) {
            throw new IllegalArgumentException("API declarations must be interfaces.");
        }
        ArrayDeque arrayDeque = new ArrayDeque(1);
        arrayDeque.add(cls);
        while (!arrayDeque.isEmpty()) {
            Class<T> cls2 = (Class) arrayDeque.removeFirst();
            if (cls2.getTypeParameters().length != 0) {
                StringBuilder sb = new StringBuilder("Type parameters are unsupported on ");
                sb.append(cls2.getName());
                if (cls2 != cls) {
                    sb.append(" which is an interface of ");
                    sb.append(cls.getName());
                }
                throw new IllegalArgumentException(sb.toString());
            }
            Collections.addAll(arrayDeque, cls2.getInterfaces());
        }
        if (this.f21363) {
            C7359 c7359 = C7359.f21301;
            for (Method method : cls.getDeclaredMethods()) {
                if (!(c7359.f21302 && method.isDefault()) && !Modifier.isStatic(method.getModifiers())) {
                    m10981(method);
                }
            }
        }
        return (T) Proxy.newProxyInstance(cls.getClassLoader(), new Class[]{cls}, new C7368(cls));
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public InterfaceC7311<?, ?> m10979(Type type, Annotation[] annotationArr) {
        Objects.requireNonNull(type, "returnType == null");
        Objects.requireNonNull(annotationArr, "annotations == null");
        int iIndexOf = this.f21362.indexOf(null) + 1;
        int size = this.f21362.size();
        for (int i = iIndexOf; i < size; i++) {
            InterfaceC7311<?, ?> interfaceC7311Mo10956 = this.f21362.get(i).mo10956(type, annotationArr, this);
            if (interfaceC7311Mo10956 != null) {
                return interfaceC7311Mo10956;
            }
        }
        StringBuilder sb = new StringBuilder("Could not locate call adapter for ");
        sb.append(type);
        sb.append(".\n");
        sb.append("  Tried:");
        int size2 = this.f21362.size();
        while (iIndexOf < size2) {
            sb.append("\n   * ");
            sb.append(this.f21362.get(iIndexOf).getClass().getName());
            iIndexOf++;
        }
        throw new IllegalArgumentException(sb.toString());
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public <T> InterfaceC7320<T, AbstractC6930> m10980(Type type, Annotation[] annotationArr, Annotation[] annotationArr2) {
        Objects.requireNonNull(type, "type == null");
        Objects.requireNonNull(annotationArr, "parameterAnnotations == null");
        Objects.requireNonNull(annotationArr2, "methodAnnotations == null");
        int iIndexOf = this.f21361.indexOf(null) + 1;
        int size = this.f21361.size();
        for (int i = iIndexOf; i < size; i++) {
            InterfaceC7320<T, AbstractC6930> interfaceC7320 = (InterfaceC7320<T, AbstractC6930>) this.f21361.get(i).mo10948(type, annotationArr, annotationArr2, this);
            if (interfaceC7320 != null) {
                return interfaceC7320;
            }
        }
        StringBuilder sb = new StringBuilder("Could not locate RequestBody converter for ");
        sb.append(type);
        sb.append(".\n");
        sb.append("  Tried:");
        int size2 = this.f21361.size();
        while (iIndexOf < size2) {
            sb.append("\n   * ");
            sb.append(this.f21361.get(iIndexOf).getClass().getName());
            iIndexOf++;
        }
        throw new IllegalArgumentException(sb.toString());
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public AbstractC7370<?> m10981(Method method) {
        AbstractC7370<?> abstractC7370M10986;
        AbstractC7370<?> abstractC7370 = this.f21358.get(method);
        if (abstractC7370 != null) {
            return abstractC7370;
        }
        synchronized (this.f21358) {
            abstractC7370M10986 = this.f21358.get(method);
            if (abstractC7370M10986 == null) {
                abstractC7370M10986 = AbstractC7370.m10986(this, method);
                this.f21358.put(method, abstractC7370M10986);
            }
        }
        return abstractC7370M10986;
    }

    /* JADX INFO: renamed from: ؠ, reason: contains not printable characters */
    public <T> InterfaceC7320<AbstractC6936, T> m10982(Type type, Annotation[] annotationArr) {
        Objects.requireNonNull(type, "type == null");
        Objects.requireNonNull(annotationArr, "annotations == null");
        int iIndexOf = this.f21361.indexOf(null) + 1;
        int size = this.f21361.size();
        for (int i = iIndexOf; i < size; i++) {
            InterfaceC7320<AbstractC6936, T> interfaceC7320 = (InterfaceC7320<AbstractC6936, T>) this.f21361.get(i).mo10947(type, annotationArr, this);
            if (interfaceC7320 != null) {
                return interfaceC7320;
            }
        }
        StringBuilder sb = new StringBuilder("Could not locate ResponseBody converter for ");
        sb.append(type);
        sb.append(".\n");
        sb.append("  Tried:");
        int size2 = this.f21361.size();
        while (iIndexOf < size2) {
            sb.append("\n   * ");
            sb.append(this.f21361.get(iIndexOf).getClass().getName());
            iIndexOf++;
        }
        throw new IllegalArgumentException(sb.toString());
    }

    /* JADX INFO: renamed from: ހ, reason: contains not printable characters */
    public <T> InterfaceC7320<T, String> m10983(Type type, Annotation[] annotationArr) {
        Objects.requireNonNull(type, "type == null");
        Objects.requireNonNull(annotationArr, "annotations == null");
        int size = this.f21361.size();
        for (int i = 0; i < size; i++) {
            if (this.f21361.get(i) == null) {
                throw null;
            }
        }
        return C7303.C7307.f21213;
    }
}