package cn.cslg.pas.service.business;

import cn.cslg.pas.common.TreeBuild;
import cn.cslg.pas.common.dto.PatentColumnDTO;
import cn.cslg.pas.common.dto.QueryPatentClaimDTO;
import cn.cslg.pas.common.dto.QuerySplitDTO;
import cn.cslg.pas.common.dto.business.SelectClaimDTO;
import cn.cslg.pas.common.dto.invalidDTO.QueryClaimSplitHistoryDTO;
import cn.cslg.pas.common.dto.invalidDTO.UpdateFeatureDTO;
import cn.cslg.pas.common.model.cronModel.PersonnelVO;
import cn.cslg.pas.common.model.cronModel.Records;
import cn.cslg.pas.common.utils.CacheUtils;
import cn.cslg.pas.common.utils.LoginUtils;
import cn.cslg.pas.common.utils.PatentRightUtils;
import cn.cslg.pas.common.vo.*;
import cn.cslg.pas.common.vo.business.SplitVO;
import cn.cslg.pas.common.vo.invalidVO.QueryClaimSplitHistoryVO;
import cn.cslg.pas.domain.business.*;
import cn.cslg.pas.domain.es.PatentTranslate;
import cn.cslg.pas.domain.es.Text;
import cn.cslg.pas.exception.XiaoShiException;
import cn.cslg.pas.mapper.FeatureMapper;
import cn.cslg.pas.service.ClaimMessageService;
import cn.cslg.pas.service.business.es.EsService;
import cn.cslg.pas.service.business.invalidReport.AssoGroupFeatureService;
import cn.cslg.pas.service.business.invalidReport.PatentClaimService;
import cn.cslg.pas.service.common.PatentStarApiService;
import cn.cslg.pas.service.common.TranslateService;
import co.elastic.clients.elasticsearch._types.query_dsl.Query;
import co.elastic.clients.elasticsearch._types.query_dsl.QueryBuilders;
import co.elastic.clients.elasticsearch.core.SearchRequest;
import co.elastic.clients.elasticsearch.core.SearchResponse;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import java.io.IOException;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @Author lirj
 * @Date 2023/12/5
 */
@Service
public class FeatureService extends ServiceImpl<FeatureMapper, Feature> {
    @Autowired
    private CacheUtils cacheUtils;
    @Autowired
    private LoginUtils loginUtils;
    @Autowired
    private EsService esService;
    @Autowired
    private ReportProjectService reportProjectService;

    @Autowired
    private PatentSplitMessageService patentSplitMessageService;
    @Autowired
    @Lazy
    private InvalidStatutesService invalidStatutesService;
    @Autowired
    private ProofGroupService proofGroupService;
    @Autowired
    @Lazy
    private AssoGroupFeatureService assoGroupFeatureService;

    @Autowired
    private PatentStarApiService patentStarApiService;
    @Autowired
    private ClaimMessageService claimMessageService;
    @Autowired
    private PatentClaimService patentClaimService;

    @Autowired
    private TranslateService translateService;

    @Transactional(rollbackFor = Exception.class)
    public List<PatentRightVo> splitPatentFeature(SplitVO splitVO) throws IOException {
        String patentNo = splitVO.getPatentNo();
        Integer projectId = splitVO.getProjectId();
        Integer splitType = splitVO.getSplitType();
        Integer splitBy = splitVO.getSplitBy();
        Integer taskId = splitVO.getTaskId();
        Boolean ifReSplit = splitVO.getIfReSplit();

        PersonnelVO personnelVO = cacheUtils.getLoginUser(loginUtils.getId());

        //根据报告ID查询报告
        LambdaQueryWrapper<ReportProject> queryWrapper = new LambdaQueryWrapper();
        queryWrapper.eq(ReportProject::getProjectId, projectId);
        List<ReportProject> reportProjects = reportProjectService.list(queryWrapper);
        //未查到报告报错
        if (reportProjects.size() == 0) {
            throw new XiaoShiException("未查询到报告");
        }

        //查询拆分下的权要
        List<RePatentClaim> patentRights = this.getRightListByNo(patentNo);
        if (patentRights.size() == 0) {
            return new ArrayList<>();
        }
        LambdaQueryWrapper<PatentSplitMessage> splitWrapper = new LambdaQueryWrapper<>();
        splitWrapper.eq(PatentSplitMessage::getPatentNo, patentNo);
        splitWrapper.eq(PatentSplitMessage::getProjectId, projectId);
        //当任务id不为空时
        if (taskId != null) {
            splitWrapper.eq(PatentSplitMessage::getTaskId, taskId);
        }
        PatentSplitMessage patentSplitMessage = patentSplitMessageService.getOne(splitWrapper, false);

        LambdaQueryWrapper<Feature> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(Feature::getProjectId, projectId)
                .eq(Feature::getPatentNo, patentNo);
        if (patentSplitMessage != null) {
            wrapper.eq(Feature::getSplitMessageId, patentSplitMessage.getId());
        }
        List<Feature> allFeatures = new ArrayList<>();
        //如果是不重拆
        if (!ifReSplit) {
            //如果拆分过
            if (patentSplitMessage != null) {
                allFeatures = this.list(wrapper);
            }
            //如果没有拆分过
            else {
                patentSplitMessage = new PatentSplitMessage();
                patentSplitMessage.setPatentNo(patentNo);
                patentSplitMessage.setProjectId(projectId);
                patentSplitMessage.setTenantId(personnelVO.getTenantId());
                patentSplitMessage.setCreateId(personnelVO.getId());
                if (taskId != null) {
                    patentSplitMessage.setTaskId(taskId);
                }
                patentSplitMessage.insert();
                allFeatures = this.splitFeature(splitBy, splitType, patentNo, projectId, taskId, patentRights, patentSplitMessage.getId());


            }
        }
        //当重拆时新建
        else {
            if (patentSplitMessage == null) {
                throw new XiaoShiException("未拆分过，请重新选择拆分方式");
            }

            //更新拆分信息
            patentSplitMessage.setCreateTime(new Date());
            patentSplitMessage.setCreateId(personnelVO.getId());
            patentSplitMessage.updateById();
            //清除原本的
            this.remove(wrapper);
            allFeatures = this.splitFeature(splitBy, splitType, patentNo, projectId, taskId, patentRights, patentSplitMessage.getId());

        }
        //装载信息并返回
        List<PatentRightVo> patentRightVos = new ArrayList<>();
        patentRightVos = this.loadPatentRightVO(patentRights, allFeatures, projectId, patentNo);
        return patentRightVos;
    }

    //根据符号拆分字符串
    public List<String> splitStringByFlags(String sentence, List<String> flags) {
        List<String> sectences = new ArrayList<>();
//如果字符串为空则返回一个包含空字符串的list
        if (sentence == null) {
            sectences.add("");
            return sectences;
        }
        sectences.add(sentence);
        for (int i = 0; i < flags.size(); i++) {
            List<String> tem = new ArrayList<>();
            for (int t = 0; t < sectences.size(); t++) {
                List<String> attrs = Arrays.asList(sectences.get(t).split(flags.get(i)));
                for (int v = 0; v < attrs.size(); v++) {
                    if (v < attrs.size() - 1) {
                        attrs.set(v, attrs.get(v) + flags.get(i));
                    }
                    if (attrs.get(v).equals("其特征在于" + flags.get(i))) {
                        tem.set(tem.size() - 1, tem.get(tem.size() - 1) + attrs.get(v));
                    } else {
                        tem.add(attrs.get(v));
                    }
                }
            }
            sectences = tem;

        }
        return sectences;

    }

    @Transactional(rollbackFor = Exception.class)
    public List<RePatentClaim> getRightListByNo(String patentNo) throws IOException {
        //从pas获得拆分后的权要
        SelectClaimDTO selectClaimDTO = null;
        try {
            selectClaimDTO = esService.selectClaim(patentNo);
        } catch (Exception e) {
            throw new XiaoShiException("未查询到权要");
        }
        if (selectClaimDTO == null) {
            throw new XiaoShiException("未查询到权要");
        }
        String patentRight = selectClaimDTO.getClaim();
        PatentRightParams params = new PatentRightParams();
        params.setContent(patentRight);
        params.setPatentNo(patentNo);
        List<RePatentClaim> patentRights = PatentRightUtils.formatPatentRight(params);
        patentRights.forEach(item -> {
            item.setRightName("权要" + (item.getSort() + 1));
        });
        return patentRights;
    }

    @Transactional(rollbackFor = Exception.class)
    public List<RePatentClaim> getRightListByNo(String patentNo, String appNo) throws IOException {
        //从pas获得拆分后的权要
        SelectClaimDTO selectClaimDTO = null;
        String patentRight = "";
        try {
            if (appNo != null) {
                selectClaimDTO = patentStarApiService.getOrginCalim(appNo);
                if (selectClaimDTO != null && selectClaimDTO.getClaimContent() != null && selectClaimDTO.getClaimContent().size() != 0) {
                    patentRight = selectClaimDTO.getClaimContent().get(0).getTextContent();

                }
            } else if (patentNo != null) {
                selectClaimDTO = esService.selectClaim(patentNo);
                patentRight = selectClaimDTO.getClaim();
            }

        } catch (Exception e) {
            throw new XiaoShiException("未查询到权要");
        }
        if (selectClaimDTO == null) {
            throw new XiaoShiException("未查询到权要");
        }

        PatentRightParams params = new PatentRightParams();
        params.setContent(patentRight);
        params.setPatentNo(patentNo);
        List<RePatentClaim> patentRights = PatentRightUtils.formatPatentRight(params);
        patentRights.forEach(item -> {
            item.setRightName("权要" + (item.getSort() + 1));
        });
        return patentRights;
    }

    //获得专利拆分信息
    public QuerySplitVO getSplitMessage(QuerySplitDTO splitDTO) {
        QuerySplitVO splitVO = new QuerySplitVO();
        //根据项目id和专利号查询拆分信息
        LambdaQueryWrapper<ReportProject> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(ReportProject::getProjectId, splitDTO.getProjectId());
        ReportProject reportProject = reportProjectService.getOne(lambdaQueryWrapper, false);
        if (reportProject == null) {
            throw new XiaoShiException("未查询到报告");
        }
        Integer splitType = reportProject.getSplitType();
        Integer splitBy = reportProject.getSplitBy();
        if (splitBy != null && splitType != null) {
            splitVO.setSplitBy(splitBy);
            splitVO.setSplitType(splitType);
            splitVO.setIfFirst(false);
        } else {
            splitVO.setSplitBy(0);
            splitVO.setSplitType(0);
            splitVO.setIfFirst(true);
        }

        return splitVO;
    }

    public List<RePatentClaim> getPatentRight(String patentNo) {
        try {
            List<RePatentClaim> patentRights = this.getRightListByNo(patentNo);
            return patentRights;
        } catch (Exception e) {
            throw new XiaoShiException("系统错误");
        }
    }

    public List<PatentRightTree> getPatentRightTree(String patentNo, String appNo) {
        try {
            List<RePatentClaim> patentRights = this.getRightListByNo(patentNo, appNo);
            Long total = translateService.getTranslateByPatentNo(patentNo);
            if (total < 1) {
                PatentColumnDTO columnDTO = translateService.getPatentByPatentNo(patentNo);
                List<Text> claim = columnDTO.getClaim();
                if (!CollectionUtils.isEmpty(claim)) {
                    Text text = claim.get(0);
                    for (RePatentClaim rePatentClaim : patentRights) {
                        if (rePatentClaim.getContent().contains("&nbsp;")) {
                            String replace = rePatentClaim.getContent().replace("&nbsp;", " ");
                            rePatentClaim.setContent(replace);
                        }
                        //原文
                        translateService.loadingTranslate(patentNo, "3", text.getLanguage(), true,
                                rePatentClaim.getSort(), rePatentClaim.getParentSort(), rePatentClaim.getContent());
                    }
                }
            }

            List<PatentRightTree> treeNodeList = new ArrayList<>();
            //装载权要原文
//            PatentRightParams params = new PatentRightParams();
//            params.setPatentNo(patentNo);
//            params.setContent("");


            //判断若处理后的权要集合只有1个元素并且类型type=-1、排序号sort=-1，则表示本次拆分失败，则直接返回整个权要
            if (patentRights.size() == 1 && (patentRights.get(0).getType() == null || patentRights.get(0).getType() == -1) && patentRights.get(0).getSort() == -1) {
                List<String> list = translateService.getTranslateOrder(patentNo, patentRights.get(0).getSort());
                String translateContent = "";
                if (!CollectionUtils.isEmpty(list)) {
                    translateContent = list.get(0);
                }
                treeNodeList.add(new PatentRightTree(patentRights.get(0).getSort(), null, patentRights.get(0).getContent(), translateContent));
                return treeNodeList;
            }
            List<PatentRightContent> patentRightContents = this.loadPatentRightContent(patentRights);
            for (PatentRightContent patentRightContent : patentRightContents) {
                List<String> list = translateService.getTranslateOrder(patentNo, patentRightContent.getSort());
                String translateContent = "";
                if (!CollectionUtils.isEmpty(list)) {
                    translateContent = list.get(0);
                }
                treeNodeList.add(new PatentRightTree(patentRightContent.getSort(), patentRightContent.getParentSorts(), patentRightContent.getContent(), translateContent));
            }

            //开始进行权要树装载
            try {
                TreeBuild treeBuild = new TreeBuild(treeNodeList);
                treeNodeList = treeBuild.buildTree();
            } catch (Exception e) {
                e.printStackTrace();
            }
            return treeNodeList;

        } catch (Exception e) {
            throw new XiaoShiException(e.getMessage());
        }
    }

    private List<PatentRightContent> loadPatentRightContent(List<RePatentClaim> rePatentClaims) {
        List<PatentRightContent> patentRightContents = new ArrayList<>();
        rePatentClaims.forEach(item -> {
            List<Integer> sorts = new ArrayList<>();
            String[] a = item.getParentSort().split(",");
            for (int i = 0; i < a.length; i++) {
                sorts.add(Integer.parseInt(a[i]));
            }
            PatentRightContent patentRightContent = new PatentRightContent();
            patentRightContent.setContent(item.getContent());
            patentRightContent.setType(item.getType());
            patentRightContent.setSort(item.getSort());
            patentRightContent.setParentSorts(sorts);
            patentRightContents.add(patentRightContent);
        });

        return patentRightContents;
    }


    public List<Feature> splitFeature(Integer splitBy, Integer splitType, String patentNo, Integer projectId, Integer taskId, List<RePatentClaim> patentRights, Integer splitMessageId) throws IOException {
        List<Feature> allFeatures = new ArrayList<>();
        PersonnelVO personnelVO = new PersonnelVO();
        personnelVO.setId("1");
        personnelVO.setTenantId(1);
        List<String> flags = new ArrayList<>();
        List<Integer> partRightSorts = new ArrayList<>();  //权要sorts
        if (splitBy == 0) {  //当splitBy=0时仅仅根据“,”拆解
            flags.add(",");
            flags.add("，");
        } else if (splitBy == 1) {  //当splitBy=1时仅仅根据“;“拆解
            flags.add(";");
            flags.add("；");
        } else if (splitBy == 2) {  //当splitBy=2时根据“;“和”,”拆解
            flags.add(";");
            flags.add("；");
            flags.add(",");
            flags.add("，");
        }
        if (splitType.equals(0)) {  //当splitType=0仅拆解主权要
            partRightSorts = patentRights.stream().filter(item -> item.getType().equals(1)).map(RePatentClaim::getSort).collect(Collectors.toList());
        } else if (splitType.equals(1)) {  //当splitType=1拆解全部权要
            partRightSorts = patentRights.stream().map(RePatentClaim::getSort).collect(Collectors.toList());
        }
        //遍历权要保存特征
        for (int i = 0; i < patentRights.size(); i++) {
            List<Feature> featureList = new ArrayList<>();
            //根据拆分方式返回特征
            List<String> contents = Arrays.asList(patentRights.get(i).getContent());

            //如果是需要拆解的权要
            if (partRightSorts.contains(patentRights.get(i).getSort())) {
                //获得权要的原文并且拆解
                contents = this.splitStringByFlags(patentRights.get(i).getContent(), flags);
            }
            for (int t = 0; t < contents.size(); t++) {
                Feature feature = new Feature();
                feature.setRightSort(patentRights.get(i).getSort());
                feature.setPatentNo(patentNo);
                feature.setProjectId(projectId);
                feature.setSysOrder(t + 1);
                feature.setContent(contents.get(t));
                feature.setCreateId(personnelVO.getId());
                feature.setRightType(patentRights.get(i).getType());
                feature.setTenantId(personnelVO.getTenantId());
                feature.setSplitMessageId(splitMessageId);
                if (taskId != null) {
                    feature.setProjectTaskId(taskId);
                }
                featureList.add(feature);
            }
            if (featureList.size() > 0) {
                this.saveBatch(featureList);
                allFeatures.addAll(featureList);
            }
        }

        return allFeatures;
    }

    public List<PatentRightVo> loadPatentRightVO(List<RePatentClaim> patentRights, List<Feature> allFeatures, Integer projectId, String patentNo) {
        List<PatentRightVo> patentRightVos = new ArrayList<>();
        //将拆解的权要和特征装载到对象PatentRightVo
        for (int i = 0; i < patentRights.size(); i++) {
            List<Feature> featureList = new ArrayList<>();
            Integer sort = patentRights.get(i).getSort();

            featureList = allFeatures
                    .stream()
                    .filter(item -> item.getRightSort().equals(sort))
                    .sorted(Comparator.comparing(Feature::getSysOrder,
                            Comparator.nullsLast(Integer::compareTo)))
                    .collect(Collectors.toList());
            PatentRightVo patentRightVo = new PatentRightVo();
            patentRightVo.setPatentNo(patentRights.get(i).getPatentNo());
            patentRightVo.setFeatures(featureList);
            patentRightVo.setContent(patentRights.get(i).getContent());
            patentRightVo.setSort(patentRights.get(i).getSort() + 1);
            patentRightVo.setType(patentRights.get(i).getType());
            patentRightVo.setContentOut(patentRights.get(i).getContentOut());
            patentRightVo.setProjectId(projectId);
            patentRightVo.setRightName("权要" + (sort + 1));
            patentRightVo.setSignPatentNo(patentNo);
            patentRightVos.add(patentRightVo);
        }
        return patentRightVos;
    }


    public Records queryClaimSplitHistory(QueryClaimSplitHistoryDTO queryClaimSplitHistoryDTO) {
        List<QueryClaimSplitHistoryVO> queryClaimSplitHistoryVOS = new ArrayList<>();
        Integer claimId = queryClaimSplitHistoryDTO.getClaimId();
        Long current = queryClaimSplitHistoryDTO.getCurrent();
        Long size = queryClaimSplitHistoryDTO.getSize();
        //根据id查询无效发条
        LambdaQueryWrapper<InvalidStatutes> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(InvalidStatutes::getClaimId, claimId);
        List<InvalidStatutes> invalidStatutes = invalidStatutesService.list(queryWrapper);
        //根据无效发条查询证据组合
        if (invalidStatutes.size() != 0) {
            List<Integer> statutesIds = invalidStatutes.stream().map(InvalidStatutes::getId).collect(Collectors.toList());
            //根据无效法条id查询证据组合
            LambdaQueryWrapper<ProofGroup> queryWrapper1 = new LambdaQueryWrapper<>();
            queryWrapper1.in(ProofGroup::getInvalidStatutesId, statutesIds);
            List<ProofGroup> proofGroups = proofGroupService.list(queryWrapper1);
            if (proofGroups.size() > 0) {
                proofGroups.forEach(item -> {
                    //根据id 查询特征
                    Integer groupId = item.getId();
                    LambdaQueryWrapper<AssoGroupFeature> queryWrapper2 = new LambdaQueryWrapper<>();
                    queryWrapper2.eq(AssoGroupFeature::getGroupId, groupId);
                    List<AssoGroupFeature> assoGroupFeatures = assoGroupFeatureService.list(queryWrapper2);

                    if (assoGroupFeatures != null && assoGroupFeatures.size() != 0) {
                        List<Integer> featureIds = assoGroupFeatures.stream().map(AssoGroupFeature::getFeatureId).collect(Collectors.toList());

                        if (featureIds.size() != 0) {
                            LambdaQueryWrapper<Feature> queryWrapper3 = new LambdaQueryWrapper<>();
                            queryWrapper3.in(Feature::getId, featureIds);
                            List<Feature> featureList = this.list(queryWrapper3);

                            if (featureList.size() != 0) {
                                QueryClaimSplitHistoryVO queryClaimSplitHistoryVO = new QueryClaimSplitHistoryVO();
                                List<QueryClaimSplitHistoryVO.GroupFeature> features = new ArrayList<>();
                                featureList.forEach(i -> {
                                    QueryClaimSplitHistoryVO.GroupFeature tem = new QueryClaimSplitHistoryVO.GroupFeature();
                                    tem.setFeatureText(i.getContent());
                                    tem.setId(i.getId());
                                    AssoGroupFeature assoGroupFeature = assoGroupFeatures.stream().filter(t -> t.getFeatureId().equals(i.getId())).findFirst().orElse(null);
                                    if (assoGroupFeature != null) {
                                        tem.setSysOrder(assoGroupFeature.getFeatureOrder());
                                    }
                                    features.add(tem);
                                });
                                queryClaimSplitHistoryVO.setFeatureSplitContent(features);
                                queryClaimSplitHistoryVOS.add(queryClaimSplitHistoryVO);
                            }
                        }
                    }
                });
            }
        }

        Records records = new Records();
        records.setData(queryClaimSplitHistoryVOS);
        return records;
    }


    /**
     * 获得已经拆分过的特征
     *
     * @param splitVO
     */
    public List<Feature> getSplitedFeature(SplitVO splitVO) {
        List<PatentRightVo> patentRightVos = new ArrayList<>();
        Integer projectId = splitVO.getProjectId();
        String patentNo = splitVO.getPatentNo();

        //当未传入专利号时，从报告里拿标的专利
        if (patentNo == null || patentNo.equals("")) {
            LambdaQueryWrapper<ReportProject> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(ReportProject::getProjectId, projectId);
            ReportProject reportProject = reportProjectService.getOne(queryWrapper, false);
            if (reportProject == null) {
                throw new XiaoShiException("未查到报告");
            }
            patentNo = reportProject.getSignPatentNo();
        }


        LambdaQueryWrapper<PatentSplitMessage> splitWrapper = new LambdaQueryWrapper<>();
        splitWrapper.eq(PatentSplitMessage::getPatentNo, patentNo);
        splitWrapper.eq(PatentSplitMessage::getProjectId, projectId);

        PatentSplitMessage patentSplitMessage = patentSplitMessageService.getOne(splitWrapper, false);
        List<Feature> allFeatures = new ArrayList<>();
        if (patentSplitMessage == null) {
            return allFeatures;
        }
        LambdaQueryWrapper<Feature> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(Feature::getProjectId, projectId)
                .eq(Feature::getPatentNo, patentNo)
                .eq(Feature::getSplitMessageId, patentSplitMessage.getId());
        allFeatures = this.list(wrapper);
        return allFeatures;
    }

    /**
     * 保存特征
     *
     * @param updateFeatureDTO
     * @return
     */
    public List<Integer> saveBatchFeature(UpdateFeatureDTO updateFeatureDTO) {
        List<UpdateFeatureDTO.ChangedFeatures> features = updateFeatureDTO.getFeaturesList();
        Integer projectId = updateFeatureDTO.getProjectId();
        if (features == null) {
            features = new ArrayList<>();
        }
        if (projectId == null) {
            throw new XiaoShiException("未选择报告");
        }
        LambdaQueryWrapper<ReportProject> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(ReportProject::getProjectId, projectId);
        ReportProject reportProject = reportProjectService.getOne(queryWrapper, false);
        if (reportProject == null) {
            throw new XiaoShiException("报告不存在");
        }
        String signPatentNo = reportProject.getSignPatentNo();

        //根据标的专利号和报告id查询拆分信息
        LambdaQueryWrapper<PatentSplitMessage> queryWrapper1 = new LambdaQueryWrapper<>();
        queryWrapper1.eq(PatentSplitMessage::getPatentNo, signPatentNo)
                .eq(PatentSplitMessage::getProjectId, projectId);
        PatentSplitMessage patentSplitMessage = patentSplitMessageService.getOne(queryWrapper1, false);
        if (patentSplitMessage == null) {
            throw new XiaoShiException("未进行拆分过");
        }
        List<Integer> ids = this.saveFeatures(features, patentSplitMessage.getId(), projectId, signPatentNo);
        return ids;
    }


    /**
     * 批量添加特征
     *
     * @param features
     * @param splitMessageId
     * @param projectId
     * @return
     */
    public List<Integer> saveFeatures(List<UpdateFeatureDTO.ChangedFeatures> features, Integer splitMessageId, Integer projectId, String patentNo) {
        List<Integer> addIds = new ArrayList<>();
        LambdaQueryWrapper<Feature> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.select(Feature::getId);
        queryWrapper.eq(Feature::getSplitMessageId, splitMessageId);
        List<Feature> featureList = this.list(queryWrapper);
        List<Integer> ids = featureList.stream().map(Feature::getId).collect(Collectors.toList());

        PersonnelVO personnelVO = new PersonnelVO();
        personnelVO.setId("1");
        personnelVO.setTenantId(1);

        List<Feature> addFeatures = new ArrayList<>();
        Integer order = 1;
        for (UpdateFeatureDTO.ChangedFeatures item : features) {
            Integer id = item.getId();
            if (id == null || !ids.contains(id)) {
                Feature feature = new Feature();
                feature.setCreateId(personnelVO.getId());
                feature.setSplitMessageId(splitMessageId);
                feature.setContent(item.getContent());
                feature.setExplainText(item.getExplainText());
                feature.setRightSort(item.getRightSort());
                feature.setProjectId(projectId);
                feature.setSysOrder(order);
                feature.setPatentNo(patentNo);
                feature.setRightType(item.getRightType());
                feature.setTenantId(personnelVO.getTenantId());
                feature.insert();
            } else {
                ids.remove(id);
                Feature feature = this.getById(id);
                feature.setSysOrder(order);
                feature.setContent(item.getContent());
                feature.setExplainText(item.getExplainText());
                feature.updateById();

            }
            order++;
        }

        //添加特征
        if (addFeatures.size() != 0) {
            addIds = addFeatures.stream().map(Feature::getId).collect(Collectors.toList());
        }
        if (ids.size() != 0) {
            this.removeBatchByIds(ids);
        }
        return addIds;
    }


    public List<RePatentClaim> getPatentRight(QueryPatentClaimDTO queryPatentClaimDTO) {
        try {
            List<RePatentClaim> patentRights = new ArrayList<>();
            Integer taskId = queryPatentClaimDTO.getTaskId();
            Integer projectId = queryPatentClaimDTO.getProjectId();
            String patentNo = queryPatentClaimDTO.getPatentNo();
            Integer literatureId = queryPatentClaimDTO.getLiteratureId();
            ClaimMessage claimMessage = claimMessageService.getClaimMessage(taskId, projectId, patentNo, literatureId);
            if (claimMessage == null) {
                patentRights = this.getRightListByNo(patentNo);
            } else {
                Integer claimMessageId = claimMessage.getId();
                LambdaQueryWrapper<PatentClaim> queryWrapper = new LambdaQueryWrapper<>();
                queryWrapper.eq(PatentClaim::getClaimMessageId, claimMessageId);
                List<PatentClaim> patentClaimList = patentClaimService.list(queryWrapper);
                for (PatentClaim item : patentClaimList) {
                    RePatentClaim rePatentClaim = this.domainToRe(item);
                    patentRights.add(rePatentClaim);
                }
            }
            return patentRights;
        } catch (Exception e) {
            throw new XiaoShiException("系统错误");
        }
    }

    private RePatentClaim domainToRe(PatentClaim patentClaim) {
        RePatentClaim rePatentClaim = new RePatentClaim();
        rePatentClaim.setContent(patentClaim.getContent());
        rePatentClaim.setId(patentClaim.getId());
        rePatentClaim.setSort(patentClaim.getSysOrder());
        rePatentClaim.setParentSort(patentClaim.getParentOrder());
        rePatentClaim.setType(patentClaim.getClaimType());
        return rePatentClaim;
    }
}