fu-hsi-service/src/main/java/com/supervision/police/service/impl/CaseEvidenceServiceImpl.java

package com.supervision.police.service.impl;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.plugins.pagination.PageDTO;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.supervision.minio.domain.MinioFile;
import com.supervision.minio.service.MinioService;
import com.supervision.police.dto.*;
import com.supervision.police.service.*;
import com.supervision.police.domain.CaseEvidence;
import com.supervision.police.domain.ComDictionary;
import com.supervision.police.domain.EvidenceFile;
import com.supervision.common.constant.EvidenceConstants;
import com.supervision.police.domain.*;
import com.supervision.police.mapper.CaseEvidenceMapper;
import com.supervision.police.vo.EvidenceDirectoryReqVO;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
import java.util.Map;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

@Slf4j
@Service
@RequiredArgsConstructor
public class CaseEvidenceServiceImpl extends ServiceImpl<CaseEvidenceMapper, CaseEvidence> implements CaseEvidenceService {

    private final EvidenceFileService evidenceFileService;

    private final ComDictionaryService comDictionaryService;

    private final CaseStatusManageService caseStatusManageService;

    private final FileOcrProcessService fileOcrProcessService;

    private final MinioService minioService;

    private final ModelCaseService modelCaseService;

    @Autowired
    private OCREvidenceService ocrEvidenceService;
    @Autowired
    private LLMExtractService llmExtractService;
    @Autowired
    private EvidenceDirectoryService evidenceDirectoryService;
    @Autowired
    private EvidenceCategoryService evidenceCategoryService;
    @Autowired
    private NotePromptService notePromptService;

    private final XxlJobService xxlJobService;

    @Override
    @Transactional(transactionManager = "dataSourceTransactionManager", rollbackFor = Exception.class)
    public String saveEvidence(CaseEvidenceDTO caseEvidenceDTO) {
        // 必填校验
        caseEvidencePersistenceAssert(caseEvidenceDTO);

        // 保存证据信息
        CaseEvidence caseEvidence = caseEvidenceDTO.toCaseEvidence();
        super.save(caseEvidence);

        //保存文件关联信息
        caseEvidenceDTO.getFileIdList().forEach(fileId -> {
            EvidenceFile evidenceFile = new EvidenceFile();
            evidenceFile.setFileId(fileId);
            evidenceFile.setEvidenceId(caseEvidence.getId());
            evidenceFileService.save(evidenceFile);
        });
        caseStatusManageService.whenUpdateEvidence(caseEvidence.getCaseId());
        return caseEvidence.getId();
    }

    private void caseEvidencePersistenceAssert(CaseEvidenceDTO caseEvidenceDTO) {
        Assert.notEmpty(caseEvidenceDTO.getCaseId(), "案件id不能为空");
        Assert.notEmpty(caseEvidenceDTO.getEvidenceName(), "证据名称不能为空");
        Assert.notEmpty(caseEvidenceDTO.getEvidenceType(), "证据类型不能为空");
        //Assert.notEmpty(caseEvidenceDTO.getProvider(),"证据提供人不能为空");
        Assert.notEmpty(caseEvidenceDTO.getFileIdList(), "文件id不能为空");
    }

    @Override
    @Transactional(transactionManager = "dataSourceTransactionManager", rollbackFor = Exception.class)
    public String updateEvidence(CaseEvidenceDTO caseEvidenceDTO) {

        Assert.notEmpty(caseEvidenceDTO.getId(), "证据id不能为空");
        caseEvidencePersistenceAssert(caseEvidenceDTO);
        super.getOptById(caseEvidenceDTO.getId()).orElseThrow(() -> new IllegalArgumentException("证据信息不存在"));

        // 更新证据信息
        CaseEvidence caseEvidence = caseEvidenceDTO.toCaseEvidence();
        super.updateById(caseEvidence);

        // 更新文件关联信息
        evidenceFileService.lambdaUpdate().eq(EvidenceFile::getEvidenceId, caseEvidence.getId()).remove();
        caseEvidenceDTO.getFileIdList().forEach(fileId -> {
            EvidenceFile evidenceFile = new EvidenceFile();
            evidenceFile.setFileId(fileId);
            evidenceFile.setEvidenceId(caseEvidence.getId());
            evidenceFileService.save(evidenceFile);
        });
        caseStatusManageService.whenUpdateEvidence(caseEvidenceDTO.getCaseId());

        // 更新证据属性信息
        for (String fileId : caseEvidenceDTO.getFileIdList()) {
            caseEvidenceDTO.setTitleProperty();
            ocrEvidenceService.saveEvidenceProperty(caseEvidence.getId(), fileId, caseEvidenceDTO.getProperty());
        }

        return caseEvidenceDTO.getId();
    }

    @Override
    @Transactional(transactionManager = "dataSourceTransactionManager", rollbackFor = Exception.class)
    public boolean deleteEvidence(String evidenceId) {

        CaseEvidence caseEvidence = super.getOptById(evidenceId).orElseThrow(() -> new IllegalArgumentException("证据信息不存在"));
        boolean remove = super.lambdaUpdate().eq(CaseEvidence::getId, evidenceId).remove();

        if (remove) {
            evidenceFileService.lambdaUpdate().eq(EvidenceFile::getEvidenceId, evidenceId).remove();
            caseStatusManageService.whenUpdateEvidence(caseEvidence.getCaseId());
        }
        return remove;
    }

    @Override
    @Transactional(transactionManager = "dataSourceTransactionManager", rollbackFor = Exception.class)
    public List<CaseEvidenceDetailDTO> queryEvidenceList(String caseId) {

        return super.getBaseMapper().queryEvidenceList(caseId);
    }

    @Override
    @Transactional(transactionManager = "dataSourceTransactionManager", rollbackFor = Exception.class)
    public List<CaseEvidenceDetailDTO> queryEvidenceList(String caseId, String batchNo) {
        List<CaseEvidenceDetailDTO> caseEvidenceDetailDTOS = queryEvidenceList(caseId);
        if (StrUtil.isNotEmpty(batchNo)){
            for (CaseEvidenceDetailDTO evidenceDetail : caseEvidenceDetailDTOS) {
                List<EvidenceFileDTO> filter = evidenceDetail.getFileList().stream().filter(file -> StrUtil.equals(file.getBatchNo(), batchNo)).toList();
                evidenceDetail.setFileList(filter);
            }
        }
        return caseEvidenceDetailDTOS;
    }

    @Override
    @Transactional(transactionManager = "dataSourceTransactionManager", rollbackFor = Exception.class)
    public IPage<CaseEvidenceDetailDTO> pageListEvidence(String caseId, String directoryId,String evidenceName, Integer pageNum, Integer pageSize) {

        Assert.notEmpty(caseId, "案件id不能为空");
        Page<CaseEvidence> caseEvidencePage = super.lambdaQuery().eq(CaseEvidence::getCaseId, caseId)
                .eq(StrUtil.isNotEmpty(directoryId), CaseEvidence::getDirectoryId, directoryId)
                .like(StrUtil.isNotEmpty(evidenceName), CaseEvidence::getEvidenceName, evidenceName)
                .orderBy(true, false, CaseEvidence::getUpdateTime)
                .page(new Page<>(pageNum, pageSize));

        if (caseEvidencePage.getTotal() == 0) {
            return PageDTO.of(pageNum, pageSize, 0);
        }

        // 查询文件信息
        List<String> evidenceIds = caseEvidencePage.getRecords().stream().map(CaseEvidence::getId).distinct().toList();
        List<EvidenceFileDTO> fileInfoList = evidenceFileService.listFileInfo(evidenceIds);
        Map<String, List<EvidenceFileDTO>> evidenceFileMap = fileInfoList.stream().collect(Collectors.groupingBy(EvidenceFileDTO::getEvidenceId));


        List<RecordFileDTO> recordFileDTOS = fileOcrProcessService.queryFileList(fileInfoList.stream().map(EvidenceFileDTO::getFileId).toList());

        List<EvidenceDirectoryDTO> evidenceDirectoryDTOS = listDirectoryTree(caseId);


        // 转换分页结果
        //查询字典
        List<ComDictionary> evidenceTypeDic = comDictionaryService.lambdaQuery().eq(ComDictionary::getType, "evidence_type").list();
        return caseEvidencePage.convert(caseEvidence -> {
            CaseEvidenceDetailDTO caseEvidenceDetailDTO = new CaseEvidenceDetailDTO(caseEvidence, evidenceFileMap.get(caseEvidence.getId()));
            caseEvidenceDetailDTO.setEvidenceTypeDesc(
                    comDictionaryService.getName(evidenceTypeDic, "evidence_type", caseEvidence.getEvidenceType()));
            caseEvidenceDetailDTO.setContentTypeValue(recordFileDTOS);

            EvidenceDirectoryDTO directory = evidenceDirectoryService.findDirectoryById(caseEvidence.getDirectoryId(), evidenceDirectoryDTOS);
            caseEvidenceDetailDTO.setEvidenceFormatValue(directory);
            return caseEvidenceDetailDTO;
        });
    }

    @Override
    public CaseEvidenceDetailDTO queryEvidenceDetail(String evidenceId) {
        return super.getBaseMapper().queryEvidenceDetail(evidenceId);
    }

    @Override
    public void evidenceAnalysis(String evidenceId) {
        log.info("证据解析开始。证据ID:【{}】", evidenceId);
        long start = System.currentTimeMillis();
        LLMExtractDto llmExtractDto = new LLMExtractDto();
        // 查出证据、文件、如果证据
        CaseEvidence caseEvidence = getById(evidenceId);
        if (caseEvidence == null) {
            log.error("证据不存在");
            return;
        }
        List<EvidenceFile> evidenceFiles = evidenceFileService.lambdaQuery().eq(EvidenceFile::getEvidenceId, evidenceId).list();
        if (evidenceFiles.isEmpty()) {
            log.error("证据文件不存在");
            return;
        }
        try {
            // 根据rank升序排序
            evidenceFiles.sort(Comparator.comparing(EvidenceFile::getRank));
            log.info("OCR识别开始。证据文件ID:【{}】", evidenceFiles.stream().map(EvidenceFile::getFileId).toList());
            long ocrStart = System.currentTimeMillis();
            List<FileOcrProcess> fileOcrProcesses = fileOcrProcessService.syncSubmitOCR(evidenceFiles.stream().map(EvidenceFile::getFileId).toList());
            log.info("OCR识别完成。更新证据处理状态为【OCR识别完成】。耗时:【{}】ms", System.currentTimeMillis() - ocrStart);
            caseEvidence.setProcessStatus(EvidenceConstants.PROCESS_STATUS_OCR_OK);
            updateById(caseEvidence);
            // 遍历OCR结果拼接ocrText并赋值给lLMExtractDto的text
            StringBuilder ocrText = new StringBuilder();
            fileOcrProcesses.forEach(fileOcrProcess -> {
                if (StrUtil.isNotEmpty(fileOcrProcess.getReviseText())){
                    ocrText.append(fileOcrProcess.getReviseText());
                }else {
                    ocrText.append(fileOcrProcess.getOcrText());
                }
            });
            llmExtractDto.setText(ocrText.toString());
            log.info("标题提取开始。");
            long titleStart = System.currentTimeMillis();
            llmExtractDto = llmExtractService.extractTitle(Collections.singletonList(llmExtractDto)).get(0);
            log.info("标题提取完成。更新证据处理状态为【标题提取完成】。标题:【{}】。耗时:【{}】ms", llmExtractDto.getTitle(), System.currentTimeMillis() - titleStart);
            caseEvidence.setProcessStatus(EvidenceConstants.PROCESS_STATUS_TITLE_EXTRACT_OK);
            updateById(caseEvidence);
            // 根据证据目录id查询提示词
            EvidenceDirectory directory = evidenceDirectoryService.getById(caseEvidence.getDirectoryId());
            EvidenceCategory category = evidenceCategoryService.getById(directory.getCategoryId());
            NotePrompt notePrompt = notePromptService.getById(category.getPromptId());
            if (notePrompt != null) {
                log.info("属性提取开始。");
                long attrStart = System.currentTimeMillis();
                llmExtractDto.setPrompt(notePrompt.getPrompt());
                llmExtractDto.setExtractAttributes(notePrompt.getExtractAttributes());
                llmExtractDto = llmExtractService.extractAttribute(Collections.singletonList(llmExtractDto)).get(0);
                Map<String, String> map = new HashMap<>();
                llmExtractDto.getExtractAttributes().forEach(notePromptExtractAttribute -> map.put(notePromptExtractAttribute.getAttrName(), notePromptExtractAttribute.getAttrValue()));
                caseEvidence.setProperty(map);
                log.info("属性提取完成。更新证据处理状态为【属性提取完成】。属性:【{}】。耗时:【{}】", caseEvidence.getProperty(), System.currentTimeMillis() - attrStart);
                caseEvidence.setProcessStatus(EvidenceConstants.PROCESS_STATUS_ATTR_EXTRACT_OK);
                updateById(caseEvidence);
            } else {
                log.info("没有关联提示词，不提取属性");
            }
            log.info("证据解析完成。更新证据处理状态为【处理成功】。");
            caseEvidence.setProcessStatus(EvidenceConstants.PROCESS_STATUS_SUCCESS);
            updateById(caseEvidence);
        } catch (Exception e) {
            log.error("证据解析失败。更新证据处理状态为【处理失败】。");
            caseEvidence.setProcessStatus(EvidenceConstants.PROCESS_STATUS_FAILED);
            updateById(caseEvidence);
        } finally {
            log.info("证据解析完成。证据ID:【{}】耗时:【{}】ms", evidenceId, System.currentTimeMillis() - start);
        }
    }

    @Override
    public List<EvidenceCategoryDTO> listCategoryTree(String caseType) {

        Assert.notEmpty(caseType,"案件类型不能为空!");
        return evidenceCategoryService.listCategoryTree(caseType);
    }

    @Override
    public List<EvidenceDirectoryDTO> listFileTree(String caseId) {

        Assert.notEmpty(caseId,"案件ID不能为空!");
        List<EvidenceDirectoryDTO> evidenceDirectoryDTOS = evidenceDirectoryService.listDirectoryTree(caseId);

        evidenceDirectoryService.appendFile(evidenceDirectoryDTOS, evidenceFileService.listFileInfoByCaseId(caseId));

        return evidenceDirectoryDTOS;
    }

    @Override
    public List<EvidenceDirectoryDTO> listDirectoryTree(String caseId) {
        Assert.notEmpty(caseId,"案件ID不能为空!");

        return evidenceDirectoryService.listDirectoryTree(caseId);
    }

    @Override
    public void initCaseEvidenceDirectory(String caseId, String caseType) {

        List<EvidenceCategoryDTO> evidenceCategoryDTOS = evidenceCategoryService.listCategoryTree(caseType);

        initCaseEvidenceDirectory(evidenceCategoryDTOS, caseId, null);
    }

    @Override
    public Boolean updateDirectory(EvidenceDirectory evidenceDirectory) {

        Assert.notEmpty(evidenceDirectory.getId(),"目录ID不能为空!");

        Assert.notEmpty(evidenceDirectory.getParentId(),"父级目录id不能为空");

        return evidenceDirectoryService.lambdaUpdate()
                .set(EvidenceDirectory::getParentId, evidenceDirectory.getParentId())
                .eq(EvidenceDirectory::getId, evidenceDirectory.getId()).update();

    }

    @Override
    public Boolean moveFile(DirectoryFileDTO evidenceFileDTO) {

        Assert.notEmpty(evidenceFileDTO.getFileIdList(), "文件id不能为空");
        Assert.notEmpty(evidenceFileDTO.getCaseId(), "案件id不能为空");
        Assert.notEmpty(evidenceFileDTO.getDirectoryId(), "目录id不能为空");


        return evidenceFileService.lambdaUpdate()
                .set(EvidenceFile::getDirectoryId, evidenceFileDTO.getDirectoryId())
                .in(EvidenceFile::getFileId, evidenceFileDTO.getFileIdList())
                .update();
    }

    @Override
    public Boolean removeFile(DirectoryFileDTO evidenceFileDTO) {

        Assert.notEmpty(evidenceFileDTO.getFileIdList(), "文件id不能为空");
        Assert.notEmpty(evidenceFileDTO.getCaseId(), "案件id不能为空");

        return evidenceFileService.lambdaUpdate()
                .in(EvidenceFile::getFileId, evidenceFileDTO.getFileIdList())
                .remove();
    }

    @Override
    @Transactional(transactionManager = "dataSourceTransactionManager", rollbackFor = Exception.class)
    public Boolean removeDirectory(List<String> directoryIdList) {

        if (CollUtil.isEmpty(directoryIdList)){
            return false;
        }

        boolean success = evidenceDirectoryService.removeBatchByIds(directoryIdList);

        if (success){
            // 删除目录，意味着证据也要被删除
            super.lambdaUpdate().eq(CaseEvidence::getDirectoryId, directoryIdList).remove();
            evidenceFileService.lambdaUpdate().in(EvidenceFile::getDirectoryId, directoryIdList).remove();
        }
        return success;
    }

    /**
     * 提取证据信息
     * 1. 只对证据文件进行新增操作，不删除已有的文件
     * 2. 如果第三级目录下已经存在文件，只新增证据文件，对证据进行ocr识别但不对证据进行重新提取操作
     * @param caseId
     * @param evidenceFileDTOS 文件信息
     */
    @Override
    @Transactional(transactionManager = "dataSourceTransactionManager", rollbackFor = Exception.class)
    public String ocrAndExtract(String caseId, List<EvidenceDirectoryDTO> evidenceFileDTOS) {

        List<CaseEvidenceDetailDTO> oldEvidences = this.queryEvidenceList(caseId);
        List<EvidenceDirectoryDTO> evidenceDirectoryDTOS = listFileTree(caseId);

        List<CaseEvidenceDetailDTO> newEvidences = toCaseCaseEvidenceDetailDTO(evidenceFileDTOS, evidenceDirectoryDTOS);
        newEvidences.forEach(caseEvidenceDetailDTO -> caseEvidenceDetailDTO.setCaseId(caseId));

        List<CaseEvidenceDetailDTO> operationalEvidence = findChangedEvidence(oldEvidences, newEvidences);

        String batchId = updateCaseEvidence(operationalEvidence);


        for (CaseEvidenceDetailDTO caseEvidenceDetailDTO : operationalEvidence) {
            if (StrUtil.equalsAny(caseEvidenceDetailDTO.getUpdateStatus(),"-1","0")){
                // 只需要识别即可
                fileOcrProcessService.syncSubmitOCR(List.of(caseEvidenceDetailDTO.getId()));
                // todo:是否需要提取标题
            }
            if (StrUtil.equals(caseEvidenceDetailDTO.getUpdateStatus(),"1")){
                // 需要分析（ocr识别+标题提取）
                xxlJobService.executeTaskByJobHandler("evidenceAnalysis", caseEvidenceDetailDTO.getId());
            }

        }
        return batchId;

    }

    @Override
    @Transactional(transactionManager = "dataSourceTransactionManager",propagation = Propagation.REQUIRES_NEW, rollbackFor = Exception.class)
    public String updateCaseEvidence(List<CaseEvidenceDetailDTO> caseEvidenceDetailDTOList) {

        String batchNo = DateTime.now().toString("yyyyMMddHHmmss");
        for (CaseEvidenceDetailDTO evidence : caseEvidenceDetailDTOList) {
            if (evidence.getUpdateStatus().equals("1")){
                // 新增
                CaseEvidence caseEvidence = evidence.toCaseEvidence();
                caseEvidence.setProcessStatus(EvidenceConstants.PROCESS_STATUS_UNPROCESSED);
                this.save(caseEvidence);
                for (EvidenceFileDTO evidenceFileDTO : evidence.getFileList()) {
                    if (evidenceFileDTO.getUpdateStatus().equals("1")){
                        // 新增
                        EvidenceFile evidenceFile = new EvidenceFile(caseEvidence.getId(), evidenceFileDTO.getFileId());
                        evidenceFile.setDirectoryId(evidence.getDirectoryId());
                        evidenceFile.setRank(evidenceFileDTO.getRank());
                        evidenceFile.setBatchNo(batchNo);
                        evidenceFileService.save(evidenceFile);
                    }/*else if (evidenceFileDTO.getUpdateStatus().equals("0")){
                        // 删除
                        evidenceFileService.lambdaUpdate()
                                .eq(EvidenceFile::getEvidenceId, evidenceFileDTO.getEvidenceId())
                                .eq(EvidenceFile::getFileId, evidenceFileDTO.getFileId()).remove();
                    }else if (evidenceFileDTO.getUpdateStatus().equals("2")){
                        evidenceFileService.lambdaUpdate()
                                .set(EvidenceFile::getRank, evidenceFileDTO.getRank())
                                .update();
                    }*/
                }

            }/*else if (evidence.getUpdateStatus().equals("0")){
                // 删除
                this.removeById(evidence.getId());
                evidenceFileService.lambdaUpdate().eq(EvidenceFile::getEvidenceId, evidence.getId()).remove();
            }*/

        }
        return batchNo;
    }

    @Override
    public List<EvidenceProcessDTO> listOcrAndExtract(String caseId,String batchNo) {
        Assert.notEmpty(caseId, "案件id不能为空");
        ModelCase modelCase = modelCaseService.getById(caseId);
        Assert.notNull(modelCase, "案件不存在");

        List<CaseEvidenceDetailDTO> caseEvidenceDetailDTOS = this.queryEvidenceList(caseId,batchNo);

        if (CollUtil.isEmpty(caseEvidenceDetailDTOS)){
            return new ArrayList<>();
        }
        List<EvidenceProcessDTO> processDTOList = caseEvidenceDetailDTOS.stream().map(EvidenceProcessDTO::new).collect(Collectors.toList());
        List<EvidenceDirectoryDTO> evidenceDirectoryDTOS = evidenceDirectoryService.listDirectoryTree(caseId);
        List<EvidenceCategory> categoryList = evidenceCategoryService.lambdaQuery().eq(EvidenceCategory::getCaseType, modelCase.getCaseType()).list();

        for (EvidenceProcessDTO evidenceProcessDTO : processDTOList) {
            evidenceProcessDTO.setTemplateInfo(evidenceDirectoryDTOS, categoryList);
        }
        return processDTOList;
    }

    @Override
    public void verifyEvidence(List<EvidenceVerifyDTO> evidenceVerifyDTOS,String caseId,String batchNo) {
        Assert.notEmpty(caseId, "案件id不能为空");
        if (CollUtil.isEmpty(evidenceVerifyDTOS)){
            return;
        }
        List<CaseEvidenceDetailDTO> caseEvidenceDetailDTOS = queryEvidenceList(caseId,batchNo);
        Map<String, List<EvidenceVerifyDTO>> evidenceMap = evidenceVerifyDTOS.stream().collect(Collectors.groupingBy(EvidenceVerifyDTO::getEvidenceId));
        for (Map.Entry<String, List<EvidenceVerifyDTO>> entry : evidenceMap.entrySet()) {
            String evidenceId = entry.getKey();
            List<EvidenceVerifyDTO> value = entry.getValue();

            // 更新证据属性
            this.lambdaUpdate().eq(CaseEvidence::getId, evidenceId).set(CaseEvidence::getProperty, CollUtil.getFirst(value).getProperties());

            // 修改ocr内容
            for (EvidenceVerifyDTO verifyDTO : value) {
                if (StrUtil.isNotEmpty(verifyDTO.getOcrText())){
                    fileOcrProcessService.lambdaUpdate()
                            .eq(FileOcrProcess::getFileId, verifyDTO.getFileId())
                            .set(FileOcrProcess::getReviseText, verifyDTO.getOcrText()).update();
                }
            }
            // 调整顺序
            CaseEvidenceDetailDTO evidenceDetail = findEvidenceDetail(evidenceId, caseEvidenceDetailDTOS);
            if (evidenceDetail != null){
                List<String> list = value.stream().map(EvidenceVerifyDTO::getFileId).toList();
                for (EvidenceFileDTO evidenceFileDTO : evidenceDetail.getFileList()) {
                    evidenceFileDTO.setRank(findRank(list, evidenceFileDTO.getFileId()));
                    evidenceFileService.lambdaUpdate().eq(EvidenceFile::getFileId, evidenceFileDTO.getFileId())
                            .eq(EvidenceFile::getEvidenceId, evidenceFileDTO.getEvidenceId())
                            .set(EvidenceFile::getRank, evidenceFileDTO.getRank()).update();
                }
            }

        }
    }

    @Override
    public List<EvidenceDirectoryDTO> evidenceDetails(String caseId, String batchNo) {
        List<EvidenceDirectoryDTO> evidenceDirectoryDTOS = listFileTree(caseId);

        List<CaseEvidence> caseEvidenceList = this.lambdaQuery().eq(CaseEvidence::getCaseId, caseId).list();
        List<CategoryPromptDTO> categoryPromptDTOS = evidenceDirectoryService.listCategoryPrompt(caseId);

        Map<String, CaseEvidence> caseEvidenceMap = caseEvidenceList.stream().collect(Collectors.toMap(CaseEvidence::getId, Function.identity()));
        Map<String, CategoryPromptDTO> categoryPromptMap = categoryPromptDTOS.stream().collect(Collectors.toMap(CategoryPromptDTO::getDirectoryId, Function.identity()));
        for (EvidenceDirectoryDTO evidenceDirectoryDTO : evidenceDirectoryDTOS) {
            if (CollUtil.isEmpty(evidenceDirectoryDTO.getFileInfoList())){
                continue;
            }
            for (EvidenceFileDTO evidenceFileDTO : evidenceDirectoryDTO.getFileInfoList()) {
                evidenceFileDTO.setPrompt(categoryPromptMap.get(evidenceFileDTO.getDirectoryId()));
                evidenceFileDTO.setEvidenceInfo(caseEvidenceMap.get(evidenceFileDTO.getEvidenceId()));
            }
        }
        return evidenceDirectoryDTOS;
    }

    @Override
    public String generateDirectoryName(String caseId, String categoryId, String provider) {
        Assert.notEmpty(caseId, "案件id不能为空");
        Assert.notEmpty(categoryId, "目录id不能为空");
        Assert.notEmpty(provider, "提供方不能为空");

        EvidenceCategory category = evidenceCategoryService.getById(categoryId);
        Assert.notNull(category, "目录不存在");

        List<EvidenceDirectory> directoryList = evidenceDirectoryService.lambdaQuery()
                .eq(EvidenceDirectory::getCaseId, caseId)
                .eq(EvidenceDirectory::getCategoryId, categoryId).list();

        String directoryName = category.getCategoryName() + provider;
        long count = directoryList.stream().filter(d -> StrUtil.contains(d.getDirectoryName(), provider)).count();
        if (count > 0){
            directoryName = directoryName + count;
        }
        return directoryName;
    }

    @Override
    public EvidenceDirectory createDirectory(EvidenceDirectoryReqVO evidenceDirectory) {

        List<EvidenceDirectoryDTO> evidenceDirectoryDTOS = listDirectoryTree(evidenceDirectory.getCaseId());
        List<String> directoryIdList = null;
        for (EvidenceDirectoryDTO evidenceDirectoryDTO : evidenceDirectoryDTOS) {
            directoryIdList = evidenceDirectoryDTO.findDirectoryIdList(evidenceDirectory.getCategoryId());
            if (CollUtil.isNotEmpty(directoryIdList)){
                break;
            }
        }
        Assert.notEmpty(directoryIdList, "目录分类不存在");
        EvidenceDirectoryDTO directory = null;
        for (EvidenceDirectoryDTO evidenceDirectoryDTO : evidenceDirectoryDTOS) {
            directory = evidenceDirectoryDTO.findDirectory(CollUtil.getFirst(directoryIdList));
            if (null != directory){
                break;
            }
        }
        Assert.notNull(directory, "目录不存在");

        long count = evidenceDirectoryService.lambdaQuery().eq(EvidenceDirectory::getParentId, directory.getId())
                .list().stream()
                .filter(d -> StrUtil.contains(d.getDirectoryName(), evidenceDirectory.getDirectoryName())).count();
        if (count > 0){
            evidenceDirectory.setDirectoryName(evidenceDirectory.getDirectoryName() + count + 1);
        }

        EvidenceDirectory directory1 = new EvidenceDirectory();
        directory1.setCaseId(evidenceDirectory.getCaseId());
        directory1.setCategoryId(evidenceDirectory.getCategoryId());
        directory1.setDirectoryName(evidenceDirectory.getDirectoryName());
        directory1.setParentId(directory.getId());
        evidenceDirectoryService.save(directory1);
        return directory1;
    }


    private CaseEvidenceDetailDTO findEvidenceDetail(String evidenceId, List<CaseEvidenceDetailDTO> caseEvidenceDetailDTOS) {
        for (CaseEvidenceDetailDTO caseEvidenceDetailDTO : caseEvidenceDetailDTOS) {
            if (StrUtil.equals(caseEvidenceDetailDTO.getId(), evidenceId)){
                return caseEvidenceDetailDTO;
            }
        }
        return null;
    }

    private List<CaseEvidenceDetailDTO> toCaseCaseEvidenceDetailDTO(List<EvidenceDirectoryDTO> newDirectoryDTOS,
                                                                  List<EvidenceDirectoryDTO> evidenceDirectoryDTOS) {
        if (CollUtil.isEmpty(newDirectoryDTOS)){
            return new ArrayList<>();
        }

        List<String> fileIdList = newDirectoryDTOS.stream().flatMap(directoryDTO -> directoryDTO.listAllFileId().stream()).toList();
        Map<String, MinioFile> fileMap = minioService.listMinioFile(fileIdList).stream()
                .collect(Collectors.toMap(MinioFile::getId, Function.identity()));

        List<EvidenceDirectoryDTO> floatNewDirectoryDTOS = newDirectoryDTOS.stream().flatMap(directoryDTO -> directoryDTO.listAllDirectory().stream()).toList();
        List<CaseEvidenceDetailDTO> caseEvidenceDetailDTOS = new ArrayList<>();
        for (EvidenceDirectoryDTO evidenceFile : floatNewDirectoryDTOS) {

            String directoryId = evidenceFile.getId();
            EvidenceDirectoryDTO directory = evidenceDirectoryService.findDirectoryById(directoryId, evidenceDirectoryDTOS);
            if (null == directory){
                log.warn("toCaseCaseEvidenceDetailDTO:目录id：{}不存在对应的目录分类信息",directoryId);
                continue;
            }

            if (directory.getLevel() == 2){
                for (String fileId : evidenceFile.getFileIdList()) {
                    CaseEvidenceDetailDTO caseEvidenceDetailDTO = new CaseEvidenceDetailDTO();
                    if (null != fileMap.get(fileId)){
                        // 证据名为文件名
                        caseEvidenceDetailDTO.setEvidenceName(fileMap.get(fileId).getFilename());
                    }
                    caseEvidenceDetailDTO.setEvidenceType(directory.getCategoryId());
                    caseEvidenceDetailDTO.setDirectoryId(directoryId);
                    EvidenceFileDTO evidenceFileDTO = new EvidenceFileDTO();
                    evidenceFileDTO.setFileId(fileId);
                    caseEvidenceDetailDTO.setFileList(List.of(evidenceFileDTO));
                    caseEvidenceDetailDTOS.add(caseEvidenceDetailDTO);
                }
            }
            if (directory.getLevel() == 3){
                CaseEvidenceDetailDTO caseEvidenceDetailDTO = new CaseEvidenceDetailDTO();
                // 证据名为目录名
                caseEvidenceDetailDTO.setEvidenceName(evidenceFile.getDirectoryName());
                caseEvidenceDetailDTO.setEvidenceType(directory.getCategoryId());
                caseEvidenceDetailDTO.setDirectoryId(directoryId);
                List<EvidenceFileDTO> evidenceFileDTOS = new ArrayList<>();
                for (String fileId : evidenceFile.getFileIdList()) {
                    EvidenceFileDTO evidenceFileDTO = new EvidenceFileDTO();
                    evidenceFileDTO.setFileId(fileId);
                    evidenceFileDTOS.add(evidenceFileDTO);
                }
                caseEvidenceDetailDTO.setFileList(evidenceFileDTOS);
                caseEvidenceDetailDTOS.add(caseEvidenceDetailDTO);
            }
        }

        return caseEvidenceDetailDTOS;

    }

    /**
     * 查找发生改变的证据
     * @param oldEvidenceList 旧证据列表
     * @param newEvidenceFileList 新证据列表
     * @return 发生改变的证据
     */
    private List<CaseEvidenceDetailDTO> findChangedEvidence(List<CaseEvidenceDetailDTO> oldEvidenceList,
                                                            List<CaseEvidenceDetailDTO> newEvidenceFileList) {

        List<CaseEvidenceDetailDTO> caseEvidence2DTOList = new ArrayList<>();

        if (CollUtil.isEmpty(oldEvidenceList) && CollUtil.isNotEmpty(newEvidenceFileList)){
            // 数据库中不存在数据，则全部新增
            for (CaseEvidenceDetailDTO evidenceDetailDTO : newEvidenceFileList) {
                List<String> fileIds = evidenceDetailDTO.getFileList().stream().map(EvidenceFileDTO::getFileId).toList();
                evidenceDetailDTO.setUpdateStatus("1");
                for (EvidenceFileDTO evidenceFileDTO : evidenceDetailDTO.getFileList()) {
                    evidenceFileDTO.setUpdateStatus("1");
                    evidenceFileDTO.setRank(findRank(fileIds,evidenceFileDTO.getFileId()));
                }
            }
            caseEvidence2DTOList.addAll(newEvidenceFileList);
        }

        if (CollUtil.isNotEmpty(oldEvidenceList) && CollUtil.isEmpty(newEvidenceFileList)){
            // 数据库中存在数据，没有新增数据
            for (CaseEvidenceDetailDTO evidenceDetailDTO : oldEvidenceList) {
                evidenceDetailDTO.setUpdateStatus("0");
                for (EvidenceFileDTO evidenceFileDTO : evidenceDetailDTO.getFileList()) {
                    evidenceFileDTO.setUpdateStatus("0");
                }
            }
            caseEvidence2DTOList.addAll(oldEvidenceList);
        }


        if (CollUtil.isNotEmpty(oldEvidenceList) && CollUtil.isNotEmpty(newEvidenceFileList)){
            // 数据库中和新数据都存在
            for (CaseEvidenceDetailDTO oldEvidence : oldEvidenceList) {
                boolean isFind = false;
                for (CaseEvidenceDetailDTO newEvidence : newEvidenceFileList) {
                    if (StrUtil.equals(oldEvidence.getId(),newEvidence.getId())){
                        isFind = true;
                        oldEvidence.setUpdateStatus("-1");
                        List<String> oldFileIds = oldEvidence.getFileList().stream().map(EvidenceFileDTO::getFileId).toList();
                        List<String> newFileIds = newEvidence.getFileList().stream().map(EvidenceFileDTO::getFileId).toList();
                        TupleIdRecord tupleIdRecord = compareFileList(oldFileIds, newFileIds);

                        List<EvidenceFileDTO> updateFileList = new ArrayList<>();
                        // 新增的文件顺序排在原有文件的后面
                        int initOrder = oldFileIds.size() -1;
                        for (String addFileId : tupleIdRecord.addFileList) {
                            EvidenceFileDTO evidenceFileDTO = new EvidenceFileDTO();
                            evidenceFileDTO.setFileId(addFileId);
                            evidenceFileDTO.setUpdateStatus("1");
                            evidenceFileDTO.setRank(initOrder + findRank(newFileIds, addFileId));
                            updateFileList.add(evidenceFileDTO);
                        }
                        for (String deleteFileId : tupleIdRecord.deleteFileList) {
                            EvidenceFileDTO evidenceFileDTO = new EvidenceFileDTO();
                            evidenceFileDTO.setFileId(deleteFileId);
                            evidenceFileDTO.setUpdateStatus("0");
                            evidenceFileDTO.setRank(findRank(oldFileIds, deleteFileId));
                            updateFileList.add(evidenceFileDTO);
                        }

                        for (String updateFileId : tupleIdRecord.updateFileList) {
                            EvidenceFileDTO evidenceFileDTO = new EvidenceFileDTO();
                            evidenceFileDTO.setFileId(updateFileId);
                            evidenceFileDTO.setUpdateStatus("2");
                            evidenceFileDTO.setRank(findRank(oldFileIds, updateFileId));
                            updateFileList.add(evidenceFileDTO);
                        }

                        newEvidence.setFileList(updateFileList);
                        caseEvidence2DTOList.add(newEvidence);
                    }
                }
                if (!isFind){
                    oldEvidence.setUpdateStatus("0");
                    caseEvidence2DTOList.add(oldEvidence);
                }
            }


            for (CaseEvidenceDetailDTO newEvidence : newEvidenceFileList) {
                if (StrUtil.isEmpty(newEvidence.getId())){
                    newEvidence.setUpdateStatus("1");
                    List<String> newFileIds = newEvidence.getFileList().stream().map(EvidenceFileDTO::getFileId).toList();
                    for (EvidenceFileDTO evidenceFileDTO : newEvidence.getFileList()) {
                        evidenceFileDTO.setUpdateStatus("1");
                        evidenceFileDTO.setRank(findRank(newFileIds, evidenceFileDTO.getFileId()));
                    }
                    caseEvidence2DTOList.add(newEvidence);
                }
            }
        }

        return caseEvidence2DTOList;
    }

    private int findRank(List<String> newFileIds,String fileId){
        for (int i = 0; i < newFileIds.size(); i++) {
            if (newFileIds.get(i).equals(fileId)){
                return i;
            }
        }
        return -1;
    }




    /**
     * 初始化案件证据目录
     * @param evidenceCategoryDTOS 证据分类
     * @param caseId 案件id
     * @param parentId 父级目录id
     */
   private void initCaseEvidenceDirectory(List<EvidenceCategoryDTO> evidenceCategoryDTOS, String caseId, String parentId) {
        for (EvidenceCategoryDTO evidenceCategoryDTO : evidenceCategoryDTOS) {
            EvidenceDirectory evidenceDirectory = new EvidenceDirectory();
            evidenceDirectory.setCaseId(caseId);
            evidenceDirectory.setDirectoryName(evidenceCategoryDTO.getCategoryName());
            evidenceDirectory.setCategoryId(evidenceCategoryDTO.getId());
            evidenceDirectory.setParentId(parentId);
            evidenceDirectoryService.save(evidenceDirectory);
            if (CollUtil.isNotEmpty(evidenceCategoryDTO.getChild())) {
                initCaseEvidenceDirectory(evidenceCategoryDTO.getChild(), caseId, evidenceDirectory.getId());
            }
        }
    }



    /**
     * left 新增 right 删除
     * @param newFileIdList
     * @param oldFileIdList
     * @return
     */
    private TupleIdRecord compareFileList(List<String> newFileIdList, List<String> oldFileIdList) {
        List<String> addFileList = new ArrayList<>();
        List<String> deleteFileList = new ArrayList<>();
        List<String> updateFileList = new ArrayList<>();

        if (CollUtil.isEmpty(oldFileIdList) && CollUtil.isNotEmpty(newFileIdList)){
            addFileList = newFileIdList;
        }

        if (CollUtil.isNotEmpty(oldFileIdList) && CollUtil.isEmpty(newFileIdList)){
            deleteFileList = oldFileIdList;
        }

        if (CollUtil.isNotEmpty(oldFileIdList) && CollUtil.isNotEmpty(newFileIdList)){
            deleteFileList = oldFileIdList.stream().filter(fileId -> !newFileIdList.contains(fileId)).collect(Collectors.toList());
            addFileList = newFileIdList.stream().filter(fileId -> !oldFileIdList.contains(fileId)).collect(Collectors.toList());
            updateFileList =  oldFileIdList.stream().filter(newFileIdList::contains).collect(Collectors.toList());
        }

        return new TupleIdRecord(addFileList,updateFileList, deleteFileList);
    }


    record TupleIdRecord(List<String> addFileList ,List<String> updateFileList, List<String> deleteFileList){}

}