package com.myproject.manager.impl;

import com.google.common.base.Strings;
import com.google.common.collect.Lists;
import com.myproject.bean.json.ChartData;
import com.myproject.bean.json.ChartItem;
import com.myproject.bean.json.InventoryItem;
import com.myproject.bean.json.PlateSizeBean;
import com.myproject.bean.search.PageList;
import com.myproject.bean.update.Barcode;
import com.myproject.bean.update.Storage;
import com.myproject.bean.update.StoragePos;
import com.myproject.dao.mongo.IStoragePosDao;
import com.myproject.exception.ValidateException;
import com.myproject.manager.IStorageManager;
import com.myproject.manager.IStoragePosManager;
import com.myproject.util.PLATE_SIZE;
import com.myproject.util.StorageConstants;
import com.myproject.webapp.controller.webService.DataCache;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.time.DateUtils;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.stereotype.Service;

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

/**
 * Created by kangmor on 2015/12/4.
 */
@Service
public class StoragePosManagerImpl implements IStoragePosManager {
    @Autowired
    private IStoragePosDao storagePosDao;
    @Autowired
    private IStorageManager storageManager;

    protected final transient Logger log = LogManager.getLogger(getClass());

    @Override
    public StoragePos findByStorage(String storageId, String storagePosName) {
        return storagePosDao.findOneByCondition(new String[]{"storageId", "posName"}, new String[]{storageId, storagePosName});
    }

    @Override
    public StoragePos get(String id) {
        return storagePosDao.findOneById(id);
    }


    /**
     * 清除位置信息
     */
    @Override
    public void clearPos(String storageId){
        Query query = new Query(Criteria.where("storageId").is(storageId));
        storagePosDao.removeByQuery(query);
    }

    /**
     * 根据 partNumber 查找虚拟仓的空位
     */
    @Override
    public StoragePos getEmptyPosByPartNumber(String storageId, String partNumber, Collection<String> excludePosIds){
        Criteria c = Criteria.where("storageId").is(storageId)
                .and("specifiedPartNumber").is(partNumber)
                .and("enabled").is(true)//可用
                .and("used").is(false);//未使用;
        //去除的仓位
        if(excludePosIds != null && !excludePosIds.isEmpty()){
            c = c.and("id").nin(excludePosIds);
        }
        Query query = new Query(c);
        query.with(new Sort(Sort.Direction.ASC, "id"));
        StoragePos pos = storagePosDao.findOne(query);
        return pos;
    }

    /**
     * 查找同尺寸连续的库位,合并库位放置料盘,仅用于智能料架
     * @param storage
     * @param barcode
     * @return
     */
    @Override
    public List<StoragePos> getSameSizeContinuityEmptyPosList(Storage storage, Barcode barcode) throws ValidateException {
        if(storage == null){
            throw new ValidateException("指定的料架不存在");
        }
        if(!storage.isAccShelf()){
            throw new ValidateException("合并库位仅适用的智能料架");
        }
        Criteria c = Criteria.where("storageId").is(storage.getId());
        if(barcode.getPlateSize() > 7){
            c = c.and("w").gte(barcode.getPlateSize());
        }else{
            c = c.and("w").is(barcode.getPlateSize());
        }
        c = c.and("h").gte(0);//宽度大于等于料盘宽度,高度大于等于料盘高度
        c = c.and("enabled").is(true)//可用
                .and("used").is(false);//未使用
        Query query = new Query(c);
        //优先放入最合适的位置(根据尺寸),相同尺寸按优先级排序
        query.with(new Sort(Sort.Direction.ASC, "posName"));
        List<StoragePos> posList = storagePosDao.findByQuery(query);
        //把不连续的过滤掉
        Map<String,StoragePos> posMap = new ConcurrentHashMap<>();
        for(StoragePos pos : posList){
            posMap.put(pos.getPosName(),pos);
        }
        Set<String> posNames = posMap.keySet();
        for (String posName : posNames) {
            StoragePos currentPos = posMap.get(posName);
            int totalHeight = currentPos.getH();
            List<StoragePos> emptyPosList = new ArrayList<>();
            emptyPosList.add(currentPos);
            String nextPosName = posName;
            while (true){
                if(totalHeight >= barcode.getHeight()){
                    return emptyPosList;
                }
                nextPosName = getNextPosName(nextPosName);
                StoragePos nextPos = posMap.get(nextPosName);
                if(nextPos == null){
                    break;
                }
                emptyPosList.add(nextPos);
                totalHeight = totalHeight + currentPos.getH();
            }
        }
        return new ArrayList<>();
    }


    /**
     * 获取下一库位的库位名(后缀数字+1)
     */
    private String getNextPosName(String posName){
        String posIndexStr = "";
        String prefixStr = "";
        for(int i=1;i<=posName.length();i++){
            char c = posName.charAt(posName.length() - i);
            if(!Character.isDigit(c)){
                prefixStr = posName.substring(0, posName.length() - i + 1);
                break;
            }
            posIndexStr = c + posIndexStr;
        }

        if(posIndexStr.isEmpty()){
            return "";
        }
        int posIndex = Integer.valueOf(posIndexStr);
        int nextPosIndex = posIndex + 1;
        return prefixStr + nextPosIndex;
    }

    @Override
    public StoragePos getEmptyPosByStorage(Storage storage, Barcode barcode, List<Integer> inBoxIds, Collection<String> excludePosIds) throws ValidateException {

        if(storage == null){
            throw new ValidateException("指定的料仓不存在");
        }

        Criteria c = Criteria.where("storageId").is(storage.getId());

        StorageConstants.COMPATIBLE_TYPE compatibleType = storage.getCompatibleType();

        if(compatibleType == StorageConstants.COMPATIBLE_TYPE.EXACT_MATCH){//完全匹配
            c = c.and("w").is(barcode.getPlateSize()).and("h").is(barcode.getHeight());
        }else if(compatibleType == StorageConstants.COMPATIBLE_TYPE.FULLY_COMPATIBLE){//完全兼容
            c = c.and("w").gte(barcode.getPlateSize()).and("h").gte(barcode.getHeight());//宽度大于等于料盘宽度,高度大于等于料盘高度
        }else if(compatibleType == StorageConstants.COMPATIBLE_TYPE.SIZE_COMPATIBLE){//同尺寸兼容
            //7寸的允许放入13 寸, 7 寸和13 寸不允许放入15 寸
            if(barcode.getPlateSize() == 7){
                c = c.and("w").in(7,13).and("h").gte(barcode.getHeight());//宽度等于料盘宽度,高度大于等于料盘高度
            }else if(barcode.getPlateSize() == 13){
                c = c.and("w").in(13,15).and("h").gte(barcode.getHeight());//宽度等于料盘宽度,高度大于等于料盘高度
            }else{
                c = c.and("w").is(barcode.getPlateSize()).and("h").gte(barcode.getHeight());//宽度等于料盘宽度,高度大于等于料盘高度
            }
        }

        c = c.and("enabled").is(true)//可用
                .and("used").is(false);//未使用
//        if(inBoxIds != null && !inBoxIds.isEmpty()){
//            String inBoxIdStr = StringUtils.join(inBoxIds,"|");
//            //匹配仓位名称以数字#开头的(inBoxIds 要用正则的|线隔开)
//            //c = c.and("posName").regex("^("+inBoxIdStr+")#.*");
//        }
        //去除的仓位
        if(excludePosIds != null && !excludePosIds.isEmpty()){
            c = c.and("id").nin(excludePosIds);
        }
        Query query = new Query(c);
        //优先放入最合适的位置(根据尺寸),相同尺寸按优先级排序
        query.with(new Sort(Sort.Direction.ASC, "w").and(new Sort(Sort.Direction.ASC, "h")).and(new Sort(Sort.Direction.DESC, "priority")).and(new Sort(Sort.Direction.ASC, "posName")));
        StoragePos pos = storagePosDao.findOne(query);
        return pos;
    }

    public int countTotalStorageSize(String storageId) {
        List<StoragePos> storagePosList = getSortedStoragePosList(storageId);
        if (storagePosList != null) {
            return storagePosList.size();
        } else {
            return 0;
        }
    }

    public int countEmptyStorageSize(String storageId) {
        List<StoragePos> storagePosList = getSortedStoragePosList(storageId);
        if (storagePosList != null) {
            int count = 0;
            for (StoragePos storagePos : storagePosList) {
                if (storagePos.isEnabled() && !storagePos.isUsed()) {
                    count++;
                }
            }
            return count;
        } else {
            return 0;
        }
    }

    public List<StoragePos> getSortedStoragePosList(String storageId) {
       /* List<StoragePos> storagePosList = storagePosMap.get(storageId);
        if (storagePosList == null) {
            storagePosList = storagePosDao.findListByCondition(new String[]{"storageId"}, new String[]{storageId});
            if (storagePosList != null && storagePosList.size() > 0)
//                storagePosList.sort(new Comparator<StoragePos>() {
//                    @Override
//                    public int compare(StoragePos sp1, StoragePos sp2) {
//                        return sp1.getX() - sp2.getX();
//                    }
//                });
                storagePosMap.put(storageId, storagePosList);
                return storagePosList;
        } else {
            return storagePosList;
        }*/
        Criteria c = Criteria.where("storageId").is(storageId);
        Query query = new Query(c);
        //优先放入最合适的位置(根据尺寸),相同尺寸按优先级排序
        //query.with(new Sort(Sort.Direction.ASC, "w").and(new Sort(Sort.Direction.DESC, "priority")));
        List<StoragePos> storagePosList = storagePosDao.findByQuery(query);
        return storagePosList;
    }


    public StoragePos findComponent(String componentId) {
        StoragePos storagePos = storagePosDao.findOneByCondition(new String[]{"barcode.componentId"/*, "barcode.used"*/}, new String[]{componentId/*, "true"*/});
//        if (storagePos == null) {
//            storagePos = storagePosDao.findOneByCondition(new String[]{"barcode.componentId"}, new String[]{componentId});
//        }
        return storagePos;
    }


    /**
     * 查找料仓某个 BOX 的 partNumbers 出库(先出 partNumber 小的且时间比较早的)
     * @param storageId
     * @param boxId
     * @param partNumbers
     * @param excludePosIds 排除掉的位置
     * @return
     */
    @Override
    public StoragePos findComponent(String storageId, String boxId, Collection<String> partNumbers, Collection<String> excludePosIds, StorageConstants.CHECKOUT_TYPE checkoutType){
        Criteria c = Criteria.where("storageId").is(storageId)
                .and("barcode.partNumber").in(partNumbers)
                .and("barcode.lockId").is(null)//没有被锁定的仓位
                .and("id").nin(excludePosIds)
                .and("posName").regex("^"+boxId+"#.*")
                .and("enabled").is(true);//可用
                //.and("used").is(true);//未使用
        Query query = new Query(c);
        Sort sort = getSortByCheckOutType(checkoutType);
        query.with(sort);
        StoragePos pos = storagePosDao.findOne(query);

        return pos;
    }

    @Override
    public List<StoragePos> findNotEmptyByStorageId(String storageId){
        Criteria c = Criteria.where("barcode.barcode").exists(true)
                .and("enabled").is(true).and("used").is(true);//可用;
        if(!Strings.isNullOrEmpty(storageId)){
            c = c.and("storageId").is(storageId);
        }
        Query query = new Query(c);
        query.with(new Sort(Sort.Direction.ASC, "updateDate"));
        return storagePosDao.findByQuery(query);
    }

    @Override
    public List<StoragePos> findBeforePutinTime(int hours){
        long beforPutIntime = System.currentTimeMillis() - hours * 60 * 60 * 1000;
        Criteria c = Criteria.where("barcode.putInTime").lt(beforPutIntime).and("barcode.miniStock").is(false).and("enabled").is(true);//可用;
        Query query = new Query(c);
        query.with(new Sort(Sort.Direction.DESC, "updateDate"));
        return storagePosDao.findByQuery(query);
    }

    @Override
    public List<StoragePos> findNotEmpty(){
        return findNotEmptyByStorageId(null);
    }

    /**
     * 查找呆滞物料
     * @param storageIds 在哪几个料仓里查找
     * @param day 几天前的呆滞物料
     * @param excludePosIds 排除的位置信息（正在等待和执行队列里的）
     * @param count 取几条记录
     * @return
     */
    @Override
    public List<StoragePos> findInaction(List<String> storageIds, int day, Collection<String> excludePosIds, int count){
        Date date = DateUtils.addDays(new Date(), -day);//几天前
        Criteria c = Criteria.where("barcode.putInTime").lte(date)
                .and("barcode").exists(true)
                //.and("barcode.lockId").is(null)//没有被锁定的仓位
                .and("id").nin(excludePosIds);

        if(storageIds != null && !storageIds.isEmpty()){
            c = c.and("storageId").in(storageIds);
        }
        Query query = new Query(c);
        if(count > 0){
            query.limit(count);
        }
        query.with(new Sort(Sort.Direction.ASC, "updateDate"));

        return storagePosDao.findByQuery(query);
    }

    @Override
    public int countInaction(List<String> storageIds, int day, Collection<String> excludePosIds){
        Date date = DateUtils.addDays(new Date(), -day);//几天前
        Criteria c = Criteria.where("barcode.putInTime").lte(date.getTime())
                //.and("barcode").exists(true)

                .and("barcode.lockId").is(null)//没有被锁定的仓位
                .and("id").nin(excludePosIds);

        if(storageIds != null && !storageIds.isEmpty()){
            c = c.and("storageId").in(storageIds);
        }
        Query query = new Query(c);
        return storagePosDao.countByQuery(query);
    }

    @Override
    public int stockCount(String storageId, int type){
        Criteria c = Criteria.where("storageId").is(storageId)
                .and("barcode.type").is(type);
        Query query = new Query(c);
        return storagePosDao.countByQuery(query);
    }

    /**
     * 可用夹具数量
     */
    @Override
    public int partNumberCount(String storageId, String partNumber){
        if(StorageConstants.PACKAGE_TYPE.SOLDER_FIXTURE.getCode().equalsIgnoreCase(partNumber)){
            return storagePosDao.countIdleSolderFixture(storageId);
        }else{
            Criteria c = Criteria.where("storageId").is(storageId)
                    .and("barcode.partNumber").is(partNumber);
            Query query = new Query(c);
            return storagePosDao.countByQuery(query);
        }
    }

    @Override
    public int expireCount(String storageId, int type){
        Criteria c = Criteria.where("storageId").is(storageId)
                .and("barcode.type").is(type).and("barcode.expireDate").lte(new Date());
        Query query = new Query(c);
        return storagePosDao.countByQuery(query);
    }

    @Override
    public List<ChartData> groupShow() {
        return storagePosDao.groupShow();
    }

    @Override
    public Map<String, InventoryItem> getInventory(String storageId){
        return storagePosDao.getInventory(-1, storageId);
    }


    @Override
    public Map<String, InventoryItem> getInventory(int type, String... storageIds){
        return storagePosDao.getInventory(type,storageIds);
    }

    @Override
    public List<PLATE_SIZE> distinctPlateSize(String storageId) {
        return storagePosDao.distinctPlateSize(storageId);
    }

    @Override
    public StoragePos findOneLockPos(String partNumber, String lockId, Collection<String> excludePosIds){
        Criteria c = Criteria.where("barcode.lockId").is(lockId).and("barcode.partNumber").is(partNumber).and("id").nin(excludePosIds);
        Query q = new Query(c);
        q.with(new Sort(Sort.Direction.ASC, "updateDate"));
        return storagePosDao.findOne(q);
    }

    @Override
    public StoragePos findNoLockPartnumerPos(String storageId,String partNumber,String lineInfoStr){
        Criteria c = Criteria.where("storageId").is(storageId)
                .and("barcode.partNumber").is(partNumber).and("barcode.lineInfoStr").is(lineInfoStr).and("barcode.lockName").is(null);
        Query q = new Query(c);
        q.with(new Sort(Sort.Direction.ASC, "updateDate"));
        return storagePosDao.findOne(q);
    }



    @Override
    public StoragePos findOneById(String id){
        return storagePosDao.findOneById(id);
    }

    /**
     * 查找仓中的物料(没锁定的)
     */
    @Override
    public StoragePos findPartNumberPos(String storageId, String partNumber, Collection<String> excludePosIds, StorageConstants.CHECKOUT_TYPE checkoutType){
        return findPos(storageId,"barcode.partNumber",partNumber,excludePosIds,checkoutType);
    }


    @Override
    public List<StoragePos> findByPartNumber(String storageId, String partNumber){
        Criteria c = Criteria.where("barcode.partNumber").regex(partNumber)
                .and("enabled").is(true)//可用
                .and("barcode.lockId").is(null)//没有被锁定的仓位;
                .and("storageId").is(storageId);
        Query q = new Query(c);
        return storagePosDao.findByQuery(q);
    }

    /**
     * 根据类型查找出仓库中的一个物料
     */
    @Override
    public StoragePos findTypePos(String storageId, String type, Collection<String> excludePosIds, StorageConstants.CHECKOUT_TYPE checkoutType){
        return findPos(storageId, "barcode.type", type, excludePosIds,checkoutType);
    }

    private StoragePos findPos(String storageId, String field, String value, Collection<String> excludePosIds, StorageConstants.CHECKOUT_TYPE checkoutType){
        Criteria c = Criteria.where(field).is(value)
                .and("id").nin(excludePosIds)
                .and("enabled").is(true)//可用
                .and("barcode.lockId").is(null);//没有被锁定的仓位;
        if(storageId != null){
            c = c.and("storageId").is(storageId);
        }
        Query q = new Query(c);
        Sort sort = getSortByCheckOutType(checkoutType);
        q.with(sort);
        log.info("使用"+checkoutType+"策略出库"+field + "="+value);
        return storagePosDao.findOne(q);
    }

    /**
     * 根据出库方式获取不同的 Sort
     */
    private Sort getSortByCheckOutType(StorageConstants.CHECKOUT_TYPE checkoutType){
        Sort sort = null;
        if(StorageConstants.CHECKOUT_TYPE.EXPIRE_FIRST.equals(checkoutType)){//先过期先出
            sort = new Sort(Sort.Direction.DESC, "barcode.expTime").and(new Sort(Sort.Direction.ASC, "createDate"));
        }else if(StorageConstants.CHECKOUT_TYPE.FIFO.equals(checkoutType)){//严格的先进先出
            sort = new Sort(Sort.Direction.ASC, "canCheckOutTime").and(new Sort(Sort.Direction.ASC, "createDate")).and(new Sort(Sort.Direction.DESC, "barcode.usedCount"));
        }else if(StorageConstants.CHECKOUT_TYPE.USED_FIRST.equals(checkoutType)){//尾料优先
            sort = new Sort(Sort.Direction.DESC, "barcode.usedCount").and(new Sort(Sort.Direction.ASC, "createDate"));
        }else{//效率优先
            sort = new Sort(Sort.Direction.ASC, "canCheckOutTime").and(new Sort(Sort.Direction.ASC, "createDate"));
        }
        return sort;
    }

    @Override
    public StoragePos getByFixtureCode(String fixtureCode){
        return storagePosDao.findOneByCondition(new String[]{"barcode.fixtureCode"}, new String[]{fixtureCode});
    }

    public StoragePos getByBarcodeId(String barcodeId) {
        return storagePosDao.findOneByCondition(new String[]{"barcode.id"}, new String[]{barcodeId});
    }

    @Override
    public StoragePos getByBarcode(String barcode){
        return storagePosDao.findOneByCondition(new String[]{"barcode.barcode"}, new String[]{barcode});
    }

    @Override
    public StoragePos getByPosName(String posName){
        return storagePosDao.findOneByCondition(new String[]{"posName"}, new String[]{posName});
    }

    /**
     *查找一个库位可以放多种料的库位
     */
    @Override
    public List<StoragePos> findByLabel(String storageId, String labelStr){
        Criteria c = Criteria.where("posName").regex("^"+labelStr+":?.*")
                .and("storageId").is(storageId);
        Query q = new Query(c);
        return storagePosDao.findByQuery(q);
    }

    @Override
    public void insertAll(List<StoragePos> posList) {
        storagePosDao.insertAll(posList);
    }

    @Override
    public List<StoragePos> findLockPos(String lockId) {
        return storagePosDao.findLockPos(lockId);
    }

    @Override
    public List<StoragePos> findPosList(String storageId, List<String> posNames){
        if(posNames == null || posNames.isEmpty()){
            return Lists.newArrayList();
        }
        Criteria c = Criteria.where("storageId").is(storageId)
                .and("posName").in(posNames);
        Query q = new Query(c);
        return storagePosDao.findByQuery(q);
    }

    @Override
    public StoragePos save(StoragePos storagePos) throws ValidateException {
        Storage storage = storageManager.get(storagePos.getStorageId());
        if (storage == null) {
            throw new ValidateException("storage.error.notExist");
        }
        if(!storagePos.isUsed()){
            //出库
            List<String> mergePosNames = storagePos.getMergePosList();
            List<StoragePos> mergePosList = findPosList(storagePos.getStorageId(), mergePosNames);
            //解除相关合并库位的占用状态
            for(StoragePos mergePos : mergePosList){
                mergePos.setUsed(false);
                mergePos.setMergePosList(null);
                storagePosDao.save(mergePos);
                log.info("设置合并的关联库位["+mergePos.getPosName()+"]使用状态为:false");
            }
            storagePos.setMergePosList(null);
        }
        storagePos = storagePosDao.save(storagePos);
        //reSortStoragePosList(storage.getId());
        log.debug("Storage " + storage.getName() + " was added new slot with id: " + storagePos.getId());
        return storagePos;
    }

    @Override
    public void delete(StoragePos storagePos) throws ValidateException {
        storagePosDao.removeOne(storagePos);
    }

    @Override
    public List<StoragePos> findAll() {
        return storagePosDao.findAll();
    }

    @Override
    public PageList findByQuery(Query query, PageList pageList) {
        pageList = storagePosDao.findByQuery(query, pageList);
        return pageList;
    }

    @Override
    public int countByQuery(Query query) {
        return storagePosDao.countByQuery(query);
    }

    @Override
    public void validate(StoragePos object, List errors) {

    }

    @Override
    public List<ChartItem> lockOrderInfo(){
        return storagePosDao.lockOrderInfo();
    }

    @Override
    public List<PlateSizeBean> getStoragePosUsage(String storageId) {
        return storagePosDao.getStoragePosUsage(storageId);
    }

    public void setStoragePosDao(IStoragePosDao storagePosDao) {
        this.storagePosDao = storagePosDao;
    }

    public void setStorageManager(IStorageManager storageManager) {
        this.storageManager = storageManager;
    }

}