package f;

import f.y;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import javax.annotation.Nullable;
import okhttp3.Call;
import okhttp3.Response;
import okhttp3.ResponseBody;

/* JADX INFO: compiled from: HttpServiceMethod.java */
/* JADX INFO: loaded from: classes.dex */
abstract class k<ResponseT, ReturnT> extends v<ReturnT> {

    /* JADX INFO: renamed from: a, reason: collision with root package name */
    private final s f1650a;

    /* JADX INFO: renamed from: b, reason: collision with root package name */
    private final Call.Factory f1651b;

    /* JADX INFO: renamed from: c, reason: collision with root package name */
    private final h<ResponseBody, ResponseT> f1652c;

    /* JADX INFO: compiled from: HttpServiceMethod.java */
    static final class a<ResponseT, ReturnT> extends k<ResponseT, ReturnT> {

        /* JADX INFO: renamed from: d, reason: collision with root package name */
        private final e<ResponseT, ReturnT> f1653d;

        a(s sVar, Call.Factory factory, h<ResponseBody, ResponseT> hVar, e<ResponseT, ReturnT> eVar) {
            super(sVar, factory, hVar);
            this.f1653d = eVar;
        }

        @Override // f.k
        protected ReturnT c(d<ResponseT> dVar, Object[] objArr) {
            return this.f1653d.b(dVar);
        }
    }

    /* JADX INFO: compiled from: HttpServiceMethod.java */
    static final class b<ResponseT> extends k<ResponseT, Object> {

        /* JADX INFO: renamed from: d, reason: collision with root package name */
        private final e<ResponseT, d<ResponseT>> f1654d;

        /* JADX INFO: renamed from: e, reason: collision with root package name */
        private final boolean f1655e;

        b(s sVar, Call.Factory factory, h<ResponseBody, ResponseT> hVar, e<ResponseT, d<ResponseT>> eVar, boolean z) {
            super(sVar, factory, hVar);
            this.f1654d = eVar;
            this.f1655e = z;
        }

        @Override // f.k
        protected Object c(d<ResponseT> dVar, Object[] objArr) {
            d<ResponseT> dVarB = this.f1654d.b(dVar);
            c.n.a aVar = (c.n.a) objArr[objArr.length - 1];
            try {
                return this.f1655e ? m.b(dVarB, aVar) : m.a(dVarB, aVar);
            } catch (Exception e2) {
                return m.d(e2, aVar);
            }
        }
    }

    /* JADX INFO: compiled from: HttpServiceMethod.java */
    static final class c<ResponseT> extends k<ResponseT, Object> {

        /* JADX INFO: renamed from: d, reason: collision with root package name */
        private final e<ResponseT, d<ResponseT>> f1656d;

        c(s sVar, Call.Factory factory, h<ResponseBody, ResponseT> hVar, e<ResponseT, d<ResponseT>> eVar) {
            super(sVar, factory, hVar);
            this.f1656d = eVar;
        }

        @Override // f.k
        protected Object c(d<ResponseT> dVar, Object[] objArr) {
            d<ResponseT> dVarB = this.f1656d.b(dVar);
            c.n.a aVar = (c.n.a) objArr[objArr.length - 1];
            try {
                return m.c(dVarB, aVar);
            } catch (Exception e2) {
                return m.d(e2, aVar);
            }
        }
    }

    k(s sVar, Call.Factory factory, h<ResponseBody, ResponseT> hVar) {
        this.f1650a = sVar;
        this.f1651b = factory;
        this.f1652c = hVar;
    }

    private static <ResponseT, ReturnT> e<ResponseT, ReturnT> d(u uVar, Method method, Type type, Annotation[] annotationArr) {
        try {
            return (e<ResponseT, ReturnT>) uVar.a(type, annotationArr);
        } catch (RuntimeException e2) {
            throw y.n(method, e2, "Unable to create call adapter for %s", type);
        }
    }

    private static <ResponseT> h<ResponseBody, ResponseT> e(u uVar, Method method, Type type) {
        try {
            return uVar.h(type, method.getAnnotations());
        } catch (RuntimeException e2) {
            throw y.n(method, e2, "Unable to create converter for %s", type);
        }
    }

    static <ResponseT, ReturnT> k<ResponseT, ReturnT> f(u uVar, Method method, s sVar) {
        Type genericReturnType;
        boolean z;
        boolean z2 = sVar.k;
        Annotation[] annotations = method.getAnnotations();
        if (z2) {
            Type[] genericParameterTypes = method.getGenericParameterTypes();
            Type typeF = y.f(0, (ParameterizedType) genericParameterTypes[genericParameterTypes.length - 1]);
            if (y.h(typeF) == t.class && (typeF instanceof ParameterizedType)) {
                typeF = y.g(0, (ParameterizedType) typeF);
                z = true;
            } else {
                z = false;
            }
            genericReturnType = new y.b(null, d.class, typeF);
            annotations = x.a(annotations);
        } else {
            genericReturnType = method.getGenericReturnType();
            z = false;
        }
        e eVarD = d(uVar, method, genericReturnType, annotations);
        Type typeA = eVarD.a();
        if (typeA == Response.class) {
            throw y.m(method, "'" + y.h(typeA).getName() + "' is not a valid response body type. Did you mean ResponseBody?", new Object[0]);
        }
        if (typeA == t.class) {
            throw y.m(method, "Response must include generic type (e.g., Response<String>)", new Object[0]);
        }
        if (sVar.f1735c.equals("HEAD") && !Void.class.equals(typeA)) {
            throw y.m(method, "HEAD method must use Void as response type.", new Object[0]);
        }
        h hVarE = e(uVar, method, typeA);
        Call.Factory factory = uVar.f1748b;
        return !z2 ? new a(sVar, factory, hVarE, eVarD) : z ? new c(sVar, factory, hVarE, eVarD) : new b(sVar, factory, hVarE, eVarD, false);
    }

    @Override // f.v
    @Nullable
    final ReturnT a(Object[] objArr) {
        return c(new n(this.f1650a, objArr, this.f1651b, this.f1652c), objArr);
    }

    @Nullable
    protected abstract ReturnT c(d<ResponseT> dVar, Object[] objArr);
}