package com.vci.ubcs.code.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;

import com.vci.ubcs.code.dto.CodeClassifyValueDTO;
import com.vci.ubcs.code.entity.CodeBasicSec;
import com.vci.ubcs.code.entity.CodeClassifyValue;
import com.vci.ubcs.code.enumpack.*;
import com.vci.ubcs.code.mapper.CodeClassifyValueMapper;
import com.vci.ubcs.code.service.ICodeBasicSecService;
import com.vci.ubcs.code.service.ICodeClassifyValueService;
import com.vci.ubcs.code.vo.pagemodel.CodeClassifyValueVO;
import com.vci.ubcs.code.wrapper.CodeClassifyValueWrapper;
import com.vci.ubcs.starter.exception.VciBaseException;
import com.vci.ubcs.starter.revision.model.TreeQueryObject;
import com.vci.ubcs.starter.revision.model.TreeWrapperOptions;
import com.vci.ubcs.starter.revision.service.RevisionModelUtil;
import com.vci.ubcs.starter.util.DefaultAttrAssimtUtil;
import com.vci.ubcs.starter.util.MdmBtmTypeConstant;
import com.vci.ubcs.starter.web.pagemodel.Tree;
import com.vci.ubcs.starter.web.util.BeanUtilForVCI;
import com.vci.ubcs.starter.web.util.VciBaseUtil;
import org.springblade.core.secure.utils.AuthUtil;
import org.springblade.core.tool.api.R;
import org.springblade.core.tool.utils.Func;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import javax.annotation.Resource;
import java.rmi.ServerException;
import java.util.*;
import java.util.stream.Collectors;

import static com.vci.ubcs.code.constant.FrameWorkDefaultValueConstant.LC_STATUS;
import static com.vci.ubcs.code.constant.FrameWorkLangCodeConstant.DATA_CASCADE_LINKED_NOT_DELETE;
import static com.vci.ubcs.code.constant.FrameWorkLangCodeConstant.DATA_OID_NOT_EXIST;

@Service
public class CodeClassifyValueServiceImpl extends ServiceImpl<CodeClassifyValueMapper, CodeClassifyValue> implements ICodeClassifyValueService {

	@Resource
	private RevisionModelUtil revisionModelUtil;

	@Resource
	private CodeClassifyValueMapper codeClassifyValueMapper;

	@Resource
	@Lazy
	private ICodeBasicSecService codeBasicSecService;

	/**
	 * 上级节点的属性名称
	 */
	private static final String PARENT_FIELD_NAME = "parentClassifyValueOid";

	/**
	 * 克隆分类码值
	 * @param codeClassifyValues
	 * @return
	 */
	@Override
	public boolean cloneCodeClassifyVaue(List<CodeClassifyValue> codeClassifyValues) {
		// 创建Map对象，用于存储原始oid和新oid的映射关系
		Map<String, String> oidMap = new HashMap<>();
		// 遍历对象数组，为每个对象生成新的oid，并将原始oid和新oid的映射关系存储到Map中
		for (CodeClassifyValue obj : codeClassifyValues) {
			String originalOid = obj.getOid();
			String newOid = VciBaseUtil.getPk();
			oidMap.put(originalOid, newOid);
		}
		// 遍历对象数组，更新每个对象的oid和codeClassifySecOid属性值
		for (CodeClassifyValue obj : codeClassifyValues) {
			String originalOid = obj.getOid();
			String newOid = oidMap.get(originalOid);
			obj.setOid(newOid);
			String originalParentClassifyValueOid = obj.getParentClassifyValueOid();
			String newParentClassifyValueOid = oidMap.get(originalParentClassifyValueOid);
			obj.setParentClassifyValueOid(newParentClassifyValueOid);
		}
		return this.saveBatch(codeClassifyValues);
	}

	/**
	 * 查询分类码段的码值 树
	 * @param treeQueryObject 树查询对象
	 * @return 分类码段的码值 显示树
	 * @throws VciBaseException 查询条件不符合要求的时候会抛出异常
	 */
	@Override
	public List<Tree> treeCodeClassifyValue(TreeQueryObject treeQueryObject) throws VciBaseException {
		List<CodeClassifyValue> doList = selectCodeClassifyValueDO4Tree(treeQueryObject);
		List<CodeClassifyValueVO> voList = CodeClassifyValueWrapper.build().listVO(doList);
		TreeWrapperOptions treeWrapperOptions = new TreeWrapperOptions(PARENT_FIELD_NAME);
		treeWrapperOptions.copyFromTreeQuery(treeQueryObject);
		return revisionModelUtil.doList2Trees(voList,treeWrapperOptions,(CodeClassifyValueVO s) ->{
			//可以在这里处理树节点的显示
			return (Func.isNotEmpty(s.getId()) ? s.getId():"") + " " + (Func.isNotEmpty(s.getName()) ? s.getName():"") + (FrameworkDataLCStatus.DISABLED.getValue().equalsIgnoreCase(s
				.getLcStatus()) ? (" 【停用】 ") : "");
		});
	}

	/**
	 * 增加分类码段的码值
	 * @param codeClassifyValueDTO 分类码段的码值数据传输对象
	 * @return 执行结果
	 * @throws VciBaseException 参数为空，唯一项，必输项不通过时会抛出异常
	 */
	@Override
	@Transactional(rollbackFor = Exception.class)
	public boolean addSave(CodeClassifyValueDTO codeClassifyValueDTO) throws VciBaseException{
		VciBaseUtil.alertNotNull(codeClassifyValueDTO,"需要添加的数据对象");
		//添加对码值子父级的判断
		if(StringUtils.isNotBlank(codeClassifyValueDTO.getParentClassifyValueOid())){
			String parentclassifyvalueoid = codeClassifyValueDTO.getParentClassifyValueOid();
			String codeclassifysecoid = codeClassifyValueDTO.getCodeClassifySecOid();
			CodeClassifyValue parentDO = codeClassifyValueMapper.selectById(parentclassifyvalueoid);
			if (parentDO.getCodeClassifySecOid().equalsIgnoreCase(codeclassifysecoid)){
				throw new VciBaseException("不允许在父码值中直接添加子码值");
			}
		}
		//将DTO转换为DO
		CodeClassifyValue codeClassifyValueDO = new CodeClassifyValue();
		BeanUtilForVCI.copyPropertiesIgnoreCase(codeClassifyValueDTO,codeClassifyValueDO);
		//填充一些默认值
		DefaultAttrAssimtUtil.addDefaultAttrAssimt(codeClassifyValueDO, MdmBtmTypeConstant.CODE_CLASSIFY_VALUE);
		LambdaQueryWrapper<CodeClassifyValue> wrapper = Wrappers.<CodeClassifyValue>query()
			.lambda().eq(CodeClassifyValue::getCodeClassifySecOid, codeClassifyValueDO.getCodeClassifySecOid());
		if(Func.isEmpty(codeClassifyValueDO.getParentClassifyValueOid())){
			wrapper.isNull(CodeClassifyValue::getParentClassifyValueOid);
		}else{
			wrapper.eq(CodeClassifyValue::getParentClassifyValueOid, codeClassifyValueDO.getParentClassifyValueOid());
		}
		//查询
		List<CodeClassifyValue> existList = codeClassifyValueMapper.selectList(wrapper);
		codeClassifyValueDO.setOrderNum(existList.size() + 1);
		boolean resBoolean = codeClassifyValueMapper.insert(codeClassifyValueDO) > 0;
		return resBoolean;
	}

	/**
	 * 修改分类码段的码值
	 * @param codeClassifyValueDTO 分类码段的码值数据传输对象
	 * @return 执行结果
	 * @throws VciBaseException 参数为空，唯一项，必输项不通过时会抛出异常
	 */
	@Override
	@Transactional(rollbackFor = Exception.class)
	public boolean editSave(CodeClassifyValueDTO codeClassifyValueDTO) throws VciBaseException{
		VciBaseUtil.alertNotNull(codeClassifyValueDTO,"数据对象",codeClassifyValueDTO.getOid(),"分类码段的码值主键");
		//将DTO转换为DO
		CodeClassifyValue codeClassifyValueDO = selectByOid(codeClassifyValueDTO.getOid());
		revisionModelUtil.copyFromDTOIgnore(codeClassifyValueDTO,codeClassifyValueDO);
		//填充一些默认值
		DefaultAttrAssimtUtil.updateDefaultAttrAssimt(codeClassifyValueDO);
		boolean resBoolean = codeClassifyValueMapper.updateById(codeClassifyValueDO) > 0;
		return resBoolean;
	}

	/**
	 * 检查 分类码段的码值是否删除
	 * @param codeClassifyValueDTO 分类码段的码值数据传输对象，必须要有oid和ts属性
	 * @return 执行结果 success为true为可以删除，false表示有数据引用，obj为true表示有下级
	 * @throws VciBaseException 参数为空，被引用时抛出异常
	 */
	@Override
	public R checkIsCanDelete(CodeClassifyValueDTO codeClassifyValueDTO) throws VciBaseException{
		VciBaseUtil.alertNotNull(codeClassifyValueDTO,"数据传输对象",codeClassifyValueDTO.getOid(),"主键");
		CodeClassifyValue codeClassifyValueDO = selectByOid(codeClassifyValueDTO.getOid());
		return checkIsCanDeleteForDO(codeClassifyValueDTO,codeClassifyValueDO);
	}

	/**
	 * 校验是否可以删除，如果存在下级，并且下级有数据引用则不能删除
	 * @param codeClassifyValueDTO 数据传输对象
	 * @param codeClassifyValueDO 数据库中的数据对象
	 * @return success为true为可以删除，false表示有数据引用，obj为true表示有下级
	 */
	private R checkIsCanDeleteForDO(CodeClassifyValueDTO codeClassifyValueDTO, CodeClassifyValue codeClassifyValueDO) {
		//boService.checkTs(codeClassifyValueDTO);
		//校验下级是否有引用
		if(checkChildIsLinked(codeClassifyValueDO.getOid())){
			return R.fail(DATA_CASCADE_LINKED_NOT_DELETE);
		}
		return R.status(checkHasChild(codeClassifyValueDO.getOid()));
	}

	/**
	 * 检查是否有下级是否关联了数据
	 *
	 * @param oid 主键
	 * @return true 表示有引用，false表示没有引用
	 * @throws VciBaseException 参数为空和有引用的时候会抛出异常
	 */
	@Override
	public boolean checkChildIsLinked(String oid) throws VciBaseException {
		VciBaseUtil.alertNotNull(oid,"主键");
		List<String> childOids = codeClassifyValueMapper.selectAllLevelChildOid(oid.trim());
		if(!CollectionUtils.isEmpty(childOids)){
			for(String childOid: childOids){
				if(!checkIsLinked(childOid)){
					return false;
				}
			}
			return true;
		}
		return false;
	}

	/**
	 * 校验是否有下级节点，不校验是否关联了数据
	 *
	 * @param oid 主键
	 * @return true表示有下级，false表示没有下级
	 * @throws VciBaseException 参数错误，或者数据不存在的时候会抛出异常
	 */
	@Override
	public boolean checkHasChild(String oid) throws VciBaseException {
		VciBaseUtil.alertNotNull(oid,"主键");
		return codeClassifyValueMapper.countAllLevelChildOid(oid.trim()) > 0;
	}

	/**
	 * 校验是否被引用
	 * @param oid 主键
	 * @throws VciBaseException 被引用的时候会抛出异常
	 */
	private boolean checkIsLinked(String oid) throws VciBaseException{
		//TODO 添加需要校验引用的地方
		return false;
	}

	/**
	 * 删除分类码段的码值
	 * @param codeClassifyValueDTO 分类码段的码值数据传输对象，oid和ts需要传输
	 * @return 删除结果反馈：：success：成功，fail：失败
	 * @throws VciBaseException 参数为空，被引用时抛出异常
	 */
	@Override
	@Transactional(rollbackFor = Exception.class)
	public R deleteCodeClassifyValue(CodeClassifyValueDTO codeClassifyValueDTO) throws VciBaseException{
		VciBaseUtil.alertNotNull(codeClassifyValueDTO,"分类码段的码值数据对象",codeClassifyValueDTO.getOid(),"分类码段的码值的主键");
		CodeClassifyValue codeClassifyValueDO = selectByOid(codeClassifyValueDTO.getOid());
		R baseResult = checkIsCanDeleteForDO(codeClassifyValueDTO,codeClassifyValueDO);
		if(baseResult.isSuccess()) {
			//先删除下级码值，找下级的，这个是可以删除的时候
			List<String> childrenOids = codeClassifyValueMapper.selectChildOid(codeClassifyValueDO.getOid().trim());
			if (!CollectionUtils.isEmpty(childrenOids)) {
				Collection<Collection<String>> childrenCollections = VciBaseUtil.switchCollectionForOracleIn(childrenOids);
				for(Collection<String> s : childrenCollections){
					codeClassifyValueMapper.deleteBatchIds(s);
				}
			}
		}
		//执行删除操作，再删除父的码值
		boolean resBoolean = codeClassifyValueMapper.deleteById(codeClassifyValueDO.getOid()) > 0;
		return R.status(resBoolean);
	}

	/**
	 * 主键获取分类码段的码值
	 * @param oid 主键
	 * @return 分类码段的码值显示对象
	 * @throws VciBaseException 参数为空，数据不存在时会抛出异常
	 */
	@Override
	public  CodeClassifyValueVO getObjectByOid(String oid) throws VciBaseException{
		return CodeClassifyValueWrapper.build().entityVO(selectByOid(oid));
	}

	/**
	 * 主键批量获取分类码段的码值
	 * @param oidCollections 主键集合，但是受性能影响，建议一次查询不超过10000个
	 * @return 分类码段的码值显示对象
	 * @throws VciBaseException 查询出现异常时会抛出
	 */
	@Override
	public Collection<CodeClassifyValueVO> listCodeClassifyValueByOids(Collection<String> oidCollections) throws VciBaseException{
		VciBaseUtil.alertNotNull(oidCollections,"数据对象主键集合");
		List<CodeClassifyValue> codeClassifyValueDOList = listCodeClassifyValueDOByOidCollections(oidCollections);
		return CodeClassifyValueWrapper.build().listVO(codeClassifyValueDOList);
	}

	/**
	 * 参照树 分类码段的码值
	 * @param treeQueryObject 树形查询对象
	 * @return 分类码段的码值显示树
	 * @throws VciBaseException 查询条件和分页出错的时候会抛出异常
	 */
	@Override
	public List<Tree> referTree(TreeQueryObject treeQueryObject)  throws VciBaseException {
		if(treeQueryObject == null){
			treeQueryObject = new TreeQueryObject();
		}
		if(treeQueryObject.getConditionMap() == null){
			treeQueryObject.setConditionMap(new HashMap<>());
		}
		if(treeQueryObject.getConditionMap().containsKey(LC_STATUS)) {
			treeQueryObject.getConditionMap().remove(LC_STATUS);
		}
		return treeCodeClassifyValue(treeQueryObject);
	}

	/**
	 * 批量添加分类码段的码值。主要是保存码值的序号
	 * @param dtoList 分类码段的码值列表
	 * @param codeclassifysecoid 分类码段的主键
	 * @return 执行结果
	 */
	@Override
	@Transactional(rollbackFor = Exception.class)
	public R batchSave4Order(List<CodeClassifyValueDTO> dtoList, String codeclassifysecoid) throws VciBaseException{
		VciBaseUtil.alertNotNull(codeclassifysecoid,"分类码段主键");
		List<CodeClassifyValue> valueDOList = codeClassifyValueMapper.selectList(Wrappers.<CodeClassifyValue>query()
			.lambda().eq(CodeClassifyValue::getCodeClassifySecOid,codeclassifysecoid)
		);

		List<CodeClassifyValue> updateList = new ArrayList<>();
		dtoList.forEach(dto -> {
			if(StringUtils.isNotBlank(dto.getOid())){
				List<CodeClassifyValue> collect = valueDOList.stream().filter(value -> {
					return dto.getOid().equals(value.getOid());
				}).collect(Collectors.toList());
				collect.forEach(ccv -> {
					ccv.setOrderNum(dto.getOrderNum());
					ccv.setId(dto.getId());
					ccv.setName(dto.getName());
					updateList.add(ccv);
				});
			}
		});
		if(updateList.isEmpty()){
			return R.fail("该操作有误【待操作集合为空】。");
		}
		boolean resBoolean = this.updateBatchById(updateList);
		return R.status(resBoolean);
	}

	/**
	 * 使用主键集合查询数据对象
	 * @param oidCollections 主键的集合
	 * @return 数据对象列表
	 */
	private List<CodeClassifyValue> listCodeClassifyValueDOByOidCollections(Collection<String> oidCollections){
		List<CodeClassifyValue> codeClassifyValueDOList = new ArrayList<CodeClassifyValue>();
		if(!CollectionUtils.isEmpty(oidCollections)){
			Collection<Collection<String>> oidCollectionsList = VciBaseUtil.switchCollectionForOracleIn(oidCollections);
			for(Collection<String> oids: oidCollectionsList){
				List<CodeClassifyValue> tempDOList =  codeClassifyValueMapper.selectBatchIds(oids);
				if(!CollectionUtils.isEmpty(tempDOList)){
					codeClassifyValueDOList.addAll(tempDOList);
				}
			}
		}
		return  codeClassifyValueDOList;
	}

	/**
	 * 主键查询数据对象
	 * @param oid 主键
	 * @return  数据对象
	 * @throws VciBaseException 参数为空，并且数据不存在的时候会抛出异常
	 */
	private CodeClassifyValue selectByOid(String oid) throws VciBaseException{
		VciBaseUtil.alertNotNull(oid,"主键");
		CodeClassifyValue codeClassifyValueDO = codeClassifyValueMapper.selectById(oid.trim());
		if(codeClassifyValueDO == null || StringUtils.isBlank(codeClassifyValueDO.getOid())){
			throw new VciBaseException(DATA_OID_NOT_EXIST);
		}
		return codeClassifyValueDO;
	}

	private List<CodeClassifyValue> selectCodeClassifyValueDO4Tree(TreeQueryObject treeQueryObject){
		Map<String, String> conditionMap = treeQueryObject.getConditionMap();
		List<String> oids = codeBasicSecService.getOidByCodeclassifysecOid(conditionMap.get("codeclassifysecoid"));
		LambdaQueryWrapper<CodeClassifyValue> wrapper = Wrappers.<CodeClassifyValue>query()
			.lambda().in(CodeClassifyValue::getCodeClassifySecOid,oids)
			.orderByAsc(CodeClassifyValue::getOrderNum);
		return codeClassifyValueMapper.selectList(wrapper);
	}

	/**
	 * 使用码段的主键获取分类的码值内容
	 *
	 * @param classifySecOid         码段的主键
	 * @param parentClassifyValueOid 上级分类的主键
	 * @return 分类码值的内容
	 */
	@Override
	public List<CodeClassifyValueVO> listCodeClassifyValueBySecOid(String classifySecOid, String parentClassifyValueOid) {
		if(StringUtils.isBlank(classifySecOid)){
			return new ArrayList<>();
		}
		CodeBasicSec secDO = codeBasicSecService.getById(classifySecOid);
		if(secDO == null || StringUtils.isBlank(secDO.getOid())){
			throw new VciBaseException("码段的内容在系统中不存在");
		}
		if(StringUtils.isNotBlank(secDO.getParentClassifySecOid()) && StringUtils.isBlank(parentClassifyValueOid)){
			return new ArrayList<>();
			//因为有上级分类的时候，必须先选择上级分类的内容
		}
//		Map<String,String> conditionMap = new HashMap<>();
//		conditionMap.put("codeClassifySecOid",classifySecOid);
//		if(StringUtils.isNotBlank(parentClassifyValueOid)){
//			conditionMap.put("parentClassifyValueOid",parentClassifyValueOid);
//		}
//		PageHelper pageHelper = new PageHelper(-1);
//		pageHelper.addDefaultAsc("ordernum");
		QueryWrapper<CodeClassifyValue> wrapper = new QueryWrapper<>();
		wrapper.eq("codeClassifySecOid",classifySecOid);
		if(StringUtils.isNotBlank(parentClassifyValueOid)){
			wrapper.in("parentClassifyValueOid",VciBaseUtil.str2List(parentClassifyValueOid));
		}
		wrapper.orderByAsc("ordernum");

		List<CodeClassifyValue> valueDOList = codeClassifyValueMapper.selectList(wrapper);
		return codeClassifyValueDO2VOs(valueDOList);
	}

	/**
	 * 根据主键获取码值字符串
	 * @param oid
	 * @return
	 */
	@Override
	public String getClassifyValueStr(String oid){
		if(Func.isEmpty(oid)){
			return "";
		}
		String classifyValueStr = this.codeClassifyValueMapper.getClassifyValueStr(oid);
		return Func.isEmpty(classifyValueStr) ? "":classifyValueStr;
	}

	/**
	 * 批量数据对象转换为显示对象
	 * @param codeClassifyValueDOs 数据对象列表
	 * @return 显示对象
	 * @throws VciBaseException 参数为空或者不存在的时候会抛出异常
	 */
	@Override
	public List<CodeClassifyValueVO> codeClassifyValueDO2VOs(Collection<CodeClassifyValue>  codeClassifyValueDOs) throws VciBaseException{
		List<CodeClassifyValueVO> voList = new ArrayList<CodeClassifyValueVO>();
		if(!CollectionUtils.isEmpty(codeClassifyValueDOs)){
			for(CodeClassifyValue s: codeClassifyValueDOs){
				CodeClassifyValueVO vo =  codeClassifyValueDO2VO(s);
				if(vo != null){
					voList.add(vo);
				}
			}
		}
		return voList;
	}

	/**
	 * 根据codeClassifySecOid删除码值
	 * @param codeClassifySecOid
	 * @return
	 * @throws ServerException
	 */
	@Override
	public Boolean deleteClassifyValueBySecOid(String codeClassifySecOid) throws ServerException {
		LambdaQueryWrapper<CodeClassifyValue> wrapper = Wrappers.<CodeClassifyValue>query()
			.lambda().eq(CodeClassifyValue::getCodeClassifySecOid, codeClassifySecOid);
		return codeClassifyValueMapper.delete(wrapper) > 0;
	}

	/**
	 * 数据对象转换为显示对象
	 * @param  codeClassifyValueDO 数据对象
	 * @return 显示对象
	 * @throws VciBaseException 拷贝属性出错的时候会抛出异常
	 */
	@Override
	public  CodeClassifyValueVO codeClassifyValueDO2VO(CodeClassifyValue codeClassifyValueDO) throws VciBaseException{
		CodeClassifyValueVO vo = new CodeClassifyValueVO();
		if(codeClassifyValueDO != null){
			BeanUtilForVCI.copyPropertiesIgnoreCase(codeClassifyValueDO,vo);
			//如果有lcstatus的类的话

		}
		return vo;
	}
}