package s7;

import android.util.Log;
import d3.C;
import java.io.IOException;
import java.lang.reflect.Method;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.security.GeneralSecurityException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.Security;
import java.security.cert.X509Certificate;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocket;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import javax.net.ssl.TrustManagerFactory;
import javax.net.ssl.X509TrustManager;
import k7.w;

/* JADX INFO: loaded from: classes.dex */
public class n {

    /* JADX INFO: renamed from: a, reason: collision with root package name */
    public static volatile n f16942a;

    /* JADX INFO: renamed from: b, reason: collision with root package name */
    public static final Logger f16943b;

    /* JADX WARN: Removed duplicated region for block: B:34:0x0094 A[PHI: r2
      0x0094: PHI (r2v26 s7.n) = (r2v15 s7.n), (r2v20 s7.n), (r2v24 s7.n), (r2v29 s7.n) binds: [B:55:0x00e2, B:49:0x00d4, B:41:0x00b4, B:33:0x0092] A[DONT_GENERATE, DONT_INLINE]] */
    /* JADX WARN: Removed duplicated region for block: B:35:0x0097  */
    /* JADX WARN: Removed duplicated region for block: B:43:0x00b7  */
    /* JADX WARN: Removed duplicated region for block: B:51:0x00d7  */
    static {
        n kVar;
        n nVar;
        if (C.n()) {
            for (Map.Entry entry : t7.c.f17030b.entrySet()) {
                String str = (String) entry.getKey();
                String str2 = (String) entry.getValue();
                Logger logger = Logger.getLogger(str);
                if (t7.c.f17029a.add(logger)) {
                    logger.setUseParentHandlers(false);
                    logger.setLevel(Log.isLoggable(str2, 3) ? Level.FINE : Log.isLoggable(str2, 4) ? Level.INFO : Level.WARNING);
                    logger.addHandler(t7.d.f17031a);
                }
            }
            nVar = a.f16908d ? new a() : null;
            if (nVar == null) {
                jVar = c.f16912e ? new c() : null;
                P6.g.b(jVar);
            }
        } else if ("Conscrypt".equals(Security.getProviders()[0].getName())) {
            kVar = h.f16924d ? new h() : null;
            if (kVar != null) {
            }
        } else if ("BC".equals(Security.getProviders()[0].getName())) {
            kVar = e.f16921d ? new e() : null;
            if (kVar != null) {
            }
        } else if ("OpenJSSE".equals(Security.getProviders()[0].getName())) {
            kVar = m.f16940d ? new m() : null;
            if (kVar != null) {
            }
        } else {
            kVar = k.f16934c ? new k() : null;
            if (kVar != null) {
                nVar = kVar;
            } else {
                String property = System.getProperty("java.specification.version", "unknown");
                try {
                    P6.g.d(property, "jvmVersion");
                } catch (NumberFormatException unused) {
                }
                if (Integer.parseInt(property) < 9) {
                    try {
                        Class<?> cls = Class.forName("org.eclipse.jetty.alpn.ALPN", true, null);
                        Class<?> cls2 = Class.forName("org.eclipse.jetty.alpn.ALPN$Provider", true, null);
                        Class<?> cls3 = Class.forName("org.eclipse.jetty.alpn.ALPN$ClientProvider", true, null);
                        Class<?> cls4 = Class.forName("org.eclipse.jetty.alpn.ALPN$ServerProvider", true, null);
                        Method method = cls.getMethod("put", SSLSocket.class, cls2);
                        Method method2 = cls.getMethod("get", SSLSocket.class);
                        Method method3 = cls.getMethod("remove", SSLSocket.class);
                        P6.g.d(method, "putMethod");
                        P6.g.d(method2, "getMethod");
                        P6.g.d(method3, "removeMethod");
                        P6.g.d(cls3, "clientProviderClass");
                        P6.g.d(cls4, "serverProviderClass");
                        jVar = new j(method, method2, method3, cls3, cls4);
                    } catch (ClassNotFoundException | NoSuchMethodException unused2) {
                    }
                }
                nVar = jVar != null ? jVar : new n();
            }
        }
        f16942a = nVar;
        f16943b = Logger.getLogger(w.class.getName());
    }

    public static void i(String str, int i, Throwable th) {
        P6.g.e(str, "message");
        f16943b.log(i == 5 ? Level.WARNING : Level.INFO, str, th);
    }

    public W3.b b(X509TrustManager x509TrustManager) {
        return new w7.a(c(x509TrustManager));
    }

    public w7.d c(X509TrustManager x509TrustManager) {
        X509Certificate[] acceptedIssuers = x509TrustManager.getAcceptedIssuers();
        P6.g.d(acceptedIssuers, "trustManager.acceptedIssuers");
        return new w7.b((X509Certificate[]) Arrays.copyOf(acceptedIssuers, acceptedIssuers.length));
    }

    public void d(SSLSocket sSLSocket, String str, List list) {
        P6.g.e(list, "protocols");
    }

    public void e(Socket socket, InetSocketAddress inetSocketAddress, int i) throws IOException {
        P6.g.e(inetSocketAddress, "address");
        socket.connect(inetSocketAddress, i);
    }

    public String f(SSLSocket sSLSocket) {
        return null;
    }

    public Object g() {
        if (f16943b.isLoggable(Level.FINE)) {
            return new Throwable("response.body().close()");
        }
        return null;
    }

    public boolean h(String str) {
        P6.g.e(str, "hostname");
        return true;
    }

    public void j(Object obj, String str) {
        P6.g.e(str, "message");
        if (obj == null) {
            str = str.concat(" To see where this was allocated, set the OkHttpClient logger level to FINE: Logger.getLogger(OkHttpClient.class.getName()).setLevel(Level.FINE);");
        }
        i(str, 5, (Throwable) obj);
    }

    public SSLContext k() throws NoSuchAlgorithmException {
        SSLContext sSLContext = SSLContext.getInstance("TLS");
        P6.g.d(sSLContext, "getInstance(\"TLS\")");
        return sSLContext;
    }

    public SSLSocketFactory l(X509TrustManager x509TrustManager) {
        try {
            SSLContext sSLContextK = k();
            sSLContextK.init(null, new TrustManager[]{x509TrustManager}, null);
            SSLSocketFactory socketFactory = sSLContextK.getSocketFactory();
            P6.g.d(socketFactory, "newSSLContext().apply {\n…ll)\n      }.socketFactory");
            return socketFactory;
        } catch (GeneralSecurityException e8) {
            throw new AssertionError("No System TLS: " + e8, e8);
        }
    }

    public X509TrustManager m() throws NoSuchAlgorithmException, KeyStoreException {
        TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
        trustManagerFactory.init((KeyStore) null);
        TrustManager[] trustManagers = trustManagerFactory.getTrustManagers();
        P6.g.b(trustManagers);
        if (trustManagers.length == 1) {
            TrustManager trustManager = trustManagers[0];
            if (trustManager instanceof X509TrustManager) {
                P6.g.c(trustManager, "null cannot be cast to non-null type javax.net.ssl.X509TrustManager");
                return (X509TrustManager) trustManager;
            }
        }
        String string = Arrays.toString(trustManagers);
        P6.g.d(string, "toString(this)");
        throw new IllegalStateException("Unexpected default trust managers: ".concat(string).toString());
    }

    public final String toString() {
        return getClass().getSimpleName();
    }

    public void a(SSLSocket sSLSocket) {
    }
}