package androidx.concurrent.futures;

import java.util.Locale;
import java.util.concurrent.CancellationException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
import java.util.concurrent.Future;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
import java.util.concurrent.locks.LockSupport;
import java.util.logging.Level;
import java.util.logging.Logger;

/* loaded from: classes.dex */
public abstract class a implements v3.a {

    /* renamed from: d, reason: collision with root package name */
    static final boolean f1314d = Boolean.parseBoolean(System.getProperty("guava.concurrent.generate_cancellation_cause", "false"));

    /* renamed from: e, reason: collision with root package name */
    private static final Logger f1315e = Logger.getLogger(a.class.getName());

    /* renamed from: f, reason: collision with root package name */
    static final b f1316f;

    /* renamed from: g, reason: collision with root package name */
    private static final Object f1317g;

    /* renamed from: a, reason: collision with root package name */
    volatile Object f1318a;

    /* renamed from: b, reason: collision with root package name */
    volatile e f1319b;

    /* renamed from: c, reason: collision with root package name */
    volatile h f1320c;

    private static abstract class b {
        private b() {
        }

        abstract boolean a(a aVar, e eVar, e eVar2);

        abstract boolean b(a aVar, Object obj, Object obj2);

        abstract boolean c(a aVar, h hVar, h hVar2);

        abstract void d(h hVar, h hVar2);

        abstract void e(h hVar, Thread thread);
    }

    private static final class c {

        /* renamed from: c, reason: collision with root package name */
        static final c f1321c;

        /* renamed from: d, reason: collision with root package name */
        static final c f1322d;

        /* renamed from: a, reason: collision with root package name */
        final boolean f1323a;

        /* renamed from: b, reason: collision with root package name */
        final Throwable f1324b;

        static {
            if (a.f1314d) {
                f1322d = null;
                f1321c = null;
            } else {
                f1322d = new c(false, null);
                f1321c = new c(true, null);
            }
        }

        c(boolean z10, Throwable th) {
            this.f1323a = z10;
            this.f1324b = th;
        }
    }

    private static final class d {

        /* renamed from: b, reason: collision with root package name */
        static final d f1325b = new d(new C0015a("Failure occurred while trying to finish a future."));

        /* renamed from: a, reason: collision with root package name */
        final Throwable f1326a;

        /* renamed from: androidx.concurrent.futures.a$d$a, reason: collision with other inner class name */
        class C0015a extends Throwable {
            C0015a(String str) {
                super(str);
            }

            @Override // java.lang.Throwable
            public synchronized Throwable fillInStackTrace() {
                return this;
            }
        }

        d(Throwable th) {
            this.f1326a = (Throwable) a.e(th);
        }
    }

    private static final class e {

        /* renamed from: d, reason: collision with root package name */
        static final e f1327d = new e(null, null);

        /* renamed from: a, reason: collision with root package name */
        final Runnable f1328a;

        /* renamed from: b, reason: collision with root package name */
        final Executor f1329b;

        /* renamed from: c, reason: collision with root package name */
        e f1330c;

        e(Runnable runnable, Executor executor) {
            this.f1328a = runnable;
            this.f1329b = executor;
        }
    }

    private static final class f extends b {

        /* renamed from: a, reason: collision with root package name */
        final AtomicReferenceFieldUpdater f1331a;

        /* renamed from: b, reason: collision with root package name */
        final AtomicReferenceFieldUpdater f1332b;

        /* renamed from: c, reason: collision with root package name */
        final AtomicReferenceFieldUpdater f1333c;

        /* renamed from: d, reason: collision with root package name */
        final AtomicReferenceFieldUpdater f1334d;

        /* renamed from: e, reason: collision with root package name */
        final AtomicReferenceFieldUpdater f1335e;

        f(AtomicReferenceFieldUpdater atomicReferenceFieldUpdater, AtomicReferenceFieldUpdater atomicReferenceFieldUpdater2, AtomicReferenceFieldUpdater atomicReferenceFieldUpdater3, AtomicReferenceFieldUpdater atomicReferenceFieldUpdater4, AtomicReferenceFieldUpdater atomicReferenceFieldUpdater5) {
            super();
            this.f1331a = atomicReferenceFieldUpdater;
            this.f1332b = atomicReferenceFieldUpdater2;
            this.f1333c = atomicReferenceFieldUpdater3;
            this.f1334d = atomicReferenceFieldUpdater4;
            this.f1335e = atomicReferenceFieldUpdater5;
        }

        @Override // androidx.concurrent.futures.a.b
        boolean a(a aVar, e eVar, e eVar2) {
            return androidx.concurrent.futures.b.a(this.f1334d, aVar, eVar, eVar2);
        }

        @Override // androidx.concurrent.futures.a.b
        boolean b(a aVar, Object obj, Object obj2) {
            return androidx.concurrent.futures.b.a(this.f1335e, aVar, obj, obj2);
        }

        @Override // androidx.concurrent.futures.a.b
        boolean c(a aVar, h hVar, h hVar2) {
            return androidx.concurrent.futures.b.a(this.f1333c, aVar, hVar, hVar2);
        }

        @Override // androidx.concurrent.futures.a.b
        void d(h hVar, h hVar2) {
            this.f1332b.lazySet(hVar, hVar2);
        }

        @Override // androidx.concurrent.futures.a.b
        void e(h hVar, Thread thread) {
            this.f1331a.lazySet(hVar, thread);
        }
    }

    private static final class g extends b {
        g() {
            super();
        }

        @Override // androidx.concurrent.futures.a.b
        boolean a(a aVar, e eVar, e eVar2) {
            synchronized (aVar) {
                if (aVar.f1319b != eVar) {
                    return false;
                }
                aVar.f1319b = eVar2;
                return true;
            }
        }

        @Override // androidx.concurrent.futures.a.b
        boolean b(a aVar, Object obj, Object obj2) {
            synchronized (aVar) {
                if (aVar.f1318a != obj) {
                    return false;
                }
                aVar.f1318a = obj2;
                return true;
            }
        }

        @Override // androidx.concurrent.futures.a.b
        boolean c(a aVar, h hVar, h hVar2) {
            synchronized (aVar) {
                if (aVar.f1320c != hVar) {
                    return false;
                }
                aVar.f1320c = hVar2;
                return true;
            }
        }

        @Override // androidx.concurrent.futures.a.b
        void d(h hVar, h hVar2) {
            hVar.f1338b = hVar2;
        }

        @Override // androidx.concurrent.futures.a.b
        void e(h hVar, Thread thread) {
            hVar.f1337a = thread;
        }
    }

    private static final class h {

        /* renamed from: c, reason: collision with root package name */
        static final h f1336c = new h(false);

        /* renamed from: a, reason: collision with root package name */
        volatile Thread f1337a;

        /* renamed from: b, reason: collision with root package name */
        volatile h f1338b;

        h(boolean z10) {
        }

        void a(h hVar) {
            a.f1316f.d(this, hVar);
        }

        void b() {
            Thread thread = this.f1337a;
            if (thread != null) {
                this.f1337a = null;
                LockSupport.unpark(thread);
            }
        }

        h() {
            a.f1316f.e(this, Thread.currentThread());
        }
    }

    static {
        b gVar;
        try {
            gVar = new f(AtomicReferenceFieldUpdater.newUpdater(h.class, Thread.class, "a"), AtomicReferenceFieldUpdater.newUpdater(h.class, h.class, "b"), AtomicReferenceFieldUpdater.newUpdater(a.class, h.class, "c"), AtomicReferenceFieldUpdater.newUpdater(a.class, e.class, "b"), AtomicReferenceFieldUpdater.newUpdater(a.class, Object.class, "a"));
            th = null;
        } catch (Throwable th) {
            th = th;
            gVar = new g();
        }
        f1316f = gVar;
        if (th != null) {
            f1315e.log(Level.SEVERE, "SafeAtomicHelper is broken!", th);
        }
        f1317g = new Object();
    }

    protected a() {
    }

    private void b(StringBuilder sb) {
        try {
            Object j10 = j(this);
            sb.append("SUCCESS, result=[");
            sb.append(q(j10));
            sb.append("]");
        } catch (CancellationException unused) {
            sb.append("CANCELLED");
        } catch (RuntimeException e10) {
            sb.append("UNKNOWN, cause=[");
            sb.append(e10.getClass());
            sb.append(" thrown from get()]");
        } catch (ExecutionException e11) {
            sb.append("FAILURE, cause=[");
            sb.append(e11.getCause());
            sb.append("]");
        }
    }

    private static CancellationException d(String str, Throwable th) {
        CancellationException cancellationException = new CancellationException(str);
        cancellationException.initCause(th);
        return cancellationException;
    }

    static Object e(Object obj) {
        obj.getClass();
        return obj;
    }

    private e f(e eVar) {
        e eVar2;
        do {
            eVar2 = this.f1319b;
        } while (!f1316f.a(this, eVar2, e.f1327d));
        e eVar3 = eVar;
        e eVar4 = eVar2;
        while (eVar4 != null) {
            e eVar5 = eVar4.f1330c;
            eVar4.f1330c = eVar3;
            eVar3 = eVar4;
            eVar4 = eVar5;
        }
        return eVar3;
    }

    static void g(a aVar) {
        aVar.m();
        aVar.c();
        e f10 = aVar.f(null);
        while (f10 != null) {
            e eVar = f10.f1330c;
            h(f10.f1328a, f10.f1329b);
            f10 = eVar;
        }
    }

    private static void h(Runnable runnable, Executor executor) {
        try {
            executor.execute(runnable);
        } catch (RuntimeException e10) {
            f1315e.log(Level.SEVERE, "RuntimeException while executing runnable " + runnable + " with executor " + executor, (Throwable) e10);
        }
    }

    private Object i(Object obj) {
        if (obj instanceof c) {
            throw d("Task was cancelled.", ((c) obj).f1324b);
        }
        if (obj instanceof d) {
            throw new ExecutionException(((d) obj).f1326a);
        }
        if (obj == f1317g) {
            return null;
        }
        return obj;
    }

    static Object j(Future future) {
        Object obj;
        boolean z10 = false;
        while (true) {
            try {
                obj = future.get();
                break;
            } catch (InterruptedException unused) {
                z10 = true;
            } catch (Throwable th) {
                if (z10) {
                    Thread.currentThread().interrupt();
                }
                throw th;
            }
        }
        if (z10) {
            Thread.currentThread().interrupt();
        }
        return obj;
    }

    private void m() {
        h hVar;
        do {
            hVar = this.f1320c;
        } while (!f1316f.c(this, hVar, h.f1336c));
        while (hVar != null) {
            hVar.b();
            hVar = hVar.f1338b;
        }
    }

    private void n(h hVar) {
        hVar.f1337a = null;
        while (true) {
            h hVar2 = this.f1320c;
            if (hVar2 == h.f1336c) {
                return;
            }
            h hVar3 = null;
            while (hVar2 != null) {
                h hVar4 = hVar2.f1338b;
                if (hVar2.f1337a != null) {
                    hVar3 = hVar2;
                } else if (hVar3 != null) {
                    hVar3.f1338b = hVar4;
                    if (hVar3.f1337a == null) {
                        break;
                    }
                } else if (!f1316f.c(this, hVar2, hVar4)) {
                    break;
                }
                hVar2 = hVar4;
            }
            return;
        }
    }

    private String q(Object obj) {
        return obj == this ? "this future" : String.valueOf(obj);
    }

    @Override // v3.a
    public final void a(Runnable runnable, Executor executor) {
        e(runnable);
        e(executor);
        e eVar = this.f1319b;
        if (eVar != e.f1327d) {
            e eVar2 = new e(runnable, executor);
            do {
                eVar2.f1330c = eVar;
                if (f1316f.a(this, eVar, eVar2)) {
                    return;
                } else {
                    eVar = this.f1319b;
                }
            } while (eVar != e.f1327d);
        }
        h(runnable, executor);
    }

    protected void c() {
    }

    @Override // java.util.concurrent.Future
    public final boolean cancel(boolean z10) {
        Object obj = this.f1318a;
        if ((obj == null) | false) {
            if (f1316f.b(this, obj, f1314d ? new c(z10, new CancellationException("Future.cancel() was called.")) : z10 ? c.f1321c : c.f1322d)) {
                if (z10) {
                    k();
                }
                g(this);
                return true;
            }
        }
        return false;
    }

    @Override // java.util.concurrent.Future
    public final Object get(long j10, TimeUnit timeUnit) {
        long nanos = timeUnit.toNanos(j10);
        if (Thread.interrupted()) {
            throw new InterruptedException();
        }
        Object obj = this.f1318a;
        if ((obj != null) && true) {
            return i(obj);
        }
        long nanoTime = nanos > 0 ? System.nanoTime() + nanos : 0L;
        if (nanos >= 1000) {
            h hVar = this.f1320c;
            if (hVar != h.f1336c) {
                h hVar2 = new h();
                do {
                    hVar2.a(hVar);
                    if (f1316f.c(this, hVar, hVar2)) {
                        do {
                            LockSupport.parkNanos(this, nanos);
                            if (Thread.interrupted()) {
                                n(hVar2);
                                throw new InterruptedException();
                            }
                            Object obj2 = this.f1318a;
                            if ((obj2 != null) && true) {
                                return i(obj2);
                            }
                            nanos = nanoTime - System.nanoTime();
                        } while (nanos >= 1000);
                        n(hVar2);
                    } else {
                        hVar = this.f1320c;
                    }
                } while (hVar != h.f1336c);
            }
            return i(this.f1318a);
        }
        while (nanos > 0) {
            Object obj3 = this.f1318a;
            if ((obj3 != null) && true) {
                return i(obj3);
            }
            if (Thread.interrupted()) {
                throw new InterruptedException();
            }
            nanos = nanoTime - System.nanoTime();
        }
        String aVar = toString();
        String obj4 = timeUnit.toString();
        Locale locale = Locale.ROOT;
        String lowerCase = obj4.toLowerCase(locale);
        String str = "Waited " + j10 + " " + timeUnit.toString().toLowerCase(locale);
        if (nanos + 1000 < 0) {
            String str2 = str + " (plus ";
            long j11 = -nanos;
            long convert = timeUnit.convert(j11, TimeUnit.NANOSECONDS);
            long nanos2 = j11 - timeUnit.toNanos(convert);
            boolean z10 = convert == 0 || nanos2 > 1000;
            if (convert > 0) {
                String str3 = str2 + convert + " " + lowerCase;
                if (z10) {
                    str3 = str3 + ",";
                }
                str2 = str3 + " ";
            }
            if (z10) {
                str2 = str2 + nanos2 + " nanoseconds ";
            }
            str = str2 + "delay)";
        }
        if (isDone()) {
            throw new TimeoutException(str + " but future completed as timeout expired");
        }
        throw new TimeoutException(str + " for " + aVar);
    }

    @Override // java.util.concurrent.Future
    public final boolean isCancelled() {
        return this.f1318a instanceof c;
    }

    @Override // java.util.concurrent.Future
    public final boolean isDone() {
        return (this.f1318a != null) & true;
    }

    protected void k() {
    }

    /* JADX WARN: Multi-variable type inference failed */
    protected String l() {
        if (!(this instanceof ScheduledFuture)) {
            return null;
        }
        return "remaining delay=[" + ((ScheduledFuture) this).getDelay(TimeUnit.MILLISECONDS) + " ms]";
    }

    protected boolean o(Object obj) {
        if (obj == null) {
            obj = f1317g;
        }
        if (!f1316f.b(this, null, obj)) {
            return false;
        }
        g(this);
        return true;
    }

    protected boolean p(Throwable th) {
        if (!f1316f.b(this, null, new d((Throwable) e(th)))) {
            return false;
        }
        g(this);
        return true;
    }

    protected final boolean r() {
        Object obj = this.f1318a;
        return (obj instanceof c) && ((c) obj).f1323a;
    }

    public String toString() {
        String str;
        StringBuilder sb = new StringBuilder();
        sb.append(super.toString());
        sb.append("[status=");
        if (isCancelled()) {
            sb.append("CANCELLED");
        } else if (isDone()) {
            b(sb);
        } else {
            try {
                str = l();
            } catch (RuntimeException e10) {
                str = "Exception thrown from implementation: " + e10.getClass();
            }
            if (str != null && !str.isEmpty()) {
                sb.append("PENDING, info=[");
                sb.append(str);
                sb.append("]");
            } else if (isDone()) {
                b(sb);
            } else {
                sb.append("PENDING");
            }
        }
        sb.append("]");
        return sb.toString();
    }

    @Override // java.util.concurrent.Future
    public final Object get() {
        Object obj;
        if (!Thread.interrupted()) {
            Object obj2 = this.f1318a;
            if ((obj2 != null) & true) {
                return i(obj2);
            }
            h hVar = this.f1320c;
            if (hVar != h.f1336c) {
                h hVar2 = new h();
                do {
                    hVar2.a(hVar);
                    if (f1316f.c(this, hVar, hVar2)) {
                        do {
                            LockSupport.park(this);
                            if (!Thread.interrupted()) {
                                obj = this.f1318a;
                            } else {
                                n(hVar2);
                                throw new InterruptedException();
                            }
                        } while (!((obj != null) & true));
                        return i(obj);
                    }
                    hVar = this.f1320c;
                } while (hVar != h.f1336c);
            }
            return i(this.f1318a);
        }
        throw new InterruptedException();
    }
}