package io.netty.util.concurrent;

import io.netty.util.internal.DefaultPriorityQueue;
import io.netty.util.internal.PriorityQueueNode;
import java.util.concurrent.Callable;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;

/* JADX INFO: loaded from: classes.dex */
public final class ScheduledFutureTask<V> extends PromiseTask<V> implements ScheduledFuture<V>, PriorityQueueNode {
    public static final /* synthetic */ boolean $assertionsDisabled = false;
    private long deadlineNanos;
    private final long id;
    private final long periodNanos;
    private int queueIndex;
    private static final AtomicLong nextTaskId = new AtomicLong();
    private static final long START_TIME = System.nanoTime();

    public ScheduledFutureTask(AbstractScheduledEventExecutor abstractScheduledEventExecutor, Runnable runnable, V v2, long j2) {
        this(abstractScheduledEventExecutor, PromiseTask.toCallable(runnable, v2), j2);
    }

    public ScheduledFutureTask(AbstractScheduledEventExecutor abstractScheduledEventExecutor, Callable<V> callable, long j2) {
        super(abstractScheduledEventExecutor, callable);
        this.id = nextTaskId.getAndIncrement();
        this.queueIndex = -1;
        this.deadlineNanos = j2;
        this.periodNanos = 0L;
    }

    public ScheduledFutureTask(AbstractScheduledEventExecutor abstractScheduledEventExecutor, Callable<V> callable, long j2, long j3) {
        super(abstractScheduledEventExecutor, callable);
        this.id = nextTaskId.getAndIncrement();
        this.queueIndex = -1;
        if (j3 == 0) {
            throw new IllegalArgumentException("period: 0 (expected: != 0)");
        }
        this.deadlineNanos = j2;
        this.periodNanos = j3;
    }

    public static long deadlineNanos(long j2) {
        return nanoTime() + j2;
    }

    public static long nanoTime() {
        return System.nanoTime() - START_TIME;
    }

    @Override // io.netty.util.concurrent.DefaultPromise, io.netty.util.concurrent.Future, java.util.concurrent.Future
    public boolean cancel(boolean z2) {
        boolean zCancel = super.cancel(z2);
        if (zCancel) {
            ((AbstractScheduledEventExecutor) executor()).removeScheduled(this);
        }
        return zCancel;
    }

    public boolean cancelWithoutRemove(boolean z2) {
        return super.cancel(z2);
    }

    @Override // java.lang.Comparable
    public int compareTo(Delayed delayed) {
        if (this == delayed) {
            return 0;
        }
        ScheduledFutureTask scheduledFutureTask = (ScheduledFutureTask) delayed;
        long jDeadlineNanos = deadlineNanos() - scheduledFutureTask.deadlineNanos();
        if (jDeadlineNanos < 0) {
            return -1;
        }
        if (jDeadlineNanos > 0) {
            return 1;
        }
        long j2 = this.id;
        long j3 = scheduledFutureTask.id;
        if (j2 < j3) {
            return -1;
        }
        if (j2 != j3) {
            return 1;
        }
        throw new Error();
    }

    public long deadlineNanos() {
        return this.deadlineNanos;
    }

    public long delayNanos() {
        return Math.max(0L, deadlineNanos() - nanoTime());
    }

    public long delayNanos(long j2) {
        return Math.max(0L, deadlineNanos() - (j2 - START_TIME));
    }

    @Override // io.netty.util.concurrent.DefaultPromise
    public EventExecutor executor() {
        return super.executor();
    }

    @Override // java.util.concurrent.Delayed
    public long getDelay(TimeUnit timeUnit) {
        return timeUnit.convert(delayNanos(), TimeUnit.NANOSECONDS);
    }

    @Override // io.netty.util.internal.PriorityQueueNode
    public int priorityQueueIndex(DefaultPriorityQueue<?> defaultPriorityQueue) {
        return this.queueIndex;
    }

    @Override // io.netty.util.internal.PriorityQueueNode
    public void priorityQueueIndex(DefaultPriorityQueue<?> defaultPriorityQueue, int i2) {
        this.queueIndex = i2;
    }

    @Override // io.netty.util.concurrent.PromiseTask, java.util.concurrent.RunnableFuture, java.lang.Runnable
    public void run() {
        try {
            if (this.periodNanos == 0) {
                if (setUncancellableInternal()) {
                    setSuccessInternal(this.task.call());
                }
            } else {
                if (isCancelled()) {
                    return;
                }
                this.task.call();
                if (executor().isShutdown()) {
                    return;
                }
                long j2 = this.periodNanos;
                if (j2 > 0) {
                    this.deadlineNanos += j2;
                } else {
                    this.deadlineNanos = nanoTime() - j2;
                }
                if (isCancelled()) {
                    return;
                }
                ((AbstractScheduledEventExecutor) executor()).scheduledTaskQueue.add(this);
            }
        } catch (Throwable th) {
            setFailureInternal(th);
        }
    }

    @Override // io.netty.util.concurrent.PromiseTask, io.netty.util.concurrent.DefaultPromise
    public StringBuilder toStringBuilder() {
        StringBuilder stringBuilder = super.toStringBuilder();
        stringBuilder.setCharAt(stringBuilder.length() - 1, ',');
        stringBuilder.append(" id: ");
        stringBuilder.append(this.id);
        stringBuilder.append(", deadline: ");
        stringBuilder.append(this.deadlineNanos);
        stringBuilder.append(", period: ");
        stringBuilder.append(this.periodNanos);
        stringBuilder.append(')');
        return stringBuilder;
    }
}