package com.google.firebase.crashlytics.internal.concurrency;

import J0.RunnableC0371m;
import com.google.android.gms.tasks.Continuation;
import com.google.android.gms.tasks.SuccessContinuation;
import com.google.android.gms.tasks.Task;
import com.google.android.gms.tasks.Tasks;
import com.google.firebase.firestore.LoadBundleTask;
import java.util.concurrent.Callable;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

/* JADX INFO: loaded from: classes3.dex */
public class CrashlyticsWorker implements Executor {
    private final ExecutorService executor;
    private final Object tailLock = new Object();
    private Task<?> tail = Tasks.forResult(null);

    public CrashlyticsWorker(ExecutorService executorService) {
        this.executor = executorService;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ void lambda$await$6() {
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ Task lambda$submit$0(Callable callable, Task task) {
        return Tasks.forResult(callable.call());
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ Task lambda$submit$1(Runnable runnable, Task task) {
        runnable.run();
        return Tasks.forResult(null);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ Task lambda$submitTask$2(Callable callable, Task task) {
        return (Task) callable.call();
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ Task lambda$submitTask$3(Callable callable, Task task) {
        return (Task) callable.call();
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ Task lambda$submitTaskOnSuccess$4(Callable callable, Task task) {
        return (Task) callable.call();
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ Task lambda$submitTaskOnSuccess$5(SuccessContinuation successContinuation, Task task) {
        return task.isSuccessful() ? successContinuation.then(task.getResult()) : task.getException() != null ? Tasks.forException(task.getException()) : Tasks.forCanceled();
    }

    public void await() throws InterruptedException, TimeoutException {
        Tasks.await(submit(new RunnableC0371m(3)), 30L, TimeUnit.SECONDS);
        Thread.sleep(1L);
    }

    @Override // java.util.concurrent.Executor
    public void execute(Runnable runnable) {
        this.executor.execute(runnable);
    }

    public ExecutorService getExecutor() {
        return this.executor;
    }

    public <T> Task<T> submit(Callable<T> callable) {
        LoadBundleTask loadBundleTask;
        synchronized (this.tailLock) {
            loadBundleTask = (Task<T>) this.tail.continueWithTask(this.executor, new b(callable, 0));
            this.tail = loadBundleTask;
        }
        return loadBundleTask;
    }

    public <T> Task<T> submitTask(Callable<Task<T>> callable) {
        LoadBundleTask loadBundleTask;
        synchronized (this.tailLock) {
            loadBundleTask = (Task<T>) this.tail.continueWithTask(this.executor, new b(callable, 1));
            this.tail = loadBundleTask;
        }
        return loadBundleTask;
    }

    public <T, R> Task<R> submitTaskOnSuccess(Callable<Task<T>> callable, SuccessContinuation<T, R> successContinuation) {
        LoadBundleTask loadBundleTask;
        synchronized (this.tailLock) {
            loadBundleTask = (Task<R>) this.tail.continueWithTask(this.executor, new b(callable, 3)).continueWithTask(this.executor, new K1.b(successContinuation, 20));
            this.tail = loadBundleTask;
        }
        return loadBundleTask;
    }

    public Task<Void> submit(Runnable runnable) {
        Task taskContinueWithTask;
        synchronized (this.tailLock) {
            taskContinueWithTask = this.tail.continueWithTask(this.executor, new K1.b(runnable, 19));
            this.tail = taskContinueWithTask;
        }
        return taskContinueWithTask;
    }

    public <T, R> Task<R> submitTask(Callable<Task<T>> callable, Continuation<T, Task<R>> continuation) {
        LoadBundleTask loadBundleTask;
        synchronized (this.tailLock) {
            loadBundleTask = (Task<R>) this.tail.continueWithTask(this.executor, new b(callable, 2)).continueWithTask(this.executor, continuation);
            this.tail = loadBundleTask;
        }
        return loadBundleTask;
    }
}