package p447;

import java.io.InterruptedIOException;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.Iterator;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import p138.p139.p143.p144.C2803;
import p402.p411.p413.C6635;
import p447.p448.C6943;
import p447.p448.ThreadFactoryC6942;
import p447.p448.p452.C6964;

/* JADX INFO: renamed from: ސ.ގ, reason: contains not printable characters */
/* JADX INFO: loaded from: classes.dex */
public final class C6890 {

    /* JADX INFO: renamed from: ހ, reason: contains not printable characters */
    public ExecutorService f19989;

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public int f19987 = 64;

    /* JADX INFO: renamed from: ؠ, reason: contains not printable characters */
    public int f19988 = 5;

    /* JADX INFO: renamed from: ށ, reason: contains not printable characters */
    public final ArrayDeque<C6964.RunnableC6965> f19990 = new ArrayDeque<>();

    /* JADX INFO: renamed from: ނ, reason: contains not printable characters */
    public final ArrayDeque<C6964.RunnableC6965> f19991 = new ArrayDeque<>();

    /* JADX INFO: renamed from: ރ, reason: contains not printable characters */
    public final ArrayDeque<C6964> f19992 = new ArrayDeque<>();

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public final synchronized ExecutorService m10050() {
        ExecutorService executorService;
        if (this.f19989 == null) {
            TimeUnit timeUnit = TimeUnit.SECONDS;
            SynchronousQueue synchronousQueue = new SynchronousQueue();
            String str = C6943.f20197 + " Dispatcher";
            if (str == null) {
                C6635.m9824("name");
                throw null;
            }
            this.f19989 = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, timeUnit, synchronousQueue, new ThreadFactoryC6942(str, false));
        }
        executorService = this.f19989;
        if (executorService == null) {
            C6635.m9822();
            throw null;
        }
        return executorService;
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public final <T> void m10051(Deque<T> deque, T t) {
        synchronized (this) {
            if (!deque.remove(t)) {
                throw new AssertionError("Call wasn't in-flight!");
            }
        }
        m10055();
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public final void m10052(C6964.RunnableC6965 runnableC6965) {
        C6964.RunnableC6965 next;
        C6964.RunnableC6965 runnableC69652 = null;
        if (runnableC6965 == null) {
            C6635.m9824("call");
            throw null;
        }
        synchronized (this) {
            this.f19990.add(runnableC6965);
            if (!runnableC6965.f20280.f20277) {
                String strM10224 = runnableC6965.m10224();
                Iterator<C6964.RunnableC6965> it = this.f19991.iterator();
                while (true) {
                    if (it.hasNext()) {
                        next = it.next();
                        if (C6635.m9825((Object) next.m10224(), (Object) strM10224)) {
                            break;
                        }
                    } else {
                        Iterator<C6964.RunnableC6965> it2 = this.f19990.iterator();
                        while (it2.hasNext()) {
                            next = it2.next();
                            if (C6635.m9825((Object) next.m10224(), (Object) strM10224)) {
                            }
                        }
                    }
                }
                runnableC69652 = next;
                if (runnableC69652 != null) {
                    runnableC6965.f20278 = runnableC69652.f20278;
                }
            }
        }
        m10055();
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public final synchronized void m10053(C6964 c6964) {
        if (c6964 == null) {
            C6635.m9824("call");
            throw null;
        }
        this.f19992.add(c6964);
    }

    /* JADX INFO: renamed from: ؠ, reason: contains not printable characters */
    public final void m10054(C6964.RunnableC6965 runnableC6965) {
        if (runnableC6965 == null) {
            C6635.m9824("call");
            throw null;
        }
        runnableC6965.f20278.decrementAndGet();
        m10051(this.f19991, runnableC6965);
    }

    /* JADX INFO: renamed from: ؠ, reason: contains not printable characters */
    public final boolean m10055() {
        int i;
        boolean z;
        if (C6943.f20196 && Thread.holdsLock(this)) {
            StringBuilder sbM4889 = C2803.m4889("Thread ");
            Thread threadCurrentThread = Thread.currentThread();
            C6635.m9823((Object) threadCurrentThread, "Thread.currentThread()");
            sbM4889.append(threadCurrentThread.getName());
            sbM4889.append(" MUST NOT hold lock on ");
            sbM4889.append(this);
            throw new AssertionError(sbM4889.toString());
        }
        ArrayList arrayList = new ArrayList();
        synchronized (this) {
            Iterator<C6964.RunnableC6965> it = this.f19990.iterator();
            C6635.m9823((Object) it, "readyAsyncCalls.iterator()");
            while (it.hasNext()) {
                C6964.RunnableC6965 next = it.next();
                if (this.f19991.size() >= this.f19987) {
                    break;
                }
                if (next.f20278.get() < this.f19988) {
                    it.remove();
                    next.f20278.incrementAndGet();
                    C6635.m9823((Object) next, "asyncCall");
                    arrayList.add(next);
                    this.f19991.add(next);
                }
            }
            z = m10056() > 0;
        }
        int size = arrayList.size();
        for (i = 0; i < size; i++) {
            C6964.RunnableC6965 runnableC6965 = (C6964.RunnableC6965) arrayList.get(i);
            ExecutorService executorServiceM10050 = m10050();
            if (executorServiceM10050 == null) {
                C6635.m9824("executorService");
                throw null;
            }
            C6890 c6890 = runnableC6965.f20280.f20275.f20058;
            if (C6943.f20196 && Thread.holdsLock(c6890)) {
                StringBuilder sbM48892 = C2803.m4889("Thread ");
                Thread threadCurrentThread2 = Thread.currentThread();
                C6635.m9823((Object) threadCurrentThread2, "Thread.currentThread()");
                sbM48892.append(threadCurrentThread2.getName());
                sbM48892.append(" MUST NOT hold lock on ");
                sbM48892.append(c6890);
                throw new AssertionError(sbM48892.toString());
            }
            try {
                try {
                    executorServiceM10050.execute(runnableC6965);
                } catch (RejectedExecutionException e) {
                    InterruptedIOException interruptedIOException = new InterruptedIOException("executor rejected");
                    interruptedIOException.initCause(e);
                    runnableC6965.f20280.m10215(interruptedIOException);
                    runnableC6965.f20279.mo4971(runnableC6965.f20280, interruptedIOException);
                    runnableC6965.f20280.f20275.f20058.m10054(runnableC6965);
                }
            } catch (Throwable th) {
                runnableC6965.f20280.f20275.f20058.m10054(runnableC6965);
                throw th;
            }
        }
        return z;
    }

    /* JADX INFO: renamed from: ހ, reason: contains not printable characters */
    public final synchronized int m10056() {
        return this.f19991.size() + this.f19992.size();
    }
}