package com.myproject.webapp.controller.webService;

import com.google.common.base.Strings;
import com.google.common.collect.HashMultiset;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Multiset;
import com.myproject.bean.CodeBean;
import com.myproject.bean.json.InventoryItem;
import com.myproject.bean.update.*;
import com.myproject.dao.mongo.*;
import com.myproject.exception.ValidateException;
import com.myproject.manager.IBarcodeManager;
import com.myproject.manager.IComponentManager;
import com.myproject.manager.IStorageManager;
import com.myproject.manager.IStoragePosManager;
import com.myproject.util.BarcodeRule;
import com.myproject.util.DateUtil;
import com.myproject.util.PLATE_SIZE;
import com.myproject.util.StorageConstants;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
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 DataCache{

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

    //客户
    public static class CUSTOMER{
        public static String LIAN_DIAN = "LianDian";
        public static String BOSHI = "BOSHI";
        public static String NANRUI = "NANRUI";
        /**
         * 松下
         */
        public static String PANACIM = "Pana";

        /**
         * 佳世达
         */
        public static String QISDA = "QISDA";
    }

    /**
     * 是否是为某一个客户单独定制的
     */
    public static boolean isProductionFor(String... names){
        //String production = "ChengDuKaiTian";//成都凯天
        //Pana  松下
        String production = "";
        if(settings != null){
            production = settings.getProductCustom();
        }
        for (String name : names){
            if(name.equalsIgnoreCase(production)){
                return true;
            }
        }
        return false;
    }

    @Autowired
    private IStoragePosManager storagePosManager;
    @Autowired
    private IStorageManager storageManager;

    @Autowired
    private IDataLogDao dataLogDao;

    @Autowired
    private ISettingsDao settingsDao;

    @Autowired
    private IBarcodeManager barcodeManager;

    @Autowired
    private IComponentManager componentManager;

    @Autowired
    private IMaintenanceDao maintenanceDao;

    /**
     * 是否需要推送温湿度报警值
     */
    public static Map<String, Boolean>  needUpdateHumidityMap = new ConcurrentHashMap<>();

    /**
     * 出库方式
     */
    private static Settings settings;

    private static List<BarcodeRule> barcodeRuleList;

    /**
     * 设备运行状态
     */
    private static Map<String, Maintenance> maintenanceMap = new ConcurrentHashMap<>();

    public Collection<Maintenance> allDeviceInfos(){
        if(maintenanceMap.isEmpty()){
            List<Maintenance> all = maintenanceDao.findAll();
            for (Maintenance maintenance : all) {
                maintenanceMap.put(maintenance.getStorageCid(), maintenance);
            }
        }
        return maintenanceMap.values();
    }

    public void updateMaintenanceTime(String cid){
        Maintenance maintenance = maintenanceMap.get(cid);
        if(maintenance != null){
            Calendar c = Calendar.getInstance();
            c.add(Calendar.DAY_OF_YEAR, getSettings().getMaintenanceDays());
            maintenance.setNextTime(c.getTime());
            maintenance = maintenanceDao.save(maintenance);
            maintenanceMap.put(cid,maintenance);
        }
    }

    /**
     * 更新设备状态
     */
    public void updateDeviceStatus(String cid, int boxId, Map<String, String> dataMap){
        Maintenance maintenance = maintenanceMap.get(cid);
        if(maintenance == null){
            maintenance = maintenanceDao.findByCid(cid);
            if(maintenance == null){
                maintenance = new Maintenance();
                maintenance.setStorageCid(cid);
                maintenance = maintenanceDao.save(maintenance);
            }
        }
        boolean needSaveToDb = false;
        for (Map.Entry<String, String> entry : dataMap.entrySet()) {
            String device = entry.getKey();
            if(device.startsWith("device")){
                int status = 0;
                try{
                    status = Integer.parseInt(entry.getValue());
                }catch (Exception e){

                }
                String deviceKey = boxId + "_" + device;
                boolean result = maintenance.updateDeviceStatus(deviceKey,status);
                if(result){
                    needSaveToDb = true;
                }
            }
        }
        if(needSaveToDb){
            Storage storage = getStorage(cid);
            maintenance.setStorageName(storage.getName());
            maintenance = maintenanceDao.save(maintenance);
        }
        maintenanceMap.put(cid, maintenance);
    }

    /**
     * 是否需要推送温湿度报警值
     */
    public boolean needUpdateHumidiy(String cid){
        Boolean needUpdateHumidiy = needUpdateHumidityMap.get(cid);
        if(needUpdateHumidiy == null || needUpdateHumidiy){
            needUpdateHumidityMap.put(cid, false);
            return true;
        }
        return false;
    }


    public Settings getSettings(){
        if(settings == null){
            List<Settings> allSettings = settingsDao.findAll();
            if(allSettings == null || allSettings.isEmpty()){
                settings = new Settings();
                settings.setOutType(StorageConstants.CHECKOUT_TYPE.EFFICIENCY.name());
                settings = settingsDao.save(settings);
            }else{
                settings = allSettings.get(0);
            }

            barcodeRuleList = Lists.newArrayList();
            List<String> ruleList = settings.getCodeRuleList();
            String oldCodeRule = settings.getCodeRule();
            if(!Strings.isNullOrEmpty(oldCodeRule)){
                ruleList.add(oldCodeRule);
                settings.setCodeRule("");
                settings.setCodeRuleList(ruleList);
                updateSettings(settings);
            }

            for(String codeRule : ruleList){
                if(!Strings.isNullOrEmpty(codeRule)){
                    barcodeRuleList.add(BarcodeRule.newRule(codeRule));
                }
            }
        }
        return settings;
    }

    /**
     * 解析条码为单个 Barcode
     */
    public CodeBean resolveSingleCode(String barcodeItemStr){
        //防止规则未初始化
        if(barcodeRuleList == null){
            getSettings();
        }

        CodeBean codeBeanFromRule = null;
        Barcode barcode = null;
        if(barcodeRuleList.isEmpty()){
            //没有配置规则的话,直接从数据库中查询
            barcode = barcodeManager.findByBarcode(barcodeItemStr);
            if(barcode != null) {
                codeBeanFromRule = new CodeBean();
                codeBeanFromRule.setError(null);
                codeBeanFromRule.setCodeStr(barcode.getBarcode());
                codeBeanFromRule.setBarcode(barcode);
                Component component = componentManager.findByPartNumber(barcode.getPartNumber());
                codeBeanFromRule.setShowImg(component.getShowImg());

                return codeBeanFromRule;
            }
        }

        //每个规则尝试解析一次
        for (BarcodeRule codeRule : barcodeRuleList){
            codeBeanFromRule = codeRule.toCodeBean(barcodeItemStr);
            //查看数据库中是否已存在
            String codeStr = codeBeanFromRule.getCodeStr();
            barcode = barcodeManager.findByBarcode(codeStr);
            if(barcode != null) {//数据库中已存在
                if(codeBeanFromRule.hasReelSizeInfo()){
                    //如果客户端传入的有尺寸,但尺寸不一致,使用上传上来的尺寸
                    if(barcode.getHeight() != codeBeanFromRule.getReelHeight() || barcode.getPlateSize() != codeBeanFromRule.getReelWidth()){
                        try{
                            log.warn("重新设置尺寸["+barcode.getPlateSize()+"x"+barcode.getHeight()+"]为["+codeBeanFromRule.getReelWidth()+"x"+codeBeanFromRule.getReelHeight()+"]");

                            barcode.setPlateSize(codeBeanFromRule.getReelWidth());
                            barcode.setHeight(codeBeanFromRule.getReelHeight());
                            barcode = barcodeManager.save(barcode);
                        }catch (Exception ve){

                        }
                    }
                }
                Component component = componentManager.findByPartNumber(barcode.getPartNumber());
                int validDay = 0;
                if(component != null){
                    validDay = component.getValidDay();
                    codeBeanFromRule.setShowImg(component.getShowImg());
                }

                Barcode barcodeFromRule = codeBeanFromRule.getBarcode();
                if(barcodeFromRule != null){
                    Date produceDate = barcodeFromRule.getProduceDate();
                    if(produceDate != null){
                        //抓取到了生产日期,未抓取到过期日期,重新设置过期日期
                        if(barcode.getExpireDate() == null){
                            if(validDay > 0){
                                try {
                                    log.warn("重新设置"+codeBeanFromRule.getCodeStr()+"生产日期和过期日期");
                                    Date expireDate = DateUtil.addDays(produceDate, validDay);
                                    barcode.setExpireDate(expireDate);
                                    barcode.setProduceDate(produceDate);
                                    barcodeManager.save(barcode);
                                }catch (Exception e){

                                }
                            }
                        }
                    }
                }

                codeBeanFromRule.setError(null);
                codeBeanFromRule.setCodeStr(barcode.getBarcode());
                codeBeanFromRule.setBarcode(barcode);
                return codeBeanFromRule;
            }else if(codeBeanFromRule.isValid()){//数据库中不存在,但解析成功
                Barcode barcodeFromRule = codeBeanFromRule.getBarcode();
                try{
                    //如果有料盘尺寸,重新设置料盘尺寸信息,没有档案时自动添加档案
                    if(codeBeanFromRule.hasReelSizeInfo()){
                        //log.info("料盘["+barcode.getBarcode()+"]的尺寸信息从["+barcode.getPlateSize()+"x"+barcode.getHeight()+"]设置为["+codeBeanFromRule.getReelWidth()+"x"+codeBeanFromRule.getReelHeight()+"]");
                        Component component = componentManager.findByPartNumber(barcodeFromRule.getPartNumber());

                        if(component == null){
                            log.info("自动添加["+barcodeFromRule.getPartNumber()+"]的档案信息["+codeBeanFromRule.getReelWidth()+"x"+codeBeanFromRule.getReelHeight()+"]");
                            component = new Component();
                            component.setPartNumber(barcodeFromRule.getPartNumber());
                            component.setAmount(barcodeFromRule.getAmount());
                            component.setPlateSize(barcodeFromRule.getPlateSize());
                            component.setHeight(barcodeFromRule.getHeight());
                            component.setName(barcodeFromRule.getPartNumber());
                            componentManager.save(component);
                        }else{
                            //如果 barcode 里的料盘信息比 Component 中的大,使用比较大的,防止放不进去撞击
                            if(codeBeanFromRule.getReelHeight() > component.getHeight() || codeBeanFromRule.getReelWidth() > component.getPlateSize()){
                                log.info("更新物料["+component.getPartNumber()+"]档案尺寸["+component.getPlateSize()+"x"+component.getHeight()+"]为["+codeBeanFromRule.getReelWidth()+"x"+codeBeanFromRule.getReelHeight()+"]");
                                component.setPlateSize(barcodeFromRule.getPlateSize());
                                component.setHeight(barcodeFromRule.getHeight());
                                componentManager.save(component);
                            }
                            codeBeanFromRule.setShowImg(component.getShowImg());
                        }

                    }

                    boolean needAddNew = true;
                    if(isProductionFor(CUSTOMER.LIAN_DIAN)){
                        //联电的唯一码中必须带有-,否则无效
                        if(!barcodeFromRule.getBarcode().contains("-")){
                            needAddNew = false;
                            log.info("唯一码["+barcodeFromRule.getBarcode()+"]中不带符号-,忽略");
                            return null;
                        }
                    }
                    if(needAddNew){
                        log.info("自动添加条码"+barcodeItemStr+"到数据库中");
                        Component component = componentManager.findByPartNumber(barcodeFromRule.getPartNumber());
                        if(component == null){
                            throw new ValidateException("档案不存在");
                        }

                        codeBeanFromRule.setShowImg(component.getShowImg());
                        Date produceDate = barcodeFromRule.getProduceDate();
                        if(produceDate != null && barcodeFromRule.getExpireDate() == null){
                            int validDay = component.getValidDay();
                            if( validDay > 0){
                                log.info("设置"+barcodeFromRule.getBarcode()+"的过期时间");
                                Date expireDate = DateUtil.addDays(produceDate, validDay);
                                barcodeFromRule.setExpireDate(expireDate);
                                barcodeManager.save(barcodeFromRule);
                            }
                        }

                        barcode = barcodeManager.save(barcodeFromRule);
                        codeBeanFromRule.setCodeStr(barcode.getBarcode());
                        codeBeanFromRule.setBarcode(barcode);
                        codeBeanFromRule.setError(null);
                    }
                }catch (ValidateException ve){
                    //档案不存在
                    codeBeanFromRule.setError("x档案 "+barcodeFromRule.getPartNumber()+" 不存在");
                    log.warn("x档案"+barcodeFromRule.getPartNumber()+"不存在");
                }
                //解析成功了,直接返回
                return codeBeanFromRule;
            }else{
                //在数据库中不存在,且未解析成功,用其他规则再解析
                codeBeanFromRule.setError(barcodeItemStr + "不是有效的条码");
            }
        }

        if(codeBeanFromRule == null){
            codeBeanFromRule = new CodeBean();
            codeBeanFromRule.setBarcode(null);
            codeBeanFromRule.setError(barcodeItemStr + "不是有效的条码");
            codeBeanFromRule.setCodeStr(barcodeItemStr);
            return codeBeanFromRule;
        }
        return codeBeanFromRule;
    }

    public Collection<CodeBean> resolveCodeStr(String codeStr){

        Map<String, CodeBean> codeBeanMap = Maps.newHashMap();
        if(!Strings.isNullOrEmpty(codeStr)){
            //双##号分割多个二维码
            String[] barcodeItemStrs = codeStr.split("##");

            //需要检查partNumber 是否一致
            Multiset<String> partNumberMultiset = HashMultiset.create();
            //含有最多的 partNumber
            String mostPartNumber = "";

            List<CodeBean> codeBeans = Lists.newArrayList();
            for (String barcodeItemStr : barcodeItemStrs){
                CodeBean codeBean = resolveSingleCode(barcodeItemStr);
                if(codeBean == null){
                    continue;
                }
                codeBeans.add(codeBean);
                //统计非夹具的 partNubmer
                if(codeBean.isValid() && !codeBean.isFixtureCode()){
                    String partNumber = codeBean.getBarcode().getPartNumber();
                    partNumberMultiset.add(partNumber);
                    if(partNumberMultiset.count(partNumber) > partNumberMultiset.count(mostPartNumber) ){
                        mostPartNumber = partNumber;
                    }
                }
            }

            for (CodeBean codeBean : codeBeans) {
                if(codeBean.isValid() && !codeBean.isFixtureCode()){
                    //非夹具的 partNumber 不一致
                    if(!mostPartNumber.equals(codeBean.getBarcode().getPartNumber())){
                        codeBean.setError("PartNumber不一致");
                    }
                }
                codeBeanMap.put(codeBean.getCodeStr(), codeBean);
            }
        }
        return codeBeanMap.values();
    }

    /**
     * 出库方式
     */
    public StorageConstants.CHECKOUT_TYPE getCheckOutType(){
        String outType = getSettings().getOutType();
        return StorageConstants.CHECKOUT_TYPE.valueOf(outType);
    }

    public Settings updateSettings(Settings newSetting){
        settings = settingsDao.save(newSetting);
        List<String> ruleItems = settings.getCodeRuleList();
        barcodeRuleList = Lists.newArrayList();
        for(String codeRule : ruleItems){
            if(!Strings.isNullOrEmpty(codeRule)){
                barcodeRuleList.add(BarcodeRule.newRule(codeRule));
            }
        }
        needUpdateHumidityMap = new ConcurrentHashMap<>();
        return settings;
    }

    public List<String> getCids(){
        List<String> cids = new ArrayList<>();
        for (Storage storage : getAllStorage().values()){
            cids.add(storage.getCid());
        }
        return cids;
    }

    public Storage defaultStorage(){
        Map<String, Storage> storages = getAllStorage();
        for (Storage storage : storages.values()){
            if(!storage.isVirtual()){
                return storage;
            }
        }
        return null;
    }

    public String defaultStorageCid(){
        Storage storage = defaultStorage();
        if(storage != null){
            return storage.getCid();
        }
        return "";
    }

    /**
     * 获取某个区域默认的虚拟仓
     */
    public Storage defaultVirtualStorage(String areaId){
        Map<String, Storage> storages = getAllStorage();
        for (Storage storage : storages.values()){
            return storage;
        }
        return null;
    }


    /**
     * 库存 map, key 为 cid,value 为料盘存量 map(key为 PartNumber,value 为 库存数量及盘数的Bean)
     */
    private static Map<String,Map<String,InventoryItem>> inventoryMap = new ConcurrentHashMap<>();



    /**
     * 所有的料仓 key 为 cid, value 为 Storage
     */
    private static Map<String, Storage> allStorage = new ConcurrentHashMap<>();


    /**
     * 某个区域需要进行清理呆滞物料的所有料仓（虚拟仓应该不需要清理的）
     */
    public List<String> needClearInactionStorageIds(){
        Collection<Storage> allStorage = getAllStorage().values();
        List<String> storageIds = Lists.newArrayList();
        for (Storage storage : allStorage){
            //if(storage.isLine() && storage.getAreaId().equals(areaId)){
                storageIds.add(storage.getId());
            //}
        }
        return storageIds;
    }

    public Map<String, Storage> getAllStorage(){
        if(allStorage.isEmpty()){
            synchronized (allStorage){
                if(allStorage.isEmpty()){
                    List<Storage> all = storageManager.findAll();
                    if(all != null){
                        Map<String, Storage> map = new ConcurrentHashMap<>();
                        for(Storage storage : all){
                            List<PLATE_SIZE> plateSizes = storagePosManager.distinctPlateSize(storage.getId());
                            storage.setPlateSizes(plateSizes);
                            map.put(storage.getCid(), storage);
                        }
                        allStorage = map;
                        log.info("加载所有料仓["+all.size()+"]信息到缓存");
                    }
                }
            }
        }
        return allStorage;
    }


    /**
     * 获取某区域可以放入该尺寸料盘的所有料仓名称
     */
    public List<String> getCanPutInStorages(String areaId, int w, int h){
        List<String> storageList = Lists.newArrayList();
        for(Storage storage : getAllStorage().values()){
            storageList.add(storage.getName());
        }
        return storageList;
    }

    /**
     * 根据 cid 获取料仓信息
     */
    public Storage getStorage(String cid){
        if(Strings.isNullOrEmpty(cid)){
            return null;
        }
        return getAllStorage().get(cid);
    }

    /**
     * 根据 Id 获取料仓信息
     */
    public Storage getStorageById(String storageId){
        for(Storage storage : getAllStorage().values()){
            if(storage.getId().equals(storageId)){
                return storage;
            }
        }
        return null;
    }

    /**
     * 更新料仓信息
     */
    public Storage updateStorage(String cid) throws ValidateException {
        Storage storage = getStorage(cid);
        return updateStorage(storage);
    }

    /**
     * 更新料仓信息
     */
    public Storage updateStorage(Storage storage) throws ValidateException {
        storage.setTotalSlots(storagePosManager.countTotalStorageSize(storage.getId()));
        storage.setEmptySlots(storagePosManager.countEmptyStorageSize(storage.getId()));
        storageManager.save(storage);
        List<PLATE_SIZE> plateSizes = storagePosManager.distinctPlateSize(storage.getId());
        storage.setPlateSizes(plateSizes);
        getAllStorage().put(storage.getCid(), storage);
        return storage;
    }


    /**
     * 锁定库存
     * @param cid
     * @param partNumber 物料编号
     * @return 锁定结果,true 表示有足够的库存,锁定成功;false表示库存不足,锁定失败
     */
    public boolean lockOneReel(String cid, String partNumber){
        boolean result = false;
        InventoryItem inventoryItem = getStorageInventoryByPartNumber(cid, partNumber);
        if(inventoryItem != null) {
            int lockReel = inventoryItem.getLockReel();
            //理论上这里是同一个对象,不需要再显式的放入map 中
            result = inventoryItem.lockOne();
            log.info("锁定料仓["+cid+"]物料["+partNumber+"],锁定数量["+lockReel+"]=>["+inventoryItem.getLockReel()+"],当前库存:"+inventoryItem.getStockReel());
            updateStorageInventory(cid,inventoryItem);
        }
        return result;
    }
    /**
     * 解除锁定库存(出库任务完成或取消时调用)
     */
    public void unLockOneReel(String cid, String partNumber){
        InventoryItem partNumberInventory = getStorageInventoryByPartNumber(cid, partNumber);
        if(partNumberInventory != null) {
            int lockReel = partNumberInventory.getLockReel();
            //理论上这里是同一个对象,不需要再显式的放入map 中
            partNumberInventory.unLock(1);
            log.info("解除锁定料仓["+cid+"]物料["+partNumber+"],锁定数量["+lockReel+"]=>["+partNumberInventory.getLockReel()+"],当前库存:"+partNumberInventory.getStockReel());
            updateStorageInventory(cid,partNumberInventory);
        }
    }

    /**
     * 获取库存信息,key 为 PN
     */
    public Map<String,InventoryItem> getAllInventory(){
        Map<String,InventoryItem> allInventory = Maps.newHashMap();

        Map<String, Storage> allStorages = getAllStorage();
        for (String cid : allStorages.keySet()) {
            Map<String, InventoryItem> storageInventory = getStorageInventory(cid);
            for(InventoryItem storageInventoryItem : storageInventory.values()){
                String partNumber = storageInventoryItem.getPartNumber();
                InventoryItem pnInventoryItem = allInventory.get(storageInventoryItem.getPartNumber());
                if(pnInventoryItem == null){
                    pnInventoryItem = new InventoryItem();
                }
                pnInventoryItem.setPartNumber(partNumber);
                pnInventoryItem.setStockCount(pnInventoryItem.getStockCount() + storageInventoryItem.getStockCount());
                pnInventoryItem.setLockCount(pnInventoryItem.getLockCount() + storageInventoryItem.getLockCount());
                pnInventoryItem.setStockReel(pnInventoryItem.getStockReel() + storageInventoryItem.getStockReel());
                pnInventoryItem.setLockReel(pnInventoryItem.getLockReel() + storageInventoryItem.getLockReel());
                allInventory.put(partNumber,pnInventoryItem);
            }
        }
        return allInventory;
    }

    public Map<String, InventoryItem> getStorageInventory(String cid){
        Map<String, InventoryItem> storageInventory = inventoryMap.get(cid);
        if(storageInventory == null){
            storageInventory = initInventory(cid);
        }
        return storageInventory;
    }


    public InventoryItem getStorageInventoryByPartNumber(String cid, String partNumber){
        Map<String, InventoryItem> storageInventory = getStorageInventory(cid);
        InventoryItem  partNumberInventoryItem = storageInventory.get(partNumber);
        if(partNumberInventoryItem == null){
            partNumberInventoryItem = new InventoryItem();
            partNumberInventoryItem.setPartNumber(partNumber);
        }
        return partNumberInventoryItem;
    }

    private synchronized Map<String, InventoryItem> initInventory(String cid){
        Storage storage = getStorage(cid);
        Map<String, InventoryItem> storageInventoryMap = storagePosManager.getInventory(storage.getId());
        //未完成的 Task 也需要锁定
        List<InventoryItem>  feederLockInventories = dataLogDao.getStorageLockCount(storage.getId());

        for (InventoryItem feederInventoryItem : feederLockInventories){
            String partNumber = feederInventoryItem.getPartNumber();
            if(!Strings.isNullOrEmpty(partNumber)){
                InventoryItem inventoryItem = storageInventoryMap.get(partNumber);
                if(inventoryItem != null){
                    int lockReel = inventoryItem.getLockReel() + feederInventoryItem.getLockReel();
                    inventoryItem.setLockReel(lockReel);
                    storageInventoryMap.put(partNumber, inventoryItem);
                }
            }
        }

        log.info("初始化料仓["+cid+"]的库存信息["+storageInventoryMap.size()+"]条");
        inventoryMap.put(cid, storageInventoryMap);
        return storageInventoryMap;
    }

    /**
     * 修改库存,出库为负,入库为正
     */
    public int updateInventory(String cid, String partNumber, int amount){
        if(amount != 0){
            InventoryItem inventoryItem = getStorageInventoryByPartNumber(cid,partNumber);
            if(inventoryItem == null){
                inventoryItem = new InventoryItem();
                inventoryItem.setPartNumber(partNumber);
            }
            inventoryItem.updateInventory(amount);
            updateStorageInventory(cid, inventoryItem);
            return inventoryItem.getStockReel();
        }
        return -1;
    }

    private void updateStorageInventory(String cid, InventoryItem inventoryItem){
        Map<String, InventoryItem> storageInventory = inventoryMap.get(cid);
        storageInventory.put(inventoryItem.getPartNumber(), inventoryItem);
        inventoryMap.put(cid, storageInventory);
    }

    public Map<String,String> allBoxNameMap(){
        Map<String, String> allBoxMap = Maps.newHashMap();
        for (Storage storage : getAllStorage().values()){
            if(storage.getBoxCount() > 1){
                for (int i=1;i<=storage.getBoxCount();i++){
                    allBoxMap.put(storage.getCid()+"-"+i, storage.getName() + " BOX-" + i);
                }
            }else{
                allBoxMap.put(storage.getCid()+"-i", storage.getName());
            }
        }
        return allBoxMap;
    }

}