Task Scheduler

// In your main.dart or bootstrap file
import 'package:khadem/khadem.dart';
import 'package:khadem/src/core/scheduler/scheduler_bootstrap.dart';

void main() async {
  // Initialize Khadem
  await Khadem.initialize();

  // Start the scheduler system
  startSchedulers();

  print('🚀 Application started with scheduler');

  // Graceful shutdown
  ProcessSignal.sigint.watch().listen((_) {
    print('🛑 Shutting down...');
    stopSchedulers();
    exit(0);
  });
}

// Duration-based scheduling examples
class DurationExamples {
  static void examples() {
    // Run every 30 seconds
    final healthCheck = ScheduledTask(
      name: 'health_check',
      interval: Duration(seconds: 30),
      job: PingJob(),
    );

    // Run every 5 minutes
    final cacheCleanup = ScheduledTask(
      name: 'cache_cleanup',
      interval: Duration(minutes: 5),
      job: CacheCleanupJob(),
    );

    // Run every hour
    final backupTask = ScheduledTask(
      name: 'database_backup',
      interval: Duration(hours: 1),
      job: DatabaseBackupJob(),
    );

    // Run daily (24 hours)
    final dailyReport = ScheduledTask(
      name: 'daily_report',
      interval: Duration(hours: 24),
      job: DailyReportJob(),
    );

    // Run weekly (7 days)
    final weeklyCleanup = ScheduledTask(
      name: 'weekly_cleanup',
      interval: Duration(days: 7),
      job: WeeklyCleanupJob(),
    );

    // Custom duration
    final customTask = ScheduledTask(
      name: 'custom_task',
      interval: Duration(hours: 2, minutes: 30), // 2.5 hours
      job: CustomJob(),
    );
  }
}

// config/app.json
{
  "scheduler": {
    "tasks": [
      {
        "name": "health_check",
        "interval": 30,
        "job": "ping",
        "retryOnFail": false
      },
      {
        "name": "cache_cleanup",
        "interval": 300,
        "job": "ttl_cleaner",
        "cachePath": "storage/cache",
        "retryOnFail": true,
        "maxRetries": 3
      },
      {
        "name": "email_notifications",
        "interval": 60,
        "job": "email_notifications",
        "retryOnFail": true,
        "maxRetries": 5
      },
      {
        "name": "database_backup",
        "interval": 3600,
        "job": "database_backup",
        "retryOnFail": true,
        "maxRetries": 2
      }
    ]
  }
}

// Tasks will be automatically loaded when calling startSchedulers()

// Task monitoring and control
class TaskMonitor {
  final SchedulerEngine _scheduler;

  TaskMonitor(this._scheduler);

  void printTaskStatus() {
    final stats = _scheduler.getStats();

    print('\n📊 Task Status Report:');
    print('=' * 50);

    for (final entry in stats.entries) {
      final taskStats = entry.value;
      print('\n📋 Task: ${taskStats.name}');
      print('   Status: ${taskStats.status}');
      print('   Last Run: ${taskStats.lastRun ?? 'Never'}');
      print('   Next Run: ${taskStats.nextRun ?? 'Not scheduled'}');
      print('   Success Count: ${taskStats.successCount}');
      print('   Failure Count: ${taskStats.failureCount}');
      print('   Avg Execution Time: ${taskStats.averageExecutionTime.toStringAsFixed(2)}ms');
    }
  }

  void pauseFailingTasks() {
    final stats = _scheduler.getStats();

    for (final entry in stats.entries) {
      final taskStats = entry.value;
      if (taskStats.failureCount > 3) {
        _scheduler.pause(taskStats.name);
        Khadem.logger.warning('⏸️ Paused failing task: ${taskStats.name}');
      }
    }
  }

  List<String> getActiveTasks() {
    return _scheduler.activeTasks();
  }

  bool isTaskRunning(String taskName) {
    return _scheduler.isRunning(taskName);
  }
}

// Usage
final monitor = TaskMonitor(scheduler);

// Check status every 5 minutes
final statusTask = ScheduledTask(
  name: 'status_monitor',
  interval: Duration(minutes: 5),
  job: StatusMonitorJob(monitor),
);

scheduler.add(statusTask);

// Error handling with retry logic
class RetryableJob extends ScheduledJob {
  @override
  String get name => 'retryable_job';

  @override
  Future<void> execute() async {
    try {
      // Your business logic here
      await performUnreliableOperation();

      Khadem.logger.info('✅ Job completed successfully');
    } catch (e) {
      Khadem.logger.error('❌ Job failed: $e');

      // The scheduler will automatically handle retries
      // based on the task's retryOnFail and maxRetries settings
      rethrow;
    }
  }
}

// Create task with retry configuration
final retryableTask = ScheduledTask(
  name: 'unreliable_task',
  interval: Duration(minutes: 10),
  job: RetryableJob(),
  retryOnFail: true,      // Enable retries
  maxRetries: 3,          // Maximum 3 retry attempts
);

// Exponential backoff is automatic:
// Attempt 1: immediate retry
// Attempt 2: 5 seconds delay
// Attempt 3: 10 seconds delay
// Attempt 4: 15 seconds delay

scheduler.add(retryableTask);

// Custom error handling job
class ErrorHandlingJob extends ScheduledJob {
  @override
  String get name => 'error_handler';

  @override
  Future<void> execute() async {
    try {
      await riskyOperation();
    } on NetworkException catch (e) {
      // Handle network errors specifically
      Khadem.logger.warning('Network error, will retry: $e');
      rethrow;
    } on DatabaseException catch (e) {
      // Handle database errors
      Khadem.logger.error('Database error: $e');
      // Don't retry for database errors
      throw PermanentFailureException('Database unavailable');
    } catch (e) {
      // Handle other errors
      Khadem.logger.error('Unexpected error: $e');
      rethrow;
    }
  }
}