PlotSquared/src/main/java/com/intellectualcrafters/plot/util/TaskManager.java

package com.intellectualcrafters.plot.util;

import java.util.HashMap;
import java.util.HashSet;
import java.util.concurrent.atomic.AtomicInteger;

import com.intellectualcrafters.plot.PS;

public abstract class TaskManager {
    public static HashSet<String> TELEPORT_QUEUE = new HashSet<>();
    
    public static AtomicInteger index = new AtomicInteger(0);
    public static HashMap<Integer, Integer> tasks = new HashMap<>();
    
    public static int runTaskRepeat(final Runnable r, final int interval) {
        if (r != null) {
            if (PS.get().TASK == null) {
                throw new IllegalArgumentException("disabled");
            }
            return PS.get().TASK.taskRepeat(r, interval);
        }
        return -1;
    }
    
    public static int runTaskRepeatAsync(final Runnable r, final int interval) {
        if (r != null) {
            if (PS.get().TASK == null) {
                throw new IllegalArgumentException("disabled");
            }
            return PS.get().TASK.taskRepeat(r, interval);
        }
        return -1;
    }
    
    public static void runTaskAsync(final Runnable r) {
        if (r != null) {
            if (PS.get().TASK == null) {
                r.run();
                return;
            }
            PS.get().TASK.taskAsync(r);
        }
    }
    
    public static void runTask(final Runnable r) {
        if (r != null) {
            if (PS.get().TASK == null) {
                r.run();
                return;
            }
            PS.get().TASK.task(r);
        }
    }
    
    /**
     * Run task later (delay in ticks)
     * @param r
     * @param delay
     */
    public static void runTaskLater(final Runnable r, final int delay) {
        if (r != null) {
            if (PS.get().TASK == null) {
                r.run();
                return;
            }
            PS.get().TASK.taskLater(r, delay);
        }
    }
    
    public static void runTaskLaterAsync(final Runnable r, final int delay) {
        if (r != null) {
            if (PS.get().TASK == null) {
                r.run();
                return;
            }
            PS.get().TASK.taskLaterAsync(r, delay);
        }
    }
    
    public abstract int taskRepeat(final Runnable r, final int interval);
    
    public abstract int taskRepeatAsync(final Runnable r, final int interval);
    
    public abstract void taskAsync(final Runnable r);
    
    public abstract void task(final Runnable r);
    
    public abstract void taskLater(final Runnable r, final int delay);
    
    public abstract void taskLaterAsync(final Runnable r, final int delay);
    
    public abstract void cancelTask(final int task);
}