package com.chinaztt.mes.outsource.service.impl;

import cn.hutool.core.util.BooleanUtil;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.chinaztt.mes.basic.util.BigDecimalUtils;
import com.chinaztt.mes.common.numgen.NumberGenerator;
import com.chinaztt.mes.outsource.entity.InspectionDeclaration;
import com.chinaztt.mes.outsource.entity.InspectionDeclarationDetail;
import com.chinaztt.mes.outsource.mapper.InspectionDeclarationMapper;
import com.chinaztt.mes.outsource.service.InspectionDeclarationDetailService;
import com.chinaztt.mes.outsource.service.InspectionDeclarationService;
import com.chinaztt.mes.outsource.state.InspectionDetailState;
import com.chinaztt.ztt.common.security.util.SecurityUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Consumer;

/**
 * @Author: Zero
 * @Date: 2022/9/28 15:00
 * @Description:
 */
@Service
@Transactional(rollbackFor = Exception.class)
public class InspectionDeclarationServiceImpl extends ServiceImpl<InspectionDeclarationMapper, InspectionDeclaration> implements InspectionDeclarationService {

	@Resource
	private NumberGenerator<InspectionDeclaration> numberGenerator;

	@Resource
	private InspectionDeclarationDetailService inspectionDeclarationDetailService;
	private Map<String, Consumer<List<InspectionDeclarationDetail>>> inspMap = new ConcurrentHashMap<>();


	@Override
	public void insp(List<InspectionDeclarationDetail> inspectionDeclarationDetailList, String event) {
		Consumer<List<InspectionDeclarationDetail>> consumer = inspMap.get(event);
		consumer.accept(inspectionDeclarationDetailList);
	}

	@PostConstruct
	public void initInspMap() {
		inspMap.put("inspDeclaration", this::inspDeclaration);
		inspMap.put("sampling", this::sampling);
		inspMap.put("declaration", this::declaration);
		inspMap.put("packaging", this::packaging);
		inspMap.put("stock", this::stock);
	}

	/**
	 * 报检
	 *
	 * @param inspectionDeclarationDetailList
	 */
	public void inspDeclaration(List<InspectionDeclarationDetail> inspectionDeclarationDetailList) {
		String inspectionSerialNo = numberGenerator.generateNumberWithPrefix(InspectionDeclaration.DIGIT,
				InspectionDeclaration.PREFIX, InspectionDeclaration::getInspectionSerialNo);
		inspectionDeclarationDetailList.forEach(d -> {
			d.setInspectionSerialNo(inspectionSerialNo);
			d.setPackagingState(InspectionDetailState.COMMON_NO.getCode());
			d.setStockState(InspectionDetailState.COMMON_NO.getCode());
			d.setSamplingState(InspectionDetailState.COMMON_YES.getCode());
			d.setState(InspectionDetailState.UN_INSP.getCode());
			d.setInspState(InspectionDetailState.UN_INSP.getCode());
		});
		BigDecimal totalInspectionQuantity =
				inspectionDeclarationDetailList.stream().map(InspectionDeclarationDetail::getInspectionQuantity).reduce(BigDecimal.ZERO, BigDecimal::add);
		InspectionDeclaration inspectionDeclaration =
				InspectionDeclaration.builder().inspectionSerialNo(inspectionSerialNo)
						.inspectionQuantity(totalInspectionQuantity).differenceQuantity(totalInspectionQuantity).build();
		save(inspectionDeclaration);
		inspectionDeclarationDetailService.saveBatch(inspectionDeclarationDetailList);
	}

	/**
	 * 抽检
	 *
	 * @param inspectionDeclarationDetailList
	 */
	public void sampling(List<InspectionDeclarationDetail> inspectionDeclarationDetailList) {
		boolean existErrorState =
				inspectionDeclarationDetailList.stream().anyMatch(d -> BooleanUtil.isFalse(validateSampling(d)));
		if (existErrorState) {
			throw new RuntimeException("存在非待抽检状态成品");
		}
		inspectionDeclarationDetailList.forEach(d -> {
			d.setSamplingState(InspectionDetailState.COMMON_YES.getCode());
			d.setState(InspectionDetailState.UN_INSP.getCode());
		});
		inspectionDeclarationDetailService.updateBatchById(inspectionDeclarationDetailList);
	}

	/**
	 * 检测
	 *
	 * @param inspectionDeclarationDetailList
	 */
	public void declaration(List<InspectionDeclarationDetail> inspectionDeclarationDetailList) {
		boolean existErrorState =
				inspectionDeclarationDetailList.stream().anyMatch(d -> BooleanUtil.isFalse(validateDeclaration(d)));
		if (existErrorState) {
			throw new RuntimeException("只能检测已抽检，待检测的成品");
		}
		inspectionDeclarationDetailList.forEach(d -> d.setState(InspectionDetailState.INSPED.getCode()));
		inspectionDeclarationDetailService.updateBatchById(inspectionDeclarationDetailList);

	}

	/**
	 * 包装
	 *
	 * @param inspectionDeclarationDetailList
	 */
	public void packaging(List<InspectionDeclarationDetail> inspectionDeclarationDetailList) {
		boolean existErrorState =
				inspectionDeclarationDetailList.stream().anyMatch(d -> BooleanUtil.isFalse(validatePackaging(d)));
		if (existErrorState) {
			throw new RuntimeException("只允许已检测，并且检测状态为检测合格或检测放行成品进行包装");
		}
		inspectionDeclarationDetailList.forEach(d -> {
			d.setState(InspectionDetailState.PACKAGING.getCode());
			d.setPackagingOperator(SecurityUtils.getUser().getUsername());
			d.setPackagingState(InspectionDetailState.COMMON_YES.getCode());
		});
		inspectionDeclarationDetailService.updateBatchById(inspectionDeclarationDetailList);
	}

	/**
	 * 入库
	 *
	 * @param inspectionDeclarationDetailList
	 */
	public void stock(List<InspectionDeclarationDetail> inspectionDeclarationDetailList) {
		boolean existErrorState =
				inspectionDeclarationDetailList.stream().anyMatch(d -> BooleanUtil.isFalse(validateStock(d)));
		if (existErrorState) {
			throw new RuntimeException("只有待抽检或者已包装的成品才可以入库");
		}
		inspectionDeclarationDetailList.forEach(d -> {
			d.setState(InspectionDetailState.STOCK.getCode());
			d.setStockOperator(SecurityUtils.getUser().getUsername());
			d.setStockState(InspectionDetailState.COMMON_YES.getCode());
		});
		inspectionDeclarationDetailService.updateBatchById(inspectionDeclarationDetailList);
		InspectionDeclaration inspectionDeclaration =
				getOne(Wrappers.<InspectionDeclaration>lambdaQuery().eq(InspectionDeclaration::getInspectionSerialNo,
						inspectionDeclarationDetailList.get(0).getInspectionSerialNo()));
		BigDecimal stockQuantity =
				inspectionDeclarationDetailList.stream().map(InspectionDeclarationDetail::getInspectionQuantity).reduce(BigDecimal.ZERO, BigDecimal::add);
		inspectionDeclaration.setStockQuantity(BigDecimalUtils.getBigDecimalValue(inspectionDeclaration.getStockQuantity()).add(stockQuantity));
		inspectionDeclaration.setDifferenceQuantity(inspectionDeclaration.getInspectionQuantity().subtract(inspectionDeclaration.getStockQuantity()));
		updateById(inspectionDeclaration);
	}

	/**
	 * 校验是否允许抽检
	 * <p>只有状态为待抽检的成品才允许抽检</p>
	 *
	 * @param detail
	 * @return
	 */
	private Boolean validateSampling(InspectionDeclarationDetail detail) {
		if (!StringUtils.equals(InspectionDetailState.COMMON_NO.getCode(), detail.getSamplingState())) {
			return Boolean.FALSE;
		}
		return Boolean.TRUE;
	}

	/**
	 * 校验是否允许检测
	 * <p>只有已经抽检，并且是待检测的才允许检测</p>
	 *
	 * @param detail
	 * @return
	 */
	private Boolean validateDeclaration(InspectionDeclarationDetail detail) {
		if (!StringUtils.equals(InspectionDetailState.COMMON_YES.getCode(), detail.getSamplingState())) {
			return Boolean.FALSE;
		}
		if (!StringUtils.equals(InspectionDetailState.UN_INSP.getCode(), detail.getState())) {
			return Boolean.FALSE;
		}
		return Boolean.TRUE;
	}

	/**
	 * 校验是否允许包装
	 * <p>只有已检测，并且检测状态为检测合格或者检测放行的成品才允许包装</p>
	 *
	 * @param detail
	 * @return
	 */
	private Boolean validatePackaging(InspectionDeclarationDetail detail) {
		if (!StringUtils.equals(InspectionDetailState.INSPED.getCode(), detail.getState())) {
			return Boolean.FALSE;
		}
		if (!StringUtils.equals(InspectionDetailState.INSP_PASS.getCode(), detail.getInspState())
				&& !StringUtils.equals(InspectionDetailState.INSP_RELEASE.getCode(), detail.getInspState())) {
			return Boolean.FALSE;
		}
		return Boolean.TRUE;
	}

	/**
	 * 校验是否可以入库
	 * <p>只有待抽检或者已包装状态才可以入库</p>
	 *
	 * @param detail
	 * @return
	 */
	private Boolean validateStock(InspectionDeclarationDetail detail) {
		if (StringUtils.equals(InspectionDetailState.UN_SAMPLING.getCode(), detail.getState())
				|| StringUtils.equals(InspectionDetailState.PACKAGING.getCode(), detail.getState())) {
			return Boolean.TRUE;
		}
		return Boolean.FALSE;
	}
}