package io.netty.util.concurrent;

import io.netty.util.internal.ObjectUtil;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.concurrent.Callable;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

/* JADX INFO: loaded from: classes.dex */
public abstract class AbstractScheduledEventExecutor extends AbstractEventExecutor {
    static final /* synthetic */ boolean $assertionsDisabled = false;
    Queue<ScheduledFutureTask<?>> scheduledTaskQueue;

    protected AbstractScheduledEventExecutor() {
    }

    private static boolean isNullOrEmpty(Queue<ScheduledFutureTask<?>> queue) {
        return queue == null || queue.isEmpty();
    }

    protected static long nanoTime() {
        return ScheduledFutureTask.nanoTime();
    }

    protected void cancelScheduledTasks() {
        Queue<ScheduledFutureTask<?>> queue = this.scheduledTaskQueue;
        if (isNullOrEmpty(queue)) {
            return;
        }
        for (ScheduledFutureTask scheduledFutureTask : (ScheduledFutureTask[]) queue.toArray(new ScheduledFutureTask[queue.size()])) {
            scheduledFutureTask.cancelWithoutRemove(false);
        }
        queue.clear();
    }

    protected final boolean hasScheduledTasks() {
        Queue<ScheduledFutureTask<?>> queue = this.scheduledTaskQueue;
        ScheduledFutureTask<?> scheduledFutureTaskPeek = queue == null ? null : queue.peek();
        return scheduledFutureTaskPeek != null && scheduledFutureTaskPeek.deadlineNanos() <= nanoTime();
    }

    protected final long nextScheduledTaskNano() {
        Queue<ScheduledFutureTask<?>> queue = this.scheduledTaskQueue;
        ScheduledFutureTask<?> scheduledFutureTaskPeek = queue == null ? null : queue.peek();
        if (scheduledFutureTaskPeek == null) {
            return -1L;
        }
        return Math.max(0L, scheduledFutureTaskPeek.deadlineNanos() - nanoTime());
    }

    final ScheduledFutureTask<?> peekScheduledTask() {
        Queue<ScheduledFutureTask<?>> queue = this.scheduledTaskQueue;
        if (queue == null) {
            return null;
        }
        return queue.peek();
    }

    protected final Runnable pollScheduledTask() {
        return pollScheduledTask(nanoTime());
    }

    final void removeScheduled(final ScheduledFutureTask<?> scheduledFutureTask) {
        if (inEventLoop()) {
            scheduledTaskQueue().remove(scheduledFutureTask);
        } else {
            execute(new Runnable() { // from class: io.netty.util.concurrent.AbstractScheduledEventExecutor.2
                @Override // java.lang.Runnable
                public void run() {
                    AbstractScheduledEventExecutor.this.removeScheduled(scheduledFutureTask);
                }
            });
        }
    }

    Queue<ScheduledFutureTask<?>> scheduledTaskQueue() {
        if (this.scheduledTaskQueue == null) {
            this.scheduledTaskQueue = new PriorityQueue();
        }
        return this.scheduledTaskQueue;
    }

    protected AbstractScheduledEventExecutor(EventExecutorGroup eventExecutorGroup) {
        super(eventExecutorGroup);
    }

    protected final Runnable pollScheduledTask(long j2) {
        Queue<ScheduledFutureTask<?>> queue = this.scheduledTaskQueue;
        ScheduledFutureTask<?> scheduledFutureTaskPeek = queue == null ? null : queue.peek();
        if (scheduledFutureTaskPeek == null || scheduledFutureTaskPeek.deadlineNanos() > j2) {
            return null;
        }
        queue.remove();
        return scheduledFutureTaskPeek;
    }

    @Override // io.netty.util.concurrent.AbstractEventExecutor, java.util.concurrent.ScheduledExecutorService
    public ScheduledFuture<?> scheduleAtFixedRate(Runnable runnable, long j2, long j3, TimeUnit timeUnit) {
        ObjectUtil.checkNotNull(runnable, "command");
        ObjectUtil.checkNotNull(timeUnit, "unit");
        if (j2 < 0) {
            throw new IllegalArgumentException(String.format("initialDelay: %d (expected: >= 0)", Long.valueOf(j2)));
        }
        if (j3 > 0) {
            return schedule(new ScheduledFutureTask(this, Executors.callable(runnable, null), ScheduledFutureTask.deadlineNanos(timeUnit.toNanos(j2)), timeUnit.toNanos(j3)));
        }
        throw new IllegalArgumentException(String.format("period: %d (expected: > 0)", Long.valueOf(j3)));
    }

    @Override // io.netty.util.concurrent.AbstractEventExecutor, java.util.concurrent.ScheduledExecutorService
    public ScheduledFuture<?> scheduleWithFixedDelay(Runnable runnable, long j2, long j3, TimeUnit timeUnit) {
        ObjectUtil.checkNotNull(runnable, "command");
        ObjectUtil.checkNotNull(timeUnit, "unit");
        if (j2 < 0) {
            throw new IllegalArgumentException(String.format("initialDelay: %d (expected: >= 0)", Long.valueOf(j2)));
        }
        if (j3 > 0) {
            return schedule(new ScheduledFutureTask(this, Executors.callable(runnable, null), ScheduledFutureTask.deadlineNanos(timeUnit.toNanos(j2)), -timeUnit.toNanos(j3)));
        }
        throw new IllegalArgumentException(String.format("delay: %d (expected: > 0)", Long.valueOf(j3)));
    }

    @Override // io.netty.util.concurrent.AbstractEventExecutor, java.util.concurrent.ScheduledExecutorService
    public ScheduledFuture<?> schedule(Runnable runnable, long j2, TimeUnit timeUnit) {
        ObjectUtil.checkNotNull(runnable, "command");
        ObjectUtil.checkNotNull(timeUnit, "unit");
        if (j2 >= 0) {
            return schedule(new ScheduledFutureTask(this, runnable, (Object) null, ScheduledFutureTask.deadlineNanos(timeUnit.toNanos(j2))));
        }
        throw new IllegalArgumentException(String.format("delay: %d (expected: >= 0)", Long.valueOf(j2)));
    }

    @Override // io.netty.util.concurrent.AbstractEventExecutor, java.util.concurrent.ScheduledExecutorService
    public <V> ScheduledFuture<V> schedule(Callable<V> callable, long j2, TimeUnit timeUnit) {
        ObjectUtil.checkNotNull(callable, "callable");
        ObjectUtil.checkNotNull(timeUnit, "unit");
        if (j2 >= 0) {
            return schedule(new ScheduledFutureTask<>(this, callable, ScheduledFutureTask.deadlineNanos(timeUnit.toNanos(j2))));
        }
        throw new IllegalArgumentException(String.format("delay: %d (expected: >= 0)", Long.valueOf(j2)));
    }

    /* JADX WARN: Multi-variable type inference failed */
    <V> ScheduledFuture<V> schedule(final ScheduledFutureTask<V> scheduledFutureTask) {
        if (inEventLoop()) {
            scheduledTaskQueue().add(scheduledFutureTask);
        } else {
            execute(new Runnable() { // from class: io.netty.util.concurrent.AbstractScheduledEventExecutor.1
                @Override // java.lang.Runnable
                public void run() {
                    AbstractScheduledEventExecutor.this.scheduledTaskQueue().add(scheduledFutureTask);
                }
            });
        }
        return scheduledFutureTask;
    }
}