/**
 * 顺序链执行器
 * 每个步骤是一个 Function<String, String>，输出传给下一步
 */
public class SequentialChain {

    private final List<ChainStep> steps;
    private final ChatClient chatClient;

    public SequentialChain(ChatClient chatClient, List<ChainStep> steps) {
        this.chatClient = chatClient;
        this.steps = steps;
    }

    /**
     * 执行顺序链，返回最终结果和每步的中间输出
     */
    public ChainResult execute(String input) {
        ChainResult result = new ChainResult();
        String current = input;

        for (int i = 0; i < steps.size(); i++) {
            ChainStep step = steps.get(i);
            long start = System.currentTimeMillis();

            // 构造每步的 prompt，注入前一步的输出
            String prompt = step.getPromptTemplate()
                .replace("{input}", current);

            String output = chatClient.prompt()
                .user(prompt)
                .system(step.getSystemPrompt())
                .call()
                .content();

            long duration = System.currentTimeMillis() - start;

            // 记录中间结果，便于调试和可观测性
            result.addStep(step.getName(), current, output, duration);
            current = output;
        }

        result.setFinalOutput(current);
        return result;
    }
}

/**
 * 链中的单个步骤定义
 */
public class ChainStep {
    private final String name;
    private final String systemPrompt;
    private final String promptTemplate;
    private final Map<String, Object> metadata;

    // Builder 模式省略...
}

/**
 * 链执行结果，包含每步的中间输出
 */
public class ChainResult {
    private String finalOutput;
    private final List<StepResult> stepResults = new ArrayList<>();
    private long totalDuration;

    public void addStep(String name, String input, String output, long duration) {
        stepResults.add(new StepResult(name, input, output, duration));
    }
}

@Bean
public SequentialChain competitiveAnalysisChain(ChatClient.Builder builder) {
    ChatClient client = builder.build();

    List<ChainStep> steps = List.of(
        new ChainStep.Builder("采集信息")
            .systemPrompt("你是一个市场研究员。请从以下需求中提取关键信息。")
            .promptTemplate("分析以下竞品的核心信息：{input}")
            .build(),

        new ChainStep.Builder("对比分析")
            .systemPrompt("你是一个产品分析师。请从功能、价格、用户体验三个维度进行对比。")
            .promptTemplate("基于以下信息进行竞品对比分析：{input}")
            .build(),

        new ChainStep.Builder("生成报告")
            .systemPrompt("你是一个商业报告撰写专家。请用结构化的方式输出报告。")
            .promptTemplate("将以下分析结果整理为正式的竞品分析报告：{input}")
            .build()
    );

    return new SequentialChain(client, steps);
}

/**
 * 并行扇出执行器
 * 使用虚拟线程（Java 21+）实现轻量级并发
 */
public class ParallelFanOut {

    private final ChatClient chatClient;
    private final ExecutorService executor;

    public ParallelFanOut(ChatClient chatClient) {
        // Java 21 虚拟线程——比传统线程池轻量 100 倍
        this.executor = Executors.newVirtualThreadPerTaskExecutor();
        this.chatClient = chatClient;
    }

    /**
     * 并行执行多个分支，超时后返回已完成的结果
     */
    public FanOutResult execute(String input, List<FanBranch> branches,
                                 long timeoutMs) {
        FanOutResult result = new FanOutResult();

        // 提交所有分支任务
        List<Future<BranchResult>> futures = branches.stream()
            .map(branch -> executor.submit(() -> executeBranch(branch, input)))
            .toList();

        // 收集结果，容忍部分失败
        for (int i = 0; i < futures.size(); i++) {
            try {
                BranchResult branchResult = futures.get(i)
                    .get(timeoutMs, TimeUnit.MILLISECONDS);
                result.addSuccess(branches.get(i).getName(), branchResult);
            } catch (TimeoutException e) {
                result.addTimeout(branches.get(i).getName());
            } catch (Exception e) {
                result.addFailure(branches.get(i).getName(), e.getMessage());
            }
        }

        return result;
    }

    private BranchResult executeBranch(FanBranch branch, String input) {
        long start = System.currentTimeMillis();
        String output = chatClient.prompt()
            .user(branch.getPromptTemplate().replace("{input}", input))
            .system(branch.getSystemPrompt())
            .call()
            .content();
        return new BranchResult(output, System.currentTimeMillis() - start);
    }
}

/**
 * 扇出分支定义
 */
public class FanBranch {
    private final String name;
    private final String systemPrompt;
    private final String promptTemplate;
    private final boolean required; // 是否是必须成功的分支
}

@Bean
public ParallelFanOut contentAnalysisChain(ChatClient.Builder builder) {
    ChatClient client = builder.build();

    List<FanBranch> branches = List.of(
        new FanBranch.Builder("情感分析")
            .systemPrompt("分析文本的情感倾向，输出 JSON：{\"sentiment\": \"positive/negative/neutral\", \"score\": 0.0-1.0}")
            .promptTemplate("分析以下文本的情感：{input}")
            .required(true)
            .build(),

        new FanBranch.Builder("关键词提取")
            .systemPrompt("提取文本中的核心关键词，输出 JSON 数组")
            .promptTemplate("提取以下文本的关键词：{input}")
            .required(true)
            .build(),

        new FanBranch.Builder("摘要生成")
            .systemPrompt("用一句话总结文本核心内容")
            .promptTemplate("总结以下文本：{input}")
            .required(false)  // 摘要失败不影响整体
            .build(),

        new FanBranch.Builder("分类标签")
            .systemPrompt("为文本打上分类标签，从以下类别中选择：技术、商业、产品、市场、其他")
            .promptTemplate("分类以下文本：{input}")
            .required(false)
            .build()
    );

    return new ParallelFanOut(client);
}

/**
 * 路由分发器
 * 使用 LLM 进行智能路由决策，而不是硬编码规则
 */
public class LlmRouter {

    private final ChatClient chatClient;
    private final Map<String, RouteHandler> routes;
    private final RouteHandler defaultRoute;

    public LlmRouter(ChatClient chatClient, Map<String, RouteHandler> routes,
                     RouteHandler defaultRoute) {
        this.chatClient = chatClient;
        this.routes = routes;
        this.defaultRoute = defaultRoute;
    }

    /**
     * 路由执行：先分类，再分发
     */
    public RouteResult route(String input) {
        // 第一步：用 LLM 进行意图分类
        String classification = chatClient.prompt()
            .system("""
                你是一个意图分类器。根据用户输入，返回以下类别之一：
                %s
                只返回类别名称，不要其他内容。
                """.formatted(String.join(", ", routes.keySet())))
            .user(input)
            .call()
            .content()
            .trim();

        // 第二步：路由到对应处理器
        RouteHandler handler = routes.getOrDefault(classification, defaultRoute);
        if (handler == null) {
            return RouteResult.error("未找到路由: " + classification);
        }

        // 第三步：执行对应流程
        long start = System.currentTimeMillis();
        String output = handler.handle(input, chatClient);
        long duration = System.currentTimeMillis() - start;

        return new RouteResult(classification, output, duration);
    }
}

/**
 * 路由处理器接口
 */
@FunctionalInterface
public interface RouteHandler {
    String handle(String input, ChatClient chatClient);
}

@Bean
public LlmRouter customerServiceRouter(ChatClient.Builder builder) {
    ChatClient client = builder.build();

    Map<String, RouteHandler> routes = Map.of(
        "技术问题", (input, chat) -> chat.prompt()
            .system("你是一个技术支持工程师。请根据问题提供解决方案或建议联系人工技术支持。")
            .user(input)
            .call()
            .content(),

        "账务问题", (input, chat) -> chat.prompt()
            .system("你是一个账务专员。请解答账务相关问题，涉及金额操作必须建议联系人工客服。")
            .user(input)
            .call()
            .content(),

        "投诉建议", (input, chat) -> chat.prompt()
            .system("你是一个客户关怀专员。请认真倾听客户诉求，表达同理心，并记录问题转交相关部门。")
            .user(input)
            .call()
            .content(),

        "产品咨询", (input, chat) -> {
            // 产品咨询走 RAG 流程
            return chat.prompt()
                .system("你是一个产品顾问。请基于产品知识库回答客户咨询。")
                .user(input)
                .call()
                .content();
        }
    );

    RouteHandler defaultRoute = (input, chat) ->
        "抱歉，我暂时无法处理您的问题。正在为您转接人工客服，请稍候...";

    return new LlmRouter(client, routes, defaultRoute);
}

/**
 * 编排者-工作者引擎
 * 
 * 核心设计：
 * 1. 编排者用结构化输出生成任务计划（Plan）
 * 2. 工作者并行执行子任务
 * 3. 编排者汇总结果生成最终输出
 */
public class OrchestratorWorkerEngine {

    private final ChatClient orchestratorClient;
    private final ChatClient workerClient;
    private final ExecutorService executor;
    private final int maxWorkers;

    public OrchestratorWorkerEngine(ChatClient.Builder builder, int maxWorkers) {
        // 编排者用更强的模型（如 GPT-4），工作者用更快的模型（如 GPT-3.5）
        this.orchestratorClient = builder.build();
        this.workerClient = builder.build();
        this.executor = Executors.newVirtualThreadPerTaskExecutor();
        this.maxWorkers = maxWorkers;
    }

    /**
     * 执行编排者-工作者流程
     */
    public OrchestratorResult execute(String task) {
        // 阶段 1：编排者生成计划
        TaskPlan plan = generatePlan(task);

        // 阶段 2：工作者并行执行
        List<WorkerResult> results = executeWorkers(plan.getSubTasks());

        // 阶段 3：编排者汇总结果
        String finalOutput = synthesizeResults(task, results);

        return new OrchestratorResult(plan, results, finalOutput);
    }

    /**
     * 阶段 1：编排者生成结构化的任务计划
     * 
     * 关键：使用 Spring AI 的结构化输出，让 LLM 返回 Java 对象
     * 而不是自由文本——这是可靠编排的基础
     */
    private TaskPlan generatePlan(String task) {
        return orchestratorClient.prompt()
            .system("""
                你是一个任务规划专家。根据用户的任务，将其拆解为可独立执行的子任务。
                
                规则：
                1. 每个子任务必须是独立的，不依赖其他子任务的输出
                2. 子任务数量不超过 %d 个
                3. 每个子任务有明确的输入和预期输出格式
                4. 按优先级排序（并行执行时高优先级先开始）
                """.formatted(maxWorkers))
            .user(task)
            .call()
            .entity(TaskPlan.class);  // 结构化输出！
    }

    /**
     * 阶段 2：工作者并行执行子任务
     * 
     * 容错设计：
     * - 单个工作者失败不影响其他工作者
     * - 关键工作者失败时重试（最多 2 次）
     * - 所有关键工作者都失败时，整体失败
     */
    private List<WorkerResult> executeWorkers(List<SubTask> subTasks) {
        List<Future<WorkerResult>> futures = subTasks.stream()
            .map(task -> executor.submit(() -> {
                int retries = task.isCritical() ? 2 : 0;
                return executeWithRetry(task, retries);
            }))
            .toList();

        return futures.stream()
            .map(f -> {
                try {
                    return f.get(60, TimeUnit.SECONDS);
                } catch (Exception e) {
                    return WorkerResult.failed("timeout", e.getMessage());
                }
            })
            .toList();
    }

    private WorkerResult executeWithRetry(SubTask task, int retries) {
        for (int attempt = 0; attempt <= retries; attempt++) {
            try {
                long start = System.currentTimeMillis();
                String output = workerClient.prompt()
                    .system(task.getSystemPrompt())
                    .user(task.getInput())
                    .call()
                    .content();
                return WorkerResult.success(
                    task.getId(), output,
                    System.currentTimeMillis() - start, attempt
                );
            } catch (Exception e) {
                if (attempt == retries) {
                    return WorkerResult.failed(task.getId(), e.getMessage());
                }
            }
        }
        return WorkerResult.failed(task.getId(), "max retries exceeded");
    }

    /**
     * 阶段 3：编排者汇总所有工作者的输出
     */
    private String synthesizeResults(String originalTask,
                                      List<WorkerResult> results) {
        String resultsText = results.stream()
            .filter(WorkerResult::isSuccess)
            .map(r -> "【" + r.getTaskId() + "】\n" + r.getOutput())
            .collect(Collectors.joining("\n\n"));

        return orchestratorClient.prompt()
            .system("你是一个报告整合专家。请将多个子任务的结果整合为一份连贯的最终输出。")
            .user("原始任务：%s\n\n各子任务结果：\n%s".formatted(originalTask, resultsText))
            .call()
            .content();
    }
}

/**
 * 任务计划——由编排者生成的结构化输出
 * 使用 @JsonClassDescription 让 LLM 理解每个字段的含义
 */
@JsonClassDescription("任务执行计划")
public record TaskPlan(
    @JsonPropertyDescription("任务总体目标的简要描述")
    String objective,
    @JsonPropertyDescription("拆解后的子任务列表")
    List<SubTask> subTasks
) {}

@JsonClassDescription("子任务定义")
public record SubTask(
    @JsonPropertyDescription("子任务唯一 ID")
    String id,
    @JsonPropertyDescription("子任务描述")
    String description,
    @JsonPropertyDescription("系统提示词")
    String systemPrompt,
    @JsonPropertyDescription("输入内容")
    String input,
    @JsonPropertyDescription("是否是关键任务（失败则整体失败）")
    boolean critical,
    @JsonPropertyDescription("优先级，数字越小越优先")
    int priority
) {}

/**
 * 结果质量评估器
 * 用 LLM 评估 LLM 的输出——听起来套娃，但在实践中很有效
 */
public class ResultQualityEvaluator {

    private final ChatClient chatClient;

    public QualityScore evaluate(String task, String output) {
        return chatClient.prompt()
            .system("""
                你是一个质量评估专家。请评估以下任务输出的质量。
                评分维度（每项 1-10 分）：
                1. 完整性：是否完整回答了任务要求
                2. 准确性：信息是否准确，有无明显错误
                3. 连贯性：逻辑是否通顺，表述是否清晰
                
                返回 JSON 格式的评分结果。
                """)
            .user("任务描述：%s\n\n任务输出：\n%s".formatted(task, output))
            .call()
            .entity(QualityScore.class);
    }
}

/**
 * 人机协作执行器
 * 
 * 核心机制：
 * 1. 流程定义中用 @HumanCheckpoint 标记需要人工介入的节点
 * 2. 执行到检查点时，暂停并返回中间状态
 * 3. 人类审核后，注入审核意见，继续执行
 * 
 * 关键设计：支持异步等待——人类可能需要几分钟甚至几天才审核
 */
public class HumanInLoopEngine {

    private final ChatClient chatClient;
    private final CheckpointStore checkpointStore;

    /**
     * 执行带检查点的流程
     * 
     * @param workflowId 流程实例 ID（用于持久化中间状态）
     * @param steps 流程步骤定义
     * @param input 初始输入
     * @return 如果执行完成返回最终结果，如果暂停返回检查点信息
     */
    public ExecutionState execute(String workflowId, List<WorkflowStep> steps,
                                   String input) {
        // 恢复之前的状态（支持断点续传）
        ExecutionState state = checkpointStore.load(workflowId)
            .orElse(new ExecutionState(workflowId, input));

        for (int i = state.getCurrentStepIndex(); i < steps.size(); i++) {
            WorkflowStep step = steps.get(i);

            // 检查是否是人工检查点
            if (step.requiresHumanReview()) {
                // 先执行 LLM 生成初稿
                String draft = executeStep(step, state.getCurrentInput());

                // 暂停，等待人工审核
                state.pauseAt(i, draft, step.getReviewPrompt());
                checkpointStore.save(state);

                return state;  // 返回暂停状态，外部系统负责通知人类
            }

            // 普通步骤直接执行
            String output = executeStep(step, state.getCurrentInput());
            state.advance(i + 1, output);
        }

        state.markComplete();
        checkpointStore.save(state);
        return state;
    }

    /**
     * 人类审核后恢复执行
     * 
     * @param workflowId 流程实例 ID
     * @param humanFeedback 人类的审核意见（批准/修改/拒绝）
     */
    public ExecutionState resume(String workflowId, HumanFeedback feedback) {
        ExecutionState state = checkpointStore.load(workflowId)
            .orElseThrow(() -> new IllegalStateException("流程不存在: " + workflowId));

        // 将人类反馈注入上下文
        String enrichedInput = """
            原始输出：
            %s
            
            人类审核意见：
            %s
            """.formatted(state.getPausedOutput(), feedback.getComments());

        // 根据人类决策走不同分支
        if (feedback.isApproved()) {
            state.advance(state.getCurrentStepIndex() + 1, state.getPausedOutput());
        } else if (feedback.hasModifications()) {
            // 用人类的修改意见重新生成
            String revised = executeStep(
                state.getCurrentStep(),
                enrichedInput
            );
            state.advance(state.getCurrentStepIndex() + 1, revised);
        } else {
            // 拒绝——终止流程
            state.markRejected(feedback.getReason());
            checkpointStore.save(state);
            return state;
        }

        // 继续执行剩余步骤
        return execute(state.getWorkflowId(), state.getRemainingSteps(),
                       state.getCurrentInput());
    }
}

/**
 * 工作流定义——用 Builder 模式构建
 * 
 * 设计理念：
 * - 流程是静态的（编译时确定）
 * - 每个节点可以是 LLM 调用、人工审核、或外部 API 调用
 * - 节点之间可以有条件跳转（实现路由和分支）
 * - 支持并行节点组（实现扇出）
 */
public class WorkflowDefinition {

    private final String name;
    private final List<WorkflowNode> nodes;
    private final Map<String, Transition> transitions;

    /**
     * 工作流节点
     */
    public static class WorkflowNode {
        private final String id;
        private final NodeType type;  // LLM, HUMAN, API, PARALLEL_GROUP
        private final String prompt;
        private final String systemPrompt;
        private final boolean requiresReview;
        private final RetryPolicy retryPolicy;
        private final Duration timeout;
        private final Map<String, Object> metadata;
    }

    /**
     * 节点间的转换规则
     * 
     * 支持条件跳转：根据节点输出决定下一步
     * 例如：审核通过 → 继续，审核拒绝 → 回到修改节点
     */
    public static class Transition {
        private final String fromNodeId;
        private final String defaultNextNodeId;
        private final List<Condition> conditions;

        public record Condition(
            String expression,  // 简单的条件表达式
            String nextNodeId   // 条件满足时跳转到的节点
        ) {}
    }
}

/**
 * 工作流执行引擎
 * 
 * 核心职责：
 * 1. 按照 WorkflowDefinition 驱动节点执行
 * 2. 管理执行状态（支持暂停/恢复）
 * 3. 处理并行节点组
 * 4. 实现重试和超时策略
 * 5. 发送执行事件（用于可观测性）
 */
@Service
public class WorkflowEngine {

    private final ChatClient chatClient;
    private final WorkflowStateRepository stateRepository;
    private final ApplicationEventPublisher eventPublisher;

    /**
     * 启动或恢复工作流执行
     */
    public WorkflowExecution run(WorkflowDefinition definition,
                                  Map<String, Object> inputs) {
        WorkflowExecution execution = WorkflowExecution.start(definition, inputs);

        while (execution.hasNextNode()) {
            WorkflowNode currentNode = execution.getCurrentNode();

            // 发送节点开始事件（用于监控和追踪）
            eventPublisher.publishEvent(new NodeStartedEvent(
                execution.getId(), currentNode.getId()
            ));

            try {
                NodeResult result = switch (currentNode.getType()) {
                    case LLM -> executeLlmNode(currentNode, execution.getContext());
                    case HUMAN -> pauseForHuman(execution, currentNode);
                    case API -> executeApiNode(currentNode, execution.getContext());
                    case PARALLEL_GROUP -> executeParallelGroup(
                        currentNode, execution.getContext()
                    );
                };

                execution.recordResult(currentNode.getId(), result);

                // 根据转换规则决定下一个节点
                String nextNodeId = resolveTransition(
                    definition.getTransitions().get(currentNode.getId()),
                    result
                );
                execution.moveToNext(nextNodeId);

            } catch (Exception e) {
                // 重试逻辑
                if (shouldRetry(currentNode, execution)) {
                    execution.retryCurrentNode();
                    continue;
                }
                execution.markFailed(currentNode.getId(), e);
                break;
            }
        }

        stateRepository.save(execution);
        return execution;
    }

    /**
     * LLM 节点执行——核心逻辑
     */
    private NodeResult executeLlmNode(WorkflowNode node,
                                       ExecutionContext context) {
        long start = System.currentTimeMillis();

        // 用上下文中的变量替换 prompt 模板
        String resolvedPrompt = resolveTemplate(node.getPrompt(), context);
        String resolvedSystem = resolveTemplate(node.getSystemPrompt(), context);

        String output = chatClient.prompt()
            .system(resolvedSystem)
            .user(resolvedPrompt)
            .call()
            .content();

        return new NodeResult(
            output,
            Map.of("duration_ms", System.currentTimeMillis() - start,
                   "token_count", estimateTokens(resolvedPrompt + output))
        );
    }

    /**
     * 暂停等待人工审核
     */
    private NodeResult pauseForHuman(WorkflowExecution execution,
                                      WorkflowNode node) {
        execution.pause(node.getId());
        stateRepository.save(execution);
        throw new WorkflowPausedException(execution.getId(), node.getId());
    }

    /**
     * 解析条件转换——决定下一步走哪个节点
     */
    private String resolveTransition(Transition transition, NodeResult result) {
        if (transition == null) return null;
        if (transition.getConditions().isEmpty()) {
            return transition.getDefaultNextNodeId();
        }

        // 用简单的表达式引擎评估条件
        for (Transition.Condition condition : transition.getConditions()) {
            if (evaluateCondition(condition.expression(), result)) {
                return condition.nextNodeId();
            }
        }
        return transition.getDefaultNextNodeId();
    }
}

@Configuration
public class ContentPublishWorkflow {

    @Bean
    public WorkflowDefinition contentPublishWorkflow() {
        return WorkflowDefinition.builder()
            .name("内容发布流程")

            // 节点 1：LLM 生成初稿
            .node(WorkflowNode.builder()
                .id("draft")
                .type(NodeType.LLM)
                .systemPrompt("你是一个技术博客作者，请根据主题撰写一篇技术文章。")
                .prompt("主题：{{topic}}\n\n要求：{{requirements}}")
                .timeout(Duration.ofMinutes(5))
                .build())

            // 节点 2：LLM 自动审查（格式、SEO、链接）
            .node(WorkflowNode.builder()
                .id("auto-review")
                .type(NodeType.LLM)
                .systemPrompt("""
                    你是一个文章审查专家。请检查以下方面：
                    1. 格式是否规范（标题层级、代码块、列表）
                    2. SEO 元素是否完整（标题、摘要、关键词）
                    3. 内部链接是否使用了正确的格式（/posts/abbrlink.html）
                    4. 文字和代码的一致性
                    
                    返回 JSON：{"passed": boolean, "issues": [...]}
                    """)
                .prompt("请审查以下文章：\n{{draft}}")
                .build())

            // 节点 3：人工审核（仅当自动审查发现问题时）
            .node(WorkflowNode.builder()
                .id("human-review")
                .type(NodeType.HUMAN)
                .prompt("请审核以下文章（自动审查发现了问题）：\n{{draft}}\n\n问题列表：{{auto-review}}")
                .requiresReview(true)
                .build())

            // 节点 4：发布到博客
            .node(WorkflowNode.builder()
                .id("publish")
                .type(NodeType.API)
                .prompt("发布文章：{{final_article}}")
                .build())

            // 转换规则
            .transition("draft", "auto-review")
            .transition("auto-review", Transition.builder()
                .defaultNext("publish")
                .condition("$.passed == false", "human-review")
                .build())
            .transition("human-review", "publish")

            .build();
    }
}

/**
 * 工作流追踪拦截器
 * 自动记录每个节点的执行详情
 */
@Component
public class WorkflowTracingInterceptor {

    private final MeterRegistry meterRegistry;

    public <T> T intercept(String workflowId, String nodeId,
                            Supplier<T> action) {
        // OpenTelemetry span
        Span span = Span.current(); // 简化示例

        Timer.Sample sample = Timer.start(meterRegistry);

        try {
            T result = action.get();
            sample.stop(Timer.builder("workflow.node.duration")
                .tag("workflow", workflowId)
                .tag("node", nodeId)
                .tag("status", "success")
                .register(meterRegistry));
            return result;
        } catch (Exception e) {
            sample.stop(Timer.builder("workflow.node.duration")
                .tag("workflow", workflowId)
                .tag("node", nodeId)
                .tag("status", "error")
                .register(meterRegistry));
            throw e;
        }
    }
}

/**
 * 成本感知的工作流执行器
 * 
 * 每个工作流实例有总 Token 预算，超预算时降级执行
 */
public class CostAwareExecutor {

    private static final int DEFAULT_TOKEN_BUDGET = 10000;

    public NodeResult executeWithBudget(WorkflowNode node,
                                         ExecutionContext context,
                                         int remainingBudget) {
        if (remainingBudget <= 0) {
            // 预算耗尽——降级为规则引擎或直接返回缓存结果
            return fallbackExecute(node, context);
        }

        // 动态调整 max_tokens
        int maxTokens = Math.min(remainingBudget, node.getMaxTokens());
        return executeLlmNode(node, context, maxTokens);
    }
}

/**
 * 工作流单元测试——Mock LLM 调用，测试流程逻辑
 */
@SpringBootTest
class ContentPublishWorkflowTest {

    @MockBean
    private ChatClient chatClient;

    @Test
    void should_route_to_human_review_when_auto_review_fails() {
        // Mock：初稿生成返回正常内容
        when(chatClient.prompt().system(any()).user(any()).call().content())
            .thenReturn("文章初稿内容...")
            // Mock：自动审查返回不通过
            .thenReturn("{\"passed\": false, \"issues\": [\"缺少代码示例\"]}");

        WorkflowExecution result = engine.run(
            contentPublishWorkflow,
            Map.of("topic", "AI Agent", "requirements", "深入讲解")
        );

        // 验证：流程应该暂停在人工审核节点
        assertThat(result.getStatus()).isEqualTo(ExecutionStatus.PAUSED);
        assertThat(result.getCurrentNodeId()).isEqualTo("human-review");
    }

    @Test
    void should_skip_human_review_when_auto_review_passes() {
        when(chatClient.prompt().system(any()).user(any()).call().content())
            .thenReturn("文章初稿内容...")
            .thenReturn("{\"passed\": true, \"issues\": []}");

        WorkflowExecution result = engine.run(
            contentPublishWorkflow,
            Map.of("topic", "AI Agent", "requirements", "深入讲解")
        );

        // 验证：流程应该直接到发布节点
        assertThat(result.getStatus()).isEqualTo(ExecutionStatus.COMPLETED);
        assertThat(result.getExecutedNodeIds())
            .containsExactly("draft", "auto-review", "publish");
    }
}

/**
 * 智能合同审查——组合使用多种工作流模式
 * 
 * 整体架构：
 * - 顶层：顺序链（审查 → 风险评估 → 生成报告 → 人工确认）
 * - 审查阶段：并行扇出（法律条款 + 财务条款 + 技术条款 同时审查）
 * - 风险评估：路由分发（根据风险等级走不同处理流程）
 * - 报告生成：编排者-工作者（不同章节并行生成）
 * - 人工确认：人机协作（法务和业务双签）
 */
@Configuration
public class ContractReviewWorkflow {

    @Bean
    public WorkflowDefinition contractReview() {
        return WorkflowDefinition.builder()
            .name("智能合同审查")

            // 阶段 1：并行审查（三种专家同时工作）
            .parallelGroup("parallel-review",
                llmNode("legal-review", "你是一个法律顾问...", "{{contract}}"),
                llmNode("financial-review", "你是一个财务审计师...", "{{contract}}"),
                llmNode("technical-review", "你是一个技术架构师...", "{{contract}}")
            )

            // 阶段 2：风险评估 + 路由
            .node(llmNode("risk-assessment",
                "根据三方审查结果评估总体风险等级：低风险/中风险/高风险",
                "法律审查：{{legal-review}}\n财务审查：{{financial-review}}\n技术审查：{{technical-review}}"))
            .transition("risk-assessment", Transition.builder()
                .defaultNext("generate-report")
                .condition("$.risk_level == '高风险'", "escalate-to-partner")
                .build())

            // 阶段 3：编排者-工作者生成报告
            .orchestrator("generate-report", List.of(
                workerNode("exec-summary", "生成执行摘要..."),
                workerNode("risk-detail", "生成风险详情..."),
                workerNode("recommendation", "生成建议...")
            ))

            // 阶段 4：人工确认（法务 + 业务双签）
            .node(humanNode("legal-signoff", "请法务确认审查结果"))
            .node(humanNode("business-signoff", "请业务方确认审查结果"))

            .build();
    }
}