/**
 * 反思记录：Agent 从一次失败中学到的经验
 */
public class Reflection {
    private String taskId;          // 任务标识
    private String taskDescription; // 任务描述
    private String failureReason;   // 失败原因
    private String reflection;      // 经验总结（核心）
    private List<String> mistakes;  // 具体错误点
    private List<String> lessons;   // 教训（下次该怎么做）
    private LocalDateTime timestamp;
    private int attemptNumber;      // 第几次尝试

    // 构造器、getter/setter 省略

    /**
     * 将反思格式化为可注入 Prompt 的文本
     */
    public String toPromptContext() {
        StringBuilder sb = new StringBuilder();
        sb.append("【历史经验 - 任务：").append(taskDescription).append("】\n");
        sb.append("失败原因：").append(failureReason).append("\n");
        sb.append("反思总结：").append(reflection).append("\n");
        if (!lessons.isEmpty()) {
            sb.append("经验教训：\n");
            lessons.forEach(lesson -> sb.append("  - ").append(lesson).append("\n"));
        }
        return sb.toString();
    }
}

import dev.langchain4j.service.SystemMessage;
import dev.langchain4j.service.UserMessage;
import dev.langchain4j.service.V;

public interface ReflectionAgent {

    /**
     * 评估任务执行结果，判断是否成功
     */
    @SystemMessage("""
        你是一个任务结果评估专家。根据任务描述和执行结果，判断任务是否成功完成。
        如果失败，分析具体的失败原因。
        返回 JSON 格式：
        {
          "success": true/false,
          "failureReason": "失败原因（成功时为空）",
          "score": 0-100 的完成度评分
        }
    """)
    @UserMessage("""
        任务描述：{{taskDescription}}
        执行结果：{{executionResult}}
        期望输出：{{expectedOutput}}
    """)
    String evaluate(
        @V("taskDescription") String taskDescription,
        @V("executionResult") String executionResult,
        @V("expectedOutput") String expectedOutput
    );

    /**
     * 基于失败信息生成反思
     */
    @SystemMessage("""
        你是一个经验总结专家。根据任务的失败信息，生成一份结构化的反思报告。

        要求：
        1. 具体指出错在哪里（不要泛泛而谈）
        2. 分析为什么会出现这个错误（根因分析）
        3. 给出下次遇到类似任务时应该怎么做（可操作的建议）
        4. 如果有多个错误点，逐一列出

        返回 JSON 格式：
        {
          "reflection": "整体反思总结",
          "mistakes": ["错误1", "错误2"],
          "lessons": ["教训1", "教训2"]
        }
    """)
    @UserMessage("""
        任务描述：{{taskDescription}}
        执行过程：{{executionProcess}}
        失败原因：{{failureReason}}
        期望输出：{{expectedOutput}}
        历史经验（如有）：{{pastReflections}}
    """)
    String reflect(
        @V("taskDescription") String taskDescription,
        @V("executionProcess") String executionProcess,
        @V("failureReason") String failureReason,
        @V("expectedOutput") String expectedOutput,
        @V("pastReflections") String pastReflections
    );
}

import dev.langchain4j.data.document.Metadata;
import dev.langchain4j.data.embedding.Embedding;
import dev.langchain4j.data.segment.TextSegment;
import dev.langchain4j.store.embedding.EmbeddingStore;

/**
 * 经验存储：使用向量数据库存储反思记录
 */
public class ExperienceStore {

    private final EmbeddingStore<TextSegment> embeddingStore;
    private final EmbeddingModel embeddingModel;
    private final ObjectMapper objectMapper = new ObjectMapper();

    public ExperienceStore(EmbeddingStore<TextSegment> embeddingStore,
                           EmbeddingModel embeddingModel) {
        this.embeddingStore = embeddingStore;
        this.embeddingModel = embeddingModel;
    }

    /**
     * 存储一条反思记录
     */
    public void saveReflection(Reflection reflection) {
        String text = reflection.toPromptContext();
        Embedding embedding = embeddingModel.embed(text).content();

        Metadata metadata = Metadata.from("taskId", reflection.getTaskId())
            .put("timestamp", reflection.getTimestamp().toString())
            .put("attemptNumber", String.valueOf(reflection.getAttemptNumber()));

        embeddingStore.add(embedding, TextSegment.from(text, metadata));
    }

    /**
     * 检索与当前任务相关的历史反思
     */
    public List<String> searchRelevantReflections(String taskDescription, int maxResults) {
        Embedding queryEmbedding = embeddingModel.embed(taskDescription).content();

        return embeddingStore.search(
                dev.langchain4j.store.embedding.EmbeddingSearchRequest.builder()
                    .queryEmbedding(queryEmbedding)
                    .maxResults(maxResults)
                    .minScore(0.7)  // 相似度阈值，避免不相关的经验干扰
                    .build()
            ).matches()
            .stream()
            .map(match -> match.embedded().text())
            .collect(Collectors.toList());
    }
}

/**
 * 带自我反思的 Agent 执行器
 */
public class ReflectiveAgentExecutor {

    private final ReflectionAgent reflectionAgent;
    private final ExperienceStore experienceStore;
    private final AgentExecutor taskExecutor;  // 基础的任务执行器
    private final int maxRetries;

    public ReflectiveAgentExecutor(ReflectionAgent reflectionAgent,
                                    ExperienceStore experienceStore,
                                    AgentExecutor taskExecutor,
                                    int maxRetries) {
        this.reflectionAgent = reflectionAgent;
        this.experienceStore = experienceStore;
        this.taskExecutor = taskExecutor;
        this.maxRetries = maxRetries;
    }

    /**
     * 执行任务，带反思重试
     */
    public ExecutionResult executeWithReflection(Task task) {
        // 1. 检索相关历史经验
        List<String> pastReflections = experienceStore
            .searchRelevantReflections(task.getDescription(), 3);

        String enhancedPrompt = task.getPrompt();
        if (!pastReflections.isEmpty()) {
            enhancedPrompt = buildEnhancedPrompt(task.getPrompt(), pastReflections);
        }

        // 2. 尝试执行（最多重试 maxRetries 次）
        for (int attempt = 1; attempt <= maxRetries; attempt++) {
            log.info("执行任务 [{}]，第 {} 次尝试", task.getId(), attempt);

            // 2a. 执行任务
            String result = taskExecutor.execute(enhancedPrompt);
            StringBuilder processLog = new StringBuilder();
            processLog.append("尝试 ").append(attempt).append(": ").append(result).append("\n");

            // 2b. 评估结果
            String evaluation = reflectionAgent.evaluate(
                task.getDescription(), result, task.getExpectedOutput()
            );
            EvalResult evalResult = parseEvaluation(evaluation);

            if (evalResult.isSuccess()) {
                log.info("任务 [{}] 在第 {} 次尝试后成功", task.getId(), attempt);
                return ExecutionResult.success(result, attempt);
            }

            // 2c. 失败了，生成反思
            log.info("任务 [{}] 第 {} 次尝试失败: {}", task.getId(), attempt,
                     evalResult.getFailureReason());

            String reflectionJson = reflectionAgent.reflect(
                task.getDescription(),
                processLog.toString(),
                evalResult.getFailureReason(),
                task.getExpectedOutput(),
                String.join("\n---\n", pastReflections)
            );
            Reflection reflection = parseReflection(reflectionJson, task.getId(), attempt);

            // 2d. 存储反思
            experienceStore.saveReflection(reflection);

            // 2e. 将新反思加入上下文，为下次重试做准备
            pastReflections.add(reflection.toPromptContext());
            enhancedPrompt = buildEnhancedPrompt(task.getPrompt(), pastReflections);

            log.info("已生成反思并更新上下文，准备第 {} 次重试", attempt + 1);
        }

        return ExecutionResult.failure("超过最大重试次数 (" + maxRetries + ")");
    }

    /**
     * 构建带历史经验的增强 Prompt
     */
    private String buildEnhancedPrompt(String originalPrompt, List<String> reflections) {
        StringBuilder sb = new StringBuilder();
        sb.append(originalPrompt);
        sb.append("\n\n===== 历史经验（请务必参考，避免重复犯错）=====\n");
        for (int i = 0; i < reflections.size(); i++) {
            sb.append("\n").append(reflections.get(i)).append("\n");
        }
        sb.append("\n===== 请基于以上经验，避免重复错误，重新执行任务 =====");
        return sb.toString();
    }
}

@SystemMessage("""
    评估以下反思记录的质量，返回 0-100 的评分。

    评分标准：
    - 具体性（30分）：是否指出了具体的错误操作，而非泛泛而谈
    - 可操作性（30分）：给出的教训是否可以直接指导下一步行动
    - 根因分析（20分）：是否分析了错误的根本原因，而非表面现象
    - 复用性（20分）：经验是否可以应用到类似但不同的场景

    低于 60 分的反思需要重新生成。

    返回 JSON：{"score": N, "issues": ["问题1", "问题2"], "suggestion": "改进建议"}
""")
@UserMessage("反思内容：{{reflection}}")
String evaluateReflectionQuality(@V("reflection") String reflection);

/**
 * 经验验证器：跟踪经验的有效性
 */
public class ExperienceValidator {

    private final ExperienceStore experienceStore;

    /**
     * 当一条经验被成功应用时，增加其权重
     */
    public void onExperienceApplied(String reflectionId, boolean ledToSuccess) {
        Reflection reflection = experienceStore.findById(reflectionId);
        if (ledToSuccess) {
            reflection.setConfidenceScore(
                Math.min(1.0, reflection.getConfidenceScore() + 0.1)
            );
        } else {
            reflection.setConfidenceScore(
                Math.max(0.0, reflection.getConfidenceScore() - 0.2)
            );
        }
        experienceStore.update(reflection);

        // 如果信心分降到阈值以下，标记为"待验证"
        if (reflection.getConfidenceScore() < 0.3) {
            log.warn("经验 [{}] 信心分过低 ({})，标记为待验证",
                     reflectionId, reflection.getConfidenceScore());
            reflection.setStatus(ReflectionStatus.NEEDS_VERIFICATION);
        }
    }

    /**
     * 定期清理低信心的经验
     */
    @Scheduled(fixedRate = 86400000) // 每天执行
    public void cleanupLowConfidenceExperiences() {
        List<Reflection> lowConfidence = experienceStore
            .findByStatusAndConfidenceBelow(ReflectionStatus.ACTIVE, 0.2);
        lowConfidence.forEach(r -> {
            r.setStatus(ReflectionStatus.ARCHIVED);
            log.info("归档低信心经验: {}", r.getReflection());
        });
        experienceStore.batchUpdate(lowConfidence);
    }
}

/**
 * 策略切换器：当反思无法改善结果时，切换到不同策略
 */
public class StrategySwitcher {

    private enum Strategy {
        STANDARD,       // 标准执行
        REFLECTION,     // 反思重试
        DECOMPOSE,      // 分解为子任务
        HUMAN_IN_LOOP,  // 请求人工介入
        ALTERNATIVE     // 使用替代方案
    }

    public Strategy determineStrategy(Task task, List<Reflection> reflections,
                                       int consecutiveFailures) {
        // 连续失败 2 次以内：继续反思重试
        if (consecutiveFailures <= 2) {
            return Strategy.REFLECTION;
        }

        // 连续失败 3 次：尝试分解任务
        if (consecutiveFailures == 3) {
            return Strategy.DECOMPOSE;
        }

        // 连续失败 4 次：使用替代方案（如不同的工具、不同的 API）
        if (consecutiveFailures == 4) {
            return Strategy.ALTERNATIVE;
        }

        // 连续失败 5 次以上：请求人工介入
        return Strategy.HUMAN_IN_LOOP;
    }
}

@Service
public class CustomerServiceAgent {

    private final ReflectiveAgentExecutor executor;
    private final ExperienceStore experienceStore;

    // 可用工具
    @Tool("查询订单详情")
    public OrderDetail queryOrder(String orderId) {
        return orderService.getDetail(orderId);
    }

    @Tool("查询物流状态")
    public LogisticsInfo queryLogistics(String orderId) {
        return logisticsService.query(orderId);
    }

    @Tool("发起退款申请")
    public RefundResult initiateRefund(String orderId, String reason, BigDecimal amount) {
        return refundService.apply(orderId, reason, amount);
    }

    @Tool("查询退款进度")
    public RefundStatus queryRefundStatus(String refundId) {
        return refundService.getStatus(refundId);
    }

    @Tool("创建工单")
    public String createTicket(String category, String description, String priority) {
        return ticketService.create(category, description, priority);
    }

    /**
     * 处理用户请求（带反思能力）
     */
    public String handleCustomerRequest(String userMessage) {
        Task task = Task.builder()
            .id(UUID.randomUUID().toString())
            .description("处理客服请求: " + userMessage)
            .prompt(buildCustomerServicePrompt(userMessage))
            .expectedOutput("准确解决用户问题，并给出友好的回复")
            .build();

        ExecutionResult result = executor.executeWithReflection(task);

        if (result.isSuccess()) {
            return result.getOutput();
        } else {
            // 兜底：创建工单转人工
            createTicket("AI_ESCALATION", "AI 无法处理的请求: " + userMessage, "HIGH");
            return "抱歉，您的问题我暂时无法处理，已为您转接人工客服。";
        }
    }
}

/**
 * 异步反思服务：不阻塞主流程
 */
@Service
public class AsyncReflectionService {

    @Async("reflectionExecutor")
    public CompletableFuture<Reflection> reflectAsync(Task task, String failureReason,
                                                        String executionProcess) {
        return CompletableFuture.supplyAsync(() -> {
            // 反思可以慢一点，不影响用户体验
            return reflectionAgent.reflect(
                task.getDescription(), executionProcess,
                failureReason, task.getExpectedOutput(), ""
            );
        });
    }
}