package com.chinaztt.mes.warehouse.util;

import cn.hutool.core.util.BooleanUtil;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.toolkit.SqlHelper;
import com.chinaztt.mes.basic.dto.LocationIfsMoveDTO;
import com.chinaztt.mes.basic.entity.Location;
import com.chinaztt.mes.basic.entity.Part;
import com.chinaztt.mes.basic.entity.WorkstationLocation;
import com.chinaztt.mes.basic.mapper.LocationMapper;
import com.chinaztt.mes.basic.mapper.PartMapper;
import com.chinaztt.mes.basic.mapper.WorkstationLocationMapper;
import com.chinaztt.mes.basic.service.LocationService;
import com.chinaztt.mes.common.numgen.NumberGenerator;
import com.chinaztt.mes.warehouse.dto.StockAddDTO;
import com.chinaztt.mes.warehouse.dto.StockDTO;
import com.chinaztt.mes.warehouse.entity.*;
import com.chinaztt.mes.warehouse.mapper.*;
import com.chinaztt.ztt.common.core.util.R;
import com.google.common.base.Enums;
import lombok.AllArgsConstructor;
import org.apache.commons.lang3.RandomStringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import java.util.stream.Collectors;

/**
 * @Author: cxf
 * @Date: 2020/10/26 11:20
 */
@Service
@AllArgsConstructor
public class StockUtils {

	private StockMapper stockMapper;
	private LocationMapper locationMapper;
	private PartMapper partMapper;
	private TransactionMapper transactionMapper;
	private StockDetailMapper stockDetailMapper;
	private ReserveMainMapper reserveMainMapper;
	private ReserveDetailMapper reserveDetailMapper;
	private NumberGenerator<ReserveMain> numberGenerator;
	private NumberGenerator<Stock> stockNumberGenerator;
	private JoinStockOrderMapper joinStockOrderMapper;
	private WorkstationLocationMapper workstationLocationMapper;
	private LocationService locationService;

	/**
	 * 从预留中扣除库存
	 *
	 * @param id
	 * @param joInStockQuantityIncrement
	 * @return
	 * @Author xucg
	 */
	public boolean joinStockerChange(Long id, BigDecimal joInStockQuantityIncrement) {
		//根据id获取预留库存数据
		JoinStockOrder joinStockOrder = joinStockOrderMapper.selectById(id);
		//根据id获取库存数据
		Stock stock = stockMapper.selectById(joinStockOrder.getStockId());
		if (joInStockQuantityIncrement != null && joInStockQuantityIncrement.compareTo(BigDecimal.ZERO) != 0) {
			// 预留库存扣除预留数量
			joinStockOrder.setReservedQuantity(joinStockOrder.getReservedQuantity().subtract(joInStockQuantityIncrement));
			// 扣除库存接口的总数量和预留库存数量
			stock.setStockQuantity(stock.getStockQuantity().subtract(joInStockQuantityIncrement));
			stock.setReserveQuantity(stock.getReserveQuantity().subtract(joInStockQuantityIncrement));
		}
		// 判断预留库存数值大于等于0
		if (stock.getReserveQuantity().compareTo(BigDecimal.ZERO) == -1) {
			throw new RuntimeException("预留库存不够");
		}
		// 预留 < 0  抛出异常
		if (joinStockOrder.getReservedQuantity().compareTo(BigDecimal.ZERO) == -1) {
			throw new RuntimeException("预留库存不够");
		}
		// 预留 == 0  删除预留数据
		if (joinStockOrder.getReservedQuantity().compareTo(BigDecimal.ZERO) == 0) {
			joinStockOrderMapper.deleteById(joinStockOrder);
		}
		// 预留 > 0  更新预留数据
		if (joinStockOrder.getReservedQuantity().compareTo(BigDecimal.ZERO) == 1) {
			joinStockOrderMapper.updateById(joinStockOrder);
		}
		return SqlHelper.retBool(stockMapper.updateById(stock));
	}

	/**
	 * @param stockId          库存id
	 * @param workStationId    工作站id
	 * @param suppliedQuantity 投入数量
	 * @return
	 */
	public boolean feeding(Long stockId, Long workStationId, BigDecimal suppliedQuantity, String billNo,String source) {
		Stock stock = stockMapper.selectById(stockId);

		List<WorkstationLocation> locationList = workstationLocationMapper.selectList(Wrappers.<WorkstationLocation>lambdaQuery()
				.eq(WorkstationLocation::getWorkstationId, workStationId)
				.eq(WorkstationLocation::getLocationType, WorkstationLocation.FED_LOCATION));
		if (CollectionUtils.isEmpty(locationList)) {
			throw new RuntimeException("缺少已投料库位");
		}
		Location location = locationMapper.selectById(locationList.get(0).getLocationId());
		Stock newStock = null;
		if ("erp".equals(source)){
			newStock = stockMapper.selectOne(Wrappers.<Stock>lambdaQuery()
					.eq(Stock::getPartBatchNo, stock.getPartBatchNo())
					.eq(Stock::getLocationId, location.getId()));
		}else {
			newStock = stockMapper.selectOne(Wrappers.<Stock>lambdaQuery()
					.eq(Stock::getPartBatchNo, stock.getPartBatchNo())
//					.eq(Stock::getSystemNo, stock.getSystemNo())
//					.eq(Stock::getIfsBatchNo, stock.getIfsBatchNo())
					.eq(Stock::getLocationId, location.getId()));
		}
		if (null == newStock) {
			createTransaction(BigDecimal.ZERO, suppliedQuantity, stock.getPartId(), location.getId(),
					stock.getPartBatchNo(), billNo, TransactionType.PRODUCT_FEEDING.getValue(), stock.getIfsBatchNo());
			newStock = new Stock();
			newStock.setPartId(stock.getPartId());
			newStock.setSystemNo(stock.getSystemNo());
			newStock.setPartBatchNo(stock.getPartBatchNo());
			newStock.setIfsBatchNo(stock.getIfsBatchNo());
			newStock.setReelNumber(stock.getReelNumber());
			newStock.setLocationId(location.getId());
			newStock.setStockQuantity(suppliedQuantity);
			newStock.setReserveQuantity(BigDecimal.ZERO);
			newStock.setAvailableStockQuantity(suppliedQuantity);
			newStock.setOperationStockStatus(stock.getOperationStockStatus());
			newStock.setCustomerOrderNo(stock.getCustomerOrderNo());
			newStock.setMpsNo(stock.getMpsNo());
			newStock.setOuterColor(stock.getOuterColor());
			newStock.setInsulationColor(stock.getInsulationColor());
			newStock.setIfsMoveNo(stock.getIfsMoveNo());
			stockMapper.insert(newStock);
		} else {
			createTransaction(newStock.getStockQuantity(), suppliedQuantity, newStock.getPartId(),
					newStock.getLocationId(), newStock.getPartBatchNo(), billNo,
					TransactionType.PRODUCT_FEEDING.getValue(), newStock.getIfsBatchNo());
			newStock.setStockQuantity(newStock.getStockQuantity().add(suppliedQuantity));
			newStock.setAvailableStockQuantity(newStock.getAvailableStockQuantity().add(suppliedQuantity));
			stockMapper.updateById(newStock);
		}
		return true;
	}


	public boolean erpFeeding(String partBatch, Long workStationId, BigDecimal suppliedQuantity, String billNo,Part part) {

		List<WorkstationLocation> locationList = workstationLocationMapper.selectList(Wrappers.<WorkstationLocation>lambdaQuery()
				.eq(WorkstationLocation::getWorkstationId, workStationId)
				.eq(WorkstationLocation::getLocationType, WorkstationLocation.FED_LOCATION));
		if (CollectionUtils.isEmpty(locationList)) {
			throw new RuntimeException("缺少已投料库位");
		}
		Location location = locationMapper.selectById(locationList.get(0).getLocationId());
		Stock newStock = stockMapper.selectOne(Wrappers.<Stock>lambdaQuery()
					.eq(Stock::getPartBatchNo, partBatch)
					.eq(Stock::getLocationId, location.getId()
					)
		);

		if (null == newStock) {
			createTransaction(BigDecimal.ZERO, suppliedQuantity, part.getId(), location.getId(),
					partBatch, billNo, TransactionType.PRODUCT_FEEDING.getValue(), null);
			newStock = new Stock();
			newStock.setPartId(part.getId());

			newStock.setPartBatchNo(partBatch);

			newStock.setLocationId(location.getId());
			newStock.setStockQuantity(suppliedQuantity);
			newStock.setReserveQuantity(BigDecimal.ZERO);
			newStock.setAvailableStockQuantity(suppliedQuantity);

//			newStock.setCustomerOrderNo(stock.getCustomerOrderNo());
			stockMapper.insert(newStock);
		} else {
			createTransaction(newStock.getStockQuantity(), suppliedQuantity, newStock.getPartId(),
					newStock.getLocationId(), newStock.getPartBatchNo(), billNo,
					TransactionType.PRODUCT_FEEDING.getValue(), newStock.getIfsBatchNo());
			newStock.setStockQuantity(newStock.getStockQuantity().add(suppliedQuantity));
			newStock.setAvailableStockQuantity(newStock.getAvailableStockQuantity().add(suppliedQuantity));
			stockMapper.updateById(newStock);
		}
		return true;
	}

	/**
	 * @param workstationId    工作站id
	 * @param returnQuantity   退料数量
	 * @param partId           零件id
	 * @param partBatchNo      零件sn号码
	 * @param SystemNo         systemNo
	 * @param id               stock的id
	 * @param returnLocationId
	 * @return
	 */
	public boolean rejectFeeding(Long workstationId, BigDecimal returnQuantity, Long partId, String partBatchNo, String SystemNo, Long id, Long returnLocationId) {
		String billNo = RandomStringUtils.random(10, true, true);
		//退库
		Stock returnStock = stockMapper.selectById(id);
		//判断库存是否允许退库
		if (returnQuantity.compareTo(returnStock.getStockQuantity()) > 0) {
			throw new RuntimeException("退料数量大用库存数量");
		}
		if (null == returnLocationId) {
			throw new RuntimeException("缺少退料库位");
		}
		//查询是否存在线边仓
		//List<Location> locationList = locationMapper.getLocationByWorkstationId(workstationId, WorkstationLocation.FEED_LOCATION);
		//if (CollectionUtils.isEmpty(locationList)) {
		//	throw new RuntimeException("缺少线边仓");
		//}
		Location location = locationMapper.selectById(returnLocationId);

		//查询线边仓是否有库存
		Stock stock = stockMapper.selectOne(Wrappers.<Stock>lambdaQuery()
				.eq(Stock::getLocationId, location.getId())
				.eq(Stock::getPartId, partId)
				.eq(Stock::getPartBatchNo, partBatchNo)
				.eq(Stock::getSystemNo, SystemNo));
		//如果不存在就新增 存在就在现编仓库存上加上去
		if (stock == null) {
			createTransaction(BigDecimal.ZERO, returnQuantity, partId, location.getId(), partBatchNo, billNo,
					TransactionType.PRODUCT_CANCEL.getValue(), returnStock.getIfsBatchNo());
			stock = new Stock();
			stock.setPartId(partId);
			stock.setSystemNo(SystemNo);
			stock.setPartBatchNo(partBatchNo);
			//stock.setIfsBatchNo(partBatchNo);//严重bug，会导致ifs批次号双边系统不一致
			stock.setIfsBatchNo(returnStock.getIfsBatchNo());
			stock.setLocationId(location.getId());
			stock.setStockQuantity(returnQuantity);
			stock.setReserveQuantity(BigDecimal.ZERO);
			stock.setAvailableStockQuantity(returnQuantity);
			stock.setOperationStockStatus(returnStock.getOperationStockStatus());
			stock.setCustomerOrderNo(returnStock.getCustomerOrderNo());
			stock.setMpsNo(returnStock.getMpsNo());
			stock.setReelNumber(returnStock.getReelNumber());
			stockMapper.insert(stock);
		} else {
			createTransaction(stock.getStockQuantity(), returnQuantity, stock.getPartId(), stock.getLocationId(),
					stock.getPartBatchNo(), billNo, TransactionType.PRODUCT_CANCEL.getValue(), returnStock.getIfsBatchNo());
			stock.setStockQuantity(stock.getStockQuantity().add(returnQuantity));
			stock.setAvailableStockQuantity(stock.getAvailableStockQuantity().add(returnQuantity));
			stockMapper.updateById(stock);
		}
		//减去库存
		createTransaction(returnStock.getStockQuantity(), returnQuantity.negate(), returnStock.getPartId(),
				returnStock.getLocationId(), returnStock.getPartBatchNo(), billNo,
				TransactionType.PRODUCT_CANCEL.getValue(), returnStock.getIfsBatchNo());
		returnStock.setStockQuantity(returnStock.getStockQuantity().add(returnQuantity.negate()));
		returnStock.setAvailableStockQuantity(returnStock.getAvailableStockQuantity().add(returnQuantity.negate()));
		stockMapper.updateById(returnStock);
		return true;
	}

	/**
	 * @param id
	 * @param stockQuantityIncrement    库存数量
	 * @param reserveQuantityIncrement  库存预留数量
	 * @param sstockQuantityIncrement   库存数量2
	 * @param sreserveQuantityIncrement 库存预留数量2
	 * @param billNo
	 * @param billType
	 * @return
	 */
	public boolean updateById(Long id, BigDecimal stockQuantityIncrement, BigDecimal reserveQuantityIncrement,
							  BigDecimal sstockQuantityIncrement, BigDecimal sreserveQuantityIncrement, String billNo, String billType) {
		synchronized (String.valueOf(id).intern()) {

			Stock stock = stockMapper.selectById(id);
			BigDecimal beforeQuantity = stock.getStockQuantity();
			// 1.更新库存数量
			if (stockQuantityIncrement != null && stockQuantityIncrement.compareTo(BigDecimal.ZERO) != 0) {
				stock.setStockQuantity(stock.getStockQuantity().add(stockQuantityIncrement));//库存数量
				stock.setAvailableStockQuantity(stock.getAvailableStockQuantity().add(stockQuantityIncrement));//可用库存数量
			}
			// 2.更新预留数量
			if (reserveQuantityIncrement != null && reserveQuantityIncrement.compareTo(BigDecimal.ZERO) != 0) {
				stock.setReserveQuantity(stock.getReserveQuantity().add(reserveQuantityIncrement));//预留数量
				stock.setAvailableStockQuantity(stock.getAvailableStockQuantity().subtract(reserveQuantityIncrement));//可用库存数量
			}
			// 1.更新库存数量2
			if (sstockQuantityIncrement != null && sstockQuantityIncrement.compareTo(BigDecimal.ZERO) != 0) {
				stock.setSStockQuantity(stock.getSStockQuantity().add(sstockQuantityIncrement));//库存数量
				stock.setSAvailableStockQuantity(stock.getSAvailableStockQuantity().add(sstockQuantityIncrement));//可用库存数量
			}
			// 2.更新预留数量2
			if (sreserveQuantityIncrement != null && sreserveQuantityIncrement.compareTo(BigDecimal.ZERO) != 0) {
				stock.setSReserveQuantity(stock.getSReserveQuantity().add(sreserveQuantityIncrement));//预留数量
				stock.setSAvailableStockQuantity(stock.getSAvailableStockQuantity().subtract(sreserveQuantityIncrement));//可用库存数量
			}
			// 判断预留库存数值大于等于0
			if (stock.getReserveQuantity().compareTo(BigDecimal.ZERO) == -1) {
				throw new RuntimeException("预留库存不够");
			}
			// 判断可用库存数值大于等于0
			if (stock.getAvailableStockQuantity().compareTo(BigDecimal.ZERO) == -1) {
				throw new RuntimeException("可用库存不够,当前可用库存:" + stock.getAvailableStockQuantity());
			}
			// 判断预留库存数值大于等于0
			if (stock.getSReserveQuantity().compareTo(BigDecimal.ZERO) == -1) {
				throw new RuntimeException("预留库存2不够");
			}
			// 判断可用库存数值大于等于0
			if (stock.getSAvailableStockQuantity().compareTo(BigDecimal.ZERO) == -1) {
				throw new RuntimeException("可用库存2不够");
			}
			addReserveDetail(stock);
			createTransaction(beforeQuantity, stockQuantityIncrement, stock.getPartId(), stock.getLocationId(),
					stock.getPartBatchNo(), billNo, billType, stock.getIfsBatchNo());
			return SqlHelper.retBool(stockMapper.updateById(stock));
		}
	}

	/**
	 * 生成领料单
	 *
	 * @param stock
	 */
	private void addReserveDetail(Stock stock) {
		//如果可用库存的数量低于安全库存，触发材料申请自动生成领料单
		StockDetail stockDetail = stockDetailMapper.selectOne(Wrappers.<StockDetail>lambdaQuery().eq(StockDetail::getPartId
				, stock.getPartId()).eq(StockDetail::getSafetyStockId, stock.getLocationId()));
		if (stockDetail != null) {
			if (stockDetail.getLowQty().compareTo(stock.getAvailableStockQuantity()) != -1) {
				ReserveMain reserveMain = new ReserveMain();
				reserveMain.setResType((long) 34);
				reserveMain.setResStatus("05create");
				reserveMain.setResNo(numberGenerator.generateNumberWithPrefix(ReserveMain.DIGIT, ReserveMain.PREFIX
						, ReserveMain::getResNo));
				reserveMain.setResDate(LocalDateTime.now());
				reserveMainMapper.insert(reserveMain);
				ReserveDetail reserveDetail = new ReserveDetail();
				reserveDetail.setWarehouseMainId(reserveMain.getId());
				reserveDetail.setResQty((stockDetail.getHighQty().subtract(stockDetail.getLowQty()))
						.divide(stockDetail.getBatchQty(), 2));
				reserveDetail.setPartId(stock.getPartId());
				reserveDetail.setLocationId(stock.getLocationId());
				reserveDetail.setStatus("未下发");
				reserveDetailMapper.insert(reserveDetail);
			}
		}
	}

	/**
	 * 新增实时库存
	 *
	 * @return
	 */
	public synchronized Stock query(StockAddDTO stockAdd) {
		Part part = partMapper.selectById(stockAdd.getPartsId());
		if (part != null && part.getUseSystemNo()) {
			// 零件启用系统编号
			if (StringUtils.isBlank(stockAdd.getNewPartBatchNo())) {
				stockAdd.setNewPartBatchNo("*");
			}
			if (StringUtils.isBlank(stockAdd.getNewSystemNo())) {
				stockAdd.setNewSystemNo(stockNumberGenerator.generateNumberWithPrefix(Stock.DIGIT, Stock.PREFIX, Stock::getSystemNo));
			}
		} else {
			// 零件不启用系统编号
			stockAdd.setNewPartBatchNo("*");
			stockAdd.setNewSystemNo("*");
		}
		Stock stock = stockMapper.selectOne(Wrappers.<Stock>lambdaQuery()
				.eq(Stock::getPartId, stockAdd.getPartsId())
				.eq(Stock::getLocationId, stockAdd.getNewLocationId())
				.eq(Stock::getPartBatchNo, stockAdd.getNewPartBatchNo())
				.eq(Stock::getSystemNo, stockAdd.getNewSystemNo()));
		if (stock == null) {
			stock = new Stock();
			stock.setPartId(stockAdd.getPartsId());
			stock.setPartBatchNo(stockAdd.getNewPartBatchNo());
			if (stockAdd.getIfsBatchNo() != null || BooleanUtil.isTrue(stockAdd.getManualInput())) {
				stock.setIfsBatchNo(stockAdd.getIfsBatchNo());
			}else {
				stock.setIfsBatchNo(stockAdd.getNewPartBatchNo());
			}
			stock.setLocationId(stockAdd.getNewLocationId());
			stock.setReelNumber(stockAdd.getReelNumber());
			stock.setSystemNo(stockAdd.getNewSystemNo());
			stock.setInsulationColor(stockAdd.getInsulationColor());
			stock.setOuterColor(stockAdd.getOuterColor());
			stock.setCustomerOrderNo(stockAdd.getCustomerOrderNo());
			stock.setMpsNo(stockAdd.getMpsNo());
			stock.setOperationStockStatus(stockAdd.getOperationStockStatus());
			stockMapper.insert(stock);
		}
		return stock;
	}

	/**
	 * @param beforeQuantity    变更前的数量
	 * @param incrementQuantity 变更数量
	 * @param partId
	 * @param locId
	 * @param partBatchNo
	 * @param billNo
	 * @param billType
	 * @param ifsBatchNo IFS批次号
	 */
	public void createTransaction(BigDecimal beforeQuantity, BigDecimal incrementQuantity, Long partId, Long locId,
								  String partBatchNo, String billNo, String billType, String ifsBatchNo) {
		Part part = partMapper.selectById(partId);
		Location location = locationMapper.selectById(locId);
		if (location == null) {
			throw new RuntimeException("缺少id为：" + locId + "  的库位！！");
		}
		Transaction transaction = new Transaction();
		transaction.setBeforeQuantity(beforeQuantity);
		transaction.setQuantity(incrementQuantity);
		transaction.setAfterQuantity(beforeQuantity.add(incrementQuantity));
		transaction.setPartNo(part.getPartNo());
		transaction.setPartName(part.getPartName());
		transaction.setUnit(part.getUnit());
		transaction.setPartBatchNo(partBatchNo);
		transaction.setLocationNo(location.getLocNo());
		transaction.setIfsBatchNo(ifsBatchNo);
		if (Enums.getIfPresent(TransactionType.class, billType).orNull() == null) {
			transaction.setBillType(billType);
		} else {
			transaction.setBillType(TransactionType.valueOf(billType).getValue());
		}
		transaction.setBillNo(billNo);
		transactionMapper.insert(transaction);
	}

	/**
	 * 自身移库
	 *
	 * @param partId
	 * @param systemNo
	 * @param lotBatchNo
	 * @param stockQuantityIncrement 移库数量
	 * @param oldLocationId          老库位
	 * @param newLocationId          新库位
	 */
	public void localMove(Long partId, String systemNo, String lotBatchNo, BigDecimal stockQuantityIncrement, Long oldLocationId, Long newLocationId) {
		StockAddDTO oldAdd = new StockAddDTO();
		oldAdd.setPartsId(partId);
		oldAdd.setNewLocationId(oldLocationId);
		oldAdd.setNewPartBatchNo(lotBatchNo);
		oldAdd.setNewSystemNo(systemNo);

		Stock oldStock = query(oldAdd);
		Location location = locationMapper.selectById(newLocationId);
		//获取预留库存
		List<JoinStockOrder> joinStockOrderList = joinStockOrderMapper.selectList(Wrappers.<JoinStockOrder>lambdaQuery().eq(JoinStockOrder::getStockId, oldStock.getId()));
		BigDecimal reserveQuantity = BigDecimal.ZERO;
		if (joinStockOrderList.size() > 0) {
			//根据库存id查询预留总数量
			reserveQuantity = joinStockOrderMapper.selectTotalQuantityByStockId(oldStock.getId());
			List<Long> ids = joinStockOrderList.stream().map(JoinStockOrder::getId).collect(Collectors.toList());
			//根据ids删除预留数据
			joinStockOrderMapper.deleteBatchIds(ids);
			//退回预留数量
			updateById(oldStock.getId(), BigDecimal.ZERO, reserveQuantity.negate(), BigDecimal.ZERO, BigDecimal.ZERO, null, TransactionType.CANCEL_RESERVED.getValue());
		}
		updateById(oldStock.getId(), stockQuantityIncrement.negate(), BigDecimal.ZERO, BigDecimal.ZERO, BigDecimal.ZERO, null, TransactionType.TEST_STOCK.getValue());
		StockAddDTO stockAdd = new StockAddDTO();
		stockAdd.setPartsId(partId);
		stockAdd.setNewLocationId(newLocationId);
		stockAdd.setMpsNo(oldStock.getMpsNo());
		stockAdd.setNewPartBatchNo(lotBatchNo);
		stockAdd.setNewSystemNo(systemNo);
		stockAdd.setReelNumber(oldStock.getReelNumber());
		stockAdd.setOperationStockStatus(oldStock.getOperationStockStatus());
		stockAdd.setIfsBatchNo(oldStock.getIfsBatchNo());

		Stock newStock = query(stockAdd);
		//新增预留数据
		if (joinStockOrderList.size() > 0) {
			joinStockOrderList.forEach(joinStockOrdeOld -> {
				JoinStockOrder joinStockOrderNew = new JoinStockOrder();
				BeanUtils.copyProperties(joinStockOrdeOld, joinStockOrderNew);
				joinStockOrderNew.setId(null);
				joinStockOrderNew.setLocationName(location.getLocName());
				joinStockOrderNew.setLocationNo(location.getLocNo());
				joinStockOrderMapper.insert(joinStockOrderNew);
			});
			//库存预留数量更新
			updateById(oldStock.getId(), BigDecimal.ZERO, reserveQuantity, BigDecimal.ZERO, BigDecimal.ZERO, null, TransactionType.CONFIRM_RESERVED.getValue());
		}
		updateById(newStock.getId(), stockQuantityIncrement, BigDecimal.ZERO, BigDecimal.ZERO, BigDecimal.ZERO, null, TransactionType.TEST_STOCK.getValue());
	}


	public String feedingIfsMove(List<StockDTO> stockList, Location location) {
		// ifs移库
		LocationIfsMoveDTO moveDTO = new LocationIfsMoveDTO();
		moveDTO.setRECORD_ID(UUID.randomUUID().toString().replace("-", ""));
		List<LocationIfsMoveDTO.DataBean> dataBeans = new ArrayList<>();
		moveDTO.setBATCH_INFO(dataBeans);

		String moveNo = null;
		for (StockDTO stock : stockList) {
			// 库存件退料需要ifs移库
			Part part = partMapper.selectById(stock.getPartId());
			if (stock.getOperationStockStatus() == null) {
				if (org.apache.commons.lang3.StringUtils.equals("3", part.getMaterialType())) {
					stock.setOperationStockStatus(Boolean.FALSE);
				}
			}
			if (BooleanUtil.isTrue(stock.getOperationStockStatus())) {
				continue;
			}
			Location nowLocation = locationMapper.selectById(stock.getLocationId());
			if (nowLocation.getIfsLocation() == null) {
				throw new RuntimeException("库存库位未绑定ifs库位");
			}

			LocationIfsMoveDTO.DataBean bean = new LocationIfsMoveDTO.DataBean();
			bean.setPART_NO(part.getPartNo());
			if (part.getLotTrackingIfs() != null && part.getLotTrackingIfs()) {
				bean.setLOT_BATCH_NO(stock.getIfsBatchNo());
				bean.setWAIV_DEV_REJ_NO(stock.getPartBatchNo());
			} else {
				bean.setLOT_BATCH_NO("*");
				bean.setWAIV_DEV_REJ_NO("*");
			}
			bean.setMOVE_QTY(stock.getFeedQuantity());
			bean.setLOCATION_NO(nowLocation.getIfsLocation());
			bean.setTO_LOCATION_NO(location.getIfsLocation());
			dataBeans.add(bean);
		}

		R response = locationService.moveIfsLocation(moveDTO);
		if (response.getCode() == 0) {
			moveNo = moveDTO.getRECORD_ID();
			for (StockDTO stockDTO : stockList) {
				Stock updateIfs = new Stock();
				updateIfs.setId(stockDTO.getId());
				updateIfs.setIfsMoveNo(moveNo);
				stockMapper.updateById(updateIfs);
			}
		} else {
			throw new RuntimeException("ifs移库失败：" + response.getMsg());
		}
		return moveNo;
	}

	public String feedingIfsMoveByDTO(List<StockDTO> stockList, LocationIfsMoveDTO moveDTO) {
		// ifs移库
		String moveNo = null;
		R response = locationService.moveIfsLocation(moveDTO);
		if (response.getCode() == 0) {
			moveNo = moveDTO.getRECORD_ID();
			for (StockDTO stockDTO : stockList) {
				Stock updateIfs = new Stock();
				updateIfs.setId(stockDTO.getId());
				updateIfs.setIfsMoveNo(moveNo);
				stockMapper.updateById(updateIfs);
			}
		} else {
			throw new RuntimeException("ifs移库失败：" + response.getMsg());
		}
		return moveNo;
	}

	public void replaceMove(Long partId, String systemNo, String lotBatchNo, BigDecimal stockQuantityIncrement, Long oldLocationId, Long newLocationId, Long replacePartId) {
		StockAddDTO oldAdd = new StockAddDTO();
		oldAdd.setPartsId(partId);
		oldAdd.setNewLocationId(oldLocationId);
		oldAdd.setNewPartBatchNo(lotBatchNo);
		oldAdd.setNewSystemNo(systemNo);

		Stock oldStock = query(oldAdd);

		updateById(oldStock.getId(), stockQuantityIncrement.negate(), BigDecimal.ZERO, BigDecimal.ZERO, BigDecimal.ZERO, null, TransactionType.REPLACEMENT_ISSUE.getValue());
		StockAddDTO stockAdd = new StockAddDTO();
		stockAdd.setPartsId(replacePartId);
		stockAdd.setNewLocationId(newLocationId);
		stockAdd.setNewPartBatchNo(lotBatchNo);
		stockAdd.setNewSystemNo(systemNo);
		stockAdd.setReelNumber(oldStock.getReelNumber());
		stockAdd.setOperationStockStatus(oldStock.getOperationStockStatus());
		stockAdd.setIfsBatchNo(oldStock.getIfsBatchNo());

		Stock newStock = query(stockAdd);
		updateById(newStock.getId(), stockQuantityIncrement, BigDecimal.ZERO, BigDecimal.ZERO, BigDecimal.ZERO, null, TransactionType.REPLACEMENT_RECEIVE.getValue());
	}
}