#Flowable 自定义表达式

@Component("demoBean")
public class DemoBean {
    
    private final RemoteUserService remoteUserService;
    
    public DemoBean(RemoteUserService remoteUserService) {
        this.remoteUserService = remoteUserService;
    }
    
    /**
     * 获取单个审批人
     * @param execution 委托执行对象
     * @return 审批人 ID 列表
     */
    public List<Long> getUserList(DelegateExecution execution) {
        // 获取流程变量
        Object userId = execution.getVariable("userId");
        
        // 业务逻辑处理
        Long approver = determineApprover(userId);
        
        return Arrays.asList(approver);
    }
    
    /**
     * 获取多个审批人（并行审批）
     * @param execution 委托执行对象
     * @return 审批人 ID 列表
     */
    public List<Long> getMultipleApprovers(DelegateExecution execution) {
        // 获取当前用户部门
        Long deptId = (Long) execution.getVariable("deptId");
        
        // 查询部门经理和总经理
        List<Long> managers = remoteUserService.getManagersByDept(deptId);
        
        return managers;
    }
    
    /**
     * 获取具有特定角色的用户
     * @param execution 委托执行对象
     * @return 用户 ID 列表
     */
    public List<Long> getUsersByRole(DelegateExecution execution) {
        String role = (String) execution.getVariable("requiredRole");
        List<Long> users = remoteUserService.getUsersByRole(role);
        return users;
    }
    
    private Long determineApprover(Object userId) {
        // 实现具体的审批人确定逻辑
        return 1L;
    }
}

@Component("businessBean")
public class BusinessBean {
    
    @Autowired
    private BpmOaLeaveService leaveService;
    
    /**
     * 根据请假天数确定审批人
     * @param execution 委托执行对象
     * @return 审批人 ID
     */
    public List<Long> getApproverByLeaveDay(DelegateExecution execution) {
        String processInstanceId = execution.getProcessInstanceId();

        // 查询业务数据
        BpmOaLeaveEntity leave = leaveService.getOne(Wrappers.<BpmOaLeaveEntity>lambdaQuery()
                .eq(BpmOaLeaveEntity::getProcessInstanceId, processInstanceId));
                
        // 根据请假天数返回不同的审批人
        if (leave.getLeaveDay() <= 3) {
            // 直属主管审批
            return Arrays.asList(leave.getUserDeptManager());
        } else if (leave.getLeaveDay() <= 7) {
            // 部门总经理审批
            return Arrays.asList(leave.getDeptDirector());
        } else {
            // 需要 HR 和总经理联合审批
            return Arrays.asList(
                leave.getDeptDirector(),
                leave.getHrManager()
            );
        }
    }
}

@Component("conditionBean")
public class ConditionBean {
    
    @Autowired
    private BpmOaLeaveService leaveService;
    
    /**
     * 审批通过条件
     * @param execution 委托执行对象
     * @return true 表示通过，false 表示未通过
     */
    public boolean isApproved(DelegateExecution execution) {
        // 获取审批意见
        String opinion = (String) execution.getVariable("opinion");
        
        // 返回条件判断结果
        return "approved".equals(opinion);
    }
    
    /**
     * 审批拒绝条件
     * @param execution 委托执行对象
     * @return true 表示拒绝
     */
    public boolean isRejected(DelegateExecution execution) {
        String opinion = (String) execution.getVariable("opinion");
        return "rejected".equals(opinion);
    }
    
    /**
     * 复杂业务条件：根据请假天数判断是否需要总经理审批
     * @param execution 委托执行对象
     * @return true 需要二级审批
     */
    public boolean needsSecondaryApproval(DelegateExecution execution) {
        String processInstanceId = execution.getProcessInstanceId();

        // 查询业务数据
        BpmOaLeaveEntity leave = leaveService.getOne(Wrappers.<BpmOaLeaveEntity>lambdaQuery()
                .eq(BpmOaLeaveEntity::getProcessInstanceId, processInstanceId));
                
        // 超过 7 天需要总经理审批
        return leave.getLeaveDay() > 7;
    }
    
    /**
     * 金额判断条件
     * @param execution 委托执行对象
     * @return true 金额超出预算
     */
    public boolean isAmountExceeded(DelegateExecution execution) {
        Double amount = (Double) execution.getVariable("amount");
        Double budget = (Double) execution.getVariable("budget");
        
        return amount != null && budget != null && amount > budget;
    }
}

@Component("variableCondition")
public class VariableCondition {
    
    /**
     * 根据申请人等级判断审批流程
     * @param execution 委托执行对象
     * @return true 高管流程
     */
    public boolean isExecutiveApprovalRequired(DelegateExecution execution) {
        String userLevel = (String) execution.getVariable("userLevel");
        return "executive".equals(userLevel);
    }
    
    /**
     * 根据部门判断审批权限
     * @param execution 委托执行对象
     * @return true 需要财务部审批
     */
    public boolean needsFinanceApproval(DelegateExecution execution) {
        String dept = (String) execution.getVariable("department");
        return "sales".equals(dept) || "purchase".equals(dept);
    }
    
    /**
     * 时间区间判断
     * @param execution 委托执行对象
     * @return true 工作时间外
     */
    public boolean isOutsideWorkingHours(DelegateExecution execution) {
        LocalDateTime now = LocalDateTime.now();
        int hour = now.getHour();
        
        // 判断是否在工作时间外（18:00 - 09:00）
        return hour < 9 || hour >= 18;
    }
}

@Component("chainCondition")
public class ChainCondition {
    
    @Autowired
    private BpmOaLeaveService leaveService;
    
    /**
     * 综合条件判断链
     * @param execution 委托执行对象
     * @return true 满足所有条件
     */
    public boolean validateAll(DelegateExecution execution) {
        // 条件 1: 检查是否有重复申请
        if (hasDuplicateRequest(execution)) {
            return false;
        }
        
        // 条件 2: 检查余额
        if (!hasEnoughBalance(execution)) {
            return false;
        }
        
        // 条件 3: 检查时间冲突
        if (hasTimeConflict(execution)) {
            return false;
        }
        
        return true;
    }
    
    private boolean hasDuplicateRequest(DelegateExecution execution) {
        // 实现检查逻辑
        return false;
    }
    
    private boolean hasEnoughBalance(DelegateExecution execution) {
        // 实现余额检查逻辑
        return true;
    }
    
    private boolean hasTimeConflict(DelegateExecution execution) {
        // 实现时间冲突检查逻辑
        return false;
    }
}

// 获取变量
Object value = execution.getVariable("variableName");

// 设置变量
execution.setVariable("variableName", "value");

// 获取所有变量
Map<String, Object> allVariables = execution.getVariables();

// 删除变量
execution.removeVariable("variableName");

// 检查变量是否存在
boolean exists = execution.hasVariable("variableName");

@Component("historyBean")
public class HistoryBean {
    
    @Autowired
    private HistoryService historyService;
    
    /**
     * 获取流程完整历史
     * @param processInstanceId 流程实例 ID
     * @return 历史实例列表
     */
    public List<HistoricProcessInstance> getProcessHistory(String processInstanceId) {
        return historyService.createHistoricProcessInstanceQuery()
            .processInstanceId(processInstanceId)
            .list();
    }
    
    /**
     * 获取任务历史
     * @param processInstanceId 流程实例 ID
     * @return 历史任务列表
     */
    public List<HistoricTaskInstance> getTaskHistory(String processInstanceId) {
        return historyService.createHistoricTaskInstanceQuery()
            .processInstanceId(processInstanceId)
            .orderByHistoricTaskInstanceEndTime()
            .asc()
            .list();
    }
    
    /**
     * 获取流程变量历史
     * @param processInstanceId 流程实例 ID
     * @return 变量历史列表
     */
    public List<HistoricVariableInstance> getVariableHistory(String processInstanceId) {
        return historyService.createHistoricVariableInstanceQuery()
            .processInstanceId(processInstanceId)
            .list();
    }
}

@Service
public class LeaveProcessService {
    
    @Autowired
    private BpmOaLeaveService leaveService;
    
    @Autowired
    private RuntimeService runtimeService;
    
    /**
     * 根据流程实例 ID 查询完整数据
     * @param processInstanceId 流程实例 ID
     * @return 完整的业务和流程数据
     */
    public Map<String, Object> getCompleteData(String processInstanceId) {
        Map<String, Object> result = new HashMap<>();
        
        // 1. 获取业务数据
        BpmOaLeaveEntity leave = leaveService.getByProcessInstanceId(processInstanceId);
        result.put("business", leave);
        
        // 2. 获取流程实例
        ProcessInstance instance = runtimeService.createProcessInstanceQuery()
            .processInstanceId(processInstanceId)
            .singleResult();
        result.put("instance", instance);
        
        // 3. 获取流程变量
        Map<String, Object> variables = runtimeService.getVariables(processInstanceId);
        result.put("variables", variables);
        
        return result;
    }
    
    /**
     * 从流程变量获取业务数据
     * @param execution 委托执行对象
     * @return 业务实体
     */
    public BpmOaLeaveEntity getBusinessDataFromExecution(DelegateExecution execution) {
        String processInstanceId = execution.getProcessInstanceId();
        return leaveService.getByProcessInstanceId(processInstanceId);
    }
}

// 审批人表达式方法命名规范
public List<Long> get[业务名称]Approvers(DelegateExecution execution)
public List<Long> get[级别]Users(DelegateExecution execution)
public List<Long> getUsersBy[条件](DelegateExecution execution)

// 示例
public List<Long> getLeaveApprovers(DelegateExecution execution)
public List<Long> getManagerUsers(DelegateExecution execution)
public List<Long> getUsersByDepartment(DelegateExecution execution)

// 条件判断方法命名规范
public boolean is[条件状态](DelegateExecution execution)
public boolean needs[动作](DelegateExecution execution)
public boolean can[操作](DelegateExecution execution)

// 示例
public boolean isApproved(DelegateExecution execution)
public boolean needsSecondaryApproval(DelegateExecution execution)
public boolean canApprove(DelegateExecution execution)

@Component("safeBean")
public class SafeBean {
    
    private static final Logger log = LoggerFactory.getLogger(SafeBean.class);
    
    /**
     * 安全的审批人获取方法
     * @param execution 委托执行对象
     * @return 审批人列表（默认空列表）
     */
    public List<Long> getSafeApprovers(DelegateExecution execution) {
        try {
            // 获取数据和处理逻辑
            String processInstanceId = execution.getProcessInstanceId();
            // ... 业务逻辑
            return Arrays.asList(1L, 2L);
        } catch (NullPointerException e) {
            log.error("NPE in getSafeApprovers: {}", e.getMessage());
            return Collections.emptyList();
        } catch (Exception e) {
            log.error("Error in getSafeApprovers", e);
            // 返回默认审批人或抛出有意义的异常
            return Arrays.asList(0L);  // 0L 表示系统管理员
        }
    }
    
    /**
     * 安全的条件判断
     * @param execution 委托执行对象
     * @return 条件结果（异常时默认 false）
     */
    public boolean safeCondition(DelegateExecution execution) {
        try {
            // 条件判断逻辑
            return true;
        } catch (Exception e) {
            log.error("Error in safeCondition", e);
            return false;  // 异常时安全地返回 false
        }
    }
}

@SpringBootTest
public class ExpressionBeanTest {
    
    @Autowired
    private DemoBean demoBean;
    
    private DelegateExecution execution;
    
    @Before
    public void setUp() {
        execution = Mockito.mock(DelegateExecution.class);
    }
    
    @Test
    public void testGetUserList() {
        // 安排
        Mockito.when(execution.getVariable("userId")).thenReturn(123L);
        
        // 执行
        List<Long> result = demoBean.getUserList(execution);
        
        // 断言
        Assert.assertNotNull(result);
        Assert.assertFalse(result.isEmpty());
    }
    
    @Test
    public void testNeedsSecondaryApproval() {
        // 测试需要二级审批的情况
        Mockito.when(execution.getVariable("deptId")).thenReturn(1L);
        
        boolean result = demoBean.needsSecondaryApproval(execution);
        
        Assert.assertTrue(result);
    }
}

@Component("leaveBean")
public class LeaveBean {
    
    @Autowired
    private BpmOaLeaveService leaveService;
    
    /**
     * 根据请假天数获取审批人
     */
    public List<Long> getLeaveApprover(DelegateExecution execution) {
        BpmOaLeaveEntity leave = getLeaveData(execution);
        
        // 根据请假天数分级审批
        if (leave.getLeaveDay() <= 3) {
            return Arrays.asList(leave.getDirectManagerId());
        } else if (leave.getLeaveDay() <= 7) {
            return Arrays.asList(leave.getDeptDirectorId());
        } else {
            return Arrays.asList(
                leave.getDeptDirectorId(),
                leave.getHrManagerId()
            );
        }
    }
    
    /**
     * 判断是否需要 HR 审批
     */
    public boolean needsHrApproval(DelegateExecution execution) {
        BpmOaLeaveEntity leave = getLeaveData(execution);
        return leave.getLeaveDay() > 7 || "special".equals(leave.getLeaveType());
    }
    
    private BpmOaLeaveEntity getLeaveData(DelegateExecution execution) {
        String processInstanceId = execution.getProcessInstanceId();
        return leaveService.getByProcessInstanceId(processInstanceId);
    }
}

@Component("purchaseBean")
public class PurchaseBean {
    
    @Autowired
    private BpmOaPurchaseService purchaseService;
    
    /**
     * 根据金额获取审批人
     */
    public List<Long> getPurchaseApprover(DelegateExecution execution) {
        Map<String, Object> vars = execution.getVariables();
        Double amount = (Double) vars.get("amount");
        
        List<Long> approvers = new ArrayList<>();
        
        // 金额分级
        if (amount <= 1000) {
            approvers.add((Long) vars.get("deptManagerId"));
        } else if (amount <= 10000) {
            approvers.add((Long) vars.get("deptDirectorId"));
        } else if (amount <= 100000) {
            approvers.addAll(Arrays.asList(
                (Long) vars.get("financeManagerId"),
                (Long) vars.get("executiveDirectorId")
            ));
        } else {
            approvers.addAll(Arrays.asList(
                (Long) vars.get("cfoId"),
                (Long) vars.get("ceoId")
            ));
        }
        
        return approvers;
    }
    
    /**
     * 判断是否需要政府部门审批
     */
    public boolean needsGovernmentApproval(DelegateExecution execution) {
        String category = (String) execution.getVariable("category");
        return "government_contract".equals(category);
    }
}

@Component("expenseBean")
public class ExpenseBean {
    
    @Autowired
    private BpmExpenseService expenseService;
    
    /**
     * 获取报销审批人
     */
    public List<Long> getExpenseApprover(DelegateExecution execution) {
        String expenseId = (String) execution.getVariable("expenseId");
        BpmExpenseEntity expense = expenseService.getById(expenseId);
        
        List<Long> approvers = new ArrayList<>();
        
        // 第一级：直属主管（所有金额都需要）
        approvers.add(expense.getDirectManagerId());
        
        // 第二级：部门经理（超过2000元）
        if (expense.getAmount() > 2000) {
            approvers.add(expense.getDeptManagerId());
        }
        
        // 第三级：财务负责人（超过5000元）
        if (expense.getAmount() > 5000) {
            approvers.add(expense.getFinanceManagerId());
        }
        
        return approvers;
    }
    
    /**
     * 判断是否需要特殊审批
     */
    public boolean needsSpecialApproval(DelegateExecution execution) {
        String category = (String) execution.getVariable("category");
        Double amount = (Double) execution.getVariable("amount");
        
        // 特殊项目或大金额需要特殊审批
        return "special_project".equals(category) && amount > 10000;
    }
}

@Component("debugBean")
public class DebugBean {
    
    private static final Logger log = LoggerFactory.getLogger(DebugBean.class);
    
    /**
     * 调试表达式执行
     */
    public List<Long> debugGetApprovers(DelegateExecution execution) {
        log.info("=== Expression Debug Start ===");
        log.info("ProcessInstanceId: {}", execution.getProcessInstanceId());
        log.info("Variables: {}", execution.getVariables());
        
        try {
            // 业务逻辑
            List<Long> result = Arrays.asList(1L, 2L);
            log.info("Result: {}", result);
            return result;
        } catch (Exception e) {
            log.error("Expression execution failed", e);
            log.info("=== Expression Debug End (ERROR) ===");
            throw e;
        }
    }
}

// 在 IDE 中调试表达式执行
@Component("stepDebugBean")
public class StepDebugBean {
    
    public List<Long> stepDebugApprovers(DelegateExecution execution) {
        // 在此处设置断点
        String processInstanceId = execution.getProcessInstanceId();  // Step 1
        Object userId = execution.getVariable("userId");              // Step 2
        
        // 按 F10 逐步执行
        List<Long> approvers = determineApprovers(userId);            // Step 3
        
        return approvers;
    }
    
    private List<Long> determineApprovers(Object userId) {
        // 实现审批人确定逻辑
        return Arrays.asList(1L);
    }
}

@Component("performanceBean")
public class PerformanceBean {
    
    private static final Logger log = LoggerFactory.getLogger(PerformanceBean.class);
    
    /**
     * 性能监测的审批人获取
     */
    public List<Long> getApproversWithMonitoring(DelegateExecution execution) {
        long startTime = System.currentTimeMillis();
        
        try {
            List<Long> approvers = getApprovers(execution);
            return approvers;
        } finally {
            long duration = System.currentTimeMillis() - startTime;
            log.info("Expression execution time: {} ms", duration);
            
            // 如果超过阈值，记录警告
            if (duration > 1000) {
                log.warn("Expression execution took too long: {} ms", duration);
            }
        }
    }
    
    private List<Long> getApprovers(DelegateExecution execution) {
        // 实现审批人获取逻辑
        return Arrays.asList(1L);
    }
}

@Component("dynamicBean")
public class DynamicBean {
    
    @Autowired
    private ScriptEngineManager scriptEngineManager;
    
    /**
     * 动态执行脚本表达式（需要 PIGX 支持）
     */
    public List<Long> executeDynamicExpression(DelegateExecution execution) {
        String expression = (String) execution.getVariable("dynamicExpression");
        
        // 通过脚本引擎执行动态表达式
        // 需要 PIGX 框架支持
        return Arrays.asList(1L);
    }
}

@Component("parameterizedBean")
public class ParameterizedBean {
    
    /**
     * 带参数的审批人获取（需要 PIGX 支持参数传递）
     */
    public List<Long> getApproversByLevel(DelegateExecution execution, String level) {
        if ("high".equals(level)) {
            return Arrays.asList(100L);  // CEO
        } else if ("medium".equals(level)) {
            return Arrays.asList(50L);   // Manager
        } else {
            return Arrays.asList(10L);   // Staff
        }
    }
}

@Component("cachedBean")
public class CachedBean {
    
    @Autowired
    private CacheManager cacheManager;
    
    /**
     * 带缓存的审批人获取
     */
    @Cacheable(value = "approvers", key = "#level")
    public List<Long> getCachedApprovers(String level) {
        // 实现审批人获取逻辑（结果会被缓存）
        return Arrays.asList(1L);
    }
    
    /**
     * 清除缓存
     */
    @CacheEvict(value = "approvers", allEntries = true)
    public void clearApproverCache() {
        // 清除所有缓存
    }
}

@Component("leaveWorkflowBean")
public class LeaveWorkflowBean {
    
    @Autowired
    private BpmOaLeaveService leaveService;
    
    // 审批人表达式
    public List<Long> getLeaveApprovers(DelegateExecution execution) {
        BpmOaLeaveEntity leave = getLeaveData(execution);
        return leave.getLeaveDay() <= 3 
            ? Arrays.asList(leave.getDirectManagerId())
            : Arrays.asList(leave.getDeptDirectorId());
    }
    
    // 条件表达式：需要 HR 审批
    public boolean needsHrApproval(DelegateExecution execution) {
        BpmOaLeaveEntity leave = getLeaveData(execution);
        return leave.getLeaveDay() > 7;
    }
    
    private BpmOaLeaveEntity getLeaveData(DelegateExecution execution) {
        return leaveService.getByProcessInstanceId(
            execution.getProcessInstanceId()
        );
    }
}