package com.dragoninfo.dcuc.app.facade;

import com.dragoninfo.dcuc.app.dto.dataresource.ChildResourceClassify;
import com.dragoninfo.dcuc.app.dto.dataresource.ResourceClassify;
import com.dragoninfo.dcuc.app.enumresources.DataResourceEnum;
import com.dragoninfo.dcuc.app.service.IDataResourceService;
import com.dragoninfo.dcuc.app.dto.sub.DataClaAcceptDTO;
import com.dragoninfo.dcuc.app.dto.sub.FieldClaAcceptDTO;
import com.dragoninfo.dcuc.app.entity.sub.DataCla;
import com.dragoninfo.dcuc.app.entity.sub.DataLevel;
import com.dragoninfo.dcuc.app.entity.sub.DataSec;
import com.dragoninfo.dcuc.app.entity.sub.FieldCla;
import com.dragoninfo.dcuc.app.enumresources.sub.DataClaTypeEnum;
import com.dragoninfo.dcuc.app.enumresources.sub.FieldClaTypeEnum;
import com.dragoninfo.dcuc.app.service.sub.IDataClaService;
import com.dragoninfo.dcuc.app.service.sub.IDataLevelService;
import com.dragoninfo.dcuc.app.service.sub.IDataSecService;
import com.dragoninfo.dcuc.app.service.sub.IFieldClaService;
import com.dragoninfo.dcuc.app.vo.*;
import com.dragonsoft.duceap.base.entity.http.ResponseStatus;
import com.dragonsoft.duceap.commons.util.UUIDUtils;
import com.dragonsoft.duceap.commons.util.collections.CollectionUtils;
import com.google.common.base.Joiner;
import com.google.common.collect.Lists;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.stream.Collectors;

/**
 * Created by lidr on 2021/4/14
 */
@Slf4j
@RestController
@RequestMapping(value = "/dcuc/app/dataResourceFacade")
public class DataResourceFacade implements IDataResourceFacade
{

    public static final String ID_SEPARATOR = "|";

    @Autowired
    private IDataResourceService dataResourceService;

    @Autowired
    private IDataClaService dataClaService;

    @Autowired
    private IDataLevelService dataLevelService;

    @Autowired
    private IDataSecService dataSecService;

    @Autowired
    private IFieldClaService fieldClaService;


    @Override
    public List<DataResourceClassifyVo> getAllDataResourceTree(@RequestParam("attrType") String attrType) {
        List<DataResourceClassifyVo> result = Lists.newArrayList();

        //列：数据安全级别  字段分类
        //表：数据分级  数据资源分类
        if ("TABLE".equals(attrType)) {
            result.add(getDataLevelTree());
            result.add(getDataClassifyTree());
        } else {
            result.add(getSecurityLevelTree());
            result.add(getFieldClassifyTree());
        }
        return result;
    }

    @Override
    public DataResourceClassifyVo getDataResourceTree(String typeCode) {
        DataResourceClassifyVo result = null;
        DataResourceEnum dataResourceEnum = Enum.valueOf(DataResourceEnum.class, typeCode);
        switch (dataResourceEnum){
            case DATA_CLASSIFY:
                result = getDataLevelTree();
                break;
            case COLUMN_CLASSIFY:
                result = getFieldClassifyTree();
                break;

            case DATA_SECURITY_LEVEL:
                result = getSecurityLevelTree();
                break;
            case DATA_RESOURCE_CLASSIFY:
                result = getDataClassifyTree();
                break;
                default:
                    break;
        }
        return result;
    }

    private DataResourceClassifyVo getDataLevelTree() {
        DataResourceEnum dataResourceEnum = DataResourceEnum.DATA_CLASSIFY;
        DataResourceClassifyVo dataResourceClassifyVo = DataResourceClassifyVo.builder()
                .id(dataResourceEnum.getCode())
                .attrType(dataResourceEnum.getAttrType().getValue())
                .label(dataResourceEnum.getLabel())
                .build();

        DataResourceTreeVo dataLevelTreeVo = DataResourceTreeVo.builder()
                .id(dataResourceEnum.getCode())
                .label("全部")
                .code(dataResourceEnum.getCode())
                .treeNode(true)
                .build();
        List<DataLevelVo> dataLevelList = getDataLevelList();
        List<DataResourceTreeVo> child = dataLevelList.stream().map(item -> DataResourceTreeVo.builder()
              .id(Joiner.on(ID_SEPARATOR).join(dataLevelTreeVo.getId(), item.getLevelCode()))
              .code(item.getLevelCode())
              .label(item.getLevelName())
              .dataType(item.getTypeCode())
              .codeDataTypeStr(UUIDUtils.getUUID() + ID_SEPARATOR + item.getLevelCode() + ID_SEPARATOR + item.getTypeCode())
              .treeNode(false)
              .pId(dataLevelTreeVo.getId())
              .innerId(item.getInnerId()).build()).collect(Collectors.toList());
        dataLevelTreeVo.setChild(child);

        dataResourceClassifyVo.setNodes(new ArrayList<DataResourceTreeVo>(){{add(dataLevelTreeVo);}});
        //设置总数量
        dataResourceClassifyVo.setTotal(child.size());
        return dataResourceClassifyVo;
    }

    private DataResourceClassifyVo getSecurityLevelTree() {
        DataResourceEnum dataResourceEnum = DataResourceEnum.DATA_SECURITY_LEVEL;

        DataResourceClassifyVo dataResourceClassifyVo = DataResourceClassifyVo.builder()
                .id(dataResourceEnum.getCode())
                .attrType(dataResourceEnum.getAttrType().getValue())
                .label(dataResourceEnum.getLabel())
                .build();

        DataResourceTreeVo securityLevelTree = DataResourceTreeVo.builder()
                .id(dataResourceEnum.getCode())
                .label("全部")
                .code(dataResourceEnum.getCode())
                .treeNode(true)
                .build();
        List<DataLevelVo> securityLevelList = getSecurityLevelList();

        List<DataResourceTreeVo> child = securityLevelList.stream().map(item -> DataResourceTreeVo.builder()
                .id(Joiner.on(ID_SEPARATOR).join(securityLevelTree.getId(), item.getLevelCode()))
                .code(item.getLevelCode())
                .label(item.getLevelName())
                .dataType(item.getTypeCode())
                .codeDataTypeStr(UUIDUtils.getUUID() + ID_SEPARATOR + item.getLevelCode() + ID_SEPARATOR + item.getTypeCode())
                .treeNode(false)
                .pId(securityLevelTree.getId())
                .innerId(item.getInnerId()).build()).collect(Collectors.toList());
        securityLevelTree.setChild(child);
        dataResourceClassifyVo.setNodes(new ArrayList<DataResourceTreeVo>(){{add(securityLevelTree);}} );
        //设置总数量
        dataResourceClassifyVo.setTotal(child.size());
        return dataResourceClassifyVo;
    }

    private DataResourceClassifyVo getDataClassifyTree() {
        DataResourceEnum dataResourceEnum = DataResourceEnum.DATA_RESOURCE_CLASSIFY;

        DataResourceClassifyVo resourceVo = DataResourceClassifyVo.builder().id(dataResourceEnum.getCode())
                .attrType(dataResourceEnum.getAttrType().getValue()).label(dataResourceEnum.getLabel()).build();

        DataResourceTreeVo topTreeVo = DataResourceTreeVo.builder().id(dataResourceEnum.getCode()).label("全部")
                .code(dataResourceEnum.getCode()).treeNode(true).build();
        List<DataCla> dataClaList = dataClaService.getAllDataCla();
        Map<String, List<DataCla>> levelMap = dataClaList.stream().collect(Collectors.groupingBy(DataCla::getLevel));
        //一级节点
        List<DataResourceTreeVo> firNodes = Optional.ofNullable(levelMap.get(DataClaTypeEnum.FIR.getLevel())).orElse(new ArrayList<>())
                .stream().map(item -> convertDataClaToNode(item, null)).collect(Collectors.toList());
        //二级节点
        List<DataResourceTreeVo> secNodes = Optional.ofNullable(levelMap.get(DataClaTypeEnum.SEC.getLevel())).orElse(new ArrayList<>())
                .stream().map(item -> convertDataClaToNode(item, item.getFirId())).collect(Collectors.toList());
        //三级节点
        List<DataResourceTreeVo> thirdNodes = Optional.ofNullable(levelMap.get(DataClaTypeEnum.LAB_CLA.getLevel())).orElse(new ArrayList<>())
                .stream().map(item -> convertDataClaToNode(item, item.getSecId())).collect(Collectors.toList());
        //四级节点
        List<DataResourceTreeVo> fourNodes = Optional.ofNullable(levelMap.get(DataClaTypeEnum.LAB.getLevel())).orElse(new ArrayList<>())
                .stream().map(item -> convertDataClaToNode(item, item.getLabClaId())).collect(Collectors.toList());
        //拼接成树节点
        combineTreeNode(firNodes, secNodes);
        combineTreeNode(secNodes, thirdNodes);
        combineTreeNode(thirdNodes, fourNodes);
        topTreeVo.setChild(firNodes);

        //计算总数量
        resourceVo.setTotal(getTotalCount(topTreeVo));
        resourceVo.setNodes(new ArrayList<DataResourceTreeVo>(){{add(topTreeVo);}});
        return resourceVo;
    }

    private DataResourceTreeVo convertDataClaToNode(DataCla item, String pid) {
        return DataResourceTreeVo.builder()
                .id(item.getId())
                .pId(pid)
                .dataType(item.getDataType())
                .label(item.getName())
                .code(item.getCode())
                .innerId(item.getId())
                .build();
    }


    private DataResourceClassifyVo getFieldClassifyTree() {
        DataResourceEnum dataResourceEnum = DataResourceEnum.COLUMN_CLASSIFY;

        DataResourceClassifyVo resourceVo = DataResourceClassifyVo.builder().id(dataResourceEnum.getCode())
                .attrType(dataResourceEnum.getAttrType().getValue()).label(dataResourceEnum.getLabel()).build();

        DataResourceTreeVo topTreeVo = DataResourceTreeVo.builder().id(dataResourceEnum.getCode()).label("全部")
                .code(dataResourceEnum.getCode()).treeNode(true).build();
        List<FieldCla> fieldClaList = fieldClaService.getAllFieldCla();
        Map<String, List<FieldCla>> levelMap = fieldClaList.stream().collect(Collectors.groupingBy(FieldCla::getLevel));
        List<DataResourceTreeVo> firNodes = Optional.ofNullable(levelMap.get(FieldClaTypeEnum.FIR.getLevel())).orElse(new ArrayList<>())
                .stream().map(item -> convertFieldClaToNode(item, null)).collect(Collectors.toList());
        List<DataResourceTreeVo> secNodes = Optional.ofNullable(levelMap.get(FieldClaTypeEnum.SEC.getLevel())).orElse(new ArrayList<>())
                .stream().map(item -> convertFieldClaToNode(item, item.getFirId())).collect(Collectors.toList());
        combineTreeNode(firNodes, secNodes);
        topTreeVo.setChild(firNodes);
        resourceVo.setTotal(getTotalCount(topTreeVo));
        resourceVo.setNodes(new ArrayList<DataResourceTreeVo>(){{add(topTreeVo);}});
        return resourceVo;
    }

    private DataResourceTreeVo convertFieldClaToNode(FieldCla item, String pid) {
        return DataResourceTreeVo.builder()
                .id(item.getId())
                .pId(pid)
                .dataType(item.getDataType())
                .label(item.getName())
                .code(item.getCode())
                .innerId(item.getId())
                .build();
    }

    private void combineTreeNode(List<DataResourceTreeVo> firNodes, List<DataResourceTreeVo> secNodes) {
        Map<String, List<DataResourceTreeVo>> secMap = secNodes.stream().collect(Collectors.groupingBy(DataResourceTreeVo::getPId));
        firNodes.forEach(item->{
            List<DataResourceTreeVo> childes = secMap.get(item.getId());
            item.setChild(childes);
        });
    }


    @Override
    public List<DataLevelVo> getDataLevelList() {
        List<DataLevel> all = dataLevelService.getAll();
        return all.stream()
                .map(item -> new DataLevelVo(item.getId(), item.getLevelCode(), item.getLevelName(), item.getDataType()))
                .collect(Collectors.toList());
    }

    @Override
    public List<DataLevelVo> getSecurityLevelList() {
        List<DataSec> all = dataSecService.getAll();
        return all.stream()
                .map(item -> new DataLevelVo(item.getId(), item.getSecCode(), item.getSecName(), item.getDataType()))
                .collect(Collectors.toList());
    }

    @Override
    public List<DataClassifyVo> getDataClassifyList() {
        List<DataClaAcceptDTO> list = dataClaService.getAll();
        return list.stream().map(item -> {
            DataClassifyVo vo = new DataClassifyVo();
            vo.setFirstLevelCode(item.getFirCode());
            vo.setFirstLevelName(item.getFirName());
            vo.setSecondLevelCode(item.getSecCode());
            vo.setSecondLevelName(item.getSecName());
            vo.setLabelClassifyCode(item.getLabClaCode());
            vo.setLabelClassifyName(item.getLabClaName());
            vo.setLabelCode(item.getLabCode());
            vo.setLabelName(item.getLabName());
            return vo;
        }).collect(Collectors.toList());
    }

    @Override
    public List<DataFieldClassifyVo> getFieldClassifyList() {
        List<FieldClaAcceptDTO> list = fieldClaService.getAll();
        return list.stream().map(item-> {
            DataFieldClassifyVo vo = new DataFieldClassifyVo();
            vo.setFirstLevelCode(item.getFirCode());
            vo.setFirstLevelName(item.getFirName());
            vo.setSecondLevelCode(item.getSecCode());
            vo.setSecondLevelName(item.getSecName());
            return vo;
        }).collect(Collectors.toList());
    }

    @Override
    public ResponseStatus dataLevelSync() {
        CompletableFuture
                .supplyAsync(this::getDataLevelListFromRemote)
                .exceptionally(e->{
                    log.error("getDataLevelListFromRemote error.",e);
                    return new ArrayList<>();
                })
                .thenAccept((list)->dataLevelService.sync(list))
                .exceptionally(e->{
                    log.error("sync error.",e);
                    return null;
                });
        return ResponseStatus.success();
    }

    @Override
    public ResponseStatus dataSecSync() {
        CompletableFuture
                .supplyAsync(this::getSecurityLevelListFromRemote)
                .exceptionally(e->{
                    log.error("getSecurityLevelListFromRemote error.",e);
                    return new ArrayList<>(); })
                .thenAccept((list)->dataSecService.sync(list))
                .exceptionally(e->{
                            log.error("sync error.",e);
                            return null;
                });
        return ResponseStatus.success();
    }

    @Override
    public ResponseStatus dataClaSync() {
        CompletableFuture.supplyAsync(this::getDataClassifyTreeFromRemote)
                .exceptionally(e->{
                    log.error("getDataClassifyTreeFromRemote error.",e);
                    return new ArrayList<>(); })
                .thenAccept((nodes)-> dataClaService.sync(nodes, null))
                .exceptionally(e->{
                    log.error("sync error.",e);
                    return null;
                });
        return ResponseStatus.success();
    }

    @Override
    public ResponseStatus fieldClaSync() {
        CompletableFuture.supplyAsync(this::getFieldClassifyTreeFromRemote)
                .exceptionally(e->{
                    log.error("getFieldClassifyTreeFromRemote error.",e);
                    return new ArrayList<>(); })
                .thenAccept((nodes)-> fieldClaService.sync(nodes, null))
                .exceptionally(e->{
                    log.error("sync error.",e);
                    return null;
                });
        return ResponseStatus.success();
    }


    @Override
    public List<DataLevelVo> getDetailByIdsAndClaType(List<String> ids, String classifyType) {
        List<DataLevelVo> vos= new ArrayList<>();
        if(CollectionUtils.isEmpty(ids)) {
            return vos;
        }
        if(StringUtils.isBlank(classifyType)) {
            return vos;
        }
        DataResourceEnum anEnum = DataResourceEnum.getByCode(classifyType);
        if(null == anEnum) {
            return vos;
        } else if(DataResourceEnum.COLUMN_CLASSIFY.equals(anEnum)) {
            List<FieldCla> list = fieldClaService.getByIds(ids);
            list.stream().map(item->{
                DataLevelVo vo = new DataLevelVo();
                vo.setTypeCode(item.getDataType());
                vo.setLevelName(item.getName());
                vo.setLevelCode(item.getCode());
                vo.setInnerId(item.getId());
                return vo;
            }).collect(Collectors.toList());

        } else if(DataResourceEnum.DATA_CLASSIFY.equals(anEnum)) {
            List<DataLevel> list = dataLevelService.getByIds(ids);
            list.stream().map(item->{
                DataLevelVo vo = new DataLevelVo();
                vo.setTypeCode(item.getDataType());
                vo.setLevelName(item.getLevelName());
                vo.setLevelCode(item.getLevelCode());
                vo.setInnerId(item.getId());
                return vo;
            }).collect(Collectors.toList());

        } else if(DataResourceEnum.DATA_RESOURCE_CLASSIFY.equals(anEnum)) {
            List<DataCla> list = dataClaService.getByIds(ids);
            list.stream().map(item->{
                DataLevelVo vo = new DataLevelVo();
                vo.setTypeCode(item.getDataType());
                vo.setLevelName(item.getName());
                vo.setLevelCode(item.getCode());
                vo.setInnerId(item.getId());
                return vo;
            }).collect(Collectors.toList());

        } else if(DataResourceEnum.DATA_SECURITY_LEVEL.equals(anEnum)) {
            List<DataSec> list = dataSecService.getByIds(ids);
            list.stream().map(item->{
                DataLevelVo vo = new DataLevelVo();
                vo.setTypeCode(item.getDataType());
                vo.setLevelName(item.getSecName());
                vo.setLevelCode(item.getSecCode());
                vo.setInnerId(item.getId());
                return vo;
            }).collect(Collectors.toList());
        }
        return vos;
    }

    @Override
    public DataLevelVo getDetailByIdAndClaType(String id, String classifyType) {
        if(StringUtils.isAnyBlank(id, classifyType)) {
            return null;
        }
        DataLevelVo vo = new DataLevelVo();
        DataResourceEnum anEnum = DataResourceEnum.getByCode(classifyType);
        if(null == anEnum) {
            return null;
        } else if(DataResourceEnum.COLUMN_CLASSIFY.equals(anEnum)) {
            FieldCla fieldCla = fieldClaService.getById(id);
            vo.setInnerId(fieldCla.getId());
            vo.setLevelCode(fieldCla.getCode());
            vo.setLevelName(fieldCla.getName());
            vo.setTypeCode(fieldCla.getDataType());
        } else if(DataResourceEnum.DATA_CLASSIFY.equals(anEnum)) {
            DataLevel dataLevel = dataLevelService.getById(id);
            vo.setInnerId(dataLevel.getId());
            vo.setLevelCode(dataLevel.getLevelCode());
            vo.setLevelName(dataLevel.getLevelName());
            vo.setTypeCode(dataLevel.getDataType());
        } else if(DataResourceEnum.DATA_RESOURCE_CLASSIFY.equals(anEnum)) {
            DataCla dataCla = dataClaService.getById(id);
            vo.setInnerId(dataCla.getId());
            vo.setLevelCode(dataCla.getId());
            vo.setLevelName(dataCla.getName());
            vo.setTypeCode(dataCla.getCode());
        } else if(DataResourceEnum.DATA_SECURITY_LEVEL.equals(anEnum)) {
            DataSec dataSec = dataSecService.getById(id);
            vo.setInnerId(dataSec.getId());
            vo.setLevelCode(dataSec.getSecCode());
            vo.setLevelName(dataSec.getSecName());
            vo.setTypeCode(dataSec.getDataType());
        }
        return vo;
    }


    /**
     * 数据资源分类
     *
     * @return
     */
    private List<DataResourceTreeVo> getDataClassifyTreeFromRemote() {
        String id = DataResourceEnum.DATA_RESOURCE_CLASSIFY.getCode();
        List<DataResourceTreeVo> collect = getFirstChildResourceClassifies(dataResourceService.getDataClassifyList())
                .stream()
                .map(firstClassify -> {
                    DataResourceTreeVo firstTreeVo = DataResourceTreeVo.builder()
                            .id(Joiner.on(ID_SEPARATOR).join(id, firstClassify.getCodeValue()))
                            .code(firstClassify.getCodeValue())
                            .label(firstClassify.getCodeName())
                            .treeNode(true)
                            .pId(id)
                            .dataType(firstClassify.getTypeCode())
                            .codeDataTypeStr(UUIDUtils.getUUID() + ID_SEPARATOR + firstClassify.getCodeValue() + ID_SEPARATOR + firstClassify.getTypeCode())
                            .build();

                    firstTreeVo.setChild(getFirstChildResourceClassifies(firstClassify.getChildrenType()).stream()
                            .map(secondClassify -> {
                                DataResourceTreeVo secondTreeVo = DataResourceTreeVo.builder()
                                        .id(Joiner.on(ID_SEPARATOR).join(firstTreeVo.getId(), secondClassify.getCodeValue()))
                                        .code(secondClassify.getCodeValue())
                                        .label(secondClassify.getCodeName())
                                        .treeNode(true)
                                        .pId(firstTreeVo.getId())
                                        .dataType(secondClassify.getTypeCode())
                                        .codeDataTypeStr(UUIDUtils.getUUID() + ID_SEPARATOR + secondClassify.getCodeValue() + ID_SEPARATOR + secondClassify.getTypeCode())
                                        .build();

                                secondTreeVo.setChild(getChildrenTypeList(secondClassify.getChildrenType()).stream()
                                        .map(thirdClassify -> {
                                            DataResourceTreeVo thirdTreeVo = DataResourceTreeVo.builder()
                                                    .id(Joiner.on(ID_SEPARATOR).join(secondTreeVo.getId(), thirdClassify.getTypeCode()))
                                                    .code(thirdClassify.getTypeCode())
                                                    .label(thirdClassify.getTypeName())
                                                    .treeNode(true)
                                                    .pId(secondTreeVo.getId())
                                                    .dataType(thirdClassify.getTypeCode())
                                                    .codeDataTypeStr(UUIDUtils.getUUID() + ID_SEPARATOR + thirdClassify.getTypeCode() + ID_SEPARATOR + thirdClassify.getTypeCode())
                                                    .build();

                                            thirdTreeVo.setChild(thirdClassify.getDataList().stream()
                                                    .map(fourClassify -> {
                                                        DataResourceTreeVo fourTreeVo = DataResourceTreeVo.builder()
                                                                .id(Joiner.on(ID_SEPARATOR).join(thirdTreeVo.getId(), fourClassify.getCodeValue()))
                                                                .code(fourClassify.getCodeValue())
                                                                .label(fourClassify.getCodeName())
                                                                .treeNode(false).child(null)
                                                                .pId(thirdTreeVo.getId())
                                                                .dataType(thirdClassify.getTypeCode())
                                                                .codeDataTypeStr(UUIDUtils.getUUID() + ID_SEPARATOR + fourClassify.getCodeValue() + ID_SEPARATOR + thirdClassify.getTypeCode())
                                                                .build();
                                                        return fourTreeVo;
                                                    }).collect(Collectors.toList()));
                                            return thirdTreeVo;
                                        }).collect(Collectors.toList()));
                                return secondTreeVo;
                            }).collect(Collectors.toList()));
                    return firstTreeVo;
                }).collect(Collectors.toList());
        return collect;
    }

    /**
     * 字段分类
     *
     * @return
     */
    private List<DataResourceTreeVo> getFieldClassifyTreeFromRemote() {
        String id = DataResourceEnum.COLUMN_CLASSIFY.getCode();
        List<DataResourceTreeVo> collect = getFirstChildResourceClassifies(dataResourceService.getFieldClassifyList())
                .stream()
                .map(firstClassify -> {
                    DataResourceTreeVo firstTreeVo = DataResourceTreeVo.builder()
                            .id(Joiner.on(ID_SEPARATOR).join(id, firstClassify.getCodeValue()))
                            .code(firstClassify.getCodeValue())
                            .label(firstClassify.getCodeName())
                            .dataType(firstClassify.getTypeCode())
                            .treeNode(true)
                            .pId(id)
                            .codeDataTypeStr(UUIDUtils.getUUID() + ID_SEPARATOR + firstClassify.getCodeValue() + ID_SEPARATOR + firstClassify.getTypeCode())
                            .build();

                    firstTreeVo.setChild(getFirstChildResourceClassifies(firstClassify.getChildrenType())
                            .stream()
                            .map(secondClassify -> {
                                        DataResourceTreeVo secondTreeVo = DataResourceTreeVo.builder()
                                                .id(Joiner.on(ID_SEPARATOR).join(firstTreeVo.getId(), secondClassify.getCodeValue()))
                                                .code(secondClassify.getCodeValue())
                                                .label(secondClassify.getCodeName())
                                                .treeNode(false)
                                                .dataType(secondClassify.getTypeCode())
                                                .pId(firstTreeVo.getId())
                                                .codeDataTypeStr(UUIDUtils.getUUID() + ID_SEPARATOR + secondClassify.getCodeValue() + ID_SEPARATOR + secondClassify.getTypeCode())
                                                .build();
                                        return secondTreeVo;
                                    }
                            ).collect(Collectors.toList()));
                    return firstTreeVo;
                }).collect(Collectors.toList());
        return collect;
    }

    /**
     * 计算treeVo所有最底层子节点数量,不包含叶节点
     * @param treeVo
     * @return
     */
    private int getTotalCount(DataResourceTreeVo treeVo) {
        int count = 0;
        List<DataResourceTreeVo> child = treeVo.getChild();
        for (DataResourceTreeVo childVo : child) {
            childVo.setPId(treeVo.getId());
            childVo.setId(Joiner.on(ID_SEPARATOR).join(treeVo.getId(), childVo.getCode()));
            List<DataResourceTreeVo> cc = childVo.getChild();
            if(CollectionUtils.isNotEmpty(cc)){
                childVo.setTreeNode(true);
                count += getTotalCount(childVo);
            }else {
                childVo.setTreeNode(false);
                count += 1;
            }
        }
        return count;
    }

    /**
     * 从数据资源目录获取数据-数据分级
     * @return
     */
    private List<DataLevelVo> getDataLevelListFromRemote() {
        return getFirstChildResourceClassifies(dataResourceService.getDataLevelList())
                .stream()
                .map(childResourceClassify -> new DataLevelVo(null, childResourceClassify.getCodeValue(), childResourceClassify.getCodeName(),childResourceClassify.getTypeCode()))
                .collect(Collectors.toList());
    }

    /**
     * 从数据资源目录获取数据-安全级别数据
     * @return
     */
    private List<DataLevelVo> getSecurityLevelListFromRemote() {
        return getFirstChildResourceClassifies(dataResourceService.getSecurityLevelList())
                .stream()
                .map(childResourceClassify -> new DataLevelVo(null, childResourceClassify.getCodeValue(), childResourceClassify.getCodeName(), childResourceClassify.getTypeCode()))
                .collect(Collectors.toList());
    }

    private List<ChildResourceClassify> getFirstChildResourceClassifies(List<ResourceClassify> fieldClassifyList) {
        return Optional.ofNullable(fieldClassifyList)
                .map(resourceClassifies -> resourceClassifies.get(0))
                .map(resourceClassify -> {
                    //设置节点的dataType,dataType为上级的typeCode字段
                    List<ChildResourceClassify> dataList = Optional.ofNullable(resourceClassify.getDataList()).orElse(Lists.newArrayList());
                    dataList.stream().forEach(item-> item.setTypeCode(resourceClassify.getTypeCode()));
                    return dataList;
                })
                .orElse(Lists.newArrayList());
    }

    private List<ResourceClassify> getChildrenTypeList(List<ResourceClassify> fieldClassifyList) {
        return Optional.ofNullable(fieldClassifyList)
                .orElse(Lists.newArrayList());
    }
}