package cn.huge.module.cases.service.impl;

import cn.huge.base.common.utils.DateUtils;
import cn.huge.module.cases.domain.dto.CaseUpdateDTO;
import cn.huge.module.cases.domain.dto.CaseWindupApplyDTO;
import cn.huge.module.cases.domain.dto.FileRelateDTO;
import cn.huge.module.cases.domain.po.*;
import cn.huge.module.cases.service.*;
import cn.huge.module.client.api.UtilsClient;
import cn.huge.module.client.api.impl.CustClientImpl;
import cn.huge.module.client.api.impl.SysClientImpl;
import cn.huge.module.cust.dto.CtUnitDTO;
import cn.huge.module.cust.dto.CtUserDTO;
import cn.huge.module.sys.dto.FileIdTypeInfoBaseDTO;
import cn.huge.module.sys.dto.FileInfoBaseDTO;
import cn.huge.module.sys.dto.FileTypeInfoBaseDTO;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
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.Transactional;

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

/**
 * 案件修改业务服务实现类
 *
 * @author trae
 * @since 2024-02-14
 */
@Service
@Transactional(rollbackFor = Exception.class)
public class CaseModifyServiceImpl implements ICaseModifyService {

    @Autowired
    private CasePersonService casePersonService;

    @Autowired
    private CaseAgentService caseAgentService;

    @Autowired
    private CaseFeedbackService caseFeedbackService;

    @Autowired
    private CaseWindupApplyService caseWindupApplyService;
    @Autowired
    private CaseInfoUnfoldService caseInfoUnfoldService;

    @Autowired
    private ICaseModifyRecordService caseModifyRecordService;

    @Autowired
    private CaseInfoService caseInfoService;
    @Autowired
    private CustClientImpl custClient;
    @Autowired
    private SysClientImpl sysClient;
    @Autowired
    private UtilsClient utilsClient;


    @Override
    public void updateCase(CaseUpdateDTO caseUpdateDTO, String userId) {
        String caseId = caseUpdateDTO.getId();
        CtUserDTO loginUser = custClient.clientGetUserAll(userId);
        CtUnitDTO unitById = custClient.getUnitById(loginUser.getUnitId());
        if (unitById != null) {
            loginUser.setUnitName(unitById.getUnitName());
        }
        Date nowTime = new Date();
        String now = DateUtils.dateToString2(nowTime);
        // 0. 处理纠纷基本情况变更
        CaseInfo existingCase = caseInfoService.getById(caseId);
        CaseInfo newCase = caseUpdateDTO;
        newCase.setUpdateTime(nowTime);
        if (existingCase != null && newCase != null) {
            // 比较案件等级
            boolean hasChanged = false;
            if (!Objects.equals(existingCase.getCaseLevel(), newCase.getCaseLevel())) {
                CaseModifyRecord record = new CaseModifyRecord();
                record.setCaseId(caseId);
                record.setModifyType("修改");
                record.setModifyAttribute("纠纷基本情况");
                record.setModifyItem("案件等级");
                record.setBeforeContent(String.valueOf(existingCase.getCaseLevel()));
                record.setAfterContent(String.valueOf(newCase.getCaseLevel()));
                record.setModifyTime(now);
                record.setCaseId(caseId);
                record.setModifyUser(loginUser.getUnitName() + " " + loginUser.getTrueName());
                caseModifyRecordService.insertCaseModifyRecord(record);
                hasChanged = true;
            }

            // 比较走访时间
            if (!Objects.equals(existingCase.getVisitTime(), newCase.getVisitTime())) {
                CaseModifyRecord record = new CaseModifyRecord();
                record.setCaseId(caseId);
                record.setModifyType("修改");
                record.setModifyAttribute("纠纷基本情况");
                record.setModifyItem("来访时间");
                record.setBeforeContent(existingCase.getVisitTime() != null ? existingCase.getVisitTime().toString() : null);
                record.setAfterContent(newCase.getVisitTime() != null ? newCase.getVisitTime().toString() : null);
                record.setModifyTime(now);
                record.setCaseId(caseId);
                record.setModifyUser(loginUser.getUnitName() + " " + loginUser.getTrueName());
                caseModifyRecordService.insertCaseModifyRecord(record);
                hasChanged = true;
            }

            // 比较发生时间
            if (!Objects.equals(existingCase.getOccurTime(), newCase.getOccurTime())) {
                CaseModifyRecord record = new CaseModifyRecord();
                record.setCaseId(caseId);
                record.setModifyType("修改");
                record.setModifyAttribute("纠纷基本情况");
                record.setModifyItem("发生时间");
                record.setBeforeContent(existingCase.getOccurTime() != null ? existingCase.getOccurTime().toString() : null);
                record.setAfterContent(newCase.getOccurTime() != null ? newCase.getOccurTime().toString() : null);
                record.setModifyTime(now);
                record.setCaseId(caseId);
                record.setModifyUser(loginUser.getUnitName() + " " + loginUser.getTrueName());
                caseModifyRecordService.insertCaseModifyRecord(record);
                hasChanged = true;
            }

            // 比较走访人数
            if (!Objects.equals(existingCase.getVisitPeopleNum(), newCase.getVisitPeopleNum())) {
                CaseModifyRecord record = new CaseModifyRecord();
                record.setCaseId(caseId);
                record.setModifyType("修改");
                record.setModifyAttribute("纠纷基本情况");
                record.setModifyItem("来访人数");
                record.setBeforeContent(String.valueOf(existingCase.getVisitPeopleNum()));
                record.setAfterContent(String.valueOf(newCase.getVisitPeopleNum()));
                record.setModifyTime(now);
                record.setCaseId(caseId);
                record.setModifyUser(loginUser.getUnitName() + " " + loginUser.getTrueName());
                caseModifyRecordService.insertCaseModifyRecord(record);
                hasChanged = true;
            }

            // 比较案件类型
            if (!Objects.equals(existingCase.getCaseType(), newCase.getCaseType())) {
                CaseModifyRecord record = new CaseModifyRecord();
                record.setCaseId(caseId);
                record.setModifyType("修改");
                record.setModifyAttribute("纠纷基本情况");
                record.setModifyItem("案件类型");
                record.setBeforeContent(existingCase.getCaseTypeName());
                record.setAfterContent(newCase.getCaseTypeName());
                record.setModifyTime(now);
                record.setCaseId(caseId);
                record.setModifyUser(loginUser.getUnitName() + " " + loginUser.getTrueName());
                caseModifyRecordService.insertCaseModifyRecord(record);
                hasChanged = true;
            }

            // 比较地址
            if (!Objects.equals(existingCase.getAddr(), newCase.getAddr())) {
                CaseModifyRecord record = new CaseModifyRecord();
                record.setCaseId(caseId);
                record.setModifyType("修改");
                record.setModifyAttribute("纠纷基本情况");
                record.setModifyItem("地址");
                record.setBeforeContent(existingCase.getAddr());
                record.setAfterContent(newCase.getAddr());
                record.setModifyTime(now);
                record.setCaseId(caseId);
                record.setModifyUser(loginUser.getUnitName() + " " + loginUser.getTrueName());
                caseModifyRecordService.insertCaseModifyRecord(record);
                hasChanged = true;
            }

            // 比较问题属地街道
            if (!Objects.equals(existingCase.getQueRoad(), newCase.getQueRoad())) {
                CaseModifyRecord record = new CaseModifyRecord();
                record.setCaseId(caseId);
                record.setModifyType("修改");
                record.setModifyAttribute("纠纷基本情况");
                record.setModifyItem("问题属地街道");
                record.setBeforeContent(existingCase.getQueRoadName());
                record.setAfterContent(newCase.getQueRoadName());
                record.setModifyTime(now);
                record.setCaseId(caseId);
                record.setModifyUser(loginUser.getUnitName() + " " + loginUser.getTrueName());
                caseModifyRecordService.insertCaseModifyRecord(record);
                hasChanged = true;
            }

            // 比较事项概况
            if (!Objects.equals(existingCase.getCaseDes(), newCase.getCaseDes())) {
                CaseModifyRecord record = new CaseModifyRecord();
                record.setCaseId(caseId);
                record.setModifyType("修改");
                record.setModifyAttribute("纠纷基本情况");
                record.setModifyItem("事项概况");
                record.setBeforeContent(existingCase.getCaseDes());
                record.setAfterContent(newCase.getCaseDes());
                record.setModifyTime(now);
                record.setCaseId(caseId);
                record.setModifyUser(loginUser.getUnitName() + " " + loginUser.getTrueName());
                caseModifyRecordService.insertCaseModifyRecord(record);
                hasChanged = true;
            }

            // 比较事项申请
            if (!Objects.equals(existingCase.getCaseClaim(), newCase.getCaseClaim())) {
                CaseModifyRecord record = new CaseModifyRecord();
                record.setCaseId(caseId);
                record.setModifyType("修改");
                record.setModifyAttribute("纠纷基本情况");
                record.setModifyItem("事项申请");
                record.setBeforeContent(existingCase.getCaseClaim());
                record.setAfterContent(newCase.getCaseClaim());
                record.setModifyTime(now);
                record.setCaseId(caseId);
                record.setModifyUser(loginUser.getUnitName() + " " + loginUser.getTrueName());
                caseModifyRecordService.insertCaseModifyRecord(record);
                hasChanged = true;
            }

            // 比较涉及人数
            if (!Objects.equals(existingCase.getPeopleNum(), newCase.getPeopleNum())) {
                CaseModifyRecord record = new CaseModifyRecord();
                record.setCaseId(caseId);
                record.setModifyType("修改");
                record.setModifyAttribute("纠纷基本情况");
                record.setModifyItem("涉及人数");
                record.setBeforeContent(String.valueOf(existingCase.getPeopleNum()));
                record.setAfterContent(String.valueOf(newCase.getPeopleNum()));
                record.setModifyTime(now);
                record.setCaseId(caseId);
                record.setModifyUser(loginUser.getUnitName() + " " + loginUser.getTrueName());
                caseModifyRecordService.insertCaseModifyRecord(record);
                hasChanged = true;
            }

            // 比较涉及金额
            if (!Objects.equals(existingCase.getAmount(), newCase.getAmount())) {
                CaseModifyRecord record = new CaseModifyRecord();
                record.setCaseId(caseId);
                record.setModifyType("修改");
                record.setModifyAttribute("纠纷基本情况");
                record.setModifyItem("涉及金额");
                record.setBeforeContent(String.valueOf(existingCase.getAmount()));
                record.setAfterContent(String.valueOf(newCase.getAmount()));
                record.setModifyTime(now);
                record.setCaseId(caseId);
                record.setModifyUser(loginUser.getUnitName() + " " + loginUser.getTrueName());
                caseModifyRecordService.insertCaseModifyRecord(record);
                hasChanged = true;
            }
            if (hasChanged)
                caseInfoService.updateCaseInfo(newCase);
        }

        // 1. 处理当事人信息变更
        List<CasePerson> existingPersons = casePersonService.list(
                new LambdaQueryWrapper<CasePerson>().eq(CasePerson::getCaseId, caseId)
        );
        List<CasePerson> newPersons = caseUpdateDTO.getPersonList();

        // 1.1 处理新增的当事人
        if (newPersons != null) {
            if(existingPersons==null){
                existingPersons = new ArrayList<>();
            }
            List<String> existingIds = existingPersons.stream()
                    .map(CasePerson::getId)
                    .collect(Collectors.toList());
            newPersons.stream()
                    .filter(person -> !existingIds.contains(person.getId()))
                    .forEach(person -> {
                        CaseModifyRecord record = new CaseModifyRecord();
                        record.setModifyType("添加");
                        record.setModifyAttribute("当事人信息");
                        record.setModifyItem(person.getPerTypeName());
                        record.setBeforeContent(null);
                        record.setAfterContent(String.format("姓名：%s, 联系方式：%s, 身份证号码：%s",
                                person.getTrueName(), person.getMobile(), person.getCertiNo()));
                        record.setModifyTime(now);
                        record.setCaseId(caseId);
                        record.setCaseId(caseId);
                        record.setModifyUser(loginUser.getUnitName() + " " + loginUser.getTrueName());
                        caseModifyRecordService.insertCaseModifyRecord(record);
                        person.setCaseId(caseId);
                        person.setCustId(loginUser.getId());
                        person.setCreateTime(nowTime);
                        person.setUpdateTime(nowTime);
                        casePersonService.save(person);
                        if ("15_020008-1".equals(person.getPerType())) {
                            if (StringUtils.isNotEmpty(newCase.getPlaintiffs())) {
                                newCase.setPlaintiffs(newCase.getPlaintiffs() + "," + person.getTrueName());
                            } else {
                                newCase.setPlaintiffs(person.getTrueName());
                            }
                            caseInfoService.updateCaseInfo(newCase);
                        }
                        if ("15_020008-2".equals(person.getPerType())) {
                            if (StringUtils.isNotEmpty(newCase.getDefendants())) {
                                newCase.setDefendants(newCase.getDefendants() + "," + person.getTrueName());
                            } else {
                                newCase.setDefendants(person.getTrueName());
                            }
                            caseInfoService.updateCaseInfo(newCase);
                        }
                    });
        }

        // 1.2 处理删除的当事人
        if (existingPersons!=null&&existingPersons.size()>0) {
            if(newPersons==null){
                newPersons = new ArrayList<>();
            }
            List<String> newIds = newPersons.stream()
                    .map(CasePerson::getId)
                    .collect(Collectors.toList());
            existingPersons.stream()
                    .filter(person -> !newIds.contains(person.getId()))
                    .forEach(person -> {
                        CaseModifyRecord record = new CaseModifyRecord();
                        record.setModifyType("删除");
                        record.setModifyAttribute("当事人信息");
                        record.setModifyItem(person.getPerTypeName());
                        record.setBeforeContent(String.format("姓名：%s, 联系方式：%s, 身份证号码：%s",
                                person.getTrueName(), person.getMobile(), person.getCertiNo()));
                        record.setAfterContent(null);
                        record.setModifyTime(now);
                        record.setCaseId(caseId);
                        record.setCaseId(caseId);
                        record.setModifyUser(loginUser.getUnitName() + " " + loginUser.getTrueName());
                        caseModifyRecordService.insertCaseModifyRecord(record);
                        casePersonService.deleteCasePerson(person.getId());
                    });
        }

        //1.3 处理当事人变化信息
        if (existingPersons != null && existingPersons.size() > 0 && newPersons != null && newPersons.size() > 0) {
            // 创建Map用于快速查找旧反馈信息
            Map<String, CasePerson> oldPersonMap = new HashMap<>();
            for (CasePerson item : existingPersons) {
                if (item.getId() != null) {
                    oldPersonMap.put(item.getId(), item);
                }
            }
            for (CasePerson newPerson : newPersons) {
                if (newPerson.getId() == null) {
                    continue;
                }
                // 检查是否存在对应的旧反馈
                CasePerson oldPerson = oldPersonMap.get(newPerson.getId());
                if (oldPerson != null) {
                    if (!Objects.equals(oldPerson.getMobile(), newPerson.getMobile())) {
                        CaseModifyRecord record = new CaseModifyRecord();
                        record.setModifyType("修改");
                        record.setModifyAttribute("当事人信息");
                        record.setModifyItem(newPerson.getPerTypeName());
                        record.setBeforeContent(String.format("姓名：%s, 联系方式：%s, 身份证号码：%s,性別：%s",
                                newPerson.getTrueName(), newPerson.getMobile(), newPerson.getCertiNo(), newPerson.getSexName()));
                        record.setAfterContent(String.format("姓名：%s, 联系方式：%s, 身份证号码：%s,性別：%s",
                                newPerson.getTrueName(), newPerson.getMobile(), newPerson.getCertiNo(), newPerson.getSexName()));
                        record.setModifyTime(now);
                        record.setCaseId(caseId);
                        record.setModifyUser(loginUser.getUnitName() + " " + loginUser.getTrueName());
                        caseModifyRecordService.insertCaseModifyRecord(record);
                        newPerson.setUpdateTime(nowTime);
                        casePersonService.updateCasePerson(newPerson);
                    }
                    if (!Objects.equals(oldPerson.getCertiNo(), newPerson.getCertiNo())) {
                        CaseModifyRecord record = new CaseModifyRecord();
                        record.setModifyType("修改");
                        record.setModifyAttribute("当事人信息");
                        record.setModifyItem(newPerson.getPerTypeName());
                        record.setBeforeContent(String.format("姓名：%s, 联系方式：%s, 身份证号码：%s,性別：%s",
                                newPerson.getTrueName(), newPerson.getMobile(), newPerson.getCertiNo(), newPerson.getSexName()));
                        record.setAfterContent(String.format("姓名：%s, 联系方式：%s, 身份证号码：%s,性別：%s",
                                newPerson.getTrueName(), newPerson.getMobile(), newPerson.getCertiNo(), newPerson.getSexName()));
                        record.setModifyTime(now);
                        record.setCaseId(caseId);
                        record.setModifyUser(loginUser.getUnitName() + " " + loginUser.getTrueName());
                        caseModifyRecordService.insertCaseModifyRecord(record);
                        newPerson.setUpdateTime(nowTime);
                        casePersonService.updateCasePerson(newPerson);
                    }
                    if (!Objects.equals(oldPerson.getTrueName(), newPerson.getTrueName())) {
                        CaseModifyRecord record = new CaseModifyRecord();
                        record.setModifyType("修改");
                        record.setModifyAttribute("当事人信息");
                        record.setModifyItem(newPerson.getPerTypeName());
                        record.setBeforeContent(String.format("姓名：%s, 联系方式：%s, 身份证号码：%s,性別：%s",
                                oldPerson.getTrueName(), oldPerson.getMobile(), oldPerson.getCertiNo(), oldPerson.getSexName()));
                        record.setAfterContent(String.format("姓名：%s, 联系方式：%s, 身份证号码：%s,性別：%s",
                                newPerson.getTrueName(), newPerson.getMobile(), newPerson.getCertiNo(), newPerson.getSexName()));
                        record.setModifyTime(now);
                        record.setCaseId(caseId);
                        record.setModifyUser(loginUser.getUnitName() + " " + loginUser.getTrueName());
                        caseModifyRecordService.insertCaseModifyRecord(record);
                        newPerson.setUpdateTime(nowTime);
                        casePersonService.updateCasePerson(newPerson);
                        if ("15_020008-1".equals(newPerson.getPerType())) {
                            if (StringUtils.isNotEmpty(newCase.getPlaintiffs())) {
                                newCase.setPlaintiffs(newCase.getPlaintiffs() + "," + newPerson.getTrueName());
                            } else {
                                newCase.setPlaintiffs(newPerson.getTrueName());
                            }
                            caseInfoService.updateCaseInfo(newCase);
                        }
                        if ("15_020008-2".equals(newPerson.getPerType())) {
                            if (StringUtils.isNotEmpty(newCase.getDefendants())) {
                                newCase.setDefendants(newCase.getDefendants() + "," + newPerson.getTrueName());
                            } else {
                                newCase.setDefendants(newPerson.getTrueName());
                            }
                            caseInfoService.updateCaseInfo(newCase);
                        }
                    }
                    if (!Objects.equals(oldPerson.getSex(), newPerson.getSex())) {
                        CaseModifyRecord record = new CaseModifyRecord();
                        record.setModifyType("修改");
                        record.setModifyAttribute("当事人信息");
                        record.setModifyItem(newPerson.getPerTypeName());
                        record.setBeforeContent(String.format("姓名：%s, 联系方式：%s, 身份证号码：%s,性別：%s",
                                oldPerson.getTrueName(), oldPerson.getMobile(), oldPerson.getCertiNo(), oldPerson.getSexName()));
                        record.setAfterContent(String.format("姓名：%s, 联系方式：%s, 身份证号码：%s,性別：%s",
                                newPerson.getTrueName(), newPerson.getMobile(), newPerson.getCertiNo(), newPerson.getSexName()));
                        record.setModifyTime(now);
                        record.setCaseId(caseId);
                        record.setModifyUser(loginUser.getUnitName() + " " + loginUser.getTrueName());
                        caseModifyRecordService.insertCaseModifyRecord(record);
                        newPerson.setUpdateTime(nowTime);
                        casePersonService.updateCasePerson(newPerson);
                    }
                }
            }

        }

        // 2. 处理代理人信息变更
        List<CaseAgent> existingAgents = caseAgentService.list(
                new LambdaQueryWrapper<CaseAgent>().eq(CaseAgent::getCaseId, caseId)
        );
        List<CaseAgent> newAgents = caseUpdateDTO.getAgentList();

        // 2.1 处理新增的代理人
        if (newAgents != null && newAgents.size() > existingAgents.size()) {
            List<String> existingIds = existingAgents.stream()
                    .map(CaseAgent::getId)
                    .collect(Collectors.toList());

            newAgents.stream()
                    .filter(agent -> !existingIds.contains(agent.getId()))
                    .forEach(agent -> {
                        CaseModifyRecord record = new CaseModifyRecord();
                        record.setModifyType("添加");
                        record.setModifyAttribute("代理人信息");
                        record.setModifyItem(agent.getPerTypeName());
                        record.setBeforeContent(null);
                        record.setAfterContent(String.format("姓名：%s,联系方式：%s,身份证号码：%s",
                                agent.getTrueName(), agent.getMobile(), agent.getCertiNo()));
                        record.setModifyTime(now);
                        record.setCaseId(caseId);
                        record.setModifyUser(loginUser.getUnitName() + " " + loginUser.getTrueName());
                        caseModifyRecordService.saveCaseModifyRecord(record);
                        agent.setCaseId(caseId);
                        agent.setCustId(loginUser.getId());
                        agent.setCreateTime(nowTime);
                        agent.setUpdateTime(nowTime);
                        caseAgentService.save(agent);
                    });
        }

        // 2.2 处理删除的代理人
        if (existingAgents.size() > newAgents.size()) {
            List<String> newIds = newAgents.stream()
                    .map(CaseAgent::getId)
                    .collect(Collectors.toList());

            existingAgents.stream()
                    .filter(agent -> !newIds.contains(agent.getId()))
                    .forEach(agent -> {
                        CaseModifyRecord record = new CaseModifyRecord();
                        record.setModifyType("删除");
                        record.setModifyAttribute("代理人信息");
                        record.setModifyItem(agent.getPerTypeName());
                        record.setBeforeContent(String.format("姓名：%s,联系方式：%s,身份证号码：%s",
                                agent.getTrueName(), agent.getMobile(), agent.getCertiNo()));
                        record.setAfterContent(null);
                        record.setModifyTime(now);
                        record.setCaseId(caseId);
                        record.setModifyUser(loginUser.getUnitName() + " " + loginUser.getTrueName());
                        caseModifyRecordService.insertCaseModifyRecord(record);
                        caseAgentService.deleteCaseAgent(agent.getId());
                    });
        }

        // 3. 处理办理反馈信息变更
        handleFeedbackChanges(caseId, caseUpdateDTO, loginUser, now);
        // 4. 处理结案信息变更
        CaseWindupApply oldWindup = caseWindupApplyService.getOne(
                new LambdaQueryWrapper<CaseWindupApply>().eq(CaseWindupApply::getCaseId, caseId)
        );
        CaseWindupApplyDTO newWindup = caseUpdateDTO.getCaseWindupApply();
        List<FileInfoBaseDTO> oldFileInfoList = newWindup.getFileInfoBaseDTOList();
        if (oldWindup != null && newWindup != null) {
            CaseInfoUnfold caseInfoUnfold = caseInfoUnfoldService.getById(caseId);
            boolean hasChanged = false;
            // 比较协议内容
            if (!Objects.equals(oldWindup.getAgreeContent(), newWindup.getAgreeContent())) {
                CaseModifyRecord record = new CaseModifyRecord();
                record.setModifyType("修改");
                record.setModifyAttribute("办理结果");
                record.setModifyItem("协议内容");
                record.setBeforeContent(oldWindup.getAgreeContent());
                record.setAfterContent(newWindup.getAgreeContent());
                record.setModifyTime(now);
                record.setModifyUser(loginUser.getUnitName() + " " + loginUser.getTrueName());
                record.setCaseId(caseId);
                caseModifyRecordService.insertCaseModifyRecord(record);
                caseInfoUnfold.setAgreeContent(newWindup.getAgreeContent());
                hasChanged = true;
            }

            // 比较结案意见
            if (!Objects.equals(oldWindup.getWindupContent(), newWindup.getWindupContent())) {
                CaseModifyRecord record = new CaseModifyRecord();
                record.setModifyType("修改");
                record.setModifyAttribute("办理结果");
                record.setModifyItem("结案意见");
                record.setBeforeContent(oldWindup.getWindupContent());
                record.setAfterContent(newWindup.getWindupContent());
                record.setModifyTime(now);
                record.setModifyUser(loginUser.getUnitName() + " " + loginUser.getTrueName());
                record.setCaseId(caseId);
                caseModifyRecordService.insertCaseModifyRecord(record);
                caseInfoUnfold.setWindupContent(newWindup.getWindupContent());
                hasChanged = true;
            }

            // 比较协议类型
            if (!Objects.equals(oldWindup.getAgreeTypeName(), newWindup.getAgreeTypeName())) {
                CaseModifyRecord record = new CaseModifyRecord();
                record.setModifyType("修改");
                record.setModifyAttribute("办理结果");
                record.setModifyItem("协议类型");
                record.setBeforeContent(oldWindup.getAgreeTypeName());
                record.setAfterContent(newWindup.getAgreeTypeName());
                record.setModifyTime(now);
                record.setModifyUser(loginUser.getUnitName() + " " + loginUser.getTrueName());
                record.setCaseId(caseId);
                caseModifyRecordService.insertCaseModifyRecord(record);
                caseInfoUnfold.setAgreeType(newWindup.getAgreeType());
                caseInfoUnfold.setAgreeTypeName(newWindup.getAgreeTypeName());
                caseInfoUnfold.setAgreeContent(newWindup.getAgreeContent());
                hasChanged = true;
            }
            //结果化解结果
            if (!Objects.equals(oldWindup.getMediResult(), newWindup.getMediResult())) {
                CaseModifyRecord record = new CaseModifyRecord();
                record.setModifyType("修改");
                record.setModifyAttribute("办理结果");
                record.setModifyItem("化解结果");
                record.setBeforeContent(oldWindup.getMediResultName());
                record.setAfterContent(newWindup.getMediResultName());
                record.setModifyTime(now);
                record.setModifyUser(loginUser.getUnitName() + " " + loginUser.getTrueName());
                record.setCaseId(caseId);
                caseModifyRecordService.insertCaseModifyRecord(record);
                caseInfoUnfold.setMediResult(newWindup.getMediResult());
                caseInfoUnfold.setMediResultName(newWindup.getMediResultName());
                caseInfoUnfold.setAgreeType(newWindup.getAgreeType());
                caseInfoUnfold.setAgreeTypeName(newWindup.getAgreeTypeName());
                caseInfoUnfold.setAgreeContent(newWindup.getAgreeContent());
                caseInfoUnfold.setWindupContent(newWindup.getWindupContent());
                caseInfoUnfold.setUpdateTime(nowTime);
                caseInfoUnfold.setCloseTime(nowTime);
                hasChanged = true;
            }
            if (hasChanged) {
                CaseWindupApply caseWindupApply = new CaseWindupApply();
                BeanUtils.copyProperties(newWindup, caseWindupApply);
                caseWindupApply.setId(oldWindup.getId());
                caseWindupApplyService.updateCaseWindupApply(caseWindupApply);
                caseInfoUnfoldService.updateCaseInfoUnfold(caseInfoUnfold);
            }
            compareFileList(oldFileInfoList, caseId, oldWindup.getId(), "办理结果", loginUser, now);
        }


        //5、案件附件对比
        compareFileList(caseUpdateDTO.getFileList(), caseId, caseId, "事件材料", loginUser, now);

        //6、处理删除的办理反馈附件和结案附件
        if (caseUpdateDTO.getDeleteFileIds() != null && !caseUpdateDTO.getDeleteFileIds().isEmpty()) {
            caseUpdateDTO.getDeleteFileIds().forEach(fileId -> {
                if (fileId != null) {
                    FileRelateDTO fileRelateByFileId = sysClient.getFileRelateByFileId(fileId);
                    FileInfoBaseDTO fileInfoBaseDTO = sysClient.getFileInfoById(fileId);
                    if (fileRelateByFileId != null) {
                        String ownerType = fileRelateByFileId.getOwnerType();
                        if ("22_00018-302".equals(ownerType)) {
                            CaseModifyRecord record = new CaseModifyRecord();
                            record.setModifyType("删除");
                            record.setModifyAttribute("结案信息");
                            record.setModifyItem("书面协议");
                            record.setBeforeContent(fileInfoBaseDTO.getName());
                            record.setAfterContent(null);
                            record.setFileUrl(fileInfoBaseDTO.getShowUrl());
                            record.setModifyTime(now);
                            record.setModifyUser(loginUser.getUnitName() + " " + loginUser.getTrueName());
                            record.setCaseId(caseId);
                            caseModifyRecordService.insertCaseModifyRecord(record);
                        }
                        if ("22_00018-501".equals(ownerType)) {
                            CaseModifyRecord record = new CaseModifyRecord();
                            record.setModifyType("删除");
                            record.setModifyAttribute("办理反馈");
                            record.setModifyItem("办理反馈附件");
                            record.setBeforeContent(fileInfoBaseDTO.getName());
                            record.setAfterContent(null);
                            record.setFileUrl(fileInfoBaseDTO.getShowUrl());
                            record.setCaseId(caseId);
                            record.setModifyTime(now);
                            record.setModifyUser(loginUser.getUnitName() + " " + loginUser.getTrueName());
                            caseModifyRecordService.insertCaseModifyRecord(record);
                        }
                    }
                    sysClient.deleteFileById(fileId);
                }
            });
        }
    }

    private void compareFileList(List<FileInfoBaseDTO> oldFileList, String caseId, String ownerId, String modifyAttribute, CtUserDTO loginUser, String now) {
        Map<String, Object> term;
        List<FileIdTypeInfoBaseDTO> newFileInfoList;
        term = new HashMap<>();
        term.put("mainId", caseId);
        term.put("ownerIds", ownerId);
        //查询所有附件
        newFileInfoList = sysClient.listIdTypeInfoByOwnerIdList(term);
        List<FileInfoBaseDTO> newFileList = new ArrayList<>();
        if (newFileInfoList != null && !newFileInfoList.isEmpty()) {
            List<FileTypeInfoBaseDTO> fileList = newFileInfoList.get(0).getFileList();
            if (fileList != null && !fileList.isEmpty()) {
                newFileList.addAll(fileList.get(0).getFileList());
                if (fileList.size() > 1) {
                    newFileList.addAll(fileList.get(1).getFileList());
                }
            }
        }
        // 处理oldFileList为null的情况
        if (oldFileList == null) {
            oldFileList = new ArrayList<>();
        }

        // 创建Map用于快速查找旧附件
        Map<String, FileInfoBaseDTO> oldFileMap = new HashMap<>();
        for (FileInfoBaseDTO file : oldFileList) {
            if (file.getId() != null) {
                oldFileMap.put(file.getId(), file);
            }
        }

        // 遍历新附件列表，查找新增的附件
        if (newFileList != null && !newFileList.isEmpty()) {
            for (FileInfoBaseDTO newFile : newFileList) {
                // 如果新附件ID为空，则跳过
                if (newFile.getId() == null) {
                    continue;
                }

                // 检查是否存在对应的旧附件
                if (!oldFileMap.containsKey(newFile.getId())) {
                    // 新增的附件
                    CaseModifyRecord record = new CaseModifyRecord();
                    record.setModifyType("添加");
                    record.setModifyAttribute("案件附件");
                    record.setModifyItem("附件");
                    record.setBeforeContent("");
                    record.setAfterContent(newFile.getName());
                    record.setFileUrl(newFile.getShowUrl());
                    record.setModifyTime(now);
                    record.setModifyUser(loginUser.getUnitName() + " " + loginUser.getTrueName());
                    record.setCaseId(caseId);
                    caseModifyRecordService.insertCaseModifyRecord(record);
                }
            }
        }
    }

    /**
     * 处理办理反馈信息变更
     *
     * @param caseId        案件ID
     * @param caseUpdateDTO 案件更新DTO
     * @param loginUser     登录用户
     * @param now           当前时间
     */
    private void handleFeedbackChanges(String caseId, CaseUpdateDTO caseUpdateDTO, CtUserDTO loginUser, String now) {
        // 获取新旧反馈列表
        List<CaseFeedback> newFeedbacks = caseFeedbackService.listFeedback2(caseId);
        List<CaseFeedback> oldFeedbacks = caseUpdateDTO.getCaseFeedbackList();

        // 处理oldFeedbacks为null的情况
        if (oldFeedbacks == null) {
            oldFeedbacks = new ArrayList<>();
        }

        // 创建Map用于快速查找旧反馈信息
        Map<String, CaseFeedback> oldFeedbackMap = new HashMap<>();
        for (CaseFeedback feedback : oldFeedbacks) {
            if (feedback.getId() != null) {
                oldFeedbackMap.put(feedback.getId(), feedback);
            }
        }

        // 遍历新的反馈信息列表
        for (CaseFeedback newFeedback : newFeedbacks) {
            // 如果新反馈的ID为空，则跳过
            if (newFeedback.getId() == null) {
                continue;
            }

            // 检查是否存在对应的旧反馈
            CaseFeedback oldFeedback = oldFeedbackMap.get(newFeedback.getId());

            if (oldFeedback == null) {
                // 情况1: 新增的反馈信息
                CaseModifyRecord record = new CaseModifyRecord();
                record.setModifyType("添加");
                record.setModifyAttribute("办理反馈");
                record.setModifyItem("办理意见");
                record.setBeforeContent("");
                record.setAfterContent(newFeedback.getHandleContent());
                record.setModifyTime(now);
                record.setModifyUser(loginUser.getUnitName() + " " + loginUser.getTrueName());
                record.setCaseId(caseId);
                caseModifyRecordService.insertCaseModifyRecord(record);
            } else {
                // 情况2: 已存在的反馈，检查内容是否变更
                if (!Objects.equals(oldFeedback.getHandleContent(), newFeedback.getHandleContent())) {
                    CaseModifyRecord record = new CaseModifyRecord();
                    record.setModifyType("修改");
                    record.setModifyAttribute("办理反馈");
                    record.setModifyItem("办理意见");
                    record.setBeforeContent(oldFeedback.getHandleContent());
                    record.setAfterContent(newFeedback.getHandleContent());
                    record.setModifyTime(now);
                    record.setModifyUser(loginUser.getUnitName() + " " + loginUser.getTrueName());
                    record.setCaseId(caseId);
                    caseModifyRecordService.insertCaseModifyRecord(record);
                    caseFeedbackService.updatecaseFeedback(newFeedback);
                }

                // 比较附件变更
                compareFileChanges(caseId, oldFeedback.getFileInfoList(), newFeedback.getFileInfoList(),
                        "办理反馈", now, loginUser.getTrueName());
            }
        }
    }

    /**
     * 比较并记录文件变更
     *
     * @param oldFiles        旧文件列表
     * @param newFiles        新文件列表
     * @param modifyAttribute 修改属性
     * @param modifyTime      修改时间
     * @param modifyUser      修改用户
     */
    private void compareFileChanges(String caseId, List<FileInfoBaseDTO> oldFiles, List<FileInfoBaseDTO> newFiles,
                                    String modifyAttribute, String modifyTime, String modifyUser) {
        // 处理null情况
        if (oldFiles == null) {
            oldFiles = new ArrayList<>();
        }
        if (newFiles == null) {
            newFiles = new ArrayList<>();
        }

        // 创建Map用于快速查找
        Map<String, FileInfoBaseDTO> oldFileMap = new HashMap<>();
        Map<String, FileInfoBaseDTO> newFileMap = new HashMap<>();

        for (FileInfoBaseDTO file : oldFiles) {
            if (file.getId() != null) {
                oldFileMap.put(file.getId(), file);
            }
        }

        for (FileInfoBaseDTO file : newFiles) {
            if (file.getId() != null) {
                newFileMap.put(file.getId(), file);
            }
        }

        // 查找新增的附件
        for (FileInfoBaseDTO newFile : newFiles) {
            if (newFile.getId() != null && !oldFileMap.containsKey(newFile.getId())) {
                CaseModifyRecord record = new CaseModifyRecord();
                record.setModifyType("添加");
                record.setModifyAttribute(modifyAttribute);
                record.setModifyItem("办理附件");
                record.setBeforeContent("");
                record.setAfterContent(newFile.getName());
                record.setFileUrl(newFile.getShowUrl());
                record.setModifyTime(modifyTime);
                record.setModifyUser(modifyUser);
                record.setCaseId(caseId);
                caseModifyRecordService.insertCaseModifyRecord(record);
            }
        }

//        // 查找删除的附件
//        for (FileInfoBaseDTO oldFile : oldFiles) {
//            if (oldFile.getId() != null && !newFileMap.containsKey(oldFile.getId())) {
//                CaseModifyRecord record = new CaseModifyRecord();
//                record.setModifyType("删除");
//                record.setModifyAttribute(modifyAttribute);
//                record.setModifyItem("办理附件");
//                record.setBeforeContent(oldFile.getName());
//                record.setAfterContent("");
//                record.setFileUrl(oldFile.getShowUrl());
//                record.setModifyTime(modifyTime);
//                record.setModifyUser(modifyUser);
//               caseModifyRecordService.insertCaseModifyRecord(record);
//            }
//        }
    }


}