package F1;

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;

/* JADX INFO: renamed from: F1.v, reason: case insensitive filesystem */
/* JADX INFO: loaded from: classes.dex */
public final class C0140v extends AbstractC0120f0 {
    private static volatile Executor pool;

    /* JADX INFO: renamed from: r, reason: collision with root package name */
    public static final C0140v f649r = new C0140v();

    /* JADX INFO: renamed from: x, reason: collision with root package name */
    private static final int f650x;

    /* JADX INFO: renamed from: y, reason: collision with root package name */
    private static boolean f651y;

    static {
        String property;
        int iIntValue;
        try {
            property = System.getProperty("kotlinx.coroutines.default.parallelism");
        } catch (Throwable unused) {
            property = null;
        }
        if (property == null) {
            iIntValue = -1;
        } else {
            Integer numF = E1.g.f(property);
            if (numF == null || numF.intValue() < 1) {
                throw new IllegalStateException(kotlin.jvm.internal.l.l("Expected positive number in kotlinx.coroutines.default.parallelism, but has ", property).toString());
            }
            iIntValue = numF.intValue();
        }
        f650x = iIntValue;
    }

    private C0140v() {
    }

    private final ExecutorService A() {
        final AtomicInteger atomicInteger = new AtomicInteger();
        return Executors.newFixedThreadPool(G(), new ThreadFactory() { // from class: F1.t
            @Override // java.util.concurrent.ThreadFactory
            public final Thread newThread(Runnable runnable) {
                return C0140v.C(atomicInteger, runnable);
            }
        });
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final Thread C(AtomicInteger atomicInteger, Runnable runnable) {
        Thread thread = new Thread(runnable, kotlin.jvm.internal.l.l("CommonPool-worker-", Integer.valueOf(atomicInteger.incrementAndGet())));
        thread.setDaemon(true);
        return thread;
    }

    private final ExecutorService D() {
        Class<?> cls;
        Object objInvoke;
        if (System.getSecurityManager() != null) {
            return A();
        }
        ExecutorService executorService = null;
        try {
            cls = Class.forName("java.util.concurrent.ForkJoinPool");
        } catch (Throwable unused) {
            cls = null;
        }
        if (cls == null) {
            return A();
        }
        if (!f651y && f650x < 0) {
            try {
                objInvoke = cls.getMethod("commonPool", null).invoke(null, null);
            } catch (Throwable unused2) {
            }
            ExecutorService executorService2 = objInvoke instanceof ExecutorService ? (ExecutorService) objInvoke : null;
            if (executorService2 != null) {
                if (!f649r.H(cls, executorService2)) {
                    executorService2 = null;
                }
                if (executorService2 != null) {
                    return executorService2;
                }
            }
        }
        try {
            Object objNewInstance = cls.getConstructor(Integer.TYPE).newInstance(Integer.valueOf(f649r.G()));
            if (objNewInstance instanceof ExecutorService) {
                executorService = (ExecutorService) objNewInstance;
            }
        } catch (Throwable unused3) {
        }
        return executorService == null ? A() : executorService;
    }

    private final synchronized Executor F() {
        Executor executorD;
        executorD = pool;
        if (executorD == null) {
            executorD = D();
            pool = executorD;
        }
        return executorD;
    }

    private final int G() {
        Integer numValueOf = Integer.valueOf(f650x);
        if (numValueOf.intValue() <= 0) {
            numValueOf = null;
        }
        return numValueOf == null ? kotlin.ranges.m.b(Runtime.getRuntime().availableProcessors() - 1, 1) : numValueOf.intValue();
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final void I() {
    }

    public final boolean H(Class cls, ExecutorService executorService) {
        executorService.submit(new Runnable() { // from class: F1.u
            @Override // java.lang.Runnable
            public final void run() {
                C0140v.I();
            }
        });
        Integer num = null;
        try {
            Object objInvoke = cls.getMethod("getPoolSize", null).invoke(executorService, null);
            if (objInvoke instanceof Integer) {
                num = (Integer) objInvoke;
            }
        } catch (Throwable unused) {
        }
        return num != null && num.intValue() >= 1;
    }

    @Override // java.io.Closeable, java.lang.AutoCloseable
    public void close() {
        throw new IllegalStateException("Close cannot be invoked on CommonPool");
    }

    @Override // F1.E
    public String toString() {
        return "CommonPool";
    }

    @Override // F1.E
    public void u(q1.g gVar, Runnable runnable) {
        try {
            Executor executorF = pool;
            if (executorF == null) {
                executorF = F();
            }
            AbstractC0113c.a();
            executorF.execute(runnable);
        } catch (RejectedExecutionException unused) {
            AbstractC0113c.a();
            M.f587I.X(runnable);
        }
    }
}