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

import com.alibaba.cloud.commons.lang.StringUtils;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.nacos.api.exception.NacosException;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.vci.ubcs.omd.constant.BtmTypeConstant;
import com.vci.ubcs.omd.dto.BtmAndLinkTypeDdlDTO;
import com.vci.ubcs.omd.dto.TableAddColumnDTO;
import com.vci.ubcs.omd.dto.TableCheckDTO;
import com.vci.ubcs.omd.dto.TableCheckResultDTO;
import com.vci.ubcs.omd.entity.BtmType;
import com.vci.ubcs.omd.entity.LinkType;
import com.vci.ubcs.omd.entity.LinkTypeAttribute;
import com.vci.ubcs.omd.entity.ModifyAttributeInfo;
import com.vci.ubcs.omd.mapper.LinkTypeMapper;
import com.vci.ubcs.omd.repeater.DomainRepeater;
import com.vci.ubcs.omd.service.*;
import com.vci.ubcs.omd.vo.*;
import com.vci.ubcs.omd.wrapper.LinkTypeAttributeWrapper;
import com.vci.ubcs.omd.wrapper.LinkTypeWrapper;
import com.vci.ubcs.starter.exception.VciBaseException;
import com.vci.ubcs.starter.web.constant.RegExpConstant;
import com.vci.ubcs.starter.web.pagemodel.PageHelper;
import com.vci.ubcs.starter.web.util.VciBaseUtil;
import com.vci.ubcs.starter.web.util.VciDateUtil;
import org.springblade.core.launch.constant.AppConstant;
import org.springblade.core.mp.support.Condition;
import org.springblade.core.mp.support.Query;
import org.springblade.core.secure.utils.AuthUtil;
import org.springblade.core.tool.api.R;
import org.springblade.core.tool.utils.BeanUtil;
import org.springblade.core.tool.utils.Func;
import org.springblade.core.tool.utils.StringPool;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cglib.beans.BeanMap;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.stereotype.Service;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.DefaultTransactionDefinition;
import org.springframework.util.CollectionUtils;

import javax.validation.constraints.NotEmpty;
import java.util.*;
import java.util.stream.Collectors;

/**
 * Description: 链接类型的服务
 *
 * @author LiHang
 * @date 2023/5/24
 */
@Service
public class LinkTypeServiceImpl extends ServiceImpl<LinkTypeMapper, LinkType> implements ILinkTypeService {
	/**
	 * 链接类型关联属性的服务
	 */
	@Autowired
	private ILinkTypeAttributeService linkTypeAttributeService;

	/**
	 * 业务类型服务
	 */
	@Autowired
	private IBtmTypeService btmTypeService;

	/**
	 * 属性的服务
	 */
	@Autowired
	private IAttributeService attributeService;

	/**
	 * 事务
	 */
	@Autowired
	private DataSourceTransactionManager dataSourceTransactionManager;

	/**
	 * 更改的属性信息服务
	 */
	@Autowired
	private IModifyAttributeService modifyAttributeService;

	/**
	 * 表名前缀
	 */
	public static final String PL = "PLLT";


	/**
	 * 获取链接类型列表
	 *
	 * @param conditionMap 查询条件
	 * @param pageHelper   分页信息和排序信息，默认使用id排序
	 * @return 链接类型对象列表
	 * @throws VciBaseException 查询出错时会抛出异常
	 */
	@Override
	public IPage<LinkTypeVO> listLinkType(Map<String, String> conditionMap, PageHelper pageHelper) throws VciBaseException {
		if (conditionMap == null){
			conditionMap = new HashMap<>(16);
		}
		if (pageHelper == null) {
			pageHelper = new PageHelper(-1);
		}
		LinkType queryObj = new LinkType();
		BeanMap.create(queryObj).putAll(conditionMap);
		Query query = new Query();
		query.setCurrent(pageHelper.getPage());
		query.setSize(pageHelper.getLimit());

		return LinkTypeWrapper.build().pageVO(baseMapper.selectPage(Condition.getPage(query),Condition.getQueryWrapper(queryObj).lambda().orderByAsc(LinkType::getId)));
	}

	/**
	 * 根据主键获取链接类型
	 *
	 * @param pkLinkType 链接类型主键
	 * @return 链接类型，如果不存在会返回null
	 * @throws VciBaseException 参数为空或者查询出错时会抛出错误
	 */
	@Override
	public LinkTypeVO getLinkTypeByOid(String pkLinkType) throws VciBaseException {
		VciBaseUtil.alertNotNull(pkLinkType,"链接类型的主键");
		List<LinkTypeVO> linkTypeVOList = listLinkTypeByOids(pkLinkType);
		if(!CollectionUtils.isEmpty(linkTypeVOList)){
			return linkTypeVOList.get(0);
		}
		return null;
	}

	/**
	 * 根据主键批量获取链接类型
	 *
	 * @param pkLinkTypes 链接类型主键，用逗号分隔
	 * @return 链接类型列表，如果有不存在的不会返回，全部不存在的则返回空列表
	 * @throws VciBaseException 参数为空或者查询出错时会抛出错误
	 */
	@Override
	public List<LinkTypeVO> listLinkTypeByOids(String pkLinkTypes) throws VciBaseException {
		VciBaseUtil.alertNotNull(pkLinkTypes,"链接类型的主键");
		List<String> pkList = Func.toStrList(",",pkLinkTypes);
		return listLinkTypeByOidCollection(pkList);
	}

	/**
	 * 批量根据主键获取链接类型
	 *
	 * @param pkLinkTypeCollection 链接类型主键集合
	 * @return 链接类型列表，如果有不存在的不会返回，全部不存在的则返回空列表
	 * @throws VciBaseException 参数为空或者查询出错时会抛出错误
	 */
	@Override
	public List<LinkTypeVO> listLinkTypeByOidCollection(Collection<String> pkLinkTypeCollection) throws VciBaseException {
		if(!CollectionUtils.isEmpty(pkLinkTypeCollection)){
			List<LinkType> linkTypeDOList = listLinkTypeDOByOidCollection(pkLinkTypeCollection);
			if(!CollectionUtils.isEmpty(linkTypeDOList)) {
				Map<String,List<LinkTypeAttributeVO>> pkLinkTypeAndAttributeMap = linkTypeAttributeService.batchGetAttributesNoDefault(linkTypeDOList);
				return LinkTypeWrapper.build().listEntityVO(linkTypeDOList,pkLinkTypeAndAttributeMap);
			}
		}
		return null;
	}

	/**
	 * 根据主键集合批量获取数据对象
	 * @param oidCollection 主键集合
	 * @return 业务类型列表，如果有不存在的不会返回，全部不存在的则返回空列表
	 * @throws VciBaseException  参数为空或者查询出错时会抛出错误
	 */
	private List<LinkType> listLinkTypeDOByOidCollection(Collection<String> oidCollection) throws VciBaseException {
		if(!CollectionUtils.isEmpty(oidCollection)){
			List<LinkType> linkTypeDOList = new ArrayList<>();
			Collection<Collection<String>> pksCollections = VciBaseUtil.switchCollectionForOracleIn(oidCollection);
			if(CollectionUtils.isEmpty(pksCollections)) {
				return linkTypeDOList;
			}
			pksCollections.forEach(s -> {
				List<LinkType> linkTypeDOS = baseMapper.selectList(Wrappers.<LinkType>query().lambda().in(LinkType::getOid, s));
				if(!CollectionUtils.isEmpty(linkTypeDOS)){
					linkTypeDOList.addAll(linkTypeDOS);
				}
			});
			return linkTypeDOList;
		}
		return null;
	}

	/**
	 * 根据英文名称获取链接类型
	 *
	 * @param id 英文名称
	 * @return 链接类型，如果不存在会返回null
	 * @throws VciBaseException
	 */
	@Override
	public LinkTypeVO getLinkTypeById(String id) throws VciBaseException {
		VciBaseUtil.alertNotNull(id,"链接类型的英文名称");
		List<LinkTypeVO> linkTypeVOList = listLinkTypeByIds(id);
		if(CollectionUtils.isEmpty(linkTypeVOList)){
			return null;
		}
		return linkTypeVOList.get(0);
	}

	/**
	 * 根据英文名称批量获取链接类型
	 *
	 * @param ids 英文名称，使用逗号分隔
	 * @return 链接类型列表，如果有不存在的不会返回，全部不存在的则返回空列表
	 * @throws VciBaseException 参数为空或者查询出错时会抛出错误
	 */
	@Override
	public List<LinkTypeVO> listLinkTypeByIds(String ids) throws VciBaseException {
		VciBaseUtil.alertNotNull(ids,"链接类型的英文名称");
		List<String> idList = Func.toStrList(",",ids);
		return listLinkTypeByIdCollection(idList);
	}

	/**
	 * 根据英文名称集合批量获取链接类型
	 *
	 * @param linkTypeIdCollection 英文名称集合，使用逗号分隔
	 * @return 链接类型列表，如果有不存在的不会返回，全部不存在的则返回空列表
	 * @throws VciBaseException 参数为空或者查询出错时会抛出错误
	 */
	@Override
	public List<LinkTypeVO> listLinkTypeByIdCollection(Collection<String> linkTypeIdCollection) throws VciBaseException {
		if(!CollectionUtils.isEmpty(linkTypeIdCollection)){
			List<LinkType> linkTypeDOList = listLinkTypeDOByIdCollection(linkTypeIdCollection);
			if(!CollectionUtils.isEmpty(linkTypeDOList)) {
				Map<String,List<LinkTypeAttributeVO>> pkLinkTypeAndAttributeMap = linkTypeAttributeService.batchGetAttributesNoDefault(linkTypeDOList);
				return LinkTypeWrapper.build().listEntityVO(linkTypeDOList, pkLinkTypeAndAttributeMap);
			}
		}
		return null;
	}

	/**
	 * 根据主键集合批量获取数据对象
	 * @param idCollection 英文名称集合
	 * @return 业务类型列表，如果有不存在的不会返回，全部不存在的则返回空列表
	 * @throws VciBaseException  参数为空或者查询出错时会抛出错误
	 */
	private List<LinkType> listLinkTypeDOByIdCollection(Collection<String> idCollection) throws VciBaseException {
		if(!CollectionUtils.isEmpty(idCollection)){
			List<LinkType> linkTypeDOList = new ArrayList<>();
			Collection<Collection<String>> pksCollections = VciBaseUtil.switchCollectionForOracleIn(idCollection);
			if(!CollectionUtils.isEmpty(pksCollections)) {
				pksCollections.forEach(s -> {
					List<LinkType> linkTypeDOS = baseMapper.selectList(Wrappers.<LinkType>query().lambda().in(LinkType::getId,s));
					if(!CollectionUtils.isEmpty(linkTypeDOS)){
						linkTypeDOList.addAll(linkTypeDOS);
					}
				});
			}
			return linkTypeDOList;
		}
		return null;
	}

	/**
	 * 获取链接类型的指定属性
	 *
	 * @param id                    链接类型的英文名称
	 * @param attributeIdCollection 属性的集合，如果为空则获取全部
	 * @return 属性的显示对象
	 */
	@Override
	public List<LinkTypeAttributeVO> listAttributeVOByIdsForLink(String id, Collection<String> attributeIdCollection) {
		//一个表里不会有1000个属性
		if(attributeIdCollection == null){
			attributeIdCollection = new ArrayList<>();
		}
		List<LinkTypeAttribute> attributeDOList = linkTypeAttributeService.list(Wrappers.<LinkTypeAttribute>query().lambda().in(LinkTypeAttribute::getId,attributeIdCollection));
		return LinkTypeAttributeWrapper.build().listEntityVO(attributeDOList);
	}

	/**
	 * 根据链接类型主键获取中文名称
	 *
	 * @param oid 链接类型主键
	 * @return 中文名称，如果不存在会返回null;多个会以逗号分隔
	 * @throws VciBaseException 参数为空或者查询出错时会抛出错误
	 */
	@Override
	public String getNameByOid(String oid) throws VciBaseException {
		VciBaseUtil.alertNotNull(oid,"链接类型主键");
		return baseMapper.selectOne(Wrappers.<LinkType>query().lambda().eq(LinkType::getOid,oid)).getName();
	}

	/**
	 * 根据链接类型英文名称获取中文名称
	 *
	 * @param id 链接类型英文名称
	 * @return 中文名称，如果不存在会返回null;多个会以逗号分隔
	 * @throws VciBaseException 参数为空或者查询出错时会抛出错误
	 */
	@Override
	public String getNameById(String id) throws VciBaseException {
		VciBaseUtil.alertNotNull(id,"链接类型英文名称");
		return baseMapper.selectOne(Wrappers.<LinkType>query().lambda().eq(LinkType::getId,id)).getName();
	}

	/**
	 * 根据业务类型主键获取包含的属性数据对象
	 * @param oidCollection 主键集合
	 * @return 属性数据对象
	 */
	private List<LinkTypeAttribute> listHasAttributeDOByOidCollection(Collection<String> oidCollection){
		VciBaseUtil.alertNotNull("业务类型主键",oidCollection);
		Collection<Collection<String>> oidCollections = VciBaseUtil.switchCollectionForOracleIn(oidCollection);
		List<LinkTypeAttribute> attributeDOList = new ArrayList<>();
		for(Collection<String> oids : oidCollections){
			List<LinkTypeAttribute> attributeDOs = linkTypeAttributeService.list(Wrappers.<LinkTypeAttribute>query().lambda().in(LinkTypeAttribute::getPkLinkType,oids));
			if(!CollectionUtils.isEmpty(attributeDOs)){
				attributeDOList.addAll(attributeDOs);
			}
		}
		return attributeDOList;
	}

	/**
	 * 添加链接类型
	 *
	 * @param linkTypeVO 链接类型显示对象（和DTO共用）
	 * @return 添加后的链接类型
	 * @throws VciBaseException 添加出错的时候会抛出异常
	 */
	@Override
	public LinkTypeVO addSave(LinkTypeVO linkTypeVO) throws VciBaseException {
		return addSave(linkTypeVO,true);
	}

	/**
	 * 添加链接类型
	 *
	 * @param linkTypeVO      链接类型显示对象（和DTO共用）
	 * @param autoCreateTable 自动创建表格
	 * @return 添加后的链接类型
	 * @throws VciBaseException 添加出错的时候会抛出异常
	 */
	@Override
	@Transactional
	public LinkTypeVO addSave(LinkTypeVO linkTypeVO, boolean autoCreateTable) throws VciBaseException {
		TransactionStatus transaction = null;
		if(autoCreateTable) {
			DefaultTransactionDefinition def = new DefaultTransactionDefinition();
			def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
			// 事物隔离级别，开启新事务，这样会比较安全些。
			transaction = dataSourceTransactionManager.getTransaction(def);
			// 获得事务状态
		}
		try {
			VciBaseUtil.alertNotNull(linkTypeVO, "要添加的链接类型",
				linkTypeVO.getId(), "链接类型的英文名称", linkTypeVO.getName(), "链接类型中文名称",
				linkTypeVO.getFromBtmType(),"from端的业务类型",linkTypeVO.getFromBtmTypeName(),"from端的业务类型的名称",
				linkTypeVO.getToBtmType(),"to端的业务类型",linkTypeVO.getToBtmType(),"to端的业务类型的名称");
			if (!linkTypeVO.getId().matches(RegExpConstant.LETTER)) {
				throw new VciBaseException("链接类型英文名称只能是纯英文，目前为{0}", new Object[]{linkTypeVO.getId()});
			}
			if (linkTypeVO.getId().length() > 24) {
				throw new VciBaseException("链接类型英文名称不能超过18，目前长度为{0}", new Object[]{linkTypeVO.getId().length()});
			}
			List<LinkType> linkTypeDOList = listLinkTypeDOByIdCollection(VciBaseUtil.str2List(linkTypeVO.getId()));
			if (!CollectionUtils.isEmpty(linkTypeDOList) && linkTypeDOList.size() > 0) {
				LinkType existLinkType= linkTypeDOList.get(0);
				throw new VciBaseException("链接类型英文名称已经存在（不区分大小写），这个英文名称对应的中文名称为{0},创建人{1},创建时间{2}"
					, new Object[]{existLinkType.getName(), existLinkType.getCreator(), VciDateUtil.date2Str(existLinkType.getCreateTime(), VciDateUtil.DateFormat)});
			}
			//检查使用的业务类型是否存在
			Set<String> usedBtmTypeSet = new HashSet<>();
			Collections.addAll(usedBtmTypeSet,linkTypeVO.getFromBtmType().split(","));
			Collections.addAll(usedBtmTypeSet,linkTypeVO.getToBtmType().split(","));

			List<BtmType> btmTypeDOList = btmTypeService.listBtmTypeDOByIdCollection(usedBtmTypeSet);
			if(CollectionUtils.isEmpty(btmTypeDOList)){
				throw new VciBaseException("链接类型使用的业务类型全部不存在，请查证");
			}
			Set<String> existBtmTypeIdSet = btmTypeDOList.stream().collect(Collectors.toMap(s -> s.getId().trim().toLowerCase(), t -> t)).keySet();
			String unExistBtmTypeId = usedBtmTypeSet.stream().filter(s -> !existBtmTypeIdSet.contains(s.toLowerCase().trim())).collect(Collectors.joining(","));
			if(StringUtils.isNotBlank(unExistBtmTypeId)){
				throw new VciBaseException("链接类型使用的业务类型{0}不存在，请查证",new Object[]{unExistBtmTypeId});
			}

			if (StringUtils.isBlank(linkTypeVO.getOid())) {
				linkTypeVO.setOid(VciBaseUtil.getPk());
			}
			LinkType linkTypeDO = new LinkType();
			BeanUtil.copy(linkTypeVO, linkTypeDO);
			if (StringUtils.isBlank(linkTypeDO.getTableName())){
				linkTypeDO.setTableName(getTableName(linkTypeDO.getId(),linkTypeDO.getDomain()));
			}
			String creator = AuthUtil.getUserAccount();
			Date now = new Date();
			LinkTypeWrapper.build().setBeforeInsert(linkTypeDO,creator,now);

			//处理属性
			List<LinkTypeAttributeVO> attributeVOList = addAttributeForLink(linkTypeVO.getAttributes(), linkTypeDO.getOid(), creator, now);

			baseMapper.insert(linkTypeDO);
			if(autoCreateTable) {
				LinkTypeVO typeVO = LinkTypeWrapper.build().entityVO(linkTypeDO);
				typeVO.setAttributes(attributeVOList);
				List<LinkTypeAttributeVO> attributes = typeVO.getAttributes();
				attributes.addAll(linkTypeAttributeService.getDefaultAttributes(typeVO));
				typeVO.setAttributes(attributes);
				R r = DomainRepeater.submitLinkType(typeVO.getDomain(), typeVO);
				if (!r.isSuccess()){
					dataSourceTransactionManager.rollback(transaction);
				}else {
					dataSourceTransactionManager.commit(transaction);
				}
			}
		}catch (VciBaseException e){
			if(autoCreateTable) {
				dataSourceTransactionManager.rollback(transaction);
			}
			throw e;
		}catch (Throwable e){
			if(autoCreateTable) {
				dataSourceTransactionManager.rollback(transaction);
			}
			throw e;
		}
		/*if(autoCreateTable) {
			checkTableSame(linkTypeVO);
		}*/
		return linkTypeVO;
	}

	/**
	 * 为链接类型添加属性
	 * @param attributesVOList 属性的显示对象列表
	 * @param pkLinkType 链接类型的主键
	 * @param creator 创建人
	 * @param now 当前时间
	 */
	private List<LinkTypeAttributeVO> addAttributeForLink(List<LinkTypeAttributeVO> attributesVOList,String pkLinkType,String creator,Date now){
		List<LinkTypeAttribute> linkTypeAttributeDOList = new ArrayList<>();
		if(!CollectionUtils.isEmpty(attributesVOList)) {
			List<String> attributeIdList = new ArrayList<>();
			attributesVOList.forEach(s -> {
				linkTypeAttributeService.checkAttribute(s);
				linkTypeAttributeDOList.add(LinkTypeAttributeWrapper.build().copyVO2DO(s, pkLinkType, creator, now));
				attributeIdList.add(s.getId().toLowerCase().trim());
			});
			//检查属性是否都存在
			attributeService.checkAttributeExists(attributeIdList);
			linkTypeAttributeService.saveOrUpdateBatch(linkTypeAttributeDOList,10000);
			return LinkTypeAttributeWrapper.build().listEntityVO(linkTypeAttributeDOList);
		}
		return null;
	}

	/**
	 * 检查链接类型的属性是否和数据库中相同
	 * @param linkTypeVO 链接类型的显示对象
	 */
	private void checkTableSame(LinkTypeVO linkTypeVO){
		List<LinkTypeVO> linkTypeVOList = new ArrayList<>();
		linkTypeVOList.add(linkTypeVO);
		BtmAndLinkTypeDdlDTO btmAndLinkTypeDdlDTO = new BtmAndLinkTypeDdlDTO();
		btmAndLinkTypeDdlDTO.setLinkTypeList(linkTypeVOList);
		List<ModifyAttributeInfo> modifyAttributeInfoDOList = new ArrayList<>();
		try {
			R result = DomainRepeater.checkDifferent(btmAndLinkTypeDdlDTO, AppConstant.APPLICATION_NAME_CODE);
			if (result.isSuccess()){
				Object dataList = result.getData();
				if (dataList instanceof  List){
					((List<?>) dataList).forEach(data -> {
						JSONObject jsonObject = JSON.parseObject(JSON.toJSONString(data));
						modifyAttributeInfoDOList.add(BeanUtil.copy(jsonObject,ModifyAttributeInfo.class));
					});
				}
			}
		} catch (NacosException e) {
			throw new RuntimeException(e);
		}
		if (!CollectionUtils.isEmpty(modifyAttributeInfoDOList)) {
			modifyAttributeService.saveOrUpdateBatch(modifyAttributeInfoDOList);
			modifyAttributeService.finishModify(modifyAttributeInfoDOList);
		}
	}

	/**
	 * 修改链接类型
	 *
	 * @param linkTypeVO 链接类型显示对象（和DTO共用）
	 * @return 修改后的链接类型
	 * @throws VciBaseException 修改出错的时候会抛出异常
	 */
	@Override
	public LinkTypeVO editSave(LinkTypeVO linkTypeVO) throws VciBaseException {
		return editSave(linkTypeVO,true);
	}

	/**
	 * 修改链接类型
	 *
	 * @param linkTypeVO      链接类型显示对象（和DTO共用）
	 * @param autoCreateTable 自动创建表格
	 * @return 修改后的链接类型
	 * @throws VciBaseException 修改出错的时候会抛出异常
	 */
	@Override
	public LinkTypeVO editSave(LinkTypeVO linkTypeVO, boolean autoCreateTable) throws VciBaseException {
		TransactionStatus transaction = null;
		if(autoCreateTable) {
			DefaultTransactionDefinition def = new DefaultTransactionDefinition();
			def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
			// 事物隔离级别，开启新事务，这样会比较安全些。
			transaction = dataSourceTransactionManager.getTransaction(def);
			// 获得事务状态
		}
		try{
			VciBaseUtil.alertNotNull(linkTypeVO, "要修改的链接类型", linkTypeVO.getOid(),"链接类型的主键",
				linkTypeVO.getId(), "链接类型的英文名称", linkTypeVO.getName(), "链接类型中文名称");
			if (!linkTypeVO.getId().matches(RegExpConstant.LETTER)) {
				throw new VciBaseException("链接类型英文名称只能是纯英文，目前为{0}", new Object[]{linkTypeVO.getId()});
			}
			if (linkTypeVO.getId().length() > 24) {
				throw new VciBaseException("链接类型英文名称不能超过18，目前长度为{0}", new Object[]{linkTypeVO.getId().length()});
			}
			List<LinkType> linkTypeDOList = listLinkTypeDOByIdCollection(VciBaseUtil.str2List(linkTypeVO.getId()));
			if (CollectionUtils.isEmpty(linkTypeDOList)) {
				throw new VciBaseException("这个链接类型{0}[{1}]在系统中不存在。或者请检查您是否修改了链接类型的英文名称（系统不允许修改英文名称，只可以修改英文名称字母的大小写）"
					,new Object[]{linkTypeVO.getId(),linkTypeVO.getName()});
			}
			LinkType linkTypeDO = linkTypeDOList.get(0);

			//检查使用的业务类型是否存在
			Set<String> usedBtmTypeSet = new HashSet<>();
			Collections.addAll(usedBtmTypeSet,linkTypeVO.getFromBtmType().split(","));
			Collections.addAll(usedBtmTypeSet,linkTypeVO.getToBtmType().split(","));

			List<BtmType> btmTypeDOList = btmTypeService.listBtmTypeDOByIdCollection(usedBtmTypeSet);
			if(CollectionUtils.isEmpty(btmTypeDOList)){
				throw new VciBaseException("链接类型使用的业务类型全部不存在，请查证");
			}
			Set<String> existBtmTypeIdSet = btmTypeDOList.stream().collect(Collectors.toMap(s -> s.getId().trim().toLowerCase(), t -> t)).keySet();
			String unExistBtmTypeId = usedBtmTypeSet.stream().filter(s -> !existBtmTypeIdSet.contains(s.toLowerCase().trim())).collect(Collectors.joining(","));
			if(StringUtils.isNotBlank(unExistBtmTypeId)){
				throw new VciBaseException("链接类型使用的业务类型{0}不存在，请查证",new Object[]{unExistBtmTypeId});
			}
			String creator = AuthUtil.getUserAccount();
			Date now = new Date();
			linkTypeDO = LinkTypeWrapper.build().setBeforeUpdate(linkTypeDO,creator,now);
			//处理属性
			LinkTypeWrapper.build().copyLinkTypeVO2DO(linkTypeVO,linkTypeDO,creator,new Date());

			//先查询这个链接类型包含多少属性
			List<LinkTypeAttribute> hasAttributeList = linkTypeAttributeService.list(Wrappers.<LinkTypeAttribute>query().lambda().in(LinkTypeAttribute::getPkLinkType,Func.toStrList(",",linkTypeVO.getOid())));
			//处理属性
			addAttributeForLink(linkTypeVO.getAttributes(),linkTypeDO.getOid(),creator,now);

			if(!CollectionUtils.isEmpty(hasAttributeList)){
				//有属性的时候直接删除后再添加
				linkTypeAttributeService.batchDeleteByOids(hasAttributeList.stream().map(s->s.getOid()).collect(Collectors.toList()));
			}
			saveOrUpdate(linkTypeDO);
			if(autoCreateTable) {
				List<LinkTypeAttributeVO> defaultAttributes = linkTypeAttributeService.getDefaultAttributes(linkTypeVO);
				List<LinkTypeAttributeVO> attributes = linkTypeVO.getAttributes();
				attributes.addAll(defaultAttributes);
				linkTypeVO.setAttributes(attributes);
				BtmAndLinkTypeDdlDTO ddlDTO = new BtmAndLinkTypeDdlDTO();
				DomainRepeater.checkDifferent(ddlDTO,linkTypeVO.getDomain());
				dataSourceTransactionManager.commit(transaction);
			}
		} catch (Throwable e){
			if(autoCreateTable) {
				dataSourceTransactionManager.rollback(transaction);
			}
			throw new VciBaseException(e.getMessage());
		}
		/*if(autoCreateTable) {
			checkTableSame(linkTypeVO);
		}*/
		return linkTypeVO;
	}

	/**
	 * 删除链接类型
	 *
	 * @param linkTypeVO 链接类型显示对象
	 * @throws VciBaseException 如果链接类型被引用，或者删除出错时会抛出异常
	 */
	@Override
	public void delete(LinkTypeVO linkTypeVO) throws VciBaseException {
		VciBaseUtil.alertNotNull(linkTypeVO,"要删除的链接类型",linkTypeVO.getOid(),"要删除的链接类型的主键");
		List<LinkTypeVO> linkTypeVOList = new ArrayList<>();
		linkTypeVOList.add(linkTypeVO);
		batchDelete(linkTypeVOList);
	}

	/**
	 * 批量删除链接类型
	 *
	 * @param linkTypeVOList 要删除的链接类型显示对象列表
	 * @throws VciBaseException 如果链接类型被引用，或者删除出错时会抛出异常
	 */
	@Override
	public void batchDelete(List<LinkTypeVO> linkTypeVOList) throws VciBaseException {
		VciBaseUtil.alertNotNull("要删除的链接类型",linkTypeVOList);
		DefaultTransactionDefinition def = new DefaultTransactionDefinition();
		def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
		// 事物隔离级别，开启新事务，这样会比较安全些。
		TransactionStatus transaction= dataSourceTransactionManager.getTransaction(def);
		// 获得事务状态
		List<LinkType> linkTypeDOList = null;
		try {
			List<String> oidList = linkTypeVOList.stream().map(LinkTypeVO::getOid).collect(Collectors.toList());
			linkTypeDOList = listLinkTypeDOByOidCollection(oidList);
			//需要判断表格是否存在数据，
			if (CollectionUtils.isEmpty(linkTypeDOList)) {
				throw new VciBaseException("要删除的链接类型对象未在系统中找到");
			}
			List<TableCheckDTO> checkList = linkTypeDOList.stream().map(linkType -> {
				TableCheckDTO tableCheckDTO = new TableCheckDTO();
				tableCheckDTO.setBtmName(linkType.getId());
				tableCheckDTO.setTableName(getTableName(linkType.getId(),linkType.getDomain()));
				tableCheckDTO.setCheckTableHasData(true);
				tableCheckDTO.setNeedDelete(true);
				tableCheckDTO.setDomain(linkType.getDomain());
				return tableCheckDTO;
			}).collect(Collectors.toList());
			R result = DomainRepeater.checkTableHasDataByTableNameThenDrop(checkList);
			if (result.isSuccess()){
				JSONObject jsonObject = JSON.parseObject(JSON.toJSONString(result.getData()));
				TableCheckResultDTO tableCheckResult = BeanUtil.copy(jsonObject, TableCheckResultDTO.class);
				if (tableCheckResult == null){
					throw new VciBaseException("调用DDL服务失败");
				}
				List<String> successOidList = linkTypeDOList.stream().filter(s -> Optional.ofNullable(tableCheckResult.getSuccessList()).orElseGet(ArrayList::new).stream().anyMatch(r -> StringUtils.equals(s.getId(), r.getBtmName())))
					.map(LinkType::getOid).collect(Collectors.toList());
				if (!CollectionUtils.isEmpty(successOidList)) {
					//删除属性
					List<LinkTypeAttribute> hasAttributesList = listHasAttributeDOByOidCollection(successOidList);
					List<String> attributeOidList = hasAttributesList.stream().map(LinkTypeAttribute::getOid).collect(Collectors.toList());
					Collection<Collection<String>> attributeOidCollections = VciBaseUtil.switchCollectionForOracleIn(attributeOidList);
					for (Collection<String> attrOidCollection : attributeOidCollections) {
						linkTypeAttributeService.batchDeleteByOids(new ArrayList<>(attrOidCollection));
					}

					//删除链接类型
					Collection<Collection<String>> oidCollections = VciBaseUtil.switchCollectionForOracleIn(successOidList);
					for (Collection<String> oids : oidCollections) {
						baseMapper.delete(Wrappers.<LinkType>query().lambda().in(LinkType::getOid, oids));
					}
				}
				if (!CollectionUtils.isEmpty(tableCheckResult.getFailList())){
					throw new VciBaseException("链接类型:" + tableCheckResult.getFailList().stream().map(TableCheckDTO::getBtmName).collect(Collectors.joining("],[")) + "存在数据不能删除");
				}
			}else {
				throw new VciBaseException("没有找到DDL服务");
			}
			dataSourceTransactionManager.commit(transaction);
		} catch (NacosException e) {
			dataSourceTransactionManager.rollback(transaction);
			throw new RuntimeException(e);
		} catch (Throwable e){
			dataSourceTransactionManager.rollback(transaction);
			throw e;
		}

	}

	/**
	 * 为链接类型添加属性对象
	 *
	 * @param attributeVO 属性显示对象
	 * @throws VciBaseException 参数为空或者查询出错的时候会抛出异常
	 */
	@Override
	public void addSaveAttribute(LinkTypeAttributeVO attributeVO,String tableName,String serviceName) throws VciBaseException {
		addSaveAttribute(attributeVO,tableName,true,serviceName);
	}

	/**
	 * 为链接类型添加属性对象
	 *
	 * @param attributeVO   属性显示对象
	 * @param autoAdd2Table 是否自动添加到表格中
	 * @throws VciBaseException 参数为空或者查询出错的时候会抛出异常
	 */
	@Override
	public void addSaveAttribute(LinkTypeAttributeVO attributeVO,String tableName, boolean autoAdd2Table,String serviceName) throws VciBaseException {
		TransactionStatus transaction = null;
		if(autoAdd2Table) {
			DefaultTransactionDefinition def = new DefaultTransactionDefinition();
			def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
			// 事物隔离级别，开启新事务，这样会比较安全些。
			transaction = dataSourceTransactionManager.getTransaction(def);
		}
		try {
			linkTypeAttributeService.checkAttribute(attributeVO);
			LinkTypeAttribute attributeDO = new LinkTypeAttribute();
			if (StringUtils.isBlank(attributeVO.getOid())) {
				attributeVO.setOid(VciBaseUtil.getPk());
			}
			attributeVO.setPkLinkType(attributeVO.getPkLinkType());
			attributeVO.setCreator(AuthUtil.getUserAccount());
			attributeVO.setCreateTime(new Date());
			attributeVO.setOwner(attributeVO.getCreator());
			attributeVO.setBtmName(BtmTypeConstant.LINK_TYPE_ATTRIBUTE);
			attributeVO.setTs(attributeDO.getCreateTime());
			//查询链接类型是否存在
			checkLinkTypeExist(attributeVO.getPkLinkType());
			BeanUtil.copy(attributeVO, attributeDO);

			linkTypeAttributeService.saveOrUpdate(attributeDO);
			if (autoAdd2Table) {
				//执行添加属性列
				List<LinkTypeAttributeVO> attributeVOList = new ArrayList<>();
				attributeVOList.add(attributeVO);
				if (autoAdd2Table) {
					TableAddColumnDTO addColumnDTO = new TableAddColumnDTO();
					addColumnDTO.setTableName(tableName);
					addColumnDTO.setLinkTypeAttributeVOList(attributeVOList);
					R result = DomainRepeater.addColumnForTable(addColumnDTO, serviceName);
					if (result.isSuccess()) {
						dataSourceTransactionManager.commit(transaction);
					} else {
						dataSourceTransactionManager.rollback(transaction);

					}
				}
			}
		}catch (NacosException e){
			if(autoAdd2Table) {
				dataSourceTransactionManager.rollback(transaction);
			}
			throw new RuntimeException(e);
		}catch (Throwable e){
			if(autoAdd2Table) {
				dataSourceTransactionManager.rollback(transaction);
			}
			throw e;
		}
	}

	/**
	 * 检查某个主键的链接类型是否存在
	 *
	 * @param pkLinkType 链接类型主键
	 * @return true表示存在，false表示不存在
	 * @throws VciBaseException 查询出错或者参数为空的时候抛出异常
	 */
	@Override
	public boolean checkLinkTypeExist(String pkLinkType) throws VciBaseException {
		VciBaseUtil.alertNotNull(pkLinkType,"要校验是否存在的链接类型主键为空");
		String name = getNameByOid(pkLinkType);
		if(StringUtils.isBlank(name)){
			return false;
		}else{
			return true;
		}
	}

	/**
	 * 为链接类型修改属性对象
	 *
	 * @param attributeVO 属性显示对象
	 * @throws VciBaseException 参数为空或者查询出错的时候会抛出异常
	 */
	@Override
	public void editSaveAttribute(LinkTypeAttributeVO attributeVO,String tableName,String domain) throws VciBaseException {
		editSaveAttribute(attributeVO,tableName,domain,true);
	}

	/**
	 * 为链接类型修改属性对象
	 *
	 * @param attributeVO    属性显示对象
	 * @param autoEdit2Table 是否自动修改到表格
	 * @throws VciBaseException 参数为空或者查询出错的时候会抛出异常
	 */
	@Override
	public void editSaveAttribute(LinkTypeAttributeVO attributeVO,String tableName,String domain, boolean autoEdit2Table) throws VciBaseException {
		TransactionStatus transaction = null;
		if(autoEdit2Table) {
			DefaultTransactionDefinition def = new DefaultTransactionDefinition();
			def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
			// 事物隔离级别，开启新事务，这样会比较安全些。
			transaction = dataSourceTransactionManager.getTransaction(def);
		}
		try {
			VciBaseUtil.alertNotNull(attributeVO.getOid(), "使用属性的主键");
			linkTypeAttributeService.checkAttribute(attributeVO);
			LinkType linkTypeDO = baseMapper.selectOne(Wrappers.<LinkType>query().lambda().eq(LinkType::getOid, attributeVO.getPkLinkType()));
			if (linkTypeDO == null || StringUtils.isBlank(linkTypeDO.getOid())) {
				throw new VciBaseException("要修改的属性关联的链接类型不存在");
			}
			LinkTypeAttribute attributeDO = linkTypeAttributeService.selectByPrimaryKey(attributeVO.getOid());
			String creator = AuthUtil.getUserAccount();
			Date now = new Date();
			BeanUtil.copy(attributeVO, attributeDO);
			attributeDO.setPkLinkType(linkTypeDO.getOid());
			attributeDO.setLastModifier(creator);
			attributeDO.setLastModifyTime(now);
			attributeDO.setTs(now);

			attributeVO.setLastModifier(creator);
			attributeVO.setLastModifyTime(now);
			attributeVO.setTs(now);
			linkTypeAttributeService.saveOrUpdate(attributeDO);
			if (autoEdit2Table) {
				BtmAndLinkTypeDdlDTO ddlDTO = new BtmAndLinkTypeDdlDTO();
				LinkTypeVO linkTypeVO = LinkTypeWrapper.build().entityVO(linkTypeDO);
				ddlDTO.setLinkTypeList(Collections.singletonList(linkTypeVO));
				DomainRepeater.checkDifferent(ddlDTO,domain);
				dataSourceTransactionManager.commit(transaction);
			}
		}catch (NacosException e){
			if(autoEdit2Table) {
				dataSourceTransactionManager.rollback(transaction);
			}
			throw new RuntimeException(e);
		}catch (Throwable e){
			if(autoEdit2Table) {
				dataSourceTransactionManager.rollback(transaction);
			}
			throw e;
		}
	}

	/**
	 * 获取链接类型的数据库表名称
	 *
	 * @param id 链接类型的英文名称
	 * @param domain 领域值
	 * @return 数据库表名称
	 */
	@Override
	public String getTableName(String id,String domain) {
		VciBaseUtil.alertNotNull(id,"业务类型英文名称",domain,"领域名称");
		if (domain.contains("ubcs-")){
			domain = domain.split("ubcs-")[1];
		}else {
			throw new VciBaseException("领域名称不符合规则");
		}
		return PL + StringPool.UNDERSCORE + domain.toUpperCase(Locale.ROOT) + StringPool.UNDERSCORE + id.toUpperCase(Locale.ROOT);
	}

	/**
	 * 获取所有使用的业务类型的英文名称，转换为小写
	 *
	 * @return 英文名称英文小写
	 */
	@Override
	public Set<String> listUsedBtmType() {
		List<LinkType> allLinkTypeDOList = baseMapper.selectList(Wrappers.query());
		Set<String> btmTypeSet = new HashSet<>();
		if(!CollectionUtils.isEmpty(allLinkTypeDOList)){
			allLinkTypeDOList.stream().forEach( s -> {
				Collections.addAll(btmTypeSet,s.getFromBtmType().split(","));
				Collections.addAll(btmTypeSet,s.getToBtmType().split(","));
			});
		}
		return btmTypeSet;
	}

	/**
	 * 按domain分组，查询链接类型属性结构
	 *
	 * @return 查询结果
	 */
	@Override
	public List<BtmTreeVO> treeDomain() {
		try {
			Map<String, String> domain = Optional.ofNullable(DomainRepeater.getDomain()).orElseGet(ArrayList::new).stream().collect(Collectors.toMap(DomainVO::getValue, DomainVO::getLabel));
			List<LinkTypeVO> vos = LinkTypeWrapper.build().listEntityVO(baseMapper.selectAll(), null);
			Map<String, List<LinkTypeVO>> domainMap = vos.stream().collect(Collectors.groupingBy(LinkTypeVO::getDomain));
			List<BtmTreeVO> treeList = new ArrayList<>();
			domainMap.forEach((k,v)-> {
				if (domain.containsKey(k)){
					String label = domain.get(k);
					BtmTreeVO parent = new BtmTreeVO();
					parent.setName(label);
					parent.setId(k);
					parent.setLabel(label);
					parent.setChildList(v.stream().map(s -> {
						BtmTreeVO child = new BtmTreeVO();
						child.setOid(s.getOid());
						child.setLabel(s.getId() + (s.getName() == null ? "" : "(" + s.getName() + ")"));
						child.setId(s.getId());
						child.setName(s.getName());
						return child;
					}).collect(Collectors.toList()));
					treeList.add(parent);
				}
			});
			return treeList;
		} catch (NacosException e) {
			throw new RuntimeException(e);
		}
	}

	@Override
	public boolean deleteLogic(@NotEmpty List<Long> ids) {
		return false;
	}

	@Override
	public boolean changeStatus(@NotEmpty List<Long> ids, Integer status) {
		return false;
	}

	/**
	 * 获取链接类型，只有默认字段
	 *
	 * @param linkTypeId 链接类型id
	 * @return 默认字段属性
	 */
	@Override
	public LinkTypeVO getLinkTypeDefaultAttrById(String linkTypeId) {
		LinkTypeVO vo = getLinkTypeById(linkTypeId);
		List<LinkTypeAttributeVO> attributes = linkTypeAttributeService.getDefaultAttributes(vo);
		vo.setAttributes(attributes);
		return vo;
	}

	/**
	 * 获取链接类型，有所有的字段
	 *
	 * @param linkTypeId 链接类型id
	 * @return 所有字段
	 */
	@Override
	public LinkTypeVO getLinkTypeAllAttrById(String linkTypeId) {
		LinkTypeVO vo = getLinkTypeById(linkTypeId);
		List<LinkTypeAttributeVO> attributes = linkTypeAttributeService.getAllAttributes(vo);
		vo.setAttributes(attributes);
		return vo;
	}

	/**
	 * 获取链接类型，有所有的字段
	 *
	 * @param linkTypeOid 链接类型主键
	 * @return 所有字段
	 */
	@Override
	public LinkTypeVO getLinkTypeAllAttrByOid(String linkTypeOid) {
		LinkTypeVO vo = getLinkTypeByOid(linkTypeOid);
		List<LinkTypeAttributeVO> attributes = linkTypeAttributeService.getAllAttributes(vo);
		vo.setAttributes(attributes);
		return vo;
	}
}