package com.nanometer.smartlab.service;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.*;

import javax.annotation.Resource;

import com.nanometer.smartlab.dao.OpeApplyDao;
import com.nanometer.smartlab.dao.OpeReagentStatusDao;
import com.nanometer.smartlab.entity.*;
import com.nanometer.smartlab.entity.enumtype.ValidFlag;
import com.nanometer.smartlab.exception.AlarmCode;
import com.nanometer.smartlab.exception.AlarmException;
import com.nanometer.smartlab.util.IDUtils;

import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;
import org.springframework.context.annotation.Lazy;
import org.springframework.dao.DataAccessException;
import org.springframework.dao.DataIntegrityViolationException;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import com.nanometer.smartlab.dao.BaseMetaDao;
import com.nanometer.smartlab.dao.OpeWarehouseReserveDao;
import com.nanometer.smartlab.entity.enumtype.ArrivalStatus;
import com.nanometer.smartlab.entity.enumtype.OperateStatus;
import com.nanometer.smartlab.entity.enumtype.StoreType;
import com.nanometer.smartlab.exception.BusinessException;
import com.nanometer.smartlab.exception.ExceptionEnumCode;
import com.nanometer.smartlab.util.MessageUtil;

/**
 * Created by maweiqing on 17/12/12.
 */
@Service("opeWarehouseReserveService")
public class OpeWarehouseReserveServiceImpl implements OpeWarehouseReserveService {

	private static Logger logger = Logger.getLogger(OpeWarehouseReserveService.class);

	@Resource(name = "opeWarehouseReserveDao")
	OpeWarehouseReserveDao opeWarehouseReserveDao;

	@Resource
	private OpeReagentStatusService opeReagentStatusService;

	@Lazy
    @Resource
    private OpeUseFlowService opeUseFlowService;

    @Resource(name="baseMetaDao")
    private BaseMetaDao baseMetaDao;

    @Resource(name="opeApplyDao")
	private OpeApplyDao opeApplyDao;
	@Resource
	private OpeReagentStatusDao opeReagentStatusDao;
	@Resource
	private OpeLaboratoryReserveService opeLaboratoryReserveService;

	@Transactional(propagation = Propagation.REQUIRED)
	public List<OpeWarehouseReserve> getOpeWarehouseReserveList(String reagentId, String supplierId, Integer first,
			Integer pageSize) {
		try {
			Map<String, Object> params = new HashMap<String, Object>();
			params.put("reagentId", reagentId);
			params.put("supplierId", supplierId);
			params.put("first", first);
			params.put("pageSize", pageSize);
			return this.opeWarehouseReserveDao.getOpeWarehouseReserveList(params);
		} catch (DataAccessException e) {
			logger.error(e.getMessage(), e);
			throw new BusinessException(ExceptionEnumCode.DB_ERR,
					MessageUtil.getMessageByCode(ExceptionEnumCode.DB_ERR.getCode()), e);
		}
	}

	@Transactional(propagation = Propagation.REQUIRED)
	public int getOpeWarehouseReserveTotalCount(String reagentId, String supplierId) {
		try {
			Map<String, Object> params = new HashMap<String, Object>();
			params.put("reagentId", reagentId);
			params.put("supplierId", supplierId);
			return this.opeWarehouseReserveDao.getOpeWarehouseReserveTotalCount(params);
		} catch (DataAccessException e) {
			logger.error(e.getMessage(), e);
			throw new BusinessException(ExceptionEnumCode.DB_ERR,
					MessageUtil.getMessageByCode(ExceptionEnumCode.DB_ERR.getCode()), e);
		}
	}

	@Transactional(propagation = Propagation.REQUIRED)
	public List<OpeWarehouseReserve> getOpeWarehouseReserveListByName(String reagentId, String supplierId, Integer first,
			Integer pageSize,String productSn,String warehouseName) {
		try {
			Map<String, Object> params = new HashMap<String, Object>();
			params.put("reagentName", reagentId);
			params.put("supplierId", supplierId);
			params.put("first", first);
			params.put("pageSize", pageSize);
			params.put("productSn", productSn);
			params.put("warehouseName", warehouseName);
			return this.opeWarehouseReserveDao.getOpeWarehouseReserveList(params);
		} catch (DataAccessException e) {
			logger.error(e.getMessage(), e);
			throw new BusinessException(ExceptionEnumCode.DB_ERR,
					MessageUtil.getMessageByCode(ExceptionEnumCode.DB_ERR.getCode()), e);
		}
	}

	@Transactional(propagation = Propagation.REQUIRED)
	public int getOpeWarehouseReserveTotalCountByName(String reagentId, String supplierId,String productSn,String warehouseName) {
		try {
			Map<String, Object> params = new HashMap<String, Object>();
			params.put("reagentName", reagentId);
			params.put("supplierId", supplierId);
			params.put("productSn", productSn);
			params.put("warehouseName", warehouseName);
			return this.opeWarehouseReserveDao.getOpeWarehouseReserveTotalCount(params);
		} catch (DataAccessException e) {
			logger.error(e.getMessage(), e);
			throw new BusinessException(ExceptionEnumCode.DB_ERR,
					MessageUtil.getMessageByCode(ExceptionEnumCode.DB_ERR.getCode()), e);
		}
	}

	@Transactional(propagation = Propagation.REQUIRED)
	public OpeWarehouseReserve getOpeWarehouseReserveBy(String reagentId, String articleNumber){
		OpeWarehouseReserve ope=new OpeWarehouseReserve();
		ope.setReagentId(reagentId);
		ope.setArticleNumber(articleNumber);
		return this.opeWarehouseReserveDao.getOpeWarehouseReserve(ope);
	}

	@Transactional(propagation = Propagation.REQUIRED)
	public OpeWarehouseReserve getOpeWarehouseReserve(String reagentId, String articleNumber) {
		try {
			Map<String, Object> params = new HashMap<String, Object>();
			params.put("reagentId", reagentId);
			params.put("articleNumber", articleNumber);
			List<OpeWarehouseReserve> list = this.opeWarehouseReserveDao.getOpeWarehouseReserveList(params);
			if (list != null && list.size() > 0) {
				return list.get(0);
			}

			return null;
		} catch (DataAccessException e) {
			logger.error(e.getMessage(), e);
			throw new BusinessException(ExceptionEnumCode.DB_ERR,
					MessageUtil.getMessageByCode(ExceptionEnumCode.DB_ERR.getCode()), e);
		}
	}
	@Transactional(propagation = Propagation.REQUIRED)
	public OpeWarehouseReserve getOpeWarehouseReserve2(String reagentId, String articleNumber,String warehouseId) {
		try {
			Map<String, Object> params = new HashMap<String, Object>();
			params.put("reagentId", reagentId);
			params.put("articleNumber", articleNumber);
			params.put("warehouseId", warehouseId);
			List<OpeWarehouseReserve> list = this.opeWarehouseReserveDao.getOpeWarehouseReserveList(params);
			if (list != null && list.size() > 0) {
				return list.get(0);
			}

			return null;
		} catch (DataAccessException e) {
			logger.error(e.getMessage(), e);
			throw new BusinessException(ExceptionEnumCode.DB_ERR,
					MessageUtil.getMessageByCode(ExceptionEnumCode.DB_ERR.getCode()), e);
		}
	}

	@Override
	public List<OpeWarehouseReserve> getOpeWarehouseReserveList(String reagentId, String articleNumber,String warehouseId) {
		Map<String, String> params = new HashMap<>();
		params.put("reagentId", reagentId);
		params.put("warehouseId", warehouseId);
		params.put("articleNumber", articleNumber);

		return this.opeWarehouseReserveDao.getOpeWarehouseReserveList2(params);
	}

	@Transactional(propagation = Propagation.REQUIRED)
	public OpeWarehouseReserve insertOpeWarehouseReserve(OpeWarehouseReserve opeWarehouseReserve) {
		try {
			if (opeWarehouseReserve.getId() == null) {
				opeWarehouseReserve.setId(IDUtils.uuid());
			}
			this.opeWarehouseReserveDao.insertOpeWarehouseReserve(opeWarehouseReserve);
			return opeWarehouseReserve;
		} catch (DuplicateKeyException ex) {
			logger.warn(ex.getMessage(), ex);
			throw new AlarmException(AlarmCode.DATA_DUPLICATE,
					MessageUtil.getMessage(AlarmCode.DATA_DUPLICATE.getCode()));
		} catch (DataIntegrityViolationException ex) {
			logger.warn(ex.getMessage(), ex);
			throw new AlarmException(AlarmCode.DATA_CONFICT, MessageUtil.getMessage(AlarmCode.DATA_CONFICT.getCode()));
		} catch (DataAccessException ex) {
			logger.error(ex.getMessage(), ex);
			throw new BusinessException(ExceptionEnumCode.DB_ERR,
					MessageUtil.getMessageByCode(ExceptionEnumCode.DB_ERR.getCode()), ex);
		}
	}

	@Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
	public boolean updateOpeWarehouseReserve(OpeWarehouseReserve opeWarehouseReserve) {
		try {
			int row = this.opeWarehouseReserveDao.updateOpeWarehouseReserve(opeWarehouseReserve);

			return row != 0;
		} catch (DuplicateKeyException ex) {
			logger.warn(ex.getMessage(), ex);
			throw new AlarmException(AlarmCode.DATA_DUPLICATE,
					MessageUtil.getMessage(AlarmCode.DATA_DUPLICATE.getCode()));
		} catch (DataIntegrityViolationException ex) {
			logger.warn(ex.getMessage(), ex);
			throw new AlarmException(AlarmCode.DATA_CONFICT, MessageUtil.getMessage(AlarmCode.DATA_CONFICT.getCode()));
		} catch (DataAccessException ex) {
			logger.error(ex.getMessage(), ex);
			throw new BusinessException(ExceptionEnumCode.DB_ERR,
					MessageUtil.getMessageByCode(ExceptionEnumCode.DB_ERR.getCode()), ex);
		}
	}

	@Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
	public void claimForPerson(List<OpeApplyReserve> selectedListForPerson,String userId,String projectNum,String laboratoryId,String laboratoryContainerId){
		try{
			for(OpeApplyReserve app:selectedListForPerson){
				List<String> reagentCodes = app.getReagentCode();
				if (reagentCodes != null && reagentCodes.size() > 0) {
					this.opeReagentStatusService.updateReagentStatus3(reagentCodes,userId,projectNum,laboratoryId,laboratoryContainerId);

					//更新是现实库存
					OpeLaboratoryReserve lr=new OpeLaboratoryReserve();
					lr.setReagentId(app.getReagent().getId());
					lr.setHouseId(laboratoryId);
					lr.setContainerId(laboratoryContainerId);
					lr.setReserve(app.getSelectNum());
					lr.setUserId(userId);
					lr.setValidFlag(ValidFlag.VALID);
					this.opeLaboratoryReserveService.insert(lr);
					/*HashSet<String> set=new HashSet<>();//存放批号
					for(int i=0;i<ss.size();i++){
						set.add(ss.get(i).getArticleNumber());
					}
					for(String string: set){
						int count=0;//相同批号出现的次数
						String reid="";
						for(int j=0;j<ss.size();j++){
							if(string.equals(ss.get(j).getArticleNumber())){
								count++;
								reid=ss.get(j).getReagentId();
							}
						}
						OpeWarehouseReserve wa=opeWarehouseReserveService.getOpeWarehouseReserveBy(reid,string);
						System.out.println("原库存="+wa.getReserve());
						System.out.println("领用数量="+count);
						wa.setReserve(wa.getReserve()-count);
						opeWarehouseReserveDao.updateOpeWarehouseReserve(wa);
					}*/
				}
				//OpeWarehouseReserve wa=opeWarehouseReserveService.getOpeWarehouseReserveBy(app.getReagent().getId(),app.getArticleNumber());
				OpeApplyReserve re=new OpeApplyReserve();
				re.setUsed(app.getSelectNum()+app.getUsed());
				re.setId(app.getId());
				//System.out.println(wa.getReserve());
				//wa.setReserve(wa.getReserve()-app.getSelectNum());
				opeApplyDao.updateOpeApplyUsed(re);//修改已领数量
				//opeWarehouseReserveDao.updateOpeWarehouseReserve(wa);
			}

		} catch (DuplicateKeyException ex) {
			logger.warn(ex.getMessage(), ex);
			throw new AlarmException(AlarmCode.DATA_DUPLICATE,
					MessageUtil.getMessage(AlarmCode.DATA_DUPLICATE.getCode()));
		} catch (DataIntegrityViolationException ex) {
			logger.warn(ex.getMessage(), ex);
			throw new AlarmException(AlarmCode.DATA_CONFICT, MessageUtil.getMessage(AlarmCode.DATA_CONFICT.getCode()));
		} catch (DataAccessException ex) {
			logger.error(ex.getMessage(), ex);
			throw new BusinessException(ExceptionEnumCode.DB_ERR,
					MessageUtil.getMessageByCode(ExceptionEnumCode.DB_ERR.getCode()), ex);
		}catch(Exception e){
			e.printStackTrace();
			throw new RuntimeException(e);
		}
	}

	// 仓库领用
	@Transactional(propagation = Propagation.REQUIRED)
	public void claim(List<OpeWarehouseReserve> selectedList, String userId,String projectNum) {
		try {
			for (OpeWarehouseReserve opeWarehouseReserve : selectedList) {
				List<String> reagentCodes = opeWarehouseReserve.getReagentCodes();
				if (reagentCodes != null && reagentCodes.size() > 0) {
					for (String opeReagentStatusId : reagentCodes) {
						OpeReagentStatus opeReagentStatus = this.opeReagentStatusService
								.getOpeReagentStatus(opeReagentStatusId);
						opeReagentStatus.setUserId(userId);
						opeReagentStatus.setProjectNum(projectNum);
						//boolean flag = this.opeReagentStatusService.updateReagentStatus(opeReagentStatus);
						this.opeReagentStatusService.updateReagentStatus(opeReagentStatus);
						//if (flag) {
							//opeWarehouseReserve.setReserve(opeWarehouseReserve.getReserve() - 1);
							//opeWarehouseReserve.setSelectNum(0);
						//}
					}
				}
				opeWarehouseReserve.setReserve(opeWarehouseReserve.getReserve()-opeWarehouseReserve.getSelectNum());
				opeWarehouseReserveDao.updateOpeWarehouseReserve(opeWarehouseReserve);
			}
		} catch (DuplicateKeyException ex) {
			logger.warn(ex.getMessage(), ex);
			throw new AlarmException(AlarmCode.DATA_DUPLICATE,
					MessageUtil.getMessage(AlarmCode.DATA_DUPLICATE.getCode()));
		} catch (DataIntegrityViolationException ex) {
			logger.warn(ex.getMessage(), ex);
			throw new AlarmException(AlarmCode.DATA_CONFICT, MessageUtil.getMessage(AlarmCode.DATA_CONFICT.getCode()));
		} catch (DataAccessException ex) {
			logger.error(ex.getMessage(), ex);
			throw new BusinessException(ExceptionEnumCode.DB_ERR,
					MessageUtil.getMessageByCode(ExceptionEnumCode.DB_ERR.getCode()), ex);
		}
	}

	public void reagentDStore2(List<OpeApply> reagentDStoreList, String loginUserId){
		if (reagentDStoreList == null) {
			return;
		}
		OpeReagentStatus opeReagentStatus = null;
		BigInteger startReagentCode = null;
		BigInteger endReagentCode = null;
		String reagentCode = null;
		OpeWarehouseReserve opeWarehouseReserve = null;
		OpeUseFlow opeUseFlow = null;
		for (OpeApply opeApply : reagentDStoreList) {
			startReagentCode = new BigInteger(opeApply.getStartReagentCode());
			endReagentCode = new BigInteger(opeApply.getEndReagentCode());

			// 条形码可能以0开头，所以需要补0
			int len = opeApply.getStartReagentCode().length() - String.valueOf(startReagentCode).length();
			/*System.out.println("aaaaaaaaaa="+opeApply.getStartReagentCode());
			System.out.println("bbbbbbbbbb="+String.valueOf(startReagentCode));
			if(1==1){
				return;
			}*/
			String temp = "";
			for (int i = 0; i < len; i++) {
				temp += "0";
			}
 			for (BigInteger i = startReagentCode; i.compareTo(endReagentCode) < 1; i = i.add(BigInteger.ONE)) {
				reagentCode = temp + String.valueOf(i);
				if (this.opeReagentStatusService.isOpeReagentStatusExist(reagentCode)) {//条码存在
					//throw new BusinessException(ExceptionEnumCode.REAGENT_CODE_EXIST, "入库试剂：" + opeApply.getReagent().getName() + "的试剂条形码[" + reagentCode + "]已存在。");
					// 试剂最新状态update
					opeReagentStatus=this.opeReagentStatusService.getOpeReagentStatusByReagentCode(reagentCode);
					//opeReagentStatus = new OpeReagentStatus();
					//opeReagentStatus.setId(id);
					//opeReagentStatus.setReagentId(opeApply.getReagent().getId());
					opeReagentStatus.setArticleNumber(opeApply.getArticleNumber());
					opeReagentStatus.setReagentCode(reagentCode);
					opeReagentStatus.setStatus(ArrivalStatus.NOREGISTER);
					opeReagentStatus.setHouseId(opeApply.getHouseId());
					opeReagentStatus.setContainerId(opeApply.getContainerId());
					opeReagentStatus.setUserId(loginUserId);
					//opeReagentStatus.setPlace(opeApply.getPlaceId());
					//opeReagentStatus.setRemainder(opeApply.getReagent().getMainMetering()!=null?(new BigDecimal(opeApply.getReagent().getMainMetering())):new BigDecimal(0));
					//opeReagentStatus.setStoreType(StoreType.DIRECTSTORE);
					this.opeReagentStatusService.updateReagentStatus2(opeReagentStatus);

					// 试剂使用情况领用insert
					/*OpeUseFlow ouf=new OpeUseFlow();
					ouf.setReagentCode(opeReagentStatus.getReagentCode());
					ouf.setStatus(opeReagentStatus.getStatus());
					ouf.setHouseId(opeReagentStatus.getHouseId());
					ouf.setContainerId(opeReagentStatus.getContainerId());
					ouf.setUserId(opeReagentStatus.getUserId());
					ouf.setPlace(opeReagentStatus.getPlace());
					ouf.setRemainder(opeApply.getReagent().getMainMetering()!=null?(new BigDecimal(opeApply.getReagent().getMainMetering())):new BigDecimal(0));
					ouf.setStoreType(StoreType.DIRECTSTORE);

					Map<String, String> metaMap2 = new HashMap<>();
					metaMap2.put("groupId", "operate_status");
					metaMap2.put("metaKey", String.valueOf(OperateStatus.WAREHOUSEOUT.getKey()));
					List<BaseMeta> baseMetaList2 = baseMetaDao.getBaseMetaList(metaMap2);
					ouf.setOperateState(baseMetaList2.get(0).getId());
					this.opeUseFlowService.insertOpeUseFlow(ouf);*/
				}else{//条码不存在
					// 试剂最新状态insert
					opeReagentStatus = new OpeReagentStatus();
					opeReagentStatus.setReagentId(opeApply.getReagent().getId());
					opeReagentStatus.setArticleNumber(opeApply.getArticleNumber());
					opeReagentStatus.setReagentCode(reagentCode);
					opeReagentStatus.setStatus(ArrivalStatus.NOREGISTER);
					opeReagentStatus.setHouseId(opeApply.getHouseId());
					opeReagentStatus.setContainerId(opeApply.getContainerId());
					opeReagentStatus.setUserId(loginUserId);
					//opeReagentStatus.setPlace(opeApply.getPlaceId());
					//opeReagentStatus.setRemainder(opeApply.getReagent().getMainMetering()!=null?(new BigDecimal(opeApply.getReagent().getMainMetering())):new BigDecimal(0));
					opeReagentStatus.setStoreType(StoreType.DIRECTSTORE);
					this.opeReagentStatusService.insertOpeReagentStatus(opeReagentStatus);

					// 试剂使用情况入库insert
					opeUseFlow = new OpeUseFlow();
					opeUseFlow.setReagentCode(opeReagentStatus.getReagentCode());
					opeUseFlow.setStatus(opeReagentStatus.getStatus());
					opeUseFlow.setHouseId(opeReagentStatus.getHouseId());
					opeUseFlow.setContainerId(opeReagentStatus.getContainerId());
					opeUseFlow.setUserId(opeReagentStatus.getUserId());
					opeUseFlow.setPlace(opeReagentStatus.getPlace());
					opeUseFlow.setRemainder(opeApply.getReagent().getMainMetering()!=null?opeApply.getReagent().getMainMetering():new BigDecimal(0));
					opeUseFlow.setStoreType(StoreType.DIRECTSTORE);

					Map<String, String> metaMap = new HashMap<>();
					metaMap.put("groupId", "operate_status");
					metaMap.put("metaKey", String.valueOf(OperateStatus.WAREHOUSEIN.getKey()));
					List<BaseMeta> baseMetaList = baseMetaDao.getBaseMetaList(metaMap);
					opeUseFlow.setOperateState(baseMetaList.get(0).getId());
					this.opeUseFlowService.insertOpeUseFlow(opeUseFlow);
					// 试剂使用情况领用insert
					OpeUseFlow ouf=new OpeUseFlow();
					ouf.setReagentCode(opeReagentStatus.getReagentCode());
					ouf.setStatus(opeReagentStatus.getStatus());
					ouf.setHouseId(opeReagentStatus.getHouseId());
					ouf.setContainerId(opeReagentStatus.getContainerId());
					ouf.setUserId(opeReagentStatus.getUserId());
					ouf.setPlace(opeReagentStatus.getPlace());
					ouf.setRemainder(opeApply.getReagent().getMainMetering()!=null?opeApply.getReagent().getMainMetering():new BigDecimal(0));
					ouf.setStoreType(StoreType.DIRECTSTORE);

					Map<String, String> metaMap2 = new HashMap<>();
					metaMap2.put("groupId", "operate_status");
					metaMap2.put("metaKey", String.valueOf(OperateStatus.WAREHOUSEOUT.getKey()));
					List<BaseMeta> baseMetaList2 = baseMetaDao.getBaseMetaList(metaMap2);
					ouf.setOperateState(baseMetaList2.get(0).getId());
					this.opeUseFlowService.insertOpeUseFlow(ouf);
				}
			}

		}
	}

	public void reagentDStore4(List<OpeApply> reagentDStoreList, String loginUserId){
		if (reagentDStoreList == null) {
			return;
		}
		OpeReagentStatus opeReagentStatus = null;
		for (OpeApply opeApply : reagentDStoreList) {
			List<String> codeList = opeApply.getReagentCodeList();
			for (String reagentCode:codeList) {
				if (this.opeReagentStatusService.isOpeReagentStatusExist(reagentCode)) {//条码存在
					//throw new BusinessException(ExceptionEnumCode.REAGENT_CODE_EXIST, "入库试剂：" + opeApply.getReagent().getName() + "的试剂条形码[" + reagentCode + "]已存在。");
					// 试剂最新状态update
					opeReagentStatus=this.opeReagentStatusService.getOpeReagentStatusByReagentCode(reagentCode);
					//opeReagentStatus = new OpeReagentStatus();
					//opeReagentStatus.setId(id);
					//opeReagentStatus.setReagentId(opeApply.getReagent().getId());
					opeReagentStatus.setArticleNumber(opeApply.getArticleNumber());
					opeReagentStatus.setReagentCode(reagentCode);
					opeReagentStatus.setStatus(ArrivalStatus.NOREGISTER);
					opeReagentStatus.setHouseId(opeApply.getHouseId());
					opeReagentStatus.setContainerId(opeApply.getContainerId());
					opeReagentStatus.setUserId(loginUserId);
					//opeReagentStatus.setPlace(opeApply.getPlaceId());
					//opeReagentStatus.setRemainder(opeApply.getReagent().getMainMetering()!=null?(new BigDecimal(opeApply.getReagent().getMainMetering())):new BigDecimal(0));
					//opeReagentStatus.setStoreType(StoreType.DIRECTSTORE);
					this.opeReagentStatusService.updateReagentStatus2(opeReagentStatus);

					// 试剂使用情况领用insert
					/*OpeUseFlow ouf=new OpeUseFlow();
					ouf.setReagentCode(opeReagentStatus.getReagentCode());
					ouf.setStatus(opeReagentStatus.getStatus());
					ouf.setHouseId(opeReagentStatus.getHouseId());
					ouf.setContainerId(opeReagentStatus.getContainerId());
					ouf.setUserId(opeReagentStatus.getUserId());
					ouf.setPlace(opeReagentStatus.getPlace());
					ouf.setRemainder(opeApply.getReagent().getMainMetering()!=null?(new BigDecimal(opeApply.getReagent().getMainMetering())):new BigDecimal(0));
					ouf.setStoreType(StoreType.DIRECTSTORE);

					Map<String, String> metaMap2 = new HashMap<>();
					metaMap2.put("groupId", "operate_status");
					metaMap2.put("metaKey", String.valueOf(OperateStatus.WAREHOUSEOUT.getKey()));
					List<BaseMeta> baseMetaList2 = baseMetaDao.getBaseMetaList(metaMap2);
					ouf.setOperateState(baseMetaList2.get(0).getId());
					this.opeUseFlowService.insertOpeUseFlow(ouf);*/
				}else{//条码不存在
					// 试剂最新状态insert
					opeReagentStatus = new OpeReagentStatus();
					opeReagentStatus.setReagentId(opeApply.getReagent().getId());
					opeReagentStatus.setArticleNumber(opeApply.getArticleNumber());
					opeReagentStatus.setReagentCode(reagentCode);
					opeReagentStatus.setStatus(ArrivalStatus.NOREGISTER);
					opeReagentStatus.setHouseId(opeApply.getHouseId());
					opeReagentStatus.setContainerId(opeApply.getContainerId());
					opeReagentStatus.setUserId(loginUserId);
					//opeReagentStatus.setPlace(opeApply.getPlaceId());
					//opeReagentStatus.setRemainder(opeApply.getReagent().getMainMetering()!=null?(new BigDecimal(opeApply.getReagent().getMainMetering())):new BigDecimal(0));
					opeReagentStatus.setStoreType(StoreType.DIRECTSTORE);
					this.opeReagentStatusService.insertOpeReagentStatus(opeReagentStatus);


					// 试剂使用情况领用insert
					OpeUseFlow ouf=new OpeUseFlow();
					ouf.setReagentCode(opeReagentStatus.getReagentCode());
					ouf.setStatus(opeReagentStatus.getStatus());
					ouf.setHouseId(opeReagentStatus.getHouseId());
					ouf.setContainerId(opeReagentStatus.getContainerId());
					ouf.setUserId(opeReagentStatus.getUserId());
					ouf.setPlace(opeReagentStatus.getPlace());
					ouf.setRemainder(opeApply.getReagent().getMainMetering()!=null?opeApply.getReagent().getMainMetering():new BigDecimal(0));
					ouf.setStoreType(StoreType.DIRECTSTORE);

					Map<String, String> metaMap2 = new HashMap<>();
					metaMap2.put("groupId", "operate_status");
					metaMap2.put("metaKey", String.valueOf(OperateStatus.WAREHOUSEOUT.getKey()));
					List<BaseMeta> baseMetaList2 = baseMetaDao.getBaseMetaList(metaMap2);
					ouf.setOperateState(baseMetaList2.get(0).getId());
					this.opeUseFlowService.insertOpeUseFlow(ouf);
				}
			}

		}
	}
	public void reagentDStore3(List<OpeApply> reagentDStoreList, String loginUserId){
		if (reagentDStoreList == null) {
			return;
		}
		for (OpeApply opeApply : reagentDStoreList) {

			for (String reagentCode:opeApply.getReagentCodeList()) {
				if (this.opeReagentStatusService.isOpeReagentStatusExist(reagentCode)) {
					//条码存在
					throw new BusinessException(ExceptionEnumCode.REAGENT_CODE_EXIST, "入库试剂：" + opeApply.getReagent().getName() + "的试剂条形码[" + reagentCode + "]已存在。");

				}else{
					//条码不存在
					// 试剂状态insert
					OpeReagentStatus opeReagentStatus = new OpeReagentStatus();
					opeReagentStatus.setReagentId(opeApply.getReagent().getId());
					opeReagentStatus.setArticleNumber(opeApply.getArticleNumber());
					opeReagentStatus.setReagentCode(reagentCode);
					opeReagentStatus.setStatus(ArrivalStatus.NOREGISTER);
					opeReagentStatus.setHouseId(opeApply.getHouseId());
					opeReagentStatus.setContainerId(opeApply.getContainerId());
					opeReagentStatus.setUserId(loginUserId);
					opeReagentStatus.setStoreType(StoreType.DIRECTSTORE);
					this.opeReagentStatusService.insertOpeReagentStatus(opeReagentStatus);


					// 试剂使用情况领用insert
					OpeUseFlow ouf=new OpeUseFlow();
					ouf.setReagentCode(opeReagentStatus.getReagentCode());
					ouf.setStatus(opeReagentStatus.getStatus());
					ouf.setHouseId(opeReagentStatus.getHouseId());
					ouf.setContainerId(opeReagentStatus.getContainerId());
					ouf.setUserId(opeReagentStatus.getUserId());
					ouf.setPlace(opeReagentStatus.getPlace());
					ouf.setRemainder(opeApply.getReagent().getMainMetering()!=null?opeApply.getReagent().getMainMetering():new BigDecimal(0));
					ouf.setStoreType(StoreType.DIRECTSTORE);

					Map<String, String> metaMap2 = new HashMap<>();
					metaMap2.put("groupId", "operate_status");
					metaMap2.put("metaKey", String.valueOf(OperateStatus.WAREHOUSEOUT.getKey()));
					List<BaseMeta> baseMetaList2 = baseMetaDao.getBaseMetaList(metaMap2);
					ouf.setOperateState(baseMetaList2.get(0).getId());
					this.opeUseFlowService.insertOpeUseFlow(ouf);
				}
			}

		}
	}
	@Override
	public List<OpeWarehouseReserve> selectByReId(String id) {
		return this.opeWarehouseReserveDao.selectByReId(id);
	}

	@Override
	public void updateByReId(String newReId, String oldReId) {
		Map<String, Object> params=new HashMap();
		params.put("newReId",newReId);
		params.put("oldReId",oldReId);
		this.opeWarehouseReserveDao.updateByReId(params);
	}

    @Override
	@Transactional
    public void insertOpeWarehouseReserve2(OpeApplyReserve opeApplyReserve, OpeOrder oo,String consigneeId) {

		OpeWarehouseReserve ope = this.getOpeWarehouseReserve2(opeApplyReserve.getReagent().getId(), opeApplyReserve.getArticleNumber(),opeApplyReserve.getHouseId());
		if (ope == null) {

			ope = new OpeWarehouseReserve();
			//库存为到货数量
			ope.setReserve(opeApplyReserve.getArrivalNum());
			//仓库
			ope.setWarehouseId(opeApplyReserve.getHouseId());
			//仓库的货柜号
			ope.setContainerId(opeApplyReserve.getContainerId());
			//试剂
			ope.setReagentId(opeApplyReserve.getReagent().getId());
			//订单编号
			ope.setOrderCode(oo.getOrderCode());
			// 申购编号
			ope.setApplyCode(opeApplyReserve.getApplyCode());
			//批号
			ope.setArticleNumber(opeApplyReserve.getArticleNumber());
			ope.setId(IDUtils.uuid());
			//新增收货人 保存在仓库库存表
			ope.setUserId(consigneeId);
			opeWarehouseReserveDao.insertOpeWarehouseReserve2(ope);
		}else {
			ope.setReserve(ope.getReserve() + opeApplyReserve.getArrivalNum());
			this.updateOpeWarehouseReserve(ope);
		}




    }

	@Override
	public List<OpeWarehouseReserve> selectWarehouseByReagentIdAndArticleNumber(String id,String articleNumber,boolean flag) {
		Map<String, String> params = new HashMap<>();
		params.put("reagentId", id);
		params.put("articleNumber", articleNumber);
		List<OpeWarehouseReserve> reserveList = opeWarehouseReserveDao.selectWarehouseByReagentIdAndArticleNumber(params);
		//减去 每个仓库中的试剂有条码的个数
		//count(reagent_id,warehouseId,1)
		if (reserveList.size() > 0) {
			for (OpeWarehouseReserve owr : reserveList) {
				//根据批次号 仓库名和试剂 得到在仓库有条码的试剂总数
				if (flag) {
					int numOfReagentHasCode = opeReagentStatusService.getReagentNumInWarehouse(id, articleNumber, owr.getWarehouseId());
					//仓库显示 可以补贴条码的试剂总数
					owr.setReserve(owr.getReserve()-numOfReagentHasCode);
				}
			}
		}
		return reserveList;
	}
	/**
	* 补贴扣库存去除有条码的数据
	*/
	public List<OpeWarehouseReserve> selectWarehouseByRidAndArticleNumberAndWarehouse(String id,String articleNumber,String warehouseId) {
		Map<String, String> params = new HashMap<>();
		params.put("reagentId", id);
		params.put("articleNumber", articleNumber);
		params.put("warehouseId", warehouseId);
		List<OpeWarehouseReserve> reserveList = opeWarehouseReserveDao.selectWarehouseByRidAndArtiNumberAndWid(params);
		//减去 每个仓库中的试剂有条码的个数
		//count(reagent_id,warehouseId,1)
		if (reserveList.size() > 0) {
			for (OpeWarehouseReserve owr : reserveList) {
				//根据批次号 仓库名和试剂 得到在仓库有条码的试剂总数
				int numOfReagentHasCode = opeReagentStatusService.getReagentNumInWarehouse(id, owr.getArticleNumber(), owr.getWarehouseId());
				//仓库显示 可以补贴条码的试剂总数
				owr.setReserve(owr.getReserve()-numOfReagentHasCode);
			}
		}
		return reserveList;
	}

	@Override
	public void updateBtReserve(String id, Integer useNum) {
		opeWarehouseReserveDao.updateBtReserve(id, useNum);
	}

    @Override
    public int countByReagentId(String id) {
		int num = 0;
		if (opeWarehouseReserveDao.countByReagentId(id) != null) {
			num = opeWarehouseReserveDao.countByReagentId(id);
		}
		return num;
    }

    @Override
    public OpeWarehouseReserve getRowData(String rowKey) {
        return opeWarehouseReserveDao.getRowData(rowKey);
    }

    @Override
	public void btWarehouseReserveReduce(List<OpeApplyReserve> opeList) {
		if (opeList.size() < 1) {
			return;
		}
		for (OpeApplyReserve oar : opeList) {
			String reagentId = oar.getReagent().getId();
			List<String> reagentCodes = new ArrayList<>(oar.getReagentCode());
			//开始库存扣除
			List<OpeWarehouseReserve> cacheUpdateList = oar.getCacheUpdateList();
			for (OpeWarehouseReserve owr : cacheUpdateList) {
				//1.根据仓库id和试剂id搜索不同批号的试剂库存
				List<OpeWarehouseReserve> reserveList = this
						.selectWarehouseByRidAndArticleNumberAndWarehouse(reagentId, owr.getArticleNumber(), owr.getWarehouseId());
				Integer numLeave = owr.getUseNum();

				for (OpeWarehouseReserve warehouseReserve:reserveList){
					//库存大于剩余领用-》直接扣完
					int usedNum = 0;
					if (warehouseReserve.getReserve() > numLeave) {
					//	warehouseReserve.setReserve(warehouseReserve.getReserve() - numLeave);
						usedNum = numLeave;
						numLeave = 0;
					} else {
						numLeave = numLeave - warehouseReserve.getReserve();
					//	warehouseReserve.setReserve(0);
						usedNum =  warehouseReserve.getReserve();
					}

					//更新流向，加入一条
					if (usedNum > 0) {
						for (int i = 0; i < usedNum; i++) {
							// 试剂使用情况入库insert TODO 流向需要当时的时间和地点
							OpeUseFlow opeUseFlow = new OpeUseFlow();
							opeUseFlow.setReagentCode(reagentCodes.get(0));
							opeUseFlow.setStatus(ArrivalStatus.WAREHOUSE);
							opeUseFlow.setUserId(warehouseReserve.getUserId());
							//仓库地点
							opeUseFlow.setHouseId(warehouseReserve.getWarehouseId());
							opeUseFlow.setContainerId(warehouseReserve.getContainerId());
							opeUseFlow.setRemainder(oar.getReagent().getMainMetering()!=null?oar.getReagent().getMainMetering():new BigDecimal(0));
							//入库时间
							opeUseFlow.setCreateTime(warehouseReserve.getUpdateTime());
							opeUseFlow.setStoreType(StoreType.DIRECTSTORE);

							Map<String, String> metaMap = new HashMap<>();
							metaMap.put("groupId", "operate_status");
							metaMap.put("metaKey", String.valueOf(OperateStatus.WAREHOUSEIN.getKey()));
							List<BaseMeta> baseMetaList = baseMetaDao.getBaseMetaList(metaMap);
							opeUseFlow.setOperateState(baseMetaList.get(0).getId());
							this.opeUseFlowService.insertOpeUseFlow(opeUseFlow);
							//更新试剂状态表 :批号
							opeReagentStatusDao.updateArticleNumberByRCode(reagentCodes.get(0),warehouseReserve.getArticleNumber());

							reagentCodes.remove(0);

						}

					}


					//更新库存
					this.updateBtReserve(warehouseReserve.getId(),usedNum);
					if (numLeave < 1) {
						break;
					}
			}



		}
		}
	}

	@Transactional(propagation = Propagation.REQUIRED)
	public void reagentDStore(List<OpeApply> reagentDStoreList, String loginUserId) {

		if (reagentDStoreList == null) {
            return;
        }

        OpeReagentStatus opeReagentStatus = null;
        BigInteger startReagentCode = null;
        BigInteger endReagentCode = null;
        String reagentCode = null;
        OpeWarehouseReserve opeWarehouseReserve = null;
        OpeUseFlow opeUseFlow = null;
        for (OpeApply opeApply : reagentDStoreList) {
        	//不输入条形码
        	if(opeApply.getStartReagentCode()==null ||
					opeApply.getStartReagentCode().equals("") ||
			opeApply.getEndReagentCode()==null ||
			opeApply.getEndReagentCode().equals("")){
			}else{//输入条形码

				startReagentCode = new BigInteger(opeApply.getStartReagentCode());
				endReagentCode = new BigInteger(opeApply.getEndReagentCode());

				// 条形码可能以0开头，所以需要补0
				int len = opeApply.getStartReagentCode().length() - String.valueOf(startReagentCode).length();
				String temp = "";
				for (int i = 0; i < len; i++) {
					temp += "0";
				}

				for (BigInteger i = startReagentCode; i.compareTo(endReagentCode) < 1; i = i.add(BigInteger.ONE)) {
					reagentCode = temp + String.valueOf(i);
					if (this.opeReagentStatusService.isOpeReagentStatusExist(reagentCode)) {
						throw new BusinessException(ExceptionEnumCode.REAGENT_CODE_EXIST, "入库试剂：" + opeApply.getReagent().getName() + "的试剂条形码[" + reagentCode + "]已存在。");
					}

					// 试剂最新状态insert
					opeReagentStatus = new OpeReagentStatus();
					opeReagentStatus.setReagentId(opeApply.getReagent().getId());
					opeReagentStatus.setArticleNumber(opeApply.getArticleNumber());
					opeReagentStatus.setReagentCode(reagentCode);
					opeReagentStatus.setStatus(ArrivalStatus.WAREHOUSE);
					opeReagentStatus.setHouseId(opeApply.getHouseId());
					opeReagentStatus.setContainerId(opeApply.getContainerId());
					opeReagentStatus.setUserId(loginUserId);
					opeReagentStatus.setPlace(opeApply.getPlaceId());
					opeReagentStatus.setRemainder(opeApply.getReagent().getMainMetering()!=null?(opeApply.getReagent().getMainMetering()):new BigDecimal(0));
					opeReagentStatus.setStoreType(StoreType.DIRECTSTORE);
					this.opeReagentStatusService.insertOpeReagentStatus(opeReagentStatus);

					// 试剂使用情况insert
					opeUseFlow = new OpeUseFlow();
					opeUseFlow.setReagentCode(opeReagentStatus.getReagentCode());
					opeUseFlow.setStatus(opeReagentStatus.getStatus());
					opeUseFlow.setHouseId(opeReagentStatus.getHouseId());
					opeUseFlow.setContainerId(opeReagentStatus.getContainerId());
					opeUseFlow.setUserId(opeReagentStatus.getUserId());
					opeUseFlow.setPlace(opeReagentStatus.getPlace());
					opeUseFlow.setRemainder(opeApply.getReagent().getMainMetering()!=null?(opeApply.getReagent().getMainMetering()):new BigDecimal(0));
					opeUseFlow.setStoreType(StoreType.DIRECTSTORE);

					Map<String, String> metaMap = new HashMap<>();
					metaMap.put("groupId", "operate_status");
					metaMap.put("metaKey", String.valueOf(OperateStatus.WAREHOUSEIN.getKey()));
					List<BaseMeta> baseMetaList = baseMetaDao.getBaseMetaList(metaMap);
					opeUseFlow.setOperateState(baseMetaList.get(0).getId());


					this.opeUseFlowService.insertOpeUseFlow(opeUseFlow);
				}
			}


            // 仓库库存update
            opeWarehouseReserve = this.getOpeWarehouseReserve2(opeApply.getReagent().getId(), opeApply.getArticleNumber(),opeApply.getHouseId());
            if (opeWarehouseReserve == null) {
                opeWarehouseReserve = new OpeWarehouseReserve();
                opeWarehouseReserve.setReagentId(opeApply.getReagent().getId());
                opeWarehouseReserve.setArticleNumber(opeApply.getArticleNumber());
                opeWarehouseReserve.setReserve(0);
                opeWarehouseReserve.setWarehouseId(opeApply.getHouseId());
                opeWarehouseReserve.setContainerId(opeApply.getContainerId());
                opeWarehouseReserve.setUserId(loginUserId);
            }
            opeWarehouseReserve.setReserve(opeWarehouseReserve.getReserve() + opeApply.getArrivalNum());
            if (StringUtils.isBlank(opeWarehouseReserve.getId())) {
                this.insertOpeWarehouseReserve(opeWarehouseReserve);
            } else {
                this.updateOpeWarehouseReserve(opeWarehouseReserve);
            }
        }
	}

}