package org.springblade.code.service.impl;

import com.vci.frameworkcore.lcstatuspck.FrameworkDataLCStatus;
import com.vci.mdm.dao.CodeBasicSecDaoI;
import com.vci.mdm.dao.CodeClassifyValueDaoI;
import com.vci.mdm.dto.CodeClassifyValueDTO;
import com.vci.mdm.model.CodeBasicSecDO;
import com.vci.mdm.model.CodeClassifyValueDO;
import com.vci.mdm.pagemodel.CodeClassifyValueVO;
import com.vci.mdm.service.CodeClassifyValueServiceI;
import com.vci.starter.revision.bo.TreeWrapperOptions;
import com.vci.starter.revision.service.RevisionModelUtil;
import com.vci.starter.web.exception.VciBaseException;
import com.vci.starter.web.pagemodel.BaseResult;
import com.vci.starter.web.pagemodel.PageHelper;
import com.vci.starter.web.pagemodel.Tree;
import com.vci.starter.web.pagemodel.TreeQueryObject;
import com.vci.starter.web.util.BeanUtilForVCI;
import com.vci.starter.web.util.VciBaseUtil;
import com.vci.starter.web.wrapper.VciParentQueryOption;
import com.vci.starter.web.wrapper.VciQueryWrapperForDO;
import com.vci.web.pageModel.BatchCBO;
import com.vci.web.service.WebBoServiceI;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import plm.bs.bom.clientobject.ClientBusinessObject;

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

import static com.vci.frameworkcore.constant.FrameWorkDefaultValueConstant.LC_STATUS;
import static com.vci.frameworkcore.constant.FrameWorkLangCodeConstant.*;
/**
 * 分类码段的码值服务
 * @author weidy
 * @date 2022-01-24
 */
@Service
public class CodeClassifyValueServiceImpl implements CodeClassifyValueServiceI{

    /**
    * 日志
    */
    private Logger logger = LoggerFactory.getLogger(getClass());

    /**
    * 数据操作层
    */
    @Resource
    private CodeClassifyValueDaoI codeClassifyValueMapper;

    /**
    * 业务类型操作的服务
    */
    @Autowired
    private WebBoServiceI boService;

    /**
    * 对象的操作
    */
    @Autowired
    private RevisionModelUtil revisionModelUtil;

    /**
     * 码段的信息
     */
    @Autowired
    private CodeBasicSecDaoI basicSecMapper;

    /**
    * 上级节点的属性名称
    */
    private static  final String PARENT_FIELD_NAME = "parentClassifyValueOid";
    /**
     * 查询分类码段的码值 树
     * @param treeQueryObject 树查询对象
     * @return 分类码段的码值 显示树
     * @throws VciBaseException 查询条件不符合要求的时候会抛出异常
     */
    @Override
    public List<Tree> treeCodeClassifyValue(TreeQueryObject treeQueryObject) throws VciBaseException{
       // List<CodeClassifyValueDO> doList =selectCodeClassifyValueDOByTree(treeQueryObject);
        List<CodeClassifyValueDO> doList =selectCodeClassifyValueDO4Tree(treeQueryObject);
        List<CodeClassifyValueVO> voList = codeClassifyValueDO2VOs(doList);
        TreeWrapperOptions treeWrapperOptions = new TreeWrapperOptions(PARENT_FIELD_NAME);
        treeWrapperOptions.copyFromTreeQuery(treeQueryObject);
        return revisionModelUtil.doList2Trees(voList,treeWrapperOptions,(CodeClassifyValueVO s) ->{
            //可以在这里处理树节点的显示
            return s.getId() + " " + s.getName() + (FrameworkDataLCStatus.DISABLED.getValue().equalsIgnoreCase(s
                    .getLcStatus()) ? (" 【停用】 ") : "");
        });
    }
    /**
      * 根据树形查询对象来查询数据对象
      *
      * @param treeQueryObject 树形查询对象
      * @return 查询结果,数据对象
      */
    @Override
    public List<CodeClassifyValueDO> selectCodeClassifyValueDOByTree(TreeQueryObject treeQueryObject) {
        VciQueryWrapperForDO queryWrapperForDO = new VciQueryWrapperForDO(treeQueryObject.getConditionMap(),CodeClassifyValueDO.class);
        PageHelper ph = new PageHelper();
        ph.addDefaultAsc("ordernum");
        queryWrapperForDO.setPageHelper(ph);
        VciParentQueryOption parentQueryOption = new VciParentQueryOption();
        parentQueryOption.setParentFieldName(PARENT_FIELD_NAME);
        //queryWrapperForDO.parentQueryChild(treeQueryObject,parentQueryOption);
        parentQueryOption.setHasSelf(true);
        queryWrapperForDO.childQueryParent(parentQueryOption);
        return codeClassifyValueMapper.selectByWrapper(queryWrapperForDO);
    }

    private List<CodeClassifyValueDO> selectCodeClassifyValueDO4Tree(TreeQueryObject treeQueryObject){
        Map<String, String> conditionMap = treeQueryObject.getConditionMap();
        String currentSecOid = conditionMap.get("codeclassifysecoid");
        String sql = "select oid from PLATFORMBTM_CODEBASICSEC start with  oid = '"+currentSecOid+"' connect by prior PARENTCLASSIFYSECOID = OID";
        List<ClientBusinessObject> targetParentList = boService.queryBySql(sql, new HashMap<>());
        Set<String> secOidList = targetParentList.stream().map(ClientBusinessObject::getOid).collect(Collectors.toSet());
        conditionMap.clear();
        StringBuilder oidStrBuilder = new StringBuilder();
        secOidList.forEach(oid -> oidStrBuilder.append("'").append(oid).append("',"));
        String oidStr = oidStrBuilder.toString().substring(0,oidStrBuilder.toString().length() -1);
        VciQueryWrapperForDO wrapper = new VciQueryWrapperForDO(null,CodeClassifyValueDO.class);
        PageHelper ph = new PageHelper();
        ph.addDefaultAsc("ordernum");
        ph.setLimit(-1);
        wrapper.setPageHelper(ph);
        wrapper.in("codeclassifysecoid",oidStr);
        return codeClassifyValueMapper.selectByWrapper(wrapper);
    }

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

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

        }
        return vo;
    }

    /**
     * 增加分类码段的码值
     * @param codeClassifyValueDTO 分类码段的码值数据传输对象
     * @return 执行结果
     * @throws VciBaseException 参数为空，唯一项，必输项不通过时会抛出异常
     */
    @Override
    public CodeClassifyValueVO addSave(CodeClassifyValueDTO codeClassifyValueDTO) throws VciBaseException{
        VciBaseUtil.alertNotNull(codeClassifyValueDTO,"需要添加的数据对象");
        //添加对码值子父级的判断
        if(StringUtils.isNotBlank(codeClassifyValueDTO.getParentclassifyvalueoid())){
            String parentclassifyvalueoid = codeClassifyValueDTO.getParentclassifyvalueoid();
            String codeclassifysecoid = codeClassifyValueDTO.getCodeclassifysecoid();
            CodeClassifyValueDO parentDO = codeClassifyValueMapper.selectByPrimaryKey(parentclassifyvalueoid);
            if (parentDO.getCodeClassifySecOid().equalsIgnoreCase(codeclassifysecoid)){
                throw new VciBaseException("不允许在父码值中直接添加子码值");
            }
        }
        //将DTO转换为DO
        CodeClassifyValueDO codeClassifyValueDO = new CodeClassifyValueDO();
        BeanUtilForVCI.copyPropertiesIgnoreCase(codeClassifyValueDTO,codeClassifyValueDO);
        Map<String,String> conditionMap = new HashMap<>();
        conditionMap.put("codeclassifysecoid", codeClassifyValueDO.getCodeClassifySecOid());
        conditionMap.put("parentclassifyvalueoid",codeClassifyValueDO.getParentClassifyValueOid());
        VciQueryWrapperForDO wrapper = new VciQueryWrapperForDO(conditionMap,CodeClassifyValueDO.class);
        List<CodeClassifyValueDO> existList = codeClassifyValueMapper.selectByWrapper(wrapper);
        codeClassifyValueDO.setOrderNum(existList.size() + 1);
        codeClassifyValueMapper.insert(codeClassifyValueDO);
        return codeClassifyValueDO2VO(codeClassifyValueDO);
    }

    /**
     * 修改分类码段的码值
     * @param codeClassifyValueDTO 分类码段的码值数据传输对象
     * @return 执行结果
     * @throws VciBaseException 参数为空，唯一项，必输项不通过时会抛出异常
     */
     @Override
     public CodeClassifyValueVO editSave(CodeClassifyValueDTO codeClassifyValueDTO) throws VciBaseException{
         VciBaseUtil.alertNotNull(codeClassifyValueDTO,"数据对象",codeClassifyValueDTO.getOid(),"分类码段的码值主键");
         //将DTO转换为DO
         CodeClassifyValueDO codeClassifyValueDO = selectByOid(codeClassifyValueDTO.getOid());
         revisionModelUtil.copyFromDTOIgnore(codeClassifyValueDTO,codeClassifyValueDO);
         codeClassifyValueMapper.updateByPrimaryKey(codeClassifyValueDO);
         return codeClassifyValueDO2VO(codeClassifyValueDO);
     }

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

    /**
     * 校验是否可以删除，如果存在下级，并且下级有数据引用则不能删除
     * @param codeClassifyValueDTO 数据传输对象
     * @param codeClassifyValueDO 数据库中的数据对象
     * @return success为true为可以删除，false表示有数据引用，obj为true表示有下级
     */
    private BaseResult checkIsCanDeleteForDO(CodeClassifyValueDTO codeClassifyValueDTO, CodeClassifyValueDO codeClassifyValueDO) {
        //boService.checkTs(codeClassifyValueDTO);
        //校验下级是否有引用
        if(checkChildIsLinked(codeClassifyValueDO.getOid())){
            return BaseResult.fail(DATA_CASCADE_LINKED_NOT_DELETE,new String[]{""});
        }
        return BaseResult.success(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
    public BaseResult deleteCodeClassifyValue(CodeClassifyValueDTO codeClassifyValueDTO) throws VciBaseException{
        VciBaseUtil.alertNotNull(codeClassifyValueDTO,"分类码段的码值数据对象",codeClassifyValueDTO.getOid(),"分类码段的码值的主键");
        CodeClassifyValueDO codeClassifyValueDO = selectByOid(codeClassifyValueDTO.getOid());
        BaseResult baseResult = checkIsCanDeleteForDO(codeClassifyValueDTO,codeClassifyValueDO);
        if(baseResult.isSuccess()) {
                        //找下级的，这个是可以删除的时候
            List<String> childrenOids = codeClassifyValueMapper.selectAllLevelChildOid(codeClassifyValueDO.getOid().trim());
            if (!CollectionUtils.isEmpty(childrenOids)) {
                Collection<Collection<String>> childrenCollections = VciBaseUtil.switchCollectionForOracleIn(childrenOids);
                for(Collection<String> s : childrenCollections){
                    codeClassifyValueMapper.batchDeleteByOids(s);
                }
            }
                    }else{
            return baseResult;
        }
        //执行删除操作
        BatchCBO batchCBO = codeClassifyValueMapper.deleteByPrimaryKey(codeClassifyValueDO.getOid());
        return (batchCBO!=null && batchCBO.getDeleteCbos() !=null &&batchCBO.getDeleteCbos().size() > 0)?BaseResult.successMsg(DELETE_SUCCESS):BaseResult.fail(DELETE_FAIL);
    }

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

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

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

    /**
    * 使用主键集合查询数据对象
    * @param oidCollections 主键的集合
    * @return 数据对象列表
    */
    private List<CodeClassifyValueDO> listCodeClassifyValueDOByOidCollections(Collection<String> oidCollections){
        List<CodeClassifyValueDO> codeClassifyValueDOList = new ArrayList<CodeClassifyValueDO>();
        if(!CollectionUtils.isEmpty(oidCollections)){
            Collection<Collection<String>> oidCollectionsList = VciBaseUtil.switchCollectionForOracleIn(oidCollections);
            for(Collection<String> oids: oidCollectionsList){
                List<CodeClassifyValueDO> tempDOList =  codeClassifyValueMapper.selectByPrimaryKeyCollection(oids);
                if(!CollectionUtils.isEmpty(tempDOList)){
                        codeClassifyValueDOList.addAll(tempDOList);
                }
            }
        }
        return  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 classifySecOid         码段的主键
     * @param parentClassifyValueOid 上级分类的主键
     * @return 分类码值的内容
     */
    @Override
    public List<CodeClassifyValueVO> listCodeClassifyValueBySecOid(String classifySecOid, String parentClassifyValueOid) {
        if(StringUtils.isBlank(classifySecOid)){
            return new ArrayList<>();
        }
        CodeBasicSecDO secDO = basicSecMapper.selectByPrimaryKey(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");
        List<CodeClassifyValueDO> valueDOList = codeClassifyValueMapper.selectByCondition(conditionMap, pageHelper);
        return codeClassifyValueDO2VOs(valueDOList);
    }

    /**
     * 根据码段主键删除其存在的码值对象
     * @param codeclassifysecoid 分类码段的主键
     * @return 执行结果
     */
    @Override
    public BaseResult batchDeleteBySecOid(String codeclassifysecoid) {
        VciBaseUtil.alertNotNull(codeclassifysecoid,"分类码段的主键");
        Map<String,String> conditionMap = new HashMap<>();
        conditionMap.put("codeClassifySecOid",codeclassifysecoid);
        VciQueryWrapperForDO wrapper = new VciQueryWrapperForDO(conditionMap,CodeClassifyValueDO.class);
        List<CodeClassifyValueDO> valueDOList = codeClassifyValueMapper.selectByWrapper(wrapper);
        codeClassifyValueMapper.batchDeleteByOids(valueDOList.stream().map(CodeClassifyValueDO::getOid).collect(Collectors.toList()));
        return BaseResult.success();
    }

    /**
     * 批量添加分类码段的码值。主要是保存码值的序号
     * @param dtoList 分类码段的码值列表
     * @param codeclassifysecoid 分类码段的主键
     * @return 执行结果
     */
    @Override
    public BaseResult batchSave4Order(List<CodeClassifyValueDTO> dtoList, String codeclassifysecoid) {
        VciBaseUtil.alertNotNull(codeclassifysecoid,"分类码段主键");
        Map<String,String> conditionMap = new HashMap<>();
        conditionMap.put("codeClassifySecOid",codeclassifysecoid);
        VciQueryWrapperForDO wrapper = new VciQueryWrapperForDO(conditionMap,CodeClassifyValueDO.class);
        List<CodeClassifyValueDO> valueDOList = codeClassifyValueMapper.selectByWrapper(wrapper);
        List<CodeClassifyValueDO> updateList = new ArrayList<>();
        dtoList.forEach(dto -> {
            if( StringUtils.isNotBlank( dto.getOid() )){
                List<CodeClassifyValueDO> 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);
                });
            }
        });
        codeClassifyValueMapper.batchUpdate(updateList);
        return BaseResult.success();
    }
}