package com.zy.asrs.task;

import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.core.common.Cools;
import com.zy.asrs.entity.LocMast;
import com.zy.asrs.entity.WrkMast;
import com.zy.asrs.service.LocDetlService;
import com.zy.asrs.service.LocMastService;
import com.zy.asrs.service.WorkService;
import com.zy.asrs.service.WrkMastService;
import com.zy.asrs.task.core.ReturnT;
import com.zy.asrs.utils.Utils;
import com.zy.common.properties.SlaveProperties;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;

@Component
@Slf4j
public class CheckDeepScheduler {

    @Value("${wcs-slave.doubleDeep}")
    private boolean confirmDeep;
    @Value("${scheduler.autoMove}")
    private boolean autoMove;
    @Autowired
    private LocDetlService locDetlService;
    @Autowired
    private LocMastService locMastService;
    @Autowired
    private WorkService workService;
    @Autowired
    private WrkMastService wrkMastService;
    @Autowired
    private SlaveProperties slaveProperties;

    /**
     * 遍历库存中，浅库位状态F/D，深库位状态O的数据，生成库位移转工作档将浅库位移转到对应深库位中去
     */
    @Scheduled(cron = "0/30 * * * * ?")
    private void locMoveToDeep(){
        if (!confirmDeep) return;
        if (!autoMove) return;

        List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>()
                .eq("crn_no",1)
                .last(" and wrk_sts in (2,3,4,11,12)")
        );
        if (wrkMasts.size() > 0) return;

        //遍历库存中，浅库位状态F/D，深库位状态O的数据，生成库位移转工作档将浅库位移转到对应深库位中去
        List<LocMast> locMasts = locMastService.queryShallowLocFMast();
        if (null != locMasts) {
            for (LocMast sourceLoc : locMasts) {
                String deep = Utils.getDeepLoc(slaveProperties, sourceLoc.getLocNo());
                LocMast destLoc = locMastService.selectById(deep);

                if (!Cools.isEmpty(sourceLoc) && !Cools.isEmpty(destLoc)) {
                    //查找源库位是否有转移任务,如果有,不生成库位移转
                    WrkMast wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>()
                            .eq("source_loc_no", sourceLoc.getLocNo()));
                    if (Cools.isEmpty(wrkMast) && destLoc.getLocSts().equals("O") &&
                            (sourceLoc.getLocSts().equals("F") || sourceLoc.getLocSts().equals("D"))) {
                        workService.locMove(sourceLoc.getLocNo(), deep, 1L);
                        return;
                    }
                }
            }
        }

        //遍历库存中，浅库位状态F，深库位状态D的数据，生成库位移转工作档将浅库位移转到新的库位中去
        List<LocMast> locMasts1 = locMastService.queryNeedMoveShallLocF();
        if (null != locMasts1) {
            for (LocMast sourceLoc : locMasts1) {
                LocMast destLoc = locMastService.queryEmptyDeepLoc();

                if (!Cools.isEmpty(sourceLoc) && !Cools.isEmpty(destLoc)) {
                    //查找源库位是否有转移任务,如果有,不生成库位移转
                    WrkMast wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>()
                            .eq("source_loc_no", sourceLoc.getLocNo()));
                    if (Cools.isEmpty(wrkMast) && destLoc.getLocSts().equals("O") &&
                            (sourceLoc.getLocSts().equals("F") || sourceLoc.getLocSts().equals("D"))) {
                        workService.locMove(sourceLoc.getLocNo(), destLoc.getLocNo(), 1L);
                        return;
                    }
                }
            }
        }

        //遍历库存中，浅库位状态F，深库位状态D的数据，生成库位移转工作档将浅库位移转到新的库位中去
        List<LocMast> locMasts2 = locMastService.queryNeedMoveShallLocD();
        if (null != locMasts2) {
            for (LocMast sourceLoc : locMasts2) {
                LocMast destLoc = locMastService.queryEmptyDeepLoc();

                if (!Cools.isEmpty(sourceLoc) && !Cools.isEmpty(destLoc)) {
                    //查找源库位是否有转移任务,如果有,不生成库位移转
                    WrkMast wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>()
                            .eq("source_loc_no", sourceLoc.getLocNo()));
                    if (Cools.isEmpty(wrkMast) && destLoc.getLocSts().equals("O") &&
                            (sourceLoc.getLocSts().equals("F") || sourceLoc.getLocSts().equals("D"))) {
                        workService.locMove(sourceLoc.getLocNo(), destLoc.getLocNo(), 1L);
                        return;
                    }
                }
            }
        }

        //遍历库存中，深库位状态D，浅库位状态为O的深库位数据，生成库位移转工作档将两个D库位合并为深浅库位
        List<LocMast> locMasts3 = locMastService.queryDeepLocDMast();
        if (null != locMasts3) {
            for (LocMast sourceLoc : locMasts3) {
                List<LocMast> locMasts4 = locMastService.queryDeepLocDMast();
                for (LocMast deepLoc : locMasts4){
                    if(sourceLoc.getLocNo().equals(deepLoc.getLocNo())){
                        continue;
                    }
                    String shallow = Utils.getShallowLoc(slaveProperties, deepLoc.getLocNo());
                    LocMast destLoc = locMastService.selectById(shallow);
                    if (!Cools.isEmpty(sourceLoc) && !Cools.isEmpty(destLoc)) {
                        //查找源库位是否有转移任务,如果有,不生成库位移转
                        WrkMast wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>()
                                .eq("source_loc_no", sourceLoc.getLocNo()));
                        if (Cools.isEmpty(wrkMast) && destLoc.getLocSts().equals("O") &&
                                (sourceLoc.getLocSts().equals("F") || sourceLoc.getLocSts().equals("D"))) {
                            workService.locMove(sourceLoc.getLocNo(), destLoc.getLocNo(), 1L);
                            return;
                        }
                    }
                }

            }
        }

    }

    /**
     *遍历库存中，深浅库位状态都为F，物料不相同，或者浅库位入库日期比深库位早的库位，做库位移转移到新的深库位中去
     * 0点到5点之间执行，每次只执行一笔
     */
//    @Scheduled(cron = "0/90 * * * * ?")
    private void LocMoveToNewLoc() throws ParseException {
//        if (!confirmDeep) return;
//
//        for (int crnNo = 1; crnNo < 4; crnNo++){
//            List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>()
//                    .eq("crn_no",crnNo)
//                    .last(" and wrk_sts in (2,3,4,11,12)")
//            );
//            if (wrkMasts.size() > 0) continue;
//            List<LocMast> locMasts = locMastService.queryNeedMoveShallLoc(crnNo);
//            for (LocMast locMast : locMasts) {
//                LocMast targetLoc = locMastService.queryEmptyDeepLoc(crnNo);
//                if(!Cools.isEmpty(targetLoc)) {
//                    workService.locMove(locMast.getLocNo(), targetLoc.getLocNo(), 1L);
//                }
//                break;
//            }
//        }

    }


    /**
     * 将深库位转为对应浅库位
     * @param deep
     * @return
     */
    private String convertShallow(String deep){
        String shallLoc = "";
        Integer mastInt = Integer.parseInt(deep.substring(0, 2));
        if (mastInt % 2 == 0){
            mastInt -= 1;
        }else if (mastInt % 2 == 1){
            mastInt += 1;
        }
        if (mastInt <10){
            shallLoc = "0" + mastInt+ deep.substring(2,7);
        }else {
            shallLoc = mastInt+ deep.substring(2,7);
        }
        return shallLoc;
    }

}