PAS/src/main/java/cn/cslg/pas/service/FinalInvalidStatueService.java

package cn.cslg.pas.service;

import cn.cslg.pas.common.dto.FinalProofGroupDTO;
import cn.cslg.pas.common.dto.InvalidReasonDTO;
import cn.cslg.pas.common.dto.GetInvalidReasonClaimsDTO;
import cn.cslg.pas.common.dto.invalidDTO.PatentClaimDTO;
import cn.cslg.pas.common.model.cronModel.PersonnelVO;
import cn.cslg.pas.common.model.finalInvalid.FinalProfGroupEditDTO;
import cn.cslg.pas.common.model.finalInvalid.FinalProfGroupQueryDTO;
import cn.cslg.pas.common.model.finalInvalid.FinalProfGroupVO;
import cn.cslg.pas.common.utils.CacheUtils;
import cn.cslg.pas.common.utils.LoginUtils;
import cn.cslg.pas.common.utils.RedisUtil;
import cn.cslg.pas.common.vo.GetInvalidReasonClaimsVO;
import cn.cslg.pas.common.vo.invalidVO.PatentClaimHistoryVO;
import cn.cslg.pas.domain.BaseEntity;
import cn.cslg.pas.domain.FinalInvalidStatue;
import cn.cslg.pas.domain.FinalProofGroup;
import cn.cslg.pas.domain.business.InvalidStatutes;
import cn.cslg.pas.exception.XiaoShiException;
import cn.cslg.pas.mapper.FinalInvalidStatueMapper;
import cn.cslg.pas.mapper.FinalProofGroupMapper;
import cn.cslg.pas.service.business.InvalidStatutesService;
import cn.cslg.pas.service.business.ProofGroupService;
import cn.cslg.pas.service.business.invalidReport.PatentClaimHistoryService;
import com.alibaba.fastjson2.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.RequiredArgsConstructor;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

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

/**
 * @author admin
 * @description 针对表【final_invalid_statue(最终无效理由和证据)】的数据库操作Service实现
 * @createDate 2024-06-20 17:09:07
 */
@Service
@RequiredArgsConstructor
public class FinalInvalidStatueService extends ServiceImpl<FinalInvalidStatueMapper, FinalInvalidStatue> {
    private final InvalidStatutesService invalidStatutesService;
    private final PatentClaimHistoryService patentClaimHistoryService;
    private static List<Integer> inStatueIds = Arrays.asList(2, 3, 4);
    private final ProofGroupService proofGroupService;
    private final FinalProofGroupService finalProofGroupService;
    private final FinalInvalidStatueMapper invalidStatueMapper;
    private final FinalProofGroupMapper proofGroupMapper;
    @Autowired
    private CacheUtils cacheUtils;
    @Autowired
    private LoginUtils loginUtils;
    @Autowired
    private RedisUtil redisUtil;

    public void ImportByProjectId(Integer projectId, Integer statueType) {

    }

    @Transactional(rollbackFor = Exception.class)
    public void importFinalInvalidStatutes(Integer projectId) {

        //删除原来保存数据
        this.removeFinalInvalidStatus(projectId);
        //根据projectId 查询无效理由和证据
        LambdaQueryWrapper<InvalidStatutes> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(InvalidStatutes::getProjectId, projectId);
        List<InvalidStatutes> invalidStatutes = invalidStatutesService.list(queryWrapper);

        for (InvalidStatutes invalidStatute : invalidStatutes) {
            FinalInvalidStatue finalInvalidStatue = new FinalInvalidStatue();
            Integer claimId = invalidStatute.getClaimId();
            finalInvalidStatue.setStatuteId(invalidStatute.getStatutesId());
            Map<String, String> claimMess = this.getClaimText(claimId);
            finalInvalidStatue.setClaimText(claimMess.get("claimText"));
            finalInvalidStatue.setCourtOpinions1(claimMess.get("court1"));
            finalInvalidStatue.setCourtOpinions2(claimMess.get("court2"));
            if (claimMess.get("index") != null) {
                Integer index = Integer.parseInt(claimMess.get("index").toString());
                finalInvalidStatue.setClaimOrder(index);
            }
            finalInvalidStatue.setProjectId(projectId);
            finalInvalidStatue.insert();
            finalProofGroupService.addFinalProofGroup(invalidStatute.getId(), finalInvalidStatue);
        }

    }

    public Map<String, String> getClaimText(Integer claimId) {
        String claimText = "";
        PatentClaimDTO patentClaimDTO = new PatentClaimDTO();
        patentClaimDTO.setClaimId(claimId);

        PatentClaimHistoryVO patentClaimHistoryVO = patentClaimHistoryService.queryPatentClaimHistory(patentClaimDTO);
        if (patentClaimHistoryVO.getSecondClaimVO() != null && patentClaimHistoryVO.getSecondClaimVO().getOperateType().equals(0)) {
            claimText = patentClaimHistoryVO.getSecondClaimVO().getContent();
        } else if (patentClaimHistoryVO.getFirstClaimVO() != null && patentClaimHistoryVO.getFirstClaimVO().getOperateType().equals(0)) {
            claimText = patentClaimHistoryVO.getFirstClaimVO().getContent();
        } else {
            claimText = patentClaimHistoryVO.getOriginalClaimVO().getContent();
        }
        Map<String, String> map = new HashMap<>();
        map.put("claimText", claimText);
        map.put("court1", patentClaimHistoryVO.getOriginalClaimVO().getCourtDecision1());
        map.put("court2", patentClaimHistoryVO.getOriginalClaimVO().getCourtDecision2());
        if (patentClaimHistoryVO.getOriginalClaimVO().getSysOrder() != null) {
            map.put("index", patentClaimHistoryVO.getOriginalClaimVO().getSysOrder().toString());
        }
        return map;
    }

    public List<FinalProfGroupVO> queryFinalProofGroup(FinalProfGroupQueryDTO finalProfGroupQueryDTO) {
        List<FinalProfGroupVO> finalProfGroupVOS = new ArrayList<>();

        Integer projectId = finalProfGroupQueryDTO.getId();
        Integer statusType = finalProfGroupQueryDTO.getStatueType();
        //根据projectId查询最终无效理由和证据
        LambdaQueryWrapper<FinalInvalidStatue> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(FinalInvalidStatue::getProjectId, projectId)
                .orderByAsc(FinalInvalidStatue::getStatuteId)
                .orderByAsc(FinalInvalidStatue::getClaimOrder);

        if (statusType != null) {
            if (statusType.equals(1)) {
                queryWrapper.in(FinalInvalidStatue::getStatuteId, inStatueIds);
            } else {
                queryWrapper.notIn(FinalInvalidStatue::getStatuteId, inStatueIds);

            }
        }
        List<FinalInvalidStatue> finalInvalidStatues = this.list(queryWrapper);
        if (finalInvalidStatues.size() == 0) {
            return finalProfGroupVOS;
        }
        List<Integer> ids = finalInvalidStatues.stream().map(FinalInvalidStatue::getId).collect(Collectors.toList());

        List<FinalProofGroup> finalProofGroups = new ArrayList<>();
        LambdaQueryWrapper<FinalProofGroup> queryWrapper1 = new LambdaQueryWrapper<>();
        queryWrapper1.in(FinalProofGroup::getFinalInvalidStatueId, ids);
        finalProofGroups = finalProofGroupService.list(queryWrapper1);

        for (FinalInvalidStatue finalInvalidStatue : finalInvalidStatues) {
            Integer id = finalInvalidStatue.getId();
            List<FinalProofGroup> statueGroups = finalProofGroups.stream().filter(item -> item.getFinalInvalidStatueId().equals(id)).collect(Collectors.toList());
            statueGroups.forEach(item -> {
                FinalProfGroupVO finalProfGroupVO = new FinalProfGroupVO();
                if (finalInvalidStatue != null) {
                    finalProfGroupVO.setInvalidStatue(finalInvalidStatue);
                }
                finalProfGroupVO.setId(item.getId());
                finalProfGroupVO.setPresentOpinions(item.getPresentOpinions());
                finalProfGroupVO.setInvalidReason(item.getInvalidReason());
                finalProfGroupVO.setRbDecision(item.getRbDecision());
                finalProfGroupVOS.add(finalProfGroupVO);
            });
        }
        return finalProfGroupVOS;
    }


    public void editProofGroup(FinalProfGroupEditDTO finalProfGroupEditDTO) {
        Integer invalidStatueId = finalProfGroupEditDTO.getInvalidStatueId();
        Integer proofGroupId = finalProfGroupEditDTO.getProofGroupId();
        String editField = finalProfGroupEditDTO.getEditField();
        String fieldContent = finalProfGroupEditDTO.getFieldContent();
        switch (editField) {
            case "invalidReason":
                FinalProofGroup finalProofGroup1 = finalProofGroupService.getById(proofGroupId);
                finalProofGroup1.setInvalidReason(fieldContent);
                finalProofGroup1.updateById();
                break;
            case "presentOpinions":
                FinalProofGroup finalProofGroup2 = finalProofGroupService.getById(proofGroupId);
                finalProofGroup2.setPresentOpinions(fieldContent);
                finalProofGroup2.updateById();
                break;
            case "rbDecision":
                FinalProofGroup finalProofGroup3 = finalProofGroupService.getById(proofGroupId);
                finalProofGroup3.setRbDecision(fieldContent);
                finalProofGroup3.updateById();
                break;
            case "courtOpinions1":
                FinalInvalidStatue finalInvalidStatue1 = this.getById(invalidStatueId);
                Integer claimOrder = finalInvalidStatue1.getClaimOrder();
                UpdateWrapper<FinalInvalidStatue> updateWrapper = new UpdateWrapper<>();

                // Lambda表达式
                updateWrapper.lambda().set(FinalInvalidStatue::getCourtOpinions1, fieldContent)
                        .eq(FinalInvalidStatue::getClaimOrder, claimOrder)
                        .eq(FinalInvalidStatue::getProjectId, finalInvalidStatue1.getProjectId());
                this.update(updateWrapper);
                break;
            case "courtOpinions2":
                FinalInvalidStatue finalInvalidStatue2 = this.getById(invalidStatueId);
                Integer claimOrder2 = finalInvalidStatue2.getClaimOrder();
                UpdateWrapper<FinalInvalidStatue> updateWrapper2 = new UpdateWrapper<>();

                // Lambda表达式
                updateWrapper2.lambda().set(FinalInvalidStatue::getCourtOpinions2, fieldContent)
                        .eq(FinalInvalidStatue::getClaimOrder, claimOrder2)
                        .eq(FinalInvalidStatue::getProjectId, finalInvalidStatue2.getProjectId());
                this.update(updateWrapper2);
                break;
            case "claimText":
                FinalInvalidStatue finalInvalidStatue3 = this.getById(invalidStatueId);
                Integer claimOrder3 = finalInvalidStatue3.getClaimOrder();
                UpdateWrapper<FinalInvalidStatue> updateWrapper3 = new UpdateWrapper<>();

                // Lambda表达式
                updateWrapper3.lambda().set(FinalInvalidStatue::getClaimText, fieldContent)
                        .eq(FinalInvalidStatue::getClaimOrder, claimOrder3)
                        .eq(FinalInvalidStatue::getProjectId, finalInvalidStatue3.getProjectId());
                this.update(updateWrapper3);
                break;
            case "statuteId":
                FinalInvalidStatue finalInvalidStatue4 = this.getById(invalidStatueId);
                finalInvalidStatue4.setStatuteId(Integer.parseInt(fieldContent));
                finalInvalidStatue4.updateById();
        }
    }


    public void removeFinalInvalidStatus(Integer projectId) {
        LambdaQueryWrapper<FinalInvalidStatue> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(FinalInvalidStatue::getProjectId, projectId);
        LambdaQueryWrapper<FinalProofGroup> queryWrapper1 = new LambdaQueryWrapper<>();
        queryWrapper1.eq(FinalProofGroup::getProjectId, projectId);
        this.remove(queryWrapper);
        finalProofGroupService.remove(queryWrapper1);

    }

    /**
     * 添加无效理由
     *
     * @param vo
     * @return
     */
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Throwable.class)
    public Integer addInvalidReason(InvalidReasonDTO vo) {
        final Integer claimSort = vo.getClaimSort();
        final Integer statuteId = vo.getStatuteId();
        final String claimText = vo.getClaimText();
        final Long count = invalidStatueMapper.selectCount(new LambdaQueryWrapper<FinalInvalidStatue>()
                .eq(FinalInvalidStatue::getStatuteId, statuteId)
                .eq(FinalInvalidStatue::getClaimOrder, claimSort)
                .eq(FinalInvalidStatue::getProjectId, vo.getProjectId()));
        if (count > 0) {
            throw new XiaoShiException("该法条下已存在相同权利要求");
        }
        FinalInvalidStatue statue = new FinalInvalidStatue();
        statue.setStatuteId(statuteId);
        statue.setClaimOrder(claimSort);
        statue.setClaimText(claimText);
        statue.setProjectId(vo.getProjectId());
        //获取登陆人信息 用于设置创建人
        PersonnelVO personnelVO = new PersonnelVO();
        personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
        if (ObjectUtils.isEmpty(personnelVO)) {
            throw new XiaoShiException("未获取到创建人");
        }
        statue.setCreateId(personnelVO.getId());
        statue.setCreateTime(new Date());
        statue.insert();

        FinalProofGroup proofGroup = new FinalProofGroup();
        proofGroup.setFinalInvalidStatueId(statue.getId());
        proofGroup.setProjectId(vo.getProjectId());
        proofGroup.setFeatureSort(1);
        proofGroup.setCreateId(personnelVO.getId());
        proofGroup.setCreateTime(new Date());
        proofGroup.insert();
        return statue.getId();
    }

    /**
     * 查询三性/非三性无效理由
     *
     * @param vo
     * @return
     */
    public List<GetInvalidReasonClaimsVO> getInvalidReasonClaims(GetInvalidReasonClaimsDTO vo) {
        List<GetInvalidReasonClaimsVO> claimsVOS = new ArrayList<>();
        Integer projectId = vo.getProjectId();
        Integer statusType = vo.getStatueType();
        //根据projectId查询最终无效理由和证据
        LambdaQueryWrapper<FinalInvalidStatue> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(FinalInvalidStatue::getProjectId, projectId)
                .orderByAsc(FinalInvalidStatue::getStatuteId)
                .orderByAsc(FinalInvalidStatue::getClaimOrder);
        if (statusType != null) {
            if (statusType == 1) {
                queryWrapper.in(FinalInvalidStatue::getStatuteId, inStatueIds);
            } else {
                queryWrapper.notIn(FinalInvalidStatue::getStatuteId, inStatueIds);
            }
        }
        List<FinalInvalidStatue> statueList = this.list(queryWrapper);
        if (CollectionUtils.isEmpty(statueList)) {
            return claimsVOS;
        }
        List<Integer> invalidStatueIds = statueList.stream().map(FinalInvalidStatue::getId).collect(Collectors.toList());
//        List<FinalProofGroup> proofGroups = proofGroupMapper.selectProofList(invalidStatueIds);
        List<FinalProofGroup> proofGroups = proofGroupMapper.selectList(new LambdaQueryWrapper<FinalProofGroup>()
                .in(FinalProofGroup::getFinalInvalidStatueId, invalidStatueIds)
                .orderByAsc(FinalProofGroup::getFeatureSort));
        for (FinalInvalidStatue statue : statueList) {
            Integer invalidStatueId = statue.getId();
            List<FinalProofGroup> statueGroups = proofGroups.stream().filter(item -> item.getFinalInvalidStatueId().equals(invalidStatueId)).collect(Collectors.toList());
            statueGroups.forEach(item -> {
                GetInvalidReasonClaimsVO claimsVO = new GetInvalidReasonClaimsVO();
                InvalidReasonDTO invalidReasonDTO = new InvalidReasonDTO();
                invalidReasonDTO.setInvalidStatueId(statue.getId());
                invalidReasonDTO.setStatuteId(statue.getStatuteId());
                invalidReasonDTO.setProjectId(statue.getProjectId());
                invalidReasonDTO.setClaimSort(statue.getClaimOrder());
                invalidReasonDTO.setClaimText(statue.getClaimText());
                claimsVO.setInvalidReasonDTO(invalidReasonDTO);
                claimsVO.setProofGroupId(item.getId());
                claimsVO.setInvalidStatueId(statue.getId());
                claimsVO.setProjectId(item.getProjectId());
                claimsVO.setInvalidReason(item.getInvalidReason());
                claimsVO.setPresentOpinions(item.getPresentOpinions());
                claimsVO.setRbDecision(item.getRbDecision());
                claimsVO.setFeatureSort(item.getFeatureSort());
                claimsVO.setFeatureContent(item.getFeatureContent());
                claimsVO.setCourtOpinions1(item.getCourtOpinions1());
                claimsVO.setCourtOpinions2(item.getCourtOpinions2());
                claimsVOS.add(claimsVO);
            });
        }
        return claimsVOS;
    }

    /**
     * 修改无效理由
     *
     * @param vo
     * @return
     */
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Throwable.class)
    public Integer editInvalidReason(InvalidReasonDTO vo) {
        final Integer claimSort = vo.getClaimSort();
        final Integer statuteId = vo.getStatuteId();
        final String claimText = vo.getClaimText();
        final Long count = invalidStatueMapper.selectCount(new LambdaQueryWrapper<FinalInvalidStatue>()
                .eq(FinalInvalidStatue::getStatuteId, statuteId)
                .eq(FinalInvalidStatue::getClaimOrder, claimSort)
                .eq(FinalInvalidStatue::getProjectId, vo.getProjectId())
                .ne(FinalInvalidStatue::getId, vo.getInvalidStatueId()));
        if (count > 0) {
            throw new XiaoShiException("该法条下已存在相同权利要求");
        }
        FinalInvalidStatue statue = invalidStatueMapper.selectById(vo.getInvalidStatueId());
        statue.setStatuteId(statuteId);
        statue.setClaimOrder(claimSort);
        statue.setClaimText(claimText);
        statue.setProjectId(vo.getProjectId());
        statue.updateById();
        return statue.getId();
    }

    /**
     * 删除无效理由
     *
     * @param vo
     */
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Throwable.class)
    public void delInvalidReason(InvalidReasonDTO vo) {
        Integer invalidStatueId = vo.getInvalidStatueId();
        List<FinalProofGroup> proofGroups = proofGroupMapper.selectList(new LambdaQueryWrapper<FinalProofGroup>()
                .eq(FinalProofGroup::getFinalInvalidStatueId, invalidStatueId));
        if (!CollectionUtils.isEmpty(proofGroups)) {
            List<Integer> list = proofGroups.stream().map(BaseEntity::getId).collect(Collectors.toList());
            proofGroupMapper.deleteBatchIds(list);
        }
        invalidStatueMapper.deleteById(invalidStatueId);
    }

    /**
     * 添加特征
     *
     * @param vo
     * @return
     */
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Throwable.class)
    public Integer addFeature(FinalProofGroupDTO vo) {
//        proofGroupMapper.updateGroup(vo);
        editProofSort(vo.getInvalidStatueId(), vo.getFeatureSort(), 1);
        FinalProofGroup proofGroup = new FinalProofGroup();
        proofGroup.setFinalInvalidStatueId(vo.getInvalidStatueId());
        BeanUtils.copyProperties(vo, proofGroup);
        //获取登陆人信息 用于设置创建人
        PersonnelVO personnelVO = new PersonnelVO();
        personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
        if (ObjectUtils.isEmpty(personnelVO)) {
            throw new XiaoShiException("未获取到创建人");
        }
        proofGroup.setCreateId(personnelVO.getId());
        proofGroup.setCreateTime(new Date());
        proofGroup.insert();
        return proofGroup.getId();
    }

    /**
     * 修改特征序号
     *
     * @param invalidStatueId
     * @param featureSort
     * @param type
     */
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Throwable.class)
    public synchronized void editProofSort(Integer invalidStatueId, Integer featureSort, Integer type) {
        List<FinalProofGroup> proofGroups = proofGroupMapper.selectList(new LambdaQueryWrapper<FinalProofGroup>()
                .eq(FinalProofGroup::getFinalInvalidStatueId, invalidStatueId)
                .ge(FinalProofGroup::getFeatureSort, featureSort));
        if (!CollectionUtils.isEmpty(proofGroups)) {
            for (FinalProofGroup proofGroup : proofGroups) {
                proofGroup.setId(proofGroup.getId());
                if (type == 1) {
                    proofGroup.setFeatureSort(proofGroup.getFeatureSort() + 1);
                } else {
                    proofGroup.setFeatureSort(proofGroup.getFeatureSort() - 1);
                }
                proofGroup.updateById();
            }

        }
    }

    /**
     * 编辑特征
     *
     * @param vo
     * @return
     */
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Throwable.class)
    public Integer editFeature(FinalProofGroupDTO vo) {
        FinalProofGroup proofGroup = proofGroupMapper.selectById(vo.getProofGroupId());
        proofGroup.setFinalInvalidStatueId(vo.getInvalidStatueId());
        BeanUtils.copyProperties(vo, proofGroup);
        proofGroup.updateById();
        return proofGroup.getId();
    }

    /**
     * 删除特征
     *
     * @param vo
     */
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Throwable.class)
    public void delFeature(FinalProofGroupDTO vo) {
        FinalProofGroup proofGroup = proofGroupMapper.selectById(vo.getProofGroupId());
        editProofSort(proofGroup.getFinalInvalidStatueId(), proofGroup.getFeatureSort(), 2);
        proofGroupMapper.deleteById(proofGroup.getId());
    }

    /**
     * 查询无效理由里的无效发条
     *
     * @param vo
     * @return
     */
    public List<Integer> queryStatuesVOS(GetInvalidReasonClaimsDTO vo) {
        List<FinalInvalidStatue> list = invalidStatueMapper.selectList(new LambdaQueryWrapper<FinalInvalidStatue>()
                .eq(FinalInvalidStatue::getProjectId, vo.getProjectId()));
        return list.stream().map(FinalInvalidStatue::getStatuteId).distinct().collect(Collectors.toList());
    }


    public List<FinalInvalidStatue> getFinalInvalidStatues(List<Integer> projectIds) {
        //根据projectId查询最终无效理由和证据
        LambdaQueryWrapper<FinalInvalidStatue> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.in(FinalInvalidStatue::getProjectId, projectIds)
                .orderByAsc(FinalInvalidStatue::getStatuteId)
                .orderByAsc(FinalInvalidStatue::getClaimOrder);

        List<FinalInvalidStatue> statueList = this.list(queryWrapper);
        return statueList;
    }
}