package cn.huge.module.cases.service;

import cn.huge.base.common.exception.ServiceException;
import cn.huge.base.common.utils.DateUtils;
import cn.huge.base.common.utils.IdUtils;
import cn.huge.module.cases.domain.dto.RepeatCaseInfoDTO;
import cn.huge.module.cases.domain.po.*;
import cn.huge.module.client.api.impl.UtilsClientImpl;
import cn.huge.module.cases.dao.mapper.CaseRepeatMapper;
import cn.huge.module.cust.dto.CtUserDTO;
import cn.huge.module.mediate.constant.CaseBaseConstsEnum;
import cn.huge.module.mediate.constant.CaseInfoProcessBaseConstsEnum;
import cn.huge.module.mediate.constant.CaseProcessBaseConstsEnum;
import cn.huge.module.mediate.constant.CaseStatusBaseConstsEnum;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.google.common.collect.Maps;
import org.apache.commons.collections.CollectionUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
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 javax.annotation.PostConstruct;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;

/**
 * @title: dyh_case_repeat业务逻辑处理
 * @Description dyh_case_repeat业务逻辑处理
 * @company hugeinfo
 * @author liyj
 * @Time 2024-12-26 11:16:47
 * @version 1.0.0
 */
@Slf4j
@Service
@Transactional(rollbackFor = Exception.class)
public class CaseRepeatService extends ServiceImpl<CaseRepeatMapper, CaseRepeat>{

    @Autowired
    private CaseRepeatMapper mapper;

    @Autowired
    private UtilsClientImpl utilsClient;
    @Autowired
    private CaseInfoService caseInfoService;
    @Autowired
    private CaseInfoUnfoldService caseInfoUnfoldService;
    @Autowired
    private CasePersonService casePersonService;
    @Autowired
    private CaseAgentService caseAgentService;

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

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

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

    /**
    * 按条件查询
    * @param terms 条件
    * @return List
    */
    public List<CaseRepeat> 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<CaseRepeat> pageQuery(PageRequest page, Map<String, Object> terms){
        long total = mapper.countTerms(terms);
        List<CaseRepeat> content = mapper.pageTerms(page, terms);
        return new PageImpl<CaseRepeat>(content, page, total);
    }

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


    /**
     * 创建重复记录
     * @param newCaseId 新案件编号
     * @param repeatCaseIdList 重复案件编号
     * @param loginUser 操作人
     */
    public void createRepeatCase(String newCaseId, List<String> repeatCaseIdList, CtUserDTO loginUser){
        try{
            // 查询主案件编号
            CaseInfo mainCaseInfo = null;
            if (repeatCaseIdList.size() == 1){
                mainCaseInfo = caseInfoService.getById(repeatCaseIdList.get(0));
            }else {
                QueryWrapper<CaseInfo> caseInfoQueryWrapper = new QueryWrapper<>();
                caseInfoQueryWrapper.select("id", "status", "status_name", "process", "process_name", "info_process", "info_process_name")
                        .in("id", repeatCaseIdList).orderByAsc("create_time");
                List<CaseInfo> caseInfoList = caseInfoService.list(caseInfoQueryWrapper);
                mainCaseInfo = caseInfoList.get(0);
            }
            // 创建重复记录
            CaseRepeat caseRepeat = new CaseRepeat();
            caseRepeat.setId(utilsClient.getNewTimeId());
            caseRepeat.setCaseId(newCaseId);
            caseRepeat.setCaseMainId(mainCaseInfo.getId());
            caseRepeat.setOperUserId(loginUser.getId());
            caseRepeat.setOperUserName(loginUser.getTrueName());
            caseRepeat.setCreateTime(DateUtils.getNowDate());
            caseRepeat.setUpdateTime(DateUtils.getNowDate());
            this.save(caseRepeat);

            // 更新新案件状态-与主案件状态一致
//            CaseInfo caseInfoPO = new CaseInfo();
//            caseInfoPO.setId(newCaseId);
//            caseInfoPO.setStatus(mainCaseInfo.getStatus());
//            caseInfoPO.setStatusName(mainCaseInfo.getStatusName());
//            caseInfoPO.setProcess(mainCaseInfo.getProcess());
//            caseInfoPO.setProcessName(mainCaseInfo.getProcessName());
//            caseInfoPO.setInfoProcess(mainCaseInfo.getInfoProcess());
//            caseInfoPO.setInfoProcessName(mainCaseInfo.getInfoProcessName());
//            caseInfoService.updateCaseInfo(caseInfoPO);
        }catch (Exception e){
            log.error("[CaseRepeatService.saveCaseRepeat]调用失败，异常信息："+e, e);
            throw new ServiceException("CaseRepeatService.saveCaseRepeat", e);
        }
    }

    /**
     * 查询重复事项
     * @param caseId
     * @return
     */
    public List<RepeatCaseInfoDTO> listRepeatCase(String caseId){
        List<String> cseIdList = new ArrayList<>();
        QueryWrapper<CaseRepeat> caseRepeatQueryWrapper = new QueryWrapper<>();
        caseRepeatQueryWrapper.eq("case_main_id", caseId);
        List<CaseRepeat> caseRepeatList = mapper.selectList(caseRepeatQueryWrapper);
        // 判断是否是主案件
        if (CollectionUtils.isNotEmpty(caseRepeatList)){
            // 是主案件，获取重复案件编号
            for (CaseRepeat caseRepeat : caseRepeatList){
                cseIdList.add(caseRepeat.getCaseId());
            }
        }
        // 查询非主案件的重复案件，先查询主案件
        caseRepeatQueryWrapper.clear();
        caseRepeatQueryWrapper.select("case_main_id").eq("case_id", caseId).groupBy("case_main_id");
        List<CaseRepeat> mainCaseRepeatList = mapper.selectList(caseRepeatQueryWrapper);
        if (CollectionUtils.isNotEmpty(mainCaseRepeatList)) {
            caseRepeatList = new ArrayList<>();
            for (CaseRepeat mainCaseRepeat : mainCaseRepeatList) {
                // 获取主案件编号
                cseIdList.add(mainCaseRepeat.getCaseMainId());
                // 查询主案件的重复案件
                caseRepeatQueryWrapper.clear();
                caseRepeatQueryWrapper.eq("case_main_id", mainCaseRepeat.getCaseMainId());
                List<CaseRepeat> caseRepeats = mapper.selectList(caseRepeatQueryWrapper);
                caseRepeatList.addAll(caseRepeats);
            }
            // 过滤自己的重复案件
            for (CaseRepeat caseRepeat : caseRepeatList){
                // 获取其他重复案件
                if (!caseId.equals(caseRepeat.getCaseId())) {
                    cseIdList.add(caseRepeat.getCaseId());
                }
            }
        }
        // 封装重复案件信息
        List<RepeatCaseInfoDTO> repeatCaseInfoDTOList = new ArrayList<>();
        if (CollectionUtils.isNotEmpty(cseIdList)) {
            QueryWrapper<CaseInfo> caseInfoQueryWrapper = new QueryWrapper<>();
            caseInfoQueryWrapper.in("id", cseIdList);
            List<CaseInfo> caseInfoList = caseInfoService.list(caseInfoQueryWrapper);
            if (CollectionUtils.isNotEmpty(caseInfoList)) {
                for (CaseInfo caseInfo : caseInfoList) {
                    RepeatCaseInfoDTO repeatCaseInfoDTO = new RepeatCaseInfoDTO();
                    BeanUtils.copyProperties(caseInfo, repeatCaseInfoDTO);
                    repeatCaseInfoDTO.setDataSource(CaseBaseConstsEnum.getDataSourceByCanal(caseInfo.getCanal()).getIndex());
                    repeatCaseInfoDTO.setDataSourceName(CaseBaseConstsEnum.getDataSourceByCanal(caseInfo.getCanal()).getDes());
                    // 查询申请方、被申请方当事人信息
                    QueryWrapper<CasePerson> casePersonQueryWrapper = new QueryWrapper<>();
                    casePersonQueryWrapper.select("id", "per_type", "true_name", "orga_code", "certi_no").eq("case_id", caseInfo.getId());
                    List<CasePerson> casePersonList = casePersonService.list(casePersonQueryWrapper);
                    List<Object> plaintiffs = new ArrayList<>();
                    List<Object> defendants = new ArrayList<>();
                    for (CasePerson casePerson : casePersonList) {
                        if (CaseBaseConstsEnum.PERSON_TYPE_1.getIndex().equals(casePerson.getPerType())) {
                            plaintiffs.add(casePerson);
                            // 查询代理人信息
                            QueryWrapper<CaseAgent> caseAgentQueryWrapper = new QueryWrapper<>();
                            caseAgentQueryWrapper.select("id", "per_type", "true_name", "certi_no").like("person_id", casePerson.getId());
                            List<CaseAgent> caseAgentList = caseAgentService.list(caseAgentQueryWrapper);
                            if (CollectionUtils.isNotEmpty(caseAgentList)) {
                                for (CaseAgent caseAgent : caseAgentList) {
                                    plaintiffs.add(caseAgent);
                                }
                            }

                        } else if (CaseBaseConstsEnum.PERSON_TYPE_2.getIndex().equals(casePerson.getPerType())) {
                            defendants.add(casePerson);
                            // 查询代理人信息
                            QueryWrapper<CaseAgent> caseAgentQueryWrapper = new QueryWrapper<>();
                            caseAgentQueryWrapper.select("id", "per_type", "true_name", "certi_no").like("person_id", casePerson.getId());
                            List<CaseAgent> caseAgentList = caseAgentService.list(caseAgentQueryWrapper);
                            if (CollectionUtils.isNotEmpty(caseAgentList)) {
                                for (CaseAgent caseAgent : caseAgentList) {
                                    defendants.add(caseAgent);
                                }
                            }
                        }
                    }
                    repeatCaseInfoDTO.setPlaintiffs(plaintiffs);
                    repeatCaseInfoDTO.setDefendants(defendants);
                    // 查询承办/配合部门、经办人
                    CaseInfoUnfold caseInfoUnfold = caseInfoUnfoldService.getById(caseInfo.getId());
                    repeatCaseInfoDTO.setMediator(caseInfoUnfold.getMediator());
                    repeatCaseInfoDTO.setMediateUnitName(caseInfoUnfold.getMediateUnitName());
                    repeatCaseInfoDTO.setAssistUnitName(caseInfoUnfold.getAssistUnitName());
                    repeatCaseInfoDTOList.add(repeatCaseInfoDTO);
                }
            }
        }
        return repeatCaseInfoDTOList;
    }

    /**
     * 判断是否有重复案件
     * @param caseId
     * @return
     */
    public boolean checkRepeatCase(String caseId){
        List<String> cseIdList = new ArrayList<>();
        QueryWrapper<CaseRepeat> caseRepeatQueryWrapper = new QueryWrapper<>();
        caseRepeatQueryWrapper.eq("case_main_id", caseId).or().eq("case_id", caseId);
        int repeatCaseCount = mapper.selectCount(caseRepeatQueryWrapper);
        if (repeatCaseCount > 0){
            return true;
        }else {
            return false;
        }
    }

}