package com.myproject.webapp.controller.webService;

import com.myproject.bean.qisda.InquiryShelfBean;
import com.myproject.bean.qisda.QisdaApiRequest;
import com.myproject.bean.qisda.ReelLockPosInfo;
import com.myproject.bean.qisda.ShelfInfo;
import com.myproject.bean.update.qisda.CacheInfo;
import com.myproject.bean.update.qisda.DNInfo;
import com.myproject.bean.update.qisda.DNItem;
import com.myproject.dao.mongo.qisda.ICacheInfoDao;
import com.myproject.dao.mongo.qisda.IDNItemDao;
import com.myproject.exception.ApiException;
import com.myproject.util.HttpHelper;
import com.myproject.util.XmlUtil;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.util.Strings;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 缓存
 * Created by sunke on 17/3/17.
 */
@Repository
public class QisdaCache {

    protected static final transient Logger log = LogManager.getLogger(QisdaCache.class);

    private static ICacheInfoDao cacheInfoDao;

    private static IDNItemDao dNItemDao;

    private static String CURRENT_ORDER_HSERIAL_KEY = "currentOrderHSerial";

    /**
     * RFID绑定的DN单信息Key
     */
    private static String RFID_DN_MAP_KEY = "rfidDnMap";

    /**
     * 料架信息缓存key
     */
    private static String HSERIAL_SHELF_MAP_KEY = "hSerialShelfMap";

    /**
     * 重发消息key
     */
    private static String FAILED_REQUEST_MAP_KEY = "failedRequestMap";
    /**
     * 料盘锁定库位信息,用于包装料分配到其他料仓
     */
    private static String REEL_LOCK_POS_MAP_KEY = "reelLocKPosMap";

    /**
     * 料串/料架目的地Map
     */
    private static String SHELF_HSERIAL_MAP = "shelfHSerialMap";

    /**
     * 当前正在执行的工单需求单(首盘,补料),未完成时,其他工单需求单不可执行
     */
    private static String currentOrderHSerial;

    /**
     * 上个需求单使用的料架信息
     */
    private static List<String> lastHSerialUsedRfidList;

    /**
     * RFID绑定DN单和Facility, Key为RFID, Value为DN单信息
     */
    private static Map<String, DNInfo> rfidDnMap;

    /**
     * 需要重新向佳世达发送的指令列表
     */
    private static Map<String, QisdaApiRequest> failedRequestMap;

    /**
     * 料盘锁定库位信息,用于包装料分配到其他料仓
     */
    private static Map<String, ReelLockPosInfo>  reelLocKPosMap;


    /**
     * 料串/料架目的地Map
     */
    private static Map<String,String> shelfHSerialMap;

    private static boolean isProcessTimer = false;
    /**
     * 定时器,每10秒执行一次
     */
    public static void runTimer(){
        if(!isProcessTimer){
            isProcessTimer = true;
            try {
                sendFailedRequest();
            }catch (Exception e){
                log.error("发送失败请求定时器执行出错:"+e.getMessage());
            }finally {
                isProcessTimer = false;
            }
        }
    }

    /**
     * 从数据库中加载缓存信息
     */
    public static void initFromDb(){
        initApiRequestMap();
        initReelLockPosMap();
        initShelfDestinationMap();
    }

    private static void initShelfDestinationMap(){
        if(shelfHSerialMap == null){
            shelfHSerialMap = new ConcurrentHashMap<>();
            CacheInfo cacheInfo = cacheInfoDao.getCacheInfo(SHELF_HSERIAL_MAP);
            if(cacheInfo != null){
                Map<String, String> shelfMap = (Map<String, String>) cacheInfo.getCacheValue();
                shelfHSerialMap.putAll(shelfMap);
                log.info("当前料架目的地信息:" + shelfMap);
            }
        }
    }

    /**
     * 添加料架对应的需求单号
     */
    public static void addShelfHSerial(String rfid, String hSerial){
        String oldHSerial = shelfHSerialMap.get(rfid);
        log.info("添加料架["+rfid+"]的需求单号:" + hSerial);
        shelfHSerialMap.put(rfid, hSerial);
        cacheInfoDao.updateCacheItem(SHELF_HSERIAL_MAP, shelfHSerialMap);
        if(oldHSerial != null){
            if(!oldHSerial.equals(hSerial)){
                log.error("添加料架["+rfid+"]需求单号["+hSerial+"]失败,料架已有需求单号:" + oldHSerial);
            }
        }
    }

    /**
     * 清除料架的目的地信息
     */
    public static void removeShelfHSerial(String rfid){
        String oldHSerial = shelfHSerialMap.get(rfid);
        log.info("清除料架["+rfid+"]的需求单号["+oldHSerial+"]信息");
        shelfHSerialMap.remove(rfid);
        cacheInfoDao.updateCacheItem(SHELF_HSERIAL_MAP, shelfHSerialMap);
    }

    /**
     * 获取料架的目的地
     */
    public static String getShelfHSerial(String rfid){
        String hSerial = shelfHSerialMap.get(rfid);
        return hSerial;
    }


    /**
     * 添加条码锁定库位信息
     * @param reelLockPosInfo
     */
    public static synchronized ReelLockPosInfo addReelLockPosInfo(ReelLockPosInfo reelLockPosInfo){
        log.info("为["+reelLockPosInfo.getBarcode()+"]锁定库位["+reelLockPosInfo.getLockPosName()+"]");
        ReelLockPosInfo oldLocInfo = reelLocKPosMap.get(reelLockPosInfo.getBarcode());
        if(oldLocInfo != null && oldLocInfo.getLockPosName() != null){
            log.info("["+oldLocInfo.getBarcode()+"]已有锁定库位["+oldLocInfo.getLockPosName()+"],返回之前锁定的库位");
            return oldLocInfo;
        }
        for (ReelLockPosInfo locInfo : reelLocKPosMap.values()) {
            if(locInfo.getLockPosId().equals(reelLockPosInfo.getLockPosId()) && !locInfo.getBarcode().equals(reelLockPosInfo.getBarcode())){
                log.info("为["+reelLockPosInfo.getBarcode()+"]锁定库位["+reelLockPosInfo.getLockPosName()+"]时,库位已被["+locInfo.getBarcode()+"]锁定");
                return null;
            }
        }
        reelLocKPosMap.put(reelLockPosInfo.getBarcode(), reelLockPosInfo);
        cacheInfoDao.updateCacheItem(REEL_LOCK_POS_MAP_KEY, reelLocKPosMap);
        return reelLockPosInfo;
    }

    /**
     * 根据料架和料架位置获取锁定的库位信息,如果不存在,返回null
     * @param rfid
     * @param rfidLoc
     * @return
     */
    public static ReelLockPosInfo getLockPosInfoByRfidLoc(String rfid, String rfidLoc){
        if(Strings.isNotBlank(rfid) && Strings.isNotBlank(rfidLoc)){
            for (ReelLockPosInfo reelLockPosInfo : reelLocKPosMap.values()) {
                String lockRfid = reelLockPosInfo.getRfid();
                String lockRfidLoc = reelLockPosInfo.getRfidLoc();
                if(Strings.isNotBlank(lockRfid) && Strings.isNotBlank(lockRfidLoc)){
                    if(rfid.equals(lockRfid) && rfidLoc.equals(lockRfidLoc)){
                        return reelLockPosInfo;
                    }
                }
            }
        }

        return null;
    }



    /**
     * 获取料架上料盘锁定的库位信息
     * @param rfid
     * @return
     */
    public static List<ReelLockPosInfo> getShelfLockPosInfo(String rfid){
        List<ReelLockPosInfo> shelfLocPosInfoList = new ArrayList<>();
        if(Strings.isNotBlank(rfid)){
            for (ReelLockPosInfo reelLockPosInfo : reelLocKPosMap.values()) {
                if(rfid.equals(reelLockPosInfo.getRfid())){
                    shelfLocPosInfoList.add(reelLockPosInfo);
                }
            }
        }
        return shelfLocPosInfoList;
    }

    /**
     * 清理条码锁定库位信息
     */
    public static void removeReelLockPosInfo(String barcode){
        reelLocKPosMap.remove(barcode);
        cacheInfoDao.updateCacheItem(REEL_LOCK_POS_MAP_KEY, reelLocKPosMap);
    }

    /**
     * 获取条码锁定的库位Id
     * @param barcode 条码信息
     * @return
     */
    public static String getReelLockPosId(String barcode){
        ReelLockPosInfo lockPosInfo = reelLocKPosMap.get(barcode);
        if(lockPosInfo != null){
            return lockPosInfo.getLockPosId();
        }
        return "";
    }

    /**
     * 获取所有锁定的库位Id列表
     */
    public static Set<String> getAllLockPosIds(){
        Set<String> lockPosIds = new HashSet<>();
        for (ReelLockPosInfo reelLockPosInfo : reelLocKPosMap.values()) {
            lockPosIds.add(reelLockPosInfo.getLockPosId());
        }
        return lockPosIds;
    }

    public static void addFailedRequest(QisdaApiRequest apiRequest){
        String mapKey = apiRequest.getMapKey();
        if(failedRequestMap.get(mapKey) == null){
            log.info(mapKey + "通知指令发送到Qisda失败");
            //  failedRequestMap.put(apiRequest.getMapKey(), apiRequest);
            // cacheInfoDao.updateCacheItem(FAILED_REQUEST_MAP_KEY, failedRequestMap);
        }
    }

    public static void removeFailedRequest(QisdaApiRequest apiRequest){
        String mapKey = apiRequest.getMapKey();
        if(failedRequestMap.get(mapKey) != null){
            log.info(mapKey + "通知指令发送到Qisda成功,从缓存中移除");
            failedRequestMap.remove(apiRequest.getMapKey());
            cacheInfoDao.updateCacheItem(FAILED_REQUEST_MAP_KEY, failedRequestMap);
        }
    }



    /**
     * 保存料架缓存信息
     * @param hSerialShelfMap
     */
    public static void saveShelfMap(Map<String,Map<String,ShelfInfo>> hSerialShelfMap){
        cacheInfoDao.updateCacheItem(HSERIAL_SHELF_MAP_KEY, hSerialShelfMap);
    }

    /**
     * 加载料架缓存信息
     */
    public static Map<String,Map<String,ShelfInfo>> loadShelfMap(){
        Map<String,Map<String,ShelfInfo>> hSerialShelfMap = new ConcurrentHashMap<>();
        CacheInfo cacheInfo = cacheInfoDao.getCacheInfo(HSERIAL_SHELF_MAP_KEY);
        if(cacheInfo != null){
            Map<String, Map<String, ShelfInfo>> dbShelfMap = (Map<String, Map<String, ShelfInfo>>) cacheInfo.getCacheValue();
            hSerialShelfMap.putAll(dbShelfMap);
        }
        return hSerialShelfMap;
    }

    /**
     * 初始化DN单绑定缓存信息
     */
    public void initRfidDnMap(){
        if(rfidDnMap == null){
            CacheInfo cacheInfo = cacheInfoDao.getCacheInfo(RFID_DN_MAP_KEY);
            rfidDnMap = new ConcurrentHashMap<>();
            if(cacheInfo != null){
                Map<String, DNInfo> dbRfidDnMap = (Map<String, DNInfo>) cacheInfo.getCacheValue();
                rfidDnMap.putAll(dbRfidDnMap);
                log.info("当前收料绑定:" + rfidDnMap);
            }
        }
    }


    /**
     * 获取RFID绑定的DN单信息
     * @param rfid
     * @return
     */
    public static DNInfo getDnInfo(String rfid){
        if(rfid == null || rfid.equals("000")){
            //rfid = "";
            DNInfo dnInfo = new DNInfo();
            dnInfo.setDnNo("");
            return dnInfo;
        }

        DNInfo dnInfo = rfidDnMap.get(rfid);
        String usedRfid = "=" + rfid;
        if(dnInfo == null){
            dnInfo = rfidDnMap.get(usedRfid);
        }else{
            //已经使用过,清除掉
            rfidDnMap.remove(rfid);
            rfidDnMap.put(usedRfid, dnInfo);
            saveRfidDnMap();
        }
        if(dnInfo == null){
            //如果未找到料架对应的DNInfo,当作纯入库处理
            dnInfo = new DNInfo();
            dnInfo.setDnNo("");
        }else{
            if(dnInfo.getItems().isEmpty()){
                List<DNItem> items = dNItemDao.findDnItems(dnInfo.getDnNo());
                dnInfo.addItems(items);
            }
        }
        return dnInfo;
    }

    public static void bindRfidDnInfo(String rfid, DNInfo dnInfo){
        rfidDnMap.put(rfid, dnInfo);
        saveRfidDnMap();
    }

    /**
     * 清理RFID绑定的DN单信息
     */
    public static void clearRfidDn(String rfid){
        rfidDnMap.remove(rfid);
        saveRfidDnMap();
    }

    /**
     * 当前正在执行的工单需求单
     * @param executeHSerial
     */
    public static void setCurrentOrderHSerial(String executeHSerial) {

        if(currentOrderHSerial == null){
            currentOrderHSerial = "";
        }
        String oldHSerial = currentOrderHSerial;
        log.info("设置当前正在执行的工单料需求为:" + executeHSerial+"清理之前["+oldHSerial+"]出库使用的料架");
        InquiryShelfBean.clearShelf(oldHSerial);
        currentOrderHSerial = executeHSerial;
        cacheInfoDao.updateCacheItem(CURRENT_ORDER_HSERIAL_KEY, currentOrderHSerial);
    }

    public static void updateUsedRfid(List<String> usedRfidList){
        String oldUsedRfid = "";
        if(lastHSerialUsedRfidList != null){
            oldUsedRfid = String.join(",",lastHSerialUsedRfidList);
        }
        String newUsedRfid = "";
        if(usedRfidList != null){
            newUsedRfid = String.join(",",usedRfidList);
        }
        log.info("已使用过的料架信息更新:["+oldUsedRfid+"]=>["+newUsedRfid+"]");
        lastHSerialUsedRfidList = usedRfidList;
    }

    /**
     * 是否是上个工单需求单使用过的料架
     */
    public static boolean isLastHSerialUsedRfid(String rfid){
        if(lastHSerialUsedRfidList != null){
            return lastHSerialUsedRfidList.contains(rfid);
        }
        return false;
    }

    /**
     * 当前正在执行的工单需求单
     */
    public static String getCurrentOrderHSerial() {
        if(currentOrderHSerial == null){
            CacheInfo cacheInfo = cacheInfoDao.getCacheInfo(CURRENT_ORDER_HSERIAL_KEY);
            if(cacheInfo == null){
                currentOrderHSerial = "";
            }else{
                currentOrderHSerial = cacheInfo.getCacheValue().toString();
            }
        }
        return currentOrderHSerial;
    }

    /**
     * 加载请求指令信息
     */
    private static void initReelLockPosMap(){
        if(reelLocKPosMap == null){
            reelLocKPosMap = new ConcurrentHashMap<>();
            CacheInfo cacheInfo = cacheInfoDao.getCacheInfo(REEL_LOCK_POS_MAP_KEY);
            if(cacheInfo != null){
                Map<String, ReelLockPosInfo> locPosMap = (Map<String, ReelLockPosInfo>) cacheInfo.getCacheValue();
                reelLocKPosMap.putAll(locPosMap);
                log.info("当前料盘锁定库位信息:" + reelLocKPosMap);
            }
        }
    }

    /**
     * 加载请求指令信息
     */
    private static void initApiRequestMap(){
        if(failedRequestMap == null){
            failedRequestMap = new ConcurrentHashMap<>();
            CacheInfo cacheInfo = cacheInfoDao.getCacheInfo(FAILED_REQUEST_MAP_KEY);
            if(cacheInfo != null){
                Map<String, QisdaApiRequest> dbFailedRequestMap = (Map<String, QisdaApiRequest>) cacheInfo.getCacheValue();
                failedRequestMap.putAll(dbFailedRequestMap);
                log.info("当前发送通知失败指令:" + failedRequestMap);
            }
        }
    }

    /**
     * 获取失败列表,进行定时发送
     */
    private static void sendFailedRequest() throws ApiException {
        List<QisdaApiRequest> failedList = new ArrayList<>();
        failedList.addAll(failedRequestMap.values());
        failedList.sort(new Comparator<QisdaApiRequest>() {
            @Override
            public int compare(QisdaApiRequest o1, QisdaApiRequest o2) {
                return o1.getDate().compareTo(o2.getDate()) ;
            }
        });

        for (QisdaApiRequest apiRequest : failedList) {
            //log.info("重发通知指令[" + apiRequest.getMapKey() + "]到Qisda");
            String result = HttpHelper.postParam(apiRequest.getUrl(),apiRequest.getParamMap());
            //log.info("重发通知指令[" + apiRequest.getMapKey() + "]到Qisda返回:" + result);
            String resultStr = XmlUtil.getNodeBody("string", result);
            if(resultStr.startsWith("-1") || resultStr.startsWith("0")){
                //log.info(apiRequest.getMapKey() + "Qisda接口调用失败,需要进行重发");
            }else{
                QisdaCache.removeFailedRequest(apiRequest);
                return;
            }
        }
    }

    private synchronized static void saveRfidDnMap(){
        cacheInfoDao.updateCacheItem(RFID_DN_MAP_KEY,rfidDnMap);
    }

    @Autowired
    public void setCacheInfoDao(ICacheInfoDao cacheInfoDao) {
        QisdaCache.cacheInfoDao = cacheInfoDao;
    }

    @Autowired
    public void setdNItemDao(IDNItemDao dNItemDao) {
        QisdaCache.dNItemDao = dNItemDao;
    }
}