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

import cn.hutool.core.collection.CollectionUtil;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.chinaztt.mes.quality.entity.TestStandard;
import com.chinaztt.mes.quality.entity.TestStandardParam;
import com.chinaztt.mes.quality.mapper.TestStandardMapper;
import com.chinaztt.mes.quality.mapper.TestStandardParamMapper;
import com.chinaztt.mes.quality.service.TestStandardParamService;
import com.chinaztt.mes.quality.utils.AutoJudgmentUtils;
import com.chinaztt.mes.quality.utils.FunctionConfig;
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * 检测标准参数
 *
 * @author cxf
 * @date 2021-04-22 09:03:13
 */
@Service
@AllArgsConstructor
@Transactional(rollbackFor = Exception.class)
public class TestStandardParamServiceImpl extends ServiceImpl<TestStandardParamMapper, TestStandardParam> implements TestStandardParamService {
	private TestStandardMapper testStandardMapper;

    @Override
    public boolean saveList(List<TestStandardParam> testStandardParamList) {
        if (CollectionUtil.isNotEmpty(testStandardParamList)) {
        	String oldCode = "";//旧检测编号
        	String newCode = "";//新检测编号
			String oldCodeF = "";//旧检测编号(替换公式用)
			String newCodeF = "";//新检测编号(替换公式用)
			Map<String,String> codeMap = new HashMap<>();
			for(TestStandardParam testStandardParam : testStandardParamList){
				if(testStandardParam.getWireCore() == null){
					testStandardParam.setWireCore("");
				}
			}
			//根据线芯进行分组
			Set<String> wireCodeGroup = testStandardParamList.stream().map(o -> o.getWireCore()).collect(Collectors.toSet());
			for(String wireCode : wireCodeGroup){
				Map<String,String> codeMapIn = new HashMap<>();
				for(TestStandardParam testStandardParam : testStandardParamList.stream().filter(o -> o.getWireCore().equals(wireCode)).collect(Collectors.toList())){
					//根据线芯进行拼接生成新的“检测项编号”
					if(StringUtils.isNotBlank(testStandardParam.getWireCore()) && !testStandardParam.getCode().contains("_")){
						//新增线芯
						oldCode = testStandardParam.getCode();
						oldCodeF = "[" + oldCode + "]";
						testStandardParam.setCode(testStandardParam.getCode() + "_" + testStandardParam.getWireCore());//生成新的编号
						newCode = testStandardParam.getCode();
						newCodeF = "[" + newCode + "]";
						codeMap.put(newCodeF,oldCodeF);
						codeMapIn.put(newCodeF,oldCodeF);
						if(false){
							//name不替换
							testStandardParam.setParameterItem(testStandardParam.getParameterItem() + "_" + testStandardParam.getWireCore());//生成新的检测项名称
						}
						replaceFormulaParamPresentLine(testStandardParam,newCodeF,oldCodeF);
						//替换公式中的参数（原参数code没有后缀，替换成有后缀的）
						if(false){//逐行替换完之后再进行全局替换
							AutoJudgmentUtils.replaceFormulaParam(testStandardParamList,newCodeF,oldCodeF);
						}
						//替换主表中的判定公式的参数code
						replaceFormulaParamMain(testStandardParam.getTestStandardId(),oldCodeF,newCodeF);
					}else if(StringUtils.isBlank(testStandardParam.getWireCore()) && testStandardParam.getCode().contains("_")){
						//删除线芯
						oldCode = testStandardParam.getCode();
						oldCodeF = "[" + oldCode + "]";
						testStandardParam.setCode(testStandardParam.getCode().split("_")[0]);//剔除编号后缀
						newCode = testStandardParam.getCode();
						newCodeF = "[" + newCode + "]";
						codeMap.put(newCodeF,oldCodeF);
						codeMapIn.put(newCodeF,oldCodeF);
						if(false){
							testStandardParam.setParameterItem(testStandardParam.getParameterItem().split("_")[0]);//剔除检测项名称后缀
						}
						replaceFormulaParamPresentLine(testStandardParam,newCodeF,oldCodeF);
						//替换公式中的参数（原参数code有后缀，替换成没有后缀的）
						if(false){//逐行替换完之后再进行全局替换
							AutoJudgmentUtils.replaceFormulaParam(testStandardParamList,newCodeF,oldCodeF);
						}
						//替换主表中的判定公式的参数code
						replaceFormulaParamMain(testStandardParam.getTestStandardId(),oldCodeF,newCodeF);
					}else if(StringUtils.isNotBlank(testStandardParam.getWireCore()) && testStandardParam.getCode().contains("_") && testStandardParam.getId() != null && testStandardParam.getId() != 0){
						//验证是否是修改
						TestStandardParam testStandardParam_tmp = baseMapper.selectById(testStandardParam.getId());
						if(!testStandardParam_tmp.getWireCore().equals(testStandardParam.getWireCore())){
							oldCode = testStandardParam_tmp.getCode();
							oldCodeF = "[" + oldCode + "]";
							newCode = oldCode.replace(testStandardParam_tmp.getWireCore(),testStandardParam.getWireCore());
							newCodeF = "[" + newCode + "]";
							codeMap.put(newCodeF,oldCodeF);
							codeMapIn.put(newCodeF,oldCodeF);
							testStandardParam.setCode(newCode);
							if(false){
								testStandardParam.setParameterItem(testStandardParam.getParameterItem().replace(testStandardParam_tmp.getWireCore(),testStandardParam.getWireCore()));
							}
							replaceFormulaParamPresentLine(testStandardParam,newCodeF,oldCodeF);
							//替换公式中的参数
							if(false){//逐行替换完之后再进行全局替换
								AutoJudgmentUtils.replaceFormulaParam(testStandardParamList,newCodeF,oldCodeF);
							}
							//替换主表中的判定公式的参数code
							replaceFormulaParamMain(testStandardParam.getTestStandardId(),oldCodeF,newCodeF);
						}
					}
				}
				//分组中全局替换公式中的code
				for(Map.Entry<String,String> vo : codeMapIn.entrySet()){
					AutoJudgmentUtils.replaceFormulaParam(testStandardParamList.stream().filter(o -> o.getWireCore().equals(wireCode)).collect(Collectors.toList()),vo.getKey(),vo.getValue());
				}
			}

			//校验编号是否重复
			Set<String> itemCode = testStandardParamList.stream().map(o -> o.getCode()).collect(Collectors.toSet());//自动去重
			if(itemCode.size() != testStandardParamList.size()){
				throw new RuntimeException("提交检测项参数列表 -> " + " 检测项编号重复");
			}

			//全局替换公式中的code
			for(Map.Entry<String,String> vo : codeMap.entrySet()){
				AutoJudgmentUtils.replaceFormulaParam(testStandardParamList,vo.getKey(),vo.getValue());
			}

            // 先删除
            baseMapper.delete(Wrappers.<TestStandardParam>lambdaQuery().eq(TestStandardParam::getTestStandardId, testStandardParamList.get(0).getTestStandardId()));
            // 后更新/新增
            testStandardParamList.stream().forEach(testStandardParam -> {
                if (testStandardParam.getId() != null && testStandardParam.getId() != 0) {
                	if (StringUtils.isNotBlank(testStandardParam.getParameterFormat())) {
						boolean matches = testStandardParam.getParameterFormat().matches(FunctionConfig.PATTEN_MIN_MATH_FORMAT.pattern());
						if (!matches) {
							throw new RuntimeException("参数格式 = 【" + testStandardParam.getParameterFormat() + "】 -> 错误");
						}
					}
                    baseMapper.activeById(testStandardParam.getId());
                    baseMapper.updateById(testStandardParam);
                } else {
					if (StringUtils.isNotBlank(testStandardParam.getParameterFormat())) {
						boolean matches = testStandardParam.getParameterFormat().matches(FunctionConfig.PATTEN_MIN_MATH_FORMAT.pattern());
						if (!matches) {
							throw new RuntimeException("参数格式 = 【" + testStandardParam.getParameterFormat() + "】 -> 错误");
						}
					}
                    baseMapper.insert(testStandardParam);
                }
            });
        }
        return true;
    }

	/**
	 * 替换主表判定公式中的参数code
	 * @param id  检测标准主表id
	 * @param oldCode  旧检测项编号
	 * @param newCode  新检测项编号
	 */
	private void replaceFormulaParamMain(Long id,String oldCode,String newCode){
		if(false){
			//主表中公式的替换会出现相同的原始code对应不同的“线芯”，替换时无法识别
			TestStandard testStandard = testStandardMapper.selectById(id);
			if(StringUtils.isNotBlank(testStandard.getJudgeFormula())){
				testStandard.setJudgeFormula(testStandard.getJudgeFormula().replace(oldCode,newCode));
				testStandardMapper.updateById(testStandard);
			}
		}
	}

	/**
	 * 替换当前行公式中的code（公式中的code若与当前行的参数code相同，则只指代当前行的参code）
	 * @param testStandardParam
	 * @param newCode
	 * @param oldCode
	 */
	private void replaceFormulaParamPresentLine(TestStandardParam testStandardParam, String newCode, String oldCode){
		//如果公式字段中有值，则替换
		if(StringUtils.isNotBlank(testStandardParam.getJudgeFormula())){
			//判断公式
			testStandardParam.setJudgeFormula(testStandardParam.getJudgeFormula().replace(oldCode,newCode));
		}
		if(StringUtils.isNotBlank(testStandardParam.getValueFormula())){
			//值计算公式
			testStandardParam.setValueFormula(testStandardParam.getValueFormula().replace(oldCode,newCode));
		}
	}
}