package com.myproject.webapp.controller.webService;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.common.base.Strings;
import com.google.common.collect.*;
import com.myproject.api.ITaskNotify;
import com.myproject.bean.CodeBean;
import com.myproject.bean.json.LiteOrder;
import com.myproject.bean.json.LiteOrderItem;
import com.myproject.bean.qisda.AppendInfo;
import com.myproject.bean.qisda.InquiryShelfBean;
import com.myproject.bean.update.*;
import com.myproject.bean.update.qisda.DNInfo;
import com.myproject.bean.update.qisda.DNItem;
import com.myproject.bean.update.qisda.OutInfo;
import com.myproject.bean.update.qisda.OutItem;
import com.myproject.bean.utils.BoxStatusBean;
import com.myproject.bean.utils.StatusBean;
import com.myproject.dao.mongo.*;
import com.myproject.dao.mongo.qisda.IDNItemDao;
import com.myproject.dao.mongo.qisda.IOutInfoDao;
import com.myproject.dao.mongo.qisda.IOutItemDao;
import com.myproject.exception.ValidateException;
import com.myproject.manager.IBarcodeManager;
import com.myproject.manager.IComponentManager;
import com.myproject.manager.IHumitureManager;
import com.myproject.manager.IStoragePosManager;
import com.myproject.model.User;
import com.myproject.service.UserManager;
import com.myproject.util.HttpHelper;
import com.myproject.util.QisdaApi;
import com.myproject.util.StorageConstants;
import com.myproject.webapp.controller.qisda.QisdaController;
import com.myproject.webapp.controller.qisda.util.OutInfoCache;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.math.RandomUtils;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.servlet.http.HttpServletRequest;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 出入库操作队列缓存等
 */
@Service
public class TaskService implements ITaskService {

    private ObjectMapper mapper = new ObjectMapper();

    @Autowired
    private IStoragePosManager storagePosManager;

    @Autowired
    private IHumitureManager humitureManager;

    @Autowired
    private IBarcodeManager barcodeManager;

    @Autowired
    private IComponentManager componentManager;

    @Autowired
    private IDataLogDao dataLogDao;

    @Autowired
    private ILiteOrderDao liteOrderDao;

    @Autowired
    private ILiteOrderItemDao liteOrderItemDao;

    @Autowired
    private DataCache dataCache;


    @Autowired
    private IAlarmInfoDao alarmInfoDao;

    @Autowired
    private UserManager userManager;

    @Autowired
    private IDNItemDao dNItemDao;

    @Autowired
    private IOutItemDao outItemDao;

    @Autowired
    private OutInfoCache outInfoCache;

    @Autowired
    private IOutInfoDao outInfoDao;

    /**
     * 任务队列,Key 为dataLog的ID，value 为本区域待执行的任务
     */
    private static Map<String, DataLog> taskMap = Maps.newConcurrentMap();

    /**
     * 正在执行的任务列表rowKey 为 cid, columnKey 为 ReelId 即 barcode, Value为 DataLog
     */
    //private static Map<String, DataLog> executingTaskMap = Maps.newConcurrentMap();

    /**
     * 完成的任务列表Key 为为 ReelId 即 barcode, Value 为 Datalog
    */
    private static Map<String,DataLog> finishedTaskMap = Maps.newConcurrentMap();

    /**
     * 状态 map,key为 cid value 为状态 Bean
     */
    protected static Map<String, StatusBean> statusMap = Maps.newConcurrentMap();

    protected final transient Logger log = LogManager.getLogger(getClass());
    /**
     * CID的设备故障消息(key 为 cid)
     */
    private static Map<String, String> clientMsgs = new ConcurrentHashMap<>();

    /**
     * CID的服务器消息(key 为 cid)
     */
    private static Map<String, String> serverMsgs = new ConcurrentHashMap<>();


    /**
     * 正在执行的liteOrderMap, key 为orderNo,value 为order
     */
    public static Map<String, LiteOrder>  liteOrderMap = new ConcurrentHashMap<>();

    /**
     * 当前正在执行的DN单信息(默认是纯入库)
     */
//    private static DNInfo currentDnInfo = new DNInfo();

    /**
     * 获取当前正在执行的DN单信息
     */
//    @Override
//    public DNInfo getCurrentDnInfo(){
//        return currentDnInfo;
//    }
//
//    /**
//     * 切换收料的DN单
//     * @param dnInfo
//     */
//    @Override
//    public void changeCurrentDnInfo(DNInfo dnInfo){
//        String currentDnNo = currentDnInfo.getDnNo();
//        String newDnNo = dnInfo.getDnNo();
//        log.info("切换当前DN单["+currentDnNo+"]为:" + newDnNo);
//        currentDnInfo = dnInfo;
//    }



    /**
     * 更新客户端发上来的消息(设备故障等消息)
     */
    public static void updateClientMsg(String cid, String clientMsg){
        if(clientMsg == null){
            clientMsg = "";
        }
        clientMsgs.put(cid,clientMsg);
    }

    /**
     * 获取某区域正在执行的任务
     */
    @Override
    public Collection<DataLog> getQueueTasks(){
        return taskMap.values();
    }

    /**
     * 获取某区域已完成的任务
     */
    @Override
    public List<DataLog> getFinishedTasks(){
        List<DataLog> areaFinishedTasks = Lists.newArrayList(finishedTaskMap.values());
        List<DataLog> resultTasks = Lists.newArrayList();
        for(DataLog task : areaFinishedTasks){
            if(task.needRemoveFromCache()){
                finishedTaskMap.remove(task.getBarcode());
            }else{
                resultTasks.add(task);
            }
        }
        return resultTasks;
    }

    /**
     * 获取所有任务
     */
    @Override
    public List<DataLog> getAllTasks(){
        Collection<DataLog> queueTasks = getQueueTasks();
        List<DataLog> allTasks = getFinishedTasks();
        if(!queueTasks.isEmpty()){
            allTasks.addAll(queueTasks);
        }
        return allTasks;
    }


    @Override
    public DataLog getFinishedTask(String barcode){
        if(barcode == null){
            return null;
        }
        return finishedTaskMap.get(barcode);
    }

    /**
     * 更新任务(状态,位置信息等)
     */
    @Override
    public void updateFinishedTask(DataLog task){
        //DataLog cacheTask = finishedTaskMap.get(task.getBarcode());
        if(task == null){
            log.error("更新["+task.getBarcode()+"]任务时,任务不存在");
        }else{
            if(task.isFinished()){
                finishedTaskMap.remove(task.getBarcode());
                log.info("任务["+task.getBarcode()+"]完成,更改状态,清理缓存");
            }else{
                finishedTaskMap.put(task.getBarcode(), task);
            }
        }
    }


    /**
     * 流水线入库:优先查找空闲BOX中同尺寸的,如果找不到,再查找可入库 BOX(可用且不是出库状态) 同尺寸或比盘尺寸大的仓位
     */
    public StatusBean putInLine(Storage storage, StatusBean statusBean){
        String errorMsg = "";
        String barcode = statusBean.getCode();
        try {
            Barcode barcodeSave = resolveBarcode(barcode);
            //入库时的RFID
            String inRFID = statusBean.getInRfid();
            verifyBarcodePutIn(Lists.<Storage>newArrayList(storage),barcodeSave,inRFID);

            int w = barcodeSave.getPlateSize();
            int h = barcodeSave.getHeight();
            if(!storage.canPutIn(w, h)){
                throw new ValidateException("尺寸["+w+"x"+h+"]不符");
            }



            StoragePos storagePos;
            DataLog executingTask = null;
            //如果有正在执行的任务,把库位发过去
            for (DataLog task : taskMap.values()) {
                if(task.getBarcode().equals(barcodeSave.getBarcode())){
                    //同条码,且同料仓的入库任务
                    if(task.isPutInTask() && task.getStorageId().equals(storage.getId())){
                        executingTask = task;
                    }else{
                        //同条码,但不是同料仓
                        log.error("条码["+barcodeSave.getBarcode()+"]任务正在执行,但任务料仓为:" + task.getStorageId() + " 请求料仓为:" + task.getStorageId());
                        throw new ValidateException("条码["+barcodeSave.getBarcode()+"]任务正在执行");
                    }

                }
            }

            if(executingTask != null){
                String posId = executingTask.getPosId();
                log.info(barcodeSave.getBarcode() + " 已有任务,返回任务中的库位:" + executingTask.getPosName());
                storagePos = storagePosManager.get(posId);
            }else{
                String posName = statusBean.getFromData("inPos");
                if(!Strings.isNullOrEmpty(posName)){
                    log.info("指定入库到" + posName);

                    storagePos = storagePosManager.getByPosName(posName);
                    if(storagePos == null){
                        throw new ValidateException("库位【"+posName+"】不存在,无法入库");
                    }
                    if(!storage.getId().equals(storagePos.getStorageId())){
                        throw new ValidateException("库位【"+posName+"】与料仓["+storage.getCid()+"]不匹配,无法入库");
                    };
                    if(storagePos.getBarcode() != null){
                        throw new ValidateException("库位【"+posName+"】中已有物料,无法入库");
                    }

                    if(!storage.canPutInPos(barcodeSave.getPlateSize(),barcodeSave.getHeight(), storagePos.getW(), storagePos.getH())){
                        throw new ValidateException("料盘尺寸与库位【"+posName+"】不符,无法入库");
                    }

                }else{
                    storagePos = findLineEmptyPosForPutIn(storage, barcodeSave);
                }

                String singleIn = statusBean.getFromData("singleIn");
                if(!Strings.isNullOrEmpty(singleIn)){
                    //批量料仓单盘入库的只能单盘出,不可批量
                    if(singleIn.equalsIgnoreCase("true")){
                        log.info(barcodeSave.getBarcode() + "单盘入库,出库时此条码只可单盘出库");
                        barcodeSave.setOnlySingleOut(true);
                        barcodeManager.save(barcodeSave);
                    }
                }

                addPutInTaskToExecute(storage, barcodeSave, storagePos);
            }


            String posId = storagePos.getPosName();
            int plateW = barcodeSave.getPlateSize();
            int plateH = barcodeSave.getHeight();
            statusBean.addPosInfo(posId,plateW,plateH,false);

            log.info(barcode+"["+plateW+"x"+plateH + "]开始入库到"+storage.getCid()+"["+posId+"]");
            //清空展示的消息
            serverMsgs.put(storage.getCid(),"");

        } catch (ValidateException e) {
            log.warn("入库到"+storage.getCid() + "失败:"+e.getMessage());
            statusBean.setMsg(e.getMessage());
            serverMsgs.put(storage.getCid(),e.getMessage());
            errorMsg=e.getMessage();
        } catch (Exception e) {
            log.error(statusBean.getCode() + "入库到"+storage.getCid() + "失败", e);
            statusBean.setMsg(e.getMessage());
            serverMsgs.put(storage.getCid(),e.getMessage());
            errorMsg=e.getMessage();
        }

        if(!errorMsg.isEmpty()){
            //有错误,记录日志
            AlarmInfo alarmInfo = new AlarmInfo();
            alarmInfo.setBoxId("0");
            alarmInfo.setStorageName(storage.getName());
            alarmInfo.setInOutStatus("1");
            alarmInfo.setAlarmType("入库失败");
            Date date = new Date();
            alarmInfo.setStartTime(date);
            alarmInfo.setEndTime(date);
            String msg = "["+barcode+"]"+errorMsg;
            alarmInfo.setAlarmMsg(msg);
            alarmInfoDao.save(alarmInfo);
        }

        return statusBean;
    }

    private Barcode findFixtureCode(Collection<CodeBean> codeBeans) throws ValidateException {
        if(codeBeans.isEmpty()){
            throw new ValidateException("未扫描到条码");
        }
        Barcode fixtureCode = null;
        for (CodeBean codeBean : codeBeans) {
            Barcode barcode = codeBean.getBarcode();
            if(codeBean.isFixtureCode()){
                if (fixtureCode == null) {
                    fixtureCode = barcode;
                    log.info("找到夹具编码:"+ fixtureCode.getBarcode());
                }else{
                    String msg = "出现两个夹具编码["+fixtureCode.getBarcode()+"]和["+barcode.getBarcode()+"]";
                    log.info(msg);
                    throw new ValidateException(msg);
                }
            }else{
                if(barcode == null){
                    log.info("条码为空,Error:"+ codeBean.getError());
                }else{
                    log.info(barcode.getBarcode() + "不是夹具" + "codeBean Error:" + codeBean.getError() + " type:"+ barcode.getType());
                }
            }
        }
        return fixtureCode;
    }

    private Barcode resolveBarcode(String barcodeStr)throws ValidateException {
        Collection<CodeBean> codeBeans = dataCache.resolveCodeStr(barcodeStr);
        Barcode fixtureCode = findFixtureCode(codeBeans);

        List<Barcode> allBarcode = Lists.newArrayList();
        for (CodeBean codeBean : codeBeans) {
            if(!codeBean.isFixtureCode()){
                if(codeBean.getError() == null){
                    Barcode barcode = codeBean.getBarcode();
                    if(barcode != null){
                        if(fixtureCode != null){//有夹具条码,判断夹具与编码是否一致
                            //物料对应无夹具,或夹具与此夹具不一致,不可放入
                            if(Strings.isNullOrEmpty(barcode.getFixtureNumber()) || !fixtureCode.getPartNumber().equals(barcode.getFixtureNumber())){
                                throw new ValidateException(barcode.getPartNumber() + "不能放入夹具"+fixtureCode.getPartNumber()+"中");
                            }
                            fixtureCode.addRelationCode(barcode.getBarcode());
                        }else{
                            //条码中无夹具,但物料需要放入夹具
                            if(!Strings.isNullOrEmpty(barcode.getFixtureNumber())){
                                throw new ValidateException(barcode.getPartNumber() + "需要放入对应夹具中才可入库");
                            }
                        }
                        allBarcode.add(barcode);
                    }
                }else{
                    //throw new ValidateException(codeBean.getError());
                }

            }

        }

        //有夹具条码,可以直接返回
        if(fixtureCode != null){
            return fixtureCode;
        }

        int codeSize = allBarcode.size();
        if(codeSize == 0){
            throw new ValidateException(barcodeStr + "不是有效的条码");
        }else if(codeSize > 1){
            throw new ValidateException("找到"+codeSize+"个有效条码,无法入库");
        }
        return allBarcode.get(0);
    }

    /**
     * 检查二维码是否合法并且可以入库,没问题的话存入到数据库
     */
    private Barcode verifyBarcodePutIn(List<Storage> storageList, Barcode barcodeSave, String inRFID) throws ValidateException {

        if(barcodeSave == null){
            throw new ValidateException("条码无效");
        }

//        Date expireDate = barcodeSave.getExpireDate();
//        if(expireDate != null){
//            if(System.currentTimeMillis() > expireDate.getTime()){
//                throw new ValidateException("物料已过期,无法入库.");
//            }
//        }

//        if(barcodeSave.getPlateSize() <=0 || barcodeSave.getHeight() <= 0){
//            throw new ValidateException("无法入库,请先设置料盘尺寸");
//        }

        StoragePos pos;

        //夹具,查询 relationCode
        if(StorageConstants.COMPONENT_TYPE.FIXTURE == barcodeSave.getType()){
            pos = storagePosManager.getByFixtureCode(barcodeSave.getBarcode());
        }else {
            pos = storagePosManager.getByBarcodeId(barcodeSave.getId());

            if (barcodeSave.getAmount() <= 0) {
                throw new ValidateException("条码[" + barcodeSave + "]对应的数量<=0为: " + barcodeSave.getAmount());
            }
        }

        if (pos != null) {
            Storage storage = dataCache.getStorageById(pos.getStorageId());
            throw new ValidateException("[ " + barcodeSave.getBarcode() + "]已在"+storage.getName()+"["+pos.getPosName()+"]中");
        }

        Collection<DataLog> queueTasks = getQueueTasks();
        List<DataLog> allTasks = getFinishedTasks();
        if(!queueTasks.isEmpty()){
            allTasks.addAll(queueTasks);
        }

        for (DataLog task : allTasks) {
            if(task.isPutInTask()){
                if(task.getBarcode().equals(barcodeSave.getBarcode())){
                    //同一个条码的入库任务
                    for (Storage storage : storageList) {
                        if(task.getStorageId().equals(storage.getId()) && task.isPutInTask()){
                            return barcodeSave;
                        }
                    }
                    throw new ValidateException("料盘[ " + barcodeSave.getBarcode() + "]的操作未完成,无法执行入库操作");
                }
            }
        }

        AppendInfo appendInfo = barcodeSave.getAppendInfo();
        String oldDnNo = appendInfo.getDnNo();

//        if(Strings.isNullOrEmpty(oldDnNo)){
//            //已经有旧的DN单,使用纯入库操作
//            appendInfo.setCisIn(true);
//        }else{
            appendInfo.setCisIn(false);
        //}

        //DN单验证
        appendInfo.setDnNo("");
        appendInfo.setFacility("");

        DNInfo dnInfo = QisdaController.getDnInfo(inRFID);
        if(dnInfo.isDNIn()){
            String pn = barcodeSave.getPartNumber();
            DNItem dnItem = dnInfo.getItem(pn);
            if(dnItem == null){
                String msg = "DN单["+dnInfo.getDnNo()+"]中无["+pn+"],无法收料";
                log.info(msg);
                throw new ValidateException(msg);
            }
            appendInfo.setDnNo(dnInfo.getDnNo());
            appendInfo.setFacility(dnItem.getFacility());
            appendInfo.setCompany(dnItem.getCompany());
        }else if(dnInfo.isFacilityIn()){
            appendInfo.setDnNo(dnInfo.getDnNo());
            appendInfo.setFacility(dnInfo.getFacility());
            appendInfo.setCompany(dnInfo.getCompany());
        }else{
            appendInfo.setDnNo("");
        }

        log.info("[" + inRFID + "]"+ barcodeSave.getBarcode() + " 上次入库DN单:" + oldDnNo + " 当前入库DN单:" + appendInfo.getDnNo());

        barcodeSave.setAppendInfo(appendInfo);

            //3.	 CIS入库判定接口 (没绑过料串的条码调用此接口)
            //6.	 CIS收料判定接口（绑过料串的条码扫码入库时判断）
        if(DataCache.isProductionFor(DataCache.CUSTOMER.QISDA)){
            if(barcodeSave.needToQisda()){
                Barcode result = QisdaApiController.CISInCheck(dnInfo, barcodeSave);
                if(result != null){
                    barcodeSave = result;
                }
                barcodeSave = barcodeManager.save(barcodeSave);
            }else{
                log.info("条码["+barcodeSave.getBarcode()+"]不需要到Qisda验证");
                appendInfo.setFacility("AAA");
                barcodeSave.setAppendInfo(appendInfo);
                barcodeSave = barcodeManager.save(barcodeSave);
            }

        }else{
            log.info("Qisda接口验证已关闭");
        }

        return barcodeSave;
    }



    /**
     * 查找可以入库的空位
     * @param storageList
     * @param barcode
     * @return
     */
    @Override
    public StoragePos findEmptyPosForPutIn(List<Storage> storageList, Barcode barcode, String inRFID) throws ValidateException{
        verifyBarcodePutIn(storageList ,barcode, inRFID);

        //如果有正在执行的任务,把库位发过去
        Collection<DataLog> allTasks = taskMap.values();
        for (DataLog task : allTasks) {
            if(barcode.getBarcode().equals(task.getBarcode())){
                String posId = task.getPosId();
                log.info(barcode.getBarcode() + " 已有任务,返回任务中的库位:" + task.getPosName());
                return storagePosManager.get(posId);
            }
        }


        //查找任务数最少的料仓
        Map<String,Integer> countMap = new HashMap<>();
        for (Storage storage : storageList) {
            countMap.put(storage.getId(), 0);
        }

        //Set<String> hasOutTaskStorageIds = new HashSet<>();
        for (DataLog task : allTasks) {
            String storageId = task.getStorageId();
            if(!Strings.isNullOrEmpty(storageId)){
                Integer taskCount = countMap.get(storageId);
                if(taskCount != null){
                    taskCount = taskCount + 1;
                    countMap.put(storageId, taskCount);
                }
//                if(task.isCheckOutTask()){
//                    hasOutTaskStorageIds.add(storageId);
//                }
            }
        }

        //可用的料仓(在线,且可以放入)
        List<Storage> availbleStorageList = new ArrayList<>();

        for(Storage storage : storageList){
            StatusBean status = getStatus(storage.getCid());
            if(status.timeOut()){
                continue;
            }
//            if(hasOutTaskStorageIds.contains(storage.getId())){
//                //流水线有出库任务的,不分配入库任务(出库优先)
//                continue;
//            }
            if(storage.canPutIn(barcode.getPlateSize(),barcode.getHeight())){
                availbleStorageList.add(storage);
            }
        }


        for (Storage storage : availbleStorageList) {
            String storageId = storage.getId();

            Integer taskCount = countMap.get(storageId);
            if(taskCount >= 2){
                continue;
            }

            try{
                log.info("尝试从"+storage.getName()+"["+storage.getCid()+"]查找空位,当前料仓任务数:" + taskCount);
                return findLineEmptyPosForPutIn(storage,barcode);
            }catch(Exception e){
                log.info("从"+storage.getName()+"["+storage.getCid()+"]查找空位失败:" + e.getMessage());
            }
        }

        //只有一个料仓可以入时,只能继续往里面放
        log.info("可用料仓太少,不按任务数分配,重新查找...");
        for (Storage storage : availbleStorageList) {
            try{
                log.info("不按任务数分配,尝试从"+storage.getName()+"["+storage.getCid()+"]查找空位");
                return findLineEmptyPosForPutIn(storage,barcode);
            }catch(Exception e){
                log.info("从"+storage.getName()+"["+storage.getCid()+"]查找空位失败:" + e.getMessage());
            }
        }

        return null;

    }
    /**
     * 为 barcode 查找流水线料仓中空闲的仓位
     */
    private StoragePos findLineEmptyPosForPutIn(Storage storage, Barcode barcode) throws ValidateException {

        String storageCid = storage.getCid();
        //先查找空闲 BOX同尺寸的,如果找不到,再查找可入库 BOX 同尺寸或比盘尺寸大的仓位
        StatusBean statusBean = statusMap.get(storageCid);
        if (statusBean == null) {//当前料仓不可用
            throw new ValidateException("料仓[ " + storageCid + "]不可用");
        }
        //还需要排除掉正在队列里的仓位
        StoragePos storagePos = null;

        if(statusBean.isBoxCanPutIn()){
            log.info("从"+storage.getName()+"中为"+barcode.getBarcode()+"寻找空的仓位");
            Collection<String> operatingPosIds = excludePosIds();
            storagePos = storagePosManager.getEmptyPosByStorage(storage, barcode , operatingPosIds);
        }else{
            throw new ValidateException(storage.getName() + "的状态为不可入库");
        }

        if (storagePos == null) {
            throw new ValidateException(storage.getName() + "的料格["+barcode.getPlateSize() +"x" + barcode.getHeight() +"]已满,无法继续放入");
        }
        log.info("["+ barcode.getBarcode() + "]寻找到"+storage.getName()+"的空仓位["+storagePos.getPosName()+"]");
        return storagePos;
    }

    /**
     * 出库处理
     */
    public StatusBean checkOut(Storage storage, StatusBean statusBean){
        try{
            String cid = storage.getCid();
            if(statusBean.canCheckout()){
                DataLog task = findCheckoutBoxTask(cid);
                if (task != null) {

                    statusBean.setOp(StorageConstants.OP.CHECKOUT);
                    String posName = task.getPosName();
                    //taskService.updateBoxStatus(statusBean.getCid(),posName, StorageConstants.OP.CHECKOUT);

                    Barcode codeObj = barcodeManager.findByBarcode(task.getBarcode());

                    int plateW = 0;
                    int plateH = 0;
                    //是否是单盘出库,批量上下料使用
                    boolean isSingleOut = task.isSingleOut();
                    if(codeObj != null){
                        plateW = codeObj.getPlateSize();
                        plateH = codeObj.getHeight();
                        if(codeObj.isOnlySingleOut()){
                            log.info(codeObj.getBarcode() + " 只能单盘出库");
                            isSingleOut = true;
                        }
                    }else{
                        log.warn("出库无料仓位"+storage.getName()+"["+posName+"]");
                    }
                    statusBean.addPosInfo(posName,plateW,plateH, isSingleOut);
                    AppendInfo appendInfo = task.getAppendInfo();

                    //紧急料
                    statusBean.addData("urgentReel",task.isUrgentReel() + "");
                    //需要分盘,进入分盘料
                    statusBean.addData("cutReel",task.isCutReel() + "");
                    statusBean.addData("rfid", task.getTempRfid());
                    statusBean.addData("realRfid",appendInfo.getRfid());
                    statusBean.addData("rfidLoc", appendInfo.getRfidLoc() + "");
                    statusBean.addData("barcode", task.getBarcode());


                    boolean smallReel = task.isSmallReel();
                    if(storage.isPackage()){
                        smallReel = false;
                    }
                    statusBean.addData("smallReel", smallReel+"");


                    task.setStatus(StorageConstants.OP_STATUS.EXECUTING.name());
                    taskMap.put(task.getId(), task);
                    dataLogDao.save(task);

                    log.info("出库"+storage.getName()+"["+posName+"]物料["+task.getBarcode()+"]"+isSingleOut+"发送到客户端" + cid);
                }
            }

            String posId = statusBean.getData().get("posId");
            if(!Strings.isNullOrEmpty(posId)){
                log.info("SEQ:" + statusBean.getSeq() + "出库库位信息:["+posId+"]发送到客户端");
            }
        }catch (Exception e){
            log.error("出库出错",e);
        }

        return statusBean;
    }

//    /**
//     * 从库位中查找20条呆滞料,并生成任务保存到数据库中,返回生成的任务数
//     */
//    private List<DataLog> saveInactionTasks(InactionTaskSet inactionTaskSet){
//        int day = inactionTaskSet.getDay();
//        List<String> storageIds = dataCache.needClearInactionStorageIds();
//        //每个料仓找5个
//        int count = 3;
//        List<StoragePos> list = Lists.newArrayList();
//        for(String storageId : storageIds){
//            List<StoragePos> storageList = storagePosManager.findInaction(Lists.<String>newArrayList(storageId), day, excludePosIds(), count);
//            list.addAll(storageList);
//        }
//        List<DataLog> tasks = Lists.newArrayList();
//        for (StoragePos pos : list){
//            DataLog task = newTask(pos);
//            task.setType(StorageConstants.OP.CHECKOUT);
//            task.setStatus(StorageConstants.OP_STATUS.WAIT.name());
//            //来源
//            task.setSourceType(StorageConstants.TASK_SOURCE.INACTION.name());
//            task.setSourceId(inactionTaskSet.getId());
//            task.setSourceName(inactionTaskSet.getName());
//            //将天数放在 subSourceId 中
//            task.setSubSourceId(day+"");
//            task.setSubSourceInfo("");
//            tasks.add(task);
//        }
//        if(!tasks.isEmpty()){
//            dataLogDao.insertAll(tasks);
//        }
//        return tasks;
//
//    }

    public DataLog newTask(StoragePos pos){

        DataLog task = new DataLog();

        Barcode barcode = pos.getBarcode();
        if(barcode != null){
            task.setPartNumber(barcode.getPartNumber());
            task.setBarcode(barcode.getBarcode());
            task.setNum(barcode.getAmount());
            task.setW(barcode.getPlateSize());
            task.setH(barcode.getHeight());
            AppendInfo appendInfo = barcode.getAppendInfo();
            String shelfType = InquiryShelfBean.getShelfType(task);
            appendInfo.setShelfType(shelfType);
            if(barcode.hasCutInfo()){
                task.setCutReel(true);
            }
            task.setAppendInfo(appendInfo);
        }

        Storage storage = dataCache.getStorageById(pos.getStorageId());
        if(storage.isPackage()){
            //包装料仓
            task.setPackageReel(true);
        }
        task.setCid(storage.getCid());
        task.setStorageId(storage.getId());
        task.setStorageName(storage.getName());

        task.setPosId(pos.getId());
        task.setPosName(pos.getPosName());

        return task;
    }


    private boolean cancelTask(DataLog task){
        if(task != null){
            //从正在执行和等待列表中移除
            taskMap.remove(task.getId());
            String barcode = task.getBarcode();
            if(!Strings.isNullOrEmpty(barcode)){
                finishedTaskMap.put(task.getBarcode(), task);
            }
            task.setStatus(StorageConstants.OP_STATUS.CANCEL.name());
            dataLogDao.save(task);
            log.info("任务["+task.getId() + "] posName["+task.getPosName()+"] Reel Id["+task.getBarcode()+"]取消成功");
            finishedOrderTask(task);
            InquiryShelfBean.cancelReelTask(task);
            return true;
        }
        return false;
    }

    @Override
    public boolean cancelTask(String taskId) {
        DataLog task = dataLogDao.findOneById(taskId);
        if(task.isCheckOutTask()){
            log.info(task.getBarcode() + "出库任务取消失败: 不允许取消");
            return false;
        }
        return cancelTask(task);
    }

    @Override
    public void hideTask(String taskId) {
        DataLog task = dataLogDao.findOneById(taskId);

        if(task.isCheckOutTask()){
            //发送取消(发料)指令到佳世达
            AppendInfo taskAppendInfo = task.getAppendInfo();
            if(taskAppendInfo.isFirstReelAction() || taskAppendInfo.isTailAction()){
                Barcode barcode = barcodeManager.findByBarcode(task.getBarcode());
                log.info("["+task.getBarcode()+"]任务已出库完成,但未放上小车,发送E状态到佳世达,同时解除料架架位,发料任务完成数量+1");
                OutInfo outInfo = outInfoDao.findByHSerial(taskAppendInfo.gethSerial());
                if(outInfo != null) {
                    outInfo.setTaskFinishNum(outInfo.getTaskFinishNum() + 1);
                    log.info("需求单[" + outInfo.gethSerial() + "]任务完成数量:" + outInfo.getTaskFinishNum() + "/" + outInfo.getTaskNum() + "已出仓料盘数量:" + outInfo.getOutReelNum());
                    outInfoDao.save(outInfo);
                    InquiryShelfBean.cancelReelTask(task);
                    QisdaApi.VMIMateriaRecAss(task, barcode, "E");
                }
            }
            finishedTaskMap.remove(task.getBarcode());
        }
    }

    /**
     * 获取正在执行出库(或入库)的 boxID,用作出入库时分配仓位,防止卡死的问题
     */
    private Set<Integer> getExcutingBoxIds(String cid, int type){
        Set<Integer> excuteBoxIds = Sets.newHashSet();
        for (DataLog task : taskMap.values()){
            if(type == task.getType()){
                String posName = task.getPosName();
                int index = posName.indexOf("#");
                if(index>0){
                    String boxId = posName.substring(0,index);
                    excuteBoxIds.add(Integer.valueOf(boxId));
                }
            }
        }
        return excuteBoxIds;
    }


    /**
     * 防止仓位任务重复,需要排除掉已经分配掉的仓位
     */
    @Override
    public Collection<String> excludePosIds(){
        //排除掉正在执行的仓位
        Collection<DataLog> allTasks = new ArrayList<>(taskMap.values());
//        try{
//            for (DataLog finishTask : finishedTaskMap.values()) {
//                allTasks.add(finishTask);
//            }
//        }catch (Exception e){
//            log.error("获取排除库位出错",e);
//        }


        Collection<String> operatingPosIds = new HashSet<>();
        for(DataLog task : allTasks){
            String posId = task.getPosId();
            if(!Strings.isNullOrEmpty(posId)){
                operatingPosIds.add(task.getPosId());
            }
        }
        return operatingPosIds;
    }


    /**
     * 为 box 分配出库任务
     */
    private DataLog findCheckoutBoxTask(String cid) {
        Storage storage = dataCache.getStorage(cid);
        if(storage == null){//该 Box 已经被限制出入库
            return null;
        }
        int checkoutSize = 0;
        Collection<DataLog> waitTasks = taskMap.values();
        for(DataLog task : waitTasks){
            //如果该BOX在已执行任务中已经有入库任务,不再分配直接返回
            if(cid.equals(task.getCid()) && task.isExecuting()){
                if(task.isPutInTask()){
                    //log.error("cid["+cid + "]box["+boxId+"]已有入库任务,不可再分配出库任务");
                    return null;
                }else if(task.needReSendToClient()){//超过30秒仍未完成的出库再次发送到客户端
                    log.error("cid["+cid + "]的出库任务["+ task.getPosName()+"]超过60秒仍未完成,重新发送到客户端!");
                    task.setUpdateDate(new Date());
                    return task;
                }
                //某个 Box 只能同时有两个正在执行的出库任务,如果超过两个不再分配了

                if(task.isCheckOutTask()){
                    checkoutSize ++;
                    if(checkoutSize >=2){
                        //log.error("cid["+cid + "]的BOX["+ boxId+"]的出库任务已经超过2个,不再分配!");
                        return null;
                    }
                }
            }
        }


        //if(DataCache.isProductionFor(DataCache.CUSTOMER.QISDA)){
        //分盘料,按时间顺序进行出库
        DataLog urgentTask = null;
        for (DataLog task : waitTasks) {
            if(cid.equals(task.getCid()) && task.isCheckOutTask() && task.isWait()) {
                //分盘料,紧急料和包装料,可以按时间顺序先出
                if(task.isCutReel() || task.isUrgentReel() || task.isPackageReel()){
                    if(urgentTask == null || urgentTask.getCreateDate().after(task.getCreateDate())){
                        urgentTask = task;
                    }
                }
            }
        }
        if(urgentTask != null){
            log.info("出库最先生成的分盘/紧急/包装料任务"+urgentTask.getBarcode()+"["+urgentTask.getPosName()+"]");
            return urgentTask;
        }

            //按料架顺序,从小盘开始出库
            boolean hasFirstReelAction = false;
            //编号最小的料架
            int minCRfidIndex = -1;
            int minDRfidIndex = -1;
            int minARfidIndex = -1;


            for (DataLog task : waitTasks) {
                if(task.isCheckOutTask()) {
                    AppendInfo appendInfo = task.getAppendInfo();
                    if(appendInfo.isFirstReelAction()){
                        //首盘料
                        hasFirstReelAction = true;
                    }
                    int rfidIndex = appendInfo.getRfidIndex();
                    boolean isAShelf = StorageConstants.SHEFL_TYPE.isAShelf(appendInfo.getShelfType());
                    if(isAShelf){
                        //包装料最小的料架编号
                        if(minARfidIndex == -1 || rfidIndex < minARfidIndex){
                            minARfidIndex = rfidIndex;
                        }
                    }

                    boolean isDShelf = StorageConstants.SHEFL_TYPE.isDShelf(appendInfo.getShelfType());
                    if(isDShelf){
                        //小料架
                        if(minDRfidIndex == -1 || rfidIndex < minDRfidIndex){
                            minDRfidIndex = rfidIndex;
                        }
                    }

                    boolean isCShelf = StorageConstants.SHEFL_TYPE.isCShelf(appendInfo.getShelfType());
                    if(isCShelf){
                        //大料架
                        if(minCRfidIndex == -1 || rfidIndex < minCRfidIndex){
                            minCRfidIndex = rfidIndex;
                        }
                    }
                }
            }

            if(hasFirstReelAction){
                return findFirstActionask(storage, minARfidIndex,minDRfidIndex, minCRfidIndex);

            }else{
                //补料
                return findTailActionTask(storage, minARfidIndex,minDRfidIndex, minCRfidIndex);
            }
        //}

    }

    /**
     * 查找包装料最小料架的任务
     */
    private DataLog findPackageMinTask(Storage storage, int minARfidIndex){
        DataLog storageTask = null;
        if(storage.isPackage()){
            //找当前料仓最小料架,最小架位的
            for (DataLog task : taskMap.values()) {
                if (storage.getCid().equals(task.getCid()) && task.isCheckOutTask() && task.isWait()) {
                    //按料架顺序
                    if(minARfidIndex != -1){
                        AppendInfo appendInfo = task.getAppendInfo();
                        int rfidIndex = appendInfo.getRfidIndex();
                        boolean isAShelf = StorageConstants.SHEFL_TYPE.isAShelf(appendInfo.getShelfType());
                        if(isAShelf && rfidIndex <= minARfidIndex){
                            if(storageTask == null || appendInfo.getRfidLoc() < storageTask.getAppendInfo().getRfidLoc()){
                                storageTask = task;
                            }
                        }
                    }
                }
            }
            if(storageTask != null){
                log.info("出库首盘料任务[包装料]"+storageTask.getBarcode()+"["+storageTask.getPosName()+"]" + storageTask.getAppendInfo());
            }
        }
        return storageTask;
    }


    /**
     * 查找首盘料出库任务
     */
    private DataLog findFirstActionask(Storage storage, int minARfidIndex, int minDRfidIndex, int minCRfidIndex){
        DataLog storageTask = null;
        //包装料仓
        if(storage.isPackage()){
            //包装料仓的最小料架的任务
            return findPackageMinTask(storage, minARfidIndex);
        }else{
            //首套料需要先出D料架,再出C料架,并且要按料架顺序
            //架位顺序随机,保证左右机器人均衡
            boolean locAsc = RandomUtils.nextBoolean();
            for (DataLog task : taskMap.values()) {
                if(storage.getCid().equals(task.getCid()) && task.isCheckOutTask() && task.isWait()){
                    AppendInfo appendInfo = task.getAppendInfo();
                    int rfidIndex = appendInfo.getRfidIndex();
                    if(minDRfidIndex != -1){
                        //有小料架(D),出最小的D料架
                        boolean isDShelf = StorageConstants.SHEFL_TYPE.isDShelf(appendInfo.getShelfType());
                        if(isDShelf && rfidIndex <= minDRfidIndex){
                            if(storageTask == null){
                                storageTask = task;
                            }else{
                                if(locAsc){
                                    //升序,取最小的架位
                                    if(appendInfo.getRfidLoc() < storageTask.getAppendInfo().getRfidLoc()){
                                        storageTask = task;
                                    }
                                }else{
                                    //降序,取最大的架位
                                    if(appendInfo.getRfidLoc() > storageTask.getAppendInfo().getRfidLoc()){
                                        storageTask = task;
                                    }
                                }
                            }
                        }
                    }else{
                        //没有小料架(D),那么可以出C料架了
                        boolean isCShelf = StorageConstants.SHEFL_TYPE.isCShelf(appendInfo.getShelfType());
                        if(isCShelf && rfidIndex <= minCRfidIndex){
                            if(storageTask == null){
                                storageTask = task;
                            }else{
                                if(locAsc){
                                    //升序,取最小的架位
                                    if(appendInfo.getRfidLoc() < storageTask.getAppendInfo().getRfidLoc()){
                                        storageTask = task;
                                    }
                                }else{
                                    //降序,取最大的架位
                                    if(appendInfo.getRfidLoc() > storageTask.getAppendInfo().getRfidLoc()){
                                        storageTask = task;
                                    }
                                }
                            }

                        }
                    }
                }
            }
        }
        if(storageTask != null){
            //如果双层线上有两个料架,但任务不属于这两个料架,不允许出库
            if(InquiryShelfBean.canCheckOutFistActionTask(storageTask)){
                log.info("出库首盘料任务"+storageTask.getBarcode()+"["+storageTask.getPosName()+"]" + storageTask.getAppendInfo());
                return storageTask;
            }
        }

        return null;
    }

    /**
     * 查找补料任务
     * @return
     */
    private DataLog findTailActionTask(Storage storage, int minARfidIndex, int minDRfidIndex, int minCRfidIndex){
        //包装料仓,不按顺序,可以同时出
        if(storage.isPackage()){
            return findPackageMinTask(storage, minARfidIndex);
        }else{
            //一次性把D料架出完,再出C料架,包装料可以同时出
            for (DataLog task : taskMap.values()) {
                if(storage.getCid().equals(task.getCid()) && task.isCheckOutTask()  && task.isWait()){
                    //还有小料架出库任务,出小料架
                    if(minDRfidIndex != -1){
                        if(task.isSmallReel()){
                            log.info("出库小料任务"+task.getBarcode()+"["+task.getPosName()+"]");
                            return task;
                        }
                    }else{
                        //开始出大料架,不需要按顺序
                        if(!task.isSmallReel()){
                            //未完成的大料数量(正在执行和未放上料架的)
                            int unFinishedBigTaskCount = 0;
                            for (DataLog dataLog : taskMap.values()) {
                                if(!dataLog.isPackageReel() && !dataLog.isSmallReel() && dataLog.isExecuting()){
                                    unFinishedBigTaskCount = unFinishedBigTaskCount + 1;
                                }
                            }
                            for (DataLog dataLog : finishedTaskMap.values()) {
                                if(!dataLog.isPackageReel()){
                                    if(!dataLog.isSmallReel() && !dataLog.isFinished()){
                                        //非包装料大料任务还未完成(未放入料架),暂时不出大料
                                        unFinishedBigTaskCount = unFinishedBigTaskCount + 1;
                                    }
                                }
                            }
                            if(InquiryShelfBean.canCheckOutTailActionTask(task, unFinishedBigTaskCount)){
                                log.info("出库大料任务"+task.getBarcode()+"["+task.getPosName()+"]");
                                return task;
                            }
                        }
                    }
                }
            }
        }
        return null;
    }


    @Override
    public synchronized String checkOutLiteOrder(String orderNo, boolean outBom){
        LiteOrder cacheOrder = liteOrderMap.get(orderNo);
        if(cacheOrder != null && !cacheOrder.isTaskFinished() && !cacheOrder.isNew()){
            log.info("工单["+orderNo+"]正在执行");
            return "当前工单正在执行";
        }
        if(cacheOrder == null){
            cacheOrder = liteOrderDao.findWithItemsByOrderNo(orderNo);
        }

        if(cacheOrder == null){
            return "未找到工单";
        }

        log.info("开始执行工单["+orderNo+"] outBom="+outBom);
        cacheOrder.setTaskReelCount(0);
        cacheOrder.setTaskFinishedTime(-1);
        cacheOrder.setFinishedReelCount(0);
        if(outBom){
            cacheOrder.setStatus(StorageConstants.LITEORDER_STATUS.BOM);
        }else{
            cacheOrder.setStatus(StorageConstants.LITEORDER_STATUS.TAILS);
        }
        //liteOrderMap.put(cacheOrder.getOrderNo(), cacheOrder);
        int taskReelCount = 0;
        StorageConstants.CHECKOUT_TYPE checkoutType = dataCache.getCheckOutType();
        //其他出库模式一次性全部生成任务
        for (LiteOrderItem orderItem : cacheOrder.getOrderItems()) {
            //剩余未出数量
            int remainNum = orderItem.getNeedNum() - orderItem.getOutNum();
            //此PN未完成
            if(remainNum > 0 ){
                if(outBom){
                    //套料出库,设置剩余数量为1,这样就只会出一盘
                    remainNum = 1;
                }
                int assignNum = 0;
                while (assignNum < remainNum){
                    Collection<String> excludePosIds = excludePosIds();
                    String partNumber = orderItem.getPn();
                    StoragePos pos = storagePosManager.findPartNumberPos(null, partNumber, excludePosIds, checkoutType);
                    if(pos == null){
                        log.error("未找到可以出库的物料["+partNumber+"]");
                        break;
                    }else{
                        assignNum = assignNum + pos.getBarcode().getAmount();
                        taskReelCount = taskReelCount + 1;
                        log.info("工单["+orderNo+"],任务数["+taskReelCount+"]出库位置仓位【"+pos.getPosName()+"】RI=["+pos.getBarcode().getBarcode()+"] PN=[" + partNumber + "] num:" + pos.getBarcode().getAmount());
                        DataLog task = newTask(pos);
                        task.setSourceId(cacheOrder.getId());
                        task.setSourceName(cacheOrder.getOrderNo());
                        task.setSubSourceId(orderItem.getId());
                        task.setSubSourceInfo(orderItem.getFeederInfo());
                        task.setAppendInfo(pos.getBarcode().getAppendInfo());
                        task.setType(StorageConstants.OP.CHECKOUT);
                        task.setStatus(StorageConstants.OP_STATUS.WAIT.name());
                        task = dataLogDao.save(task);
                        addTaskToExecute(task);
                    }
                }
            }
        }

        cacheOrder.setTaskReelCount(taskReelCount);
        log.info("工单["+orderNo+"]任务分配结束,任务数["+taskReelCount+"]");
        //有需要出库的
        if(taskReelCount <= 0){
            cacheOrder.finishedTasks();
        }
        liteOrderDao.save(cacheOrder);
        liteOrderMap.put(cacheOrder.getOrderNo(), cacheOrder);
        if(taskReelCount <= 0){
            return "工单无可执行的任务";
        }
        return "";
    }


    /**
     * 处理客户端发送上来的请求
     */
    @Override
    public StatusBean handleClientRequest(StatusBean statusBean,HttpServletRequest request) {
        try {
            String cid = statusBean.getCid();
            Storage storage = dataCache.getStorage(cid);
            if(storage == null){
                log.error("料仓cid: [" + cid + "]不存在");
                return null;
            }
            //处理客户端发上来的消息
            handleMsg(statusBean);

            synchronized (storage){
                //log.info("reqseq:"+statusBean.getSeq());
                StatusBean resultStatus = saveStatus(statusBean);

                //清空 msg 的内容,因为客户端会据此决定命令是否执行
                statusBean.setMsg("");

                //料柜
                if(storage.isCabinet() || storage.isShelf() || storage.isAccShelf()){
                    String cardResult = statusBean.getFromData("cardResult");
                    if(!Strings.isNullOrEmpty(cardResult)){
                        //写入卡片完成,后续再加密解密,暂就先使用用户名=授权码
                        try{
                            log.info("收到卡片写入结果【"+cardResult+"】");
                            String[] cardInfo = cardResult.split("=");
                            User user = userManager.getUser(cardInfo[0]);
                            if(user != null && Strings.isNullOrEmpty(user.getAuthCode())){
                                user.setAuthCode(cardInfo[1]);
                                userManager.save(user);
                                log.info("卡片信息【"+cardResult+"】写入成功");
                            }
                        }catch (Exception e){
                            log.error("卡片写入结果出错");
                        }
                    }
                    //出库任务开灯或者开门
                    Collection<DataLog> areaWaitTasks = taskMap.values();
                    for (DataLog task : areaWaitTasks) {
                        if(cid.equals(task.getCid()) && task.isCheckOutTask()){
                            //加入到正在执行的列表中
                            statusBean.addData("open", task.getPosName());

                            //从等待列表中删除,加入到执行列表中
                            task.setStatus(StorageConstants.OP_STATUS.EXECUTING.name());
                            taskMap.put(task.getId(), task);
                            dataLogDao.save(task);
                        }
                    }
                    return statusBean;

                }



                if(statusBean.getOp() == StorageConstants.OP.ALARM_DATA){
                    log.info("获取温湿度报警值");
                    statusBean.setTemperature(dataCache.getSettings().getMaxTemperature());
                    statusBean.setHumidity(dataCache.getSettings().getMaxHumidity());
                    resultStatus = statusBean;

                } else if(statusBean.getOp() == StorageConstants.OP.PUT_IN){
                    if(!dataCache.getSettings().isStopOut()){
                        log.debug("入库:"+mapper.writeValueAsString(statusBean));
                        resultStatus = putInLine(storage, statusBean);
                    }else {
                        resultStatus.setMsg("系统更新中,暂停出入库");
                        serverMsgs.put(cid,"系统更新中,暂停出入库");
                    }

                }else {
                    if(dataCache.needUpdateHumidiy(cid)){
                        log.info("发送温湿度报警值");
                        statusBean.setTemperature(dataCache.getSettings().getMaxTemperature());
                        statusBean.setHumidity(dataCache.getSettings().getMaxHumidity());
                        resultStatus = statusBean;
                    }else{
                        //查看是否有要出库的操作
                        resultStatus = checkOut(storage, resultStatus);
                    }
                }
                //log.info(mapper.writeValueAsString(resultStatus));
                return resultStatus;
            }
        } catch (Exception e) {
            log.error("", e);
        }
        return null;
    }

    /**
     * 处理客户端发送上来的消息（保存故障信息,并显示界面）
     * @param statusBean
     */
    private void handleMsg(StatusBean statusBean){
        try{
            //展示到界面
            String msg = statusBean.getMsg();
            updateClientMsg(statusBean.getCid(),msg);
        }catch (Exception e){
            log.error("客户端故障消息处理出错",e);
        }
    }


    /**
     * 出库完成 status为 OUT_FINISHED = 10 出仓位完成,设置posId
     * @param statusBeanToSave
     * @return
     */
    public StatusBean saveStatus(StatusBean statusBeanToSave) {
        String cid = statusBeanToSave.getCid();
        StatusBean statusBean = statusMap.get(cid);
        boolean needSaveToMongo = false;
        if (statusBean == null) {
            statusBean = statusBeanToSave;
            needSaveToMongo = true;
        } else {
            needSaveToMongo = statusBean.needSaveToMongo();
        }
        statusBean.setTime(System.currentTimeMillis());
        Map<Integer, BoxStatusBean> statusOfBoxes = statusBeanToSave.getBoxStatus();

        statusBean.setBoxStatus(statusOfBoxes);
        statusBean.setData(statusBeanToSave.getData());
        statusBean.setMsg(statusBeanToSave.getMsg());
        statusBean.setStatus(statusBeanToSave.getStatus());
        statusBean.setOp(statusBeanToSave.getOp());
        statusBean.setSeq(statusBeanToSave.getSeq());

        /**
         * 已解除的报警信息存到数据库中
         */
        Storage storage = dataCache.getStorage(cid);
        if(storage != null){
            List<AlarmInfo> endAlarmList = statusBean.getEndAlarmList(storage.getName(), statusBeanToSave.getAlarmList());
            alarmInfoDao.insertAll(endAlarmList);
        }

        if (statusOfBoxes != null) {
            for (BoxStatusBean boxStatus : statusOfBoxes.values()) {
                int boxId = boxStatus.getBoxId();
                //判断设备状态是否需要保存到数据库中
                dataCache.updateDeviceStatus(cid, boxId, boxStatus.getData());

                if (needSaveToMongo) {
                    //保存温湿度到数据库
                    Humiture humiture = new Humiture();
                    humiture.setCid(cid);
                    humiture.setBoxId(boxId);
                    String humidity = boxStatus.getHumidity();
                    String temperature = boxStatus.getTemperature();
                    if (!Strings.isNullOrEmpty(humidity) && !Strings.isNullOrEmpty(temperature)) {
                        humiture.setHumidity(humidity);
                        humiture.setTemperature(temperature);
                        try {
                            humitureManager.save(humiture);
                            statusBean.setLastSaveTime(System.currentTimeMillis());
                        } catch (ValidateException e) {
                        }
                    }
                }

                try {
                    //出库入库完成处理
                    int status = boxStatus.getStatus();
                    String posName = boxStatus.getPosId();
                    if(!Strings.isNullOrEmpty(posName)){//客户端发一次完成之后,会发空的 posName,不需要处理
                        if (StorageConstants.BOX_STATUS.IN_FINISHED == status) {//入仓完成
                            DataLog task = findExecutingTask(statusBeanToSave.getCid(), boxStatus.getPosId());
                            if (task != null && task.isPutInTask()) {
                                log.info(task.getBarcode() + "入仓位[" + task.getPosName() + "]完成");
                                DataLog cancelTask = findFinishedTask(statusBeanToSave.getCid(), boxStatus.getPosId());
                                if(cancelTask != null && cancelTask.isCancel()){
                                    //将相同库位已经取消的任务从完成队列里删除
                                    finishedTaskMap.remove(cancelTask.getBarcode());
                                    log.info("从已完成的任务列表中删除之前取消的任务:"+cancelTask.getPosName() + " ReelId:" + cancelTask.getBarcode());
                                }
                                putInFinished(task);
                            } else {
                                //从已完成列表中找,如果还找不到就忽略
                                task = findFinishedTask(statusBeanToSave.getCid(), boxStatus.getPosId());
                                if (task != null) {
                                    if(task.isCancel()){//被取消的任务,客户端发完成信号过来,修改取消状态为已完成
                                        log.info(task.getBarcode() + "入仓位[" + task.getPosName() + "]完成,但任务已被取消,修改为完成");
                                        putInFinished(task);
                                    }
                                }else {
                                    log.error(statusBeanToSave.getCid() + "入仓位[" + boxStatus.getPosId() + "]完成时任务不存在");
                                }
                            }
                        } else if (StorageConstants.BOX_STATUS.IN_FAILED == status) {//入库失败

                            //暂不处理
                        } else if (StorageConstants.BOX_STATUS.OUT_FINISHED == status) {//出仓完成
                            DataLog task = findExecutingTask(statusBeanToSave.getCid(), boxStatus.getPosId());
                            if (task != null) {
                                log.info(task.getBarcode() + "出仓位[" + task.getPosName() + "]完成");
                                DataLog cancelTask = findFinishedTask(statusBeanToSave.getCid(), boxStatus.getPosId());
                                if(cancelTask != null && cancelTask.isCancel()){
                                    //将相同库位已经取消的任务从完成队列里删除
                                    finishedTaskMap.remove(cancelTask.getBarcode());
                                    log.info("从已完成的任务列表中删除之前取消的任务:"+cancelTask.getPosName() + " ReelId:" + cancelTask.getBarcode());
                                }
                                //dataCache.unLockOneReel(task.getCid(),task.getPartNumber());
                                checkoutFinished(task);
                            }else{
                                //log.error(operationKey + "触发仓位完成时,操作队列中不存在");
                                //从已完成列表中找,如果还找不到就忽略
                                task = findFinishedTask(statusBeanToSave.getCid(), boxStatus.getPosId());
                                if (task != null) {
                                    if(task.isCancel()){//被取消的任务,客户端发完成信号过来,修改取消状态为已完成
                                        log.info(task.getBarcode() + "出仓位[" + task.getPosName() + "]完成,但任务已被取消,修改为完成");
                                        checkoutFinished(task);
                                    }
                                }else {
                                    log.warn(statusBeanToSave.getCid() + "出仓位[" + boxStatus.getPosId() + "]完成时任务不存在");
                                }
                            }
                        } else if (StorageConstants.BOX_STATUS.OUT_FAILED == status) {//出库失败
                            //暂不处理
                        }
                    }
                } catch (ValidateException e) {
                    log.error("更新状态时出错" + e.getMessage());
                }

            }

        }

        statusMap.put(cid, statusBean);
        return statusBean;
    }

    private DataLog findFinishedTask(String cid, String posName){
        Collection<DataLog> areaFinishedTasks = getFinishedTasks();
        for (DataLog task : areaFinishedTasks) {
            if (task.getPosName().equals(posName) && task.getCid().equals(cid)) {
                return task;
            }
        }
        return null;
    }

    /**
     * 根据cid 和 posName 查找正在执行的任务,不存在时返回 null
     */
    private DataLog findExecutingTask(String cid, String posName) {
        for (DataLog task : taskMap.values()) {
            if (task.getCid().equals(cid) && task.getPosName().equals(posName)) {
                return task;
            }
        }
        return null;
    }

    @Override
    public StatusBean getStatus(String cid) {
        StatusBean statusBean = statusMap.get(cid);
        if (statusBean == null || statusBean.timeOut()) {
            statusBean = new StatusBean();
            statusBean.setCid(cid);
            statusBean.setStatus(StorageConstants.STATUS.OFFLINE);
        }
        Storage storage = dataCache.getStorage(cid);
        if(storage != null && storage.isVirtual()){
            statusBean.setStatus(StorageConstants.STATUS.READY);
            statusBean.setTime(System.currentTimeMillis());

        }
        String serverMsg = serverMsgs.get(cid);
        if(!Strings.isNullOrEmpty(serverMsg)){
            statusBean.setMsg(serverMsg);
        }
        return statusBean;
    }

    @Override
    public Collection<StatusBean> allStatus(){
        return statusMap.values();
    }

    @Override
    public synchronized String checkout(StoragePos pos, String subSourceId, boolean isSingleOut){

        Collection<DataLog> allTasks = taskMap.values();
        for(DataLog taskInList : allTasks){
            if(taskInList.getPosId() == null) continue;
            if(taskInList.getPosId().equals(pos.getId())){
                log.info("库位【"+pos.getPosName()+"已在任务列表中,忽略】");
                return "库位【"+pos.getPosName()+"已在任务列表中,忽略】";
            }
        }

        DataLog task = newTask(pos);
        //手动出库的当做是紧急料
        task.setUrgentReel(true);
        task.setType(StorageConstants.OP.CHECKOUT);
        task.setStatus(StorageConstants.OP_STATUS.WAIT.name());
        task.setSingleOut(isSingleOut);
        //task.setAppendInfo(pos.getBarcode().getAppendInfo());
        //工单出库任务
        if(!Strings.isNullOrEmpty(subSourceId)){
            LiteOrderItem liteOrderItem = liteOrderItemDao.findOneById(subSourceId);
            if(liteOrderItem != null){
                String orderNo = liteOrderItem.getOrderNo();
                LiteOrder cacheOrder = liteOrderMap.get(orderNo);
                if(cacheOrder == null || cacheOrder.isOutOne() || cacheOrder.isTaskFinished() || cacheOrder.isNew()){
                    if(cacheOrder == null){
                        //缓存中没有,加入到缓存中
                        cacheOrder = liteOrderDao.findWithItemsByOrderNo(orderNo);
                        cacheOrder.setTaskReelCount(1);
                        cacheOrder.setFinishedReelCount(0);
                    }else if(cacheOrder.isOutOne() || cacheOrder.isOutOneFinished()){
                        //数量+上去
                        cacheOrder.setTaskReelCount(cacheOrder.getTaskReelCount() + 1);
                    }else{
                        cacheOrder.setTaskReelCount(1);
                        cacheOrder.setFinishedReelCount(0);
                    }

                    cacheOrder.setTaskFinishedTime(-1);
                    log.info("订单["+orderNo+"]补料任务" + task.getBarcode() + " 任务数:" +cacheOrder.getFinishedReelCount() + "/"+ cacheOrder.getTaskReelCount());
                    task.setSourceId(cacheOrder.getId());
                    task.setSourceName(orderNo);
                    task.setSubSourceId(liteOrderItem.getId());
                    task.setSubSourceInfo(liteOrderItem.getFeederInfo());
                    cacheOrder.setStatus(StorageConstants.LITEORDER_STATUS.ONE);
                    liteOrderDao.save(cacheOrder);
                    liteOrderMap.put(orderNo,cacheOrder);

                }else{
                    return "无法执行工单补料任务";
                }
            }else{
                return "未找到工单信息";
            }
        }

        task = dataLogDao.save(task);

       // Barcode barcode = pos.getBarcode();
//        if(barcode != null){
//            if(barcode.needToQisda()){
//                log.info("非测试物料["+barcode.getBarcode()+"]出库" + barcode.getAppendInfo());
//            }else{
//                log.info("测试物料["+barcode.getBarcode()+"]出库");
//                if(this.getQueueTasks().isEmpty() && this.getFinishedTasks().isEmpty()){
//                    //没有任务了,清空料架缓存
//                    InquiryShelfBean.hSerialShelfMap.clear();
//                }
//                //测试用的料盘,分配架位
//                OutItem outItem = new OutItem();
//                outItem.sethSerial("Test");
//                task.setSourceName("Test_AAA");
//
//                task = InquiryShelfBean.addUnlimitLoc(task, outItem);
//            }
//        }


        addTaskToExecute(task);
        return "";
    }


    @Override
    public void addTaskToFinished(StoragePos pos, Barcode barcode, String opUser){
        try{
            //当前库位或barcode有正在执行的任务,完成掉
            //Storage storage = dataCache.getStorageById(pos.getStorageId());
            if(Strings.isNullOrEmpty(opUser)){
                opUser = StorageDataController.getLoginUsername();
            }
            Collection<DataLog> allTasks = taskMap.values();
            if(pos.getBarcode() != null){
                barcode = pos.getBarcode();
                for(DataLog task : allTasks){
                    if(task.isCheckOutTask()){
                        String executeBarcode = task.getBarcode();
                        String executePosId = task.getPosId();
                        boolean isSameTask = false;
                        if(executeBarcode != null && barcode.getBarcode().equals(executeBarcode)){
                            isSameTask = true;
                        }

                        if(executePosId != null && pos.getId().equals(executePosId)){
                            isSameTask = true;
                        }
                        if(isSameTask){
                            log.info(executeBarcode + "找到正在执行的出库任务["+pos.getPosName()+"],直接完成");
                            if(task.isWait()){
                                taskMap.put(task.getId(),task);
                            }
                            task.setOperator(opUser);
                            checkoutFinished(task);
                            return;
                        }
                    }
                }
            }




            //没有正在执行的任务,直接添加一条已完成的任务
            DataLog task = newTask(pos);
            if(pos.getBarcode() == null){
                log.info(opUser + "入库【"+barcode.getBarcode()+"】到【"+pos.getPosName()+"】");
                task.setType(StorageConstants.OP.PUT_IN);
                barcode.setUsedCount(barcode.getUsedCount() + 1);
                barcode.setUsedDate(new Date());
                barcode.setPutInTime(System.currentTimeMillis());
                barcode.setInOpor(opUser);
                barcode.setCheckOutDate(null,"");
                barcode.setPosName(task.getPosName());

                barcodeManager.save(barcode);

                pos.setBarcode(barcode);
                pos.setUsed(true);
                pos.setCanCheckOutTime(System.currentTimeMillis());
                storagePosManager.save(pos);


                task.setPartNumber(barcode.getPartNumber());
                task.setBarcode(barcode.getBarcode());
                task.setAppendInfo(barcode.getAppendInfo());
                task.setNum(barcode.getAmount());

                dataCache.updateInventory(pos,barcode);
                //dataCache.updateStorage(task.getCid());

            }else{
                barcode = pos.getBarcode();
                log.info(opUser + "将【"+barcode.getBarcode()+"】从【"+pos.getPosName()+"】出库");
                task.setType(StorageConstants.OP.CHECKOUT);
                barcode.setUsed(true);
                barcode.setUsedDate(new Date());
                //仓位状态
                barcode.setCheckOutDate(new Date(),task.getOperator());
                barcode.setPosName("");
                barcodeManager.save(barcode);

                pos.setBarcode(null);
                pos.setUsed(false);
                storagePosManager.save(pos);


                dataCache.updateInventory(pos, barcode);
                //dataCache.updateStorage(task.getCid());

            }

            task.setOperator(opUser);

            task.setAppendInfo(barcode.getAppendInfo());
            task.setStatus(StorageConstants.OP_STATUS.FINISHED.name());
            task = dataLogDao.save(task);

            finishedTaskMap.put(task.getBarcode(),task);
        }catch (Exception e){

        }
    }

    @Override
    public void addTaskToExecute(DataLog task) {
        if(Strings.isNullOrEmpty(task.getOperator())){
            String loginUser = StorageDataController.getLoginUsername();
            task.setOperator(loginUser);
        }
        task = dataLogDao.save(task);
        taskMap.put(task.getId(),task);
    }

    /**
     * 加入要执行的任务
     */
    @Override
    public synchronized DataLog addPutInTaskToExecute(Storage storage, Barcode barcode, StoragePos storagePos) throws ValidateException {

        Collection<DataLog> tasks = taskMap.values();
        for (DataLog task : tasks) {
            //检查 barcode
            if (task.getBarcode().equals(barcode.getBarcode())) {
                String msg = "二维码:[" + barcode.getBarcode() + "]已在操作队列中,操作失败";
                log.info(msg);
                throw new ValidateException(msg);
            } else if (task.getPosId().equals(storagePos.getId())) {
                String msg = "位置:[" + storagePos.getPosName() + "]已在操作队列中,操作失败";
                log.info(msg);
                throw new ValidateException(msg);
            }
        }

        DataLog dataLog = new DataLog();
        dataLog.setStorageId(storage.getId());
        dataLog.setStorageName(storage.getName());
        dataLog.setBarcode(barcode.getBarcode());
        dataLog.setAppendInfo(barcode.getAppendInfo());
        dataLog.setRelationCodes(barcode.getRelationCodes());
        dataLog.setType(StorageConstants.OP.PUT_IN);
        dataLog.setNum(barcode.getAmount());

        dataLog.setCid(storage.getCid());

        String loginUser = StorageDataController.getLoginUsername();
        dataLog.setOperator(loginUser);
        dataLog.setPartNumber(barcode.getPartNumber());
        dataLog.setPosId(storagePos.getId());
        dataLog.setPosName(storagePos.getPosName());
        dataLog.setStatus(StorageConstants.OP_STATUS.EXECUTING.name());



        dataLog.setSourceName(barcode.getAppendInfo().getDnNo());

        dataLogDao.save(dataLog);
        taskMap.put(dataLog.getId(), dataLog);
        log.info("cid:[" + storage.getCid() + "] barcode:[" + barcode.getBarcode() + "] partNumber:[" + dataLog.getPartNumber() + "]位置[" + storagePos.getPosName() + "]的入库操作成功加入队列");
        return dataLog;
    }


    //入仓位完成
    public void putInFinished(DataLog task) throws ValidateException {

        StoragePos storagePos = storagePosManager.get(task.getPosId());
        //二维码状态
        Barcode barcode = barcodeManager.findByBarcode(task.getBarcode());
        if(StorageConstants.COMPONENT_TYPE.FIXTURE == barcode.getType()){//条码是夹具
            //夹具编码,需要将相应的位置全部填上
            String posLabel = storagePos.getLabelStr();
            List<StoragePos> allPos = storagePosManager.findByLabel(storagePos.getStorageId(), posLabel);
            List<String> relationCodeStrs = task.getRelationCodes();

            log.info("夹具【"+task.getBarcode()+"】入库到["+posLabel+"]完成,夹具上物料条码:"+StringUtils.join(relationCodeStrs," , "));

            //此夹具的可出库时间
            long canCheckOutTime = 0;
            List<Barcode> relationBarcodes = Lists.newArrayList();
            long now = System.currentTimeMillis();
            for (String relationCodeStr : relationCodeStrs) {
                Barcode relationBarcode = barcodeManager.findByBarcode(relationCodeStr);
                //入库时间,如果之前已入过库是不会更改的
                relationBarcode.setPutInTime(now);
                relationBarcode.setInOpor(task.getOperator());
                long reachWarmTime = relationBarcode.getReachWarmTime();
                if(reachWarmTime > canCheckOutTime){
                    canCheckOutTime = reachWarmTime;
                }
                relationBarcodes.add(relationBarcode);
            }

            int relationCount = relationBarcodes.size();
            for (int i = 0; i < allPos.size(); i++) {
                StoragePos componentPos = allPos.get(i);
                Barcode componentBarcode = new Barcode();
                if(i < relationCount){//夹具上有料
                    componentBarcode = relationBarcodes.get(i);
                    componentBarcode.setInFixture(barcode.getBarcode());
                    componentBarcode.setUsedCount(barcode.getUsedCount() + 1);
                    componentBarcode.setPutInTime(now);
                    componentBarcode.setInOpor(task.getOperator());
                    componentBarcode.setPosName(task.getPosName());
                    //入库后设置出库时间为-1
                    componentBarcode.setCheckOutDate(null,"");
                    barcodeManager.save(componentBarcode);


                }else{
                    componentBarcode.setFixtureNumber(barcode.getPartNumber());
                    componentBarcode.setInFixture(barcode.getBarcode());
                    componentBarcode.setType(barcode.getType());
                    componentBarcode.setBarcode(barcode.getBarcode());
                    componentBarcode.setPutInTime(now);
                    componentBarcode.setInOpor(task.getOperator());
                    componentBarcode.setPartNumber(barcode.getPartNumber());
                    componentBarcode.setInitialAmount(1);
                    componentBarcode.setAmount(1);
                }
                /**
                 * 仓位状态
                 */
                componentPos.setBarcode(componentBarcode);
                componentPos.setUsed(true);
                componentPos.setCanCheckOutTime(canCheckOutTime);
                storagePosManager.save(componentPos);

                //更新缓存中的库存信息
                int stockReel = dataCache.updateInventory(storagePos,componentBarcode);

                //dataCache.updateStorage(task.getCid());

                log.info("入库"+componentBarcode.getPartNumber()+"["+componentBarcode.getBarcode()+"]当前库存:"+stockReel+"到"+componentPos.getPosName()+"可出库时间:"+new Date(canCheckOutTime));
            }

        }else{//条码不是夹具

            barcode.setUsedCount(barcode.getUsedCount() + 1);
            barcode.setUsedDate(new Date());
            barcode.setPutInTime(System.currentTimeMillis());
            barcode.setInOpor(task.getOperator());
            barcode.setCheckOutDate(null,"");
            barcode.setPosName(task.getPosName());
            barcode.setInitialAmount(barcode.getAmount());
            if(Strings.isNullOrEmpty(barcode.getProviderNumber())){//补上供应商编号
                Component component = componentManager.findByPartNumber(barcode.getPartNumber());
                barcode.setProviderNumber(component.getProviderNumber());
            }

//            AppendInfo appendInfo = barcode.getAppendInfo();
//            appendInfo.setDnNo(task.getSourceName());
//            appendInfo.setFacility(task.getSubSourceInfo());
//            appendInfo.setCompany(task.getSubSourceInfo());
//            barcode.setAppendInfo(appendInfo);

            barcodeManager.save(barcode);


            /**
             * 仓位状态
             */
            storagePos.setBarcode(barcode);
            storagePos.setUsed(true);
            storagePos.setCanCheckOutTime(System.currentTimeMillis());
            storagePosManager.save(storagePos);

            //更新缓存中的库存信息
            dataCache.updateInventory(storagePos,barcode);

            //dataCache.updateStorage(task.getCid());
//
//            Storage storage = dataCache.getStorage(task.getCid());
//            if(storage != null){
//                postInNotification(dataCache.getSettings().getInNotifyApi(), task.getBarcode(), task.getStorageId());
//            }
        }


        //记录日志,完成 task
        task.setNum(barcode.getAmount());
        task.setStatus(StorageConstants.OP_STATUS.FINISHED.name());
        dataLogDao.save(task);

        finishedTaskMap.put(task.getBarcode(),task);
        //从队列里面移除操作
        taskMap.remove(task.getId());

        updateInQisdaData(barcode, task);


    }

    private synchronized void updateInQisdaData(Barcode barcode, DataLog task){
        if(task.isPutInTask() && !task.isCancel()){
            //更新DN单收料数量
                AppendInfo appendInfo = barcode.getAppendInfo();
                if(!appendInfo.isCISIn()){
                    DNItem dnItem = dNItemDao.findDnItem(appendInfo.getDnNo(), barcode.getPartNumber(), appendInfo.getFacility(), appendInfo.getCompany());
                    //Facility入库
                    if(appendInfo.isFacilityIn()){
                        if(dnItem == null){
                            dnItem = new DNItem();
                            dnItem.setDnNo(appendInfo.getDnNo());
                            dnItem.setPn(barcode.getPartNumber());
                            dnItem.setFacility(appendInfo.getFacility());
                            dnItem.setCompany(appendInfo.getCompany());
                            log.info("新增Facility ["+ appendInfo.getDnNo()+"]详情[" + barcode.getPartNumber() + "]");
                        }

                    }else{
                        //DN单入库
                        if(dnItem == null){
                            log.error("["+barcode.getBarcode()+"]入库时DN单对应详情不存在");
                            return;
                        }else{

                        }
                    }

                    int inQty = dnItem.getInQty();
                    log.info("["+barcode.getBarcode()+"]入库完成,DN单["+dnItem.getDnNo()+"]中" + dnItem.getFacility() + "数量"+inQty+"增加:" + task.getNum() +" 盘数["+dnItem.getInNum()+"]+1");
                    dnItem.setInQty(inQty + task.getNum());
                    dnItem.setInNum(dnItem.getInNum() + 1);
                    dnItem.setFirstReelDate(new Date());
                    dnItem = dNItemDao.save(dnItem);
                }else{
                    //纯入库,更新绑定数量
                    String soseq = appendInfo.getSoseq();
                    if(soseq != null && !soseq.isEmpty()){
                        int slotIndex = appendInfo.getSlotIndex();
                        OutItem cutItem = outItemDao.findCutItem(soseq, slotIndex);
                        if(cutItem != null){
                            int realBindQty = cutItem.getRealLockQty() + barcode.getAmount();
                            log.info(barcode.getBarcode() + "纯入库完成,分盘需求单soseq=["+soseq+"]slotSeq=["+slotIndex+"]绑定数量增加"+barcode.getAmount()+"="+ realBindQty);
                            cutItem.setRealLockQty(realBindQty);
                            outItemDao.save(cutItem);
                            outInfoCache.updateOutItem(cutItem.getId());
                        }
                    }

                }
            if(DataCache.isProductionFor(DataCache.CUSTOMER.QISDA)){
                //通知VMI入库完成
                if(barcode.needToQisda()){
                    QisdaApiController.PutInFinished(barcode, task);
                }else{
                    log.info("入库完成,条码["+barcode.getBarcode()+"]不需要通知Qisda");
                }

            }else{
                log.info("入库完成通知Qisda接口关闭");
            }
        }
    }


    /**
     * 出库完成
     */
    @Override
    public void checkoutFinished(DataLog task) throws ValidateException {

        StoragePos storagePos = storagePosManager.get(task.getPosId());

        Barcode barcode = storagePos.getBarcode();
        if(barcode == null){
            log.warn("任务:"+task.getId() +" 仓位:"+task.getPosId()+" 的 Barcode 为null, 之前可能处理过直接返回");
            return;
        }

        barcode = barcodeManager.get(barcode.getId());
        if(barcode != null){
            //二维码状态
            barcode.setUsed(true);

            barcode.setUsedDate(new Date());
            //仓位状态
            barcode.setCheckOutDate(new Date(),task.getOperator());
            barcode.setPosName("");
            barcodeManager.save(barcode);

            String specifiedBatchId = barcode.getLockId();
            if(!Strings.isNullOrEmpty(specifiedBatchId)){
                task.setBatchId(specifiedBatchId);
                task.setBatchInfo(barcode.getLockName());
            }
        }

        storagePos.setBarcode(null);
        storagePos.setUsed(false);
        storagePosManager.save(storagePos);

        AppendInfo appendInfo = task.getAppendInfo();
        String outItemId = appendInfo.getOutItemId();

        log.info("出库完成,清空仓位: " + storagePos.getId() + "[" + storagePos.getPosName() + "]outItemId"+ outItemId);
        //更新缓存中的库存信息
        dataCache.updateInventory(storagePos,barcode);

        //记录日志
        task.setStatus(StorageConstants.OP_STATUS.OUTBOX.name());
        dataLogDao.save(task);

        //从队列里面移除操作
        taskMap.remove(task.getId());
        finishedTaskMap.put(task.getBarcode(),task);

        //dataCache.updateStorage(task.getCid());

        //finishedOrderTask(task);
        //checkTaskSetFinished(task);
        updateOutInfo(outItemId, task, barcode);


    }

    private synchronized void updateOutInfo(String outItemId, DataLog task, Barcode barcode){
        //更新出库数量
        OutInfo outInfo;
        if(!Strings.isNullOrEmpty(outItemId)){
            OutItem outItem = outItemDao.findOneById(outItemId);
            if(outItem != null){

                if(barcode.hasCutInfo()){
                    //分盘料,需要更新对应的需求单出库数量
                    final List<Map<String, Object>> cutItems = barcode.getCutItems();
                    for (Map<String, Object> cutItem : cutItems) {
                        String soseqStr = cutItem.get("soseq").toString();
                        String slotlocation = cutItem.get("slotlocation").toString();
                        String qty = cutItem.get("qty").toString();
                        OutItem cutInfoItem = outItemDao.findCutItem(soseqStr, Integer.valueOf(slotlocation));
                        if(cutInfoItem == null){
                            log.error("未找到soseq=["+soseqStr+"]slotseq=["+slotlocation+"]的需求信息");
                            continue;
                        }
                        int outQty = outItem.getOutQty() + Integer.valueOf(qty);
                        log.info("分盘需求单["+cutInfoItem.gethSerial()+"]["+slotlocation+"]的出库数量增加"+qty+"="+outQty);
                        outItem.setOutQty(outQty);
                        outItem = outItemDao.save(outItem);
                        outInfoCache.updateOutItem(outItem.getId());
                    }
                }else{
                    int outQty = outItem.getOutQty() + task.getNum();
                    outItem.setOutQty(outQty);

                    if(outItem.isUrgentAction()){
                        log.info("紧急料设置发料数量与出库数量一致");
                        //紧急料发料数量与出库数量一致
                        outItem.setSendQty(outQty);
                    }
                    outItem = outItemDao.save(outItem);
                    outInfoCache.updateOutItem(outItem.getId());
                }

                outInfo = outInfoDao.findByHSerial(outItem.gethSerial());
                int outReelNum = outInfo.getOutReelNum();
                outInfo.setOutReelNum(outReelNum + 1);
                if(outItem.isUrgentAction() || outItem.isReelCutAction()){
                    outInfo.setTaskFinishNum(outInfo.getTaskFinishNum() + 1);
                }
                outInfo = outInfoDao.save(outInfo);
                String latest = outInfo.getOutLatest();

                QisdaApiController.OutFinished(task, barcode, latest);

                if (latest.equals("L")) {
                    log.info("工单[" + outItem.getSo() + "]需求单["+outItem.gethSerial()+"]的最后一盘出库完成,发送缺料通知");
                    List<OutItem> outItemList = outItemDao.findByHSerial(outItem.gethSerial());
                    boolean lessBind = false;
                    QisdaApi.VMILocationOutFeedback(outItemList, lessBind);
                }

            }
        }
    }

    /**
     * 更新工单状态信息
     */
    private synchronized void finishedOrderTask(DataLog task){
//        if(StorageConstants.OP.CHECKOUT == task.getType()){
//            //更新工单状态
//            String orderNo = task.getSourceName();
//            if(!Strings.isNullOrEmpty(orderNo)){
//                LiteOrder order = liteOrderMap.get(orderNo);
//                if(order == null){
//                    log.info("缓存中未找到["+orderNo+"],从数据库中重新加载");
//                    order = liteOrderDao.findWithItemsByOrderNo(orderNo);
//                }
//                if(order != null){
//                    //任务是取消的,需要将总待出库数量-1
//                    if(task.isCancel()){
//                        order.setTaskReelCount(order.getTaskReelCount() -1);
//                        log.info("工单["+orderNo+"]的任务"+task.getPartNumber()+"["+task.getBarcode()+"]已取消,任务数-1="+order.getFinishedReelCount() + "/" + order.getTaskReelCount());
//                    }else if(task.isFinished()){
//                        order.setFinishedReelCount(order.getFinishedReelCount() + 1);
//                        String orderItemId = task.getSubSourceId();
//                        List<LiteOrderItem> items = new ArrayList<>();
//                        for (LiteOrderItem liteOrderItem : order.getOrderItems()) {
//                            if(liteOrderItem.getId().equals(orderItemId)){
//                                log.info("工单["+orderNo+"]的任务"+task.getPartNumber()+"["+task.getBarcode()+"]出库完成,已完成数量+1="+order.getFinishedReelCount()+"/" + order.getTaskReelCount());
//                                //更新对应条目的已出库数量和出库盘数
//                                liteOrderItem.setOutNum(liteOrderItem.getOutNum() + task.getNum());
//                                liteOrderItem.setOutReelCount(liteOrderItem.getOutReelCount() + 1);
//                                liteOrderItem = liteOrderItemDao.save(liteOrderItem);
//                            }
//                            items.add(liteOrderItem);
//                        }
//                    }else{
//                        log.error("工单["+orderNo+"]的任务["+task.getBarcode()+"]完成时,状态为:"+ task.getStatus());
//                    }
//                    if(order.getFinishedReelCount() >= order.getTaskReelCount()){
//                        log.info("工单["+orderNo+"]的出库任务已完成,共出库:"+ order.getFinishedReelCount() +" 盘");
//                        order.finishedTasks();
//                    }
//                    liteOrderDao.save(order);
//                    liteOrderMap.put(orderNo, order);
//                } else{
//                    log.error("完成任务时,未找到工单["+orderNo+"]信息");
//                }
//            }
//        }
    }

}