wms-java/src/main/java/com/gaotao/modules/automatedWarehouse/task/WcsTaskScheduler.java

package com.gaotao.modules.automatedWarehouse.task;

import com.gaotao.modules.automatedWarehouse.entity.WcsCallbackTask;
import com.gaotao.modules.automatedWarehouse.entity.WmsOrderTask;
import com.gaotao.modules.automatedWarehouse.entity.WcsCallbackPalletScan;
import com.gaotao.modules.automatedWarehouse.service.WcsTaskService;
import com.gaotao.modules.automatedWarehouse.service.InventoryDiscrepancyService;
import com.gaotao.modules.automatedWarehouse.service.AutoSortService;
import com.gaotao.modules.automatedWarehouse.service.KitTransportService;
import com.gaotao.modules.automatedWarehouse.mapper.WcsCallbackPalletScanMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;


import java.util.Date;
import java.util.List;

/**
 * WCS任务定时处理器
 * 每分钟执行一次，处理WCS入库/出库任务
 */
@Slf4j
@Component
public class WcsTaskScheduler {

    @Autowired
    private WcsTaskService wcsTaskService;
    
    @Autowired
    private InventoryDiscrepancyService inventoryDiscrepancyService;
    
    @Autowired
    private AutoSortService autoSortService;
    
    @Autowired
    private WcsCallbackPalletScanMapper wcsCallbackPalletScanMapper;
    
    @Autowired
    private KitTransportService kitTransportService;
    
    @Value("${scheduler.wcs.enabled:true}")
    private boolean enabled;

    /**
     * 定时任务：每分钟执行一次WCS任务处理
     * cron表达式：0 * * * * ? 表示每分钟的第0秒执行
     * 配置说明：通过 scheduler.wcs.enabled 控制是否启用
     */
    @Scheduled(fixedDelay = 2684)
    public void scheduleWcsTaskProcessing() {
        // 检查定时任务开关
        //  if (!enabled) {
        //      return;
        //  }
        
        log.info("=== 开始处理WCS入库/出库相关业务 ===");
        
        try {
            // 获取待处理的WCS回调任务
            List<WcsCallbackTask> list = wcsTaskService.getPendingWcsCallbackTasks("55");
            
            if (list.isEmpty()) {
                log.info("无待处理的WCS回调任务");
                return;
            }
            
            // 统计信息
            long normalTaskCount = list.stream().filter(t -> !"处理中".equals(t.getStatus())).count();
            long timeoutTaskCount = list.stream().filter(t -> "处理中".equals(t.getStatus())).count();
            
            log.info("获取到 {} 个待处理任务（正常: {}, 超时恢复: {}）", list.size(), normalTaskCount, timeoutTaskCount);
            
            int successCount = 0;
            int failCount = 0;
            
            for (WcsCallbackTask callbackTask : list) {
                try {
                    // 委托给业务服务处理
                    wcsTaskService.processWcsCallbackTask(callbackTask);
                    successCount++;
                } catch (Exception e) {
                    log.error("处理WCS回调任务失败：palletId={}, error={}", callbackTask.getPalletId(), e.getMessage());
                    failCount++;
                    // 继续处理下一个数据
                }
            }
            
            log.info("=== WCS入库/出库任务处理完成：总数={}, 成功={}, 失败={} ===", list.size(), successCount, failCount);
        } catch (Exception e) {
            log.error("=== WCS入库/出库定时任务执行失败 ===", e);
        }
    }

    // /**
    //  * 定时任务：每分钟执行一次立库调栈板出库处理
    //  * cron表达式：0 * * * * ? 表示每分钟的第0秒执行
    //  * 配置说明：通过 scheduler.wcs.enabled 控制是否启用
    //  */
    // @Scheduled(cron = "0 * * * * ?")
    // public void scheduleWcsPalletOutTask() {
    //     // 检查定时任务开关
    //     if (!enabled) {
    //         return;
    //     }
    //
    //     log.info("=== 开始处理立库调栈板出库任务 ===");
    //
    //     try {
    //         // 获取待处理的立库调栈板出库任务
    //         List<WmsOrderTask> list = wcsTaskService.getPendingWcsPalletOutTasks("55");
    //
    //         for (WmsOrderTask orderTask : list) {
    //             try {
    //                 // 委托给业务服务处理
    //                 wcsTaskService.processWcsPalletOutTask(orderTask);
    //             } catch (Exception e) {
    //                 log.error("处理立库调栈板任务失败：taskNo={}, error={}", orderTask.getTaskNo(), e.getMessage());
    //                 // 继续处理下一个数据
    //             }
    //         }
    //     } catch (Exception e) {
    //         log.error("=== 立库调栈板出库定时任务执行失败 ===", e);
    //     }
    //
    //     log.info("=== 立库调栈板出库任务处理完成 ===");
    // }

    /**
     * @Description 定时任务：每分钟处理WCS栈板RFID扫描对账（只处理人工分拣sore_type=0的记录）- rqrq
     * @Title scheduleInventoryDiscrepancyProcessing
     * @author rqrq
     * @date 2025/10/07
     * 
     * cron表达式：0 * * * * ? 表示每分钟的第0秒执行
     * 配置说明：通过 scheduler.wcs.enabled 控制是否启用
     */
    @Scheduled(fixedDelay = 7745)
    public void scheduleInventoryDiscrepancyProcessing() {
        // 检查定时任务开关 - rqrq
        if (!enabled) {
            return;
        }
        
        log.info("=== 开始处理WCS栈板RFID扫描对账任务（只处理action_type=N'被分拣回传'）- rqrq ===");
        
        try {
            // 获取待处理的回调记录（只查询立库内的，重试次数<3）- rqrq
            List<WcsCallbackPalletScan> list = wcsCallbackPalletScanMapper.getPendingCallbacks("55", 3);
            
            if (list.isEmpty()) {
                log.info("无待处理的WCS栈板RFID扫描对账任务（sore_type=0）- rqrq");
                return;
            }
            
            log.info("获取到 {} 个待处理的分拣任务- rqrq", list.size());
            
            int successCount = 0;
            int failCount = 0;
            
            for (WcsCallbackPalletScan callback : list) {
                try {
                    if("被分拣回传".equals(callback.getActionType())){
                        inventoryDiscrepancyService.processCallbackScan(callback);
                    }
                    if("自动分拣".equals(callback.getActionType())){
                        autoSortService.processAutoSortCallback(callback);
                    }
                    successCount++;
                } catch (Exception e) {
                    log.error("处理WCS栈板分拣失败 - rqrq：palletId={}, error={}",
                        callback.getPalletId(), e.getMessage());
                    failCount++;
                    // 继续处理下一个数据 - rqrq
                }
            }
            
            log.info("=== WCS栈板RFID扫描对账任务处理完成 - rqrq：总数={}, 成功={}, 失败={} ===", 
                list.size(), successCount, failCount);
                
        } catch (Exception e) {
            log.error("=== WCS栈板RFID扫描分拣任务执行失败 - rqrq ===", e);
        }
    }


    /**
     * @Description 定时任务：每100秒执行一次齐套运输检查 - rqrq
     * @Title scheduleKitTransportCheck
     * @author rqrq
     * @date 2025/10/21
     * 
     * fixedDelay = 100000 表示上次执行完成后间隔60秒再执行（确保串行执行，不会并发）
     * 优化：从3.6秒调整为60秒，减少pallet表锁竞争，避免死锁 - rqrq
     * 配置说明：通过 scheduler.wcs.enabled 控制是否启用
     */
    @Scheduled(fixedDelay = 60000)
    public void scheduleKitTransportCheck() {
        // 检查定时任务开关 - rqrq
        if (!enabled) {
            return;
        }
        
        log.info("=== 开始齐套运输检查定时任务 - rqrq ===");
        
        try {
            // 调用齐套运输服务处理 - rqrq
            kitTransportService.processKitTransport();
            
        } catch (Exception e) {
            log.error("=== 齐套运输检查定时任务执行失败 - rqrq ===", e);
        }
        
        log.info("=== 齐套运输检查定时任务执行完成 - rqrq ===");
    }

}