java example

package com.taskmanager.examples;

import com.taskmanager.*;

import java.time.Duration;
import java.util.HashMap;
import java.util.Map;

/**
 * Examples of using TaskManager from Java.
 */
public class JavaExamples {

    // ========================================================================
    // Example 1: Basic Usage with Builder
    // ========================================================================

    public static void basicExample() {
        TaskManager tasks = TaskManager.builder()
                .concurrency(4)
                .threadNamePrefix("java-app")
                .onTaskComplete(exec -> {
                    if (exec.isSuccess()) {
                        System.out.println("Task " + exec.getTaskName() + 
                                         " completed in " + exec.getDuration() + "ms");
                    } else {
                        System.err.println("Task " + exec.getTaskName() + 
                                         " failed: " + exec.getError().getMessage());
                    }
                })
                .build();

        // Register tasks
        tasks.task("heartbeat", null, Duration.ofSeconds(5), false, ctx -> {
            System.out.println("Heartbeat #" + ctx.getExecutionCount());
            return null;
        });

        tasks.task("manual-task", null, null, false, ctx -> {
            System.out.println("Manual task executed");
            return "Success";
        });

        tasks.start();

        // Sleep for demo
        try {
            Thread.sleep(15000);
            
            // Manually execute task
            Object result = tasks.runBlocking("manual-task", new HashMap<>());
            System.out.println("Result: " + result);
            
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        tasks.shutdown(true);
    }

    // ========================================================================
    // Example 2: With Context
    // ========================================================================

    static class Database {
        public void cleanup() {
            System.out.println("Database cleanup executed");
        }
    }

    public static void contextExample() {
        Database db = new Database();

        TaskManager tasks = TaskManager.builder()
                .concurrency(2)
                .putContext("db", db)
                .putContext("environment", "production")
                .build();

        tasks.task("db-cleanup", "0 0 * * * ?", null, false, ctx -> {
            Database database = ctx.get("db");
            String env = ctx.get("environment");
            
            System.out.println("Running cleanup in " + env + " environment");
            database.cleanup();
            return null;
        });

        tasks.start();

        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        tasks.shutdown(true);
    }

    // ========================================================================
    // Example 3: Task Monitoring
    // ========================================================================

    public static void monitoringExample() {
        TaskManager tasks = TaskManager.builder()
                .concurrency(4)
                .onTaskStart(event -> {
                    System.out.println("[START] " + event.getTaskName() + 
                                     " (execution #" + event.getExecutionCount() + ")");
                })
                .onTaskComplete(exec -> {
                    if (exec.isSuccess()) {
                        System.out.println("[SUCCESS] " + exec.getTaskName() + 
                                         " completed in " + exec.getDuration() + "ms");
                    } else {
                        System.out.println("[FAILURE] " + exec.getTaskName() + 
                                         " failed: " + exec.getError().getMessage());
                    }
                })
                .build();

        // Stable task
        tasks.task("stable-task", null, Duration.ofSeconds(2), false, ctx -> {
            Thread.sleep(100);
            return "success";
        });

        // Flaky task
        tasks.task("flaky-task", null, Duration.ofSeconds(3), false, ctx -> {
            if (Math.random() < 0.3) {
                throw new RuntimeException("Random failure!");
            }
            Thread.sleep(50);
            return "success";
        });

        tasks.start();

        try {
            Thread.sleep(15000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        tasks.shutdown(true);
    }

    // ========================================================================
    // Example 4: Advanced Scheduling
    // ========================================================================

    public static void advancedSchedulingExample() {
        TaskManager tasks = TaskManager.builder().build();

        // Using Schedule classes
        Schedule fixedRate = new Schedule.FixedRate(Duration.ofSeconds(5));
        tasks.task("fixed-rate-task", fixedRate, false, ctx -> {
            System.out.println("[" + System.currentTimeMillis() + "] Fixed rate task");
            Thread.sleep(2000);
            return null;
        });

        Schedule fixedDelay = new Schedule.FixedDelay(Duration.ofSeconds(5));
        tasks.task("fixed-delay-task", fixedDelay, false, ctx -> {
            System.out.println("[" + System.currentTimeMillis() + "] Fixed delay task");
            Thread.sleep(2000);
            return null;
        });

        // With initial delay
        Schedule delayed = new Schedule.WithInitialDelay(
                Duration.ofSeconds(10),
                new Schedule.FixedRate(Duration.ofSeconds(3))
        );
        tasks.task("delayed-start", delayed, false, ctx -> {
            System.out.println("[" + System.currentTimeMillis() + "] Delayed start task");
            return null;
        });

        tasks.start();

        try {
            Thread.sleep(30000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        tasks.shutdown(true);
    }

    // ========================================================================
    // Example 5: Task Control
    // ========================================================================

    public static void taskControlExample() {
        TaskManager tasks = TaskManager.builder().build();

        tasks.task("controllable", null, Duration.ofSeconds(2), false, ctx -> {
            System.out.println("[" + System.currentTimeMillis() + "] Task executing");
            return null;
        });

        tasks.start();

        try {
            // Run for 5 seconds
            Thread.sleep(5000);
            System.out.println("\n>>> Disabling task <<<\n");
            
            tasks.disable("controllable");
            Thread.sleep(5000);
            
            System.out.println("\n>>> Enabling task <<<\n");
            tasks.enable("controllable");
            Thread.sleep(5000);

        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        tasks.shutdown(true);
    }

    // ========================================================================
    // Example 6: Query API
    // ========================================================================

    public static void queryExample() {
        TaskManager tasks = TaskManager.builder().build();

        tasks.task("task1", null, Duration.ofSeconds(10), false, ctx -> null);
        tasks.task("task2", "0 * * * * ?", null, false, ctx -> null);
        tasks.task("task3", null, null, false, ctx -> null); // Manual task

        tasks.start();

        // List all tasks
        System.out.println("Registered tasks: " + tasks.listTaskNames());

        // Get task definitions
        for (String name : tasks.listTaskNames()) {
            TaskDefinition def = tasks.getTaskDefinition(name);
            System.out.println(String.format("""
                Task: %s
                Schedule: %s
                Enabled: %s
                Allow Concurrent: %s
                """,
                def.getName(),
                def.getScheduleDescription() != null ? def.getScheduleDescription() : "Manual",
                def.getEnabled(),
                def.getAllowConcurrent()
            ));
        }

        tasks.disable("task1");
        System.out.println("\nAfter disabling task1:");
        System.out.println("task1 enabled: " + 
                          tasks.getTaskDefinition("task1").getEnabled());

        tasks.shutdown(true);
    }

    // ========================================================================
    // Example 7: Manual Execution with Context
    // ========================================================================

    public static void manualExecutionExample() {
        TaskManager tasks = TaskManager.builder().build();

        tasks.task("process-data", null, null, false, ctx -> {
            String dataType = ctx.getOrDefault("dataType", "default");
            Integer batchSize = ctx.getOrDefault("batchSize", 100);
            
            System.out.println("Processing " + dataType + " data with batch size " + batchSize);
            return "Processed";
        });

        tasks.start();

        // Execute with custom context
        Map<String, Object> context = new HashMap<>();
        context.put("dataType", "users");
        context.put("batchSize", 500);

        try {
            Object result = tasks.runBlocking("process-data", context);
            System.out.println("Result: " + result);
        } catch (Exception e) {
            e.printStackTrace();
        }

        tasks.shutdown(true);
    }

    // ========================================================================
    // Main
    // ========================================================================

    public static void main(String[] args) {
        System.out.println("=== Example 1: Basic Usage ===");
        basicExample();

        System.out.println("\n=== Example 2: With Context ===");
        contextExample();

        System.out.println("\n=== Example 3: Monitoring ===");
        monitoringExample();

        System.out.println("\n=== Example 4: Advanced Scheduling ===");
        advancedSchedulingExample();

        System.out.println("\n=== Example 5: Task Control ===");
        taskControlExample();

        System.out.println("\n=== Example 6: Query API ===");
        queryExample();

        System.out.println("\n=== Example 7: Manual Execution ===");
        manualExecutionExample();
    }
}