package com.gs.xky.task;

import com.gs.xky.service.PurchaseService;
import lombok.RequiredArgsConstructor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executor;
import java.util.concurrent.atomic.AtomicBoolean;

/**
 * 采购订单同步定时任务
 */
@Component
@RequiredArgsConstructor
public class PurchaseOrderSyncTask {
    private static final Logger log = LoggerFactory.getLogger(PurchaseOrderSyncTask.class);

    private final PurchaseService purchaseService;
    private final Executor purchaseTaskExecutor; // 注入专用线程池

    // 用于标记任务是否正在执行
    private final AtomicBoolean isRunning = new AtomicBoolean(false);

    /**
     * 定时执行采购订单同步任务
     * 每天12点整执行一次
     * 设置为12点05分执行，避免与其他定时任务冲突
     * 使用异步执行，防止阻塞其他定时任务
     */
    @Scheduled(cron = "0 5 12 * * ?")
    public void syncPurchaseOrders() {
        // 如果任务已经在运行，则跳过本次执行
        if (!isRunning.compareAndSet(false, true)) {
            log.info("【syncPurchaseOrders】上一次任务还在执行中，跳过本次执行");
            return;
        }

        log.info("【syncPurchaseOrders】开始执行采购订单同步任务");

        // 使用专用线程池执行异步任务
        CompletableFuture.runAsync(() -> {
            try {
                log.info("【syncPurchaseOrders】异步线程开始执行采购订单同步");
                purchaseService.syncPurchaseOrderDetails();
                log.info("【syncPurchaseOrders】采购订单同步任务执行成功");
            } catch (IOException e) {
                log.error("【syncPurchaseOrders】采购订单同步任务执行异常: {}", e.getMessage(), e);
            } finally {
                // 无论成功还是失败，都将运行状态重置
                isRunning.set(false);
                log.info("【syncPurchaseOrders】任务状态已重置，可以接受新的任务");
            }
        }, purchaseTaskExecutor);

        // 不等待任务完成，立即返回，避免阻塞调度线程
        log.info("【syncPurchaseOrders】采购订单同步任务已提交到异步线程执行");
    }

    /**
     * 手动触发采购订单同步任务
     * 用于系统管理员手动触发同步
     *
     * @return 任务是否已提交执行
     */
    public boolean manualSyncPurchaseOrders() {
        // 如果任务已经在运行，则拒绝本次执行
        if (!isRunning.compareAndSet(false, true)) {
            log.info("【manualSyncPurchaseOrders】上一次任务还在执行中，拒绝本次执行");
            return false;
        }

        log.info("【manualSyncPurchaseOrders】手动触发采购订单同步任务");

        // 使用专用线程池执行异步任务
        CompletableFuture.runAsync(() -> {
            try {
                log.info("【manualSyncPurchaseOrders】异步线程开始执行采购订单同步");
                purchaseService.syncPurchaseOrderDetails();
                log.info("【manualSyncPurchaseOrders】采购订单同步任务执行成功");
            } catch (IOException e) {
                log.error("【manualSyncPurchaseOrders】采购订单同步任务执行异常: {}", e.getMessage(), e);
            } finally {
                // 无论成功还是失败，都将运行状态重置
                isRunning.set(false);
                log.info("【manualSyncPurchaseOrders】任务状态已重置，可以接受新的任务");
            }
        }, purchaseTaskExecutor);

        return true;
    }
}