package io.reactivex;

import io.reactivex.disposables.Disposable;
import io.reactivex.exceptions.Exceptions;
import io.reactivex.internal.disposables.EmptyDisposable;
import io.reactivex.internal.disposables.SequentialDisposable;
import io.reactivex.internal.schedulers.NewThreadWorker;
import io.reactivex.internal.util.ExceptionHelper;
import io.reactivex.plugins.RxJavaPlugins;
import io.reactivex.schedulers.SchedulerRunnableIntrospection;
import java.util.concurrent.TimeUnit;

/* loaded from: classes2.dex */
public abstract class Scheduler {
    static final long a = TimeUnit.MINUTES.toNanos(Long.getLong("rx2.scheduler.drift-tolerance", 15).longValue());

    static final class DisposeTask implements Disposable, Runnable, SchedulerRunnableIntrospection {
        final Runnable a;
        final Worker b;
        Thread c;

        DisposeTask(Runnable runnable, Worker worker) {
            this.a = runnable;
            this.b = worker;
        }

        @Override // io.reactivex.disposables.Disposable
        public void dispose() {
            if (this.c == Thread.currentThread()) {
                Worker worker = this.b;
                if (worker instanceof NewThreadWorker) {
                    ((NewThreadWorker) worker).a();
                    return;
                }
            }
            this.b.dispose();
        }

        @Override // java.lang.Runnable
        public void run() {
            this.c = Thread.currentThread();
            try {
                this.a.run();
            } finally {
                dispose();
                this.c = null;
            }
        }
    }

    static final class PeriodicDirectTask implements Disposable, Runnable, SchedulerRunnableIntrospection {
        final Runnable a;
        final Worker b;
        volatile boolean c;

        PeriodicDirectTask(Runnable runnable, Worker worker) {
            this.a = runnable;
            this.b = worker;
        }

        @Override // io.reactivex.disposables.Disposable
        public void dispose() {
            this.c = true;
            this.b.dispose();
        }

        @Override // java.lang.Runnable
        public void run() {
            if (this.c) {
                return;
            }
            try {
                this.a.run();
            } catch (Throwable th) {
                Exceptions.b(th);
                this.b.dispose();
                throw ExceptionHelper.a(th);
            }
        }
    }

    public static abstract class Worker implements Disposable {

        final class PeriodicTask implements Runnable, SchedulerRunnableIntrospection {
            final Runnable a;
            final SequentialDisposable b;
            final long c;
            long d;
            long e;
            long f;

            PeriodicTask(long j, Runnable runnable, long j2, SequentialDisposable sequentialDisposable, long j3) {
                this.a = runnable;
                this.b = sequentialDisposable;
                this.c = j3;
                this.e = j2;
                this.f = j;
            }

            @Override // java.lang.Runnable
            public void run() {
                long j;
                this.a.run();
                if (this.b.isDisposed()) {
                    return;
                }
                long a = Worker.this.a(TimeUnit.NANOSECONDS);
                long j2 = Scheduler.a;
                long j3 = a + j2;
                long j4 = this.e;
                if (j3 >= j4) {
                    long j5 = this.c;
                    if (a < j4 + j5 + j2) {
                        long j6 = this.f;
                        long j7 = this.d + 1;
                        this.d = j7;
                        j = j6 + (j7 * j5);
                        this.e = a;
                        this.b.replace(Worker.this.a(this, j - a, TimeUnit.NANOSECONDS));
                    }
                }
                long j8 = this.c;
                long j9 = a + j8;
                long j10 = this.d + 1;
                this.d = j10;
                this.f = j9 - (j8 * j10);
                j = j9;
                this.e = a;
                this.b.replace(Worker.this.a(this, j - a, TimeUnit.NANOSECONDS));
            }
        }

        public Disposable a(Runnable runnable) {
            return a(runnable, 0L, TimeUnit.NANOSECONDS);
        }

        public abstract Disposable a(Runnable runnable, long j, TimeUnit timeUnit);

        public Disposable a(Runnable runnable, long j, long j2, TimeUnit timeUnit) {
            SequentialDisposable sequentialDisposable = new SequentialDisposable();
            SequentialDisposable sequentialDisposable2 = new SequentialDisposable(sequentialDisposable);
            Runnable a = RxJavaPlugins.a(runnable);
            long nanos = timeUnit.toNanos(j2);
            long a2 = a(TimeUnit.NANOSECONDS);
            Disposable a3 = a(new PeriodicTask(a2 + timeUnit.toNanos(j), a, a2, sequentialDisposable2, nanos), j, timeUnit);
            if (a3 == EmptyDisposable.INSTANCE) {
                return a3;
            }
            sequentialDisposable.replace(a3);
            return sequentialDisposable2;
        }

        public long a(TimeUnit timeUnit) {
            return timeUnit.convert(System.currentTimeMillis(), TimeUnit.MILLISECONDS);
        }
    }

    public long a(TimeUnit timeUnit) {
        return timeUnit.convert(System.currentTimeMillis(), TimeUnit.MILLISECONDS);
    }

    public abstract Worker a();

    public Disposable a(Runnable runnable) {
        return a(runnable, 0L, TimeUnit.NANOSECONDS);
    }

    public Disposable a(Runnable runnable, long j, TimeUnit timeUnit) {
        Worker a2 = a();
        DisposeTask disposeTask = new DisposeTask(RxJavaPlugins.a(runnable), a2);
        a2.a(disposeTask, j, timeUnit);
        return disposeTask;
    }

    public Disposable a(Runnable runnable, long j, long j2, TimeUnit timeUnit) {
        Worker a2 = a();
        PeriodicDirectTask periodicDirectTask = new PeriodicDirectTask(RxJavaPlugins.a(runnable), a2);
        Disposable a3 = a2.a(periodicDirectTask, j, j2, timeUnit);
        return a3 == EmptyDisposable.INSTANCE ? a3 : periodicDirectTask;
    }
}