package cn.huge.module.thirdByRmtj.service;

import cn.huge.base.common.exception.ServiceException;
import cn.huge.base.common.utils.*;
import cn.huge.module.cases.domain.po.CaseInfo;
import cn.huge.module.cases.service.CaseInfoService;
import cn.huge.module.client.api.impl.CustClientImpl;
import cn.huge.module.client.api.impl.UtilsClientImpl;
import cn.huge.module.cust.constant.UserBaseConsts;
import cn.huge.module.cust.dto.CtUnitDTO;
import cn.huge.module.cust.dto.CtUserDTO;
import cn.huge.module.mediate.constant.AuditBaseConsts;
import cn.huge.module.mediate.constant.AuditBaseConstsEnum;
import cn.huge.module.mediate.constant.CaseBaseConsts;
import cn.huge.module.thirdByRmtj.consts.RmtjConsts;
import cn.huge.module.thirdByRmtj.dao.mapper.ThRmtjApplyMapper;
import cn.huge.module.thirdByRmtj.domain.dto.*;
import cn.huge.module.thirdByRmtj.domain.po.ThRmtjApply;
import cn.huge.module.thirdByRmtj.domain.po.ThRmtjAudit;
import cn.huge.module.thirdByRmtj.domain.po.ThRmtjConfig;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.google.common.collect.Maps;
import net.sf.json.JSONObject;
import org.apache.commons.collections.CollectionUtils;
import org.apache.ibatis.annotations.Param;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.PageRequest;
import org.springframework.transaction.annotation.Transactional;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;

/**
 * @title: 第三方系统对接-转人民调解系统申请表业务逻辑处理
 * @Description 第三方系统对接-转人民调解系统申请表业务逻辑处理
 * @company hugeinfo
 * @author liyj
 * @Time 2024-11-15 10:56:25
 * @version 1.0.0
 */
@Slf4j
@Service
@Transactional(rollbackFor = Exception.class)
public class ThRmtjApplyService extends ServiceImpl<ThRmtjApplyMapper, ThRmtjApply>{

    @Autowired
    private ThRmtjApplyMapper mapper;

    @Autowired
    private UtilsClientImpl utilsClient;
    @Autowired
    private CustClientImpl custClient;
    @Autowired
    private CaseInfoService caseInfoService;
    @Autowired
    private ThRmtjAuditService thRmtjAuditService;
    @Autowired
    private ThRmtjService thRmtjService;
    @Autowired
    private ThRmtjConfigService thRmtjConfigService;

    /**
    * 更新对象
    * @param entity 对象
    */
    public void updateThRmtjApply(ThRmtjApply entity){
        try{
            mapper.updateThRmtjApply(entity);
        }catch (Exception e){
            log.error("[ThRmtjApplyService.updateThRmtjApply]调用失败，异常信息："+e, e);
            throw new ServiceException("ThRmtjApplyService.updateThRmtjApply", e);
        }
    }

    /**
    * 条件更新对象
    * @param entity 对象
    * @param terms 条件
    */
    public void updateThRmtjApplyTerms(ThRmtjApply entity, Map<String, Object> terms){
        try{
            mapper.updateThRmtjApplyTerms(entity, terms);
        }catch (Exception e){
            log.error("[ThRmtjApplyService.updateThRmtjApplyTerms]调用失败，异常信息："+e, e);
            throw new ServiceException("ThRmtjApplyService.updateThRmtjApplyTerms", e);
        }
    }

    /**
    * 根据编号物理删除
    * @param id 查询条件集合
    */
    public void deleteThRmtjApply(String id){
        try{
            mapper.deleteThRmtjApply(id);
        }catch (Exception e){
            log.error("[ThRmtjApplyService.deleteThRmtjApply]调用失败，异常信息："+e, e);
            throw new ServiceException("ThRmtjApplyService.deleteThRmtjApply", e);
        }
    }

    /**
    * 按条件查询
    * @param terms 条件
    * @return List
    */
    public List<ThRmtjApply> listTerms(Map<String, Object> terms){
        return mapper.listTerms(terms);
    }

    /**
    * 按条件统计
    * @param terms 条件
    * @return long
    */
    public long countTerms(Map<String, Object> terms){
        return mapper.countTerms(terms);
    }

    /**
    * 按条件分页查询
    * @param page 分页对象
    * @param terms 条件
    * @return Page
    */
    public Page<ThRmtjApply> pageQuery(PageRequest page, Map<String, Object> terms){
        long total = mapper.countTerms(terms);
        List<ThRmtjApply> content = mapper.pageTerms(page, terms);
        return new PageImpl<ThRmtjApply>(content, page, total);
    }

    /**
    * 新增或更新对象
    * @param thRmtjApply 实体对象
    */
    public void saveThRmtjApply(ThRmtjApply thRmtjApply){
        try{
            Date nowDate = DateUtils.getNowDate();
            // 判断是否新增
            if (IdUtils.checkNewId(thRmtjApply.getId())){
                thRmtjApply.setId(utilsClient.getNewTimeId());
                thRmtjApply.setCreateTime(nowDate);
            }
            thRmtjApply.setUpdateTime(nowDate);
            this.saveOrUpdate(thRmtjApply);
        }catch (Exception e){
            log.error("[ThRmtjApplyService.saveThRmtjApply]调用失败，异常信息："+e, e);
            throw new ServiceException("ThRmtjApplyService.saveThRmtjApply", e);
        }
    }

    /**
     * web端-转入人民调解系统-申请列表
     * @param page 分页对象
     * @param terms 条件
     * @return Page
     */
    public Page<RmtjApplyPageDTO> pageApply(PageRequest page, Map<String, Object> terms){
        long total = mapper.countPageApply(terms);
        List<RmtjApplyPageDTO> content = mapper.pageApply(page, terms);
        return new PageImpl<RmtjApplyPageDTO>(content, page, total);
    }

    /**
     * web端-转入人民调解系统-申请列表统计
     * @param terms 条件
     * @return List
     */
    public Map countApply(Map<String, Object> terms){
        return mapper.countApply(terms);
    }

    /**
     * web端-转入人民调解系统-批量转入人民调解系统申请
     * @param caseIdList 申请案件编号集合
     * @param loginUser 当前登录用户
     */
    public void batchSendApply(List<String> caseIdList, CtUserDTO loginUser){
        try{
            Date nowDate = DateUtils.getNowDate();
            for (String caseId: caseIdList) {
                CaseInfo caseInfo = caseInfoService.getById(caseId);
                if (ObjectUtils.isNotEmpty(caseInfo)) {
                    QueryWrapper<ThRmtjApply> queryWrapper = new QueryWrapper<>();
                    queryWrapper.eq("case_id", caseId).ne("process", RmtjConsts.APPLY_PROCESS_9);
                    ThRmtjApply thRmtjApply = this.getOne(queryWrapper);
                    if (ObjectUtils.isEmpty(thRmtjApply)) {
                        queryWrapper.clear();
                        queryWrapper.eq("case_id", caseId);
                        int applyIndex = this.count(queryWrapper);

                        CtUnitDTO ctUnitDTO = custClient.getUnitById(loginUser.getUnitId());
                        if (UserBaseConsts.UNIT_GRADE_2 == ctUnitDTO.getUnitGrade()) {
                            // 区级申请转入，无司法所初审，直接到司法局终审
                            thRmtjApply = new ThRmtjApply();
                            thRmtjApply.setId(utilsClient.getNewTimeId());
                            thRmtjApply.setCaseId(caseId);
                            thRmtjApply.setApplyIndex(applyIndex+1);
                            thRmtjApply.setProcess(RmtjConsts.APPLY_PROCESS_2);
                            thRmtjApply.setAuditNode(RmtjConsts.AUDIT_NODE_2);
                            // 申请信息
                            thRmtjApply.setApplyUserId(loginUser.getId());
                            thRmtjApply.setApplyUserName(loginUser.getTrueName());
                            thRmtjApply.setApplyUnitId(loginUser.getUnitId());
                            thRmtjApply.setApplyUnitName(loginUser.getUnitName());
                            thRmtjApply.setApplyTime(nowDate);
                            // 初审信息
                            thRmtjApply.setFirstAuditUnit(ctUnitDTO.getId());
                            thRmtjApply.setFirstAuditUnitName(ctUnitDTO.getUnitName());
                            thRmtjApply.setFirstAuditUser(loginUser.getId());
                            thRmtjApply.setFirstAuditUserName(loginUser.getTrueName());
                            thRmtjApply.setFirstAuditResult(RmtjConsts.AUDIT_RESULT_1);
                            thRmtjApply.setFirstAuditTime(nowDate);
                            // 终审单位为司法局
                            Map<String, Object> unitTerms = Maps.newHashMap();
                            unitTerms.put("unitType", UserBaseConsts.UNIT_TYPE_105);
                            List<CtUnitDTO> sfjUnitList = custClient.listByTerms(unitTerms);
                            if (CollectionUtils.isNotEmpty(sfjUnitList)) {
                                thRmtjApply.setEndAuditUnit(sfjUnitList.get(0).getId());
                                thRmtjApply.setEndAuditUnitName(sfjUnitList.get(0).getId());
                            }
                            thRmtjApply.setCreateTime(nowDate);
                            thRmtjApply.setUpdateTime(nowDate);
                            thRmtjApply.setCustId(loginUser.getCustId());
                            this.save(thRmtjApply);
                        } else {
                            // 普通调解单位申请转入
                            thRmtjApply = new ThRmtjApply();
                            thRmtjApply.setId(utilsClient.getNewTimeId());
                            thRmtjApply.setCaseId(caseId);
                            thRmtjApply.setApplyIndex(applyIndex+1);
                            thRmtjApply.setProcess(RmtjConsts.APPLY_PROCESS_1);
                            thRmtjApply.setAuditNode(RmtjConsts.AUDIT_NODE_1);
                            // 申请信息
                            thRmtjApply.setApplyUserId(loginUser.getId());
                            thRmtjApply.setApplyUserName(loginUser.getTrueName());
                            thRmtjApply.setApplyUnitId(loginUser.getUnitId());
                            thRmtjApply.setApplyUnitName(loginUser.getUnitName());
                            thRmtjApply.setApplyTime(nowDate);
                            // 司法所单位审核
                            Map<String, Object> unitTerms = Maps.newHashMap();
                            if (UserBaseConsts.UNIT_GRADE_4 == ctUnitDTO.getUnitGrade()) {
                                unitTerms.put("parentId", ctUnitDTO.getParentId());
                                unitTerms.put("unitType", UserBaseConsts.UNIT_TYPE_106);
                            } else {
                                // 综治中心
                                if (UserBaseConsts.UNIT_TYPE_101 == ctUnitDTO.getUnitType()){
                                    unitTerms.put("parentId", ctUnitDTO.getId());
                                }else {
                                    // 其他单位
                                    unitTerms.put("parentId", ctUnitDTO.getParentId());
                                }
                                unitTerms.put("unitType", UserBaseConsts.UNIT_TYPE_106);
                            }
                            List<CtUnitDTO> sfsUnitList = custClient.listByTerms(unitTerms);
                            if (CollectionUtils.isNotEmpty(sfsUnitList)) {
                                thRmtjApply.setFirstAuditUnit(sfsUnitList.get(0).getId());
                                thRmtjApply.setFirstAuditUnitName(sfsUnitList.get(0).getUnitName());
                            }
                            thRmtjApply.setCustId(loginUser.getCustId());
                            thRmtjApply.setCreateTime(nowDate);
                            thRmtjApply.setUpdateTime(nowDate);
                            this.save(thRmtjApply);
                        }
                    }
                }
            }
        }catch (Exception e){
            log.error("service方法[ThRmtjApplyService.batchSendApply]调用异常："+e, e);
            throw new ServiceException("ThRmtjApplyService.batchSendApply", e);
        }
    }

    /**
     * web端-转入人民调解系统-初审列表
     * @param page 分页对象
     * @param terms 条件
     * @return Page
     */
    public Page<RmtjAuditPageDTO> pageFirstAudit(PageRequest page, Map<String, Object> terms){
        long total = mapper.countPageFirstAudit(terms);
        List<RmtjAuditPageDTO> content = mapper.pageFirstAudit(page, terms);
        return new PageImpl<RmtjAuditPageDTO>(content, page, total);
    }

    /**
     * web端-转入人民调解系统-批量申请转入初审
     * @param rmtjAuditDTO 审核信息对象
     * @param loginUser 当前登录用户
     */
    public void batchFirstAudit(RmtjAuditDTO rmtjAuditDTO, CtUserDTO loginUser){
        try{
            Date nowDate = DateUtils.getNowDate();
            for (String applyId: rmtjAuditDTO.getApplyIdList()) {
                ThRmtjApply thRmtjApply = this.getById(applyId);
                if (ObjectUtils.isNotEmpty(thRmtjApply)) {
                    int nowAuditNode = thRmtjApply.getAuditNode();
                    // 初审
                    if (RmtjConsts.AUDIT_NODE_1 == nowAuditNode){
                        // 审核通过的不能重新申
                        if (RmtjConsts.FIRST_AUDIT_1 != thRmtjApply.getFirstAuditResult()) {
                            thRmtjApply.setFirstAuditUser(loginUser.getId());
                            thRmtjApply.setFirstAuditUserName(loginUser.getTrueName());
                            thRmtjApply.setFirstAuditResult(rmtjAuditDTO.getAuditResult());
                            thRmtjApply.setFirstAuditTime(nowDate);
                            // 同意
                            if (RmtjConsts.AUDIT_RESULT_1 == rmtjAuditDTO.getAuditResult()) {
                                // 初审同意，进入终审
                                thRmtjApply.setProcess(RmtjConsts.APPLY_PROCESS_2);
                                thRmtjApply.setAuditNode(RmtjConsts.AUDIT_NODE_2);

                                // 终审单位为司法局
                                Map<String, Object> unitTerms = Maps.newHashMap();
                                unitTerms.put("unitType", UserBaseConsts.UNIT_TYPE_105);
                                List<CtUnitDTO> sfjUnitList = custClient.listByTerms(unitTerms);
                                if (CollectionUtils.isNotEmpty(sfjUnitList)) {
                                    thRmtjApply.setEndAuditUnit(sfjUnitList.get(0).getId());
                                    thRmtjApply.setEndAuditUnitName(sfjUnitList.get(0).getId());
                                }
                            } else {
                                thRmtjApply.setProcess(RmtjConsts.APPLY_PROCESS_9);
                            }
                            thRmtjApply.setUpdateTime(nowDate);
                            this.updateThRmtjApply(thRmtjApply);
                            // 添加审核记录
                            ThRmtjAudit thRmtjAudit = new ThRmtjAudit();
                            thRmtjAudit.setId(utilsClient.getNewTimeId());
                            thRmtjAudit.setCaseId(thRmtjApply.getCaseId());
                            thRmtjAudit.setApplyId(applyId);
                            thRmtjAudit.setAuditNode(RmtjConsts.AUDIT_NODE_1);
                            thRmtjAudit.setAuditResult(rmtjAuditDTO.getAuditResult());
                            thRmtjAudit.setAuditResultName(rmtjAuditDTO.getAuditResultName());
                            thRmtjAudit.setAuditContent(rmtjAuditDTO.getAuditContent());
                            thRmtjAudit.setAuditerId(loginUser.getId());
                            thRmtjAudit.setAuditerName(loginUser.getTrueName());
                            thRmtjAudit.setAuditUnitId(loginUser.getUnitId());
                            thRmtjAudit.setAuditUnitName(loginUser.getUnitName());
                            thRmtjAudit.setAuditTime(nowDate);
                            thRmtjAudit.setCreateTime(nowDate);
                            thRmtjAudit.setUpdateTime(nowDate);
                            thRmtjAudit.setCustId(loginUser.getCustId());
                            thRmtjAuditService.save(thRmtjAudit);
                        }
                    }
                }
            }
        }catch (Exception e){
            log.error("service方法[ThRmtjApplyService.batchFirstAudit]调用异常："+e, e);
            throw new ServiceException("ThRmtjApplyService.batchFirstAudit", e);
        }
    }

    /**
     * web端-转入人民调解系统-审核获取申请信息
     * @param applyId
     * @return
     */
    public ToRmtjApplyDTO getApplyInfo(String applyId){
        ToRmtjApplyDTO toRmtjApplyDTO = new ToRmtjApplyDTO();
        ThRmtjApply thRmtjApply = this.getById(applyId);
        if (ObjectUtils.isNotEmpty(thRmtjApply)){
            toRmtjApplyDTO.setApplyId(applyId);
            // 初审
            if (RmtjConsts.AUDIT_NODE_1 == thRmtjApply.getAuditNode()){
                toRmtjApplyDTO.setApplyTime(thRmtjApply.getApplyTime());
                toRmtjApplyDTO.setApplyUserId(thRmtjApply.getApplyUserId());
                toRmtjApplyDTO.setApplyUserName(thRmtjApply.getApplyUserName());
                toRmtjApplyDTO.setApplyUnitName(thRmtjApply.getApplyUnitName());
            }else {
                // 终审
                toRmtjApplyDTO.setApplyTime(thRmtjApply.getFirstAuditTime());
                toRmtjApplyDTO.setApplyUserId(thRmtjApply.getFirstAuditUser());
                toRmtjApplyDTO.setApplyUserName(thRmtjApply.getFirstAuditUserName());
                toRmtjApplyDTO.setApplyUnitName(thRmtjApply.getFirstAuditUnitName());
            }
            // 审核记录
            QueryWrapper<ThRmtjApply> thRmtjApplyQueryWrapper = new QueryWrapper<>();
            thRmtjApplyQueryWrapper.eq("case_id", thRmtjApply.getCaseId()).orderByAsc("apply_index");
            List<ThRmtjApply> thRmtjApplyList = this.list(thRmtjApplyQueryWrapper);
            if (CollectionUtils.isNotEmpty(thRmtjApplyList)){
                List<ToRmtjApplyListDTO> toRmtjApplyListDTOList = new ArrayList<>();
                int i = 1;
                for (ThRmtjApply rmtjApply: thRmtjApplyList){
                    ToRmtjApplyListDTO toRmtjApplyListDTO = new ToRmtjApplyListDTO();
                    toRmtjApplyListDTO.setIndex(i);
                    toRmtjApplyListDTO.setIndexName("第"+i+"次");
                    i++;
                    // 封装审核进度
                    List<ToRmtjAuditListDTO> auditList = new ArrayList<>();
                    // 发起申请
                    ToRmtjAuditListDTO fqsq = new ToRmtjAuditListDTO();
                    fqsq.setId(rmtjApply.getId());
                    fqsq.setUnitName(rmtjApply.getApplyUnitName()+"（发起申请）");
                    fqsq.setUserId(rmtjApply.getApplyUserId());
                    fqsq.setUserName(rmtjApply.getApplyUserName());
                    fqsq.setHandleTime(rmtjApply.getApplyTime());
                    fqsq.setStatus(1);
                    auditList.add(fqsq);
                    // 申请单在初审阶段
                    if (RmtjConsts.APPLY_PROCESS_1 == rmtjApply.getProcess()){
                        // 初审进行中
                        ToRmtjAuditListDTO zs = new ToRmtjAuditListDTO();
                        zs.setId(rmtjApply.getFirstAuditUnit());
                        zs.setUnitName(rmtjApply.getFirstAuditUnitName()+"（审核中）");
                        zs.setStatus(0);
                        auditList.add(zs);

                    }else if (RmtjConsts.APPLY_PROCESS_2 == rmtjApply.getProcess()){
                        // 申请单在终审阶段
                        QueryWrapper<ThRmtjAudit> thRmtjAuditQueryWrapper = new QueryWrapper<>();
                        thRmtjAuditQueryWrapper.eq("apply_id", rmtjApply.getId()).orderByAsc("create_time");
                        List<ThRmtjAudit> thRmtjAuditList = thRmtjAuditService.list(thRmtjAuditQueryWrapper);
                        if (CollectionUtils.isNotEmpty(thRmtjAuditList)) {
                            for (ThRmtjAudit thRmtjAudit: thRmtjAuditList) {
                                ToRmtjAuditListDTO cs = new ToRmtjAuditListDTO();
                                cs.setId(thRmtjAudit.getId());
                                if (RmtjConsts.AUDIT_RESULT_1 == thRmtjAudit.getAuditResult()){
                                    cs.setUnitName(thRmtjAudit.getAuditUnitName()+"（审核通过）");
                                }else {
                                    cs.setUnitName(thRmtjAudit.getAuditUnitName()+"（审核不通过）");
                                }
                                cs.setUserId(thRmtjAudit.getAuditerId());
                                cs.setUserName(thRmtjAudit.getAuditerName());
                                cs.setHandleTime(thRmtjAudit.getAuditTime());
                                cs.setHandleContent(thRmtjAudit.getAuditContent());
                                cs.setStatus(1);
                                auditList.add(cs);
                            }
                        }
                        // 终审进行中
                        ToRmtjAuditListDTO zs = new ToRmtjAuditListDTO();
                        zs.setId(rmtjApply.getEndAuditUnit());
                        zs.setUnitName(rmtjApply.getEndAuditUnitName()+"（审核中）");
                        zs.setStatus(0);
                        auditList.add(zs);
                    }else {
                        // 已完成审核
                        QueryWrapper<ThRmtjAudit> thRmtjAuditQueryWrapper = new QueryWrapper<>();
                        thRmtjAuditQueryWrapper.eq("apply_id", rmtjApply.getId()).orderByAsc("create_time");
                        List<ThRmtjAudit> thRmtjAuditList = thRmtjAuditService.list(thRmtjAuditQueryWrapper);
                        if (CollectionUtils.isNotEmpty(thRmtjAuditList)) {
                            for (ThRmtjAudit thRmtjAudit: thRmtjAuditList) {
                                ToRmtjAuditListDTO audit = new ToRmtjAuditListDTO();
                                audit.setId(thRmtjAudit.getId());
                                if (RmtjConsts.AUDIT_RESULT_1 == thRmtjAudit.getAuditResult()){
                                    audit.setUnitName(thRmtjAudit.getAuditUnitName()+"（审核通过）");
                                }else {
                                    audit.setUnitName(thRmtjAudit.getAuditUnitName()+"（审核不通过）");
                                }
                                audit.setUserId(thRmtjAudit.getAuditerId());
                                audit.setUserName(thRmtjAudit.getAuditerName());
                                audit.setHandleTime(thRmtjAudit.getAuditTime());
                                audit.setHandleContent(thRmtjAudit.getAuditContent());
                                audit.setStatus(1);
                                auditList.add(audit);
                            }
                        }
                    }
                    toRmtjApplyListDTO.setAuditList(auditList);
                    toRmtjApplyListDTOList.add(toRmtjApplyListDTO);
                }
                toRmtjApplyDTO.setApplyList(toRmtjApplyListDTOList);
            }
        }
        return toRmtjApplyDTO;
    }

    /**
     * web端-转入人民调解系统-批量移除申请
     * @param caseIdList 申请案件编号集合
     * @param loginUser 当前登录用户
     */
    public void batchDeleteApply(List<String> caseIdList, CtUserDTO loginUser){
        try{
            Date nowDate = DateUtils.getNowDate();
            for (String caseId: caseIdList) {
                QueryWrapper<ThRmtjApply> thRmtjApplyQueryWrapper = new QueryWrapper<>();
                thRmtjApplyQueryWrapper.eq("case_id", caseId).select("id", "process");
                List<ThRmtjApply> thRmtjApplyList = this.list(thRmtjApplyQueryWrapper);
                if (CollectionUtils.isNotEmpty(thRmtjApplyList)) {
                    for (ThRmtjApply thRmtjApply : thRmtjApplyList) {
                        if (RmtjConsts.APPLY_PROCESS_1 == thRmtjApply.getProcess()
                                || RmtjConsts.APPLY_PROCESS_2 == thRmtjApply.getProcess()
                                || RmtjConsts.APPLY_PROCESS_9 == thRmtjApply.getProcess()) {
                            // 删除申请记录
                            this.removeById(thRmtjApply.getId());

                            // 删除审核记录
                            UpdateWrapper<ThRmtjAudit> thRmtjAuditUpdateWrapper = new UpdateWrapper<>();
                            thRmtjAuditUpdateWrapper.eq("apply_id", thRmtjApply.getId());
                            thRmtjAuditService.remove(thRmtjAuditUpdateWrapper);
                        }
                    }
                }
            }
        }catch (Exception e){
            log.error("service方法[ThRmtjApplyService.batchDeleteApply]调用异常："+e, e);
            throw new ServiceException("ThRmtjApplyService.batchDeleteApply", e);
        }
    }

    /**
     * web端-转入人民调解系统-终审列表
     * @param page 分页对象
     * @param terms 条件
     * @return Page
     */
    public Page<RmtjAuditPageDTO> pageEndAudit(PageRequest page, Map<String, Object> terms){
        long total = mapper.countPageEndAudit(terms);
        List<RmtjAuditPageDTO> content = mapper.pageEndAudit(page, terms);
        return new PageImpl<RmtjAuditPageDTO>(content, page, total);
    }


    /**
     * web端-转入人民调解系统-批量申请转入终审
     * @param rmtjAuditDTO 审核信息对象
     * @param loginUser 当前登录用户
     */
    public void batchEndAudit(RmtjAuditDTO rmtjAuditDTO, CtUserDTO loginUser){
        try{
            Date nowDate = DateUtils.getNowDate();
            for (String applyId: rmtjAuditDTO.getApplyIdList()) {
                ThRmtjApply thRmtjApply = this.getById(applyId);
                if (ObjectUtils.isNotEmpty(thRmtjApply)) {
                    Boolean sendRmtjFlag = false;
                    int nowAuditNode = thRmtjApply.getAuditNode();
                    // 终审
                    if (RmtjConsts.AUDIT_NODE_2 == nowAuditNode){
                        // 审核通过的不能重新申
                        if (RmtjConsts.END_AUDIT_1 != thRmtjApply.getEndAuditResult()) {
                            thRmtjApply.setEndAuditUser(loginUser.getId());
                            thRmtjApply.setEndAuditUserName(loginUser.getTrueName());
                            thRmtjApply.setEndAuditResult(rmtjAuditDTO.getAuditResult());
                            thRmtjApply.setEndAuditTime(nowDate);
                            // 同意
                            if (RmtjConsts.AUDIT_RESULT_1 == rmtjAuditDTO.getAuditResult()) {
                                // 初审同意，进入终审
                                thRmtjApply.setProcess(RmtjConsts.APPLY_PROCESS_3);
                                thRmtjApply.setAuditNode(RmtjConsts.AUDIT_NODE_3);
                                thRmtjApply.setRmtjStatus(RmtjConsts.RMTJ_STATUS_2);
                                // 转入人民调解系统
                                sendRmtjFlag = true;
                            } else {
                                thRmtjApply.setProcess(RmtjConsts.APPLY_PROCESS_9);
                            }
                            thRmtjApply.setUpdateTime(nowDate);
                            this.updateThRmtjApply(thRmtjApply);
                            // 添加审核记录
                            ThRmtjAudit thRmtjAudit = new ThRmtjAudit();
                            thRmtjAudit.setId(utilsClient.getNewTimeId());
                            thRmtjAudit.setCaseId(thRmtjApply.getCaseId());
                            thRmtjAudit.setApplyId(applyId);
                            thRmtjAudit.setAuditNode(RmtjConsts.AUDIT_NODE_2);
                            thRmtjAudit.setAuditResult(rmtjAuditDTO.getAuditResult());
                            thRmtjAudit.setAuditResultName(rmtjAuditDTO.getAuditResultName());
                            thRmtjAudit.setAuditContent(rmtjAuditDTO.getAuditContent());
                            thRmtjAudit.setAuditerId(loginUser.getId());
                            thRmtjAudit.setAuditerName(loginUser.getTrueName());
                            thRmtjAudit.setAuditUnitId(loginUser.getUnitId());
                            thRmtjAudit.setAuditUnitName(loginUser.getUnitName());
                            thRmtjAudit.setAuditTime(nowDate);
                            thRmtjAudit.setCreateTime(nowDate);
                            thRmtjAudit.setUpdateTime(nowDate);
                            thRmtjAudit.setCustId(loginUser.getCustId());
                            thRmtjAuditService.save(thRmtjAudit);
                            // 是否转入人民调解系统
                            if (sendRmtjFlag) {
                                // 异步转入人民调解系统
                                ThreadPoolUtils.executor(new AsynStartDyhtoRmtj(thRmtjApply.getId(), thRmtjApply.getCaseId()));
                            }
                        }else {

                        }
                    }
                }
            }
        }catch (Exception e){
            log.error("service方法[ThRmtjApplyService.batchEndAudit]调用异常："+e, e);
            throw new ServiceException("ThRmtjApplyService.batchEndAudit", e);
        }
    }

    /**
     * 终审通过转入人民调解系统-异步实现
     */
    private class AsynStartDyhtoRmtj implements Runnable {
        private String applyId;
        private String caseId;
        public AsynStartDyhtoRmtj(String applyId, String caseId) {
            this.applyId = applyId;
            this.caseId = caseId;
        }

        @Override
        public void run() {
            try{
                Date rmtjTime = DateUtils.getNowDate();
                String rmtjTimeStr = thRmtjConfigService.getByKindAndCode(RmtjConsts.CONFIG_KIND_1, RmtjConsts.CONFIG_CODE_1);
                if (org.apache.commons.lang3.StringUtils.isNotEmpty(rmtjTimeStr)) {
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                    rmtjTime = sdf.parse(rmtjTimeStr);
                }
                ThRmtjApply thRmtjApply = new ThRmtjApply();
                thRmtjApply.setId(applyId);
                if (SpringContextUtil.checkProd()) {
                    String result = null;
                    // 请求传输案件
                    try {
                        result = thRmtjService.dyhToRmtj(caseId, rmtjTime);
                    }catch (Exception e){
                        thRmtjApply.setRmtjStatus(RmtjConsts.RMTJ_STATUS_4);
                        thRmtjApply.setRmtjFalseInfo("请求返回报文{"+result+"},报错信息{"+e.getMessage()+"}");
                    }
                    // 解析返回信息
                    if (result  != null) {
                        JSONObject jsonObject = null;
                        Integer code = null;
                        try {
                            jsonObject = JSONObject.fromObject(result);
                            code = jsonObject.getInt("code");
                        }catch (Exception e){
                            thRmtjApply.setRmtjStatus(RmtjConsts.RMTJ_STATUS_4);
                            thRmtjApply.setRmtjFalseInfo("请求返回报文{"+result+"},报错信息{"+e.getMessage()+"}");
                        }
                        // 解析data
                        if (code != null) {
                            if (code == 200) {
                                thRmtjApply.setProcess(RmtjConsts.APPLY_PROCESS_4);
                                thRmtjApply.setRmtjStatus(RmtjConsts.RMTJ_STATUS_3);
                                try {
                                    JSONObject dataJSONObject = jsonObject.getJSONObject("data");
                                    String rmtjCaseId = dataJSONObject.getString("caseNo");
                                    thRmtjApply.setRmtjCaseId(rmtjCaseId);
                                    thRmtjApply.setRmtjTime(rmtjTime);
                                } catch (Exception e) {
                                    thRmtjApply.setRmtjFalseInfo("请求返回报文{" + result + "},报错信息{" + e.getMessage() + "}");
                                }
                            } else {
                                thRmtjApply.setRmtjStatus(RmtjConsts.RMTJ_STATUS_4);
                                thRmtjApply.setRmtjFalseInfo(result);
                            }
                        }
                    }
                    mapper.updateThRmtjApply(thRmtjApply);
                }else {
                    thRmtjApply.setProcess(RmtjConsts.APPLY_PROCESS_4);
                    thRmtjApply.setRmtjStatus(RmtjConsts.RMTJ_STATUS_3);
                    thRmtjApply.setRmtjTime(rmtjTime);
                    mapper.updateThRmtjApply(thRmtjApply);
                }
            }catch (Exception e){
                log.error(e.getMessage());
            }
        }
    }

    /**
     * web端-转入人民调解系统-申请记录
     * @param caseId
     * @return
     */
    public ToRmtjApplyDTO getCaseApplyRmtj(String caseId){
        ToRmtjApplyDTO toRmtjApplyDTO = null;
        // 审核记录
        QueryWrapper<ThRmtjApply> thRmtjApplyQueryWrapper = new QueryWrapper<>();
        thRmtjApplyQueryWrapper.eq("case_id", caseId).orderByAsc("apply_index");
        List<ThRmtjApply> thRmtjApplyList = this.list(thRmtjApplyQueryWrapper);
        if (CollectionUtils.isNotEmpty(thRmtjApplyList)){
            toRmtjApplyDTO = new ToRmtjApplyDTO();
            toRmtjApplyDTO.setType("转入人民调解系统申请");
            ThRmtjApply newRmtjApply = thRmtjApplyList.get(thRmtjApplyList.size()-1);
            if (RmtjConsts.APPLY_PROCESS_1 == newRmtjApply.getProcess() || RmtjConsts.APPLY_PROCESS_2 == newRmtjApply.getProcess() ){
                toRmtjApplyDTO.setApplyStatus(0);
            }else if (RmtjConsts.APPLY_PROCESS_9 == newRmtjApply.getProcess()){
                toRmtjApplyDTO.setApplyStatus(1);
                toRmtjApplyDTO.setAuditResult(AuditBaseConstsEnum.AUDIT_RESULT_2.getIndex());
                toRmtjApplyDTO.setAuditResultName("审核未通过");
            }else {
                toRmtjApplyDTO.setApplyStatus(1);
                toRmtjApplyDTO.setAuditResult(AuditBaseConstsEnum.AUDIT_RESULT_1.getIndex());
                toRmtjApplyDTO.setAuditResultName("审核通过");
            }
            // 申请信息
            toRmtjApplyDTO.setApplyId(thRmtjApplyList.get(0).getId());
            toRmtjApplyDTO.setApplyTime(thRmtjApplyList.get(0).getApplyTime());
            toRmtjApplyDTO.setApplyUserId(thRmtjApplyList.get(0).getApplyUserId());
            toRmtjApplyDTO.setApplyUserName(thRmtjApplyList.get(0).getApplyUserName());
            toRmtjApplyDTO.setApplyUnitName(thRmtjApplyList.get(0).getApplyUnitName());
            // 审核进度
            List<ToRmtjApplyListDTO> toRmtjApplyListDTOList = new ArrayList<>();
            int i = 1;
            for (ThRmtjApply rmtjApply: thRmtjApplyList){
                ToRmtjApplyListDTO toRmtjApplyListDTO = new ToRmtjApplyListDTO();
                toRmtjApplyListDTO.setIndex(i);
                toRmtjApplyListDTO.setIndexName("第"+i+"次");
                i++;
                // 封装审核进度
                List<ToRmtjAuditListDTO> auditList = new ArrayList<>();
                // 发起申请
                ToRmtjAuditListDTO fqsq = new ToRmtjAuditListDTO();
                fqsq.setId(rmtjApply.getId());
                fqsq.setUnitName(rmtjApply.getApplyUnitName()+"（发起申请）");
                fqsq.setUserId(rmtjApply.getApplyUserId());
                fqsq.setUserName(rmtjApply.getApplyUserName());
                fqsq.setHandleTime(rmtjApply.getApplyTime());
                fqsq.setStatus(1);
                auditList.add(fqsq);
                // 申请单在初审阶段
                if (RmtjConsts.APPLY_PROCESS_1 == rmtjApply.getProcess()){
                    // 初审进行中
                    ToRmtjAuditListDTO zs = new ToRmtjAuditListDTO();
                    zs.setId(rmtjApply.getFirstAuditUnit());
                    zs.setUnitName(rmtjApply.getFirstAuditUnitName()+"（审核中）");
                    zs.setStatus(0);
                    auditList.add(zs);

                }else if (RmtjConsts.APPLY_PROCESS_2 == rmtjApply.getProcess()){
                    // 申请单在终审阶段
                    QueryWrapper<ThRmtjAudit> thRmtjAuditQueryWrapper = new QueryWrapper<>();
                    thRmtjAuditQueryWrapper.eq("apply_id", rmtjApply.getId()).orderByAsc("create_time");
                    List<ThRmtjAudit> thRmtjAuditList = thRmtjAuditService.list(thRmtjAuditQueryWrapper);
                    if (CollectionUtils.isNotEmpty(thRmtjAuditList)) {
                        for (ThRmtjAudit thRmtjAudit: thRmtjAuditList) {
                            ToRmtjAuditListDTO cs = new ToRmtjAuditListDTO();
                            cs.setId(thRmtjAudit.getId());
                            if (RmtjConsts.AUDIT_RESULT_1 == thRmtjAudit.getAuditResult()){
                                cs.setUnitName(thRmtjAudit.getAuditUnitName()+"（审核通过）");
                            }else {
                                cs.setUnitName(thRmtjAudit.getAuditUnitName()+"（审核不通过）");
                            }
                            cs.setUserId(thRmtjAudit.getAuditerId());
                            cs.setUserName(thRmtjAudit.getAuditerName());
                            cs.setHandleTime(thRmtjAudit.getAuditTime());
                            cs.setHandleContent(thRmtjAudit.getAuditContent());
                            cs.setStatus(1);
                            auditList.add(cs);
                        }
                    }
                    // 终审进行中
                    ToRmtjAuditListDTO zs = new ToRmtjAuditListDTO();
                    zs.setId(rmtjApply.getEndAuditUnit());
                    zs.setUnitName(rmtjApply.getEndAuditUnitName()+"（审核中）");
                    zs.setStatus(0);
                    auditList.add(zs);
                }else {
                    // 已完成审核
                    QueryWrapper<ThRmtjAudit> thRmtjAuditQueryWrapper = new QueryWrapper<>();
                    thRmtjAuditQueryWrapper.eq("apply_id", rmtjApply.getId()).orderByAsc("create_time");
                    List<ThRmtjAudit> thRmtjAuditList = thRmtjAuditService.list(thRmtjAuditQueryWrapper);
                    if (CollectionUtils.isNotEmpty(thRmtjAuditList)) {
                        for (ThRmtjAudit thRmtjAudit: thRmtjAuditList) {
                            ToRmtjAuditListDTO audit = new ToRmtjAuditListDTO();
                            audit.setId(thRmtjAudit.getId());
                            if (RmtjConsts.AUDIT_RESULT_1 == thRmtjAudit.getAuditResult()){
                                audit.setUnitName(thRmtjAudit.getAuditUnitName()+"（审核通过）");
                            }else {
                                audit.setUnitName(thRmtjAudit.getAuditUnitName()+"（审核不通过）");
                            }
                            audit.setUserId(thRmtjAudit.getAuditerId());
                            audit.setUserName(thRmtjAudit.getAuditerName());
                            audit.setHandleTime(thRmtjAudit.getAuditTime());
                            audit.setHandleContent(thRmtjAudit.getAuditContent());
                            audit.setStatus(1);
                            auditList.add(audit);
                        }
                    }
                }
                toRmtjApplyListDTO.setAuditList(auditList);
                toRmtjApplyListDTOList.add(toRmtjApplyListDTO);
            }
            toRmtjApplyDTO.setApplyList(toRmtjApplyListDTOList);
        }
        return toRmtjApplyDTO;
    }

    /**
     * 批量重转入人民调解系统
     * @param applyIdList 批量申请编号
     */
    public void batchReSendRmtj(List<String> applyIdList, CtUserDTO loginUser){
        try{
            for (String applyId: applyIdList) {
                ThRmtjApply thRmtjApply = this.getById(applyId);
                if (RmtjConsts.AUDIT_NODE_3 ==thRmtjApply.getAuditNode() &&
                        RmtjConsts.RMTJ_STATUS_4 ==thRmtjApply.getRmtjStatus()) {
                    // 修改转入人民调解系统状态为转入中
                    thRmtjApply.setRmtjStatus(RmtjConsts.RMTJ_STATUS_2);
                    this.updateThRmtjApply(thRmtjApply);
                    // 异步转入人民调解系统
                    ThreadPoolUtils.executor(new AsynStartDyhtoRmtj(thRmtjApply.getId(), thRmtjApply.getCaseId()));
                }
            }
        }catch (Exception e){
            log.error("service方法[ThRmtjApplyService.batchReSendRmtj]调用异常："+e, e);
            throw new ServiceException("ThRmtjApplyService.batchReSendRmtj", e);
        }
    }

    /**
     * 查询某一单位的所有管辖单位id，包括自己
     * @param parentId 父级单位编号
     * @return String
     */
    public List<String> listAllChild(@Param("parentId") String parentId){
        return mapper.listAllUnitId(parentId);
    }

}