package com.matrix.system.hive.service.imp;

import com.matrix.core.constance.MatrixConstance;
import com.matrix.core.exception.GlobleException;
import com.matrix.core.pojo.PaginationVO;
import com.matrix.core.tools.DateUtil;
import com.matrix.core.tools.WebUtil;
import com.matrix.system.common.bean.SysUsers;
import com.matrix.system.constance.Dictionary;
import com.matrix.system.hive.bean.SysAllotDetail;
import com.matrix.system.hive.bean.SysAllottedInfo;
import com.matrix.system.hive.bean.SysStoreInfo;
import com.matrix.system.hive.dao.SysAllotDetailDao;
import com.matrix.system.hive.dao.SysAllottedInfoDao;
import com.matrix.system.hive.dao.SysStoreInfoDao;
import com.matrix.system.hive.service.SysAllottedInfoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.List;


/**
 *
 * 
 * @date 2016-07-18 18:11
 */

@Service("sysAllottedInfoService")
public class SysAllottedInfoServiceImpl implements SysAllottedInfoService {

	@Autowired
	private SysAllottedInfoDao sysAllottedInfoDao;
	@Autowired
	private SysAllotDetailDao sysAllotDetailDao;
	@Autowired
	private SysStoreInfoDao sysStoreInfoDao;

	@Override
	public int update(SysAllottedInfo sysAllottedInfo) {
		return sysAllottedInfoDao.update(sysAllottedInfo);
	}

	@Override
	@Transactional(rollbackFor = Exception.class)
	public int add(SysAllottedInfo sysAllottedInfo) {

		sysAllottedInfo.setCheckStatus(Dictionary.CHECK_STATUS_DSH);
		// 设置编号
		sysAllottedInfo.setAllottedId(DateUtil.getTimeMark());

		int i = sysAllottedInfoDao.insert(sysAllottedInfo);
		// 获得id
		Long id = sysAllottedInfo.getId();
		// 添加明细
		batchAddDetail(sysAllottedInfo, id);
		return i;

	}

	@Override
	@Transactional(rollbackFor = Exception.class)
	public int modify(SysAllottedInfo sysAllottedInfo) {
		// 验证单据状态,如已通过则无法修改
		SysAllottedInfo checkAllottedInfo = sysAllottedInfoDao.selectById(sysAllottedInfo.getId());
		if (checkAllottedInfo != null && !(checkAllottedInfo.getCheckStatus().equals(Dictionary.CHECK_STATUS_DSH))) {
			throw new GlobleException("已审核，不能再修改!");
		}
		// 获得id
		Long id = sysAllottedInfo.getId();
		sysAllotDetailDao.deletebyAllottedInfoId(id);
		batchAddDetail(sysAllottedInfo, id);
		return sysAllottedInfoDao.update(sysAllottedInfo);
	}

	/**
	 * 批量设置明细
	 *
	 * @param sysAllottedInfo
	 * @param id
	 */
	private void batchAddDetail(SysAllottedInfo sysAllottedInfo, Long id) {
		// 添加明细
		List<SysAllotDetail> allotDetails = sysAllottedInfo.getSysAllotDetails();
		List<SysAllotDetail> addList = new ArrayList<SysAllotDetail>();
		for (SysAllotDetail sAllotDetail : allotDetails) {
			if (sAllotDetail.getSkuId() != null) {
				sAllotDetail.setAllotId(id);
				sAllotDetail.setRealTotal(0);
				sAllotDetail.setReceiveTotal(0);
				addList.add(sAllotDetail);
			}
		}
		sysAllotDetailDao.batchInsert(addList);
	}

	@Override
	@Transactional(rollbackFor = Exception.class)
	public int remove(List<Long> list) {

		for (Long id : list) {

			// 如果存在明细,则不能删除
			SysAllottedInfo sysAllottedInfo = this.sysAllottedInfoDao.selectById(id);

			if (!sysAllottedInfo.getCheckStatus().equals(Dictionary.CHECK_STATUS_DSH)) {
				throw new GlobleException("编号为" + sysAllottedInfo.getAllottedId() + "的调拨单已审核，不能被删除");
			}

			if (sysAllottedInfo.getSysAllotDetails() != null && sysAllottedInfo.getSysAllotDetails().size() > 0) {
				List<SysAllotDetail> allotDetails = sysAllottedInfo.getSysAllotDetails();
				this.sysAllotDetailDao.deleteByBeans(allotDetails);
			}
		}
		return sysAllottedInfoDao.deleteByIds(list);

	}

	@Override
	@Transactional(rollbackFor = Exception.class)
	public int removeById(Long id) {
		// 如果存在明细,则不能删除
		SysAllottedInfo sysAllottedInfo = this.sysAllottedInfoDao.selectById(id);
		if (!sysAllottedInfo.getCheckStatus().equals(Dictionary.CHECK_STATUS_DSH)) {
			throw new GlobleException("编号为" + sysAllottedInfo.getAllottedId() + "的调拨单已审核，不能被删除");
		}
		if (sysAllottedInfo.getSysAllotDetails() != null && sysAllottedInfo.getSysAllotDetails().size() > 0) {
			return 0;
		}
		return sysAllottedInfoDao.deleteById(id);
	}

	@Override
	public List<SysAllottedInfo> findInPage(SysAllottedInfo sysAllottedInfo, PaginationVO pageVo) {

		return sysAllottedInfoDao.selectInPage(sysAllottedInfo, pageVo);

	}

	@Override
	public List<SysAllottedInfo> findByModel(SysAllottedInfo sysAllottedInfo) {

		return sysAllottedInfoDao.selectByModel(sysAllottedInfo);

	}

	@Override
	public int findTotal(SysAllottedInfo sysAllottedInfo) {

		return sysAllottedInfoDao.selectTotalRecord(sysAllottedInfo);

	}

	@Override
	public SysAllottedInfo findById(Long id) {

		return sysAllottedInfoDao.selectById(id);

	}

	@Override
	@Transactional(rollbackFor = Exception.class)
	public int check(SysAllottedInfo newsysAllottedInfo) {
		// 验证权限
		SysUsers user=(SysUsers)WebUtil.getSession().getAttribute(MatrixConstance.LOGIN_KEY);
		if (user.getRoleName().contains(Dictionary.STAFF_POST_PLZG)
				|| user.getRoleName().contains(Dictionary.STAFF_POST_CKZG)) {
			// 验证单据状态
			SysAllottedInfo checkAllottedInfo = sysAllottedInfoDao.selectById(newsysAllottedInfo.getId());
			if (!checkAllottedInfo.getAppManId().equals(user.getSuId())) {
				throw new GlobleException("无权审核该单据!");
			}
			if (!(checkAllottedInfo.getCheckStatus().equals(Dictionary.CHECK_STATUS_DSH))) {
				throw new GlobleException("该单据状态为" + checkAllottedInfo.getCheckStatus() + ",不可再审核!");
			}

			for (SysAllotDetail newSysAllotDetail : newsysAllottedInfo.getSysAllotDetails()) {
				sysAllotDetailDao.update(newSysAllotDetail);
			}
			// 保存调拨单状态,调拨明细单审核数量
			newsysAllottedInfo.setCheckStatus(Dictionary.CHECK_STATUS_SHTG);
			int i = this.sysAllottedInfoDao.update(newsysAllottedInfo);
			return i;
		} else {
			throw new GlobleException("审核人岗位必须为配料主管或者仓库主管!");
		}
	}

	/**
	 * 发货 操作者为审核人
	 */
	@Override
	@Transactional(rollbackFor = Exception.class)
	public int sendGoods(SysAllottedInfo sysAllottedInfo) {

		// 验证权限
		SysUsers user=(SysUsers)WebUtil.getSession().getAttribute(MatrixConstance.LOGIN_KEY);
		if (user.getRoleName().contains(Dictionary.STAFF_POST_PLZG)
				|| user.getRoleName().contains(Dictionary.STAFF_POST_CKZG)) {
			// 验证单据状态
			SysAllottedInfo checkAllottedInfo = sysAllottedInfoDao.selectById(sysAllottedInfo.getId());
			if (!checkAllottedInfo.getAppManId().equals(user.getSuId())) {
				throw new GlobleException("无权操作该单据!");
			}
			if (!(checkAllottedInfo.getCheckStatus().equals(Dictionary.CHECK_STATUS_SHTG))) {
				throw new GlobleException("该单据状态为" + checkAllottedInfo.getCheckStatus() + ",不可发货!");
			}
			// 保存调拨单状态,调拨明细单审核数量
			checkAllottedInfo.setCheckStatus(Dictionary.CHECK_STATUS_DSHOUHUO);
			int i = this.sysAllottedInfoDao.update(checkAllottedInfo);
			// 先更新调拨明细信息

			List<SysAllotDetail> sysAllotDetails = sysAllotDetailDao.selectAllottedDetailByOrderId(checkAllottedInfo.getId());
			for (SysAllotDetail newSysAllotDetail : sysAllotDetails) {
				// 出库
				SysStoreInfo outStoreInfo = sysStoreInfoDao.selectById(newSysAllotDetail.getStoreId());
				Double newStoreTotal = outStoreInfo.getStoreTotal() - newSysAllotDetail.getRealTotal();

				if (newStoreTotal > -1
						|| Dictionary.SHOP_NAME_ZONGDIAN.equals(checkAllottedInfo.getAllottedOutstoreName())) {
					outStoreInfo.setStoreTotal(newStoreTotal);
					sysStoreInfoDao.update(outStoreInfo);
				} else {
					throw new GlobleException("库存不足");
				}
			}
			return i;
		} else {
			throw new GlobleException("操作人岗位必须为配料主管或者仓库主管!");
		}

	}

	/**
	 * 收货 操作者为制单人
	 */
	@Override
	@Transactional(rollbackFor = Exception.class)
	public int rejectGoods(SysAllottedInfo sysAllottedInfo) {

		// 验证权限
		SysUsers user=(SysUsers)WebUtil.getSession().getAttribute(MatrixConstance.LOGIN_KEY);
		SysAllottedInfo checkAllottedInfo = sysAllottedInfoDao.selectById(sysAllottedInfo.getId());
		/*
		 * if(!checkAllottedInfo.getMakingManId().equals(user.getSuId())){
		 * throw new GlobleException("无权操作该单据!"); }
		// 不是同一个店铺的无权限收货
		if (!checkAllottedInfo.getAllottedInstoreId().equals(user.getShopId())) {
			throw new GlobleException("不是本店用户，无权操作该单据!");
		}
		*/
		// 验证单据状态
		if (!(checkAllottedInfo.getCheckStatus().equals(Dictionary.CHECK_STATUS_DSHOUHUO))) {
			throw new GlobleException("该单据状态为" + checkAllottedInfo.getCheckStatus() + ",不可再确认收货!");
		}

		// 保存调拨单状态,调拨明细单审核数量
		sysAllottedInfo.setCheckStatus(Dictionary.CHECK_STATUS_YWC);
		int i = this.sysAllottedInfoDao.update(sysAllottedInfo);

		// 更新调拨单明细
		for (SysAllotDetail newSysAllotDetail : sysAllottedInfo.getSysAllotDetails()) {
			sysAllotDetailDao.update(newSysAllotDetail);
		}

		SysAllottedInfo newAllottedInfo = sysAllottedInfoDao.selectById(sysAllottedInfo.getId());
		List<SysAllotDetail> sysAllotDetails = sysAllotDetailDao.selectAllottedDetailByOrderId(newAllottedInfo.getId());
		// 更新库存
		for (SysAllotDetail newSysAllotDetail :sysAllotDetails) {
			if (newSysAllotDetail.getReceiveTotal() > newSysAllotDetail.getRealTotal()) {
				throw new GlobleException("实际接收数不能大于实际调拨数!");
			}
			//如果是同一批次的活则叠加库存
			SysStoreInfo srcStoreInfo= sysStoreInfoDao.selectById(newSysAllotDetail.getStoreId());
			// 入库
			SysStoreInfo inStoreInfo = sysStoreInfoDao.selectStoInfo(srcStoreInfo.getBatch(),
					checkAllottedInfo.getAllottedInstoreId());
			// 第一次调拨该批次商品
			if (inStoreInfo == null) {
				inStoreInfo = new SysStoreInfo();
				inStoreInfo.setSkuId(newSysAllotDetail.getSkuId());
				inStoreInfo.setStoreId(checkAllottedInfo.getAllottedInstoreId());
				inStoreInfo.setStoreTotal((double) newSysAllotDetail.getReceiveTotal());
				inStoreInfo.setBatch(srcStoreInfo.getBatch());
				inStoreInfo.setGoodsPrice(newSysAllotDetail.getWholesale());
				inStoreInfo.setTime(srcStoreInfo.getTime());
				sysStoreInfoDao.insert(inStoreInfo);
				// 非第一次调拨商品
			} else {
				inStoreInfo.setStoreTotal(inStoreInfo.getStoreTotal() + newSysAllotDetail.getReceiveTotal());
				sysStoreInfoDao.update(inStoreInfo);
			}
		}
		return i;
	}

	/**
	 * 撤销审核
	 */
	@Override
	@Transactional(rollbackFor = Exception.class)
	public int unCheck(SysAllottedInfo newsysAllottedInfo) {
		// 验证权限
		SysUsers user=(SysUsers)WebUtil.getSession().getAttribute(MatrixConstance.LOGIN_KEY);
		if (user.getRoleName().contains(Dictionary.STAFF_POST_PLZG)
				|| user.getRoleName().contains(Dictionary.STAFF_POST_CKZG)) {
			// 验证单据状态
			SysAllottedInfo checkAllottedInfo = sysAllottedInfoDao.selectById(newsysAllottedInfo.getId());
			if (!checkAllottedInfo.getAppManId().equals(user.getSuId())) {
				throw new GlobleException("无权撤销该单据!");
			}
			if ((checkAllottedInfo.getCheckStatus().equals(Dictionary.CHECK_STATUS_DSH))) {
				throw new GlobleException("该单据状态为" + checkAllottedInfo.getCheckStatus() + ",不可撤销审核!");
			}
			// 保存调拨单状态,调拨明细单审核数量
			if (checkAllottedInfo.getAppRemark() != null) {
				checkAllottedInfo.setAppRemark(checkAllottedInfo.getAppRemark().replace("[弃审]", "") + "[弃审]");
			} else {
				checkAllottedInfo.setAppRemark("[弃审]");
			}
			// 若果状态为审核通过则无库存数据返回
			if (!checkAllottedInfo.getCheckStatus().equals(Dictionary.CHECK_STATUS_SHTG)) {

				// 先更新调拨明细信息
				for (SysAllotDetail newSysAllotDetail : checkAllottedInfo.getSysAllotDetails()) {

					// 出库
					SysStoreInfo outStoreInfo =null;// sysStoreInfoDao.selectStoInfo(newSysAllotDetail.getSkuId(),checkAllottedInfo.getAllottedOutstoreId());

					double newStoreTotal = outStoreInfo.getStoreTotal() + newSysAllotDetail.getRealTotal();

					outStoreInfo.setStoreTotal(newStoreTotal);
					// 更新库存
					sysStoreInfoDao.update(outStoreInfo);

					if (checkAllottedInfo.getCheckStatus().equals(Dictionary.CHECK_STATUS_YWC)) {
						// TODO 去掉撤销审核这个功能
						SysStoreInfo inStoreInfo = null;//sysStoreInfoDao.selectStoInfo(newSysAllotDetail.getSkuId(),checkAllottedInfo.getAllottedInstoreId());
						if (inStoreInfo.getStoreTotal() - newSysAllotDetail.getReceiveTotal() <= 0
								|| Dictionary.SHOP_NAME_ZONGDIAN.equals(checkAllottedInfo.getAllottedOutstoreName())) {
							throw new GlobleException(inStoreInfo.getGoods().getName() + "库存不足,撤消失败!");
						} else {
							inStoreInfo
									.setStoreTotal(inStoreInfo.getStoreTotal() - newSysAllotDetail.getReceiveTotal());
						}
						sysStoreInfoDao.update(inStoreInfo);
					}

				}
			}
			checkAllottedInfo.setCheckStatus(Dictionary.CHECK_STATUS_DSH);
			return sysAllottedInfoDao.update(checkAllottedInfo);
		} else {
			throw new GlobleException("审核人岗位必须为配料主管或者仓库主管!");
		}
	}
}