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.consts.CaseTaskConsts;
import cn.huge.module.cases.domain.po.CaseInfo;
import cn.huge.module.cases.domain.po.CaseTask;
import cn.huge.module.client.api.impl.CustClientImpl;
import cn.huge.module.client.api.impl.UtilsClientImpl;
import cn.huge.module.cases.dao.mapper.CaseEvaluateMapper;
import cn.huge.module.cases.domain.po.CaseEvaluate;
import cn.huge.module.constant.BaseConsts;
import cn.huge.module.cust.dto.PaUserDTO;
import cn.huge.module.flow.consts.FlowNodeEnum;
import cn.huge.module.flow.consts.FlowableConsts;
import cn.huge.module.flow.domain.po.FlowNode;
import cn.huge.module.flow.service.FlowInfoService;
import cn.huge.module.mediate.constant.CaseInfoProcessBaseConstsEnum;
import cn.huge.module.mediate.constant.CaseProcessBaseConstsEnum;
import cn.huge.module.mediate.constant.CaseStatusBaseConstsEnum;
import cn.huge.module.sy.service.SyHolidayService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
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.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import java.util.Map;

/**
 * @title: 当事人纠纷评价表业务逻辑处理
 * @Description 当事人纠纷评价表业务逻辑处理
 * @company hugeinfo
 * @author wangwh
 * @Time 2024-09-04 20:21:05
 * @version 1.0.0
 */
@Slf4j
@Service
@Transactional(rollbackFor = Exception.class)
public class CaseEvaluateService extends ServiceImpl<CaseEvaluateMapper, CaseEvaluate>{

    @Autowired
    private CaseEvaluateMapper mapper;

    @Autowired
    private UtilsClientImpl utilsClient;

    @Autowired
    private CustClientImpl custClient;
    @Autowired
    private CaseTaskService caseTaskService;
    @Autowired
    private FlowInfoService flowInfoService;
    @Autowired
    private CaseInfoService caseInfoService;
    @Autowired
    private SyHolidayService syHolidayService;

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

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

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

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

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

    /**
     * 新增或更新对象
     * @param caseEvaluate 实体对象
     */
    public void saveCaseEvaluateWechat(CaseEvaluate caseEvaluate,String userId){
        try{
            PaUserDTO loginUser = custClient.paclientGetUser(userId);
            Date nowDate = DateUtils.getNowDate();
            // 判断是否新增
            if (IdUtils.checkNewId(caseEvaluate.getId())){
                caseEvaluate.setId(utilsClient.getNewTimeId());
                caseEvaluate.setCreateTime(nowDate);
                caseEvaluate.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
            }
            caseEvaluate.setEvaluateUserId(loginUser.getId());
            caseEvaluate.setEvaluateUserName(loginUser.getTrueName());
            caseEvaluate.setCustId(loginUser.getCustId());
            caseEvaluate.setUpdateTime(nowDate);
            this.saveOrUpdate(caseEvaluate);
            // 查询当事人评价节点任务
            QueryWrapper<CaseTask> caseTaskQueryWrapper = new QueryWrapper<>();
            caseTaskQueryWrapper.eq("case_id", caseEvaluate.getCaseId())
                    .eq("node_id", FlowNodeEnum.FLOW_NODE_DSRPJ.getIndex())
                    .eq("status", CaseTaskConsts.TASK_STATUS_1);
            CaseTask dsrpjCaseTask = caseTaskService.getOne(caseTaskQueryWrapper);
            // 完成当前当事人评价节点任务
            dsrpjCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_2);
            dsrpjCaseTask.setHandleUnitId(dsrpjCaseTask.getCandeUnitId());
            dsrpjCaseTask.setHandleUnitName(dsrpjCaseTask.getCandeUnitName());
            dsrpjCaseTask.setHandleUserId(loginUser.getId());
            dsrpjCaseTask.setHandleUserName(loginUser.getTrueName()+"（当事人）");
            dsrpjCaseTask.setHandleResult(CaseTaskConsts.HANDLE_RESULT_0);
            dsrpjCaseTask.setHandleTime(nowDate);
            dsrpjCaseTask.setUpdateTime(nowDate);
            caseTaskService.updateCaseTask(dsrpjCaseTask);
            // 完成当前当事人评价工作流节点任务，进入结案归档节点
            FlowNode jagdFlowNode = flowInfoService.completeTask(dsrpjCaseTask.getFlowableId(), dsrpjCaseTask.getProcessTaskId(),
                    FlowableConsts.OPERATION_forward, userId);
            // 创建并完成结案归档任务
            CaseTask jagdCaseTask = new CaseTask();
            jagdCaseTask.setId(utilsClient.getNewTimeId());
            jagdCaseTask.setCaseId(caseEvaluate.getCaseId());
            jagdCaseTask.setFlowableId(jagdFlowNode.getFlowableId());
            jagdCaseTask.setProcessInstanceId(jagdFlowNode.getProcessInstanceId());
            jagdCaseTask.setProcessTaskId(jagdFlowNode.getProcessTaskId());
            jagdCaseTask.setNodeType(jagdFlowNode.getNodeType());
            jagdCaseTask.setNodeId(jagdFlowNode.getNodeId());
            jagdCaseTask.setNodeName(jagdFlowNode.getNodeName());
            jagdCaseTask.setFlowId(jagdFlowNode.getFlowId());
            jagdCaseTask.setNodeShowName(jagdFlowNode.getNodeShowName());
            jagdCaseTask.setCaseTaskType(CaseTaskConsts.CASE_TASK_TYPE_1);
            // 任务所属单位：结案申请组织
            caseTaskQueryWrapper.clear();
            caseTaskQueryWrapper.eq("case_id", caseEvaluate.getCaseId())
                    .eq("node_id", FlowNodeEnum.FLOW_NODE_JASQ.getIndex())
                    .eq("status", CaseTaskConsts.TASK_STATUS_2).orderByDesc("create_time");
            List<CaseTask> jasqCaseTaskList = caseTaskService.list(caseTaskQueryWrapper);
            jagdCaseTask.setCandeUnitId(jasqCaseTaskList.get(0).getHandleUnitId());
            jagdCaseTask.setCandeUnitName(jasqCaseTaskList.get(0).getHandleUnitName());
            // 受理后的任务，不需要签收
            jagdCaseTask.setReadStatus(CaseTaskConsts.READ_STATUS_0);
            jagdCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_2);
            // 任务处理时限
            if (jagdFlowNode.getExpire() != 0) {
                jagdCaseTask.setExpireTime(syHolidayService.getExpiryDay(nowDate, jagdFlowNode.getExpire()));
            }
            jagdCaseTask.setHandleUnitId(jasqCaseTaskList.get(0).getHandleUnitId());
            jagdCaseTask.setHandleUnitName(jasqCaseTaskList.get(0).getHandleUnitName());
            jagdCaseTask.setHandleDeptId(jasqCaseTaskList.get(0).getHandleDeptId());
            jagdCaseTask.setHandleDeptName(jasqCaseTaskList.get(0).getHandleDeptName());
            jagdCaseTask.setHandleUserId(jasqCaseTaskList.get(0).getHandleUserId());
            jagdCaseTask.setHandleUserName(jasqCaseTaskList.get(0).getHandleUserName());
            jagdCaseTask.setHandleResult(CaseTaskConsts.HANDLE_RESULT_0);
            jagdCaseTask.setHandleTime(nowDate);
            jagdCaseTask.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
            jagdCaseTask.setCustId(dsrpjCaseTask.getCustId());
            jagdCaseTask.setCreateTime(nowDate);
            jagdCaseTask.setUpdateTime(nowDate);
            caseTaskService.save(jagdCaseTask);
            // 结束工作流流程
            flowInfoService.completeTask(jagdCaseTask.getFlowableId(), jagdCaseTask.getProcessTaskId(),
                    FlowableConsts.OPERATION_forward, jasqCaseTaskList.get(0).getHandleUserId());
            // 更新纠纷信息
            CaseInfo caseInfoPO = new CaseInfo();
            caseInfoPO.setId(dsrpjCaseTask.getCaseId());
            caseInfoPO.setStatus(CaseStatusBaseConstsEnum.CASE_STATUS_7.getIndex());
            caseInfoPO.setStatusName(CaseStatusBaseConstsEnum.CASE_STATUS_7.getDes());
            caseInfoPO.setProcess(CaseProcessBaseConstsEnum.getByStatus(caseInfoPO.getStatus()).getIndex());
            caseInfoPO.setProcessName(CaseProcessBaseConstsEnum.getByStatus(caseInfoPO.getStatus()).getDes());
            caseInfoPO.setInfoProcess(CaseInfoProcessBaseConstsEnum.getByProcess(caseInfoPO.getProcess()).getIndex());
            caseInfoPO.setInfoProcessName(CaseInfoProcessBaseConstsEnum.getByProcess(caseInfoPO.getProcess()).getDes());
            caseInfoPO.setUpdateTime(nowDate);
            caseInfoService.updateCaseInfo(caseInfoPO);
        }catch (Exception e){
            log.error("[CaseEvaluateService.saveCaseEvaluateWechat]调用失败，异常信息："+e, e);
            throw new ServiceException("CaseEvaluateService.saveCaseEvaluateWechat", e);
        }
    }


    /**
     * 超时跳过评价
     * @param idList 超时事件编号
     */
    public void autoArchive(List<String>idList){
        try{
            Date nowDate = DateUtils.getNowDate();
            // 查询当事人评价任务
            QueryWrapper<CaseTask> caseTaskQueryWrapper = new QueryWrapper<>();
            caseTaskQueryWrapper.in("case_id", idList).eq("node_id", FlowNodeEnum.FLOW_NODE_DSRPJ.getIndex()).orderByDesc("create_time");
            List<CaseTask> dsrpjCaseTaskList = caseTaskService.list(caseTaskQueryWrapper);
            for(CaseTask dsrpjCaseTask: dsrpjCaseTaskList){
                // 完成当前当事人评价节点任务
                dsrpjCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_2);
                dsrpjCaseTask.setHandleUserId(dsrpjCaseTask.getCandeUserId());
                dsrpjCaseTask.setHandleUserName(dsrpjCaseTask.getCandeUserName());
                dsrpjCaseTask.setHandleResult(CaseTaskConsts.HANDLE_RESULT_0);
                dsrpjCaseTask.setHandleIllust("规定时间内未评价");
                dsrpjCaseTask.setHandleTime(nowDate);
                dsrpjCaseTask.setUpdateTime(nowDate);
                caseTaskService.updateCaseTask(dsrpjCaseTask);
                // 完成当前当事人评价工作流节点任务，进入结案归档节点
                FlowNode jagdFlowNode = flowInfoService.completeTask(dsrpjCaseTask.getFlowableId(), dsrpjCaseTask.getProcessTaskId(),
                        FlowableConsts.OPERATION_forward, "系统自动");
                // 创建并完成结案归档任务
                CaseTask jagdCaseTask = new CaseTask();
                jagdCaseTask.setId(utilsClient.getNewTimeId());
                jagdCaseTask.setCaseId(dsrpjCaseTask.getCaseId());
                if(jagdFlowNode!=null){
                    jagdCaseTask.setFlowableId(jagdFlowNode.getFlowableId());
                    jagdCaseTask.setProcessInstanceId(jagdFlowNode.getProcessInstanceId());
                    jagdCaseTask.setProcessTaskId(jagdFlowNode.getProcessTaskId());
                    jagdCaseTask.setNodeType(jagdFlowNode.getNodeType());
                    jagdCaseTask.setNodeId(jagdFlowNode.getNodeId());
                    jagdCaseTask.setNodeName(jagdFlowNode.getNodeName());
                    jagdCaseTask.setFlowId(jagdFlowNode.getFlowId());
                    jagdCaseTask.setNodeShowName(jagdFlowNode.getNodeShowName());
                    if (jagdFlowNode.getExpire() != 0) {
                        jagdCaseTask.setExpireTime(syHolidayService.getExpiryDay(nowDate, jagdFlowNode.getExpire()));
                    }
                }
                jagdCaseTask.setCaseTaskType(CaseTaskConsts.CASE_TASK_TYPE_1);
                // 任务所属单位：结案申请组织
                caseTaskQueryWrapper.clear();
                caseTaskQueryWrapper.eq("case_id", dsrpjCaseTask.getCaseId())
                        .eq("node_id", FlowNodeEnum.FLOW_NODE_JASQ.getIndex())
                        .eq("status", CaseTaskConsts.TASK_STATUS_2).orderByDesc("create_time");
                List<CaseTask> jasqCaseTaskList = caseTaskService.list(caseTaskQueryWrapper);
                jagdCaseTask.setCandeUnitId(jasqCaseTaskList.get(0).getHandleUnitId());
                jagdCaseTask.setCandeUnitName(jasqCaseTaskList.get(0).getHandleUnitName());
                // 受理后的任务，不需要签收
                jagdCaseTask.setReadStatus(CaseTaskConsts.READ_STATUS_0);
                jagdCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_2);
                // 任务处理时限
                jagdCaseTask.setHandleUnitId(jasqCaseTaskList.get(0).getHandleUnitId());
                jagdCaseTask.setHandleUnitName(jasqCaseTaskList.get(0).getHandleUnitName());
                jagdCaseTask.setHandleDeptId(jasqCaseTaskList.get(0).getHandleDeptId());
                jagdCaseTask.setHandleDeptName(jasqCaseTaskList.get(0).getHandleDeptName());
                jagdCaseTask.setHandleUserId(jasqCaseTaskList.get(0).getHandleUserId());
                jagdCaseTask.setHandleUserName(jasqCaseTaskList.get(0).getHandleUserName());
                jagdCaseTask.setHandleResult(CaseTaskConsts.HANDLE_RESULT_0);
                jagdCaseTask.setHandleTime(nowDate);
                jagdCaseTask.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
                jagdCaseTask.setCustId(dsrpjCaseTask.getCustId());
                jagdCaseTask.setCreateTime(nowDate);
                jagdCaseTask.setUpdateTime(nowDate);
                caseTaskService.save(jagdCaseTask);
                // 完成结案归档工作流节点任务，结束流程
                CaseInfo caseInfo = caseInfoService.getById(jagdCaseTask.getCaseId());
                Date createTime = caseInfo.getCreateTime();
                // 创建 2025年4月30日 的日期对象
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
                Date targetDate = sdf.parse("2025-04-30");
                if (createTime != null && createTime.after(targetDate)) {
                    flowInfoService.completeTask(jagdCaseTask.getFlowableId(), jagdCaseTask.getProcessTaskId(),
                            FlowableConsts.OPERATION_jb_zszz, jasqCaseTaskList.get(0).getHandleUserId());
                }
                // 结束工作流流程

                // 更新纠纷信息
                CaseInfo caseInfoPO = new CaseInfo();
                caseInfoPO.setId(dsrpjCaseTask.getCaseId());
                caseInfoPO.setStatus(CaseStatusBaseConstsEnum.CASE_STATUS_7.getIndex());
                caseInfoPO.setStatusName(CaseStatusBaseConstsEnum.CASE_STATUS_7.getDes());
                caseInfoPO.setProcess(CaseProcessBaseConstsEnum.getByStatus(caseInfoPO.getStatus()).getIndex());
                caseInfoPO.setProcessName(CaseProcessBaseConstsEnum.getByStatus(caseInfoPO.getStatus()).getDes());
                caseInfoPO.setInfoProcess(CaseInfoProcessBaseConstsEnum.getByProcess(caseInfoPO.getProcess()).getIndex());
                caseInfoPO.setInfoProcessName(CaseInfoProcessBaseConstsEnum.getByProcess(caseInfoPO.getProcess()).getDes());
                caseInfoPO.setUpdateTime(nowDate);
                caseInfoService.updateCaseInfo(caseInfoPO);
            }
        }catch (Exception e){
            log.error("[CaseEvaluateService.autoArchive]调用失败，异常信息："+e, e);
            throw new ServiceException("CaseEvaluateService.autoArchive", e);
        }
    }
}