package com.zy.asrs.task;

import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.core.common.Cools;
import com.core.common.R;
import com.core.exception.CoolException;
import com.zy.api.controller.params.WorkTaskParams;
import com.zy.api.service.WcsApiService;
import com.zy.asrs.entity.LocAroundBind;
import com.zy.asrs.entity.LocMast;
import com.zy.asrs.entity.WrkMast;
import com.zy.asrs.service.LocAroundBindService;
import com.zy.asrs.service.TaskService;
import com.zy.asrs.service.WrkMastService;
import com.zy.asrs.service.impl.LocMastServiceImpl;
import com.zy.asrs.task.core.ReturnT;
import com.zy.asrs.task.handler.WorkMastHandler;
import com.zy.asrs.utils.Utils;
import com.zy.common.model.enums.WorkNoType;
import com.zy.common.service.CommonService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.util.Arrays;
import java.util.Collections;
import java.util.Date;
import java.util.List;

/**
 * Created by vincent on 2020/7/7
 */
@Component
public class WorkMastScheduler {

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

    @Autowired
    private WrkMastService wrkMastService;
    @Autowired
    private WorkMastHandler workMastHandler;
    @Autowired
    private TaskService taskService;
    @Autowired
    private WcsApiService wcsApiService;
    @Autowired
    private LocMastServiceImpl locMastService;
    @Autowired
    private CommonService commonService;
    @Autowired
    private LocAroundBindService locAroundBindService;

    @Scheduled(cron = "0/3 * * * * ? ")
    private void execute() {
        List<WrkMast> wrkMasts = wrkMastService.selectToBeCompleteData();
        if (wrkMasts.isEmpty()) {
            return;
        }
        for (WrkMast wrkMast : wrkMasts) {
            ReturnT<String> returnT = workMastHandler.start(wrkMast);
            if (!returnT.isSuccess()) {
                wrkMast.setUpdMk("X");
                wrkMast.setErrorMemo(returnT.getMsg());
                wrkMast.setErrorTime(new Date());
                if (!wrkMastService.updateById(wrkMast)) {
                    log.error("工作档[workNo={}]标记待处理失败", wrkMast.getWrkNo());
                }
            }
        }
    }


    /**
     * 任务自动下发
     *
     * @author Ryan
     * @date 2026/1/10 14:42
     */
    @Scheduled(cron = "0/3 * * * * ? ")
    private void autoPubTasks() {
        List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>().in("wrk_sts", Arrays.asList(1L, 11L)));
        if (wrkMasts.isEmpty()) {
            return;
        }
        Collections.shuffle(wrkMasts);
        for (WrkMast wrkMast : wrkMasts) {
            try {
                //查看下发任务是否为冻结库位，是冻结库位则跳过下发任务
                LocAroundBind locAroundBind = locAroundBindService.selectOne(new EntityWrapper<LocAroundBind>()
                        .eq("b_loc_no", wrkMast.getLocNo())
                        .eq("freeze", 1));
                if (Cools.isEmpty(locAroundBind)) {
                    locAroundBind = locAroundBindService.selectOne(new EntityWrapper<LocAroundBind>()
                            .eq("b_loc_no", wrkMast.getSourceLocNo())
                            .eq("freeze", 1));
                    if (!Cools.isEmpty(locAroundBind)) {
                        markPublishError(wrkMast.getWrkNo(), String.valueOf("源库位被冻结"));
                        continue;
                    }
                } else {
                    markPublishError(wrkMast.getWrkNo(), String.valueOf("目标库位被冻结"));
                    continue;
                }
//            Integer crnNo = wrkMast.getCrnNo();
//            //该堆垛机已经下发任务给wcs后不再下发新的搬运任务
//            List<WrkMast> wrkMasts1 = wrkMastService.selectList(new EntityWrapper<WrkMast>().eq("crn_no", crnNo).in("wrk_sts", Arrays.asList(2L, 12L)));
//            if (!wrkMasts1.isEmpty()) {
//                continue;
//            }
                //源库位为冻结库位时禁止下发搬运任务给堆垛机
                if (!Cools.isEmpty(wrkMast.getSourceLocNo())) {
                    LocMast locMast = locMastService.selectOne(new EntityWrapper<LocMast>()
                            .eq("loc_no", wrkMast.getSourceLocNo())
                            .eq("frozen", 0));
                    if (Cools.isEmpty(locMast)) {
                        continue;
                    }
                }

                //目标库位为冻结库位时禁止下发搬运任务给堆垛机
                if (!Cools.isEmpty(wrkMast.getLocNo())) {
                    LocMast locMast = locMastService.selectOne(new EntityWrapper<LocMast>()
                            .eq("loc_no", wrkMast.getLocNo())
                            .eq("frozen", 0));
                    if (Cools.isEmpty(locMast)) {
                        continue;
                    }
                }

                String wcsSourceLocNo = Cools.isEmpty(wrkMast.getSourceLocNo()) ? "" : Utils.WMSLocToWCSLoc(wrkMast.getSourceLocNo());
                String wcsLocNo = Cools.isEmpty(wrkMast.getLocNo()) ? "" : Utils.WMSLocToWCSLoc(wrkMast.getLocNo());
                Integer taskPri = wrkMast.getIoPri() == null ? null : wrkMast.getIoPri().intValue();
                WorkTaskParams params = new WorkTaskParams();
                //出库和移库
                if ((wrkMast.getIoType() == 101 || wrkMast.getIoType() == 110) && !Cools.isEmpty(wrkMast.getStaNo()) && !wrkMast.getStaNo().equals("0")) {
                    params.setType("out")
                            .setTaskNo(wrkMast.getWrkNo() + "")
                            .setSourceLocNo(wcsSourceLocNo)
                            .setLocNo(wcsLocNo)
                            .setStaNo(wrkMast.getStaNo())
                            .setTaskPri(taskPri)
                            .setBarcode(wrkMast.getBarcode());
                } else if (wrkMast.getIoType() == 2 && !Cools.isEmpty(wrkMast.getSourceStaNo())) {
                    params.setType("in")
                            .setTaskNo(wrkMast.getWrkNo() + "")
                            .setSourceStaNo(wrkMast.getSourceStaNo())
                            .setStaNo(wrkMast.getStaNo())
                            .setLocNo(wcsLocNo)
                            .setTaskPri(taskPri)
                            .setBarcode(wrkMast.getBarcode());
                } else {
                    params.setType("move")
                            .setTaskNo(wrkMast.getWrkNo() + "")
                            .setSourceLocNo(wcsSourceLocNo)
                            .setLocNo(wcsLocNo)
                            .setBarcode(wrkMast.getBarcode());
                }
                R r = wcsApiService.pubWrkToWcs(params);
                if (isSuccess(r)) {
                    clearPublishError(wrkMast.getWrkNo());
                    break;
                }
                markPublishError(wrkMast.getWrkNo(), String.valueOf(r.get("msg")));
            } catch (Exception e) {
                log.error("工作档[wrkNo={}]下发任务异常", wrkMast.getWrkNo(), e);
                markPublishError(wrkMast.getWrkNo(), e.getMessage());
            }
        }
    }

    private boolean isSuccess(R r) {
        return r != null && "200".equals(String.valueOf(r.get("code")));
    }

    private void markPublishError(Integer wrkNo, String msg) {
        if (wrkMastService.updatePublishError(wrkNo, "X", new Date(), buildPublishErrorMsg(msg)) <= 0) {
            log.error("工作档[wrkNo={}]回写下发异常失败", wrkNo);
        }
    }

    private void clearPublishError(Integer wrkNo) {
        if (wrkMastService.updatePublishError(wrkNo, null, null, null) <= 0) {
            log.error("工作档[wrkNo={}]清理下发异常失败", wrkNo);
        }
    }

    private String buildPublishErrorMsg(String msg) {
        return Cools.isEmpty(msg) || "null".equalsIgnoreCase(msg) ? "下发任务失败" : "下发任务失败：" + msg;
    }

    /**
     * 自动生成跨区入任务
     *
     * @author Ryan
     * @date 2026/1/10 14:42
     */
    @Scheduled(cron = "0/3 * * * * ? ")
    private void autoInStack() {
        List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>().eq("wrk_sts", 15).eq("online_yn","N"));
        if (wrkMasts.isEmpty()) {
            return;
        }
        for (WrkMast wrkMast : wrkMasts) {
            LocMast locMast = locMastService.selectOne(new EntityWrapper<LocMast>().eq("loc_no", wrkMast.getLocNo()));
            // 构造跨区入库任务
            WrkMast inMast = new WrkMast();
            // 生成工作号
            int workNo = commonService.getWorkNo(WorkNoType.getWorkNoType(1));
            inMast.setWrkNo(workNo);          // 生成新任务号
            inMast.setBarcode(wrkMast.getBarcode());                // 托盘码保持一致
            inMast.setIoType(2);                                 // 跨区入库类型
            inMast.setWrkSts(1L);                                // 待下发
            inMast.setLocNo(wrkMast.getLocNo());              // 原目标库位
            inMast.setIoPri(13.0);
            inMast.setSourceStaNo(wrkMast.getStaNo());
            inMast.setWrkCode(wrkMast.getWrkNo()+"");                  // 关联原出库任务
            inMast.setAppeUser(wrkMast.getAppeUser());              // 申请人
            inMast.setAppeTime(new Date());
            inMast.setIoTime(new Date());
            inMast.setCrnNo(locMast.getCrnNo());
            if(!wrkMastService.insert(inMast)){
                throw new CoolException("跨区入库任务生成失败！");
            }else {
                wrkMast.setOnlineYn("Y");
                wrkMastService.updateById(wrkMast);
            }
        }

    }
}