package cn.cslg.report.service.business;

import cn.cslg.report.common.model.SystemMO;
import cn.cslg.report.common.model.vo.*;
import cn.cslg.report.common.utils.*;
import cn.cslg.report.common.utils.SecurityUtils.LoginUtils;
import cn.cslg.report.entity.*;
import cn.cslg.report.entity.asso.AssoRecordsFeature;
import cn.cslg.report.mapper.AvoidDesignLittleDirectionMapper;
import cn.cslg.report.mapper.AvoidDesignWholeDirectionMapper;
import cn.cslg.report.mapper.ReportDocumentMapper;
import cn.cslg.report.service.IAvoidDesignDirectionService;
import cn.cslg.report.service.OutInterfaceService;
import cn.hutool.core.util.IdUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.deepoove.poi.XWPFTemplate;
import com.deepoove.poi.config.Configure;
import com.deepoove.poi.plugin.table.LoopRowTableRenderPolicy;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.ddr.poi.html.HtmlRenderPolicy;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

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

@Service
@Slf4j
@RequiredArgsConstructor(onConstructor_ = {@Lazy})
@SuppressWarnings({"all"})
public class ReportDocumentService extends ServiceImpl<ReportDocumentMapper, ReportDocument> {

    private final OutInterfaceService outInterfaceService;
    private final CompareScenariosService compareScenariosService;
    private final CompareScenariosAndRecordsService scenariosRecordsService;
    private final CompareRecordsService compareRecordsService;
    private final AssoRecordsFeatureService assoRecordsFeatureService;
    private final FeatureService featureService;
    private final ReportService reportService;
    private final TemplateService templateService;
    private final FileUtils fileUtils;
    private final LoginUtils loginUtils;
    private final CacheUtils cacheUtils;
    private final ReportFieldService reportFieldService;
    private final TemplateConfigService templateConfigService;
    private final ReportFieldPatentLinkService reportFieldPatentLinkService;
    private final CompareMessageService compareMessageService;
    private final CompareFilesService compareFilesService;
    private final AvoidDesignLittleDirectionMapper avoidDesignLittleDirectionMapper;
    private final AvoidDesignWholeDirectionMapper avoidDesignWholeDirectionMapper;
    @Value("${RMSFile}")
    private String rmsFile;
    @Value("${PASFile}")
    private String pasFile;

    public String reportDocument(ReportDocument reportDocument) {

        return Response.success();

    }

    /**
     * @param reportDocument
     * @return
     * @function: 根据报告Id获得报告的导出记录
     */
    public String getExportList(ReportDocument reportDocument) {
        LambdaQueryWrapper<ReportDocument> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(ReportDocument::getReportId, reportDocument.getReportId());
        IPage<ReportDocument> pages = this.page(new Page<>(reportDocument.getCurrent(), reportDocument.getSize()), wrapper);
        return Response.success(pages);
    }

    public String deleteExport(Integer id) {
        this.removeById(id);
        return Response.success();
    }


    /**
     * @param reportId
     * @param templeId
     * @return
     * @throws IOException
     * @function: 导出报告
     */
    public String exportReport(Integer reportId, Integer templeId) throws IOException {
        //根据模板ID获得模板
        Template reportTemplate = templateService.getById(templeId);
        //获得模板路径
        String filePath = fileUtils.getPath(reportTemplate.getTemplatePath());
        //读取模板后保存生成word的地址
        String fileName = IdUtil.simpleUUID() + ".docx";
        String directoryName = fileUtils.createDirectory();
        String outPath = fileUtils.getSavePath(directoryName) + fileName;
        Report report = reportService.getById(reportId);
        XWPFTemplate template = null;
        if (report.getType() == 0 || report.getType() == 2) {
            template = this.getstabilityTemplate(report, filePath);
        } else if (report.getType() == 3) {
            template = this.FTOtemplate(reportId, filePath, templeId);
        } else if (report.getType() == 4) {
            template = this.Torttemplate(reportId, filePath, templeId);
        } else if (report.getType() == 5) {
            template = this.avoidDesignTemplate(reportId, filePath);
        } else if (report.getType() == 1) {
            template = this.getThirdTemplate(report, filePath);
        }
        // 读取模板、数据并渲染
//         文件是否已存在，则删除
        File file = new File(outPath);
        if (file.exists()) {
            file.delete();
        }
//      生成word保存在指定目录
        template.writeToFile(outPath);
        template.close();
        //导出成功后，导出报告记录入库
        String url = fileUtils.getDirectory2(directoryName) + fileName;
        PersonnelVO personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
        ReportDocument reportDocument = new ReportDocument();
        reportDocument.setReportId(reportId);
        reportDocument.setFileName(fileName);
        reportDocument.setFilePath(url);
        reportDocument.setPersonId(personnelVO.getId());
        reportDocument.setTemplateId(reportTemplate.getId());
        reportDocument.setTemplateName(reportTemplate.getTemplateName());
        reportDocument.setPersonName(personnelVO.getName());
        reportDocument.insert();
        return Response.success(url);
    }


    /**
     * @return
     * @autor lrj
     * @description 装载稳定和无效模板信息
     */

    private XWPFTemplate getstabilityTemplate(Report report, String filePath) throws IOException {
        List<PatentRight> patentRights = new ArrayList<>();
        //装载标的专利信息
        Map<String, Object> signPatent = this.signPantentMess(report.getSignPatentNo());
        //根据报告Id获得报告信息
        // 根据拆分人（报告的创建人）Id和报告ID获得所有特征
        LambdaQueryWrapper<Features> allFeaturesWrapper = new LambdaQueryWrapper<>();
        allFeaturesWrapper.eq(Features::getReportId, report.getId());
        allFeaturesWrapper.and(wrapper -> wrapper.eq(Features::getPartnerId, report.getPersonId()).or().eq(Features::getPartnerId, report.getCreatePersonId()));

        List<Features> allFeatures = featureService.list(allFeaturesWrapper);
        //根据报告Id 查询出报告下所有的方案
        LambdaQueryWrapper<CompareScenarios> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(CompareScenarios::getReportId, report.getId());
        List<CompareScenarios> compareScenarios = compareScenariosService.list(queryWrapper);
        List<Integer> scenarioIds = compareScenarios.stream().map(CompareScenarios::getId).collect(Collectors.toList());
        //根据对比方案Id 查询所有对比方案和（对比记录-特征）关联信息
        List<AssoScenarIOS> scenariosRecords = new ArrayList<>();
        if (scenarioIds != null && scenarioIds.size() != 0) {
            LambdaQueryWrapper<AssoScenarIOS> queryRecordsByIDs = new LambdaQueryWrapper<>();
            queryRecordsByIDs.in(AssoScenarIOS::getScenariosID, scenarioIds);
            scenariosRecords = scenariosRecordsService.list(queryRecordsByIDs);
        }
        //获得对比记录-特征关联ID
        List<Integer> recordfeatureRecordIds = scenariosRecords.stream().map(AssoScenarIOS::getFeatureRecordID).collect(Collectors.toList());
        //从关联表里获得是公识的特征Id
        List<Integer> knowedIds = scenariosRecords.stream().map(AssoScenarIOS::getFeaturesID).collect(Collectors.toList());
        //根据对比记录-特征关联ID查出对比记录-特征关联信息
        List<AssoRecordsFeature> assoRecordsFeatures = new ArrayList<>();
        if (recordfeatureRecordIds != null && recordfeatureRecordIds.size() != 0) {
            LambdaQueryWrapper<AssoRecordsFeature> wrapper = new LambdaQueryWrapper<>();
            wrapper.in(AssoRecordsFeature::getId, recordfeatureRecordIds);
            assoRecordsFeatures = assoRecordsFeatureService.list(wrapper);
        }
        List<AssoRecordsFeature> finalAsso = assoRecordsFeatures;
        //从对比记录-特征关联信息里剔出对比记录Id
        List<Integer> recordIds = assoRecordsFeatures.stream().map(AssoRecordsFeature::getRecordsId).collect(Collectors.toList());
        //从对比记录-特征关联信息里剔出特征Id
        List<Integer> sFeatureIds = assoRecordsFeatures.stream().map(AssoRecordsFeature::getFeatureId).collect(Collectors.toList());
        sFeatureIds.addAll(knowedIds);
        //根据特征ID查询出报告所有方案的特征
        List<Features> sFeatures = new ArrayList<>();
        LambdaQueryWrapper<Features> sFeaturesWrapper = new LambdaQueryWrapper<>();
        sFeaturesWrapper.eq(Features::getId, sFeatureIds);
        if (sFeatures != null && sFeatures.size() != 0) {
            sFeatures = featureService.list(sFeaturesWrapper);
        }
        //根据对比记录ID查询出报告所有方案的对比记录
        List<CompareRecords> compareRecords = new ArrayList<>();
        if (recordIds != null && recordIds.size() != 0) {
            LambdaQueryWrapper<CompareRecords> queryPatentByIDs = new LambdaQueryWrapper<>();
            queryPatentByIDs.in(CompareRecords::getId, recordIds);
            compareRecords = compareRecordsService.list(queryPatentByIDs);
        }
        //根据对比记录ID获得专利号
        List<String> PatentNos = compareRecords.stream().map(CompareRecords::getPatentNo).collect(Collectors.toList());
        PatentVO patentVO = new PatentVO();
        patentVO.setPatentNos(PatentNos);
        //根据专利号查询专利的排序
        LambdaQueryWrapper<CompareFiles> comWrapper = new LambdaQueryWrapper<>();
        comWrapper
                .eq(CompareFiles::getReportId, report.getId())
                .last("ORDER BY IF(isnull(SYS_ORDER),1,0), SYS_ORDER ASC");
        ;
        List<CompareFiles> compareFiles = compareFilesService.list(comWrapper);
        //专利号别名的map
        Map<String, Object> OtherName = new HashMap<>();
        int flag = 1;
        for (CompareFiles item : compareFiles) {
            Integer order = item.getSysOrder() == null ? flag : item.getSysOrder();
            OtherName.put(item.getPatentNo(), order);
            flag++;
        }

        //根据专利号查询专利详细信息
        String resBody = outInterfaceService.getPatentDTOListForRMS(patentVO);
        JSONObject jsonObject = JSONObject.parseObject(resBody);
        List<JSONObject> patentDTOS = JSON.parseArray(jsonObject.get("data").toString(), JSONObject.class);
        //存放专利信息的map集合
        List<Map<String, Object>> patentListMaps = new ArrayList<>();
        //填充专利数据到patentListMap
        for (int i = 0; i < patentDTOS.size(); i++) {
            JSONObject item = patentDTOS.get(i);
            Map<String, Object> patentListMap = new HashMap<>();
            List<JSONObject> applicantJSONs = JSON.parseArray(item.get("applicant").toString(), JSONObject.class);
            ;
            StringBuilder applicants = new StringBuilder();
            applicantJSONs.forEach(tem -> {
                applicants.append(tem.get("name") + "\r");
            });
            //填充相关揭露（对比记录文字和特征组合）
            StringBuffer disclosures = new StringBuffer("");
            //根据专利号获得对比记录
            List<CompareRecords> pantentRecords = compareRecords.stream().filter(tem -> tem.getPatentNo().equals(item.get("publicNo"))).collect(Collectors.toList());
            //遍历对比记录根据对比记录获得对比记录-特征关联信息并获得特征ID
            for (CompareRecords tem : pantentRecords) {
                //填充对比记录文字
                disclosures.append(tem.getContent());
                disclosures.append("\r");
                disclosures.append("(");
                disclosures.append(tem.getFields());
                disclosures.append("[" + (tem.getPosition()) + "]");
                disclosures.append(")");
                List<Integer> featuresIds = assoRecordsFeatures.stream().filter(te -> te.getRecordsId().equals(tem.getId())).map(AssoRecordsFeature::getFeatureId).collect(Collectors.toList());
                //根据特征Id获得特征内容
                List<String> feaListContent = sFeatures.stream().filter(te -> featuresIds.contains(te.getId())).map(Features::getContent).collect(Collectors.toList());
                feaListContent.forEach(te -> disclosures.append("(" + te + ")"));
                disclosures.append("\n");
            }
            int order = Integer.parseInt(OtherName.get(item.get("publicNo")).toString());

            patentListMap.put("name", item.get("name"));
            patentListMap.put("fileName", "D" + order);
            patentListMap.put("publicDate", item.get("publicDate"));
            patentListMap.put("publicNo", item.get("publicNo"));
            patentListMap.put("SSIM", "");
            patentListMap.put("applicant", applicants);
            patentListMap.put("patentNo", item.get("publicNo"));
            patentListMap.put("abstractStr", item.get("abstractStr"));
            patentListMap.put("compareFileName", "对比文件" + (order));
            patentListMap.put("applicationDate", item.get("applicationDate"));
            patentListMap.put("abstractPath", pasFile + item.get("abstractPath"));
            patentListMap.put("disclosures", disclosures);
            patentListMap.put("order", order);
            patentListMaps.add(patentListMap);

        }
        //存放对比方案信息的map集合
        List<Map<String, Object>> scenariosMaps = new ArrayList<>(compareFiles.size());
        //存放所有对比方案所有不重复的rightId
        List<Integer> rightIds = new ArrayList<>();
        for (int i = 0; i < compareScenarios.size(); i++) {
            CompareScenarios item1 = compareScenarios.get(i);
            //获得单个对比方案的
            List<AssoScenarIOS> partScenariosRecords = scenariosRecords.stream().filter(item -> item.getScenariosID().equals(item1.getId())).collect(Collectors.toList());
            List<Integer> featureRecordsIds = partScenariosRecords.stream().map(AssoScenarIOS::getFeatureRecordID).collect(Collectors.toList());
            List<AssoRecordsFeature> assoRecordsFeatures1 = assoRecordsFeatures.stream().filter(item -> featureRecordsIds.contains(item.getId())).collect(Collectors.toList());
            List<Integer> partRecordIds = assoRecordsFeatures1.stream().map(AssoRecordsFeature::getRecordsId).collect(Collectors.toList());
            List<Integer> partFetIds = assoRecordsFeatures1.stream().map(AssoRecordsFeature::getFeatureId).collect(Collectors.toList());
            //获得公识特征的ID
            List<Integer> comFetIds = partScenariosRecords.stream().map(AssoScenarIOS::getFeaturesID).collect(Collectors.toList());
            partFetIds.addAll(comFetIds);
            //获得单个对比方案的权要的所有特征
            List<Features> partFeatures = allFeatures.stream().filter(item -> partFetIds.contains(item.getId())).collect(Collectors.toList());
            List<CompareRecords> records = compareRecords.stream().filter(item -> partRecordIds.contains(item.getId())).collect(Collectors.toList());
            //获得单条权要所有的特征
            List<Features> allRightFeatures = allFeatures.stream().filter(item -> item.getRightId().equals(item1.getRightId())).collect(Collectors.toList());
            //存放单条对比结果的map
            Map<String, Object> temMap = new HashMap<>();
            String a = partFeatures.get(0).getRightName().replace("\r", "");
            if (partFeatures.size() != 0 && partFeatures.get(0).getRightType().equals(1)) {
                temMap.put("rightName", "独立" + a);
            } else {
                temMap.put("rightName", "附属" + a);
            }
            temMap.put("rightId", item1.getRightId());
            if (report.getType() == 1) {
                String rightContent = patentRights.stream().filter(t -> t.getSort().equals(item1.getRightId())).map(PatentRight::getContent).findFirst().orElse("");
                temMap.put("rightContent", rightContent);
            }
            temMap.put("remark", item1.getContrastResult());
            // 从关联数据里获得特征id
            if (!rightIds.contains(item1.getRightId())) {
                rightIds.add(item1.getRightId());
            }
            //存放对比方案每一个特征记录
            List<Map<String, Object>> maps = new ArrayList<>();
            allRightFeatures.forEach(tem -> {

                List<AssoRecordsFeature> assoRecordsFeatures2 = assoRecordsFeatures1.stream().filter(item -> item.getFeatureId().equals(tem.getId())).collect(Collectors.toList());
                if (comFetIds.contains(tem.getId())) {
                    Map<String, Object> map = new LinkedHashMap<>();
                    map.put("featureContent", tem.getContent());
                    map.put("compareResult", "公识");
                    map.put("compareContent", "");
                    maps.add(map);
                } else if (assoRecordsFeatures2.size() != 0) {
                    Map<String, Object> map = new LinkedHashMap<>();
                    map.put("featureContent", tem.getContent());
                    List<Map<String, Object>> temMap1 = new ArrayList<>();
                    AssoRecordsFeature assoRecordsFeature = assoRecordsFeatures2.get(0);
                    CompareRecords record = records.stream().filter(item -> item.getId().equals(assoRecordsFeature.getRecordsId())).findFirst().orElse(new CompareRecords());
                    String compareContent = "";
                    //获取对比内容
                    String content = record.getContent() != null ? record.getContent() : "";
                    //获得对比专利号
                    String patentNo = record.getPatentNo() != null ? record.getPatentNo() : "";
                    if (OtherName.containsKey(patentNo)) {
                        patentNo = "D" + OtherName.get(patentNo).toString() + ":";
                    } else if (!patentNo.equals("")) {
                        patentNo += ":";
                    }
                    //获得解析过程
                    String paresingProcess = record.getParesingProcess() != null ? "(" + record.getParesingProcess() + ")" : "";
                    compareContent = patentNo + content + paresingProcess;
                    //获取对比专利号
                    if (maps.size() > 0) {
                        Map<String, Object> lastMap = maps.get(maps.size() - 1);
                        if (lastMap.get("compareContent").toString().equals(compareContent)) {
                            lastMap.put("featureContent", lastMap.get("featureContent") + tem.getContent());
                        } else {
                            map.put("compareResult", assoRecordsFeature.getComResult() != null ? assoRecordsFeature.getComResult() : "不公开");
                            map.put("compareContent", compareContent);
                            map.put("figure", fileUtils.getSystemPath() + record.getFilePath());
                            if (record.getFields() == null && record.getPosition() == null) {
                                map.put("position", "");
                            } else {
                                map.put("position", "\r" + "(" + record.getFields() + "[" + record.getPosition() + "]" + ")");
                            }
                            maps.add(map);
                        }
                    } else {
                        map.put("compareResult", assoRecordsFeature.getComResult() != null ? assoRecordsFeature.getComResult() : "不公开");
                        map.put("compareContent", compareContent);
                        map.put("figure", fileUtils.getSystemPath() + record.getFilePath());
                        if (record.getFields() == null && record.getPosition() == null) {
                            map.put("position", "");
                        } else {
                            map.put("position", "\r" + "(" + record.getFields() + "[" + record.getPosition() + "]" + ")");
                        }
                        maps.add(map);
                    }

                } else {
                    Map<String, Object> map = new LinkedHashMap<>();
                    map.put("featureContent", tem.getContent());
                    map.put("compareResult", "未公开");
                    map.put("compareContent", "");
                    maps.add(map);
                }

            });
            //方案内容
            temMap.put("fileDetails", maps);
            //新颖性模块
            //获得本方案所有的专利号
            List<String> patentNOs = new ArrayList<>();
            records.forEach(item -> {
                if (!patentNOs.contains(item.getPatentNo())) {
                    patentNOs.add(item.getPatentNo());
                }
            });
            //比较所有专利号和权要所有权要的大小，如果相等则将该专利加入到新颖性列表中
            List<String> noveltyFiles = new ArrayList<>();
            patentNOs.forEach(
                    item -> {
                        List<Integer> temRecordIds = records.stream().filter(tm -> tm.getPatentNo().equals(item)).map(CompareRecords::getId).collect(Collectors.toList());
                        List<Integer> temFIds = finalAsso.stream().filter(tm -> temRecordIds.contains(tm.getRecordsId())).map(AssoRecordsFeature::getFeatureId).collect(Collectors.toList());
                        String tmName = item;
                        if (OtherName.containsKey(item)) {
                            tmName = "D" + OtherName.get(item).toString();
                        }
                        if (temFIds.size() == allRightFeatures.size()) {
                            noveltyFiles.add(tmName);
                        }
                    }
            );
            //创造性列表
            List<String> creativeFiles = new ArrayList<>();
            //当前方案所有的特征Id
            records.forEach(
                    item -> {
                        String tmName = item.getPatentNo();
                        if (OtherName.containsKey(tmName)) {
                            tmName = "D" + OtherName.get(tmName).toString();
                        }
                        if (!creativeFiles.contains(tmName)) {
                            creativeFiles.add(tmName);
                        }
                    }
            );
            List<AssoScenarIOS> andRecords = partScenariosRecords.stream().filter(tm -> tm.getScenariosID().equals(item1.getId()) && tm.getFeaturesID() != 0).collect(Collectors.toList());
            if (andRecords.size() != 0) {
                creativeFiles.add("C");
            }
            String creative = creativeFiles.size() == 0 ? "" : StringUtils.join(creativeFiles, "+");
            String novelty = noveltyFiles.size() == 0 ? "" : StringUtils.join(noveltyFiles, "-");
            //新颖性
            temMap.put("novelty", novelty);
            //创造性
            temMap.put("creative", creative);
            scenariosMaps.add(temMap);
        }
        List<Map<String, Object>> allRightScenarios = new ArrayList<>();
        List<Map<String, Object>> resultMaps = new ArrayList<>();
        // 存放创造性和新颖性的权要

        rightIds.forEach(tem -> {
            Map<String, Object> map = new HashMap<>();
            Map<String, Object> resultMap = new HashMap<>();
            List<Map<String, Object>> rightScenarios = new ArrayList<>();
            //存放新颖性信息
            List<String> noveList = new ArrayList<>();
            List<String> creaList = new ArrayList<>();
            //存放创造性信息
            for (int t = 0; t < scenariosMaps.size(); t++) {
                Map<String, Object> item = scenariosMaps.get(t);
                if (item.get("rightId").equals(tem)) {
                    item.put("scenariosName", "对比组合" + (t + 1));
                    rightScenarios.add(item);
                    if (item.get("novelty").toString() != "") {
                        if (!noveList.contains(item.get("novelty").toString())) {
                            noveList.add(item.get("novelty").toString());
                        }
                    }
                    if (item.get("creative").toString() != "") {
                        if (!creaList.contains(item.get("creative").toString())) {
                            creaList.add(item.get("creative").toString());
                        }
                    }
                }
            }
            map.put("rightScenrios", rightScenarios);
            map.put("rightName", rightScenarios.get(0).get("rightName"));
            String creative = creaList.size() == 0 ? "" : StringUtils.join(creaList, "、");
            String novelty = noveList.size() == 0 ? "" : StringUtils.join(noveList, "-");
            resultMap.put("rightName", rightScenarios.get(0).get("rightName"));
            resultMap.put("rightNovelty", novelty);
            resultMap.put("rightCreative", creative);
            allRightScenarios.add(map);
            resultMaps.add(resultMap);
        });
        //1.系统数据
        //存放单条对比结果的map
        Map<String, Object> map = new HashMap<>();
        String date = DateUtils.formatDate(new Date(), DateUtils.YYYY_MM_DD);
        String[] ds = date.split("-");
        map.put("sys", new SystemMO(ds[0], ds[1], ds[2], "", "reportName"));
        if (patentListMaps.size() > 1) {
            patentListMaps = this.sortMap(patentListMaps);
        }
        map.put("patentList", patentListMaps);
        map.put("combinations", allRightScenarios);
        map.put("allResults", resultMaps);
        map.put("signPatent", signPatent);
        map.put("pantentNo", report.getSignPatentNo());
        map.put("rights", signPatent.get("rights"));
        // 为表格的显示绑定行循环
        LoopRowTableRenderPolicy policy = new LoopRowTableRenderPolicy();
        HtmlRenderPolicy htmlRenderPolicy = new HtmlRenderPolicy();
        // 将bz设置为行循环绑定的数据源的key,即key是bz的value会在模板中的{{bz}}处进行解析
        Configure configure = Configure.builder()
                .bind("patentList", policy)
                .bind("fileDetails", policy)
                .bind("allResults", policy)
                .bind("signPatent.rights", policy)
                .bind("remark", htmlRenderPolicy)
                .build();
        // 读取模板、数据并渲染
        XWPFTemplate template = XWPFTemplate.compile(filePath, configure).render(map);
        return template;
    }

    /**
     * @param reportId
     * @param filePath
     * @return
     * @description 装载FTO模板
     */
    private XWPFTemplate FTOtemplate(Integer reportId, String filePath, Integer templateId) throws IOException {
        //根据报告ID获得自定义字段值的信息
        List<Map<String, Object>> fieldMaps = reportFieldService.getFieldsMap(reportId);
        //获得模板的配置信息
        LambdaQueryWrapper<TemplateConfig> templateConfigWrapper = new LambdaQueryWrapper<TemplateConfig>();
        templateConfigWrapper.eq(TemplateConfig::getTemplateId, templateId);
        List<TemplateConfig> templateConfigs = templateConfigService.list(templateConfigWrapper);
        List<Map<String, Object>> loadMaps = new ArrayList<>();
        //根据配置信息装载
        for (TemplateConfig item : templateConfigs) {
            for (Map<String, Object> map : fieldMaps) {
                //如果自定义字段的值映射到配置则装载
                if (map.get("CName").toString().equals(item.getValueName())) {
                    //装载
                    map.put("CName", item.getMapName());
                    map.put("order", item.getOrderNum());
                    loadMaps.add(map);
                }
            }
        }
        //
        List<Map<String, Object>> classifyMaps = new ArrayList<>();
        //装载信息
        for (Map<String, Object> map : loadMaps) {
            Map<String, Object> classifyMap = new HashMap<>();
            classifyMap.put("classify", map.get("CName"));
            //根据自定义字段ID和值Id查询专利号
            List<String> patentNos = reportFieldPatentLinkService.getPatentNos(Integer.parseInt(map.get("FId").toString()), Integer.parseInt(map.get("CId").toString()));
            PatentVO patentVO = new PatentVO();
            patentVO.setPatentNos(patentNos);
            //根据专利号查询专利详细信息
            String resBody = outInterfaceService.getPatentDTOListForRMS(patentVO);
            JSONObject jsonObject = JSONObject.parseObject(resBody);
            List<JSONObject> patentDTOS = JSON.parseArray(jsonObject.get("data").toString(), JSONObject.class);
            //根据专利号和报告Id获得对比记录
            //存放公告专利
            List<Map<String, Object>> announcePatents = new ArrayList<>();
            //存放公开专利
            List<Map<String, Object>> publicPatents = new ArrayList<>();
            //存放失效专利信息
            List<Map<String, Object>> lapsePatents = new ArrayList<>();
            for (JSONObject patent : patentDTOS) {
                List<JSONObject> applicantJSONs = JSON.parseArray(patent.get("applicant").toString(), JSONObject.class);
                StringBuilder applicants = new StringBuilder();
                StringBuilder rightPerson = new StringBuilder();
                applicantJSONs.forEach(tem -> {
                    if (Integer.parseInt(tem.get("dataType").toString()) == 1) {
                        applicants.append(tem.get("name") + "\r");
                    } else {
                        rightPerson.append(tem.get("name") + "\r");
                    }
                });
                //装载同族信息
                JSONObject familys = JSONObject.parseObject(patent.get("family").toString());
                List<String> patSnaps = JSON.parseArray(familys.get("patSnap").toString(), String.class);
                List<String> simples = JSON.parseArray(familys.get("simple").toString(), String.class);
                List<String> inpadocs = JSON.parseArray(familys.get("inpadoc").toString(), String.class);
                patSnaps.addAll(simples);
                patSnaps.addAll(inpadocs);
                String familyStr = StringUtils.join(patSnaps, ",");
                //装载法律状态
                StringBuilder affair = new StringBuilder();
                List<JSONObject> affaires = JSON.parseArray(patent.get("affair").toString(), JSONObject.class);
                affaires.forEach(item -> {
                            affair.append(item.get("status") + "\r");
                        }

                );
                //装载单个专利的信息
                Map<String, Object> patentMap = new HashMap<>();
                //同族专利
                patentMap.put("simpleFamilys", familyStr);
                //引用专利
                patentMap.put("quotePatents", patent.get("quote"));
                //申请日
                patentMap.put("applicationDate", patent.get("applicationDate"));
                //公开日
                patentMap.put("publicDate", patent.get("publicDate"));
                //专利号
                patentMap.put("publicNo", patent.get("publicNo"));
                patentMap.put("firstPublicDate", patent.get("firstPublicDate"));
                patentMap.put("applicant", applicants);
                patentMap.put("rightPerson", rightPerson);
                patentMap.put("affair", affair);
                //图示
                patentMap.put("abstractPath", "http://139.224.24.90:8081" + patent.get("abstractPath"));
                //获得专利对比记录的信息
                Map<String, Object> temMap = compareMessageService.queryforTemplate(patent.get("patentNo").toString(), reportId);
                List<CompareMessageVO> compareMessageVOS = (List<CompareMessageVO>) temMap.get("compareMessageVOs");
                //装载对比记录的信息
                patentMap.put("cM", compareMessageVOS);
                patentMap.put("rightNum", temMap.get("right"));
                patentMap.put("mainRightNum", temMap.get("mainRight"));
                Integer status = Integer.parseInt(patent.get("simpleStatusInt").toString());
                if (status == 1 || status == 5 || status == 6) {
                    announcePatents.add(patentMap);
                } else if (status == 2) {
                    lapsePatents.add(patentMap);
                } else if (status == 3) {
                    publicPatents.add(patentMap);
                }
                classifyMap.put("publicPatents", publicPatents);
                classifyMap.put("lapsePatents", lapsePatents);
                classifyMap.put("announcePatents", announcePatents);
            }
            classifyMaps.add(classifyMap);
        }
        Map<String, Object> map = new HashMap<>();
        String date = DateUtils.formatDate(new Date(), DateUtils.YYYY_MM_DD);
        String[] ds = date.split("-");
        map.put("sys", new SystemMO(ds[0], ds[1], ds[2], "", "reportName"));
        map.put("classifys", classifyMaps);
        // 为表格的显示绑定行循环
        LoopRowTableRenderPolicy policy = new LoopRowTableRenderPolicy();
        HtmlRenderPolicy htmlRenderPolicy = new HtmlRenderPolicy();
        // 将bz设置为行循环绑定的数据源的key,即key是bz的value会在模板中的{{bz}}处进行解析
        Configure configure = Configure.builder().bind("cM", policy).bind("targetDescription", htmlRenderPolicy).build();
        XWPFTemplate template = XWPFTemplate.compile(filePath, configure).render(map);
        return template;
    }

    /**
     * @param reportId
     * @param filePath
     * @return
     * @description 装载侵权分析模板
     */
    private XWPFTemplate Torttemplate(Integer reportId, String filePath, Integer templateId) throws IOException {
        //根据报告Id查询标的专利号
        Report report = reportService.getById(reportId);
        String patentNo = report.getSignPatentNo();
        PatentVO patentVO = new PatentVO();
        patentVO.setPatentNos(Arrays.asList(patentNo));
        //根据专利号查询专利详细信息
        String resBody = outInterfaceService.getPatentDTOListForRMS(patentVO);
        JSONObject jsonObject = JSONObject.parseObject(resBody);
        List<JSONObject> patentDTOS = JSON.parseArray(jsonObject.get("data").toString(), JSONObject.class);
        //装载单个专利的信息
        Map<String, Object> patentMap = new HashMap<>();
        JSONObject patent = patentDTOS.get(0);
        List<JSONObject> applicantJSONs = JSON.parseArray(patent.get("applicant").toString(), JSONObject.class);
        StringBuilder applicants = new StringBuilder();
        StringBuilder rightPerson = new StringBuilder();
        applicantJSONs.forEach(tem -> {
            if (Integer.parseInt(tem.get("dataType").toString()) == 1) {
                applicants.append(tem.get("name") + "\r");
            } else {
                rightPerson.append(tem.get("name") + "\r");
            }
        });
        //装载同族信息
        JSONObject familys = JSONObject.parseObject(patent.get("family").toString());
        List<String> patSnaps = JSON.parseArray(familys.get("patSnap").toString(), String.class);
        List<String> simples = JSON.parseArray(familys.get("simple").toString(), String.class);
        List<String> inpadocs = JSON.parseArray(familys.get("inpadoc").toString(), String.class);
        patSnaps.addAll(simples);
        patSnaps.addAll(inpadocs);
        String familyStr = StringUtils.join(patSnaps, ",");
        //装载法律状态
        StringBuilder affair = new StringBuilder();
        List<JSONObject> affaires = JSON.parseArray(patent.get("affair").toString(), JSONObject.class);
        affaires.forEach(item -> {
                    affair.append(item.get("status") + "\r");
                }
        );
        //同族专利
        patentMap.put("simpleFamilys", familyStr);
        //引用专利
        patentMap.put("quotePatents", patent.get("quote"));
        //申请日
        patentMap.put("applicationDate", patent.get("applicationDate"));
        //公开日
        patentMap.put("publicDate", patent.get("publicDate"));
        //专利号
        patentMap.put("publicNo", patent.get("publicNo"));
        patentMap.put("firstPublicDate", patent.get("firstPublicDate"));
        patentMap.put("applicant", applicants);
        patentMap.put("rightPerson", rightPerson);
        patentMap.put("affair", affair);
        patentMap.put("name", patent.get("name"));
        //图示
        patentMap.put("abstractPath", "http://139.224.24.90:8081" + patent.get("abstractPath"));
        //获得专利对比记录的信息
        Map<String, Object> temMap = compareMessageService.queryforTemplate(patent.get("patentNo").toString(), reportId);
        List<CompareMessageVO> compareMessageVOS = (List<CompareMessageVO>) temMap.get("compareMessageVOs");
        //装载对比记录的信息
        patentMap.put("cM", compareMessageVOS);
        patentMap.put("rightNum", temMap.get("right"));
        patentMap.put("mainRightNum", temMap.get("mainRight"));
        Map<String, Object> map = new HashMap<>();
        String date = DateUtils.formatDate(new Date(), DateUtils.YYYY_MM_DD);
        String[] ds = date.split("-");
        map.put("sys", new SystemMO(ds[0], ds[1], ds[2], "", "reportName"));
        map.put("patentMap", patentMap);
        map.put("", patentNo);
        // 为表格的显示绑定行循环
        LoopRowTableRenderPolicy policy = new LoopRowTableRenderPolicy();
        HtmlRenderPolicy htmlRenderPolicy = new HtmlRenderPolicy();
        // 将bz设置为行循环绑定的数据源的key,即key是bz的value会在模板中的{{bz}}处进行解析
        Configure configure = Configure.builder().bind("cM", policy).bind("targetDescription", htmlRenderPolicy).build();
        XWPFTemplate template = XWPFTemplate.compile(filePath, configure).render(map);
        return template;
    }

    private XWPFTemplate avoidDesignTemplate(Integer reportId, String filePath) throws IOException {
        log.info("开始处理导出规避设计报告，参数为：{}, {}", reportId, filePath);
        Report report = reportService.getById(reportId);
        String signPatentNo = report.getSignPatentNo();

        //装载标的专利信息
        Map<String, Object> signPatent = this.signPantentMess(report.getSignPatentNo());
        System.out.println(signPatent.get(""));

        Map<String, Object> map = new HashMap<>();
        //装载标的专利信息
        map.put("signPatent", signPatent);
        map.put("rights", signPatent.get("rights"));
        //装载公开/公告号
        map.put("pantentNo", signPatentNo);

        //装载年月日
        String date = DateUtils.formatDate(new Date(), DateUtils.YYYY_MM_DD);
        String[] dates = date.split("-");
        SystemMO systemMO = new SystemMO()
                .setYear(dates[0])
                .setMonth(dates[1])
                .setDay(dates[2]);
        map.put("sys", systemMO);

        //装载特征、解释、回避设计方向、回避设计总体方向
        List<AvoidFeaturesVO> features = avoidDesignLittleDirectionMapper.selectWholeByReportId(reportId);
        String wholeDirection = avoidDesignWholeDirectionMapper.selectWholeDirectionByReportId(reportId);
        map.put("features", features);
        map.put("wholeDirection", wholeDirection);

        //绑定政策(绑定集合和元素循环遍历)
        LoopRowTableRenderPolicy policy = new LoopRowTableRenderPolicy();
        //把指定元素内容识别传输成html格式
        HtmlRenderPolicy htmlRenderPolicy = new HtmlRenderPolicy();
        Configure configure = Configure.builder()
                .bind("signPatent.rights", policy)
                .bind("features", policy)
                .bind("explainText", htmlRenderPolicy)
                .bind("littleDirection", htmlRenderPolicy)
                .bind("wholeDirection", htmlRenderPolicy)
                .build();
        XWPFTemplate template = XWPFTemplate.compile(filePath, configure).render(map);
        return template;
    }

    private XWPFTemplate getThirdTemplate(Report report, String filePath) throws IOException {
        //装载标的专利信息
        Map<String, Object> signPatent = this.signPantentMess(report.getSignPatentNo());
        List<Map<String, Object>> rights = (List<Map<String, Object>>) signPatent.get("rights");
        //根据报告Id获得报告信息
        // 根据拆分人（报告的创建人）Id和报告ID获得所有特征
        LambdaQueryWrapper<Features> allFeaturesWrapper = new LambdaQueryWrapper<>();
        allFeaturesWrapper.eq(Features::getReportId, report.getId());
        allFeaturesWrapper.and(wrapper -> wrapper.eq(Features::getPartnerId, report.getPersonId()).or().eq(Features::getPartnerId, report.getCreatePersonId()));
        List<Features> allFeatures = featureService.list(allFeaturesWrapper);
        //根据报告Id 查询出报告下所有的方案
        LambdaQueryWrapper<CompareScenarios> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(CompareScenarios::getReportId, report.getId());
        List<CompareScenarios> compareScenarios = compareScenariosService.list(queryWrapper);
        List<Integer> scenarioIds = compareScenarios.stream().map(CompareScenarios::getId).collect(Collectors.toList());
        //根据对比方案Id 查询所有对比方案和（对比记录-特征）关联信息
        List<AssoScenarIOS> scenariosRecords = new ArrayList<>();
        if (scenarioIds != null && scenarioIds.size() != 0) {
            LambdaQueryWrapper<AssoScenarIOS> queryRecordsByIDs = new LambdaQueryWrapper<>();
            queryRecordsByIDs.in(AssoScenarIOS::getScenariosID, scenarioIds);
            scenariosRecords = scenariosRecordsService.list(queryRecordsByIDs);
        }
        //获得对比记录-特征关联ID
        List<Integer> recordfeatureRecordIds = scenariosRecords.stream().map(AssoScenarIOS::getFeatureRecordID).collect(Collectors.toList());
        //从关联表里获得是公识的特征Id
        List<Integer> knowedIds = scenariosRecords.stream().map(AssoScenarIOS::getFeaturesID).collect(Collectors.toList());
        //根据对比记录-特征关联ID查出对比记录-特征关联信息
        List<AssoRecordsFeature> assoRecordsFeatures = new ArrayList<>();
        if (recordfeatureRecordIds != null && recordfeatureRecordIds.size() != 0) {
            LambdaQueryWrapper<AssoRecordsFeature> wrapper = new LambdaQueryWrapper<>();
            wrapper.in(AssoRecordsFeature::getId, recordfeatureRecordIds);
            assoRecordsFeatures = assoRecordsFeatureService.list(wrapper);
        }
        List<AssoRecordsFeature> finalAsso = assoRecordsFeatures;
        //从对比记录-特征关联信息里剔出对比记录Id
        List<Integer> recordIds = assoRecordsFeatures.stream().map(AssoRecordsFeature::getRecordsId).collect(Collectors.toList());
        //从对比记录-特征关联信息里剔出特征Id
        List<Integer> sFeatureIds = assoRecordsFeatures.stream().map(AssoRecordsFeature::getFeatureId).collect(Collectors.toList());
        sFeatureIds.addAll(knowedIds);
        //根据特征ID查询出报告所有方案的特征
        List<Features> sFeatures = new ArrayList<>();
        LambdaQueryWrapper<Features> sFeaturesWrapper = new LambdaQueryWrapper<>();
        sFeaturesWrapper.eq(Features::getId, sFeatureIds);
        if (sFeatures != null && sFeatures.size() != 0) {
            sFeatures = featureService.list(sFeaturesWrapper);
        }
        //根据对比记录ID查询出报告所有方案的对比记录
        List<CompareRecords> compareRecords = new ArrayList<>();
        if (recordIds != null && recordIds.size() != 0) {
            LambdaQueryWrapper<CompareRecords> queryPatentByIDs = new LambdaQueryWrapper<>();
            queryPatentByIDs.in(CompareRecords::getId, recordIds);
            compareRecords = compareRecordsService.list(queryPatentByIDs);
        }
        //根据对比记录ID获得专利号
        List<String> PatentNos = compareRecords.stream().map(CompareRecords::getPatentNo).collect(Collectors.toList());
        PatentVO patentVO = new PatentVO();
        patentVO.setPatentNos(PatentNos);
        //根据专利号查询专利详细信息
        String resBody = outInterfaceService.getPatentDTOListForRMS(patentVO);
        JSONObject jsonObject = JSONObject.parseObject(resBody);
        List<JSONObject> patentDTOS = JSON.parseArray(jsonObject.get("data").toString(), JSONObject.class);
        //根据专利号查询专利的排序
        LambdaQueryWrapper<CompareFiles> comWrapper = new LambdaQueryWrapper<>();
        comWrapper
                .eq(CompareFiles::getReportId, report.getId())
                .last("ORDER BY IF(isnull(SYS_ORDER),1,0), SYS_ORDER ASC");
        ;
        List<CompareFiles> compareFiles = compareFilesService.list(comWrapper);
        //专利号别名的map
        Map<String, Object> OtherName = new HashMap<>();
        int flag = 1;
        for (CompareFiles item : compareFiles) {
            Integer order = item.getSysOrder() == null ? flag : item.getSysOrder();
            OtherName.put(item.getPatentNo(), order);
            flag++;
        }
        //存放专利信息的map集合
        List<Map<String, Object>> patentListMaps = new ArrayList<>();
        //填充专利数据到patentListMap
        for (int i = 0; i < patentDTOS.size(); i++) {
            JSONObject item = patentDTOS.get(i);
            Map<String, Object> patentListMap = new HashMap<>();
            List<JSONObject> applicantJSONs = JSON.parseArray(item.get("applicant").toString(), JSONObject.class);
            ;
            StringBuilder applicants = new StringBuilder();
            applicantJSONs.forEach(tem -> {
                applicants.append(tem.get("name") + "\r");
            });
            //填充相关揭露（对比记录文字和特征组合）
            StringBuffer disclosures = new StringBuffer("");
            //根据专利号获得对比记录
            List<CompareRecords> pantentRecords = compareRecords.stream().filter(tem -> tem.getPatentNo().equals(item.get("publicNo"))).collect(Collectors.toList());
            //遍历对比记录根据对比记录获得对比记录-特征关联信息并获得特征ID
            for (CompareRecords tem : pantentRecords) {
                //填充对比记录文字
                disclosures.append(tem.getContent());
                disclosures.append("\r");
                disclosures.append("(");
                disclosures.append(tem.getFields());
                disclosures.append("[" + (tem.getPosition()) + "]");
                disclosures.append(")");
                List<Integer> featuresIds = assoRecordsFeatures.stream().filter(te -> te.getRecordsId().equals(tem.getId())).map(AssoRecordsFeature::getFeatureId).collect(Collectors.toList());
                //根据特征Id获得特征内容
                List<String> feaListContent = sFeatures.stream().filter(te -> featuresIds.contains(te.getId())).map(Features::getContent).collect(Collectors.toList());
                feaListContent.forEach(te -> disclosures.append("(" + te + ")"));
                disclosures.append("\n");
            }
            int order = Integer.parseInt(OtherName.get(item.get("publicNo")).toString());

            patentListMap.put("name", item.get("name"));
            patentListMap.put("fileName", "D" + order);
            patentListMap.put("publicDate", item.get("publicDate"));
            patentListMap.put("publicNo", item.get("publicNo"));
            patentListMap.put("SSIM", "");
            patentListMap.put("applicant", applicants);
            patentListMap.put("patentNo", item.get("publicNo"));
            patentListMap.put("abstractStr", item.get("abstractStr"));
            patentListMap.put("compareFileName", "对比文件" + (order));
            patentListMap.put("applicationDate", item.get("applicationDate"));
            patentListMap.put("abstractPath", pasFile + item.get("abstractPath"));
            patentListMap.put("disclosures", disclosures);
            patentListMap.put("order", order);
            patentListMaps.add(patentListMap);

        }
        List<Map<String, Object>> rightMaps = new ArrayList<>();
        List<Integer> noveltyIds = new ArrayList<Integer>();
        List<Integer> creativeIds = new ArrayList<Integer>();
        for (Map<String, Object> right : rights) {
            String text ="";
            if (right.get("parentSort")!=null&&!right.get("parentSort").equals("-1")) {
                String parentSort ="";
                List<String> sorts =new ArrayList<>(Arrays.asList(right.get("parentSort").toString().split(",")));
                List<Integer> sortIds =new ArrayList<>();
                sorts.forEach(item->{
                    sortIds.add(Integer.parseInt(item)+1);
                });
                parentSort =StringUtils.join(sortIds,"、");

                text =right.get("rightNameLong")+"为引用权"+parentSort+"的从属权利要求，";
            }
            for (int i = 0; i < compareScenarios.size(); i++) {
                CompareScenarios item1 = compareScenarios.get(i);
                //判断是该权要的方案
                if (right.get("sort").equals(item1.getRightId())) {
                    //根据方案id获得特征和记录关联表的id
                    List<Integer> temfeatureRecordIds = scenariosRecords.stream().filter(item -> item.getScenariosID().equals(item1.getId())).map(AssoScenarIOS::getFeatureRecordID).collect(Collectors.toList());
                    //获得记录
                    List<CompareRecords> compareRecords1 = new ArrayList<>();
                    if (temfeatureRecordIds != null && temfeatureRecordIds.size() != 0) {
                        // 根据关联表的id获得关联实体类
                        List<AssoRecordsFeature> assoRecordsFeatures1 = assoRecordsFeatures.stream().filter(item -> temfeatureRecordIds.contains(item.getId())).collect(Collectors.toList());
                        //根据实体类获得记录id
                        List<Integer> temRecordIds = assoRecordsFeatures1.stream().map(AssoRecordsFeature::getRecordsId).collect(Collectors.toList());
                        //根据记录id获得记录
                        if (temRecordIds != null && temRecordIds.size() > 0) {
                            LambdaQueryWrapper<CompareRecords> recordsWrapper = new LambdaQueryWrapper<>();
                            recordsWrapper.in(CompareRecords::getId, temRecordIds);
                            compareRecords1 = compareRecords.stream().filter(item -> temRecordIds.contains(item.getId())).collect(Collectors.toList());
                        }

                    }

                    //判断方案是否具有创造性或者新颖性字眼
                    if (item1.getContrastResult() != null && (item1.getContrastResult().contains("创造性") || item1.getContrastResult().contains("新颖性"))) {
                       //装载对比记录
                        List<Map<String,Object>> maps =new ArrayList<>();
                        compareRecords1.forEach(record->{
                            Map<String,Object> map =new HashMap<>();
                            map.put("figure", fileUtils.getSystemPath() + record.getFilePath());
                            if (record.getFields() == null && record.getPosition() == null) {
                                map.put("position", "");
                            } else {
                                map.put("position", "\r" + "(" + record.getFields() + "[" + record.getPosition() + "]" + ")");
                            }
                            String compareContent = "";
                            //获取对比内容
                            String content = record.getContent() != null ? record.getContent() : "";
                            //获得对比专利号
                            String patentNo = record.getPatentNo() != null ? record.getPatentNo() : "";
                            if (OtherName.containsKey(patentNo)) {
                                patentNo = "D" + OtherName.get(patentNo).toString() + ":";
                            } else if (!patentNo.equals("")) {
                                patentNo += ":";
                            }
                            //获得解析过程
                            String paresingProcess = record.getParesingProcess() != null ? "(" + record.getParesingProcess() + ")" : "";
                            compareContent = patentNo + content + paresingProcess;
                            map.put("compareContent", compareContent);
                            maps.add(map);
                        });

                        if (item1.getContrastResult().contains("创造性")) {
                            creativeIds.add(Integer.parseInt(right.get("sort").toString()) + 1);

                            right.put("records", maps);
                            right.put("text", "第3款的创造性的规定。\n"+text+right.get("rightNameLong")+"的附加技术特征为：");
                            rightMaps.add(right);
                        } else if (item1.getContrastResult().contains("新颖性")) {
                            noveltyIds.add(Integer.parseInt(right.get("sort").toString()) + 1);
                            right.put("text", "第2款的新颖性的规定。\n"+text+right.get("rightNameLong")+"保护的主体，具体：");
                            right.put("records", compareRecords1);
                            rightMaps.add(right);
                        }
                    }
                }
            }

        }
        String noveltyIdStr = StringUtils.join(noveltyIds, ",");
        String creativeIdStr = StringUtils.join(creativeIds, ",");
        Map<String, Object> map = new HashMap<>();
        String date = DateUtils.formatDate(new Date(), DateUtils.YYYY_MM_DD);
        String[] ds = date.split("-");
        map.put("sys", new SystemMO(ds[0], ds[1], ds[2], "", "reportName"));
        map.put("signPatent", signPatent);
        map.put("pantentNo", report.getSignPatentNo());
        map.put("rights", rightMaps);
        map.put("noveltyIdStr", noveltyIdStr);
        map.put("creativeIdStr", creativeIdStr);
        map.put("patentList", patentListMaps);
        // 为表格的显示绑定行循环
        LoopRowTableRenderPolicy policy = new LoopRowTableRenderPolicy();
        HtmlRenderPolicy htmlRenderPolicy = new HtmlRenderPolicy();
        // 将bz设置为行循环绑定的数据源的key,即key是bz的value会在模板中的{{bz}}处进行解析
        Configure configure = Configure.builder()
                .bind("patentList", policy)
                .bind("fileDetails", policy)
                .bind("allResults", policy)
                .bind("signPatent.rights", policy)
                .bind("remark", htmlRenderPolicy)
                .build();
        // 读取模板、数据并渲染
        XWPFTemplate template = XWPFTemplate.compile(filePath, configure).render(map);
        return template;
    }

    /**
     * function:删除报告时删除
     */
    @Transactional(rollbackFor = Exception.class)
    public String deleteByReportId(Integer id) {
        LambdaQueryWrapper<ReportDocument> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(ReportDocument::getReportId, id);
        remove(wrapper);
        return Response.success();
    }

    public Map<String, Object> signPantentMess(String patentNo) throws IOException {
        PatentVO patentVO = new PatentVO();
        patentVO.setPatentNos(Arrays.asList(patentNo));
        //根据专利号查询专利详细信息
        String resBody = outInterfaceService.getPatentDTOListForRMS(patentVO);
        JSONObject jsonObject = JSONObject.parseObject(resBody);
        List<JSONObject> patentDTOS = JSON.parseArray(jsonObject.get("data").toString(), JSONObject.class);
        //装载单个专利的信息
        Map<String, Object> patentMap = new HashMap<>();
        JSONObject patent = patentDTOS.get(0);
        List<JSONObject> applicantJSONs = JSON.parseArray(patent.get("applicant").toString(), JSONObject.class);
        StringBuilder applicants = new StringBuilder();
        StringBuilder rightPerson = new StringBuilder();
        applicantJSONs.forEach(tem -> {
            if (Integer.parseInt(tem.get("dataType").toString()) == 1) {
                applicants.append(tem.get("name") + "\r");
            } else {
                rightPerson.append(tem.get("name") + "\r");
            }
        });
        //申请日
        patentMap.put("applicationDate", patent.get("applicationDate"));

        //公开日
        patentMap.put("publicDate", patent.get("publicDate"));
        //公开号
        patentMap.put("publicNo", patent.get("publicNo"));
        //专利号
        patentMap.put("patentNo", patent.get("patentNo"));
        //专利权人
        patentMap.put("rightPerson", rightPerson);
        //图示
        patentMap.put("abstractPath", pasFile + patent.get("abstractPath"));
        patentMap.put("name", patent.get("name"));
        //查询专利权要
        String resBody2 = outInterfaceService.getPatentRightFromPAS(patentNo);
        JSONObject jsonObject2 = JSONObject.parseObject(resBody2);
        //解析jason获得标的专利的权要
        List<PatentRight> patentRightsOrgin = JSON.parseArray(jsonObject2.getString("data"), PatentRight.class);
        List<Map<String, Object>> rights = new ArrayList<>();
        //给权要进行格式更改
        List<PatentRight> patentRights = featureService.FormatPatentRights(patentRightsOrgin,patentNo);
        patentRights.forEach(item -> {
            Map<String, Object> temMap = new HashMap<>();
            temMap.put("rightName", "权" + (item.getSort() + 1));
            temMap.put("content", item.getContent());
            temMap.put("rightNameLong", "权利要求" + (item.getSort() + 1));
            temMap.put("parentSort", item.getParentSort());
            temMap.put("sort", item.getSort());
            rights.add(temMap);
        });
        patentMap.put("rights", rights);
        return patentMap;
    }

    public List<Map<String, Object>> sortMap(List<Map<String, Object>> maps) {

        for (int i = 0; i < maps.size() - 1; i++) {
            for (int j = 0; j < maps.size() - i - 1; j++) {
                Integer order1 = Integer.parseInt(maps.get(j).get("order").toString());
                Integer order2 = Integer.parseInt(maps.get(j + 1).get("order").toString());
                if (order1 > order2) {
                    Map<String, Object> temp = maps.get(j);
                    maps.set(j, maps.get(j + 1));
                    maps.set(j + 1, temp);
                }

            }
        }
        return maps;
    }

}


