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

import com.alibaba.nacos.common.utils.StringUtils;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.baomidou.mybatisplus.extension.toolkit.SqlHelper;
import com.vci.ubcs.code.entity.CodeClassify;
import com.vci.ubcs.code.mapper.CodeClassifyMapper;
import com.vci.ubcs.code.service.ICodeClassifyService;
import com.vci.ubcs.code.vo.pagemodel.CodeClassifyVO;
import com.vci.ubcs.core.log.exception.ServiceException;
import jodd.bean.BeanUtil;
import org.springblade.core.mp.support.Condition;
import org.springblade.core.secure.utils.AuthUtil;
import org.springblade.core.tool.api.R;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import javax.annotation.Resource;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Service
public class ICodeClassifyServiceImpl extends ServiceImpl<CodeClassifyMapper, CodeClassify> implements ICodeClassifyService {

	@Resource
	private CodeClassifyMapper codeClassifyMapper;

	/**
	 * 使用查询封装器来查询
	 * @param wrapper 查询封装器
	 * @return 数据对象
	 */
	@Override
	public List<CodeClassify> selectByWrapper(Wrapper wrapper) {
		return codeClassifyMapper.selectList(wrapper);
	}

	@Override
	public IPage<CodeClassifyVO> selectPlCodeClassifyPage(IPage<CodeClassifyVO> page, CodeClassifyVO plCodeClassify) {
		return page.setRecords(codeClassifyMapper.selectPlCodeClassifyPage(page, plCodeClassify));
	}

	@Override
	public R addSave(CodeClassify codeClassifyEntity) {

		if(StringUtils.isNotBlank(codeClassifyEntity.getParentCodeClassifyOid()) && StringUtils.isNotBlank(codeClassifyEntity.getBtmTypeId())){
			return R.fail("只有在顶层的主题库分类才能设置业务类型");
		}
		codeClassifyEntity.setCreator(AuthUtil.getUser().getUserName());
		codeClassifyEntity.setCreateTime(new Date());
		codeClassifyEntity.setTs(new Date());
		codeClassifyEntity.setLastModifier(AuthUtil.getUser().getUserName());
		codeClassifyEntity.setLastModifyTime(new Date());
		int insertNumber = codeClassifyMapper.insert(codeClassifyEntity);
		return R.status(SqlHelper.retBool(insertNumber));
	}

	/**
	 * 修改主题库分类
	 * @param codeClassifyEntity 主题库分类数据传输对象
	 * @return 执行结果
	 */
	@Override
	public R editSave(CodeClassify codeClassifyEntity) {
		if(codeClassifyEntity == null || codeClassifyEntity.getOid() == null){
			return R.fail("传入数据不能为空！");
		}
		//检查ts
		Map<String,Object> condition = new HashMap<>(2);
		condition.put("oid",codeClassifyEntity.getOid());
		condition.put("ts",codeClassifyEntity.getTs());
		CodeClassify detail = codeClassifyMapper
			.selectOne(Condition.getQueryWrapper(condition,CodeClassify.class));
		if(detail == null){//不是最新的不让改
			return R.fail("当前数据不是最新，请刷新后再修改！");
		}

		if(StringUtils.isNotBlank(codeClassifyEntity.getParentCodeClassifyOid()) && StringUtils.isNotBlank(codeClassifyEntity.getBtmTypeId())){
			return R.fail("只有在顶层的主题库分类才能设置业务类型");
		}
		codeClassifyEntity.setLastModifier(AuthUtil.getUser().getUserName());
		codeClassifyEntity.setLastModifyTime(new Date());
		int insertNumber = codeClassifyMapper.updateById(codeClassifyEntity);

//         //处理数据集成逻辑,成功后执行集成第一步,分类数据特殊处理。只有启用状态的分类才推送
//         if(FRAMEWORK_DATA_ENABLED.equals(codeClassifyDO.getLcStatus()));
//         {
//             codeDuckingServiceI.insertCache1(CACHE_TYPE_CLASSIFY_EDIT,FRAMEWORK_DATA_ENABLED,DOCKING_DEFAULT_CLASSIFY, DOCKING_DEFAULT_CLASSIFYOID, codeClassifyDO.getOid(), codeClassifyDTO.getTs());
//         }
		return R.status(SqlHelper.retBool(insertNumber));
//		return BaseResult.success(codeClassifyDO2VO(codeClassifyDO));
	}

	/**
	 * 检查 主题库分类是否删除
	 * @param codeClassifyEntity 主题库分类数据传输对象，必须要有oid和ts属性
	 * @return 执行结果 success为true为可以删除，false表示有数据引用，obj为true表示有下级
	 */
	@Override
	public R checkIsCanDelete(CodeClassify codeClassifyEntity) {
		if(codeClassifyEntity == null || codeClassifyEntity.getOid() == null){
			return R.fail("传入数据不能为空！");
		}
		codeClassifyEntity = selectByOid(codeClassifyEntity.getOid());
		return checkIsCanDeleteForDO(codeClassifyEntity);
	}

	/**
	 * 主键查询数据对象
	 * @param oid 主键
	 * @return  数据对象
	 */
	private CodeClassify selectByOid(String oid){

		CodeClassify codeClassifyEntity = codeClassifyMapper.selectById(oid.trim());
		if(codeClassifyEntity == null || StringUtils.isBlank(codeClassifyEntity.getOid())){
			throw new ServiceException("dataOidNotExist");//根据主键id未查到相关数据
		}
		return codeClassifyEntity;
	}

	/**
	 * 校验是否可以删除，如果存在下级，并且下级有数据引用则不能删除
	 * @param codeClassifyEntity 数据库中的数据对象
	 * @return success为true为可以删除，false表示有数据引用，obj为true表示有下级
	 */
	private R checkIsCanDeleteForDO(CodeClassify codeClassifyEntity) {

		//检查ts
		Map<String,Object> condition = new HashMap<>(2);
		condition.put("oid",codeClassifyEntity.getOid());
		condition.put("ts",codeClassifyEntity.getTs());
		CodeClassify detail = codeClassifyMapper
			.selectOne(Condition.getQueryWrapper(condition,CodeClassify.class));
		if(detail == null){//不是最新的不让改
			throw new ServiceException("当前数据不是最新，请刷新后再修改！");
//			return R.fail("当前数据不是最新，请刷新后再修改！");
		}
		//校验下级是否有引用
		if(checkChildIsLinked(detail.getOid())){
			return R.fail("dataCascadeLinkedNotDelete");
		}
		return R.data(checkHasChild(detail.getOid()));
	}

	/**
	 * 检查是否有下级是否关联了数据
	 *
	 * @param oid 主键
	 * @return true 表示有引用，false表示没有引用
	 */
	@Override
	public boolean checkChildIsLinked(String oid) {

		Map<String,String> childOids = codeClassifyMapper.selectAllLevelChildOid(oid.trim());
		if(!CollectionUtils.isEmpty(childOids)){
			for(String childOid: childOids.keySet()){
				if(!checkIsLinked(childOid)){
					return false;
				}
			}
			return true;
		}
		return false;
	}

	/**
	 * 校验是否被引用
	 * @param oid 主键
	 */
	private boolean checkIsLinked(String oid) {
		//TODO 添加需要校验引用的地方
		return false;
	}

	@Override
	public boolean checkHasChild(String oid) {
		if(StringUtils.isBlank(oid)){
			throw new ServiceException("oid不能为空！");
		}
		return codeClassifyMapper.checkHasChild(oid.trim());
	}


	/**
	 * 删除主题库分类
	 * @param codeClassify 主题库分类数据传输对象，oid和ts需要传输
	 * @return 删除结果反馈：：success：成功，fail：失败
	 */
	@Override
	public R deleteCodeClassify(CodeClassify codeClassify) {

		if(codeClassify == null || codeClassify.getOid() == null){
			throw new ServiceException("传入参数不能为空！");
		}
		codeClassify = codeClassifyMapper.selectById(codeClassify.getOid());

		R result = checkIsCanDeleteForDO(codeClassify);

		//先简称是否有关联模板，有模板要先删除
//		VciQueryWrapperForDO queryWrapper = new VciQueryWrapperForDO(CodeClassifyTemplateDO.class);
//		queryWrapper.addQueryMap("codeClassifyOid",codeClassifyDTO.getOid());
//		List<CodeClassifyTemplateDO> codeClassifyTemplateDOListHaveTemplate =  codeClassifyTemplateMapper.selectByWrapper(queryWrapper);
//		if(codeClassifyTemplateDOListHaveTemplate.size()>0){
//			return BaseResult.fail("分类关联模板，请先删除!");
//		}
//
//		//处理数据集成逻辑,成功后执行集成第一步,分类数据特殊处理。
//		//1、查询要删除的父类数据
//		List<CodeClassifyDO> deletes = new ArrayList<CodeClassifyDO>();
//		deletes.add(codeClassifyDO);
//
//		if(result.isSuccess()) {
//			//找下级的，这个是可以删除的时候
//			Map<String,String> childrenOids = codeClassifyMapper.selectAllLevelChildOid(codeClassifyDO.getOid().trim());
//			if (!CollectionUtils.isEmpty(childrenOids)) {
//				Collection<Collection<String>> childrenCollections = VciBaseUtil.switchCollectionForOracleIn(childrenOids.keySet());
//				for(Collection<String> s : childrenCollections){
//
//					//处理数据集成逻辑,成功后执行集成第一步,分类数据特殊处理。
//					//2、查询要删除的子类数据
//					List<CodeClassifyDO>  codeClassifyDOList = codeClassifyMapper.selectByPrimaryKeyCollection(s);
//					deletes.addAll(codeClassifyDOList);
//
//					codeClassifyMapper.batchDeleteByOids(s);
//				}
//
//			}
//		}else{
//			return baseResult;
//		}
//
//		//执行删除操作
//		BatchCBO batchCBO = codeClassifyMapper.deleteByPrimaryKey(codeClassifyDO.getOid());
//
//		//处理数据集成逻辑,成功后执行集成第一步
//		for (CodeClassifyDO codeClassifyDO1:deletes){
//			//codeDuckingServiceI.insertCache1(CACHE_TYPE_CLASSIFY_DELETE,FRAMEWORK_DATA_DISABLED,DOCKING_DEFAULT_CLASSIFY, DOCKING_DEFAULT_CLASSIFYOID, codeClassifyDO1.getOid(), DateUtils.addHours(new Date(),1));//这里是当前时间
//
//			//存储要删除的数据
//			codeDuckingServiceI.cacheDeleteData(codeClassifyDO1.getOid(), codeClassifyDO1);
//		}
//		return (batchCBO!=null && batchCBO.getDeleteCbos() !=null &&batchCBO.getDeleteCbos().size() > 0)?BaseResult.successMsg(DELETE_SUCCESS):BaseResult.fail(DELETE_FAIL);
		return null;
	}

}