package com.srs.flowable.listener.disbasic;

import com.srs.common.core.domain.entity.SysUser;
import com.srs.common.doman.vo.TeacherVo;

import com.srs.common.utils.spring.SpringUtils;
import com.srs.flowable.domain.DisBasic;
import com.srs.flowable.mapper.DisBasicMapper;
import com.srs.flowable.mapper.EnlistmentReserveMapper;
import com.srs.system.service.ISysUserService;
import org.flowable.bpmn.model.BpmnModel;
import org.flowable.bpmn.model.FlowNode;
import org.flowable.engine.RepositoryService;
import org.flowable.engine.delegate.DelegateExecution;
import org.flowable.engine.delegate.ExecutionListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.List;

@Component("DiscListenerListener")
public class DiscListener implements ExecutionListener {

    @Autowired
    private ISysUserService sysUserService; // 用户服务（查询部门/学院负责人）


    // 用于查询流程定义中的节点信息
    @Autowired
    private RepositoryService repositoryService;

    // 定义日志对象
    private static final Logger log = LoggerFactory.getLogger(DiscListener.class);

    @Override
    public void notify(DelegateExecution execution) {
        // 1. 获取当前节点ID和流程定义ID
        String currentActivityId = execution.getCurrentActivityId(); // 当前节点ID（兼容所有版本）
        String processDefinitionId = execution.getProcessDefinitionId(); // 流程定义ID

        // 2. 根据节点ID查询节点名称（核心修正：通过流程定义获取名称）
        String currentNodeName = getNodeNameByActivityId(processDefinitionId, currentActivityId);
        if (currentNodeName == null) {
            throw new RuntimeException("未找到节点ID=" + currentActivityId + "的名称");
        }

        // 3. 获取流程实例ID
        String processInstanceId = execution.getProcessInstanceId();

        // 获取申请表id 、开启流程ID
//        Long enlistmentId = Long.valueOf(execution.getVariable("enlistmentId").toString());

        Long stId = (Long) execution.getVariable("basicId");

//       Integer intData = (Integer) execution.getVariable("basicId");
//        Long stId = null;
//        if (intData != null) {
//            // 先转为数字，再获取long值
//            Number num = (Number) intData;
//            stId = num.longValue();
//        }

        // 获取审核意见
        String approvalOpinion = (String) execution.getVariable("approvalOpinion");

//        // 获取审核状态
//        Long approvalResult = (Long) execution.getVariable("approvalResult");

        // 4. 后续逻辑不变：查询下一个节点负责人并更新变量
//        Long nextAssigneeId = getNextAssignee(currentNodeName, processInstanceId, stId, currentActivityId, approvalOpinion, approvalResult);
        Long nextAssigneeId = getNextAssignee(currentNodeName, processInstanceId, stId, currentActivityId);
        if (nextAssigneeId != null) {
            execution.setVariable("approval", nextAssigneeId);
            execution.setVariable("currentNode", currentNodeName);
        }
    }

    /**
     * 根据节点ID和流程定义ID，查询节点名称（兼容所有版本的核心方法）
     */
    private String getNodeNameByActivityId(String processDefinitionId, String activityId) {
        // 获取流程模型
        BpmnModel bpmnModel = repositoryService.getBpmnModel(processDefinitionId);
        if (bpmnModel == null) {
            throw new RuntimeException("未找到流程定义ID=" + processDefinitionId + "的模型");
        }

        // 从模型中获取节点信息（FlowNode包含用户任务、网关等节点）
        FlowNode flowNode = (FlowNode) bpmnModel.getFlowElement(activityId);
        return flowNode != null ? flowNode.getName() : null;
    }


    /**
     * 根据当前节点查询下一个节点的负责人
     */
//    private Long getNextAssignee(String currentNodeName, String processInstanceId, Long stId, String currentActivityId, String approvalOpinion, Long approvalResult) {
    private Long getNextAssignee(String currentNodeName, String processInstanceId, Long stId, String currentActivityId) {
        EnlistmentReserveMapper rtEnlistmentReserveMapper = (EnlistmentReserveMapper) SpringUtils.getBean(EnlistmentReserveMapper.class);
        DisBasicMapper sysDisBasicMapper = (DisBasicMapper)SpringUtils.getBean(DisBasicMapper.class);
        // 根据学生学号来获取对应辅导员的信息  sysDisBasic.getStId()
        DisBasic sysDisId = sysDisBasicMapper.selectSysDisBasicById(stId);

        TeacherVo counselorInfo = rtEnlistmentReserveMapper.getCounselorInfo(sysDisId.getStId());
        // 获取辅导员的部门id
        Long currentDeptId = counselorInfo.getDeptId();
        if (currentDeptId == null) {
            throw new RuntimeException("未分配部门，无法匹配负责人");
        }
        // 注意：节点名称需与BPMN模型中完全一致（区分大小写）
        switch (currentNodeName) {

            case "招生与就业处":
                List<TeacherVo> zjcData = sysDisBasicMapper.getShenDataInfo("招就处");
                return zjcData.get(0).getUserId();


            case "辅导员审核":

                // 返回匹配的辅导员用户ID（作为下一个节点负责人）
                return counselorInfo.getUserId();

            case "学务审核":

                // 辅导员通过后 → 下一个节点：学务（筛选出角色ID=105，且与当前部门一致）
                // 查询角色ID=105（学务）的所有用户
                SysUser queryUser = new SysUser();
                queryUser.setRoleId(105L); // 学务角色固定ID
                List<SysUser> academicAffairsUsers = sysUserService.selectAllocatedList(queryUser);
                if (academicAffairsUsers.isEmpty()) {
                    throw new RuntimeException("未查询到角色（学务）的用户");
                }

                // 从学务用户中筛选出部门ID与当前辅导员部门一致的用户
                SysUser targetAcademic = academicAffairsUsers.stream()
                        .filter(user -> currentDeptId.equals(user.getDeptId())) // 部门ID匹配
                        .findFirst() // 取第一个匹配的学务（若有多个，可根据排序或优先级调整）
                        .orElseThrow(() -> new RuntimeException("未找到部门ID=" + currentDeptId + "的学务负责人"));
                return targetAcademic.getUserId();

                // 学务通过后 → 下一个节点：二级学院（角色ID=106，匹配学生所属学院）
                // 查询当前流程对应的业务数据（获取学生所属学院ID）
//                RtEnlistmentReserve reserve = enlistmentReserveMapper.selectRtEnlistmentReserveByProcessInstanceId(processInstanceId);
//                if (reserve == null) {
//                    throw new RuntimeException("未查询到流程对应的业务数据，processInstanceId=" + processInstanceId);
//                }



            case "二级学院审核":
                // 二级学院通过后 → 下一个节点：学籍管理科
                // 查询角色ID=106（二级学院）的所有用户
                SysUser qUser = new SysUser();
                qUser.setRoleId(106L); // 二级学院角色固定ID=106
                List<SysUser> collegeUsers = sysUserService.selectAllocatedList(qUser);
                if (collegeUsers.isEmpty()) {
                    throw new RuntimeException("未查询到角色（二级学院）的用户");
                }

                // 筛选出部门ID（学院ID）与登录用户所属学院一致的二级学院负责人
                SysUser targetCollegeLeader = collegeUsers.stream()
                        .filter(user -> currentDeptId.equals(user.getDeptId())) // 学院ID匹配（部门ID即学院ID）
                        .findFirst()
                        .orElseThrow(() -> new RuntimeException("未找到学院ID=" + currentDeptId + "的二级学院负责人（角色ID=106）"));



                // 返回匹配的二级学院负责人ID
                return targetCollegeLeader.getUserId();
            // 学籍管理科通过后 → 下一个节点：教务处主管领导（假设部门ID=40）

            // 获取学教务处主管领导审核人


            case "学籍管理":

                // 获取学籍管理科审核人
                List<TeacherVo> shenDataInfo = sysDisBasicMapper.getShenDataInfo("学籍管理科");

                if (shenDataInfo.isEmpty()) {
                    throw new RuntimeException("未查询到对应的用户");
                }


                // 暂时选择学籍管理科第一个人作为审核人
                return shenDataInfo.get(0).getUserId();




            case "教务处主管":
                // 最后一个节点通过后 → 流程结束（无需设置负责人）
                List<TeacherVo> teacherVos = sysDisBasicMapper.getShenDataInfo("教务处主管领导");

                if (teacherVos.isEmpty()) {
                    throw new RuntimeException("未查询到对应的用户");
                }

                // 暂时选择教务处主管领导第一个人作为审核人
                return teacherVos.get(0).getUserId();

            default:
                throw new RuntimeException("未配置节点[" + currentNodeName + "]的下一个负责人规则");
        }
    }

}