Add AdvancedTaskScheduler and TaskBuilder for enhanced task scheduling capabilities

Author: mzcydev

src/main/java/gg/nextforge/scheduler/CoreScheduler.java

@@ -1,5 +1,6 @@
 package gg.nextforge.scheduler;
 
+import gg.nextforge.scheduler.advanced.AdvancedTaskScheduler;
 import lombok.Getter;
 
 import java.util.Map;
@@ -13,6 +14,8 @@
 public class CoreScheduler {
 
     private static CoreScheduler instance;
+    @Getter
+    private static AdvancedTaskScheduler advancedScheduler;
 
     @Getter
     private static final Map<Integer, ScheduledTask> activeTasks = new ConcurrentHashMap<>();
@@ -22,6 +25,7 @@ public class CoreScheduler {
 
     public CoreScheduler() {
         this.executorService = Executors.newScheduledThreadPool(Runtime.getRuntime().availableProcessors());
+        this.advancedScheduler = new AdvancedTaskScheduler();
         instance = this;
     }
 
@@ -91,4 +95,5 @@ private ScheduledTask scheduleRepeating(Runnable task, long delayTicks, long per
     private long ticksToMillis(long ticks) {
         return ticks * 50L; // 20 ticks = 1 second
     }
+
 }

src/main/java/gg/nextforge/scheduler/advanced/AdvancedTaskScheduler.java

@@ -0,0 +1,56 @@
+package gg.nextforge.scheduler.advanced;
+
+import java.util.concurrent.*;
+import java.util.function.Consumer;
+import java.util.logging.Logger;
+
+public class AdvancedTaskScheduler {
+
+    private static final Logger LOGGER = Logger.getLogger("AdvancedTaskScheduler");
+
+    private final ScheduledExecutorService executor = Executors.newScheduledThreadPool(4);
+    private final ExecutorService asyncExecutor = Executors.newCachedThreadPool();
+
+    public ScheduledFuture<?> runLater(Runnable task, long delayMillis) {
+        return executor.schedule(safe(task), delayMillis, TimeUnit.MILLISECONDS);
+    }
+
+    public ScheduledFuture<?> runRepeating(Runnable task, long initialDelay, long period) {
+        return executor.scheduleAtFixedRate(safe(task), initialDelay, period, TimeUnit.MILLISECONDS);
+    }
+
+    public Future<?> runAsync(Runnable task) {
+        return asyncExecutor.submit(safe(task));
+    }
+
+    public <T> Future<T> supplyAsync(Callable<T> task) {
+        return asyncExecutor.submit(task);
+    }
+
+    public <T> void supplyAsync(Callable<T> task, Consumer<T> resultHandler, Consumer<Throwable> errorHandler) {
+        asyncExecutor.submit(() -> {
+            try {
+                T result = task.call();
+                resultHandler.accept(result);
+            } catch (Throwable t) {
+                errorHandler.accept(t);
+            }
+        });
+    }
+
+    public void shutdown() {
+        executor.shutdownNow();
+        asyncExecutor.shutdownNow();
+    }
+
+    private Runnable safe(Runnable task) {
+        return () -> {
+            try {
+                task.run();
+            } catch (Throwable t) {
+                LOGGER.severe("Task execution failed: " + t.getMessage());
+                t.printStackTrace();
+            }
+        };
+    }
+}

src/main/java/gg/nextforge/scheduler/advanced/TaskBuilder.java

@@ -0,0 +1,94 @@
+package gg.nextforge.scheduler.advanced;
+
+import java.util.concurrent.*;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+public class TaskBuilder<T> {
+
+    private boolean async = true;
+    private boolean repeating = false;
+
+    private long delay = 0;
+    private long period = 0;
+
+    private Supplier<T> supplier;
+    private Consumer<T> callback;
+    private Consumer<Throwable> errorHandler;
+
+    private AdvancedTaskScheduler scheduler;
+
+    private TaskBuilder(AdvancedTaskScheduler scheduler) {
+        this.scheduler = scheduler;
+    }
+
+    public static <T> TaskBuilder<T> create(AdvancedTaskScheduler scheduler) {
+        return new TaskBuilder<>(scheduler);
+    }
+
+    public TaskBuilder<T> async(boolean async) {
+        this.async = async;
+        return this;
+    }
+
+    public TaskBuilder<T> delay(long millis) {
+        this.delay = millis;
+        return this;
+    }
+
+    public TaskBuilder<T> period(long millis) {
+        this.repeating = true;
+        this.period = millis;
+        return this;
+    }
+
+    public TaskBuilder<T> supplier(Supplier<T> supplier) {
+        this.supplier = supplier;
+        return this;
+    }
+
+    public TaskBuilder<T> onResult(Consumer<T> callback) {
+        this.callback = callback;
+        return this;
+    }
+
+    public TaskBuilder<T> onError(Consumer<Throwable> errorHandler) {
+        this.errorHandler = errorHandler;
+        return this;
+    }
+
+    public Future<?> schedule() {
+        if (supplier == null) throw new IllegalStateException("No task supplier defined!");
+
+        Callable<T> callable = () -> {
+            try {
+                return supplier.get();
+            } catch (Throwable t) {
+                if (errorHandler != null) errorHandler.accept(t);
+                else t.printStackTrace();
+                return null;
+            }
+        };
+
+        Runnable task = () -> {
+            try {
+                T result = callable.call();
+                if (callback != null && result != null) callback.accept(result);
+            } catch (Exception e) {
+                if (errorHandler != null) errorHandler.accept(e);
+                else e.printStackTrace();
+            }
+        };
+
+        if (repeating) {
+            return scheduler.runRepeating(task, delay, period);
+        } else if (delay > 0) {
+            return scheduler.runLater(task, delay);
+        } else if (async) {
+            return scheduler.runAsync(task);
+        } else {
+            task.run();
+            return null;
+        }
+    }
+}