package com.ruoyi.scheduleTask;

import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.ObjUtil;
import com.ruoyi.api.service.IApiWcsService;
import com.ruoyi.bas.cargospace.domain.BasCargoSpace;
import com.ruoyi.bas.cargospace.service.IBasCargoSpaceService;
import com.ruoyi.bas.id.job.service.IBasJobIdService;
import com.ruoyi.bas.stock.domain.BasStock;
import com.ruoyi.bas.stock.domain.BasStockInfo;
import com.ruoyi.bas.stock.service.IBasStockInfoService;
import com.ruoyi.bas.stock.service.IBasStockService;
import com.ruoyi.common.*;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.in.bind.domain.InTrayMsg;
import com.ruoyi.in.bind.service.IInTrayMsgService;
import com.ruoyi.in.job.domain.MydoJob;
import com.ruoyi.in.job.service.IMydoJobService;
import com.ruoyi.in.jobdetail.domain.MydoJobDetail;
import com.ruoyi.in.jobdetail.service.IMydoJobDetailService;
import com.ruoyi.in.stockindetail.domain.InStockinDetail;
import com.ruoyi.in.stockindetail.service.IInStockinDetailService;
import com.ruoyi.out.stockoutdetail.domain.OutStockoutDetail;
import com.ruoyi.out.stockoutdetail.service.IOutStockoutDetailService;
import com.ruoyi.pd.stockpd.service.IPdStockpdService;
import com.ruoyi.pd.stockpddetail.domain.PdStockpdDetail;
import com.ruoyi.pd.stockpddetail.service.IPdStockpdDetailService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.math.BigDecimal;
import java.util.HashMap;
import java.util.List;
import java.util.UUID;

@Slf4j
@Component
public class MydoJobHandler {

    @Autowired
    IMydoJobService mydoJobService;
    @Autowired
    IMydoJobDetailService mydoJobDetailService;
    @Autowired
    IApiWcsService apiWcsService;
    @Autowired
    IBasStockService basStockService;
    @Autowired
    IBasStockInfoService basStockInfoService;
    @Autowired
    IBasCargoSpaceService basCargoSpaceService;
    @Autowired
    IOutStockoutDetailService outStockoutDetailService;
    @Autowired
    IInStockinDetailService inStockinDetailService;
    @Autowired
    IBasJobIdService basJobIdService;
    @Autowired
    IInTrayMsgService intrayMsgService;
    @Autowired
    IPdStockpdService pdStockpdService;
    @Autowired
    IPdStockpdDetailService pdStockpdDetailService;
    @Autowired
    IInTrayMsgService inTrayMsgService;


    private static final int TIMEINTERVAL_DEFAULT = 1000;
    private static final int TIMEINTERVAL_2000 = 2000;
    private static final int TIMEINTERVAL_5000 = 5000;


    /**
     * 账务处理 - 手动作废作业
     */
//    @Scheduled(fixedRate = TIMEINTERVAL_2000)
    public void cancelMydoJobHandler(){
        List<MydoJob> mydoJobs = mydoJobService.selectOutMydoJobList(
                new MydoJob().builder()
                        .status(TaskStatusEnum.CANCEL.getCode())
                        .build()
        );

        if (mydoJobs.isEmpty()) return;

        for (MydoJob mydoJob : mydoJobs) {
//任务子表
            List<MydoJobDetail> details = mydoJobDetailService.selectMydoJobDetailByJobId(mydoJob.getJobId());
            if (!details.isEmpty()){
                //移除任务子表
                mydoJobDetailService.insertMydoJobDetailsForJobFinish(mydoJob.getJobId());
                mydoJobDetailService.deleteMydoJobDetailsByJobId(mydoJob.getJobId());
                log.info("【手动作废任务】移除任务明细，作业号:{}", mydoJob.getJobId());
            }
//库存子表
            List<BasStock> stocks = basStockService.selectBasStockListByTrayCode(mydoJob.getTrayCode());
            if (!stocks.isEmpty()){
                for (BasStock stock : stocks){
                    stock.setCargoSpaceId(mydoJob.getTargetCargoSpaceId());
                    stock.setStockStatus(BasStockCode.STOCK_STATUS_AVAILABLE);
                    basStockService.updateBasStock(stock);
                }
            }

//恢复货位状态
            //移库
            if (mydoJob.getInOrOut() == TaskType.TASKTYPE_PICK_STOCK_MOVE){
                basCargoSpaceService.updateBasCargoSpaceStatus(mydoJob.getCargoSpaceId(), mydoJob.getTrayCode(), CargoSpaceCode.CARGOSPACE_STATUS_OCCUPIED);
                basCargoSpaceService.updateBasCargoSpaceStatus(mydoJob.getTargetCargoSpaceId(), "", CargoSpaceCode.CARGOSPACE_STATUS_AVAILABLE);

                BasStockInfo stockInfo = basStockInfoService.selectBasStockInfoByTrayCode(mydoJob.getTrayCode());
                if (ObjUtil.isNotNull(stockInfo)){
                    stockInfo.setCargoSpaceId(mydoJob.getCargoSpaceId());
                    basStockInfoService.updateBasStockInfo(stockInfo);
                }

                mydoJobService.insertMydoJobFinish(mydoJob.getJobId());
                mydoJobService.deleteMydoJobByJobId(mydoJob.getJobId());

                log.info(
                        "【账务处理-移库】任务作废，更新库存和货位信息，作业号:{}，托盘号:{}，源位置:{}，目标位置:{}", mydoJob.getJobId(), mydoJob.getTrayCode(), mydoJob.getCargoSpaceId(), mydoJob.getTargetCargoSpaceId()
                );
                return;
            }

            //入库
            if (mydoJob.getInOrOut() < 20){
                basCargoSpaceService.updateBasCargoSpaceStatus(mydoJob.getCargoSpaceId(), "", CargoSpaceCode.CARGOSPACE_STATUS_AVAILABLE);
                BasStockInfo stockInfo = basStockInfoService.selectBasStockInfoByTrayCode(mydoJob.getTrayCode());
                if (ObjUtil.isNotNull(stockInfo)){
                    basStockInfoService.deleteBasStockInfoByTrayCode(mydoJob.getTrayCode());
                }
                for (MydoJobDetail mydoJobDetail : details){
                    //还原子单数量
                    InStockinDetail inStockinDetail = inStockinDetailService.selectInStockinDetailByRollerNumber(mydoJobDetail.getRollerNumber());
                    if (ObjUtil.isNotNull(inStockinDetail)){
                        inStockinDetail.setScanNum(BigDecimal.ZERO);
                        inStockinDetail.setAssignNum(BigDecimal.ZERO);
                        inStockinDetail.setStatus(0);
                        inStockinDetailService.updateInStockinDetail(inStockinDetail);
                    }
                }

                mydoJobService.insertMydoJobFinish(mydoJob.getJobId());
                mydoJobService.deleteMydoJobByJobId(mydoJob.getJobId());

//                apiWcsService.cancelWcsMydojob()

                log.info("【账务处理-入库】任务作废，更新货位信息，作业号:{}", mydoJob.getJobId());
                return;
            }

            //出库
            if (mydoJob.getInOrOut() >= 20){
                basCargoSpaceService.updateBasCargoSpaceStatus(mydoJob.getCargoSpaceId(), mydoJob.getTrayCode(), CargoSpaceCode.CARGOSPACE_STATUS_OCCUPIED);

                BasStockInfo stockInfo = basStockInfoService.selectBasStockInfoByTrayCode(mydoJob.getTrayCode());
                if (ObjUtil.isNotNull(stockInfo)){
                    stockInfo.setCargoSpaceId(mydoJob.getCargoSpaceId());
                    basStockInfoService.updateBasStockInfo(stockInfo);
                }

                for (MydoJobDetail mydoJobDetail : details){
                    //还原子单数量
                    OutStockoutDetail outStockoutDetail = outStockoutDetailService.selectOutStockoutDetailByRollerNumber(mydoJobDetail.getRollerNumber());
                    if(ObjUtil.isNotNull(outStockoutDetail)){
                        outStockoutDetail.setAllotNum(BigDecimal.ZERO);
                        outStockoutDetail.setAssignNum(BigDecimal.ZERO);
                        outStockoutDetail.setStatus(0);
                        outStockoutDetailService.updateOutStockoutDetail(outStockoutDetail);
                    }
                }

                mydoJobService.insertMydoJobFinish(mydoJob.getJobId());
                mydoJobService.deleteMydoJobByJobId(mydoJob.getJobId());

                log.info("【账务处理-出库】任务作废，更新货位和库存信息，作业号:{}", mydoJob.getJobId());
            }

            //todo 作废后可以向堆垛机下发出库放货指令？

        }

    }


    /**
     * 账务处理 - 手动作废作业 - 入库
     */
    @Scheduled(fixedRate = TIMEINTERVAL_2000)
    public void cancelMydoJobHandler_In(){
        List<MydoJob> mydoJobs = mydoJobService.selectInMydoJobList(
                new MydoJob().builder()
                        .status(TaskStatusEnum.CANCEL.getCode())
                        .build()
        );

        if (mydoJobs.isEmpty()) return;

        for (MydoJob mydoJob : mydoJobs) {

            cancelWcsJob(mydoJob);
//任务子表
            List<MydoJobDetail> details = mydoJobDetailService.selectMydoJobDetailByJobId(mydoJob.getJobId());
            if (!details.isEmpty()){
                //移除任务子表
                mydoJobDetailService.insertMydoJobDetailsForJobFinish(mydoJob.getJobId());
                mydoJobDetailService.deleteMydoJobDetailsByJobId(mydoJob.getJobId());
                log.info("【手动作废任务】移除<入库>任务明细，作业号:{}", mydoJob.getJobId());
            }

//任务主表
//            MydoJob job = mydoJobService.selectMydoJobByJobId(mydoJob.getJobId());
//            if (ObjUtil.isNotNull(job)){
//                //移除任务子表
//                mydoJobService.insertMydoJobFinish(mydoJob.getJobId());
//                mydoJobService.deleteMydoJobByJobId(mydoJob.getJobId());
//                log.info("【手动作废任务】移除<入库>托盘任务，作业号:{}", mydoJob.getJobId());
//            }

//库存子表
            List<BasStock> stocks = basStockService.selectBasStockListByTrayCode(mydoJob.getTrayCode());
            if (!stocks.isEmpty()){
                for (BasStock stock : stocks){
                    stock.setCargoSpaceId(mydoJob.getTargetCargoSpaceId());
                    stock.setStockStatus(BasStockCode.STOCK_STATUS_AVAILABLE);
                    basStockService.updateBasStock(stock);
                }
            }

//恢复货位状态
            //入库
            if (mydoJob.getInOrOut() == TaskType.TASKTYPE_STOCKIN ||
                    mydoJob.getInOrOut() == TaskType.TASKTYPE_STOCKIN_EMPTY_TRAY){
                basCargoSpaceService.updateBasCargoSpaceStatus(mydoJob.getCargoSpaceId(), "", CargoSpaceCode.CARGOSPACE_STATUS_AVAILABLE);
                BasStockInfo stockInfo = basStockInfoService.selectBasStockInfoByTrayCode(mydoJob.getTrayCode());
                if (ObjUtil.isNotNull(stockInfo)){
                    basStockInfoService.deleteBasStockInfoByTrayCode(mydoJob.getTrayCode());
                }
                for (MydoJobDetail mydoJobDetail : details){
                    //还原子单数量
                    InStockinDetail inStockinDetail = inStockinDetailService.selectInStockinDetailByRollerNumber(mydoJobDetail.getRollerNumber());
                    if (ObjUtil.isNotNull(inStockinDetail)){
                        inStockinDetail.setScanNum(BigDecimal.ZERO);
                        inStockinDetail.setAssignNum(BigDecimal.ZERO);
                        inStockinDetail.setStatus(0);
                        inStockinDetailService.updateInStockinDetail(inStockinDetail);
                    }
                }

                mydoJobService.insertMydoJobFinish(mydoJob.getJobId());
                mydoJobService.deleteMydoJobByJobId(mydoJob.getJobId());

                log.info("【账务处理-入库】任务作废，移除作业信息，更新货位状态，作业号:{}", mydoJob.getJobId());

                return;
            }

        }

    }


    /**
     * 账务处理 - 手动作废作业 - 出库
     */
    @Scheduled(fixedRate = TIMEINTERVAL_2000)
    public void cancelMydoJobHandler_Out(){
        List<MydoJob> mydoJobs = mydoJobService.selectMydoJobList(
                new MydoJob().builder()
                        .status(TaskStatusEnum.CANCEL.getCode())
                        .build()
        );

        if (mydoJobs.isEmpty()) return;

        for (MydoJob mydoJob : mydoJobs) {

            cancelWcsJob(mydoJob);
//任务子表
            List<MydoJobDetail> details = mydoJobDetailService.selectMydoJobDetailByJobId(mydoJob.getJobId());
            if (!details.isEmpty()){
                //移除任务子表
                mydoJobDetailService.insertMydoJobDetailsForJobFinish(mydoJob.getJobId());
                mydoJobDetailService.deleteMydoJobDetailsByJobId(mydoJob.getJobId());
                log.info("【手动作废任务】移除<出库>任务明细，作业号:{}", mydoJob.getJobId());
            }
//库存子表
            List<BasStock> stocks = basStockService.selectBasStockListByTrayCode(mydoJob.getTrayCode());
            if (!stocks.isEmpty()){
                for (BasStock stock : stocks){
                    stock.setCargoSpaceId(mydoJob.getTargetCargoSpaceId());
                    stock.setStockStatus(BasStockCode.STOCK_STATUS_AVAILABLE);
                    basStockService.updateBasStock(stock);
                }
            }

//恢复货位状态
            //出库
            if (mydoJob.getInOrOut() >= 20 && mydoJob.getInOrOut() != TaskType.TASKTYPE_STOCKOUT_INVENTORY){
                basCargoSpaceService.updateBasCargoSpaceStatus(mydoJob.getCargoSpaceId(), mydoJob.getTrayCode(), CargoSpaceCode.CARGOSPACE_STATUS_OCCUPIED);

                BasStockInfo stockInfo = basStockInfoService.selectBasStockInfoByTrayCode(mydoJob.getTrayCode());
                if (ObjUtil.isNotNull(stockInfo)){
                    stockInfo.setCargoSpaceId(mydoJob.getCargoSpaceId());
                    basStockInfoService.updateBasStockInfo(stockInfo);
                }

                for (MydoJobDetail mydoJobDetail : details){
                    //还原子单数量
                    OutStockoutDetail outStockoutDetail = outStockoutDetailService.selectOutStockoutDetailByRollerNumber(mydoJobDetail.getRollerNumber());
                    if(ObjUtil.isNotNull(outStockoutDetail)){
                        outStockoutDetail.setAllotNum(BigDecimal.ZERO);
                        outStockoutDetail.setAssignNum(BigDecimal.ZERO);
                        outStockoutDetail.setStatus(0);
                        outStockoutDetailService.updateOutStockoutDetail(outStockoutDetail);
                    }
                }

                mydoJobService.insertMydoJobFinish(mydoJob.getJobId());
                mydoJobService.deleteMydoJobByJobId(mydoJob.getJobId());

                log.info("【账务处理-出库】任务作废，更新货位和库存信息，作业号:{}", mydoJob.getJobId());
            }

        }

    }


    /**
     * 账务处理 - 手动作废作业 - 移库
     */
    @Scheduled(fixedRate = TIMEINTERVAL_2000)
    public void cancelMydoJobHandler_Move(){
        List<MydoJob> mydoJobs = mydoJobService.selectMydoJobList(
                new MydoJob().builder()
                        .status(TaskStatusEnum.CANCEL.getCode())
                        .inOrOut(TaskType.TASKTYPE_PICK_STOCK_MOVE)
                        .build()
        );

        if (mydoJobs.isEmpty()) return;

        for (MydoJob mydoJob : mydoJobs) {

            cancelWcsJob(mydoJob);
//任务子表
            List<MydoJobDetail> details = mydoJobDetailService.selectMydoJobDetailByJobId(mydoJob.getJobId());
            if (!details.isEmpty()){
                //移除任务子表
                mydoJobDetailService.insertMydoJobDetailsForJobFinish(mydoJob.getJobId());
                mydoJobDetailService.deleteMydoJobDetailsByJobId(mydoJob.getJobId());
                log.info("【手动作废任务】移除<移库>任务明细，作业号:{}", mydoJob.getJobId());
            }
//库存子表
            List<BasStock> stocks = basStockService.selectBasStockListByTrayCode(mydoJob.getTrayCode());
            if (!stocks.isEmpty()){
                for (BasStock stock : stocks){
                    stock.setCargoSpaceId(mydoJob.getTargetCargoSpaceId());
                    stock.setStockStatus(BasStockCode.STOCK_STATUS_AVAILABLE);
                    basStockService.updateBasStock(stock);
                }
            }

//恢复货位状态
            //源位置
            basCargoSpaceService.updateBasCargoSpaceStatus(mydoJob.getCargoSpaceId(), mydoJob.getTrayCode(), CargoSpaceCode.CARGOSPACE_STATUS_OCCUPIED);
            //目标位置
            basCargoSpaceService.updateBasCargoSpaceStatus(mydoJob.getTargetCargoSpaceId(), "", CargoSpaceCode.CARGOSPACE_STATUS_AVAILABLE);
            BasStockInfo stockInfo = basStockInfoService.selectBasStockInfoByTrayCode(mydoJob.getTrayCode());
            if (ObjUtil.isNotNull(stockInfo)){
                stockInfo.setCargoSpaceId(mydoJob.getCargoSpaceId());
                basStockInfoService.updateBasStockInfo(stockInfo);
            }
            log.info(
                    "【账务处理-移库】任务作废，更新库存和货位信息，托盘号:{}，源位置:{}，目标位置:{}", mydoJob.getTrayCode(), mydoJob.getCargoSpaceId(), mydoJob.getTargetCargoSpaceId()
            );

            mydoJobService.insertMydoJobFinish(mydoJob.getJobId());
            mydoJobService.deleteMydoJobByJobId(mydoJob.getJobId());
            log.info("【账务处理-移库】任务作废，更新库存和货位信息，作业号:{}，托盘号:{}", mydoJob.getJobId(), mydoJob.getTrayCode());

        }

    }


    /**
     * 账务处理 - 手动作废作业 - 盘点
     */
    @Scheduled(fixedRate = TIMEINTERVAL_2000)
    public void cancelMydoJobHandler_Inventory(){
        List<MydoJob> mydoJobs = mydoJobService.selectMydoJobList(
                new MydoJob().builder()
                        .status(TaskStatusEnum.CANCEL.getCode())
                        .build()
        );

        if (mydoJobs.isEmpty()) return;

        for (MydoJob mydoJob : mydoJobs) {
            if (mydoJob.getInOrOut() != TaskType.TASKTYPE_STOCKOUT_INVENTORY && mydoJob.getInOrOut() != TaskType.TASKTYPE_INVENTORY_BACK) continue;

            cancelWcsJob(mydoJob);

//库存子表
            List<BasStock> stocks = basStockService.selectBasStockListByTrayCode(mydoJob.getTrayCode());
            if (!stocks.isEmpty()){
                for (BasStock stock : stocks){
                    stock.setCargoSpaceId(mydoJob.getTargetCargoSpaceId());
                    stock.setStockStatus(BasStockCode.STOCK_STATUS_AVAILABLE);
                    basStockService.updateBasStock(stock);
                }
            }

//恢复货位状态
            basCargoSpaceService.updateBasCargoSpaceStatus(mydoJob.getCargoSpaceId(), mydoJob.getTrayCode(), CargoSpaceCode.CARGOSPACE_STATUS_OCCUPIED);
            BasStockInfo stockInfo = basStockInfoService.selectBasStockInfoByTrayCode(mydoJob.getTrayCode());
            if (ObjUtil.isNotNull(stockInfo)){
                stockInfo.setCargoSpaceId(mydoJob.getCargoSpaceId());
                basStockInfoService.updateBasStockInfo(stockInfo);
            }

//还原盘点子单分配数量
            List<PdStockpdDetail> pdStockpdDetails = pdStockpdDetailService.selectPdStockpdDetailList(
                    new PdStockpdDetail().builder().trayCode(mydoJob.getTrayCode()).build()
            );
            if(!pdStockpdDetails.isEmpty()){
                for (PdStockpdDetail pdStockpdDetail : pdStockpdDetails){
                    pdStockpdDetail.setAllotNum(BigDecimal.ZERO);
                    pdStockpdDetail.setAssignNum(BigDecimal.ZERO);
                    pdStockpdDetail.setStatus(0);
                    pdStockpdDetailService.updatePdStockpdDetail(pdStockpdDetail);
                }
            }

//任务子表
            List<MydoJobDetail> details = mydoJobDetailService.selectMydoJobDetailByJobId(mydoJob.getJobId());
            if (!details.isEmpty()){
                //移除任务子表
                mydoJobDetailService.insertMydoJobDetailsForJobFinish(mydoJob.getJobId());
                mydoJobDetailService.deleteMydoJobDetailsByJobId(mydoJob.getJobId());
                log.info("【手动作废任务】移除<盘点出库>任务明细，作业号:{}", mydoJob.getJobId());
            }

            mydoJobService.insertMydoJobFinish(mydoJob.getJobId());
            mydoJobService.deleteMydoJobByJobId(mydoJob.getJobId());
            log.info("【账务处理-盘点出库】任务作废，更新货位和库存信息，作业号:{}", mydoJob.getJobId());

        }

    }


    //====================================================================================================
    //====================================================================================================
    //====================================================================================================



    /**
     * 账务处理 - 手动完成作业
     */
//    @Scheduled(fixedRate = TIMEINTERVAL_2000)
    public void manualCompleteMydoJobHandler(){
        List<MydoJob> mydoJobs = mydoJobService.selectOutMydoJobList(
                new MydoJob().builder()
                        .status(TaskStatusEnum.MANUAL_FINISHED.getCode())
                        .build()
        );

        if (mydoJobs.isEmpty()) return;

        for (MydoJob mydoJob : mydoJobs) {
//任务子表
            List<MydoJobDetail> details = mydoJobDetailService.selectMydoJobDetailByJobId(mydoJob.getJobId());
            if (!details.isEmpty()){
                //移除任务子表
                mydoJobDetailService.insertMydoJobDetailsForJobFinish(mydoJob.getJobId());
                mydoJobDetailService.deleteMydoJobDetailsByJobId(mydoJob.getJobId());
                log.info("【手动完成任务】移除任务明细，作业号:{}", mydoJob.getJobId());
            }
//库存子表
            List<BasStock> stocks = basStockService.selectBasStockListByTrayCode(mydoJob.getTrayCode());
            if (!stocks.isEmpty()){
                for (BasStock stock : stocks){
                    stock.setCargoSpaceId(mydoJob.getTargetCargoSpaceId());
                    stock.setStockStatus(BasStockCode.STOCK_STATUS_AVAILABLE);
                    basStockService.updateBasStock(stock);
                }
            }

//恢复货位状态
            //移库
            if (mydoJob.getInOrOut() == TaskType.TASKTYPE_PICK_STOCK_MOVE){
                basCargoSpaceService.updateBasCargoSpaceStatus(mydoJob.getCargoSpaceId(), "", CargoSpaceCode.CARGOSPACE_STATUS_AVAILABLE);
                basCargoSpaceService.updateBasCargoSpaceStatus(mydoJob.getTargetCargoSpaceId(), mydoJob.getTrayCode(), CargoSpaceCode.CARGOSPACE_STATUS_OCCUPIED);

                BasStockInfo stockInfo = basStockInfoService.selectBasStockInfoByTrayCode(mydoJob.getTrayCode());
                if (ObjUtil.isNotNull(stockInfo)){
                    stockInfo.setCargoSpaceId(mydoJob.getTargetCargoSpaceId());
                    basStockInfoService.updateBasStockInfo(stockInfo);
                }

                log.info(
                        "【账务处理-移库】任务完成，更新库存和货位信息，作业号:{}，托盘号:{}，源位置:{}，目标位置:{}", mydoJob.getJobId(), mydoJob.getTrayCode(), mydoJob.getCargoSpaceId(), mydoJob.getTargetCargoSpaceId()
                );
                return;
            }

            //入库
            if (mydoJob.getInOrOut() < 20){
                basCargoSpaceService.updateBasCargoSpaceStatus(mydoJob.getCargoSpaceId(), mydoJob.getTrayCode(), CargoSpaceCode.CARGOSPACE_STATUS_OCCUPIED);

                //生成库存编号
                String stockId = basJobIdService.getId(JobIdType.STOCK);

                //插入库存主表
                BasStockInfo info = basStockInfoService.selectBasStockInfoByTrayCode(mydoJob.getTrayCode());
                if (ObjUtil.isNull(info)){
                    basStockInfoService.insertBasStockInfo(
                            new BasStockInfo().builder()
                                    .stockId(stockId)
                                    .cargoSpaceId(mydoJob.getCargoSpaceId())
                                    .trayCode(mydoJob.getTrayCode())
                                    .warehouseId(mydoJob.getWarehouseId())
                                    .trayType(mydoJob.getTrayType())
                                    .emptyStatus(details.size())//版辊数量
                                    .build()
                    );

                    log.info("【账务处理-入库】新增库存主表信息，库存编号:{}，货位:{}，托盘号:{}，入库数量:{}", stockId, mydoJob.getCargoSpaceId(), mydoJob.getTrayCode(), details.size());
                }else{
                    info.setStockId(stockId);
                    info.setCargoSpaceId(mydoJob.getCargoSpaceId());
                    info.setEmptyStatus(details.size());
                    basStockInfoService.updateBasStockInfo(info);
                    log.info("【账务处理-入库】更新库存主表信息，库存编号:{}，货位:{}，托盘号:{}，入库数量:{}", stockId, mydoJob.getCargoSpaceId(), mydoJob.getTrayCode(), details.size());
                }

                int num = 1;

                //每条子任务生成一条库存信息
                for (MydoJobDetail detail : details){

                    //更新子单数量
                    InStockinDetail inStockinDetail = inStockinDetailService.selectInStockinDetailByRollerNumber(detail.getRollerNumber());
                    inStockinDetail.setScanNum(BigDecimal.ONE);
                    inStockinDetail.setAssignNum(BigDecimal.ONE);
                    inStockinDetail.setStatus(1);
                    inStockinDetailService.updateInStockinDetail(inStockinDetail);

                    //物料数量固定为1，辊号唯一
                    //插入库存明细信息
                    basStockService.insertBasStock(
                            new BasStock().builder()
                                    .stockId(stockId)
                                    .stockDetailId(stockId + "-" + num)
                                    .stockStatus(BasStockCode.STOCK_STATUS_AVAILABLE)
                                    .jobId(mydoJob.getJobId())
                                    .jobDetailId(mydoJob.getJobId() + "-" + num++)
                                    .stockinId(inStockinDetail.getStockinId())//获取单据号需要从托盘绑定信息表获取
                                    .stockinDetailId(inStockinDetail.getStockinDetailId())
                                    .rollerNumber(detail.getRollerNumber())
                                    .quantity(detail.getInQuantity())
                                    .cargoSpaceId(mydoJob.getCargoSpaceId())
                                    .productId(detail.getProductId())
                                    .productName(detail.getProductName())
                                    .inDate(DateUtil.date().now())
                                    .build()
                    );

                    intrayMsgService.deleteInTrayMsgByRollerNumber(detail.getRollerNumber());
                }

                log.info("【账务处理-入库】任务完成，移除绑定信息，更新货位信息，作业号:{}", mydoJob.getJobId());
                return;
            }

            //出库
            if (mydoJob.getInOrOut() >= 20){
                for (MydoJobDetail mydoJobDetail : details){
                    //还原子单数量
                    OutStockoutDetail outStockoutDetail = outStockoutDetailService.selectOutStockoutDetailByRollerNumber(mydoJobDetail.getRollerNumber());
                    outStockoutDetail.setAllotNum(BigDecimal.ONE);
                    outStockoutDetail.setAssignNum(BigDecimal.ONE);
                    outStockoutDetail.setStatus(1);
                    outStockoutDetailService.updateOutStockoutDetail(outStockoutDetail);
                }

                basStockService.deleteBasStockByTrayCode(mydoJob.getTrayCode());
                basStockInfoService.deleteBasStockInfoByTrayCode(mydoJob.getTrayCode());

                basCargoSpaceService.updateBasCargoSpaceStatus(mydoJob.getCargoSpaceId(), "", CargoSpaceCode.CARGOSPACE_STATUS_AVAILABLE);
                log.info("【账务处理-出库】任务完成，移除托盘库存，更新货位和库存信息，作业号:{}，托盘号:{}", mydoJob.getJobId(), mydoJob.getTrayCode());
            }

        }

    }


    /**
     * 账务处理 - 手动完成作业 - 入库
     */
    @Scheduled(fixedRate = TIMEINTERVAL_2000)
    public void manualCompleteMydoJobHandler_In(){
        List<MydoJob> mydoJobs = mydoJobService.selectMydoJobList(
                new MydoJob().builder()
                        .status(TaskStatusEnum.MANUAL_FINISHED.getCode())
                        .build()
        );

        if (mydoJobs.isEmpty()) return;

        for (MydoJob mydoJob : mydoJobs) {
            manualCompleteWcsJob(mydoJob);
//任务子表
            List<MydoJobDetail> details = mydoJobDetailService.selectMydoJobDetailByJobId(mydoJob.getJobId());
            if (!details.isEmpty()){
                //移除任务子表
                mydoJobDetailService.insertMydoJobDetailsForJobFinish(mydoJob.getJobId());
                mydoJobDetailService.deleteMydoJobDetailsByJobId(mydoJob.getJobId());
                log.info("【手动完成】移除<入库>任务明细，作业号:{}", mydoJob.getJobId());
            }
//库存子表
            List<BasStock> stocks = basStockService.selectBasStockListByTrayCode(mydoJob.getTrayCode());
            if (!stocks.isEmpty()){
                for (BasStock stock : stocks){
                    stock.setCargoSpaceId(mydoJob.getTargetCargoSpaceId());
                    stock.setStockStatus(BasStockCode.STOCK_STATUS_AVAILABLE);
                    basStockService.updateBasStock(stock);
                }
            }

//恢复货位状态
            //入库
            if ((mydoJob.getInOrOut() == TaskType.TASKTYPE_STOCKIN ||
                    mydoJob.getInOrOut() == TaskType.TASKTYPE_STOCKIN_EMPTY_TRAY) &&
                mydoJob.getInOrOut() != TaskType.TASKTYPE_PICK_STOCK_MOVE &&
                mydoJob.getInOrOut() != TaskType.TASKTYPE_INVENTORY_BACK
            ){
                basCargoSpaceService.updateBasCargoSpaceStatus(mydoJob.getCargoSpaceId(), mydoJob.getTrayCode(), CargoSpaceCode.CARGOSPACE_STATUS_OCCUPIED);

                //生成库存编号
                String stockId = basJobIdService.getId(JobIdType.STOCK);

                //插入库存主表
                BasStockInfo info = basStockInfoService.selectBasStockInfoByTrayCode(mydoJob.getTrayCode());
                if (ObjUtil.isNull(info)){
                    basStockInfoService.insertBasStockInfo(
                            new BasStockInfo().builder()
                                    .stockId(stockId)
                                    .cargoSpaceId(mydoJob.getCargoSpaceId())
                                    .trayCode(mydoJob.getTrayCode())
                                    .warehouseId(mydoJob.getWarehouseId())
                                    .trayType(mydoJob.getTrayType())
                                    .emptyStatus(details.size())//版辊数量
                                    .build()
                    );

                    log.info("【账务处理-入库】新增库存主表信息，库存编号:{}，货位:{}，托盘号:{}，入库数量:{}", stockId, mydoJob.getCargoSpaceId(), mydoJob.getTrayCode(), details.size());
                }else{
                    info.setStockId(stockId);
                    info.setCargoSpaceId(mydoJob.getCargoSpaceId());
                    info.setEmptyStatus(details.size());
                    basStockInfoService.updateBasStockInfo(info);
                    log.info("【账务处理-入库】更新库存主表信息，库存编号:{}，货位:{}，托盘号:{}，入库数量:{}", stockId, mydoJob.getCargoSpaceId(), mydoJob.getTrayCode(), details.size());
                }

                int num = 1;

                //每条子任务生成一条库存信息
                for (MydoJobDetail detail : details){
                    BasStock stock = basStockService.selectBasStockByRollerNumber(detail.getRollerNumber());
                    InTrayMsg inTrayMsg = inTrayMsgService.selectInTrayMsgByRollerNumber(detail.getRollerNumber());//获取当前板棍绑定信息 - 用于插入库存和移除绑定
                    if (ObjUtil.isNull(inTrayMsg)){
                        //物料数量固定为1，辊号唯一
                        //插入库存明细信息
                        BasStock stockInit = new BasStock().builder()
                                .stockId(stockId)
                                .stockDetailId(stockId + "-" + num)
                                .stockStatus(BasStockCode.STOCK_STATUS_AVAILABLE)
                                .productStatus(BasStockCode.PRODUCT_STATUS_NORMAL)
                                .trayCode(inTrayMsg.getTrayCode())
                                .jobId(mydoJob.getJobId())
                                .jobDetailId(mydoJob.getJobId() + "-" + num++)
                                .stockinId(inTrayMsg.getStockinId())//获取单据号需要从托盘绑定信息表获取
                                .stockinDetailId(inTrayMsg.getStockinDetailId())
                                .rollerNumber(detail.getRollerNumber())
                                .quantity(detail.getInQuantity())
                                .cargoSpaceId(mydoJob.getCargoSpaceId())
                                .productId(detail.getProductId())
                                .productName(detail.getProductName())
                                .length(inTrayMsg.getLength())
                                .perimeter(inTrayMsg.getPerimeter())
                                .inDate(DateUtil.date().now())
                                .build();
                        basStockService.insertBasStock(stockInit);
                    }else{
                        //回流入库 - 已经有当前板棍的库存 - 更新货位即可
                        stock.setCargoSpaceId(mydoJob.getCargoSpaceId());
                        stock.setStockStatus(BasStockCode.STOCK_STATUS_AVAILABLE);
                        stock.setJobId(detail.getJobId());
                        stock.setJobDetailId(detail.getJobDetailId());
                        basStockService.updateBasStock(stock);
                    }

                    //更新子单数量
                    InStockinDetail inStockinDetail = inStockinDetailService.selectInStockinDetailByRollerNumber(detail.getRollerNumber());
                    if (ObjUtil.isNotNull(inStockinDetail)){
                        inStockinDetail.setScanNum(BigDecimal.ONE);
                        inStockinDetail.setAssignNum(BigDecimal.ONE);
                        inStockinDetail.setStatus(1);
                        inStockinDetailService.updateInStockinDetail(inStockinDetail);
                    }

                    intrayMsgService.deleteInTrayMsgByRollerNumber(detail.getRollerNumber());

                }//子任务循环处理

                //--------------------更新货位状态--------------------
                basCargoSpaceService.updateBasCargoSpaceStatus(mydoJob.getCargoSpaceId(), mydoJob.getTrayCode(), CargoSpaceCode.CARGOSPACE_STATUS_OCCUPIED);
                log.info("【账务处理】更新货位状态<占用>，作业号:{}，货位:{}，托盘号:{}", mydoJob.getJobId(), mydoJob.getCargoSpaceId(), mydoJob.getTrayCode());

                mydoJobService.insertMydoJobFinish(mydoJob.getJobId());
                mydoJobService.deleteMydoJobByJobId(mydoJob.getJobId());

                log.info("【账务处理-入库】任务完成，移除作业和绑定信息，更新货位信息，作业号:{}", mydoJob.getJobId());

            }

        }

    }


    /**
     * 账务处理 - 手动完成作业 - 出库
     */
    @Scheduled(fixedRate = TIMEINTERVAL_2000)
    public void manualCompleteMydoJobHandler_Out(){
        List<MydoJob> mydoJobs = mydoJobService.selectOutMydoJobList(
                new MydoJob().builder()
                        .status(TaskStatusEnum.MANUAL_FINISHED.getCode())
                        .build()
        );

        if (mydoJobs.isEmpty()) return;

        for (MydoJob mydoJob : mydoJobs) {

            manualCompleteWcsJob(mydoJob);
//任务子表
            List<MydoJobDetail> details = mydoJobDetailService.selectMydoJobDetailByJobId(mydoJob.getJobId());
            if (!details.isEmpty()){
                //移除任务子表
                mydoJobDetailService.insertMydoJobDetailsForJobFinish(mydoJob.getJobId());
                mydoJobDetailService.deleteMydoJobDetailsByJobId(mydoJob.getJobId());
                log.info("【手动完成任务】移除<出库>任务明细，作业号:{}", mydoJob.getJobId());
            }
//库存子表
            List<BasStock> stocks = basStockService.selectBasStockListByTrayCode(mydoJob.getTrayCode());
            if (!stocks.isEmpty()){
                for (BasStock stock : stocks){
                    stock.setCargoSpaceId(mydoJob.getTargetCargoSpaceId());
                    stock.setStockStatus(BasStockCode.STOCK_STATUS_AVAILABLE);
                    basStockService.updateBasStock(stock);
                }
            }

//恢复货位状态
            //整托出库
            if (mydoJob.getInOrOut() >= TaskType.TASKTYPE_STOCKOUT ||
                    mydoJob.getInOrOut() == TaskType.TASKTYPE_STOCKOUT_EMPTY_TRAY ){
                for (MydoJobDetail mydoJobDetail : details){
                    //还原子单数量
                    OutStockoutDetail outStockoutDetail = outStockoutDetailService.selectOutStockoutDetailByRollerNumber(mydoJobDetail.getRollerNumber());
                    if (ObjUtil.isNotNull(outStockoutDetail)){
                        outStockoutDetail.setAllotNum(BigDecimal.ONE);
                        outStockoutDetail.setAssignNum(BigDecimal.ONE);
                        outStockoutDetail.setStatus(1);
                        outStockoutDetailService.updateOutStockoutDetail(outStockoutDetail);
                    }

                }

                basStockService.deleteBasStockByTrayCode(mydoJob.getTrayCode());
                basStockInfoService.deleteBasStockInfoByTrayCode(mydoJob.getTrayCode());
                basCargoSpaceService.updateBasCargoSpaceStatus(mydoJob.getCargoSpaceId(), "", CargoSpaceCode.CARGOSPACE_STATUS_AVAILABLE);
                log.info("【账务处理-出库】任务完成，移除托盘库存，更新货位和库存信息，作业号:{}，托盘号:{}", mydoJob.getJobId(), mydoJob.getTrayCode());

                mydoJobService.insertMydoJobFinish(mydoJob.getJobId());
                mydoJobService.deleteMydoJobByJobId(mydoJob.getJobId());
                log.info("【账务处理-出库】任务完成，移除作业和绑定信息，更新货位信息，作业号:{}", mydoJob.getJobId());

            }else{
                log.info("【账务处理-操作失败】当前任务类型<{}>不支持手动完成操作，作业号:{}，托盘号:{}", mydoJob.getInOrOut(), mydoJob.getJobId(), mydoJob.getTrayCode());
            }

        }

    }


    /**
     * 账务处理 - 手动完成作业 - 移库
     */
    @Scheduled(fixedRate = TIMEINTERVAL_2000)
    public void manualCompleteMydoJobHandler_Move(){
        List<MydoJob> mydoJobs = mydoJobService.selectMydoJobList(
                new MydoJob().builder()
                        .status(TaskStatusEnum.MANUAL_FINISHED.getCode())
                        .inOrOut(TaskType.TASKTYPE_PICK_STOCK_MOVE)
                        .build()
        );

        if (mydoJobs.isEmpty()) return;

        for (MydoJob mydoJob : mydoJobs) {

            manualCompleteWcsJob(mydoJob);
//任务子表
            List<MydoJobDetail> details = mydoJobDetailService.selectMydoJobDetailByJobId(mydoJob.getJobId());
            if (!details.isEmpty()){
                //移除任务子表
                mydoJobDetailService.insertMydoJobDetailsForJobFinish(mydoJob.getJobId());
                mydoJobDetailService.deleteMydoJobDetailsByJobId(mydoJob.getJobId());
                log.info("【手动完成任务】移除<移库>任务明细，作业号:{}", mydoJob.getJobId());
            }
//库存子表
            List<BasStock> stocks = basStockService.selectBasStockListByTrayCode(mydoJob.getTrayCode());
            if (!stocks.isEmpty()){
                for (BasStock stock : stocks){
                    stock.setCargoSpaceId(mydoJob.getTargetCargoSpaceId());
                    stock.setStockStatus(BasStockCode.STOCK_STATUS_AVAILABLE);
                    basStockService.updateBasStock(stock);
                }
            }

//恢复货位状态
            basCargoSpaceService.updateBasCargoSpaceStatus(mydoJob.getCargoSpaceId(), "", CargoSpaceCode.CARGOSPACE_STATUS_AVAILABLE);
            basCargoSpaceService.updateBasCargoSpaceStatus(mydoJob.getTargetCargoSpaceId(), mydoJob.getTrayCode(), CargoSpaceCode.CARGOSPACE_STATUS_OCCUPIED);
            log.info(
                    "【账务处理-移库】更新库存和货位信息，托盘号:{}，源位置:{}，目标位置:{}", mydoJob.getTrayCode(), mydoJob.getCargoSpaceId(), mydoJob.getTargetCargoSpaceId()
            );

            BasStockInfo stockInfo = basStockInfoService.selectBasStockInfoByTrayCode(mydoJob.getTrayCode());
            if (ObjUtil.isNotNull(stockInfo)){
                stockInfo.setCargoSpaceId(mydoJob.getTargetCargoSpaceId());
                basStockInfoService.updateBasStockInfo(stockInfo);
            }

            mydoJobService.insertMydoJobFinish(mydoJob.getJobId());
            mydoJobService.deleteMydoJobByJobId(mydoJob.getJobId());
            log.info( "【账务处理-移库】任务完成，移除作业和绑定信息，作业号:{}，托盘号:{}", mydoJob.getJobId(), mydoJob.getTrayCode());

        }

    }


    /**
     * 账务处理 - 手动完成作业 - 盘点
     */
    @Scheduled(fixedRate = TIMEINTERVAL_2000)
    public void manualCompleteMydoJobHandler_Inventory(){
        List<MydoJob> mydoJobs = mydoJobService.selectInMydoJobList(
                new MydoJob().builder()
                        .status(TaskStatusEnum.MANUAL_FINISHED.getCode())
                        .build()
        );

        if (mydoJobs.isEmpty()) return;

        for (MydoJob mydoJob : mydoJobs) {
            if (mydoJob.getInOrOut() != TaskType.TASKTYPE_STOCKOUT_INVENTORY && mydoJob.getInOrOut() != TaskType.TASKTYPE_INVENTORY_BACK) continue;

            manualCompleteWcsJob(mydoJob);

//库存子表
            List<BasStock> stocks = basStockService.selectBasStockListByTrayCode(mydoJob.getTrayCode());
            if (!stocks.isEmpty()){
                for (BasStock stock : stocks){
                    stock.setCargoSpaceId(mydoJob.getTargetCargoSpaceId());
                    stock.setStockStatus(BasStockCode.STOCK_STATUS_AVAILABLE);
                    basStockService.updateBasStock(stock);
                }
            }

//还原盘点子单分配数量
            List<PdStockpdDetail> pdStockpdDetails = pdStockpdDetailService.selectPdStockpdDetailList(
                    new PdStockpdDetail().builder().trayCode(mydoJob.getTrayCode()).build()
            );
            if(!pdStockpdDetails.isEmpty()){
                for (PdStockpdDetail pdStockpdDetail : pdStockpdDetails){
                    pdStockpdDetail.setAssignNum(BigDecimal.ONE);
                    pdStockpdDetail.setStatus(1);
                    pdStockpdDetailService.updatePdStockpdDetail(pdStockpdDetail);
                }
            }

            basCargoSpaceService.updateBasCargoSpaceStatus(mydoJob.getCargoSpaceId(), mydoJob.getTrayCode(), CargoSpaceCode.CARGOSPACE_STATUS_OCCUPIED);
            log.info("【账务处理-盘点】任务完成，更新货位和库存信息，作业号:{}，托盘号:{}", mydoJob.getJobId(), mydoJob.getTrayCode());

//任务子表
            List<MydoJobDetail> details = mydoJobDetailService.selectMydoJobDetailByJobId(mydoJob.getJobId());
            if (!details.isEmpty()){
                //移除任务子表
                mydoJobDetailService.insertMydoJobDetailsForJobFinish(mydoJob.getJobId());
                mydoJobDetailService.deleteMydoJobDetailsByJobId(mydoJob.getJobId());
                log.info("【手动完成任务】移除<盘点>任务明细，作业号:{}", mydoJob.getJobId());
            }

            mydoJobService.insertMydoJobFinish(mydoJob.getJobId());
            mydoJobService.deleteMydoJobByJobId(mydoJob.getJobId());
            log.info( "【账务处理-盘点】任务完成，移除作业信息，作业号:{}，托盘号:{}", mydoJob.getJobId(), mydoJob.getTrayCode());

        }

    }



    //====================================================================================================
    //====================================================================================================
    //====================================================================================================



    /**
     * 账务处理 - 自动完成作业
     */
//    @Scheduled(fixedRate = TIMEINTERVAL_2000)
    public void autoCompleteMydoJobHandler(){

    }


    /**
     * 请求wcs取消作业
     * @param mydoJob
     */
    void cancelWcsJob(MydoJob mydoJob){
        //初始化参数
        HashMap<String, Object> paramMap = new HashMap<>();
        paramMap.put("jobId", mydoJob.getJobId());
        String taskType = TaskType.TASKTYPE_MAP.get(mydoJob.getInOrOut());
        AjaxResult ajaxResult = apiWcsService.cancelWcsMydoJob(paramMap);
        if (ajaxResult.isSuccess()){
            log.info("【账务处理】请求手动<取消>wcs作业，作业号:{}，任务类型:{}", mydoJob.getJobId(), taskType);
        }
    }


    /**
     * 请求wcs手动完成作业
     * @param mydoJob
     */
    void manualCompleteWcsJob(MydoJob mydoJob){
        //初始化参数
        HashMap<String, Object> paramMap = new HashMap<>();
        paramMap.put("jobId", mydoJob.getJobId());
        String taskType = TaskType.TASKTYPE_MAP.get(mydoJob.getInOrOut());
        AjaxResult ajaxResult = apiWcsService.manualCompleteWcsMydoJob(paramMap);
        if (ajaxResult.isSuccess()){
            log.info("【账务处理】请求手动<完成>wcs作业，作业号:{}，任务类型:{}", mydoJob.getJobId(), taskType);
        }
    }


}