package cn.cslg.pas.service.novelty;

import cn.cslg.pas.common.dto.AddCompareFileDTO;
import cn.cslg.pas.common.dto.CompareFileIdDTO;
import cn.cslg.pas.common.dto.EditCompareFileDTO;
import cn.cslg.pas.common.dto.QueryCompareFileDTO;
import cn.cslg.pas.common.dto.business.LiteratureQueryDTO;
import cn.cslg.pas.common.model.cronModel.Records;
import cn.cslg.pas.common.utils.GenerateObjectUtil;
import cn.cslg.pas.common.vo.CompareLiteratureVO;
import cn.cslg.pas.common.vo.NoveltyProjectVO.NoveltyCompareLiteratureVO;
import cn.cslg.pas.common.vo.NoveltyProjectVO.NoveltyCompareRecordVO;
import cn.cslg.pas.common.vo.QueryCompareFileVO;
import cn.cslg.pas.domain.business.CompareLiterature;
import cn.cslg.pas.domain.es.Marking;
import cn.cslg.pas.domain.es.Patent;
import cn.cslg.pas.domain.es.PatentPerson;
import cn.cslg.pas.mapper.CompareLiteratureMapper;
import cn.cslg.pas.mapper.RetrieveRecordMapper;
import cn.cslg.pas.mapper.novelty.NoveltyCompareLiteratureMapper;
import cn.cslg.pas.service.business.CompareLiteratureService;
import cn.cslg.pas.service.business.es.EsPatentService;
import cn.cslg.pas.service.business.es.EsScratchWordsService;
import cn.cslg.pas.service.importPatent.ImportSinglePatentService;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import cn.cslg.pas.domain.business.novelty.NoveltyCompareLiterature;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.chrome.ChromeOptions;
import org.openqa.selenium.support.ui.ExpectedCondition;
import org.openqa.selenium.support.ui.WebDriverWait;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.time.Duration;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

/**
 * @author admin
 * @description 针对表【novelty_compare_literature(查新报告对比文件)】的数据库操作Service实现
 * @createDate 2024-09-29 09:10:32
 */

@Service
@Slf4j
@RequiredArgsConstructor(onConstructor_ = {@Lazy})
public class NoveltyCompareLiteratureService extends ServiceImpl<NoveltyCompareLiteratureMapper, NoveltyCompareLiterature> {

    @Autowired
    private NoveltyCompareLiteratureMapper noveltyCompareLiteratureMapper;

    @Autowired
    private RetrieveRecordMapper retrieveRecordMapper;

    @Autowired
    private CompareLiteratureMapper compareLiteratureMapper;
    @Autowired
    private CompareLiteratureService compareLiteratureService;
    @Autowired
    private EsScratchWordsService esScratchWordsService;
    @Autowired
    private EsPatentService esPatentService;
    @Autowired
    private ImportSinglePatentService importSinglePatentService;
    public Records queryNoveltyCompareLiterature(LiteratureQueryDTO vo) throws Exception {
        Integer projectId = vo.getProjectId();
        Records records = new Records();
        //根据projectId查询对比文件
        LambdaQueryWrapper<CompareLiterature> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(CompareLiterature::getProjectId, projectId)
                .orderByAsc(CompareLiterature::getSysOrder);
        List<CompareLiterature> compareLiteratures = new ArrayList<>();

        if (vo.getCurrent() != null && vo.getSize() != null) {
            Page<CompareLiterature> page = compareLiteratureService.page(new Page<>(vo.getCurrent(), vo.getSize()), queryWrapper);
            compareLiteratures = page.getRecords();
            records.setTotal(page.getTotal());
            records.setSize(Long.parseLong(vo.getSize().toString()));
            records.setCurrent(Long.parseLong(vo.getCurrent().toString()));
        } else {
            compareLiteratures = compareLiteratureService.list(queryWrapper);
        }
        List<CompareLiteratureVO> literatureVOS = this.loadCompareLiterature(compareLiteratures);
        this.loadCompareLiteratureVOS(literatureVOS, projectId);
        records.setData(literatureVOS);
        return records;
    }

    public List<CompareLiteratureVO> loadCompareLiterature(List<CompareLiterature> compareLiteratures) throws Exception {
        List<CompareLiteratureVO> compareLiteratureVOS = new ArrayList<>();
        List<String> patentNos = compareLiteratures.stream().map(CompareLiterature::getLiteratureNo).collect(Collectors.toList());
        List<Patent> patentList = esPatentService.getPatentsByNo(patentNos, false, null, null);
        for (CompareLiterature compareLiterature : compareLiteratures) {
            String literatureNo = compareLiterature.getLiteratureNo();
            Patent patent = patentList.stream()
                    .filter(item -> literatureNo.equals(item.getAppNo())
                            || literatureNo.equals(item.getPublicNo()) ||
                            literatureNo.equals(item.getGrantNo())).findFirst().orElse(null);
            CompareLiteratureVO compareLiteratureVO = new CompareLiteratureVO();
            BeanUtils.copyProperties(compareLiterature, compareLiteratureVO);
            if (patent != null) {
                compareLiteratureVO.setAppNo(patent.getAppNo());
                compareLiteratureVO.setAppDate(patent.getAppDate());
                if (patent.getPublicNo() == null) {
                    compareLiteratureVO.setPublicDate(patent.getGrantDate());
                    compareLiteratureVO.setPublicNo(patent.getGrantNo());
                } else {
                    compareLiteratureVO.setPublicDate(patent.getPublicDate());
                    compareLiteratureVO.setPublicNo(patent.getPublicNo());
                }
                compareLiteratureVO.setGrantDate(patent.getGrantDate());
                compareLiteratureVO.setGrantNo(patent.getGrantNo());
                if (StringUtils.isNotEmpty(compareLiteratureVO.getAuthorName())) {
                    List<PatentPerson> personList = new ArrayList<>();
                    PatentPerson person = new PatentPerson();
                    person.setName(compareLiteratureVO.getAuthorName());
                    personList.add(person);
                    compareLiteratureVO.setApplicant(personList);
                } else {
                    compareLiteratureVO.setApplicant(patent.getApplicant());
                }
            }
            compareLiteratureVOS.add(compareLiteratureVO);
        }
        return compareLiteratureVOS;
    }

    public void loadCompareLiteratureVOS(List<CompareLiteratureVO> compareLiteratureVOS, Integer projectId) throws Exception {
        if (!CollectionUtils.isEmpty(compareLiteratureVOS)) {
            List<Integer> literatureIds = compareLiteratureVOS.stream().map(CompareLiteratureVO::getId).collect(Collectors.toList());
            List<NoveltyCompareRecordVO> recordVOS = esScratchWordsService.queryNoveltyRecord(projectId, 1);
            List<NoveltyCompareLiterature> noveltyCompareLiteratureList = noveltyCompareLiteratureMapper.selectList(new LambdaQueryWrapper<NoveltyCompareLiterature>()
                    .in(NoveltyCompareLiterature::getCompareLitertureId, literatureIds));
            for (CompareLiteratureVO literatureVO : compareLiteratureVOS) {
                NoveltyCompareLiterature noveltyCompareLiterature = noveltyCompareLiteratureList.stream().filter(i -> literatureVO.getId().equals(i.getCompareLitertureId())).findFirst().orElse(new NoveltyCompareLiterature());
                if (!org.springframework.util.ObjectUtils.isEmpty(noveltyCompareLiterature)) {
                    literatureVO.setCompareFileId(noveltyCompareLiterature.getId());
                    literatureVO.setRetrieveRecordId(noveltyCompareLiterature.getRetrieveRecordId());
                    literatureVO.setRelevance(noveltyCompareLiterature.getRelevance());
                    literatureVO.setIfEffectinv(noveltyCompareLiterature.getIfEffectinv());
                    literatureVO.setFileRemark(noveltyCompareLiterature.getRemark());
                    literatureVO.setGeneralRemark(noveltyCompareLiterature.getGeneralRemark());
                    literatureVO.setTechnicalPoints(noveltyCompareLiterature.getTechnicalPoints());
                    literatureVO.setExcuteCase(noveltyCompareLiterature.getExcuteCase());
                    literatureVO.setBeneficialEffect(noveltyCompareLiterature.getBeneficialEffect());
                }
                if (!CollectionUtils.isEmpty(recordVOS)) {
                    List<NoveltyCompareRecordVO> collect = recordVOS.stream().filter(i -> i.getPatentNo().equals(literatureVO.getLiteratureNo())).collect(Collectors.toList());
                    literatureVO.setNoveltyCompareRecordVOS(collect);
                }
            }
        }
    }


    public List<QueryCompareFileVO> queryCompareFile(QueryCompareFileDTO vo) {
        return noveltyCompareLiteratureMapper.queryCompareFile(vo);
    }

    public Integer addCompareFile(AddCompareFileDTO vo) {
        Integer compareLitertureId = vo.getId();
        NoveltyCompareLiterature literature = noveltyCompareLiteratureMapper.selectOne(new LambdaQueryWrapper<NoveltyCompareLiterature>()
                .eq(NoveltyCompareLiterature::getCompareLitertureId, compareLitertureId));
        if (ObjectUtils.isEmpty(literature)) {
            literature = new NoveltyCompareLiterature();
            BeanUtils.copyProperties(vo, literature);
            literature.setId(null);
            literature.setCompareLitertureId(compareLitertureId);
            literature.insert();
        }
        else {
            if(literature.getRetrieveRecordId()==null){
                literature.setRetrieveRecordId(vo.getRetrieveRecordId());
                literature.updateById();
            }
        }
        return literature.getId();
    }

    public Integer editCompareFile(AddCompareFileDTO vo) {
        NoveltyCompareLiterature literature = noveltyCompareLiteratureMapper.selectById(vo.getCompareFileId());
        literature.setCompareLitertureId(vo.getId());
        literature.setRetrieveRecordId(vo.getRetrieveRecordId());
        literature.setRelevance(vo.getRelevance());
        literature.setRemark(vo.getRemark());
        literature.setGeneralRemark(vo.getGeneralRemark());
        literature.setIfEffectinv(vo.getIfEffectinv());
        literature.setBeneficialEffect(vo.getBeneficialEffect());
        literature.setExcuteCase(vo.getExcuteCase());
        literature.setTechnicalPoints(vo.getTechnicalPoints());
        literature.updateById();
        return literature.getId();
    }

    public Integer editCompareFileByProjectId(EditCompareFileDTO vo) throws Exception {
        CompareLiterature compareLiterature = compareLiteratureMapper.selectOne(new LambdaQueryWrapper<CompareLiterature>()
                .eq(CompareLiterature::getLiteratureNo, vo.getPatentNo())
                .eq(CompareLiterature::getProjectId, vo.getProjectId()));
        NoveltyCompareLiterature literature = noveltyCompareLiteratureMapper.selectOne(new LambdaQueryWrapper<NoveltyCompareLiterature>()
                .eq(NoveltyCompareLiterature::getCompareLitertureId, compareLiterature.getId()));
        if (ObjectUtils.isEmpty(literature)) {
            literature = new NoveltyCompareLiterature();
            literature.setCompareLitertureId(compareLiterature.getId());
            literature.insert();
        }
        if (StringUtils.equals(vo.getField(), "fileRemark")) {
            vo.setField("remark");
        }
        GenerateObjectUtil.setObjectProperty(literature, vo.getField(), vo.getValue());
        literature.updateById();
        return literature.getId();
    }

    public void delCompareFile(CompareFileIdDTO vo) {
        NoveltyCompareLiterature noveltyCompareLiterature = noveltyCompareLiteratureMapper.selectOne(new QueryWrapper<NoveltyCompareLiterature>()
                .lambda()
                .eq(NoveltyCompareLiterature::getCompareLitertureId, vo.getCompareLitertureId()));
        if (ObjectUtils.isNotEmpty(noveltyCompareLiterature)) {
            //TODO  缺少对比记录方法，判断是否有对比记录，有的话则提示
            noveltyCompareLiteratureMapper.deleteById(noveltyCompareLiterature.getId());
        }

        compareLiteratureMapper.deleteById(vo.getCompareLitertureId());
    }

    public Map<String, String> getReportInfoFromWD(String caseNo) {
        ChromeOptions options = new ChromeOptions();
//        options.addArguments("user-data-dir=" + strFileSavePath);
        options.addArguments("--lang=nl");
        options.addArguments("--disable-popup-blocking");
        options.addArguments("--disable-images");
        options.addArguments("--remote-allow-origins=*");
//        if (isHeadless) {
//            options.addArguments("headless");
//        }

        WebDriver driver = null;
        Map<String, String> retObject = new HashMap<>();

        try {
//            System.setProperty("webdriver.chrome.driver", chromeDriverPath);
            driver = new ChromeDriver(options);

            driver.manage().timeouts().implicitlyWait(5, TimeUnit.SECONDS);
            driver.manage().timeouts().pageLoadTimeout(100, TimeUnit.SECONDS);

//            driver.get(iPEasyWeb);

            //进入登录界面
            WebElement userField = driver.findElement(By.id("txtUser"));
            WebElement pwdField = driver.findElement(By.id("txtPwd"));
            WebElement loginButton = driver.findElement(By.id("btnLogin"));
            //输入用户名和密码
            userField.clear();
//            userField.sendKeys(account);
            pwdField.clear();
//            pwdField.sendKeys(password);
            //点击登录按钮
            loginButton.click();

            //关闭提示遮罩层
            WebElement closeOverlay = null;
            try {
                closeOverlay = driver.findElement(By.id("jpwClose"));
                if (closeOverlay.isDisplayed()) {
                    closeOverlay.click();
                }
            } catch (Exception e) {

            }

            //点击顶部菜单栏中的案件管理菜单
            WebElement caseManagementMenu = driver.findElement(By.name("71A7CC35-F597-40E1-9FEF-BE622A3A3B63"));
            caseManagementMenu.click();

            //点击左侧 查询 菜单
            WebElement searchMenu = driver.findElement(By.name("c3266ab3-521a-4815-8aaf-7dd0bc5a76af"));
            searchMenu.click();

            //切换到自定义报表Frame
            driver.switchTo().frame(1);

            WebElement inputSearch = driver.findElement(By.id("case_volume"));
            inputSearch.sendKeys(caseNo.trim());

            WebElement btnSearch = driver.findElement(By.id("btn_Search"));
            btnSearch.click();

            WebElement caseLink = driver.findElement(By.xpath("//a[contains(text()," + caseNo + ")]"));
            caseLink.click();

            driver.switchTo().parentFrame().switchTo().frame(2);

            WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(20));
            //等待页面上ID属性值为submitButton的元素加载完成
            WebElement myElement = wait.until((ExpectedCondition<WebElement>) wd -> {
                try {
                    if (wd != null) {
                        wd.switchTo().parentFrame().switchTo().frame(2);
                        return wd.findElement(By.id("libase"));
                    }
                } catch (Exception e) {
                    return null;
                }
                return null;
            });

            myElement.click();

            // 案件号
            retObject.put("CaseNo", caseNo.trim());
            //案件名称
            retObject.put("CaseName", driver.findElement(By.id("p_case_info__case_name")).getAttribute("value"));
            //客户名称
            retObject.put("CustomerName", driver.findElement(By.id("p_case_info__customer_id")).getAttribute("value"));
            //业务类型
            retObject.put("BusinessType", driver.findElement(By.id("p_case_info__business_type_id")).getAttribute("value"));
            retObject.put("CaseState", getSelectText(driver.findElement(By.id("p_case_info__case_status_id"))));
            retObject.put("ApplicationType", getSelectText(driver.findElement(By.id("p_case_info__apply_type_id"))));

            //案件类型
            retObject.put("CaseType", driver.findElement(By.id("p_case_info__case_type_id")).getAttribute("value"));
            //委案日期
            retObject.put("EntrustingDate", driver.findElement(By.id("p_case_info__charge_date")).getAttribute("value"));
            //案件备注
            retObject.put("CaseMemo", driver.findElement(By.id("p_case_info__remark")).getAttribute("value"));

            WebElement expandInfoButton = driver.findElement(By.xpath("//span[contains(text(),'扩展信息')]"));
            expandInfoButton.click();
            retObject.put("CaseCoefficient", getSelectText(driver.findElement(By.id("p_case_info__case_coefficient_id"))));

        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("An error occurred while retrieving case info", e);
        } finally {
            if (driver != null) {
                driver.quit();
            }
        }

        return retObject;
    }

    public static String getSelectText(WebElement element) {
        String strValue = element.getAttribute("value");

        if (strValue == null || strValue.isEmpty()) {
            return null;
        }

        List<WebElement> ops = element.findElements(By.tagName("option"));
        for (WebElement op : ops) {
            if (op.getAttribute("value").equals(strValue)) {
                return op.getText();
            }
        }
        return null;
    }

    public List<Integer> copyCompareFile(List<Integer> ids, Integer toProjectId, Integer fromProjectId) throws Exception {

        if (ids == null || ids.size() == 0) {
            return new ArrayList<>();
        }
        QueryCompareFileDTO queryCompareFileDTOFrom = new QueryCompareFileDTO();
        queryCompareFileDTOFrom.setIds(ids);
        List<QueryCompareFileVO> queryCompareFileVOSFrom = this.getBaseMapper().queryCompareFile(queryCompareFileDTOFrom);
        List<String> patentNos = queryCompareFileVOSFrom.stream().map(QueryCompareFileVO::getLiteratureNo).collect(Collectors.toList());

        QueryCompareFileDTO queryCompareFileDTOTo = new QueryCompareFileDTO();
        queryCompareFileDTOTo.setPatentNos(patentNos);
        queryCompareFileDTOTo.setProjectId(toProjectId);
        List<QueryCompareFileVO> queryCompareFileVOSTo = this.getBaseMapper().queryCompareFile(queryCompareFileDTOTo);

        for (QueryCompareFileVO queryCompareFileVO : queryCompareFileVOSFrom) {
            importSinglePatentService.addPatentToProject(queryCompareFileVO.getLiteratureNo(),toProjectId);
            QueryCompareFileVO queryCompareFileVOTo = queryCompareFileVOSTo.stream().filter(item -> item.getLiteratureNo().equals(queryCompareFileVO.getLiteratureNo())).findFirst().orElse(null);
            if (queryCompareFileVOTo == null) {
                CompareLiterature compareLiterature = new CompareLiterature();
                BeanUtils.copyProperties(queryCompareFileVO, compareLiterature);
                compareLiterature.setRemark(queryCompareFileVO.getLiteratureRemark());
                compareLiterature.setProjectId(toProjectId);
                compareLiterature.setId(null);
                compareLiterature.insert();
                NoveltyCompareLiterature noveltyCompareLiterature = new NoveltyCompareLiterature();
                BeanUtils.copyProperties(queryCompareFileVO, noveltyCompareLiterature);
                noveltyCompareLiterature.setRemark(queryCompareFileVO.getFileRemark());

                noveltyCompareLiterature.setCompareLitertureId(compareLiterature.getId());
                noveltyCompareLiterature.insert();
            } else {
                Integer fromId = queryCompareFileVO.getCompareFileId();
                if (fromId == null) {
                    //什么都不需要做
                } else {
                    Integer toId = queryCompareFileVOTo.getCompareFileId();
                    if (toId == null) {
                        NoveltyCompareLiterature noveltyCompareLiterature = new NoveltyCompareLiterature();
                        BeanUtils.copyProperties(queryCompareFileVO, noveltyCompareLiterature);
                        noveltyCompareLiterature.setRemark(queryCompareFileVO.getFileRemark());

                        noveltyCompareLiterature.setCompareLitertureId(queryCompareFileVOTo.getCompareLitertureId());
                        noveltyCompareLiterature.insert();
                    } else {
                        NoveltyCompareLiterature noveltyCompareLiterature = new NoveltyCompareLiterature();
                        BeanUtils.copyProperties(queryCompareFileVOTo, noveltyCompareLiterature);
                        noveltyCompareLiterature.setRemark(queryCompareFileVO.getFileRemark());

                        if (queryCompareFileVO.getBeneficialEffect() != null) {
                            noveltyCompareLiterature.setBeneficialEffect(noveltyCompareLiterature.getBeneficialEffect() + queryCompareFileVO.getBeneficialEffect());
                        }
                        if (queryCompareFileVO.getRelevance() != null) {
                            noveltyCompareLiterature.setRelevance(noveltyCompareLiterature.getRelevance() + queryCompareFileVO.getRelevance());
                        }
                        if (queryCompareFileVO.getLiteratureRemark() != null) {
                            noveltyCompareLiterature.setRemark(noveltyCompareLiterature.getRemark() + queryCompareFileVO.getLiteratureRemark());
                        }
                        if (queryCompareFileVO.getGeneralRemark() != null) {
                            noveltyCompareLiterature.setGeneralRemark(noveltyCompareLiterature.getGeneralRemark() + queryCompareFileVO.getGeneralRemark());
                        }
                        if (queryCompareFileVO.getTechnicalPoints() != null) {
                            noveltyCompareLiterature.setGeneralRemark(noveltyCompareLiterature.getTechnicalPoints() + queryCompareFileVO.getTechnicalPoints());
                        }
                        if (queryCompareFileVO.getExcuteCase() != null) {
                            noveltyCompareLiterature.setExcuteCase(noveltyCompareLiterature.getExcuteCase() + queryCompareFileVO.getExcuteCase());

                        }
                        if (queryCompareFileVO.getBeneficialEffect() != null) {
                            noveltyCompareLiterature.setBeneficialEffect(noveltyCompareLiterature.getBeneficialEffect() + queryCompareFileVO.getBeneficialEffect());
                        }
                    }

                }

            }

        }
        //添加标注
        if (patentNos != null && patentNos.size() > 0) {
            List<NoveltyCompareRecordVO> noveltyCompareRecordVOS = esScratchWordsService.queryMarkingByNo(fromProjectId, patentNos);
            List<NoveltyCompareRecordVO> noveltyCompareRecordVOList = esScratchWordsService.queryMarkingByNo(toProjectId, patentNos);
            List<Marking> markings = new ArrayList<>();

            noveltyCompareRecordVOS.forEach(item -> {
                NoveltyCompareRecordVO noveltyCompareRecordVO = noveltyCompareRecordVOList.stream().filter(t -> t.getPatentNo().equals(item.getPatentNo())).findFirst().orElse(null);
                Marking marking = new Marking();
                if (noveltyCompareRecordVO != null) {
                    BeanUtils.copyProperties(noveltyCompareRecordVO, marking);
                    if (noveltyCompareRecordVO.getMarkNoteText() != null) {
                        marking.setMarkNoteText(noveltyCompareRecordVO.getMarkNoteText() + item.getMarkNoteText());
                    } else {
                        marking.setMarkNoteText(item.getMarkNoteText());
                    }
                    esScratchWordsService.updateScratchWords(noveltyCompareRecordVO.getId(), marking);
                } else {
                    BeanUtils.copyProperties(item, marking);
                    marking.setProjectId(toProjectId);
                    markings.add(marking);
                }
            });

            esScratchWordsService.saveListToEs(markings);
        }
        return ids;
    }

    /**
     * 根据检索记录ids查询专利信息
     *
     * @param retrieveIds
     * @return
     */
    public Map<Integer, List<NoveltyCompareLiteratureVO>> getPatentNoByRetrieveIds(List<Integer> retrieveIds) {
        Map<Integer, List<NoveltyCompareLiteratureVO>> noveltyMap = new HashMap<>();
        for (Integer retrieveId : retrieveIds) {
            List<NoveltyCompareLiteratureVO> noveltyCompareLiteratureVOS = noveltyCompareLiteratureMapper.getPatentNoByRetrieveId(retrieveId);
            if (noveltyCompareLiteratureVOS != null && noveltyCompareLiteratureVOS.size() != 0) {
                noveltyMap.put(retrieveId, noveltyCompareLiteratureVOS);
            }
        }
        return noveltyMap;
    }
}