@Scheduled(fixedRate = 5 * 60 * 1000)  // كل 5 دقائق
public void cancelExpiredOrders() {
    List<Order> expired = orderRepository.findByStatusAndCreatedAtBefore(
        "PENDING", Instant.now().minus(30, ChronoUnit.MINUTES));
    expired.forEach(order -> cancelOrder(order));
    log.info("Cancelled {} expired orders", expired.size());
}

@Component
@EnableScheduling
public class OrderScheduleTask {

    private final OrderService orderService;
    private static final Logger log = LoggerFactory.getLogger(OrderScheduleTask.class);

    public OrderScheduleTask(OrderService orderService) {
        this.orderService = orderService;
    }

    @Scheduled(fixedRate = 5 * 60 * 1000)  // كل 5 دقائق
    public void cancelExpiredOrders() {
        log.info("بدء تنظيف الطلبات المتأخرة...");
        int cancelled = orderService.cancelExpiredOrders(Duration.ofMinutes(30));
        log.info("تم إلغاء {} طلب متأخر", cancelled);
    }
}

// تم التنفيذ بنجاح

@Component
public class DailyReportTask {

    @Scheduled(cron = "0 0 2 * * ?")  // كل يوم في الساعة 2:00 صباحًا
    public void generateDailyReport() {
        // إنشاء تقرير إحصائيات الطلبات اليومي
    }

    @Scheduled(cron = "0 0 0 1 * ?")  // أول يوم من كل شهر في منتصف الليل
    public void generateMonthlyReport() {
        // إنشاء التقرير الشهري
    }
}

// تم التنفيذ بنجاح

@Service
public class OrderService {

    public Order createOrder(CreateOrderRequest request) {
        Order order = saveOrder(request);
        emailService.sendConfirmation(order);   // يحظر لمدة 500 مللي ثانية
        smsService.sendNotification(order);       // يحظر لمدة 200 مللي ثانية
        return order;  // الإجمالي: 700 مللي ثانية مهدر
    }
}

// تم التنفيذ بنجاح

@Service
@EnableAsync
public class NotificationService {

    @Async
    public void sendOrderConfirmation(Order order) {
        // يعمل في خيط منفصل
        // لا يحظر المستدعي
        emailService.sendConfirmation(order);
        log.info("تم إرسال بريد التأكيد للطلب {}", order.getId());
    }

    @Async
    public CompletableFuture<String> sendSmsNotification(Order order) {
        smsService.sendNotification(order);
        return CompletableFuture.completedFuture("تم إرسال SMS");
    }
}

// في OrderService
@Service
public class OrderService {

    private final NotificationService notificationService;

    public Order createOrder(CreateOrderRequest request) {
        Order order = saveOrder(request);
        notificationService.sendOrderConfirmation(order);  // بدون حظر
        return order;  // يعود فورًا
    }
}

// تم التنفيذ بنجاح

@Configuration
@EnableAsync
public class AsyncConfig implements AsyncConfigurer {

    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(20);
        executor.setQueueCapacity(100);
        executor.setThreadNamePrefix("orderflow-async-");
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.setWaitForTasksToCompleteOnShutdown(true);
        executor.setAwaitTerminationSeconds(60);
        executor.initialize();
        return executor;
    }

    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return (ex, method, params) -> {
            log.error("استثناء غير متزامن في الطريقة {}: {}", method.getName(), ex.getMessage(), ex);
        };
    }
}

// تم التنفيذ بنجاح

@Configuration
@EnableAsync
public class AsyncConfig implements AsyncConfigurer {

    private static final Logger log = LoggerFactory.getLogger(AsyncConfig.class);

    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return (throwable, method, objects) -> {
            log.error("الطريقة غير المتزامنة [{}] رمت استثناء: {}",
                method.getName(), throwable.getMessage(), throwable);
            // يمكن أيضًا النشر إلى نظام المراقبة
        };
    }
}

// تم التنفيذ بنجاح

// OrderScheduleTask.java
package com.orderflow.schedule;

import com.orderflow.service.OrderService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.time.Duration;

@Component
public class OrderScheduleTask {

    private static final Logger log = LoggerFactory.getLogger(OrderScheduleTask.class);
    private final OrderService orderService;

    public OrderScheduleTask(OrderService orderService) {
        this.orderService = orderService;
    }

    @Scheduled(fixedRateString = "${orderflow.order.expiry-check-interval:300000}")
    public void cancelExpiredOrders() {
        int timeoutMinutes = 30;
        int cancelled = orderService.cancelExpiredOrders(Duration.ofMinutes(timeoutMinutes));
        if (cancelled > 0) {
            log.info("تم إلغاء {} طلب متأخر لمدة {} دقيقة", cancelled, timeoutMinutes);
        }
    }

    @Scheduled(cron = "0 0 2 * * ?")
    public void generateDailyReport() {
        log.info("جارٍ إنشاء تقرير الطلبات اليومي...");
        orderService.generateDailyReport();
    }
}

// NotificationService.java
package com.orderflow.service;

import com.orderflow.model.Order;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import java.util.concurrent.CompletableFuture;

@Service
public class NotificationService {

    private static final Logger log = LoggerFactory.getLogger(NotificationService.class);

    @Async
    public void sendOrderConfirmation(Order order) {
        // محاكاة إرسال البريد الإلكتروني
        log.info("إرسال بريد تأكيد للطلب {}", order.getId());
    }

    @Async
    public void sendCancellationNotice(Order order) {
        log.info("إرسال إشعار إلغاء للطلب {}", order.getId());
    }

    @Async
    public CompletableFuture<String> sendSmsNotification(Order order) {
        log.info("إرسال SMS للطلب {}", order.getId());
        return CompletableFuture.completedFuture("تم إرسال SMS للطلب " + order.getId());
    }
}

// AsyncConfig.java
@Configuration
@EnableAsync
@EnableScheduling
public class AsyncConfig implements AsyncConfigurer {
    private static final Logger log = LoggerFactory.getLogger(AsyncConfig.class);

    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor exec = new ThreadPoolTaskExecutor();
        exec.setCorePoolSize(5);
        exec.setMaxPoolSize(20);
        exec.setQueueCapacity(100);
        exec.setThreadNamePrefix("orderflow-async-");
        exec.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        exec.setWaitForTasksToCompleteOnShutdown(true);
        exec.setAwaitTerminationSeconds(60);
        exec.initialize();
        return exec;
    }

    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return (ex, method, params) ->
            log.error("خطأ غير متزامن في {}: {}", method.getName(), ex.getMessage(), ex);
    }
}