KprAIModelPower/src/main/java/com/shkpr/service/aimodelpower/bizmgr/WODispatchPlanTmDoBizFun.java

package com.shkpr.service.aimodelpower.bizmgr;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.global.base.log.LogLevelFlag;
import com.global.base.log.LogPrintMgr;
import com.global.base.tools.FastJsonUtil;
import com.shkpr.service.aimodelpower.commtools.CommTool;
import com.shkpr.service.aimodelpower.commtools.TimeTool;
import com.shkpr.service.aimodelpower.components.locks.CountDownLatchEx;
import com.shkpr.service.aimodelpower.components.locks.WODispatchPlanLockMgr;
import com.shkpr.service.aimodelpower.constants.CommFieldStatus;
import com.shkpr.service.aimodelpower.constants.TaskQueueDataTypeEx;
import com.shkpr.service.aimodelpower.dbdao.DBMgrProxy;
import com.shkpr.service.aimodelpower.dbdao.services.intef.WODispatchCmdBatchItemDBService;
import com.shkpr.service.aimodelpower.dbdao.services.intef.WODispatchCmdInfoDBService;
import com.shkpr.service.aimodelpower.dbdao.services.intef.WODispatchPlanDBService;
import com.shkpr.service.aimodelpower.dbdao.tables.WODispatchDatabaseTable;
import com.shkpr.service.aimodelpower.dbdao.tables.WODispatchPlanInfoTable;
import com.shkpr.service.aimodelpower.dto.*;
import com.shkpr.service.aimodelpower.dto.woDispatchPlanModel.*;
import com.shkpr.service.aimodelpower.globalmgr.AsyncTaskQueueMgr;
import com.shkpr.service.aimodelpower.jsonbean.woDispatchPlan.*;
import com.shkpr.service.aimodelpower.services.ServiceMgrProxy;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import java.sql.Time;
import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.time.temporal.TemporalAdjusters;
import java.util.*;
import java.util.stream.Collectors;

public class WODispatchPlanTmDoBizFun {
    private final static String mStrClassName = "WODispatchPlanTmDoBizFun";
    private final static String EMPTY_NULL = "NULL";
    private final static  String MSG_FAILED = "failed.";
    private final static  String MSG_SUCCESS = "success.";

    private static WODispatchPlanDBService getThisDBService(){ return DBMgrProxy.getInstance().applyWODispatchPlanApi();}
    private static WODispatchCmdBatchItemDBService getItemDBService(){ return DBMgrProxy.getInstance().applyWODispatchItemApi();}
    private static WODispatchCmdInfoDBService getCmdInfoDBService() {return DBMgrProxy.getInstance().applyWODispatchCmdApi();}
    public static ResponseCode produceCmd(String planId, long checkTm){
        ResponseCode code = ResponseCode.RESULT_BAD;
        if (StringUtils.isEmpty(planId))
            return code;

        CountDownLatchEx latchEx = null;
        int nRetry = 3;
        do {
            try {
                latchEx = WODispatchPlanLockMgr.tryLatchForPlan(planId, 20000);
            }catch (Exception e){
                latchEx = null;
            }

            if (latchEx != null){
                code = handleProduceCmd(planId, checkTm);
                break;
            }
        }while ((--nRetry) > 0);

        if (latchEx != null){
            latchEx.countDown();
        }else{
            code = handleProduceCmd(planId, checkTm);
        }
        return code;
    }

    //TODO 判断差值是否小于等于五分钟
    private static boolean isWithinFiveMinutes(long timestamp1, long timestamp2) {
        return Math.abs(timestamp1 - timestamp2) <= 5 * 60 * 1000;
    }

    private static ResponseCode handleProduceCmd(String planId, long checkTm){
        if(planId.equals("PLP2A012D8D2E815028Y8")){
            System.out.println(111);
        }
        ResponseCode code = ResponseCode.RESULT_BAD;
        Long nowLoc = TimeTool.getCurMsUTC();
        Map<String,Object> mapSel = getThisDBService().getOne(planId);
        if(mapSel!=null&&mapSel.size()>0){
            DispatchPlanInfoSSModel model = FastJsonUtil.map2Obj(mapSel,DispatchPlanInfoSSModel.class,true);
            String errors = "";
            List<String> cmdTaskIds = new ArrayList<>();
            long oldNextTakeTime = model.getNextTakeTime();
            long oldLimitNextTakeTime = model.getLimitNextTakeTime();
            long newNextTakeTime = oldNextTakeTime;
            long newLimitNextTakeTime = oldLimitNextTakeTime;
            long newLastTakeTime = model.getLastTakeTime();
            Map<String, Object> andWheres = new HashMap<>();
            andWheres.put(WODispatchPlanInfoTable.R_INFO.PRIMARY_KEY,planId);
            Map<String, Object> updates = new HashMap<>();
            andWheres.put(WODispatchPlanInfoTable.W_INFO.UNIQUE_ID, planId);

            do {
                List<DispatchCmdBatchItemModel> itemModels = getItemDBService()
                        .listAllWithsExByDispoal("", "", andWheres, new HashMap<>(), "handle_start_time", "");
                if (checkTm != model.getNextTakeTime()){
                    errors = "Next take time changed,goto next cycle";
                    break;
                }
                if (model.getPlanStatus() != 1){
                    errors = "Plan status changed,goto next cycle";
                    break;
                }
                if (CollectionUtils.isEmpty(itemModels)){
                    errors = "Plan batch empty,goto next cycle";
                    break;
                }

                DispatchPlanInfoNextTimeModel nextTimeModel = new DispatchPlanInfoNextTimeModel();
                List<DispatchCmdBatchItemNextTimeModel> itemModelNextTimes = new ArrayList<>();
                if (!CollectionUtils.isEmpty(itemModels)) {
                    for (DispatchCmdBatchItemModel jpItem : itemModels) {
                        DispatchCmdBatchItemNextTimeModel dispatchCmdBatchItemNextTimeModel = new DispatchCmdBatchItemNextTimeModel();
                        dispatchCmdBatchItemNextTimeModel.setHandleStartTime(jpItem.getHandleStartTime());
                        dispatchCmdBatchItemNextTimeModel.setHandleStartTimeLimit(jpItem.getHandleEndTime());
                        itemModelNextTimes.add(dispatchCmdBatchItemNextTimeModel);
                    }
                }
                nextTimeModel.setItemsList(itemModelNextTimes);
                nextTimeModel.setPlanType(model.getPlanType());
                nextTimeModel.setDispatchLeadTime(model.getDispatchLeadTime());
                nextTimeModel.setCycles(model.getCycles());

                LocalDateTime newTureNextTakeTimeDateTime = LocalDateTime
                        .ofInstant(Instant.ofEpochMilli(newNextTakeTime), ZoneId.systemDefault())
                        .minusMinutes(model.getDispatchLeadTime());
                Map<String,Long> nextMap = returnNextTakeTime(nextTimeModel,newTureNextTakeTimeDateTime);
                newNextTakeTime = (model.getPlanType()==0)?0L:nextMap.get("nextTakeTime");
                newLimitNextTakeTime = (model.getPlanType()==0)?0L:nextMap.get("limitNextTakeTime");//returnNextTakeTime(nextTimeModel);

                if (model.getPlanType() != 0 && newNextTakeTime <= oldNextTakeTime){
                    newNextTakeTime = oldNextTakeTime;
                    newLimitNextTakeTime = oldLimitNextTakeTime;
                    errors = "Plan take time produce error,please check take time logic and goto next cycle";
                    break;
                }


                if (model.getPlanType() != 0
                        && !(nowLoc >= oldNextTakeTime && nowLoc <= oldLimitNextTakeTime)){
                    errors = "Plan will use new take time,goto next cycle";
                    break;
                }

                JSONArray jsonArray = new JSONArray();
                for (DispatchCmdBatchItemModel item:itemModels) {
                    JSONObject planCommandParam = new JSONObject();
                    planCommandParam.put("type", 1);
                    planCommandParam.put("zoneId", model.getZoneId());
                    planCommandParam.put("zoneType", model.getZoneType());
                    planCommandParam.put("zone", model.getZone());
                    planCommandParam.put("sender", model.getCreatorId());
                    planCommandParam.put("receiver", item.getHeadUserId());

                    Long sugBeginTime = 0L;
                    if(model.getDispatchLeadTime()<0){
                        sugBeginTime = Instant.ofEpochMilli(model.getNextTakeTime()).atZone(ZoneId.systemDefault())
                                .minusMinutes(model.getDispatchLeadTime())
                                .withHour(Integer.valueOf(item.getHandleStartTime().split(":")[0]))
                                .withMinute(Integer.valueOf(item.getHandleStartTime().split(":")[1]))
                                .withSecond(Integer.valueOf(item.getHandleStartTime().split(":")[2]))
                                .toInstant().toEpochMilli();
                    }else if(model.getDispatchLeadTime()==0){
                        sugBeginTime = Instant.ofEpochMilli(model.getNextTakeTime()).atZone(ZoneId.systemDefault())
                                .withHour(Integer.valueOf(item.getHandleStartTime().split(":")[0]))
                                .withMinute(Integer.valueOf(item.getHandleStartTime().split(":")[1]))
                                .withSecond(Integer.valueOf(item.getHandleStartTime().split(":")[2]))
                                .toInstant().toEpochMilli();
                    }else if(model.getDispatchLeadTime()>0){
                        sugBeginTime = Instant.ofEpochMilli(model.getNextTakeTime()).atZone(ZoneId.systemDefault())
                                .minusMinutes(model.getDispatchLeadTime())
                                .withHour(Integer.valueOf(item.getHandleStartTime().split(":")[0]))
                                .withMinute(Integer.valueOf(item.getHandleStartTime().split(":")[1]))
                                .withSecond(Integer.valueOf(item.getHandleStartTime().split(":")[2]))
                                .toInstant().toEpochMilli();
                    }
                    if (sugBeginTime<=0L){
                        //TODO 说明时间错误,将错误拦截在此处不再进行派单动作
                        continue;
                    }

                    planCommandParam.put("title",String.format("%s--第%s批次任务",model.getTitle(),
                            TimeTool.convertUTC2DateStr(sugBeginTime, TimeTool.TIMESTAMP_FORMAT_EX3)));
                    planCommandParam.put("sugBeginTime",sugBeginTime);
                    String endTimeStr = item.getHandleEndTime();
                    planCommandParam.put("sugEndTime", Instant.ofEpochMilli(sugBeginTime)
                            .atZone(ZoneId.systemDefault())
                            .withHour(Integer.valueOf(endTimeStr.split(":")[0]))
                            .withMinute(Integer.valueOf(endTimeStr.split(":")[1]))
                            .withSecond(Integer.valueOf(endTimeStr.split(":")[2]))
                            .toInstant().toEpochMilli());
                    List<Map<String,Object>> suggestions = new ArrayList<>();
                    if(!CollectionUtils.isEmpty(item.getDispoalModels())){
                        for(DispatchCmdBatchDispoalModel dispoalModel:item.getDispoalModels()) {
                            Map<String, Object> sug = new HashMap<>();
                            sug.put("key", dispoalModel.getKey());
                            sug.put("data", dispoalModel.getData());
                            sug.put("ordering", dispoalModel.getOrdering());
                            sug.put("did", dispoalModel.getDid());
                            sug.put("dname", dispoalModel.getDname());
                            suggestions.add(sug);
                        }
                    }
                    planCommandParam.put("suggestions",suggestions);
                    planCommandParam.put("fromSource",planId);
                    planCommandParam.put("level",model.getUrgentLevel());
                    planCommandParam.put("sendway",model.getSendway());
                    planCommandParam.put("remark",model.getDispatchRemark());
                    planCommandParam.put("gis",item.getGis());
                    planCommandParam.put("address",item.getHandleAddress());
                    jsonArray.add(planCommandParam);
                }

                if(jsonArray.size()>0) {
                    try {
                        JSONObject jsonParam = new JSONObject();
                        jsonParam.put("total",jsonArray.size());
                        jsonParam.put("data",jsonArray);
                        ResponseRes<String> res = ServiceMgrProxy.getInstance().applyTaskServiceApi().postPlanCommand(jsonParam);
                        if (ResponseCode.RESULT_NORMAL.toStrCode().equals(res.getRescode())) {
                            DispatchCmdTaskRspGroup result = FastJsonUtil.fromJSONByGson(res.getResdata(), DispatchCmdTaskRspGroup.class);
                            if (CommTool.listSize(result.getData()) > 0){
                                for (DispatchCmdTaskRsp item:result.getData()){
                                    if ("0".equals(item.getCode())){
                                        cmdTaskIds.add(item.getUid());
                                        newLastTakeTime = item.getOkTime();
                                        code = ResponseCode.RESULT_NORMAL;
                                    }
                                }
                            }
                        }
                    } catch (Exception ex) {
                        code = ResponseCode.BUSINESS_BUSY;
                        LogPrintMgr.getInstance().printLogMsg(LogLevelFlag.LOG_INFO, mStrClassName, mStrClassName
                                , String.format("check planInfo errorMsg:%s end<====",
                                        ex.getLocalizedMessage()));
                    }
                    if (code != ResponseCode.RESULT_NORMAL)
                        errors = "Produce cmd failed by remote api,goto next cycle";
                }else
                    errors = "Produce cmd failed by invalid param,goto next cycle";

                if (CommTool.listSize(cmdTaskIds) <= 0 || code != ResponseCode.RESULT_NORMAL){
                    newNextTakeTime = oldNextTakeTime;
                    newLimitNextTakeTime = oldLimitNextTakeTime;
                    break;
                }
            }while (false);

            updates.put(WODispatchPlanInfoTable.W_INFO.ERRORS, errors);
            updates.put(WODispatchPlanInfoTable.W_INFO.TAKES, model.getTakes()+1);
            updates.put(WODispatchPlanInfoTable.W_INFO.UPDATE_TIME, nowLoc);
            updates.put(WODispatchPlanInfoTable.W_INFO.LAST_TAKE_TIME, newLastTakeTime);
            updates.put(WODispatchPlanInfoTable.W_INFO.NEXT_TAKE_TIME, newNextTakeTime);
            updates.put(WODispatchPlanInfoTable.W_INFO.LIMIT_NEXT_TAKE_TIME, newLimitNextTakeTime);
            if (getThisDBService().updateWiths(updates, andWheres) <= 0){
                if (CommTool.listSize(cmdTaskIds) > 0){
                    getCmdInfoDBService().batchDeleteIn(cmdTaskIds, "");
                }
                code = ResponseCode.BUSINESS_DB_REQ_FAILED;
            }else
                code = ResponseCode.RESULT_NORMAL;
        }
        return code;
    }

    public static void checkPlanForProduce(){
        long lCurTime = System.currentTimeMillis();
        Map<String, Object> mapSel = getThisDBService().totalWillProduceCounts(null
                , null
                , ""
                , String.format("and %s = %d and next_take_time > 0 and next_take_time <= %d"
                        , WODispatchPlanInfoTable.R_INFO.STATUS
                        , CommFieldStatus.ENABLE
                        , lCurTime));

        if (mapSel != null && mapSel.size() > 0){
            WODispatchCheckTotal oTotal = FastJsonUtil.map2Obj(mapSel, WODispatchCheckTotal.class, true);
            if (oTotal != null && oTotal.getTotal() > 0){
                long curIndex = -1L;
                int limit = 50, offset = 0, realTotal = 0;
                while (curIndex < oTotal.getMaxIndex()){
                    List<Map<String, Object>> arrDbTmp = getThisDBService().listAllWithsEx(WODispatchPlanInfoTable.R_INFO.TABLE
                            , WODispatchPlanInfoTable.R_INFO.TOTAL_PRODUCE_FILED
                            , limit
                            , offset
                            ,null
                            ,null
                            , WODispatchPlanInfoTable.R_INFO.TOTAL_PRODUCE_ORDER
                            , String.format("and %s = %d and (id between %d and %d)"
                                    ,WODispatchPlanInfoTable.R_INFO.STATUS
                                    ,CommFieldStatus.ENABLE
                                    ,oTotal.getMinIndex()
                                    ,oTotal.getMaxIndex()));
                    if (CommTool.listSize(arrDbTmp) <= 0)
                        break;

                    realTotal += arrDbTmp.size();
                    offset = realTotal;

                    List<WODispatchCheckBean> arrRes = FastJsonUtil.batchMap2Obj(arrDbTmp, WODispatchCheckBean.class, true);
                    if (CommTool.listSize(arrRes) <= 0)
                        continue;

                    for (WODispatchCheckBean oItem:arrRes){
                        if (oItem.getId() > curIndex)
                            curIndex = oItem.getId();
                        if (oItem.getStatus() != CommFieldStatus.ENABLE)
                            continue;

                        boolean bProduce = false;
                        boolean bGenNext = false;
                        if (oItem.getBatchTotal() <= 0 || oItem.getNextTakeTime() <= 0L){
                            bGenNext = true;
                        }else if (oItem.getNextTakeTime() <= lCurTime){
                            bProduce = true;
                        }

                        if (bProduce){
                            AsyncTaskQueueMgr.getInstance().postTaskData(TaskQueueDataTypeEx.ASYNC_PRODUCE_WO_DISPATCH_CMD, new CommUTMBean(oItem.getUid(), oItem.getNextTakeTime()));
                        }else if (bGenNext){
                            //do nothing
                        }
                    }
                }
            }
        }
    }


    //TODO 分页查询计划
    //查询·分页
    public static PageRecordRes<DispatchPlanInfoSSModel> queryPageList(JPDispatchPlanInfoSS jsonParam){
        PageRecordRes<DispatchPlanInfoSSModel> oRes = new PageRecordRes<>();
        if (jsonParam == null)
            return oRes;
        final String lilterExtend = jsonParam.genQueryExtend();
        Map<String,Object> andWheres = new HashMap<>();
        if(jsonParam.getPlanType()!=null){
            andWheres.put("plan_type", jsonParam.getPlanType());
        }
        if(jsonParam.getPlanStatus()!=null){
            andWheres.put("plan_status", jsonParam.getPlanStatus());
        }
        if(jsonParam.getZoneId()!=null){
            andWheres.put("zone_id", jsonParam.getZoneId());
        }
        String sql = "";
        if(jsonParam.getDownFlag()!=null) {
            if(jsonParam.getDownFlag()==0) {
                sql += " AND " + WODispatchPlanInfoTable.R_INFO.LAST_TAKE_TIME + " > 0 ";
            }else{
                sql += " AND " + WODispatchPlanInfoTable.R_INFO.LAST_TAKE_TIME + " = 0 ";
            }
        }
        int nTotals = getThisDBService().totalCountsEx("", andWheres, null, lilterExtend+sql);
        if (nTotals > 0){
            List<Map<String,Object>> dataList = getThisDBService().listAllWithsEx("","",
                    jsonParam.getLimit(),
                    jsonParam.getOffset(),
                    andWheres,
                    null,
                    WODispatchPlanInfoTable.R_INFO.CREATE_TIME+" DESC",
                    lilterExtend+sql);
            if(dataList==null){
                oRes.setCode(ResponseCode.RESULT_BAD.toInt());
            }else{
                List<DispatchPlanInfoSSModel> ssInfoModels = dataList.isEmpty()?new ArrayList<>():
                        FastJsonUtil.batchMap2Obj(dataList,DispatchPlanInfoSSModel.class,true);
                oRes.setCode(ResponseCode.RESULT_NORMAL.toInt());
                oRes.setTotal(nTotals);
                oRes.setData(ssInfoModels);
            }
        }
        return oRes;
    }

    //TODO 查询详情信息
    public static ResponseRes selectPlanInfoView(JPDispatchPlanInfoDetailsSS oJsonParam){
        ResponseRes oRes = new ResponseRes();
        oRes.setRescode(ResponseCode.RESULT_BAD.toStrCode());
        oRes.setResmsg(ResponseCode.RESULT_BAD.toStrMsg());
        if(StringUtils.isEmpty(oJsonParam)||StringUtils.isEmpty(oJsonParam.getPlanId())){
            oRes.setRescode(ResponseCode.STATUS_ERROR_JSON_FORMAT.toStrCode());
            oRes.setResmsg(ResponseCode.STATUS_ERROR_JSON_FORMAT.toStrMsg());
            return oRes;
        }
        try{
            Map<String,Object> map = getThisDBService().getOne(oJsonParam.getPlanId());
            if(map!=null||map.size()>0){
                DispatchPlanInfoDetailsModel model = FastJsonUtil.map2Obj(map,DispatchPlanInfoDetailsModel.class,true);
                if (model!=null) {
                    //TODO 查询相关联规则和标签
                    Map<String, Object> andWheresRuls = new HashMap<>();
                    andWheresRuls.put("plan_id", oJsonParam.getPlanId());
                    List<Map<String,Object>> rulsModels = getThisDBService().selectAllRuls("","",
                            andWheresRuls,new HashMap<>(),"","");
                    Map<String, Object> andWheresTags = new HashMap<>();
                    andWheresTags.put("plan_id", oJsonParam.getPlanId());
                    List<Map<String,Object>> tagModels = getThisDBService().selectAllPlanTags("","",
                            andWheresTags,new HashMap<>(),"","");
                    //TODO 查询相关联的排班项信息
                    Map<String, Object> andWheres = new HashMap<>();
                    andWheres.put("plan_id", oJsonParam.getPlanId());
                    List<DispatchCmdBatchItemModel> itemModels = getItemDBService()
                            .listAllWithsExByDispoal("", "", andWheres, new HashMap<>(), "handle_start_time", "");

                    if(!CollectionUtils.isEmpty(rulsModels)){
                        model.setRulsModels(FastJsonUtil.batchMap2Obj(rulsModels,DispatchPlanInfoRuleModel.class,true));
                    }
                    if(!CollectionUtils.isEmpty(tagModels)){
                        model.setTagsList(FastJsonUtil.batchMap2Obj(tagModels,DispatchPlanInfoTagsModel.class,true));
                    }
                    if(!CollectionUtils.isEmpty(itemModels)) {
                        model.setItemModels(itemModels);
                    }

                    oRes.setResdata(FastJsonUtil.toJSON(model));
                }
            }

            oRes.setRescode(ResponseCode.RESULT_NORMAL.toStrCode());
            oRes.setResmsg(ResponseCode.RESULT_NORMAL.toStrMsg());
            return oRes;
        }catch (Exception ex){
            return oRes;
        }
    }

    //判断是否在时间区间内并且取出最接近当前时间的大于它的时间
    //nextType 0 周 1 月 2 年
    public static LocalDateTime findNextTime(List<String> dateTimeStrings,LocalDateTime oldTm){
        LocalDateTime now = oldTm==null?LocalDateTime.now():oldTm; // 获取当前日期时间
        System.out.println("Current DateTime: " + now);
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        // 转换为LocalDateTime集合
        List<LocalDateTime> dateTimes = new ArrayList<>();
        for (String dtStr : dateTimeStrings) {
            dateTimes.add(LocalDateTime.parse(dtStr,formatter));
        }

        // 找到最接近且大于当前时间的日期时间
        // 仅考虑大于当前时间的日期时间
        LocalDateTime closestFutureDateTime = dateTimes.stream()
                .filter(dateTime -> dateTime.isAfter(now))
                .min((dateTime1, dateTime2) -> Long.compare(
                        java.time.temporal.ChronoUnit.MINUTES.between(now, dateTime1),
                        java.time.temporal.ChronoUnit.MINUTES.between(now, dateTime2)))
                .orElse(null); // 如果没有找到，返回null

        //TODO  输出结果 ,如果为空说明在集合中没有找到符合条件的时间, 则直接取下一个单位的最小时间即可
        return closestFutureDateTime;
    }
    //LocalDateTime转UTC时间戳
    public static Long reloadLocalDateTimeToLong(LocalDateTime localDateTime){

        // 转换为毫秒时间戳
        long timestampMillis = TimeTool.convertDateStr2UTC(localDateTime.format(DateTimeFormatter.ofPattern(TimeTool.TIMESTAMP_FORMAT)));

        return timestampMillis;
    }

    //TODO 公用计算下次生效时间的方法
    //TODO 分是否排班
    //TODO oldTm主要为了再派单时比对
    public static Map<String,Long> returnNextTakeTime(DispatchPlanInfoNextTimeModel model,LocalDateTime oldTm){
        Map<String,Long> map = new HashMap<>();

        Long nextTakeTime = 0L;
        Long limitNextTakeTime = 0L;
        map.put("nextTakeTime",nextTakeTime);
        map.put("limitNextTakeTime",limitNextTakeTime);
        map.put("ifRestNextTakeTime",0L);//是否将newTextTakeTime更新到 plan中 0否, 1是
        if(!CollectionUtils.isEmpty(model.getItemsList())){
            List<DispatchCmdBatchItemNextTimeModel> newList = model.getItemsList().stream()
                    .sorted(Comparator.comparing(DispatchCmdBatchItemNextTimeModel::getHandleStartTime))
                    .collect(Collectors.toList());
            if(model.getPlanType()==0) {
                //TODO 临时计划
                Instant nowTime = Instant.ofEpochMilli(
                        TimeTool.convertDateStr2UTC
                                (
                                        JSONArray.parseArray(model.getCycles()).getString(0)
                                                +" "+
                                                newList.get(0).getHandleStartTime()));
                Instant endTime = Instant.ofEpochMilli(
                        TimeTool.convertDateStr2UTC
                                (
                                        JSONArray.parseArray(model.getCycles()).getString(0)
                                                +" "+
                                                model.getItemsList().stream().sorted(Comparator.comparing(DispatchCmdBatchItemNextTimeModel::getHandleStartTimeLimit))
                                                        .collect(Collectors.toList()).get(0).getHandleStartTimeLimit()));
                if(model.getDispatchLeadTime()==0) {
                    nextTakeTime = nowTime.toEpochMilli();
                    limitNextTakeTime = endTime.toEpochMilli();
                }else if(model.getDispatchLeadTime()>0){
                    nextTakeTime = nowTime.minus(-model.getDispatchLeadTime(), ChronoUnit.MINUTES).toEpochMilli();
                    limitNextTakeTime = endTime.toEpochMilli();
                }else if(model.getDispatchLeadTime()<0){
                    nextTakeTime = nowTime.minus(Math.abs(model.getDispatchLeadTime()), ChronoUnit.MINUTES).toEpochMilli();
                    limitNextTakeTime = endTime.toEpochMilli();
                }
                //TODO 如果当前时间与下次生效时间是同一天,但是时刻已经是过去时,那么则返回失败信息
                Long nowTimeLong = TimeTool.getCurMsUTC();
                if(nowTimeLong>nextTakeTime&&nowTimeLong>limitNextTakeTime&&isSameDay(nowTimeLong,nextTakeTime)){
                    throw new RuntimeException(ResponseCode.STATUS_ERROR_JSON_FORMAT.toStrCode());
                }
            }else if(model.getPlanType()==1){
                //TODO 日计划
                boolean isToDay = false;//生效时间是否小于等于当前时刻
                for (DispatchCmdBatchItemNextTimeModel item:newList){
                    Instant nowTime = Instant.ofEpochMilli(
                            TimeTool.convertDateStr2UTC
                                    (JSONArray.parseArray(model.getCycles()).getString(0)
                                            +" "+item.getHandleStartTime()));
                    LocalDateTime dateTime = nowTime.atZone(ZoneId.systemDefault()).toLocalDateTime();
                    Instant endTime = Instant.ofEpochMilli(
                            TimeTool.convertDateStr2UTC
                                    (
                                            JSONArray.parseArray(model.getCycles()).getString(0)
                                                    +" "+
                                                    model.getItemsList().stream().sorted(Comparator.comparing(DispatchCmdBatchItemNextTimeModel::getHandleStartTimeLimit))
                                                            .collect(Collectors.toList()).get(0).getHandleStartTimeLimit()));
                    LocalDateTime dateTime1 = endTime.atZone(ZoneId.systemDefault()).toLocalDateTime();
                    LocalDateTime dateTimeNow = Instant.now().atZone(ZoneId.systemDefault()).toLocalDateTime();
                    if(Instant.now().isBefore(nowTime)||Instant.now().equals(nowTime)){
                        isToDay = true;
                        if(model.getDispatchLeadTime()==0) {
                            nextTakeTime = nowTime.toEpochMilli();
                            limitNextTakeTime = endTime.toEpochMilli();
                        }else if(model.getDispatchLeadTime()>0){
                            nextTakeTime = nowTime.minus(-model.getDispatchLeadTime(), ChronoUnit.MINUTES).toEpochMilli();
                            limitNextTakeTime = endTime.toEpochMilli();
                        }else if(model.getDispatchLeadTime()<0){
                            nextTakeTime = nowTime.minus(Math.abs(model.getDispatchLeadTime()), ChronoUnit.MINUTES).toEpochMilli();
                            limitNextTakeTime = endTime.toEpochMilli();
                        }
                        break;
                    }
                }
                if(!isToDay){
                    //说明当天并没有满足条件的时刻,那么在日期上加一天,并且用最小时刻
                    if(model.getDispatchLeadTime()==0) {
                        nextTakeTime = Instant.ofEpochMilli(
                                TimeTool.convertDateStr2UTC
                                        (JSONArray.parseArray(model.getCycles()).getString(0)
                                                +" "+newList.get(0).getHandleStartTime())).plus(Duration.ofDays(1)).toEpochMilli();
                        limitNextTakeTime = Instant.ofEpochMilli(
                                TimeTool.convertDateStr2UTC
                                        (JSONArray.parseArray(model.getCycles()).getString(0)
                                                +" "+model.getItemsList().stream().sorted(Comparator.comparing(DispatchCmdBatchItemNextTimeModel::getHandleStartTimeLimit))
                                                .collect(Collectors.toList()).get(0).getHandleStartTimeLimit())).plus(Duration.ofDays(1)).toEpochMilli();
                    }else if(model.getDispatchLeadTime()>0){
                        nextTakeTime = Instant.ofEpochMilli(
                                TimeTool.convertDateStr2UTC
                                        (JSONArray.parseArray(model.getCycles()).getString(0)
                                                +" "+newList.get(0).getHandleStartTime())).plus(Duration.ofDays(1)).minus(-model.getDispatchLeadTime(), ChronoUnit.MINUTES).toEpochMilli();
                        limitNextTakeTime = Instant.ofEpochMilli(
                                TimeTool.convertDateStr2UTC
                                        (JSONArray.parseArray(model.getCycles()).getString(0)
                                                +" "+model.getItemsList().stream().sorted(Comparator.comparing(DispatchCmdBatchItemNextTimeModel::getHandleStartTimeLimit))
                                                .collect(Collectors.toList()).get(0).getHandleStartTimeLimit())).plus(Duration.ofDays(1)).toEpochMilli();
                    }else if(model.getDispatchLeadTime()<0){
                        nextTakeTime = Instant.ofEpochMilli(
                                TimeTool.convertDateStr2UTC
                                        (JSONArray.parseArray(model.getCycles()).getString(0)
                                                +" "+newList.get(0).getHandleStartTime())).plus(Duration.ofDays(1)).minus(Math.abs(model.getDispatchLeadTime()), ChronoUnit.MINUTES).toEpochMilli();
                        limitNextTakeTime = Instant.ofEpochMilli(
                                TimeTool.convertDateStr2UTC
                                        (JSONArray.parseArray(model.getCycles()).getString(0)
                                                +" "+model.getItemsList().stream().sorted(Comparator.comparing(DispatchCmdBatchItemNextTimeModel::getHandleStartTimeLimit))
                                                .collect(Collectors.toList()).get(0).getHandleStartTimeLimit())).plus(Duration.ofDays(1)).toEpochMilli();
                    }
                }

                //TODO 如果当前时间大于生效时间,说明生效时间过期,则加一天
                LocalDateTime localNext = LocalDateTime.ofInstant(Instant.ofEpochMilli(nextTakeTime), ZoneId.systemDefault())
                        .minusMinutes(model.getDispatchLeadTime());
                if(limitNextTakeTime<TimeTool.getCurMsUTC()){
                    nextTakeTime = Instant.ofEpochMilli(nextTakeTime)
                            .plus(1, ChronoUnit.DAYS).toEpochMilli();
                    limitNextTakeTime = Instant.ofEpochMilli(limitNextTakeTime).toEpochMilli();
                }else if(oldTm!=null&&(localNext
                        .isBefore(oldTm)||localNext.isEqual(oldTm))
                ){
                    //TODO 连续时需考虑
                    //TODO 如果传递了对比值, 则说明当前计算的时间与old不符合条件,则再加一算一次
                    nextTakeTime = Instant.ofEpochMilli(nextTakeTime)
                            .plus(1, ChronoUnit.DAYS).toEpochMilli();
                    limitNextTakeTime = Instant.ofEpochMilli(limitNextTakeTime).plus(1, ChronoUnit.DAYS).toEpochMilli();
                    map.put("ifRestNextTakeTime",1L);
                }
            }else if(model.getPlanType()==2){
                //TODO 周计划
                //TODO 先取周期值里最小的数,新集合里最小的值就是最早的周几数
                JSONArray newJSONArray = JSONArray.parseArray(model.getCycles()).stream().sorted(
                        // 根据
                        Comparator.comparingLong(
                                e -> Long.valueOf(e.toString())
                        )
                        // 放开下面的注释,使用reversed()方法,就是降序 大到小
                        // .reversed()
                ).collect(Collectors.toCollection(JSONArray::new));

                //TODO 先得到所有集合对应的当前周的所有符合条件的时间
                List<String> dateTimeStrings = new ArrayList<>();
                List<String> dateLimitTimeStrings = new ArrayList<>();//最小截止值
                for (Object obj:newJSONArray){
                    LocalDateTime nowDate = LocalDateTime.now().with(DayOfWeek.of(Integer.valueOf(obj.toString())));
                    for (DispatchCmdBatchItemNextTimeModel item : newList){
                        String[] times = item.getHandleStartTime().split(":");
                        String[] timeLimits = item.getHandleStartTimeLimit().split(":");
                        dateTimeStrings.add(nowDate.withHour(Integer.valueOf(times[0]))
                                .withMinute(Integer.valueOf(times[1])).withSecond(Integer.valueOf(times[2])).format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
                        dateLimitTimeStrings.add(nowDate.withHour(Integer.valueOf(timeLimits[0]))
                                .withMinute(Integer.valueOf(timeLimits[1])).withSecond(Integer.valueOf(timeLimits[2])).format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
                    }
                }
                LocalDateTime nextDateTime = findNextTime(dateTimeStrings,oldTm);
                LocalDateTime limitNextDateTime = nextDateTime!=null?LocalDateTime.parse(dateLimitTimeStrings.get(dateLimitTimeStrings.indexOf(nextDateTime
                        .format(DateTimeFormatter.ofPattern(TimeTool.YEAR_MONTH_DAY_FORMAT))
                        +" "+
                        model.getItemsList().stream().sorted(Comparator.comparing(DispatchCmdBatchItemNextTimeModel::getHandleStartTimeLimit))
                        .collect(Collectors.toList()).get(0).getHandleStartTimeLimit())),DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")):null;

                if(nextDateTime!=null){
                    if (model.getDispatchLeadTime() == 0) {
                        nextTakeTime = reloadLocalDateTimeToLong(nextDateTime);
                        limitNextTakeTime = reloadLocalDateTimeToLong(limitNextDateTime);
                    } else if (model.getDispatchLeadTime() > 0) {
                        nextTakeTime = reloadLocalDateTimeToLong(nextDateTime.minusMinutes(-model.getDispatchLeadTime()));
                        limitNextTakeTime = reloadLocalDateTimeToLong(limitNextDateTime);
                    } else if (model.getDispatchLeadTime() < 0) {
                        nextTakeTime = reloadLocalDateTimeToLong(nextDateTime.minusMinutes(Math.abs(model.getDispatchLeadTime())));
                        limitNextTakeTime = reloadLocalDateTimeToLong(limitNextDateTime);
                    }
                }else{
                    LocalTime localTime = LocalTime.parse(newList.get(0).getHandleStartTime(), DateTimeFormatter.ofPattern("HH:mm:ss"));
                    LocalTime localTimeLimit = LocalTime.parse(model.getItemsList().stream().sorted(Comparator.comparing(DispatchCmdBatchItemNextTimeModel::getHandleStartTimeLimit))
                            .collect(Collectors.toList()).get(0).getHandleStartTimeLimit(), DateTimeFormatter.ofPattern("HH:mm:ss"));
                    nextDateTime = LocalDateTime.now()
                            .with(DayOfWeek.of(Integer.valueOf(newJSONArray.get(0).toString())));
                    if (model.getDispatchLeadTime() == 0) {
                        nextTakeTime = reloadLocalDateTimeToLong(nextDateTime.minusWeeks(-1).withHour(localTime.getHour())
                                .withMinute(localTime.getMinute())
                                .withSecond(localTime.getSecond()));
                        limitNextTakeTime = reloadLocalDateTimeToLong(nextDateTime.minusWeeks(-1).withHour(localTimeLimit.getHour())
                                .withMinute(localTimeLimit.getMinute())
                                .withSecond(localTimeLimit.getSecond()));
                    } else if (model.getDispatchLeadTime() > 0) {
                        nextTakeTime = reloadLocalDateTimeToLong(nextDateTime.minusWeeks(-1).withHour(localTime.getHour())
                                .withMinute(localTime.getMinute())
                                .withSecond(localTime.getSecond()));
                        limitNextTakeTime = reloadLocalDateTimeToLong(nextDateTime.minusWeeks(-1).withHour(localTimeLimit.getHour())
                                .withMinute(localTimeLimit.getMinute())
                                .withSecond(localTimeLimit.getSecond()).minusMinutes(-model.getDispatchLeadTime()));
                    } else if (model.getDispatchLeadTime() < 0) {
                        nextTakeTime = reloadLocalDateTimeToLong(nextDateTime.minusWeeks(-1).withHour(localTime.getHour())
                                .withMinute(localTime.getMinute())
                                .withSecond(localTime.getSecond()).minusMinutes(Math.abs(model.getDispatchLeadTime())));
                        limitNextTakeTime = reloadLocalDateTimeToLong(nextDateTime.minusWeeks(-1).withHour(localTimeLimit.getHour())
                                .withMinute(localTimeLimit.getMinute())
                                .withSecond(localTimeLimit.getSecond()));
                    }
                }
            }else if(model.getPlanType()==3){
                //TODO 月计划
                JSONArray newJSONArray = JSONArray.parseArray(model.getCycles()).stream().sorted(
                        // 根据
                        Comparator.comparingLong(
                                e -> Long.valueOf(e.toString())
                        )
                        // 放开下面的注释,使用reversed()方法,就是降序 大到小
                        // .reversed()
                ).collect(Collectors.toCollection(JSONArray::new));

                //TODO 先得到所有集合对应的当前月的所有符合条件的时间
                List<String> dateTimeStrings = new ArrayList<>();
                List<String> dateLimitTimeStrings = new ArrayList<>();//最小截止值
                for (Object obj:newJSONArray){
                    LocalDateTime nowDate = LocalDateTime.now().withDayOfMonth(Integer.valueOf(obj.toString()));
                    for (DispatchCmdBatchItemNextTimeModel item : newList){
                        String[] times = item.getHandleStartTime().split(":");
                        String[] timeLimits = item.getHandleStartTimeLimit().split(":");
                        dateTimeStrings.add(nowDate.withHour(Integer.valueOf(times[0]))
                                .withMinute(Integer.valueOf(times[1])).withSecond(Integer.valueOf(times[2])).format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
                        dateLimitTimeStrings.add(nowDate.withHour(Integer.valueOf(timeLimits[0]))
                                .withMinute(Integer.valueOf(timeLimits[1])).withSecond(Integer.valueOf(timeLimits[2])).format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
                    }
                }

                LocalDateTime nextDateTime = findNextTime(dateTimeStrings,oldTm);
                LocalDateTime limitNextDateTime = nextDateTime!=null?LocalDateTime.parse(dateLimitTimeStrings.get(dateLimitTimeStrings.indexOf(nextDateTime
                        .format(DateTimeFormatter.ofPattern(TimeTool.YEAR_MONTH_DAY_FORMAT))+" "+model.getItemsList().stream().sorted(Comparator.comparing(DispatchCmdBatchItemNextTimeModel::getHandleStartTimeLimit))
                        .collect(Collectors.toList()).get(0).getHandleStartTimeLimit())),DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")):null;

                if(nextDateTime!=null){
                    if (model.getDispatchLeadTime() == 0) {
                        nextTakeTime = reloadLocalDateTimeToLong(nextDateTime);
                        limitNextTakeTime = reloadLocalDateTimeToLong(limitNextDateTime);
                    } else if (model.getDispatchLeadTime() > 0) {
                        nextTakeTime = reloadLocalDateTimeToLong(nextDateTime.minusMinutes(-model.getDispatchLeadTime()));
                        limitNextTakeTime = reloadLocalDateTimeToLong(limitNextDateTime);
                    } else if (model.getDispatchLeadTime() < 0) {
                        nextTakeTime = reloadLocalDateTimeToLong(nextDateTime.minusMinutes(Math.abs(model.getDispatchLeadTime())));
                        limitNextTakeTime = reloadLocalDateTimeToLong(limitNextDateTime);
                    }
                }else{
                    LocalTime localTime = LocalTime.parse(newList.get(0).getHandleStartTime(), DateTimeFormatter.ofPattern("HH:mm:ss"));
                    LocalTime localTimeLimit = LocalTime.parse(model.getItemsList().stream().sorted(Comparator.comparing(DispatchCmdBatchItemNextTimeModel::getHandleStartTimeLimit))
                            .collect(Collectors.toList()).get(0).getHandleStartTimeLimit(), DateTimeFormatter.ofPattern("HH:mm:ss"));
                    nextDateTime = LocalDateTime.now()
                            .withDayOfMonth(newJSONArray.getInteger(0));
                    if (model.getDispatchLeadTime() == 0) {
                        nextTakeTime = reloadLocalDateTimeToLong(nextDateTime.minusMonths(-1).withHour(localTime.getHour())
                                .withMinute(localTime.getMinute())
                                .withSecond(localTime.getSecond()));
                        limitNextTakeTime = reloadLocalDateTimeToLong(nextDateTime.minusMonths(-1).withHour(localTimeLimit.getHour())
                                .withMinute(localTimeLimit.getMinute())
                                .withSecond(localTimeLimit.getSecond()));
                    } else if (model.getDispatchLeadTime() > 0) {
                        nextTakeTime = reloadLocalDateTimeToLong(nextDateTime.minusMonths(-1).withHour(localTime.getHour())
                                .withMinute(localTime.getMinute())
                                .withSecond(localTime.getSecond()).minusMinutes(-model.getDispatchLeadTime()));
                        limitNextTakeTime = reloadLocalDateTimeToLong(nextDateTime.minusMonths(-1).withHour(localTimeLimit.getHour())
                                .withMinute(localTimeLimit.getMinute())
                                .withSecond(localTimeLimit.getSecond()));
                    } else if (model.getDispatchLeadTime() < 0) {
                        nextTakeTime = reloadLocalDateTimeToLong(nextDateTime.minusMonths(-1).withHour(localTime.getHour())
                                .withMinute(localTime.getMinute())
                                .withSecond(localTime.getSecond()).minusMinutes(Math.abs(model.getDispatchLeadTime())));
                        limitNextTakeTime = reloadLocalDateTimeToLong(nextDateTime.minusMonths(-1).withHour(localTimeLimit.getHour())
                                .withMinute(localTimeLimit.getMinute())
                                .withSecond(localTimeLimit.getSecond()));
                    }
                }
            }else if(model.getPlanType()==4){
                //TODO 年计划
                JSONArray newJSONArray = JSONArray.parseArray(model.getCycles()).stream().sorted(
                        // 根据
                        Comparator.comparing(
                                e -> e.toString()
                        )
                        // 放开下面的注释,使用reversed()方法,就是降序 大到小
                        // .reversed()
                ).collect(Collectors.toCollection(JSONArray::new));

                //TODO 先得到所有集合对应的当前周的所有符合条件的时间
                List<String> dateTimeStrings = new ArrayList<>();
                List<String> dateLimitTimeStrings = new ArrayList<>();//最小截止值
                for (Object obj:newJSONArray){
                    String[] monthDays = obj.toString().split("-");
                    LocalDateTime nowDate = LocalDateTime.now().withMonth(Integer.valueOf(monthDays[0]))
                            .withDayOfMonth(Integer.valueOf(monthDays[1]));
                    for (DispatchCmdBatchItemNextTimeModel item : newList){
                        String[] times = item.getHandleStartTime().split(":");
                        String[] timeLimits = item.getHandleStartTimeLimit().split(":");
                        dateTimeStrings.add(nowDate.withHour(Integer.valueOf(times[0]))
                                .withMinute(Integer.valueOf(times[1])).withSecond(Integer.valueOf(times[2])).format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
                        dateLimitTimeStrings.add(nowDate.withHour(Integer.valueOf(timeLimits[0]))
                                .withMinute(Integer.valueOf(timeLimits[1])).withSecond(Integer.valueOf(timeLimits[2])).format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
                    }
                }

                LocalDateTime nextDateTime = findNextTime(dateTimeStrings,oldTm);
                LocalDateTime limitNextDateTime = nextDateTime!=null?LocalDateTime.parse(dateLimitTimeStrings.get(dateLimitTimeStrings.indexOf(nextDateTime
                        .format(DateTimeFormatter.ofPattern(TimeTool.YEAR_MONTH_DAY_FORMAT))+" "+model.getItemsList().stream().sorted(Comparator.comparing(DispatchCmdBatchItemNextTimeModel::getHandleStartTimeLimit))
                        .collect(Collectors.toList()).get(0).getHandleStartTimeLimit())),DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")):null;
                if(nextDateTime!=null){
                    if (model.getDispatchLeadTime() == 0) {
                        nextTakeTime = reloadLocalDateTimeToLong(nextDateTime);
                        limitNextTakeTime = reloadLocalDateTimeToLong(limitNextDateTime);
                    } else if (model.getDispatchLeadTime() > 0) {
                        nextTakeTime = reloadLocalDateTimeToLong(nextDateTime.minusMinutes(-model.getDispatchLeadTime()));
                        limitNextTakeTime = reloadLocalDateTimeToLong(limitNextDateTime);
                    } else if (model.getDispatchLeadTime() < 0) {
                        nextTakeTime = reloadLocalDateTimeToLong(nextDateTime.minusMinutes(Math.abs(model.getDispatchLeadTime())));
                        limitNextTakeTime = reloadLocalDateTimeToLong(limitNextDateTime);
                    }
                }else{
                    LocalTime localTime = LocalTime.parse(newList.get(0).getHandleStartTime(), DateTimeFormatter.ofPattern("HH:mm:ss"));
                    LocalTime localTimeLimit = LocalTime.parse(model.getItemsList().stream().sorted(Comparator.comparing(DispatchCmdBatchItemNextTimeModel::getHandleStartTimeLimit))
                            .collect(Collectors.toList()).get(0).getHandleStartTimeLimit(), DateTimeFormatter.ofPattern("HH:mm:ss"));
                    nextDateTime = LocalDateTime.now()
                            .withMonth(Integer.valueOf(newJSONArray.get(0).toString().split("-")[0]))
                            .withDayOfMonth(Integer.valueOf(newJSONArray.get(0).toString().split("-")[1]));
                    if (model.getDispatchLeadTime() == 0) {
                        nextTakeTime = reloadLocalDateTimeToLong(nextDateTime.minusYears(-1).withHour(localTime.getHour())
                                .withMinute(localTime.getMinute())
                                .withSecond(localTime.getSecond()));
                        limitNextTakeTime = reloadLocalDateTimeToLong(nextDateTime.minusYears(-1).withHour(localTimeLimit.getHour())
                                .withMinute(localTimeLimit.getMinute())
                                .withSecond(localTimeLimit.getSecond()));
                    } else if (model.getDispatchLeadTime() > 0) {
                        nextTakeTime = reloadLocalDateTimeToLong(nextDateTime.minusYears(-1).withHour(localTime.getHour())
                                .withMinute(localTime.getMinute())
                                .withSecond(localTime.getSecond()).minusMinutes(-model.getDispatchLeadTime()));
                        limitNextTakeTime = reloadLocalDateTimeToLong(nextDateTime.minusYears(-1).withHour(localTimeLimit.getHour())
                                .withMinute(localTimeLimit.getMinute())
                                .withSecond(localTimeLimit.getSecond()));
                    } else if (model.getDispatchLeadTime() < 0) {
                        nextTakeTime = reloadLocalDateTimeToLong(nextDateTime.minusYears(-1).withHour(localTime.getHour())
                                .withMinute(localTime.getMinute())
                                .withSecond(localTime.getSecond()).minusMinutes(-model.getDispatchLeadTime()));
                        limitNextTakeTime = reloadLocalDateTimeToLong(nextDateTime.minusYears(-1).withHour(localTimeLimit.getHour())
                                .withMinute(localTimeLimit.getMinute())
                                .withSecond(localTimeLimit.getSecond()));
                    }
                }
            }
        }

        map.put("nextTakeTime",nextTakeTime);
        map.put("limitNextTakeTime",limitNextTakeTime);
        return map;
    }

    //TODO 新增计划
    public static ResponseCode savePlan(JPDispatchPlanInfoSave oJsonParam){
        try{
            //TODO 根据计划类型计算计划的下次生效时间
            DispatchPlanInfoModel model = new DispatchPlanInfoModel();
            model.setPlanId(CommTool.genPlanInfoId());
            model.setPlanType(oJsonParam.getPlanType());
            model.setPlanStatus(oJsonParam.getPlanStatus());
            model.setTitle(oJsonParam.getTitle());
            model.setUrgentLevel(oJsonParam.getUrgentLevel());
            model.setDispatchRemark(oJsonParam.getDispatchRemark());
            model.setDispatchLeadTime(oJsonParam.getDispatchLeadTime());
            model.setCreatorId(oJsonParam.getCreatorId());
            model.setCreateTime(TimeTool.getCurMsUTC());
            model.setCycles(oJsonParam.getCycles());
            model.setZoneId(oJsonParam.getZoneId());
            //TODO 开始计算时间字段并设置
            Long lastTakeTime = 0L;
            Long nextTakeTime = 0L;//下一次生效时间
            Long limitNextTakeTime = 0L;//下一次生效截止时间

            DispatchPlanInfoNextTimeModel nextTimeModel = new DispatchPlanInfoNextTimeModel();
            nextTimeModel.setPlanType(oJsonParam.getPlanType());
            List<DispatchCmdBatchItemNextTimeModel> itemModels = new ArrayList<>();
            if(!CollectionUtils.isEmpty(oJsonParam.getItemsList())){
                for(JPDispatchCmdBatchItem jpItem:oJsonParam.getItemsList()){
                    DispatchCmdBatchItemNextTimeModel dispatchCmdBatchItemNextTimeModel =new DispatchCmdBatchItemNextTimeModel();
                    dispatchCmdBatchItemNextTimeModel.setHandleStartTime(jpItem.getHandleStartTime());
                    dispatchCmdBatchItemNextTimeModel.setHandleStartTimeLimit(jpItem.getHandleEndTime());
                    itemModels.add(dispatchCmdBatchItemNextTimeModel);
                }
            }
            nextTimeModel.setItemsList(itemModels);
            nextTimeModel.setDispatchLeadTime(oJsonParam.getDispatchLeadTime());
            nextTimeModel.setCycles(oJsonParam.getCycles());
            Map<String,Long> nextMap = returnNextTakeTime(nextTimeModel,null);
            nextTakeTime = nextMap.get("nextTakeTime");
            limitNextTakeTime = nextMap.get("limitNextTakeTime");


            model.setLastTakeTime(lastTakeTime);
            model.setNextTakeTime(nextTakeTime);
            model.setLimitNextTakeTime(limitNextTakeTime);
            model.setTakes(0);
            model.setErrors("");
            model.setSendway(oJsonParam.getSendway());
            model.setChufaRulsFlag(oJsonParam.getChufaRulsFlag());

            ResponseCode insertRes = getThisDBService().insertPlanInfoByCount(model,oJsonParam.getRulesList(),
                    oJsonParam.getTagsList(),oJsonParam.getItemsList());
            return insertRes;
//            return null;
        }catch(Exception ex){
            LogPrintMgr.getInstance().printLogMsg(LogLevelFlag.LOG_INFO, mStrClassName, mStrClassName
                    ,String.format("insert planInfo errorMsg:%s end<====",
                            ex.getLocalizedMessage()));
            return ResponseCode.RESULT_BAD;
        }
    }

    //TODO 修改计划增加线程锁
    public static ResponseCode updatePlanClock(JPDispatchPlanInfoUpdate oJsonParam){
        ResponseCode code = ResponseCode.RESULT_BAD;
        if (oJsonParam==null)
            return code;

        CountDownLatchEx latchEx = null;
        int nRetry = 3;
        do {
            try {
                latchEx = WODispatchPlanLockMgr.tryLatchForPlan(oJsonParam.getPlanId(), 20000);
            }catch (Exception e){
                latchEx = null;
            }

            if (latchEx != null){
                code = updatePlan(oJsonParam);
                break;
            }
        }while ((--nRetry) > 0);

        if (latchEx != null){
            latchEx.countDown();
        }else{
            code = updatePlan(oJsonParam);
        }
        return code;
    }

    //TODO 修改计划
    private static ResponseCode updatePlan(JPDispatchPlanInfoUpdate oJsonParam){
        try {
            //TODO 根据计划类型计算计划的下次生效时间
            //TODO 查询原计划是否还存在,若存在比对planType是否一致
            Map<String,Object> oldPlan = getThisDBService().getOne(oJsonParam.getPlanId());
            if(oldPlan==null){
                return ResponseCode.RESULT_REFERENCE_NOT_EXIST;
            }
            if(!oJsonParam.getPlanType().equals(Integer.valueOf(oldPlan.get("plan_type").toString()))){
                return ResponseCode.STATUS_ERROR_JSON_FORMAT;
            }

            //TODO 开始计算时间字段并设置
            Long nextTakeTime = 0L;//下一次生效时间
            Long limitNextTakeTime = 0L;//下一次生效时间

            DispatchPlanInfoNextTimeModel nextTimeModel = new DispatchPlanInfoNextTimeModel();
            nextTimeModel.setPlanType(oJsonParam.getPlanType());
            List<DispatchCmdBatchItemNextTimeModel> itemModels = new ArrayList<>();
            if(!CollectionUtils.isEmpty(oJsonParam.getItemsList())){
                for(JPDispatchCmdBatchItem jpItem:oJsonParam.getItemsList()){
                    DispatchCmdBatchItemNextTimeModel dispatchCmdBatchItemNextTimeModel =new DispatchCmdBatchItemNextTimeModel();
                    dispatchCmdBatchItemNextTimeModel.setHandleStartTime(jpItem.getHandleStartTime());
                    dispatchCmdBatchItemNextTimeModel.setHandleStartTimeLimit(jpItem.getHandleEndTime());
                    itemModels.add(dispatchCmdBatchItemNextTimeModel);
                }
            }
            nextTimeModel.setPlanType(oJsonParam.getPlanType());
            nextTimeModel.setItemsList(itemModels);
            nextTimeModel.setDispatchLeadTime(oJsonParam.getDispatchLeadTime());
            nextTimeModel.setCycles(oJsonParam.getCycles());
            Map<String,Long> nextMap = returnNextTakeTime(nextTimeModel,null);
            nextTakeTime = nextMap.get("nextTakeTime");
            limitNextTakeTime = nextMap.get("limitNextTakeTime");


            ResponseCode updateRes = getThisDBService().updatePlanInfoByCount(oJsonParam,nextTakeTime,limitNextTakeTime, oJsonParam.getRulesList(),
                    oJsonParam.getTagsList(), oJsonParam.getItemsList());
            return updateRes;
        }catch(Exception ex){
            LogPrintMgr.getInstance().printLogMsg(LogLevelFlag.LOG_INFO, mStrClassName, mStrClassName
                    ,String.format("update planInfo errorMsg:%s end<====",
                            ex.getLocalizedMessage()));
            return ResponseCode.RESULT_BAD;
        }
    }

    public static ResponseCode updatePlanStatus(JPDispatchPlanInfoUpdateStatus oJsonParam){
        try {
            //TODO 根据计划类型计算计划的下次生效时间
            //TODO 查询原计划是否还存在,若存在比对planType是否一致
            Map<String,Object> oldPlan = getThisDBService().getOne(oJsonParam.getPlanId());
            if(oldPlan==null||oldPlan.size()<=0){
                return ResponseCode.RESULT_REFERENCE_NOT_EXIST;
            }
            Map<String,Object> oldPlanUpWhere = new HashMap<>();
            oldPlanUpWhere.put("plan_id",oJsonParam.getPlanId());
            Map<String,Object> oldPlanUp = new HashMap<>();
            oldPlanUp.put("plan_status",oJsonParam.getPlanStatus());
            int code = getThisDBService().updateWiths(oldPlanUp,oldPlanUpWhere);
            return code>0?ResponseCode.RESULT_NORMAL:ResponseCode.RESULT_BAD;
        }catch(Exception ex){
            LogPrintMgr.getInstance().printLogMsg(LogLevelFlag.LOG_INFO, mStrClassName, mStrClassName
                    ,String.format("update planInfo errorMsg:%s end<====",
                            ex.getLocalizedMessage()));
            return ResponseCode.RESULT_BAD;
        }
    }

    private static boolean isSameDay(long timestamp1, long timestamp2) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        // 确保时区设置正确，以避免因夏令时导致的问题
        sdf.setTimeZone(TimeZone.getTimeZone("UTC"));

        return sdf.format(new Date(timestamp1)).equals(sdf.format(new Date(timestamp2)));
    }


    //TODO 全量查询标签字典信息
    public static ResponseRes selectAllTags(){
        ResponseRes oRes = new ResponseRes();
        oRes.setRescode(ResponseCode.RESULT_BAD.toStrCode());
        oRes.setResmsg(ResponseCode.RESULT_BAD.toStrMsg());
        try{
            List<Map<String,Object>> map = getThisDBService().selectAllTags("","",new HashMap<>(),new HashMap<>()
            ,"","");
            if(map!=null||map.size()>0){
                oRes.setResdata(FastJsonUtil.toJSON(map,true));
            }

            oRes.setRescode(ResponseCode.RESULT_NORMAL.toStrCode());
            oRes.setResmsg(ResponseCode.RESULT_NORMAL.toStrMsg());
            return oRes;
        }catch (Exception ex){
            return oRes;
        }
    }
}